Activity启动过程详解

天高空 发布于 2012/03/20 14:13
阅读 3K+
收藏 4

 前面发了blog分析了ActivityManager框架的大体结构,主要就是一个进程通信机制,今天我通过深入Activity的启动过程再次深入到ActivityManager框架,对其进行一个更深入的了解

     以桌面启动一个应用Activity为例,onClick事件后,会调用startActivityForResult(Intent, int)

       

  public void startActivityForResult(Intent intent, int requestCode) {
        if (mParent == null) {
                        //Activity启动执行交由Instrumentation对象去处理
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode);


              
//mMainThread attach 方法中被设置,当 ActivityThread PerformLauchActivity ,调用 attach ActivityThread.this 传送过来
               //mMainThread.getApplicationThread()
它是一个进程通信服务端存根对象,提供了很多操作 ActivityThread 的方法,它继承了 ApplicationThreadNative              
          
  if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }
        } else {
            mParent.startActivityFromChild(this, intent, requestCode);
        }
    }
Instrumentation.execStartActivity
    public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode) {
                                ......
        try {
        //ActivityManagerNative.getDefault()实际返回的是一个ActivityManagerProxy对象
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        null, 0, token, target != null ? target.mEmbeddedID : null,
                        requestCode, false, false);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
        }
        return null;
    }

     ActivityManagerProxy是实现IActivityManager接口的一个进程通信代理对象,在该方法ActivityManagerProxy.startActivity中,它只负责
准备相关的数据发送到system_process进程去处理startActivity

    

public int startActivity(IApplicationThread caller, Intent intent,
            String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
            IBinder resultTo, String resultWho,
            int requestCode, boolean onlyIfNeeded,
            boolean debug) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(caller != null ? caller.asBinder() : null);
        intent.writeToParcel(data, 0);
        data.writeString(resolvedType);
        data.writeTypedArray(grantedUriPermissions, 0);
        data.writeInt(grantedMode);
        data.writeStrongBinder(resultTo);
        data.writeString(resultWho);
        data.writeInt(requestCode);
        data.writeInt(onlyIfNeeded ? 1 : 0);
        data.writeInt(debug ? 1 : 0);
        //mRemote是一个BinderProxy对象,transact方法本地化实现
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }

     到此前面3步都是在Laucher2进程中执行,调用mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);后,系统转到
system_process
进程中执行,根据我前面讲的进程通信机制,入口函数是ActivityManagerNative.onTransact方法,在system_process进程中
ActivityManagerNative
被继承,实际执行的是ActivityManagerService.onTransact方法,调用堆栈如下:

ActivityManagerService(ActivityManagerNative).onTransact(int, Parcel, Parcel, int) line: 129       
ActivityManagerService.onTransact(int, Parcel, Parcel, int) line: 1481       
ActivityManagerService(Binder).execTransact(int, int, int, int) line: 288       
NativeStart.run() line: not available [native method]

     ActivityManagerService(ActivityManagerNative).onTransact中根据前面的参数START_ACTIVITY_TRANSACTION,执行对应的case代码:

    

    case START_ACTIVITY_TRANSACTION:
        {
            data.enforceInterface(IActivityManager.descriptor);
            IBinder b = data.readStrongBinder();
            IApplicationThread app = ApplicationThreadNative.asInterface(b);
            Intent intent = Intent.CREATOR.createFromParcel(data);
            String resolvedType = data.readString();
            Uri[] grantedUriPermissions = data.createTypedArray(Uri.CREATOR);
            int grantedMode = data.readInt();
            IBinder resultTo = data.readStrongBinder();
            String resultWho = data.readString();   
            int requestCode = data.readInt();
            boolean onlyIfNeeded = data.readInt() != 0;
            boolean debug = data.readInt() != 0;
            //执行对应Stub的IActivityManager接口方法
            int result = startActivity(app, intent, resolvedType,
                    grantedUriPermissions, grantedMode, resultTo, resultWho,
                    requestCode, onlyIfNeeded, debug);
            reply.writeNoException();
            reply.writeInt(result);
            return true;
        }

startActivity方法实际是执行的ActivityManagerService中的startActivity,接下来的执行很复杂,要想搞清楚这些细节还需要一些时间,我我们跳过这些,继续沿着主干道前行:

ActivityManagerService.startProcessLocked(ProcessRecord, String, String) line: 2043       
ActivityManagerService.startProcessLocked(String, ApplicationInfo, boolean, int, String, ComponentName, boolean) line: 1982       
ActivityManagerService.startSpecificActivityLocked(HistoryRecord, boolean, boolean) line: 1908       
ActivityManagerService.resumeTopActivityLocked(HistoryRecord) line: 2855       
ActivityManagerService.completePauseLocked() line: 2237       
ActivityManagerService.activityPaused(IBinder, Bundle, boolean) line: 5963       
ActivityManagerService.activityPaused(IBinder, Bundle) line: 5941       
ActivityManagerService(ActivityManagerNative).onTransact(int, Parcel, Parcel, int) line: 387       
ActivityManagerService.onTransact(int, Parcel, Parcel, int) line: 1481       
ActivityManagerService(Binder).execTransact(int, int, int, int) line: 288       
SystemServer.init1(String[]) line: not available [native method]       
SystemServer.main(String[]) line: 582       
Method.invokeNative(Object, Object[], Class, Class[], Class, int, boolean) line: not available [native method]       
Method.invoke(Object, Object...) line: 521       
ZygoteInit$MethodAndArgsCaller.run() line: 868       
ZygoteInit.main(String[]) line: 626       
NativeStart.main(String[]) line: not available [native method]

在用例进程onPause后,通过ActivityManagerProxy.activityPaused执行相关操作,这也是一个用例进程到system_process进程的远程调用,原来的用例进程需要进栈,并启动一个新的Activity在屏幕最前端,我们只关注新Activity的启动,首先关注新Activity应用进程的创建,看上面的调用堆栈,在函数startProcessLocked

//app记录的是一个要启动ActivityThread进程的信息,

hostingType=activity,hostingNameStr="com.iaiai.activity/.IaiaiActivity"
    private final void startProcessLocked(ProcessRecord app,
            String hostingType, String hostingNameStr) {
            ......
            //Process.start

    private final void startProcessLocked(ProcessRecord app,
            String hostingType, String hostingNameStr) {
            ......
            //Process.start
是一个静态方法,它将启动一个新的进程,新进程的的入口 main 方法为 android.app.ActivityThread.main
            int pid = Process.start("android.app.ActivityThread",
                    mSimpleProcessManagement ? app.processName : null, uid, uid,
                    gids, debugFlags, null);  
            ......


 

     现在,我们终于看到了一个新的应用进程的创建,别急,在启动主Activity我们还有很多工作要做,我我们可以想象到得,一个新的应用肯定要建立闭环的消息循环,然后它要把的一个ApplicationThreadProxy代理对象传递给system_process进程,这样system_process进程就可以通过ApplicationThreadProxy代理对象来控制我们的应用进程了,比如它把广播消息转给应用进程,关闭应用进程等

    先看新进程的main函数:

  

  public static final void main(String[] args) {
     SamplingProfilerIntegration.start();

        Process.setArgV0("<pre-initialized>");
        //建立looper消息循环队列
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        //开始主线程消息循环
        Looper.loop();

        if (Process.supportsProcesses()) {
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }

        thread.detach();
        String name = (thread.mInitialApplication != null)
            ? thread.mInitialApplication.getPackageName()
            : "<unknown>";
        Slog.i(TAG, "Main thread of " + name + " is now exiting");
    }

      main函数中建立了闭环的消息循环,这个是一般ui程序做法,很容易理解,但是后续应用的启动工作是如何进程的,关注我上面标注的红色代码,这里创建了一个ActivityThread对象,ActivityThread构造时初始化了该应用进程的一些基本成员,最重要的我们关注

    final Looper mLooper = Looper.myLooper();
    final H mH = new H();//
消息处理handler
在这里,我们建立了消息处理器,它将负责处理main线程中Looper消息循环中的消息。

     还用一个成员对象值得我们关注,那就是ApplicationThread对象,在ActivityThread对象被创建时,它也被构造了,我前面已经提到过了,它继承了ApplicationThreadNative类,熟悉进程通信代理机制的朋友就清楚了,ApplicationThread就是一个通信代理存根实现类,我们可以看它的实现方法,都是调用queueOrSendMessage方法,派发消息交给ActivityThreadmH去处理,那么我们很清楚了,ActivityThread代理存根对象,它负责执行来自远程的调用,这些远程的调用大部分来自system_process,所以,system_process很容易通过ApplicationThread的客户端代理对象控制ActivityThread,事实就是如此,后面我们可以很好地看到这一点,

     继续看thread.attach(false)函数,参数标识是否系统进程,系统进程的入口函数是systemMain,而不是main方法,

   private final void attach(boolean system) {//system==false
        sThreadLocal.set(this);//ActivityThread
对象关联到主线程
        mSystemThread = system;
        if (!system) {//
是非系统进程
            ...
            IActivityManager mgr = ActivityManagerNative.getDefault();
            try {
              //
ApplicationThread mAppThread attach到系统进程system_process,以便system_process控制当前应用的ActivityThread
               
mgr.attachApplication(mAppThread);
            } catch (RemoteException ex) {
            }
        } else {
            //
系统进程要作的处理
            ...
        }
        //
接收来自ViewRootConfigurationChanged消息,派发给mH处理(H.CONFIGURATION_CHANGED),
        //
一旦配置发生变更,mH将执行H.CONFIGURATION_CHANGED
        ViewRoot.addConfigCallback(new ComponentCallbacks() {
            public void onConfigurationChanged(Configuration newConfig) {
                synchronized (mPackages) {
                    // We need to apply this change to the resources
                    // immediately, because upon returning the view
                    // hierarchy will be informed about it.
                    if (applyConfigurationToResourcesLocked(newConfig)) {
                        // This actually changed the resources!  Tell
                        // everyone about it.
                        if (mPendingConfiguration == null ||
                                mPendingConfiguration.isOtherSeqNewer(newConfig)) {
                            mPendingConfiguration = newConfig;
                           
                            queueOrSendMessage(H.CONFIGURATION_CHANGED, newConfig);
                        }
                    }
                }
            }
            public void onLowMemory() {
            }
        });
    }
    
再来看一下attach方法的调用堆栈:

ActivityManagerProxy.attachApplication(IApplicationThread) line: 1542       
ActivityThread.attach(boolean) line: 4555       
ActivityThread.main(String[]) line: 4632       
Method.invokeNative(Object, Object[], Class, Class[], Class, int, boolean) line: not available [native method]       
Method.invoke(Object, Object...) line: 521       
ZygoteInit$MethodAndArgsCaller.run() line: 868       
ZygoteInit.main(String[]) line: 626       
NativeStart.main(String[]) line: not available [native method]

这里你又会看到一个熟悉的身影,ActivityManagerProxy,是的,这里又使用了进程通信,通知ActivityManagerService执行attachApplication
看一下ActivityManagerProxy.attachApplication方法的代码:

    public void attachApplication(IApplicationThread app) throws RemoteException
    {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
       
//参数IApplicationThread app通过进程通信传送到system_process进程,而app是一个ApplicationThread对象,不要被它的名称所迷惑
        //
这里它只是一个对象,它继承了ApplicationThreadNative,而ApplicationThreadNative是实现IApplicationThread接口的一个进程通信接口存根类,当它到达system_processsystem_process得到的是它的一个代理类ActivityManagerProxy
        data.writeStrongBinder(app.asBinder());
        mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
        reply.readException();
        data.recycle();
        reply.recycle();
    }
     
再次回到了system_process进程,先看一下system接收到来自新的Activity的远程调用堆栈:

ActivityManagerService.attachApplicationLocked(IApplicationThread, int) line: 5591       
ActivityManagerService.attachApplication(IApplicationThread) line: 5677       
ActivityManagerService(ActivityManagerNative).onTransact(int, Parcel, Parcel, int) line: 363       
ActivityManagerService.onTransact(int, Parcel, Parcel, int) line: 1481       
ActivityManagerService(Binder).execTransact(int, int, int, int) line: 288       
NativeStart.run() line: not available [native method]    

我们看attachApplicationLocked的实现,由于函数比较长,而且我也没有深入仔细看,所以我只列出我理解的关键部分代码

    //thread来用户进程的ApplicationThread代理对象,pid是用户进程的pid
    private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid) {
    ......
    ProcessRecord app;
        if (pid != MY_PID && pid >= 0) {
            synchronized (mPidsSelfLocked) {
            //
当用户进程创建时有一个标识用户进程的pid,它关联了ProcessRecord记录,现在根据pid或者该记录
                app = mPidsSelfLocked.get(pid);
            }
        } else if (mStartingProcesses.size() > 0) {
            app = mStartingProcesses.remove(0);
            app.setPid(pid);
        } else {
            app = null;
        }
        ......
        //
设置app相关参数
        app.thread = thread;//
设置appthread为用户进程代理对象ActivityManagerProxy
        app.curAdj = app.setAdj = -100;
        app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
        app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
        app.forcingToForeground = null;
        app.foregroundServices = false;
        app.debugging = false;

    ......
           
thread.bindApplication(processName, app.instrumentationInfo != null
                    ? app.instrumentationInfo : app.info, providers,
                    app.instrumentationClass, app.instrumentationProfileFile,
                    app.instrumentationArguments, app.instrumentationWatcher, testMode,
                    isRestrictedBackupMode || !normalMode,
                    mConfiguration, getCommonServicesLocked());
            updateLruProcessLocked(app, false, true);
            app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();
       ......
               HistoryRecord hr = topRunningActivityLocked(null);
        if (hr != null && normalMode) {
            if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid
                    && processName.equals(hr.processName)) {
                try {
                   
//realStartActivityLocked会调用thread.scheduleLaunchActivity
                    if (realStartActivityLocked(hr, app, true, true))
{
                        didSomething = true;
                    }
}

这里通过远程调用后thread并不是一个ApplicationThread对象,而是其一个远程代理对象ApplicationThreadProxy,通过thread,可以操作ApplicationThread对象调用bindApplicationscheduleLaunchActivity:

先看bindApplication

ActivityThread$ApplicationThread.bindApplication(String, ApplicationInfo, List, ComponentName, String, Bundle, IInstrumentationWatcher, int, boolean, Configuration, Map) line: 1655       
ActivityThread$ApplicationThread(ApplicationThreadNative).onTransact(int, Parcel, Parcel, int) line: 251       
ActivityThread$ApplicationThread(Binder).execTransact(int, int, int, int) line: 288       
NativeStart.run() line: not available [native method]

        public final void bindApplication(String processName,
                ApplicationInfo appInfo, List<ProviderInfo> providers,
                ComponentName instrumentationName, String profileFile,
                Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher,
                int debugMode, boolean isRestrictedBackupMode, Configuration config,
                Map<String, IBinder> services) {
            //
获取来自system_process远程调用传递过来的相关参数
            if (services != null) {
                // Setup the service cache in the ServiceManager
                ServiceManager.initServiceCache(services);
            }

            AppBindData data = new AppBindData();
            data.processName = processName;
            data.appInfo = appInfo;
            data.providers = providers;
            data.instrumentationName = instrumentationName;
            data.profileFile = profileFile;
            data.instrumentationArgs = instrumentationArgs;
            data.instrumentationWatcher = instrumentationWatcher;
            data.debugMode = debugMode;
            data.restrictedBackupMode = isRestrictedBackupMode;
            data.config = config;
            //
派发给ActivityThread.mH去处理执行H.BIND_APPLICATION
            queueOrSendMessage(H.BIND_APPLICATION, data);
        }

我们看mH是如何处理的,mH接收到H.BIND_APPLICATION消息执行的对应是handleBindApplication函数,handleBindApplication函数中做了大量初始化ActivityThread的操作:

  初始化mConfiguration

  设置进程名

  本地语言设置

  设置包名称

  设置应用程序根路径

  设置应用程序data路径

  设置activitycontext

等等,我没有详细看,有不正之处希望高手指正,小弟不胜感激

     接着是第二步,scheduleLaunchActivity,先看调用堆栈:
ActivityThread$ApplicationThread.scheduleLaunchActivity(Intent, IBinder, int, ActivityInfo, Bundle, List, List, boolean, boolean) line: 1526       
ActivityThread$ApplicationThread(ApplicationThreadNative).onTransact(int, Parcel, Parcel, int) line: 130       
ActivityThread$ApplicationThread(Binder).execTransact(int, int, int, int) line: 288       
NativeStart.run() line: not available [native method]

同样,该函数操作也是交给ActivityThread.mH来处理,对应case消息为:H.LAUNCH_ACTIVITY

交由函数handleLaunchActivity处理,在这个函数中,根据ActivityRecord对像,获取要启动的Activity类信息,然后创建一个Activity,执行Activity的生命周期函数:onCreate,onResume,至此ActivitThreadhandleBindApplicationhandleLaunchActivity完成Activity的启动操作。

     最后,我再总结一下从桌面启动一个应用Activity的启动过程,画了一个时序图,有助于理解,希望走过路过的朋友别忘了留个脚印,或者留个砖板,这个blog花费了我不少时间:

转自:http://blog.sina.com.cn/s/blog_8984d3f301011peg.html

加载中
OSCHINA
登录后可查看更多优质内容
返回顶部
顶部