6、解析系统已经安装的包

Android启动时要扫描和安装现有app，或许是为了防止corrupted（损坏）信息的存在，或许是为了能在升级系统或更新系统属性后保持app也有效，也或是因为有些信息（如uid）必须要动态生成和调整的。总之，为了要还原现有app的安装信息，这些信息被放在/data/system/package.xml文件中，由Settings管理。另外，/data/system/packages.list记录了app的uid和数据路径等信息。packages.xml这个文件很庞大，记载了每个应用的详细情况，包括permission、shared-user、key等等，每一个应用都对应一个package节点，所以一开机就可以把系统内安装的所有应用都读到Settings的mPackages对象中，它是一个map，维护了系统内所有应用的详情。当然这个文件里维护的是全系统的所有应用，不区分用户。readLPw()方法就是用于恢复这些信息，实现方法位于/frameworks\base\services\core\java\com\android\server\pm\Settings.java。

首先检测/data/system/packages-backup.xml文件是否存在，该文件是packages.xml文件的备份文件，如果存在则解析该文件，因为packages.xml文件可能已经被破坏；不存在则解析packages.xml。 readLPw()先打开packages.xml，再通过XmlPullParser类解析其内容。它会根据不同的tag调用相应的函数来读取信息：

    boolean readLPw(PackageManagerService service, List users, int sdkVersion,            boolean onlyCore) {        FileInputStream str = null;        if (mBackupSettingsFilename.exists()) {// /data/system/packages-backup.xml            try {                str = new FileInputStream(mBackupSettingsFilename);                mReadMessages.append("Reading from backup settings file\n");                PackageManagerService.reportSettingsProblem(Log.INFO,                        "Need to read from backup settings file");                if (mSettingsFilename.exists()) {// /data/system/packages.xml                    // If both the backup and settings file exist, we                    // ignore the settings since it might have been                    // corrupted.//         如果packages.xml和packages-backup.xml文件都存在，则删除packages.xml文件，因为这个文件可能已被破坏                    Slog.w(PackageManagerService.TAG, "Cleaning up settings file "                            + mSettingsFilename);                    mSettingsFilename.delete();                }            } catch (java.io.IOException e) {                // We'll try for the normal settings file.            }        }        mPendingPackages.clear();        mPastSignatures.clear();        try {            if (str == null) {///data/system/packages-backup.xml文件不存在                if (!mSettingsFilename.exists()) {// 如果/data/system/packages.xml文件也不存在，直接返回false                    mReadMessages.append("No settings file found\n");                    PackageManagerService.reportSettingsProblem(Log.INFO,                            "No settings file; creating initial state");                    mInternalSdkPlatform = mExternalSdkPlatform = sdkVersion;                    mFingerprint = Build.FINGERPRINT;                    return false;                }                str = new FileInputStream(mSettingsFilename);//packages-backup.xml文件不存在时，创建packages.xml文件输入流            }            XmlPullParser parser = Xml.newPullParser();            parser.setInput(str, null);//xml文件解析器            int type;            while ((type = parser.next()) != XmlPullParser.START_TAG                    && type != XmlPullParser.END_DOCUMENT) {                ;            }            if (type != XmlPullParser.START_TAG) {                mReadMessages.append("No start tag found in settings file\n");                PackageManagerService.reportSettingsProblem(Log.WARN,                        "No start tag found in package manager settings");                Slog.wtf(PackageManagerService.TAG,                        "No start tag found in package manager settings");                return false;            }            int outerDepth = parser.getDepth();            while ((type = parser.next()) != XmlPullParser.END_DOCUMENT                    && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {                if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {                    continue;                }//                它会根据不同的tag调用相应的函数来读取信息：                String tagName = parser.getName();                if (tagName.equals("package")) {//                  解析应用，创建一个PackageSetting对象，添加到mPendingPackages中                    readPackageLPw(parser);                } else if (tagName.equals("permissions")) {//                 解析系统定义了哪些权限，由那个包定义的，构建BasePermission结构都添加到mPermissions                      readPermissionsLPw(mPermissions, parser);                } else if (tagName.equals("permission-trees")) {                    readPermissionsLPw(mPermissionTrees, parser);                } else if (tagName.equals("shared-user")) {                  //解析系统中可被用户共享的一些uid所拥有的权限//                    代表一个共享UID，通常，共同实现一系列相似功能的APK共享一个UID。                    readSharedUserLPw(parser);                } else if (tagName.equals("preferred-packages")) {                    // no longer used.                } else if (tagName.equals("preferred-activities")) {                    // Upgrading from old single-user implementation;                    // these are the preferred activities for user 0.                    readPreferredActivitiesLPw(parser, 0);//解析优先设置的activity                } else if (tagName.equals(TAG_PERSISTENT_PREFERRED_ACTIVITIES)) {                    // TODO: check whether this is okay! as it is very                    // similar to how preferred-activities are treated                    readPersistentPreferredActivitiesLPw(parser, 0);//"persistent-preferred-activities"                } else if (tagName.equals(TAG_CROSS_PROFILE_INTENT_FILTERS)) {                    // TODO: check whether this is okay! as it is very                    // similar to how preferred-activities are treated                    readCrossProfileIntentFiltersLPw(parser, 0);//"crossProfile-intent-filters"                } else if (tagName.equals("updated-package")) {                    readDisabledSysPackageLPw(parser);//解析升级的系统应用，保存到mDisabledSysPackages中                } else if (tagName.equals("cleaning-package")) {                    String name = parser.getAttributeValue(null, ATTR_NAME);                    String userStr = parser.getAttributeValue(null, ATTR_USER);                    String codeStr = parser.getAttributeValue(null, ATTR_CODE);                    if (name != null) {                        int userId = 0;                        boolean andCode = true;                        try {                            if (userStr != null) {                                userId = Integer.parseInt(userStr);                            }                        } catch (NumberFormatException e) {                        }                        if (codeStr != null) {                            andCode = Boolean.parseBoolean(codeStr);                        }                        addPackageToCleanLPw(new PackageCleanItem(userId, name, andCode));                    }                } else if (tagName.equals("renamed-package")) {                    String nname = parser.getAttributeValue(null, "new");                    String oname = parser.getAttributeValue(null, "old");                    if (nname != null && oname != null) {                        mRenamedPackages.put(nname, oname);                    }                } else if (tagName.equals("last-platform-version")) {//解析                    mInternalSdkPlatform = mExternalSdkPlatform = 0;                    try {                        String internal = parser.getAttributeValue(null, "internal");                        if (internal != null) {                            mInternalSdkPlatform = Integer.parseInt(internal);                        }                        String external = parser.getAttributeValue(null, "external");                        if (external != null) {                            mExternalSdkPlatform = Integer.parseInt(external);                        }                    } catch (NumberFormatException e) {                    }                    mFingerprint = parser.getAttributeValue(null, "fingerprint");                } else if (tagName.equals("database-version")) {//解析                    mInternalDatabaseVersion = mExternalDatabaseVersion = 0;                    try {                        String internalDbVersionString = parser.getAttributeValue(null, "internal");                        if (internalDbVersionString != null) {                            mInternalDatabaseVersion = Integer.parseInt(internalDbVersionString);                        }                        String externalDbVersionString = parser.getAttributeValue(null, "external");                        if (externalDbVersionString != null) {                            mExternalDatabaseVersion = Integer.parseInt(externalDbVersionString);                        }                    } catch (NumberFormatException ignored) {                    }                } else if (tagName.equals("verifier")) {                    final String deviceIdentity = parser.getAttributeValue(null, "device");                    try {                        mVerifierDeviceIdentity = VerifierDeviceIdentity.parse(deviceIdentity);                    } catch (IllegalArgumentException e) {                        Slog.w(PackageManagerService.TAG, "Discard invalid verifier device id: "                                + e.getMessage());                    }                } else if (TAG_READ_EXTERNAL_STORAGE.equals(tagName)) {                    final String enforcement = parser.getAttributeValue(null, ATTR_ENFORCEMENT);                    mReadExternalStorageEnforced = "1".equals(enforcement);                } else if (tagName.equals("keyset-settings")) {                    mKeySetManagerService.readKeySetsLPw(parser);                } else {                    Slog.w(PackageManagerService.TAG, "Unknown element under : "                            + parser.getName());                    XmlUtils.skipCurrentTag(parser);                }            }            str.close();        } catch (XmlPullParserException e) {            mReadMessages.append("Error reading: " + e.toString());            PackageManagerService.reportSettingsProblem(Log.ERROR, "Error reading settings: " + e);            Slog.wtf(PackageManagerService.TAG, "Error reading package manager settings", e);        } catch (java.io.IOException e) {            mReadMessages.append("Error reading: " + e.toString());            PackageManagerService.reportSettingsProblem(Log.ERROR, "Error reading settings: " + e);            Slog.wtf(PackageManagerService.TAG, "Error reading package manager settings", e);        }        final int N = mPendingPackages.size();        for (int i = 0; i < N; i++) {            final PendingPackage pp = mPendingPackages.get(i);            Object idObj = getUserIdLPr(pp.sharedId);            if (idObj != null && idObj instanceof SharedUserSetting) {                PackageSetting p = getPackageLPw(pp.name, null, pp.realName,                        (SharedUserSetting) idObj, pp.codePath, pp.resourcePath,                        pp.legacyNativeLibraryPathString, pp.primaryCpuAbiString,                        pp.secondaryCpuAbiString, pp.versionCode, pp.pkgFlags, null,                        true /* add */, false /* allowInstall */);                if (p == null) {                    PackageManagerService.reportSettingsProblem(Log.WARN,                            "Unable to create application package for " + pp.name);                    continue;                }                p.copyFrom(pp);            } else if (idObj != null) {                String msg = "Bad package setting: package " + pp.name + " has shared uid "                        + pp.sharedId + " that is not a shared uid\n";                mReadMessages.append(msg);                PackageManagerService.reportSettingsProblem(Log.ERROR, msg);            } else {                String msg = "Bad package setting: package " + pp.name + " has shared uid "                        + pp.sharedId + " that is not defined\n";                mReadMessages.append(msg);                PackageManagerService.reportSettingsProblem(Log.ERROR, msg);            }        }        mPendingPackages.clear();        if (mBackupStoppedPackagesFilename.exists()                || mStoppedPackagesFilename.exists()) {            // Read old file            readStoppedLPw();            mBackupStoppedPackagesFilename.delete();            mStoppedPackagesFilename.delete();            // Migrate to new file format，迁移到新的文件格式            writePackageRestrictionsLPr(0);        } else {            if (users == null) {                readPackageRestrictionsLPr(0);            } else {                for (UserInfo user : users) {                    readPackageRestrictionsLPr(user.id);                }            }        }        /*         * Make sure all the updated system packages have their shared users         * associated with them.确保所有更新的系统应用包 有与它们相关联的共享用户。         */        final Iterator disabledIt = mDisabledSysPackages.values().iterator();        while (disabledIt.hasNext()) {            final PackageSetting disabledPs = disabledIt.next();            final Object id = getUserIdLPr(disabledPs.appId);//uid            if (id != null && id instanceof SharedUserSetting) {                disabledPs.sharedUser = (SharedUserSetting) id;            }        }        mReadMessages.append("Read completed successfully: " + mPackages.size() + " packages, "                + mSharedUsers.size() + " shared uids\n");        return true;    }

7、扫描应用目录的过程

PMS的构造方法中调用了scanDirLI()方法来扫描某个目录中apk文件，如下：

    private void scanDirLI(File dir, int parseFlags, int scanFlags, long currentTime) {        final File[] files = dir.listFiles();//遍历dir目录下的文件        if (ArrayUtils.isEmpty(files)) {            Log.d(TAG, "No files in app dir " + dir);            return;// 如果扫描的目录是空的，返回        }        if (DEBUG_PACKAGE_SCANNING) {            Log.d(TAG, "Scanning app dir " + dir + " scanFlags=" + scanFlags                    + " flags=0x" + Integer.toHexString(parseFlags));        }        Log.d(TAG, "start scanDirLI:"+dir);        int iMultitaskNum = SystemProperties.getInt("persist.pm.multitask",0);        boolean bMultitask = (iMultitaskNum > 1);        Log.d(TAG, "bMultitask:" + bMultitask + " max thread:" + iMultitaskNum);        final MultiTaskDealer dealer = bMultitask ? MultiTaskDealer.startDealer(MultiTaskDealer.PACKAGEMANAGER_SCANER, iMultitaskNum) : null;        for (File file : files) {//            判断文件是否是应用文件            final boolean isPackage = (isApkFile(file) || file.isDirectory())                    && !PackageInstallerService.isStageName(file.getName());            if (!isPackage) {                // Ignore entries which are not packages                continue;            }            final File ref_file = file;            final int ref_parseFlags = parseFlags;            final int ref_scanFlags = scanFlags;            final long ref_currentTime = currentTime;            Runnable scanTask = new Runnable() {            public void run() {                try {// 调用scanPackageLI方法继续扫描文件                    scanPackageLI(ref_file, ref_parseFlags | PackageParser.PARSE_MUST_BE_APK,                        ref_scanFlags, ref_currentTime, null);                } catch (PackageManagerException e) {                    Slog.w(TAG, "Failed to parse " + ref_file + ": " + e.getMessage());                     // Delete invalid userdata apps。删除安装失败的文件和数据目录                    if ((ref_parseFlags & PackageParser.PARSE_IS_SYSTEM) == 0 &&                        e.error == PackageManager.INSTALL_FAILED_INVALID_APK) {                        logCriticalInfo(Log.WARN, "Deleting invalid package at " + ref_file);                        if (ref_file.isDirectory()) {                            FileUtils.deleteContents(ref_file);                        }                        ref_file.delete();                    }                }            }};            if(dealer!=null)                dealer.addTask(scanTask);            else                scanTask.run();        }        if(dealer!=null)            dealer.waitAll();        Log.d(TAG, "end scanDirLI:"+dir);    }

（1）解析文件：

/*     *  Scan a package and return the newly parsed package.     *  Returns null in case of errors and the error code is stored in mLastScanError     */    private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanFlags,            long currentTime, UserHandle user) throws PackageManagerException {        if (DEBUG_INSTALL) Slog.d(TAG, "Parsing: " + scanFile);        parseFlags |= mDefParseFlags;        PackageParser pp = new PackageParser();//创建文件解析器对象        pp.setSeparateProcesses(mSeparateProcesses);        pp.setOnlyCoreApps(mOnlyCore);        pp.setDisplayMetrics(mMetrics);        if ((scanFlags & SCAN_TRUSTED_OVERLAY) != 0) {            parseFlags |= PackageParser.PARSE_TRUSTED_OVERLAY;        }        final PackageParser.Package pkg;        try {//调用PackageParser对象的parsePackage方法，解析APK文件，生成PackageParser.Package对象            pkg = pp.parsePackage(scanFile, parseFlags);        } catch (PackageParserException e) {            throw PackageManagerException.from(e);        }

（2）处理更改了包名的应用。

这里是在检查应用是否属于标签标记的改了包名的应用，如果是，则使用原始的包的信息：

        PackageSetting ps = null;        PackageSetting updatedPkg;        // reader        synchronized (mPackages) {            // Look to see if we already know about this package.获取旧的包名            String oldName = mSettings.mRenamedPackages.get(pkg.packageName);            if (pkg.mOriginalPackages != null && pkg.mOriginalPackages.contains(oldName)) {                // This package has been renamed to its original name.  Let's                // use that.这个包已经被重新命名为原来的名称，根据原始包名创建一个PackageSetting对象                ps = mSettings.peekPackageLPr(oldName);            }            // If there was no original package, see one for the real package name.            if (ps == null) {//如果没有原始包，根据新包名创建一个PackageSetting对象                ps = mSettings.peekPackageLPr(pkg.packageName);            }

            // Check to see if this package could be hiding/updating a system            // package.  Must look for it either under the original or real            // package name depending on our state. 检查应用是否存在升级包            updatedPkg = mSettings.getDisabledSystemPkgLPr(ps != null ? ps.name : pkg.packageName);            if (DEBUG_INSTALL && updatedPkg != null) Slog.d(TAG, "updatedPkg = " + updatedPkg);        }        boolean updatedPkgBetter = false;        // First check if this is a system package that may involve an update如果扫描的是系统应用并且有升级包        if (updatedPkg != null && (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {            // If new package is not located in "/system/priv-app" (e.g. due to an OTA),            // it needs to drop FLAG_PRIVILEGED.            if (locationIsPrivileged(scanFile)) {//位于/system/priv-app目录下                updatedPkg.pkgFlags |= ApplicationInfo.FLAG_PRIVILEGED;            } else {                updatedPkg.pkgFlags &= ~ApplicationInfo.FLAG_PRIVILEGED;            }            if (ps != null && !ps.codePath.equals(scanFile)) {                // The path has changed from what was last scanned...  check the                // version of the new path against what we have stored to determine                // what to do.如果包名和上次扫描的结果不相同了，根据版本号来决定如何处理                if (DEBUG_INSTALL) Slog.d(TAG, "Path changing from " + ps.codePath);                if (pkg.mVersionCode <= ps.versionCode) {//如果扫描文件的版本号低于升级包的版本，忽略这个文件                    // The system package has been updated and the code path does not match                    // Ignore entry. Skip it.                    Slog.i(TAG, "Package " + ps.name + " at " + scanFile                            + " ignored: updated version " + ps.versionCode                            + " better than this " + pkg.mVersionCode);                    if (!updatedPkg.codePath.equals(scanFile)) {                        Slog.w(PackageManagerService.TAG, "Code path for hidden system pkg : "                                + ps.name + " changing from " + updatedPkg.codePathString                                + " to " + scanFile);                        updatedPkg.codePath = scanFile;                        updatedPkg.codePathString = scanFile.toString();                    }                    updatedPkg.pkg = pkg;                    throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE, null);                } else {                    // The current app on the system partition is better than                    // what we have updated to on the data partition; switch                    // back to the system partition version.                    // At this point, its safely assumed that package installation for                    // apps in system partition will go through. If not there won't be a working                    // version of the app                    // writer如果扫描文件的版本号高于升级包的版本，则把升级包删除掉                    synchronized (mPackages) {                        // Just remove the loaded entries from package lists.                        mPackages.remove(ps.name);                    }                    logCriticalInfo(Log.WARN, "Package " + ps.name + " at " + scanFile                            + " reverting from " + ps.codePathString                            + ": new version " + pkg.mVersionCode                            + " better than installed " + ps.versionCode);                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,                            getAppDexInstructionSets(ps));                    synchronized (mInstallLock) {                        args.cleanUpResourcesLI();                    }                    synchronized (mPackages) {                        mSettings.enableSystemPackageLPw(ps.name);                    }                    updatedPkgBetter = true;                }            }        }        if (updatedPkg != null) {//如果升级包存在，把属性设为系统应用            // An updated system app will not have the PARSE_IS_SYSTEM flag set            // initially            parseFlags |= PackageParser.PARSE_IS_SYSTEM;            // An updated privileged app will not have the PARSE_IS_PRIVILEGED            // flag set initially            if ((updatedPkg.pkgFlags & ApplicationInfo.FLAG_PRIVILEGED) != 0) {                parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;            }        }

（4）扫描文件的签名。

        // Verify certificates against what was last scanned        collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags);

        /*         * A new system app appeared, but we already had a non-system one of the         * same name installed earlier.         */        boolean shouldHideSystemApp = false;        if (updatedPkg == null && ps != null//如果扫描的文件是系统应用，但是也存在一个同名的普通应用                && (parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) != 0 && !isSystemApp(ps)) {            /*             * Check to make sure the signatures match first. If they don't,             * wipe the installed application and its data.             */            if (compareSignatures(ps.signatures.mSignatures, pkg.mSignatures)                    != PackageManager.SIGNATURE_MATCH) {//比较它们的签名，如果不相同就删除扫描到的系统应用                logCriticalInfo(Log.WARN, "Package " + ps.name + " appeared on system, but"                        + " signatures don't match existing userdata copy; removing");                deletePackageLI(pkg.packageName, null, true, null, null, 0, null, false);                ps = null;            } else {                /*                 * If the newly-added system app is an older version than the                 * already installed version, hide it. It will be scanned later                 * and re-added like an update.如果扫描的系统应用和安装的应用签名相同，则比较他们的版本；                 */                if (pkg.mVersionCode <= ps.versionCode) {//如果安装的应用版本高，则构成了升级关系，把系统应用隐藏。                    shouldHideSystemApp = true;                    logCriticalInfo(Log.INFO, "Package " + ps.name + " appeared at " + scanFile                            + " but new version " + pkg.mVersionCode + " better than installed "                            + ps.versionCode + "; hiding system");                } else {//删除安装的应用                    /*                     * The newly found system app is a newer version that the                     * one previously installed. Simply remove the                     * already-installed application and replace it with our own                     * while keeping the application data.                     */                    logCriticalInfo(Log.WARN, "Package " + ps.name + " at " + scanFile                            + " reverting from " + ps.codePathString + ": new version "                            + pkg.mVersionCode + " better than installed " + ps.versionCode);                    InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),                            ps.codePathString, ps.resourcePathString, ps.legacyNativeLibraryPathString,                            getAppDexInstructionSets(ps));                    synchronized (mInstallLock) {                        args.cleanUpResourcesLI();                    }                }            }        }

        // The apk is forward locked (not public) if its code and resources        // are kept in different files. (except for app in either system or        // vendor path).        // 如果一个应用的代码路径和资源路径不相同，则加上PARSE_FORWARD_LOCK标记，这类应用是forward locked类应用        if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {            if (ps != null && !ps.codePath.equals(ps.resourcePath)) {                parseFlags |= PackageParser.PARSE_FORWARD_LOCK;            }        }        // TODO: extend to support forward-locked splits        String resourcePath = null;        String baseResourcePath = null;        if ((parseFlags & PackageParser.PARSE_FORWARD_LOCK) != 0 && !updatedPkgBetter) {            if (ps != null && ps.resourcePathString != null) {//如果是forward locked类应用，且他们的资源路径不为空，单独设置他们的资源路径                resourcePath = ps.resourcePathString;                baseResourcePath = ps.resourcePathString;            } else {                // Should not happen at all. Just log an error.                Slog.e(TAG, "Resource path not set for pkg : " + pkg.packageName);            }        } else {//如果是普通应用，设置他们的资源路径和代码路径一致            resourcePath = pkg.codePath;            baseResourcePath = pkg.baseCodePath;        }        // Set application objects path explicitly.        pkg.applicationInfo.setCodePath(pkg.codePath);        pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);        pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);        pkg.applicationInfo.setResourcePath(resourcePath);        pkg.applicationInfo.setBaseResourcePath(baseResourcePath);        pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);

       // Note that we invoke the following method only if we are about to unpack an application        PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanFlags                | SCAN_UPDATE_SIGNATURE, currentTime, user);

       /*         * If the system app should be overridden by a previously installed         * data, hide the system app now and let the /data/app scan pick it up         * again.         */        if (shouldHideSystemApp) {            synchronized (mPackages) {                /*                 * We have to grant systems permissions before we hide, because                 * grantPermissions will assume the package update is trying to                 * expand its permissions.如果扫描的应用带有升级包，把他们的关系保存到mSettings中                 */                grantPermissionsLPw(pkg, true, pkg.packageName);                mSettings.disableSystemPackageLPw(pkg.packageName);            }        }        return scannedPkg;    }

scanPackageLI方法在解析出了apk文件的信息后，主要是通过对比上次启动的结果来检查系统中是否存在和扫描的文件相冲突的应用包存在，如果有scanPackageLI方法会设法纠正错误，保证系统启动后的一致性。完成错误检查后，将进入第二阶段，调用PackageParser.Package对象的scanPackageLI方法来构建PackageManagerService中的数据结构。

        接下来分析下应用安装流程： Android应用管理二 --APK包的安装、卸载和优化（PackageManagerService）

更多相关文章

1. 一款常用的 Squid 日志分析工具
2. GitHub 标星 8K+！一款开源替代 ls 的工具你值得拥有！
3. RHEL 6 下 DHCP+TFTP+FTP+PXE+Kickstart 实现无人值守安装
4. Linux 环境下实战 Rsync 备份工具及配置 rsync+inotify 实时同步
5. Nginx系列教程（六）| 手把手教你搭建 LNMP 架构并部署天空网络电影
6. android中的设计模式--观察者模式
7. android gen 目录消失
8. Android中实现应用程序的国际化与本地化
9. Android(安卓)Studio中使用过程中遇到的问题（二）--SVN的安装与使用

随机推荐

1. Android(安卓)选择图片、上传图片之Pictu
2. spring for android
3. Android(安卓)sdk 软件栈
4. [Android] 使用Matrix矩阵类对图像进行缩
5. Android学习日记----------Android(安卓)
6. Android使用xutils3框架实现应用程序内的
7. Android澶氱偣瑙︽懜鐨勫疄鐜?(杞?
8. 让Qt应用程序跑在Android上
9. Android中的资源与国际化!
10. Android(安卓)开发艺术探索笔记-Activity