binder理解

Binder理解

 

例子代码：

/** {@hide} */
public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
    /**
     * Cast a Binder object into an activity manager interface, generating
     * a proxy if needed.
     */
    static public IActivityManager asInterface(IBinder obj)
    {
        if (obj == null) {
            return null;
        }
        IActivityManager in =
            (IActivityManager)obj.queryLocalInterface(descriptor);
        if (in != null) {
            return in;
        }
       
        return new ActivityManagerProxy(obj);
    }
   
    /**
     * Retrieve the system's default/global activity manager.
     */
    static public IActivityManager getDefault()
    {
        if (gDefault != null) {
            //if (Config.LOGV) Log.v(
            //    "ActivityManager", "returning cur default = " + gDefault);
            return gDefault;
        }
        IBinder b = ServiceManager.getService("activity");
        if (Config.LOGV) Log.v(
            "ActivityManager", "default service binder = " + b);
        gDefault = asInterface(b);
        if (Config.LOGV) Log.v(
            "ActivityManager", "default service = " + gDefault);
        return gDefault;
    }

 

 

如上代码：

通过asInterface(b)可以把b转成IActivityManager 实现ActivityManagerService的一个代理

IActivityManager的实现是ActivityManagerService

class ActivityManagerProxy implements IActivityManager作为ActivityManagerService的一个代理。也实现了IActivityManager接口，应该和ActivityMangerService一样，但同时拥有activityManagerService的应用。

public ActivityManagerProxy(IBinder remote)

    {

        mRemote = remote;

    }

   

    public IBinder asBinder()

    {

        return mRemote;

    }

   调用这个服务实现mRemote做事

启动activity：

   Aactivity启动Bactivity的过程描述

 代码如下：

            Intent intent =new  Intent(Aactivity.this, Bactivity.class);

            startActivity(intent);

接下来分析：

1.Acticity.startActivityForResult()      @Aactivity

2.Instrumention.execStartActivity();  @ Insrumention

此类是一个监控类，主要用于监控Activity的生命周期 的执行，比如，什么时候调用了onCreate，什么时候调用了onPause()方法等。

3.ActivityManagerNative.getDefault() .startActivity()
   3.1 ActivityManagerNative.getDefault()返回的是ActivityManagerProxy的实例，
        它只是一个代理类，这个代理类实际上代理的是IBinder b = ServiceManager.getService("activity");
        这个Service。
  3.2 这个Service是什么时候添加进来的呢？
        在SystemServer.java的run()中有调用
        ActivityManagerService.setSystemProcess();
        ServiceManager.addService("activity", m);
        这里还会添加许多系统关键服务。
      （TODO：查看在SystemServer的Log输出）

  3.3 由于ActivityManagerService是一个系统类，因此访问他要经过一个代理，不能直接访问，而且用代理类访问他，我们可以在访问他以前做一些其它操作，因此ActivityManagerNative.getDefault()，看代码是返回的一个 ActivityManagerProxy类的实例，这个类就是ActivityManagerService的代理类，也就是通过这个类来访问AMS, 代码如下

     static public IActivityManager getDefault() {

          if(gDefault!=null) {

              return gDefault

          }

          IBinder b=ServiceManager.getService("activity"); // 从ServiceManager进程中获得AMS实例

          gDefault=asInterface(b); // 把获得的AMS实例要通过adInterface接口赋给其代理类

         return gDefault

      }

   再看asInterface() 方法，如下

 

    static public IActivityManager asInterface(IBinder obj) {

       if(obj==null) {

           return null;

       }

       IActivityManager in=(IActivityManager)obj.queryLocalInterface(descriptor);

       if(in!=null) {

          return in;

       }

       return new ActivityManagerproxy(obj);  // 这句就是把AMS的实例当作参数传给了ActivityManagerProxy类

                                                               //  因此我们想操作AMS就要通过此代理类来操作，不能直接调用

    }

   因此，ActivityManagerNative.getDefault() .startActivity() 这句代码，实际执行的是

   ActivityManagerProxy类中的startActivity() 方法

 4：我们再分析ActivityManagerProxy类

      ActivityManagerProxy是ActivityManagerNative类的一个内部类，其定义如下：

       class ActivityManagerProxy implements IActivityManager {

            private IBinder mRemote;

            // 构造函数

            public  ActivityManagerProxy(IBinder remote) {

                 mRemote=remote; // 此处就是asInterface方法中定义时把AMS实例传过来的，也就是说

                                             // 此处的mRemote就是ActivityManagerService实例

             }

       }

再分析ActivityManagerProxy中的startActivity方法，定义如下：

public int startActivity(IApplicationThread caller, 

                                Intent intent ,

                                String resolvedType,

                                Uri[] grantedUriPermissions,

                                int grantedMode,

                                IBinder resultTo,

                                String resultWho

                                 int requestCode,

                                boolean onlyIfNeeded,

                                boolean debug)  {

        Parcel data=Parcel.obtain();  //把客户端传递的数据封装一下，然后跨进程传递

        Parcel reply =Parcel.obtain();

        data.writeInterfaceToken(IActivityManage.descriptor); // 保存数据

        ....

        ....

        mRote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);

         // 此句代码很重要，它会把以上所有数据，跨进程传递给ActivityManagerService类中onTrasact方法处理。

       

}

5: 分析ActivityManagerService类

      第一个方法是onTrasact() ,来接受客户端传递数据，方法定义如下：

      public boolean onTransact(int code , Parcel data , Parcel reply, int flags) {

          super.onTransact(code ,data  , reply , flags);  // 调用父类ActivityManagerNative中的onTrasact()方法

       }

    onTrasact() 方法主要是接受trasact()方法封装的参数，也就是trasact()函数相当于封包，onTrasact()相当于拆包

    把解析出来的参数，传给ActivityManagerService中的 startActivity()

     ------startActivity()               @ActivityManagerService

     ------startActivityMayWait()   @ActivityManagerService

     ------startActivityLocked()     @ActivityManagerService

     ------startActivityUncheckedLocked() @ActivityManagerService 此方法检查权限，解析Intent中的flag语句

    -------startActivityLocked()   @ActivityManagerService// 与上个方法参数不一样，

   --------resumeTopActivityLocked() @ActivityManagerService

   --------startSpecificActivityLocked  @ActivityManagerService  // 此方法内容会分两部分执行，首先判断activity的进程是否启动，如果已经启动则执行第1种方案，如果没有启动，则启动第2种方案，

   方案1：

    --------startProcessLocked ()        @ActivityManagerService

  方案2:

   --------realStartActivityLocked() @ActivityManagerService // 此方法是进入真正启动一个Activity流程

   --------scheduleLaunchActivity () @ActivityThread  @ApplicationThread  // 此方法进入到

                 ApplicationThreadNative提供的服务，也就是到ActivityThread的内部类ApplicationThread类中，

                 这里相当于进入客户端处理了，(到此服务端的Activity实例初始化完毕)。

            scheduleLaunchActivity方法定义如下:

           scheduleLaunchActivity (Intent intent, IBinder token, int ident......) {

              ActivityRecord r = new ActivityRecord() ; // 为此Activity定义一个客户端实例

              ....

             queueOrSendMessage(H.LAUNCH_ACTIVITY, r); // 把启动Activity的消息传给一个内部类(H)来处理

              // H类是一个Handler，

         }

   --------------handleLaunchActivity   @ ActivityThread

   --------------performLaunchActivity  @ActivityThread   // 此方法开始具体创建Activity，并调用其生命周期

   此方法定义如下 :

         private final Activity performLauchActivity(ActivityRecord r, Intent customIntent)  {

         .....

        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);

                                                                       //   通过反射构造出Activity对象

        activity.attach();// 调用Activity的attach() 方法, 此方法比较重要，主要创建Activity中的Window及

                               // WindowManager  ， 等会儿具体分析

       

         以下会逐渐调用Activity中生命周期的方法

        mInstrumentation.callActivityOnCreate(activity, r.state); // 调用Activity中的onCreate方法

       activity.performStart() ;  // 调用

       mInstrumentation.callActivityOnRestoreInstanceState(activity,r.state);

       mInstrumentation.callActivityOnPostCreate(activity,r.state);

       mActivitys.put(r.token,r);  // 压入栈

       }

--------------handleResumeActivity:  开始调用onResume() 方法，

--------------performResumeActivity(); // 调用onResume()方法

        performResumeActivity () {

           ....

           r.activity.performResume();  // 调用Activity中的onResume方法

           .....

       }

到此为止，整个Activity已经创建，启动了，但是他还什么都没有显示，因为没有显示在屏幕上，

 handleResumeActivity() {

    --r.window.getDecorView();                                   //开始把DecorView添加进Window
    --wm.addView(decor, l);

 }

屏幕上的内容，会显示出来，  至于窗口是怎么创建出来的，那要分析Activity中的Attach()方法了，以后再分析！

6:Activity与Window，View的关系分析，

        

   在Android系统中，一个界面可以由两部分组成，

   一：逻辑控制部分：Activity部分

  二：界面显示部分：Window+View 部分，其中主要是View部分

 Activity主要是