KeyEvents interception made via window.callback swizzling

KeyEventHook.kt

class KeyEventHook private constructor(
        private val window: Window,
        private val handleKeyEvent: (KeyEvent) -> Boolean,
        private var originalCallback: Window.Callback) 
: Window.Callback by originalCallback
{
    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
        if (handleKeyEvent(event))
            return true
        return originalCallback.dispatchKeyEvent(event)
    }

    fun unhook() {
        if (originalCallback !is KeyEventHook)
            window.callback = originalCallback
        else if (window.callback is KeyEventHook)
            window.callback = null
    }

    init {
        window.callback = this
    }

    companion object {
        fun hook(activity: Activity, handler: (KeyEvent) -> Boolean): KeyEventHook? {
            val window = activity.window ?: return null
            val callback = window.callback ?: return null
            return KeyEventHook(activity, window, handler, callback)
        }
    }
}

SomeView.kt

class SomeView: View {
    @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0) : super(context, attrs, defStyleAttr) {}
    
    private var _hook: KeyEventHook? = null
    override fun onAttachedToWindow() {
        super.onAttachedToWindow()
        (this.context as? Activity)?.let {
            _hook = KeyEventHook.hook(it) { event ->
                if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
                    setBackgroundColor(Color.RED)
                    true
                } else
                    false
            }
        }
    }

    override fun onDetachedFromWindow() {
        _hook?.unhook()
        super.onDetachedFromWindow()
    }
}