ActivityManagerService第一讲之Activity启动流程

最新推荐文章于 2023-04-04 22:55:02 发布

adroid_newbie

最新推荐文章于 2023-04-04 22:55:02 发布

阅读量1.9k

点赞数 2

分类专栏： Android Frameworks

本文链接：https://blog.csdn.net/zplxl99/article/details/104293179

版权

本文详细探讨了Android系统中Activity的启动过程，从Activity的startActivity开始，经过Intent传递，到ActivityTaskManagerService，再到ActivityStackSupervisor，最终执行到Activity的onCreate方法。涵盖了从用户点击应用图标到Activity实例化的主要步骤。

摘要由CSDN通过智能技术生成

一.Activity启动简述

我们从Launcher启动某个应用，本质上就是Activity的启动。我们下面简单的讲述一下整个流程。此处流程是基于Android-10源码。

二.Activity启动流程

该流程是基于根Activity启动的，也就是我从桌面中点击应用图标开始的。

1.Activity#startActivity

传入参数为intent和Bundle。最终都是调用startActivityForResult方法，且第二个参数均为-1(requestCode值)

    @Override
    public void startActivity(Intent intent) {
   
        this.startActivity(intent, null);
    }
    
    
    @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);
        }
    }

2.Activity#startActivityForResult

先去判断mParent是否为空，即是否有父Activity。接着调用Instrumentation的execStartActivity方法（Instrumentation类主要是用来监控应用和系统之间的交互）

    public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
   
        // 判断父activity是否为空
        if (mParent == null) {
   
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            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;
            }

            cancelInputsAndStartExitTransition(options);
            // TODO Consider clearing/flushing other event sources and events for child windows.
        } else {
   
            if (options != null) {
   
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
   
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

3.Instrumentation#execStartActivity

关键方法在try-catch语句中，会通过ActivityTaskManager的getService方法获取ActivityTaskManagerService。以此调用startActivity方法。

    @UnsupportedAppUsage
    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
   
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        Uri referrer = target != null ? target.onProvideReferrer() : null;
        if (referrer != null) {
   
            intent.putExtra(Intent.EXTRA_REFERRER, referrer);
        }
        //Activity监控器不为空
        if (mActivityMonitors != null) {
   
            //加锁
            synchronized (mSync) {
   
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
   
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    ActivityResult result = null;
                    if (am.ignoreMatchingSpecificIntents()) {
   
                        result = am.onStartActivity(intent);
                    }
                    if (result != null) {
   
                        am.mHits++;
                        return result;
                    } else if (am.match(who, null, intent)) {
   
                        am.mHits++;
                        if (am.isBlocking()) {
   
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
   
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess(who);
            // 调用startActivity
            int result = ActivityTaskManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
   
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

这里看一下ActivityTaskManager的getService实现，定义一个单例IActivityTaskManagerSingleton

    /** @hide */
    public static IActivityTaskManager getService() {
   
        return IActivityTaskManagerSingleton.get();
    }

    @UnsupportedAppUsage(trackingBug = 129726065)
    private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
            new Singleton<IActivityTaskManager>() {
   
                @Override
                protected IActivityTaskManager create() {
   
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
                    return IActivityTaskManager.Stub.asInterface(b);
                }
            };

IActivityTaskManager是一个AIDL，而对应的实现是在ActivityTaskManagerService。（原因是： ActivityTaskManagerService 继承了IActivityTaskManager.Stub ）

4.ActivityTaskManagerService#startActivity

startActivity方法最终返回startActivityAsUser方法，其实仔细看多两个参数：useId和validateIncomingUser

    @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());
    }

5.ActivityTaskManagerService#startActivityAsUser

上面多传入的两个参数均用在ActivityStartController的checkTargetUser方法中，具体的大家有兴趣可以看下

    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("startActivityAsUser");

        //获取userid
        userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
                Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

        // TODO: Switch to user app stacks here.
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                .setCaller(caller)
                .setCallingPackage(callingPackage)
                .setResolvedType(resolvedType)
                .setResultTo(resultTo)
                .setResultWho(resultWho)
                .setRequestCode(requestCode)
                .setStartFlags(startFlags)
                .setProfilerInfo(profilerInfo)
                .setActivityOptions(bOptions)
                .setMayWait(userId)
                .execute();

    }

这里关键是return语句上的实现。先看getActivityStartController().obtainStarter：

    ActivityStarter obtainStarter(Intent intent, String reason) {
   
        return mFactory.obtain().setIntent(intent).setReason(reason);
    }

这里返回的是一个ActivityStarter类型。所以当调用到execute方法的时候，就是在ActivityStarter中实现的。ActivityStarter类是用来加载Activity

6.ActivityStarter#execute

    int execute() {
   
        try {
   
            // TODO(b/64750076): Look into passing request directly to these methods to allow
            // for transactional diffs and preprocessing.
            // 一般情况下mRequest.mayWait为false
            if (mRequest.mayWait) {
   
                return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                        mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
                        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,
                        mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
            } 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,
                        mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
            }
        } finally {
   
            onExecutionComplete();
        }
    }

我们先来看startActivity方法。

7.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, boolean restrictedBgActivity) {
   
        int result = START_CANCELED;
        final ActivityStack startedActivityStack;
        try {
   
            mService.mWindowManager.deferSurfaceLayout();
            // 这里会调用startActivityUnchecked
            result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
        } finally {
   
            final ActivityStack currentStack = r.getActivityStack();
            startedActivityStack = currentStack != null ? currentStack : mTargetStack;

            if (ActivityManager.isStartResultSuccessful(result)) {
   
                if (startedActivityStack != null) {