首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >深入理解Activity启动流程和AMS框架(二)

深入理解Activity启动流程和AMS框架(二)

作者头像
open
发布2020-03-19 17:05:51
1.7K0
发布2020-03-19 17:05:51
举报

提示

文中代码较多,点击文章末尾处阅读原文获取更好略读体验。

深入理解Activity启动流程和AMS框架(一)

由此我们可以得到ActivityThread框架图:

通常ApplicationThread中的接口方法都是以“schedule”开头,而ActivityThread中对应的处理方法则以“handle”开头。

6、Activity的创建并回调onCreate()

ActivityThread中的成员变量mActivities中保存了所有ActivityClientRecord对象,该类中重要的成员变量如下:

static final class ActivityClientRecord {
   IBinder token;                // Activity对象的全局唯一标示
   Intent intent;                // 启动Activity的Intent
   Activity activity;            // Activity对象
   Window window;                // Activity的窗口对象
   boolean paused;               // 是否在暂停状态的标志
   boolean stopped;              // 是否在停止状态的标志
   ActivityInfo activityInfo;    // Activity的信息
   LoadedApk packageInfo;        // 包的信息
}

token的类型是IBinder,在ActivityManagerService中会为每个应用程序中的Activity对象建立了一个对应的ActivityRecord对象,ActivityRecord会创建一个token对象来作为Activity的标识。这个token是个Binder对象,但是它不是为提供Binder服务而创建的,这里只是利用Binder对象的 系统全局唯一性 来作为标识符。 每一个Activity都包含了一个Window对象,Window对象关联着应用框架的一大块内容。

从上面的框架图我们可以得知:启动一个Activity,首先会经过AMS和ActivityThread之间又长又臭的调用和回调,最终才会调到ActivityThread的handleLaunchActivity()方法。下面我们看一下接下来的流程。

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
     ......
     // 执行Activity创建和onCreate流程
     Activity a = performLaunchActivity(r, customIntent);     if (a != null) {
         r.createdConfig = new Configuration(mConfiguration);
         Bundle oldState = r.state;
         // 执行Activity的onResume流程
         handleResumeActivity(r.token, false, r.isForward,
                 !r.activity.mFinished && !r.startsNotResumed);
         ......
     } else {
         // If there was an error, for any reason, tell the activity
         // manager to stop us.
         try {
             ActivityManagerNative.getDefault()
                 .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);
         } catch (RemoteException ex) {
             // Ignore
         }
     }
 }

handleLaunchActivity()再调用performLaunchActivity()方法来创建Activity并执行onCreate流程,返回后再执行Activity的onResume流程。继续深入,不要怂。

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 首先,从ActivityClientRecord中获取待启动的Activity的组件信息            
    ActivityInfo aInfo = r.activityInfo;
    if (r.packageInfo == null) {
        // 获取Activity的packageInfo
        r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                Context.CONTEXT_INCLUDE_CODE);
    }    ComponentName component = r.intent.getComponent();
    if (component == null) {
        // 获取Activity的ComponentName
        component = r.intent.resolveActivity(
            mInitialApplication.getPackageManager());
        r.intent.setComponent(component);
    }    if (r.activityInfo.targetActivity != null) {
        component = new ComponentName(r.activityInfo.packageName,
                r.activityInfo.targetActivity);
    }    Activity activity = null;
    try {
        // 拿到加载Activity的ClassLoader, 创建Activity对象
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
        StrictMode.incrementExpectedActivityCount(activity.getClass());
        r.intent.setExtrasClassLoader(cl);
        r.intent.prepareToEnterProcess();
        if (r.state != null) {
            r.state.setClassLoader(cl);
        }
    } catch (Exception e) {
        if (!mInstrumentation.onException(activity, e)) {
            throw new RuntimeException(
                "Unable to instantiate activity " + component
                + ": " + e.toString(), e);
        }
    }    try {
        // 拿到当前进程中的Application对象
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);        if (activity != null) {
            // 创建Activity的ApplicationContext
            Context appContext = createBaseContextForActivity(r, activity);
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mCompatConfiguration);
            // 调用Activity的attach方法在其内部保存一些ActivityClientRecord内的属性
            // 来完成一些重要的数据初始化
            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);
            ......
            // 通过mInstrumentation调用Activity的onCreate方法
            if (r.isPersistable()) {  
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            ...
            // 将ActivityClientRecord中的activity属性设置为当前activity
            r.activity = activity;
            ......
        }
        r.paused = true;        // 以ActivityClientRecord中的token为key,mActivities中添加待启动的activity
        mActivities.put(r.token, r);    } catch (SuperNotCalledException e) {
        throw e;    } catch (Exception e) {
        if (!mInstrumentation.onException(activity, e)) {
            throw new RuntimeException(
                "Unable to start activity " + component
                + ": " + e.toString(), e);
        }
    }    return activity;
}

从上面代码我们发现,ActivityThread最后调用了mInstrumentation变量的newActivity()方法来创建Activity对象,并回调了callActivityOnCreate()方法,走完Activity的onCreate流程。

public class Instrumentation {
   public void callActivityOnCreate(Activity activity, Bundle icicle) {
       prePerformCreate(activity);
       activity.performCreate(icicle); // 回调Activity.onCreate()
       postPerformCreate(activity);
   }   public void callActivityOnCreate(Activity activity, Bundle icicle,
           PersistableBundle persistentState) {
       prePerformCreate(activity);
       activity.performCreate(icicle, persistentState); // 回调Activity.onCreate()
       postPerformCreate(activity);
   }
}public class Activity extends ContextThemeWrapper
       implements LayoutInflater.Factory2,
       Window.Callback, KeyEvent.Callback,
       OnCreateContextMenuListener, ComponentCallbacks2,
       Window.OnWindowDismissedCallback {   final void performCreate(Bundle icicle) {
       onCreate(icicle);
       mActivityTransitionState.readState(icicle);
       performCreateCommon();
   }   final void performCreate(Bundle icicle, PersistableBundle persistentState) {
       onCreate(icicle, persistentState);
       mActivityTransitionState.readState(icicle);
       performCreateCommon();
   }
}

这样Activity在应用端进程ActivityThread的启动流程和生命周期回调流程都简单分析完了。

Instrumentation是什么?和ActivityThread是什么关系?

Instrumentation可以理解为应用进程的管家,ActivityThread要执行创建或暂停某个Activity等操作时,都需要通过Instrumentation来进行具体的实现(回调Activity的生命周期)。每一个应用程序只有一个Instrumentation对象,每个Activity内都有一个对该对象的引用。 另外,当我们在Activity中调用startActivity()的 时候,实际上调用的还是Instrumentation的相关的方法mInstrumentation.execStartActivity()。

public ActivityResult execStartActivity(
       Context who, IBinder contextThread, IBinder token, String target,
       Intent intent, int requestCode, Bundle options) {
   IApplicationThread whoThread = (IApplicationThread) contextThread;
   if (mActivityMonitors != null) {
       synchronized (mSync) {
           final int N = mActivityMonitors.size();
           for (int i=0; i<N; i++) {
               final ActivityMonitor am = mActivityMonitors.get(i);
               if (am.match(who, null, intent)) {
                   am.mHits++;
                   if (am.isBlocking()) {
                       return requestCode >= 0 ? am.getResult() : null;
                   }
                   break;
               }
           }
       }
   }
   try {
       intent.migrateExtraStreamToClipData();
       intent.prepareToLeaveProcess();
       // 通知AMS执行startActivity的流程
       int result = ActivityManagerNative.getDefault()
           .startActivity(whoThread, who.getBasePackageName(), intent,
                   intent.resolveTypeIfNeeded(who.getContentResolver()),
                   token, target, requestCode, 0, null, options);
       checkStartActivityResult(result, intent);
   } catch (RemoteException e) {
       throw new RuntimeException("Failure from system", e);
   }
   return null;
}

ActivityManagerNative.getDefault返回的就是ActivityManagerService的远程接口,即ActivityManagerProxy。 除了启动Activity之外,还有很多方法,有兴趣的可以深入了解一下:

通俗的理解,ActivityThread负责创建这个“家庭”,并负责对外打交道,比如接收AMS的通知等。Instrumentation负责管理这个家庭,安排每个Activity的日常流程等工作。

四、小结

AMS通过Binder进行IPC通讯,通知应用进程ActivityThread启动指定Activity

  • 调用ApplicationThread.scheduleLaunchActivity()。
  • 经过Handler消息传动,调用ActivityThread.handleLaunchActivity()。
  • 调用ActivityThread.performLaunchActivity()完成Activity的加载,并最终调用Activity生命周期的onCreate()方法
  • performLaunchActivity返回,继续调用ActivityThread.handleResumeActivity(),该方法内部又调用ActivityThread.performResumeActivity(),其内部仅仅调用了目标Activity的onResume()方法。到此Activity启动完成。
  • Activity的其他生命周期方法onRestart等,可以根据onCreate流程为类推,举一反三。

五、ActivitymanagerService(AMS)框架

ActivitymanagerService是Android Framework的一个核心系统服务,它管理着Android系统中的4大组件:Activity、Service、ContentProvider和BroadcastReceiver。前面已经介绍了,Android希望模糊进程的作用,取而代之以组件的概念,AMS正是这一理念的实现。AMS除了管理这4大组件之外,同时也管理和调度所有用户进程。

1、ActivityManager、ActivityManagerService、ActivityManagerNative、ActivityManagerProxy的关系

AMS是一个Binder服务,但是AMS的Binder框架代码不是通过AIDL自动生成的。AMS从ActivityManagerNative类派生,这个类加上IActivityManager、ActivityManagerProxy和ActivityManager共同实现了AMS Binder框架。它们的关系如下图:

  • ActivityManagerNative类的代码虽然也很庞大,但只是实现Binder的框架,我们可以不用关心这个类的实现细节。
  • ActivityManagerProxy类是作为ActivityManagerNative的嵌入类来实现的,它是代理对象,起接口作用。
  • ActivityManager通过调用ActivityManagerNative的getDefault()方法来得到ActivityManagerProxy对象的引用。

理解了AMS的Binder框架类的作用,后面分析AMS服务的时候,可以不用关系这些类,只需要集中精力在AMS类的本身上。

2、AMS的初始化

AMS运行在SystemServer进程中,对象的创建是在SystemServer类初始化时完成的。

public final class SystemServer {
   ......
   private ActivityManagerService mActivityManagerService;
   private void startBootstrapServices() {
       ...
       mActivityManagerService = mSystemServiceManager.startService(
               ActivityManagerService.Lifecycle.class).getService();  // 创建AMS服务
       mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
       mActivityManagerService.setInstaller(installer);
       ...
   }
   ......
}

从代码中可以看到,这里调用了mSystemServiceManager.startService()方法,这个方法将根据传入的参数(类的class)来创建类的实例对象,并注册到ServiceManager中。 接下来我们看一下AMS的构造方法做了些什么:

public ActivityManagerService(Context systemContext) {
   mContext = systemContext;
   mFactoryTest = FactoryTest.getMode();
   // 获取运行在SystemServer中的ActivityThread对象
   mSystemThread = ActivityThread.currentActivityThread();
   // 创建用于处理消息的线程和Handler对象
   mHandlerThread = new ServiceThread(TAG,
           android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
   mHandlerThread.start();
   mHandler = new MainHandler(mHandlerThread.getLooper());
   // 创建用于UI操作相关的Handler对象
   mUiHandler = new UiHandler();   // 创建管理广播的数据结构
   mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
           "foreground", BROADCAST_FG_TIMEOUT, false);
   mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
           "background", BROADCAST_BG_TIMEOUT, true);
   mBroadcastQueues[0] = mFgBroadcastQueue;
   mBroadcastQueues[1] = mBgBroadcastQueue;   mServices = new ActiveServices(this);  // 创建管理组件Service的对象
   mProviderMap = new ProviderMap(this);  // 创建管理组件Provider的对象   // 获取系统的data和system目录
   File dataDir = Environment.getDataDirectory();
   File systemDir = new File(dataDir, "system");
   systemDir.mkdirs();   // 创建BatteryStatsService服务
   mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
   mBatteryStatsService.getActiveStatistics().readLocked();
   mBatteryStatsService.scheduleWriteToDisk();
   mOnBattery = DEBUG_POWER ? true
           : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
   mBatteryStatsService.getActiveStatistics().setCallback(this);
   // 创建ProcessStatsService服务
   mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
   // 创建AppOpsService应用权限管理服务
   mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);
   // 打开文件urigrants.xml
   mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));   // 设置0号用户作为第一个用户
   mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true));
   mUserLru.add(UserHandle.USER_OWNER);
   updateStartedUserArrayLocked();
   // 获取OpenglES的版本
   GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
       ConfigurationInfo.GL_ES_VERSION_UNDEFINED);   mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
   // 设置mConfiguration配置项为系统缺省值
   mConfiguration.setToDefaults();
   mConfiguration.setLocale(Locale.getDefault());   mConfigurationSeq = mConfiguration.seq = 1;
   mProcessCpuTracker.init();   mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
   // 创建Intent “防火墙”
   mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
   // 创建最近任务栏的栈管理对象
   mRecentTasks = new RecentTasks(this);
   // 创建Activity栈的管理对象mStackSupervisor
   mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
   mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);
   // 创建统计CPU使用情况的线程
   mProcessCpuThread = new Thread("CpuTracker") {
       ......
   }   // 把服务加到watchdog的监控中
   Watchdog.getInstance().addMonitor(this);
   Watchdog.getInstance().addThread(mHandler);
}

AMS构造方法的主要作用是创建了4大组件Activity、Service、BroadcastReceiver和ContentProvider的管理对象以及一些内部对象,逻辑比较简单。

3、如何启动进程

AMS中启动一个进程调用的是addAppLocked()方法。

final ProcessRecord addAppLocked(ApplicationInfo info, boolean isolated,
           String abiOverride) {
     ProcessRecord app;
     // isolated为true表示要启动一个新进程
     if (!isolated) { // 在已经启动的进程列表中查找
         app = getProcessRecordLocked(info.processName, info.uid, true);
     } else {
         app = null;
     }     if (app == null) {
         // 创建一个ProcessRecord对象
         app = newProcessRecordLocked(info, null, isolated, 0);
         updateLruProcessLocked(app, false, null);
         updateOomAdjLocked();
     }
     ......
     if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) {
         mPersistentStartingProcesses.add(app);
         // 启动进程
         startProcessLocked(app, "added application", app.processName, abiOverride,
                 null /* entryPoint */, null /* entryPointArgs */);
     }     return app;
 }

addAppLocked()方法会根据参数isolated来决定是否启动一个新进程,如果为true,即使系统中可能已经有一个同名的进程存在,也会再创建一个新进程。getProcessRecordLocked()方法用来在当前运行的进程列表中查找进程。newProcessRecordLocked()方法用来创建一个ProcessRecord的数据结构。updateLruProcessLocked方法用来更新运行中的进程的状态,updateOomAdjLocked用来更新进程的优先级,这两个方法是Process管理的核心。篇幅有限,这里不再展开分析咯。

4、ActivityRecord、TaskRecord、ActivityStack的关系

(1)、ActivityRecord
final class ActivityRecord {
   // AMS的引用  
   final ActivityManagerService service; // owner  
   // token用来和WMS交互  
   final IApplicationToken.Stub appToken; // window manager token  
   final ActivityInfo info; // all about me  
   final ApplicationInfo appInfo; // information about activity's app  
   final ComponentName realActivity;  // the intent component, or target of an alias.
   ...     //Activity资源信息  
   CharSequence nonLocalizedLabel;  // the label information from the package mgr.  
   int labelRes;           // the label information from the package mgr.  
   int icon;               // resource identifier of activity's icon.  
   int logo;               // resource identifier of activity's logo.  
   int theme;              // resource identifier of activity's theme.  
   int realTheme;          // actual theme resource we will use, never 0.  
   int windowFlags;        // custom window flags for preview window.     // ActivityRecord所在的TaskRecord  
   TaskRecord task;        // the task this is in.  
   ...  
   // ActivityRecord所在进程  
   ProcessRecord app;      // if non-null, hosting application  
   ActivityState state;    // current state we are in  
   ...  
}

ActivityRecord就是Activity在AMS中的代表,ActivityRecord和应用中的Activity一一对应,并且包含了Activity的所有信息。(就好比Activity在ActivityThread中对应ActivityClientRecord一样) 每一个ActivityRecord都会有一个Activity与之对应,一个Activity可能会有多个ActivityRecord,因为Activity可以被多次实例化,取决于其Launchmode。 其中task对象标识了其所归属的TaskRecord,这样ActivityRecord和TaskRecord就联系起来了。

(2)TaskRecord
final class TaskRecord {
   // TaskRecord的唯一标识  
   final int taskId;       // Unique identifier for this task.  
   .....  
   // This represents the last resolved activity values for this task  
   // NOTE: This value needs to be persisted with each task  
   TaskDescription lastTaskDescription = new TaskDescription();     // TaskRecord里所有的ActivityRecord信息  
   /** List of all activities in the task arranged in history order */  
   final ArrayList<ActivityRecord> mActivities;     // TaskRecord所在的stack  
   ActivityStack stack;  
   ......
}

TaskRecord中我列出来三个成员变量:

  • taskId:唯一标示的id号
  • mActivities:当前栈中所有的ActivityRecord
  • stack:ActivityStack的引用,为了回调ActivityStack的方法

从TaskRecord 的数据结构我们可以看到,mActivities保存了一组ActivityRecord信息,同时每一个ActivityRecord都有其所在TaskRecord的引用。TaskRecord都有一个唯一标示taskId,还包含了ActivityStack的引用对象。 因此,TaskRecord可以理解为一个mActivities组成的栈,也可以理解为一个由一系列Activity组成的活动。

(3)、 ActivityStack
final class ActivityStack {
   /**
    * The back history of all previous (and possibly still
    * running) activities.  It contains #TaskRecord objects.
    */  
   private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();     ...     final int mStackId;  
   ...  
   /** Run all ActivityStacks through this */  
   final ActivityStackSupervisor mStackSupervisor;
}
  • mStackId:唯一标示的id号
  • mTaskHistory:这个记录的是一组TaskRecord的栈信息
  • mStackSupervisor:ActivityStack的管理类,也是为了方便管理Task,被AMS调用等

从名字上看,ActivityStack更像是一个栈,实际上它就是一个Manager的角色。 ActivityStack负责管理协调ActivityRecord和TaskRecord,通过mStackId来唯一标识,持有ActivityStackSupervisor的引用。

(4)、关系图

每一个ActivityRecord都会有一个Activity与之对应。一系列相关的ActivityRecord组成了一个TaskRecord,TaskRecord是存在于ActivityStack中,ActivityStackSupervisor是用来管理这些ActivityStack的。 下面是一个简单的关系图

Task 是Activity的集合。Android把用户一次相关操作用使用的Activity按照先后顺序保存在Task中,这样当用户按back键的时候就能按照相反的顺序依次返回退出。Task像一个栈,以先进后出的方式管理着Activity。系统运行时内存中会存在多个Task,当我们查看最近任务栏时,会弹出一个列表让你选择,这个列表就是系统中存在的Task集合,选择一个Task会将它所包含的Activity作为一个整体带到前台。Task中的Activity的顺序通常是不能改变的,只能压栈和出栈。

AMS中使用ActivityStack 类来管理Task,它管理的Task都存放在成员变量mTaskHistory中。mTaskHistory也是一个列表,存储的是TaskRecord对象。TaskRecord对象代表一个Task,他的成员变量mActivities也是一个列表,存储了属于该Task中的所有ActivityRecord对象。

本文由原作者彭小川独家授权Open软件开发小组发布,著作权归原作者所有。如需转载请申请授权。

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2017-08-22,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Open软件开发小组 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 6、Activity的创建并回调onCreate()
  • Instrumentation是什么?和ActivityThread是什么关系?
  • 四、小结
  • 五、ActivitymanagerService(AMS)框架
    • 1、ActivityManager、ActivityManagerService、ActivityManagerNative、ActivityManagerProxy的关系
      • 2、AMS的初始化
        • 3、如何启动进程
          • 4、ActivityRecord、TaskRecord、ActivityStack的关系
          领券
          问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档