Android系统四大组件源代码情景分析之Activity

于 2018-11-11 20:13:24 发布
阅读量231 收藏
点赞数
分类专栏： Android 文章标签： Android 四大组件 Activity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litao55555/article/details/83961774
版权

1. Activity的生命周期

在这里插入图片描述

生命周期方法作用说明
onCreate表示 Activity 正在被创建activity 被创建时调用，一般在这个方法中进行活动的初始化工作，如设置布局工作、加载数据、绑定控件等。
onRestart表示 Activity 正在重新启动这个回调代表了 Activity 由完全不可见重新变为可见的过程，当 Activity 经历了 onStop() 回调变为完全不可见后，如果用户返回原 Activity，便会触发该回调，并且紧接着会触发 onStart() 来使活动重新可见。
onStart表示 Activity 正在被启动经历该回调后，Activity 由不可见变为可见，但此时处于后台可见，还不能和用户进行交互。
onResume表示 Activity 已经可见已经可见的 Activity 从后台来到前台，可以和用户进行交互。
onPause表示 Activity 正在停止当用户启动了新的 Activity ，原来的 Activity 不再处于前台，也无法与用户进行交互，并且紧接着就会调用 onStop() 方法，但如果用户这时立刻按返回键回到原 Activity ，就会调用 onResume() 方法让活动重新回到前台。而且在官方文档中给出了说明，不允许在 onPause() 方法中执行耗时操作，因为这会影响到新 Activity 的启动。
onStop表示 Activity 即将停止这个回调代表了 Activity 由可见变为完全不可见，在这里可以进行一些稍微重量级的操作。需要注意的是，处于 onPause() 和 onStop() 回调后的 Activity 优先级很低，当有优先级更高的应用需要内存时，该应用就会被杀死，那么当再次返回原 Activity 的时候，会重新调用 Activity 的onCreate()方法。
onDestroy表示 Activity 即将被销毁来到了这个回调，说明 Activity 即将被销毁，应该将资源的回收和释放工作在该方法中执行。

1.1 按back键

第一次打开应用：onCreate -> onStart -> onResume
按 back 键退出：onPause -> onStop -> onDestroy

1.2 按 home 键

按home键退出：onPause() -> onStop()
按home键后回到应用：onRestart() -> onStart() -> onResume()

1.3 按电源键

按电源键息屏：onPause() -> onStop()
按电源键亮屏：onRestart() -> onStart() -> onResume()

1.4 A、B两个Activity的跳转

a. 第一个Activity启动第二个Activity时:
第一个Activity onPause() -> 第二个Activity onCreate() -> onStart() -> onResume() -> 第一个Activity onStop()
b. 当返回到第一个Activity时：
第二个Activity onPause() -> 第一个Activity onRestart() -> onStart() -> onResume() -> 第二个Activity onStop() -> onDestroy()

1.5 横竖屏切换

c. 横竖屏切换时候Activity的生命周期
c.1 不设置Activity的android:configChanges时
横屏时：销毁并重启onPause - onStop - onDestroy — onCreate - onStart - onResume
竖屏时：销毁并重启2次 onPause - onStop - onDestroy — onCreate - onStart - onResume — onPause - onStop - onDestroy — onCreate - onStart - onResume
c.2 设置Activity的android:configChanges="orientation"时
横屏时：销毁并重启onPause - onStop - onDestroy — onCreate - onStart - onResume
竖屏时：销毁并重启onPause - onStop - onDestroy — onCreate - onStart - onResume
d. onStart()和onResume()的区别
onStart()是activity界面被显示出来的时候执行的 //用户可见，包括有一个activity在他上面，但没有将它完全覆盖，用户可以看到部分activity但不能与它交互
onResume()是当该activity与用户能进行交互时被执行 //用户可以获得activity的焦点，能够与用户交互
Activity生命周期小结：
新活动不完全遮挡就活动：onPause -> onResume
新活动完全遮挡就活动 ：onPause -> onStop -> onRestart -> onStart -> onResume
资源被回收：onCreate -> onStart -> onResume

2. Activity生命周期调用流程源代码分析

public class ReadFile extends AppCompatActivity {		//AppCompatActivity最开始的父类为Activity
	...
	Intent intent = new Intent(ReadFile.this, ActivityNew.class);
	startActivity(intent);
}

//frameworks\base\core\java\android\app\Activity.java：
public class Activity extends ContextThemeWrapper
        implements LayoutInflater.Factory2,
        Window.Callback, KeyEvent.Callback,
        OnCreateContextMenuListener, ComponentCallbacks2,
        Window.OnWindowDismissedCallback {
    ...
    public void startActivity(Intent intent) {
        this.startActivity(intent, null);
    }
    public void startActivity(Intent intent, @Nullable Bundle options) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            startActivityForResult(intent, -1);
        }
    }
    public void startActivityForResult(Intent intent, int requestCode) {
        startActivityForResult(intent, requestCode, null);
    }
    public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
		...
		if (mParent == null) {
		Instrumentation.ActivityResult ar =
			mInstrumentation.execStartActivity(
				this, mMainThread.getApplicationThread(), mToken, this,
				intent, requestCode, options);
		}
    }
}

//frameworks\base\core\java\android\app\Instrumentation.java
public class Instrumentation {
public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
	...
	int result = ActivityManagerNative.getDefault()		//gDefault是一种代理模式，返回的是代理类ActivityManagerProxy
			.startActivity(whoThread, who.getBasePackageName(), intent,
					intent.resolveTypeIfNeeded(who.getContentResolver()),
					token, target != null ? target.mEmbeddedID : null,
					requestCode, 0, null, options);
}

frameworks\base\core\java\android\app\ActivityManagerNative.java：
class ActivityManagerProxy implements IActivityManager
{
	...
	public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
		String resolvedType, IBinder resultTo, String resultWho, int requestCode,
		int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
    	...
    	mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
    }
}

		||
		\/Binder通信

//frameworks\base\core\java\android\app\ActivityManagerNative.java：
public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
	...
	public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
		throws RemoteException {
			switch (code) {
        case START_ACTIVITY_TRANSACTION:
        {
            ...
            int result = startActivity(app, callingPackage, intent, resolvedType,
                    resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
        }
    }
}

frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java：
public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
	...
	public final int startActivity(IApplicationThread caller, String callingPackage,
		Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
		int startFlags, ProfilerInfo profilerInfo, Bundle options) {
        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, options,
            UserHandle.getCallingUserId());
    }
    public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {
        enforceNotIsolatedCaller("startActivity");		//检查调用者是否属于被隔离的对象
        userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,		//判断调用者是否有权利执行这一操作
                false, ALLOW_FULL_ONLY, "startActivity", null);
        // TODO: Switch to user app stacks here.
        return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,		//核心
                resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
                profilerInfo, null, null, options, userId, null, null);
    }
}

frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java:
public final class ActivityStackSupervisor implements DisplayListener {
	...
    final int startActivityMayWait(IApplicationThread caller, int callingUid,
		String callingPackage, Intent intent, String resolvedType,
		IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
		IBinder resultTo, String resultWho, int requestCode, int startFlags,
		ProfilerInfo profilerInfo, WaitResult outResult, Configuration config,
		Bundle options, int userId, IActivityContainer iContainer, TaskRecord inTask) {
			...
			int res = startActivityLocked(caller, intent, resolvedType, aInfo,
				voiceSession, voiceInteractor, resultTo, resultWho,
				requestCode, callingPid, callingUid, callingPackage,
				realCallingPid, realCallingUid, startFlags, options,
				componentSpecified, null, container, inTask);
	}

	final int startActivityLocked(IApplicationThread caller,
		Intent intent, String resolvedType, ActivityInfo aInfo,
		IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
		IBinder resultTo, String resultWho, int requestCode,
		int callingPid, int callingUid, String callingPackage,
		int realCallingPid, int realCallingUid, int startFlags, Bundle options,
		boolean componentSpecified, ActivityRecord[] outActivity, ActivityContainer container,
		TaskRecord inTask) {
		...
		err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
			startFlags, true, options, inTask);
	}

	final int startActivityUncheckedLocked(ActivityRecord r, ActivityRecord sourceRecord,
		IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags,
		boolean doResume, Bundle options, TaskRecord inTask) {
		...
		targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);		-----------------------------------------------		//函数的最后面几行
	}
}

frameworks\base\services\core\java\com\android\server\am\ActivityStack.java：
final class ActivityStack {
	...
	/*此函数的详细分析请参考SourceInsight的源码*/
	final void startActivityLocked(ActivityRecord r, boolean newTask,
		boolean doResume, boolean keepCurTransition, Bundle options) {
			...
			mWindowManager.addAppToken(...);	//WMS.java中执行atoken = new AppWindowToken(this, token, voiceInteraction);创建一个AppWindowToken对象
			mWindowManager.setAppStartingWindow(...);		//为正在启动的Activity组件设置一个启动窗口，分析参考：6. WMS显示Activity组件的启动窗口的过程分析
			mStackSupervisor.resumeTopActivitiesLocked(this, r, options);		---------------------------------------		//字面意思：启动最上面的Activity
	}
}

frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java:
public final class ActivityStackSupervisor implements DisplayListener {
	...
	boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
		Bundle targetOptions) {
        if (targetStack == null) {
            targetStack = getFocusedStack();
        }
        // Do targetStack first.
        boolean result = false;
        if (isFrontStack(targetStack)) {	//如果ActivityStack不为空
            result = targetStack.resumeTopActivityLocked(target, targetOptions);
        }
        for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
            final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
            for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
                final ActivityStack stack = stacks.get(stackNdx);
                if (stack == targetStack) {
                    // Already started above.
                    continue;
                }
                if (isFrontStack(stack)) {
                    stack.resumeTopActivityLocked(null);
				}
			}
		}
		return result;
	}
}

frameworks\base\services\core\java\com\android\server\am\ActivityStack.java：
final class ActivityStack {
		...
		final boolean resumeTopActivityLocked(ActivityRecord prev) {
        return resumeTopActivityLocked(prev, null);
    }
    final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
        ...
        result = resumeTopActivityInnerLocked(prev, options);
        return result;
    }

    final boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
		...
		ActivityRecord next = topRunningActivityLocked(null);		//1. 从mHistory中逐一取出ActivityRecord（取出下一个准备运行的Activity）	-------------->android类专题：3
		if (next == null) {		//如果next为空，则启动Launcher主界面（即无论何时android系统都会有运行的activity，默认为Launcher）												 ActivityRecord对象是Activity组件启动的过程中创建的，用来描述Activity组件的运行状态
			...
			return isOnHomeDisplay() &&  mStackSupervisor.resumeHomeStackTask(returnTaskType, prev);
		}
        if (mResumedActivity == next && next.state == ActivityState.RESUMED &&		//2. 判断当前正在运行的activity(mResumedActivity)是否就是目标对象(next)，如果是则返回false表明不需要重复启动
                    mStackSupervisor.allResumedActivitiesComplete()) {
            ...
            // Make sure to notify Keyguard as well if it is waiting for an activity to be drawn.
            mStackSupervisor.notifyActivityDrawnForKeyguard();
            return false;
        }
		if (mService.isSleepingOrShuttingDown()		//3. 如果目标Activity正在stopping，那么就要终止这一操作
		&& mLastPausedActivity == next
		&& mStackSupervisor.allPausedActivitiesComplete()) {
			...
			ActivityOptions.abort(options);
		}
    	...
    	if (mResumedActivity != null) {		//4. 如果当前正在运行的activity(mResumedActivity)不为空，那么需要执行pause操作，终止正在运行的Activity
            pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);	//执行pause操作，以终止前一个Activity
            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Pausing " + mResumedActivity);
		}
        ...
        if (prev != null && prev != next) {	//5. 如果上一个Activity不为空且不等于下一个Activity
            if (!prev.waitingVisible && next != null && !next.nowVisible) {	//5.1 如果即将启动的Activity不是可见的(!next.nowVisible)
                prev.waitingVisible = true;
                mStackSupervisor.mWaitingVisibleActivities.add(prev);	//将不可见的Activity添加到mWaitingVisibleActivities（即将上一个Activity添加到等待可见的Activity队列中）
                if (DEBUG_SWITCH) Slog.v(
					TAG, "Resuming top, waiting visible to hide: " + prev);
            } else {		//5.2 如果即将启动的Activity可见
				...
				mWindowManager.setAppVisibility(prev.appToken, false);	//隐藏前一个Activity，为下一个即将启动的Activity做准备
            }
        }
        if (prev != null) {		//6. 如果上一个Activity不为空且已经停止
            if (prev.finishing) {
				...
				mWindowManager.setAppWillBeHidden(prev.appToken);		//在启动新的Activity之前，通知WMS前一个Activity即将被隐藏
			}
        }
        ...
        if (next.app != null && next.app.thread != null) {		//7.1 若即将启动的Activity的承载进程已经启动
			...
			mWindowManager.setAppVisibility(next.appToken, true);	//通知WMS这个Activity已经具备了显示条件
			...
			next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,		//告知目标线程要Resume指定的Activity，最终执行onResume，第1857行
				mService.isNextTransitionForward(), resumeAnimOptions);
				mWindowManager.setAppStartingWindow(		//添加启动窗口（参考内核分析的P434）
					next.appToken, next.packageName, next.theme,
					mService.compatibilityInfoForPackageLocked(next.info.applicationInfo),
					next.nonLocalizedLabel, next.labelRes, next.icon, next.logo,
					next.windowFlags, null, true);
				...
			} else {		//7.2 若即将启动的Activity的承载进程没有启动（重点：由此可看出，当执行startactivity时，最终会执行onCreate -> onStart -> onResume）
				...
				mStackSupervisor.startSpecificActivityLocked(next, true, true);		//最终会执行onCreate -> onStart -> onResume
			}
		}
	}
}

如果承载目标Activity进程的Activity已经启动，则会直接调用scheduleResumeActivity，此函数会会执行Activity生命周期：onResume
如果承载目标Activity进程的Activity没有启动，则会调用startSpecificActivityLocked，最终会执行Activity生命周期：onCreate -> onStart -> onResume

frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java：
public final class ActivityStackSupervisor implements DisplayListener {
	...
	void startSpecificActivityLocked(ActivityRecord r,
		boolean andResume, boolean checkConfig) {
		...
		mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
		"activity", r.intent.getComponent(), false, false, true);
	}
}

frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java：
public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
	...
    final ProcessRecord startProcessLocked(String processName,
            ApplicationInfo info, boolean knownToBeDead, int intentFlags,
            String hostingType, ComponentName hostingName, boolean allowWhileBooting,
            boolean isolated, boolean keepIfLarge) {
        return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
                hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
                null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
                null /* crashHandler */);
    }
    final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
            boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
            boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
            String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
        startProcessLocked(app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
    }
    private final void startProcessLocked(ProcessRecord app, String hostingType,
            String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
        ...
        //--------------------------------------------------------------------------------------------------------------------------------调用zygote启动一个新进程
        if (entryPoint == null) entryPoint = "android.app.ActivityThread";
			Process.ProcessStartResult startResult = Process.start(entryPoint,		//启动android.app.ActivityThread进程，分析到3192行
				app.processName, uid, uid, gids, debugFlags, mountExternal,
				app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
				app.info.dataDir, entryPointArgs);
		}
}

frameworks\base\core\java\android\app\ActivityThread.java:
public final class ActivityThread {
	...
	public static void main(String[] args) {
		...
		Looper.prepareMainLooper();		//新建UI主线程的Looper对象，分析参考内核分析P147
		ActivityThread thread = new ActivityThread();		//创建UI主线程ActivityThread的实例化对象
        thread.attach(false);
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();  //新建UI主线程的Handler对象
        }
	}

	private void attach(boolean system) {
		...
		final IActivityManager mgr = ActivityManagerNative.getDefault();	//return gDefault.get();	gDefault是一种代理模式，返回的是代理类ActivityManagerProxy
        try {
            mgr.attachApplication(mAppThread);
        } catch (RemoteException ex) {
            // Ignore
        }
    }
}

frameworks\base\core\java\android\app\IActivityManager.java:
public interface IActivityManager extends IInterface {
	...
	public void attachApplication(IApplicationThread app) throws RemoteException;
}

Ctrl+/搜索attachApplication找到：

frameworks\base\core\java\android\app\ActivityManagerNative.java：
class ActivityManagerProxy implements IActivityManager
{
	...
    public void attachApplication(IApplicationThread app) throws RemoteException
    {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(app.asBinder());
        mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
        reply.readException();
		data.recycle();
        reply.recycle();
    }
}
		||	binder
		\/
ctrl+/搜索ATTACH_APPLICATION_TRANSACTION找到：
frameworks\base\core\java\android\app\ActivityManagerNative.java：
public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
	public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
		throws RemoteException {
	switch (code) {
					...
			case ATTACH_APPLICATION_TRANSACTION: {
				data.enforceInterface(IActivityManager.descriptor);
				IApplicationThread app = ApplicationThreadNative.asInterface(
						data.readStrongBinder());
				if (app != null) {
					attachApplication(app);
				}
				reply.writeNoException();
				return true;
			}
		}
	}
}

frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java:
public final class ActivityManagerService extends ActivityManagerNative
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    @Override
    public final void attachApplication(IApplicationThread thread) {
        synchronized (this) {
            int callingPid = Binder.getCallingPid();
            final long origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread, callingPid);
            Binder.restoreCallingIdentity(origId);
        }
    }

    private final boolean attachApplicationLocked(IApplicationThread thread,
        int pid) {
    		...
    		if (normalMode) {
            try {
                if (mStackSupervisor.attachApplicationLocked(app)) {		//最终会调用onCreate、onStart、onResume
                    didSomething = true;
                }
            } catch (Exception e) {
                ...
            }
        }
    }
}

frameworks\base\services\core\java\com\android\server\am\ActivityStackSupervisor.java：
public final class ActivityStackSupervisor implements DisplayListener {
	...
   	boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {		//第511行
		...
		ActivityRecord hr = stack.topRunningActivityLocked(null);
        if (hr != null) {
            if (hr.app == null && app.uid == hr.info.applicationInfo.uid
                    && processName.equals(hr.processName)) {
                try {
                    if (realStartActivityLocked(hr, app, true, true)) {		//启动Activity，即onCreate -> onStart -> onResume
                        didSomething = true;
                    }
                } catch (RemoteException e) {
                    ...
                }
			}
		}
	}
    final boolean realStartActivityLocked(ActivityRecord r,
            ProcessRecord app, boolean andResume, boolean checkConfig)
            throws RemoteException {
        ...
        app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                r.compat, r.task.voiceInteractor, app.repProcState, r.icicle, r.persistentState,
                results, newIntents, !andResume, mService.isNextTransitionForward(),
                profilerInfo);
    }
}

frameworks\base\core\java\android\app\IApplicationThread.java：
public interface IApplicationThread extends IInterface {
	...
    void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
            ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
            IVoiceInteractor voiceInteractor, int procState, Bundle state,
            PersistableBundle persistentState, List<ResultInfo> pendingResults,
            List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,
            ProfilerInfo profilerInfo) throws RemoteException;
}

frameworks\base\core\java\android\app\ApplicationThreadNative.java:
class ApplicationThreadProxy implements IApplicationThread {
	...
    public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
            ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
            IVoiceInteractor voiceInteractor, int procState, Bundle state,
            PersistableBundle persistentState, List<ResultInfo> pendingResults,
            List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,
            ProfilerInfo profilerInfo) throws RemoteException {
        Parcel data = Parcel.obtain();
        ...
        mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
                IBinder.FLAG_ONEWAY);
        data.recycle();
    }
}
					||binder
					\/
ActivityStackSupervisor.realStartActivityLocked：通过Binder驱动进入到ApplicationThread的scheduleLaunchActivity函数。
做完这些工作，AMS通过Binder调用ApplicationThread（是个Binder对象）的scheduleLaunchActivity . ApplicationThread通过消息机制控制Activity生命周期。

frameworks\base\core\java\android\app\ApplicationThreadNative.java:
public abstract class ApplicationThreadNative extends Binder
        implements IApplicationThread {
		...
    @Override
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
			...
			case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:
			{
				...
				scheduleLaunchActivity(intent, b, ident, info, curConfig, compatInfo, voiceInteractor,
						procState, state, persistentState, ri, pi, notResumed, isForward, profilerInfo);
				return true;
			}
			case SCHEDULE_PAUSE_ACTIVITY_TRANSACTION:			//暂停Activity
					...
			case SCHEDULE_STOP_ACTIVITY_TRANSACTION:		  //停止Activity
					...
			}
		}
}

frameworks\base\core\java\android\app\ActivityThread.java：
public final class ActivityThread {
	...
    private class ApplicationThread extends ApplicationThreadNative {
    		...
        public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
                ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
                IVoiceInteractor voiceInteractor, int procState, Bundle state,
                PersistableBundle persistentState, List<ResultInfo> pendingResults,
                List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,
                ProfilerInfo profilerInfo) {
			...
			ActivityClientRecord r = new ActivityClientRecord();
            updateProcessState(procState, false);
            sendMessage(H.LAUNCH_ACTIVITY, r);	//通过消息机制控制Activity生命周期
        }
    }
}

frameworks\base\core\java\android\app\ActivityThread.java：
public final class ActivityThread {
	...
    private class H extends Handler {
		...
		public void handleMessage(Message msg) {
			switch (msg.what) {
				case LAUNCH_ACTIVITY: {
					Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
					final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

					r.packageInfo = getPackageInfoNoCheck(
							r.activityInfo.applicationInfo, r.compatInfo);
					handleLaunchActivity(r, null);
					Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
				} break;
				...
			}
		}
	}
    private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
		...
		Activity a = performLaunchActivity(r, customIntent);		//最终调用onCreate和onStart
		...
		handleResumeActivity(r.token, false, r.isForward,				//最终调用onResume
				!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
    }
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    	...
        if (r.isPersistable()) {
			...
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);		//调用onCreate，第2249行
        }
        if (!r.activity.mFinished) {
            activity.performStart();   										//调用onStart，第2261行
        }
    }
}

最终会调用：
a. performLaunchActivity 最终调用onCreate和onStart
b. handleResumeActivity 最终调用onResume

frameworks\base\core\java\android\app\Instrumentation.java:
public class Instrumentation {
	...
    public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
        activity.performCreate(icicle);
        postPerformCreate(activity);
    }
}

frameworks\base\core\java\android\app\Activity.java:
public class Activity extends ContextThemeWrapper
        implements LayoutInflater.Factory2,
        Window.Callback, KeyEvent.Callback,
        OnCreateContextMenuListener, ComponentCallbacks2,
        Window.OnWindowDismissedCallback {
	...
    final void performCreate(Bundle icicle) {
        onCreate(icicle);			//终于调用onCreate函数了
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
    }
    final void performStart() {
		...
		mInstrumentation.callActivityOnStart(this);
    }
}

frameworks\base\core\java\android\app\Instrumentation.java:
public class Instrumentation {
		...
		public void callActivityOnStart(Activity activity) {
        activity.onStart();		//终于调用了onStart函数了
    }
}

3. Activity生命周期总结

IPC调用AMS.startActivity()，最终调用ActivityStack.resumeTopActivityInnerLocked启动Activity，在此方法中分别执行
a. 如果承载目标Activity进程的Activity已经启动
执行scheduleResumeActivity，最终执行Activity的生命周期：onResume
b. 如果承载目标Activity进程的Activity没有启动
执行startSpecificActivityLocked，执行Process.start(…)启动承载目标Activity的进程，接着分别执行
b.1 ActivityThread.performLaunchActivity，最终执行Activity的生命周期：onCreate -> onStart
b.2 ActivityThread.handleResumeActivity，最终执行Activity的生命周期：onResume

Activity启动流程如下：

startActivity(intent);
	ActivityManagerNative.getDefault().startActivity		//getDefault返回的是代理类ActivityManagerProxy
			||Binder
			\/
		AMS.startActivity			//为什么会调用AMS的startActivity：定义startActivity为虚函数是为了允许用基类的指针来调用子类的这个函数
			ActivityStack.startActivityLocked
				WMS.addAppToken				//1. 创建一个AppWindowToken对象
				WMS.setAppStartingWindow	//2. 为正在启动的Activity组件设置一个启动窗口
				ActivityStackSupervisor.resumeTopActivitiesLocked
					//3. 从mHistory中逐一取出ActivityRecord（取出下一个准备运行的Activity）
					ActivityRecord next = topRunningActivityLocked(null);
					//4. 若即将启动的Activity的承载进程已经启动
					next.app.thread.scheduleResumeActivity			//执行onResume
					//5. 若即将启动的Activity的承载进程没有启动
					ActivityStackSupervisor.startSpecificActivityLocked
						ActivityThread.performLaunchActivity		//执行onCreate -> onStart
							SetContentView创建DecorView（DecorView = ContentView（用户需要显示的组件） + 系统其它组件）
						ActivityThread.handleResumeActivity			//执行onResume
							WindowManager.addView
								WindowManagerImpl.addView	 （将DecorView保存到WindowManagerImpl.mViews，将ViewRootImpl保存到mRoots）
									ViewRootImpl.setView		 （将DecorView保存到ViewRootImpl.mView）//------------------------------1. ViewTree的创建过程
										WMS.addWindow 	//添加窗口
										WMS.addWindowToListInOrderLocked(new WindowState());		//将系统中当前所有窗口进行排列
										WMS.assignLayersLocked 		//计算系统中所有窗口的Z轴位置		//------------------------------2. Activity窗口的添加过程
暖阳55555
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值