Android 悬浮窗权限各机型各系统适配大全（总结）
程序员文章站
2023-11-29 19:46:52
这篇博客主要介绍的是 android 主流各种机型和各种版本的悬浮窗权限适配，但是由于碎片化的问题，所以在适配方面也无法做到完全的主流机型适配，这个需要大家的一起努力，这个...
这篇博客主要介绍的是 android 主流各种机型和各种版本的悬浮窗权限适配，但是由于碎片化的问题，所以在适配方面也无法做到完全的主流机型适配，这个需要大家的一起努力，这个博客的名字永远都是一个将来时。
悬浮窗适配
悬浮窗适配有两种方法：第一种是按照正规的流程，如果系统没有赋予 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 命令，然后在打印出来的信息中找到相关的机型信息即可，这里贴出国产几款常见机型的判断：
/**
* 获取 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;
}
public static boolean checkishuaweirom() {
return build.manufacturer.contains("huawei");
}
/**
* check if is miui rom
*/
public static boolean checkismiuirom() {
return !textutils.isempty(getsystemproperty("ro.miui.ui.version.name"));
}
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;
}
}
/**
* check if is 360 rom
*/
public static boolean checkis360rom() {
return build.manufacturer.contains("qiku");
}
小米
首先需要适配的就应该是小米了，而且比较麻烦的事情是，miui 的每个版本适配方法都是不一样的，所以只能每个版本去单独适配，不过还好由于使用的人数多，网上的资料也比较全。首先第一步当然是判断是否赋予了悬浮窗权限，这个时候就需要使用到 appopsmanager 这个类了，它里面有一个 checkop 方法：
/**
* 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;
}
找到悬浮窗权限的 op 值是：
/** @hide */ public static final int op_system_alert_window = 24;
注意到这个函数和这个值其实都是 hide 的，所以没办法，你懂的，只能用反射：
/**
* 检测 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;
}
检测完成之后就是跳转到授权页面去开启权限了，但是由于 miui 不同版本的权限授权页面不一样，所以需要根据不同版本进行不同处理：
/**
* 获取小米 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;
}
/**
* 小米 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.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!");
}
}
getsystemproperty 方法是直接调用 getprop 方法来获取系统信息：
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;
}
最新的 v8 版本有些机型已经是 6.0 ，所以就是下面介绍到 6.0 的适配方法了，感谢 @pinocchio2mx 的反馈，有些机型的 miui8 版本还是5.1.1，所以 miui8 依旧需要做适配，非常感谢，希望大家一起多多反馈问题，谢谢~~。
魅族
魅族的适配，由于我司魅族的机器相对较少，所以只适配了 flyme5.1.1/android 5.1.1 版本 mx4 pro 的系统。和小米一样，首先也要通过 api19 版本添加的 appopsmanager 类判断是否授予了权限：
/**
* 检测 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;
}
然后是跳转去悬浮窗权限授予界面：
/**
* 去魅族权限申请页面
*/
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);
}
如果有魅族其他版本的适配方案，请联系我。
华为
华为的适配是根据网上找的方案，外加自己的一些优化而成，但是由于华为手机的众多机型，所以覆盖的机型和系统版本还不是那么全面，如果有其他机型和版本的适配方案，请联系我，我更新到 github 上。和小米，魅族一样，首先通过 appopsmanager 来判断权限是否已经授权：
/**
* 检测 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;
}
然后根据不同的机型和版本跳转到不同的页面：
/**
* 去华为权限申请页面
*/
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));
}
}
emui4 之后就是 6.0 版本了，按照下面介绍的 6.0 适配方案即可。
360
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;
}
@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;
}
如果没有授予悬浮窗权限，就跳转去权限授予界面：
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);
context.startactivity(intent);
}
哈哈哈，是不是很简单，有时候真相往往一点也不复杂，ok，适配完成。
android 6.0 及之后版本
悬浮窗权限在 6.0 之后就被 google 单独拿出来管理了，好处就是对我们来说适配就非常方便了，在所有手机和 6.0 以及之后的版本上适配的方法都是一样的，首先要在 manifest 中静态申请<uses-permission android:name="android.permission.system_alert_window" />权限，然后在使用时先判断该权限是否已经被授权，如果没有授权使用下面这段代码进行动态申请：
private static final int request_code = 1;
//判断权限
private boolean commonrompermissioncheck(context context) {
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));
}
}
return result;
}
//申请权限
private void requestalertwindowpermission() {
intent intent = new intent(settings.action_manage_overlay_permission);
intent.setdata(uri.parse("package:" + getpackagename()));
startactivityforresult(intent, request_code);
}
@override
//处理回调
protected void onactivityresult(int requestcode, int resultcode, intent data) {
super.onactivityresult(requestcode, resultcode, data);
if (requestcode == request_code) {
if (settings.candrawoverlays(this)) {
log.i(logtag, "onactivityresult granted");
}
}
}
上述代码需要注意的是：
- 使用action settings.action_manage_overlay_permission 启动隐式intent；
- 使用 “package:” + getpackagename() 携带app的包名信息；
- 使用 settings.candrawoverlays 方法判断授权结果。
在用户开启相关权限之后才能使用 windowmanager.layoutparams.type_system_error ,要不然是会直接崩溃的哦。
特殊适配流程
如何绕过系统的权限检查，直接弹出悬浮窗？需要使用mparams.type = windowmanager.layoutparams.type_toast; 来取代 mparams.type = windowmanager.layoutparams.type_system_error;，这样就可以达到不申请权限，而直接弹出悬浮窗，至于原因嘛，我们看看 phonewindowmanager 源码的关键处：
@override
public int checkaddpermission(windowmanager.layoutparams attrs, int[] outappop) {
....
switch (type) {
case type_toast:
// xxx right now the app process has complete control over
// this... should introduce a token to let the system
// monitor/control what they are doing.
outappop[0] = appopsmanager.op_toast_window;
break;
case type_dream:
case type_input_method:
case type_wallpaper:
case type_private_presentation:
case type_voice_interaction:
case type_accessibility_overlay:
// the window manager will check these.
break;
case type_phone:
case type_priority_phone:
case type_system_alert:
case type_system_error:
case type_system_overlay:
permission = android.manifest.permission.system_alert_window;
outappop[0] = appopsmanager.op_system_alert_window;
break;
default:
permission = android.manifest.permission.internal_system_window;
}
if (permission != null) {
if (permission == android.manifest.permission.system_alert_window) {
final int callinguid = binder.getcallinguid();
// system processes will be automatically allowed privilege to draw
if (callinguid == process.system_uid) {
return windowmanagerglobal.add_okay;
}
// check if user has enabled this operation. securityexception will be thrown if
// this app has not been allowed by the user
final int mode = mappopsmanager.checkop(outappop[0], callinguid,
attrs.packagename);
switch (mode) {
case appopsmanager.mode_allowed:
case appopsmanager.mode_ignored:
// although we return add_okay for mode_ignored, the added window will
// actually be hidden in windowmanagerservice
return windowmanagerglobal.add_okay;
case appopsmanager.mode_errored:
return windowmanagerglobal.add_permission_denied;
default:
// in the default mode, we will make a decision here based on
// checkcallingpermission()
if (mcontext.checkcallingpermission(permission) !=
packagemanager.permission_granted) {
return windowmanagerglobal.add_permission_denied;
} else {
return windowmanagerglobal.add_okay;
}
}
}
if (mcontext.checkcallingorselfpermission(permission)
!= packagemanager.permission_granted) {
return windowmanagerglobal.add_permission_denied;
}
}
return windowmanagerglobal.add_okay;
}
从源码中可以看到，其实 type_toast 没有做权限检查，直接返回了 windowmanagerglobal.add_okay，所以呢，这就是为什么可以绕过权限的原因。还有需要注意的一点是 addview 方法中会调用到 mpolicy.adjustwindowparamslw(win.mattrs);，这个方法在不同的版本有不同的实现：
//android 2.0 - 2.3.7 phonewindowmanager
public void adjustwindowparamslw(windowmanager.layoutparams attrs) {
switch (attrs.type) {
case type_system_overlay:
case type_secure_system_overlay:
case type_toast:
// these types of windows can't receive input events.
attrs.flags |= windowmanager.layoutparams.flag_not_focusable
| windowmanager.layoutparams.flag_not_touchable;
break;
}
}
//android 4.0.1 - 4.3.1 phonewindowmanager
public void adjustwindowparamslw(windowmanager.layoutparams attrs) {
switch (attrs.type) {
case type_system_overlay:
case type_secure_system_overlay:
case type_toast:
// these types of windows can't receive input events.
attrs.flags |= windowmanager.layoutparams.flag_not_focusable
| windowmanager.layoutparams.flag_not_touchable;
attrs.flags &= ~windowmanager.layoutparams.flag_watch_outside_touch;
break;
}
}
//android 4.4 phonewindowmanager
@override
public void adjustwindowparamslw(windowmanager.layoutparams attrs) {
switch (attrs.type) {
case type_system_overlay:
case type_secure_system_overlay:
// these types of windows can't receive input events.
attrs.flags |= windowmanager.layoutparams.flag_not_focusable
| windowmanager.layoutparams.flag_not_touchable;
attrs.flags &= ~windowmanager.layoutparams.flag_watch_outside_touch;
break;
}
}
可以看到，在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 重复添加两次悬浮窗，第二次会崩溃，跑出来下面的错误：
e/androidruntime: fatal exception: main
android.view.windowmanager$badtokenexception: unable to add window -- window android.view.viewrootimpl$w@d7a4e96 has already been added
at android.view.viewrootimpl.setview(viewrootimpl.java:691)
at android.view.windowmanagerglobal.addview(windowmanagerglobal.java:342)
at android.view.windowmanagerimpl.addview(windowmanagerimpl.java:93)
at com.tencent.ysdk.module.icon.impl.a.g(unknown source)
at com.tencent.ysdk.module.icon.impl.floatingviews.q.onanimationend(unknown source)
at android.view.animation.animation$3.run(animation.java:381)
at android.os.handler.handlecallback(handler.java:751)
at android.os.handler.dispatchmessage(handler.java:95)
at android.os.looper.loop(looper.java:154)
at android.app.activitythread.main(activitythread.java:6119)
at java.lang.reflect.method.invoke(native method)
at com.android.internal.os.zygoteinit$methodandargscaller.run(zygoteinit.java:886)
at com.android.internal.os.zygoteinit.main(zygoteinit.java:776)
去追溯源码，发现是这里抛出来的错误：
try {
morigwindowtype = mwindowattributes.type;
mattachinfo.mrecomputeglobalattributes = true;
collectviewattributes();
res = mwindowsession.addtodisplay(mwindow, mseq, mwindowattributes,
gethostvisibility(), mdisplay.getdisplayid(),
mattachinfo.mcontentinsets, mattachinfo.mstableinsets,
mattachinfo.moutsets, minputchannel);
} catch (remoteexception e) {
.....
} finally {
if (restore) {
attrs.restore();
}
}
.....
if (res < windowmanagerglobal.add_okay) {
.....
switch (res) {
....
case windowmanagerglobal.add_duplicate_add:
throw new windowmanager.badtokenexception(
"unable to add window -- window " + mwindow
+ " has already been added");
}
}
然后去查看抛出这个异常处的代码：
if (mwindowmap.containskey(client.asbinder())) {
slog.w(tag_wm, "window " + client + " is already added");
return windowmanagerglobal.add_duplicate_add;
}
然后我们从 mwindowmap 这个变量出发去分析，但是最后发现，根本不行，这些代码从 5.x 版本就存在了，而且每次调用 addview 方法去添加一个 view 的时候，都是一个新的 client 对象，所以 mwindowmap.containskey(client.asbinder()) 一直是不成立的，所以无法从这里去分析，于是继续分析在 7.0 版本是没有问题的，但是在 7.1.1 版本就出现问题了，所以我们去查看 7.1.1 版本代码的变更：
我们从里面寻找关于 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
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。