悬浮窗管理

最新推荐文章于 2021-05-26 17:34:56 发布
最新推荐文章于 2021-05-26 17:34:56 发布
阅读量819 收藏 3
点赞数 1
分类专栏： Android基础

转载地址:http://blog.csdn.net/guolin_blog/article/details/8689140

主界面启动服务，在服务中根据不同状态对悬浮窗进行管理

public class MainActivity extends Activity
{
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button btn = (Button)findViewById(R.id.btn_float_window);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v)
            {
                Intent intent = new Intent(MainActivity.this,FloatWindowService.class);
                startService(intent);
                finish();
            }
        });
    }
}

自定义大悬浮窗VIEW

public class BigFloatView extends LinearLayout implements View.OnClickListener
{
    public static int viewHeight;
    public static int viewWidth;

    public BigFloatView(Context context){
        super(context);
        LayoutInflater.from(context).inflate(R.layout.big_float_window,this);
        View view = findViewById(R.id.big_window);
        viewWidth = view.getLayoutParams().width;
        viewHeight = view.getLayoutParams().height;
        Button btnClose = (Button)view.findViewById(R.id.close);
        Button btnBack = (Button)view.findViewById(R.id.back);
        btnClose.setOnClickListener(this);
        btnBack.setOnClickListener(this);
    }

    @Override
    public void onClick(View v)
    {
        switch(v.getId()){
            //关闭所有悬浮窗并停止服务
            case R.id.close:
                Intent intent = new Intent(getContext(),FloatWindowService.class);
                getContext().stopService(intent);
                MyWindowManager.removeBigWindow(getContext());
                MyWindowManager.removeSmallView(getContext());
                break;
            //从大悬浮窗返回到小悬浮窗
            case R.id.back:
                MyWindowManager.removeBigWindow(getContext());
                MyWindowManager.createSmallWindow(getContext());
                break;
        }
    }

    //回退键进入小悬浮窗
    @Override
    public boolean dispatchKeyEvent(KeyEvent event) {
        if(event.getAction()==KeyEvent.ACTION_DOWN&&event.getKeyCode()==KeyEvent.KEYCODE_BACK){
            MyWindowManager.removeBigWindow(getContext());
            MyWindowManager.createSmallWindow(getContext());
            return true;
        }
        return super.dispatchKeyEvent(event);
    }
}

自定义可拖拽的小悬浮窗VIEW

public class SmallFloatView extends LinearLayout
{
    /**
     * 记录小悬浮窗的宽度
     */
    public static int viewWidth;

    /**
     * 记录小悬浮窗的高度
     */
    public static int viewHeight;

    /**
     * 记录系统状态栏的高度
     */
    private static int statusBarHeight;

    /**
     * 用于更新小悬浮窗的位置
     */
    private WindowManager windowManager;

    /**
     * 小悬浮窗的参数
     */
    private WindowManager.LayoutParams mParams;

    /**
     * 记录当前手指位置在屏幕上的横坐标值
     */
    private float xInScreen;

    /**
     * 记录当前手指位置在屏幕上的纵坐标值
     */
    private float yInScreen;

    /**
     * 记录手指按下时在屏幕上的横坐标的值
     */
    private float xDownInScreen;

    /**
     * 记录手指按下时在屏幕上的纵坐标的值
     */
    private float yDownInScreen;

    /**
     * 记录手指按下时在小悬浮窗的View上的横坐标的值
     */
    private float xInView;

    /**
     * 记录手指按下时在小悬浮窗的View上的纵坐标的值
     */
    private float yInView;

    public SmallFloatView(Context context){
        super(context);
        windowManager  = (WindowManager)context.getSystemService(context.WINDOW_SERVICE);
        LayoutInflater.from(context).inflate(R.layout.small_float_window,this);
        View view = findViewById(R.id.small_window);
        TextView tvPercent = (TextView)view.findViewById(R.id.percent);
        viewWidth = view.getLayoutParams().width;
        viewHeight = view.getLayoutParams().height;
        tvPercent.setText(MyWindowManager.getMemoryUsedPercent(context));
    }

    @Override
    public boolean onTouchEvent(MotionEvent event)
    {
        int slop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
        Log.d("TAG",slop+"");
        switch(event.getAction()){
            case MotionEvent.ACTION_DOWN:
                xInView = event.getX();
                yInView = event.getY();
                xDownInScreen = event.getRawX();
                yDownInScreen = event.getRawY() - getStatusBarHeight();
                xInScreen = event.getRawX();
                yInScreen = event.getRawY() - getStatusBarHeight();
                break;
            case MotionEvent.ACTION_MOVE:
                xInScreen = event.getRawX();
                yInScreen = event.getRawY() - getStatusBarHeight();
                //更新小悬浮窗的位置
                updateViewPosition();
                break;
            case MotionEvent.ACTION_UP:
                // 如果手指离开屏幕时，xDownInScreen和xInScreen相等，且yDownInScreen和yInScreen相等，则视为触发了单击事件。
                if (xDownInScreen == xInScreen && yDownInScreen == yInScreen) {
                    openBigWindow();
                }
                break;
        }
        return true;
    }

    //获取状态栏高度
    private int getStatusBarHeight(){
        if(statusBarHeight==0){
            Class<?> c;
            try
            {
                c = Class.forName("com.android.internal.R$dimen");
                Object o = c.newInstance();
                Field field = c.getField("status_bar_height");
                int x = (Integer) field.get(o);
                statusBarHeight = getResources().getDimensionPixelSize(x);
            }catch(Exception e)
            {
                e.printStackTrace();
            }
        }
        return statusBarHeight;
    }

    //给小悬浮窗设置窗口布局参数
    public void setParams(WindowManager.LayoutParams params) {
        mParams = params;
    }

    private void updateViewPosition() {
        mParams.x = (int) (xInScreen - xInView);
        mParams.y = (int) (yInScreen - yInView);
        windowManager.updateViewLayout(this, mParams);
    }

    public void openBigWindow(){
        MyWindowManager.createBigWindow(getContext());
        MyWindowManager.removeSmallView(getContext());
    }

}

封装大小悬浮窗的添加、移除操作

public class MyWindowManager
{
    /**
     * 小悬浮窗View的实例
     */
    private static SmallFloatView smallWindow;

    /**
     * 大悬浮窗View的实例
     */
    private static BigFloatView bigWindow;

    /**
     * 小悬浮窗View的参数
     */
    private static WindowManager.LayoutParams smallWindowParams;

    /**
     * 大悬浮窗View的参数
     */
    private static WindowManager.LayoutParams bigWindowParams;

    /**
     * 用于控制在屏幕上添加或移除悬浮窗
     */
    private static WindowManager mWindowManager;

    /**
     * 用于获取手机可用内存
     */
    private static ActivityManager mActivityManager;

    /**
     * 创建小悬浮窗在右边中间位置
     * @param context
     */
    public static void createSmallWindow(Context context){
        WindowManager windowManager = getWindowManager(context);
        int screenWidth = windowManager.getDefaultDisplay().getWidth();
        int screenHeight = windowManager.getDefaultDisplay().getHeight();
        if(smallWindow==null){
            Toast.makeText(context,"new smallWindow",Toast.LENGTH_SHORT).show();
            smallWindow = new SmallFloatView(context);
            if(smallWindowParams==null){
                Toast.makeText(context,"new params",Toast.LENGTH_SHORT).show();
                smallWindowParams = new LayoutParams();
                smallWindowParams.type = LayoutParams.TYPE_PHONE;
                smallWindowParams.format = PixelFormat.RGBA_8888;
                smallWindowParams.flags = LayoutParams.FLAG_NOT_TOUCH_MODAL
                        | LayoutParams.FLAG_NOT_FOCUSABLE;
                smallWindowParams.gravity = Gravity.LEFT | Gravity.TOP;
                smallWindowParams.width = SmallFloatView.viewWidth;
                smallWindowParams.height = SmallFloatView.viewHeight;
                //TAG
                smallWindowParams.x = screenWidth - SmallFloatView.viewWidth;
                smallWindowParams.y = screenHeight / 2 - SmallFloatView.viewHeight/2;
            }
            //TAG
            smallWindow.setParams(smallWindowParams);
            windowManager.addView(smallWindow,smallWindowParams);
        }
    }

    public static void removeSmallView(Context context){
        if(smallWindow!=null){
            WindowManager windowManager = getWindowManager(context);
            windowManager.removeView(smallWindow);
            smallWindow = null;
        }
    }


    /**
     * 创建大悬浮窗在屏幕中间位置
     * @param context
     */
    public static void createBigWindow(Context context){
        WindowManager windowManager = getWindowManager(context);
        int screenWidth = windowManager.getDefaultDisplay().getWidth();
        int screenHeight = windowManager.getDefaultDisplay().getHeight();
        if(bigWindow==null){
            bigWindow = new BigFloatView(context);
            if(bigWindowParams==null){
                bigWindowParams = new LayoutParams();
                bigWindowParams = new LayoutParams();
                bigWindowParams.x = screenWidth / 2 - BigFloatView.viewWidth / 2;
                bigWindowParams.y = screenHeight / 2 - BigFloatView.viewHeight / 2;
                bigWindowParams.type = LayoutParams.TYPE_PHONE;
                bigWindowParams.format = PixelFormat.RGBA_8888;
                bigWindowParams.gravity = Gravity.LEFT | Gravity.TOP;
                bigWindowParams.width = BigFloatView.viewWidth;
                bigWindowParams.height = BigFloatView.viewHeight;
            }
            windowManager.addView(bigWindow,bigWindowParams);
        }
    }

    public static void removeBigWindow(Context context){
        if(bigWindow!=null){
            WindowManager windowManager = getWindowManager(context);
            windowManager.removeView(bigWindow);
            bigWindow = null;
        }
    }

    public static WindowManager getWindowManager(Context context){
        if(mWindowManager==null)
            mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        return mWindowManager;
    }

    public static ActivityManager getActivityManager(Context context){
        if(mActivityManager==null)
            mActivityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        return mActivityManager;
    }

    /**
     * 获取当前可用内存,字节为单位
     * @param context
     * @return
     */
    public static long getAvailableMemory(Context context){
        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
        getActivityManager(context).getMemoryInfo(memoryInfo);
        return memoryInfo.availMem;
    }

    public static String getMemoryUsedPercent(Context context){
        String filePath = "/proc/meminfo";
        try {
            FileReader fileReader = new FileReader(filePath);
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            String memoryLine = bufferedReader.readLine();
            String subMemoryLine = memoryLine.substring(memoryLine.indexOf("MemTotal:"));
            bufferedReader.close();
            long totalMemorySize = Integer.parseInt(subMemoryLine.replaceAll("\\D+", ""));
            long availableSize = getAvailableMemory(context) / 1024;
            int percent = (int) ((totalMemorySize - availableSize) / (float) totalMemorySize * 100);
            return percent + "%";
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "Error";
    }

    public static boolean isWindowShow(){
        return smallWindow!=null||bigWindow!=null;
    }

    /**
     * 小悬浮窗数据更新
     * @param context
     */
    public static void updateMemoryUsedPercent(Context context){
        if(smallWindow!=null){
            TextView tv = (TextView) smallWindow.findViewById(R.id.percent);
            tv.setText(getMemoryUsedPercent(context));
        }
    }
}

服务中开启新线程，每隔0.5S刷新状态

//在服务中管理悬浮窗的显示，刷新悬浮窗数据
public int onStartCommand(Intent intent, int flags, int startId) {
    if (timer == null) {
        timer = new Timer();
        timer.scheduleAtFixedRate(new RefreshTask(), 0, 500);
    }
    return super.onStartCommand(intent, flags, startId);
}

//服务销毁时定时器取消任务
public void onDestroy() {
    super.onDestroy();
    if (timer != null)
        timer.cancel();
    timer = null;
}

//刷新任务，每500ms执行一次
class RefreshTask extends TimerTask {
    @Override
    public void run() {
        //在桌面且没有悬浮窗显示
        if (isHome() && !MyWindowManager.isWindowShow()) {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    MyWindowManager.createSmallWindow(FloatWindowService.this);
                }
            });
        //不在桌面且有悬浮窗显示
        } else if (!isHome() && MyWindowManager.isWindowShow()) {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    MyWindowManager.removeBigWindow(FloatWindowService.this);
                    MyWindowManager.removeSmallView(FloatWindowService.this);
                }
            });
        //在桌面且有悬浮窗显示
        } else if (isHome() && MyWindowManager.isWindowShow()) {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    MyWindowManager.updateMemoryUsedPercent(FloatWindowService.this);
                }
            });
        }
    }
}

//判断当前界面是否在桌面
private boolean isHome() {
    ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    List<ActivityManager.RunningTaskInfo> runningTasks = activityManager.getRunningTasks(1);
    return getHome().contains(runningTasks.get(0).topActivity.getPackageName());
}

private List<String> getHome() {
    PackageManager packageManager = getPackageManager();
    List<String> names = new ArrayList<String>();
    Intent intent = new Intent();
    intent.setAction(Intent.ACTION_MAIN);
    intent.addCategory(Intent.CATEGORY_HOME);
    List<ResolveInfo> resolveInfos = packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
    for (ResolveInfo info : resolveInfos) {
        names.add(info.activityInfo.packageName);
    }
    return names;
}
alive3
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
锁屏界面无法无法显示Toast
u013398960的博客
06-13 3486
锁屏界面无法无法显示Toast
在Keyguard锁屏上面可弹出Toast消息的方法
知识空间
05-07 1824
通过调用toast的getWindowParams方法获取toast的WindowParams，再设置允许在锁屏之上显示的window flag: FLAG_SHOW_WHEN_LOCKED 参考代码如下 Toast mToast = Toast.makeText(InCallActivity.this, res, Toast.LENGTH_LONG); mToast.getWindowPara...
android 7.0 悬浮窗管理,微信7.0.6内测版来了！新增智能“悬浮窗”，超方便！（附链接）...
weixin_29612623的博客
05-26 375
前几天小编才写了篇文章表示手机莫名其妙自动更新到7.0.5版本，其中的朋友圈视频自动播放功能让人很无奈，因为这个只有在移动网络下可以关闭，在WiFi下是关闭不了的，希望之后的微信版本可以增加WiFi的关闭设置，没想到微信7.0.6内测版本这就来了？虽然有点嫌弃7.0.5版本，但是还是忍不住试了一下内测版本，这次更新主要的是增加了一个新功能，那就是“智能悬浮窗口”，这个之前也有一些大V爆料过，下面就...
cpp-TrafficMonitor一个用于显示当前网速CPU及内存利用率的桌面悬浮窗软件
08-16
Traffic Monitor是一款用于Windows平台的网速监控悬浮窗软件，可以显示当前网速、CPU及内存利用率，支持嵌入到任务栏显示，支持更换皮肤、历史流量统计等功能。
VC++玩转炫酷悬浮窗2---不规则窗体的实现源码
08-22
VC++玩转炫酷悬浮窗2---不规则窗体的实现源码 blog请见： http://blog.csdn.net/lincyang/article/details/38752319
桌面悬浮窗
07-19
4. **悬浮窗管理器**：使用`WindowManager`接口来添加、更新或移除悬浮窗。通过`addView()`方法将悬浮窗添加到系统窗口层次结构中。 5. **事件监听**：为悬浮窗设置触摸事件监听器，以便在用户触摸悬浮窗时触发相应...
E4A悬浮窗类库，面板悬浮窗类库
11-26
在E4A中，"悬浮窗类库"是一种实用的组件，能够实现应用内的浮动窗口功能，类似于电脑上的桌面小工具。这种悬浮窗可以承载各种信息，如通知、计时器、快捷按钮等，为用户提供便捷的操作界面。 悬浮窗在E4A中的实现...
Android悬浮窗屏蔽悬浮窗外部所有的点击事件的实例代码
08-30
首先，Android悬浮窗通常是通过`WindowManager`服务来添加和管理的。`WindowManager`允许我们在系统的窗口层次结构中添加、更新或移除视图。创建悬浮窗的关键在于设置合适的`LayoutParams`，这是一个用于描述窗口...
android surfaceview 悬浮窗圆角 windowmanager
最新发布
02-01
对于悬浮窗，一般会使用`WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY`类型，这使得悬浮窗能够在所有应用之上显示，但低于系统通知。接着，可以调用`WindowManager.addView()`将自定义的`View`添加到窗口中...
android悬浮窗demo
10-19
5. **悬浮窗生命周期管理**：当应用被后台化或设备屏幕关闭时，悬浮窗需要妥善处理，如保存当前状态并在合适的时候恢复。使用`onResume()`、`onPause()`等生命周期回调方法来管理悬浮窗的显示与隐藏。 6. **处理...
实现窗口悬浮效果
12-29
Qt悬浮窗口，实现主窗口与子悬浮窗口之间的转换，悬浮窗口显示的桌面最顶端，且可以实现自动隐藏，当鼠标移动到窗口顶部，悬浮窗口又可以显示出来
MFC模拟360悬浮窗加速球
05-26
MFC模拟360悬浮窗加速球。暂时是静态的，但目前的界面已经出来了，需要的话拿去扩展吧！
VC++玩转炫酷悬浮窗3源码
09-05
VC++玩转炫酷悬浮窗3---GDI+完美实现不规则窗体 源码，详细见： http://blog.csdn.net/lincyang/article/details/39078295
C++ 控制台创建窗口，GDIPLUS加载png图片，实现悬浮窗
07-23
C++ 控制台创建窗口，GDIPLUS加载png图片，实现悬浮窗，UpdateLayeredWindow，特效窗口。内含已编译的可执行文件。
VC++玩转炫酷悬浮窗1---悬浮窗的实现
08-21
VC++玩转炫酷悬浮窗1---悬浮窗的实现 源码，blog请看 http://blog.csdn.net/lincyang/article/details/38729275
MFC悬浮窗收起.rar
05-16
MFC不规则外观，并且仿360悬浮窗拖到窗口边缘后收起的效果。
WindowManager对于窗口的管理以及悬浮窗的实现
想飞的企鹅
11-02 8852
WindowManager WindowManager是窗口管理器, 所有显示窗口都可以通过它来控制 WindowManager.addView(view, layoutParams) 添加一个View到窗口中 WindowManager.updateView(view, layoutParams) 更新窗口中的View属性 WindowManager.remove
突破小米悬浮窗权限控制--不需要权限的悬浮窗
热门推荐
苦逼程序员的笔记
07-06 2万+
上一篇文章讲了Android的Toast拓展，在原生Toast基础上对显示时长和显示动画做了二次封装，强化了Toast的部分功能。也分析了对于二次封装的ExToast设计原理，以及Toast的关键点。Toast其实就是系统悬浮窗的一种，基于Toast我们可以拓展出不需要权限的悬浮窗，而悬浮窗能做什么，你们懂的。但是，小米系统对开发者恶心，你们也懂的，下面分析一下如何突破小米悬浮窗权限封锁。
android 12 悬浮窗权限
06-06
新的“悬浮窗管理器”界面提供了对所有应用程序悬浮窗权限的集中管理，用户可以更加直观地了解每个应用程序的权限状态，并对其进行灵活的控制。 其次，在Android 12中，悬浮窗权限的使用条件也得到了更加明确的规定...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值