應客戶需要，在最近的項目中需要添加懸浮窗。
但是懸浮窗在需要適配的地方比較多，因此在這里做一下記錄。
也希望對有這種需求的伙計有所幫助！！！

懸浮窗分類：

系統懸浮窗：所有界面都會展示，包括主屏、鎖屏

應用懸浮窗：只在應用Activity中展示。

Window類

認識懸浮窗之前我們先了解一下Window類，Android Framework將窗口分為三個類型：

1.應用窗口：所謂應用窗口指的就是該窗口對應一個Activity，因此，要創建應用窗口就必須在Activity中完成了。
2.子窗口：所謂子窗口指的是必須依附在某個父窗口之上，比如PopWindow，Dialog。
3.系統窗口：所謂系統窗口指的是由系統進程創建，不依賴于任何應用或者不依附在任何父窗口之上，系統窗口是需要權限才能創建的，如：Toast,來電窗口等。

Framework定義的三種類型的窗口，都是在WindowManager.LayoutParams中，通過type參數進行細化，每一種類型都是用一個int型常量表示，代表其所在層級。常量值越大，代表位置越靠上。應用程序Window的層值常量要小于子Window的層值常量，子Window的層值常量要小于系統Window的層值常量。我們可以用一個直觀表格來表示：

WindowManager.LayoutParams

提供懸浮窗需要的參數，常用的屬性有：

x：如果忽略默認的gravity，它表示窗口的x坐標。設置gravity為LEFT或START、RIGHT、END后，x表示到特定邊的距離。
y：如果忽略默認的gravity，它表示窗口的y坐標。設置gravity為TOP或BOTTOM后，y表示到特定邊的距離。
gravity：窗口的對齊方式，一般設為左上角，方便計算位置。
width：窗口寬度。
height：窗口高度。
type：窗口類型。
flag： 窗口行為。

type類型

 /**
  * 應用窗口
  */
     //第一個應用窗口
     public static final int FIRST_APPLICATION_WINDOW = 1;
     //所有程序窗口的base窗口，其他應用程序窗口都顯示在它上面
     public static final int TYPE_BASE_APPLICATION   = 1;
     //所有Activity的窗口，只能配合Activity在當前APP使用
     public static final int TYPE_APPLICATION        = 2;
     //目標應用窗口未啟動之前的那個窗口
     public static final int TYPE_APPLICATION_STARTING = 3;
     //最后一個應用窗口
     public static final int LAST_APPLICATION_WINDOW = 99;

 /**
  * 子窗口
  */
     //第一個子窗口
     public static final int FIRST_SUB_WINDOW        = 1000;
    // 面板窗口，顯示于宿主窗口的上層,只能配合Activity在當前APP使用
    public static final int TYPE_APPLICATION_PANEL  = FIRST_SUB_WINDOW;
    // 媒體窗口（例如視頻），顯示于宿主窗口下層
    public static final int TYPE_APPLICATION_MEDIA  = FIRST_SUB_WINDOW+1;
    // 應用程序窗口的子面板，只能配合Activity在當前APP使用(PopupWindow默認就是這個Type)
    public static final int TYPE_APPLICATION_SUB_PANEL = FIRST_SUB_WINDOW+2;
    //對話框窗口,只能配合Activity在當前APP使用
    public static final int TYPE_APPLICATION_ATTACHED_DIALOG = FIRST_SUB_WINDOW+3;
    //
    public static final int TYPE_APPLICATION_MEDIA_OVERLAY  = FIRST_SUB_WINDOW+4;
    //最后一個子窗口
    public static final int LAST_SUB_WINDOW         = 1999;
 /**
  * 子窗口
  */
   //系統窗口，非應用程序創建
   public static final int FIRST_SYSTEM_WINDOW     = 2000;
   //狀態欄，只能有一個狀態欄，位于屏幕頂端，其他窗口都位于它下方
   public static final int TYPE_STATUS_BAR         = FIRST_SYSTEM_WINDOW;
   //搜索欄，只能有一個搜索欄，位于屏幕上方
   public static final int TYPE_SEARCH_BAR         = FIRST_SYSTEM_WINDOW+1; 
  //電話窗口，它用于電話交互（特別是呼入），置于所有應用程序之上，狀態欄之下,屬于懸浮窗(并且給一個Activity的話按下HOME鍵會出現看不到桌面上的圖標異常情況)
   public static final int TYPE_PHONE              = FIRST_SYSTEM_WINDOW+2;
   //系統警告提示窗口，出現在應用程序窗口之上,屬于懸浮窗, 但是會被禁止
   public static final int TYPE_SYSTEM_ALERT       = FIRST_SYSTEM_WINDOW+3;

   //信息窗口，用于顯示Toast, 不屬于懸浮窗, 但有懸浮窗的功能, 缺點是在Android2.3上無法接收點擊事件
   public static final int TYPE_TOAST              = FIRST_SYSTEM_WINDOW+5;
   //
   public static final int TYPE_KEYGUARD           = FIRST_SYSTEM_WINDOW+4;
   //鎖屏窗口
   public static final int TYPE_KEYGUARD           = FIRST_SYSTEM_WINDOW+4;
   //系統頂層窗口，顯示在其他一切內容之上，此窗口不能獲得輸入焦點，否則影響鎖屏
   public static final int TYPE_SYSTEM_OVERLAY     = FIRST_SYSTEM_WINDOW+6;
   //電話優先，當鎖屏時顯示，此窗口不能獲得輸入焦點，否則影響鎖屏
   public static final int TYPE_PRIORITY_PHONE     = FIRST_SYSTEM_WINDOW+7;
   //系統對話框窗口
   public static final int TYPE_SYSTEM_DIALOG      = FIRST_SYSTEM_WINDOW+8;
   //鎖屏時顯示的對話框
   public static final int TYPE_KEYGUARD_DIALOG    = FIRST_SYSTEM_WINDOW+9;
   //系統內部錯誤提示，顯示在任何窗口之上
   public static final int TYPE_SYSTEM_ERROR       = FIRST_SYSTEM_WINDOW+10;
   //內部輸入法窗口，顯示于普通UI之上，應用程序可重新布局以免被此窗口覆蓋
   public static final int TYPE_INPUT_METHOD       = FIRST_SYSTEM_WINDOW+11;
   //內部輸入法對話框，顯示于當前輸入法窗口之上
   public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12;
   //墻紙窗口
   public static final int TYPE_WALLPAPER          = FIRST_SYSTEM_WINDOW+13;
   //狀態欄的滑動面板
   public static final int TYPE_STATUS_BAR_PANEL   = FIRST_SYSTEM_WINDOW+14;
   //安全系統覆蓋窗口，這些窗戶必須不帶輸入焦點，否則會干擾鍵盤
   public static final int TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15;
   //最后一個系統窗口
   public static final int LAST_SYSTEM_WINDOW      = 2999;

常用的type取值：

TYPE_SYSTEM_ALERT：系統提示，總是出現在應用程序窗口之上。
TYPE_SYSTEM_OVERLAY：系統頂層窗口，顯示在其它一切內容上。此窗口不能>獲得輸入焦點，否則會影響鎖屏。
TYPE_SYSTEM_ERROR：系統內部錯誤提示，顯示在所有內容之上。
TYPE_PHONE：電話窗口，用于電話交互（特別是呼入）。顯示在所有應用程序>之上，狀態欄之下。

type類型

   //窗口特征標記
   public int flags;
   //當該window對用戶可見的時候，允許鎖屏
   public static final int FLAG_ALLOW_LOCK_WHILE_SCREEN_ON     = 0x00000001;
   //窗口后面的所有內容都變暗
   public static final int FLAG_DIM_BEHIND        = 0x00000002;
   //Flag：窗口后面的所有內容都變模糊
   public static final int FLAG_BLUR_BEHIND        = 0x00000004;
   //窗口不能獲得焦點
   public static final int FLAG_NOT_FOCUSABLE      = 0x00000008;
   //窗口不接受觸摸屏事件
   public static final int FLAG_NOT_TOUCHABLE      = 0x00000010;
   //即使在該window在可獲得焦點情況下，允許該窗口之外的點擊事件傳遞到當前窗口后面的的窗口去
   public static final int FLAG_NOT_TOUCH_MODAL    = 0x00000020;
   //當手機處于睡眠狀態時，如果屏幕被按下，那么該window將第一個收到觸摸事件
   public static final int FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040;
   //當該window對用戶可見時，屏幕出于常亮狀態
   public static final int FLAG_KEEP_SCREEN_ON     = 0x00000080;
   //：讓window占滿整個手機屏幕，不留任何邊界
   public static final int FLAG_LAYOUT_IN_SCREEN   = 0x00000100;
   //允許窗口超出整個手機屏幕
   public static final int FLAG_LAYOUT_NO_LIMITS   = 0x00000200;
   //window全屏顯示
   public static final int FLAG_FULLSCREEN      = 0x00000400;
   //恢復window非全屏顯示
   public static final int FLAG_FORCE_NOT_FULLSCREEN   = 0x00000800;
   //開啟窗口抖動
   public static final int FLAG_DITHER             = 0x00001000;
   //安全內容窗口，該窗口顯示時不允許截屏
   public static final int FLAG_SECURE             = 0x00002000;
   //鎖屏時顯示該窗口
   public static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000;
   //系統的墻紙顯示在該窗口之后
   public static final int FLAG_SHOW_WALLPAPER = 0x00100000;
   //當window被顯示的時候，系統將把它當做一個用戶活動事件，以點亮手機屏幕
   public static final int FLAG_TURN_SCREEN_ON = 0x00200000;
   //該窗口顯示，消失鍵盤
   public static final int FLAG_DISMISS_KEYGUARD = 0x00400000;
   //當該window在可以接受觸摸屏情況下，讓因在該window之外，而發送到后面的window的觸摸屏可以支持split touch
   public static final int FLAG_SPLIT_TOUCH = 0x00800000;
   //對該window進行硬件加速，該flag必須在Activity或Dialog的Content View之前進行設置
  public static final int FLAG_HARDWARE_ACCELERATED = 0x01000000;
  //讓window占滿整個手機屏幕，不留任何邊界
  public static final int FLAG_LAYOUT_IN_OVERSCAN = 0x02000000;
  //透明狀態欄
  public static final int FLAG_TRANSLUCENT_STATUS = 0x04000000;
  //透明導航欄
  public static final int FLAG_TRANSLUCENT_NAVIGATION = 0x08000000;

WindowManager

懸浮窗主要是通過WindowManager實現的。其中的三個方法：

void addView (View view, WindowManager.LayoutParams params)//添加一個懸浮窗
void removeView (View view)//移除懸浮窗
void updateViewLayout (View view, WindowManager.LayoutParams params)//更新懸浮窗參數

懸浮窗實現

首先需要聲明權限

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

權限適配

https://blog.csdn.net/ltym2014/article/details/78860620
https://github.com/czy1121/settingscompat
參考上述文章關于懸浮權限的檢測及跳轉授權界面適配，用一張表格來展示。

可以看出在6.0之前的版本并未將懸浮窗權限獨立出來，而是不同手機廠商自己的ROM做了處理。
現將國產手機機型判斷貼出來，再針對其做對應的權限處理。

public class RomUtils {
    private static final String TAG = "RomUtils";

    /**
     * 獲取 emui 版本號
     * @return
     */
    public static double getEmuiVersion() {
        try {
            String emuiVersion = getSystemProperty("ro.build.version.emui");
            String version = emuiVersion.substring(emuiVersion.indexOf("_") + 1);
            return Double.parseDouble(version);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 4.0;
    }

    /**
     * 獲取小米 rom 版本號，獲取失敗返回 -1
     *
     * @return miui rom version code, if fail , return -1
     */
    public static int getMiuiVersion() {
        String version = getSystemProperty("ro.miui.ui.version.name");
        if (version != null) {
            try {
                return Integer.parseInt(version.substring(1));
            } catch (Exception e) {
                Log.e(TAG, "get miui version code error, version : " + version);
            }
        }
        return -1;
    }

    public static String getSystemProperty(String propName) {
        String line;
        BufferedReader input = null;
        try {
            Process p = Runtime.getRuntime().exec("getprop " + propName);
            input = new BufferedReader(new InputStreamReader(p.getInputStream()), 1024);
            line = input.readLine();
            input.close();
        } catch (IOException ex) {
            Log.e(TAG, "Unable to read sysprop " + propName, ex);
            return null;
        } finally {
            if (input != null) {
                try {
                    input.close();
                } catch (IOException e) {
                    Log.e(TAG, "Exception while closing InputStream", e);
                }
            }
        }
        return line;
    }
    /**
     * 判斷是否是華為ROM
     */
    public static boolean checkIsHuaweiRom() {
        return Build.MANUFACTURER.contains("HUAWEI");
    }

    /**
     * 判斷是否是 miui ROM
     */
    public static boolean checkIsMiuiRom() {
        return !TextUtils.isEmpty(getSystemProperty("ro.miui.ui.version.name"));
    }
    /**
     * 判斷是否是  魅族 ROM
     */
    public static boolean checkIsMeizuRom() {
        //return Build.MANUFACTURER.contains("Meizu");
        String meizuFlymeOSFlag  = getSystemProperty("ro.build.display.id");
        if (TextUtils.isEmpty(meizuFlymeOSFlag)){
            return false;
        }else if (meizuFlymeOSFlag.contains("flyme") || meizuFlymeOSFlag.toLowerCase().contains("flyme")){
            return  true;
        }else {
            return false;
        }
    }
    /**
     * 判斷是否是360 ROM
     */
    public static boolean checkIs360Rom() {
        //fix issue https://github.com/zhaozepeng/FloatWindowPermission/issues/9
        return Build.MANUFACTURER.contains("QiKU")
                || Build.MANUFACTURER.contains("360");
    }
}

針對不同的ROM調用不同的權限判斷方法

不同Rom判斷權限的方法

小米 MIUI

懸浮窗權限的op值是public static final int OP_SYSTEM_ALERT_WINDOW = 24;

    /**
     * 檢測 miui 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;

        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        } else {
//            if ((context.getApplicationInfo().flags & 1 << 27) == 1) {
//                return true;
//            } else {
//                return false;
//            }
            return true;
        }
    }
    /**
     * 小米檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int) method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e(TAG, "Below API 19 cannot invoke!");
        }
        return false;
    }

魅族 flyme

   /**
     * 檢測 meizu 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        }
        return true;
    }
    /**
     * 魅族檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int)method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e(TAG, "Below API 19 cannot invoke!");
        }
        return false;
    }

華為

   /**
     * 檢測 Huawei 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        }
        return true;
    }
    /**
     * 華為檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int) method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e(TAG, "Below API 19 cannot invoke!");
        }
        return false;
    }

360

    /**
     * 檢測 360 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        }
        return true;
    }
    /**
     * 360檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int)method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e("", "Below API 19 cannot invoke!");
        }
        return false;
    }

6.0以上手機檢測權限

    private boolean commonROMPermissionCheck(Context context) {
        //最新發現魅族6.0的系統這種方式不好用，天殺的，只有你是奇葩，沒辦法，單獨適配一下
        if (RomUtils.checkIsMeizuRom()) {
            return meizuPermissionCheck(context);
        } else {
            Boolean result = true;
            if (Build.VERSION.SDK_INT >= 23) {
                try {
                    Class clazz = Settings.class;
                    Method canDrawOverlays = clazz.getDeclaredMethod("canDrawOverlays", Context.class);
                    result = (Boolean) canDrawOverlays.invoke(null, context);
                } catch (Exception e) {
                    Log.e(TAG, Log.getStackTraceString(e));
                }
              //Settings.canDrawOverlays(context);//也可以直接用這一個
            }
            return result;
        }
    }

總體權限檢測代碼

  public boolean checkPermission(Context context) {
        //6.0 版本之后由于 google 增加了對懸浮窗權限的管理，所以方式就統一了
        if (Build.VERSION.SDK_INT < 23) {
            if (RomUtils.checkIsMiuiRom()) {
                return miuiPermissionCheck(context);
            } else if (RomUtils.checkIsMeizuRom()) {
                return meizuPermissionCheck(context);
            } else if (RomUtils.checkIsHuaweiRom()) {
                return huaweiPermissionCheck(context);
            } else if (RomUtils.checkIs360Rom()) {
                return qikuPermissionCheck(context);
            }
        }
        return commonROMPermissionCheck(context);
    }
    private boolean huaweiPermissionCheck(Context context) {
        return HuaweiUtils.checkFloatWindowPermission(context);
    }

    private boolean miuiPermissionCheck(Context context) {
        return MiuiUtils.checkFloatWindowPermission(context);
    }

    private boolean meizuPermissionCheck(Context context) {
        return MeizuUtils.checkFloatWindowPermission(context);
    }

    private boolean qikuPermissionCheck(Context context) {
        return QikuUtils.checkFloatWindowPermission(context);
    }

    private boolean commonROMPermissionCheck(Context context) {
        //最新發現魅族6.0的系統這種方式不好用，天殺的，只有你是奇葩，沒辦法，單獨適配一下
        if (RomUtils.checkIsMeizuRom()) {
            return meizuPermissionCheck(context);
        } else {
            Boolean result = true;
            if (Build.VERSION.SDK_INT >= 23) {
                try {
                    Class clazz = Settings.class;
                    Method canDrawOverlays = clazz.getDeclaredMethod("canDrawOverlays", Context.class);
                    result = (Boolean) canDrawOverlays.invoke(null, context);
                } catch (Exception e) {
                    Log.e(TAG, Log.getStackTraceString(e));
                }
              //Settings.canDrawOverlays(context);//也可以直接用這一個
            }
            return result;
        }
    }

檢測完權限后，如果沒用權限就需要跳轉到權限授權界面了，我們還是將不同的ROM做處理。

小米MIUI

MIUI不同版本的權限授權頁面不一樣，所以需要根據不同版本進行不同處理。

public class MiuiUtils {
    private static final String TAG = "MiuiUtils";

    /**
     * 獲取小米 rom 版本號，獲取失敗返回 -1
     *
     * @return miui rom version code, if fail , return -1
     */
    public static int getMiuiVersion() {
        String version = RomUtils.getSystemProperty("ro.miui.ui.version.name");
        if (version != null) {
            try {
                return Integer.parseInt(version.substring(1));
            } catch (Exception e) {
                Log.e(TAG, "get miui version code error, version : " + version);
                Log.e(TAG, Log.getStackTraceString(e));
            }
        }
        return -1;
    }

    /**
     * 檢測 miui 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;

        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        } else {
//            if ((context.getApplicationInfo().flags & 1 << 27) == 1) {
//                return true;
//            } else {
//                return false;
//            }
            return true;
        }
    }
    /**
     * 小米檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int) method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e(TAG, "Below API 19 cannot invoke!");
        }
        return false;
    }

    /**
     * 小米 ROM 權限申請
     */
    public static void applyMiuiPermission(Context context) {
        int versionCode = getMiuiVersion();
        if (versionCode == 5) {
            goToMiuiPermissionActivity_V5(context);
        } else if (versionCode == 6) {
            goToMiuiPermissionActivity_V6(context);
        } else if (versionCode == 7) {
            goToMiuiPermissionActivity_V7(context);
        } else if (versionCode == 8) {
            goToMiuiPermissionActivity_V8(context);
        } else {
            Log.e(TAG, "this is a special MIUI rom version, its version code " + versionCode);
        }
    }

    private static boolean isIntentAvailable(Intent intent, Context context) {
        if (intent == null) {
            return false;
        }
        return context.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY).size() > 0;
    }

    /**
     * 小米 V5 版本 ROM權限申請
     */
    public static void goToMiuiPermissionActivity_V5(Context context) {
        Intent intent = null;
        String packageName = context.getPackageName();
        intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        Uri uri = Uri.fromParts("package", packageName, null);
        intent.setData(uri);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        if (isIntentAvailable(intent, context)) {
            context.startActivity(intent);
        } else {
            Log.e(TAG, "intent is not available!");
        }

        //設置頁面在應用詳情頁面
//        Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
//        PackageInfo pInfo = null;
//        try {
//            pInfo = context.getPackageManager().getPackageInfo
//                    (HostInterfaceManager.getHostInterface().getApp().getPackageName(), 0);
//        } catch (PackageManager.NameNotFoundException e) {
//            AVLogUtils.e(TAG, e.getMessage());
//        }
//        intent.setClassName("com.android.settings", "com.miui.securitycenter.permission.AppPermissionsEditor");
//        intent.putExtra("extra_package_uid", pInfo.applicationInfo.uid);
//        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//        if (isIntentAvailable(intent, context)) {
//            context.startActivity(intent);
//        } else {
//            AVLogUtils.e(TAG, "Intent is not available!");
//        }
    }

    /**
     * 小米 V6 版本 ROM權限申請
     */
    public static void goToMiuiPermissionActivity_V6(Context context) {
        Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
        intent.setClassName("com.miui.securitycenter", "com.miui.permcenter.permissions.AppPermissionsEditorActivity");
        intent.putExtra("extra_pkgname", context.getPackageName());
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        if (isIntentAvailable(intent, context)) {
            context.startActivity(intent);
        } else {
            Log.e(TAG, "Intent is not available!");
        }
    }

    /**
     * 小米 V7 版本 ROM權限申請
     */
    public static void goToMiuiPermissionActivity_V7(Context context) {
        Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
        intent.setClassName("com.miui.securitycenter", "com.miui.permcenter.permissions.AppPermissionsEditorActivity");
        intent.putExtra("extra_pkgname", context.getPackageName());
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        if (isIntentAvailable(intent, context)) {
            context.startActivity(intent);
        } else {
            Log.e(TAG, "Intent is not available!");
        }
    }

    /**
     * 小米 V8 版本 ROM權限申請
     */
    public static void goToMiuiPermissionActivity_V8(Context context) {
        Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
        intent.setClassName("com.miui.securitycenter", "com.miui.permcenter.permissions.PermissionsEditorActivity");
//        intent.setPackage("com.miui.securitycenter");
        intent.putExtra("extra_pkgname", context.getPackageName());
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        if (isIntentAvailable(intent, context)) {
            context.startActivity(intent);
        } else {
            intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
            intent.setPackage("com.miui.securitycenter");
            intent.putExtra("extra_pkgname", context.getPackageName());
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            
            if (isIntentAvailable(intent, context)) {
                context.startActivity(intent);
            } else {
                Log.e(TAG, "Intent is not available!");
            }
        }
    }
}

魅族flyme跳轉去懸浮窗權限授予界面

public class MeizuUtils {
    private static final String TAG = "MeizuUtils";

    /**
     * 檢測 meizu 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        }
        return true;
    }

    /**
     * 去魅族權限申請頁面
     */
    public static void applyPermission(Context context){
        Intent intent = new Intent("com.meizu.safe.security.SHOW_APPSEC");
        intent.setClassName("com.meizu.safe", "com.meizu.safe.security.AppSecActivity");
        intent.putExtra("packageName", context.getPackageName());
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(intent);
    }
    /**
     * 魅族檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int)method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e(TAG, "Below API 19 cannot invoke!");
        }
        return false;
    }
}

華為跳轉去懸浮窗權限授予界面

public class HuaweiUtils {
    private static final String TAG = "HuaweiUtils";

    /**
     * 檢測 Huawei 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        }
        return true;
    }

    /**
     * 去華為權限申請頁面
     */
    public static void applyPermission(Context context) {
        try {
            Intent intent = new Intent();
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//   ComponentName comp = new ComponentName("com.huawei.systemmanager","com.huawei.permissionmanager.ui.MainActivity");//華為權限管理
//   ComponentName comp = new ComponentName("com.huawei.systemmanager",
//      "com.huawei.permissionmanager.ui.SingleAppActivity");//華為權限管理，跳轉到指定app的權限管理位置需要華為接口權限，未解決
            ComponentName comp = new ComponentName("com.huawei.systemmanager", "com.huawei.systemmanager.addviewmonitor.AddViewMonitorActivity");//懸浮窗管理頁面
            intent.setComponent(comp);
            if (RomUtils.getEmuiVersion() == 3.1) {
                //emui 3.1 的適配
                context.startActivity(intent);
            } else {
                //emui 3.0 的適配
                comp = new ComponentName("com.huawei.systemmanager", "com.huawei.notificationmanager.ui.NotificationManagmentActivity");//懸浮窗管理頁面
                intent.setComponent(comp);
                context.startActivity(intent);
            }
        } catch (SecurityException e) {
            Intent intent = new Intent();
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//   ComponentName comp = new ComponentName("com.huawei.systemmanager","com.huawei.permissionmanager.ui.MainActivity");//華為權限管理
            ComponentName comp = new ComponentName("com.huawei.systemmanager",
                    "com.huawei.permissionmanager.ui.MainActivity");//華為權限管理，跳轉到本app的權限管理頁面,這個需要華為接口權限，未解決
//      ComponentName comp = new ComponentName("com.huawei.systemmanager","com.huawei.systemmanager.addviewmonitor.AddViewMonitorActivity");//懸浮窗管理頁面
            intent.setComponent(comp);
            context.startActivity(intent);
            Log.e(TAG, Log.getStackTraceString(e));
        } catch (ActivityNotFoundException e) {
            /**
             * 手機管家版本較低 HUAWEI SC-UL10
             */
//   Toast.makeText(MainActivity.this, "act找不到", Toast.LENGTH_LONG).show();
            Intent intent = new Intent();
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            ComponentName comp = new ComponentName("com.Android.settings", "com.android.settings.permission.TabItem");//權限管理頁面 android4.4
//   ComponentName comp = new ComponentName("com.android.settings","com.android.settings.permission.single_app_activity");//此處可跳轉到指定app對應的權限管理頁面，但是需要相關權限，未解決
            intent.setComponent(comp);
            context.startActivity(intent);
            e.printStackTrace();
            Log.e(TAG, Log.getStackTraceString(e));
        } catch (Exception e) {
            //拋出異常時提示信息
            Toast.makeText(context, "進入設置頁面失敗，請手動設置", Toast.LENGTH_LONG).show();
            Log.e(TAG, Log.getStackTraceString(e));
        }
    }
    /**
     * 華為檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int) method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e(TAG, "Below API 19 cannot invoke!");
        }
        return false;
    }
}

360跳轉去懸浮窗權限授予界面

public class QikuUtils {
    private static final String TAG = "QikuUtils";

    /**
     * 檢測 360 懸浮窗權限
     */
    public static boolean checkFloatWindowPermission(Context context) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            return checkOp(context, 24); //OP_SYSTEM_ALERT_WINDOW = 24;
        }
        return true;
    }
    /**
     * 360檢測權限
     */
    @TargetApi(Build.VERSION_CODES.KITKAT)
    private static boolean checkOp(Context context, int op) {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 19) {
            AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
            try {
                Class clazz = AppOpsManager.class;
                Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
                return AppOpsManager.MODE_ALLOWED == (int)method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
            } catch (Exception e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } else {
            Log.e("", "Below API 19 cannot invoke!");
        }
        return false;
    }

    /**
     * 去360權限申請頁面
     */
    public static void applyPermission(Context context) {
        Intent intent = new Intent();
        intent.setClassName("com.android.settings", "com.android.settings.Settings$OverlaySettingsActivity");
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        if (isIntentAvailable(intent, context)) {
            context.startActivity(intent);
        } else {
            intent.setClassName("com.qihoo360.mobilesafe", "com.qihoo360.mobilesafe.ui.index.AppEnterActivity");
            if (isIntentAvailable(intent, context)) {
                context.startActivity(intent);
            } else {
                Log.e(TAG, "can't open permission page with particular name, please use " +
                        "\"adb shell dumpsys activity\" command and tell me the name of the float window permission page");
            }
        }
    }

    private static boolean isIntentAvailable(Intent intent, Context context) {
        if (intent == null) {
            return false;
        }
        return context.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY).size() > 0;
    }
}

6.0之后版本

 private void commonROMPermissionApply(final Context context) {
        //這里也一樣，魅族系統需要單獨適配
        if (RomUtils.checkIsMeizuRom()) {
            meizuROMPermissionApply(context);
        } else {
            if (Build.VERSION.SDK_INT >= 23) {
                showConfirmDialog(context, new OnConfirmResult() {
                    @Override
                    public void confirmResult(boolean confirm) {
                        if (confirm) {
                            try {
                                Class clazz = Settings.class;
                                Field field = clazz.getDeclaredField("ACTION_MANAGE_OVERLAY_PERMISSION");
                                Intent intent = new Intent(field.get(null).toString());
                                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                                intent.setData(Uri.parse("package:" + context.getPackageName()));
                                context.startActivity(intent);
                            } catch (Exception e) {
                                Log.e(TAG, Log.getStackTraceString(e));
                            }
                        } else {
                            Log.d(TAG, "user manually refuse OVERLAY_PERMISSION");
                        }
                    }
                });
            }
        }
    }

以上的代碼都是用startActivity()方式打開，授權頁面。實際情況中我們需要改為startActivityForResult()方式打開，當回到應用中在onActivityResult()中再判斷是否權限已經授權，進而打開懸浮窗。
權限適配部分內容參考http://www.lxweimin.com/p/41c8b2c5c953
如果想繞過權限申請，請參考https://blog.csdn.net/u013651405/article/details/79350857
希望本篇文章對需要適配懸浮窗權限的伙計們有所幫助！！！