/** * API for interacting with "application operation" tracking. * * <p>This API is not generally intended for third party application developers; most * features are only available to system applications. Obtain an instance of it through * {@link Context#getSystemService(String) Context.getSystemService} with * {@link Context#APP_OPS_SERVICE Context.APP_OPS_SERVICE}.</p> */

/** * Result from {@link #checkOp}, {@link #noteOp}, {@link #startOp}: the given caller is * allowed to perform the given operation. */public static final int MODE_ALLOWED = 0;/** * Result from {@link #checkOp}, {@link #noteOp}, {@link #startOp}: the given caller is * not allowed to perform the given operation, and this attempt should * <em>silently fail</em> (it should not cause the app to crash). */public static final int MODE_IGNORED = 1;/** * Result from {@link #checkOpNoThrow}, {@link #noteOpNoThrow}, {@link #startOpNoThrow}: the * given caller is not allowed to perform the given operation, and this attempt should * cause it to have a fatal error, typically a {@link SecurityException}. */public static final int MODE_ERRORED = 2;/** * Result from {@link #checkOp}, {@link #noteOp}, {@link #startOp}: the given caller should * use its default security check. This mode is not normally used; it should only be used * with appop permissions, and callers must explicitly check for it and deal with it. */public static final int MODE_DEFAULT = 3;

/** * Do a quick check for whether an application might be able to perform an operation. * This is <em>not</em> a security check; you must use {@link #noteOp(int, int, String)} * or {@link #startOp(int, int, String)} for your actual security checks, which also * ensure that the given uid and package name are consistent. This function can just be * used for a quick check to see if an operation has been disabled for the application, * as an early reject of some work. This does not modify the time stamp or other data * about the operation. * @param op The operation to check. One of the OP_* constants. * @param uid The user id of the application attempting to perform the operation. * @param packageName The name of the application attempting to perform the operation. * @return Returns {@link #MODE_ALLOWED} if the operation is allowed, or * {@link #MODE_IGNORED} if it is not allowed and should be silently ignored (without * causing the app to crash). * @throws SecurityException If the app has been configured to crash on this op. * @hide */public int checkOp(int op, int uid, String packageName) { try {  int mode = mService.checkOperation(op, uid, packageName);  if (mode == MODE_ERRORED) {   throw new SecurityException(buildSecurityExceptionMsg(op, uid, packageName));  }  return mode; } catch (RemoteException e) { } return MODE_IGNORED;}

 /**  * 判斷 懸浮窗口權限是否打開  *  * @param context  * @return true 允許 false禁止  */ public static boolean getAppOps(Context context) {  try {   Object object = context.getSystemService("appops");   if (object == null) {    return false;   }   Class localClass = object.getClass();   Class[] arrayOfClass = new Class[3];   arrayOfClass[0] = Integer.TYPE;   arrayOfClass[1] = Integer.TYPE;   arrayOfClass[2] = String.class;   Method method = localClass.getMethod("checkOp", arrayOfClass);   if (method == null) {    return false;   }   Object[] arrayOfObject1 = new Object[3];   arrayOfObject1[0] = Integer.valueOf(24);   arrayOfObject1[1] = Integer.valueOf(Binder.getCallingUid());   arrayOfObject1[2] = context.getPackageName();   int m = ((Integer) method.invoke(object, arrayOfObject1)).intValue();   return m == AppOpsManager.MODE_ALLOWED;  } catch (Exception ex) {   }  return false; }