AMS システムサービスマネージャーによる起動#
public final class SystemServer implements Dumpable {
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
... 省略部分
try {
t.traceBegin("StartServices");
// AMS はブートサービスです
startBootstrapServices(t); // ブートサービスを起動
startCoreServices(t); // コアサービスを起動
startOtherServices(t); // その他のサービスを起動
startApexServices(t); // Apexサービスを起動
} /*省略 catch*/
... 省略部分
}
// AMS を起動する関数
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
... 省略部分
// アクティビティマネージャーがショーを実行します。
// ActivityTaskManagerService クラスを作成したことに相当します
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
// ActivityManagerService.Lifecycle.startService を分析
mActivityManagerService = ActivityManagerService
.Lifecycle.startService( // startService は onStart メソッドを呼び出します
mSystemServiceManager,
atm
);
... 省略部分
// その後の分析
mActivityManagerService.setSystemProcess();
... 省略部分
}
}
AMS AMS#Lifecycle 内部クラスによる作成#
// ActivityManagerService.java
// SystemService (抽象クラス) を継承
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
private static ActivityTaskManagerService sAtm;
public Lifecycle(Context context) {
super(context);
// AMS を作成
mService = new ActivityManagerService(context, sAtm);
}
// SystemService#startService は onStart メソッドを呼び出します
@Override
public void onStart() {
// AMS プライベート関数 start()
mService.start();
}
... 省略部分
}
SystemService#startService が onStart メソッドを呼び出す#
// ActivityManagerService.java
private void start() {
// バッテリー統計サービスを起動
mBatteryStatsService.publish();
mAppOpsService.publish();
Slog.d("AppOps", "AppOpsService published");
// ローカル LocalServices に追加
LocalServices.addService(ActivityManagerInternal.class, mInternal);
LocalManagerRegistry.addManager(ActivityManagerLocal.class,
(ActivityManagerLocal) mInternal);
mActivityTaskManager.onActivityManagerInternalAdded();
mPendingIntentController.onActivityManagerInternalAdded();
mAppProfiler.onActivityManagerInternalAdded();
}
コンストラクタ#
// /services/core/java/com/android/server/am/ActivityManagerService.java
// AMS 構築関数
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
mInjector = new Injector(systemContext);
// システムレベルの Context
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
// 現在の ActivityThread を取得
mSystemThread = ActivityThread.currentActivityThread();
// システム UiContext を取得
mUiContext = mSystemThread.getSystemUiContext();
Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
// Handler メッセージを処理する Handler Thread を作成
mHandlerThread = new ServiceThread(TAG,
THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
// UI 関連メッセージを処理する Handler
mUiHandler = mInjector.getUiHandler(this);
mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
mProcStartHandlerThread.start();
// プロセス起動の Handler
mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
// AMS の定数を管理し、ベンダーがシステムを変更する可能性があります
mConstants = new ActivityManagerConstants(mContext, this, mHandler);
final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
mPlatformCompat = (PlatformCompat) ServiceManager.getService(
Context.PLATFORM_COMPAT_SERVICE);
mProcessList = mInjector.getProcessList(this);
mProcessList.init(this, activeUids, mPlatformCompat);
mAppProfiler = new AppProfiler(this, BackgroundThread.getHandler().getLooper(),
new LowMemDetector(this));
mPhantomProcessList = new PhantomProcessList(this);
mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
// ブロードキャストポリシーパラメータ
// 前台、バックグラウンド、アンインストールブロードキャストキューを初期化
// システムは前台ブロードキャストを優先的に送信します
final BroadcastConstants foreConstants = new BroadcastConstants(
Settings.Global.BROADCAST_FG_CONSTANTS); // 前台
foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
final BroadcastConstants backConstants = new BroadcastConstants(
Settings.Global.BROADCAST_BG_CONSTANTS); // バックグラウンド
backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
final BroadcastConstants offloadConstants = new BroadcastConstants(
Settings.Global.BROADCAST_OFFLOAD_CONSTANTS); // アンインストール
offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
// デフォルトでは、このキューに「遅い」ポリシーはありません
offloadConstants.SLOW_TIME = Integer.MAX_VALUE;
mEnableOffloadQueue = SystemProperties.getBoolean(
"persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", foreConstants, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", backConstants, true);
mBgOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
"offload_bg", offloadConstants, true);
mFgOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
"offload_fg", foreConstants, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
mBroadcastQueues[2] = mBgOffloadBroadcastQueue;
mBroadcastQueues[3] = mFgOffloadBroadcastQueue;
// サービスを管理する ActiveServices オブジェクトを初期化
mServices = new ActiveServices(this);
// ContentProvider を初期化
mCpHelper = new ContentProviderHelper(this, true);
// パッケージ WatchDog
mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
// APP エラーログ記録コンポーネントを初期化
mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
mUidObserverController = new UidObserverController(mUiHandler);
// システムディレクトリを取得
final File systemDir = SystemServiceManager.ensureSystemDir();
// TODO: ActivityManagerService の外でバッテリー統計サービスを作成する。
// バッテリー統計サービスを作成
mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
BackgroundThread.get().getHandler());
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.scheduleWriteToDisk();
mOnBattery = DEBUG_POWER ? true
: mBatteryStatsService.getActiveStatistics().getIsOnBattery();
// プロセス統計分析サービスを作成し、プロセスの乱用や悪行を追跡
mBatteryStatsService.getActiveStatistics().setCallback(this);
mOomAdjProfiler.batteryPowerChanged(mOnBattery);
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
// マルチユーザーを管理する責任
mUserController = new UserController(this);
mPendingIntentController = new PendingIntentController(
mHandlerThread.getLooper(), mUserController, mConstants);
// システムプロパティを初期化
mUseFifoUiScheduling = SystemProperties.getInt("sys.use_fifo_ui", 0) != 0;
mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
// ActivityTaskManager に付与
mActivityTaskManager = atm;
// 初期化、内部で ActivityStackSupervisor クラスを作成します
// ActivityStackSupervisor は Activity の状態情報を記録し、AMS のコアクラスです
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
DisplayThread.get().getLooper());
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
mSdkSandboxSettings = new SdkSandboxSettings(mContext);
// Watchdog 監視 (プロセスが異常な場合は Kill されます)
Watchdog.getInstance().addMonitor(this);
Watchdog.getInstance().addThread(mHandler);
// バックグラウンドスレッドを小さなコアにバインド
// フレームワークテスト内で失敗することが予想されます。アプリは直接 cpusets に触れられません
// まず、system_server の内部ビューを調整したことを確認してください
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
try {
Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
Process.THREAD_GROUP_SYSTEM);
Process.setThreadGroupAndCpuset(
mOomAdjuster.mCachedAppOptimizer.mCachedAppOptimizerThread.getThreadId(),
Process.THREAD_GROUP_SYSTEM);
} catch (Exception e) {
Slog.w(TAG, "Setting background thread cpuset failed");
}
mInternal = new LocalService();
mPendingStartActivityUids = new PendingStartActivityUids(mContext);
mTraceErrorLogger = new TraceErrorLogger();
mComponentAliasResolver = new ComponentAliasResolver(this);
}
AMS#setSystemProcess メソッドは、単に自分自身 (AMS) のサーバーを Binder ドライバーに登録するだけでなく、一連のプロセス関連サービスも登録します。以下の表では、いくつかの一般的なサービス項目について言及します。
// /ActivityManagerService.java
public void setSystemProcess() {
try {
// AMS を登録
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
// ProcessStatsService を登録
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_HIGH);
// 以下、さまざまなサービスを登録
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this),
/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
}
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
ServiceManager.addService("cacheinfo", new CacheBinder(this));
// PackageManagerService のインターフェースを呼び出し、パッケージ名が android のアプリ App の ApplicationInfo 情報を取得
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
// Activity#installSystemApplicationInfo 関数を分析
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
// ProcessRecord オブジェクトを作成し、AMS オブジェクト情報を保存
synchronized (this) {
ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
false,
0,
new HostingRecord("system"));
app.setPersistent(true);
app.setPid(MY_PID);
app.mState.setMaxAdj(ProcessList.SYSTEM_ADJ);
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
addPidLocked(app);
updateLruProcessLocked(app, false, null);
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
}
... 省略部分
} catch (PackageManager.NameNotFoundException e) {
throw new RuntimeException(
"Unable to find android system package", e);
}
... 省略部分
}
Binder - AMS 機能#
すべての AMS 機能を知るには、IActivityManager を調べるのが最適です。これには、AMS が提供するすべての機能が含まれています。以下は、いくつかのカテゴリに分けて説明します。
コンポーネント状態 - 管理: 4 つの主要コンポーネントの管理、startActivity、startActivityAndWait、startService、stopService、removeContentProvider … など
コンポーネント状態 - クエリ: 現在のコンポーネントの実行状況を確認する getCallingActivity、getServices… など
タスク関連：タスク関連の関数、removeSubTask、remove Task … など
その他: getMemoryInfo、setDebugApp… など
AMS 重点クラス#
| AMS 関連クラス | 機能 |
|---|---|
| ActivityStackSupervisor | Activity Stack を管理 |
| ClientLifecycleManager | Android 28 以降に追加され、Activity のライフサイクルを管理 |
| ActivityStart | Activity スターターで、Activity の起動の詳細も管理 |
| ActivityStartController | ActivityStart のインスタンスを生成し、再利用 |
| ActivityTaskManagerService (略称 ATMS) | Android のコアサービスで、4 つの主要コンポーネントを起動します |
| ActivityTaskManager | Activity と ATMS の間のプロセス間通信のインターフェースで、ATMS の補助クラス |
| ProcessRecord | 身分を記述するデータ |
| RecentTasks | 最近開いた Activity |
| App 関連クラス | 機能 |
|---|---|
| ActivityThread | アプリケーションのエントリーポイントで、メインスレッドを起動 |
ActivityThread#ApplicationThread | ApplicationThread は ActivityThread の内部クラスで、IApplication.Sub を継承し、APP と AMS の通信のサービス側 |
| Instrumentation | Activity の起動、終了などの操作をフックし、アプリ APP と AMS の相互作用はすべて Instrumentation を介して行われます |
| ActivityStack | スタック単位 (AndroidManifest の 4 つの起動方法に関連) で、複数の Activity を管理 |
ProcessRecord プロセス管理#
ProcessRecord クラス - プロセス関連情報
| パラメータ | 説明 |
|---|---|
| info : ApplicationInfo | AndroidManifest.xml に定義された <\application> タグに関連する情報 |
| isolated : Boolean | isolated プロセス |
| uid : int | ユーザー ID |
| pid : int | プロセス ID |
| gids : int[] | グループ ID |
| userId : int | Android のマルチユーザーシステム ID (Windows のマルチユーザー機能に似ています) |
| processName : String | プロセス名、デフォルトではパッケージ名を使用 |
| uidRecord : UidRecord | 使用される uid を記録 |
| thread : IApplicationThread | このオブジェクトを介して AMS が APP にメッセージを送信します。このオブジェクトが null でない場合、APK は使用可能です |
| procStatFile：String | proc ディレクトリ内の各プロセスには、pid で命名されたディレクトリファイルがあり、そのファイルはプロセスに関連するすべての情報を記録します。このディレクトリは Linux カーネルによって作成されます |
| compat : CompatibilityInfo | 互換性情報 |
| requiredAbi : String | abi 情報 |
| instructionSet : String | 命令セット |
| mPkgDeps : ArraySet | 現在のプロセスが依存しているパッケージ |
ProcessRecord クラス - プロセスコンポーネントを記述
| パラメータ | 説明 |
|---|---|
| maxAdj : int | プロセスの Adj 上限 (adjustment) |
| curRawAdj : int | 現在計算中の adj。この値は maxAdj より大きくなる可能性があります。 |
ProcessRecord クラス - プロセスコンポーネントを記述（4 つの主要コンポーネント関連）
| パラメータ | 説明 | その他 |
|---|---|---|
| mWindowProcessController : WindowProcessController | WindowProcessController を介してすべての Activity を管理 | Activity は ActivityRecord で表されます |
| mServices : ProcessServiceRecord | このプロセス内のすべての Service | Service は ServiceRecord で表されます |
| mProviders : ProcessProviderRecord | このプロセス内のすべての Provider | ContentProvider は ContentProviderRecord で表されます |
| mReceivers : ProcessReceiverRecord | このプロセス内のすべての Receiver | ContentProvider は BroadcastRecord で表されます |
ActivityRecord - Activity#
ActivityRecord は Activity のすべての情報を記録し、履歴スタック内の Activity です。内部には ActivityInfo (AndroidManifest 設定)、task サービスが記録されています。
final class ActivityRecord extends WindowToken implements WindowManagerService.AppFreezeListener {
// 所属する Task サービス
final ActivityTaskManagerService mAtmService;
// AndroidManifest 設定の値
final ActivityInfo info;
// WindowsManager トークン
final ActivityRecord.Token appToken;
// プライベートコンストラクタ
// ビルダーパターンを介して ActivityRecord オブジェクトを構築
private ActivityRecord(ActivityTaskManagerService _service, WindowProcessController _caller,
int _launchedFromPid, int _launchedFromUid, String _launchedFromPackage,
@Nullable String _launchedFromFeature, Intent _intent, String _resolvedType,
ActivityInfo aInfo, ... /* 省略部份*/ ) {
... 省略部分
}
}
// ActivityStarter.java
// 最後に起動を試みたアクティビティレコード
private ActivityRecord mLastStartActivityRecord;
private int executeRequest(Request request) {
...省略 Request 分析
// ビルダーを介して AcitiviyRecord を作成
final ActivityRecord r = new ActivityRecord.Builder(mService)
.setCaller(callerApp) // 各種パラメータを設定
.setLaunchedFromPid(callingPid)
.setLaunchedFromUid(callingUid)
.setLaunchedFromPackage(callingPackage)
.setLaunchedFromFeature(callingFeatureId)
.setIntent(intent)
.setResolvedType(resolvedType)
.setActivityInfo(aInfo)
.setConfiguration(mService.getGlobalConfiguration())
.setResultTo(resultRecord)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setComponentSpecified(request.componentSpecified)
.setRootVoiceInteraction(voiceSession != null)
.setActivityOptions(checkedOptions)
.setSourceRecord(sourceRecord)
.build();
// 現在の Activity
mLastStartActivityRecord = r;
... 省略部分
}
Activity の起動 - ActivityTaskManagerService を呼び出す#
ActivityTaskManagerService はシステムサービスでもあり（Binder ドライバーに登録されています）、アプリ側が呼び出すには代理を介する必要があります。この代理が ActivityTaskManager です。
// Activity.java
public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory2,
Window.Callback, KeyEvent.Callback,
...省略部分インターフェース {
/*package*/ ActivityThread mMainThread;
private Instrumentation mInstrumentation;
@Override
public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
... 省略部分
// @ startActivityForResult メソッドを分析
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
// @ execStartActivity メソッドを分析
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this,
// ApplicationThread
mMainThread.getApplicationThread(),
mToken, this,
intent, requestCode, options);
... 省略部分
} else {
... 省略部分
}
}
}
// ---------------------------------------------------------
// ActivityThread .java
public final class ActivityThread extends ClientTransactionHandler
implements ActivityThreadInternal {
// アプリケーションスレッドは一つだけ
final ApplicationThread mAppThread = new ApplicationThread();
public ApplicationThread getApplicationThread()
{
return mAppThread;
}
private class ApplicationThread extends IApplicationThread.Stub {
... 省略細節
}
}
```
- ```java
// Instrumentation.java
public class Instrumentation {
public ActivityResult execStartActivity(
Context who,
IBinder contextThread, // IApplicationThread
IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
... 省略部分
try {
...省略部分
// ActivityTaskManager#startActivity 関数を起動
// whoThread は IApplicationThread です
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getBasePackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
// AMS の結果をチェック
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
}
// ActivityTaskManagerService.java
// SystemService によって起動されたシステムプロセス
// IActivityTaskManager.Stub はサービス側の実装です
public class ActivityTaskManagerService extends IActivityTaskManager.Stub { // IActivityTaskManager は IDE 自動生成クラス
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
}