App内自定义软键盘

class RSKeyboardView(
    context: Context,
    attrs: AttributeSet? = null
) : KeyboardView(context, attrs)  {

    // 键盘背景色
    private var mBackground: Drawable = ColorDrawable(0xFF000000.toInt())
    // 键盘文字大小
    private var mLabelTextSize: Int = 14
    // 普通按键的文字颜色
    private var mKeyTextColor: Int = 0xFF000000.toInt()
    private val mPaint: Paint by lazy {
        Paint().apply {
            textAlign = Paint.Align.CENTER
            isAntiAlias = true
        }
    }

    // 数字键盘
    private val mKeyboardNumber: Keyboard by lazy { Keyboard(context, R.xml.keyboard_number) }
    // 字母键盘
    private val mKeyboardQwerty: Keyboard by lazy { Keyboard(context, R.xml.keyboard_qwerty) }
    // 按键背景资源
    private var mKeyBackgroundResourceTriple = NUMBER_KEY_BACKGROUND

    // 默认键盘模式
    var keyboardMode = KEYBOARD_MODE_NUMBER
        private set

    /**
     * 切换键盘模式
     */
    fun toggleMode() {
        if (keyboardMode == RSKeyboardView.KEYBOARD_MODE_QWERTY) {
            keyboard = mKeyboardNumber
            keyboardMode = RSKeyboardView.KEYBOARD_MODE_NUMBER
            mKeyBackgroundResourceTriple = NUMBER_KEY_BACKGROUND
        } else {
            keyboard = mKeyboardQwerty
            keyboardMode = RSKeyboardView.KEYBOARD_MODE_QWERTY
            mKeyBackgroundResourceTriple = QWERTY_KEY_BACKGROUND
        }
    }

    init {
        // 从xml中读取设置
        val set = arrayOf(
            android.R.attr.background,
            android.R.attr.labelTextSize,
            android.R.attr.keyTextColor
        ).toIntArray()

        val a = context.obtainStyledAttributes(attrs, set)

        mBackground = a.getDrawable(0) ?: mBackground
        @SuppressLint("ResourceType")
        mLabelTextSize = a.getDimensionPixelSize(1, mLabelTextSize)
        @SuppressLint("ResourceType")
        mKeyTextColor = a.getColor(2, mKeyTextColor)

        a.recycle()

        // 设置键盘
        this.keyboard = mKeyboardNumber
        this.isEnabled = true
        this.isPreviewEnabled = false
    }

    override fun onDraw(canvas: Canvas?) {
        canvas ?: return
        val keys = keyboard?.keys ?: return

        for (key in keys) {
            when (key.codes[0]) {
                Keyboard.KEYCODE_DONE -> {
                    // DONE按键
                    drawKeyBackground(mKeyBackgroundResourceTriple.first, canvas, key)
                    drawText(canvas, key, Color.WHITE)
                    drawIcon(canvas, key)
                }
                Keyboard.KEYCODE_MODE_CHANGE,
                Keyboard.KEYCODE_DELETE,
                Keyboard.KEYCODE_CANCEL -> {
                    // 控制按键
                    drawKeyBackground(mKeyBackgroundResourceTriple.second, canvas, key)
                    drawText(canvas, key, mKeyTextColor)
                    drawIcon(canvas, key)
                }
                else -> {
                    // 普通按键
                    drawKeyBackground(mKeyBackgroundResourceTriple.third, canvas, key)
                    drawText(canvas, key, mKeyTextColor)
                    drawIcon(canvas, key)
                }
            }
        }
    }

    /**
     * 绘制按键背景
     */
    private fun drawKeyBackground(@DrawableRes drawableId: Int, canvas: Canvas, key: Keyboard.Key) {
        val drawable = ContextCompat.getDrawable(context, drawableId) ?: return

        val drawableState = key.currentDrawableState
        if (key.codes[0] != 0) {
            drawable.state = drawableState
        }

        key.run {
            drawable.setBounds(x + paddingStart, y + paddingTop, x + paddingStart + width, y + paddingTop + height)
        }
        drawable.draw(canvas)
    }

    /**
     * 绘制按键label
     */
    private fun drawText(canvas: Canvas, key: Keyboard.Key, color: Int) {
        key.label ?: return

        mPaint.color = color
        mPaint.textSize = mLabelTextSize.toFloat()

        canvas.drawText(
            key.label.toString(),
            (key.x + ((key.width - paddingLeft - paddingRight) / 2 + paddingLeft)).toFloat(),
            key.y + ((key.height - paddingTop - paddingBottom) / 2).toFloat() + (mPaint.textSize - mPaint.descent()) / 2 + paddingTop.toFloat(),
            mPaint
        )
    }

    /**
     * 绘制按键icon
     */
    private fun drawIcon(canvas: Canvas, key: Keyboard.Key) {
        key.icon ?: return

        key.icon.setBounds(
            key.x + (key.width - key.icon.intrinsicWidth) / 2 + paddingStart,
            key.y + (key.height - key.icon.intrinsicHeight) / 2 + paddingTop,
            key.x + (key.width - key.icon.intrinsicWidth) / 2 + key.icon.intrinsicWidth + paddingStart,
            key.y + (key.height - key.icon.intrinsicHeight) / 2 + key.icon.intrinsicHeight + paddingTop
        )
        key.icon.draw(canvas)
    }

    companion object {
        // 数字键盘模式
        const val KEYBOARD_MODE_NUMBER = 1
        // 字母键盘模式
        const val KEYBOARD_MODE_QWERTY = 2
        // 数字键盘模式模式下按键背景
        private val NUMBER_KEY_BACKGROUND = Triple(
            R.drawable.selector_kb_number_keyboard_done,
            R.drawable.selector_kb_number_keyboard_action,
            R.drawable.selector_kb_number_keyboard_normal
        )
        // 字母键盘模式模式下按键背景
        private val QWERTY_KEY_BACKGROUND = Triple(
            R.drawable.selector_kb_qwerty_keyboard_done,
            R.drawable.selector_kb_qwerty_keyboard_action,
            R.drawable.selector_kb_qwerty_keyboard_normal
        )
    }
}

/**
 * 软键盘辅助类
 * @param rootView 页面的根布局 会在里面findViewById(R.id.keyboard_view)
 */
class RSKeyboard(
    rootView: View
) {
    /**
     * 点击KEYCODE_CANCEL时的回调
     */
    interface OnKeyboardCancelListener {
        fun onCancel()
    }

    /**
     * 点击KEYCODE_DONE时的回调
     */
    interface OnKeyboardDoneListener {
        fun onDone()
    }

    private val mKeyboardView: RSKeyboardView = rootView.findViewById(R.id.keyboard_view)

    // 要使用自定义键盘进行输入的输入框
    private var mAttachedEditText: EditText? = null

    // 点击按键时的回调
    private val mOnKeyboardActionListener =
        object : KeyboardView.OnKeyboardActionListener {
            /**
             * code值到文字的映射
             * -1001 -> 000
             * -1002 -> 002
             * -1003 -> 300
             * -1004 -> 600
             * -1005 -> 601
             */
            private val code2StringMap = SparseArray<String>(5)
            private val KEY_000 = "000"
            private val KEY_002 = "002"
            private val KEY_300 = "300"
            private val KEY_600 = "600"
            private val KEY_601 = "601"
            private val KEY_000_CODE = -1001
            private val KEY_002_CODE = -1002
            private val KEY_300_CODE = -1003
            private val KEY_600_CODE = -1004
            private val KEY_601_CODE = -1005

            init {
                code2StringMap[KEY_000_CODE] = KEY_000
                code2StringMap[KEY_002_CODE] = KEY_002
                code2StringMap[KEY_300_CODE] = KEY_300
                code2StringMap[KEY_600_CODE] = KEY_600
                code2StringMap[KEY_601_CODE] = KEY_601
            }

            override fun swipeRight() {}
            override fun onPress(primaryCode: Int) {}
            override fun onRelease(primaryCode: Int) {}
            override fun swipeLeft() {}
            override fun swipeUp() {}
            override fun swipeDown() {}
            override fun onText(text: CharSequence?) {}

            override fun onKey(primaryCode: Int, keyCodes: IntArray?) {
                mAttachedEditText?.let {
                    val editable = it.text
                    val start = it.selectionStart

                    when (primaryCode) {
                        Keyboard.KEYCODE_DELETE -> {
                            // primaryCode=-1004 keyCodes=[-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1]
                            // primaryCode=-5 keyCodes=[-5]
                            // primaryCode=-1004 keyCodes=[-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1]
                            // primaryCode=-5 keyCodes=[-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1]
                            // 连续点击多个codes的键时 会触发delete 此时keyCodes为[-5]
                            if (keyCodes?.size == 1) {
                                return
                            }
                            if (editable != null && editable.isNotEmpty() && start > 0) {
                                editable.delete(start - 1, start)
                            } else {
                            }
                        }
                        Keyboard.KEYCODE_CANCEL -> {
                            hideKeyBoard()
                            onKeyBoardCancelListener?.onCancel()
                            mAttachedEditText?.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP)
                        }
                        Keyboard.KEYCODE_DONE -> {
                            hideKeyBoard()
                            onKeyboardOkListener?.onDone()
                            mAttachedEditText?.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP)
                        }
                        Keyboard.KEYCODE_MODE_CHANGE -> {
                            mKeyboardView.toggleMode()
                            mAttachedEditText?.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP)
                        }
                        else -> {
                            if (code2StringMap.containsKey(primaryCode)) {
                                editable.insert(start, code2StringMap[primaryCode])
                            } else {
                                editable.insert(start, primaryCode.toChar().toString())
                            }
                            mAttachedEditText?.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP)
                        }
                    }
                }
            }
        }

    /**
     * 点击KEYCODE_DONE时的回调
     */
    var onKeyboardOkListener: OnKeyboardDoneListener? = null
    /**
     * 点击KEYCODE_CANCEL时的回调
     */
    var onKeyBoardCancelListener: OnKeyboardCancelListener? = null

    @SuppressLint("ClickableViewAccessibility")
    fun attachTo(editText: EditText) {
        mAttachedEditText = editText

        // 设置按键回调
        mKeyboardView.setOnKeyboardActionListener(mOnKeyboardActionListener)

        // 处理弹出、关闭键盘的逻辑
        editText.setOnClickListener {
            showKeyBoard()
        }
        editText.setOnTouchListener { _, _ ->
            editText.requestFocus()
            editText.requestFocusFromTouch()
            hideSystemSoftKeyboard(context, editText)
            return@setOnTouchListener  false
        }
        editText.setOnFocusChangeListener { _, hasFocus ->
            if (!hasFocus) {
                hideKeyBoard()
            }
        }
    }

    /**
     * 显示键盘
     */
    fun showKeyBoard() {
        if (mKeyboardView.visibility != View.VISIBLE) {
            mKeyboardView.visibility = View.VISIBLE
        }
    }

    /**
     * 隐藏键盘
     */
    fun hideKeyBoard() {
        if ( mKeyboardView.visibility == View.VISIBLE) {
            mKeyboardView.visibility = View.GONE
        }
    }

    companion object {
        /**
         * 隐藏系统键盘
         */
        @SuppressLint("ObsoleteSdkInt")
        fun hideSystemSoftKeyboard(context: Context, editText: EditText) {
            when {
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP -> {
                    editText.showSoftInputOnFocus = false
                }
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB -> {
                    try {
                        val clazz = EditText::class.java
                        val setShowSoftInputOnFocus = clazz.getMethod("setShowSoftInputOnFocus", Boolean::class.javaPrimitiveType)
                        setShowSoftInputOnFocus.isAccessible = true
                        setShowSoftInputOnFocus.invoke(editText, false)
                    } catch (e: Exception) { }
                }
                else -> {
                    editText.inputType = InputType.TYPE_NULL
                }
            }

            val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager ?: return
            imm.hideSoftInputFromWindow(editText.windowToken, 0)
        }
    }
}

class LoginActivity : BaseActivity() {
    ...
    @Inject
    lateinit var dataBinding: ViewDataBinding

    private val mRSKeyboard by lazy { RSKeyboard(dataBinding.root) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        mRSKeyboard.attachTo(etPhone)
        mRSKeyboard.onKeyboardOkListener = object : RSKeyboard.OnKeyboardDoneListener {
            override fun onDone() {
                viewModel.toastString.value = "DONE"
            }
        }
        mRSKeyboard.onKeyBoardCancelListener = object : RSKeyboard.OnKeyboardCancelListener {
            override fun onCancel() {
                viewModel.toastString.value = "CANCEL"
            }
        }
    }
}