后台监听按键键值探索

最新推荐文章于 2024-08-05 03:05:54 发布
最新推荐文章于 2024-08-05 03:05:54 发布
阅读量1.1k 收藏 1
点赞数 2
原文链接：https://blog.csdn.net/aichidanfan/article/details/48463775
版权

探讨Android实现后台(Service)按键监听的功能
Android 在Service中监听软键盘显示状态

项目里有需求：在后台监听到物理按键的键值，而且不能依赖activity
最后方案定为用一个像素悬浮窗，通过service控制启动和移除，利用悬浮窗的view来监听按键键值。
但是，悬浮窗的view必须获取到焦点才可以监听到键值，另外，还要及时在用户触摸屏幕或点击返回按键时释放焦点。因为悬浮窗view获取了焦点后，系统的软键盘就弹不出来，返回键也会失效

public class ButtonFloatService extends Service implements View.OnTouchListener, View.OnKeyListener,SoftKeyboardDetector.SoftKeyboardListener {
    private static final String TAG = "ButtonFloatService";
    private WindowManager windowManager;
    private WindowManager.LayoutParams params;
    private boolean isShowing;
    private View view;
    //private Timer timer;
    //private TimerTask timerTask;
    private boolean isRelease = false;
    private static final int MSG = 180;
    private boolean isSoftKeyboardShowing = false;
    @Override
    public void onCreate() {
        super.onCreate();
        LayoutInflater layoutInflater = LayoutInflater.from(this);
        windowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
        view = layoutInflater.inflate(R.layout.pix_layout, null);
        initWindow();
        view.setOnTouchListener(this);
        view.setOnKeyListener(this);

    }

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


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onstart");
        show();
        return START_NOT_STICKY;
    }

    private void initWindow() {
        Log.d(TAG, "initWindow ");
        isRelease = false;
        params = new WindowManager.LayoutParams();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            params.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
        } else {
            params.type = WindowManager.LayoutParams.TYPE_PHONE;
        }
        params.format = PixelFormat.TRANSPARENT;
        params.gravity = Gravity.START | Gravity.TOP;
        params.x = 0;
        params.y = 0;
        params.width = 1;
        params.height = 1;
        params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL |
                WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH |
                WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
        params.width = WindowManager.LayoutParams.WRAP_CONTENT;
        params.height = WindowManager.LayoutParams.WRAP_CONTENT;
        view.post(() -> {
            view.setFocusable(true);
            view.setFocusableInTouchMode(true);
            view.requestFocus();
        });
    }

    private void refreshWindowCatchFocus() {
        if (isRelease) {
            Log.d(TAG, "refreshWindowCatchFocus: 获取焦点");
            isRelease = false;
            params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL |
                    WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH |
                    WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
            view.post(() -> {
                view.setFocusable(true);
                view.setFocusableInTouchMode(true);
                view.requestFocus();
            });
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                if (view.isAttachedToWindow()) {
                    windowManager.updateViewLayout(view, params);
                }
            } else {
                if (view.getParent() != null) {
                    try {
                        windowManager.updateViewLayout(view, params);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }


        }
    }


    private void refreshWindowReleaseFocus() {
        if (!isRelease) {
            Log.d(TAG, "refreshWindowReleaseFocus: 释放焦点");
            isRelease = true;
            params.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH |
                    WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;
            view.post(() -> {
                view.setFocusable(false);
                view.setFocusableInTouchMode(false);
                view.clearFocus();
            });
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                if (view.isAttachedToWindow()) {
                    windowManager.updateViewLayout(view, params);
                }
            } else {
                if (view.getParent() != null) {
                    try {
                        windowManager.updateViewLayout(view, params);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
            SoftKeyboardDetector.getInstance().setSoftKeyboardListener(this);
            SoftKeyboardDetector.getInstance().initSoftKeyboardDetector();
        }
    }

    private boolean addToWindow() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (!Settings.canDrawOverlays(this)) {
                Log.d(TAG, "addToWindow: 未开启悬浮窗权限");
                return false;
            }
        }
        if (windowManager != null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                if (!view.isAttachedToWindow()) {
                    windowManager.addView(view, params);
                    return true;
                } else {
                    return false;
                }
            } else {
                try {
                    if (view.getParent() == null) {
                        windowManager.addView(view, params);
                    }
                    return true;
                } catch (Exception e) {
                    return false;
                }
            }
        } else {
            return false;
        }
    }

    private void show() {
        Log.d(TAG, "show float-->isShowing=" + isShowing);
        if (isShowing)
            return;
        addToWindow();
        isShowing = true;
    }

    private void remove() {
        Log.d(TAG, "remove float-->isShowing=" + isShowing);
        if (!isShowing) return;
        removeFromWindow();
        isShowing = false;
    }

    private void removeFromWindow() {
        try {
            if (windowManager != null) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    if (view.isAttachedToWindow()) {
                        Log.d(TAG, "float is removeViewImmediate");
                        windowManager.removeViewImmediate(view);
                    } else {
                        if (view.getParent() != null) {
                            Log.d(TAG, "float is removeView");
                            windowManager.removeView(view);
//                            windowManager.removeViewImmediate(view);
                        }
                    }
                } else {
                    if (view.getParent() != null) {
                        windowManager.removeViewImmediate(view);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onDestroy() {
        SoftKeyboardDetector.getInstance().clearSoftKeyboardDetector();
        remove();
        super.onDestroy();
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        Log.d(TAG, "onTouch: event=" + event);
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_OUTSIDE:
                refreshWindowReleaseFocus();
                break;
        }
        return false;
    }


   /* private void timerStart2CatchFocus() {
        if (isRelease) {
            Log.d(TAG, "timerStart2CatchFocus: 启动计时器准备获取焦点");
            if (timerTask != null) {
                timerTask.cancel();
                timerTask = null;
            }
            timerTask = new TimerTask() {
                @Override
                public void run() {
                    //判断是否有软键盘，如果没有，获取焦点；否则，无动作
                    if (!SoftKeyboardDetector.getInstance().isInputMethodShowing(Utils.getContext())) {
                        Message m = Message.obtain();
                        m.what = MSG;
                        handler.sendMessage(m);
                    }
                }
            };
            if (timer != null) {
                timer.cancel();
                timer = null;
            }
            timer = new Timer();
            timer.schedule(timerTask, 1500);
        }
    }*/

    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        Log.d(TAG, "onKey: keyCode=" + keyCode + "--keyEvent=" + event);
        //桌面按键监听
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK){
            refreshWindowReleaseFocus();
           // timerStart2CatchFocus();
            return false;
        }
        if (event.getAction() == KeyEvent.ACTION_UP) {
            ToastUtils.showShortToast("keyCode==" + keyCode);
        }
  
        return false;
    }


  private ButtonHandler handler = new ButtonHandler(this);
    static class ButtonHandler extends Handler{
        WeakReference<ButtonFloatService> weakReference;

        ButtonHandler(ButtonFloatService buttonFloatService){
            weakReference = new WeakReference<>(buttonFloatService);
        }

        @Override
        public void handleMessage(Message msg) {
            if (msg.what == MSG && weakReference.get() != null)
                weakReference.get().refreshWindowCatchFocus();
            super.handleMessage(msg);
        }
    }


    @Override
    public void onShowKeyboard() {
        isSoftKeyboardShowing = true;
    }

    @Override
    public void onDismissKeyboard() {
        isSoftKeyboardShowing = false;
        Message m = Message.obtain();
        m.what = MSG;
        handler.sendMessage(m);
    }
}


/**
 * 软键盘实时检测器，无需Activity
 */

public class SoftKeyboardDetector {
    private static final String TAG = "SoftKeyboard";
    private SoftKeyboardListener softKeyboardListener;
    private static SoftKeyboardDetector instance;
    private TimerTask timerTask;
    private Timer timer;

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

    public void setSoftKeyboardListener(SoftKeyboardListener softKeyboardListener) {
        this.softKeyboardListener = softKeyboardListener;
    }

    /**
     * 初始化软键盘检测器
     */
    public void initSoftKeyboardDetector() {
        clearSoftKeyboardDetector();
        timerTask = new TimerTask() {
            @Override
            public void run() {
                if (isInputMethodShowing(Utils.getContext())) {
                    if (softKeyboardListener != null) {
                        softKeyboardListener.onShowKeyboard();
                    }
                } else {
                    if (softKeyboardListener != null) {
                        softKeyboardListener.onDismissKeyboard();
                    }
                }
            }
        };
        timer = new Timer();
        timer.schedule(timerTask, 500, 500);//周期为1s
    }

    /**
     * 清理软键盘检测器
     */
    public void clearSoftKeyboardDetector() {
        if (timer != null) {
            timer.cancel();
            timer = null;
        }
        if (timerTask != null) {
            timerTask.cancel();
            timerTask = null;
        }
    }

    /**
     * 判断软键盘是否显示
     * @param context application的上下文
     * @return
     */
    public boolean isInputMethodShowing(Context context) {
        //得到默认输入法包名
        String defaultInputName = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.DEFAULT_INPUT_METHOD);
        defaultInputName = defaultInputName.substring(0, defaultInputName.indexOf("/"));
        boolean isInputing = false;
        if (android.os.Build.VERSION.SDK_INT > 20) {
            try {
                InputMethodManager imm = (InputMethodManager) context.getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE);
                Class clazz = imm.getClass();
                Method method = clazz.getMethod("getInputMethodWindowVisibleHeight", null);
                method.setAccessible(true);
                int height = (Integer) method.invoke(imm, null);
                if (height > 100) {
                    isInputing = true;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();

            for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
                if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE) {
                    if (appProcess.processName.equals(defaultInputName)) {
                        isInputing = true;
                        break;
                    }
                }
            }
        }
        if (isInputing) {
            Log.d(TAG, "软键盘显示中");
        } else {
            Log.d(TAG, "软键盘隐藏中");
        }
        return isInputing;
    }


    public interface SoftKeyboardListener {

        void onShowKeyboard();

        void onDismissKeyboard();
    }
}

pix_layout.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">
    <View
        android:background="@color/transparent"
        android:layout_width="1dp"
        android:layout_height="1dp">
    </View>
</RelativeLayout>
14skyang
关注
android 后台监听按键事件方法及demo
08-09
android 后台监听按键事件方法及demoandroid 后台监听按键事件方法及demo
Android 后台服务监听按键(home,back,音量键)
苏法迪的专栏
03-23 1万+
0.启动1x1大小服务窗口进行监听变化，音量按键下按 不接受触摸屏事件。 public static final int FLAG_NOT_TOUCHABLE = 0x00000010; 当窗口可以获得焦点（没有设置FLAG_NOT_FOCUSALBE选项）时，仍然将窗口范围之外的点设备事件（鼠标、触摸屏）发送给后面的窗口处理。否则它将独占所有的点设备事件，而不管它们是不是发生在...
探讨Android实现后台(Service)按键监听的功能
热门推荐
拥抱世界
11-25 3万+
Android系统中实现对全局按键事件的监听
Android 反射在Service中监听软键盘显示状态
最新发布
weixin_33154775的博客
08-05 49
Android 反射在 Service 中监听软键盘显示状态 在 Android 开发中，常常需要获取软键盘的显隐状态，以便根据用户的操作调整界面或进行数据处理。在传统的做法中，我们通常会在 Activity 或 Fragment 里监听这个状态，但在某些情况下，例如在 Service 中，我们可能无法直接使用 UI 组件...
Android 在Service中如何监听按钮事件
m0_49307389的博客
08-05 1318
LayoutInflater layoutInflater = (LayoutInflater) getSystemService(Activity.LAYOUT_INFLATER_SERVICE); LinearLayout linearLay = (LinearLayout) layoutInflater.inflate(R.layout.layout, null); Button b = (Button) linearLay.getChildAt(0); b.setOnClickListener(n.
【Android】应用程序在后台运行时怎么监听按键事件
每天不是在写bug就是在写bug的路上
04-12 2239
后台服务，按键监听，广播通知
Android模拟键盘和键盘监听
Change everyday
06-25 2094
1           键盘监控分析 Android的按键产生的是一个KeyEvent，这个KeyEvent只能被最上层focus窗口的activity和view得到。 所有的按键事件都会首先触发public boolean dispatchKeyEvent(KeyEvent event)这个函数，这个函数在SDK里的英文说明如下： boolean zy.keytest.ke
Qt后台监听键盘按键事件
01-12
该实例程序使用Qt进行，windows的键盘后台监听，即使Qt桌面程序失去焦点在后台运行，也会捕捉到按键事件 这个程序使用windows的钩子（hook）实现的，Qt官方没有相关的实现 关于编译，我用的是Qt5.9.7 MinGW32位，我...
android测试键值apk（一个测试键值的apk,将apk安装到系统，操作键盘或者遥控器，会把相应键值打印出来）.zip
04-28
它作为一个调试工具，安装到设备后，可以在后台运行，监听所有传入的键值事件。当用户按下键盘或遥控器的按钮时，应用会记录并显示对应的键码和状态，这对于调试涉及硬件按键交互的应用尤其有用。例如，开发者可以...
delphi取键值
08-22
在Delphi编程中，"取键值"通常指的是监听键盘事件并获取用户按下键盘时的按键信息。这个标题和描述提到的是使用全局键盘钩子（Global Keyboard Hook）来实现这一功能，这对于开发需要监控键盘输入的应用程序非常有用...
强大的C#钩子。全局钩子，获取输入值。键盘值已处理
08-26
此程序还具备后台静默运行的功能。 #### 核心知识点解析 ##### 1. 全局键盘钩子简介 全局键盘钩子是一种特殊的钩子类型，它允许程序捕获系统中的所有键盘事件，而不仅仅是当前应用程序窗口中的键盘事件。这种钩子...
Python中捕获键盘的方式详解
09-19
当用户按下键盘上的某个键时，pygame会产生一个`KEYDOWN`事件，我们可以检查这个事件的类型和对应的键值来识别用户按下的是哪个键。以下是一个简单的示例： ```python import pygame while True: for event in ...
android 全局菜单键实现,Android service后台检测全局触摸事件
weixin_30369183的博客
05-26 548
自转载：http://kpbird.blogspot.com/2013/03/android-detect-global-touch-event.html侧栏和glvebox应用程序一夜之间就变得流行起来，因为只有一种功能。它们提供全局菜单，可以从移动屏幕的左右边沿打开。作为一名开发人员，当我展示这些应用程序时，我首先想到的是“NDK”。然后，我开始寻找解决方案。从逻辑上讲，我想如果我能发现全球O...
android在service中监听按键,Android中在service服务中监听Back键
weixin_34910865的博客
05-27 2546
如何在服务中监听Back、音量键？大体思路：在服务中创建一个悬浮窗，悬浮窗中的View添加一个自定义View；在自定义的View中重写dispatchKeyEvent、onKeyDown、onKeyUp都可，则实现了Back、音量键的监听此种方法是从网上看到的原创网址找不到了，此处为转载1.自定义Viewimport android.content.Context;import android.c...
Android studio（一）按钮监听的三种方式
tundra38的博客
09-28 2845
实现Android按钮功能的几种方法：1.在activity上实现public class Activity2 extends AppCompatActivity implements View.OnClickListener2.在监听类上实现 class Listener implements View.OnClickListener3.用Textview实现Button功能（新版的Android似无法使用switch寻址不同id的button）
Android 在service服务中监听Back键
码点
09-30 1134
如何在服务中监听Back、音量键？ 大体思路：在服务中创建一个悬浮窗，悬浮窗中的View添加一个自定义View；在自定义的View中重写dispatchKeyEvent、onKeyDown、onKeyUp都可，则实现了Back、音量键的监听 1.自定义View import android.content.Context; import android.content.Intent; import android.content.SharedPreferences; import android.util.
html 监听按键返回键值都为0
05-31
在 HTML 中监听按键事件时，可以使用 `event.keyCode` 或 `event.which` 属性来获得键码值。然而，对于某些按键（如返回键），它们的键码值是 0，而不是 ASCII 码值。 要解决这个问题，可以使用 `event.key` 属性来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值