本次源码基于Android11分析
相关源码：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
/frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
/packages/apps/Launcher3/src/com/android/launcher3/Launcher.java
/packages/apps/Launcher3/src/com/android/launcher3/LauncherModel.java
/packages/apps/Launcher3/src/com/android/launcher3/model/LoaderTask.java
在前面文章中分别讲解了在SystemServer进程的startBootstrapServices()、startOtherServices()方法中启动了ActivityManagerService(ActivityTaskManagerService)和PackageManagerService系统服务。
- ActivityManagerService：主要负责四大组件的创建和管理。
- PackageManagerService:主要负责安装包的查询、安装、卸载。
系统的桌面进程Launcher就是在ActivityManagerService服务启动完成后开始启动。
Launcher进程启动
ActivityManagerService.systemReady方法中开始了Launcher进程的启动
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
// mAtmInternal为ActivityTaskManagerService.LocalService类
public ActivityTaskManagerInternal mAtmInternal;
// ActivityManagerService准备完成
public void systemReady(final Runnable goingCallback, @NonNull TimingsTraceAndSlog t) {
// 调用启动Launcher进程
mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
}
}
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
RootWindowContainer mRootWindowContainer;
final class LocalService extends ActivityTaskManagerInternal {
@Override
public boolean startHomeOnAllDisplays(int userId, String reason) {
synchronized (mGlobalLock) {
return mRootWindowContainer.startHomeOnAllDisplays(userId, reason);
}
}
}
}
- 在AMS的systemReady方法中启动Launcher进程，但并没有真正的启动进程，这只是一个开始，而后给
ActivityTaskManagerService.LocalService类的startHomeOnAllDisplays方法继续执行。 - 在ActivityTaskManagerService中并没有做处理，而是调用了
RootWindowContainer.startHomeOnAllDisplays方法处理。
RootWindowContainer.startHomeOnAllDisplays通过一系列的调用最终调用到RootWindowContainer.startHomeOnTaskDisplayArea方法：
class RootWindowContainer extends WindowContainer<DisplayContent>
implements DisplayManager.DisplayListener {
ActivityTaskManagerService mService;
boolean startHomeOnAllDisplays(int userId, String reason) {
boolean homeStarted = false;
// getChildCount获取显示设备数目，这个主要从mChildren参数中获取对应的数量
// mChildren是一个WindowList的一个对象，其包含的数据是在setWindowManager函数被调用时，从DisplayManagerService中获取到的Display的数目
for (int i = getChildCount() - 1; i >= 0; i--) {
// 获取到对应新建的DisplayContent的displayId
final int displayId = getChildAt(i).mDisplayId;
// 调用startHomeOnDisplay函数
homeStarted |= startHomeOnDisplay(userId, reason, displayId);
}
return homeStarted;
}
//一系列调用最终调用startHomeOnTaskDisplayArea.......
boolean startHomeOnTaskDisplayArea(int userId, String reason, TaskDisplayArea taskDisplayArea,
boolean allowInstrumenting, boolean fromHomeKey) {
// Fallback to top focused display area if the provided one is invalid.
if (taskDisplayArea == null) {
final ActivityStack stack = getTopDisplayFocusedStack();
taskDisplayArea = stack != null ? stack.getDisplayArea()
: getDefaultTaskDisplayArea();
}
Intent homeIntent = null;
ActivityInfo aInfo = null;
if (taskDisplayArea == getDefaultTaskDisplayArea()) {
// 1.向ActivityTaskManagerService获取 Launcher 的启动意图
homeIntent = mService.getHomeIntent();
//2. 向PackageManagerService通过意图解析到 ActivityInfo
aInfo = resolveHomeActivity(userId, homeIntent);
} else if (shouldPlaceSecondaryHomeOnDisplayArea(taskDisplayArea)) {
Pair<ActivityInfo, Intent> info = resolveSecondaryHomeActivity(userId, taskDisplayArea);
aInfo = info.first;
homeIntent = info.second;
}
if (aInfo == null || homeIntent == null) {
return false;
}
if (!canStartHomeOnDisplayArea(aInfo, taskDisplayArea, allowInstrumenting)) {
return false;
}
// Updates the home component of the intent.
homeIntent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
homeIntent.setFlags(homeIntent.getFlags() | FLAG_ACTIVITY_NEW_TASK);
// Updates the extra information of the intent.
if (fromHomeKey) {
homeIntent.putExtra(WindowManagerPolicy.EXTRA_FROM_HOME_KEY, true);
mWindowManager.cancelRecentsAnimation(REORDER_KEEP_IN_PLACE, "startHomeActivity");
}
// Update the reason for ANR debugging to verify if the user activity is the one that
// actually launched.
final String myReason = reason + ":" + userId + ":" + UserHandle.getUserId(
aInfo.applicationInfo.uid) + ":" + taskDisplayArea.getDisplayId();
// 根据homeIntent、aInfo，调用 startHomeActivity 方法去启动和创建 Launcher
mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
taskDisplayArea);
return true;
}
// 根据Intent的Component向PackageManagerService找到对应的ActivityInfo
ActivityInfo resolveHomeActivity(int userId, Intent homeIntent) {
final int flags = ActivityManagerService.STOCK_PM_FLAGS;
final ComponentName comp = homeIntent.getComponent();
ActivityInfo aInfo = null;
try {
if (comp != null) {
// Factory test.
aInfo = AppGlobals.getPackageManager().getActivityInfo(comp, flags, userId);
} else {
final String resolvedType =
homeIntent.resolveTypeIfNeeded(mService.mContext.getContentResolver());
final ResolveInfo info = AppGlobals.getPackageManager()
.resolveIntent(homeIntent, resolvedType, flags, userId);
if (info != null) {
aInfo = info.activityInfo;
}
}
} catch (RemoteException e) {
// ignore
}
if (aInfo == null) {
Slog.wtf(TAG, "No home screen found for " + homeIntent, new Throwable());
return null;
}
aInfo = new ActivityInfo(aInfo);
aInfo.applicationInfo = mService.getAppInfoForUser(aInfo.applicationInfo, userId);
return aInfo;
}
}
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
String mTopAction = Intent.ACTION_MAIN;
String mTopData;
// homeIntent.action = Intent.ACTION_MAIN ACTION_MAIN = "android.intent.action.MAIN"
// homeIntent的flags包含Intent.FLAG_DEBUG_TRIAGED_MISSING
// homeIntent的category包含Intent.CATEGORY_HOME CATEGORY_HOME = "android.intent.category.HOME";
Intent getHomeIntent() {
Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null);
intent.setComponent(mTopComponent);
intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
intent.addCategory(Intent.CATEGORY_HOME);
}
return intent;
}
}
代码很长，但不外乎做了两件事：
- 调用ActivityTaskManagerService.getHomeIntent方法获取Intent意图
- 根据意图Intent.Component向PackageManagerService查询对应的ActivityInfo
最后，通过ActivityStartController.startHomeActivity方法,通过层层调用最后调用Process.start方法去启动和创建Launcher。关于后面进程的创建和Activity的启动后面文章讲解，本篇继续分析Launcher启动后如何查询所有App信息
Launcher查询App信息
在LauncherActivity中，会在onCreate方法去查询所有App信息：
public class Launcher extends StatefulActivity<LauncherState> implements LauncherExterns,
Callbacks, InvariantDeviceProfile.OnIDPChangeListener, PluginListener<OverlayPlugin> {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 实例化LauncherAppState
LauncherAppState app = LauncherAppState.getInstance(this);
// 根据LauncherAppState获取到LauncherModel
mModel = app.getModel();
// LauncherModel.addCallbacksAndLoad就会去查询App信息
if (!mModel.addCallbacksAndLoad(this)) {
if (!internalStateHandled) {
// If we are not binding synchronously, show a fade in animation when
// the first page bind completes.
mDragLayer.getAlphaProperty(ALPHA_INDEX_LAUNCHER_LOAD).setValue(0);
}
}
}
}
在onCreate中通过调用LauncherModel.addCallbacksAndLoad去查询App信息，此方法通过一个Handler去执行一个Runnable去执行查询任务。
public class LauncherModel extends LauncherApps.Callback implements InstallSessionTracker.Callback {
// Launcher也实现了Callbacks
public boolean addCallbacksAndLoad(Callbacks callbacks) {
synchronized (mLock) {
// 将Launcher加入到回调列表
addCallbacks(callbacks);
// 调用startLoader()
return startLoader();
}
}
public boolean startLoader() {
synchronized (mLock) {
//.....
stopLoader();
LoaderResults loaderResults = new LoaderResults(
mApp, mBgDataModel, mBgAllAppsList, callbacksList, mMainExecutor);
// 开始查询App信息
startLoaderForResults(loaderResults);
return false;
}
}
public void startLoaderForResults(LoaderResults results) {
synchronized (mLock) {
stopLoader();
// LoaderTask是一个Runnable
mLoaderTask = new LoaderTask(mApp, mBgAllAppsList, mBgDataModel, results);
// Handler去执行LoaderTask
MODEL_EXECUTOR.post(mLoaderTask);
}
}
}
通过对重点代码的查看，LauncherModel只是发送了一个LoaderTask的Runnable让Handler去执行。所以查询App在LoaderTask类的run()方法中。
public class LoaderTask implements Runnable {
public void run() {
//.....
// 加载所有App
List<LauncherActivityInfo> allActivityList = loadAllApps();
//.....
}
// 查询所有App
private List<LauncherActivityInfo> loadAllApps() {
final List<UserHandle> profiles = mUserCache.getUserProfiles();
List<LauncherActivityInfo> allActivityList = new ArrayList<>();
// Clear the list of apps
mBgAllAppsList.clear();
for (UserHandle user : profiles) {
// Query for the set of apps
final List<LauncherActivityInfo> apps = mLauncherApps.getActivityList(null, user);
// Fail if we don't have any apps
// TODO: Fix this. Only fail for the current user.
if (apps == null || apps.isEmpty()) {
return allActivityList;
}
//....
allActivityList.addAll(apps);
}
//.....
return allActivityList;
}
}
public class LauncherApps {
public List<LauncherActivityInfo> getActivityList(String packageName, UserHandle user) {
logErrorForInvalidProfileAccess(user);
try {
return convertToActivityList(mService.getLauncherActivities(mContext.getPackageName(),
packageName, user), user);
} catch (RemoteException re) {
throw re.rethrowFromSystemServer();
}
}
}
LoaderTask的run的方法会查询所有App的信息。
总结
Launcher是系统的桌面进程，它是由ActivityManagerService完成准备后开始启动的，启动的时候会通过向ActivityManagerService获取Intent意图和向PackageManagerService获取对应ActivityInfo。Launcher Activity启动后会向在onCreate()方法中查询所有App信息。
网友评论