[size=12.666666984558105px]process后面需要记住要有个”:”,这表示该进程属于你的app。 一般情况下，一块基本的空进程需要的内存大小在1.4m左右。

1 adb shell dumpsys meminfo com.example.android.apis:empty
8、基本性能优化方法的基本原则：

1）不要做你不必要的工作；

2）不要申请不必要的内存； 例如，你明明知道一个方法返回一个String之后，你需要对这个String重新进行修改，那么就不要返回一个String，返回一个StringBuffer会是你更好的选择。 再比如，使用int比使用Integer占用更少的空间。这个大家肯定都是晓得的。 数组比一个Map拥有更好的性能。 如果你的方法不需要访问类字段，那么让你的方法是static的吧，这将会带来15%-20%速度的提升。 对于常量，请尽量使用static and final定义。如果使用final定义常量之后，会减少编译器在类生成时初始化方法调用时对常量的存储，对于int型常量，将会直接使用其数值来进行替换，而对于String对象将会使用相对廉价的“string constant”指令来替换字段查找表。虽然这个方法并不完全对所有类型都有效，但是，将常量声明为static final绝对是一个好的做法。 避免Getters/Setters。虽然在一般的面向对象的设计模式中使用Getter和Setter是稀松平常的事情，但是在Android中使用getters/Setters是一个非常糟糕的主意，方法的调用相对于直接查找字段来说十分的昂贵。在没有JIT的情况下，直接对字段进行访问要比通过Getter访问快了近3倍。在有JIT的情况下，前者比后者快近7倍。 使用最新的循环方式。比如增强for。 避免使用浮点类型。在某些可以的情况下，将浮点替换成整型数据，然后进行计算会得到更精确的结果和更快的速度。 小心使用Native Methods。这里需要纠正的是，Native 方法并不一定能提高你应用的速度，有些甚至会拖后腿，因为，首先来说就需要一部分开销在Java-native transition上，而且JIT并不能对其进行优化。另外你需要为每个你想要在其上运行的系统结构上进行编译；即便是同一个处理器上，你也可能需要多个版本，比如为G1上的ARM处理器编译的就不能很好的在Nexus One的ARM上运行。Native代码最主要的用途是，你已经有了很多native 代码，并且你迫切希望接入Android中。而不是使用Native Method来提高你应用中某部分代码的运行速度。 [size=12.666666984558105px] 对于效率的提高除了使用遵守上面两条外基本准则外，选择合适的算法和数据结构也是非常关键的。

9、关于UI上的一些问题[size=12.800000190734863px] Hierarchy Viewer[size=12.666666984558105px] [size=12.666666984558105px]通过他，可以看到你自己的Layout文件存在的问题。你可以看到你的Layout每一部分计算，布局，渲染所需要的时间。尽量的使你的Layout扁平话，深度最好保持 在三层之内[size=12.666666984558105px] 。RelativeLayout[size=12.666666984558105px] 是解决使用LinearLayout堆叠多层问题的利剑。那些为了方便 使[size=12.666666984558105px] 用LinearLayout的layout_weight属性[size=12.666666984558105px] 的哥们，需要重点注意，这个属性真的可以减慢measure速度。所以在使用之前，一定要再三考虑，是否真的不能通过其他方法来完成你要的效果？ 官方文档上 推荐使用RelativeLayout和GridLayout来避免Layout深度过深的问题[size=12.666666984558105px] 。 之前看文档，Google提供一个叫 ViewSub[size=12.666666984558105px] 的控件来优化那些不是必须要立即在UI上显示的控件，感兴趣的同学可以去看看。在API Level 1中就提供了这个东西，但是在实际开发中很少见到有人用或者提及（可能是我孤陋寡闻，公司就两个Android开发，另一个还要转IOS，我们俩的Android技术就代表了我们公司的Android技术能力，想想真悲哀！），其实蛮好用的。 重用Layout。可以使用 将其他布局嵌入到当前布局中。 ListView的优化：ViewHolder的使用；AsyncTask的使用；针对ListView当前滑动状态，对图片数据的加载进行控制；（ListView在配以AsyncTask加载图片时需要注[size=12.666666984558105px] 意图片的加载完显示的位置以及图片的缓存问题，具体可以参考Google的Demo[size=12.666666984558105px] ）[size=12.666666984558105px] [size=12.800000190734863px]10、将大消耗操作交给多个线程。 11、如果你的应用需要发送Broadcast但是又不希望别的应用获取到，或者你不希望处理别的应用发送的同样的action，那么请使用LocalBroadcastManager。 [size=12.666666984558105px] 该类是在Android Support v4中提供的，用来在同一个应用内的不同组件之间发送Broadcast。好处上面说了，可以保证应用的私密性。会比全局广播有更高的效率，但是官方文档没有说明具体数值。具体使用方法：

1 LocalBroadcastManager.getInstance(this).registerReceiver( mStateReceiver, mStatusIntentFilter);LocalBroadcastManager.getInstance(this).sendBroadcast(localBroadcastIntent);

使用oc计数器的方式可以更好的控制内存

Android OnLowMemory和OnTrimMemory

OnLowMemory OnLowMemory是Android提供的API，在系统内存不足，所有后台程序（优先级为background的进程，不是指后台运行的进程）都被杀死时，系统会调用OnLowMemory。系统提供的回调有： Application.onLowMemory() Activity.OnLowMemory() Fragement.OnLowMemory() Service.OnLowMemory() ContentProvider.OnLowMemory() 除了上述系统提供的API，还可以自己实现ComponentCallbacks，通过API注册，这样也能得到OnLowMemory回调。例如： public static class MyCallback implements ComponentCallbacks {

    @Override
    public void onConfigurationChanged(Configuration arg) {
    }
    @Override
    public void onLowMemory() {
        //do release operation
    }
}

然后，通过Context.registerComponentCallbacks ()在合适的时候注册回调就可以了。通过这种自定义的方法，可以在很多地方注册回调，而不需要局限于系统提供的组件。 OnTrimMemory OnTrimMemory是Android 4.0之后提供的API，系统会根据不同的内存状态来回调。系统提供的回调有： Application.onTrimMemory() Activity.onTrimMemory() Fragement.OnTrimMemory() Service.onTrimMemory() ContentProvider.OnTrimMemory() OnTrimMemory的参数是一个int数值，代表不同的内存状态： TRIM_MEMORY_COMPLETE：内存不足，并且该进程在后台进程列表最后一个，马上就要被清理 TRIM_MEMORY_MODERATE：内存不足，并且该进程在后台进程列表的中部。 TRIM_MEMORY_BACKGROUND：内存不足，并且该进程是后台进程。 TRIM_MEMORY_UI_HIDDEN：内存不足，并且该进程的UI已经不可见了。
以上4个是4.0增加 TRIM_MEMORY_RUNNING_CRITICAL：内存不足(后台进程不足3个)，并且该进程优先级比较高，需要清理内存 TRIM_MEMORY_RUNNING_LOW：内存不足(后台进程不足5个)，并且该进程优先级比较高，需要清理内存 TRIM_MEMORY_RUNNING_MODERATE：内存不足(后台进程超过5个)，并且该进程优先级比较高，需要清理内存

  以上3个是4.1增加

系统也提供了一个ComponentCallbacks2，通过Context.registerComponentCallbacks()注册后，就会被系统回调到。 OnLowMemory和OnTrimMemory的比较 1，OnLowMemory被回调时，已经没有后台进程；而onTrimMemory被回调时，还有后台进程。 2，OnLowMemory是在最后一个后台进程被杀时调用，一般情况是low memory killer 杀进程后触发；而OnTrimMemory的触发更频繁，每次计算进程优先级时，只要满足条件，都会触发。 3，通过一键清理后，OnLowMemory不会被触发，而OnTrimMemory会被触发一次。 9.图片缓存机制

目前很多商业应用都会涉及到从网络上读取图片数据的问题，为了节约用户流量，应用一般会将图片缓存起来。图片缓存一般分为内存缓存和外存缓存。内存缓存运用java的缓存机制，在程序完全退出后，缓存所在的内存空间可能被其它应用程序占用从而丢失。外存缓存一般放在程序特有的访问空间或者sd卡中，在sd卡中存放的资源为公有资源，其它程序也可以访问，且对用户来讲没有一个强制清除缓存的规范机制。综合以上，本文采用将缓存图片放置在程序的特有空间中， 其它应用程序无法访问，且用户可以在应用程序管理中的”清除数据”选项中清除缓存。 本文提供三种缓存策略：（1）LRU算法，固定缓存图片数量(max_num)，当图片数量超出max_num时，将缓存中最近用的最少的图片删除。（2）FTU算法，固定每张图片的缓存时限，以最后一次使用算起，超过时限后删除。（3）FMU算法，在存储器中固定一定大小的存储空间，超过固定空间后将缓存中占用最大尺寸的图片删除。使用时只需要向方法体中传递图片的URL即可。

代码片段

使用方法： 1.导入jar;

2. 获取服务；
3.提交url,交给程序去判断是否下载。 

public class ImagecachetacticsdemoActivity extends Activity { public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.item); /FMU/ imageCacheManager = ImageCacheManager.getImageCacheService(this, ImageCacheManager.MODE_FIXED_MEMORY_USED, “memory”); imageCacheManager.setMax_Memory(1024 1024); /FTU/ // imageCacheManager = ImageCacheManager.getImageCacheService(this, // ImageCacheManager.MODE_FIXED_TIMED_USED, “time”); // imageCacheManager.setDelay_millisecond(3 60 1000); /LRU*/ // imageCacheManager = ImageCacheManager.getImageCacheService(this, // ImageCacheManager.MODE_LEAST_RECENTLY_USED, “num”); // imageCacheManager.setMax_num(5); // imageCacheManager = ImageCacheManager.getImageCacheService(this, // ImageCacheManager.MODE_NO_CACHE_USED, “nocache”); mImageView = (ImageView) findViewById(R.id.imageView); new DownloadTask() .execute(“http://www.touxiang99.com/uploads/allimg/110417/1_110417112640_2.jpg“); } private class DownloadTask extends AsyncTask { @Override protected Bitmap doInBackground(String… params) { try { return imageCacheManager.downlaodImage(new URL(params[0])); } catch (IOException e) { e.printStackTrace(); } return null; } @Override protected void onPostExecute(Bitmap result) { mImageView.setImageBitmap(result); super.onPostExecute(result); } @Override protected void onPreExecute() { mImageView.setImageResource(R.drawable.ic_launcher); super.onPreExecute(); } } private ImageView mImageView; private ImageCacheManager imageCacheManager; }

10.Handler机制

11.什么是ANR 如何避免它？

ANR：Application NotResponding，五秒 　　在Android中，活动管理器和窗口管理器这两个系统服务负责监视应用程序的响应。当出现下列情况时，Android就会显示ANR对话框了： 　　对输入事件(如按键、触摸屏事件)的响应超过5秒 　　意向接受器(intentReceiver)超过10秒钟仍未执行完毕 　　Android应用程序完全运行在一个独立的线程中(例如main)。这就意味着，任何在主线程中运行的，需要消耗大量时间的操作都会引发ANR。因为此时，你的应用程序已经没有机会去响应输入事件和意向广播(Intentbroadcast)。 　　因此，任何运行在主线程中的方法，都要尽可能的只做少量的工作。特别是活动生命周期中的重要方法如onCreate()和 onResume()等更应如此。潜在的比较耗时的操作，如访问网络和数据库;或者是开销很大的计算，比如改变位图的大小，需要在一个单独的子线程中完成(或者是使用异步请求，如数据库操作)。但这并不意味着你的主线程需要进入阻塞状态已等待子线程结束 — 也不需要调用Therad.wait()或者Thread.sleep()方法。取而代之的是，主线程为子线程提供一个句柄(Handler)，让子线程在即将结束的时候调用它(xing:可以参看Snake的例子，这种方法与以前我们所接触的有所不同)。使用这种方法涉及你的应用程序，能够保证你的程序对输入保持良好的响应，从而避免因为输入事件超过5秒钟不被处理而产生的ANR。这种实践需要应用到所有显示用户界面的线程，因为他们都面临着同样的超时问题。 12.sqlite操作使用

本帖最后由 y_m 于 2013-6-2 00:27 编辑SQLite数据库 数据库:它就是一个软件，需要安装，安装完后就有自己的目录结构。 都有客户端和服务端，所有的数据库都实现了SQL标准 SQLite数据库:它是一个轻量级数据库，设计目的是嵌入式的，而且它占用的资源非常少 注意:除了主键不能存储任意的类型之外，其他的字段可以存放任意的数据类型 SqliteDatabase它要求:表的主键的字段名最好是_id，一定要_id 否则报错;

Cmd操作指令： sqlite3 qjq.db 进入数据库 .tables 查看数据库里面的表 创建数据库文件： 三种方式： 第一种通过上下文创建数据库： public class DBsqlite { private Context context; public DBsqlite(Context context) { super(); this.context = context; } public void createDB() { //通过上下文创建数据库 context.openOrCreateDatabase(“persons.db”, Context.MODE_PRIVATE, null); } ｝ 第二种SQLiteDatabase创建数据库 public void createDB(){ String dir=”/data/data/“+context.getPackageName(); File file=new File(dir,”persons.db”); SQLiteDatabase.openOrCreateDatabase(file, null); } 第三种创建一个help类继承SQLiteOpenHelper 实现DBhelp构造onCreate方法onUpgrade方法 public class DBhelp extends SQLiteOpenHelper { public DBhelp(Context context) { // 上下文 ，数据库名，游标工厂 ，数据版本 super(context, “persons.db”, null, 2); // TODO Auto-generated constructor stub } //数据库第一次创建之后调用该方法。创建表、视图。。。 或者初始化表信息 public void onCreate(SQLiteDatabase db) { // 创建数据库 db.execSQL(“create table fish(_id integer primary key autoincrement,name text)”); } @Override //当数据版本被改变则会执行该方法super(context, “persons.db”, null, 3)； public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // 版本修改表添加一列 db.execSQL(“ALTER TABLE fish ADD amount integer”); } Crud 以下分别用两种方式crud了，一种是面向SQL ，一种是面向对象，但是面向对象的源码里面其实也是在帮你拼接sql。 public class OtherFishService { private SQLiteOpenHelper mOpenHelper; public OtherFishService(Context context) { // TODO Auto-generated constructor stub mOpenHelper = new DBHelper(context); } /**

     * 插入数据
     * @param name
     */
    public void insert(String name){
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();

// String sql = “insert into fish(name) values(?)”; if(db.isOpen()){ // db.execSQL(sql, new Object[]{name}); //insert into fish //ContentValues里面就是要插入的值 ContentValues values = new ContentValues(); values.put(“name”, name); db.insert(“fish”, “_id”, values); db.close(); } } public List query(){ List fishs = new ArrayList(); SQLiteDatabase db = mOpenHelper.getReadableDatabase(); // String sql =”select from fish”; if(db.isOpen()){ //cursor 就是resultset // Cursor cursor = db.rawQuery(sql, null); Cursor cursor = db.query(“fish”,//表名 new String[]{““},//要查询的列名 null,//查询条件 null,//条件参数 null,//分组 null,//条件 null);//排序 while(cursor.moveToNext()){ //得到_id的下标 int column_index = cursor.getColumnIndex(“_id”); //得到_id的值 int _id = cursor.getInt(column_index); String name = cursor.getString(cursor.getColumnIndex(“name”)); Fish fish = new Fish(_id, name); fishs.add(fish); } //cursor使用完成之后一定要关闭 cursor.close(); db.close(); } return fishs; } public void update(Fish fish){ SQLiteDatabase db = mOpenHelper.getWritableDatabase(); if(db.isOpen()){ // String sql = “update Fish set name = ? where _id = ?”; // db.execSQL(sql,new Object[]{fish.name,fish._id}); ContentValues values = new ContentValues(); values.put(“name”,fish.name); String whereClause = “ _id = ?”; String[] whereArgs = new String[]{fish._id+””}; db.update(“fish”, values, whereClause, whereArgs); } } public void delete(int _id){ SQLiteDatabase db = mOpenHelper.getWritableDatabase(); if(db.isOpen()){ // String sql = “delete from fish where _id = ?”; // db.execSQL(sql,new Object[]{_id}); String whereClause = “ _id = ?”; String[] whereArgs = new String[]{_id+””}; db.delete(“fish”, whereClause, whereArgs); } } }

SqliteDatabase事务列表显示多条数据事务，以及事务的完整性SQLiteDatabase控制事务方法： beginTransaction(); 开启事务 setTransactionSuccessful(); 设置事务成功 endTransaction();结束事务 db.beginTransaction(); //开始事务 try { db.execSQL(“update student set amount=amount-300 where name=?”, new Object[]{“张三”}); db.execSQL(“update student set amount=amount+300 where name=?”, new Object[]{“李四”}); db.setTransactionSuccessful(); //设置事务成功

    } catch (Exception e) {
            System.out.println("事务执行出现异常，不能设置事务成功！");
    }finally{
    //无论是否出现异常，都要结束事务。
            db.endTransaction();
    }

cmd常见指令： Sqlite3 xx.db 查看xx数据库 .tables 查看所有表 .exit 退出 .databases 查看所有数据库 标签： include标签实现组件复用 将另一个布局文件加载到当前布局文件，实现组件复用

属性 android:visibility=有三个选项 列表显示多条数据 simpleAdapter 代码： OtherFishService ofs = new OtherFishService(this); List fishs = ofs.query(); List>data=new ArrayList>(); for(Fish f:fishs){ Map map = new HashMap(); map.put(“_id”, f._id); map.put(“name”,f.name); map.put(“age”, f.age); data.add(map); } String[] from = new String[]{“_id”,”name”,”age”}; int[] to = new int[]{R.id.tv_id,R.id.tv_name,R.id.tv_age}; SimpleAdapter adapter = new SimpleAdapter(this, data, R.layout.item, from, to); lv.setAdapter(adapter); 以上可以实现但是过于麻烦！ 我们还可以使用专门为数据库提供的 Cursoradapter OtherFishService ofs = new OtherFishService(this); Cursor c = ofs.getAllCursor(); String[] from = new String[]{“_id”,”name”,”age”}; int[] to = new int[]{R.id.tv_id,R.id.tv_name,R.id.tv_age}; SimpleCursorAdapter adapter = new SimpleCursorAdapter( this, R.layout.item, c, from, to); lv.setAdapter(adapter); 我们不单单只用android给我们提过的CursorAdapter我们还可以自定义一个CursorAdapter 自定义CursorAdapter public class MyCursorAdapter extends CursorAdapter { //布局加载器（是一个服务，用来加载xml布局文件到java代码中） private LayoutInflater mInflater;

    public MyCursorAdapter(Context context, Cursor c) {
            super(context, c);
    mInflater=(LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            mInflater = LayoutInflater.from(context);
    }
    //创建一个item的布局
    @Override
    public View newView(Context context, Cursor cursor, ViewGroup parent) {
            // TODO Auto-generated method stub
            //通过布局加载器加载布局
            View view = mInflater.inflate(R.layout.item, null);
            return view;
    }
    //把数据绑定给item里面的布局
    @Override
    public void bindView(View view, Context context, Cursor cursor) {
            // TODO Auto-generated method stub
    //1 先得到控件
            //2 得到数据
            //3 绑定数据给控件
            TextView tv_id = (TextView) view.findViewById(R.id.tv_id);
            TextView tv_name = (TextView) view.findViewById(R.id.tv_name);
            TextView tv_age = (TextView) view.findViewById(R.id.tv_age);
            String _id = cursor.getString(0);
            String name = cursor.getString(1);
            String age = cursor.getString(2);
            tv_id.setText(_id);
            tv_name.setText(name);
            tv_age.setText(age);
            int position = cursor.getPosition();
            if(position%2 ==0){
                    view.setBackgroundColor(Color.RED);
            }else{
                    view.setBackgroundColor(Color.GREEN);
            }
    }

} 为了实现 我们想要的并且系统没提供的效果所以我们要自定义Adapter 不仅可以继承CursorAdapter 实现自定义CursorAdapter ，我们还可以通 过继承BaseAdapter 。

private class MyCursorAdapter extends BaseAdapter {
                private Context context;
                private Cursor c;
                private LayoutInflater mInflater;
                public MycursorAdapter1(Context context, Cursor c) {
                        super();
                        this.context = context;
                        this.c = c;
                        mInflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                }
                @Override
                public int getCount() {
                        // TODO Auto-generated method stub
                        return c.getCount();
                }
                @Override
                public Object getItem(int position) {
                        Person p = null;
                        if (c.moveToPosition(position)) {
                                String id = c.getString(0);
                                String name = c.getString(1);
                                String age = c.getString(2);
                                p = new Person(id, name, age);
                        }
                        return p;
                }
                @Override
                public long getItemId(int position) {
                        // TODO Auto-generated method stub
                        return position;
                }
                @Override
                public View getView(int position, View convertView, ViewGroup parent) {
                        //1得到视图
//2从视图中拿到要显示对象
//3从cursor里面拿值
//4绑定
//5返回

注意：getView方法实际会执行原本次数2倍（例：7条数据与，getView执行7*2次），第一遍执行是为了测试有多少条数据，第2遍执行才是真正的现实操作

                        View view = mInflater.inflate(R.layout.item, null);
                        TextView tv_id = (TextView) view.findViewById(R.id.bt_id);
                        TextView tv_name = (TextView) view.findViewById(R.id.bt_name);
                        TextView tv_age = (TextView) view.findViewById(R.id.bt_age);
                        if (c.moveToPosition(position)) {
                                String id = c.getString(0);
                                String name = c.getString(1);
                                String age = c.getString(2);
                                tv_id.setText(id);
                                tv_name.setText(name);
                                tv_age.setText(age);
                        }
                        if ( position% 2 == 0) {
                                view.setBackgroundColor(Color.RED);
                        }
                        return view;
                }
        }

当我们用完cursor的时候，怎么关闭他？ //应用回收资源 退出程序时调用该方法 @Override protected void onDestroy() { // TODO Auto-generated method stub super.onDestroy();r Cursor c = adapter.getCursor(); if(c != null && !c.isClosed()){ c.close(); } } 13请描述一下Intent 和 Intent Filter。

Android 中通过 Intent 对象来表示一条消息，一个 Intent 对象不仅包含有这个消息的目的地，还可以包含消息的内容，这好比一封Email，其中不仅应该包含收件地址，还可以包含具体的内容。对于一个 Intent 对象，消息“目的地”是必须的，而内容则是可选项。 通过Intent 可以实现各种系统组件的调用与激活.

Intent filter: 可以理解为邮局或者是一个信笺的分拣系统… 这个分拣系统通过3个参数来识别 Action: 动作 view Data: 数据uri uri Category : 而外的附加信息 Action 匹配 Action 是一个用户定义的字符串，用于描述一个 Android 应用程序组件，一个 Intent Filter 可以包含多个 Action。在 AndroidManifest.xml 的 Activity 定义时可以在其 节点指定一个 Action 列表用于标示 Activity 所能接受的“动作”，例如： ……

如果我们在启动一个 Activity 时使用这样的 Intent 对象： Intent intent =new Intent(); intent.setAction(“cn.itcast.action”); startActivity(intent);

那么所有的 Action 列表中包含了“cn.itcast”的 Activity 都将会匹配成功。 Android 预定义了一系列的 Action 分别表示特定的系统动作。这些 Action 通过常量的方式定义在 android.content. Intent中，以“ACTION_”开头。我们可以在 Android 提供的文档中找到它们的详细说明。 URI 数据匹配 一个 Intent 可以通过 URI 携带外部数据给目标组件。在 节点中，通过 节点匹配外部数据。 mimeType 属性指定携带外部数据的数据类型，scheme 指定协议，host、port、path 指定数据的位置、端口、和路径。如下： Intent intent = new Intent(); intent.setAction(Intent.ACTION_CALL); insent.setData( Uri.parse(tel:12345)); startAcitivty(); 电话的uri tel: 12345 http://www.baidu.com 自己定义的uri itcast://cn.itcast/person/10

如果在 Intent Filter 中指定了这些属性，那么只有所有的属性都匹配成功时 URI 数据匹配才会成功。 Category 类别匹配

节点中可以为组件定义一个 Category 类别列表，当 Intent 中包含这个列表的所有项目时 Category 类别匹配才会成功。 默认是DEFAULT14.Intent传递数据时，可以传递哪些类型数据？

1.一般的基本数据类型 Intent .putextra() intent.getextra(); Parselable Serializable

   2.数据的uri, intent.setData() intent.getData();

15.Android事件传递机制

Android中dispatchTouchEvent,onInterceptTouchEvent, onTouchEvent的理解ec android中的事件类型分为按键事件和屏幕触摸事件，Touch事件是屏幕触摸事件的基础事件，有必要对它进行深入的了解。 一个最简单的屏幕触摸动作触发了一系列Touch事件：ACTION_DOWN->ACTION_MOVE->ACTION_MOVE->ACTION_MOVE…->ACTION_MOVE->ACTION_UP android的事件处理分为3步。 1）public booleandispatchTouchEvent(MotionEvent ev) 这个方法用来分发TouchEvent 2）public boolean onInterceptTouchEvent(MotionEvent ev) 这个方法用来拦截TouchEvent 3）public boolean onTouchEvent(MotionEvent ev) 这个方法用来处理TouchEvent 假设当前Activity 布局如下：

dispatchTouchEvent事件分发 当TouchEvent发生时，首先Activity将TouchEvent传递给最顶层的View， TouchEvent最先到达最顶层 view 的 dispatchTouchEvent 。然后由 dispatchTouchEvent 方法进行分发，如果dispatchTouchEvent返回true ，则交给这个view的onTouchEvent处理，如果dispatchTouchEvent返回 false ，则交给这个 view 的 onInterceptTouchEvent方法来决定是否要拦截这个事件， 如果onInterceptTouchEvent返回 true ，也就是拦截掉了，则交给它的 onTouchEvent 来处理，如果onInterceptTouchEvent返回 false ，那么就传递给子 view，由子 view 的 dispatchTouchEvent 再来开始这个事件的分发。 如图：

事件拦截：onInterceptTouchEvent onInterceptTouchEvent用于改变事件的传递方向。决定传递方向的是返回值，返回为false时事件会传递给子控件，返回值为true时事件会传递给当前控件的onTouchEvent()，这就是所谓的Intercept(拦截)。 [tisa ps:正确的使用方法是，在此方法内仅判断事件是否需要拦截，然后返回。即便需要拦截也应该直接返回true，然后由onTouchEvent方法进行处理。] onTouchEvent用于处理事件，返回值决定当前控件是否消费（consume）了这个事件。尤其对于ACTION_DOWN事件，返回true，表示我想要处理后续事件（ACTION_MOVE或者ACTION_UP）；返回false，表示不关心此事件，并返回由父类进行处理。 在没有重写onInterceptTouchEvent()和onTouchEvent()的情况下(他们的返回值都是false), 对上面这个布局，MotionEvent事件的传递顺序如下：

当某个控件的onInterceptTouchEvent()返回值为true时，就会发生截断，事件被传到当前控件的onTouchEvent()。如我们将LayoutView2的onInterceptTouchEvent()返回值为true,则传递流程变成：

如果我们同时将LayoutView2的onInterceptTouchEvent()和onTouchEvent()设置成true，那么LayoutView2将消费被传递的事件，同时后续事件（如跟着ACTION_DOWN的ACTION_MOVE或者ACTION_UP）会直接传给LayoutView2的onTouchEvent(),不传给其他任何控件的任何函数。同时传递给子空间一个ACTION_CANCEL事件。传递流程变成（图中没有画出ACTION_CANCEL事件）：

小总结：onInterceptTouchEvent是自rootiew向下传递, onTouchEvent正好相反。 16.请介绍下Android中常用的五种布局。

FrameLayout（帧布局），LinearLayout （线性布局），AbsoluteLayout（绝对布局），RelativeLayout（相对布局），TableLayout（表格布局） FrameLayout 从屏幕的左上角开始布局,叠加显示, 实际应用 播放器的暂停按钮.
LinearLayout 线性布局，这个东西，从外框上可以理解为一个div，他首先是一个一个从上往下罗列在屏幕上。每一个LinearLayout里面又可分为垂直布局 （android:orientation=”vertical”）和水平布局（android:orientation=”horizontal” ）。当垂直布局时，每一行就只有一个元素，多个元素依次垂直往下；水平布局时，只有一行，每一个元素依次向右排列。 AbsoluteLayout 绝对布局犹如div指定了absolute属性，用X,Y坐标来指定元素的位置android:layout_x=”20px” view android:layout_y=”12px” fwvga 854480apk qq斗地主 qq游戏大厅800480 800480.apk fwvga 854480 指定平板机型的游戏开发中经常用到绝对布局 widget 绝对布局 指定机型的平板游戏开发. 2.3 3.0

1. 界面布局 任务管理器 gridview
2. 手机 任务管理 listview

lephone lepad RelativeLayout 相对布局可以理解为某一个元素为参照物，来定位的布局方式。主要属性有： 相对于某一个元素 android:layout_below=”@id/aaa” 该元素在 id为aaa的下面 android:layout_toLeftOf=”@id/bbb” 改元素的左边是bbb 相对于父元素的地方 android:layout_alignParentLeft=”true” 在父元素左对齐 android:layout_alignParentRight=”true” 在父元素右对齐

Android oa客户端. TableLayout

简单的说，Handler获取当前线程中的looper对象，looper用来从存放Message的MessageQueue中取出Message，再有Handler进行Message的分发和处理. Message Queue(消息队列)：用来存放通过Handler发布的消息，通常附属于某一个创建它的线程，可以通过Looper.myQueue()得到当前线程的消息队列. Handler：可以发布或者处理一个消息或者操作一个Runnable，通过Handler发布消息，消息将只会发送到与它关联的消息队列，然也只能处理该消息队列中的消息. Looper：是Handler和消息队列之间通讯桥梁，程序组件首先通过Handler把消息传递给Looper，Looper把消息放入队列。Looper也把消息队列里的消息广播给所有的Handler：Handler接受到消息后调用handleMessage进行处理. Message：消息的类型，在Handler类中的handleMessage方法中得到单个的消息进行处理,在单线程模型下，为了线程通信问题，Android设计了一个Message Queue(消息队列)，线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。下面将对它们进行分别介绍：

1. Message Message消息，理解为线程间交流的信息，处理数据后台线程需要更新UI，则发送Message内含一些数据给UI线程。
2. Handler Handler处理者，是Message的主要处理者，负责Message的发送，Message内容的执行处理。后台线程就是通过传进来的 Handler对象引用来sendMessage(Message)。而使用Handler，需要implement 该类的 handleMessage(Message)方法，它是处理这些Message的操作内容，例如Update UI。通常需要子类化Handler来实现handleMessage方法。
3. Message Queue Message Queue消息队列，用来存放通过Handler发布的消息，按照先进先出执行。 每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息：sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同：通过sendMessage发送的是一个message对象,会被 Handler的handleMessage()函数处理；而通过post方法发送的是一个runnable对象，则会自己执行。
4. Looper Looper是每条线程里的Message Queue的管家。Android没有Global的Message Queue，而Android会自动替主线程(UI线程)建立Message Queue，但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL，但调用Looper.myLooper() 得到当前线程的Looper就有可能为NULL。对于子线程使用Looper，API Doc提供了正确的使用方法：这个Message机制的大概流程：
5. 在Looper.loop()方法运行开始后，循环地按照接收顺序取出Message Queue里面的非NULL的Message。
6. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)到Message Queue，该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message，则调用该Message的target指向的Hander的dispatchMessage函数对Message进行处理。在dispatchMessage方法里，如何处理Message则由用户指定，三个判断，优先级从高到低： 1) Message里面的Callback，一个实现了Runnable接口的对象，其中run函数做处理工作； 2) Handler里面的mCallback指向的一个实现了Callback接口的对象，由其handleMessage进行处理； 3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数，通过这个实现的handleMessage函数处理消息。 由此可见，我们实现的handleMessage方法是优先级最低的！
7. Handler处理完该Message (update UI) 后，Looper则设置该Message为NULL，以便回收！ 在网上有很多文章讲述主线程和其他子线程如何交互，传送信息，最终谁来执行处理信息之类的，个人理解是最简单的方法——判断Handler对象里面的Looper对象是属于哪条线程的，则由该线程来执行！
8. 当Handler对象的构造函数的参数为空，则为当前所在线程的Looper；
9. Looper.getMainLooper()得到的是主线程的Looper对象，Looper.myLooper()得到的是当前线程的Looper对象。 19.AIDL的全称是什么？如何工作？

AIDL的英文全称是Android Interface Define Language当A进程要去调用B进程中的service时，并实现通信，我们通常都是通过AIDL来操作的A工程：首先我们在net.blogjava.mobile.aidlservice包中创建一个RemoteService.aidl文件，在里面我们自定义一个接口，含有方法get。ADT插件会在gen目录下自动生成一个RemoteService.java文件，该类中含有一个名为RemoteService.stub的内部类，该内部类中含有aidl文件接口的get方法。说明一：aidl文件的位置不固定，可以任意然后定义自己的MyService类，在MyService类中自定义一个内部类去继承RemoteService.stub这个内部类，实现get方法。在onBind方法中返回这个内部类的对象，系统会自动将这个对象封装成IBinder对象，传递给他的调用者。其次需要在AndroidManifest.xml文件中配置MyService类，代码如下： 为什么要指定调用AIDL服务的ID,就是要告诉外界MyService这个类能够被别的进程访问，只要别的进程知道这个ID，正是有了这个ID,B工程才能找到A工程实现通信。说明：AIDL并不需要权限B工程： 首先我们要将A工程中生成的RemoteService.java文件拷贝到B工程中，在bindService方法中绑定aidl服务 绑定AIDL服务就是将RemoteService的ID作为intent的action参数。 说明：如果我们单独将RemoteService.aidl文件放在一个包里，那个在我们将gen目录下的该包拷贝到B工程中。如果我们将RemoteService.aidl文件和我们的其他类存放在一起，那么我们在B工程中就要建立相应的包，以保证RmoteService.java文件的报名正确，我们不能修改RemoteService.java文件 bindService(new Inten(“net.blogjava.mobile.aidlservice.RemoteService”), serviceConnection, Context.BIND_AUTO_CREATE); ServiceConnection的onServiceConnected(ComponentName name, IBinder service)方法中的service参数就是A工程中MyService类中继承了RemoteService.stub类的内部类的对象。

20.请解释下Android程序运行时权限与文件系统权限的区别。

Android程序执行需要读取到安全敏感项必需在androidmanifest.xml中声明相关权限请求, 打电话,访问网络,获取坐标,读写sd卡,读写联系人等..安装的时候会提示用户…

文件系统的权限是linux权限. 比如说sharedpreference里面的Context.Mode.private Context.Mode.world_read_able Context.Mode_world_writeable 777自己 同组 其他21.系统上安装了多种浏览器，能否指定某浏览器访问指定页面

Intent intent =newIntent();
intent.setAction(“android.intent.action.VIEW”);
Uri content_url =Uri.parse(“http://www.163.com“);
intent.setData(content_url);
intent.setClassName(“com.android.browser”,”com.android.browser.BrowserActivity”);
startActivity(intent); 只要修改以intent.setClassName(“com.android.browser”,”com.android.browser.BrowserActivity”); 中相应的应用程序packagename 和要启动的activity即可启动其他浏览器来 uc浏览器”：”com.uc.browser”, “com.uc.browser.ActivityUpdate“ opera浏览器：”com.opera.mini.android”, “com.opera.mini.android.Browser” qq浏览器：”com.tencent.mtt”, “com.tencent.mtt.MainActivity”22.对android主线程的运用和理解。

主ui线程不能执行耗时的操作23.对android虚拟机的理解，包括内存管理机制垃圾回收机制。dalvik和art区别

虚拟机很小,空间很小,谈谈移动设备的虚拟机的大小限制 16M , 谈谈加载图片的时候怎么处理大图片的, outmemoryException BitmapFactory.option 垃圾回收,没有引用的对象,在某个时刻会被系统gc掉 .

Dalvik和标准Java虚拟机(JVM)首要差别 Dalvik 基于寄存器，而 JVM 基于栈。 基于寄存器的虚拟机对于编译后变大的程序来说，在它们执行的时候，花费的时间更短。 Dalvik和Java运行环境的区别 1：Dalvik主要是完成对象生命周期管理，堆栈管理，线程管理，安全和异常管理，以及垃圾回收等等重要功能。 2：Dalvik负责进程隔离和线程管理，每一个Android应用在底层都会对应一个独立的Dalvik虚拟机实例，其代码在虚拟机的解释下得以执行。 3：不同于Java虚拟机运行java字节码，Dalvik虚拟机运行的是其专有的文件格式Dex 4:dex文件格式可以减少整体文件尺寸，提高I/o操作的类查找速度。 5:odex是为了在运行过程中进一步提高性能，对dex文件的进一步优化。 6：所有的Android应用的线程都对应一个Linux线程，虚拟机因而可以更多的依赖操作系统的线程调度和管理机制 7：有一个特殊的虚拟机进程Zygote，他是虚拟机实例的孵化器。它在系统启动的时候就会产生，它会完成虚拟机的初始化，库的加载，预制类库和初始化的操作。如果系统需要一个新的虚拟机实例，它会迅速复制自身，以最快的数据提供给系统。对于一些只读的系统库，所有虚拟机实例都和Zygote共享一块内存区域。 8：Dalvik是由Dan Bornstein编写的，名字来源于他的祖先曾经居住过名叫Dalvík的小渔村，村子位于冰岛Eyjafjörður

许多GC实现都是在对象开头的地方留一小块空间给GC标记用。Dalvik VM则不同，在进行GC的时候会单独申请一块空间，以位图的形式来保存整个堆上的对象的标记，在GC结束后就释放该空间。 dalvik是执行的时候编译+运行，安装比较快，开启应用比较慢，应用占用空间小ART是安装的时候就编译好了，执行的时候直接就可以运行的，安装慢，开启应用快，占用空间大用个比喻来说就是，骑自行车dalvik 是已经折叠起来的自行车，每次骑都要先组装自行车才能骑ART 是已经组装好的自行车，每次骑直接上车就能走人效率高在开启的时候，运行中的速度是差不多的24.Framework工作方式及原理，Activity是如何生成一个view的，机制是什么。

主要用到反射和代理的知识。主要用pull解析xml，然后通过反射得到属性，在onDrew画出来

反射 , 配置文件 可以讲下activity的源码,比如说 每个activity里面都有window.callback和keyevent.callback,一些回调的接口或者函数吧. 框架把activity创建出来就会调用里面的这些回调方法,会调用activity生命周期相关的方法.

Activity创建一个view是通过ondraw 画出来的, 画这个view之前呢,还会调用onmeasure方法来计算显示的大小.25.android本身的一些限制，比如apk包大小限制，读取大文件时的时间限

这个问题问的有问题, apk包大小限制不好说, 极品飞车有100M 还是能装到手机上, 世面google market 上大程序 主程序 很小 5~10M 下载sdcard 200~300M 15分钟之内 申请退款 apk包,精简包, 素材存放在服务器. 游戏程序.

读大文件的时间限制应该是main线程里面的时间限制吧.5秒.26.Android程序与Java程序的区别？

Android程序用android sdk开发,java程序用javasdk开发. Android SDK引用了大部分的Java SDK，少数部分被Android SDK抛弃，比如说界面部分，java.awt swing package除了java.awt.font被引用外，其他都被抛弃，在Android平台开发中不能使用。 android sdk 添加工具jar httpclient , pull opengl

将Java 游戏或者j2me程序移植到Android平台的过程中， Android SDK 与Java SDK的区别是很需要注意的地方。 sampleDataAdpter(“YY-MM-DD”)27.Android中Task任务栈的分配

首先我们来看下Task的定义，Google是这样定义Task的：a task is what the user experiences as an “application.” It’s a group of related activities, arranged in a stack. A task is a stack of activities, not a class or an element in the manifest file. 这意思就是说Task实际上是一个Activity栈，通常用户感受的一个Application就是一个Task。从这个定义来看，Task跟Service或者其他Components是没有任何联系的，它只是针对Activity而言的。 Activity有不同的启动模式, 可以影响到task的分配 Task，简单的说，就是一组以栈的模式聚集在一起的Activity组件集合。它们有潜在的前后驱关联，新加入的Activity组件，位于栈顶，并仅有在栈顶的Activity，才会有机会与用户进行交互。而当栈顶的Activity完成使命退出的时候，Task会将其退栈，并让下一个将跑到栈顶的Activity来于用户面对面，直至栈中再无更多Activity，Task结束。 事件 Task栈（粗体为栈顶组件） 点开Email应用，进入收件箱（Activity A） A 选中一封邮件，点击查看详情（Activity B） AB 点击回复，开始写新邮件（Activity C） ABC 写了几行字，点击选择联系人，进入选择联系人界面（Activity D） ABCD 选择好了联系人，继续写邮件 ABC 写好邮件，发送完成，回到原始邮件 AB 点击返回，回到收件箱 A 退出Email程序 null 如上表所示，是一个实例。从用户从进入邮箱开始，到回复完成，退出应用整个过程的Task栈变化。这是一个标准的栈模式，对于大部分的状况，这样的Task模型，足以应付，但是，涉及到实际的性能、开销等问题，就会变得残酷许多。

比如，启动一个浏览器，在Android中是一个比较沉重的过程，它需要做很多初始化的工作，并且会有不小的内存开销。但与此同时，用浏览器打开一些内容，又是一般应用都会有的一个需求。设想一下，如果同时有十个运行着的应用（就会对应着是多个Task），都需要启动浏览器，这将是一个多么残酷的场面，十个Task栈都堆积着很雷同的浏览器Activity， 是多么华丽的一种浪费啊。 于是你会有这样一种设想，浏览器Activity，可不可以作为一个单独的Task而存在，不管是来自那个Task的请求，浏览器的Task，都不会归并过去。这样，虽然浏览器Activity本身需要维系的状态更多了，但整体的开销将大大的减少，这种舍小家为大家的行为，还是很值得歌颂的 standard”, “singleTop”, “singleTask”, “singleInstance”。

standard模式， 是默认的也是标准的Task模式，在没有其他因素的影响下，使用此模式的Activity，会构造一个Activity的实例，加入到调用者的Task栈中去，对于使用频度一般开销一般什么都一般的Activity而言，standard模式无疑是最合适的，因为它逻辑简单条理清晰，所以是默认的选择。

而singleTop模式，基本上于standard一致，仅在请求的Activity正好位于栈顶时，有所区别。此时，配置成singleTop的Activity，不再会构造新的实例加入到Task栈中，而是将新来的Intent发送到栈顶Activity中，栈顶的Activity可以通过重载onNewIntent来处理新的Intent（当然，也可以无视…）。这个模式，降低了位于栈顶时的一些重复开销，更避免了一些奇异的行为（想象一下，如果在栈顶连续几个都是同样的Activity，再一级级退出的时候，这是怎么样的用户体验…），很适合一些会有更新的列表Activity展示。一个活生生的实例是，在Android默认提供的应用中，浏览器（Browser）的书签Activity（BrowserBookmarkPage），就用的是singleTop。

singleTask，和singleInstance，则都采取的另辟Task的蹊径。 标志为singleTask的Activity，最多仅有一个实例存在，并且，位于以它为根的Task中。所有对该Activity的请求，都会跳到该Activity的Task中展开进行。singleTask，很象概念中的单件模式，所有的修改都是基于一个实例，这通常用在构造成本很大，但切换成本较小的Activity中。最典型的例子，还是浏览器应用的主Activity（名为Browser…），它是展示当前tab，当前页面内容的窗口。它的构造成本大，但页面的切换还是较快的，于singleTask相配，还是挺天作之合的。

singleInstance显得更为极端一些。在大部分时候singleInstance与singleTask完全一致，唯一的不同在于，singleInstance的Activity，是它所在栈中仅有的一个Activity，如果涉及到的其他Activity，都移交到其他Task中进行。这使得singleInstance的Activity，像一座孤岛，彻底的黑盒，它不关注请求来自何方，也不计较后续由谁执行。在Android默认的各个应用中，很少有这样的Activity，在我个人的工程实践中，曾尝试在有道词典的快速取词Activity中采用过， 是因为我觉得快速取词入口足够方便（从notification中点选进入），并且会在各个场合使用，应该做得完全独立。

大的apk 拆成 很多小的apk ●Activity的android:affinity属性 1.配置后 当启动这个activity时就先去找有没有activity的亲和力属性相同 有就加入这个 activity所在的任务中没有就新开任务 2.affinity起作用需要的条件而者具备一个: 1.intent包含FLAG_ACTIVITY_NEW_TASK标记 2.activity元素启用了allowTaskReparenting属性.28.在Android中，怎么节省内存的使用，怎么主动回收内存？

回收已经使用的资源, 合理的使用缓存 合理设置变量的作用范围… application 对象 //未来的某一段时间执行 System.gc();29.不同工程中的方法是否可以相互调用？

可以,列举aidl访问远程服务的例子.30.dvm的进程和Linux的进程, 应用程序的进程是否为同一个概念 是同一概念

Dvm的进程是dalivk虚拟机进程,每个android程序都运行在自己的进程里面, 每个android程序系统都会给他分配一个单独的liunx uid(user id), 每个dvm都是linux里面的一个进程.所以说这两个进程是一个进程.31.在Android中是如何实现判断区分电话的状态，去电，来电、未接来电？

Day8 showAddressService.java TelephoneyManger.listen();32.谈谈Android的优点和不足之处。

1、开放性,开源ophone 阿里云( 完全兼容android) 2、挣脱运营商束缚 3、丰富的硬件选择 mtk android 4、不受任何限制的开发商 5、无缝结合的Google应用

缺点也有5处： 1、安全问题、隐私问题 2、卖手机的不是最大运营商 3、运营商对Android手机仍然有影响 4、山寨化严重 5、过分依赖开发商，缺乏标准配置33.Android系统中GC什么情况下会出现内存泄露呢?

视频编解码/内存泄露 检测内存泄露 工具

导致内存泄漏主要的原因是，先前申请了内存空间而忘记了释放。如果程序中存在对无用对象的引用，那么这些对象就会驻留内存，消耗内存，因为无法让垃圾回收器GC验证这些对象是否不再需要。如果存在对象的引用，这个对象就被定义为”有效的活动”，同时不会被释放。要确定对象所占内存将被回收，我们就要务必确认该对象不再会被使用。典型的做法就是把对象数据成员设为null或者从集合中移除该对象。但当局部变量不需要时，不需明显的设为null，因为一个方法执行完毕时，这些引用会自动被清理。 Java带垃圾回收的机制,为什么还会内存泄露呢?

Vector v = new Vector(10);
for (int i = 1; i < 100; i++) {
　Object o = new Object(); 　 v.add(o); 　 o = null;
}//此时，所有的Object对象都没有被释放，因为变量v引用这些对象。

Java 内存泄露的根本原因就是 保存了不可能再被访问的变量类型的引用34.Android UI中的View如何刷新。

在主线程中 拿到view调用Invalide()方法,查看画画板里面更新imageview的方法

在子线程里面可以通过postInvalide()方法;35. 简单描述下Android 数字签名。

Android 数字签名 在Android系统中，所有安装到系统的应用程序都必有一个数字证书，此数字证书用于标识应用程序的作者和在应用程序之间建立信任关系 Android系统要求每一个安装进系统的应用程序都是经过数字证书签名的，数字证书的私钥则保存在程序开发者的手中。Android将数字证书用来标识应用程序的作者和在应用程序之间建立信任关系，不是用来决定最终用户可以安装哪些应用程序。 这个数字证书并不需要权威的数字证书签名机构认证(CA)，它只是用来让应用程序包自我认证的。 同一个开发者的多个程序尽可能使用同一个数字证书，这可以带来以下好处。 (1)有利于程序升级，当新版程序和旧版程序的数字证书相同时，Android系统才会认为这两个程序是同一个程序的不同版本。如果新版程序和旧版程序的数字证书不相同，则Android系统认为他们是不同的程序，并产生冲突，会要求新程序更改包名。

(2)有利于程序的模块化设计和开发。Android系统允许拥有同一个数字签名的程序运行在一个进程中，Android程序会将他们视为同一个程序。所以开发者可以将自己的程序分模块开发，而用户只需要在需要的时候下载适当的模块。 在签名时，需要考虑数字证书的有效期： (1)数字证书的有效期要包含程序的预计生命周期，一旦数字证书失效，持有改数字证书的程序将不能正常升级。 (2)如果多个程序使用同一个数字证书，则该数字证书的有效期要包含所有程序的预计生命周期。 (3)Android Market强制要求所有应用程序数字证书的有效期要持续到2033年10月22日以后。 Android数字证书包含以下几个要点： (1)所有的应用程序都必须有数字证书，Android系统不会安装一个没有数字证书的应用程序 (2)Android程序包使用的数字证书可以是自签名的，不需要一个权威的数字证书机构签名认证 (3)如果要正式发布一个Android ，必须使用一个合适的私钥生成的数字证书来给程序签名，而不能使用adt插件或者ant工具生成的调试证书来发布。 (4)数字证书都是有有效期的，Android只是在应用程序安装的时候才会检查证书的有效期。如果程序已经安装在系统中，即使证书过期也不会影响程序的正常功能。36.android中的动画有哪几类，它们的特点和区别是什么？

两种，一种是Tween动画、还有一种是Frame动画。 Tween动画，这种实现方式可以使视图组件移动、放大、缩小以及产生透明度的变化； 可以通过布局文件,可以通过代码 1、 控制View的动画 a) alpha(AlphaAnimation) 渐变透明
b) scale(ScaleAnimation) 渐变尺寸伸缩 c) translate(TranslateAnimation) 画面转换、位置移动
d) rotate(RotateAnimation) 画面转移，旋转动画

2、 控制一个Layout里面子View的动画效果 a) layoutAnimation(LayoutAnimationController) b) gridAnimation(GridLayoutAnimationController) 另一种Frame动画，传统的动画方法，通过顺序的播放排列好的图片来实现，类似电影。37.说说mvc模式的原理，它在android中的运用

Android中没有mvc，只有在j2ee中有，是用于逻辑也界面分离的 MVC英文即Model-View-Controller，即把一个应用的输入、处理、输出流程按照Model、View、Controller的方式进行分离，这样一个应用被分成三个层——模型层、视图层、控制层。

Android中界面部分也采用了当前比较流行的MVC框架，在Android中M就是应用程序中二进制的数据，V就是用户的界面。Android的界面直接采用XML文件保存的，界面开发变的很方便。在Android中C也是很简单的，一个Activity可以有多个界面，只需要将视图的ID传递到setContentView()，就指定了以哪个视图模型显示数据。

在Android SDK中的数据绑定，也都是采用了与MVC框架类似的方法来显示数据。在控制层上将数据按照视图模型的要求（也就是Android SDK中的Adapter）封装就可以直接在视图模型上显示了，从而实现了数据绑定。比如显示Cursor中所有数据的ListActivity，其视图层就是一个ListView，将数据封装为ListAdapter，并传递给ListView，数据就在ListView中显示。38.通过点击一个网页上的url 就可以完成程序的自动安装,描述下原理

Day11 AddJavascriptInterface new Object{ callphone(); installapk(); }

将js与java相互调用再来一个例子，解决相互调用之间的关系。

首先说明一重要代码的情况：

android中的关键代码： webview.getSettings().setJavaScriptEnabled(true); webview.addJavascriptInterface(object,”name”); //把Name=”name”的对象添加到object中。object如果是this，就是window.name webview.loadUrl(“file:///android_asset/index.html”); //注意这个资源的位置放在assets文件夹下。

js或html中调用android中方法代码： js中使用 window.name.java中的方法()； android中调用js的function方法： Callfunction(){ webview.loadUrl(“javascript: function ()”); 需要注意的地方，很多数据类型js中不认识，最好是在android那边封装好，提供必要的方法接口。比如传到js中的list，在js中是没办法去得到里面的元素的。 addJavascriptInterface：addJavascriptInterface方法中要绑定的Java对象及方法要运行在另外的线程中，不能运行在构造他的线程中，也就是说不能运行在当前的activity线程中，就是把这个方法绑定到页面中，js也可以调用。 文档中的解释： Use this function to bind an object to Javascript so that the methods can be accessed from Javascript. The Java object that is bound runs in another thread and not in the thread that it was constructed in.

下面给出具体的测试代码： 1、Activity 代码

public class TestWebView extends Activity {  
    private WebView mWebView;  
    private List<String> list;  
    private int mkeyCode;  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        mWebView = (WebView) findViewById(R.id.htmlview);  
        initData();  
        WebSettings webSettings = mWebView.getSettings();  
        // 是否允许在webview中执行javascript  
        webSettings.setJavaScriptEnabled(true);  
        mWebView.addJavascriptInterface(this, "javatojs");  
        //加载网页  
        mWebView.loadUrl("file:///android_asset/index.html");  
    }  
    @Override  
    public boolean onKeyUp(int keyCode, KeyEvent event) {  
        mkeyCode = keyCode;  
        Log.i("AA","keyCode="+keyCode);  
        mWebView.loadUrl("javascript: OnKeyUp()");  
        return super.onKeyUp(keyCode, event);  
    }  
    public int getKeyCode(){  
        return mkeyCode;  
    }  
    void initData() {  
        list = new ArrayList<String>();  
        for (int i = 0; i < 5; i++) {  
            list.add("我是List中的第" + (i + 1) + "行");  
        }  
    }  
    /** 
     * 该方法将在js脚本中，通过window.javatojs.....()进行调用 
     *  
     * @return 
     */  
    public Object getObject(int index) {  
        Log.i("A","getObject");       
        return list.get(index);  
    }  
    public int getSize() {  
        Log.i("A","getSize");  
        return list.size();  
    }  
    public void Callfunction() {  
        Log.i("A","Callfunction");  
        mWebView.loadUrl("javascript: GetList()");  
    }  
    public void printStr(String str){  
        Log.i("A","GetList:" + str);  
    }     
}

2、js 代码 index.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
<html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
<title>demotitle></title>  
<script language="javascript">   
function GetList(){  
    var i=window.javatojs.getSize();  
    for(var n=0;n<i;n++){  
        var jsdata= window.javatojs.getObject(n);//拿到activity里面的属性javadata  
        window.javatojs.printStr("test");  
    }  
}  
function OnKeyUp() {  
    var keycode = window.javatojs.getKeyCode();  
    window.javatojs.printStr(keycode);  
}  
</script>  
</head>  
 <body style="background-color:#000;">  
  <table width="400" align="center"><tr><td>  
  <p> </p>  
  <p>  
<table width="400" align="center">  
<div id="output" >test</div>  
    <input type="submit" value="buttons"  
    onclick="document.getElementById('output').innerHTML=window.javatojs.Callfunction()"/>  
  <br>  
  </p>  
  </td></tr></table>  
</body>  
</html>

以上代码主要测试js与java相互调用，而由于按键这种系统事件被webview截获掉，有如下两种方式进行处理

1、把方向键的流程改成：先传给webcore，假如没处理，再在webview里面处理，这个需要修改webview.java代码 2、直接应用搞定，java捕获按键，然后调js函数，上面代码就是使用这种方法。

测试结果如下： 点击buttons按钮： I/A ( 4990): Callfunction I/A ( 4990): getSize I/A ( 4990): getObject I/A ( 4990): GetList:test I/A ( 4990): getObject I/A ( 4990): GetList:test I/A ( 4990): getObject I/A ( 4990): GetList:test I/A ( 4990): getObject I/A ( 4990): GetList:test I/A ( 4990): getObject I/A ( 4990): GetList:test

you press KEY_RIGHT I/AA ( 4990): keyCode=22 I/A ( 4990): GetList:22

you press KEY_UP I/AA ( 4990): keyCode=19 I/A ( 4990): GetList:19

you press KEY_DOWN I/AA ( 4990): keyCode=20 I/A ( 4990): GetList:20

you press KEY_LEFT I/AA ( 4990): keyCode=21 I/A ( 4990): GetList:21

这里为何使用这种方式，是因为对于上下左右及确定这种功能键被webview截取掉了，无法传递到webcore中，而只能重载OnKeyDown/OnKeyUp方法，再由js调用java方法来获取得。 对于数字键的处理可以直接在js中进行处理： logcat中会有明显的打印，对于这些键没有截掉，所以可以直接获取得到： D/webcore ( 4990): proc key: code=12 D/webcore ( 4990): proc key: nativeKey return false D/webcore ( 4990): proc key: nativeKey return true js代码可以如此编写：

 <script language="JavaScript">  
document.onkeypress = grab_keypress_event;  
document.onirkeypress = grab_irkeypress_event;  
document.onsystemevent = grab_system_event;  
document.onkeydown = grab_keydown_event;  
document.onkeyup = grab_keyup_event;  
function init()  
{  
    document.getElementById("txt_keypress").innerHTML = "";  
    document.getElementById("txt_irkey").innerHTML= "";  
    document.getElementById("txt_systemevent").innerHTML="";  
    document.getElementById("txt_keydown").innerHTML="";  
    document.getElementById("txt_keyup").innerHTML="";  
}  
function grab_keypress_event(event)  
{  
    var keycode = event.keyCode;  
    document.getElementById("txt_keypress").innerHTML=keycode;  
}  
function grab_irkeypress_event(event)  
{  
    var keycode = event.keyCode;  
    document.getElementById("txt_irkey").innerHTML=keycode;  
}  
function grab_system_event(event)  
{  
    var keycode = event.which;  
    document.getElementById("txt_systemevent").innerHTML=keycode;  
}  
function grab_keydown_event(event)  
{  
    var keycode = event.keyCode;  
    var type = event.type;  
    var mod = event.modifiers;  
    document.getElementById("txt_keydown").innerHTML=keycode;  
}  
function grab_keyup_event(event)  
{  
    var keycode = event.keyCode;  
    document.getElementById("txt_keyup").innerHTML=keycode;  
}  
 </script>

39.Service和Activity在同一个线程吗

默认情况同一线程 main主线程 ui线程40.ViewStub的应用

在开发应用程序的时候，经常会遇到这样的情况，会在运行时动态根据条件来决定显示哪个View或某个布局。那么最通常的想法就是把可能用到的View都写在上面，先把它们的可见性都设为View.GONE，然后在代码中动态的更改它的可见性。这样的做法的优点是逻辑简单而且控制起来比较灵活。但是它的缺点就是，耗费资源。虽然把View的初始可见View.GONE但是在Inflate布局的时候View仍然会被Inflate，也就是说仍然会创建对象，会被实例化，会被设置属性。也就是说，会耗费内存等资源。 推荐的做法是使用android.view.ViewStub，ViewStub是一个轻量级的View，它一个看不见的，不占布局位置，占用资源非常小的控件。可以为ViewStub指定一个布局，在Inflate布局的时候，只有ViewStub会被初始化，然后当ViewStub被设置为可见的时候，或是调用了ViewStub.inflate()的时候，ViewStub所向的布局就会被Inflate和实例化，然后ViewStub的布局属性都会传给它所指向的布局。这样，就可以使用ViewStub来方便的在运行时，要还是不要显示某个布局。 但ViewStub也不是万能的，下面总结下ViewStub能做的事儿和什么时候该用ViewStub，什么时候该用可见性的控制。 首先来说说ViewStub的一些特点：

     1. ViewStub只能Inflate一次，之后ViewStub对象会被置为空。按句话说，某个被ViewStub指定的布局被Inflate后，就不会够再通过ViewStub来控制它了。
     2. ViewStub只能用来Inflate一个布局文件，而不是某个具体的View，当然也可以把View写在某个布局文件中。
 基于以上的特点，那么可以考虑使用ViewStub的情况有：
     1. 在程序的运行期间，某个布局在Inflate后，就不会有变化，除非重新启动。
          因为ViewStub只能Inflate一次，之后会被置空，所以无法指望后面接着使用ViewStub来控制布局。所以当需要在运行时不止一次的显示和隐藏某个布局，那么ViewStub是做不到的。这时就只能使用View的可见性来控制了。
     2. 想要控制显示与隐藏的是一个布局文件，而非某个View。
          因为设置给ViewStub的只能是某个布局文件的Id，所以无法让它来控制某个View。
 所以，如果想要控制某个View(如Button或TextView)的显示与隐藏，或者想要在运行时不断的显示与隐藏某个布局或View，只能使用View的可见性来控制。

下面来看一个实例 在这个例子中，要显示二种不同的布局，一个是用TextView显示一段文字，另一个则是用ImageView显示一个图片。这二个是在onCreate()时决定是显示哪一个，这里就是应用ViewStub的最佳地点。 先来看看布局，一个是主布局，里面只定义二个ViewStub，一个用来控制TextView一个用来控制ImageView，另外就是一个是为显示文字的做的TextView布局，一个是为ImageView而做的布局：

<?xml version="1.0" encoding="utf-8"?>  
<LinearLayout  
  xmlns:android="http://schemas.android.com/apk/res/android"  
  android:orientation="vertical"  
  android:layout_width="fill_parent"  
  android:layout_height="fill_parent"  
  android:gravity="center_horizontal" >   
  <ViewStub   
    android:id="@+id/viewstub_demo_text"  
    android:layout_width="wrap_content"  
    android:layout_height="wrap_content"  
    android:layout_marginLeft="5dip"  
    android:layout_marginRight="5dip"  
    android:layout_marginTop="10dip"  
    android:layout="@layout/viewstub_demo_text_layout"/>  
  <ViewStub   
    android:id="@+id/viewstub_demo_image"  
    android:layout_width="wrap_content"  
    android:layout_height="wrap_content"  
    android:layout_marginLeft="5dip"  
    android:layout_marginRight="5dip"  
    android:layout="@layout/viewstub_demo_image_layout"/>  
</LinearLayout >

为TextView的布局：

<?xml version="1.0" encoding="utf-8"?>  
<LinearLayout  
  xmlns:android="http://schemas.android.com/apk/res/android"  
  android:orientation="vertical"  
  android:layout_width="wrap_content"  
  android:layout_height="wrap_content" >   
    <TextView  
        android:id="@+id/viewstub_demo_textview"  
        android:layout_width="fill_parent"  
        android:layout_height="wrap_content"  
        android:background="#aa664411"  
        android:textSize="16sp"/>  
</LinearLayout >

为ImageView的布局：

<?xml version="1.0" encoding="utf-8"?>  
<LinearLayout  
  xmlns:android="http://schemas.android.com/apk/res/android"  
  android:orientation="vertical"  
  android:layout_width="wrap_content"  
  android:layout_height="wrap_content" >   
    <ImageView  
        android:id="@+id/viewstub_demo_imageview"  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"/>  
</LinearLayout >

下面来看代码，决定来显示哪一个，只需要找到相应的ViewStub然后调用其infalte()就可以获得相应想要的布局：

package com.effective;  
import android.app.Activity;  
import android.os.Bundle;  
import android.view.ViewStub;  
import android.widget.ImageView;  
import android.widget.TextView;  
public class ViewStubDemoActivity extends Activity {  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.viewstub_demo_activity);  
        if ((((int) (Math.random() * 100)) & 0x01) == 0) {  
            // to show text  
            // all you have to do is inflate the ViewStub for textview  
            ViewStub stub = (ViewStub) findViewById(R.id.viewstub_demo_text);  
            stub.inflate();  
            TextView text = (TextView) findViewById(R.id.viewstub_demo_textview);  
            text.setText("The tree of liberty must be refreshed from time to time" +  
                    " with the blood of patroits and tyrants! Freedom is nothing but " +  
                    "a chance to be better!");  
        } else {  
            // to show image  
            // all you have to do is inflate the ViewStub for imageview  
            ViewStub stub = (ViewStub) findViewById(R.id.viewstub_demo_image);  
            stub.inflate();  
            ImageView image = (ImageView) findViewById(R.id.viewstub_demo_imageview);  
            image.setImageResource(R.drawable.happy_running_dog);  
        }  
    }  
}

运行结果：

使用的时候的注意事项：

1. 某些布局属性要加在ViewStub而不是实际的布局上面，才会起作用，比如上面用的android:layout_margin*系列属性，如果加在TextView上面，则不会起作用，需要放在它的ViewStub上面才会起作用。而ViewStub的属性在inflate()后会都传给相应的布局。 41.android开发中怎么去调试bug

逻辑错误 1.断点 debug

1. logcat , 界面布局,显示 hierarchyviewer.bat42.书写出android工程的目录结构以及相关作用

下面是HelloAndroid项目在eclipse中的目录层次结构：

由上图可以看出项目的根目录下共有九个文件（夹），下面就这九个文件（夹）进行详解： 1.1src文件夹和assets文件夹： 每个Android程序都包含资源目录（src）和资产目录（assets），资源和资产听起来感觉没有多大差别，但在存储外部内容时用资源（src）比较多，其中它们的区别在于存放在资源（src）下的内容可以通过应用程序的R类进行访问，而存放在资产（assets）下的内容会保持原始文件的格式，如果需要访问，则必须使用AssetManager以字节流的方式来读取，用起来非常的不方便。为了方便使用，通常文件和数据都会保存在资源（src）目录下 1.2res(Resource)目录：资源目录 可以存放一些图标，界面文件和应用中用到的文字信息，下图为res目录截图: 1.2.1 drawable-*dpi文件夹:将图标按分辨率的高低放入不同的目录，其中draeable-hdpi用来存放高分辨率的图标，drawable-mdpi用来存放中等分辨率的图标，drawable-ldpi用来存放低分辨率的图标 1.2.2 values文件夹：用来存放文字的信息 （1）strings.xml:用来定义字符串和数值 <?xml version=”1.0”encoding=”utf-8”?>

<string name="hello">Hello World, Hello 3G</string>
<string name="app_name">Android1.1</string>
    <string name="test">哥想你了</string>
    <string name="startButton">按钮1</string>
    <string name="start">按钮1</string> 

<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/test"/>

/*AUTO-GENERATED FILE.  DO NOT MODIFY.
 *
 * This class was automatically generated bythe
 * aapt tool from the resource data itfound.  It
 * should not be modified by hand.
 */
packagecn.csdn.android.demo;
public final class R {
    public static final class attr {
    }
    public static final class drawable {
        public static final int ic_launcher=0x7f020000;
    }
    public static final class id {
        public static final int button1=0x7f050000;
        public static final int radioButton1=0x7f050001;
        public static final int toggleButton1=0x7f050002;
    }
    public static final class layout {
        public static final int main=0x7f030000;
    }
    public static final class string {
        public static final int app_name=0x7f040001;
        public static final int hello=0x7f040000;
        public static final int start=0x7f040004;
        public static final int startButton=0x7f040003;
        public static final int test=0x7f040002;
    }
}