Question: I've been getting reports of some Xiaomi devices (e.g. Mi 2, running API level 21) not showing overlays. My app targets API 23.

There are [several](http://forum.xda-developers.com/xiaomi-mi-3/help/link-bubble-playing-nice-t2857607) [posts](http://en.miui.com/thread-30931-1-1.html) out there regarding this. It seems that MIUI devices do not enable this permission at install time (unlike other pre-Marshmallow devices).

Unfortunately, `Settings.canDrawOverlays()` only works on Android 23+.

1. What is the correct way to check whether this permission has not yet been enabled pre-Marshmallow?
2. Is there an Intent to take the user to the relevant MUIU settings page? Maybe: `new Intent("android.settings.action.MANAGE_OVERLAY_PERMISSION", packageName)` but I have no means to test this.

Answer: 
1) on pre-API 23, the permission is already given, because the user granted it upon install.

EDIT: it seems there is a bug on Android 6 (that will [**get fixed on 6.0.1**](https://code.google.com/p/android/issues/detail?id=196597)), that if the user has denied this permission , the app will crash with SecurityException. No idea how Google fixed it though.

2) This way:

```
public static void requestSystemAlertPermission(Activity context, Fragment fragment, int requestCode) {
    if (VERSION.SDK_INT < VERSION_CODES.M)
        return;
    final String packageName = context == null ? fragment.getActivity().getPackageName() : context.getPackageName();
    final Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, Uri.parse("package:" + packageName));
    if (fragment != null)
        fragment.startActivityForResult(intent, requestCode);
    else
        context.startActivityForResult(intent, requestCode);
}

```

Then, in the onActivityResult, you can check if the permission is given or not, as such:

```
@TargetApi(VERSION_CODES.M)
public static boolean isSystemAlertPermissionGranted(Context context) {
    final boolean result = VERSION.SDK_INT < VERSION_CODES.M || Settings.canDrawOverlays(context);
    return result;
}

```

---

EDIT: for the time being, if you publish an app to the Play Store, your app will be auto-granted with this permission. You can read about it [**here**](https://commonsware.com/blog/2016/03/24/system-alert-window-now-more-hidden-than-ever.html). When I asked about it, I thought it was a part of Android itself, as I thought all we need is to target a high enough value for targetSdkVersion. What Google wrote to me ([**here**](https://code.google.com/p/android/issues/detail?id=222195)) is that they wanted to avoid issues on popular apps. 

I suggest handling this permission correctly even if you will get it auto-granted.
For searching for while about the issue in Xiaomi, Meizu I have found this. It's working perfectly.. 

```
public static boolean isMiuiFloatWindowOpAllowed(@NonNull Context context) {
    final int version = Build.VERSION.SDK_INT;

    if (version >= 19) {
        return checkOp(context, OP_SYSTEM_ALERT_WINDOW); //See AppOpsManager.OP_SYSTEM_ALERT_WINDOW=24 /*@hide/
    } else {
        return (context.getApplicationInfo().flags & 1<<27) == 1;
    }
}

public static boolean checkOp(Context context, int op, String packageName, int uid) {
    final int version = Build.VERSION.SDK_INT;

    if (version >= 19) {
        AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
        try {
            return (AppOpsManager.MODE_ALLOWED == (Integer) ReflectUtils.invokeMethod(manager, "checkOp", op, uid, packageName));
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else {
        Flog.e("Below API 19 cannot invoke!");
    }
    return false;
}

```

> 
> ReflectUtils.java
> 
> 
> 

```
public static Object invokeMethod(@NonNull Object receiver, String methodName, Object... methodArgs) throws Exception {
Class<?>[] argsClass = null;
    if (methodArgs != null && methodArgs.length != 0) {
        int length = methodArgs.length;
        argsClass = new Class[length];
        for (int i=0; i<length; i++) {
            argsClass[i] = getBaseTypeClass(methodArgs[i].getClass());
        }
    }

    Method method = receiver.getClass().getMethod(methodName, argsClass);
    return method.invoke(receiver, methodArgs);
}

```

[Reference](https://stackoverflow.com/questions/33382436/how-to-check-permission-system-alert-window-is-granted-on-android-lollipop)