devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android PMS赋予应用权限流程---安装默认赋予流程_android s legacypermissionmanagerservice

作者：花生_TL007 | 2024-03-18 07:21:46

赞

踩

android s legacypermissionmanagerservice

base/services/core/java/com/android/server/pm/PackageManagerService.java

  1.     @Override
  2.     public void systemReady() {
  3.         enforceSystemOrRoot("Only the system can claim the system is ready");
  4.  
  5.         ......
  6.  
  7.         mUserManager.systemReady();
  8.  
  9.         // Watch for external volumes that come and go over time
  10.         final StorageManager storage = mInjector.getSystemService(StorageManager.class);
  11.         storage.registerListener(mStorageListener);
  12.  
  13.         mInstallerService.systemReady();
  14.         mPackageDexOptimizer.systemReady();
  15.  
  16.         // Now that we're mostly running, clean up stale users and apps
  17.         mUserManager.reconcileUsers(StorageManager.UUID_PRIVATE_INTERNAL);
  18.         reconcileApps(StorageManager.UUID_PRIVATE_INTERNAL);
  19.  
  20.         mPermissionManager.onSystemReady();
  21.  
  22.         int[] grantPermissionsUserIds = EMPTY_INT_ARRAY;
  23.         final List<UserInfo> livingUsers = mInjector.getUserManagerInternal().getUsers(
  24.                 /* excludePartial= */ true,
  25.                 /* excludeDying= */ true,
  26.                 /* excludePreCreated= */ false);
  27.         final int livingUserCount = livingUsers.size();
  28.         for (int i = 0; i < livingUserCount; i++) {
  29.             final int userId = livingUsers.get(i).id;
  30.              if (mPmInternal.isPermissionUpgradeNeeded(userId)) {
  31.                 grantPermissionsUserIds = ArrayUtils.appendInt(
  32.                         grantPermissionsUserIds, userId);
  33.              }
  34.         }//权限处理
  35.         // If we upgraded grant all default permissions before kicking off.
  36.         for (int userId : grantPermissionsUserIds) {
  37.             mLegacyPermissionManager.grantDefaultPermissions(userId);
  38.         }
  39.         if (grantPermissionsUserIds == EMPTY_INT_ARRAY) {
  40.             // If we did not grant default permissions, we preload from this the
  41.             // default permission exceptions lazily to ensure we don't hit the
  42.             // disk on a new user creation.
  43.             mLegacyPermissionManager.scheduleReadDefaultPermissionExceptions();
  44.         }
  45.  
  46.         if (mInstantAppResolverConnection != null) {
  47.             mContext.registerReceiver(new BroadcastReceiver() {
  48.                 @Override
  49.                 public void onReceive(Context context, Intent intent) {
  50.                     mInstantAppResolverConnection.optimisticBind();
  51.                     mContext.unregisterReceiver(this);
  52.                 }
  53.             }, new IntentFilter(Intent.ACTION_BOOT_COMPLETED));
  54.         }
  55.  
  56.         ......
  57.     }

base/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java

grantPermissionsToSysComponentsAndPrivApps(pm, userId);//为sys组件和private-app赋予权限

  1.     public void grantDefaultPermissions(int userId) {
  2.         Log.d(TAG,  " grantDefaultPermissions: " + Log.getStackTraceString(new Throwable()));
  3.         Log.d(TAG, "grantDefaultPermissions " + userId);
  4.  
  5.         DelayingPackageManagerCache pm = new DelayingPackageManagerCache();
  6.  
  7.         grantPermissionsToSysComponentsAndPrivApps(pm, userId);
  8.         grantDefaultSystemHandlerPermissions(pm, userId);
  9.         grantDefaultPermissionExceptions(pm, userId);
  10.  
  11.         // Apply delayed state
  12.         pm.apply();
  13.     }
  14.  
  15. /*********************************************************************************/
  16.  
  17.     private void grantPermissionsToSysComponentsAndPrivApps(DelayingPackageManagerCache pm,
  18.             int userId) {
  19.         Log.i(TAG, "Granting permissions to platform components for user " + userId);
  20.         List<PackageInfo> packages = mContext.getPackageManager().getInstalledPackagesAsUser(
  21.                 DEFAULT_PACKAGE_INFO_QUERY_FLAGS, UserHandle.USER_SYSTEM);//获取包的相关信息
  22.         for (PackageInfo pkg : packages) {
  23.             if (pkg == null) {
  24.                 continue;
  25.             }
  26.  
  27.             // Package info is already loaded, cache it
  28.             Log.d(TAG, "pkg.packageNamer " + pkg.packageName);
  29.  
  30.             pm.addPackageInfo(pkg.packageName, pkg);
  31.  
  32.             if (!pm.isSysComponentOrPersistentPlatformSignedPrivApp(pkg)
  33.                     || !doesPackageSupportRuntimePermissions(pkg)
  34.                     || ArrayUtils.isEmpty(pkg.requestedPermissions)) {
  35.                 continue;
  36.             }
  37.             grantRuntimePermissionsForSystemPackage(pm, userId, pkg);//赋予权限
  38.         }
  39.  
  40.         // Grant READ_PHONE_STATE to all system apps that have READ_PRIVILEGED_PHONE_STATE
  41.         // R: CTA requirement - permission control
  42.         if(!CTA_MANAGER.isCtaSupported()) {
  43.            // Re-grant READ_PHONE_STATE as non-fixed to all system apps that have
  44.            // READ_PRIVILEGED_PHONE_STATE and READ_PHONE_STATE granted -- this is to undo the fixed
  45.            // grant from R.
  46.            for (PackageInfo pkg : packages) {
  47.                if (pkg == null
  48.                        || !doesPackageSupportRuntimePermissions(pkg)
  49.                        || ArrayUtils.isEmpty(pkg.requestedPermissions)
  50.                        || !pm.isGranted(Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
  51.                                pkg, UserHandle.of(userId))
  52.                        || !pm.isGranted(Manifest.permission.READ_PHONE_STATE, pkg,
  53.                                UserHandle.of(userId))) {
  54.                    continue;
  55.                }
  56.  
  57.                pm.updatePermissionFlags(Manifest.permission.READ_PHONE_STATE, pkg,
  58.                        PackageManager.FLAG_PERMISSION_SYSTEM_FIXED,
  59.                        0,
  60.                        UserHandle.of(userId));
  61.            }
  62.         }
  63.     }
  64.  
  65. /*******************************************************************************/
  66.  
  67.    private void grantRuntimePermissionsForSystemPackage(PackageManagerWrapper pm,
  68.             int userId, PackageInfo pkg) {
  69.         Set<String> permissions = new ArraySet<>();
  70.         for (String permission : pkg.requestedPermissions) {
  71.             final PermissionInfo perm = pm.getPermissionInfo(permission);
  72.             if (perm == null) {
  73.                 continue;
  74.             }
  75.             Log.d(TAG,"protectionLevel perm.protectionLevel: " +  perm.protectionLevel);
  76.             Log.d(TAG,"permission: " +  permission);
  77.  
  78.             if (perm.isRuntime()) {
  79.                 permissions.add(permission);
  80.             }
  81.         }
  82.         if (!permissions.isEmpty()) {
  83.             grantRuntimePermissions(pm, pkg, permissions, true /*systemFixed*/, userId);//权限
  84.         }
  85.     }
  86.  
  87. /*******************************************************************************/
  88.  
  89.  
  90.     private void grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg,
  91.             Set<String> permissions, boolean systemFixed, int userId) {
  92.         grantRuntimePermissions(pm, pkg, permissions, systemFixed, false,
  93.                 true /*whitelistRestrictedPermissions*/, userId);
  94.     }
  95. /*******************************************************************************/
  96.  
  97.  
  98.

grantDefaultSystemHandlerPermissions(pm, userId);//为系统的指定的应用提供相应的特殊权限

  1.     private void grantDefaultSystemHandlerPermissions(PackageManagerWrapper pm, int userId) {
  2.         Log.i(TAG, "Granting permissions to default platform handlers for user " + userId);
  3.  
  4.         final PackagesProvider locationPackagesProvider;
  5.         final PackagesProvider locationExtraPackagesProvider;
  6.         final PackagesProvider voiceInteractionPackagesProvider;
  7.         final PackagesProvider smsAppPackagesProvider;
  8.         final PackagesProvider dialerAppPackagesProvider;
  9.         final PackagesProvider simCallManagerPackagesProvider;
  10.         final PackagesProvider useOpenWifiAppPackagesProvider;
  11.         final SyncAdapterPackagesProvider syncAdapterPackagesProvider;
  12.         //config.xml中定义了具体的包名,例如    <string name="config_defaultDialer" translatable="false">com.android.dialer</string>
  13.  
  14.         synchronized (mLock) {
  15.             locationPackagesProvider = mLocationPackagesProvider;
  16.             locationExtraPackagesProvider = mLocationExtraPackagesProvider;
  17.             voiceInteractionPackagesProvider = mVoiceInteractionPackagesProvider;
  18.             smsAppPackagesProvider = mSmsAppPackagesProvider;
  19.             dialerAppPackagesProvider = mDialerAppPackagesProvider;
  20.             simCallManagerPackagesProvider = mSimCallManagerPackagesProvider;
  21.             useOpenWifiAppPackagesProvider = mUseOpenWifiAppPackagesProvider;
  22.             syncAdapterPackagesProvider = mSyncAdapterPackagesProvider;
  23.         }
  24.  
  25.         String[] voiceInteractPackageNames = (voiceInteractionPackagesProvider != null)
  26.                 ? voiceInteractionPackagesProvider.getPackages(userId) : null;
  27.         String[] locationPackageNames = (locationPackagesProvider != null)
  28.                 ? locationPackagesProvider.getPackages(userId) : null;
  29.         String[] locationExtraPackageNames = (locationExtraPackagesProvider != null)
  30.                 ? locationExtraPackagesProvider.getPackages(userId) : null;
  31.         String[] smsAppPackageNames = (smsAppPackagesProvider != null)
  32.                 ? smsAppPackagesProvider.getPackages(userId) : null;
  33.         String[] dialerAppPackageNames = (dialerAppPackagesProvider != null)
  34.                 ? dialerAppPackagesProvider.getPackages(userId) : null;
  35.         String[] simCallManagerPackageNames = (simCallManagerPackagesProvider != null)
  36.                 ? simCallManagerPackagesProvider.getPackages(userId) : null;
  37.         String[] useOpenWifiAppPackageNames = (useOpenWifiAppPackagesProvider != null)
  38.                 ? useOpenWifiAppPackagesProvider.getPackages(userId) : null;
  39.         String[] contactsSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
  40.                 syncAdapterPackagesProvider.getPackages(ContactsContract.AUTHORITY, userId) : null;
  41.         String[] calendarSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
  42.                 syncAdapterPackagesProvider.getPackages(CalendarContract.AUTHORITY, userId) : null;
  43.  
  44.         // Installer
  45.         grantSystemFixedPermissionsToSystemPackage(pm,
  46.                 ArrayUtils.firstOrNull(getKnownPackages(
  47.                         PackageManagerInternal.PACKAGE_INSTALLER, userId)),
  48.                 userId, STORAGE_PERMISSIONS);//关注最后一个参数，是需要的权限组
  49.  
  50. ......
  51.  
  52. //其余的不分析，基本调用相似，都是为了给特定的应用赋予特定的权限
  53.  
  54. }
  55.  
  56.  
  57. /******************************************************************************/
  58.  
  59.     @SafeVarargs
  60.     private final void grantSystemFixedPermissionsToSystemPackage(PackageManagerWrapper pm,
  61.             String packageName, int userId, Set<String>... permissionGroups) {
  62.         grantPermissionsToSystemPackage(pm, packageName, userId, true /* systemFixed */,
  63.                 permissionGroups);
  64.     }
  65.  
  66. /******************************************************************************/
  67.     @SafeVarargs
  68.     private final void grantSystemFixedPermissionsToSystemPackage(PackageManagerWrapper pm,
  69.             String packageName, int userId, Set<String>... permissionGroups) {
  70.         grantPermissionsToSystemPackage(pm, packageName, userId, true /* systemFixed */,
  71.                 permissionGroups);
  72.     }
  73.  
  74. /******************************************************************************/
  75.  
  76.     @SafeVarargs
  77.     private final void grantPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName,
  78.             int userId, boolean systemFixed, Set<String>... permissionGroups) {
  79.         if (!pm.isSystemPackage(packageName)) {
  80.             return;
  81.         }
  82.         grantPermissionsToPackage(pm, pm.getSystemPackageInfo(packageName),
  83.                 userId, systemFixed, false /* ignoreSystemPackage */,
  84.                 true /*whitelistRestrictedPermissions*/, permissionGroups);
  85.     }
  86.  
  87. /******************************************************************************/
  88.     @SafeVarargs
  89.     private final void grantPermissionsToPackage(PackageManagerWrapper pm, PackageInfo packageInfo,
  90.             int userId, boolean systemFixed, boolean ignoreSystemPackage,
  91.             boolean whitelistRestrictedPermissions, Set<String>... permissionGroups) {
  92.         if (packageInfo == null) {
  93.             return;
  94.         }
  95.         if (doesPackageSupportRuntimePermissions(packageInfo)) {
  96.             for (Set<String> permissionGroup : permissionGroups) {
  97.                 grantRuntimePermissions(pm, packageInfo, permissionGroup, systemFixed,
  98.                         ignoreSystemPackage, whitelistRestrictedPermissions, userId);//重点此函数
  99.             }
  100.         }
  101.     }
  102.  
  103.  
  104.  
  105. /******************************************************************************/
  106.

grantDefaultPermissionExceptions(pm, userId);//从指定文件读取需要赋予的权限

  1.     private void grantDefaultPermissionExceptions(PackageManagerWrapper pm, int userId) {
  2.         mHandler.removeMessages(MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS);
  3.         Log.d(TAG,"grantDefaultPermissionExceptions");
  4.         synchronized (mLock) {
  5.             // mGrantExceptions is null only before the first read and then
  6.             // it serves as a cache of the default grants that should be
  7.             // performed for every user. If there is an entry then the app
  8.             // is on the system image and supports runtime permissions.
  9.             if (mGrantExceptions == null) {
  10.                 mGrantExceptions = readDefaultPermissionExceptionsLocked(pm);//获取那些权限需要被赋予
  11.             }
  12.         }
  13.  
  14.         Set<String> permissions = null;
  15.         final int exceptionCount = mGrantExceptions.size();
  16.         for (int i = 0; i < exceptionCount; i++) {
  17.             String packageName = mGrantExceptions.keyAt(i);
  18.             Logd(TAG,"grantDefaultPermissionExceptions packageName: " + packageName);
  19.             PackageInfo pkg = pm.getSystemPackageInfo(packageName);
  20.             List<DefaultPermissionGrant> permissionGrants = mGrantExceptions.valueAt(i);
  21.             final int permissionGrantCount = permissionGrants.size();
  22.             for (int j = 0; j < permissionGrantCount; j++) {
  23.                 DefaultPermissionGrant permissionGrant = permissionGrants.get(j);
  24.                 if (!pm.isPermissionDangerous(permissionGrant.name)) {
  25.                     Log.w(TAG, "Ignoring permission " + permissionGrant.name
  26.                             + " which isn't dangerous");
  27.                     continue;
  28.                 }
  29.                 if (permissions == null) {
  30.                     permissions = new ArraySet<>();
  31.                 } else {
  32.                     permissions.clear();
  33.                 }
  34.                 permissions.add(permissionGrant.name);
  35.  
  36.  
  37.                 grantRuntimePermissions(pm, pkg, permissions, permissionGrant.fixed,
  38.                         permissionGrant.whitelisted, true /*whitelistRestrictedPermissions*/,
  39.                         userId);//赋予权限
  40.             }
  41.         }
  42.     }
  43.  
  44.  
  45. /********************************************************************************/
  46.  
  47.     private @NonNull ArrayMap<String, List<DefaultPermissionGrant>>
  48.             readDefaultPermissionExceptionsLocked(PackageManagerWrapper pm) {
  49.         File[] files = getDefaultPermissionFiles();
  50.         if (files == null) {
  51.             return new ArrayMap<>(0);
  52.         }
  53.  
  54.         ArrayMap<String, List<DefaultPermissionGrant>> grantExceptions = new ArrayMap<>();
  56.         // Iterate over the files in the directory and scan .xml files
  57.         for (File file : files) {
  58.             if (!file.getPath().endsWith(".xml")) {
  59.                 Slog.i(TAG, "Non-xml file " + file
  60.                         + " in " + file.getParent() + " directory, ignoring");
  61.                 continue;
  62.             }
  63.             if (!file.canRead()) {
  64.                 Slog.w(TAG, "Default permissions file " + file + " cannot be read");
  65.                 continue;
  66.             }
  67.             try (InputStream str = new FileInputStream(file)) {
  68.                 TypedXmlPullParser parser = Xml.resolvePullParser(str);
  69.                 parse(pm, parser, grantExceptions);
  70.             } catch (XmlPullParserException | IOException e) {
  71.                 Slog.w(TAG, "Error reading default permissions file " + file, e);
  72.             }
  73.         }
  74.  
  75.         return grantExceptions;
  76.     }
  77.  
  78.  
  79. /********************************************************************************/
  80.  
  81.     private File[] getDefaultPermissionFiles() {
  82.         ArrayList<File> ret = new ArrayList<File>();
  83.         File dir = new File(Environment.getRootDirectory(), "etc/default-permissions");
  84.         if (dir.isDirectory() && dir.canRead()) {
  85.             Collections.addAll(ret, dir.listFiles());
  86.             Log.d(TAG,"getDefaultPermissionFiles dir.listFiles(): " + dir.listFiles().toString());
  87.         }
  88.         dir = new File(Environment.getVendorDirectory(), "etc/default-permissions");
  89.         if (dir.isDirectory() && dir.canRead()) {
  90.             Collections.addAll(ret, dir.listFiles());
  91.         }
  92.         dir = new File(Environment.getOdmDirectory(), "etc/default-permissions");
  93.         if (dir.isDirectory() && dir.canRead()) {
  94.             Collections.addAll(ret, dir.listFiles());
  95.         }
  96.         dir = new File(Environment.getProductDirectory(), "etc/default-permissions");
  97.         if (dir.isDirectory() && dir.canRead()) {
  98.             Collections.addAll(ret, dir.listFiles());
  99.         }
  100.         dir = new File(Environment.getSystemExtDirectory(), "etc/default-permissions");
  101.         if (dir.isDirectory() && dir.canRead()) {
  102.             Collections.addAll(ret, dir.listFiles());
  103.         }
  104.         // For IoT devices, we check the oem partition for default permissions for each app.
  105.         if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_EMBEDDED, 0)) {
  106.             dir = new File(Environment.getOemDirectory(), "etc/default-permissions");
  107.             if (dir.isDirectory() && dir.canRead()) {
  108.                 Collections.addAll(ret, dir.listFiles());
  109.             }
  110.         }
  111.         return ret.isEmpty() ? null : ret.toArray(new File[0]);
  112.     }
  113.  
  114.  
  115. /********************************************************************************/

grantRuntimePermissions分析

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/261309
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号