Who moved my Activity?

  [[312428]]

Preface

I wonder if you have ever thought about this question: in daily development, the most commonly used method is to call up a new Activity through startActivity(). Who holds the reference to the created Activity object? The newly started Activity object should always be referenced during its life cycle, otherwise it will be recycled during the system GC. So what is the reference relationship?

In order to figure out the whole problem, the author began to search the source code (Android Q). First, I had to figure out how the Activity instance was created.

Creation of Activity object

The launch of an Activity is a cross-process communication process. For the client, the creation of an Activity will call back to the handleLaunchActivity() method in ActivityThread:

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

Then I found the creation of the Acitivity instance in the performLaunchActivity() method:

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
 ···
    ContextImpl appContext = createBaseContextForActivity(r);
    Activity activity = null ;
 try {
 // Note 1: Create a new Activity instance through ClassLoader and the class name of the target Activity
        java.lang.ClassLoader cl = appContext.getClassLoader();
      activity = mInstrumentation.newActivity(
             cl, component.getClassName(), r.intent);
 ···
 } ···
 }

The creation of Activity is handled by the Instrumentation class:

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

The final creation work is further implemented by the factory class AppComponentFactory:

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

At this point, the process of creating an Activity object is already very clear: get the Class object of the target Activity through the ClassLoader object and the class name, and then call the newInstance() method of the Class object to create an instance.

The graphical relationship is as follows:

Reference relationship of Activity object

After understanding the creation process of the Activity object, let's go back to the performLaunchActivity() method of the ActivityThread at the beginning and then look down:

 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);
 ···
 // Note 2: The ActivityClientRecord object holds a reference to the Activity instance
 r.activity = activity;
 }
 r.setState(ON_CREATE); 
 
 // Note 3: Add the ActivityClientRecord object to the mActivities collection
    synchronized (mResourcesManager) {
       mActivities.put(r.token, r);
 } 
 
 } ··· 
 
 return activity;
 }

Here we seem to have found the answer we were looking for:

The newly created Activity object will be held by the passed in ActivityClientRecord object, and then the ActivityClientRecord object will be added to a collection called mActivities.

ActivityClientRecord is a static inner class of ActivityThread, used to record information related to Activity. The object creation process can be found in the LaunchActivityItem class (after API 28):

frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java:

 @Override
 public 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);
 }

Let's take a look at this mActivities collection:

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

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

mActivities is a map collection, which is a member variable of the ActivityThread object. Since it is a collection, you can naturally find the operation of removing elements in the collection in the Activity destroy method callback:

 /** 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;
 }

The graphical relationship is represented as follows:

Since the Activity object is indirectly referenced by the ActivityThread object, the ActivityThread object should exist as a singleton. So how is the singleton ActivityThread object created and held?

Creation of ActivityThread object

When a new application process is created, the static main method main() of ActivityThread is called. Here, we found the answer:

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

 ···
 // Annotation 4: Static ActivityThread member variable, used to implement singleton
 private static volatile ActivityThread sCurrentActivityThread;
 ··· 
 
 // Note 5: ActivityThread's main method entry, called by RuntimeInit
 public   static void main(String[] args) {
 ···
    Looper.prepareMainLooper();
 ···
 // Annotation 6: Create a new ActivityThread object
    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) {
 // Note 7: The ActivityThread object is referenced by a static member variable
    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();
 }
 ···
 } ···
 }

From the above code, we can see that when a new application process is created, a new ActivityThread object is created in the main() method and assigned to a static member variable sCurrentActivityThread of the ActivityThread class, thus forming a relationship in which one application process corresponds to one ActivityThread object (singleton).

Summarize

Each newly started Activity, after its object instance is created by the newInstance method of the Class class, is wrapped in an ActivityClientRecord object and then added to the member variable mActivitys of the process's only ActivityThread object. In other words, the holding and release of Activity objects are managed by ActivityThread.

Finally, I would like to reiterate two additional points:

In the source code, the Activity object has a transfer relationship in multiple methods, which is quite complicated. The author is not very knowledgeable and may have missed some other important reference relationships without analysis. Everyone is welcome to correct me.

The framework source code above uses the latest Android Q version before the deadline. The relevant source code of this part will be modified for different Android system versions. I cannot compare and analyze them in detail one by one. I hope you can forgive me.