• Android—PMS: PackageInstaller到PMS

    PackageManager

    与ActivityManager和AMS的关系类似，PMS也有一个对应的管理类PackageManager，用于向应用程序进程提供一些功能。PackageManager是一个抽象类，它的具体实现类为ApplicationPackageManager，ApplicationPackageManager中的方法会通过IPackageManager与PMS进行进程间通信，因此PackageManager所提供的功能最终是由PMS来实现的，这么设计的主要用意是为了避免系统服务PMS直接被访问。PackageManager提供了一些功能，主要有以下几点：

    1. 获取一个应用程序的所有信息（ApplicationInfo）。
    2. 解析manifest.xml文件，查询permission相关信息。
    3. 获取包的信息。
    4. 安装、卸载APK.

    这里分析点击安装包的情况：

    跳转到PackageInstaller应用

    1. Intent intent = new Intent(Intent.ACTION_VIEW);
    2. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    3. if (Build.VERSION.SDK_INT >= 24) {  //7.0新跳转
    4.     Uri apkUri = FileProvider.getUriForFile(paramContext, "com.xxx.xxx.xxx", file);
    5.     intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
    6.     intent.setDataAndType(apkUri, "application/vnd.android.package-archive");
    7. } else {
    8.     intent.setDataAndType(Uri.fromFile(file), "application/vnd.android.package-archive");
    9. }

    application/vnd.android.package-archive对应文件类型apk

     PackageInstaller的AndroidManifest.xml

    1. <activity android:name=".InstallStart"
    2.                android:exported="true"
    3.                android:excludeFromRecents="true">
    4.            <intent-filter android:priority="1">
    5.                <action android:name="android.intent.action.VIEW" />
    6.                <action android:name="android.intent.action.INSTALL_PACKAGE" />
    7.                <category android:name="android.intent.category.DEFAULT" />
    8.                <data android:scheme="file" />
    9.                <data android:scheme="content" />
    10.                <data android:mimeType="application/vnd.android.package-archive" />
    11.            intent-filter>
    12.         ...
    13. activity>

    注意 action与mimeType与Intent参数对应，到InstallStart页面

    frameworks\base\packages\PackageInstaller\src\com\android\packageinstaller\InstallStart.java

    1.     @Override
    2.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    3.         super.onCreate(savedInstanceState);
    4.         mIPackageManager = AppGlobals.getPackageManager();
    5.         Intent intent = getIntent();
    6.         String callingPackage = getCallingPackage();
    7.         final boolean isSessionInstall =
    8.                 PackageInstaller.ACTION_CONFIRM_INSTALL.equals(intent.getAction());
    9.         // If the activity was started via a PackageInstaller session, we retrieve the calling
    10.         // package from that session
    11.         final int sessionId = (isSessionInstall
    12.                 ? intent.getIntExtra(PackageInstaller.EXTRA_SESSION_ID, -1)
    13.                 : -1);
    14.         .....
    15.         //获取应用信息
    16.         final ApplicationInfo sourceInfo = getSourceInfo(callingPackage);
    17.         final int originatingUid = getOriginatingUid(sourceInfo);
    18.         boolean isTrustedSource = false;
    19.         if (sourceInfo != null
    20.                 && (sourceInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0) {
    21.             isTrustedSource = intent.getBooleanExtra(Intent.EXTRA_NOT_UNKNOWN_SOURCE, false);
    22.         }
    23.         ....
    24.         Intent nextActivity = new Intent(intent);
    25.         nextActivity.setFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
    26.         // The the installation source as the nextActivity thinks this activity is the source, hence
    27.         // set the originating UID and sourceInfo explicitly
    28.         nextActivity.putExtra(PackageInstallerActivity.EXTRA_CALLING_PACKAGE, callingPackage);
    29.         nextActivity.putExtra(PackageInstallerActivity.EXTRA_ORIGINAL_SOURCE_INFO, sourceInfo);
    30.         nextActivity.putExtra(Intent.EXTRA_ORIGINATING_UID, originatingUid);
    31.  
    32.         //这里为false
    33.         if (isSessionInstall) {
    34.             nextActivity.setClass(this, PackageInstallerActivity.class);
    35.         } else {
    36.             Uri packageUri = intent.getData();
    37.             // 判断Uri的Scheme协议是否是content
    38.             if (packageUri != null && packageUri.getScheme().equals(
    39.                     ContentResolver.SCHEME_CONTENT)) {
    40.                 nextActivity.setClass(this, InstallStaging.class);
    41.             } else if (packageUri != null && packageUri.getScheme().equals(
    42.                     PackageInstallerActivity.SCHEME_PACKAGE)) {
    43.                 nextActivity.setClass(this, PackageInstallerActivity.class);
    44.             } else {
    45.                 Intent result = new Intent();
    46.                 result.putExtra(Intent.EXTRA_INSTALL_RESULT,
    47.                         PackageManager.INSTALL_FAILED_INVALID_URI);
    48.                 setResult(RESULT_FIRST_USER, result);
    49.                 nextActivity = null;
    50.             }
    51.         }
    52.  
    53.         if (nextActivity != null) {
    54.             startActivity(nextActivity);
    55.         }
    56.         finish();
    57.     }

    这里是安卓10的源码，需要用到FileProvider，所以会走到 

    nextActivity.setClass(this, InstallStaging.class);

    frameworks\base\packages\PackageInstaller\src\com\android\packageinstaller\InstallStaging.java

    1.     @Override
    2.     protected void onResume() {
    3.         super.onResume();
    4.  
    5.         // This is the first onResume in a single life of the activity
    6.         if (mStagingTask == null) {
    7.             // File does not exist, or became invalid
    8.             if (mStagedFile == null) {
    9.                 // Create file delayed to be able to show error
    10.                 try {
    11.                     mStagedFile = TemporaryFileManager.getStagedFile(this);
    12.                 } catch (IOException e) {
    13.                     showError();
    14.                     return;
    15.                 }
    16.             }
    17.  
    18.             mStagingTask = new StagingAsyncTask();
    19.             mStagingTask.execute(getIntent().getData());
    20.         }
    21.     }

     frameworks\base\packages\PackageInstaller\src\com\android\packageinstaller\TemporaryFileManager.java

    1.     @NonNull
    2.     public static File getStagedFile(@NonNull Context context) throws IOException {
    3.         return File.createTempFile("package", ".apk", context.getNoBackupFilesDir());
    4.     }

     mStagedFile是一个叫package.apk的File对象

    1.     private final class StagingAsyncTask extends AsyncTask {
    2.         @Override
    3.         protected Boolean doInBackground(Uri... params) {
    4.             if (params == null || params.length <= 0) {
    5.                 return false;
    6.             }
    7.             Uri packageUri = params[0];
    8.             try (InputStream in = getContentResolver().openInputStream(packageUri)) {
    9.                 // Despite the comments in ContentResolver#openInputStream the returned stream can
    10.                 // be null.
    11.                 if (in == null) {
    12.                     return false;
    13.                 }
    14.  
    15.                 try (OutputStream out = new FileOutputStream(mStagedFile)) {
    16.                     byte[] buffer = new byte[1024 * 1024];
    17.                     int bytesRead;
    18.                     while ((bytesRead = in.read(buffer)) >= 0) {
    19.                         // Be nice and respond to a cancellation
    20.                         if (isCancelled()) {
    21.                             return false;
    22.                         }
    23.                         out.write(buffer, 0, bytesRead);
    24.                     }
    25.                 }
    26.             } catch (IOException | SecurityException | IllegalStateException e) {
    27.                 Log.w(LOG_TAG, "Error staging apk from content URI", e);
    28.                 return false;
    29.             }
    30.             return true;
    31.         }
    32.  
    33.         @Override
    34.         protected void onPostExecute(Boolean success) {
    35.             if (success) {
    36.                 // Now start the installation again from a file
    37.                 Intent installIntent = new Intent(getIntent());
    38.                 installIntent.setClass(InstallStaging.this, DeleteStagedFileOnResult.class);
    39.                 installIntent.setData(Uri.fromFile(mStagedFile));
    40.  
    41.                 if (installIntent.getBooleanExtra(Intent.EXTRA_RETURN_RESULT, false)) {
    42.                     installIntent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
    43.                 }
    44.  
    45.                 installIntent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
    46.                 startActivity(installIntent);
    47.  
    48.                 InstallStaging.this.finish();
    49.             } else {
    50.                 showError();
    51.             }
    52.         }
    53.     }

    StagingAsyncTask工作：
    1.doInBackground 把uri中需要安装的apk拷贝到临时文件中/data/no_backup/package.apk
    2.onPostExecute 当拷贝任务处理完之后，就会把当前的临时文件Uri作为Intent的参数（这个时候会把Uri的类型设置为file），跳转到DeleteStagedFileOnResult中。

    frameworks\base\packages\PackageInstaller\src\com\android\packageinstaller\DeleteStagedFileOnResult.java

    1. public class DeleteStagedFileOnResult extends Activity {
    2.     @Override
    3.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    4.         super.onCreate(savedInstanceState);
    5.  
    6.         if (savedInstanceState == null) {
    7.             Intent installIntent = new Intent(getIntent());
    8.             installIntent.setClass(this, PackageInstallerActivity.class);
    9.  
    10.             installIntent.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
    11.             startActivityForResult(installIntent, 0);
    12.         }
    13.     }
    14.  
    15.     @Override
    16.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    17.         File sourceFile = new File(getIntent().getData().getPath());
    18.         sourceFile.delete();
    19.  
    20.         setResult(resultCode, data);
    21.         finish();
    22.     }
    23. }

     DeleteStagedFileOnResult是个过度，负责跳转后删除package.apk

    APK的安装Activity：PackageInstallerActivity

    1.     @Override
    2.     protected void onCreate(Bundle icicle) {
    3.         getWindow().addSystemFlags(SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS);
    4.         super.onCreate(null);
    5.         mPm = getPackageManager();
    6.         mIpm = AppGlobals.getPackageManager();
    7.         mAppOpsManager = (AppOpsManager) getSystemService(Context.APP_OPS_SERVICE);
    8.         mInstaller = mPm.getPackageInstaller();
    9.         mUserManager = (UserManager) getSystemService(Context.USER_SERVICE);
    10.         ....
    11.         boolean wasSetUp = processPackageUri(packageUri);
    12.         if (!wasSetUp) {
    13.             return;
    14.         }
    15.  
    16.         // load dummy layout with OK button disabled until we override this layout in
    17.         // startInstallConfirm
    18.         bindUi();
    19.         checkIfAllowedAndInitiateInstall();
    20.     }
    • PackageManager 用于向应用程序进程提供一些功能，最终的功能是由PMS来实现的 
    • AppOpsManager 用于权限动态检测,在Android4.3中被引入
    • PackageInstaller 提供安装、升级和删除应用程序功能
    • UserManager 用于多用户管理

    1.processPackageUri(packageUri);

    1.     /**
    2.      * **解析Uri并设置此包的安装程序。
    3.      *
    4.      * @param packageUri The URI to parse
    5.      *
    6.      * @return {@code true} 如果安装程序可以设置
    7.      */
    8.     private boolean processPackageUri(final Uri packageUri) {
    9.         mPackageURI = packageUri;
    10.         final String scheme = packageUri.getScheme();
    11.         switch (scheme) {
    12.             case SCHEME_PACKAGE: {
    13.                 ....
    14.             } break;
    15.             case ContentResolver.SCHEME_FILE: {
    16.                 File sourceFile = new File(packageUri.getPath());
    17.                 PackageParser.Package parsed = PackageUtil.getPackageInfo(this, sourceFile);
    18.  
    19.                 // Check for parse errors
    20.                 if (parsed == null) {
    21.                     Log.w(TAG, "Parse error when parsing manifest. Discontinuing installation");
    22.                     showDialogInner(DLG_PACKAGE_ERROR);
    23.                     setPmResult(PackageManager.INSTALL_FAILED_INVALID_APK);
    24.                     return false;
    25.                 }
    26.                 mPkgInfo = PackageParser.generatePackageInfo(parsed, null,
    27.                         PackageManager.GET_PERMISSIONS, 0, 0, null,
    28.                         new PackageUserState());
    29.                 mAppSnippet = PackageUtil.getAppSnippet(this, mPkgInfo.applicationInfo, sourceFile);
    30.             } break;
    31.  
    32.             default: {
    33.                 throw new IllegalArgumentException("Unexpected URI scheme " + packageUri);
    34.             }
    35.         }
    36.  
    37.         return true;
    38.     }

    前面apk的数据已经用

    installIntent.setData(Uri.fromFile(mStagedFile));

    传到PackageInstallerActivity了，所以这里走的是file。

    processPackageUri解析uri获取

    1. mPkgInfo，主要获取Permission相关信息。
    2. mAppSnippet，应用label名，没有定义则用应用包名

    2.bindUi()

    1.     private void bindUi() {
    2.         mAlert.setIcon(mAppSnippet.icon);
    3.         mAlert.setTitle(mAppSnippet.label);
    4.         mAlert.setView(R.layout.install_content_view);
    5.         mAlert.setButton(DialogInterface.BUTTON_POSITIVE, getString(R.string.install),
    6.                 (ignored, ignored2) -> {
    7.                     if (mOk.isEnabled()) {
    8.                         if (mSessionId != -1) {
    9.                             mInstaller.setPermissionsResult(mSessionId, true);
    10.                             finish();
    11.                         } else {
    12.                             startInstall();
    13.                         }
    14.                     }
    15.                 }, null);
    16.         mAlert.setButton(DialogInterface.BUTTON_NEGATIVE, getString(R.string.cancel),
    17.                 (ignored, ignored2) -> {
    18.                     // Cancel and finish
    19.                     setResult(RESULT_CANCELED);
    20.                     if (mSessionId != -1) {
    21.                         mInstaller.setPermissionsResult(mSessionId, false);
    22.                     }
    23.                     finish();
    24.                 }, null);
    25.         setupAlert();
    26.  
    27.         mOk = mAlert.getButton(DialogInterface.BUTTON_POSITIVE);
    28.         mOk.setEnabled(false);
    29.     }

     bindUI()就是给弹出来的安装界面设置UI，然后为安装和取消两个按钮设置点击事件。安装按钮的点击事件是startInstall();

    3.checkIfAllowedAndInitiateInstall()

    1.     private void checkIfAllowedAndInitiateInstall() {
    2.         // Check for install apps user restriction first.
    3.         final int installAppsRestrictionSource = mUserManager.getUserRestrictionSource(
    4.                 UserManager.DISALLOW_INSTALL_APPS, Process.myUserHandle());
    5.         if ((installAppsRestrictionSource & UserManager.RESTRICTION_SOURCE_SYSTEM) != 0) {
    6.             showDialogInner(DLG_INSTALL_APPS_RESTRICTED_FOR_USER);
    7.             return;
    8.         } else if (installAppsRestrictionSource != UserManager.RESTRICTION_NOT_SET) {
    9.             startActivity(new Intent(Settings.ACTION_SHOW_ADMIN_SUPPORT_DETAILS));
    10.             finish();
    11.             return;
    12.         }
    13.  
    14.         if (mAllowUnknownSources || !isInstallRequestFromUnknownSource(getIntent())) {
    15.             initiateInstall();
    16.         } else {
    17.             // Check for unknown sources restrictions.
    18.             final int unknownSourcesRestrictionSource = mUserManager.getUserRestrictionSource(
    19.                     UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES, Process.myUserHandle());
    20.             final int unknownSourcesGlobalRestrictionSource = mUserManager.getUserRestrictionSource(
    21.                     UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY, Process.myUserHandle());
    22.             final int systemRestriction = UserManager.RESTRICTION_SOURCE_SYSTEM
    23.                     & (unknownSourcesRestrictionSource | unknownSourcesGlobalRestrictionSource);
    24.             if (systemRestriction != 0) {
    25.                 showDialogInner(DLG_UNKNOWN_SOURCES_RESTRICTED_FOR_USER);
    26.             } else if (unknownSourcesRestrictionSource != UserManager.RESTRICTION_NOT_SET) {
    27.                 startAdminSupportDetailsActivity(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES);
    28.             } else if (unknownSourcesGlobalRestrictionSource != UserManager.RESTRICTION_NOT_SET) {
    29.                 startAdminSupportDetailsActivity(
    30.                         UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY);
    31.             } else {
    32.                 handleUnknownSources();
    33.             }
    34.         }
    35.     }

    这个方法作用就如名字所示了，检查应用权限，还有就是是否是未知来源安装包。

    主要看initiateInstall();

    1.     private void initiateInstall() {
    2.         String pkgName = mPkgInfo.packageName;
    3.         // Check if there is already a package on the device with this name
    4.         // but it has been renamed to something else.
    5.         String[] oldName = mPm.canonicalToCurrentPackageNames(new String[] { pkgName });
    6.         if (oldName != null && oldName.length > 0 && oldName[0] != null) {
    7.             pkgName = oldName[0];
    8.             mPkgInfo.packageName = pkgName;
    9.             mPkgInfo.applicationInfo.packageName = pkgName;
    10.         }
    11.         // Check if package is already installed. display confirmation dialog if replacing pkg
    12.         try {
    13.             // This is a little convoluted because we want to get all uninstalled
    14.             // apps, but this may include apps with just data, and if it is just
    15.             // data we still want to count it as "installed".
    16.             mAppInfo = mPm.getApplicationInfo(pkgName,
    17.                     PackageManager.MATCH_UNINSTALLED_PACKAGES);
    18.             if ((mAppInfo.flags&ApplicationInfo.FLAG_INSTALLED) == 0) {
    19.                 mAppInfo = null;
    20.             }
    21.         } catch (NameNotFoundException e) {
    22.             mAppInfo = null;
    23.         }
    24.  
    25.         startInstallConfirm();
    26.     }
    27.  
    28.     private void startInstallConfirm() {
    29.         View viewToEnable;
    30.  
    31.         if (mAppInfo != null) {
    32.             viewToEnable = (mAppInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0
    33.                     ? requireViewById(R.id.install_confirm_question_update_system)
    34.                     : requireViewById(R.id.install_confirm_question_update);
    35.         } else {
    36.             // This is a new application with no permissions.
    37.             viewToEnable = requireViewById(R.id.install_confirm_question);
    38.         }
    39.  
    40.         viewToEnable.setVisibility(View.VISIBLE);
    41.  
    42.         mEnableOk = true;
    43.         mOk.setEnabled(true);
    44.     }

    mOk.setEnabled(true);这里让界面的安装按钮可点击。

    onCreate就分析完了，接下来看点击安装按钮的点击事件startInstall()。

    1.     private void startInstall() {
    2.         // Start subactivity to actually install the application
    3.         Intent newIntent = new Intent();
    4.         newIntent.putExtra(PackageUtil.INTENT_ATTR_APPLICATION_INFO,
    5.                 mPkgInfo.applicationInfo);
    6.         newIntent.setData(mPackageURI);
    7.         newIntent.setClass(this, InstallInstalling.class);
    8.         String installerPackageName = getIntent().getStringExtra(
    9.                 Intent.EXTRA_INSTALLER_PACKAGE_NAME);
    10.         if (mOriginatingURI != null) {
    11.             newIntent.putExtra(Intent.EXTRA_ORIGINATING_URI, mOriginatingURI);
    12.         }
    13.         if (mReferrerURI != null) {
    14.             newIntent.putExtra(Intent.EXTRA_REFERRER, mReferrerURI);
    15.         }
    16.         if (mOriginatingUid != PackageInstaller.SessionParams.UID_UNKNOWN) {
    17.             newIntent.putExtra(Intent.EXTRA_ORIGINATING_UID, mOriginatingUid);
    18.         }
    19.         if (installerPackageName != null) {
    20.             newIntent.putExtra(Intent.EXTRA_INSTALLER_PACKAGE_NAME,
    21.                     installerPackageName);
    22.         }
    23.         if (getIntent().getBooleanExtra(Intent.EXTRA_RETURN_RESULT, false)) {
    24.             newIntent.putExtra(Intent.EXTRA_RETURN_RESULT, true);
    25.         }
    26.         newIntent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
    27.         if(localLOGV) Log.i(TAG, "downloaded app uri="+mPackageURI);
    28.         startActivity(newIntent);
    29.         finish();
    30.     }

    startInstall方法用于跳转到InstallInstalling这个Activity，并关闭掉当前的PackageInstallerActivity。

    frameworks\base\packages\PackageInstaller\src\com\android\packageinstaller\InstallInstalling.java

    1.     @Override
    2.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    3.         super.onCreate(savedInstanceState);
    4.         ApplicationInfo appInfo = getIntent()
    5.                 .getParcelableExtra(PackageUtil.INTENT_ATTR_APPLICATION_INFO);
    6.         mPackageURI = getIntent().getData();
    7.         //这里为false
    8.         if ("package".equals(mPackageURI.getScheme())) {
    9.             .....
    10.         } else {
    11.             final File sourceFile = new File(mPackageURI.getPath());
    12.             PackageUtil.AppSnippet as = PackageUtil.getAppSnippet(this, appInfo, sourceFile);
    13.  
    14.             mAlert.setIcon(as.icon);
    15.             mAlert.setTitle(as.label);
    16.             mAlert.setView(R.layout.install_content_view);
    17.             mAlert.setButton(DialogInterface.BUTTON_NEGATIVE, getString(R.string.cancel),
    18.                     (ignored, ignored2) -> {
    19.                         if (mInstallingTask != null) {
    20.                             mInstallingTask.cancel(true);
    21.                         }
    22.  
    23.                         if (mSessionId > 0) {
    24.                             getPackageManager().getPackageInstaller().abandonSession(mSessionId);
    25.                             mSessionId = 0;
    26.                         }
    27.  
    28.                         setResult(RESULT_CANCELED);
    29.                         finish();
    30.                     }, null);
    31.             setupAlert();
    32.             requireViewById(R.id.installing).setVisibility(View.VISIBLE);
    33.  
    34.             if (savedInstanceState != null) {
    35.                 ....
    36.             } else {
    37.                 PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
    38.                         PackageInstaller.SessionParams.MODE_FULL_INSTALL);
    39.                 params.setInstallAsInstantApp(false);
    40.                 params.setReferrerUri(getIntent().getParcelableExtra(Intent.EXTRA_REFERRER));
    41.                 params.setOriginatingUri(getIntent()
    42.                         .getParcelableExtra(Intent.EXTRA_ORIGINATING_URI));
    43.                 params.setOriginatingUid(getIntent().getIntExtra(Intent.EXTRA_ORIGINATING_UID,
    44.                         UID_UNKNOWN));
    45.                 params.setInstallerPackageName(getIntent().getStringExtra(
    46.                         Intent.EXTRA_INSTALLER_PACKAGE_NAME));
    47.                 params.setInstallReason(PackageManager.INSTALL_REASON_USER);
    48.  
    49.                 File file = new File(mPackageURI.getPath());
    50.                 try {
    51.                     PackageParser.PackageLite pkg = PackageParser.parsePackageLite(file, 0);
    52.                     params.setAppPackageName(pkg.packageName);
    53.                     params.setInstallLocation(pkg.installLocation);
    54.                     params.setSize(
    55.                             PackageHelper.calculateInstalledSize(pkg, false, params.abiOverride));
    56.                 } catch (PackageParser.PackageParserException e) {
    57.                     Log.e(LOG_TAG, "Cannot parse package " + file + ". Assuming defaults.");
    58.                     Log.e(LOG_TAG,
    59.                             "Cannot calculate installed size " + file + ". Try only apk size.");
    60.                     params.setSize(file.length());
    61.                 } catch (IOException e) {
    62.                     Log.e(LOG_TAG,
    63.                             "Cannot calculate installed size " + file + ". Try only apk size.");
    64.                     params.setSize(file.length());
    65.                 }
    66.  
    67.                 try {
    68.                     mInstallId = InstallEventReceiver
    69.                             .addObserver(this, EventResultPersister.GENERATE_NEW_ID,
    70.                                     this::launchFinishBasedOnResult);
    71.                 } catch (EventResultPersister.OutOfIdsException e) {
    72.                     launchFailure(PackageManager.INSTALL_FAILED_INTERNAL_ERROR, null);
    73.                 }
    74.  
    75.                 try {
    76.                     mSessionId = getPackageManager().getPackageInstaller().createSession(params);
    77.                 } catch (IOException e) {
    78.                     launchFailure(PackageManager.INSTALL_FAILED_INTERNAL_ERROR, null);
    79.                 }
    80.             }
    81.             mCancelButton = mAlert.getButton(DialogInterface.BUTTON_NEGATIVE);
    82.             mSessionCallback = new InstallSessionCallback();
    83.         }
    84.     }

    解析pkg获取安装包参数，通过PMS获取mSessionId。

    1.     @Override
    2.     protected void onResume() {
    3.         super.onResume();
    4.  
    5.         // This is the first onResume in a single life of the activity
    6.         if (mInstallingTask == null) {
    7.             PackageInstaller installer = getPackageManager().getPackageInstaller();
    8.             PackageInstaller.SessionInfo sessionInfo = installer.getSessionInfo(mSessionId);
    9.  
    10.             if (sessionInfo != null && !sessionInfo.isActive()) {
    11.                 mInstallingTask = new InstallingAsyncTask();
    12.                 mInstallingTask.execute();
    13.             } else {
    14.                 // we will receive a broadcast when the install is finished
    15.                 mCancelButton.setEnabled(false);
    16.                 setFinishOnTouchOutside(false);
    17.             }
    18.         }
    19.     }

    onResume执行了 InstallingAsyncTask

    1.     /**
    2.      * Send the package to the package installer and then register a event result observer that
    3.      * will call {@link #launchFinishBasedOnResult(int, int, String)}
    4.      */
    5.     private final class InstallingAsyncTask extends AsyncTask
    6.             PackageInstaller.Session> {
    7.         volatile boolean isDone;
    8.  
    9.         @Override
    10.         protected PackageInstaller.Session doInBackground(Void... params) {
    11.             PackageInstaller.Session session;
    12.             try {
    13.                 session = getPackageManager().getPackageInstaller().openSession(mSessionId);
    14.             } catch (IOException e) {
    15.                 return null;
    16.             }
    17.             session.setStagingProgress(0);
    18.             try {
    19.                 File file = new File(mPackageURI.getPath());
    20.  
    21.                 try (InputStream in = new FileInputStream(file)) {
    22.                     long sizeBytes = file.length();
    23.                     try (OutputStream out = session
    24.                             .openWrite("PackageInstaller", 0, sizeBytes)) {
    25.                         byte[] buffer = new byte[1024 * 1024];
    26.                         while (true) {
    27.                             int numRead = in.read(buffer);
    28.                             if (numRead == -1) {
    29.                                 session.fsync(out);
    30.                                 break;
    31.                             }
    32.                             if (isCancelled()) {
    33.                                 session.close();
    34.                                 break;
    35.                             }
    36.                             out.write(buffer, 0, numRead);
    37.                             if (sizeBytes > 0) {
    38.                                 float fraction = ((float) numRead / (float) sizeBytes);
    39.                                 session.addProgress(fraction);
    40.                             }
    41.                         }
    42.                     }
    43.                 }
    44.                 return session;
    45.             } catch (IOException | SecurityException e) {
    46.                 Log.e(LOG_TAG, "Could not write package", e);
    47.  
    48.                 session.close();
    49.  
    50.                 return null;
    51.             } finally {
    52.                 synchronized (this) {
    53.                     isDone = true;
    54.                     notifyAll();
    55.                 }
    56.             }
    57.         }
    58.  
    59.         @Override
    60.         protected void onPostExecute(PackageInstaller.Session session) {
    61.             if (session != null) {
    62.                 Intent broadcastIntent = new Intent(BROADCAST_ACTION);
    63.                 broadcastIntent.setFlags(Intent.FLAG_RECEIVER_FOREGROUND);
    64.                 broadcastIntent.setPackage(getPackageName());
    65.                 broadcastIntent.putExtra(EventResultPersister.EXTRA_ID, mInstallId);
    66.  
    67.                 PendingIntent pendingIntent = PendingIntent.getBroadcast(
    68.                         InstallInstalling.this,
    69.                         mInstallId,
    70.                         broadcastIntent,
    71.                         PendingIntent.FLAG_UPDATE_CURRENT);
    72.  
    73.                 session.commit(pendingIntent.getIntentSender());
    74.                 mCancelButton.setEnabled(false);
    75.                 setFinishOnTouchOutside(false);
    76.             } else {
    77.                 getPackageManager().getPackageInstaller().abandonSession(mSessionId);
    78.  
    79.                 if (!isCancelled()) {
    80.                     launchFailure(PackageManager.INSTALL_FAILED_INVALID_APK, null);
    81.                 }
    82.             }
    83.         }
    84.     }

    doInBackground将 APK 文件写入 session中。

    onPostExecute创建了一个PendingIntent，并将该PendingIntent的IntentSender通过session的commit方法发送出去

    通过 IPackageInstallerSession 来进行进程间的通信，最终会调用PackageInstallerSession 的 commit 方法

    frameworks\base\services\core\java\com\android\server\pm\PackageInstallerSession.java

    1.     @Override
    2.     public void commit(@NonNull IntentSender statusReceiver, boolean forTransfer) {
    3.         ....
    4.         mHandler.obtainMessage(MSG_COMMIT).sendToTarget();
    5.     }
    6.  
    7.     private final Handler.Callback mHandlerCallback = new Handler.Callback() {
    8.         @Override
    9.         public boolean handleMessage(Message msg) {
    10.             switch (msg.what) {
    11.                 case MSG_COMMIT:
    12.                     handleCommit();
    13.                     break;
    14.                 ....
    15.             }
    16.  
    17.             return true;
    18.         }
    19.     };
    20.  
    21.     private void handleCommit() {
    22.         ....
    23.         try {
    24.             synchronized (mLock) {
    25.                 commitNonStagedLocked(childSessions);
    26.             }
    27.         } catch (PackageManagerException e) {
    28.             final String completeMsg = ExceptionUtils.getCompleteMessage(e);
    29.             Slog.e(TAG, "Commit of session " + sessionId + " failed: " + completeMsg);
    30.             destroyInternal();
    31.             dispatchSessionFinished(e.error, completeMsg, null);
    32.         }
    33.     }
    34.  
    35.     private void commitNonStagedLocked(List childSessions)
    36.             throws PackageManagerException {
    37.         final PackageManagerService.ActiveInstallSession committingSession =
    38.                 makeSessionActiveLocked();
    39.         if (committingSession == null) {
    40.             return;
    41.         }
    42.         //多个包
    43.         if (isMultiPackage()) {
    44.             .....
    45.             mPm.installStage(activeChildSessions);
    46.         } else {
    47.             mPm.installStage(committingSession);
    48.         }
    49.     }

    这个mPm是PMS

        private final PackageManagerService mPm;

    frameworks\base\services\core\java\com\android\server\pm\PackageManagerService.java

    1.     void installStage(ActiveInstallSession activeInstallSession) {
    2.         final Message msg = mHandler.obtainMessage(INIT_COPY);
    3.         final InstallParams params = new InstallParams(activeInstallSession);
    4.         params.setTraceMethod("installStage").setTraceCookie(System.identityHashCode(params));
    5.         msg.obj = params;
    6.  
    7.         Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "installStage",
    8.                 System.identityHashCode(msg.obj));
    9.         Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "queueInstall",
    10.                 System.identityHashCode(msg.obj));
    11.  
    12.         mHandler.sendMessage(msg);
    13.     }
    14.  
    15.     class PackageHandler extends Handler {
    16.  
    17.         PackageHandler(Looper looper) {
    18.             super(looper);
    19.         }
    20.  
    21.         public void handleMessage(Message msg) {
    22.             try {
    23.                 doHandleMessage(msg);
    24.             } finally {
    25.                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    26.             }
    27.         }
    28.  
    29.         void doHandleMessage(Message msg) {
    30.             switch (msg.what) {
    31.                 case INIT_COPY: {
    32.                     HandlerParams params = (HandlerParams) msg.obj;
    33.                     if (params != null) {
    34.                         if (DEBUG_INSTALL) Slog.i(TAG, "init_copy: " + params);
    35.                         Trace.asyncTraceEnd(TRACE_TAG_PACKAGE_MANAGER, "queueInstall",
    36.                                 System.identityHashCode(params));
    37.                         Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "startCopy");
    38.                         params.startCopy();
    39.                         Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
    40.                     }
    41.                     break;
    42.                 .....
    43.                 }
    44.             }
    45.         }
    46.     }
    47.  
    48.     private abstract class HandlerParams {
    49.         /** User handle for the user requesting the information or installation. */
    50.         private final UserHandle mUser;
    51.         String traceMethod;
    52.         int traceCookie;
    53.         ....
    54.  
    55.         final void startCopy() {
    56.             if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);
    57.             handleStartCopy();
    58.             handleReturnCode();
    59.         }
    60.  
    61.         abstract void handleStartCopy();
    62.         abstract void handleReturnCode();
    63.     }

     PackageHandler 和 HandlerParams都是PMS的内部类，INIT_COPY的msg中，执行了 params.startCopy()，这个params是HandlerParams，而发送到handler之前是通过以下生成的。

    InstallParams params = new InstallParams(activeInstallSession);

     所以看InstallParams的handleStartCopy()和handleReturnCode()方法

    1.         //调用远程方法获取包信息和安装位置值。如果需要，根据默认策略覆盖安装位置，然后根据安装位置创建安装参数。
    2.         public void handleStartCopy() {
    3.             int ret = PackageManager.INSTALL_SUCCEEDED;
    4.  
    5.             final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
    6.             final boolean ephemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
    7.             PackageInfoLite pkgLite = null;
    8.             pkgLite = PackageManagerServiceUtils.getMinimalPackageInfo(mContext,
    9.                     origin.resolvedPath, installFlags, packageAbiOverride);
    10.             /*
    11.              * 如果没有空间，释放缓存
    12.              */
    13.             if (!origin.staged && pkgLite.recommendedInstallLocation
    14.                     == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
    15.                 // TODO: focus freeing disk space on the target device
    16.                 final StorageManager storage = StorageManager.from(mContext);
    17.                 final long lowThreshold = storage.getStorageLowBytes(
    18.                         Environment.getDataDirectory());
    19.  
    20.                 final long sizeBytes = PackageManagerServiceUtils.calculateInstalledSize(
    21.                         origin.resolvedPath, packageAbiOverride);
    22.                 if (sizeBytes >= 0) {
    23.                     try {
    24.                         mInstaller.freeCache(null, sizeBytes + lowThreshold, 0, 0);
    25.                         pkgLite = PackageManagerServiceUtils.getMinimalPackageInfo(mContext,
    26.                                 origin.resolvedPath, installFlags, packageAbiOverride);
    27.                     } catch (InstallerException e) {
    28.                         Slog.w(TAG, "Failed to free cache", e);
    29.                     }
    30.                 }
    31.             }
    32.  
    33.             //决定安装位置
    34.             if (ret == PackageManager.INSTALL_SUCCEEDED) {
    35.                 int loc = pkgLite.recommendedInstallLocation;
    36.                 if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
    37.                     ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
    38.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
    39.                     ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
    40.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
    41.                     ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
    42.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
    43.                     ret = PackageManager.INSTALL_FAILED_INVALID_APK;
    44.                 } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
    45.                     ret = PackageManager.INSTALL_FAILED_INVALID_URI;
    46.                 } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
    47.                     ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
    48.                 } else {
    49.                     // Override with defaults if needed.
    50.                     loc = installLocationPolicy(pkgLite);
    51.                     if (loc == PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE) {
    52.                         ret = PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
    53.                     } else if (loc == PackageHelper.RECOMMEND_FAILED_WRONG_INSTALLED_VERSION) {
    54.                         ret = PackageManager.INSTALL_FAILED_WRONG_INSTALLED_VERSION;
    55.                     } else if (!onInt) {
    56.                         // Override install location with flags
    57.                         if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
    58.                             // Set the flag to install on external media.
    59.                             installFlags &= ~PackageManager.INSTALL_INTERNAL;
    60.                         } else if (loc == PackageHelper.RECOMMEND_INSTALL_EPHEMERAL) {
    61.                             if (DEBUG_INSTANT) {
    62.                                 Slog.v(TAG, "...setting INSTALL_EPHEMERAL install flag");
    63.                             }
    64.                             installFlags |= PackageManager.INSTALL_INSTANT_APP;
    65.                             installFlags &= ~PackageManager.INSTALL_INTERNAL;
    66.                         } else {
    67.                             // Make sure the flag for installing on external
    68.                             // media is unset
    69.                             installFlags |= PackageManager.INSTALL_INTERNAL;
    70.                         }
    71.                     }
    72.                 }
    73.             }
    74.  
    75.             //生成安装参数
    76.             final InstallArgs args = createInstallArgs(this);
    77.             mVerificationCompleted = true;
    78.             mEnableRollbackCompleted = true;
    79.             mArgs = args;
    80.             ....
    81.             mRet = ret;
    82.         }
    83.  
    84.         void handleReturnCode() {
    85.             if (mVerificationCompleted && mEnableRollbackCompleted) {
    86.                 ....
    87.                 if (mRet == PackageManager.INSTALL_SUCCEEDED) {
    88.                     mRet = mArgs.copyApk();
    89.                 }
    90.                 processPendingInstall(mArgs, mRet);
    91.             }
    92.         }
    93.  
    94.     private InstallArgs createInstallArgs(InstallParams params) {
    95.         if (params.move != null) {
    96.             //处理现有已安装应用程序移动的逻辑。
    97.             return new MoveInstallArgs(params);
    98.         } else {
    99.             //处理新应用程序安装的逻辑，包括复制和重命名逻辑。
    100.             return new FileInstallArgs(params);
    101.         }
    102.     }

    handleReturnCode()有两个重要的方法

    1. mRet = mArgs.copyApk();
    2. processPendingInstall(mArgs, mRet);

    他们的作用看名字就能猜到了，1是复制apk，2是安装应用

    1.copyApk

    FileInstallArgs也是PMS内部类

    1.         int copyApk() {
    2.             Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "copyApk");
    3.             try {
    4.                 return doCopyApk();
    5.             } finally {
    6.                 Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
    7.             }
    8.         }
    9.  
    10.         private int doCopyApk() {
    11.             try {
    12.                 final boolean isEphemeral = (installFlags & PackageManager.INSTALL_INSTANT_APP) != 0;
    13.                 //创建路径
    14.                 final File tempDir =
    15.                         mInstallerService.allocateStageDirLegacy(volumeUuid, isEphemeral);
    16.                 codeFile = tempDir;
    17.                 resourceFile = tempDir;
    18.             } catch (IOException e) {
    19.                 Slog.w(TAG, "Failed to create copy file: " + e);
    20.                 return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
    21.             }
    22.             //将包复制到指定路径
    23.             int ret = PackageManagerServiceUtils.copyPackage(
    24.                     origin.file.getAbsolutePath(), codeFile);
    25.             if (ret != PackageManager.INSTALL_SUCCEEDED) {
    26.                 Slog.e(TAG, "Failed to copy package");
    27.                 return ret;
    28.             }
    29.  
    30.             final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
    31.             NativeLibraryHelper.Handle handle = null;
    32.             try {
    33.                 // 将 apk 中的动态库.so 文件也拷贝到目标路径中。
    34.                 handle = NativeLibraryHelper.Handle.create(codeFile);
    35.                 ret = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libraryRoot,
    36.                         abiOverride);
    37.             } catch (IOException e) {
    38.                 Slog.e(TAG, "Copying native libraries failed", e);
    39.                 ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
    40.             } finally {
    41.                 IoUtils.closeQuietly(handle);
    42.             }
    43.  
    44.             return ret;
    45.         }

    PackageManagerServiceUtils.copyPackage(
                        origin.file.getAbsolutePath(), codeFile);

     copyPackage就是把origin.file.getAbsolutePath()的安装包复制到codeFile，里面的实现就是输入输出流。

    至此我们的apk就在 data/app 目录下以 base.apk 的方式保存，至于为啥是在data/app，可以去看下

    final File tempDir =
                            mInstallerService.allocateStageDirLegacy(volumeUuid, isEphemeral);

    2.processPendingInstall(mArgs, mRet)

    1.     private void processPendingInstall(final InstallArgs args, final int currentStatus) {
    2.         if (args.mMultiPackageInstallParams != null) {
    3.             args.mMultiPackageInstallParams.tryProcessInstallRequest(args, currentStatus);
    4.         } else {
    5.             PackageInstalledInfo res = createPackageInstalledInfo(currentStatus);
    6.             processInstallRequestsAsync(
    7.                     res.returnCode == PackageManager.INSTALL_SUCCEEDED,
    8.                     Collections.singletonList(new InstallRequest(args, res)));
    9.         }
    10.     }
    11.  
    12.     // Queue up an async operation since the package installation may take a little while.
    13.     private void processInstallRequestsAsync(boolean success,
    14.             List installRequests) {
    15.         mHandler.post(() -> {
    16.             if (success) {
    17.                 for (InstallRequest request : installRequests) {
    18.                     //预安装
    19.                     request.args.doPreInstall(request.installResult.returnCode);
    20.                 }
    21.                 synchronized (mInstallLock) {
    22.                     //安装
    23.                     installPackagesTracedLI(installRequests);
    24.                 }
    25.                 for (InstallRequest request : installRequests) {
    26.                     request.args.doPostInstall(
    27.                             request.installResult.returnCode, request.installResult.uid);
    28.                 }
    29.             }
    30.             for (InstallRequest request : installRequests) {
    31.                 restoreAndPostInstall(request.args.user.getIdentifier(), request.installResult,
    32.                         new PostInstallData(request.args, request.installResult, null));
    33.             }
    34.         });
    35.     }

    预安装操作主要是检查安装包的状态，确保安装环境正常，如果安装环境有问题会清理拷贝文件。

    installPackagesLI是安装的核心。

    Android—PMS: installPackagesLI

    简单总结：

    InstallStaging会先把apk存储在临时文件夹，然后跳转并把URI传给PackageInstallerActivity，点击PackageInstallerActivity的OK按钮进入InstallInstalling页面，InstallInstalling页面建立异步任务将APK通过IO流的形式写入到PackageInstaller.Session，通过PackageInstaller.Session进行进程间通信，发送一个MSG_COMMIT的Message最终调用到了PackageManagerService.installStage方法。installStage方法发送了一个INIT_COPY的Message,调用copyAPK方法将apk拷贝到data/app/，然后再调用processPendingInstall进行安装。

  • 相关阅读:
    图像增强算法的安卓移植
    构建动态交互式H5导航栏：滑动高亮、吸顶和锚点导航技巧详解
    WebSocket快速入门及基本使用
    Spring原理之web.xml加载过程
    创建性-构造者设计模式
    【云原生之K8s】 Pod控制器
    NLC: Search Correlated Window Pairs on Long Time Series(VLDB2022)
    word图题表题公式按照章节编号（不用题注）
    会话技术之Coookie && Session详解
    学校网页设计成品 基于HTML+CSS+JavaScript仿山东财经大学官网 学校班级网页制作模板 校园网页设计成品
  • 原文地址：https://blog.csdn.net/weixin_41939525/article/details/126929917