查看Android中启动一个Activity过程的源代码 Android中启动一个Activity过程 0

Android中启动一个Activity过程

启动activity：

::Aactivity启动Bactivity的过程描述

:代码如下：

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

接下来分析：

<font color="red" size="+2">1.Acticity.startActivityForResult()      @Aactivity </font>


<font color="red" size="+2">2.Instrumention.execStartActivity();  @ Insrumention </font>

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


<font color="red" size="+2">3.ActivityManagerNative.getDefault() .startActivity()</font>
: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() 方法


<font color="red" size="+2">4：我们再分析ActivityManagerProxy类</font>

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

<source lang="java">
       class ActivityManagerProxy implements IActivityManager {

            private IBinder mRemote;

            // 构造函数

            public  ActivityManagerProxy(IBinder remote) {

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

                                             // 此处的mRemote就是ActivityManagerService实例

             }

       }
</source>
再分析ActivityManagerProxy中的startActivity方法，定义如下：

<source lang="java">
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方法处理。

        

}

</source>

<font color="red" size="+2">5: 分析ActivityManagerService类</font>

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

<source lang="java">
      public boolean onTransact(int code , Parcel data , Parcel reply, int flags) {

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

       }
</source>

: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()方法了，以后再分析！


<font color="red" size="+2">6:Activity与Window，View的关系分析，</font>

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

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

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

::Activity主要是一个界面的逻辑控制部分，生命周期的管理等，具体的显示则交给View来显示，
::在Activity类中有一个Window对象和一个WindowManager对象，用来管理View的显示，定义如下：

      private Window window;
     private WindowManager mWindowManager;


:在1-5个分析中，我们把界面的逻辑部分(Activity部分)分析了一下，现在开始分析界面的显示部分(View部分)，

:那么这两个对象在什么时候初始化呢？ 答案是在Activity刚被创建出来的时候，也就是在Activity中的attach()方法中初始化， 具体代码如下：


 final void attach(Context context，ActivityThread aThread，.....) {
 
      ...
 
     mWindow=PolicyManager.makeNewWindow(this);  // 创建Window对象
 
     ...
 
     mWindow.setWindowManager(null，mToken，mComponent.flattenToString());  // 创建WindowManager对象
 
     ....
 
    mWindowManager=mWindow.getWindowManager();
 
 }

:让我们跟踪mWindow对象的创建过程，进入PolicyManager类中，我们发现makeNewWindow()方法返回一个PhoneWindow对象，此类实现了Window抽象类，

:再看一下WindowManager对象的创建，mWindow.setWindowManager()方法，毫无疑问，mWindow就是PhoneWindow， setWindowManager() 实际是由Window这个类来实现的，进入Window类中的此方法，看到如下代码：


 public void setWindowManager(wm，appToken，appName) {
 
        if(wm==null)  {
 
             wm=WindowManagerImpl.getDefault();
 
        }
 
      mWindowManager=new LocalWindowManager(wm);
 
  } 


由此可以看出 LocalWindowManager是一个代理类，它代理的是WindowManagerImpl类，也就是说，真正实现功能的是

WindowManagerImpl类，

到此为止，界面的Window部分已初始化完毕，下面进入界面显示部分的主角-----View部分：
      
**system_process进程 

4 ActivityManagerNative
    |--ActivityManagerService
    
    在ActivityManagerNative的onTransact方法中最终提供了服务：
    case START_ACTIVITY_TRANSACTION：
      ActivityManagerService.startActivity（）;
        --startActivityLocked(IApplicationThread caller,
            Intent intent, String resolvedType,
            Uri[] grantedUriPermissions,
            int grantedMode, ActivityInfo aInfo, IBinder resultTo,
            String resultWho, int requestCode,
            int callingPid, int callingUid, boolean onlyIfNeeded,
            boolean componentSpecified) 



          --startActivityUncheckedLocked(r, sourceRecord,grantedUriPermissions, grantedMode, onlyIfNeeded,true)
          在这个方法里面检查权限，解析intent中的Flag。。。
          --startActivityLocked(HistoryRecord r, boolean newTask)
            --resumeTopActivityLocked(HistoryRecord prev)
              --startSpecificActivityLocked(HistoryRecord r,boolean andResume, boolean checkConfig) 
                --startProcessLocked(String processName,ApplicationInfo info, boolean knownToBeDead, int intentFlags,String hostingType, ComponentName hostingName)
                  --startProcessLocked(ProcessRecord app,String hostingType, String hostingNameStr)
                    在这里启动一个进程用来host这个应用
                    int pid = Process.start("android.app.ActivityThread",
                    mSimpleProcessManagement ? app.processName : null, uid, uid,
                    gids, debugFlags, null);
                    
ActivityManagerService.java
--startSpecificActivityLocked(HistoryRecord r,boolean andResume, boolean checkConfig)
  --realStartActivityLocked(HistoryRecord r,ProcessRecord app, boolean andResume, boolean checkConfig)
    --app.thread.scheduleLaunchActivity            //scheduleLaunchActivity()@IApplicationThread.java
      --scheduleLaunchActivity()@ActivityThread.java         //这里实际是ApplicationThreadNative提供的服务
        --handleMessage()@H$ActivityThread.java
          --handleLaunchActivity()@ActivityThread.java
            --Activity performLaunchActivity(ActivityRecord r, Intent customIntent)@ActivityThread.java  

                 //这时真正的Activity对象被构造出来
              --mInstrumentation.newActivity（）              //通过反射构造出Activity对象
              --activity.attach（）                      //初始化Activity，生成一个window对象，设置各种状态等等
              --mInstrumentation.callActivityOnCreate(activity, r.state);  //调用Activity的onCreate()方法
            
              到这里，我们自己写的activity的onCreate()方法已经被系统调用了，接下来依次回调生命周期方法：
              --activity.performStart();
                --mInstrumentation.callActivityOnStart(this);
              --mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
              --mInstrumentation.callActivityOnPostCreate(activity, r.state);
              --mActivities.put(r.token, r);               //将这个activity入栈
              
            然后就要调用onResume()方法了：
            --handleResumeActivity(IBinder token, boolean clearHide, boolean isForward)
              --performResumeActivity(token, clearHide);
                --r.activity.performResume();
                  --performRestart()@Activity.java;
                    --mInstrumentation.callActivityOnRestart(this);
                    --mInstrumentation.callActivityOnStart(this);
                --mInstrumentation.callActivityOnResume(this);
                onResume()已经调用完毕，一个activity的逻辑处理结束了，

            但是这时候屏幕上还不会显示任何东西，因为View还没有添加进去
                
                
              --r.window.getDecorView();             //开始把DecorView添加进Window
              --wm.addView(decor, l);
            
            至此一个Activity启动结束。


原文
----
http://blog.csdn.net/jyfllzy/archive/2011/03/12/6245124.aspx

[[category:Android开发]]
[[category:技术文章]]
[[category:显示]]