android github 悬浮窗 android悬浮窗开发

转载

数据探索先锋 2023-08-17 19:52:02

文章标签 android github 悬浮窗悬浮窗 WindowManager ide android 文章分类 Android 移动开发

前言：悬浮窗功能属于一个独立于应用之上在手机系统层面的一个功能，WindowManager无论应用在前台还是后台都可以显示在当前的手机界面

悬浮窗功能需要注意以下几点：

1：悬浮窗的权限管理，除了在常规的manifests中申请权限和动态权限处理之外，还有就是适配问题，在android不同的版本中悬浮窗获取权限都不一样。

2: 开发悬浮窗步骤无非就是， 1 .创建一个 serivce 让悬浮窗在服务中，2.创建悬浮窗布局，3创建 WindowManager 窗口，让悬浮窗布局加载在 window窗口中，然后在service服务中启动这个 window 窗口。（在这个过程中你会遇到一些莫名其妙的坑，最让人感觉烦的就是权限这块。需要重点关注我在开发过程中在5.0 6.0.8.0上都需要不同的处理方式否则会崩溃或者悬浮窗无法显示）

3：在开发之前需要弄清楚 WindowManager 是做什么用的。

因为悬浮窗功能在实际项目中，所以无法给出全部代码，只能给出大概的步骤部分以及悬浮窗的核心部分，

如果需要悬浮窗demo 请留言或者邮箱 binbinsongstudio@outlook.com 我会尽快提取一份demo出来分享给大家

话不多多说，直接上代码

首先需要创建一个 类继承servier

/**
 * 悬浮窗在服务中创建，通过暴露接口FloatCallBack与Activity进行交互
 */
public class FloatMonkService extends Service {
    /**
     * home键监听
     */
    private HomeWatcherReceiver mHomeKeyReceiver;


    @Override
    public void onCreate() {
        super.onCreate();
        //注册广播接收者
        mHomeKeyReceiver = new HomeWatcherReceiver();
        final IntentFilter homeFilter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
        registerReceiver(mHomeKeyReceiver, homeFilter);
        //初始化悬浮窗UI
        initWindowData();

    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * 初始化WindowManager
     */
    private void initWindowData() {
        FloatWindowManager.createFloatWindow(this);

    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        //移除悬浮窗
        FloatWindowManager.removeFloatWindowManager();
        //注销广播接收者
        if (null != mHomeKeyReceiver) {
            unregisterReceiver(mHomeKeyReceiver);
        }
    }


}

HomeWatcherReceiver 类主要是用于监听物理按键或者虚拟按键接收系统发送的广播做出一些属于自己的定制话操作

/**
 * Des:一些Home建与切换键的广播监听，需要动态注册
 */

public class HomeWatcherReceiver extends BroadcastReceiver {
    private final String TAG = "HomeWatcherReceiver";
    private final String SYSTEM_DIALOG_FROM_KEY = "reason";
    private final String SYSTEM_DIALOG_FROM_RECENT_APPS = "recentapps";
    private final String SYSTEM_DIALOG_FROM_HOME_KEY = "homekey";
    private final String SYSTEM_DIALOG_FROM_LOCK = "lock";

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Log.i(TAG, "onReceive: action: " + action);
        //根据不同的信息进行一些个性操作
        if (action.equals(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)) {
            String from = intent.getStringExtra(SYSTEM_DIALOG_FROM_KEY);
            Log.i(TAG, "from: " + from);
            if (SYSTEM_DIALOG_FROM_HOME_KEY.equals(from)) { //短按Home键
                Log.i(TAG, "Home Key");
                //按home键会直接关闭悬浮窗
                FloatWindowManager.hide();
            } else if (SYSTEM_DIALOG_FROM_RECENT_APPS.equals(from)) { //长按Home键或是Activity切换键
                FloatWindowManager.hide();
                Log.i(TAG, "long press home key or activity switch");
            } else if (SYSTEM_DIALOG_FROM_LOCK.equals(from)) { //锁屏操作
                FloatWindowManager.hide();
                Log.i(TAG, "lock");
            }
        }
    }

}

FloatLayout 是悬浮窗 布局 文件
public class FloatLayout extends FrameLayout {
    private final WindowManager mWindowManager;
    private final ImageView mFloatView;
    //  private final DraggableFlagView mDraggableFlagView;
    private long startTime;
    private float mTouchStartX;
    private float mTouchStartY;
    private boolean isclick;
    private WindowManager.LayoutParams mWmParams;
    private Context mContext;
    private long endTime;
    // FrameLayout frameLayout;
    public static boolean isOpen = false;

    public FloatLayout(Context context) {
        this(context, null);
        mContext = context;
    }

    public FloatLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
        mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        LayoutInflater.from(context).inflate(R.layout.float_littlemonk_layout, this);
        //浮动窗口按钮
        mFloatView = (ImageView) findViewById(R.id.float_id);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // 获取相对屏幕的坐标，即以屏幕左上角为原点
        isclick = false;
        int x = (int) event.getRawX();
        int y = (int) event.getRawY();
        //下面的这些事件，跟图标的移动无关，为了区分开拖动和点击事件
        int action = event.getAction();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                startTime = System.currentTimeMillis();
                mTouchStartX = event.getX();
                mTouchStartY = event.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                //图标移动的逻辑在这里
                float mMoveStartX = event.getX();
                float mMoveStartY = event.getY();
                // 如果移动量大于3才移动
                if (Math.abs(mTouchStartX - mMoveStartX) > 3
                        && Math.abs(mTouchStartY - mMoveStartY) > 3) {
                    // 更新浮动窗口位置参数
                    mWmParams.x = (int) (x - mTouchStartX);
                    mWmParams.y = (int) (y - mTouchStartY);
                    mWindowManager.updateViewLayout(this, mWmParams);
                    return false;
                }
                break;
            case MotionEvent.ACTION_UP:
                endTime = System.currentTimeMillis();
                //当从点击到弹起小于半秒的时候,则判断为点击,如果超过则不响应点击事件
                if ((endTime - startTime) > 0.1 * 1000L) {
                    isclick = false;
                } else {
                    isclick = true;
                }
                break;
        }
        //响应点击事件
        if (isclick) {
            UcePrinterPresenter.getInstance().showBleDialog(UcePrinterPresenter.STATE);
        }
        return true;
    }

    /**
     * 将小悬浮窗的参数传入，用于更新小悬浮窗的位置。
     *
     * @param params 小悬浮窗的参数
     */
    public void setParams(WindowManager.LayoutParams params) {
        mWmParams = params;
    }


    public ImageView getmFloatView() {
        return mFloatView;
    }
}

FloatActionController 是一个控制器 主要用于 被 别人调用
/**
 * Des:与悬浮窗交互的控制类，真正的实现逻辑不在这
 */
public class FloatActionController {
    private FloatActionController() {
    }

    private UcePrinterPresenter.IPResultListener listener;

    public UcePrinterPresenter.IPResultListener getListener() {
        return listener;
    }

    public void setListener(UcePrinterPresenter.IPResultListener listener) {
        this.listener = listener;
    }

    public static FloatActionController getInstance() {
        return LittleMonkProviderHolder.sInstance;
    }

    // 静态内部类
    private static class LittleMonkProviderHolder {
        private static final FloatActionController sInstance = new FloatActionController();
    }

    private FloatCallBack mFloatCallBack;

    /**
     * 开启服务悬浮窗
     */
    public void startMonkServer(Context context) {
            Intent intent = new Intent(context, FloatMonkService.class);
            context.startService(intent);
    }

    /**
     * 判断服务是否开启
     *
     * @return
     */
    public static boolean isServiceRunning(Context context, String ServiceName) {
        if (("").equals(ServiceName) || ServiceName == null)
            return false;
        ActivityManager myManager = (ActivityManager) context
                .getSystemService(Context.ACTIVITY_SERVICE);
        ArrayList<ActivityManager.RunningServiceInfo> runningService = (ArrayList<ActivityManager.RunningServiceInfo>) myManager
                .getRunningServices(30);
        for (int i = 0; i < runningService.size(); i++) {
            if (runningService.get(i).service.getClassName().toString()
                    .equals(ServiceName)) {
                return true;
            }
        }
        return false;
    }
        /**
         * 关闭悬浮窗
         */
        public void stopMonkServer (Context context){
            Intent intent = new Intent(context, FloatMonkService.class);
            context.stopService(intent);
        }

        /**
         * 注册监听
         */
        public void registerCallLittleMonk (FloatCallBack callLittleMonk){
            mFloatCallBack = callLittleMonk;
        }

        /**
         * 悬浮窗的显示
         */
        public void show () {
            if (mFloatCallBack == null) return;
            FloatWindowManager.show();
            mFloatCallBack.show();
        }

        /**
         * 悬浮窗的隐藏
         */
        public void hide () {
            if (mFloatCallBack == null) return;
            FloatWindowManager.hide();
            mFloatCallBack.hide();
        }


    }

package com.uc56.ucexpressbao.backgroundprinting.service;

import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.PixelFormat;
import android.os.Build;
import android.util.DisplayMetrics;
import android.view.Gravity;
import android.view.WindowManager;

import com.thinkcore.activity.TActivityManager;
import com.uc56.ucexpressbao.R;
import com.uc56.ucexpressbao.backgroundprinting.service.permission.FloatPermissionManager;
import com.uc56.ucexpressbao.backgroundprinting.service.view.FloatLayout;
import com.uc56.ucexpressbao.backgroundprinting.service.view.PrintFloatLayout;
import com.uc56.ucexpressbao.config.BMSApplication;
import com.uc56.ucexpressbao.presenter.UcePrinterPresenter;


/**
 * 悬浮窗统一管理，与悬浮窗交互的真正实现，整个悬浮窗功能的核心
 */
public class FloatWindowManager {
    /**
     * 悬浮窗
     */
    private static FloatLayout mFloatLayout;
    private static PrintFloatLayout floatLayout;
    private static WindowManager mWindowManager;
    private static WindowManager.LayoutParams wmParams;
    private static WindowManager.LayoutParams wmPrintParams;
    private static boolean mHasShown;
    private static boolean printmHasShown;

    /**
     * 创建一个小悬浮窗。初始位置为屏幕的右部中间位置。
     *
     * @param context 必须为应用程序的Context.
     */
    public static void createFloatWindow(Context context) {

        if (FloatPermissionManager.getInstance().checkPermission(context)) {
            wmParams = new WindowManager.LayoutParams();
            WindowManager windowManager = getWindowManager(context);
            mFloatLayout = new FloatLayout(context);
            if (Build.VERSION.SDK_INT >= 26) {
                wmParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
            } else if (Build.VERSION.SDK_INT >= 24) { /*android7.0不能用TYPE_TOAST*/
                wmParams.type = WindowManager.LayoutParams.TYPE_PHONE;
            } else { /*以下代码块使得android6.0之后的用户不必再去手动开启悬浮窗权限*/
                String packname = context.getPackageName();
                PackageManager pm = context.getPackageManager();
                boolean permission = (PackageManager.PERMISSION_GRANTED == pm.checkPermission("android.permission.SYSTEM_ALERT_WINDOW", packname));
                if (permission) {
                    wmParams.type = WindowManager.LayoutParams.TYPE_PHONE;
                } else {
                    wmParams.type = WindowManager.LayoutParams.TYPE_TOAST;
                }
            }

            //设置图片格式，效果为背景透明
            wmParams.format = PixelFormat.RGBA_8888;
            //设置浮动窗口不可聚焦（实现操作除浮动窗口外的其他可见窗口的操作）
            wmParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
            //调整悬浮窗显示的停靠位置为左侧置顶
            wmParams.gravity = Gravity.START | Gravity.TOP;

            DisplayMetrics dm = new DisplayMetrics();
            //取得窗口属性
            mWindowManager.getDefaultDisplay().getMetrics(dm);
            //窗口的宽度
            int screenWidth = dm.widthPixels;
            //窗口高度
            int screenHeight = dm.heightPixels;
            //以屏幕左上角为原点，设置x、y初始值，相对于gravity
            wmParams.x = screenWidth - screenWidth + 50;
            wmParams.y = screenHeight - screenHeight + 50;

            //设置悬浮窗口长宽数据
            wmParams.width = WindowManager.LayoutParams.WRAP_CONTENT;
            wmParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
            mFloatLayout.setParams(wmParams);
            windowManager.addView(mFloatLayout, wmParams);
            mHasShown = true;
            switch (UcePrinterPresenter.STATE) {
                case 1:
                    if (mFloatLayout.getmFloatView() != null)
                        mFloatLayout.getmFloatView().setImageResource(R.mipmap.print);
                    break;
                case 2:
                    if (mFloatLayout.getmFloatView() != null)
                        mFloatLayout.getmFloatView().setImageResource(R.mipmap.stop);
                    break;
                case 5:
                    if (mFloatLayout.getmFloatView() != null)
                        mFloatLayout.getmFloatView().setImageResource(R.mipmap.interrupt);
                    break;
            }
        } else {
            BMSApplication.showFloatWindowPermission(TActivityManager.getInstance().currentActivity(), R.string.open_float_window);
        }

    }


    /**
     * 移除悬浮窗
     */
    public static void removeFloatWindowManager() {
        //移除悬浮窗口
        if (mFloatLayout != null) {
            boolean isAttach = true;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                isAttach = mFloatLayout.isAttachedToWindow();
            }
            if (mHasShown && isAttach && mWindowManager != null)
                mWindowManager.removeView(mFloatLayout);
        }
    }

    /**
     * 返回当前已创建的WindowManager。
     */
    private static WindowManager getWindowManager(Context context) {
        if (mWindowManager == null) {
            mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        }
        return mWindowManager;
    }


    public static void hide() {
        if (mHasShown)
            mWindowManager.removeViewImmediate(mFloatLayout);
        mHasShown = false;
    }

    public static void show() {
        if (!mHasShown)
            mWindowManager.addView(mFloatLayout, wmParams);
        mHasShown = true;
    }

}

FloatPermissionManager  这里做了一些 悬浮窗 权限的处理
public class FloatPermissionManager {
    private static final String TAG = "FloatPermissionManager";

    private static volatile FloatPermissionManager instance;

    private Dialog dialog;

    public static FloatPermissionManager getInstance() {
        if (instance == null) {
            synchronized (FloatPermissionManager.class) {
                if (instance == null) {
                    instance = new FloatPermissionManager();
                }
            }
        }
        return instance;
    }

    public boolean applyFloatWindow(Context context) {
        if (checkPermission(context)) {
            return true;
        } else {
            applyPermission(context);
            return false;
        }
    }

    public boolean checkPermission(Context context) {
        try {
            //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);
        }catch (Exception ex){
        }
        return true;
    }

    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));
                }
            }
            return result;
        }
    }

    private void applyPermission(Context context) {
        if (Build.VERSION.SDK_INT < 23) {
            if (RomUtils.checkIsMiuiRom()) {
                miuiROMPermissionApply(context);
            } else if (RomUtils.checkIsMeizuRom()) {
                meizuROMPermissionApply(context);
            } else if (RomUtils.checkIsHuaweiRom()) {
                huaweiROMPermissionApply(context);
            } else if (RomUtils.checkIs360Rom()) {
                ROM360PermissionApply(context);
            }
        }
        commonROMPermissionApply(context);
    }

    private void ROM360PermissionApply(final Context context) {
        showConfirmDialog(context, new OnConfirmResult() {
            @Override
            public void confirmResult(boolean confirm) {
                if (confirm) {
                    QikuUtils.applyPermission(context);
                } else {
                    Log.e(TAG, "ROM:360, user manually refuse OVERLAY_PERMISSION");
                }
            }
        });
    }

    private void huaweiROMPermissionApply(final Context context) {
        showConfirmDialog(context, new OnConfirmResult() {
            @Override
            public void confirmResult(boolean confirm) {
                if (confirm) {
                    HuaweiUtils.applyPermission(context);
                } else {
                    Log.e(TAG, "ROM:huawei, user manually refuse OVERLAY_PERMISSION");
                }
            }
        });
    }

    private void meizuROMPermissionApply(final Context context) {
        showConfirmDialog(context, new OnConfirmResult() {
            @Override
            public void confirmResult(boolean confirm) {
                if (confirm) {
                    MeizuUtils.applyPermission(context);
                } else {
                    Log.e(TAG, "ROM:meizu, user manually refuse OVERLAY_PERMISSION");
                }
            }
        });
    }

    private void miuiROMPermissionApply(final Context context) {
        showConfirmDialog(context, new OnConfirmResult() {
            @Override
            public void confirmResult(boolean confirm) {
                if (confirm) {
                    MiuiUtils.applyMiuiPermission(context);
                } else {
                    Log.e(TAG, "ROM:miui, user manually refuse OVERLAY_PERMISSION");
                }
            }
        });
    }

    /**
     * 通用 rom 权限申请
     */
    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");
                            //需要做统计效果
                        }
                    }
                });
            }
        }
    }

    private void showConfirmDialog(Context context, OnConfirmResult result) {
        showConfirmDialog(context, "您的手机没有授予悬浮窗权限，请开启后再试", result);
    }

    private void showConfirmDialog(Context context, String message, final OnConfirmResult result) {
        if (dialog != null && dialog.isShowing()) {
            dialog.dismiss();
        }

        dialog = new AlertDialog.Builder(context).setCancelable(true).setTitle("")
                .setMessage(message)
                .setPositiveButton("现在去开启",
                        new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                result.confirmResult(true);
                                dialog.dismiss();
                            }
                        }).setNegativeButton("暂不开启",
                        new DialogInterface.OnClickListener() {

                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                result.confirmResult(false);
                                dialog.dismiss();
                            }
                        }).create();
        dialog.show();
    }

    private interface OnConfirmResult {
        void confirmResult(boolean confirm);
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。