In-depth analysis of the AMS startup process

[[432146]]

Preface

AMS (ActivityManagerService) is one of the core services of Android. For each core service of the framework, if you are not specialized in framework development, first understand its basic process mechanism, and then slowly delve into it;

Today we will learn about AMS

1. AMS Function Overview

1. Introduction to AMS

• AMS is the core service in Android. It is mainly responsible for starting, switching, and scheduling the four major components in the system, as well as the management and scheduling of application processes. Its responsibilities are similar to the process management and scheduling modules in the operating system, so it is very important in Android.
• Component state management: including a series of operations such as opening and closing the four major components, such as startActivity, startActivityAndWait, activityPaused, startService, stopService, removeContentProvider, etc.;
• Component status query: query the current running status of the component, such as getCallingActivity, getService, etc.;
• Task related: including removeTask, removeSubTask, moveTaskBackwards, moveTaskToFront, etc.;
• AMS is a system service that records and manages the status of Activities and other components in the system through ActivityStack and other data structures, and provides query functions;

2. Important data structures in AMS

ActivityRecord: records all the information of the Activity, so it is used to describe an activity. It is created when the activity is started, specifically in startActivity() of ActivityStarter. The information it stores mainly includes the following:

• service: AMS reference
• info:ActivityInfo, node information of Activity code and AndroidManifest settings, such as launchMode
• launcherFromPackage: The package name of the launcher activity
• taskAffinity: the stack to which the activity wants to belong
• task:TaskRecord, the TaskRecord where the Activity is located
• app:ProcessRecord, the application process where ActivityRecord is located
• state:ActivityState, the state of the current activity
• Icon: Activity icon resources and logo symbols
• theme:Activity theme resource identifier

TaskRecord: used to describe an Activity task stack

• taskId: unique identifier of the task stack
• Affinity: The tendency of the task stack
• Intent: The intent that starts this activity
• mActivites:ArrayList, Activity records arranged in historical order
• mStack:ActivityStack, the current ActivityStack
• mService:AMS reference

ActivityStack: It is used to manage all the activities in the system. It maintains all the states of the activities, the activities in special states, and the lists related to the activities.

2. Detailed explanation of the startup process of AMS service

1. startBootstrapServices

 private void startBootstrapServices() {
        // Activity manager runs the show.
     mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
     mActivityManagerService.setSystemProcess();
 …
     mActivityManagerService.installSystemProviders();
 …
     mActivityManagerService.systemReady(new Runnable() {
 @Override
 public void run() {
                Slog.i(TAG, "Making services ready" );
                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_ACTIVITY_MANAGER_READY);
 try {
                    mActivityManagerService.startObservingNativeCrashes();
                } catch (Throwable e) {
                    reportWtf( "observing native crashes" , e);
 }

There are several key methods for starting AMS in SystemServer, which are mainly divided into 4 steps

• Create an AMS object and start the service
• Add the system process where AMS is located to the process management
• Install a ContentProvider object for the system process
• Do the post-processing in the systemReady method
• Let's look at the functions of these methods one by one. These methods are the startup and initialization process of AMS;

2. ActivityManagerService

How to start ActivityManagerService

mActivityManagerService = mSystemServiceManager.startService(

ActivityManagerService.Lifecycle.class).getService();

The AMS service is also started through SystemServiceManager, so let's first look at the construction method of ActivityManagerService.Lifecycle, and then look at its Start function;

The Lifecycle construction method is very simple, which is to construct an AMS object.

mService = new ActivityManagerService(context);

When creating an AMS object, you need to pass a Context as a parameter. The mSystemContext is the system Context created above.

Next, let’s look at the construction method of AMS;

 public ActivityManagerService(Context systemContext) {
 //System context
 mContext = systemContext;
 //Get the system's ActivityThread
        mSystemThread = ActivityThread.currentActivityThread();
 //Create a HandlerThread to process the commands received by AMS
        mHandlerThread = new ServiceThread(TAG,
                android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        mHandler = new MainHandler(mHandlerThread.getLooper());
        mUiHandler = new UiHandler();
 // Initialize the broadcast queue
        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;
 //Initialize Service related containers
        mServices = new ActiveServices(this);
 //Initialize the Provider-related Map, which stores the registered ContentProvider
        mProviderMap = new ProviderMap(this);
 //Initialize and create the data/system/directory
        File dataDir = Environment.getDataDirectory();
        File systemDir = new File(dataDir, "system" );
 systemDir.mkdirs();
 //Initialize information related to power statistics service
        mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
        mBatteryStatsService.getActiveStatistics().readLocked();
        mBatteryStatsService.scheduleWriteToDisk();
        mOnBattery = DEBUG_POWER? true  
                : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
        mBatteryStatsService.getActiveStatistics().setCallback(this);
 // Initialize the system statistics service to count the system's running information
        mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats" ));
        mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml" ), mHandler);
        mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml" ));
 //Create the first user of the system , userID is 0, this user has administrator privileges
        mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true ));
        mUserLru.add (UserHandle.USER_OWNER);
        updateStartedUserArrayLocked();
 //Get the version of opengle
        GL_ES_VERSION = SystemProperties.getInt( "ro.opengles.version" ,
            ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
 // Initialize font language and other configuration information
        mConfiguration.setToDefaults();
        mConfiguration.setLocale(Locale.getDefault());
 ……;
        mRecentTasks = new RecentTasks(this);
 //Initialize StackSupervisor, which is the core class for Activity startup and scheduling
        mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
        mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);

• The construction method of AMS mainly performs some initialization operations;
• Save the Context and ActivityThread of its own operating environment;
• AMS is responsible for scheduling four major components, so it will initialize broadcast, service and contentProvider related variables, then initialize the power statistics service, create the first user of the system, initialize basic configuration information, and create the core class of Activity scheduling. Because Activity scheduling is more complicated, Activity related information will be initialized in ActivityStackSupervisor;

3. Start

The start method of AMS.

 private void start() {
     mProcessCpuThread.start();
     mBatteryStatsService.publish(mContext);
     LocalServices.addService(ActivityManagerInternal.class, new LocalService());
 }

• The start method of AMS is very simple. It just starts several services and saves the AMS service itself to localService for internal calls of the program.
• The AMS constructor and start method initialize some variables of the AMS service and related services. Next, let's look at the next important method, setSystemProcess;

4. setSystemProcess

ActivityManagerService's setSystemProcess method

 public void setSystemProcess() {
 try {
 //Register AMS to ServiceManager
            ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true );
 //Register other services to ServiceManager
            ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
            ServiceManager.addService( "meminfo" , new MemBinder(this));
            ServiceManager.addService( "gfxinfo" , new GraphicsBinder(this));
            ServiceManager.addService( "dbinfo" , new DbBinder(this));
            if (MONITOR_CPU_USAGE) {
                ServiceManager.addService( "cpuinfo" , new CpuBinder(this));
 }
 //Register the permission service to ServiceManager
            ServiceManager.addService( "permission" , new PermissionController(this));
            ServiceManager.addService( "processinfo" , new ProcessInfoService(this));
 //Query the application package named android from PMS, that is, the Application information of framework-res
            ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
 "android" , STOCK_PM_FLAGS);
 //Configure the application information to the activityThread that was created
            mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
            synchronized (this) {
 //Create a ProcessRecord object, which stores the process information of the system ongoing service
                ProcessRecord app = newProcessRecordLocked(info, info.processName, false , 0);
                app.persistent = true ;
                app.pid = MY_PID;
                app.maxAdj = ProcessList.SYSTEM_ADJ;
                app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
                synchronized (mPidsSelfLocked) {
 Then add the processRecord object of the system process to the mPidsSelfLocked collection, and receive the management scheduling of AMS just like the process of ordinary applications.
                    mPidsSelfLocked.put(app.pid, app);
 }
 //Scheduling information for more detailed process management
                updateLruProcessLocked(app, false , null );
                updateOomAdjLocked();
 }

• In the setSystemProcess method, first register your own AMS service with the ServiceManager, and then register other system services such as the permission service;
• Get the PMS service through the previously created Context, retrieve the Application information of framework-res, and then configure it to the system's ActivityThread;
• In order to enable AMS to manage and schedule system processes, a ProcessRecord object about the system process is also created. The ProcessRecord object saves the relevant information of a process;
• Then save it to the mPidsSelfLocked collection for easy management;
• How AMS configures the retrieved application information of framework-res into ActivityThread requires further analysis of the installSystemApplicationInfo method of ActivityThread.

Next, look at the installSystemApplicationInfo method

 public void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
 synchronized (this) {
            getSystemContext().installSystemApplicationInfo(info, classLoader);
 }
 }

This method finally calls the installSystemApplication method of the SystemContext created above, so let's look at the installSystemApplication method of ConxtextImpl.

 void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
        mPackageInfo.installSystemApplicationInfo(info, classLoader);
 }

• It finally calls the installSystemApplication method of mPackageInfo. mPackageInfo is the LoadedApk passed in when creating the Context object, which stores the basic information of an application.
• setSystemProcess is mainly used to set some information of system integration. Here, the Application information of the system process is set, and the ProcessRecord object of the system process is created and saved in the process collection to facilitate AMS management and scheduling;

5. installSystemProvider

• The installSystemProvider method of ActivityManagerService;
• There are a lot of configuration information that needs to be saved in the Android system. This information is saved in SettingsProvider, and this SettingsProvider also runs in the SystemServer process. Since the SystemServer process depends on SettingsProvider, putting it in one process can reduce the efficiency loss of inter-process communication;
• Next, let's analyze how to load SettingsProvider.apk into the SystemServer process;

 public final void installSystemProviders() {
        List<ProviderInfo> providers;
 synchronized (this) {
 //Find the process named "System", which is the processRecord object created in the previous step
            ProcessRecord app = mProcessNames.get( "system" , Process.SYSTEM_UID);
 //Find all ContentProviders related to the system process
            providers = generateApplicationProvidersLocked(app);
            if (providers != null ) {
 for ( int i=providers. size ()-1; i>=0; i --) {  
                    ProviderInfo pi = (ProviderInfo)providers.get(i);
 //Confirm again that the process is the system provider, and remove the provider that is not the process
                    if ((pi.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) == 0) {
                        Slog.w(TAG, "Not installing system proc provider " + pi. name  
                                + ": not system .apk" );
                        providers.remove(i);
 }
 }
 }
 }
        if (providers != null ) {
 //Install the provider into the system's ActivityThread
            mSystemThread.installSystemProviders(providers);
 }
        mCoreSettingsObserver = new CoreSettingsObserver(this);
 }

Find the process object named system, which is the SystemServer process, and then query all relevant ContentProviders based on the process object, and call the main thread ActivityThread of the system process to install all relevant ContentProviders. Specifically, how to find the relevant contentProvider and how to install the ContentProvider to the system main thread, then analyze the following two methods;

 private final List<ProviderInfo> generateApplicationProvidersLocked(ProcessRecord app) {
        List<ProviderInfo> providers = null ;
 try {
 //Call PMS to query Provider based on process ID and process name
            ParceledListSlice<ProviderInfo> slice = AppGlobals.getPackageManager().
                queryContentProviders(app.processName, app.uid,
                        STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS);
            providers = slice != null ? slice.getList() : null ;
        } catch (RemoteException ex) {
 }
 int userId = app.userId;
        if (providers != null ) {
 int N = providers.size ( );
 for ( int i=0; i<N; i++) {
                ProviderInfo cpi =
                    (ProviderInfo)providers.get(i);
 …
                ComponentName comp = new ComponentName(cpi.packageName, cpi.name );
 //Query the corresponding provider from the contentProvider list managed by AMS
 ContentProviderRecord cpr = mProviderMap.getProviderByClass(comp, userId);
                if (cpr == null ) {
 //If there is no corresponding Provider instance in the Provider list of AMS, create an object based on the queried provider information and save it in the queue
                    cpr = new ContentProviderRecord(this, cpi, app.info, comp, singleton);
                    mProviderMap.putProviderByClass(comp, cpr);
 }
 //Save the provider to the pubProviders list of the processRecord object at the same time
                app.pubProviders.put(cpi. name , cpr);
 …
 }
 }
 return providers;
 } 

• This method is to query the Provider related to the SystemServer process from PMS, that is, SettingsProvder, and then save it to the contentProvider list of AMS;
• It is also saved to the pubProviders list of the system process object ProcessRecord. It is saved to the provider list of AMS because AMS needs to manage all ContentProvders.
• The reason why it is saved in the pubProviders list of the process object is that each ContentProvider needs to correspond to a process;
• Next, let's see how to install SettingsProvider into the main process of the system;

 private void installContentProviders(
            Context context, List<ProviderInfo> providers) {
 …
 for (ProviderInfo cpi : providers) {
 //The installProvider method is used to encapsulate the provider into a ContentProviderHolder object, which is convenient for inter-process transmission
            IActivityManager.ContentProviderHolder cph = installProvider(context, null , cpi,
 false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
            if (cph != null ) {
                cph.noReleaseNeeded = true ;
                results.add (cph);
 }
 }
 try {
 //Publish the contentProviderHolder object obtained above to the AMS service. getApplicationThread represents a binder object of the local process. The binder object can be transferred across processes. It corresponds to a ProcessRecord in AMS.
            ActivityManagerNative.getDefault().publishContentProviders(
                getApplicationThread(), results);
 …
 }

• This method encapsulates the obtained contentProvider object into a contentProviderHolder object, which is actually a Binder object, so that it can be transmitted between processes, and then the AMS service is called across processes to register the Provider;
• AMS is responsible for managing ContentProvider. Only when ContentProvider is registered to AMS service can other processes access it.
• Next, let's see how AMS registers the Provider;

6. publishContentProviders

 public final void publishContentProviders(IApplicationThread caller,
            List<ContentProviderHolder> providers) {
 …
 //Get the corresponding processRecord object according to the caller's process, which is the ProcessRecord of the system process
            final ProcessRecord r = getRecordForAppLocked(caller);
 …
            final int N = providers. size ();
 for ( int i = 0; i < N; i++) {
 //Provider src passed by ActivityThread client
                ContentProviderHolder src = providers.get(i);
 //According to the src provider name, get the ProciderRecord saved in the process of saving at the beginning
                ContentProviderRecord dst = r.pubProviders.get(src.info. name );
                if (dst != null ) {
                    ComponentName comp = new ComponentName(dst.info.packageName, dst.info. name );
 //Save it in mProviderMap by class
                    mProviderMap.putProviderByClass(comp, dst);
                    String names[] = dst.info.authority.split( ";" );
 for ( int j = 0; j < names.length; j++) {
 //Save in mProviderMap by authority
                        mProviderMap.putProviderByName(names[j], dst);
 }
 …
 }

• The AMS registration service finds the ContentProviderRecord saved in the pubProviders list in the original process according to the provider information passed by the parameters, and then saves it in mProviderMap with class as the key and authority as the key;
• That is, AMS provides multiple solutions to find a ContentProvider, one is to find it by authority, and the other is to find it by specifying the CompomentName;
• At this point, a SettingsProvider is officially registered in the SystemServer process, so it can be seen that the main task of the installSystemProvider method is to register the SettingsProvider in the system process in a similar way to ordinary processes, so that the system process can call the configuration data of settings;

7. systemReady

ActivityManagerService's systemReady method

 public void systemReady(final Runnable goingCallback) {
 synchronized(this) {
 //Initialize the controller in Doze mode
            mLocalDeviceIdleController
                    = LocalServices.getService(DeviceIdleController.LocalService.class);
 //Reset RecentTasks
            mRecentTasks.clear();
            mRecentTasks.addAll(mTaskPersister.restoreTasksLocked());
            mRecentTasks.cleanupLocked(UserHandle.USER_ALL);
            mTaskPersister.startPersisting();
 …
 //Set systemReady to true  
            mSystemReady = true ;
 }
        ArrayList<ProcessRecord> procsToKill = null ;
 //Collect the processes started before AMS
        synchronized(mPidsSelfLocked) {
 for ( int i=mPidsSelfLocked. size ()-1; i>=0; i --) {  
                ProcessRecord proc = mPidsSelfLocked.valueAt(i);
                if (!isAllowedWhileBooting(proc.info)){
                    if (procsToKill == null ) {
                        procsToKill = new ArrayList<ProcessRecord>();
 }
                    procsToKill.add (proc);
 }
 }
 }
 // Kill the processes started before AMS. Some processes cannot be started before AMS.
 synchronized(this) {
            if (procsToKill != null ) {
 for ( int i=procsToKill. size ()-1; i>=0; i --) {  
                    ProcessRecord proc = procsToKill.get(i);
                    Slog.i(TAG, "Removing system update proc: " + proc);
                    removeProcessLocked(proc, true , false , "system update done" );
 }
 }
 }
 // Initialize some variables from the settings provider
 retrieveSettings();
 //Call the callback method, which is implemented in the systemServer code
        if (goingCallback != null ) goingCallback.run();
 //Query the applications whose persistence is 1 and start their processes
                    List apps = AppGlobals.getPackageManager().
                        getPersistentApplications(STOCK_PM_FLAGS);
                    if (apps != null ) {
 int N = apps.size ( );
 int i;
 for (i=0; i<N; i++) {
                            ApplicationInfo info
                                = (ApplicationInfo)apps.get(i);
                            if (info != null &&
                                    !info.packageName.equals( "android" )) {
                                addAppLocked(info, false , null /* ABI override */);
 }
 }
 //Start HomeActivity, which is the launcher program
 mBooting = true ;
            startHomeActivityLocked(mCurrentUserId, "systemReady" );
 …
 }
 }

The SystemReady method is also relatively long and can be roughly divided into:

• First: Initialize deviceIdleController and other objects when systemReady
• Second: Remove and kill processes that should not be started before AMS
• Third: The callback function passed in by the parameters is executed
• Fourth: Start the Launcher interface
• Fifth: Start the processes whose persistent configuration is 1;
• Let's take a look at what the callback function of the systemReady parameter does.

 try {
 //ams starts monitoring the crash information of the native layer
                    mActivityManagerService.startObservingNativeCrashes();
                } catch (Throwable e) {
                    reportWtf( "observing native crashes" , e);
 }
 //Initialize webView
                WebViewFactory.prepareWebViewInSystemServer();
 try {
 //Start systemUI
                    startSystemUi(context);
                } catch (Throwable e) {
                    reportWtf( "starting System UI" , e);
 }
 try {
 //Call the systemready method of other services
                    if (networkScoreF != null ) networkScoreF.systemReady();
                } catch (Throwable e) {
                    reportWtf( "making Network Score Service ready" , e);
 }

The main work of this callback function is to start the systemUI and call the systemReady method of other services. The SystemReady function completes the necessary work of system readiness, starts HomeActivity and SystemUI, and then the Android system is fully started;

Summarize

The AMS service startup is mainly divided into several steps:

• Call the AMS constructor and start method to initialize the necessary content of AMS;
• Register the AMS function to the ServiceManager, create a ProcessRecord object for the systemServer process, and set the Context's application to the framework-res application object;
• Load settingsProvider into the system process systemServer;
• Call the systemReady method to do some pre-startup preparation work and start HomeActivity and SystemUI;

This article is reproduced from the WeChat public account "Android Development Programming"