Activity详解

什么是Activity
Activity是一个Android的利用组件，它提供屏幕进行交互。每个Activity都会取得一个用于绘制其用户界面的窗口，窗口能够充斥哦屏幕也能够小于屏幕并浮动在其余窗口之上。

一个利用通常是由多个彼此涣散分割的Activity组成，个别会指定利用中的某个Activity为主流动，也就是说首次启动利用时给用户出现的Activity。将Activity设为主流动的办法，如上面代码所示须要在AndroidManifest文件中增加以下内容

<application>     ....    <activity android:name=".MainActivity">            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>     </activity>     ....</application>

当然Activity之间能够进行相互跳转，以便执行不同的操作。每当新Activity启动时，旧的Activity便会进行，然而零碎会在堆栈也就是返回栈中保留该Activity。当新Activity启动时，零碎也会将其推送到返回栈上，并获得用户的操作焦点。当用户实现以后Activity并按返回按钮是，零碎就会从堆栈将其弹出销毁，而后回复前一Activity

当一个Activity因某个新Activity启动而进行时，零碎会通过该Activity的生命周期回调办法告诉其这一状态的变动。Activity因状态变动每个变动可能有若干种，每一种回调都会提供执行与该状态相应的特定操作的机会

Activity 对象的创立

Activity 的启动是一个跨过程通信的过程，对客户端而言，Activity 的创立会回调到ActivityThread 中的 handleLaunchActivity() 办法：

_frameworks/base/core/java/android/app/ActivityThread.java_:

@Overridepublic Activity handleLaunchActivity(ActivityClientRecord r,      PendingTransactionActions pendingActions, Intent customIntent){  ···  final Activity a = performLaunchActivity(r, customIntent);  ···  return a;}

接着在 performLaunchActivity() 办法里找到了 Acitivity 实例的创立：

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {    ···    ContextImpl appContext = createBaseContextForActivity(r);    Activity activity = null;    try {      // 注解1：通过 ClassLoader 以及指标 Activity 的类名来创立新的 Activity 实例        java.lang.ClassLoader cl = appContext.getClassLoader();      activity = mInstrumentation.newActivity(             cl, component.getClassName(), r.intent);      ···    } ···}

Activity 相干的创立工作交由给了 Instrumentation 类解决：

_frameworks/base/core/java/android/app/Instrumentation.java_:

public Activity newActivity(ClassLoader cl, String className,      Intent intent)      throws InstantiationException, IllegalAccessException,      ClassNotFoundException {  String pkg = intent != null && intent.getComponent() != null              ? intent.getComponent().getPackageName() : null;  return getFactory(pkg).instantiateActivity(cl, className, intent);}

最终的创立工作由进一步交由工厂类 AppComponentFactory 实现：

_frameworks/base/core/java/android/app/AppComponentFactory.java_:

public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,      @Nullable Intent intent)      throws InstantiationException, IllegalAccessException, ClassNotFoundException {  return (Activity) cl.loadClass(className).newInstance();}

到这里，Activity 对象的创立过程曾经很清晰了：通过 ClassLoader 对象以及类名获取到指标 Activity 的 Class 对象， 再调用 Class 对象的 ****newInstance() 办法创立了实例。

用图形关系示意如下：

Activity 对象的援用关系

在分明了 Activity 对象的创立过程后，让咱们回到一开始的 ActivityThread 的performLaunchActivity() 办法中，接着往下看：

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {  ···   ContextImpl appContext = createBaseContextForActivity(r);   Activity activity = null;   ···  try {    Application app = r.packageInfo.makeApplication(false, mInstrumentation);    ···    if (activity != null) {      ···        activity.attach(appContext, this, getInstrumentation(), r.token,          r.ident, app, r.intent, r.activityInfo, title, r.parent,             r.embeddedID, r.lastNonConfigurationInstances, config,          r.referrer, r.voiceInteractor, window, r.configCallback,             r.assistToken);       ···        // 注解2：ActivityClientRecord 对象持有 Activity 实例的援用      r.activity = activity;     }      r.setState(ON_CREATE);    // 注解3：将 ActivityClientRecord 对象增加到 mActivities 汇合中    synchronized (mResourcesManager) {       mActivities.put(r.token, r);    }  } ···  return activity;}

在这里，咱们仿佛找到了想要的答案：

新建的 Activity 对象会被传进来的 ActivityClientRecord 对象所持有，接着该 ActivityClientRecord 对象会被增加到一个名为 mActivities 的汇合当中所持有。

ActivityClientRecord 是 ActivityThread 的一个动态外部类，用于记录 Activity 相干的信息。其对象的创立过程能够在 LaunchActivityItem 类（Api 28 之后）中找到：

_frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java_:

@Overridepublic 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, mAssistToken);   client.handleLaunchActivity(r, pendingActions, null /* customIntent */);   Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);}

再来看一下这个 mActivities 汇合：

frameworks/base/core/java/android/app/ActivityThread.java:

···final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();···

mActivities 是一个 map 汇合，为 ActivityThread 对象的一个成员变量。既然是一个汇合，天然也能够在 Activity 销毁办法回调中找到移除汇合内元素的操作：

/** Core implementation of activity destroy call. */ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,     int configChanges, boolean getNonConfigInstance, String reason){  ActivityClientRecord r = mActivities.get(token);  ···  synchronized (mResourcesManager) {    mActivities.remove(token);  }  StrictMode.decrementExpectedActivityCount(activityClass);  return r;}

图形关系示意如下：

既然 Activity 的对象是间接被 ActivityThread 对象所持有援用，那么该 ActivityThread 对象理当是单例的模式存在，那么该单例 ActivityThread 对象又是如何被创立以及持有的呢？

ActivityThread 对象的创立

一个新的利用过程创立时，会调用 ActivityThread 的动态主办法 main()，在这里，咱们找到了答案：

_frameworks/base/core/java/android/app/ActivityThread.java_:

···// 注解 4：动态的 ActivityThread 成员变量，用于实现单例private static volatile ActivityThread sCurrentActivityThread;···// 注解 5: ActivityThread 的主办法入口，由 RuntimeInit 调用public static void main(String[] args) {    ···    Looper.prepareMainLooper();    ···    // 注解 6: 新建一个 ActivityThread 对象    ActivityThread thread = new ActivityThread();    thread.attach(false, startSeq);    ···    Looper.loop();    throw new RuntimeException("Main thread loop unexpectedly exited");}···private void attach(boolean system, long startSeq) {    // 注解 7: ActivityThread 对象由动态成员变量所援用    sCurrentActivityThread = this;    mSystemThread = system;    if (!system) {        android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",                                                UserHandle.myUserId());        RuntimeInit.setApplicationObject(mAppThread.asBinder());        final IActivityManager mgr = ActivityManager.getService();        try {            mgr.attachApplication(mAppThread, startSeq);        } catch (RemoteException ex) {            throw ex.rethrowFromSystemServer();        }        ···    } ···}

由下面的代码可知，一个新的利用过程创立时，main() 办法里新建一个 ActivityThread 对象赋予给 ActivityThread 类的一个动态成员变量 sCurrentActivityThread，从而造成一个利用过程对应一个 ActivityThread 对象（单例） 的关系。

总结

每一个新启动的 Activity，其对象实例通过 Class 类的 newInstance 办法创立后，被包裹在一个 ActivityClientRecord 对象中而后增加到过程惟一的 ActivityThread 对象的成员变量 mActivitys 里。换言之，Activity 对象的持有和开释都是由 ActivityThread 来治理的。

最初，笔者想额定重申：

  • 源码中，Activity 对象会在多个办法都有传递关系，比较复杂，笔者满腹经纶，可能会漏掉一些别的重要的援用关系没有剖析，欢送大家斧正。

最初

其实对于程序员来说，要学习的常识内容、技术有太多太多，要想不被环境淘汰就只有一直晋升本人，素来都是咱们去适应环境，而不是环境来适应咱们！

这里是对于我本人的Android 学习材料整顿，蕴含面试文档，视频收集大整顿，有趣味的搭档们能够看看~