Android 6.0以降、動的パーミッションの仕組みが導入され、一部のシステムパーミッションはAndroidManifestで指定するだけでなく、アプリの実行中に割り当てる必要があります。
この投稿では、動的権限を割り当てる基本的なプロセスについて説明します。
パーミッションの割り当て
まず、パーミッションの割り当てを要求するコードを見てみましょう。
//frameworks/support/v4/java/android/support/v4/app/ActivityCompat.java
public static void requestPermissions(final @NonNull Activity activity,
final @NonNull String[] permissions, final int requestCode) {
if (Build.VERSION.SDK_INT >= 23) {//Android M以上のパーミッションを割り当てる
ActivityCompatApi23.requestPermissions(activity, permissions, requestCode);
} else if (activity instanceof OnRequestPermissionsResultCallback) {//Android M以下のパーミッションが割り当てられる
Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
@Override
public void run() {
//割り当てのようなパーミッションの割り当てを要求した結果は、PERMISSION_GRANTED
final int[] grantResults = new int[permissions.length];
PackageManager packageManager = activity.getPackageManager();
String packageName = activity.getPackageName();
final int permissionCount = permissions.length;
//パッケージ管理のCheckPermissionはパーミッションを割り当てるかどうかをチェックする。
for (int i = 0; i < permissionCount; i++) {
grantResults[i] = packageManager.checkPermission(
permissions[i], packageName);
}
((OnRequestPermissionsResultCallback) activity).onRequestPermissionsResult(
requestCode, permissions, grantResults);
}
});
}
}
//frameworks/support/v4/api23/android/support/v4/app/ActivityCompat23.java
class ActivityCompatApi23 {
...
public static void requestPermissions(Activity activity, String[] permissions,
int requestCode) {
if (activity instanceof RequestPermissionsRequestCodeValidator) {
((RequestPermissionsRequestCodeValidator) activity)
.validateRequestPermissionsRequestCode(requestCode);
}
//Android Mのアクティビティで処理する
activity.requestPermissions(permissions, requestCode);
}
...
}
//frameworks/base/core/java/android/app/Activity.java
public final void requestPermissions(@NonNull String[] permissions, int requestCode) {
if (mHasCurrentPermissionsRequest) {
Log.w(TAG, "Can reqeust 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;
}
//要求されたウィンドウをポップアップするために、要求されたパーミッションでIntentを構築する。
Intent intent = getPackageManager().buildRequestPermissionsIntent(permissions);
startActivityForResult(REQUEST_PERMISSIONS_WHO_PREFIX, intent, requestCode, null);
mHasCurrentPermissionsRequest = true;
}
public Intent buildRequestPermissionsIntent(@NonNull String[] permissions) {
if (ArrayUtils.isEmpty(permissions)) {
throw new NullPointerException("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;
}
インテントのアクションはACTION_REQUEST_PERMISSIONSで、次のように定義されます。
public static final String ACTION_REQUEST_PERMISSIONS =
"android.content.pm.action.REQUEST_PERMISSIONS";
次のパラメータは、具体的に要求されたパーミッションの配列と、パーミッション割り当て制御のための関連パッケージ名です。つまり、アクティビティのリクエストウィンドウは暗黙的に開始されます。
/packages/apps/PackageInstaller/AndroidManifest.xml
<activity android:name=".permission.ui.GrantPermissionsActivity"
android:configChanges="orientation|keyboardHidden|screenSize"
android:excludeFromRecents="true"
android:theme="@style/GrantPermissions">
<intent-filter>
<action android:name="android.content.pm.action.REQUEST_PERMISSIONS" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
//packages/apps/PackageInstaller/src/com/android/packageinstaller/permission/ui/GrantPermissionsDefaultViewHandler.java
public void onClick(View view) {
switch (view.getId()) {
case R.id.permission_allow_button://
if (mResultListener != null) {
view.clearAccessibilityFocus();
mResultListener.onPermissionGrantResult(mGroupName, true, false);
}
break;
case R.id.permission_deny_button://
mAllowButton.setEnabled(true);
if (mResultListener != null) {
view.clearAccessibilityFocus();
mResultListener.onPermissionGrantResult(mGroupName, false,
mDoNotAskCheckbox.isChecked());
}
break;
case R.id.do_not_ask_checkbox://もう質問はない
mAllowButton.setEnabled(!mDoNotAskCheckbox.isChecked());
break;
}
}
@Override
public void onPermissionGrantResult(String name, boolean granted, boolean doNotAskAgain) {
if (isObscuredTouch()) {
showOverlayDialog();
finish();
return;
}
GroupState groupState = mRequestGrantPermissionGroups.get(name);
if (groupState.mGroup != null) {
if (granted) {
groupState.mGroup.grantRuntimePermissions(doNotAskAgain);//パーミッショングループ内でパーミッションを割り当てる
groupState.mState = GroupState.STATE_ALLOWED;//パーミッショングループの状態をリセットする
} else {
groupState.mGroup.revokeRuntimePermissions(doNotAskAgain);
groupState.mState = GroupState.STATE_DENIED;
}
updateGrantResults(groupState.mGroup);
}
//次のパーミッション群の認可
if (!showNextPermissionGroupGrantRequest()) {
setResultAndFinish();
}
}
onPermissionGrantResultの3つのパラメータは、許可グループの名前を表すname、許可を割り当てるかどうかを表すgranned、許可を求めるかどうかを表すdoNotAskAgainです。内部のmRequestGrantPermissionGroupsは
//packages/apps/PackageInstaller/src/com/android/packageinstaller/permission/ui/GrantPermissionsActivity.java
public class GrantPermissionsActivity extends OverlayTouchActivity
implements GrantPermissionsViewHandler.ResultListener {
private String[] mRequestedPermissions;//要求されたパーミッションの配列
private int[] mGrantResults;//パーミッションの割り当て結果の配列
//要求されたパーミッションの配列はパーミッショングループMapに対応する。
private LinkedHashMap<String, GroupState> mRequestGrantPermissionGroups = new LinkedHashMap<>();
...
@Override
public void onCreate(Bundle icicle) {
...
//アプリケーションのパーミッショングループをロードする
mAppPermissions = new AppPermissions(this, callingPackageInfo, null, false,
new Runnable() {
@Override
public void run() {
setResultAndFinish();
}
});
//パーミッショングループをたどる
for (AppPermissionGroup group : mAppPermissions.getPermissionGroups()) {
boolean groupHasRequestedPermission = false;
for (String requestedPermission : mRequestedPermissions) {
//要求されたパーミッションがグループ内にある場合、groupHasRequestedPermissionをtrueとマークする。
if (group.hasPermission(requestedPermission)) {
groupHasRequestedPermission = true;
break;
}
}
if (!groupHasRequestedPermission) {
continue;
}
// We allow the user to choose only non-fixed permissions. A permission
// is fixed either by device policy or the user denying with prejudice.
if (!group.isUserFixed() && !group.isPolicyFixed()) {
switch (permissionPolicy) {
case DevicePolicyManager.PERMISSION_POLICY_AUTO_GRANT: {
if (!group.areRuntimePermissionsGranted()) {
group.grantRuntimePermissions(false);
}
group.setPolicyFixed();
} break;
case DevicePolicyManager.PERMISSION_POLICY_AUTO_DENY: {
if (group.areRuntimePermissionsGranted()) {
group.revokeRuntimePermissions(false);
}
group.setPolicyFixed();
} break;
default: {
//パーミッショングループにランタイムパーミッションが割り当てられているかどうか、もし割り当てられていなければ、mRequestGrantPermissionGroupsに追加する。
if (!group.areRuntimePermissionsGranted()) {
mRequestGrantPermissionGroups.put(group.getName(),
new GroupState(group));
} else {
group.grantRuntimePermissions(false);
updateGrantResults(group);
}
} break;
}
} else {
// if the permission is fixed, ensure that we return the right request result
updateGrantResults(group);
}
}
...
if (!showNextPermissionGroupGrantRequest()) {
setResultAndFinish();
}
}
}
GrantPermissionsActivity の onCreate メソッドでは、所属するパーミッショングループの状態が要求されたパーミッションに基づいて計算され、AppPermissions オブジェクトが最初に作成されます。同時に、リクエストに使用されたパーミッションの配列をトラバースし、対応するパーミッショングループを見つけると同時に、パーミッショングループがすでにダイナミックパーミッションを割り当てられているかどうかを判断します。先ほどのonPermissionGrantResultメソッドでは、さらにパーミッションを割り当てるためにGroupStateのメンバーであるmGroupのgrantRuntimePermissionsメソッドを通して認可が行われます。GroupStateの定義は以下の通りです。
private static final class GroupState {
static final int STATE_UNKNOWN = 0;
static final int STATE_ALLOWED = 1;
static final int STATE_DENIED = 2;
final AppPermissionGroup mGroup;
int mState = STATE_UNKNOWN;
GroupState(AppPermissionGroup group) {
mGroup = group;
}
}
//packages/apps/PackageInstaller/src/com/android/packageinstaller/permission/model/AppPermissionGroup.java
public boolean grantRuntimePermissions(boolean fixedByTheUser) {
final boolean isSharedUser = mPackageInfo.sharedUserId != null;
final int uid = mPackageInfo.applicationInfo.uid;
// 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 (mAppSupportsRuntimePermissions) {//動的パーミッション割り当てのサポート
// Do not touch permissions fixed by the system.
if (permission.isSystemFixed()) {//システムパーミッションは以下を返す
return false;
}
// Ensure the permission app op enabled before the permission grant.
//オープンパーミッションはオプションの付与である。
if (permission.hasAppOp() && !permission.isAppOpAllowed()) {
permission.setAppOpAllowed(true);
mAppOps.setUidMode(permission.getAppOp(), uid, AppOpsManager.MODE_ALLOWED);
}
// Grant the permission if needed.
//動的な割り当てはPMSを通して行われる
if (!permission.isGranted()) {
permission.setGranted(true);
mPackageManager.grantRuntimePermission(mPackageInfo.packageName,
permission.getName(), mUserHandle);
}
// 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(true);
mPackageManager.updatePermissionFlags(permission.getName(),
mPackageInfo.packageName,
PackageManager.FLAG_PERMISSION_USER_FIXED
| PackageManager.FLAG_PERMISSION_USER_SET,
0, mUserHandle);
}
}
} else {//Adnroid M次のバージョンのパーミッション割り当て
....
}
}
return true;
}
パーミッションの割り当ては、最終的にはPMSのgrantRuntimePermissionメソッドによって行われます。
//frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
@Override
public void grantRuntimePermission(String packageName, String name, final int userId) {
...
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.GRANT_RUNTIME_PERMISSIONS,
"grantRuntimePermission");
enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false,
"grantRuntimePermission");
final int uid;
final SettingBase sb;
synchronized (mPackages) {
//パッケージオブジェクトを取得する
final PackageParser.Package pkg = mPackages.get(packageName);
if (pkg == null) {
throw new IllegalArgumentException("Unknown package: " + packageName);
}
//グローバル設定からパーミッション情報を取得する
final BasePermission bp = mSettings.mPermissions.get(name);
if (bp == null) {
throw new IllegalArgumentException("Unknown permission: " + name);
}
enforceDeclaredAsUsedAndRuntimeOrDevelopmentPermission(pkg, bp);
uid = UserHandle.getUid(userId, pkg.applicationInfo.uid);
sb = (SettingBase) pkg.mExtras;//アプリケーションのSettingBaseをpkgから取得する。
if (sb == null) {
throw new IllegalArgumentException("Unknown package: " + packageName);
}
//パーミッションの状態を取得する
final PermissionsState permissionsState = sb.getPermissionsState();
final int flags = permissionsState.getPermissionFlags(name, userId);
if ((flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0) {
throw new SecurityException("Cannot grant system fixed permission: "
+ name + " for package: " + packageName);
}
if (bp.isDevelopment()) {
// Development permissions must be handled specially, since they are not
// normal runtime permissions. For now they apply to all users.
if (permissionsState.grantInstallPermission(bp) !=
PermissionsState.PERMISSION_OPERATION_FAILURE) {
scheduleWriteSettingsLocked();
}
return;
}
//PermissionsStateを通して動的パーミッションを割り当てる
final int result = permissionsState.grantRuntimePermission(bp, userId);
....
}
.....
}
PMSのgrantRuntimePermissionメソッドでは、まず、パッケージ名に従って、我々は、アプリケーションのいくつかの設定情報を含むアプリケーションのインストール時にPackageオブジェクトを取得し、この設定情報を介して、我々は、現在のアプリケーションに付与された権限を保持する現在のアプリケーションのPermissionStateを取得することができます。mSettingsはPMSのグローバル設定で、PMSの起動時に初期化され、プラットフォームでサポートされているすべてのパーミッションが含まれています。パーミッションの最終的な割り当てはPermissionStateを通して行われます。
//frameworks/base/services/core/java/com/android/server/pm/PermissionsState.java
//動的パーミッションを割り当てる
public int grantRuntimePermission(BasePermission permission, int userId) {
enforceValidUserId(userId);
if (userId == UserHandle.USER_ALL) {
return PERMISSION_OPERATION_FAILURE;
}
return grantPermission(permission, userId);
}
private int grantPermission(BasePermission permission, int userId) {
if (hasPermission(permission.name, userId)) {
return PERMISSION_OPERATION_FAILURE;
}
//ユーザーグループIDを計算する
final boolean hasGids = !ArrayUtils.isEmpty(permission.computeGids(userId));
final int[] oldGids = hasGids ? computeGids(userId) : NO_GIDS;
//パーミッションをPermissionDataでラップし、アプリケーションのパーミッションリストに追加する。
PermissionData permissionData = ensurePermissionData(permission);
//許可を与えるには、PermissionStateのmGrantedプロパティを変更する。
if (!permissionData.grant(userId)) {
return PERMISSION_OPERATION_FAILURE;
}
if (hasGids) {
final int[] newGids = computeGids(userId);//ユーザーのパーミッショングループIDを再計算する
//パーミッショングループIDが変わるかどうか
if (oldGids.length != newGids.length) {
return PERMISSION_OPERATION_SUCCESS_GIDS_CHANGED;
}
}
return PERMISSION_OPERATION_SUCCESS;
}
grantPermissionメソッドでは、まず、現在のユーザプロセスによって現在所有されているグループIDが計算され、次にsecurePermissionDataによってパーミッションがアプリケーションのPermissionDataリストに追加され、ここでPermissionDataが返され、最終的な割り当てはこのオブジェクトのgrantメソッドによって行われます。最終的な割り当てはこのオブジェクトのgrantメソッドによって行われ、実際に内部のPermissionStateメンバのmGranted状態をtrueに変更します。最後に、ユーザのグループIDが再計算され、グループIDが変更された場合はPERMISSION_OPERATION_SUCCESS_GIDS_CHANGEDが返され、そうでない場合はPERMISSION操作_成功
//パーミッションがユーザーリストに追加されていることを確認する
private PermissionData ensurePermissionData(BasePermission permission) {
if (mPermissions == null) {
mPermissions = new ArrayMap<>();
}
PermissionData permissionData = mPermissions.get(permission.name);
if (permissionData == null) {
permissionData = new PermissionData(permission);
mPermissions.put(permission.name, permissionData);
}
return permissionData;
}
//ユーザーパーミッションのリストに基づいてユーザーのgidを計算する
public int[] computeGids(int userId) {
enforceValidUserId(userId);
int[] gids = mGlobalGids;
if (mPermissions != null) {
final int permissionCount = mPermissions.size();
for (int i = 0; i < permissionCount; i++) {
String permission = mPermissions.keyAt(i);
if (!hasPermission(permission, userId)) {
continue;
}
PermissionData permissionData = mPermissions.valueAt(i);
//パーミッションに対応するグループIDの配列を取得すると、パーミッションは複数のIDで記述できることがわかる。
final int[] permGids = permissionData.computeGids(userId);
if (permGids != NO_GIDS) {
//パーミッションのグループIDをユーザのグループID配列に追加する。
gids = appendInts(gids, permGids);
}
}
}
return gids;
}
<permissions>
···
<permission name="android.permission.READ_EXTERNAL_STORAGE" >
<group gid="sdcard_r" />
</permission>
<permission name="android.permission.WRITE_EXTERNAL_STORAGE" >
<group gid="sdcard_r" />
<group gid="sdcard_rw" />
</permission>
<permission name="android.permission.INTERNET" >
<group gid="inet" />
</permission>
···
</permissions>
この時点で、パーミッションの本質は、実際には、いくつかの整数型に対応するgidのセットであることが理解され、これらのマッピング関係は、system/core/include/private/android_filesystem_config.hに格納されています。
#define AID_NET_BT_ADMIN 3001 /* bluetooth: create any socket */
#define AID_NET_BT 3002 /* bluetooth: create sco, rfcomm or l2cap sockets */
#define AID_INET 3003 /* can create AF_INET and AF_INET6 sockets */
#define AID_SDCARD_RW 1015 /* external storage write access */
static const struct android_id_info android_ids[] = {
...
{ "bluetooth", AID_BLUETOOTH, },
{ "sdcard_rw", AID_SDCARD_RW, },
{ "net_bt_admin", AID_NET_BT_ADMIN, },
{ "net_bt", AID_NET_BT, },
{ "inet", AID_INET, },
...
}
パーミッションをgidのセットにマッピングし、それを補足gidとしてユーザープロセスに割り当てることで、パーミッション割り当ての本質を実現します。
//PermisssionsState.PermissionData
public boolean grant(int userId) {
if (!isCompatibleUserId(userId)) {
return false;
}
if (isGranted(userId)) {
return false;
}
PermissionState userState = mUserStates.get(userId);
if (userState == null) {
userState = new PermissionState(mPerm.name);
mUserStates.put(userId, userState);
}
//パーミッションの割り当てがtrueに設定される
userState.mGranted = true;
return true;
}
PermissionDataのgrantメソッドを使用して対応するユーザのPermissionStateを作成し、mGrantedにtrueを設定することで、ユーザにパーミッションが割り当てられていることを示します。
もちろん、アクセス許可の割り当ての完了後、次の時間は、携帯電話を再起動すると、再度アクセス許可を割り当てる必要がないため、これは、すべてのパッケージのPMSは、アクセス許可の割り当てを記録するためですAndroid 6.0では、パッケージの情報のすべてのアクセス許可は、data/system/packages.xml設定ファイルに格納されているAndroid 6.0では、パッケージのパーミッションに関する情報はすべて設定ファイルdata/system/packages.xmlに保存され、アプリケーションの起動時にパーミッションが割り当てられるまで読み込むことができます。しかし、Android 6.0以降、実行時のパーミッションはdata/system/users/0/runtime-permissions.xmlに保存され、共通のパーミッションは変更されずにpackages.xmlに保存されます。パーミッションが割り当てられている場合は、パーミッション割り当て情報をこのファイルに永続化する必要があります。
//packages.xml
<package
name="com.feelschaotic.demo"
codePath="/data/app/com.feelschaotic.demo-Gi5ksdF6mUDLakfOugCcwQ=="
nativeLibraryPath="/data/app/com.feelschaotic.demo-Gi5ksdF6mUDLakfOugCcwQ==/lib"
primaryCpuAbi="x86"
publicFlags=""
privateFlags="0"
ft="16348dc3870"
it="d6aa"
ut="16348dc4c4d"
version="8220"
userId="10102">
<sigs count="1">
<cert index="20" key="..." />
</sigs>
<perms>
<!-- ここでは、通常のパーミッションの付与はデフォルトですべてtrueであり、付与された値は変更できない--。>
<item name="android.permission.CHANGE_NETWORK_STATE" granted="true" flags="0" />
<item name="android.permission.INTERNET" granted="true" flags="0" />
<item name="android.permission.CHANGE_WIFI_STATE" granted="true" flags="0" />
<item name="android.permission.ACCESS_NETWORK_STATE" granted="true" flags="0" />
</perms>
<proper-signing-keyset identifier="48" />
</package>
<pkg name="com.feelschaotic.demo">
<!-- デモは意図的にロケーションパーミッションを拒否している。_FINE_LOCATION とACCESS_COARSE_LOCATION もしgrassedがfalseであれば>
<item name="android.permission.ACCESS_FINE_LOCATION" granted="false" flags="1" />
<item name="android.permission.READ_EXTERNAL_STORAGE" granted="true" flags="0" />
<item name="android.permission.ACCESS_COARSE_LOCATION" granted="false" flags="1" />
<item name="android.permission.READ_PHONE_STATE" granted="true" flags="0" />
<item name="android.permission.WRITE_EXTERNAL_STORAGE" granted="true" flags="0" />
...
</pkg>
public void writeRuntimePermissionsForUserLPr(int userId, boolean sync) {
if (sync) {
mRuntimePermissionsPersistence.writePermissionsForUserSyncLPr(userId);
} else {
mRuntimePermissionsPersistence.writePermissionsForUserAsyncLPr(userId);
}
}
永続化が同期的に行われるか非同期的に行われるかにかかわらず、以下のメソッドは
//設定ファイルにパーミッションを書き込む
private void writePermissionsSync(int userId) {
//書き込まれるファイル/data/system/users/0/runtime-permissions.xml
AtomicFile destination = new AtomicFile(getUserRuntimePermissionsFile(userId));
ArrayMap<String, List<PermissionState>> permissionsForPackage = new ArrayMap<>();
ArrayMap<String, List<PermissionState>> permissionsForSharedUser = new ArrayMap<>();
synchronized (mLock) {
mWriteScheduled.delete(userId);
//全てのパッケージを処理する
final int packageCount = mPackages.size();
for (int i = 0; i < packageCount; i++) {
String packageName = mPackages.keyAt(i);
//PackageSettingを取得する
PackageSetting packageSetting = mPackages.valueAt(i);
if (packageSetting.sharedUser == null) {//sharedUserなし
//PermissionsStateを取得すると、このオブジェクトはパッケージのパーミッション情報を記述する。
PermissionsState permissionsState = packageSetting.getPermissionsState();
List<PermissionState> permissionsStates = permissionsState
.getRuntimePermissionStates(userId);//新しい割り当てリストを取得する
if (!permissionsStates.isEmpty()) {
//これはpermissionsForPackage Mapにパッケージ名をキーとして格納される。
permissionsForPackage.put(packageName, permissionsStates);
}
}
}
//shareUserの場合
final int sharedUserCount = mSharedUsers.size();
for (int i = 0; i < sharedUserCount; i++) {
String sharedUserName = mSharedUsers.keyAt(i);
SharedUserSetting sharedUser = mSharedUsers.valueAt(i);
PermissionsState permissionsState = sharedUser.getPermissionsState();
List<PermissionState> permissionsStates = permissionsState
.getRuntimePermissionStates(userId);
if (!permissionsStates.isEmpty()) {
permissionsForSharedUser.put(sharedUserName, permissionsStates);
}
}
}
//
FileOutputStream out = null;
try {
//出力ストリームを取得する
out = destination.startWrite();
XmlSerializer serializer = Xml.newSerializer();
serializer.setOutput(out, StandardCharsets.UTF_8.name());
serializer.setFeature(
"http://.///.#-ut", true);
serializer.startDocument(null, true);
serializer.startTag(null, TAG_RUNTIME_PERMISSIONS);
String fingerprint = mFingerprints.get(userId);
if (fingerprint != null) {
serializer.attribute(null, ATTR_FINGERPRINT, fingerprint);
}
//現在のパッケージのパーミッションを最初に書く。
final int packageCount = permissionsForPackage.size();
for (int i = 0; i < packageCount; i++) {
String packageName = permissionsForPackage.keyAt(i);
List<PermissionState> permissionStates = permissionsForPackage.valueAt(i);
serializer.startTag(null, TAG_PACKAGE);//package
serializer.attribute(null, ATTR_NAME, packageName);
writePermissions(serializer, permissionStates);
serializer.endTag(null, TAG_PACKAGE);
}
//shareUserプロセスのパーミッションを書く。
final int sharedUserCount = permissionsForSharedUser.size();
for (int i = 0; i < sharedUserCount; i++) {
String packageName = permissionsForSharedUser.keyAt(i);
List<PermissionState> permissionStates = permissionsForSharedUser.valueAt(i);
serializer.startTag(null, TAG_SHARED_USER);
serializer.attribute(null, ATTR_NAME, packageName);
writePermissions(serializer, permissionStates);
serializer.endTag(null, TAG_SHARED_USER);
}
serializer.endTag(null, TAG_RUNTIME_PERMISSIONS);
serializer.endDocument();
destination.finishWrite(out);
if (Build.FINGERPRINT.equals(fingerprint)) {
mDefaultPermissionsGranted.put(userId, true);
}
// Any error while writing is fatal.
} catch (Throwable t) {
Slog.wtf(PackageManagerService.TAG,
"Failed to write settings, restoring backup", t);
destination.failWrite(out);
} finally {
IoUtils.closeQuietly(out);
}
}
private void writePermissions(XmlSerializer serializer,
List<PermissionState> permissionStates) throws IOException {
for (PermissionState permissionState : permissionStates) {
serializer.startTag(null, TAG_ITEM);
serializer.attribute(null, ATTR_NAME,permissionState.getName());
serializer.attribute(null, ATTR_GRANTED,
String.valueOf(permissionState.isGranted()));
serializer.attribute(null, ATTR_FLAGS,
Integer.toHexString(permissionState.getFlags()));
serializer.endTag(null, TAG_ITEM);
}
}
writePermissionsは、パッケージの下のパーミッション割り当てメッセージのタグを書く役割をします。
<item name="android.permission.WRITE_EXTERNAL_STORAGE" granted="true" flags="0" />
パーミッションの検出
パーミッションのチェックはContextのcheckSelfPermissionメソッドで行います。その実装を見てみましょう
@Override
public int checkSelfPermission(String permission) {
if (permission == null) {
throw new IllegalArgumentException("permission is null");
}
return checkPermission(permission, Process.myPid(), Process.myUid());
}
@Override
public int checkPermission(String permission, int pid, int uid) {
if (permission == null) {
throw new IllegalArgumentException("permission is null");
}
try {
return ActivityManagerNative.getDefault().checkPermission(
permission, pid, uid);
} catch (RemoteException e) {
return PackageManager.PERMISSION_DENIED;
}
}
最終的にパーミッションのチェックを行うのはAMS checkPermissionです。
//frameworks/base/core/java/android/app/ActivityManager.java
@Override
public int checkPermission(String permission, int pid, int uid) {
if (permission == null) {
return PackageManager.PERMISSION_DENIED;
}
return checkComponentPermission(permission, pid, uid, -1, true);
}
int checkComponentPermission(String permission, int pid, int uid,
int owningUid, boolean exported) {
if (pid == MY_PID) {
return PackageManager.PERMISSION_GRANTED;
}
return ActivityManager.checkComponentPermission(permission, uid,
owningUid, exported);
}
/** @hide */
public static int checkComponentPermission(String permission, int uid,
int owningUid, boolean exported) {
// Root, system server get to do everything.
final int appId = UserHandle.getAppId(uid);
if (appId == Process.ROOT_UID || appId == Process.SYSTEM_UID) {
return PackageManager.PERMISSION_GRANTED;
}
// Isolated processes don't get any permissions.
if (UserHandle.isIsolated(uid)) {
return PackageManager.PERMISSION_DENIED;
}
// If there is a uid that owns whatever is being accessed, it has
// blanket access to it regardless of the permissions it requires.
if (owningUid >= 0 && UserHandle.isSameApp(uid, owningUid)) {
return PackageManager.PERMISSION_GRANTED;
}
// If the target is not exported, then nobody else can get to it.
if (!exported) {
/*
RuntimeException here = new RuntimeException("here");
here.fillInStackTrace();
Slog.w(TAG, "Permission denied: checkComponentPermission() owningUid=" + owningUid,
here);
*/
return PackageManager.PERMISSION_DENIED;
}
if (permission == null) {
return PackageManager.PERMISSION_GRANTED;
}
//PMSでチェックする
try {
return AppGlobals.getPackageManager()
.checkUidPermission(permission, uid);
} catch (RemoteException e) {
// Should never happen, but if it does... deny!
Slog.e(TAG, "PackageManager is dead?!?", e);
}
return PackageManager.PERMISSION_DENIED;
}
AMSの一連の呼び出しにおいて、最終的なパーミッションはPMSのcheckUidPermissionによってチェックされます。
//PMS
@Override
public int checkUidPermission(String permName, int uid) {
final int userId = UserHandle.getUserId(uid);
if (!sUserManager.exists(userId)) {
return PackageManager.PERMISSION_DENIED;
}
synchronized (mPackages) {
Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
if (obj != null) {
final SettingBase ps = (SettingBase) obj;
final PermissionsState permissionsState = ps.getPermissionsState();
//PermissionsStateによるチェック
if (permissionsState.hasPermission(permName, userId)) {
return PackageManager.PERMISSION_GRANTED;
}
//位置パーミッションの特別な処理を検出する
// Special case: ACCESS_FINE_LOCATION permission includes ACCESS_COARSE_LOCATION
if (Manifest.permission.ACCESS_COARSE_LOCATION.equals(permName) && permissionsState
.hasPermission(Manifest.permission.ACCESS_FINE_LOCATION, userId)) {
return PackageManager.PERMISSION_GRANTED;
}
} else {
ArraySet<String> perms = mSystemPermissions.get(uid);
if (perms != null) {
if (perms.contains(permName)) {
return PackageManager.PERMISSION_GRANTED;
}
if (Manifest.permission.ACCESS_COARSE_LOCATION.equals(permName) && perms
.contains(Manifest.permission.ACCESS_FINE_LOCATION)) {
return PackageManager.PERMISSION_GRANTED;
}
}
}
}
return PackageManager.PERMISSION_DENIED;
}
//パーミッションを検出する
public boolean hasPermission(String name, int userId) {
enforceValidUserId(userId);
if (mPermissions == null) {
return false;
}
//パーミッションに対応するPermissionDataを取得する。
PermissionData permissionData = mPermissions.get(name);
//isGrantedで判断する
return permissionData != null && permissionData.isGranted(userId);
}
まとめ
Android 6.0のバージョンでは、アプリがインストールされると、マニフェストで要求されたパーミッションがPackageオブジェクトのPackageSettingに追加されます。PMSは、インストールされたアプリごとにPackageオブジェクトを作成します。このPackageオブジェクトは、インストール処理中に作成され、また、インストール処理中のアプリごとにPackageSettingオブジェクトを作成し、PackageオブジェクトのmExtraに保存します。PMSはインストールされたアプリごとにPackageSettingオブジェクトを作成し、PackageオブジェクトのmExtraに保存します。 PackageSettingの内部にはアプリのシグネチャ情報と付与されたパーミッションのリストが保存されます。実際、PackageSetting自体はGrantedPermissionsクラスから継承されています。実際、PackageSetting自体はGrantedPermissionsクラスから継承されており、GrantedPermissionsクラスは認可されたパーミッションを担当します。アプリケーションの認可されたパーミッションはインストール完了後にpacakge.xmlファイルに書き込まれ、次回システム起動時にこのファイルを読み込むことでアプリケーションの認可情報を取得することができます。
Aandroid6.0後、googleは、このような変化に適応するために、決定するためにユーザーにアクセス許可を付与する危険なプロセスの収縮のためのアクセス許可の付与に虐待的なアクセス許可のアプリケーションを防ぐために、それは、インストール許可と実行時のアクセス許可を区別する必要がある、インストール許可は、元のロジックを維持するために、動的なアクセス許可の割り当てのために変更されないまま必然的にする必要があります。Android 6.0のPackageSettingは、もはやGrantedPermissionsから継承されていませんが、SettingBaseから継承されています。PermissionsStateを保持し、アプリケーションのパーミッションを管理する責任があります。PermissionStateはパーミッションの状態なので、動的認可の目的は最終的にPermissionDataのPermissionStateを変更することで達成されることがわかります。さらに、付与された動的パーミッションは最終的にruntime-permission.xmlに保存されます。
