Java PackageInfo.REQUESTED_PERMISSION_GRANTED属性代码示例

private boolean isDisplayablePermission(PermissionInfo pInfo, int existingReqFlags) {
    final int base = pInfo.protectionLevel & PermissionInfo.PROTECTION_MASK_BASE;
    final boolean isNormal = base == PermissionInfo.PROTECTION_NORMAL;
    final boolean isDangerous = base == PermissionInfo.PROTECTION_DANGEROUS
            || ((pInfo.protectionLevel & PermissionInfo.PROTECTION_FLAG_PRE23) != 0);

    // Dangerous and normal permissions are always shown to the user
    // this is matches the permission list in AppDetails2
    if (isNormal || isDangerous) {
        return true;
    }

    final boolean isDevelopment = (pInfo.protectionLevel & PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0;
    final boolean wasGranted = (existingReqFlags & PackageInfo.REQUESTED_PERMISSION_GRANTED) != 0;

    // Development permissions are only shown to the user if they are already
    // granted to the app -- if we are installing an app and they are not
    // already granted, they will not be granted as part of the install.
    return isDevelopment && wasGranted;
}
 

@TargetApi(Build.VERSION_CODES.JELLY_BEAN) @NonNull
static String[] neededPermissions(Context context) {
	PackageInfo info = null;
	try {
		info = context.getPackageManager().getPackageInfo(context.getPackageName(), PackageManager.GET_PERMISSIONS);
	} catch (PackageManager.NameNotFoundException e) { /* */ }
	List<String> needed = new ArrayList<>();
	if (info != null &&
		info.requestedPermissions != null &&
		info.requestedPermissionsFlags != null) {
		for (int i = 0; i < info.requestedPermissions.length; i++) {
			int flags = info.requestedPermissionsFlags[i];
			if ((flags & PackageInfo.REQUESTED_PERMISSION_GRANTED) == 0) {
				needed.add(info.requestedPermissions[i]);
			}
		}
	}
	return needed.toArray(new String[needed.size()]);
}
 

private AppDetails fetchDetail(String packageName) {
  PackageManager packageManager = context.getPackageManager();
  AppDetails appDetails = new AppDetails();
  try {
    PackageInfo packageInfo = packageManager.getPackageInfo(packageName,
        PackageManager.GET_META_DATA | PackageManager.GET_PERMISSIONS);
    appDetails.name = packageInfo.applicationInfo.loadLabel(packageManager).toString();
    appDetails.icon = packageInfo.applicationInfo.loadIcon(packageManager);
    appDetails.packageName = packageName;
    appDetails.publicSrcDir = packageInfo.applicationInfo.publicSourceDir;
    if (packageInfo.requestedPermissions != null) {
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        for (int index = 0; index < packageInfo.requestedPermissions.length; index++) {
          if ((packageInfo.requestedPermissionsFlags[index]
              & PackageInfo.REQUESTED_PERMISSION_GRANTED) != 0) {
            appDetails.grantedPermissionList.add(packageInfo.requestedPermissions[index]);
          } else {
            appDetails.deniedPermissionList.add(packageInfo.requestedPermissions[index]);
          }
        }
      } else {
        appDetails.grantedPermissionList =
            new ArrayList<>(Arrays.asList(packageInfo.requestedPermissions));
      }
    }
  } catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
  }
  return appDetails;
}
 

/**
 * A permission is a "new permission" if the app is already installed and
 * doesn't currently hold this permission. On older devices that don't support
 * this concept, permissions are never "new permissions".
 */
@TargetApi(16)
private static boolean isNewPermission(PackageInfo installedPkgInfo, int existingFlags) {
    if (installedPkgInfo == null || Build.VERSION.SDK_INT < 16) {
        return false;
    }

    return (existingFlags & PackageInfo.REQUESTED_PERMISSION_GRANTED) == 0;
}
 

@Override public PackageInfo getPackageInfo(final String pkg, final int flags) throws NameNotFoundException {
	final PackageInfo info = mCondom.proceed(OutboundType.GET_PACKAGE_INFO, pkg, null, new CondomCore.WrappedValueProcedureThrows<PackageInfo, NameNotFoundException>() {
		@Override public PackageInfo proceed() throws NameNotFoundException {
			return CondomPackageManager.super.getPackageInfo(pkg, flags);
		}
	});
	if (info == null) throw new NameNotFoundException(pkg);
	if ((flags & PackageManager.GET_PERMISSIONS) != 0 && ! mCondom.getSpoofPermissions().isEmpty() && mCondom.getPackageName().equals(pkg)) {
		final List<String> requested_permissions = info.requestedPermissions == null ? new ArrayList<String>()
				: new ArrayList<>(Arrays.asList(info.requestedPermissions));
		final List<String> missing_permissions = new ArrayList<>(mCondom.getSpoofPermissions());
		missing_permissions.removeAll(requested_permissions);
		if (! missing_permissions.isEmpty()) {
			requested_permissions.addAll(missing_permissions);
			info.requestedPermissions = requested_permissions.toArray(new String[requested_permissions.size()]);
		}    // Even if all permissions to spoof are already requested, the permission granted state still requires amending.

		if (SDK_INT >= JELLY_BEAN) {
			final int[] req_permissions_flags = info.requestedPermissionsFlags == null ? new int[requested_permissions.size()]
					: Arrays.copyOf(info.requestedPermissionsFlags, requested_permissions.size());
			for (int i = 0; i < info.requestedPermissions.length; i++)
				if (mCondom.shouldSpoofPermission(info.requestedPermissions[i]))
					req_permissions_flags[i] = PackageInfo.REQUESTED_PERMISSION_GRANTED;
			info.requestedPermissionsFlags = req_permissions_flags;
		}
	}
	return info;
}