专栏首页Open软件开发小组深入理解Activity启动流程和AMS框架(二)

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

提示

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

深入理解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软件开发小组发布,著作权归原作者所有。如需转载请申请授权。

本文分享自微信公众号 - Open软件开发小组(open_dev),作者:彭小川

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2017-08-22

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

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

    Intent中定义了一个标志FLAGACTIVITYNEW_TASK,在startActivity的Intent参数中加入该标志就能开启一个新的Task。但是,...

    open
  • 五年Android开发,让我“刻骨铭心”的那些坑

    这篇文章是本人对在开发过程中踩坑经历的一次总结;分为系统API的坑、使用不当导致的坑、开源项目中的坑等几个方面,知识面有限,认知难免会有...

    open
  • Android后台发送邮件进行日志反馈

    最近在和解决用户反馈的问题,但是出现了不方便的事情.就是获取用户操作日志的问题.想来想去还是用比较隐晦的方法---发送邮件.(需要告知用户,不然会当成流氓的!)

    open
  • 深入理解Activity启动流程和AMS框架(三)

    Intent中定义了一个标志FLAGACTIVITYNEW_TASK,在startActivity的Intent参数中加入该标志就能开启一个新的Task。但是,...

    open
  • Android四大组件之一Activity详解

    Activity是Android应用的重要组成单元之一(另外三个是Service、BroadcastReceiver和ContentProvider),而Act...

    提莫队长
  • 安卓开发之Activity

    一、Activity的作用 Activity作用就是和用户进行交互; Activity间接或者直接集成Context、ContextWrapper、Contex...

    苦咖啡
  • 精选Android中高级高频面试题:四大组件及Fragment原理

    延伸:从整个生命周期来看,onCreate和onDestroy是配对的,分别标识着Activity的创建和销毁,并且只可能有一次调用; 从Activity是否可...

    Android技术干货分享
  • 测一测你对「Activity」的了解

    在日常的移动端测试沟通过程中,我们经常会听到开发说到一些平台开发术语,本次小编将对Android四大组件之一的Activity进行些简单的介绍和测试点总结。

    用户5521279
  • Android高频面试专题 - 基础篇(一)Activity

    本篇主要介绍Activity相关面试题,既有基础知识,也有一些比较冷门的,但是面试官会问的比较晦涩的点。

    Android扫地僧
  • 从0系统学Android-2.4 Activity 的生命周期

    Android 中的 Activity 是可以层叠的。我们每次启动一个新的 Activity,就会覆盖在原来的 Activity 上面,然后点击 back 键就...

    开发者

扫码关注云+社区

领取腾讯云代金券