悬浮窗管理

最新推荐文章于 2024-05-20 11:07:01 发布
最新推荐文章于 2024-05-20 11:07:01 发布
阅读量879 收藏 3
点赞数 1
分类专栏： Android基础

转载地址:http://blog.youkuaiyun.com/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;
}
android 7.0 悬浮窗管理,微信7.0.6内测版来了！新增智能“悬浮窗”，超方便！（附链接）...
weixin_29612623的博客
05-26 442
前几天小编才写了篇文章表示手机莫名其妙自动更新到7.0.5版本，其中的朋友圈视频自动播放功能让人很无奈，因为这个只有在移动网络下可以关闭，在WiFi下是关闭不了的，希望之后的微信版本可以增加WiFi的关闭设置，没想到微信7.0.6内测版本这就来了？虽然有点嫌弃7.0.5版本，但是还是忍不住试了一下内测版本，这次更新主要的是增加了一个新功能，那就是“智能悬浮窗口”，这个之前也有一些大V爆料过，下面就...
android 7.0 悬浮窗管理,微信正式更新7.0.6版本，新增3大实用功能，悬浮窗、表情包搜索等你来！...
weixin_30140399的博客
05-26 482
原标题：微信正式更新7.0.6版本，新增3大实用功能，悬浮窗、表情包搜索等你来！之前有和大家介绍过微信7.0.6内测版本，就在前两天突然发现者之前的内测版本已经自动更新到7.0.6正式版本了，而且发现这次安卓的7.0.6版本其实和iOS的7.0.5版本很相似，下面就一起来看看吧！ 1.支持5个悬浮窗这个是微信中新添加的一个非常有趣又实用的功能，我们在使用微信的时候，在阅读里面的公众号文章需要先在页...
C++ 控制台创建窗口，GDIPLUS加载png图片，实现悬浮窗
07-23
C++ 控制台创建窗口，GDIPLUS加载png图片，实现悬浮窗，UpdateLayeredWindow，特效窗口。内含已编译的可执行文件。
VC++玩转炫酷悬浮窗1---悬浮窗的实现
08-21
VC++玩转炫酷悬浮窗1---悬浮窗的实现 源码，blog请看 http://blog.csdn.net/lincyang/article/details/38729275
亲测可用 e4a 易安卓 BG悬浮窗类库 类库 易安卓悬浮窗类库 e4a悬浮窗
01-08
2. **类库引入**：`BG悬浮窗类库`是专为e4a设计的一个第三方库，用于简化悬浮窗的创建和管理。在e4a项目中，你需要导入这个类库文件（elb格式），这通常通过“文件”->“导入”菜单完成，然后在代码中引用相关的类和...
android 悬浮窗全屏显示，锁屏页面悬浮窗全屏显示
03-22
在Android开发中，实现一个能够全屏显示并覆盖导航栏和状态栏的悬浮窗，以及在锁屏页面依然保持全屏显示，是一项涉及到系统权限、窗口管理服务和自定义视图的技术挑战。以下是对这个主题的详细解释： 1. **悬浮窗...
android跳转到华为手机管家悬浮窗管理界面demo
07-21
本示例“android跳转到华为手机管家悬浮窗管理界面demo”着重讲解如何在Android应用程序中实现跳转至华为手机（EMUI 3.0和EMUI 4.0版本）的悬浮窗管理界面，以便用户可以手动开启应用的悬浮窗权限。 首先，我们需要...
E4A悬浮窗类库，面板悬浮窗类库.zip
最新发布
06-18
7. **开发流程**：使用E4A悬浮窗类库，开发者需要先将ELB文件导入项目，然后在代码中实例化并调用类库提供的接口，创建和管理悬浮窗及面板。 8. **用户体验**：悬浮窗和面板在提升应用的易用性和交互性方面具有重要...
Android桌面悬浮窗效果实现，仿360手机卫士悬浮窗效果 源码程序
03-19
在悬浮窗管理类中，使用`LayoutInflater`从XML布局加载视图，然后设置`LayoutParams`。`LayoutParams`应包含窗口类型、宽度、高度、位置等信息。 5. **添加悬浮窗** 使用`WindowManager`的`addView()`方法将悬浮...
实现窗口悬浮效果
12-29
Qt悬浮窗口，实现主窗口与子悬浮窗口之间的转换，悬浮窗口显示的桌面最顶端，且可以实现自动隐藏，当鼠标移动到窗口顶部，悬浮窗口又可以显示出来
VC++玩转炫酷悬浮窗2---不规则窗体的实现源码
08-22
VC++玩转炫酷悬浮窗2---不规则窗体的实现源码 blog请见： http://blog.csdn.net/lincyang/article/details/38752319
VC++玩转炫酷悬浮窗3源码
09-05
VC++玩转炫酷悬浮窗3---GDI+完美实现不规则窗体 源码，详细见： http://blog.csdn.net/lincyang/article/details/39078295
cpp-TrafficMonitor一个用于显示当前网速CPU及内存利用率的桌面悬浮窗软件
08-16
Traffic Monitor是一款用于Windows平台的网速监控悬浮窗软件，可以显示当前网速、CPU及内存利用率，支持嵌入到任务栏显示，支持更换皮肤、历史流量统计等功能。
MFC悬浮窗收起.rar
05-16
MFC不规则外观，并且仿360悬浮窗拖到窗口边缘后收起的效果。
Android 悬浮窗实现
weixin_35733250的博客
08-10 1014
在工作中遇到开发悬浮窗的需求,在此整理一下,记录心得O(∩_∩)O哈哈~ 大概的思路如下: 我们将悬浮窗绑定在一个service中,某个activity界面上的开关来控制悬浮窗的显示/隐藏/移除 这里 我们简化步骤 仅用activity来控制悬浮窗1.首先是悬浮窗的布局(这里我们做一个时钟的悬浮窗) floating_window.xml<LinearLayout xmlns:andr
android 悬浮窗口和主界面同时显示,Android 悬浮窗口(及解决6.0以上无法显示问题)...
weixin_36221149的博客
05-26 563
思路实现通过WindowManager添加一个View，创建一个系统顶级的窗口，实现悬浮窗口的效果。本篇思路，来源于郭霖大神的悬浮窗口教程。大致介绍WindowManager 类创建的对象：Context.getSystemService(Context.WINDOW_SERVICE)常用API:addView():添加一个View对象updateViewLayout():更新指定的View对象r...
Android 遇坑之路及解决方案
刘旭
07-07 1722
一.在状态栏之上弹自定义吐司 1.需求：UI设计师设计的原型图是在状态栏之上的位置弹一个自定义吐司，我们的应用内全部都是沉浸式状态栏，将状态栏隐藏掉了的。 2.解决方案：首先给toast设置marginTop为负的状态栏高度是无效的，然后查阅相关资料发现Toast是显示在Window之上的，查看Toast的源码发现实际起作用的是Toast的一个静态内部类TN，TN有一个成员变量mParams，...
Android-悬浮窗开发
m0_64561613的博客
05-20 2618
很多时候我们会安装一些具备拥有悬浮窗的app，悬浮窗可以随时地去使用app的的快捷功能而不必回到app主界面，本篇就来详细了解悬浮窗是如何创建、定义、修改的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值