Android应用程序安装过程源代码分析

2023-07-20 11:58:58

文章转载至CSDN社区罗升阳的安卓之旅，原文地址：http://blog.csdn.net/luoshengyang/article/details/6766010

Android系统在启动的过程中，会启动一个应用程序管理服务PackageManagerService，这个服务 负责扫描系统中特定的目录，找到里面的应用程序文件，即以Apk为后缀的文件，然后对这些文件进解析，得到应用程序的相关信息，完成应用程序的安装过程， 本文将详细分析这个过程。

应用程序管理服务PackageManagerService安装应用程序的过程，其实就是解析析应用程序配置文件 AndroidManifest.xml的过程，并从里面得到得到应用程序的相关信息，例如得到应用程序的组件Activity、Service、 Broadcast Receiver和Content Provider等信息，有了这些信息后，通过ActivityManagerService这个服务，我们就可以在系统中正常地使用这些应用程序了。

应用程序管理服务PackageManagerService是系统启动的时候由SystemServer组件启动的，启后它就会执行应用程序安装的过 程，因此，本文将从SystemServer启动PackageManagerService服务的过程开始分析系统中的应用程序安装的过程。

应用程序管理服务PackageManagerService从启动到安装应用程序的过程如下图所示：

Android应用程序安装过程源代码分析

下面我们具体分析每一个步骤。

Step 1. SystemServer.main

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

  1. public class SystemServer
  2. {
  3. ......
  4. native public static void init1(String[] args);
  5. ......
  6. public static void main(String[] args) {
  7. ......
  8. init1(args);
  9. ......
  10. }
  11. ......
  12. }

SystemServer组件是由Zygote进程负责启动的，启动的时候就会调用它的main函数，这个函数主要调用了JNI方法init1来做一些系统初始化的工作。

Step 2. SystemServer.init1

这个函数是一个JNI方法，实现在 frameworks/base/services/jni/com_android_server_SystemServer.cpp文件中：

  1. namespace android {
  2. extern "C" int system_init();
  3. static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
  4. {
  5. system_init();
  6. }
  7. /*
  8. * JNI registration.
  9. */
  10. static JNINativeMethod gMethods[] = {
  11. /* name, signature, funcPtr */
  12. { "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 },
  13. };
  14. int register_android_server_SystemServer(JNIEnv* env)
  15. {
  16. return jniRegisterNativeMethods(env, "com/android/server/SystemServer",
  17. gMethods, NELEM(gMethods));
  18. }
  19. }; // namespace android

这个函数很简单，只是调用了system_init函数来进一步执行操作。

Step 3. libsystem_server.system_init

函数system_init实现在libsystem_server库中，源代码位于frameworks/base/cmds/system_server/library/system_init.cpp文件中：

  1. extern "C" status_t system_init()
  2. {
  3. LOGI("Entered system_init()");
  4. sp<ProcessState> proc(ProcessState::self());
  5. sp<IServiceManager> sm = defaultServiceManager();
  6. LOGI("ServiceManager: %p\n", sm.get());
  7. sp<GrimReaper> grim = new GrimReaper();
  8. sm->asBinder()->linkToDeath(grim, grim.get(), 0);
  9. char propBuf[PROPERTY_VALUE_MAX];
  10. property_get("system_init.startsurfaceflinger", propBuf, "1");
  11. if (strcmp(propBuf, "1") == 0) {
  12. // Start the SurfaceFlinger
  13. SurfaceFlinger::instantiate();
  14. }
  15. // Start the sensor service
  16. SensorService::instantiate();
  17. // On the simulator, audioflinger et al don't get started the
  18. // same way as on the device, and we need to start them here
  19. if (!proc->supportsProcesses()) {
  20. // Start the AudioFlinger
  21. AudioFlinger::instantiate();
  22. // Start the media playback service
  23. MediaPlayerService::instantiate();
  24. // Start the camera service
  25. CameraService::instantiate();
  26. // Start the audio policy service
  27. AudioPolicyService::instantiate();
  28. }
  29. // And now start the Android runtime.  We have to do this bit
  30. // of nastiness because the Android runtime initialization requires
  31. // some of the core system services to already be started.
  32. // All other servers should just start the Android runtime at
  33. // the beginning of their processes's main(), before calling
  34. // the init function.
  35. LOGI("System server: starting Android runtime.\n");
  36. AndroidRuntime* runtime = AndroidRuntime::getRuntime();
  37. LOGI("System server: starting Android services.\n");
  38. runtime->callStatic("com/android/server/SystemServer", "init2");
  39. // If running in our own process, just go into the thread
  40. // pool.  Otherwise, call the initialization finished
  41. // func to let this process continue its initilization.
  42. if (proc->supportsProcesses()) {
  43. LOGI("System server: entering thread pool.\n");
  44. ProcessState::self()->startThreadPool();
  45. IPCThreadState::self()->joinThreadPool();
  46. LOGI("System server: exiting thread pool.\n");
  47. }
  48. return NO_ERROR;
  49. }

这个函数首先会初始化SurfaceFlinger、SensorService、AudioFlinger、MediaPlayerService、 CameraService和AudioPolicyService这几个服务，然后就通过系统全局唯一的AndroidRuntime实例变量 runtime的callStatic来调用SystemServer的init2函数了。关于这个AndroidRuntime实例变量runtime 的相关资料，可能参考前面一篇文章Android应用程序进程启动过程的源代码分析一文。

Step 4. AndroidRuntime.callStatic

这个函数定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

  1. /*
  2. * Call a static Java Programming Language function that takes no arguments and returns void.
  3. */
  4. status_t AndroidRuntime::callStatic(const char* className, const char* methodName)
  5. {
  6. JNIEnv* env;
  7. jclass clazz;
  8. jmethodID methodId;
  9. env = getJNIEnv();
  10. if (env == NULL)
  11. return UNKNOWN_ERROR;
  12. clazz = findClass(env, className);
  13. if (clazz == NULL) {
  14. LOGE("ERROR: could not find class '%s'\n", className);
  15. return UNKNOWN_ERROR;
  16. }
  17. methodId = env->GetStaticMethodID(clazz, methodName, "()V");
  18. if (methodId == NULL) {
  19. LOGE("ERROR: could not find method %s.%s\n", className, methodName);
  20. return UNKNOWN_ERROR;
  21. }
  22. env->CallStaticVoidMethod(clazz, methodId);
  23. return NO_ERROR;
  24. }

这个函数调用由参数className指定的java类的静态成员函数，这个静态成员函数是由参数methodName指定的。上面传进来的参数 className的值为"com/android/server/SystemServer"，而参数methodName的值为"init2"，因 此，接下来就会调用SystemServer类的init2函数了。

Step 5. SystemServer.init2

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

  1. public class SystemServer
  2. {
  3. ......
  4. public static final void init2() {
  5. Slog.i(TAG, "Entered the Android system server!");
  6. Thread thr = new ServerThread();
  7. thr.setName("android.server.ServerThread");
  8. thr.start();
  9. }
  10. }

这个函数创建了一个ServerThread线程，PackageManagerService服务就是这个线程中启动的了。这里调用了ServerThread实例thr的start函数之后，下面就会执行这个实例的run函数了。

Step 6. ServerThread.run

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

  1. class ServerThread extends Thread {
  2. ......
  3. @Override
  4. public void run() {
  5. ......
  6. IPackageManager pm = null;
  7. ......
  8. // Critical services...
  9. try {
  10. ......
  11. Slog.i(TAG, "Package Manager");
  12. pm = PackageManagerService.main(context,
  13. factoryTest != SystemServer.FACTORY_TEST_OFF);
  14. ......
  15. } catch (RuntimeException e) {
  16. Slog.e("System", "Failure starting core service", e);
  17. }
  18. ......
  19. }
  20. ......
  21. }

这个函数除了启动PackageManagerService服务之外，还启动了其它很多的服务，例如在前面学习Activity和Service的几篇文章中经常看到的ActivityManagerService服务，有兴趣的读者可以自己研究一下。

Step 7. PackageManagerService.main

这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

  1. class PackageManagerService extends IPackageManager.Stub {
  2. ......
  3. public static final IPackageManager main(Context context, boolean factoryTest) {
  4. PackageManagerService m = new PackageManagerService(context, factoryTest);
  5. ServiceManager.addService("package", m);
  6. return m;
  7. }
  8. ......
  9. }

这个函数创建了一个PackageManagerService服务实例，然后把这个服务添加到ServiceManager中
去，ServiceManager是Android系统Binder进程间通信机制的守护进程，负责管理系统中的Binder对象，具体可以参考浅谈Service Manager成为Android进程间通信（IPC）机制Binder守护进程之路一文。
        在创建这个PackageManagerService服务实例时，会在PackageManagerService类的构造函数中开始执行安装应用程序的过程：

  1. class PackageManagerService extends IPackageManager.Stub {
  2. ......
  3. public PackageManagerService(Context context, boolean factoryTest) {
  4. ......
  5. synchronized (mInstallLock) {
  6. synchronized (mPackages) {
  7. ......
  8. File dataDir = Environment.getDataDirectory();
  9. mAppDataDir = new File(dataDir, "data");
  10. mSecureAppDataDir = new File(dataDir, "secure/data");
  11. mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
  12. ......
  13. mFrameworkDir = new File(Environment.getRootDirectory(), "framework");
  14. mDalvikCacheDir = new File(dataDir, "dalvik-cache");
  15. ......
  16. // Find base frameworks (resource packages without code).
  17. mFrameworkInstallObserver = new AppDirObserver(
  18. mFrameworkDir.getPath(), OBSERVER_EVENTS, true);
  19. mFrameworkInstallObserver.startWatching();
  20. scanDirLI(mFrameworkDir, PackageParser.PARSE_IS_SYSTEM
  21. | PackageParser.PARSE_IS_SYSTEM_DIR,
  22. scanMode | SCAN_NO_DEX, 0);
  23. // Collect all system packages.
  24. mSystemAppDir = new File(Environment.getRootDirectory(), "app");
  25. mSystemInstallObserver = new AppDirObserver(
  26. mSystemAppDir.getPath(), OBSERVER_EVENTS, true);
  27. mSystemInstallObserver.startWatching();
  28. scanDirLI(mSystemAppDir, PackageParser.PARSE_IS_SYSTEM
  29. | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
  30. // Collect all vendor packages.
  31. mVendorAppDir = new File("/vendor/app");
  32. mVendorInstallObserver = new AppDirObserver(
  33. mVendorAppDir.getPath(), OBSERVER_EVENTS, true);
  34. mVendorInstallObserver.startWatching();
  35. scanDirLI(mVendorAppDir, PackageParser.PARSE_IS_SYSTEM
  36. | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
  37. mAppInstallObserver = new AppDirObserver(
  38. mAppInstallDir.getPath(), OBSERVER_EVENTS, false);
  39. mAppInstallObserver.startWatching();
  40. scanDirLI(mAppInstallDir, 0, scanMode, 0);
  41. mDrmAppInstallObserver = new AppDirObserver(
  42. mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false);
  43. mDrmAppInstallObserver.startWatching();
  44. scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,
  45. scanMode, 0);
  46. ......
  47. }
  48. }
  49. }
  50. ......
  51. }

这里会调用scanDirLI函数来扫描移动设备上的下面这五个目录中的Apk文件：

/system/framework

        /system/app

        /vendor/app

        /data/app

        /data/app-private

Step 8. PackageManagerService.scanDirLI
       这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

  1. class PackageManagerService extends IPackageManager.Stub {
  2. ......
  3. private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
  4. String[] files = dir.list();
  5. ......
  6. int i;
  7. for (i=0; i<files.length; i++) {
  8. File file = new File(dir, files[i]);
  9. if (!isPackageFilename(files[i])) {
  10. // Ignore entries which are not apk's
  11. continue;
  12. }
  13. PackageParser.Package pkg = scanPackageLI(file,
  14. flags|PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime);
  15. // Don't mess around with apps in system partition.
  16. if (pkg == null && (flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
  17. mLastScanError == PackageManager.INSTALL_FAILED_INVALID_APK) {
  18. // Delete the apk
  19. Slog.w(TAG, "Cleaning up failed install of " + file);
  20. file.delete();
  21. }
  22. }
  23. }
  24. ......
  25. }

对于目录中的每一个文件，如果是以后Apk作为后缀名，那么就调用scanPackageLI函数来对它进行解析和安装。

Step 9. PackageManagerService.scanPackageLI

这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

  1. class PackageManagerService extends IPackageManager.Stub {
  2. ......
  3. private PackageParser.Package scanPackageLI(File scanFile,
  4. int parseFlags, int scanMode, long currentTime) {
  5. ......
  6. String scanPath = scanFile.getPath();
  7. parseFlags |= mDefParseFlags;
  8. PackageParser pp = new PackageParser(scanPath);
  9. ......
  10. final PackageParser.Package pkg = pp.parsePackage(scanFile,
  11. scanPath, mMetrics, parseFlags);
  12. ......
  13. return scanPackageLI(pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE, currentTime);
  14. }
  15. ......
  16. }

这个函数首先会为这个Apk文件创建一个PackageParser实例，接着调用这个实例的parsePackage函数来对这个Apk文件进行解
析。这个函数最后还会调用另外一个版本的scanPackageLI函数把来解析后得到的应用程序信息保存在PackageManagerService
中。

Step 10. PackageParser.parsePackage
        这个函数定义在frameworks/base/core/java/android/content/pm/PackageParser.java文件中：

  1. public class PackageParser {
  2. ......
  3. public Package parsePackage(File sourceFile, String destCodePath,
  4. DisplayMetrics metrics, int flags) {
  5. ......
  6. mArchiveSourcePath = sourceFile.getPath();
  7. ......
  8. XmlResourceParser parser = null;
  9. AssetManager assmgr = null;
  10. boolean assetError = true;
  11. try {
  12. assmgr = new AssetManager();
  13. int cookie = assmgr.addAssetPath(mArchiveSourcePath);
  14. if(cookie != 0) {
  15. parser = assmgr.openXmlResourceParser(cookie, "AndroidManifest.xml");
  16. assetError = false;
  17. } else {
  18. ......
  19. }
  20. } catch (Exception e) {
  21. ......
  22. }
  23. ......
  24. String[] errorText = new String[1];
  25. Package pkg = null;
  26. Exception errorException = null;
  27. try {
  28. // XXXX todo: need to figure out correct configuration.
  29. Resources res = new Resources(assmgr, metrics, null);
  30. pkg = parsePackage(res, parser, flags, errorText);
  31. } catch (Exception e) {
  32. ......
  33. }
  34. ......
  35. parser.close();
  36. assmgr.close();
  37. // Set code and resource paths
  38. pkg.mPath = destCodePath;
  39. pkg.mScanPath = mArchiveSourcePath;
  40. //pkg.applicationInfo.sourceDir = destCodePath;
  41. //pkg.applicationInfo.publicSourceDir = destRes;
  42. pkg.mSignatures = null;
  43. return pkg;
  44. }
  45. ......
  46. }

每一个Apk文件都是一个归档文件，它里面包含了Android应用程序的配置文件AndroidManifest.xml，这里主要就是要对这个配置
文件就行解析了，从Apk归档文件中得到这个配置文件后，就调用另一外版本的parsePackage函数对这个应用程序进行解析了：

  1. public class PackageParser {
  2. ......
  3. private Package parsePackage(
  4. Resources res, XmlResourceParser parser, int flags, String[] outError)
  5. throws XmlPullParserException, IOException {
  6. ......
  7. String pkgName = parsePackageName(parser, attrs, flags, outError);
  8. ......
  9. final Package pkg = new Package(pkgName);
  10. ......
  11. int type;
  12. ......
  13. TypedArray sa = res.obtainAttributes(attrs,
  14. com.android.internal.R.styleable.AndroidManifest);
  15. ......
  16. while ((type=parser.next()) != parser.END_DOCUMENT
  17. && (type != parser.END_TAG || parser.getDepth() > outerDepth)) {
  18. if (type == parser.END_TAG || type == parser.TEXT) {
  19. continue;
  20. }
  21. String tagName = parser.getName();
  22. if (tagName.equals("application")) {
  23. ......
  24. if (!parseApplication(pkg, res, parser, attrs, flags, outError)) {
  25. return null;
  26. }
  27. } else if (tagName.equals("permission-group")) {
  28. ......
  29. } else if (tagName.equals("permission")) {
  30. ......
  31. } else if (tagName.equals("permission-tree")) {
  32. ......
  33. } else if (tagName.equals("uses-permission")) {
  34. ......
  35. } else if (tagName.equals("uses-configuration")) {
  36. ......
  37. } else if (tagName.equals("uses-feature")) {
  38. ......
  39. } else if (tagName.equals("uses-sdk")) {
  40. ......
  41. } else if (tagName.equals("supports-screens")) {
  42. ......
  43. } else if (tagName.equals("protected-broadcast")) {
  44. ......
  45. } else if (tagName.equals("instrumentation")) {
  46. ......
  47. } else if (tagName.equals("original-package")) {
  48. ......
  49. } else if (tagName.equals("adopt-permissions")) {
  50. ......
  51. } else if (tagName.equals("uses-gl-texture")) {
  52. ......
  53. } else if (tagName.equals("compatible-screens")) {
  54. ......
  55. } else if (tagName.equals("eat-comment")) {
  56. ......
  57. } else if (RIGID_PARSER) {
  58. ......
  59. } else {
  60. ......
  61. }
  62. }
  63. ......
  64. return pkg;
  65. }
  66. ......
  67. }

这里就是对AndroidManifest.xml文件中的各个标签进行解析了，各个标签的含义可以参考官方文档http://developer.android.com/guide/topics/manifest/manifest-intro.html，这里我们只简单看一下application标签的解析，这是通过调用parseApplication函数来进行的。

Step 11. PackageParser.parseApplication
        这个函数定义在frameworks/base/core/java/android/content/pm/PackageParser.java文件中：

  1. public class PackageParser {
  2. ......
  3. private boolean parseApplication(Package owner, Resources res,
  4. XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
  5. throws XmlPullParserException, IOException {
  6. final ApplicationInfo ai = owner.applicationInfo;
  7. final String pkgName = owner.applicationInfo.packageName;
  8. TypedArray sa = res.obtainAttributes(attrs,
  9. com.android.internal.R.styleable.AndroidManifestApplication);
  10. ......
  11. int type;
  12. while ((type=parser.next()) != parser.END_DOCUMENT
  13. && (type != parser.END_TAG || parser.getDepth() > innerDepth)) {
  14. if (type == parser.END_TAG || type == parser.TEXT) {
  15. continue;
  16. }
  17. String tagName = parser.getName();
  18. if (tagName.equals("activity")) {
  19. Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false);
  20. ......
  21. owner.activities.add(a);
  22. } else if (tagName.equals("receiver")) {
  23. Activity a = parseActivity(owner, res, parser, attrs, flags, outError, true);
  24. ......
  25. owner.receivers.add(a);
  26. } else if (tagName.equals("service")) {
  27. Service s = parseService(owner, res, parser, attrs, flags, outError);
  28. ......
  29. owner.services.add(s);
  30. } else if (tagName.equals("provider")) {
  31. Provider p = parseProvider(owner, res, parser, attrs, flags, outError);
  32. ......
  33. owner.providers.add(p);
  34. } else if (tagName.equals("activity-alias")) {
  35. Activity a = parseActivityAlias(owner, res, parser, attrs, flags, outError);
  36. ......
  37. owner.activities.add(a);
  38. } else if (parser.getName().equals("meta-data")) {
  39. ......
  40. } else if (tagName.equals("uses-library")) {
  41. ......
  42. } else if (tagName.equals("uses-package")) {
  43. ......
  44. } else {
  45. ......
  46. }
  47. }
  48. return true;
  49. }
  50. ......
  51. }

这里就是对AndroidManifest.xml文件中的application标签进行解析了，我们常用到的标签就有activity、service、receiver和provider，各个标签的含义可以参考官方文档http://developer.android.com/guide/topics/manifest/manifest-intro.html。

这里解析完成后，一层层返回到Step 9中，调用另一个版本的scanPackageLI函数把来解析后得到的应用程序信息保存下来。

Step 12. PackageManagerService.scanPackageLI

这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

  1. class PackageManagerService extends IPackageManager.Stub {
  2. ......
  3. // Keys are String (package name), values are Package.  This also serves
  4. // as the lock for the global state.  Methods that must be called with
  5. // this lock held have the prefix "LP".
  6. final HashMap<String, PackageParser.Package> mPackages =
  7. new HashMap<String, PackageParser.Package>();
  8. ......
  9. // All available activities, for your resolving pleasure.
  10. final ActivityIntentResolver mActivities =
  11. new ActivityIntentResolver();
  12. // All available receivers, for your resolving pleasure.
  13. final ActivityIntentResolver mReceivers =
  14. new ActivityIntentResolver();
  15. // All available services, for your resolving pleasure.
  16. final ServiceIntentResolver mServices = new ServiceIntentResolver();
  17. // Keys are String (provider class name), values are Provider.
  18. final HashMap<ComponentName, PackageParser.Provider> mProvidersByComponent =
  19. new HashMap<ComponentName, PackageParser.Provider>();
  20. ......
  21. private PackageParser.Package scanPackageLI(PackageParser.Package pkg,
  22. int parseFlags, int scanMode, long currentTime) {
  23. ......
  24. synchronized (mPackages) {
  25. ......
  26. // Add the new setting to mPackages
  27. mPackages.put(pkg.applicationInfo.packageName, pkg);
  28. ......
  29. int N = pkg.providers.size();
  30. int i;
  31. for (i=0; i<N; i++) {
  32. PackageParser.Provider p = pkg.providers.get(i);
  33. p.info.processName = fixProcessName(pkg.applicationInfo.processName,
  34. p.info.processName, pkg.applicationInfo.uid);
  35. mProvidersByComponent.put(new ComponentName(p.info.packageName,
  36. p.info.name), p);
  37. ......
  38. }
  39. N = pkg.services.size();
  40. for (i=0; i<N; i++) {
  41. PackageParser.Service s = pkg.services.get(i);
  42. s.info.processName = fixProcessName(pkg.applicationInfo.processName,
  43. s.info.processName, pkg.applicationInfo.uid);
  44. mServices.addService(s);
  45. ......
  46. }
  47. N = pkg.receivers.size();
  48. r = null;
  49. for (i=0; i<N; i++) {
  50. PackageParser.Activity a = pkg.receivers.get(i);
  51. a.info.processName = fixProcessName(pkg.applicationInfo.processName,
  52. a.info.processName, pkg.applicationInfo.uid);
  53. mReceivers.addActivity(a, "receiver");
  54. ......
  55. }
  56. N = pkg.activities.size();
  57. for (i=0; i<N; i++) {
  58. PackageParser.Activity a = pkg.activities.get(i);
  59. a.info.processName = fixProcessName(pkg.applicationInfo.processName,
  60. a.info.processName, pkg.applicationInfo.uid);
  61. mActivities.addActivity(a, "activity");
  62. ......
  63. }
  64. ......
  65. }
  66. ......
  67. return pkg;
  68. }
  69. ......
  70. }

这个函数主要就是把前面解析应用程序得到的package、provider、service、receiver和activity等信息保存在PackageManagerService服务中了。

这样，在Android系统启动的时候安装应用程序的过程就介绍完了，但是，这些应用程序只是相当于在PackageManagerService服务
注册好了，如果我们想要在Android桌面上看到这些应用程序，还需要有一个Home应用程序，负责从PackageManagerService服务
中把这些安装好的应用程序取出来，并以友好的方式在桌面上展现出来，例如以快捷图标的形式。在Android系统中，负责把系统中已经安装的应用程序在桌
面中展现出来的Home应用程序就是Launcher了，在下一篇文章中，我们将介绍Launcher是如何启动的以及它是如何从
PackageManagerService服务中把系统中已经安装好的应用程序展现出来的，敬请期待。

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

上一篇：RingBuffer源代码分析


下一篇：Android应用程序进程启动过程的源代码分析