Android 九宫格物理键盘数字英文切换

已于 2023-08-29 10:55:30 修改
阅读量199 收藏 1
点赞数 1
分类专栏： Android客制 文章标签： android
于 2023-04-11 14:25:16 首次发布
原文链接：https://blog.csdn.net/cuckoochun/article/details/78799112
版权

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cuckoochun/article/details/78799112

前几天接到个任务，让android原生的输入法支持物理按键,同时在状态栏体现。

一开始直接在拉丁输入法LatinIME.java类中处理，然后客户要求不能在输入法中处理，于是对InputMethodService.java进行处理。

 /*begin add by csc*/
    private long timeDown,timeUp;
    private int count,typeCount ;
    private String input;
    private int lastKeyCode;
    private boolean isLongPressed = false;
    private boolean isDown = false;
    private static final long DELAY_TIME = 700;
    private boolean isInput = true;
    InputConnection inputConnection;// add by csc
    /*end add by csc*/

public boolean onKeyDown(int keyCode, KeyEvent event) {
 
        /*begin add by csc*/
        if(Settings.Global.getInt(getApplicationContext().getContentResolver(), "aa_key_switch_case_function_enabled",0)==1) {
            final EditorInfo ei = getCurrentInputEditorInfo();
            if (ei.inputType != 524289 && ei.inputType != InputType.TYPE_NULL && ei.inputType != InputType.TYPE_CLASS_NUMBER && ei.inputType != InputType.TYPE_NUMBER_FLAG_SIGNED && ei.inputType != InputType.TYPE_NUMBER_FLAG_DECIMAL && ei.inputType != InputType.TYPE_CLASS_PHONE) {
                if (isInput && keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9 || keyCode == KeyEvent.KEYCODE_STAR || keyCode == KeyEvent.KEYCODE_F3 || keyCode == KeyEvent.KEYCODE_POUND) {
                    handler.removeCallbacks(runnableUp);
                    if (typeCount != 0) {
                        if (!isLongPressed) {
                            timeDown = System.currentTimeMillis();
 
                            if (/*keyCode == KeyEvent.KEYCODE_F3||*/lastKeyCode != 0 && lastKeyCode != keyCode && timeDown - timeUp < DELAY_TIME && lastKeyCode != KeyEvent.KEYCODE_0 && !isDown) {
                                if (typeCount == 2) {
                                    input = input.toUpperCase();
                                }
                                if (DEBUG)
                                    Log.d("chenshichun", " " + this.getClass().getCanonicalName() + " :::::input::::" + input);
                                inputConnection.commitText(input, 1);
                                count = 0;
                            }
 
                            if (!isDown && keyCode != KeyEvent.KEYCODE_F3)
                                handler.postDelayed(runnableDown, DELAY_TIME);
                            isDown = true;
 
                            switch (keyCode) {
                                case KeyEvent.KEYCODE_0:
                                    input = "0";
                                    return true;
                                case KeyEvent.KEYCODE_1:
                                    input = "1";
                                    return true;
                                case KeyEvent.KEYCODE_2:
                                    input = "2";
                                    return true;
                                case KeyEvent.KEYCODE_3:
                                    input = "3";
                                    return true;
                                case KeyEvent.KEYCODE_4:
                                    input = "4";
                                    return true;
                                case KeyEvent.KEYCODE_5:
                                    input = "5";
                                    return true;
                                case KeyEvent.KEYCODE_6:
                                    input = "6";
                                    return true;
                                case KeyEvent.KEYCODE_7:
                                    input = "7";
                                    return true;
                                case KeyEvent.KEYCODE_8:
                                    input = "8";
                                    return true;
                                case KeyEvent.KEYCODE_9:
                                    input = "9";
                                    return true;
                                case KeyEvent.KEYCODE_STAR:
                                    input = "*";
                                    return true;
                                case KeyEvent.KEYCODE_POUND:
                                    input = "#";
                                    return true;
                            }
                        } else {
                            return true;
                        }
                    }
                    if (keyCode == KeyEvent.KEYCODE_F3) {
                        return true;
                    }
 
                }
            }
        }
        /*end add by csc*/
 
 
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
            if (handleBack(false)) {
                event.startTracking();
                return true;
            }
            return false;
        }
        return doMovementKey(keyCode, event, MOVEMENT_DOWN);
    }

 public boolean onKeyUp(int keyCode, KeyEvent event) {
 
        /*begin add by csc*/
        if(Settings.Global.getInt(getApplicationContext().getContentResolver(), "aa_key_switch_case_function_enabled",0)==1) {
            final EditorInfo ei = getCurrentInputEditorInfo();
            if (ei.inputType != 524289 && ei.inputType != InputType.TYPE_NULL && ei.inputType != InputType.TYPE_CLASS_NUMBER && ei.inputType != InputType.TYPE_NUMBER_FLAG_SIGNED && ei.inputType != InputType.TYPE_NUMBER_FLAG_DECIMAL && ei.inputType != InputType.TYPE_CLASS_PHONE) {
                if (isInput) {
                    isDown = false;
                    if (typeCount != 0 && /*keyCode != KeyEvent.KEYCODE_POUND && */keyCode != KeyEvent.KEYCODE_F3 &&
                            (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9 || keyCode == KeyEvent.KEYCODE_STAR || keyCode == KeyEvent.KEYCODE_POUND)) {
                        long nowTime = System.currentTimeMillis();
 
                        inputConnection = getCurrentInputConnection();
                        if (isLongPressed) {
                            isLongPressed = false;
                        } else {
                            handler.removeCallbacks(runnableDown);
                            switch (keyCode) {
                                case KeyEvent.KEYCODE_0:
                                    if (nowTime - timeDown < DELAY_TIME) {
                                        handler.removeCallbacks(runnableDown);
                                        input = " ";
                                        inputConnection.commitText(input, 1);
                                    }
                                    break;
 
                                case KeyEvent.KEYCODE_1:
                                    switch (count % 3) {
                                        case 0:
                                            input = ",";
                                            break;
                                        case 1:
                                            input = ".";
                                            break;
                                        case 2:
                                            input = "@";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_2:
 
                                    switch (count % 3) {
                                        case 0:
                                            input = "a";
                                            break;
                                        case 1:
                                            input = "b";
                                            break;
                                        case 2:
                                            input = "c";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_3:
                                    switch (count % 3) {
                                        case 0:
                                            input = "d";
                                            break;
                                        case 1:
                                            input = "e";
                                            break;
                                        case 2:
                                            input = "f";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_4:
                                    switch (count % 3) {
                                        case 0:
                                            input = "g";
                                            break;
                                        case 1:
                                            input = "h";
                                            break;
                                        case 2:
                                            input = "i";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_5:
                                    switch (count % 3) {
                                        case 0:
                                            input = "j";
                                            break;
                                        case 1:
                                            input = "k";
                                            break;
                                        case 2:
                                            input = "l";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_6:
                                    switch (count % 3) {
                                        case 0:
                                            input = "m";
                                            break;
                                        case 1:
                                            input = "n";
                                            break;
                                        case 2:
                                            input = "o";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_7:
                                    switch (count % 4) {
                                        case 0:
                                            input = "p";
                                            break;
                                        case 1:
                                            input = "q";
                                            break;
                                        case 2:
                                            input = "r";
                                            break;
                                        case 3:
                                            input = "s";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_8:
                                    switch (count % 3) {
                                        case 0:
                                            input = "t";
                                            break;
                                        case 1:
                                            input = "u";
                                            break;
                                        case 2:
                                            input = "v";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_9:
                                    switch (count % 4) {
                                        case 0:
                                            input = "w";
                                            break;
                                        case 1:
                                            input = "x";
                                            break;
                                        case 2:
                                            input = "y";
                                            break;
                                        case 3:
                                            input = "z";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_STAR:
                                    switch (count % 2) {
                                        case 0:
                                            input = ".";
                                            break;
                                        case 1:
                                            input = ",";
                                            break;
                                    }
 
                                    break;
                                case KeyEvent.KEYCODE_POUND:
                                    input = "#";
                                    break;
                            }
 
                            if (typeCount == 2) {
                                input = input.toUpperCase();
                            }
                            inputConnection.setComposingText(input, 1);
                            handler.removeCallbacks(runnableUp);
                            handler.postDelayed(runnableUp, DELAY_TIME);
                            count++;
 
                            isLongPressed = false;
                            timeUp = System.currentTimeMillis();
                            lastKeyCode = keyCode;
                        }
                    }
 
                    if (keyCode == KeyEvent.KEYCODE_F3) {
                        switch (typeCount) {
                            case 0:
                                typeCount = 1;
                                break;
                            case 1:
                                typeCount = 2;
                                break;
                            case 2:
                                typeCount = 0;
                                break;
                        }
                        input = "";
                        Intent intent = new Intent("INPUT_STATUS_CHANGE");
                        intent.putExtra("INPUT_STATUS", typeCount);
                        sendBroadcast(intent);
                    }
                }
            }
        }
    /*end add by csc*/
 
        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK && event.isTracking()
                && !event.isCanceled()) {
            return handleBack(true);
        }
        
        return doMovementKey(keyCode, event, MOVEMENT_UP);
    }

/*begin add by csc*/
    Handler handler = new Handler();
    Runnable runnableDown = new Runnable() {
        @Override
        public void run() {
            try {
                inputConnection.commitText(input, 1);
                if(DEBUG)Log.d("chenshichun"," "+this.getClass().getCanonicalName()+" :::::runnableDown::::"+input);
                isLongPressed = true;
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("exception...");
            }
        }
    };
 
    Runnable runnableUp = new Runnable() {
        @Override
        public void run() {
            try {
                if(typeCount==2){
                    input = input.toUpperCase();
                }
                inputConnection.commitText(input, 1);
                if(DEBUG)Log.d("chenshichun"," "+this.getClass().getCanonicalName()+" :::::runnableUp::::"+input);
                count = 0;
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("exception...");
            }
        }
    };
 
        /*end add by csc*/

因为监听不到长按事件，所以在每次down的时候都当长按处理，handler.postDelayed(runnableDown, DELAY_TIME); 每次up的时候先handler.removeCallbacks(runnableDown);这时候如果抬手时间大于DELAY_TIME就会当长按处理，在电话，计算器等只需要输入数字的界面就将该功能屏蔽，通过输入类型来判断即可，这里524289是计算器读出来的类型，源码中找不到就直接写数值了。

ei.inputType != 524289 && ei.inputType != InputType.TYPE_NULL && ei.inputType != InputType.TYPE_CLASS_NUMBER && ei.inputType != InputType.TYPE_NUMBER_FLAG_SIGNED && ei.inputType != InputType.TYPE_NUMBER_FLAG_DECIMAL && ei.inputType != InputType.TYPE_CLASS_PHONE

当切换大小写的时候在PhoneStatusBar.java接受广播

else if("INPUT_STATUS_CHANGE".equals(action)){// add by csc
                int inputStatus = intent.getIntExtra("INPUT_STATUS",0);
                switch (inputStatus){
                    case 0:
                        mInputStatus.setText("");
                        break;
                    case 1:
                        mInputStatus.setText(R.string.input_lower);
                        break;
                    case 2:
                        mInputStatus.setText(R.string.input_case);
                        break;
                }
            }else if ("INPUT_ON_OR_FALSE".equals(action)){// add by csc
                boolean putStatusOn = intent.getBooleanExtra("INPUT_STATUS_ON",false);
                mInputStatus.setVisibility(putStatusOn?View.VISIBLE:View.GONE);
            }

其中INPUT_ON_OR_FALSE这个广播是设置里面发出的，设置里面加了一个这个功能是否启用的开关，对应

Settings.Global.getInt(getApplicationContext().getContentResolver(), "aa_key_switch_case_function_enabled",0)==1

还需要在statusbar.xml里面加一个控件

<TextView
            android:id="@+id/input_status"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:gravity="center_vertical"
            android:text="@string/input_case"
            android:visibility="gone"
        />

后面发现在短信界面联想功能会乱，于是实体按键的时候就把联想功能去掉：
在拉丁输入法LatinIME.java里面修改：

if (!/*latinIme.mSettings.getCurrent().isSuggestionsEnabledPerUserSettings()*/false) {// mod by csc
                return;
     }
十化一
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
安卓T9实体按键中文输入法
07-22
一个Android九宫格实体按键输入法，支持中文，但不能联想输入。
android处理键盘事件之物理按键（屏蔽后退键）
02-16
本例子讲述了，android开发中常用的键盘事件的处理示例。另外，加有文档的说明
android 物理键盘 字符,Android物理键盘事件解析
weixin_35079944的博客
05-25 342
前言Android设备连接物理键盘其实是个挺小众的需求，其实Android设备本身就是支持物理键盘，dispatchKeyEvent()这个方法就可以监听物理键盘，这里提供一个封装的类，解析键盘事件。有很多事件，具体可以去看KeyEvent这个类的源码，我这里只处理的数字键盘。实现方式1.键盘事件解析类public class DispatchKeyResolver {public OnKeyIn...
Android隐藏物理键盘
zzh_receive的博客
11-15 2088
Android隐藏物理键盘
Android自定义九宫格输入框
NightRain的博客
10-02 865
继承EditText，实现九宫格输入框。在也不用担心81一个EditText的烦恼了~~~
Android Studio 实现九宫格功能
08-19
Android Studio 实现九宫格功能是指在 Android Studio 中创建一个九宫格的视图，九宫格是指一个由九个小图标组成的矩阵排列的视图。通过使用 GridView 组件和自定义的 Adapter，可以实现九宫格的功能。 在 Android ...
Android九宫格源码
03-27
这个“Android九宫格源码”是使用Eclipse IDE编写的，包含两个小型的Demo，旨在展示如何实现这样一个交互式的布局。源码结构简单，易于理解和学习，特别适合初学者或需要快速实现九宫格功能的开发者。 首先，我们要...
Android 九宫格抽奖
10-13
Android 九宫格抽奖 自定义view 可以根据后台返回的商品id设置商品曝光率,本地随机数随机抽奖
android自定义键盘数字键与英文键盘切换
01-23
本教程将探讨如何在Android Studio中实现一个可以切换数字键与英文键盘的自定义键盘，即“android自定义键盘数字键与英文键盘切换”。 首先，创建一个新的Android Studio项目，选择Empty Activity模板。在`res/...
Android 漂亮的九宫格源码
03-24
http://vs130.com/ranklist.html 最新最热门的免费源码下载 发福利，免积分，Android 漂亮的九宫格源码
Android 九宫格解锁Demo
08-19
这个"Android九宫格解锁Demo"是开发者为了展示如何实现这种功能而创建的一个示例项目。下面我们将详细探讨相关的Android开发知识点： 1. **自定义View**：九宫格解锁的核心在于自定义一个View，它需要继承自`View`...
Android 物理键盘与软键盘同时可用
Android framework
01-31 395
Android 物理键盘与软键盘同时可用
Android 12.0 软硬键盘同时使用的兼容(软键盘与内置物理键盘共存)
安卓兼职framework和app工程师的博客
02-24 329
在12.0的系统rom定制化开发中，有些设备上，如果外接了USB扫描枪之类的设备，当插入USB扫描枪以后，然后点击输入调用输入法的时候，没有反应，但是拔掉USB扫描枪以后，输入法又能正常使用，这说明和输入法起冲突了，询问了好多同时，说可能把会把USB扫描枪识别为硬键盘，所以就关闭了软键盘 这样肯定是不行的，这就要解决冲突的问题 看是哪里识别有误了
Android输入法扩展之外接键盘中文输入
热门推荐
区块链斜杠青年(爱踢门)
06-12 1万+
我们知道，android目前的输入都是通过软键盘实现的，用外接键盘的少.但是在平板上，外接键盘中文输入是必要的，软键盘输入还是太慢了，对于可以兼用办公的Android平板来说，实现PC级中文输入速度是比较有用的.在android上写文章，qq聊天，外接键盘是该发挥发挥了。但是早期的Android输入法的架构限制，它没法实现外接键盘中文输入，本文利用Android的某些隐蔽的属性分析并实现了一种外接键盘中文输入法。
Android 自定义软键盘实现 数字九宫格
最新发布
2401_83703797的博客
03-24 980
今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。还有。
android的keyevent方法,Android keyevent按键和值的对应
weixin_42576804的博客
05-26 2195
Android keyevent 中的各个值，在使用adb shell input 的时候用得到。是从http://blog.csdn.net/huiguixian/article/details/8550170转过来的。KEYCODE_UNKNOWN=0;KEYCODE_SOFT_LEFT=1;KEYCODE_SOFT_RIGHT=2;KEYCODE_HOME=3;KEYCODE_BACK=4;...
android处理键盘事件之物理按键 （一）
qq_21813987的博客
02-16 8325
android处理键盘事件之物理按键 （一）
解决Android 5.1物理键盘与软键盘的同时使用
HelloBirthday的博客
09-07 4877
在android 5.1系统中插入扫码枪物理设备后，软键盘无法弹出的问题。 在代码frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java中，如果把updateShowImeWithHardKeyboard()方法中的showImeWithHardKeyboard变量直接置为true，则可
android 九宫格解锁
12-23
Android九宫格解锁是一种常见的手机解锁方式，用户通过在九宫格上画出指定的图形来解锁手机。在设置中，用户可以选择开启九宫格解锁，然后绘制一条连续的滑动指令来设定解锁图案。之后，用户每次解锁手机时，都需要按照自己设定的图案在九宫格上划动相同的手势才能成功解锁。 使用九宫格解锁有一定的安全性，因为这种解锁方式相比于密码或者图案，更加难以被他人窥视出来。另外，九宫格解锁可以通过设置不同的复杂度来增加安全性，例如增加连接点的数量或者限制形状的复杂程度。然而，也有一些安全专家表示，由于用户习惯性的使用手指在屏幕上滑动，导致残留的手势痕迹可能会被破解者利用。 九宫格解锁的出现使得解锁手机更加直观和便捷，用户可以根据自己的喜好来设置不同的解锁图案，而不仅仅局限于数字密码。同时，它也避免了用户频繁输入密码造成的繁琐。然而，一些用户也反映出使用九宫格解锁时，误触率较高，有时会导致错误解锁。 总的来说，Android九宫格解锁是一种便捷且相对安全的手机解锁方式，但用户在设置个人解锁图案时需要考虑安全性和实用性的平衡。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值