这篇博客主要介绍的是 Android 主流各种机型和各种版本的悬浮窗权限适配，但是由于碎片化的问题，所以在适配方面也无法做到完全的主流机型适配，这个需要大家的一起努力，这个博客的名字永远都是一个将来时，感兴趣或者找到其他机型适配方法的请留言告诉我，或者加群544645972一起交流一下，非常感谢~ 
　　相关权限请看我的另一篇博客：android permission权限与安全机制解析（下），或者关于权限的案例使用：android WindowManager解析与骗取QQ密码案例分析，还有录音和摄像头权限的适配：Android 录音和摄像头权限适配。 
　　转载请注明出处：http://blog.csdn.net/self_study/article/details/52859790。 
　　源码会实时更新在 gitHub 上，不会实时更新博客，所以想要看最新代码的同学，请直接去 github 页面查看 markdown。

悬浮窗适配

　　悬浮窗适配有两种方法：第一种是按照正规的流程，如果系统没有赋予 APP 弹出悬浮窗的权限，就先跳转到权限授权界面，等用户打开该权限之后，再去弹出悬浮窗，比如 QQ 等一些主流应用就是这么做得；第二种就是利用系统的漏洞，绕过权限的申请，简单粗暴，这种方法我不是特别建议，但是现在貌似有些应用就是这样，比如 UC 和有道词典，这样适配在大多数手机上都是 OK 的，但是在一些特殊的机型不行，比如某米的 miui8。

正常适配流程

　　在 4.4~5.1.1 版本之间，和 6.0~最新版本之间的适配方法是不一样的，之前的版本由于 google 并没有对这个权限进行单独处理，所以是各家手机厂商根据需要定制的，所以每个权限的授权界面都各不一样，适配起来难度较大，6.0 之后适配起来就相对简单很多了。

Android 4.4 ~ Android 5.1.1

　　由于判断权限的类 AppOpsManager 是 API19 版本添加，所以Android 4.4 之前的版本（不包括4.4）就不用去判断了，直接调用 WindowManager 的 addView 方法弹出即可，但是貌似有些特殊的手机厂商在 API19 版本之前就已经自定义了悬浮窗权限，如果有发现的，请联系我。 
　　众所周知，国产手机的种类实在是过于丰富，而且一个品牌的不同版本还有不一样的适配方法，比如某米（嫌弃脸），所以我在实际适配的过程中总结了几种通用的方法， 大家可以参考一下：

  • 直接百度一下，搜索关键词“小米手机悬浮窗适配”等；
  • 看看 QQ 或者其他的大公司 APP 是否已经适配，如果已经适配，跳转到相关权限授权页面之后，或者自己能够直接在设置里找到悬浮窗权限授权页面也是一个道理，使用 adb shell dumpsys activity 命令，找到相关的信息，如下图所示
    可以清楚看到授权 activity 页面的包名和 activity 名，而且可以清楚地知道跳转的 intent 是否带了 extra，如果没有 extra 就可以直接跳入，如果带上了 extra，百度一下该 activity 的名字，看能否找到有用信息，比如适配方案或者源码 APK 之类的；
  • 依旧利用上面的方法，找到 activity 的名字，然后 root 准备适配的手机，直接在相关目录 /system/app 下把源码 APK 拷贝出来，反编译，根据 activity 的名字找到相关代码，之后的事情就简单了；
  • 还有一个方法就是发动人力资源去找，看看已经适配该手机机型的 app 公司是否有自己认识的人，或者干脆点，直接找这个手机公司里面是否有自己认识的手机开发朋友，直接询问，方便快捷。

常规手机

　　由于 6.0 之前的版本常规手机并没有把悬浮窗权限单独拿出来，所以正常情况下是可以直接使用 WindowManager.addView 方法直接弹出悬浮窗。 
　　如何判断手机的机型，办法很多，在这里我就不贴代码了，一般情况下在 terminal 中执行 getprop 命令，然后在打印出来的信息中找到相关的机型信息即可，这里贴出国产几款常见机型的判断：

  1. /**
  2.  * 获取 emui 版本号
  3.  * @return
  4.  */
  5. public static double getEmuiVersion() {
  6.     try {
  7.         String emuiVersion = getSystemProperty("ro.build.version.emui");
  8.         String version = emuiVersion.substring(emuiVersion.indexOf("_") + );
  9.         return Double.parseDouble(version);
  10.     } catch (Exception e) {
  11.         e.printStackTrace();
  12.     }
  13.     return 4.0;
  14. }
  15.  
  16. /**
  17.  * 获取小米 rom 版本号，获取失败返回 -1
  18.  *
  19.  * @return miui rom version code, if fail , return -1
  20.  */
  21. public static int getMiuiVersion() {
  22.     String version = getSystemProperty("ro.miui.ui.version.name");
  23.     if (version != null) {
  24.         try {
  25.             return Integer.parseInt(version.substring());
  26.         } catch (Exception e) {
  27.             Log.e(TAG, "get miui version code error, version : " + version);
  28.         }
  29.     }
  30.     return -;
  31. }
  32.  
  33. public static String getSystemProperty(String propName) {
  34.     String line;
  35.     BufferedReader input = null;
  36.     try {
  37.         Process p = Runtime.getRuntime().exec("getprop " + propName);
  38.         input = new BufferedReader(new InputStreamReader(p.getInputStream()), );
  39.         line = input.readLine();
  40.         input.close();
  41.     } catch (IOException ex) {
  42.         Log.e(TAG, "Unable to read sysprop " + propName, ex);
  43.         return null;
  44.     } finally {
  45.         if (input != null) {
  46.             try {
  47.                 input.close();
  48.             } catch (IOException e) {
  49.                 Log.e(TAG, "Exception while closing InputStream", e);
  50.             }
  51.         }
  52.     }
  53.     return line;
  54. }
  55. public static boolean checkIsHuaweiRom() {
  56.     return Build.MANUFACTURER.contains("HUAWEI");
  57. }
  58.  
  59. /**
  60.  * check if is miui ROM
  61.  */
  62. public static boolean checkIsMiuiRom() {
  63.     return !TextUtils.isEmpty(getSystemProperty("ro.miui.ui.version.name"));
  64. }
  65.  
  66. public static boolean checkIsMeizuRom() {
  67.     //return Build.MANUFACTURER.contains("Meizu");
  68.     String meizuFlymeOSFlag  = getSystemProperty("ro.build.display.id");
  69.     if (TextUtils.isEmpty(meizuFlymeOSFlag)){
  70.         return false;
  71.     }else if (meizuFlymeOSFlag.contains("flyme") || meizuFlymeOSFlag.toLowerCase().contains("flyme")){
  72.         return  true;
  73.     }else {
  74.         return false;
  75.     }
  76. }
  77.  
  78. /**
  79.  * check if is 360 ROM
  80.  */
  81. public static boolean checkIs360Rom() {
  82.     return Build.MANUFACTURER.contains("QiKU");
  83. }

小米

　　首先需要适配的就应该是小米了，而且比较麻烦的事情是，miui 的每个版本适配方法都是不一样的，所以只能每个版本去单独适配，不过还好由于使用的人数多，网上的资料也比较全。首先第一步当然是判断是否赋予了悬浮窗权限，这个时候就需要使用到 AppOpsManager 这个类了，它里面有一个 checkop 方法：

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

找到悬浮窗权限的 op 值是：

  1. /** @hide */
  2. public static final int OP_SYSTEM_ALERT_WINDOW = ;

注意到这个函数和这个值其实都是 hide 的，所以没办法，你懂的，只能用反射：

  1. /**
  2.  * 检测 miui 悬浮窗权限
  3.  */
  4. public static boolean checkFloatWindowPermission(Context context) {
  5.     final int version = Build.VERSION.SDK_INT;
  6.  
  7.     if (version >= ) {
  8.         return checkOp(context, ); //OP_SYSTEM_ALERT_WINDOW = 24;
  9.     } else {
  10. //            if ((context.getApplicationInfo().flags & 1 << 27) == 1) {
  11. //                return true;
  12. //            } else {
  13. //                return false;
  14. //            }
  15.         return true;
  16.     }
  17. }
  18.  
  19. @TargetApi(Build.VERSION_CODES.KITKAT)
  20. private static boolean checkOp(Context context, int op) {
  21.     final int version = Build.VERSION.SDK_INT;
  22.     if (version >= ) {
  23.         AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
  24.         try {
  25.             Class clazz = AppOpsManager.class;
  26.             Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
  27.             return AppOpsManager.MODE_ALLOWED == (int)method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
  28.         } catch (Exception e) {
  29.             Log.e(TAG, Log.getStackTraceString(e));
  30.         }
  31.     } else {
  32.         Log.e(TAG, "Below API 19 cannot invoke!");
  33.     }
  34.     return false;
  35. }

检测完成之后就是跳转到授权页面去开启权限了，但是由于 miui 不同版本的权限授权页面不一样，所以需要根据不同版本进行不同处理：

  1. /**
  2.  * 获取小米 rom 版本号，获取失败返回 -1
  3.  *
  4.  * @return miui rom version code, if fail , return -1
  5.  */
  6. public static int getMiuiVersion() {
  7.     String version = RomUtils.getSystemProperty("ro.miui.ui.version.name");
  8.     if (version != null) {
  9.         try {
  10.             return Integer.parseInt(version.substring());
  11.         } catch (Exception e) {
  12.             Log.e(TAG, "get miui version code error, version : " + version);
  13.             Log.e(TAG, Log.getStackTraceString(e));
  14.         }
  15.     }
  16.     return -;
  17. }
  18.  
  19. /**
  20.  * 小米 ROM 权限申请
  21.  */
  22. public static void applyMiuiPermission(Context context) {
  23.     int versionCode = getMiuiVersion();
  24.     if (versionCode == ) {
  25.         goToMiuiPermissionActivity_V5(context);
  26.     } else if (versionCode == ) {
  27.         goToMiuiPermissionActivity_V6(context);
  28.     } else if (versionCode == ) {
  29.         goToMiuiPermissionActivity_V7(context);
  30.     } else if (versionCode == ) {
  31.             goToMiuiPermissionActivity_V8(context);
  32.     } else {
  33.         Log.e(TAG, "this is a special MIUI rom version, its version code " + versionCode);
  34.     }
  35. }
  36.  
  37. private static boolean isIntentAvailable(Intent intent, Context context) {
  38.     if (intent == null) {
  39.         return false;
  40.     }
  41.     return context.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY).size() > ;
  42. }
  43.  
  44. /**
  45.  * 小米 V5 版本 ROM权限申请
  46.  */
  47. public static void goToMiuiPermissionActivity_V5(Context context) {
  48.     Intent intent = null;
  49.     String packageName = context.getPackageName();
  50.     intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
  51.     Uri uri = Uri.fromParts("package" , packageName, null);
  52.     intent.setData(uri);
  53.     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  54.     if (isIntentAvailable(intent, context)) {
  55.         context.startActivity(intent);
  56.     } else {
  57.         Log.e(TAG, "intent is not available!");
  58.     }
  59.  
  60.     //设置页面在应用详情页面
  61. //        Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
  62. //        PackageInfo pInfo = null;
  63. //        try {
  64. //            pInfo = context.getPackageManager().getPackageInfo
  65. //                    (HostInterfaceManager.getHostInterface().getApp().getPackageName(), 0);
  66. //        } catch (PackageManager.NameNotFoundException e) {
  67. //            AVLogUtils.e(TAG, e.getMessage());
  68. //        }
  69. //        intent.setClassName("com.android.settings", "com.miui.securitycenter.permission.AppPermissionsEditor");
  70. //        intent.putExtra("extra_package_uid", pInfo.applicationInfo.uid);
  71. //        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  72. //        if (isIntentAvailable(intent, context)) {
  73. //            context.startActivity(intent);
  74. //        } else {
  75. //            AVLogUtils.e(TAG, "Intent is not available!");
  76. //        }
  77. }
  78.  
  79. /**
  80.  * 小米 V6 版本 ROM权限申请
  81.  */
  82. public static void goToMiuiPermissionActivity_V6(Context context) {
  83.     Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
  84.     intent.setClassName("com.miui.securitycenter", "com.miui.permcenter.permissions.AppPermissionsEditorActivity");
  85.     intent.putExtra("extra_pkgname", context.getPackageName());
  86.     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  87.  
  88.     if (isIntentAvailable(intent, context)) {
  89.         context.startActivity(intent);
  90.     } else {
  91.         Log.e(TAG, "Intent is not available!");
  92.     }
  93. }
  94.  
  95. /**
  96.  * 小米 V7 版本 ROM权限申请
  97.  */
  98. public static void goToMiuiPermissionActivity_V7(Context context) {
  99.     Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
  100.     intent.setClassName("com.miui.securitycenter", "com.miui.permcenter.permissions.AppPermissionsEditorActivity");
  101.     intent.putExtra("extra_pkgname", context.getPackageName());
  102.     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  103.  
  104.     if (isIntentAvailable(intent, context)) {
  105.         context.startActivity(intent);
  106.     } else {
  107.         Log.e(TAG, "Intent is not available!");
  108.     }
  109. }
  110.  
  111. /**
  112.  * 小米 V8 版本 ROM权限申请
  113.  */
  114. public static void goToMiuiPermissionActivity_V8(Context context) {
  115.     Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
  116.     intent.setClassName("com.miui.securitycenter", "com.miui.permcenter.permissions.PermissionsEditorActivity");
  117.     intent.putExtra("extra_pkgname", context.getPackageName());
  118.     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  119.  
  120.     if (isIntentAvailable(intent, context)) {
  121.         context.startActivity(intent);
  122.     } else {
  123.         Log.e(TAG, "Intent is not available!");
  124.     }
  125. }

getSystemProperty 方法是直接调用 getprop 方法来获取系统信息：

  1. public static String getSystemProperty(String propName) {
  2.     String line;
  3.     BufferedReader input = null;
  4.     try {
  5.         Process p = Runtime.getRuntime().exec("getprop " + propName);
  6.         input = new BufferedReader(new InputStreamReader(p.getInputStream()), );
  7.         line = input.readLine();
  8.         input.close();
  9.     } catch (IOException ex) {
  10.         Log.e(TAG, "Unable to read sysprop " + propName, ex);
  11.         return null;
  12.     } finally {
  13.         if (input != null) {
  14.             try {
  15.                 input.close();
  16.             } catch (IOException e) {
  17.                 Log.e(TAG, "Exception while closing InputStream", e);
  18.             }
  19.         }
  20.     }
  21.     return line;
  22. }

最新的 V8 版本有些机型已经是 6.0 ，所以就是下面介绍到 6.0 的适配方法了，感谢 @pinocchio2mx 的反馈，有些机型的 miui8 版本还是5.1.1，所以 miui8 依旧需要做适配，非常感谢，希望大家一起多多反馈问题，谢谢~~。

魅族

　　魅族的适配，由于我司魅族的机器相对较少，所以只适配了 flyme5.1.1/android 5.1.1 版本 mx4 pro 的系统。和小米一样，首先也要通过 API19 版本添加的 AppOpsManager 类判断是否授予了权限：

  1. /**
  2.  * 检测 meizu 悬浮窗权限
  3.  */
  4. public static boolean checkFloatWindowPermission(Context context) {
  5.     final int version = Build.VERSION.SDK_INT;
  6.     if (version >= ) {
  7.         return checkOp(context, ); //OP_SYSTEM_ALERT_WINDOW = 24;
  8.     }
  9.     return true;
  10. }
  11.  
  12. @TargetApi(Build.VERSION_CODES.KITKAT)
  13. private static boolean checkOp(Context context, int op) {
  14.     final int version = Build.VERSION.SDK_INT;
  15.     if (version >= ) {
  16.         AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
  17.         try {
  18.             Class clazz = AppOpsManager.class;
  19.             Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
  20.             return AppOpsManager.MODE_ALLOWED == (int)method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
  21.         } catch (Exception e) {
  22.             Log.e(TAG, Log.getStackTraceString(e));
  23.         }
  24.     } else {
  25.         Log.e(TAG, "Below API 19 cannot invoke!");
  26.     }
  27.     return false;
  28. }

然后是跳转去悬浮窗权限授予界面：

  1. /**
  2.  * 去魅族权限申请页面
  3.  */
  4. public static void applyPermission(Context context){
  5.     Intent intent = new Intent("com.meizu.safe.security.SHOW_APPSEC");
  6.     intent.setClassName("com.meizu.safe", "com.meizu.safe.security.AppSecActivity");
  7.     intent.putExtra("packageName", context.getPackageName());
  8.     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  9.     context.startActivity(intent);
  10. }

如果有魅族其他版本的适配方案，请联系我。

华为

　　华为的适配是根据网上找的方案，外加自己的一些优化而成，但是由于华为手机的众多机型，所以覆盖的机型和系统版本还不是那么全面，如果有其他机型和版本的适配方案，请联系我，我更新到 github 上。和小米，魅族一样，首先通过 AppOpsManager 来判断权限是否已经授权：

  1. /**
  2.  * 检测 Huawei 悬浮窗权限
  3.  */
  4. public static boolean checkFloatWindowPermission(Context context) {
  5.     final int version = Build.VERSION.SDK_INT;
  6.     if (version >= ) {
  7.         return checkOp(context, ); //OP_SYSTEM_ALERT_WINDOW = 24;
  8.     }
  9.     return true;
  10. }
  11.  
  12. @TargetApi(Build.VERSION_CODES.KITKAT)
  13. private static boolean checkOp(Context context, int op) {
  14.     final int version = Build.VERSION.SDK_INT;
  15.     if (version >= ) {
  16.         AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
  17.         try {
  18.             Class clazz = AppOpsManager.class;
  19.             Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
  20.             return AppOpsManager.MODE_ALLOWED == (int) method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
  21.         } catch (Exception e) {
  22.             Log.e(TAG, Log.getStackTraceString(e));
  23.         }
  24.     } else {
  25.         Log.e(TAG, "Below API 19 cannot invoke!");
  26.     }
  27.     return false;
  28. }

然后根据不同的机型和版本跳转到不同的页面：

  1. /**
  2.  * 去华为权限申请页面
  3.  */
  4. public static void applyPermission(Context context) {
  5.     try {
  6.         Intent intent = new Intent();
  7.         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  8. //   ComponentName comp = new ComponentName("com.huawei.systemmanager","com.huawei.permissionmanager.ui.MainActivity");//华为权限管理
  9. //   ComponentName comp = new ComponentName("com.huawei.systemmanager",
  10. //      "com.huawei.permissionmanager.ui.SingleAppActivity");//华为权限管理，跳转到指定app的权限管理位置需要华为接口权限，未解决
  11.         ComponentName comp = new ComponentName("com.huawei.systemmanager", "com.huawei.systemmanager.addviewmonitor.AddViewMonitorActivity");//悬浮窗管理页面
  12.         intent.setComponent(comp);
  13.         if (RomUtils.getEmuiVersion() == 3.1) {
  14.             //emui 3.1 的适配
  15.             context.startActivity(intent);
  16.         } else {
  17.             //emui 3.0 的适配
  18.             comp = new ComponentName("com.huawei.systemmanager", "com.huawei.notificationmanager.ui.NotificationManagmentActivity");//悬浮窗管理页面
  19.             intent.setComponent(comp);
  20.             context.startActivity(intent);
  21.         }
  22.     } catch (SecurityException e) {
  23.         Intent intent = new Intent();
  24.         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  25. //   ComponentName comp = new ComponentName("com.huawei.systemmanager","com.huawei.permissionmanager.ui.MainActivity");//华为权限管理
  26.         ComponentName comp = new ComponentName("com.huawei.systemmanager",
  27.                 "com.huawei.permissionmanager.ui.MainActivity");//华为权限管理，跳转到本app的权限管理页面,这个需要华为接口权限，未解决
  28. //      ComponentName comp = new ComponentName("com.huawei.systemmanager","com.huawei.systemmanager.addviewmonitor.AddViewMonitorActivity");//悬浮窗管理页面
  29.         intent.setComponent(comp);
  30.         context.startActivity(intent);
  31.         Log.e(TAG, Log.getStackTraceString(e));
  32.     } catch (ActivityNotFoundException e) {
  33.         /**
  34.          * 手机管家版本较低 HUAWEI SC-UL10
  35.          */
  36. //   Toast.makeText(MainActivity.this, "act找不到", Toast.LENGTH_LONG).show();
  37.         Intent intent = new Intent();
  38.         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  39.         ComponentName comp = new ComponentName("com.Android.settings", "com.android.settings.permission.TabItem");//权限管理页面 android4.4
  40. //   ComponentName comp = new ComponentName("com.android.settings","com.android.settings.permission.single_app_activity");//此处可跳转到指定app对应的权限管理页面，但是需要相关权限，未解决
  41.         intent.setComponent(comp);
  42.         context.startActivity(intent);
  43.         e.printStackTrace();
  44.         Log.e(TAG, Log.getStackTraceString(e));
  45.     } catch (Exception e) {
  46.         //抛出异常时提示信息
  47.         Toast.makeText(context, "进入设置页面失败，请手动设置", Toast.LENGTH_LONG).show();
  48.         Log.e(TAG, Log.getStackTraceString(e));
  49.     }
  50. }

emui4 之后就是 6.0 版本了，按照下面介绍的 6.0 适配方案即可。

360

　　360手机的适配方案在网上可以找到的资料很少，唯一可以找到的就是这篇：奇酷360 手机中怎么跳转安全中心中指定包名App的权限管理页面，但是博客中也没有给出最后的适配方案，不过最后居然直接用最简单的办法就能跳进去了，首先是权限的检测：

  1. /**
  2.  * 检测 360 悬浮窗权限
  3.  */
  4. public static boolean checkFloatWindowPermission(Context context) {
  5.     final int version = Build.VERSION.SDK_INT;
  6.     if (version >= ) {
  7.         return checkOp(context, ); //OP_SYSTEM_ALERT_WINDOW = 24;
  8.     }
  9.     return true;
  10. }
  11.  
  12. @TargetApi(Build.VERSION_CODES.KITKAT)
  13. private static boolean checkOp(Context context, int op) {
  14.     final int version = Build.VERSION.SDK_INT;
  15.     if (version >= ) {
  16.         AppOpsManager manager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
  17.         try {
  18.             Class clazz = AppOpsManager.class;
  19.             Method method = clazz.getDeclaredMethod("checkOp", int.class, int.class, String.class);
  20.             return AppOpsManager.MODE_ALLOWED == (int)method.invoke(manager, op, Binder.getCallingUid(), context.getPackageName());
  21.         } catch (Exception e) {
  22.             Log.e(TAG, Log.getStackTraceString(e));
  23.         }
  24.     } else {
  25.         Log.e("", "Below API 19 cannot invoke!");
  26.     }
  27.     return false;
  28. }

如果没有授予悬浮窗权限，就跳转去权限授予界面：

  1. public static void applyPermission(Context context) {
  2.     Intent intent = new Intent();
  3.     intent.setClassName("com.android.settings", "com.android.settings.Settings$OverlaySettingsActivity");
  4.     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  5.     context.startActivity(intent);
  6. }

哈哈哈，是不是很简单，有时候真相往往一点也不复杂，OK，适配完成。

Android 6.0 及之后版本

　　我在博客android permission权限与安全机制解析（下）- SYSTEM_ALERT_WINDOW中已经介绍到了适配方案，悬浮窗权限在 6.0 之后就被 google 单独拿出来管理了，好处就是对我们来说适配就非常方便了，在所有手机和 6.0 以及之后的版本上适配的方法都是一样的，首先要在 Manifest 中静态申请<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />权限，然后在使用时先判断该权限是否已经被授权，如果没有授权使用下面这段代码进行动态申请：

  1. private static final int REQUEST_CODE = ;
  2.  
  3. //判断权限
  4. private boolean commonROMPermissionCheck(Context context) {
  5.     Boolean result = true;
  6.     if (Build.VERSION.SDK_INT >= ) {
  7.         try {
  8.             Class clazz = Settings.class;
  9.             Method canDrawOverlays = clazz.getDeclaredMethod("canDrawOverlays", Context.class);
  10.             result = (Boolean) canDrawOverlays.invoke(null, context);
  11.         } catch (Exception e) {
  12.             Log.e(TAG, Log.getStackTraceString(e));
  13.         }
  14.     }
  15.     return result;
  16. }
  17.  
  18. //申请权限
  19. private void requestAlertWindowPermission() {
  20.     Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
  21.     intent.setData(Uri.parse("package:" + getPackageName()));
  22.     startActivityForResult(intent, REQUEST_CODE);
  23. }
  24.  
  25. @Override
  26. //处理回调
  27. protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  28.     super.onActivityResult(requestCode, resultCode, data);
  29.     if (requestCode == REQUEST_CODE) {
  30.         if (Settings.canDrawOverlays(this)) {
  31.             Log.i(LOGTAG, "onActivityResult granted");
  32.         }
  33.     }
  34. }

上述代码需要注意的是：

  • 使用Action Settings.ACTION_MANAGE_OVERLAY_PERMISSION 启动隐式Intent；
  • 使用 “package:” + getPackageName() 携带App的包名信息；
  • 使用 Settings.canDrawOverlays 方法判断授权结果。

在用户开启相关权限之后才能使用 WindowManager.LayoutParams.TYPE_SYSTEM_ERROR ,要不然是会直接崩溃的哦。

特殊适配流程

　　如何绕过系统的权限检查，直接弹出悬浮窗？android WindowManager解析与骗取QQ密码案例分析这篇博客中我已经指明出来了，需要使用mParams.type = WindowManager.LayoutParams.TYPE_TOAST; 来取代 mParams.type = WindowManager.LayoutParams.TYPE_SYSTEM_ERROR;，这样就可以达到不申请权限，而直接弹出悬浮窗，至于原因嘛，我们看看 PhoneWindowManager 源码的关键处：

  1. @Override
  2. public int checkAddPermission(WindowManager.LayoutParams attrs, int[] outAppOp) {
  3.     ....
  4.     switch (type) {
  5.         case TYPE_TOAST:
  6.             // XXX right now the app process has complete control over
  7.             // this...  should introduce a token to let the system
  8.             // monitor/control what they are doing.
  9.             outAppOp[] = AppOpsManager.OP_TOAST_WINDOW;
  10.             break;
  11.         case TYPE_DREAM:
  12.         case TYPE_INPUT_METHOD:
  13.         case TYPE_WALLPAPER:
  14.         case TYPE_PRIVATE_PRESENTATION:
  15.         case TYPE_VOICE_INTERACTION:
  16.         case TYPE_ACCESSIBILITY_OVERLAY:
  17.             // The window manager will check these.
  18.             break;
  19.         case TYPE_PHONE:
  20.         case TYPE_PRIORITY_PHONE:
  21.         case TYPE_SYSTEM_ALERT:
  22.         case TYPE_SYSTEM_ERROR:
  23.         case TYPE_SYSTEM_OVERLAY:
  24.             permission = android.Manifest.permission.SYSTEM_ALERT_WINDOW;
  25.             outAppOp[] = AppOpsManager.OP_SYSTEM_ALERT_WINDOW;
  26.             break;
  27.         default:
  28.             permission = android.Manifest.permission.INTERNAL_SYSTEM_WINDOW;
  29.     }
  30.     if (permission != null) {
  31.         if (permission == android.Manifest.permission.SYSTEM_ALERT_WINDOW) {
  32.             final int callingUid = Binder.getCallingUid();
  33.             // system processes will be automatically allowed privilege to draw
  34.             if (callingUid == Process.SYSTEM_UID) {
  35.                 return WindowManagerGlobal.ADD_OKAY;
  36.             }
  37.  
  38.             // check if user has enabled this operation. SecurityException will be thrown if
  39.             // this app has not been allowed by the user
  40.             final int mode = mAppOpsManager.checkOp(outAppOp[], callingUid,
  41.                     attrs.packageName);
  42.             switch (mode) {
  43.                 case AppOpsManager.MODE_ALLOWED:
  44.                 case AppOpsManager.MODE_IGNORED:
  45.                     // although we return ADD_OKAY for MODE_IGNORED, the added window will
  46.                     // actually be hidden in WindowManagerService
  47.                     return WindowManagerGlobal.ADD_OKAY;
  48.                 case AppOpsManager.MODE_ERRORED:
  49.                     return WindowManagerGlobal.ADD_PERMISSION_DENIED;
  50.                 default:
  51.                     // in the default mode, we will make a decision here based on
  52.                     // checkCallingPermission()
  53.                     if (mContext.checkCallingPermission(permission) !=
  54.                             PackageManager.PERMISSION_GRANTED) {
  55.                         return WindowManagerGlobal.ADD_PERMISSION_DENIED;
  56.                     } else {
  57.                         return WindowManagerGlobal.ADD_OKAY;
  58.                     }
  59.             }
  60.         }
  61.  
  62.         if (mContext.checkCallingOrSelfPermission(permission)
  63.                 != PackageManager.PERMISSION_GRANTED) {
  64.             return WindowManagerGlobal.ADD_PERMISSION_DENIED;
  65.         }
  66.     }
  67.     return WindowManagerGlobal.ADD_OKAY;
  68. }

从源码中可以看到，其实 TYPE_TOAST 没有做权限检查，直接返回了 WindowManagerGlobal.ADD_OKAY，所以呢，这就是为什么可以绕过权限的原因。还有需要注意的一点是 addView 方法中会调用到 mPolicy.adjustWindowParamsLw(win.mAttrs);，这个方法在不同的版本有不同的实现：

  1. //Android 2.0 - 2.3.7 PhoneWindowManager
  2. public void adjustWindowParamsLw(WindowManager.LayoutParams attrs) {
  3.     switch (attrs.type) {
  4.         case TYPE_SYSTEM_OVERLAY:
  5.         case TYPE_SECURE_SYSTEM_OVERLAY:
  6.         case TYPE_TOAST:
  7.             // These types of windows can't receive input events.
  8.             attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
  9.                     | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
  10.             break;
  11.     }
  12. }
  13.  
  14. //Android 4.0.1 - 4.3.1 PhoneWindowManager
  15. public void adjustWindowParamsLw(WindowManager.LayoutParams attrs) {
  16.     switch (attrs.type) {
  17.         case TYPE_SYSTEM_OVERLAY:
  18.         case TYPE_SECURE_SYSTEM_OVERLAY:
  19.         case TYPE_TOAST:
  20.             // These types of windows can't receive input events.
  21.             attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
  22.                     | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
  23.             attrs.flags &= ~WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
  24.             break;
  25.     }
  26. }
  27.  
  28. //Android 4.4 PhoneWindowManager
  29. @Override
  30. public void adjustWindowParamsLw(WindowManager.LayoutParams attrs) {
  31.     switch (attrs.type) {
  32.         case TYPE_SYSTEM_OVERLAY:
  33.         case TYPE_SECURE_SYSTEM_OVERLAY:
  34.             // These types of windows can't receive input events.
  35.             attrs.flags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
  36.                     | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
  37.             attrs.flags &= ~WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
  38.             break;
  39.     }
  40. }

可以看到，在4.0.1以前， 当我们使用 TYPE_TOAST， Android 会偷偷给我们加上 FLAG_NOT_FOCUSABLE 和 FLAG_NOT_TOUCHABLE，4.0.1 开始，会额外再去掉FLAG_WATCH_OUTSIDE_TOUCH，这样真的是什么事件都没了。而 4.4 开始，TYPE_TOAST 被移除了, 所以从 4.4 开始，使用 TYPE_TOAST 的同时还可以接收触摸事件和按键事件了，而4.4以前只能显示出来，不能交互，所以 API18 及以下使用 TYPE_TOAST 是无法接收触摸事件的，但是幸运的是除了 miui 之外，这些版本可以直接在 Manifest 文件中声明 android.permission.SYSTEM_ALERT_WINDOW权限，然后直接使用 WindowManager.LayoutParams.TYPE_PHONE 或者 WindowManager.LayoutParams.TYPE_SYSTEM_ALERT 都是可以直接弹出悬浮窗的。 
　　还有一个需要提到的是 TYPE_APPLICATION，这个 type 是配合 Activity 在当前 APP 内部使用的，也就是说，回到 Launcher 界面，这个悬浮窗是会消失的。 
　　虽然这种方法确确实实可以绕过权限，至于适配的坑呢，有人遇到之后可以联系我，我会持续完善。不过由于这样可以不申请权限就弹出悬浮窗，而且在最新的 6.0+ 系统上也没有修复，所以如果这个漏洞被滥用，就会造成一些意想不到的后果，因此我个人倾向于使用 QQ 的适配方案，也就是上面的正常适配流程去处理这个权限。

更新：7.1.1之后版本

　　最新发现在 7.1.1 版本之后使用 type_toast 重复添加两次悬浮窗，第二次会崩溃，跑出来下面的错误：

  1. E/AndroidRuntime: FATAL EXCEPTION: main
  2.      android.view.WindowManager$BadTokenException: Unable to add window -- window android.view.ViewRootImpl$W@d7a4e96 has already been added
  3.          at android.view.ViewRootImpl.setView(ViewRootImpl.java:)
  4.          at android.view.WindowManagerGlobal.addView(WindowManagerGlobal.java:)
  5.          at android.view.WindowManagerImpl.addView(WindowManagerImpl.java:)
  6.          at com.tencent.ysdk.module.icon.impl.a.g(Unknown Source)
  7.          at com.tencent.ysdk.module.icon.impl.floatingviews.q.onAnimationEnd(Unknown Source)
  8.          at android.view.animation.Animation$.run(Animation.java:)
  9.          at android.os.Handler.handleCallback(Handler.java:)
  10.          at android.os.Handler.dispatchMessage(Handler.java:)
  11.          at android.os.Looper.loop(Looper.java:)
  12.          at android.app.ActivityThread.main(ActivityThread.java:)
  13.          at java.lang.reflect.Method.invoke(Native Method)
  14.          at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:)
  15.          at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:)

去追溯源码，发现是这里抛出来的错误：

  1. try {
  2.     mOrigWindowType = mWindowAttributes.type;
  3.     mAttachInfo.mRecomputeGlobalAttributes = true;
  4.     collectViewAttributes();
  5.     res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
  6.             getHostVisibility(), mDisplay.getDisplayId(),
  7.             mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
  8.             mAttachInfo.mOutsets, mInputChannel);
  9. } catch (RemoteException e) {
  10.    .....
  11. } finally {
  12.     if (restore) {
  13.         attrs.restore();
  14.     }
  15. }
  16. .....
  17. if (res < WindowManagerGlobal.ADD_OKAY) {
  18.     .....
  19.     switch (res) {
  20.         ....
  21.         case WindowManagerGlobal.ADD_DUPLICATE_ADD:
  22.             throw new WindowManager.BadTokenException(
  23.                     "Unable to add window -- window " + mWindow
  24.                     + " has already been added");
  25.     }
  26. }

然后去查看抛出这个异常处的代码：

  1. if (mWindowMap.containsKey(client.asBinder())) {
  2.     Slog.w(TAG_WM, "Window " + client + " is already added");
  3.     return WindowManagerGlobal.ADD_DUPLICATE_ADD;
  4. }

然后我们从 mWindowMap 这个变量出发去分析，但是最后发现，根本不行，这些代码从 5.X 版本就存在了，而且每次调用 addview 方法去添加一个 view 的时候，都是一个新的 client 对象，所以 mWindowMap.containsKey(client.asBinder()) 一直是不成立的，所以无法从这里去分析，于是继续分析在 7.0 版本是没有问题的，但是在 7.1.1 版本就出现问题了，所以我们去查看 7.1.1 版本代码的变更：https://android.googlesource.com/platform/frameworks/base/+log/master/services/core/java/com/android/server/wm/WindowManagerService.java?s=28f0e5bf48e2d02e1f063670e435b1232f07ba03 
我们从里面寻找关于 type_toast 的相关变更： 

最终定位到了 aa07653 那个提交，我们看看这次提交修改的内容： 
 
然后点开 WMS 的修改： 

去到 canAddToastWindowForUid： 
 
我们于是定位到了关键 7.1.1 上面不能重复添加 type_toast 类型 window 的原因！！ 
　　另外还有一点需要注意的是，在 7.1.1 上面还增加了如下的代码： 
　　
　　
可以看到在 25 版本之后，注意是之后，也就是 8.0，系统将会限制 type_toast 的使用，会直接抛出异常，这也是需要注意的地方。

最新适配结果

　　非常感谢ruanqin0706同学的大力帮忙，通过优测网的机型的测试适配，现在统计结果如下所示：

6.0/6.0+

　　更新，6.0魅族的适配方案不能使用google API，依旧要使用 6.0 之前的适配方法，已经适配完成～ 
　　6.0 上绝大部分的机型都是可以的，除了魅族这种奇葩机型：

机型 版本 详细信息 适配完成 具体表现
魅族 PRO6 6.0 型号：PRO6；版本：6.0；分辨率：1920*1080 否 检测权限结果有误，微信可正常缩小放大，而我方检测为未开启权限，为跳转至开启权限页
魅族 U20 6.0 型号：U20；版本：6.0；分辨率：1920*1080 否 检测权限结果有误，微信可正常缩小放大，而我方检测为未开启权限，为跳转至开启权限页

结论：

汇总结果
Android6.0 及以上机型覆盖：58款，其中：
三星：10款，均正常
华为：21款，均正常
小米：5款，均正常
魅族：2款，异常（1.检测权限未开启，点击 Android 6.0 及以上跳转，无法跳转，却可以选择魅族手机设置，设置后，悬浮窗打开缩小正常；2.在魅族上，及时设置悬浮窗关闭，微信也可正常缩小，但是我们检测的悬浮窗是否开发结果，和实际系统的设置是匹配的。）
其他：20款，均正常

已适配完成，针对魅族的手机，在 6.0 之后仍然使用老的跳转方式，而不是使用新版本的 Google API 进行跳转。

huawei

　　这里是华为手机的测试结果：

机型 版本 适配完成 具体表现 默认设置
华为荣耀x2 5.0 否 跳转至通知中心页面，而非悬浮窗管理处 默认关闭
华为畅玩4x（电信版） 4.4.4 可以优化 跳转至通知中心标签页面，用户需切换标签页（通知中心、悬浮窗为两个不同标签页） 默认关闭
华为 p8 lite 4.4.4 可以优化 跳转至通知中心标签页面，用户需切换标签页（通知中心、悬浮窗为两个不同标签页） 默认关闭
华为荣耀 6 移动版 4.4.2 可以优化 跳转至通知中心标签页面，用户需切换标签页（通知中心、悬浮窗为两个不同标签页） 默认关闭
华为荣耀 3c 电信版 4.3 是 跳转至通知中心，但默认是开启悬浮窗的 默认关闭
华为 G520 4.1.2 否 直接点击华为跳转设置页按钮，闪退 默认开启

结论：

汇总结果 完全兼容机型数量 次兼容机型数量 总测试机型数 兼容成功率
华为6.0以下机型覆盖：18款，其中：
5.0.1以上：11款，均默认开启，且跳转设置页面正确；5.0：1款，处理异常
（默认未开启悬浮窗权限，且点击跳转至通知栏，非悬浮窗设置入口）
4.4.4、4.4.2：3款，处理可接受
（默认未开启悬浮窗权限，点击跳转至通知中心的“通知栏”标签页，可手动切换至“悬浮窗”标签页设置）
4.3：1款，处理可接受
（默认开启，但点击华为跳转设置页，跳转至通知中心，无悬浮窗设置处）
4.2.2：1款，默认开启，处理正常
4.1.2：1款，处理有瑕疵
（默认开启，但若直接点击华为跳转按钮，出现闪退）		 12 5 18 94.44%

正在适配中…

xiaomi

　　大部分的小米机型都是可以成功适配，除了某些奇怪的机型：

机型 版本 适配完成 具体表现
小米 MI 4S 5.1.1 否 无悬浮窗权限，点击小米手机授权页跳转按钮，无反应
小米 红米NOTE 1S 4.4.4 未执行 未修改开启悬浮窗成功，真机平台不支持（为权限与之前系统有别）
小米 红米1(联通版) 4.2.2 未执行 未安装成功

结论：

汇总结果 完全兼容机型数量 次兼容机型数量 总测试机型数 兼容成功率
小米6.0以下机型覆盖：10款，其中：
5.1.1 小米 MI 4S：1款，兼容失败
（默认未开启，点击小米手机授权按钮，无跳转）
其他：9款，均成功		 9 0 10 90%

samsung

　　几乎 100% 的机型都是配完美，结论：

汇总结果 完全兼容机型数量 次兼容机型数量 总测试机型数 兼容成功率
三星6.0以下机型覆盖：28款，全部检测处理成功
（默认均开启悬浮窗权限）		 28 0 28 100%

oppo&&vivo

　　蓝绿大厂的机器，只测试了几款机型，都是OK的：

机型 版本 适配完成 是否默认开启
OPPO R7sm 5.1.1 是 默认开启
OPPO R7 Plus 5.0 是 默认开启
OPPO R7 Plus(全网通) 5.1.1 是 默认开启
OPPO A37m 5.1 未执行 默认未开启，且无法设置开启（平台真机限制修改权限导致）
OPPO A59m 5.1.1 是 默认开启

结论：

汇总结果
抽查3款，2个系统版本，均兼容，100%

others

　　其他的机型，HTC 和 Sony 大法之类的机器，随机抽取了几款，也都是 OK 的：

机型 是否正常
蓝魔 R3 是
HTC A9 是
摩托罗拉 Nexus 6 是
VIVO V3Max A 是
金立 M5 是
HTC One E8 是
努比亚 Z11 Max 是
Sony Xperia Z3+ Dual 是
酷派 大神Note3 是
三星 GALAXY J3 Pro（双4G） 是
三星 Note 5 是
中兴 威武3 是
中兴 Axon Mini 是

结论

汇总结果
随机抽查看13款，全部测试正常，100%

源码下载

　　https://github.com/zhaozepeng/FloatWindowPermission

引用

http://www.jianshu.com/p/167fd5f47d5c 
http://www.liaohuqiu.net/cn/posts/android-windows-manager/ 
http://blog.csdn.net/mzm489321926/article/details/50542065 
http://www.jianshu.com/p/634cd056b90c

版权声明：转载请标明出处http://blog.csdn.net/self_study，对技术感兴趣的同鞋加群544645972一起交流 https://blog.csdn.net/zhao_zepeng/article/details/52859790

Android 悬浮窗权限各机型各系统适配大全的更多相关文章

  1. Android 悬浮窗权限校验

    原文:Android 悬浮窗权限校验 悬浮窗权限: <uses-permission android:name="android.permission.SYSTEM_ALERT_WIN ...

  2. Android 关于悬浮窗权限的问题

    正常情况下的处理: dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT)以及在清单文件中添加 <use ...

  3. Android浮窗权限研究（转载）

    这篇博客主要介绍的是 Android 主流各种机型和各种版本的悬浮窗权限适配,但是由于碎片化的问题,所以在适配方面也无法做到完全的主流机型适配,这个需要大家的一起努力,这个博客的名字永远都是一个将来时 ...

  4. Android悬浮窗及其拖动事件

    主页面布局很简单,只有一个RelativelyLayout <?xml version="1.0" encoding="utf-8"?> <R ...

  5. Android 悬浮窗 System Alert Window

    悬浮窗能显示在其他应用上方.桌面系统例如Windows,macOS,Ubuntu,打开的程序能以窗口形式显示在屏幕上. 受限于屏幕大小,安卓系统中主要使用多任务切换的方式和分屏的方式.视频播放,视频对 ...

  6. Android悬浮窗实现 使用WindowManager

    Android悬浮窗实现 使用WindowManager WindowManager介绍 通过Context.getSystemService(Context.WINDOW_SERVICE)可以获得  ...

  7. Android 悬浮窗、悬浮球开发

    原文:Android 悬浮窗.悬浮球开发 1.权限管理 直接看我另外一篇博客吧,传送门: https://my.oschina.net/u/1462828/blog/1933162 2.Base类Ba ...

  8. 关于MIUI悬浮窗权限问题的解决方案

    先扯会....好久没写Blog了....这段时间有点小忙...瞎忙.....忙的自己都感觉都不应该.....严重影响了生活质量......生活的幸福指数!!!.....到现在还特么的单身!!!求介绍啊 ...

  9. Android 使用WindowManager实现Android悬浮窗

    WindowManager介绍 通过Context.getSystemService(Context.WINDOW_SERVICE)可以获得 WindowManager对象. 每一个WindowMan ...

随机推荐

  1. p2661 信息传递（Tarjan模板）

    传送门 题目 有 nnn 个同学(编号为 111 到 nnn )正在玩一个信息传递的游戏.在游戏里每人都有一个固定的信息传递对象,其中,编号为 iii 的同学的信息传递对象是编号为 TiT_iTi​ ...

  2. js 使用中一些需要提醒的点

    1.js 中可以直接使用输出java 变量 <script> var path = '<%=basePath%>'; 2.js重新注册事件后,如何让事件不自动执行? mzTxt ...

  3. NPM run start使用本地的http-server

    在项目开发过程中,Visual Studio 2015 一个Solution中有一个前端项目 Myproject.FrontEnd,我们使用node.js, npm来进行管理 在这个项目中,有一个pa ...

  4. linux下apache2的虚拟主机配置

    1,起因 在一星期前吧,大波说既然咱们有了自己的服务器,二级域名了.可以考虑怎样每人一个域名,分别指向我们各自的空间.想法挺好,避免我们个人的东西放在同一主页上.那就做吧 2,第一次尝试 (1)在域名 ...

  5. C#结构体指针的定义及使用详解（intptr的用法）

    在解析C#结构体指针前,必须知道C#结构体是如何定义的.在c#中同样定义该结构体. C#结构体指针之C#结构体的定义: [StructLayout(LayoutKind.Sequential)] pu ...

  6. 超级台阶 （NYOJ—76）

    很简单的高中数学题,写出来主要是提醒自己,写完递推公式(尤其是公式)一定要检查多遍. #include<stdio.h> #include<string.h> int M; i ...

  7. weex前端式写法解决方案---eros

    前言 如果想用前端的方式写一个app怎么办呢? 如果你用的是 React,那么它已经有了一个比较完善的体系跟社区.如果你用的是Vue又不想花费太多时间去重新学习React,那么目前比较靠谱的方案就是w ...

  8. 关于在SSM框架下使用PageHelper

    首先,如果各位在这块配置和代码有什么问题欢迎说出来,我也会尽自己最大的能力帮大家解答 这些代码我都是写在一个小项目里的,项目的github地址为:https://github.com/Albert-B ...

  9. thinkphp5.1常量定义使用

    thinkphp5.1取消了系统常量 可以把常量配置在app.php文件中 //配置网站地址 'WEB_URL'=>'http://127.0.0.1/tp5', 可以使用config()函数直 ...

  10. js常见问题之为什么点击弹出的i总是最后一个

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...