android APK應用安裝過程以及默認安裝路徑[轉]

一:安裝過程

APK是類似Symbian Sis或Sisx的文件格式。通過將APK文件直接傳到Android模擬器或Android手機中執行即可安裝。

Android應用安裝有如下四種方式


1.        系統應用安裝――開機時完成，沒有安裝界面


2.        網絡下載應用安裝――通過market應用完成，沒有安裝界面


3.        ADB工具安裝――沒有安裝界面。


4.        第三方應用安裝――通過SD卡里的APK文件安裝，有安裝界面，由packageinstaller.apk應用處理安裝及卸載過程的界面。


應用安裝的流程及路徑 
應用安裝涉及到如下幾個目錄：


system/app 
 系統自帶的應用程序，無法刪除
 
data/app
 用戶程序安裝的目錄，有刪除權限。


安裝時把apk文件復制到此目錄
 
data/data
 存放應用程序的數據
 
Data/dalvik-cache
 將apk中的dex文件安裝到dalvik-cache目錄下(dex文件是dalvik虛擬機的可執行文件,其大小約為原始apk文件大小的四分之一)
 


       安裝過程：復制APK安裝包到data/app目錄下，解壓並掃描安裝包，把dex文件(Dalvik字節碼)保存到dalvik-cache目錄，並data/data目錄下創建對應的應用數據目錄。


       卸載過程：刪除安裝過程中在上述三個目錄下創建的文件及目錄。




 


一、系統應用安裝： 
PackageManagerService處理各種應用的安裝，卸載，管理等工作，開機時由systemServer啟動此服務


(源文件路徑：android\frameworks\base\services\java\com\android\server\PackageManagerService.java)


PackageManagerService服務啟動的流程：


1. 首先掃描安裝“system\framework”目錄下的jar包


1. scanDirLI(mFrameworkDir,PackageParser.PARSE_IS_SYSTEM,


                    scanMode | SCAN_NO_DEX);




2.第二步掃描安裝“system\app”目錄下的各個系統應用


scanDirLI(mSystemAppDir,PackageParser.PARSE_IS_SYSTEM, scanMode);




3.第三步掃描“data\app”目錄，即用戶安裝的第三方應用


scanDirLI(mAppInstallDir, 0, scanMode);




4.第四步掃描" data\app-private"目錄，即安裝DRM保護的APK文件（目前沒有遇到過此類的應用）。


scanDirLI(mDrmAppPrivateInstallDir,0, scanMode | SCAN_FORWARD_LOCKED);


安裝應用的過程


1.scanDirLI(Filedir, int flags, int scanMode) 遍歷安裝指定目錄下的文件


2.scanPackageLI(FilescanFile,


            File destCodeFile, FiledestResourceFile, int parseFlags,


            int scanMode)                安裝package文件


3.scanPackageLI(


        File scanFile, File destCodeFile, FiledestResourceFile,


        PackageParser.Package pkg, intparseFlags, int scanMode)


通過解析安裝包parsePackage獲取到安裝包的信息結構


4.mInstaller.install(pkgName,pkg.applicationInfo.uid,


              pkg.applicationInfo.uid);   實現文件復制的安裝過程


（源文件路徑：frameworks\base\cmds\installd\installd.install）




二、從market上下載應用： 
Google Market應用需要使用gmail賬戶登錄才可以使用，選擇某一應用后，開始下載安裝包，此過程中，在手機的信號區有進度條提示，下載完成后，會自動調用Packagemanager的接口安裝，調用接口如下：


public voidinstallPackage(final Uri packageURI, final IPackageInstallObserver observer,final int flags)


final Uri packageURI：文件下載完成后保存的路徑


final IPackageInstallObserver observer：處理返回的安裝結果


final int flags：安裝的參數，從market上下載的應用，安裝參數為-r (replace)


installPackage接口函數的安裝過程：


1.public voidinstallPackage(


            final Uri packageURI, final IPackageInstallObserverobserver, final int flags,


            final String installerPackageName)


final StringinstallerPackageName:安裝完成后此名稱保存在settings里，一般為null,不是關鍵參數


2.FiletmpPackageFile = copyTempInstallFile(packageURI, res);


把apk文件復制到臨時目錄下的臨時文件


3.private voidinstallPackageLI(Uri pPackageURI,


            int pFlags, boolean newInstall,String installerPackageName,


           File tmpPackageFile, PackageInstalledInfo res)


解析臨時文件，獲取應用包名pkgName = PackageParser.parsePackageName(


                   tmpPackageFile.getAbsolutePath(), 0);


4.判斷如果帶有參數INSTALL_REPLACE_EXISTING，則調用replacePackageLI(pkgName,


                        tmpPackageFile,


                        destFilePath,destPackageFile, destResourceFile,


                        pkg, forwardLocked,newInstall, installerPackageName,


                        res)


5.如果沒有，則調用installNewPackageLI(pkgName,


                        tmpPackageFile,


                        destFilePath,destPackageFile, destResourceFile,


                        pkg,forwardLocked, newInstall, installerPackageName,


                        res);


6.privatePackageParser.Package scanPackageLI(


        File scanFile, File destCodeFile, FiledestResourceFile,


        PackageParser.Package pkg, intparseFlags, int scanMode)


scanPackageLI以后的流程，與開機時的應用安裝流程相同。


三、從ADB工具安裝 
Android Debug Bridge (adb) 是SDK自帶的管理設備的工具，通過ADB命令行的方式也可以為手機或模擬器安裝應用，其入口函數源文件為pm.java


(源文件路徑：android\frameworks\base\cmds\pm\src\com\android\commands\pm\pm.java)


ADB命令行的形式為adb install <path_to_apk> ,還可以帶安裝參數如："-l""-r" "-i" "-t"


函數runInstall()中判斷參數


"-l"――INSTALL_FORWARD_LOCK


 "-r"——INSTALL_REPLACE_EXISTING 


"-i" ——installerPackageName


"-t"——INSTALL_ALLOW_TEST


我們常用的參數為-r，表示覆蓋安裝手機上已安裝的同名應用。從market上下載的應用，也是直接傳入這個參數安裝的。


runInstall與market調用同樣的接口完成應用安裝。


public voidinstallPackage(android.net.Uri packageURI,android.content.pm.IPackageInstallObserver observer, int flags,java.lang.String installerPackageName)


四、第三方應用安裝――通過SD卡里的APK文件安裝 
把APK安裝包保存在SD卡中，從手機里訪問SD卡中的APK安裝包，點擊就可以啟動安裝界面，系統應用Packageinstaller.apk處理這種方式下的安裝及卸載界面流程，如下圖：




PackageInstallerActivity負責解析包，判斷是否是可用的Apk文件


創建臨時安裝文件/data/data/com.android.packageinstaller/files/ApiDemos.apk


並啟動安裝確認界面startInstallConfirm，列出解析得到的該應用基本信息。如果手機上已安裝有同名應用，則需要用戶確認是否要替換安裝。


確認安裝后，啟動InstallAppProgress，調用安裝接口完成安裝。


pm.installPackage(mPackageURI,observer, installFlags);


其它： 
1. PackageManagerService.java的內部類AppDirObserver實現了監聽app目錄的功能：當把某個APK拖到app目錄下時，可以直接調用scanPackageLI完成安裝。

2.手機數據區目錄“data/system/packages.xml”文件中，包含了手機上所有已安裝應用的基本信息，如安裝路徑，申請的permission等信息。

 

二:更改默認安裝路徑

    如果你是一個apk應用開發者,沒用android系統全套代碼,你只想更改你的APK的默認安裝路徑的話,可以按下面方法來更改:

 

在AndroidManifest.xml文件Manifest標簽中添加android:installLocation屬性

android:installLocation

這個屬性設置的是默認安裝位置， 共有三個有效值，auto、internalOnly、preferExternal

對應表

auto 表示自動，由系統決定安裝位置,如果系統手機內存足夠,默認安裝在手機內存里,如果手機內在不夠,則會安裝在T卡內

internalOnly 安裝在手機內存

preferExternal 安裝在外部存儲中

Constant	Value	Description
auto	0	Let the system decide install location
internalOnly	1	Explicitly request to be installed on internal phone storage only
preferExternal	2	Perfer to be installed on SD card, There is no guarantee that the system will honor this request. The application might end up being installed on internal storage if external media is unavailable or too full

 

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.ray"
      android:installLocation="auto"
      android:versionCode="1"
      android:versionName="1.0">

如果你是一個手機方案開發者,能改framework層的代碼,你希望下載到手機里的APK都默認優先安裝到T卡的話,可以按下面方法更改:

在PackageParser.java文件里,將private static final int PARSE_DEFAULT_INSTALL_LOCATION  這個PARSE_DEFAULT_INSTALL_LOCATION值,改為PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL,就可以了.默認下載就會下到T卡里,T卡不存在或者滿了時,才會下到手機內部. 或者如果在應用的AndroidManifest.xml里,指定了installLocation屬性為手機內部存儲的話,是會存在手機內部的.沒指這定的話,PARSE_DEFAULT_INSTALL_LOCATION這個值指定什么,就下到哪里

安裝在T卡里的應用,有幾個缺點:
1:因為android裝載T卡是在系統啟動完成后,才開始裝載的.所以如果應用裝在T卡里的話,那么它是收不到開機啟動完成的BOOT_COMPLETED這個廣播的
2:如果T卡損壞或者T卡撥出來了,那么裝在T卡里的應用是啟動不了的.

 

 

系統應用安裝的詳細過程,老羅有篇文章寫得很透徹,這里引用下:

 

Android系統在啟動的過程中，會啟動一個應用程序管理服務PackageManagerService，這個服務負責掃描系統中特定的目錄，找到里面的應用程序文件，即以Apk為后綴的文件，然后對這些文件進解析，得到應用程序的相關信息，完成應用程序的安裝過程，本文將詳細分析這個過程。

        應用程序管理服務PackageManagerService安裝應用程序的過程，其實就是解析析應用程序配置文件AndroidManifest.xml的過程，並從里面得到得到應用程序的相關信息，例如得到應用程序的組件Activity、Service、Broadcast Receiver和Content Provider等信息，有了這些信息后，通過ActivityManagerService這個服務，我們就可以在系統中正常地使用這些應用程序了。

        應用程序管理服務PackageManagerService是系統啟動的時候由SystemServer組件啟動的，啟后它就會執行應用程序安裝的過程，因此，本文將從SystemServer啟動PackageManagerService服務的過程開始分析系統中的應用程序安裝的過程。

        應用程序管理服務PackageManagerService從啟動到安裝應用程序的過程如下圖所示：

        下面我們具體分析每一個步驟。

        Step 1. SystemServer.main

        這個函數定義在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

 

public class SystemServer
{
    ......

    native public static void init1(String[] args);

    ......

    public static void main(String[] args) {
        ......

        init1(args);

        ......
    }

    ......
}

        SystemServer組件是由Zygote進程負責啟動的，啟動的時候就會調用它的main函數，這個函數主要調用了JNI方法init1來做一些系統初始化的工作。

 

        Step 2. SystemServer.init1

        這個函數是一個JNI方法，實現在 frameworks/base/services/jni/com_android_server_SystemServer.cpp文件中：

 

namespace android {

extern "C" int system_init();

static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
    system_init();
}

/*
 * JNI registration.
 */
static JNINativeMethod gMethods[] = {
    /* name, signature, funcPtr */
    { "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 },
};

int register_android_server_SystemServer(JNIEnv* env)
{
    return jniRegisterNativeMethods(env, "com/android/server/SystemServer",
            gMethods, NELEM(gMethods));
}

}; // namespace android

        這個函數很簡單，只是調用了system_init函數來進一步執行操作。

 

        Step 3. libsystem_server.system_init

        函數system_init實現在libsystem_server庫中，源代碼位於frameworks/base/cmds/system_server/library/system_init.cpp文件中：

 

extern "C" status_t system_init()
{
    LOGI("Entered system_init()");

    sp<ProcessState> proc(ProcessState::self());

    sp<IServiceManager> sm = defaultServiceManager();
    LOGI("ServiceManager: %p\n", sm.get());

    sp<GrimReaper> grim = new GrimReaper();
    sm->asBinder()->linkToDeath(grim, grim.get(), 0);

    char propBuf[PROPERTY_VALUE_MAX];
    property_get("system_init.startsurfaceflinger", propBuf, "1");
    if (strcmp(propBuf, "1") == 0) {
        // Start the SurfaceFlinger
        SurfaceFlinger::instantiate();
    }

    // Start the sensor service
    SensorService::instantiate();

    // On the simulator, audioflinger et al don't get started the
    // same way as on the device, and we need to start them here
    if (!proc->supportsProcesses()) {

        // Start the AudioFlinger
        AudioFlinger::instantiate();

        // Start the media playback service
        MediaPlayerService::instantiate();

        // Start the camera service
        CameraService::instantiate();

        // Start the audio policy service
        AudioPolicyService::instantiate();
    }

    // And now start the Android runtime.  We have to do this bit
    // of nastiness because the Android runtime initialization requires
    // some of the core system services to already be started.
    // All other servers should just start the Android runtime at
    // the beginning of their processes's main(), before calling
    // the init function.
    LOGI("System server: starting Android runtime.\n");

    AndroidRuntime* runtime = AndroidRuntime::getRuntime();

    LOGI("System server: starting Android services.\n");
    runtime->callStatic("com/android/server/SystemServer", "init2");

    // If running in our own process, just go into the thread
    // pool.  Otherwise, call the initialization finished
    // func to let this process continue its initilization.
    if (proc->supportsProcesses()) {
        LOGI("System server: entering thread pool.\n");
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
        LOGI("System server: exiting thread pool.\n");
    }

    return NO_ERROR;
}

        這個函數首先會初始化SurfaceFlinger、SensorService、AudioFlinger、MediaPlayerService、CameraService和AudioPolicyService這幾個服務，然后就通過系統全局唯一的AndroidRuntime實例變量runtime的callStatic來調用SystemServer的init2函數了。關於這個AndroidRuntime實例變量runtime的相關資料，可能參考前面一篇文章Android應用程序進程啟動過程的源代碼分析一文。

 

        Step 4. AndroidRuntime.callStatic

        這個函數定義在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

 

/*
* Call a static Java Programming Language function that takes no arguments and returns void.
*/
status_t AndroidRuntime::callStatic(const char* className, const char* methodName)
{
    JNIEnv* env;
    jclass clazz;
    jmethodID methodId;

    env = getJNIEnv();
    if (env == NULL)
        return UNKNOWN_ERROR;

    clazz = findClass(env, className);
    if (clazz == NULL) {
        LOGE("ERROR: could not find class '%s'\n", className);
        return UNKNOWN_ERROR;
    }
    methodId = env->GetStaticMethodID(clazz, methodName, "()V");
    if (methodId == NULL) {
        LOGE("ERROR: could not find method %s.%s\n", className, methodName);
        return UNKNOWN_ERROR;
    }

    env->CallStaticVoidMethod(clazz, methodId);

    return NO_ERROR;
}

        這個函數調用由參數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文件中：

public class SystemServer
{
    ......

    public static final void init2() {
        Slog.i(TAG, "Entered the Android system server!");
        Thread thr = new ServerThread();
        thr.setName("android.server.ServerThread");
        thr.start();
    }
}

        這個函數創建了一個ServerThread線程，PackageManagerService服務就是這個線程中啟動的了。這里調用了ServerThread實例thr的start函數之后，下面就會執行這個實例的run函數了。

 

        Step 6. ServerThread.run

        這個函數定義在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

class ServerThread extends Thread {
    ......

    @Override
    public void run() {
        ......

        IPackageManager pm = null;

        ......

        // Critical services...
        try {
            ......

            Slog.i(TAG, "Package Manager");
            pm = PackageManagerService.main(context,
                        factoryTest != SystemServer.FACTORY_TEST_OFF);

            ......
        } catch (RuntimeException e) {
            Slog.e("System", "Failure starting core service", e);
        }

        ......
    }

    ......
}

        這個函數除了啟動PackageManagerService服務之外，還啟動了其它很多的服務，例如在前面學習Activity和Service的幾篇文章中經常看到的ActivityManagerService服務，有興趣的讀者可以自己研究一下。

 

        Step 7. PackageManagerService.main

        這個函數定義在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

 

class PackageManagerService extends IPackageManager.Stub {
    ......

    public static final IPackageManager main(Context context, boolean factoryTest) {
        PackageManagerService m = new PackageManagerService(context, factoryTest);
        ServiceManager.addService("package", m);
        return m;
    }

    ......
}

        這個函數創建了一個PackageManagerService服務實例，然后把這個服務添加到ServiceManager中去，ServiceManager是Android系統Binder進程間通信機制的守護進程，負責管理系統中的Binder對象，具體可以參考淺談Service Manager成為Android進程間通信（IPC）機制Binder守護進程之路一文。
        在創建這個PackageManagerService服務實例時，會在PackageManagerService類的構造函數中開始執行安裝應用程序的過程：

 

 

class PackageManagerService extends IPackageManager.Stub {
    ......

    public PackageManagerService(Context context, boolean factoryTest) {
        ......

        synchronized (mInstallLock) {
            synchronized (mPackages) {
                ......

                File dataDir = Environment.getDataDirectory();
                mAppDataDir = new File(dataDir, "data");
                mSecureAppDataDir = new File(dataDir, "secure/data");
                mDrmAppPrivateInstallDir = new File(dataDir, "app-private");

                ......

                mFrameworkDir = new File(Environment.getRootDirectory(), "framework");
                mDalvikCacheDir = new File(dataDir, "dalvik-cache");

                ......

                // Find base frameworks (resource packages without code).
                mFrameworkInstallObserver = new AppDirObserver(
                mFrameworkDir.getPath(), OBSERVER_EVENTS, true);
                mFrameworkInstallObserver.startWatching();
                scanDirLI(mFrameworkDir, PackageParser.PARSE_IS_SYSTEM
                    | PackageParser.PARSE_IS_SYSTEM_DIR,
                    scanMode | SCAN_NO_DEX, 0);

                // Collect all system packages.
                mSystemAppDir = new File(Environment.getRootDirectory(), "app");
                mSystemInstallObserver = new AppDirObserver(
                    mSystemAppDir.getPath(), OBSERVER_EVENTS, true);
                mSystemInstallObserver.startWatching();
                scanDirLI(mSystemAppDir, PackageParser.PARSE_IS_SYSTEM
                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);

                // Collect all vendor packages.
                mVendorAppDir = new File("/vendor/app");
                mVendorInstallObserver = new AppDirObserver(
                    mVendorAppDir.getPath(), OBSERVER_EVENTS, true);
                mVendorInstallObserver.startWatching();
                scanDirLI(mVendorAppDir, PackageParser.PARSE_IS_SYSTEM
                    | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);


                mAppInstallObserver = new AppDirObserver(
                    mAppInstallDir.getPath(), OBSERVER_EVENTS, false);
                mAppInstallObserver.startWatching();
                scanDirLI(mAppInstallDir, 0, scanMode, 0);

                mDrmAppInstallObserver = new AppDirObserver(
                    mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false);
                mDrmAppInstallObserver.startWatching();
                scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,
                    scanMode, 0);

                ......
            }
        }
    }

    ......
}

        這里會調用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文件中：

 

class PackageManagerService extends IPackageManager.Stub {
    ......

    private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
        String[] files = dir.list();
        ......

        int i;
        for (i=0; i<files.length; i++) {
            File file = new File(dir, files[i]);
            if (!isPackageFilename(files[i])) {
                // Ignore entries which are not apk's
                continue;
            }
            PackageParser.Package pkg = scanPackageLI(file,
                flags|PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime);
            // Don't mess around with apps in system partition.
            if (pkg == null && (flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
                mLastScanError == PackageManager.INSTALL_FAILED_INVALID_APK) {
                    // Delete the apk
                    Slog.w(TAG, "Cleaning up failed install of " + file);
                    file.delete();
            }
        }
    }


    ......
}

         對於目錄中的每一個文件，如果是以后Apk作為后綴名，那么就調用scanPackageLI函數來對它進行解析和安裝。

 

         Step 9. PackageManagerService.scanPackageLI

         這個函數定義在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

 

class PackageManagerService extends IPackageManager.Stub {
    ......

    private PackageParser.Package scanPackageLI(File scanFile,
            int parseFlags, int scanMode, long currentTime) {
        ......

        String scanPath = scanFile.getPath();
        parseFlags |= mDefParseFlags;
        PackageParser pp = new PackageParser(scanPath);

        ......

        final PackageParser.Package pkg = pp.parsePackage(scanFile,
            scanPath, mMetrics, parseFlags);

        ......

        return scanPackageLI(pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE, currentTime);
    }

    ......
}

        這個函數首先會為這個Apk文件創建一個PackageParser實例，接着調用這個實例的parsePackage函數來對這個Apk文件進行解析。這個函數最后還會調用另外一個版本的scanPackageLI函數把來解析后得到的應用程序信息保存在PackageManagerService中。

 

        Step 10. PackageParser.parsePackage
        這個函數定義在frameworks/base/core/java/android/content/pm/PackageParser.java文件中：

 

public class PackageParser {
    ......

    public Package parsePackage(File sourceFile, String destCodePath,
            DisplayMetrics metrics, int flags) {
        ......

        mArchiveSourcePath = sourceFile.getPath();

        ......

        XmlResourceParser parser = null;
        AssetManager assmgr = null;
        boolean assetError = true;
        try {
            assmgr = new AssetManager();
            int cookie = assmgr.addAssetPath(mArchiveSourcePath);
            if(cookie != 0) {
                parser = assmgr.openXmlResourceParser(cookie, "AndroidManifest.xml");
                assetError = false;
            } else {
                ......
            }
        } catch (Exception e) {
            ......
        }

        ......

        String[] errorText = new String[1];
        Package pkg = null;
        Exception errorException = null;
        try {
            // XXXX todo: need to figure out correct configuration.
            Resources res = new Resources(assmgr, metrics, null);
            pkg = parsePackage(res, parser, flags, errorText);
        } catch (Exception e) {
            ......
        }

        ......

        parser.close();
        assmgr.close();

        // Set code and resource paths
        pkg.mPath = destCodePath;
        pkg.mScanPath = mArchiveSourcePath;
        //pkg.applicationInfo.sourceDir = destCodePath;
        //pkg.applicationInfo.publicSourceDir = destRes;
        pkg.mSignatures = null;

        return pkg;
    }

    ......
}

        每一個Apk文件都是一個歸檔文件，它里面包含了Android應用程序的配置文件AndroidManifest.xml，這里主要就是要對這個配置文件就行解析了，從Apk歸檔文件中得到這個配置文件后，就調用另一外版本的parsePackage函數對這個應用程序進行解析了：

 

 

public class PackageParser {
    ......

    private Package parsePackage(
            Resources res, XmlResourceParser parser, int flags, String[] outError)
            throws XmlPullParserException, IOException {
        ......

        String pkgName = parsePackageName(parser, attrs, flags, outError);

        ......

        final Package pkg = new Package(pkgName);

        ......

        int type;

        ......

        TypedArray sa = res.obtainAttributes(attrs,
            com.android.internal.R.styleable.AndroidManifest);

        ......

        while ((type=parser.next()) != parser.END_DOCUMENT
            && (type != parser.END_TAG || parser.getDepth() > outerDepth)) {
                if (type == parser.END_TAG || type == parser.TEXT) {
                    continue;
                }

                String tagName = parser.getName();
                if (tagName.equals("application")) {
                    ......

                    if (!parseApplication(pkg, res, parser, attrs, flags, outError)) {
                        return null;
                    }
                } else if (tagName.equals("permission-group")) {
                    ......
                } else if (tagName.equals("permission")) {
                    ......
                } else if (tagName.equals("permission-tree")) {
                    ......
                } else if (tagName.equals("uses-permission")) {
                    ......
                } else if (tagName.equals("uses-configuration")) {
                    ......
                } else if (tagName.equals("uses-feature")) {
                    ......
                } else if (tagName.equals("uses-sdk")) {
                    ......
                } else if (tagName.equals("supports-screens")) {
                    ......
                } else if (tagName.equals("protected-broadcast")) {
                    ......
                } else if (tagName.equals("instrumentation")) {
                    ......
                } else if (tagName.equals("original-package")) {
                    ......
                } else if (tagName.equals("adopt-permissions")) {
                    ......
                } else if (tagName.equals("uses-gl-texture")) {
                    ......
                } else if (tagName.equals("compatible-screens")) {
                    ......
                } else if (tagName.equals("eat-comment")) {
                    ......
                } else if (RIGID_PARSER) {
                    ......
                } else {
                    ......
                }
        }

        ......

        return pkg;
    }

    ......
}

        這里就是對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文件中：

public class PackageParser {
    ......

    private boolean parseApplication(Package owner, Resources res,
            XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
            throws XmlPullParserException, IOException {
        final ApplicationInfo ai = owner.applicationInfo;
        final String pkgName = owner.applicationInfo.packageName;

        TypedArray sa = res.obtainAttributes(attrs,
            com.android.internal.R.styleable.AndroidManifestApplication);

        ......

        int type;
        while ((type=parser.next()) != parser.END_DOCUMENT
            && (type != parser.END_TAG || parser.getDepth() > innerDepth)) {
                if (type == parser.END_TAG || type == parser.TEXT) {
                    continue;
                }

                String tagName = parser.getName();
                if (tagName.equals("activity")) {
                    Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false);
                    ......

                    owner.activities.add(a);

                } else if (tagName.equals("receiver")) {
                    Activity a = parseActivity(owner, res, parser, attrs, flags, outError, true);
                    ......

                    owner.receivers.add(a);
                } else if (tagName.equals("service")) {
                    Service s = parseService(owner, res, parser, attrs, flags, outError);
                    ......

                    owner.services.add(s);
                } else if (tagName.equals("provider")) {
                    Provider p = parseProvider(owner, res, parser, attrs, flags, outError);
                    ......

                    owner.providers.add(p);
                } else if (tagName.equals("activity-alias")) {
                    Activity a = parseActivityAlias(owner, res, parser, attrs, flags, outError);
                    ......

                    owner.activities.add(a);
                } else if (parser.getName().equals("meta-data")) {
                    ......
                } else if (tagName.equals("uses-library")) {
                    ......
                } else if (tagName.equals("uses-package")) {
                    ......
                } else {
                    ......
                }
        }

        return true;
    }

    ......
}

        這里就是對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文件中：

class PackageManagerService extends IPackageManager.Stub {
    ......

    // Keys are String (package name), values are Package.  This also serves
    // as the lock for the global state.  Methods that must be called with
    // this lock held have the prefix "LP".
    final HashMap<String, PackageParser.Package> mPackages =
        new HashMap<String, PackageParser.Package>();

    ......

    // All available activities, for your resolving pleasure.
    final ActivityIntentResolver mActivities =
    new ActivityIntentResolver();

    // All available receivers, for your resolving pleasure.
    final ActivityIntentResolver mReceivers =
        new ActivityIntentResolver();

    // All available services, for your resolving pleasure.
    final ServiceIntentResolver mServices = new ServiceIntentResolver();

    // Keys are String (provider class name), values are Provider.
    final HashMap<ComponentName, PackageParser.Provider> mProvidersByComponent =
        new HashMap<ComponentName, PackageParser.Provider>();

    ......

    private PackageParser.Package scanPackageLI(PackageParser.Package pkg,
            int parseFlags, int scanMode, long currentTime) {
        ......

        synchronized (mPackages) {
            ......

            // Add the new setting to mPackages
            mPackages.put(pkg.applicationInfo.packageName, pkg);

            ......

            int N = pkg.providers.size();
            int i;
            for (i=0; i<N; i++) {
                PackageParser.Provider p = pkg.providers.get(i);
                p.info.processName = fixProcessName(pkg.applicationInfo.processName,
                    p.info.processName, pkg.applicationInfo.uid);
                mProvidersByComponent.put(new ComponentName(p.info.packageName,
                    p.info.name), p);

                ......
            }

            N = pkg.services.size();
            for (i=0; i<N; i++) {
                PackageParser.Service s = pkg.services.get(i);
                s.info.processName = fixProcessName(pkg.applicationInfo.processName,
                    s.info.processName, pkg.applicationInfo.uid);
                mServices.addService(s);

                ......
            }

            N = pkg.receivers.size();
            r = null;
            for (i=0; i<N; i++) {
                PackageParser.Activity a = pkg.receivers.get(i);
                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
                    a.info.processName, pkg.applicationInfo.uid);
                mReceivers.addActivity(a, "receiver");

                ......
            }

            N = pkg.activities.size();
            for (i=0; i<N; i++) {
                PackageParser.Activity a = pkg.activities.get(i);
                a.info.processName = fixProcessName(pkg.applicationInfo.processName,
                    a.info.processName, pkg.applicationInfo.uid);
                mActivities.addActivity(a, "activity");

                ......
            }

            ......
        }

        ......

        return pkg;
    }

    ......
}

        這個函數主要就是把前面解析應用程序得到的package、provider、service、receiver和activity等信息保存在PackageManagerService服務中了。

 

from：http://blog.csdn.net/xuhui_7810/article/details/11654577