Activity启动流程

ActivityThread

一个应用对应一个ActivityThread，当Zygote进程孵化出一个新的应用进程后，会执行ActivityThread的main函数，main中主要做了Looper消息队列的处理，然后调用了ActivityThread的attach()函数，将其绑定到ActivityManagerService中，开始不断的读取消息队列中的消息并分发消息，是典型的基于事件驱动的模型
```
public final class ActivityThread extends ClientTransactionHandler{
    
    public static void main(String[] args){

        Looper.prepareMainLooper();
        ...
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);
        ...
        Looper.loop;
    }
}
```

activityThread.attach()函数中主任务是将ApplicationThread绑定到ActivityManagerService中

private void attach(boolean system, long startSeq){
	if(!system){
        final IActivityManager mgr = ActivityManager.getService();
        try{
            //绑定applicationThread和activityMangerService
            mgr.attachApplication(mAppThread,startSeq);
        }
    }
    //ConfigChanged事件回调处理
    ViewRootImpl.ConfigChangedCallBack configChangedCallback = (Configration globalConfig)->{
        if(mResourcesManger.applyConfigurationToResourcesLocked(globalConfig,null)){
            updateLocaleListFromAppContext(mInitialApplication.getApplicationContext(),mResourceManager.getConfiguration().getLocales());
            sendMessage(H.CONFIGURATION_CHANGED,globalConfig);
        }
    }
}

ActivityManagerService中attachApplication主要负责处理Application相关的逻辑，attachApplicationLocked主要处理activity启动，通过层层调用最终在RootWindowContainer中调用activityStackSupervisor.realStartActivityLocked()开启activity的生命周期

public class class ActivityManagerService extends IActivityManger.Stub implements Watchdog.Monitor,BetteryStatsImpl.BatteryCallback{

    public final void attachApplication(IApplicationThread thread, loog startSeq){
        synchronized(this){
            int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final int origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread,callingPid,callingUid,startSeq);
        }
    }
    private boolean attachApplicationLocked(IApplicationThread thread, int pid, int callingUid,long startSeq){
        ...
        //通过ApplicationThread向
        thread.bindApplication(...);
        ...
        //mAtmInternal为ActivityTaskManagerInternal对象，通过LocalServices.getService(class)获取其实现类是
        //ActivityTaskManagerService的内部类LocalService
        mAtmInteranl.attachApplication(app.getWindowProcessController());
        //ActivityServicesq处理Services逻辑
        mServices.attachApplicationLocked(app,processName);
        //BroadCast
     sendPendingBroadcastsLocked(app);
    }
}
public class ActivityTaskManagerService extends IActivityManger.Sub{
    public ActivityTaskManagerService(Context context){
        mInternal = new LocalService();
    }
	private void start(){
        LocalServices.addService(ActivityTaskManagerInternal.class,mInternal);
    }
	final class LocalService extends ActivityTaskManagerInternal{
    }
}
public class ActivityStackSupervisor implements RecentTasks.Callbacks{
    boolean realStartActivityLocked(ActivityRecord r,WindowProcessController proc,boolean addResume, boolean checkConfig) throw RemoteException{
        ...
        final ClientTransaction clientTransaction = ClientTransaction.obatin(proc.getThread(),r.appToken);
        clientTransaction.addCallback(LaunchActivityItem.obatin(new Intent(r.intent),...));
        final ActivityLifecycleItem lifecycleItem;
        if(addResume){
            lifecycleItem = ResumeActivityItem.obatin(dc.isNextTransitionForward());
        }else{
            lifecycleItem = PauseActivityItem.obatin();
        }
        clientTransaction.setLifecycleStateRequest(lifecycleItem);
        //schedule transaction
        mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    }
}

Activity生命周期处理，每个应用启动后会在主线程中(ActivityThread.main)调用Looper.prepareMainLooper()获取单例sMainLooper以及内部的消息队列，并将消息队列的quitAllowed属性设置成false，经过复杂的启动逻辑后最终调用Looper.looper()等待消息的到来，LifecycleManger就是通过调用各种生命周期类向主线程发生message通知主线程(activityThread)处理生命周期函数，例如LuanchActivityItem、ResumeActivityItem、DestroyActivityItem等，其调用是通过持有ApplicationThread对象的ClientTransaction对象进行事件的传递，其中ApplicationThread是ActivityThread的内部类，可以直接调用activityThread的内部函数，**ActivityItem在源码的中的位置为frameworks\base\core\java\android\app\servertransaction

class ClientLifecycleManager{
    void scheduleTransaction(ClientTransation transaction) throws RemoteException{
        final IApplicationThread client = transcation.getClient();
        transaction.schedule();
    }
}
public class ClitentTransaction implements Parcelable,ObjectPootItem{
    private List<ClitentTransactionItem> mActivityCallbacks;
    private ActivityLifecycleItem mLifecycleStateRequest;
    private IApplicationThread mClient;
    private IBinder mActivityToken;
    public void addCallback(ClitentTransactionItem activityCallback){
        mActivityCallbacks.add(activityCallback);
    }
    public void setLifecycleStateResuest(ActivityLifecycleItem stateRequest){
        mLifecycleStateRequest = stateRequest;
    }
    public void schedule() throws RemoteException{
        mClient.scheduleTransaction(this);
    }
    public void preExecute(ClientTransactionHandler clientTransactionHandler){
        if(mActivityCallbacks! = null){
            //在ActivityStackSupervisor中设置了LaunchActivityItem
           	final int size = mActivityCallbacks.size();
            for(int i = 0; i < size; i++){
        				mActivityCallbacks.get(i).preExecute(clientTransactionHandler,mActivityToenk);
               //在ActivityStackSupervisor中设置了ResumeActivityItem或PauseActivityItem
                mLifecycleStateRequest.preExecute(clientTransactionHandler,mActivityToken);
            }
        }
    }
}
private class ApplicationThread extends IApplicationThread.Stub{
    public void scheduleTransaction(ClientTransaction transaction) throws RemoteException{
        ActivityThread.this.scheduleTransaction(transaction);
    }
}

ActivityThread继承了ClientTransactionHandler类，最后调用到其父类的scheduleTransaction(this)函数，最后通过发生message通知ActivityThread处理相关逻辑其代码如下

public abstract class ClientTransactionHandler{
    void scheduleTransaction(ClientTransaction transaction){
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION,transaction);
    }
    abstract void sendMessage(int what,Object obj);
}
public final class ActivityThread extends ClientTransactionHandler{
    final H mh = new H();
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
    void sendMessage(int what,Object objt){
        sendMessage(what,obj,0,0,false);
    }
    private void sendMessage(int what,Object obj,int arg1,int arg2,boolean async){
        Message msg = Message.obtain();
        msg.what = what;
        msg.obj = obj;
        msg.arg1 = arg1;
        msg.arg2 = arg2;
        if(async){
            msg.setAsynchronous(true);
        }
        mH.sendMessage(msg);
    }
	class H extends Handler{
        public void handleMessage(Message msg){
            switch(mgs.what){
                case BIND_APPLICATION:
                    AppBindData data = (AppBindData)msg.obj;
                    handleBindApplication(data);
                    break;
                case EXECUTE_TRANASCTION:
                    final ClientTransaction transtion = (ClientTransaction)msg.obj;
                    mTransactionExecutor.execute(transtion);
                    break;
            }
        }//end handleMessage
    }//end H
}//end ActivityThread

public class TransactionExecutor{
    public void execute(ClientTransaction transaction){
        ...
        executeCallbacks(transaction);
        executeLifecycleState(transaction);
    }
    public void executeCallbacks(ClientTransaction transaction){
        ...
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        final int size = callbacks.size();
        for(int i =0; i < size; i++){
            final ClientTransactionItem item = callbacks.get(i);
            item.execute(mTransactionHandler,token,mPendingActions);
            item.postExecute(mTransctionHandler,token,mPendingAcitions);
        }
        ...
    }
}//end TransactionExecutor

public class LaunchActivityItem extends ClientTransactionItem{
    public void execute(ClientTransactionHandler client,IBinder token,PendingTransactionAction pendingActions){
        // client实现类为ActivityThread，所有的回调完成，最终代码逻辑交由主线程ActivityTrhead控制
        client.handleLaunchActivity(r,pengdingAction,null);
    }
}//end LaunchActivityItem

public class ResumeActivityTime extends ClientTransactionItem{
    public void execute(ClientTransaction client,IBinder token, PendingTransactionActions pendingActions){
        client.handleResumeActivity(token,true,mIsForward,"RESUME_ACTIVITY");
    }
}

前面所有的逻辑处理完回到了ActivityThread对象的handleLaunchActivity中，最终在preformLaunchActivity中通过反射newInstance()创建activity对象和application对象，并创建appContext对象，调用activity.attach()绑定到activity中,然后就根据需要开始调用activity的生命周期函数

public Activity handleLaunchActivity(ActivityClientRecord r, PendingTransactions pendingActions, Intent customIntent){
    final Activity a = preformLaunchActivity(r,customIntent);
}
private Activity perfromLaunchActivity(ActivityClientRecord r,Intent customIntent){
    ...
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null;
    try{
        java.lang.ClassLoader cl = appContext.getClassLoader();
        activity = mInstrumentation.newActivity(cl,component.getClassName(),r.intent);
        ...
    }catch(Exception e){
        ...
    }
    //创建完app后执行instrumentation.callApplicationOnCreate(app);执行生命周期函数
    Application app = r.packageInfo.makeApplication(false,mInstrumentation);
    ...
    activity.attach(appContext,this,...);
    //后续计算生命周期会用到
    r.setState(ON_CREATE);
    ...
    mInstrumentation.callActivityOnCreate(activity,r.state);
}
public class Instrumentation{
    public void callActivityOnCreate(Activity activity, Bundle icicle){
        prePreformCreate(activity);
        //执行activity的onCreate()函数
        activity.performCreate(icicle);
        postPerformCreate(activity);
    }
}

生命周期的执行与计算，transactionExecutor执行execute()函数会先执行callback回调(LaunchActivityItem)，然后在执行生命周期函数，分别为executeCallbacks(transaction)和executeLifecycleState(transaction)，执行生命周期会先进行计算生命周期的顺序，自动添加需要执行的生命周期状态，先处理完自动添加的生命周期函数，然后在执行主动调用的生命周期函数，关键代码如下

public abstract class ActivityLifecycleItem extends ClientTransactionItem{
    @InfDef(prefix = {"UNDEFINED","PRE_","ON_"},value={
        UNDEFINED,
        PRE_ON_CREATE,
        ON_CREATE,
        ON_STATR,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_RESTART
    })
    public static final int UNDEFINED = -1;
    public static final int PRE_ON_CREATE =0;
    public static final int ON_CREATE =1;
    public static final int ON_START = 2;
    public static final int ON_RESUME = 3;
    public static final int ON_PAUSE = 4;
    public static final int ON_STOP = 5;
    public static final int ON_DESTORY = 6;
    public static final int ON_RESTART = 7;
    //每个执行后对应的生命周期状态，如果没有则返回UNDEFINED，如LaunchActivityItme没有对应的
    //生命周期返回UNDEFINED
    public abstract int getTargetState();
}//end ActivityLifecycleItem
public class TransactionExecutor{
    public void execute(ClientTransaction transaction){
        ...
        executeCallback(transaction);
        executeLifecycleState(transaction);
    }
    private void executeLifecyleState(ClientTransaction transaction){
        //获取到ActivityStackSupervisor设置的ResumeActivityItem
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleState();
        ...
        //targeState 返回 ON_RESUME = 3
        cycleToPath(r,lifceycleItem.getTargeState(),true,transaction);
        lifecycleItem.execute(...);
        lifecycleItem.postExecute(...);
    }
	private void cycleToPath(ActivityClientRecord r, int finsh,boolean excludeLastState,ClientTransaction transaction){
        //执行LaunchActivityItem调用activityThread.performLaunchActivity()中设置成了ON_CREATE =1
        final int start = r.getLifecycleState();
        //自动添加start->finish状态中缺少的生命周期状态
        final IntArray path = mHelper.getLifecyclePath(start,finish,excludeLastState);
        //执行添加到path中的生命周期状态
        performLifecycleSequence(r,path,transaction);
    }
    private void performLifecycelSequence(ActivityClientRecord r, IntArray path, ClientTransaction transaction){
        final int size = path.size();
        for(int i = 0,state;i < size ; i++){
            state = path.get(i);
            switch(state){
                case ON_CREATE:
                    mTranscationHandler.handleLaunchActivity(r,mPendingActions,null);
                    break;
                case ON_START:
                    mTranscationHandler.handleStartActivity(r.token,mPengdingActions);
                    break;
                case ON_RESUME:
                    mTransactionHandler.handleResumeActivity(r.token,false,r.isForward,"LIFECYCLER_RESUME_ACTIVITY")
                        break;
                    ....
            }
        }
    }
}//end TransactionExecutor

mTransactionHandler是ActivityThread对象，实际执行的生命周期函数都是在ActivityThread的主线程中调用的，每个生命周期都在ActivityThread类中有对应的handle***Activity函数，从ON_CREATE->ON_RESUME生命周期中会自动添加ON_START生命周期状态，然后根据追加的IntArry中遍历取出自动增加的状态并调用ActivityThread中对应的生命周期函数，自动添加ON_START状态代码如下

public class TransactionExecutorHelper{
    private IntArray mLifecycleSequence = new IntArray(6);
    public IntArray getLifecyclePath(int start,int finish,boolean excludeLastState){
        ...
        mLifecycleSequence.clear();
        //start=ON_CREATE=1，finish=ON_RESUME=3
        if(finish >= start){
            if(start==ON_START && finish==ON_STOP){
                mLifecycleSequence.add(ON_STOP);
            }else{
                //初始值为2，finish为3，所以会自动添加2和3的状态，也就是ON_START和ON_RESUME
                for(int i = start+1;i<=finish;i++){
                    mLifecycleSequence.add(i);
                }
            }//end if
        }//end if
         ...
         if(excludeLaste && mLifecycleSequence.size() != 0){
             //删除多余的ON_RESUME,保留缺少的ON_START
         	mLifecycleSequence.remove(mLifecycleSequence.size()-1);
         }
        return mLifecycleSequence;
    }
}

posted @ 2021-06-29 22:38 JRobot 阅读(291) 评论(0) 收藏举报

刷新页面返回顶部