2. 程式人生 > 其它 >Activity啟動流程

Activity啟動流程

阿新 • • 發佈：2021-06-29

Activity啟動流程

ActivityThread

  1. 一個應用對應一個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;
    }
}

  2. 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);
        }
    }
}

  3. 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);
    }
}

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

  5. 前面所有的邏輯處理完回到了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);
    }
}

  6. 生命週期的執行與計算，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;
    }
}

相關推薦

Activity啟動流程分析

我們來看一下 startActivity 過程的具體流程。在手機桌面應用中點選某一個 icon 之後，實際上最終就是通過 startActivity 去開啟某一個 Activity 頁面。我們知道 Android 中的一個 App 就相當於一個程式，所以 start

史上最全且最簡潔易懂的Activity啟動流程解析

Activity的啟動流程是一個資深Android工程師必須掌握的內容，也是高職級面試中的高頻面試知識點，無論是從事應用層開發，還是Framework開發，其重要性都無需我多言。而要真正理解它，就不可避免地要深入到原始碼了，

Android之Activity啟動流程詳解（基於api28）

前言 Activity作為Android四大元件之一，他的啟動絕對沒有那麼簡單。這裡涉及到了系統服務程序，啟動過程細節很多，這裡我只展示主體流程。activity的啟動流程隨著版本的更替，程式碼細節一直在進行更改，每次都會有

Activity啟動流程

Activity啟動流程 ActivityThread 一個應用對應一個ActivityThread，當Zygote程序孵化出一個新的應用程序後，會執行ActivityThread的main函式，main中主要做了Looper訊息佇列的處理，然後呼叫了ActivityThread的at

Activity的啟動流程

考察要點： 啟動Activity會經歷哪些生命週期回撥 冷啟動大致流程，涉及哪些元件，通訊過程是怎麼樣的？

Android外掛化架構 - Activity的啟動流程分析

1. 概述 Android外掛化架構，目前第三方的框架比較多，早幾年自己用的是DL框架，這個框架的原始碼比較簡單主要用的是靜態代理。如果我們自己要去寫一個外掛化架構框架那要解決的問題會分為幾個方面，類的載入，資源

第八節:Activiti6.0——啟動流程相關

一、概述 介紹：在啟動流程後，每個流程例項都會有執行流（儲存在act_ru_execution表中）。例項都有主執行流，沒有父id的執行流是流程例項，其後如果流程中有一個分支則有一個子執行流，分支和子執行流一一對應。對執

Hadoop原始碼篇 --- NameNode的啟動流程解析

前言 提醒一下，這裡面需要有RPC的基礎，如果對RPC沒有了解的朋友，可以先跳轉到以往寫的兩篇RPC文章中。

SpringBoot啟動流程原始碼分析(1)

SpringApplication例項化 springboot簡化spring的大量xml的配置檔案，為了實現統一化配置管理，一般引數配置

Eureka啟動流程-原始碼小段分析

本文參考自朱榮鑫老師的書《Spring Cloud微服務架構進階》，強烈建議閱讀本書。

Spring Boot啟動流程和自動配置原理

Java程式設計師應該都知道，每個Spring Boot都有一個啟動類，Spring Boot的啟動就是執行的該類的main方法。如下圖，main方法中就是執行SpringApplication.run方法。

Spring IOC 容器啟動流程分析

Spring IOC 容器啟動流程分析 使用 Spring 時，XML 和註解是使用得最多的兩種配置方式，雖然是兩種完全不同的配置方式，但對於 IOC 容器來說，兩種方式的不同主要是在 BeanDefinition 的解析上。而對於核心的容器啟

springboot自定義stater啟動流程

springboot啟動時自動載入application.properties或者application.yml，如何定義自己的配置讓springboot自動識別：

Spring Boot啟動流程斷點過程解析

這篇文章主要介紹了Spring Boot啟動流程斷點過程解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

springboot 基於Tomcat容器的自啟動流程分析

Springboot 內建了Tomcat的容器，我們今天來說一下Springboot的自啟動流程。 一、Spring通過註解匯入Bean大體可分為四種方式，我們主要來說以下Import的兩種實現方法：

Activiti如何啟動流程並使流程前進

一、流程和任務的關係 以下是一個簡單的請假流程圖，其中有一個開始事件，兩個使用者任務，一個結束事件。

SpringBoot應用啟動流程原始碼解析

前言 　　Springboot應用在啟動的時候分為兩步：首先生成 SpringApplication 物件 ，執行 SpringApplication 的 run 方法，下面一一看一下每一步具體都幹了什麼

Spring Boot -- 啟動流程分析二

我們總經常聽說Spring容器，那Spring容器到底是什麼，在介紹建立Spring應用程式上下文之前，我們先來聊一聊Spring容器到底是什麼。

Spring Boot -- 啟動流程分析之ApplicationContext 中

上一節我們已經分析到AbsractApplicationContext類refresh方法中的postProcessBeanFactory方法，在分析registerBeanPostProcessors之前我們先介紹一下Spring 的鉤子介面。

Tomcat啟動流程簡析

Tomcat是一款我們平時開發過程中最常用到的Servlet容器。本系列部落格會記錄Tomcat的整體架構、主要元件、IO執行緒模型、請求在Tomcat內部的流轉過程以及一些Tomcat調優的相關知識。