Android应用程序（activity）启动过程（三）API28

文章基于API28本的activity启动过程，和26版本的启动过程改动不大，主要是在realStartActivityLocked方法之后，修改了activity的调用，读本文之前建议先了解之前版本activity的调用过程，文章将直接讲解主要不同之处。
Android应用程序（activity）启动过程（一）
Android应用程序（activity）启动过程（二）

对接启动过程（二） step 39或 step 50

realStartActivityLocked()方法

                // 启动LaunchActivityItem                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),                        System.identityHashCode(r), r.info,                           mergedConfiguration.getGlobalConfiguration(),                        mergedConfiguration.getOverrideConfiguration(), r.compat,                        r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,                        r.persistentState, results, newIntents, mService.isNextTransitionForward(),                        profilerInfo));                final ActivityLifecycleItem lifecycleItem;                if (andResume) {                    // 启动 ResumeActivityItem  ActivityLifecycleItem                    lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());                } else {                // 否则 启动 PauseActivityItem                    lifecycleItem = PauseActivityItem.obtain();                }                // 利用 mLifecycleStateRequest 执行 resume方法                clientTransaction.setLifecycleStateRequest(lifecycleItem);                // Schedule transaction.启动事务                mService.getLifecycleManager().scheduleTransaction(clientTransaction);

scheduleTransaction()

// ClientLifecycleManager 类void scheduleTransaction(ClientTransaction transaction) throws RemoteException {        final IApplicationThread client = transaction.getClient();        // 此处调用 transaction 的schedule()方法        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();        }    }

schedule() 方法中有个mClient 成员变量，private IApplicationThread mClient; 接口类型将用来回调ApplicationThread

// ClientTransaction

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

scheduleTransaction()，方法调用了ActivityThread 的scheduleTransaction方法，这个方法是ActivityThread 父类 ClientTransactionHandler 定义的方法

// ActivityThread 内部类 ApplicationThread @Override        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {            ActivityThread.this.scheduleTransaction(transaction);        }

scheduleTransaction(),主要是发送了message到ActivityThread.H 的handler中，返回到ActivityThread

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

ActivityThread 中的H （handler）处理此消息，调用了mTransactionExecutor 的execute 方法，这个mTransactionExecutor 是个TransactionExecutor类。

case EXECUTE_TRANSACTION:                    final ClientTransaction transaction = (ClientTransaction) msg.obj;                    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;

TransactionExecutor 的execute方法，直接调用了executeCallbacks 之前将LaunchActivityItem添加到一个callback中，这里开始解析

    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");    }

TransactionExecutor 类 executeCallbacks()

 @VisibleForTesting    public void executeCallbacks(ClientTransaction transaction) {//        LaunchActivityItem 等将要执行的活动实现了        final List callbacks = transaction.getCallbacks();               final IBinder token = transaction.getActivityToken();        ActivityClientRecord r = mTransactionHandler.getActivityClient(token);        final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();        final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()                : UNDEFINED;        // Index of the last callback that requests some post-execution state.        final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);        final int size = callbacks.size();        for (int i = 0; i < size; ++i) {            final ClientTransactionItem item = callbacks.get(i);            log("Resolving callback: " + item);            final int postExecutionState = item.getPostExecutionState();            final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,                    item.getPostExecutionState());            if (closestPreExecutionState != UNDEFINED) {                cycleToPath(r, closestPreExecutionState);            }// 循环遍历执行item 也就是LaunchActivityItem  的execute方法            item.execute(mTransactionHandler, token, mPendingActions);            item.postExecute(mTransactionHandler, token, mPendingActions);            if (r == null) {                // Launch activity request will create an activity record.                r = mTransactionHandler.getActivityClient(token);            }            if (postExecutionState != UNDEFINED && r != null) {                // Skip the very last transition and perform it by explicit state request instead.                final boolean shouldExcludeLastTransition =                        i == lastCallbackRequestingState && finalState == postExecutionState;                cycleToPath(r, postExecutionState, shouldExcludeLastTransition);            }        }    }

LaunchActivityItem 类 execute()

    @Override    public void execute(ClientTransactionHandler client, IBinder token,            PendingTransactionActions pendingActions) {        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");        ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,                mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,                mPendingResults, mPendingNewIntents, mIsForward,                mProfilerInfo, client);               // 最终回调了 ClientTransactionHandler 实现类 ActivityThread 的handleLaunchActivity方法，和之前版本的启动过程对接上了        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);    }

返回 step 7 解决完callback 后，开始 executeLifecycleState，继续处理后面的resume生命周期
同理，直接进入ResumeActivityItem execute方法

private void executeLifecycleState(ClientTransaction transaction) {        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();        if (lifecycleItem == null) {            // No lifecycle request, return early.            return;        }        log("Resolving lifecycle state: " + lifecycleItem);        final IBinder token = transaction.getActivityToken();        final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);        if (r == null) {            // Ignore requests for non-existent client records for now.            return;        }        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);        // Execute the final transition with proper parameters.        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);    }

ResumeActivityItem execute();看到 handleResumeActivity 又对接上之前的版本的方法

@Override    public void execute(ClientTransactionHandler client, IBinder token,            PendingTransactionActions pendingActions) {        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");        client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,                "RESUME_ACTIVITY");        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);    }

中间经过 ActivityThread 类 performResumeActivity 进入到Activity performResume 方法此方法会依次调用onStart和onResume方法

更多相关文章

随机推荐