伙伴们应该都了解，在Android6.0之后，关于部分权限，例如Camera、读写存储权限等，都需求用户授权才能够运用，除非你的使用为体系使用，不然这些“风险权限”将不会主动颁发，那么为什么Google在Android 6.0之后会推出动态权限请求，首要是防止一些“流氓”软件在后台获取用户隐私，从而将职责从技术侧转移到用户侧，既然用户挑选了答应这些权限运用，那么职责就由用户承担了。
那么咱们在动态请求权限时，体系是怎么处理并保存这些状态，接下来咱们深入源码一看终究。
1 权限请求
假如咱们的app需求请求读写权限，那么就能够在清单文件中进行权限的声明
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
当然咱们仅仅声明并不起作用，咱们需求在页面启动时进行权限的动态声明，咱们常用的做法便是：
class MainActivity : AppCompatActivity() {
private val REQUEST_WRITE_STORAGE_PERMISSION = 0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//首先判别权限是否请求过，或许说是否现已有这个权限了
if (ContextCompat.checkSelfPermission(
this,
Manifest.permission.WRITE_EXTERNAL_STORAGE
) != PackageManager.PERMISSION_GRANTED
) {
//假如现已拿到过了，就不需求请求了
//没拿到过，需求动态请求
if (ActivityCompat.shouldShowRequestPermissionRationale(
this,
Manifest.permission.WRITE_EXTERNAL_STORAGE
)
) {
Log.e("TAG", "之前回绝过权限，现在从头再次请求")
ActivityCompat.requestPermissions(
this,
arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE),
REQUEST_WRITE_STORAGE_PERMISSION
)
return
}
Log.e("TAG", "之前没有回绝过权限，现在第一次请求")
ActivityCompat.requestPermissions(
this,
arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE),
REQUEST_WRITE_STORAGE_PERMISSION
)
}
}
override fun onRequestPermissionsResult(
requestCode: Int,
permissions: Array<out String>,
grantResults: IntArray
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
when (requestCode) {
REQUEST_WRITE_STORAGE_PERMISSION -> {
Log.e("TAG", "onRequestPermissionsResult 获取到了权限")
permissions.forEach {
Log.e("TAG", "permissions $it")
}
grantResults.forEach {
Log.e("TAG", "grantResults $it")
}
}
}
}
}
这是官方的写法，在请求权限之前，首先会判别 是否获取过这个权限，假如没有获取过，那么就会进行动态权限的请求。当然用户可能之前回绝过权限，所以这儿也会进行一次用户是否回绝过请求权限的操作，能够做对应的一些交互上的处理，以及权限请求的目的让用户打消顾忌。下面便是用户可能存在的居中操作，做了对应日志的打印：
用户第一次请求权限时回绝了
2023-06-17 13:43:22.111 30040-30040/com.lay.nowinandroid E/TAG: 之前没有回绝过权限，现在第一次请求
2023-06-17 13:43:31.824 30040-30040/com.lay.nowinandroid E/TAG: onRequestPermissionsResult 获取到了权限
2023-06-17 13:43:31.824 30040-30040/com.lay.nowinandroid E/TAG: permissions android.permission.WRITE_EXTERNAL_STORAGE
2023-06-17 13:43:31.824 30040-30040/com.lay.nowinandroid E/TAG: grantResults -1
用户第二次回绝了权限
经过日志发现，这时现已走到了shouldShowRequestPermissionRationale代码块中，体系是知道用户之前回绝过了权限。
2023-06-17 13:44:32.813 30868-30868/com.lay.nowinandroid E/TAG: 之前回绝过权限，现在从头再次请求
2023-06-17 13:44:49.968 30868-30868/com.lay.nowinandroid E/TAG: onRequestPermissionsResult 获取到了权限
2023-06-17 13:44:49.969 30868-30868/com.lay.nowinandroid E/TAG: permissions android.permission.WRITE_EXTERNAL_STORAGE
2023-06-17 13:44:49.969 30868-30868/com.lay.nowinandroid E/TAG: grantResults -1
用户接受了权限
2023-06-17 13:45:14.135 30868-30868/com.lay.nowinandroid E/TAG: onRequestPermissionsResult 获取到了权限
2023-06-17 13:45:14.135 30868-30868/com.lay.nowinandroid E/TAG: permissions android.permission.WRITE_EXTERNAL_STORAGE
2023-06-17 13:45:14.135 30868-30868/com.lay.nowinandroid E/TAG: grantResults 0
咱们看到，当咱们请求权限时，其实在onRequestPermissionsResult回调中，无论是赞同仍是回绝都会有对应的输出，假如没有赞同权限，那么此时grantResults的值就为-1，假如接受了权限，那么grantResults的值就为0，能够看下面对应的介绍。
/**
* Permission check result: this is returned by {@link #checkPermission}
* if the permission has been granted to the given package.
*/
public static final int PERMISSION_GRANTED = 0;
/**
* Permission check result: this is returned by {@link #checkPermission}
* if the permission has not been granted to the given package.
*/
public static final int PERMISSION_DENIED = -1;
咱们看到这儿其实成果为一个数组，由于咱们在请求权限时，能够以组为单位，与permissions是一一对应的，咱们能够知道，究竟哪些权限咱们拿到了，哪些没有拿到。
2 requestPermissions源码剖析
前面在介绍权限请求时，咱们调用的是ActivityCompat的requestPermissions办法，接下来咱们跟随源码，看体系是怎么完结权限请求的。
ActivityCompat # requestPermissions
public static void requestPermissions(final @NonNull Activity activity,
final @NonNull String[] permissions, final @IntRange(from = 0) int requestCode) {
if (sDelegate != null
&& sDelegate.requestPermissions(activity, permissions, requestCode)) {
// Delegate has handled the permission request.
return;
}
for (String permission : permissions) {
if (TextUtils.isEmpty(permission)) {
throw new IllegalArgumentException("Permission request for permissions "
+ Arrays.toString(permissions) + " must not contain null or empty values");
}
}
if (Build.VERSION.SDK_INT >= 23) {
if (activity instanceof RequestPermissionsRequestCodeValidator) {
((RequestPermissionsRequestCodeValidator) activity)
.validateRequestPermissionsRequestCode(requestCode);
}
Api23Impl.requestPermissions(activity, permissions, requestCode);
} else if (activity instanceof OnRequestPermissionsResultCallback) {
Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
@Override
public void run() {
final int[] grantResults = new int[permissions.length];
PackageManager packageManager = activity.getPackageManager();
String packageName = activity.getPackageName();
final int permissionCount = permissions.length;
for (int i = 0; i < permissionCount; i++) {
grantResults[i] = packageManager.checkPermission(
permissions[i], packageName);
}
((OnRequestPermissionsResultCallback) activity).onRequestPermissionsResult(
requestCode, permissions, grantResults);
}
});
}
}
首先在requestPermissions办法中，判别了SDK的版别，假如大于等于23，也便是包含Android 6.0以上的版别，会履行对应的逻辑，在Android 6.0版别以下，则是直接经过PKMS来查看权限，并做onRequestPermissionsResult的回调，咱们重视的要点不在这儿，咱们要点看Android 6.0以上的版别。
Api23Impl # requestPermissions
@DoNotInline
static void requestPermissions(Activity activity, String[] permissions, int requestCode) {
activity.requestPermissions(permissions, requestCode);
}
经过源码咱们看到是调用了Api23Impl的requestPermissions办法，在这个办法内部，直接调用了Activity的requestPermissions办法。
Activity # requestPermissions
public final void requestPermissions(@NonNull String[] permissions, int requestCode) {
if (requestCode < 0) {
throw new IllegalArgumentException("requestCode should be >= 0");
}
//同一时间只能有一次权限请求，并发问题处理
if (mHasCurrentPermissionsRequest) {
Log.w(TAG, "Can request only one set of permissions at a time");
// Dispatch the callback with empty arrays which means a cancellation.
onRequestPermissionsResult(requestCode, new String[0], new int[0]);
return;
}
if (!getAttributionSource().getRenouncedPermissions().isEmpty()) {
final int permissionCount = permissions.length;
for (int i = 0; i < permissionCount; i++) {
if (getAttributionSource().getRenouncedPermissions().contains(permissions[i])) {
throw new IllegalArgumentException("Cannot request renounced permission: "
+ permissions[i]);
}
}
}
final Intent intent = getPackageManager().buildRequestPermissionsIntent(permissions);
startActivityForResult(REQUEST_PERMISSIONS_WHO_PREFIX, intent, requestCode, null);
mHasCurrentPermissionsRequest = true;
}
在这个办法中，前面首要做了一些判别，包含requestCode的校验、并发的处理（同一时间只能进行一次权限请求）等，最终经过PackManager创立一个Intent目标，由于需求回调状态到onRequestPermissionsResult，所以经过startActivityForResult方式启动了一个Activity。
PackageManager # buildRequestPermissionsIntent
public Intent buildRequestPermissionsIntent(@NonNull String[] permissions) {
if (ArrayUtils.isEmpty(permissions)) {
throw new IllegalArgumentException("permission cannot be null or empty");
}
Intent intent = new Intent(ACTION_REQUEST_PERMISSIONS);
intent.putExtra(EXTRA_REQUEST_PERMISSIONS_NAMES, permissions);
intent.setPackage(getPermissionControllerPackageName());
return intent;
}
这个办法十分简单，便是创立了一个Intent目标，可是这个Intent目标的详细装备咱们需求看一下。
public static final String ACTION_REQUEST_PERMISSIONS =
"android.content.pm.action.REQUEST_PERMISSIONS";
public static final String EXTRA_REQUEST_PERMISSIONS_NAMES =
"android.content.pm.extra.REQUEST_PERMISSIONS_NAMES";
在创立一个Intent目标之后，将ACTION_REQUEST_PERMISSIONS作为参数传递到Intent构造函数中，意味着这儿是创立了一个隐式目的，这儿会启动一个体系的页面。
由于通常咱们在启动一个Activity的时分，通常是一个显现目的，经过setClass将目的地声明在此，而buildRequestPermissionsIntent中则是创立了一个隐式目的，这儿的Activity便是咱们看到的那个弹窗页面。那么这些Activity是存在哪里呢，其实便是隐式装置器PackageInstaller提供的。
PackageInstaller
这儿我简单提一下，PackageInstaller其实也是一个体系使用，看姓名应该知道它的作用是用来装置或许卸载使用程序的，除此之外，还能够管理使用程序的权限，在装置使用程序时，它会向用户显现使用程序要求的权限，并答应用户对这些权限进行管理和操控。
所以咱们在装置或许卸载使用时，体系出现的弹窗，都是在PackageInstaller app中提供的，前面咱们提到的android.content.pm.action.REQUEST_PERMISSIONS这个action，在PackageInstaller中就对应一个页面，咱们能够去看下PackageInstaller的清单文件。
<activity android:name="com.android.packageinstaller.permission.ui.GrantPermissionsActivity"
android:configChanges="keyboardHidden|screenSize"
android:excludeFromRecents="true"
android:theme="@style/GrantPermissions"
android:visibleToInstantApps="true"
android:inheritShowWhenLocked="true">
<intent-filter android:priority="1">
<action android:name="android.content.pm.action.REQUEST_PERMISSIONS" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
所以当咱们请求权限时弹出的体系弹窗，便是GrantPermissionsActivity；除此之外，在构建隐式目的时，还把需求请求的权限组作为参数传进去了，所以在GrantPermissionsActivity中，会接收这些数据。
GrantPermissionsActivity
接下来咱们剖析GrantPermissionsActivity中处理逻辑，这儿我把体系源码中GrantPermissionsActivity拷贝了一份，方便剖析权限请求的流程。
public class GrantPermissionsActivity extends Activity
implements GrantPermissionsViewHandler.ResultListener {
private static final String LOG_TAG = "GrantPermissionsActivity";
private static final String KEY_REQUEST_ID = GrantPermissionsActivity.class.getName()
+ "_REQUEST_ID";
public static int NUM_BUTTONS = 5;
public static int LABEL_ALLOW_BUTTON = 0;
public static int LABEL_ALLOW_ALWAYS_BUTTON = 1;
public static int LABEL_ALLOW_FOREGROUND_BUTTON = 2;
public static int LABEL_DENY_BUTTON = 3;
public static int LABEL_DENY_AND_DONT_ASK_AGAIN_BUTTON = 4;
/** Unique Id of a request */
private long mRequestId;
private String[] mRequestedPermissions;
private CharSequence[] mButtonLabels;
private ArrayMap<Pair<String, Boolean>, GroupState> mRequestGrantPermissionGroups =
new ArrayMap<>();
private GrantPermissionsViewHandler mViewHandler;
private AppPermissions mAppPermissions;
boolean mResultSet;
/**
* Listens for changes to the permission of the app the permissions are currently getting
* granted to. {@code null} when unregistered.
*/
private @Nullable PackageManager.OnPermissionsChangedListener mPermissionChangeListener;
/**
* Listens for changes to the app the permissions are currently getting granted to. {@code null}
* when unregistered.
*/
private @Nullable PackageRemovalMonitor mPackageRemovalMonitor;
// .....
/**
* Report the result of a grant of a permission.
*
* @param permission The permission that was granted or denied
* @param result The permission grant result
*/
private void reportRequestResult(@NonNull String permission, int result) {
boolean isImplicit = !ArrayUtils.contains(mRequestedPermissions, permission);
Log.v(LOG_TAG,
"Permission grant result requestId=" + mRequestId + " callingUid=" + mCallingUid
+ " callingPackage=" + mCallingPackage + " permission=" + permission
+ " isImplicit=" + isImplicit + " result=" + result);
PermissionControllerStatsLog.write(
PermissionControllerStatsLog.PERMISSION_GRANT_REQUEST_RESULT_REPORTED, mRequestId,
mCallingUid, mCallingPackage, permission, isImplicit, result);
}
/**
* Report the result of a grant of a permission.
*
* @param permissions The permissions that were granted or denied
* @param result The permission grant result
*/
private void reportRequestResult(@NonNull String[] permissions, int result) {
for (String permission : permissions) {
reportRequestResult(permission, result);
}
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
// ......
mRequestedPermissions = getIntent().getStringArrayExtra(
PackageManager.EXTRA_REQUEST_PERMISSIONS_NAMES);
if (mRequestedPermissions == null) {
mRequestedPermissions = new String[0];
}
//......
//这儿会经过判别硬件设备类型，展现不同的UI
if (DeviceUtils.isTelevision(this)) {
mViewHandler = new com.android.packageinstaller.permission.ui.television
.GrantPermissionsViewHandlerImpl(this,
mCallingPackage).setResultListener(this);
} else if (DeviceUtils.isWear(this)) {
mViewHandler = new GrantPermissionsWatchViewHandler(this).setResultListener(this);
} else if (DeviceUtils.isAuto(this)) {
mViewHandler = new GrantPermissionsAutoViewHandler(this, mCallingPackage, userHandle)
.setResultListener(this);
} else {
mViewHandler = new com.android.packageinstaller.permission.ui.handheld
.GrantPermissionsViewHandlerImpl(this, mCallingPackage, userHandle)
.setResultListener(this);
}
// ......
setContentView(mViewHandler.createView());
// ......
}
//......
@Override
public void onPermissionGrantResult(String name,
@GrantPermissionsViewHandler.Result int result) {
logGrantPermissionActivityButtons(name, result);
GroupState foregroundGroupState = getForegroundGroupState(name);
GroupState backgroundGroupState = getBackgroundGroupState(name);
if (result == GRANTED_ALWAYS || result == GRANTED_FOREGROUND_ONLY
|| result == DENIED_DO_NOT_ASK_AGAIN) {
KeyguardManager kgm = getSystemService(KeyguardManager.class);
if (kgm.isDeviceLocked()) {
kgm.requestDismissKeyguard(this, new KeyguardManager.KeyguardDismissCallback() {
@Override
public void onDismissError() {
Log.e(LOG_TAG, "Cannot dismiss keyguard perm=" + name + " result="
+ result);
}
@Override
public void onDismissCancelled() {
// do nothing (i.e. stay at the current permission group)
}
@Override
public void onDismissSucceeded() {
// Now the keyguard is dismissed, hence the device is not locked
// anymore
onPermissionGrantResult(name, result);
}
});
return;
}
}
switch (result) {
case GRANTED_ALWAYS :
if (foregroundGroupState != null) {
onPermissionGrantResultSingleState(foregroundGroupState, true, false);
}
if (backgroundGroupState != null) {
onPermissionGrantResultSingleState(backgroundGroupState, true, false);
}
break;
case GRANTED_FOREGROUND_ONLY :
if (foregroundGroupState != null) {
onPermissionGrantResultSingleState(foregroundGroupState, true, false);
}
if (backgroundGroupState != null) {
onPermissionGrantResultSingleState(backgroundGroupState, false, false);
}
break;
case DENIED :
if (foregroundGroupState != null) {
onPermissionGrantResultSingleState(foregroundGroupState, false, false);
}
if (backgroundGroupState != null) {
onPermissionGrantResultSingleState(backgroundGroupState, false, false);
}
break;
case DENIED_DO_NOT_ASK_AGAIN :
if (foregroundGroupState != null) {
onPermissionGrantResultSingleState(foregroundGroupState, false, true);
}
if (backgroundGroupState != null) {
onPermissionGrantResultSingleState(backgroundGroupState, false, true);
}
break;
}
if (!showNextPermissionGroupGrantRequest()) {
setResultAndFinish();
}
}
/**
* Grants or revoked the affected permissions for a single {@link groupState}.
*
* @param groupState The group state with the permissions to grant/revoke
* @param granted {@code true} if the permissions should be granted, {@code false} if they
* should be revoked
* @param doNotAskAgain if the permissions should be revoked should be app be allowed to ask
* again for the same permissions?
*/
private void onPermissionGrantResultSingleState(GroupState groupState, boolean granted,
boolean doNotAskAgain) {
if (groupState != null && groupState.mGroup != null
&& groupState.mState == GroupState.STATE_UNKNOWN) {
if (granted) {
groupState.mGroup.grantRuntimePermissions(doNotAskAgain,
groupState.affectedPermissions);
groupState.mState = GroupState.STATE_ALLOWED;
reportRequestResult(groupState.affectedPermissions,
PERMISSION_GRANT_REQUEST_RESULT_REPORTED__RESULT__USER_GRANTED);
} else {
groupState.mGroup.revokeRuntimePermissions(doNotAskAgain,
groupState.affectedPermissions);
groupState.mState = GroupState.STATE_DENIED;
reportRequestResult(groupState.affectedPermissions, doNotAskAgain
?
PERMISSION_GRANT_REQUEST_RESULT_REPORTED__RESULT__USER_DENIED_WITH_PREJUDICE
: PERMISSION_GRANT_REQUEST_RESULT_REPORTED__RESULT__USER_DENIED);
}
}
}
// ......
private void setResultIfNeeded(int resultCode) {
if (!mResultSet) {
mResultSet = true;
logRequestedPermissionGroups();
Intent result = new Intent(PackageManager.ACTION_REQUEST_PERMISSIONS);
result.putExtra(PackageManager.EXTRA_REQUEST_PERMISSIONS_NAMES, mRequestedPermissions);
PackageManager pm = getPackageManager();
int numRequestedPermissions = mRequestedPermissions.length;
int[] grantResults = new int[numRequestedPermissions];
for (int i = 0; i < numRequestedPermissions; i++) {
grantResults[i] = pm.checkPermission(mRequestedPermissions[i], mCallingPackage);
}
result.putExtra(PackageManager.EXTRA_REQUEST_PERMISSIONS_RESULTS, grantResults);
setResult(resultCode, result);
}
}
private void setResultAndFinish() {
setResultIfNeeded(RESULT_OK);
finish();
}
// ......
private static final class GroupState {
static final int STATE_UNKNOWN = 0;
static final int STATE_ALLOWED = 1;
static final int STATE_DENIED = 2;
static final int STATE_SKIPPED = 3;
final AppPermissionGroup mGroup;
int mState = STATE_UNKNOWN;
/** Permissions of this group that need to be granted, null == no permissions of group */
String[] affectedPermissions;
GroupState(AppPermissionGroup group) {
mGroup = group;
}
}
private class PermissionChangeListener implements PackageManager.OnPermissionsChangedListener {
final int mCallingPackageUid;
PermissionChangeListener() throws NameNotFoundException {
mCallingPackageUid = getPackageManager().getPackageUid(mCallingPackage, 0);
}
@Override
public void onPermissionsChanged(int uid) {
if (uid == mCallingPackageUid) {
updateIfPermissionsWereGranted();
}
}
}
}
GrantPermissionsActivity # onPermissionGrantResult
当用户点击按钮时，会调用onPermissionGrantResult办法，在这个办法中，会判别用户行为，一般会有以下几种：始终答应、仅答应一次、制止、制止并且不需求再提醒，针对每种成果，都会调用onPermissionGrantResultSingleState办法来详细的实施。
在onPermissionGrantResultSingleState中，会判别granted参数，也便是否答应权限，调用AppPermissionGroup的grantRuntimePermissions办法做详细的运行时权限请求。
AppPermissionGroup # grantRuntimePermissions
留意这个办法中的参数，fixedByTheUser其实对应的便是dontAskAgain，是否需求再次问询，假如用户挑选回绝权限并且不再问询，那么就只能去设置中打开权限。
public boolean grantRuntimePermissions(boolean fixedByTheUser, String[] filterPermissions) {
boolean killApp = false;
boolean wasAllGranted = true;
// We toggle permissions only to apps that support runtime
// permissions, otherwise we toggle the app op corresponding
// to the permission if the permission is granted to the app.
for (Permission permission : mPermissions.values()) {
if (filterPermissions != null
&& !ArrayUtils.contains(filterPermissions, permission.getName())) {
continue;
}
if (!permission.isGrantingAllowed(mIsEphemeralApp, mAppSupportsRuntimePermissions)) {
// Skip unallowed permissions.
continue;
}
boolean wasGranted = permission.isGrantedIncludingAppOp();
if (mAppSupportsRuntimePermissions) {
// Do not touch permissions fixed by the system.
if (permission.isSystemFixed()) {
wasAllGranted = false;
break;
}
// Ensure the permission app op enabled before the permission grant.
if (permission.affectsAppOp() && !permission.isAppOpAllowed()) {
permission.setAppOpAllowed(true);
}
// Grant the permission if needed.
if (!permission.isGranted()) {
permission.setGranted(true);
}
// Update the permission flags.
if (!fixedByTheUser) {
// Now the apps can ask for the permission as the user
// no longer has it fixed in a denied state.
if (permission.isUserFixed() || permission.isUserSet()) {
permission.setUserFixed(false);
permission.setUserSet(false);
}
}
} else {
// Legacy apps cannot have a not granted permission but just in case.
if (!permission.isGranted()) {
continue;
}
// If the permissions has no corresponding app op, then it is a
// third-party one and we do not offer toggling of such permissions.
if (permission.affectsAppOp()) {
if (!permission.isAppOpAllowed()) {
permission.setAppOpAllowed(true);
// Legacy apps do not know that they have to retry access to a
// resource due to changes in runtime permissions (app ops in this
// case). Therefore, we restart them on app op change, so they
// can pick up the change.
killApp = true;
}
// Mark that the permission should not be be granted on upgrade
// when the app begins supporting runtime permissions.
if (permission.shouldRevokeOnUpgrade()) {
permission.setRevokeOnUpgrade(false);
}
}
// Granting a permission explicitly means the user already
// reviewed it so clear the review flag on every grant.
if (permission.isReviewRequired()) {
permission.unsetReviewRequired();
}
}
// If we newly grant background access to the fine location, double-guess the user some
// time later if this was really the right choice.
if (!wasGranted && permission.isGrantedIncludingAppOp()) {
if (permission.getName().equals(ACCESS_FINE_LOCATION)) {
Permission bgPerm = permission.getBackgroundPermission();
if (bgPerm != null) {
if (bgPerm.isGrantedIncludingAppOp()) {
mTriggerLocationAccessCheckOnPersist = true;
}
}
} else if (permission.getName().equals(ACCESS_BACKGROUND_LOCATION)) {
ArrayList<Permission> fgPerms = permission.getForegroundPermissions();
if (fgPerms != null) {
int numFgPerms = fgPerms.size();
for (int fgPermNum = 0; fgPermNum < numFgPerms; fgPermNum++) {
Permission fgPerm = fgPerms.get(fgPermNum);
if (fgPerm.getName().equals(ACCESS_FINE_LOCATION)) {
if (fgPerm.isGrantedIncludingAppOp()) {
mTriggerLocationAccessCheckOnPersist = true;
}
break;
}
}
}
}
}
}
//默认 mDelayChanges = false，这儿真实进行权限请求
if (!mDelayChanges) {
persistChanges(false);
if (killApp) {
killApp(KILL_REASON_APP_OP_CHANGE);
}
}
return wasAllGranted;
}
前面首要是进行一系列的装备，persistChanges办法中会向PKMS发起进程间通讯，调用PKMS的grantRuntimePermission办法。
void persistChanges(boolean mayKillBecauseOfAppOpsChange) {
int uid = mPackageInfo.applicationInfo.uid;
int numPermissions = mPermissions.size();
boolean shouldKillApp = false;
for (int i = 0; i < numPermissions; i++) {
Permission permission = mPermissions.valueAt(i);
if (!permission.isSystemFixed()) {
if (permission.isGranted()) {
mPackageManager.grantRuntimePermission(mPackageInfo.packageName,
permission.getName(), mUserHandle);
} else {
boolean isCurrentlyGranted = mContext.checkPermission(permission.getName(), -1,
uid) == PERMISSION_GRANTED;
if (isCurrentlyGranted) {
mPackageManager.revokeRuntimePermission(mPackageInfo.packageName,
permission.getName(), mUserHandle);
}
}
}
int flags = (permission.isUserSet() ? PackageManager.FLAG_PERMISSION_USER_SET : 0)
| (permission.isUserFixed() ? PackageManager.FLAG_PERMISSION_USER_FIXED : 0)
| (permission.shouldRevokeOnUpgrade()
? PackageManager.FLAG_PERMISSION_REVOKE_ON_UPGRADE : 0)
| (permission.isPolicyFixed() ? PackageManager.FLAG_PERMISSION_POLICY_FIXED : 0)
| (permission.isReviewRequired()
? PackageManager.FLAG_PERMISSION_REVIEW_REQUIRED : 0);
mPackageManager.updatePermissionFlags(permission.getName(),
mPackageInfo.packageName,
PackageManager.FLAG_PERMISSION_USER_SET
| PackageManager.FLAG_PERMISSION_USER_FIXED
| PackageManager.FLAG_PERMISSION_REVOKE_ON_UPGRADE
| PackageManager.FLAG_PERMISSION_POLICY_FIXED
| PackageManager.FLAG_PERMISSION_REVIEW_REQUIRED,
flags, mUserHandle);
if (permission.affectsAppOp()) {
if (!permission.isSystemFixed()) {
// Enabling/Disabling an app op may put the app in a situation in which it has
// a handle to state it shouldn't have, so we have to kill the app. This matches
// the revoke runtime permission behavior.
if (permission.isAppOpAllowed()) {
shouldKillApp |= allowAppOp(permission, uid);
} else {
shouldKillApp |= disallowAppOp(permission, uid);
}
}
}
}
if (mayKillBecauseOfAppOpsChange && shouldKillApp) {
killApp(KILL_REASON_APP_OP_CHANGE);
}
if (mTriggerLocationAccessCheckOnPersist) {
new LocationAccessCheck(mContext, null).checkLocationAccessSoon();
mTriggerLocationAccessCheckOnPersist = false;
}
}
PKMS # grantRuntimePermission
@Override
public void grantRuntimePermission(String packageName, String permName, final int userId) {
// Because this is accessed via the package manager service AIDL,
// go through the permission manager service AIDL
mContext.getSystemService(PermissionManager.class)
.grantRuntimePermission(packageName, permName, UserHandle.of(userId));
}
这儿咱们看到，是拿到PermissionManager服务目标，调用PMMS的grantRuntimePermission办法，所以咱们需求去PermissionManagerService中查找。
@Override
public void grantRuntimePermission(String packageName, String permName, final int userId) {
final int callingUid = Binder.getCallingUid();
final boolean overridePolicy =
checkUidPermission(callingUid, ADJUST_RUNTIME_PERMISSIONS_POLICY)
== PackageManager.PERMISSION_GRANTED;
grantRuntimePermissionInternal(packageName, permName, overridePolicy,
callingUid, userId, mDefaultPermissionCallback);
}
private void grantRuntimePermissionInternal(String packageName, String permName,
boolean overridePolicy, int callingUid, final int userId, PermissionCallback callback) {
// .....
final int uid = UserHandle.getUid(userId, pkg.getUid());
if (callback != null) {
if (isRuntimePermission) {
callback.onPermissionGranted(uid, userId);
} else {
callback.onInstallPermissionGranted();
}
if (permissionHasGids) {
callback.onGidsChanged(UserHandle.getAppId(pkg.getUid()), userId);
}
}
if (isRuntimePermission) {
notifyRuntimePermissionStateChanged(packageName, userId);
}
}
其实在PermissionManagerService的grantRuntimePermissionInternal前面所有的判别，都是在判别当时这个权限是不是现已获取到了，假如获取到了就退出；假如没有获取到，那么就会经过PermissionCallback回调，并判别是否为运行时权限，假如是运行时权限，会回调onPermissionGranted办法，非运行时权限会回调onInstallPermissionGranted办法。
private final PermissionCallback mDefaultPermissionCallback = new PermissionCallback() {
@Override
public void onGidsChanged(int appId, int userId) {
mHandler.post(() -> killUid(appId, userId, KILL_APP_REASON_GIDS_CHANGED));
}
@Override
public void onPermissionGranted(int uid, int userId) {
mOnPermissionChangeListeners.onPermissionsChanged(uid);
// Not critical; if this is lost, the application has to request again.
mPackageManagerInt.writeSettings(true);
}
@Override
public void onInstallPermissionGranted() {
mPackageManagerInt.writeSettings(true);
}
@Override
public void onPermissionRevoked(int uid, int userId, String reason) {
mOnPermissionChangeListeners.onPermissionsChanged(uid);
// Critical; after this call the application should never have the permission
mPackageManagerInt.writeSettings(false);
final int appId = UserHandle.getAppId(uid);
if (reason == null) {
mHandler.post(() -> killUid(appId, userId, KILL_APP_REASON_PERMISSIONS_REVOKED));
} else {
mHandler.post(() -> killUid(appId, userId, reason));
}
}
@Override
public void onInstallPermissionRevoked() {
mPackageManagerInt.writeSettings(true);
}
@Override
public void onPermissionUpdated(int[] userIds, boolean sync) {
mPackageManagerInt.writePermissionSettings(userIds, !sync);
}
@Override
public void onInstallPermissionUpdated() {
mPackageManagerInt.writeSettings(true);
}
@Override
public void onPermissionRemoved() {
mPackageManagerInt.writeSettings(false);
}
public void onPermissionUpdatedNotifyListener(@UserIdInt int[] updatedUserIds, boolean sync,
int uid) {
onPermissionUpdated(updatedUserIds, sync);
for (int i = 0; i < updatedUserIds.length; i++) {
int userUid = UserHandle.getUid(updatedUserIds[i], UserHandle.getAppId(uid));
mOnPermissionChangeListeners.onPermissionsChanged(userUid);
}
}
public void onInstallPermissionUpdatedNotifyListener(int uid) {
onInstallPermissionUpdated();
mOnPermissionChangeListeners.onPermissionsChanged(uid);
}
};
在onPermissionGranted回调办法中，会调用PackageManagerInternal的writeSettings办法，将权限信息写入到xml文件中。
PackageManagerInternal # writeSettings
@Override
public void writeSettings(boolean async) {
synchronized (mLock) {
if (async) {
scheduleWriteSettingsLocked();
} else {
writeSettingsLPrTEMP();
}
}
}
这儿是能够挑选同步或许异步，由于涉及到了IO操作，所以这儿传入的是true。
case WRITE_SETTINGS: {
Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
synchronized (mLock) {
removeMessages(WRITE_SETTINGS);
removeMessages(WRITE_PACKAGE_RESTRICTIONS);
writeSettingsLPrTEMP();
mDirtyUsers.clear();
}
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
}
break;
最终是调用writeLPr办法，创立xml文件
void writeLPr() {
//Debug.startMethodTracing("/data/system/packageprof", 8 * 1024 * 1024);
final long startTime = SystemClock.uptimeMillis();
// Whenever package manager changes something on the system, it writes out whatever it
// changed in the form of a settings object change, and it does so under its internal
// lock --- so if we invalidate the package cache here, we end up invalidating at the
// right time.
invalidatePackageCache();
// Keep the old settings around until we know the new ones have
// been successfully written.
if (mSettingsFilename.exists()) {
// Presence of backup settings file indicates that we failed
// to persist settings earlier. So preserve the older
// backup for future reference since the current settings
// might have been corrupted.
if (!mBackupSettingsFilename.exists()) {
if (!mSettingsFilename.renameTo(mBackupSettingsFilename)) {
Slog.wtf(PackageManagerService.TAG,
"Unable to backup package manager settings, "
+ " current changes will be lost at reboot");
return;
}
} else {
mSettingsFilename.delete();
Slog.w(PackageManagerService.TAG, "Preserving older settings backup");
}
}
mPastSignatures.clear();
try {
final FileOutputStream fstr = new FileOutputStream(mSettingsFilename);
final TypedXmlSerializer serializer = Xml.resolveSerializer(fstr);
serializer.startDocument(null, true);
serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
serializer.startTag(null, "packages");
for (int i = 0; i < mVersion.size(); i++) {
final String volumeUuid = mVersion.keyAt(i);
final VersionInfo ver = mVersion.valueAt(i);
serializer.startTag(null, TAG_VERSION);
XmlUtils.writeStringAttribute(serializer, ATTR_VOLUME_UUID, volumeUuid);
serializer.attributeInt(null, ATTR_SDK_VERSION, ver.sdkVersion);
serializer.attributeInt(null, ATTR_DATABASE_VERSION, ver.databaseVersion);
XmlUtils.writeStringAttribute(serializer, ATTR_FINGERPRINT, ver.fingerprint);
serializer.endTag(null, TAG_VERSION);
}
if (mVerifierDeviceIdentity != null) {
serializer.startTag(null, "verifier");
serializer.attribute(null, "device", mVerifierDeviceIdentity.toString());
serializer.endTag(null, "verifier");
}
serializer.startTag(null, "permission-trees");
mPermissions.writePermissionTrees(serializer);
serializer.endTag(null, "permission-trees");
serializer.startTag(null, "permissions");
mPermissions.writePermissions(serializer);
serializer.endTag(null, "permissions");
for (final PackageSetting pkg : mPackages.values()) {
writePackageLPr(serializer, pkg);
}
for (final PackageSetting pkg : mDisabledSysPackages.values()) {
writeDisabledSysPackageLPr(serializer, pkg);
}
for (final SharedUserSetting usr : mSharedUsers.values()) {
serializer.startTag(null, "shared-user");
serializer.attribute(null, ATTR_NAME, usr.name);
serializer.attributeInt(null, "userId", usr.userId);
usr.signatures.writeXml(serializer, "sigs", mPastSignatures.untrackedStorage());
serializer.endTag(null, "shared-user");
}
if (mRenamedPackages.size() > 0) {
for (Map.Entry<String, String> e : mRenamedPackages.entrySet()) {
serializer.startTag(null, "renamed-package");
serializer.attribute(null, "new", e.getKey());
serializer.attribute(null, "old", e.getValue());
serializer.endTag(null, "renamed-package");
}
}
mDomainVerificationManager.writeSettings(serializer, false /* includeSignatures */,
UserHandle.USER_ALL);
mKeySetManagerService.writeKeySetManagerServiceLPr(serializer);
serializer.endTag(null, "packages");
serializer.endDocument();
fstr.flush();
FileUtils.sync(fstr);
fstr.close();
// New settings successfully written, old ones are no longer
// needed.
mBackupSettingsFilename.delete();
FileUtils.setPermissions(mSettingsFilename.toString(),
FileUtils.S_IRUSR|FileUtils.S_IWUSR
|FileUtils.S_IRGRP|FileUtils.S_IWGRP,
-1, -1);
writeKernelMappingLPr();
writePackageListLPr();
writeAllUsersPackageRestrictionsLPr();
writeAllRuntimePermissionsLPr();
com.android.internal.logging.EventLogTags.writeCommitSysConfigFile(
"package", SystemClock.uptimeMillis() - startTime);
return;
} catch(java.io.IOException e) {
Slog.wtf(PackageManagerService.TAG, "Unable to write package manager settings, "
+ "current changes will be lost at reboot", e);
}
// Clean up partially written files
if (mSettingsFilename.exists()) {
if (!mSettingsFilename.delete()) {
Slog.wtf(PackageManagerService.TAG, "Failed to clean up mangled file: "
+ mSettingsFilename);
}
}
//Debug.stopMethodTracing();
}
详细文件为:
mSettingsFilename = new File(mSystemDir, "packages.xml");
也便是在data/system/packages.xml文件中永久保存，假如使用卸载那么就会清除权限.
<package name="com.lay.nowinandroid" codePath="/data/app/~~Z3KlFzqUZ3vXhgizpl-R4Q==/com.lay.nowinandroid-NcpT91M9gQfcPkeJJhPoxA==" nativeLibraryPath="/data/app/~~Z3KlFzqUZ3vXhgizpl-R4Q==/com.lay.nowinandroid-NcpT91M9gQfcPkeJJhPoxA==/lib" publicFlags="810073926" privateFlags="-1400893440" ft="188c89ab490" it="188c7e11f01" ut="188c89ab614" version="1" userId="10131">
<sigs count="1" schemeVersion="2">
<cert index="9" key="/>
</sigs>
<perms>
<item name="android.permission.INTERNET" granted="true" flags="0" />
</perms>
<proper-signing-keyset identifier="10" />
</package>
咱们能够看到，在xml文件中的perms标签下有对应权限的声明，以及granted的参数，也便是说下次再进来之后，会查看这个xml文件中咱们要请求的这个权限是不是现已获取到了，假如granted = true || flags = 0，那么就不会再弹窗了。
