Android系統分析之Activity的啟動流程
1 參考連結
2 概念
Activity就是被用來進行與使用者互動和用來與android內部特性互動的元件,在應用程式中用到的所有activity都需要在manifest.xml檔案中進行註冊。那麼Activity又是怎樣一種元件,怎麼樣進行顯示互動的,一個activity例項是如何被管理和執行起來的,activity生命週期又是怎麼一回事?
3 Activity框架和管理結構
AcitivityManagerService是Activity系統服務核心管理類,是一個獨立的程序;
ActiveThread是每一個應用程式所在程序的主執行緒、入口函式,處理迴圈的訊息;
ActiveThread與AcitivityManagerService的通訊是屬於程序間通訊,使用binder機制;
(圖片來源:Android Activity學習筆記——Activity的啟動和建立)
4 Activity啟動過程
4.1 啟動流程
以啟動一個應用程式startActivity為例看一下程式碼執行的大概流程:
可將其分為6個過程:
(1)使用代理模式ActivityManagerNative.ActivityManagerProxy啟動到ActivityManagerService中執行;
(2)ActivityStack建立ActivityRecord到歷史記錄中;
(3)通過Zygote建立ApplicationProcess程序,通過start()啟動;
(4)通過ApplicatonThread與ActivityManagerService建立通訊;
(5) ActivityManagerService通知ActiveThread啟動Activity的建立;
(6)ActivityThread建立Activity加入到mActivities中並開始排程Activity執行;
4.2 詳細請看下圖
4.3 adnroid系統中四個重要概念:
ActivityManagerService(ActivityManagerNative)系統服務核心管理類,是一個獨立的程序;
ActivityStackSupervisor 管理整個手機任務棧;
ActivityStack Activity的棧(任務棧);
PackageManagerService(管理app的包的資訊:完成元件在清單裡的掃描和註冊);
ActivityThread 每一個應用程式所在程序的主執行緒、入口函式,處理迴圈的訊息。
5 核心原始碼分析(Android 7.0)
/**
* Activity
*/
public class Activity {
public void startActivity(Intent intent) {
this.startActivity(intent, null);//startActivity()
}
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);//startActivityForResult()
} else {
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
if (mParent == null) {
Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), ,
intent, requestCode, options); //Instrumentation.execStartActivity
}
}
}
/**
* Instrumentation
*/
public class Instrumentation {
public Instrumentation.ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, android.app.Activity target,
Intent intent, int requestCode, Bundle options) {
// ActivityManagerNative.getDefault().startActivity()
int result = ActivityManagerNative.getDefault().startActivity(whoThread, who.getBasePackageName(), intent, );
return null;
}
}
/**
* ActivityManagerNative
*/
public abstract class ActivityManagerNative extends Binder implements IActivityManager {
static public IActivityManager getDefault() {
return gDefault.get();
//相當於
IBinder b = ServiceManager.getService("activity");//ActivityManagerNative.getDefault() == ActivityManagerService
gDefault = asInterface(b);
}
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) {
switch (code) {
case START_ACTIVITY_TRANSACTION: {
int result = startActivity(app, callingPackage, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
reply.writeInt(result);
return true;
}
}
}
public class ActivityManagerProxy implements IActivityManager {
public int startActivity(IApplicationThread,,,,) { //ActivityManagerService.startActivity
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
return result;
}
}
}
/**
* ActivityManagerService 系統服務核心管理類
*/
public final class ActivityManagerService extends ActivityManagerNative implements BatteryStatsImpl.BatteryCallback {
public final int startActivity(IApplicationThread caller, String callingPackage, Intent intent,,,,) {
return startActivityAsUser(caller, callingPackage, intent, , , , ); //startActivityAsUser()
}
public final int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent,,,) {
return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent, , , );//ActivityStarter.startActivityMayWait()
}
//真正啟動程序
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,,,,,,,) {
return startProcessLocked(processName, info, knownToBeDead, , , , , );//startProcessLocked
}
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,,,,,) {
startProcessLocked();
}
startProcessLocked() {
debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI;//linux的Zygote程序
Process.ProcessStartResult startResult = Process.start(entryPoint, app.processName, , , , , , , );//啟動程序:Process.start
//接著與底層通訊
}
}
//Process
public class Process {
public static final ProcessStartResult start(final String processClass, final String niceName,,,,,,) {
return startViaZygote(processClass, niceName, , , , , , , , , ); //開始一個新的程序通過Zygote機制 startViaZygote()
}
}
/**
* ActivityStarter
*/
class ActivityStarter {
final int startActivityMayWait(IApplicationThread caller, int callingUid, String callingPackage, Intent intent,,,,,,) {
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId); //ActivityStackSupervisor.resolveIntent()
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);//ActivityStackSupervisor.resolveActivity
int res = startActivityLocked(caller, intent, ephemeralIntent, , , , , , , ); //ActivityStarter.startActivityLocked()
return res;
}
//驗證intent、Class、Permission等;儲存將要啟動的Activity的Record,例如:記錄Activity跳轉順序.
final int startActivityLocked(IApplicationThread caller, Intent intent,,,,,,) {
ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
requestCode, componentSpecified, voiceSession != null, mSupervisor, container,
options, sourceRecord);
err = startActivityUnchecked(r, sourceRecord, voiceSession, , startFlags, , , inTask);//startActivityUnchecked()
return err;
}
//檢查將要啟動的Activity的launchMode(啟動模式)和啟動Flag,根據launcheMode和Flag配置task.
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,, startFlags,, inTask) {
if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0 || mLaunchSingleInstance || mLaunchSingleTask) {
final ActivityRecord top = mReusedActivity.task.performClearTaskForReuseLocked(mStartActivity, mLaunchFlags);
if (top != null) {
if (top.frontOfTask) {
top.task.setIntent(mStartActivity);
}
ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, top.task);
top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);
}
}
//任務棧歷史棧配置
mTargetStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);//ActivityStack.startActivityLocked
}
}
/**
* ActivityStackSupervisor 管理整個手機任務棧(ActivityStack)
*/
public final class ActivityStackSupervisor {
//建構函式
public ActivityStackSupervisor(ActivityManagerService service) {
mHandler = new ActivityStackSupervisorHandler(mService.mHandler.getLooper());//ActivityStackSupervisorHandler()
}
private final class ActivityStackSupervisorHandler extends Handler {
void activityIdleInternal(ActivityRecord r) {
activityIdleInternalLocked(r != null ? r.appToken : null, true, null);//activityIdleInternalLocked()
}
}
final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,) {
if (activityRemoved) {
resumeFocusedStackTopActivityLocked();//esumeFocusedStackTopActivityLocked()
}
}
boolean resumeFocusedStackTopActivityLocked() {
return resumeFocusedStackTopActivityLocked(null, null, null);//resumeFocusedStackTopActivityLocked(,,)
}
boolean resumeFocusedStackTopActivityLocked(,,) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);//ActivityStack.resumeTopActivityUncheckedLocked()
return false;
}
ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags, ProfilerInfo profilerInfo, int userId) {
final ResolveInfo rInfo = resolveIntent(intent, resolvedType, userId);
return resolveActivity(intent, rInfo, startFlags, profilerInfo);
}
ResolveInfo resolveIntent(Intent intent, String resolvedType, int userId, int flags) {
try {
//AppGlobals
return AppGlobals.getPackageManager().resolveIntent(intent, , , userId);//PackageManagerService.resolveIntent()
} catch (RemoteException e) {
}
return null;
}
//啟動程序
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
ProcessRecord app = mService.getProcessRecordLocked(r.processName, r.info.applicationInfo.uid, true);
//真正啟動程序 (AMS)ActivityManagerService.startProcessLocked()
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true);
}
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
ActivityRecord hr = stack.topRunningActivityLocked();
if (hr.app == null && app.uid == hr.info.applicationInfo.uid && processName.equals(hr.processName)) {
if (realStartActivityLocked(hr, app, true, true)) {//realStartActivityLocked()
didSomething = true;
}
}
}
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) {
app.thread.scheduleLaunchActivity(new Intent(r.intent), , , , , , );//啟動activity:ActivityThread.scheduleLaunchActivity()
}
}
public class AppGlobals {
public static IPackageManager getPackageManager() { //IPackageManager 實現類似:PackageManagerService
return ActivityThread.getPackageManager(); //ActivityThread.getPackageManager()
}
}
/**
* PackageManagerService 管理app的包的資訊:完成元件在清單裡的掃描和註冊
*/
public class PackageManagerService extends IPackageManager.Stub {
//初始化時執行
public static PackageManagerService main(Context context, Installer installer, boolean factoryTest, boolean onlyCore) {
PackageManagerService m = new PackageManagerService(context, installer, factoryTest, onlyCore);
ServiceManager.addService("package", m); //ServiceManager新增服務
return m;
}
public ResolveInfo resolveIntent(Intent intent, String resolvedType, int flags, int userId) {
final ResolveInfo bestChoice = chooseBestActivity(intent, resolvedType, flags, query, userId); //chooseBestActivity()
return bestChoice;
}
private ResolveInfo chooseBestActivity(Intent intent, String resolvedType, int flags, List<ResolveInfo> query, int userId) {
if (query != null) {
final String intentPackage = intent.getPackage(); //包名
if (!TextUtils.isEmpty(intentPackage) && allHavePackage(query, intentPackage)) {
ri.resolvePackageName = intentPackage;
// .....
}
return ri;
}
}
public final void attachApplication(IApplicationThread thread) {
attachApplicationLocked(thread, callingPid);//attachApplicationLocked()
}
//附加到Application中
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
if (mStackSupervisor.attachApplicationLocked(app)) {//ActivityStackSupervisor.attachApplicationLocked()
didSomething = true;
}
}
// Find any services that should be running in this process...
if (!badApp) {
didSomething |= mServices.attachApplicationLocked(app, processName);
}
}
}
/**
* ActivityThread 安卓java應用層的入口函式類
*/
public final class ActivityThread {
public static IPackageManager getPackageManager() {
IBinder b = ServiceManager.getService("package"); //ServiceManager獲取服務
sPackageManager = IPackageManager.Stub.asInterface(b);
return sPackageManager;
}
public static void main(String[] args) {
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false); //attach()
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
}
private void attach(boolean system) {
final IActivityManager mgr = ActivityManagerNative.getDefault();
mgr.attachApplication(mAppThread); //ActivityManagerService.attachApplication()
}
//啟動Activity
public final void scheduleLaunchActivity(Intent intent,,,,) {
sendMessage(ActivityThread.H.LAUNCH_ACTIVITY, r);//LAUNCH_ACTIVITY
}
public void handleMessage(Message msg) {
case LAUNCH_ACTIVITY: {
final ActivityThread.ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY"); //handleLaunchActivity()
}
}
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
Activity a = performLaunchActivity(r, customIntent);//performLaunchActivity()
if (a != null) {
handleResumeActivity(r.token, , , , , , );
if (!r.activity.mFinished && r.startsNotResumed) {
performPauseActivityIfNeeded(r, reason);
}
} else {
ActivityManagerNative.getDefault().finishActivity(r.token, RESULT_CANCELED, null, , , );
}
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
}
//Activity啟動完成
}
/**
* ActivityStack Activity的棧(任務棧)
*/
final class ActivityStack {
//任務棧歷史棧配置
final void startActivityLocked(ActivityRecord r, boolean newTask, boolean keepCurTransition, ActivityOptions options) {
if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
insertTaskAtTop(rTask, r);
mWindowManager.moveTaskToTop(taskId);
}
ActivityRecord prev = r.task.topRunningActivityWithStartingWindowLocked();
}
//Pause過程暫時不分析
//確保活動堆疊頂部已恢復, 在ActivityStackSupervisor中呼叫
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
result = resumeTopActivityInnerLocked(prev, options);//resumeTopActivityInnerLocked()
return result;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
if (mResumedActivity != null) {
pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);//查詢要進入暫停的Activity
}
if (pausing) {
}
ActivityStack lastStack = mStackSupervisor.getLastStack();
//驗證該啟動的Activity所在程序和app是否存在,若存在,直接啟動
if (next.app != null && next.app.thread != null) {
mStackSupervisor.startSpecificActivityLocked(next, true, false);//ActivityStackSupervisor.startSpecificActivityLocked()
} else {//否則,準備建立該程序
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
}
}
相關推薦
Android系統分析之Activity的啟動流程
1 參考連結 2 概念 Activity就是被用來進行與使用者互動和用來與android內部特性互動的元件,在應用程式中用到的所有activity都需要在manifest.xml檔案中進行註冊。那麼Activity又是怎樣一種元件,怎麼樣進行顯示
(Android 9.0)Activity啟動流程原始碼分析
前言 熟悉Activity的啟動流程和執行原理是一個合格的應用開發人員所應該具備的基本素質,其重要程度就
Android之Activity啟動流程詳解(基於api28)
### 前言 Activity作為Android四大元件之一,他的啟動絕對沒有那麼簡單。這裡涉及到了系統服務程序,啟動過程細節很多,這裡我只展示主體流程。activity的啟動流程隨著版本的更替,程式碼細節一直在進行更改,每次都會有很大的修改,如android5.0 android8.0。我這裡的版本是基於
Android四大元件之Activity-啟動模式
1.Activity的啟動模式 當我們多次呼叫同一個Activity時,系統會重複建立多個例項並把它們一一放入任務棧中,這種方式顯然不符合我們的設計要求。所以Android在設計時就提供了四種啟動模式來解決此問題。 四種啟動模式分別如下: standard-標
Android系統分析之ThreadLocal
1 ThreadLocal操作示例 1.1 例子 public class MainActivity extends AppCompatActivity { private static final String TAG = "ThreadLoacalTest"; @
Android系統程序之Activity管理——ActivityManagerService(AMS)
一. 為什麼會有AMS 對於Android app開發人員來說,Activity是其打交道最多的元件了:App的每一個介面都對應於一個Activity。每個Activity都有他的生命週期(那幾個生命週期應該已經爛熟於心了吧),所以我們應該有一種機制來記錄並管理這些Acti
android6.0原始碼分析之Activity啟動過程
Activity最為android開發者最熟悉的元件,由ActivityManagerService服務進行排程管理,而ActivityManagerService的啟動過程在activitymanagerservice服務原始碼分析一文中進行了詳細分析,本文基
Android系統篇之----解讀AMS遠端服務呼叫機制以及Activity的啟動流程
一、為何本文不介紹Hook系統的AMS服務在之前一篇文章中已經講解了 Android中Hook系統服務,以及攔截具體方法的功能了,按照流程本文應該介紹如何Hook系統的AMS服務攔截應用的啟動流程操作,
Android View系統分析之三Activity的啟動與顯示
前言在Android View系統分析之從setContentView說開來(一)與Android View系統分析之二View與ViewGroup中我們已經簡單介紹了一個Activity的UI內容與檢視樹的組成關係,即View與ViewGroup組成了Activity的視覺
【Android】原始碼分析 - Activity啟動流程
啟動Activity的方式 Activity有2種啟動的方式,一種是在Launcher介面點選應用的圖示、另一種是在應用中通過Intent進行跳轉。我們主要介紹與後者相關的啟動流程。 Intent intent = new Intent(this, TestActivity
Android 外掛化分析(3)- Activity啟動流程
在真正分析外掛化技術前,我們必須瞭解一些必要的關於Android四大元件的相關知識。 以Activity為例,我們需要了解Activity啟動過程,才能有效的進行Hook實現外掛化。 以Android 8.1為例 我們啟動一個Activity通常會使用startActi
Activity啟動流程分析(基於android 5.1)
最近由於工作需要,需要深入瞭解AMS的內部實現。說老實話,雖然已經經過了幾輪重構,AMS的程式碼還是又臭又長。。。 萬事開頭難,先找個入口開始看吧。當從Launcher介面點選啟動一個app時,會啟動一個新的activity。所以就從startActivity()看起,研究
Android 元件Activity啟動流程分析
本篇相關流程分析基於Android4.4原始碼。 通常我們啟動一個Activity都是通過startActivity來完成。下面我們分析一下關鍵流程,本篇中以前應用的主執行緒ActivityThread為界限一分為二。 意圖啟動 首先我們使用上下文物件來
Android OTA升級原理和流程分析(三)---Android系統的三種啟動模式
以下的篇幅開始分析我們在上兩個篇幅中生成的update.zip包在具體更新中所經過的過程,並根據原始碼分析每一部分的工作原理。 一、 系統更新update.zip包的兩種方式 1. 通過上一個文件,我們知道了怎樣製作一個updat
Android Activity啟動流程分析
概述 Activity作為Android的四大元件之一,Android主要的介面組成部分,用於直接跟使用者進行互動操作,在面試中與Activity相關的知識也是經常被問到,如果你面試的高階崗位,那麼對Activity的啟動和繪製流程就必須的熟悉,本文將從Act
Android Activity啟動流程(基於Android8.0系統)
主要物件介紹 ActivityManagerService:負責系統中所有Activity的生命週期; Activi
【系統之音】Activity啟動流程——史上最全最簡潔易懂版
Activity的啟動流程是一個資深Android工程師必須掌握的內容,也是高職級面試中的高頻面試知識點,無論是從事應用層開發,還是Framework開發,其重要性都無需我多言。而要真正理解它,就不可避免地要深入到原始碼了,本文將從Android8.1系
【系統之音】Activity啟動流程剖析——史上最全最簡潔易懂版
Activity的啟動流程是一個資深Android工程師必須掌握的內容,也是高職級面試中的高頻面試知識點,無論是從事應用層開發,還是Framework開發,其重要性都無需我多言。而要真正理解它,就不可避免地要深入到原始碼了,本文將從Android8.1系
Android中system server程序啟動流程原始碼解析 系統服務啟動
system server 前言 System Server fork SystemServer SystemServer.main() SystemServer.createSystemContext SystemSe
Android 元件系列 -- Activity 啟動流程(9.0)
在學習完Android應用程式啟動過程原始碼分析,針對最新Android9.0的程式碼,以相應的順序再次學習。在9.0的版本中對於Activity的啟動流程上並沒有太大的變化,但是在程式碼層面,改動的卻很多。 流程概覽 以Launcher啟動APP為例: Lau