core/java/android/content/PermissionChecker.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.content;

 import android.annotation.IntDef;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.app.AppOpsManager;
 import android.content.pm.PackageManager;
 import android.os.Binder;
 import android.os.Process;

 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;

 /**
  * This class provides permission check APIs that verify both the
  * permission and the associated app op for this permission if
  * such is defined.
  * <p>
  * In the new permission model permissions with protection level
  * dangerous are runtime permissions. For apps targeting {@link android.os.Build.VERSION_CODES#M}
  * and above the user may not grant such permissions or revoke
  * them at any time. For apps targeting API lower than {@link android.os.Build.VERSION_CODES#M}
  * these permissions are always granted as such apps do not expect
  * permission revocations and would crash. Therefore, when the
  * user disables a permission for a legacy app in the UI the
  * platform disables the APIs guarded by this permission making
  * them a no-op which is doing nothing or returning an empty
  * result or default error.
  * </p>
  * <p>
  * It is important that when you perform an operation on behalf of
  * another app you use these APIs to check for permissions as the
  * app may be a legacy app that does not participate in the new
  * permission model for which the user had disabled the "permission"
  * which is achieved by disallowing the corresponding app op.
  * </p>
  * <p>
  * This class has two types of methods and you should be careful which
  * type to call based on whether permission protected data is being
  * passed to the app or you are just checking whether the app holds a
  * permission. The reason is that a permission check requires checking
  * the runtime permission and if it is granted checking the corresponding
  * app op as for apps not supporting the runtime mode we never revoke
  * permissions but disable app ops. Since there are two types of app op
  * checks, one that does not leave a record an action was performed and
  * another the does, one needs to call the preflight flavor of the checks
  * named xxxForPreflight only if no private data is being delivered but
  * a permission check is what is needed and the xxxForDataDelivery where
  * the permission check is right before private data delivery.
  *
  * @hide
  */
 public final class PermissionChecker {
     /** Permission result: The permission is granted. */
     public static final int PERMISSION_GRANTED =  PackageManager.PERMISSION_GRANTED;

     /** Permission result: The permission is denied. */
     public static final int PERMISSION_DENIED =  PackageManager.PERMISSION_DENIED;

     /** Permission result: The permission is denied because the app op is not allowed. */
     public static final int PERMISSION_DENIED_APP_OP =  PackageManager.PERMISSION_DENIED  - 1;

     /** Constant when the PID for which we check permissions is unknown. */
     public static final int PID_UNKNOWN = -1;

     /** @hide */
     @IntDef({PERMISSION_GRANTED,
             PERMISSION_DENIED,
             PERMISSION_DENIED_APP_OP})
     @Retention(RetentionPolicy.SOURCE)
     public @interface PermissionResult {}

     private PermissionChecker() {
         /* do nothing */
     }

     /**
      * Checks whether a given package in a UID and PID has a given permission
      * and whether the app op that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * point where you will deliver the permission protected data to clients.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use {@link #checkPermissionForPreflight(Context, String, int, int, String)}
      * to determine if the app has or may have location permission (if app has only foreground
      * location the grant state depends on the app's fg/gb state) and this check will not
      * leave a trace that permission protected data was delivered. When you are about to
      * deliver the location data to a registered listener you should use this method which
      * will evaluate the permission access based on the current fg/bg state of the app and
      * leave a record that the data was accessed.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @param pid The process id for which to check. Use {@link #PID_UNKNOWN} if the PID
      *    is not known.
      * @param uid The uid for which to check.
      * @param packageName The package name for which to check. If null the
      *     the first package for the calling UID will be used.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkPermissionForPreflight(Context, String, int, int, String)
      */
     @PermissionResult
     public static int checkPermissionForDataDelivery(@NonNull Context context,
             @NonNull String permission, int pid, int uid, @Nullable String packageName) {
         return checkPermissionCommon(context, permission, pid, uid, packageName,
                 true /*forDataDelivery*/);
     }

     /**
      * Checks whether a given package in a UID and PID has a given permission
      * and whether the app op that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * preflight point where you will not deliver the permission protected data
      * to clients but schedule permission data delivery, apps register listeners,
      * etc.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use this method to determine if the app has or may have location
      * permission (if app has only foreground location the grant state depends on the app's
      * fg/gb state) and this check will not leave a trace that permission protected data
      * was delivered. When you are about to deliver the location data to a registered
      * listener you should use {@link #checkPermissionForDataDelivery(Context, String,
      * int, int, String)} which will evaluate the permission access based on the current
      * fg/bg state of the app and leave a record that the data was accessed.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @param pid The process id for which to check.
      * @param uid The uid for which to check.
      * @param packageName The package name for which to check. If null the
      *     the first package for the calling UID will be used.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkPermissionForDataDelivery(Context, String, int, int, String)
      */
     @PermissionResult
     public static int checkPermissionForPreflight(@NonNull Context context,
             @NonNull String permission, int pid, int uid, @Nullable String packageName) {
         return checkPermissionCommon(context, permission, pid, uid, packageName,
                 false /*forDataDelivery*/);
     }

     /**
      * Checks whether your app has a given permission and whether the app op
      * that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * point where you will deliver the permission protected data to clients.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use {@link #checkSelfPermissionForPreflight(Context, String)}
      * to determine if the app has or may have location permission (if app has only foreground
      * location the grant state depends on the app's fg/gb state) and this check will not
      * leave a trace that permission protected data was delivered. When you are about to
      * deliver the location data to a registered listener you should use this method
      * which will evaluate the permission access based on the current fg/bg state of the
      * app and leave a record that the data was accessed.
      *
      * <p>This API assumes the the {@link Binder#getCallingUid()} is the same as
      * {@link Process#myUid()}.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkSelfPermissionForPreflight(Context, String)
      */
     @PermissionResult
     public static int checkSelfPermissionForDataDelivery(@NonNull Context context,
             @NonNull String permission) {
         return checkPermissionForDataDelivery(context, permission, Process.myPid(),
                 Process.myUid(), context.getPackageName());
     }

     /**
      * Checks whether your app has a given permission and whether the app op
      * that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * preflight point where you will not deliver the permission protected data
      * to clients but schedule permission data delivery, apps register listeners,
      * etc.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use this method to determine if the app has or may have location
      * permission (if app has only foreground location the grant state depends on the
      * app's fg/gb state) and this check will not leave a trace that permission protected
      * data was delivered. When you are about to deliver the location data to a registered
      * listener you should use this method which will evaluate the permission access based
      * on the current fg/bg state of the app and leave a record that the data was accessed.
      *
      * <p>This API assumes the the {@link Binder#getCallingUid()} is the same as
      * {@link Process#myUid()}.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkSelfPermissionForDataDelivery(Context, String)
      */
     @PermissionResult
     public static int checkSelfPermissionForPreflight(@NonNull Context context,
             @NonNull String permission) {
         return checkPermissionForPreflight(context, permission, Process.myPid(),
                 Process.myUid(), context.getPackageName());
     }

     /**
      * Checks whether the IPC you are handling has a given permission and whether
      * the app op that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * point where you will deliver the permission protected data to clients.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use {@link #checkCallingPermissionForPreflight(Context, String, String)}
      * to determine if the app has or may have location permission (if app has only foreground
      * location the grant state depends on the app's fg/gb state) and this check will not
      * leave a trace that permission protected data was delivered. When you are about to
      * deliver the location data to a registered listener you should use this method which
      * will evaluate the permission access based on the current fg/bg state of the app and
      * leave a record that the data was accessed.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @param packageName The package name making the IPC. If null the
      *     the first package for the calling UID will be used.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkCallingPermissionForPreflight(Context, String, String)
      */
     @PermissionResult
     public static int checkCallingPermissionForDataDelivery(@NonNull Context context,
             @NonNull String permission, @Nullable String packageName) {
         if (Binder.getCallingPid() == Process.myPid()) {
             return PERMISSION_DENIED;
         }
         return checkPermissionForDataDelivery(context, permission, Binder.getCallingPid(),
                 Binder.getCallingUid(), packageName);
     }

     /**
      * Checks whether the IPC you are handling has a given permission and whether
      * the app op that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * preflight point where you will not deliver the permission protected data
      * to clients but schedule permission data delivery, apps register listeners,
      * etc.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use this method to determine if the app has or may have location
      * permission (if app has only foreground location the grant state depends on the app's
      * fg/gb state) and this check will not leave a trace that permission protected data
      * was delivered. When you are about to deliver the location data to a registered
      * listener you should use {@link #checkCallingOrSelfPermissionForDataDelivery(Context,
      * String)} which will evaluate the permission access based on the current fg/bg state
      * of the app and leave a record that the data was accessed.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @param packageName The package name making the IPC. If null the
      *     the first package for the calling UID will be used.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkCallingPermissionForDataDelivery(Context, String, String)
      */
     @PermissionResult
     public static int checkCallingPermissionForPreflight(@NonNull Context context,
             @NonNull String permission, @Nullable String packageName) {
         if (Binder.getCallingPid() == Process.myPid()) {
             return PERMISSION_DENIED;
         }
         return checkPermissionForPreflight(context, permission, Binder.getCallingPid(),
                 Binder.getCallingUid(), packageName);
     }

     /**
      * Checks whether the IPC you are handling or your app has a given permission
      * and whether the app op that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * point where you will deliver the permission protected data to clients.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use {@link #checkCallingOrSelfPermissionForPreflight(Context, String)}
      * to determine if the app has or may have location permission (if app has only foreground
      * location the grant state depends on the app's fg/gb state) and this check will not
      * leave a trace that permission protected data was delivered. When you are about to
      * deliver the location data to a registered listener you should use this method which
      * will evaluate the permission access based on the current fg/bg state of the app and
      * leave a record that the data was accessed.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkCallingOrSelfPermissionForPreflight(Context, String)
      */
     @PermissionResult
     public static int checkCallingOrSelfPermissionForDataDelivery(@NonNull Context context,
             @NonNull String permission) {
         String packageName = (Binder.getCallingPid() == Process.myPid())
                 ? context.getPackageName() : null;
         return checkPermissionForDataDelivery(context, permission, Binder.getCallingPid(),
                 Binder.getCallingUid(), packageName);
     }

     /**
      * Checks whether the IPC you are handling or your app has a given permission
      * and whether the app op that corresponds to this permission is allowed.
      *
      * <strong>NOTE:</strong> Use this method only for permission checks at the
      * preflight point where you will not deliver the permission protected data
      * to clients but schedule permission data delivery, apps register listeners,
      * etc.
      *
      * <p>For example, if an app registers a location listener it should have the location
      * permission but no data is actually sent to the app at the moment of registration
      * and you should use this method to determine if the app has or may have location
      * permission (if app has only foreground location the grant state depends on the
      * app's fg/gb state) and this check will not leave a trace that permission protected
      * data was delivered. When you are about to deliver the location data to a registered
      * listener you should use {@link #checkCallingOrSelfPermissionForDataDelivery(Context,
      * String)} which will evaluate the permission access based on the current fg/bg state
      * of the app and leave a record that the data was accessed.
      *
      * @param context Context for accessing resources.
      * @param permission The permission to check.
      * @return The permission check result which is either {@link #PERMISSION_GRANTED}
      *     or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
      *
      * @see #checkCallingOrSelfPermissionForDataDelivery(Context, String)
      */
     @PermissionResult
     public static int checkCallingOrSelfPermissionForPreflight(@NonNull Context context,
             @NonNull String permission) {
         String packageName = (Binder.getCallingPid() == Process.myPid())
                 ? context.getPackageName() : null;
         return checkPermissionForPreflight(context, permission, Binder.getCallingPid(),
                 Binder.getCallingUid(), packageName);
     }

     private static int checkPermissionCommon(@NonNull Context context, @NonNull String permission,
             int pid, int uid, @Nullable String packageName, boolean forDataDelivery) {
         if (context.checkPermission(permission, pid, uid) == PackageManager.PERMISSION_DENIED) {
             return PERMISSION_DENIED;
         }

         AppOpsManager appOpsManager = context.getSystemService(AppOpsManager.class);
         String op = appOpsManager.permissionToOp(permission);
         if (op == null) {
             return PERMISSION_GRANTED;
         }

         if (packageName == null) {
             String[] packageNames = context.getPackageManager().getPackagesForUid(uid);
             if (packageNames == null || packageNames.length <= 0) {
                 return PERMISSION_DENIED;
             }
             packageName = packageNames[0];
         }

         if (forDataDelivery) {
             if (appOpsManager.noteProxyOpNoThrow(op, packageName, uid)
                     != AppOpsManager.MODE_ALLOWED) {
                 return PERMISSION_DENIED_APP_OP;
             }
         } else {
             final int mode = appOpsManager.unsafeCheckOpRawNoThrow(op, uid, packageName);
             if (mode != AppOpsManager.MODE_ALLOWED && mode != AppOpsManager.MODE_FOREGROUND) {
                 return PERMISSION_DENIED_APP_OP;
             }
         }

         return PERMISSION_GRANTED;
     }
 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.content;

	import android.annotation.IntDef;
	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.app.AppOpsManager;
	import android.content.pm.PackageManager;
	import android.os.Binder;
	import android.os.Process;

	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;

	/**
	* This class provides permission check APIs that verify both the
	* permission and the associated app op for this permission if
	* such is defined.
	* <p>
	* In the new permission model permissions with protection level
	* dangerous are runtime permissions. For apps targeting {@link android.os.Build.VERSION_CODES#M}
	* and above the user may not grant such permissions or revoke
	* them at any time. For apps targeting API lower than {@link android.os.Build.VERSION_CODES#M}
	* these permissions are always granted as such apps do not expect
	* permission revocations and would crash. Therefore, when the
	* user disables a permission for a legacy app in the UI the
	* platform disables the APIs guarded by this permission making
	* them a no-op which is doing nothing or returning an empty
	* result or default error.
	* </p>
	* <p>
	* It is important that when you perform an operation on behalf of
	* another app you use these APIs to check for permissions as the
	* app may be a legacy app that does not participate in the new
	* permission model for which the user had disabled the "permission"
	* which is achieved by disallowing the corresponding app op.
	* </p>
	* <p>
	* This class has two types of methods and you should be careful which
	* type to call based on whether permission protected data is being
	* passed to the app or you are just checking whether the app holds a
	* permission. The reason is that a permission check requires checking
	* the runtime permission and if it is granted checking the corresponding
	* app op as for apps not supporting the runtime mode we never revoke
	* permissions but disable app ops. Since there are two types of app op
	* checks, one that does not leave a record an action was performed and
	* another the does, one needs to call the preflight flavor of the checks
	* named xxxForPreflight only if no private data is being delivered but
	* a permission check is what is needed and the xxxForDataDelivery where
	* the permission check is right before private data delivery.
	*
	* @hide
	*/
	public final class PermissionChecker {
	/** Permission result: The permission is granted. */
	public static final int PERMISSION_GRANTED = PackageManager.PERMISSION_GRANTED;

	/** Permission result: The permission is denied. */
	public static final int PERMISSION_DENIED = PackageManager.PERMISSION_DENIED;

	/** Permission result: The permission is denied because the app op is not allowed. */
	public static final int PERMISSION_DENIED_APP_OP = PackageManager.PERMISSION_DENIED - 1;

	/** Constant when the PID for which we check permissions is unknown. */
	public static final int PID_UNKNOWN = -1;

	/** @hide */
	@IntDef({PERMISSION_GRANTED,
	PERMISSION_DENIED,
	PERMISSION_DENIED_APP_OP})
	@Retention(RetentionPolicy.SOURCE)
	public @interface PermissionResult {}

	private PermissionChecker() {
	/* do nothing */
	}

	/**
	* Checks whether a given package in a UID and PID has a given permission
	* and whether the app op that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* point where you will deliver the permission protected data to clients.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use {@link #checkPermissionForPreflight(Context, String, int, int, String)}
	* to determine if the app has or may have location permission (if app has only foreground
	* location the grant state depends on the app's fg/gb state) and this check will not
	* leave a trace that permission protected data was delivered. When you are about to
	* deliver the location data to a registered listener you should use this method which
	* will evaluate the permission access based on the current fg/bg state of the app and
	* leave a record that the data was accessed.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @param pid The process id for which to check. Use {@link #PID_UNKNOWN} if the PID
	* is not known.
	* @param uid The uid for which to check.
	* @param packageName The package name for which to check. If null the
	* the first package for the calling UID will be used.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkPermissionForPreflight(Context, String, int, int, String)
	*/
	@PermissionResult
	public static int checkPermissionForDataDelivery(@NonNull Context context,
	@NonNull String permission, int pid, int uid, @Nullable String packageName) {
	return checkPermissionCommon(context, permission, pid, uid, packageName,
	true /forDataDelivery/);
	}

	/**
	* Checks whether a given package in a UID and PID has a given permission
	* and whether the app op that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* preflight point where you will not deliver the permission protected data
	* to clients but schedule permission data delivery, apps register listeners,
	* etc.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use this method to determine if the app has or may have location
	* permission (if app has only foreground location the grant state depends on the app's
	* fg/gb state) and this check will not leave a trace that permission protected data
	* was delivered. When you are about to deliver the location data to a registered
	* listener you should use {@link #checkPermissionForDataDelivery(Context, String,
	* int, int, String)} which will evaluate the permission access based on the current
	* fg/bg state of the app and leave a record that the data was accessed.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @param pid The process id for which to check.
	* @param uid The uid for which to check.
	* @param packageName The package name for which to check. If null the
	* the first package for the calling UID will be used.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkPermissionForDataDelivery(Context, String, int, int, String)
	*/
	@PermissionResult
	public static int checkPermissionForPreflight(@NonNull Context context,
	@NonNull String permission, int pid, int uid, @Nullable String packageName) {
	return checkPermissionCommon(context, permission, pid, uid, packageName,
	false /forDataDelivery/);
	}

	/**
	* Checks whether your app has a given permission and whether the app op
	* that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* point where you will deliver the permission protected data to clients.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use {@link #checkSelfPermissionForPreflight(Context, String)}
	* to determine if the app has or may have location permission (if app has only foreground
	* location the grant state depends on the app's fg/gb state) and this check will not
	* leave a trace that permission protected data was delivered. When you are about to
	* deliver the location data to a registered listener you should use this method
	* which will evaluate the permission access based on the current fg/bg state of the
	* app and leave a record that the data was accessed.
	*
	* <p>This API assumes the the {@link Binder#getCallingUid()} is the same as
	* {@link Process#myUid()}.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkSelfPermissionForPreflight(Context, String)
	*/
	@PermissionResult
	public static int checkSelfPermissionForDataDelivery(@NonNull Context context,
	@NonNull String permission) {
	return checkPermissionForDataDelivery(context, permission, Process.myPid(),
	Process.myUid(), context.getPackageName());
	}

	/**
	* Checks whether your app has a given permission and whether the app op
	* that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* preflight point where you will not deliver the permission protected data
	* to clients but schedule permission data delivery, apps register listeners,
	* etc.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use this method to determine if the app has or may have location
	* permission (if app has only foreground location the grant state depends on the
	* app's fg/gb state) and this check will not leave a trace that permission protected
	* data was delivered. When you are about to deliver the location data to a registered
	* listener you should use this method which will evaluate the permission access based
	* on the current fg/bg state of the app and leave a record that the data was accessed.
	*
	* <p>This API assumes the the {@link Binder#getCallingUid()} is the same as
	* {@link Process#myUid()}.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkSelfPermissionForDataDelivery(Context, String)
	*/
	@PermissionResult
	public static int checkSelfPermissionForPreflight(@NonNull Context context,
	@NonNull String permission) {
	return checkPermissionForPreflight(context, permission, Process.myPid(),
	Process.myUid(), context.getPackageName());
	}

	/**
	* Checks whether the IPC you are handling has a given permission and whether
	* the app op that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* point where you will deliver the permission protected data to clients.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use {@link #checkCallingPermissionForPreflight(Context, String, String)}
	* to determine if the app has or may have location permission (if app has only foreground
	* location the grant state depends on the app's fg/gb state) and this check will not
	* leave a trace that permission protected data was delivered. When you are about to
	* deliver the location data to a registered listener you should use this method which
	* will evaluate the permission access based on the current fg/bg state of the app and
	* leave a record that the data was accessed.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @param packageName The package name making the IPC. If null the
	* the first package for the calling UID will be used.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkCallingPermissionForPreflight(Context, String, String)
	*/
	@PermissionResult
	public static int checkCallingPermissionForDataDelivery(@NonNull Context context,
	@NonNull String permission, @Nullable String packageName) {
	if (Binder.getCallingPid() == Process.myPid()) {
	return PERMISSION_DENIED;
	}
	return checkPermissionForDataDelivery(context, permission, Binder.getCallingPid(),
	Binder.getCallingUid(), packageName);
	}

	/**
	* Checks whether the IPC you are handling has a given permission and whether
	* the app op that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* preflight point where you will not deliver the permission protected data
	* to clients but schedule permission data delivery, apps register listeners,
	* etc.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use this method to determine if the app has or may have location
	* permission (if app has only foreground location the grant state depends on the app's
	* fg/gb state) and this check will not leave a trace that permission protected data
	* was delivered. When you are about to deliver the location data to a registered
	* listener you should use {@link #checkCallingOrSelfPermissionForDataDelivery(Context,
	* String)} which will evaluate the permission access based on the current fg/bg state
	* of the app and leave a record that the data was accessed.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @param packageName The package name making the IPC. If null the
	* the first package for the calling UID will be used.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkCallingPermissionForDataDelivery(Context, String, String)
	*/
	@PermissionResult
	public static int checkCallingPermissionForPreflight(@NonNull Context context,
	@NonNull String permission, @Nullable String packageName) {
	if (Binder.getCallingPid() == Process.myPid()) {
	return PERMISSION_DENIED;
	}
	return checkPermissionForPreflight(context, permission, Binder.getCallingPid(),
	Binder.getCallingUid(), packageName);
	}

	/**
	* Checks whether the IPC you are handling or your app has a given permission
	* and whether the app op that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* point where you will deliver the permission protected data to clients.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use {@link #checkCallingOrSelfPermissionForPreflight(Context, String)}
	* to determine if the app has or may have location permission (if app has only foreground
	* location the grant state depends on the app's fg/gb state) and this check will not
	* leave a trace that permission protected data was delivered. When you are about to
	* deliver the location data to a registered listener you should use this method which
	* will evaluate the permission access based on the current fg/bg state of the app and
	* leave a record that the data was accessed.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkCallingOrSelfPermissionForPreflight(Context, String)
	*/
	@PermissionResult
	public static int checkCallingOrSelfPermissionForDataDelivery(@NonNull Context context,
	@NonNull String permission) {
	String packageName = (Binder.getCallingPid() == Process.myPid())
	? context.getPackageName() : null;
	return checkPermissionForDataDelivery(context, permission, Binder.getCallingPid(),
	Binder.getCallingUid(), packageName);
	}

	/**
	* Checks whether the IPC you are handling or your app has a given permission
	* and whether the app op that corresponds to this permission is allowed.
	*
	* <strong>NOTE:</strong> Use this method only for permission checks at the
	* preflight point where you will not deliver the permission protected data
	* to clients but schedule permission data delivery, apps register listeners,
	* etc.
	*
	* <p>For example, if an app registers a location listener it should have the location
	* permission but no data is actually sent to the app at the moment of registration
	* and you should use this method to determine if the app has or may have location
	* permission (if app has only foreground location the grant state depends on the
	* app's fg/gb state) and this check will not leave a trace that permission protected
	* data was delivered. When you are about to deliver the location data to a registered
	* listener you should use {@link #checkCallingOrSelfPermissionForDataDelivery(Context,
	* String)} which will evaluate the permission access based on the current fg/bg state
	* of the app and leave a record that the data was accessed.
	*
	* @param context Context for accessing resources.
	* @param permission The permission to check.
	* @return The permission check result which is either {@link #PERMISSION_GRANTED}
	* or {@link #PERMISSION_DENIED} or {@link #PERMISSION_DENIED_APP_OP}.
	*
	* @see #checkCallingOrSelfPermissionForDataDelivery(Context, String)
	*/
	@PermissionResult
	public static int checkCallingOrSelfPermissionForPreflight(@NonNull Context context,
	@NonNull String permission) {
	String packageName = (Binder.getCallingPid() == Process.myPid())
	? context.getPackageName() : null;
	return checkPermissionForPreflight(context, permission, Binder.getCallingPid(),
	Binder.getCallingUid(), packageName);
	}

	private static int checkPermissionCommon(@NonNull Context context, @NonNull String permission,
	int pid, int uid, @Nullable String packageName, boolean forDataDelivery) {
	if (context.checkPermission(permission, pid, uid) == PackageManager.PERMISSION_DENIED) {
	return PERMISSION_DENIED;
	}

	AppOpsManager appOpsManager = context.getSystemService(AppOpsManager.class);
	String op = appOpsManager.permissionToOp(permission);
	if (op == null) {
	return PERMISSION_GRANTED;
	}

	if (packageName == null) {
	String[] packageNames = context.getPackageManager().getPackagesForUid(uid);
	if (packageNames == null \|\| packageNames.length <= 0) {
	return PERMISSION_DENIED;
	}
	packageName = packageNames[0];
	}

	if (forDataDelivery) {
	if (appOpsManager.noteProxyOpNoThrow(op, packageName, uid)
	!= AppOpsManager.MODE_ALLOWED) {
	return PERMISSION_DENIED_APP_OP;
	}
	} else {
	final int mode = appOpsManager.unsafeCheckOpRawNoThrow(op, uid, packageName);
	if (mode != AppOpsManager.MODE_ALLOWED && mode != AppOpsManager.MODE_FOREGROUND) {
	return PERMISSION_DENIED_APP_OP;
	}
	}

	return PERMISSION_GRANTED;
	}
	}