美文网首页Android开发经验谈Android技术知识Android开发
Android9.0应用程序启动过程源码分析

Android9.0应用程序启动过程源码分析

作者: Joker_Wan | 来源:发表于2019-07-04 14:26 被阅读0次

    用户从Launcher程序点击应用图标可启动应用的入口Activity,Activity启动时需要多个进程之间的交互,Android系统中有一个zygote进程专用于孵化Android框架层和应用层程序的进程。还有一个system_server进程,该进程里运行了很多binder service,例如ActivityManagerService,PackageManagerService,WindowManagerService,他们分别运行在不同的线程中,其中ActivityManagerService负责管理Activity栈,应用进程,task。

    用户在Launcher程序里点击应用图标时,会通知ActivityManagerService启动应用的入口Activity,ActivityManagerService则会通知Zygote进程孵化出应用进程,然后在这个应用进程里执行ActivityThread的main方法。应用进程接下来通知ActivityManagerService应用进程已启动,ActivityManagerService保存应用进程的一个代理对象,这样ActivityManagerService可以通过这个代理对象控制应用进程,然后ActivityManagerService通知应用进程创建入口Activity的实例,并执行它的生命周期方法。Android应用程序启动过程如下图:


    Android应用程序启动过程.png

    应用程序的启动过程其实就是入口Activity的启动过程,接下来我们主要分析用户点击手机桌面应用程序的图标到根Activity的onCreate()生命周期方法的执行。

    启动过程源码调用时序图

    LauncherStartAnalyse.png

    整个 startActivity 的流程分为 3 大部分,也涉及 3 个进程之间的交互:

    • Launcher --> ActivityManagerService
    • ActivityManagerService --> ApplicationThread
    • ApplicationThread --> Activity

    详细分析源代码的实现过程


    友情提示:为了方便阅读和排版,我所截取的只是framework层部分源码,保留了源码的大概框架,目前只关心Launcher点击到执行Activity的onCreate()生命周期这一条主线,其他代码用...省略


    Launcher --> ActivityManagerService

    1、Launcher->startActivitySafely->startActivity

    路径:packages/apps/Launcher2/src/com/android/launcher2/Laucher.java

    public final class Launcher extends Activity
            implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,
            View.OnTouchListener {
        
        /**
         * Launches the intent referred by the clicked shortcut.
         *
         * @param v The view representing the clicked shortcut.
         */
        public void onClick(View v) {
            // Make sure that rogue clicks don't get through while allapps is launching, or after the
            // view has detached (it's possible for this to happen if the view is removed mid touch).
            if (v.getWindowToken() == null) {
                return;
            }
    
            if (!mWorkspace.isFinishedSwitchingState()) {
                return;
            }
    
            Object tag = v.getTag();
            if (tag instanceof ShortcutInfo) {
                // Open shortcut
                final Intent intent = ((ShortcutInfo) tag).intent;
                int[] pos = new int[2];
                v.getLocationOnScreen(pos);
                intent.setSourceBounds(new Rect(pos[0], pos[1],
                        pos[0] + v.getWidth(), pos[1] + v.getHeight()));
    
                // ---------看这里---------
                boolean success = startActivitySafely(v, intent, tag);
                ...
            } else if (tag instanceof FolderInfo) {
                ...
            } else if (v == mAllAppsButton) {
                ...
            }
        }
    
        boolean startActivitySafely(View v, Intent intent, Object tag) {
            boolean success = false;
            try {
                // ---------看这里---------
                success = startActivity(v, intent, tag);
            } catch (ActivityNotFoundException e) {
                ...
            }
            return success;
        }
    
        boolean startActivity(View v, Intent intent, Object tag) {
            // ---------看这里---------
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    
            try {
                // Only launch using the new animation if the shortcut has not opted out (this is a
                // private contract between launcher and may be ignored in the future).
                boolean useLaunchAnimation = (v != null) &&
                        !intent.hasExtra(INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION);
                UserHandle user = (UserHandle) intent.getParcelableExtra(ApplicationInfo.EXTRA_PROFILE);
                LauncherApps launcherApps = (LauncherApps)
                        this.getSystemService(Context.LAUNCHER_APPS_SERVICE);
                if (useLaunchAnimation) {
                    ActivityOptions opts = ActivityOptions.makeScaleUpAnimation(v, 0, 0,
                            v.getMeasuredWidth(), v.getMeasuredHeight());
                    if (user == null || user.equals(android.os.Process.myUserHandle())) {
                        // Could be launching some bookkeeping activity
                        // ---------看这里---------
                        startActivity(intent, opts.toBundle());
                    } else {
                        ...
                    }
                } else {
                    ...
                }
                return true;
            } catch (SecurityException e) {
                ...
            }
            return false;
        }
    }
    

    最后一个startActivity()里面调用了
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    表示要在一个新的Task(任务栈)中启动这个Activity

    Android系统中的每一个Activity都位于一个Task中,一个Task可以包含多个Activity,同一个Activity也可能有多个实例。 在AndroidManifest.xml中,我们可以通过android:launchMode来控制Activity在Task中的实例。
    在startActivity的时候,我们也可以通过setFlag 来控制启动的Activity在Task中的实例。

    在Task之外,还有一层容器,这个容器应用开发者和用户可能都不会感觉到或者用到,但它却非常重要,那就是Stack,Android系统中的多窗口管理,就是建立在Stack的数据结构上的。 一个Stack中包含了多个Task,一个Task中包含了多个Activity(Window)。

    2、Activity->startActivity->startActivityForResult

    路径:/frameworks/base/core/java/android/app/Activity.java

    public class Activity extends ContextThemeWrapper
            implements LayoutInflater.Factory2,
            Window.Callback, KeyEvent.Callback,
            OnCreateContextMenuListener, ComponentCallbacks2,
            Window.OnWindowDismissedCallback, WindowControllerCallback,
            AutofillManager.AutofillClient {
    
        @Override
        public void startActivity(Intent intent, @Nullable Bundle options) {
            if (options != null) {
                startActivityForResult(intent, -1, options);
            } else {
                // Note we want to go through this call for compatibility with
                // applications that may have overridden the method.
                // ---------看这里---------
                startActivityForResult(intent, -1);
            }
        }
        
        public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
                                           @Nullable Bundle options) {
            if (mParent == null) {
                options = transferSpringboardActivityOptions(options);
                // ---------看这里---------
                Instrumentation.ActivityResult ar =
                        mInstrumentation.execStartActivity(
                                this, mMainThread.getApplicationThread(), mToken, this,
                                intent, requestCode, options);
                ...
            } else {
                ...
            }
        }
    }
    

    Launcher继承于Activity类,而Activity类实现了startActivity函数,因此,这里就调用了Activity->startActivity函数,接着调用Activity->startActivityForResult;

    mParent是Activity类型的,表示当前Activity的父类。因为目前根Activity还没有创建出来,因此,mParent == null 为true,

    这里的mInstrumentation是Activity类的成员变量,它的类型是Intrumentation,Intrumentation主要用来监控应用程序和系统的交互,后面会讲到。

    这里的mMainThread也是Activity类的成员变量,它的类型是ActivityThread,它代表的是应用程序的主线程。通过mMainThread.getApplicationThread获得它里面的ApplicationThread成员变量,它是一个Binder对象,ActivityManagerService会使用它来和ActivityThread来进行进程间通信。要注意的是,这里的mMainThread代表的是Launcher应用程序运行的进程。mToken也是一个Binder对象,指向了服务端一个ActivityRecord对象。

    3、Instrumentation->execStartActivity

    路径:/frameworks/base/core/java/android/app/Instrumentation.java

    用于实现应用程序测试代码的基类。当在打开仪器的情况下运行时,这个类将在任何应用程序代码之前为您实例化,允许您监视系统与应用程序的所有交互。

    public ActivityResult execStartActivity(
                Context who, IBinder contextThread, IBinder token, Activity target,
                Intent intent, int requestCode, Bundle options) {
            IApplicationThread whoThread = (IApplicationThread) contextThread;
            ...
            if (mActivityMonitors != null) {
                ...
            }
            try {
                intent.migrateExtraStreamToClipData();
                intent.prepareToLeaveProcess(who);
                // ---------看这里---------
                int result = ActivityManager.getService()
                    .startActivity(whoThread, who.getBasePackageName(), intent,
                            intent.resolveTypeIfNeeded(who.getContentResolver()),
                            token, target != null ? target.mEmbeddedID : null,
                            requestCode, 0, null, options);
                ...
            } catch (RemoteException e) {
                ...
            }
            return null;
        }
    

    路径:/frameworks/base/core/java/android/app/ActivityManager.java

    该类提供与Activity、Service和Process相关的信息以及交互方法, 可以被看作是ActivityManagerService的辅助类。

     public static IActivityManager getService() {
            return IActivityManagerSingleton.get();
        }
    
        private static final Singleton<IActivityManager> IActivityManagerSingleton =
                new Singleton<IActivityManager>() {
                    @Override
                    protected IActivityManager create() {
                        final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                        final IActivityManager am = IActivityManager.Stub.asInterface(b);
                        return am;
                    }
                };
    

    这里的ActivityManager.getService()采用单例,返回的是实现IBinder类型的AMS代理对象,最后将它转换成IActivityManager类型的对象,这段代码采用的是AIDL,IActivityManager.java类是由AIDL工具在编译时自动生成的,要实现进程间通信,服务器端也就是AMS只需要继承IActivityManager.Stub类并实现相应的方法。所以execStartActivity最终调用的是AMS的startActivity方法。至此,代码逻辑进入AMS

    ActivityManagerService --> ApplicationThread

    4、ActivityManagerService->startActivity

    路径:/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

    @Override
        public final int startActivity(IApplicationThread caller, String callingPackage,
                Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
                int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
                // ---------看这里---------
            return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                    resultWho, requestCode, startFlags, profilerInfo, bOptions,
                    UserHandle.getCallingUserId());
        }
    
        @Override
        public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
                Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
                int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
                // ---------看这里---------
            return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                    resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
                    true /*validateIncomingUser*/);
        }
    
        public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
                Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
                int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
                boolean validateIncomingUser) {
            enforceNotIsolatedCaller("startActivity");
    
            userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
                    Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
    
            // TODO: Switch to user app stacks here.
            // ---------看这里---------
            return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
                    .setCaller(caller)
                    .setCallingPackage(callingPackage)
                    .setResolvedType(resolvedType)
                    .setResultTo(resultTo)
                    .setResultWho(resultWho)
                    .setRequestCode(requestCode)
                    .setStartFlags(startFlags)
                    .setProfilerInfo(profilerInfo)
                    .setActivityOptions(bOptions)
                    .setMayWait(userId)
                    .execute();
    
        }
    

    mActivityStartController一系列的链式调用初始化ActivityStarter,最终调用ActivityStarter的execute()方法

    路径:/frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java

    ActivityStarter是加载Activity的控制类,决定如何将Intent和Flags转换为Activity。并将Activity与Task、Stack相关联。

    int execute() {
            try {
                // TODO(b/64750076): Look into passing request directly to these methods to allow
                // for transactional diffs and preprocessing.
                if (mRequest.mayWait) {
                    // ---------看这里---------
                    return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                            mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
                            mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                            mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                            mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                            mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                            mRequest.inTask, mRequest.reason,
                            mRequest.allowPendingRemoteAnimationRegistryLookup);
                } else {
                    // ---------看这里---------
                    return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
                            mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
                            mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                            mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
                            mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
                            mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
                            mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
                            mRequest.outActivity, mRequest.inTask, mRequest.reason,
                            mRequest.allowPendingRemoteAnimationRegistryLookup);
                }
            } finally {
                onExecutionComplete();
            }
        }
    

    startActivityMayWait()里面最后还是会调用else里面的startActivity(),startActivity()调用还会调用ActivityStarter中的两个另外的startActivity(),最里层的startActivity()源码如下:

    private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
                    IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                    int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                    ActivityRecord[] outActivity) {
            int result = START_CANCELED;
            try {
                mService.mWindowManager.deferSurfaceLayout();
                // ---------看这里---------
                result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                        startFlags, doResume, options, inTask, outActivity);
            } finally {
                ...
            }
    
           ...
    
            return result;
        }
    

    接着继续调用ActivityStarter中的startActivityUnchecked()方法

     // Note: This method should only be called from {@link startActivity}.
        private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                ActivityRecord[] outActivity) {
    
            // 初始化ActivityStarter全局变量
            setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
                    voiceInteractor);
            
            // 计算mLaunchFlags, 一般是判断是否需要在mLaunchFlags中加入FLAG_ACTIVITY_NEW_TASK
            computeLaunchingTaskFlags();
    
            computeSourceStack();
    
            mIntent.setFlags(mLaunchFlags);
            ...
            // 判断是否应将新Activity插入到现有任务栈中
            // 如果不需要,则返回null,如果需要,则返回该任务栈信息
            ActivityRecord reusedActivity = getReusableIntentActivity();
            if (reusedActivity != null) {
    
                if (mService.getLockTaskController().isLockTaskModeViolation(reusedActivity.getTask(),
                        (mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
                                == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))) {
                    Slog.e(TAG, "startActivityUnchecked: Attempt to violate Lock Task Mode");
                    return START_RETURN_LOCK_TASK_MODE_VIOLATION;
                }
    
                ...
    
                if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
                        || isDocumentLaunchesIntoExisting(mLaunchFlags)
                        || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
                    final TaskRecord task = reusedActivity.getTask();
                    ...
                }
    
                mSupervisor.sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, reusedActivity);
    
                reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
    
                final ActivityRecord outResult =
                        outActivity != null && outActivity.length > 0 ? outActivity[0] : null;
    
                if (outResult != null && (outResult.finishing || outResult.noDisplay)) {
                    outActivity[0] = reusedActivity;
                }
    
                if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
                    resumeTargetStackIfNeeded();
                    return START_RETURN_INTENT_TO_CALLER;
                }
            }
    
            if (mStartActivity.packageName == null) {
                ...
                return START_CLASS_NOT_FOUND;
            }
    
            // If the activity being launched is the same as the one currently at the top, then
            ...
            
            if (dontStart) {
                ...
                return START_DELIVERED_TO_TOP;
            }
    
            ...
                    
            // 使新Activity可见
            if (mDoResume) {
                final ActivityRecord topTaskActivity =
                        mStartActivity.getTask().topRunningActivityLocked();
                if (!mTargetStack.isFocusable()
                        || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                        && mStartActivity != topTaskActivity)) {
                    mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
                    mService.mWindowManager.executeAppTransition();
                } else {
                    if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                        mTargetStack.moveToFront("startActivityUnchecked");
                    }
                    // ---------看这里---------
                    mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                            mOptions);
                }
            } else if (mStartActivity != null) {
                ...
            }
           ...
    
            return START_SUCCESS;
        }
    

    startActivityUnchecked函数最重要的工作就是为待启动的ActivityRecord找到他对应的TaskRecord和ActivityStack

    5、ActivityStackSupervisor->resumeFocusedStackTopActivityLocked

    路径:/frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

    boolean resumeFocusedStackTopActivityLocked(
                ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    
            if (!readyToResume()) {
                return false;
            }
    
            if (targetStack != null && isFocusedStack(targetStack)) {
                return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
            }
    
            // 获取要启动的Activity所在栈的栈顶的不是出于停止状态的ActivityRecord
            final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
            if (r == null || !r.isState(RESUMED)) {
                // ---------看这里---------
                mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
            } else if (r.isState(RESUMED)) {
                // Kick off any lingering app transitions form the MoveTaskToFront operation.
                mFocusedStack.executeAppTransition(targetOptions);
            }
    
            return false;
        }
    

    mFocusedStack是ActivityStackSupervisor的一个成员变量,类型是ActivityStack
    如果获取的ActivityRecord不为null,或者要启动的Activity的状态不是RESUMED,则会调用ActivityStack的resumeTopActivityUncheckedLocked方法。继续跟进resumeTopActivityUncheckedLocked方法。

    6、ActivityStack->resumeFocusedStackTopActivityLocked

    路径:/frameworks/base/services/core/java/com/android/server/am/ActivityStack.java

    @GuardedBy("mService")
        boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
            if (mStackSupervisor.inResumeTopActivity) {
                // Don't even start recursing.
                return false;
            }
    
            boolean result = false;
            try {
                // Protect against recursion.
                mStackSupervisor.inResumeTopActivity = true;
                
                // ---------看这里---------
                result = resumeTopActivityInnerLocked(prev, options);
    
                // When resuming the top activity, it may be necessary to pause the top activity (for
                // example, returning to the lock screen. We suppress the normal pause logic in
                // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
                // end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
                // to ensure any necessary pause logic occurs. In the case where the Activity will be
                // shown regardless of the lock screen, the call to
                // {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
                final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
                if (next == null || !next.canTurnScreenOn()) {
                    checkReadyForSleep();
                }
            } finally {
                mStackSupervisor.inResumeTopActivity = false;
            }
    
            return result;
        }
    

    接着调用resumeTopActivityInnerLocked方法,继续跟进

    @GuardedBy("mService")
        private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
           ...
            ActivityStack lastStack = mStackSupervisor.getLastStack();
            if (next.app != null && next.app.thread != null) {
                
            } else {
                // Whoops, need to restart this activity!
                if (!next.hasBeenLaunched) {
                    
                } else {
                    if (SHOW_APP_STARTING_PREVIEW) {
                        next.showStartingWindow(null /* prev */, false /* newTask */,
                                false /* taskSwich */);
                    }
                    if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
                }
                if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);
                // ---------看这里---------
                mStackSupervisor.startSpecificActivityLocked(next, true, true);
            }
    
            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            return true;
        }
    

    这里又回到了ActivityStackSupervisor中的startSpecificActivityLocked方法

    7、ActivityStackSupervisor->startSpecificActivityLocked

    路径:/frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java

    void startSpecificActivityLocked(ActivityRecord r,
                boolean andResume, boolean checkConfig) {
            // 获取即将启动的Activiy所在的应用程序进程
            ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                    r.info.applicationInfo.uid, true);
    
            getLaunchTimeTracker().setLaunchTime(r);
    
            if (app != null && app.thread != null) {// Activity所在的应用程序已经运行
                try {
                    if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                            || !"android".equals(r.info.packageName)) {
                        // Don't add this if it is a platform component that is marked
                        // to run in multiple processes, because this is actually
                        // part of the framework so doesn't make sense to track as a
                        // separate apk in the process.
                        app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,
                                mService.mProcessStats);
                    }
                    // ---------看这里---------
                    realStartActivityLocked(r, app, andResume, checkConfig);
                    return;
                } catch (RemoteException e) {
                    Slog.w(TAG, "Exception when starting activity "
                            + r.intent.getComponent().flattenToShortString(), e);
                }
    
            }
            mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
                    "activity", r.intent.getComponent(), false, false, true);
        }
    

    跟进realStartActivityLocked方法

        final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
                boolean andResume, boolean checkConfig) throws RemoteException {
                ...           
    
                try {
                    ...
    
                    // 这里传入的app.thread会赋值给ClientTransaction的成员变量mClient,
                    // 而ClientTransaction会调用mClient.scheduleTransaction(this)来执行事务
                    // 所以事务最终是调用app.thread的scheduleTransaction执行。
                    // 而这个app.thread是ActivityThread的内部类ApplicationThread。
                    final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                            r.appToken);
                    clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                            System.identityHashCode(r), r.info,
                            // TODO: Have this take the merged configuration instead of separate global
                            // and override configs.
                            mergedConfiguration.getGlobalConfiguration(),
                            mergedConfiguration.getOverrideConfiguration(), r.compat,
                            r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                            r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                            profilerInfo));
    
                    // Set desired final state.
                    final ActivityLifecycleItem lifecycleItem;
                    if (andResume) {
                        lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
                    } else {
                        lifecycleItem = PauseActivityItem.obtain();
                    }
                    clientTransaction.setLifecycleStateRequest(lifecycleItem);
    
                    // Schedule transaction.
                    // ---------看这里---------
                    // 执行Activity启动事务
                    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
                    ...
                } catch (RemoteException e) {
                    if (r.launchFailed) {
                        // 第二次启动失败的异常处理
                        return false;
                    }
    
                    // 第一次启动失败,重试
                    r.launchFailed = true;
                    app.activities.remove(r);
                    throw e;
                }
            } finally {
                endDeferResume();
            }
            ...
            return true;
        }
    

    在realStartActivityLocked中最主要的工作就是创建了Activity的启动事务ClientTransaction,并调用ClientLifecycleManager的scheduleTransaction方法启动它。接下来,看ClientTransaction事务中是怎么启动Activity的。

    路径:/frameworks/base/services/core/java/com/android/server/am/ClientLifecycleManager.java

    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            final IApplicationThread client = transaction.getClient();
            
            // ---------看这里---------
            transaction.schedule();
            
            if (!(client instanceof Binder)) {
                // If client is not an instance of Binder - it's a remote call and at this point it is
                // safe to recycle the object. All objects used for local calls will be recycled after
                // the transaction is executed on client in ActivityThread.
                transaction.recycle();
            }
        }
    

    调用ClientTransaction的schedule方法,继续跟进

        public void schedule() throws RemoteException {
            mClient.scheduleTransaction(this);
        }
    

    这里调用了mClient的scheduleTransaction方法,这里的mClient是在创建ClientTransaction事务对象的时候赋值的,也就是调用obtain方法时。

    路径:/frameworks/base/services/core/java/com/android/server/am/ClientLifecycleManager.java

        public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
            ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
            if (instance == null) {
                instance = new ClientTransaction();
            }
            instance.mClient = client;
            instance.mActivityToken = activityToken;
    
            return instance;
        }
    

    好,回到ActivityStackSupervisor的realStartActivityLocked方法中,最终会调用mService.getLifecycleManager().scheduleTransaction(clientTransaction)启动Activity事务,可以看到,获取clientTransaction参数的obtain方法中,赋值给mClient的是app.thread,所以事务最终是调用的app.thread的scheduleTransaction方法来执行,而这个app.thread是ActivityThread的内部类ApplicationThread。所以流程转到了ActivityThread的内部类ApplicationThread中。

    ApplicationThread --> Activity

    8、ActivityThread.ApplicationThread->scheduleTransaction

    路径:/frameworks/base/core/java/android/app/ActivityThread.java

        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
    

    这里还是调用了ActivityThread的scheduleTransaction方法。但是ActivityThread类中并没有scheduleTransaction这个方法。因此自然会想到很可能是继承的父类中的方法。ActivityThread继承的是ClientTransactionHandler类,在ClientTransactionHandler类中发现了scheduleTransaction方法。所以这里最终调用的就是ClientTransactionHandler中的scheduleTransaction方法。

        void scheduleTransaction(ClientTransaction transaction) {
            transaction.preExecute(this);
            sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
        }
    
    

    这里调用了sendMessage方法,而sendMessage是一个抽象方法,所以这里调用的是ActivityThread类中的sendMessage实现。

        private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
            if (DEBUG_MESSAGES) Slog.v(
                TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
                + ": " + arg1 + " / " + obj);
            Message msg = Message.obtain();
            msg.what = what;
            msg.obj = obj;
            msg.arg1 = arg1;
            msg.arg2 = arg2;
            if (async) {
                msg.setAsynchronous(true);
            }
            // ---------看这里---------
            mH.sendMessage(msg);
        }
    
    

    这里就是生成了一个Message对象,并向mH这个Handler发送一个what为ActivityThread.H.EXECUTE_TRANSACTION的消息。去查看Handler(ActivityThread.H)中对EXECUTE_TRANSACTION消息的处理。

    case EXECUTE_TRANSACTION:
            final ClientTransaction transaction = (ClientTransaction) msg.obj;
            // ---------看这里---------
            // 调用TransactionExecutor的execute方法
            mTransactionExecutor.execute(transaction);
            if (isSystem()) {
                // Client transactions inside system process are recycled on the client side
                // instead of ClientLifecycleManager to avoid being cleared before this
                // message is handled.
                transaction.recycle();
            }
            // TODO(lifecycler): Recycle locally scheduled transactions.
            break;
    
    9、TransactionExecutor->execute

    路径:/frameworks/base/core/java/android/app/servertransaction/TransactionExecutor
    这里调用了TransactionExecutor的execute方法

        public void execute(ClientTransaction transaction) {
            final IBinder token = transaction.getActivityToken();
            log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
    
            // ---------看这里---------
            executeCallbacks(transaction);
            executeLifecycleState(transaction);
            
            mPendingActions.clear();
            log("End resolving transaction");
        }
    
    

    这里调用了executeCallbacks和executeLifecycleState两个方法,查看两个方法就会发现,这两个方法最后都会调用cycleToPath这个方法。

        private void cycleToPath(ActivityClientRecord r, int finish,
                boolean excludeLastState) {
            final int start = r.getLifecycleState();
            log("Cycle from: " + start + " to: " + finish + " excludeLastState:" + excludeLastState);
            final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
            // ---------看这里---------
            performLifecycleSequence(r, path);
        }
    

    继续看performLifecycleSequence方法

        private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
            final int size = path.size();
            for (int i = 0, state; i < size; i++) {
                state = path.get(i);
                log("Transitioning to state: " + state);
                switch (state) {
                    case ON_CREATE:
                     // ---------看这里---------
                     mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                                null /* customIntent */);
                        break;
                    case ON_START:
                        mTransactionHandler.handleStartActivity(r, mPendingActions);
                        break;
                    case ON_RESUME:
                        mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                                r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                        break;
                    case ON_PAUSE:
                        mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                                false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                                "LIFECYCLER_PAUSE_ACTIVITY");
                        break;
                    case ON_STOP:
                        mTransactionHandler.handleStopActivity(r.token, false /* show */,
                                0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
                                "LIFECYCLER_STOP_ACTIVITY");
                        break;
                    case ON_DESTROY:
                        mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                                0 /* configChanges */, false /* getNonConfigInstance */,
                                "performLifecycleSequence. cycling to:" + path.get(size - 1));
                        break;
                    case ON_RESTART:
                        mTransactionHandler.performRestartActivity(r.token, false /* start */);
                        break;
                    default:
                        throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
                }
            }
        }
    

    可以看到,Activity的生命周期就是在这里进行一个相关方法的调用。
    这里的成员变量mTransactionHandler是一个ClientTransactionHandler对象,在ClientTransactionHandler中这些方法都是抽象方法,这里执行的是ClientTransactionHandler的实现类ActivityThread中的handleLaunchActivity方法。

    10、ActivityThread->handleLaunchActivity

    路径:/frameworks/base/core/java/android/app/ActivityThread.java

        public Activity handleLaunchActivity(ActivityClientRecord r,
                PendingTransactionActions pendingActions, Intent customIntent) {
            // If we are getting ready to gc after going to the background, well
            // we are back active so skip it.
            unscheduleGcIdler();
            mSomeActivitiesChanged = true;
    
            if (r.profilerInfo != null) {
                mProfiler.setProfiler(r.profilerInfo);
                mProfiler.startProfiling();
            }
    
            // Make sure we are running with the most recent config.
            handleConfigurationChanged(null, null);
    
            if (localLOGV) Slog.v(
                TAG, "Handling launch of " + r);
    
            // Initialize before creating the activity
            if (!ThreadedRenderer.sRendererDisabled) {
                GraphicsEnvironment.earlyInitEGL();
            }
            //创建WindowManagerServer
            WindowManagerGlobal.initialize();
    
            // ---------看这里---------
            // 通过反射创建指定的Activity,并回调Activity的performCreate方法执行onCreate
            final Activity a = performLaunchActivity(r, customIntent);
    
            if (a != null) {
                r.createdConfig = new Configuration(mConfiguration);
                reportSizeConfigurations(r);
                if (!r.activity.mFinished && pendingActions != null) {
                    pendingActions.setOldState(r.state);
                    pendingActions.setRestoreInstanceState(true);
                    pendingActions.setCallOnPostCreate(true);
                }
            } else {
                // If there was an error, for any reason, tell the activity manager to stop us.
                try {
                    ActivityManager.getService()
                            .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                                    Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
                } catch (RemoteException ex) {
                    throw ex.rethrowFromSystemServer();
                }
            }
    
            return a;
        }
    
    

    好,继续跟进performLaunchActivity方法

     private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
            // 获取ActivityInfo类
            ActivityInfo aInfo = r.activityInfo;
            if (r.packageInfo == null) {
                // 获取APK文件描述的LoadedAPK
                r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                        Context.CONTEXT_INCLUDE_CODE);
            }
    
            // 获取要启动的Activity的ComponentName类,该类保存了Activity类名和包名
            ComponentName component = r.intent.getComponent();
            ...
    
            // 创建要启动Activity的上下文环境
            ContextImpl appContext = createBaseContextForActivity(r);
            Activity activity = null;
            try {
                java.lang.ClassLoader cl = appContext.getClassLoader();
                // 用类加载器来创建Activity实例
                activity = mInstrumentation.newActivity(
                        cl, component.getClassName(), r.intent);
                ...
            } catch (Exception e) {
                ...
            }
    
            try {
                // 创建Application,makeApplication方法内部会调用创建Application的onCreate()
                Application app = r.packageInfo.makeApplication(false, mInstrumentation);
                ...
                if (activity != null) {
                    ...
                    // 初始化Activity,在attach方法中会创建window对象并与Activity关联
                    activity.attach(appContext, this, getInstrumentation(), r.token,
                            r.ident, app, r.intent, r.activityInfo, title, r.parent,
                            r.embeddedID, r.lastNonConfigurationInstances, config,
                            r.referrer, r.voiceInteractor, window, r.configCallback);
                    ...
    
                    if (r.isPersistable()) {
                        // ---------看这里---------
                        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnCreate(activity, r.state);
                    }
                   ...
                }
                ...
            } catch (SuperNotCalledException e) {
                throw e;
            } catch (Exception e) {
                ...
            }
    
            return activity;
        }
    

    这个方法中的注释已经很明确了,获取ActivityInfo、ComponentName、appContext,并创建了Application,回调Application的onCreate(),最后调用Instrumentation的callActivityOnCreate()方法来启动Activity

    11、Instrumentation->callActivityOnCreate

    路径:/frameworks/base/core/java/android/app/Instrumentation.java

    public void callActivityOnCreate(Activity activity, Bundle icicle,
                PersistableBundle persistentState) {
            prePerformCreate(activity);
            // ---------看这里---------
            activity.performCreate(icicle, persistentState);
            postPerformCreate(activity);
        }
    

    可以看到,最终是调用了Activity的performCreate()方法,继续跟进

    12、Activity->performCreate

    路径:/frameworks/base/core/java/android/app/Activity.java

    final void performCreate(Bundle icicle, PersistableBundle persistentState) {
            mCanEnterPictureInPicture = true;
            restoreHasCurrentPermissionRequest(icicle);
            if (persistentState != null) {
                // ---------看这里---------
                onCreate(icicle, persistentState);
            } else {
                onCreate(icicle);
            }
            writeEventLog(LOG_AM_ON_CREATE_CALLED, "performCreate");
            mActivityTransitionState.readState(icicle);
    
            mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
                    com.android.internal.R.styleable.Window_windowNoDisplay, false);
            mFragments.dispatchActivityCreated();
            mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
        }
    

    到目前为止,我们分析了Launcher请求AMS、AMS到ApplicationThread的调用过程、ActivityThread启动Activity的过程,从根Activity的启动过程中可以看到,若我们想做启动耗时优化,目前最明显且易控制的方式就是尽量少在Application和Activity的onCreate()方法中做耗时操作,一些后面才会用到的库或者其他三方库可以延迟初始化。

    相关文章

      网友评论

        本文标题:Android9.0应用程序启动过程源码分析

        本文链接:https://www.haomeiwen.com/subject/zwolhctx.html