System Button Events on Rokid Glasses

On Rokid Glasses, you can intercept system button events by listening for ordered broadcasts.

1 Button Broadcasts

Button broadcast actions are as follows:

package com.rokid.cxrssdksamples.activities.keys

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent

interface KeyReceiverListener {
    fun onReceive(keyType: KeyType)
}

enum class KeyType(val action: String) {
    CLICK(“com.android.action.ACTION_SPRITE_BUTTON_CLICK”),
    BUTTON_DOWN(“com.android.action.ACTION_SPRITE_BUTTON_DOWN”),
    BUTTON_UP(“com.android.action.ACTION_SPRITE_BUTTON_UP”),
    DOUBLE_CLICK(“com.android.action.ACTION_SPRITE_BUTTON_DOUBLE_CLICK”),
    AI_START(“com.android.action.ACTION_AI_START”),
    LONG_PRESS(“com.android.action.ACTION_SPRITE_BUTTON_LONG_PRESS”),
    ACTION_TWO_FINGER_SINGLE_TAP(“com.android.action.ACTION_TWO_FINGER_SINGLE_TAP”),
    ACTION_TWO_FINGER_DOUBLE_TAP(“com.android.action.ACTION_TWO_FINGER_DOUBLE_TAP”),
    ACTION_TWO_FINGER_SWIPE_FORWARD(“com.android.action.ACTION_TWO_FINGER_SWIPE_FORWARD”),
    ACTION_TWO_FINGER_SWIPE_BACK(“com.android.action.ACTION_TWO_FINGER_SWIPE_BACK”),
    ACTION_SETTINGS_KEY(“com.android.action.ACTION_SETTINGS_KEY”)
}

class KeyReceiver : BroadcastReceiver() {

    var listener: KeyReceiverListener? = null

    override fun onReceive(context: Context?, intent: Intent?) {
        intent?.action?.let {
            when (it) {
                KeyType.CLICK.action -> {
                    // Received button click — abort broadcast
                    listener?.onReceive(KeyType.CLICK)
                    abortBroadcast()
                }
                KeyType.BUTTON_DOWN.action -> {
                    // Button down — abort broadcast
                    listener?.onReceive(KeyType.BUTTON_DOWN)
                    abortBroadcast()
                }
                KeyType.BUTTON_UP.action -> {
                    // Button up — abort broadcast
                    listener?.onReceive(KeyType.BUTTON_UP)
                    abortBroadcast()
                }
                KeyType.DOUBLE_CLICK.action -> {
                    // Double click — abort broadcast (cannot be intercepted; this is the back/exit action)
                    listener?.onReceive(KeyType.DOUBLE_CLICK)
                    abortBroadcast()
                }
                KeyType.AI_START.action -> {
                    // AI start — abort broadcast
                    listener?.onReceive(KeyType.AI_START)
                    abortBroadcast()
                }
                KeyType.LONG_PRESS.action -> {
                    // Long press — abort broadcast
                    listener?.onReceive(KeyType.LONG_PRESS)
                    abortBroadcast()
                }
                KeyType.ACTION_TWO_FINGER_SINGLE_TAP.action -> {
                    // Two-finger single tap — abort broadcast
                    listener?.onReceive(KeyType.ACTION_TWO_FINGER_SINGLE_TAP)
                    abortBroadcast()
                }
                KeyType.ACTION_TWO_FINGER_DOUBLE_TAP.action -> {
                    // Two-finger double tap — abort broadcast
                    listener?.onReceive(KeyType.ACTION_TWO_FINGER_DOUBLE_TAP)
                    abortBroadcast()
                }
                KeyType.ACTION_TWO_FINGER_SWIPE_FORWARD.action -> {
                    // Two-finger swipe forward — abort broadcast
                    listener?.onReceive(KeyType.ACTION_TWO_FINGER_SWIPE_FORWARD)
                    abortBroadcast()
                }
                KeyType.ACTION_TWO_FINGER_SWIPE_BACK.action -> {
                    // Two-finger swipe back — abort broadcast
                    listener?.onReceive(KeyType.ACTION_TWO_FINGER_SWIPE_BACK)
                    abortBroadcast()
                }
                KeyType.ACTION_SETTINGS_KEY.action -> {
                    // Settings key — abort broadcast
                    listener?.onReceive(KeyType.ACTION_SETTINGS_KEY)
                    abortBroadcast()
                }
            }
        }
    }
}

2 Using Button Broadcasts

Reference implementation:

private val keyReceiver = KeyReceiver().apply {
    listener = object : KeyReceiverListener {
        override fun onReceive(keyType: KeyType) {
            // Update state to show latest key type in UI
            latestKeyType = keyType

            when (keyType) {
                KeyType.CLICK -> {
                    // Handle button click
                    Log.d(“KeysActivity”, “system event: button on left leg”)
                }
                KeyType.BUTTON_DOWN -> {
                    // Handle button down
                    Log.d(“KeysActivity”, “system event: button on left leg down”)
                }
                KeyType.BUTTON_UP -> {
                    // Handle button up
                    Log.d(“KeysActivity”, “system event: button on left leg up”)
                }
                KeyType.DOUBLE_CLICK -> {
                    // Handle double click
                    Log.d(“KeysActivity”, “system event: button on left leg double click”)
                }
                KeyType.AI_START -> {
                    // Touchpad long press
                    Log.d(“KeysActivity”, “system event: touchpad long pressed”)
                }
                KeyType.LONG_PRESS -> {
                    // Handle long press
                    Log.d(“KeysActivity”, “system event: long pressed the button on left leg”)
                }

                KeyType.ACTION_TWO_FINGER_SINGLE_TAP -> {
                    // Two-finger single tap
                    Log.d(“KeysActivity”, “system event: two finger single tap”)
                }
                KeyType.ACTION_TWO_FINGER_DOUBLE_TAP -> {
                    // Two-finger double tap
                    Log.d(“KeysActivity”, “system event: two finger double tap”)
                }
                KeyType.ACTION_TWO_FINGER_SWIPE_FORWARD -> {
                    // Two-finger swipe forward
                    Log.d(“KeysActivity”, “system event: two finger swipe forward”)
                }
                KeyType.ACTION_TWO_FINGER_SWIPE_BACK -> {
                    // Two-finger swipe back
                    Log.d(“KeysActivity”, “system event: two finger swipe back”)
                }
                KeyType.ACTION_SETTINGS_KEY -> {
                    // Two-finger long press
                    Log.d(“KeysActivity”, “system event: two finger long pressed”)
                }
            }
        }
    }
}
@SuppressLint(“UnspecifiedRegisterReceiverFlag”)
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    enableEdgeToEdge()

    // Keep screen on
    window.addFlags(android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)

    setContent {
        CXRSSDKSamplesTheme {
            KeysScreen(latestKeyType = latestKeyType?.name ?: "")
        }
    }
    registerReceiver(keyReceiver, IntentFilter().apply {
        addAction(KeyType.CLICK.action)
        addAction(KeyType.BUTTON_DOWN.action)
        addAction(KeyType.BUTTON_UP.action)
        addAction(KeyType.DOUBLE_CLICK.action)
        addAction(KeyType.AI_START.action)
        addAction(KeyType.LONG_PRESS.action)
        addAction(KeyType.ACTION_TWO_FINGER_SINGLE_TAP.action)
        addAction(KeyType.ACTION_TWO_FINGER_DOUBLE_TAP.action)
        addAction(KeyType.ACTION_TWO_FINGER_SWIPE_FORWARD.action)
        addAction(KeyType.ACTION_TWO_FINGER_SWIPE_BACK.action)
        addAction(KeyType.ACTION_SETTINGS_KEY.action)
        priority = 100
    })
}

Other Keys

Other key events can be received by listening for system KeyEvents.

@SuppressLint(“GestureBackNavigation”)
override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
    Log.d(“KeysActivity”, “onKeyDown: $keyCode”)
    when (keyCode) {
        KeyEvent.KEYCODE_BACK -> {
            // Intercept back key
            Log.d(“KeysActivity”, “onKeyDown: back pressed”)
            return true
        }
        KeyEvent.KEYCODE_ENTER->{
            Log.d(“KeysActivity”, “onKeyUp: touchpad single down”)
            return  true
        }
        else -> {
            Log.d(“KeysActivity”, “onKeyUp: $keyCode”)
        }
    }
    return super.onKeyDown(keyCode, event)
}

@SuppressLint(“GestureBackNavigation”)
override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
    Log.d(“KeysActivity”, “onKeyUp: $keyCode”)
    when (keyCode) {
        KeyEvent.KEYCODE_BACK -> {
            // Intercept back key
            Log.d(“KeysActivity”, “onKeyUp: back pressed”)
            return true
        }
        KeyEvent.KEYCODE_ENTER->{
            Log.d(“KeysActivity”, “onKeyUp: touchpad single up”)
            return  true
        }
        else -> {
            Log.d(“KeysActivity”, “onKeyUp: $keyCode”)
        }
    }
    return super.onKeyUp(keyCode, event)
}