美文网首页
Android系统启动（五）-ActivityManagerSe

Android系统启动（五）-ActivityManagerSe

作者: Stan_Z | 来源:发表于2018-11-08 20:23 被阅读39次

ActivityManagerService（简称AMS）是Android系统的核心服务之一。它的主要作用是管理系统中所有应用进程以及应用进程中的四大组件。

AMS的启动过程

接上篇SystemServer run( )方法，AMS的启动过程主要包含在如下两个方法中：

private void run() {
   ...
   startBootstrapServices();//创建并启动AMS服务，同时执行AMS启动后的一些初始化工作
   startOtherServices();// 进入下个阶段的一些准备工作
   ...
}

接下来按这两个方法来分析

一、startBootstrapServices( )

1.1 创建并启动AMS服务
private void startBootstrapServices() {
   ...
   //启动AMS服务
   mActivityManagerService = mSystemServiceManager.startService(
           ActivityManagerService.Lifecycle.class).getService();
   //设置AMS的系统服务管理器
  mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
   //设置AMS的APP安装器
   mActivityManagerService.setInstaller(installer);
   //初始化AMS相关的PMS
   mActivityManagerService.initPowerManagement();
   ...
    //想ServiceManager注册一系列服务,并创建system_server对应的ProcessRecord并初始化
   mActivityManagerService.setSystemProcess();
}

我们知道SystemServiceManager.startService是通过反射创建服务对象，并启动。但是这里传进去的是AMS的Lifecycle。Lifecycle是AMS中的一个静态内部类，它继承SystemService，由它来代理处理AMS的的创建与启动。

public static final class Lifecycle extends SystemService {
   private final ActivityManagerService mService;
   public Lifecycle(Context context) {
       super(context);
       mService = new ActivityManagerService(context);
   }
   @Override
   public void onStart() {
       mService.start();
   }
   public ActivityManagerService getService() {
       return mService;
   }
}

这样SystemServiceManager间接通过调用Lifecycle创建并启动了AMS服务。AMS是运行在system_server进程中的Framework服务，经过SystemServiceManager创建的服务会统一保存在队列管理。

1.2、AMS初始化工作
1.2.1 ActivityManagerService的构造方法：
public ActivityManagerService(Context systemContext) {
   mContext = systemContext;
   mFactoryTest = FactoryTest.getMode();//默认为FACTORY_TEST_OFF
   mSystemThread = ActivityThread.currentActivityThread();
   //创建名为"ActivityManager"的前台线程，并获取mHandler
   mHandlerThread = new ServiceThread(TAG, android.os.Process.THREAD_PRIORITY_FOREGROUND, false);
   mHandlerThread.start();
   mHandler = new MainHandler(mHandlerThread.getLooper());
   //通过UiThread类，创建名为"android.ui"的线程
   mUiHandler = new UiHandler();
   //前台广播接收器，在运行超过10s将放弃执行
   mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
           "foreground", BROADCAST_FG_TIMEOUT, false);
   //后台广播接收器，在运行超过60s将放弃执行
   mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
           "background", BROADCAST_BG_TIMEOUT, true);
   mBroadcastQueues[0] = mFgBroadcastQueue;
   mBroadcastQueues[1] = mBgBroadcastQueue;
   //创建ActiveServices，其中非低内存手机mMaxStartingBackground为8
   mServices = new ActiveServices(this);
   mProviderMap = new ProviderMap(this);
   //创建目录/data/system
   File dataDir = Environment.getDataDirectory();
   File systemDir = new File(dataDir, "system");
   systemDir.mkdirs();
   //创建服务BatteryStatsService
   mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
   mBatteryStatsService.getActiveStatistics().readLocked();
   ...
   //创建进程统计服务，信息保存在目录/data/system/procstats，
   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"));
   // User 0是第一个，也是唯一的一个开机过程中运行的用户
   mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true));
   mUserLru.add(UserHandle.USER_OWNER);
   updateStartedUserArrayLocked();
   ...
   //CPU使用情况的追踪器执行初始化
   mProcessCpuTracker.init();
   ...
   mRecentTasks = new RecentTasks(this);
   // 创建ActivityStackSupervisor对象
   mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
   mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);
   //创建名为"CpuTracker"的线程
   mProcessCpuThread = new Thread("CpuTracker") {
       public void run() {
         while (true) {
           try {
             try {
               synchronized(this) {
                 final long now = SystemClock.uptimeMillis();
                 long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
                 long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
                 if (nextWriteDelay < nextCpuDelay) {
                     nextCpuDelay = nextWriteDelay;
                 }
                 if (nextCpuDelay > 0) {
                     mProcessCpuMutexFree.set(true);
                     this.wait(nextCpuDelay);
                 }
               }
             } catch (InterruptedException e) {
             }
             updateCpuStatsNow(); //更新CPU状态
           } catch (Exception e) {
           }
         }
       }
   };
   ...
}

首先，创建了一个名为“ActivityManager”的消息循环线程，不断地接收其他进程发给AMS的消息；并把该消息循环线程与MainHandler绑定，这样，由MainHandler完成消息的具体处理。
然后，创建了一些服务，并在/data/system目录下创建该服务需要的文件或文件夹，具体如下：

服务 服务说明 文件 文件说明
BatteryStatsService 电池状态管理 /data/system/batterystats.bin 记录包括电压在内的各种电池信息
ProcessStatsService 进程状态管理 /data/system/procstats 记录各个进程的状态信息
AppOpsService 应用操作权限管理 /data/system/appops.xml 存储各个app的权限设置和操作信息
1.2.2 ActivityManagerService.setSystemProcess

首先，向SystemServiceManager中添加了若干个服务：

服务 服务说明
activity AMS服务本身
procstats 进程状态管理
meminfo 获取内存信息
gfxinfo 监控分析GPU profiling信息
dbinfo 数据库相关服务
cpuinfo 获取cpu相关信息
permission 权限控制相关服务

然后，调用PMS的getApplicationInfo接口，获取名为”android”的应用程序信息。包名为”android”的apk即/system/framework/framework-res.apk，里面保存着系统GUI美化的相关文件，包括图标，弹出对话框的样式，动作特效，界面布局等。调用installSystemApplicationInfo加载framework-res.apk文件。

接着，调用newProcessRecordLocked新建一个ProcessRecord 对象app。ProcessRecord用来描述一个进程的所有信息，包括该进程的所有activity和service等。在这里就是system_server（AMS就是在system_server进程中运行的）。创建后，对app的一些成员变量进行初始化，包括设置为常驻内存运行；设置system_server的pid等。

最后，调用mProcessNames.put()将创建的ProcessRecord 对象app加入到ProcessMap< ProcessRecord >类型的成员变量mProcessNames中。这里，app.processName=“system”。

这样，AMS就得到了system_server的ProcessRecord，以后AMS也可以管理system_server了。

二、startOtherServices( )

2.1 systemServer触发的AMS准备工作：
private void startOtherServices() {
 ...
  //移除非系统的provider,安装所有的系统provider,创建核心Settings Observer，用于监控Settings的改变。
 mActivityManagerService.installSystemProviders();
 …
//保存WMS对象
mActivityManagerService.setWindowManager(wm);
 …
//系统启动前的准备工作，启动SystemUI和Home界面等
mActivityManagerService.systemReady(new Runnable() {...});
}
2.2 mActivityManagerService.systemReady()

主要分三个阶段来讲：

public void systemReady(final Runnable goingCallback) {
   before goingCallback.run()
   goingCallback.run()
   after goingCallback.run()
}
2.2.1 before goingCallback.run()
public void systemReady(final Runnable goingCallback){
   if (mSystemReady) {//首次为false，不进入
       if (goingCallback != null) {
           goingCallback.run();
       }
       return;
   }
   mLocalDeviceIdleController = LocalServices.getService(DeviceIdleController.LocalService.class);
   //用户管理、最近任务、应用程序操作权限管理相关验证和准备工作。
   mUserController.onSystemReady();
   mRecentTasks.onSystemReadyLocked();
   mAppOpsService.systemReady();
   mSystemReady = true; //完成之后mSystemReady置为true
}
ArrayList<ProcessRecord> procsToKill = null;
synchronized(mPidsSelfLocked) {
   for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
       ProcessRecord proc = mPidsSelfLocked.valueAt(i);
        //非persistent进程,加入procsToKill
       if (!isAllowedWhileBooting(proc.info)){
           if (procsToKill == null) {
               procsToKill = new ArrayList<ProcessRecord>();
           }
           procsToKill.add(proc);
       }
   }
}
//杀掉procsToKill中的进程, 杀掉进程且不允许重启
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");
       }
   }
   mProcessesReady = true;  //已经为启动进程做好准备
}
Slog.i(TAG, "System now ready");
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_AMS_READY,
   SystemClock.uptimeMillis());
...
}
retrieveSettings();
final int currentUserId;
synchronized (this) {
   currentUserId = mUserController.getCurrentUserIdLocked();
   readGrantedUriPermissionsLocked();
 }
}

此阶段主要工作总结：

  • 在当前运行的进程中，查找在systemReady之前不允许启动的进程，然后调用removeProcessLocked()终止该进程并释放资源。
  • 让系统和进程都处于ready状态 即：
    mSystemReady = true;
    mProcessesReady = true;
    关于mProcessesReady的解读：
    startProcessLocked()过程对于非persistent进程必须等待mProcessesReady = true才会真正创建进程，否则进程放入mProcessesOnHold队列。 由此可见，mProcessesReady为没有处于ready状态之前则基本没有其他进程。
2.2.2 goingCallback.run()

if (goingCallback != null) goingCallback.run();
这部分是回调到systemServer startOtherServices中完成的：

private void startOtherServices() {
mActivityManagerService.systemReady(new Runnable() {
   @Override
   public void run() {
       Slog.i(TAG, "Making services ready");
       mSystemServiceManager.startBootPhase(
               SystemService.PHASE_ACTIVITY_MANAGER_READY);
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "PhaseActivityManagerReady");
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartObservingNativeCrashes");
       try {
           mActivityManagerService.startObservingNativeCrashes();
       } catch (Throwable e) {
           reportWtf("observing native crashes", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       if (!mOnlyCore) {
           Slog.i(TAG, "WebViewFactory preparation");
           Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "WebViewFactoryPreparation");
           mWebViewUpdateService.prepareWebViewInSystemServer();
           Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       }
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartSystemUI");
       try {
           startSystemUi(context);
       } catch (Throwable e) {
           reportWtf("starting System UI", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "MakeNetworkScoreReady");
       try {
           if (networkScoreF != null) networkScoreF.systemReady();
       } catch (Throwable e) {
           reportWtf("making Network Score Service ready", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "MakeNetworkManagementServiceReady");
       try {
           if (networkManagementF != null) networkManagementF.systemReady();
       } catch (Throwable e) {
           reportWtf("making Network Managment Service ready", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "MakeNetworkStatsServiceReady");
       try {
           if (networkStatsF != null) networkStatsF.systemReady();
       } catch (Throwable e) {
           reportWtf("making Network Stats Service ready", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "MakeNetworkPolicyServiceReady");
       try {
           if (networkPolicyF != null) networkPolicyF.systemReady();
       } catch (Throwable e) {
           reportWtf("making Network Policy Service ready", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "MakeConnectivityServiceReady");
       try {
           if (connectivityF != null) connectivityF.systemReady();
       } catch (Throwable e) {
           reportWtf("making Connectivity Service ready", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       Watchdog.getInstance().start();
       // It is now okay to let the various system services start their
       // third party code...
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
       Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "PhaseThirdPartyAppsCanStart");
       mSystemServiceManager.startBootPhase(
               SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
       try {
           if (locationF != null) locationF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying Location Service running", e);
       }
       try {
           if (countryDetectorF != null) countryDetectorF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying CountryDetectorService running", e);
       }
       try {
           if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying NetworkTimeService running", e);
       }
       try {
           if (commonTimeMgmtServiceF != null) {
               commonTimeMgmtServiceF.systemRunning();
           }
       } catch (Throwable e) {
           reportWtf("Notifying CommonTimeManagementService running", e);
       }
       try {
           if (atlasF != null) atlasF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying AssetAtlasService running", e);
       }
       try {
           // TODO(BT) Pass parameter to input manager
           if (inputManagerF != null) inputManagerF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying InputManagerService running", e);
       }
       try {
           if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying TelephonyRegistry running", e);
       }
       try {
           if (mediaRouterF != null) mediaRouterF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying MediaRouterService running", e);
       }
       try {
           if (mmsServiceF != null) mmsServiceF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying MmsService running", e);
       }
       try {
           if (networkScoreF != null) networkScoreF.systemRunning();
       } catch (Throwable e) {
           reportWtf("Notifying NetworkScoreService running", e);
       }
       Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
   }
});
   }
}

此阶段主要工作总结：

  • startBootPhase：550（PHASE_ACTIVITY_MANAGER_READY），回调相应onBootPhase()方法；
  • 启动WebView；
  • 启动systemui服务；
  • startBootPhase：600（PHASE_THIRD_PARTY_APPS_CAN_START），回调相应onBootPhase()方法；
  • 执行一系列服务的systemReady方法；
  • 执行一系列服务的systemRunning方法；
2.2.3 after goingCallback.run()
mSystemServiceManager.startUser(currentUserId);//回调所有SystemService的onStartUser()方法
public void systemReady(final Runnable goingCallback){
synchronized (this) {
    //启动persistent进程
   startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
   // Start up initial activity.
   mBooting = true;
   // Enable home activity for system user, so that the system can always boot
   if (UserManager.isSplitSystemUser()) {
       ComponentName cName = new ComponentName(mContext, SystemUserHomeActivity.class);
       try {
           AppGlobals.getPackageManager().setComponentEnabledSetting(cName,
                   [PackageManager.COMPONENT_ENABLED_STATE_ENABLED](http://PackageManager.COMPONENT_ENABLED_STATE_ENABLED), 0,
                   UserHandle.USER_SYSTEM);
       } catch (RemoteException e) {
           throw e.rethrowAsRuntimeException();
       }
   }
    //启动桌面activity
   startHomeActivityLocked(currentUserId, "systemReady");
   try {
       if (AppGlobals.getPackageManager().hasSystemUidErrors()) {
           Slog.e(TAG, "UIDs on the system are inconsistent, you need to wipe your"
                   + " data partition or your device will be unstable.");
       mUiHandler.obtainMessage(SHOW_UID_ERROR_UI_MSG).sendToTarget();
       }
   } catch (RemoteException e) {
   }
   if (!Build.isBuildConsistent()) {
       Slog.e(TAG, "Build fingerprint is not consistent, warning user");
       mUiHandler.obtainMessage(SHOW_FINGERPRINT_ERROR_UI_MSG).sendToTarget();
   }
   long ident = Binder.clearCallingIdentity();
   try {
        //system发送广播USER_STARTED
       Intent intent = new Intent(Intent.ACTION_USER_STARTED);
       intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
               | Intent.FLAG_RECEIVER_FOREGROUND);
       intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
       broadcastIntentLocked(null, null, intent,
               null, null, 0, null, null, null, AppOpsManager.OP_NONE,
               null, false, false, MY_PID, Process.SYSTEM_UID,
               currentUserId);
       //system发送广播USER_STARTING
       intent = new Intent(Intent.ACTION_USER_STARTING);
       intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
       intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
       broadcastIntentLocked(null, null, intent,
               null, new IIntentReceiver.Stub() {
                   @Override
                   public void performReceive(Intent intent, int resultCode, String data,
                           Bundle extras, boolean ordered, boolean sticky, int sendingUser)
                           throws RemoteException {
                   }
               }, 0, null, null,
               new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE,
               null, true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL);
   } catch (Throwable t) {
       Slog.wtf(TAG, "Failed sending first user broadcasts", t);
   } finally {
       Binder.restoreCallingIdentity(ident);
   }
   mStackSupervisor.resumeFocusedStackTopActivityLocked();
   mUserController.sendUserSwitchBroadcastsLocked(-1, currentUserId);
 }
}

此阶段主要工作总结：

  • 回调所有SystemService的onStartUser()方法；
  • 启动persistent进程；
  • 启动home Activity;
  • 发送广播USER_STARTED和USER_STARTING；
  • 发送广播USER_SWITCHED；

最后画了个简单时序图总结下AMS启动流程：

参考：
https://blog.csdn.net/u010753159/article/details/51581113
http://gityuan.com/2016/02/21/activity-manager-service/

相关文章

网友评论

      本文标题：Android系统启动（五）-ActivityManagerSe

      本文链接：https://www.haomeiwen.com/subject/mdkgxqtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Android系统启动（五）-ActivityManagerSe|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！