feat: Trinkets tab with a Bluetooth controller mode

This commit is contained in:
Kurt Himebauch committed 2026-11-02 20:58:14 -05:00
1 parent cdde9d3390
commit 6ead4af37e
8 files changed
+1741 -1

No files matched your search

@@ -0,0 +1,506 @@
package com.droiddeck.launcher
import android.content.Context
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.view.InputDevice
import android.view.KeyEvent
import android.view.MotionEvent
import android.view.WindowManager
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.gestures.awaitEachGesture
import androidx.compose.foundation.gestures.awaitFirstDown
import androidx.compose.foundation.gestures.waitForUpOrCancellation
import androidx.compose.foundation.horizontalScroll
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.offset
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.droiddeck.launcher.core.AppLanguage
import com.droiddeck.launcher.input.bt.BtGamepad
import com.droiddeck.launcher.input.bt.BtPadProfile
import com.droiddeck.launcher.input.bt.BtPadState
import com.droiddeck.launcher.ui.DroidDeckTheme
import com.droiddeck.launcher.ui.LocalPalette
import com.droiddeck.launcher.ui.PrimaryButton
import com.droiddeck.launcher.ui.SecondaryButton
import kotlin.math.hypot
import kotlin.math.roundToInt
class BtControllerActivity : ComponentActivity() {
private val physical = BtPadState()
private val touch = BtPadState()
private val merged = BtPadState()
private var keyButtons = 0
private var hatButtons = 0
private val main = Handler(Looper.getMainLooper())
private val exitHold = Runnable { finish() }
private var exitArmed = false
private var profile by mutableStateOf(BtPadProfile.GENERIC)
private var showTouch by mutableStateOf(true)
override fun attachBaseContext(newBase: Context) = super.attachBaseContext(AppLanguage.wrap(newBase))
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
val prefs = prefs(this)
profile = BtPadProfile.byId(prefs.getString(KEY_PROFILE, null))
showTouch = prefs.getBoolean(KEY_TOUCH, true)
val wanted = if (Build.VERSION.SDK_INT >= 31) NEARBY + LOCATION else LOCATION
val missing = wanted.filter { checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED }
if (missing.isEmpty()) startPad() else requestPermissions(missing.toTypedArray(), REQUEST_NEARBY)
setContent { DroidDeckTheme { Screen() } }
}
private fun startPad() {
BtGamepad.start(this, profile)
BtGamepad.openPairingWindow()
}
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
if (requestCode == REQUEST_NEARBY) startPad()
}
override fun onDestroy() {
main.removeCallbacks(exitHold)
if (isFinishing) BtGamepad.stop()
super.onDestroy()
}
private fun pickProfile(p: BtPadProfile) {
if (p == profile) return
profile = p
prefs(this).edit().putString(KEY_PROFILE, p.id).apply()
BtGamepad.switchProfile(p)
}
private fun push() {
physical.buttons = keyButtons or hatButtons
merged.merge(physical, touch)
BtGamepad.update(merged)
val combo = BtPadState.SELECT or BtPadState.START
val held = physical.buttons and combo == combo
if (held && !exitArmed) main.postDelayed(exitHold, EXIT_HOLD_MS)
else if (!held && exitArmed) main.removeCallbacks(exitHold)
exitArmed = held
}
private fun isPad(event: KeyEvent): Boolean {
val s = event.source
return s and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD ||
s and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK ||
KeyEvent.isGamepadButton(event.keyCode)
}
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
val bit = KEYS[event.keyCode]
if (bit == null || event.keyCode in DPAD_KEYS && !isPad(event) && event.source and InputDevice.SOURCE_DPAD != InputDevice.SOURCE_DPAD) {
return super.dispatchKeyEvent(event)
}
when (event.action) {
KeyEvent.ACTION_DOWN -> keyButtons = keyButtons or bit
KeyEvent.ACTION_UP -> keyButtons = keyButtons and bit.inv()
}
push()
return true
}
override fun dispatchGenericMotionEvent(event: MotionEvent): Boolean {
if (event.source and InputDevice.SOURCE_JOYSTICK != InputDevice.SOURCE_JOYSTICK || event.action != MotionEvent.ACTION_MOVE) {
return super.dispatchGenericMotionEvent(event)
}
val device = event.device
fun axis(code: Int): Float {
val range = device?.getMotionRange(code, event.source) ?: return 0f
val v = event.getAxisValue(code)
return if (Math.abs(v) > maxOf(range.flat, 0.04f)) v else 0f
}
val hasZ = device?.getMotionRange(MotionEvent.AXIS_Z, event.source) != null
physical.lx = axis(MotionEvent.AXIS_X); physical.ly = axis(MotionEvent.AXIS_Y)
physical.rx = axis(if (hasZ) MotionEvent.AXIS_Z else MotionEvent.AXIS_RX)
physical.ry = axis(if (hasZ) MotionEvent.AXIS_RZ else MotionEvent.AXIS_RY)
physical.lt = maxOf(axis(MotionEvent.AXIS_LTRIGGER), axis(MotionEvent.AXIS_BRAKE))
physical.rt = maxOf(axis(MotionEvent.AXIS_RTRIGGER), axis(MotionEvent.AXIS_GAS))
val hx = event.getAxisValue(MotionEvent.AXIS_HAT_X)
val hy = event.getAxisValue(MotionEvent.AXIS_HAT_Y)
hatButtons = (if (hy < -0.5f) BtPadState.UP else 0) or (if (hy > 0.5f) BtPadState.DOWN else 0) or
(if (hx < -0.5f) BtPadState.LEFT else 0) or (if (hx > 0.5f) BtPadState.RIGHT else 0)
push()
return true
}
private fun touchButton(bit: Int, down: Boolean) {
touch.buttons = if (down) touch.buttons or bit else touch.buttons and bit.inv()
if (bit == BtPadState.LT) touch.lt = if (down) 1f else 0f
if (bit == BtPadState.RT) touch.rt = if (down) 1f else 0f
push()
}
private fun touchStick(left: Boolean, x: Float, y: Float) {
if (left) { touch.lx = x; touch.ly = y } else { touch.rx = x; touch.ry = y }
push()
}
@Composable
private fun Screen() {
val status by BtGamepad.status.collectAsState()
val colors = MaterialTheme.colorScheme
Column(Modifier.fillMaxSize().background(colors.background).padding(horizontal = 16.dp, vertical = 10.dp)) {
Panel(status)
if (showTouch) {
Spacer(Modifier.height(8.dp))
TouchPad(Modifier.weight(1f).fillMaxWidth(), status.lightbar)
} else {
Spacer(Modifier.weight(1f))
}
Text(stringResource(R.string.btpad_exit_hint), fontSize = 12.sp, color = colors.onSurfaceVariant,
modifier = Modifier.align(Alignment.CenterHorizontally).padding(top = 6.dp))
}
}
@Composable
private fun Panel(status: BtGamepad.Status) {
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
val connected = status.phase == BtGamepad.Phase.CONNECTED
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
Box(Modifier.size(12.dp).clip(CircleShape).background(status.lightbar?.let { Color(it) } ?: if (connected) pal.signal else colors.onSurfaceVariant.copy(alpha = 0.4f)))
Column(Modifier.weight(1f)) {
Text(stringResource(R.string.btpad_title), fontSize = 20.sp, fontWeight = FontWeight.Black, color = colors.onBackground)
Text(statusText(status), fontSize = 13.sp, color = colors.onSurfaceVariant)
}
if (connected) SecondaryButton(stringResource(R.string.btpad_disconnect), compact = true) { BtGamepad.disconnect() }
else PrimaryButton(stringResource(R.string.btpad_pair), compact = true, enabled = status.phase == BtGamepad.Phase.READY) { BtGamepad.openPairingWindow() }
SecondaryButton(stringResource(R.string.btpad_close), compact = true) { finish() }
}
Row(Modifier.horizontalScroll(rememberScrollState()).padding(top = 8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {
BtPadProfile.entries.forEach { p -> Chip(profileLabel(p), p == profile) { pickProfile(p) } }
Spacer(Modifier.width(8.dp))
Chip(stringResource(R.string.btpad_touch), showTouch) {
showTouch = !showTouch
prefs(this@BtControllerActivity).edit().putBoolean(KEY_TOUCH, showTouch).apply()
}
}
if (!connected) Text(stringResource(R.string.btpad_switch_hint), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 6.dp))
}
@Composable
private fun statusText(status: BtGamepad.Status): String = when (status.phase) {
BtGamepad.Phase.OFF, BtGamepad.Phase.STARTING -> stringResource(R.string.btpad_status_starting)
BtGamepad.Phase.BLUETOOTH_OFF -> stringResource(R.string.btpad_status_bt_off)
BtGamepad.Phase.UNSUPPORTED -> stringResource(R.string.btpad_status_unsupported)
BtGamepad.Phase.READY -> stringResource(R.string.btpad_status_ready, status.name ?: "")
BtGamepad.Phase.CONNECTING -> stringResource(R.string.btpad_status_connecting, status.host ?: "")
BtGamepad.Phase.CONNECTED -> stringResource(R.string.btpad_status_connected, status.host ?: "")
}
@Composable
private fun profileLabel(p: BtPadProfile) = stringResource(when (p) {
BtPadProfile.GENERIC -> R.string.btpad_profile_generic
BtPadProfile.XBOX -> R.string.btpad_profile_xbox
BtPadProfile.DUALSHOCK4 -> R.string.btpad_profile_ds4
BtPadProfile.DUALSENSE -> R.string.btpad_profile_dualsense
BtPadProfile.STEAM -> R.string.btpad_profile_steam
})
@Composable
private fun Chip(label: String, on: Boolean, enabled: Boolean = true, onClick: () -> Unit) {
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
Text(label, fontSize = 13.sp, fontWeight = FontWeight.SemiBold,
color = if (on) colors.background else if (enabled) colors.onBackground else colors.onSurfaceVariant,
modifier = Modifier.clip(CircleShape).background(if (on) pal.signal else colors.surface)
.border(1.dp, if (on) pal.signal else pal.line2, CircleShape)
.clickable(enabled = enabled, onClick = onClick).padding(horizontal = 14.dp, vertical = 8.dp))
}
@Composable
private fun TouchPad(modifier: Modifier, lightbar: Int?) {
val sony = profile == BtPadProfile.DUALSHOCK4 || profile == BtPadProfile.DUALSENSE
val steam = profile == BtPadProfile.STEAM
BoxWithConstraints(modifier) {
val unit = minOf(maxWidth / 10f, maxHeight / 6.6f)
val gap = unit * 0.2f
val stick = unit * 2f
val btn = unit * 0.95f
val shoulderW = unit * 1.4f
val shoulderH = unit * 0.7f
Row(Modifier.fillMaxSize(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.Bottom) {
Column(verticalArrangement = Arrangement.spacedBy(gap)) {
Row(horizontalArrangement = Arrangement.spacedBy(gap)) {
PadButton(if (sony) "L2" else "LT", BtPadState.LT, shoulderW, shoulderH)
PadButton(if (sony) "L1" else "LB", BtPadState.LB, shoulderW, shoulderH)
}
Stick(stick, left = true)
Cross(btn)
}
Column(Modifier.fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(gap * 2, Alignment.CenterVertically), horizontalAlignment = Alignment.CenterHorizontally) {
if (steam) Row(horizontalArrangement = Arrangement.spacedBy(gap)) {
PadButton("L5", BtPadState.L5, unit * 0.8f, unit * 0.6f)
PadButton("L4", BtPadState.L4, unit * 0.8f, unit * 0.6f)
Spacer(Modifier.width(gap * 2))
PadButton("R4", BtPadState.R4, unit * 0.8f, unit * 0.6f)
PadButton("R5", BtPadState.R5, unit * 0.8f, unit * 0.6f)
}
Row(horizontalArrangement = Arrangement.spacedBy(gap), verticalAlignment = Alignment.CenterVertically) {
PadButton(if (sony) "Share" else "View", BtPadState.SELECT, unit * 1.2f, unit * 0.6f)
PadButton(if (sony) "PS" else if (steam) "Steam" else "Home", BtPadState.GUIDE, unit * 1.2f, unit * 0.6f, tint = lightbar?.let { Color(it) })
PadButton(if (sony) "Options" else "Menu", BtPadState.START, unit * 1.2f, unit * 0.6f)
}
Row(horizontalArrangement = Arrangement.spacedBy(gap)) {
PadButton("L3", BtPadState.L3, unit * 0.9f, unit * 0.6f)
if (sony) PadButton("Pad", BtPadState.TOUCHPAD, unit * 1.2f, unit * 0.6f)
if (steam) PadButton("···", BtPadState.SHARE, unit * 1.2f, unit * 0.6f)
PadButton("R3", BtPadState.R3, unit * 0.9f, unit * 0.6f)
}
if (steam) Row(horizontalArrangement = Arrangement.spacedBy(gap * 2)) {
Trackpad(unit * 1.9f, left = true)
Trackpad(unit * 1.9f, left = false)
}
}
Column(verticalArrangement = Arrangement.spacedBy(gap), horizontalAlignment = Alignment.End) {
Row(horizontalArrangement = Arrangement.spacedBy(gap)) {
PadButton(if (sony) "R1" else "RB", BtPadState.RB, shoulderW, shoulderH)
PadButton(if (sony) "R2" else "RT", BtPadState.RT, shoulderW, shoulderH)
}
Diamond(btn, sony)
Stick(stick, left = false)
}
}
}
}
@Composable
private fun Trackpad(size: Dp, left: Boolean) {
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
var dot by remember { mutableStateOf<Offset?>(null) }
val px = with(LocalDensity.current) { size.toPx() }
Box(
Modifier.size(size).clip(RoundedCornerShape(18.dp)).background(colors.surface).border(1.dp, pal.line2, RoundedCornerShape(18.dp))
.pointerInput(left) {
awaitEachGesture {
val first = awaitFirstDown(requireUnconsumed = false)
val started = first.uptimeMillis
fun norm(p: Offset) = Offset((p.x / this.size.width * 2f - 1f).coerceIn(-1f, 1f), (p.y / this.size.height * 2f - 1f).coerceIn(-1f, 1f))
var moved = 0f
var last = norm(first.position)
dot = last
touchPad(left, last, true)
var upTime = started
while (true) {
val change = awaitPointerEvent().changes.firstOrNull { it.id == first.id } ?: break
if (!change.pressed) { upTime = change.uptimeMillis; break }
change.consume()
val p = norm(change.position)
moved += (p - last).getDistance()
last = p
dot = p
touchPad(left, p, true)
}
dot = null
if (upTime - started < TAP_MS && moved < 0.15f) clickPad(left, last)
else touchPad(left, last, false)
}
},
) {
dot?.let { d ->
val r = px * 0.08f
Box(Modifier.offset { IntOffset(((d.x + 1f) / 2f * px - r).roundToInt(), ((d.y + 1f) / 2f * px - r).roundToInt()) }
.size(size * 0.16f).clip(CircleShape).background(pal.signal))
}
}
}
private fun touchPad(left: Boolean, p: Offset, down: Boolean) {
val bit = if (left) BtPadState.LPAD_TOUCH else BtPadState.RPAD_TOUCH
touch.buttons = if (down) touch.buttons or bit else touch.buttons and bit.inv()
if (left) { touch.lpx = p.x; touch.lpy = p.y } else { touch.rpx = p.x; touch.rpy = p.y }
push()
}
private fun clickPad(left: Boolean, p: Offset) {
val click = if (left) BtPadState.LPAD_CLICK else BtPadState.RPAD_CLICK
touch.buttons = touch.buttons or click
touchPad(left, p, true)
main.postDelayed({
touch.buttons = touch.buttons and click.inv()
touchPad(left, p, false)
}, CLICK_MS)
}
@Composable
private fun Cross(size: Dp) {
Column(horizontalAlignment = Alignment.CenterHorizontally) {
PadButton("▲", BtPadState.UP, size, size)
Row {
PadButton("◀", BtPadState.LEFT, size, size)
Spacer(Modifier.size(size))
PadButton("▶", BtPadState.RIGHT, size, size)
}
PadButton("▼", BtPadState.DOWN, size, size)
}
}
@Composable
private fun Diamond(size: Dp, sony: Boolean) {
Column(horizontalAlignment = Alignment.CenterHorizontally) {
PadButton(if (sony) "△" else "Y", BtPadState.Y, size, size, round = true)
Row {
PadButton(if (sony) "□" else "X", BtPadState.X, size, size, round = true)
Spacer(Modifier.size(size))
PadButton(if (sony) "○" else "B", BtPadState.B, size, size, round = true)
}
PadButton(if (sony) "✕" else "A", BtPadState.A, size, size, round = true)
}
}
@Composable
private fun PadButton(label: String, bit: Int, width: Dp, height: Dp, round: Boolean = false, tint: Color? = null) {
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
var down by remember { mutableStateOf(false) }
val shape = if (round) CircleShape else RoundedCornerShape(10.dp)
Box(
contentAlignment = Alignment.Center,
modifier = Modifier.size(width, height).clip(shape)
.background(if (down) pal.signal else tint?.copy(alpha = 0.35f) ?: colors.surface)
.border(1.dp, pal.line2, shape)
.pointerInput(bit) {
awaitEachGesture {
awaitFirstDown(requireUnconsumed = false)
down = true; touchButton(bit, true)
waitForUpOrCancellation()
down = false; touchButton(bit, false)
}
},
) {
Text(label, fontSize = 14.sp, fontWeight = FontWeight.Bold, color = if (down) colors.background else colors.onBackground)
}
}
@Composable
private fun Stick(size: Dp, left: Boolean) {
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
var knob by remember { mutableStateOf(Offset.Zero) }
val px = with(LocalDensity.current) { size.toPx() }
val knobSize = size * 0.42f
Box(
contentAlignment = Alignment.Center,
modifier = Modifier.size(size).clip(CircleShape).background(colors.surface).border(1.dp, pal.line2, CircleShape)
.pointerInput(left) {
awaitEachGesture {
val first = awaitFirstDown(requireUnconsumed = false)
val radius = this.size.width / 2f
val center = Offset(radius, this.size.height / 2f)
fun move(p: Offset) {
var d = (p - center) / (radius * 0.8f)
val len = hypot(d.x, d.y)
if (len > 1f) d /= len
knob = d
touchStick(left, d.x, d.y)
}
move(first.position)
while (true) {
val change = awaitPointerEvent().changes.firstOrNull { it.id == first.id } ?: break
if (!change.pressed) break
change.consume()
move(change.position)
}
knob = Offset.Zero
touchStick(left, 0f, 0f)
}
},
) {
val travel = px * 0.29f
Box(Modifier.offset { IntOffset((knob.x * travel).roundToInt(), (knob.y * travel).roundToInt()) }
.size(knobSize).clip(CircleShape).background(if (knob != Offset.Zero) pal.signal else colors.onSurfaceVariant.copy(alpha = 0.5f)))
}
}
companion object {
private const val EXIT_HOLD_MS = 1_500L
private const val TAP_MS = 200L
private const val CLICK_MS = 90L
private const val REQUEST_NEARBY = 41
private val NEARBY = listOf("android.permission.BLUETOOTH_ADVERTISE", "android.permission.BLUETOOTH_CONNECT", "android.permission.BLUETOOTH_SCAN")
private val LOCATION = listOf("android.permission.ACCESS_FINE_LOCATION")
private const val KEY_PROFILE = "btpad_profile"
private const val KEY_TOUCH = "btpad_touch"
private fun prefs(c: Context) = c.getSharedPreferences("trinkets", Context.MODE_PRIVATE)
private val DPAD_KEYS = setOf(KeyEvent.KEYCODE_DPAD_UP, KeyEvent.KEYCODE_DPAD_DOWN, KeyEvent.KEYCODE_DPAD_LEFT, KeyEvent.KEYCODE_DPAD_RIGHT)
private val KEYS = mapOf(
KeyEvent.KEYCODE_BUTTON_A to BtPadState.A,
KeyEvent.KEYCODE_BUTTON_B to BtPadState.B,
KeyEvent.KEYCODE_BUTTON_X to BtPadState.X,
KeyEvent.KEYCODE_BUTTON_Y to BtPadState.Y,
KeyEvent.KEYCODE_BUTTON_L1 to BtPadState.LB,
KeyEvent.KEYCODE_BUTTON_R1 to BtPadState.RB,
KeyEvent.KEYCODE_BUTTON_L2 to BtPadState.LT,
KeyEvent.KEYCODE_BUTTON_R2 to BtPadState.RT,
KeyEvent.KEYCODE_BUTTON_SELECT to BtPadState.SELECT,
KeyEvent.KEYCODE_BUTTON_START to BtPadState.START,
KeyEvent.KEYCODE_BUTTON_MODE to BtPadState.GUIDE,
KeyEvent.KEYCODE_BUTTON_THUMBL to BtPadState.L3,
KeyEvent.KEYCODE_BUTTON_THUMBR to BtPadState.R3,
KeyEvent.KEYCODE_BUTTON_C to BtPadState.L4,
KeyEvent.KEYCODE_BUTTON_Z to BtPadState.R4,
KeyEvent.KEYCODE_BUTTON_1 to BtPadState.L4,
KeyEvent.KEYCODE_BUTTON_2 to BtPadState.R4,
KeyEvent.KEYCODE_BUTTON_3 to BtPadState.L5,
KeyEvent.KEYCODE_BUTTON_4 to BtPadState.R5,
KeyEvent.KEYCODE_DPAD_UP to BtPadState.UP,
KeyEvent.KEYCODE_DPAD_DOWN to BtPadState.DOWN,
KeyEvent.KEYCODE_DPAD_LEFT to BtPadState.LEFT,
KeyEvent.KEYCODE_DPAD_RIGHT to BtPadState.RIGHT,
)
}
}
@@ -0,0 +1,582 @@
package com.droiddeck.launcher.input.bt
import android.annotation.SuppressLint
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothGatt
import android.bluetooth.BluetoothGattCallback
import android.bluetooth.BluetoothGattCharacteristic
import android.bluetooth.BluetoothGattDescriptor
import android.bluetooth.BluetoothGattServer
import android.bluetooth.BluetoothGattServerCallback
import android.bluetooth.BluetoothGattService
import android.bluetooth.BluetoothManager
import android.bluetooth.BluetoothProfile
import android.bluetooth.le.AdvertiseData
import android.bluetooth.le.AdvertisingSet
import android.bluetooth.le.AdvertisingSetCallback
import android.bluetooth.le.AdvertisingSetParameters
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.Build
import android.os.Handler
import android.os.HandlerThread
import android.os.ParcelUuid
import android.os.VibrationEffect
import android.os.Vibrator
import android.util.Log
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import java.util.ArrayDeque
import java.util.UUID
@SuppressLint("MissingPermission")
object BtGamepad {
enum class Phase { OFF, STARTING, BLUETOOTH_OFF, UNSUPPORTED, READY, CONNECTING, CONNECTED }
data class Status(val phase: Phase, val host: String? = null, val lightbar: Int? = null, val name: String? = null)
private const val TAG = "BtGamepad"
private val _status = MutableStateFlow(Status(Phase.OFF))
val status: StateFlow<Status> = _status
private var handler: Handler? = null
private var app: Context? = null
private var server: BluetoothGattServer? = null
private var advertising = false
private var profile = BtPadProfile.GENERIC
private var encoder: BtPadEncoder = profile.encoder()
private val pendingServices = ArrayDeque<BluetoothGattService>()
private val reportRefs = HashMap<BluetoothGattCharacteristic, Pair<Int, Int>>()
private val inputChars = HashMap<Int, BluetoothGattCharacteristic>()
private val longReads = HashMap<BluetoothGattCharacteristic, ByteArray>()
private val preparedWrites = HashMap<BluetoothGattCharacteristic, ByteArray>()
private var host: BluetoothDevice? = null
private var priorityLink: BluetoothGatt? = null
private var notifyPending = false
private var dirty = false
private var mtu = 23
private val latest = BtPadState()
private val sent = BtPadState()
private var sentOnce = false
private var vibrator: Vibrator? = null
@Volatile private var running = false
private var pairingUntil = 0L
private var fastLinkPending = false
private const val PAIRING_WINDOW_MS = 120_000L
private const val MAX_MTU = 517
private const val FAST_LINK_DELAY_MS = 1_500L
fun start(context: Context, p: BtPadProfile) {
val h = handler ?: init(context)
h.post {
running = true
if (server != null && p == profile) {
publish(Phase.READY)
startAdvertising()
} else {
close()
profile = p
publish(Phase.STARTING)
open()
}
}
}
private fun init(context: Context): Handler {
val ctx = context.applicationContext
app = ctx
vibrator = ctx.getSystemService(Vibrator::class.java)
val t = HandlerThread("bt-gamepad").apply { start() }
val h = Handler(t.looper)
handler = h
val receiver = object : BroadcastReceiver() {
override fun onReceive(c: Context, intent: Intent) {
when (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1)) {
BluetoothAdapter.STATE_ON -> h.post { if (running) open() }
BluetoothAdapter.STATE_TURNING_OFF, BluetoothAdapter.STATE_OFF -> h.post {
close()
publish(Phase.BLUETOOTH_OFF)
}
}
}
}
ctx.registerReceiver(receiver, IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED), null, h)
return h
}
fun stop() {
val h = handler ?: return
h.post {
running = false
rumble(0, 0)
pairingUntil = 0
keepScanning()
stopAdvertising()
h.removeCallbacks(periodic)
dropFastLink()
host?.let { d -> runCatching { server?.cancelConnection(d) } }
host = null
_status.value = Status(Phase.OFF)
}
}
fun switchProfile(p: BtPadProfile) {
val h = handler ?: return
h.post {
if (p == profile && server != null) return@post
profile = p
close()
publish(Phase.STARTING)
h.postDelayed(::open, 300)
}
}
fun update(s: BtPadState) {
val h = handler ?: return
synchronized(latest) { latest.set(s) }
h.post(::sendIfChanged)
}
fun openPairingWindow() {
val h = handler ?: return
h.post {
pairingUntil = System.currentTimeMillis() + PAIRING_WINDOW_MS
keepScanning()
if (host == null) {
stopAdvertising()
startAdvertising()
}
}
}
private fun keepScanning() {
val adapter = adapter() ?: return
val h = handler ?: return
h.removeCallbacks(scanTick)
if (host != null || System.currentTimeMillis() > pairingUntil) {
runCatching { if (adapter.isDiscovering) adapter.cancelDiscovery() }
return
}
runCatching { if (!adapter.isDiscovering) adapter.startDiscovery() }
h.postDelayed(scanTick, 2_000)
}
private val scanTick = Runnable { keepScanning() }
fun disconnect() {
handler?.post { host?.let { d -> server?.cancelConnection(d) } }
}
private fun manager() = app?.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
private fun adapter(): BluetoothAdapter? = manager()?.adapter
private fun open() {
val ctx = app ?: return
if (server != null || !running) return
val manager = manager()
val adapter = manager?.adapter
if (adapter == null || !ctx.packageManager.hasSystemFeature("android.hardware.bluetooth_le")) {
publish(Phase.UNSUPPORTED)
return
}
if (!adapter.isEnabled) {
publish(Phase.BLUETOOTH_OFF)
return
}
if (adapter.bluetoothLeAdvertiser == null) {
publish(Phase.UNSUPPORTED)
return
}
encoder = profile.encoder()
sentOnce = false
val s = runCatching { manager.openGattServer(ctx, serverCallback) }
.onFailure { Log.w(TAG, "no GATT server", it) }.getOrNull()
if (s == null) {
publish(Phase.UNSUPPORTED)
return
}
server = s
pendingServices.clear()
pendingServices.add(deviceInfoService())
pendingServices.add(hidService())
addNextService()
}
private fun close() {
stopAdvertising()
pairingUntil = 0
keepScanning()
dropFastLink()
server?.let { s ->
runCatching { manager()?.getConnectedDevices(BluetoothProfile.GATT_SERVER)?.forEach { s.cancelConnection(it) } }
runCatching { s.clearServices(); s.close() }
}
server = null
host = null
notifyPending = false
dirty = false
reportRefs.clear()
inputChars.clear()
longReads.clear()
preparedWrites.clear()
}
private fun addNextService() {
val s = server ?: return
val next = pendingServices.pollFirst()
if (next == null) {
Log.i(TAG, "${profile.id}: services ready")
startAdvertising()
return
}
if (!s.addService(next)) {
Log.w(TAG, "addService ${next.uuid} refused")
publish(Phase.UNSUPPORTED)
}
}
private fun deviceInfoService(): BluetoothGattService {
val service = BluetoothGattService(uuid16(0x180A), BluetoothGattService.SERVICE_TYPE_PRIMARY)
val pnp = BtPadEncoder.bytes(0x02, profile.vendorId and 0xFF, profile.vendorId shr 8,
profile.productId and 0xFF, profile.productId shr 8, profile.version and 0xFF, profile.version shr 8)
service.addCharacteristic(readOnly(0x2A50, pnp))
service.addCharacteristic(readOnly(0x2A29, "DroidDeck".toByteArray()))
return service
}
private fun hidService(): BluetoothGattService {
val service = BluetoothGattService(uuid16(0x1812), BluetoothGattService.SERVICE_TYPE_PRIMARY)
service.addCharacteristic(readOnly(0x2A4A, BtPadEncoder.bytes(0x11, 0x01, 0x00, 0x02)))
service.addCharacteristic(readOnly(0x2A4B, encoder.descriptor))
service.addCharacteristic(BluetoothGattCharacteristic(uuid16(0x2A4C),
BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE, BluetoothGattCharacteristic.PERMISSION_WRITE))
for ((id, type) in encoder.reports) {
val props = when (type) {
BtPadEncoder.INPUT -> BluetoothGattCharacteristic.PROPERTY_READ or BluetoothGattCharacteristic.PROPERTY_NOTIFY
BtPadEncoder.OUTPUT -> BluetoothGattCharacteristic.PROPERTY_READ or BluetoothGattCharacteristic.PROPERTY_WRITE or
BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE
else -> BluetoothGattCharacteristic.PROPERTY_READ or BluetoothGattCharacteristic.PROPERTY_WRITE
}
val chr = BluetoothGattCharacteristic(uuid16(0x2A4D), props,
BluetoothGattCharacteristic.PERMISSION_READ or BluetoothGattCharacteristic.PERMISSION_WRITE)
if (type == BtPadEncoder.INPUT) {
chr.addDescriptor(cccd())
inputChars[id] = chr
}
val ref = BluetoothGattDescriptor(uuid16(0x2908), BluetoothGattDescriptor.PERMISSION_READ)
@Suppress("DEPRECATION")
ref.value = BtPadEncoder.bytes(id, type)
chr.addDescriptor(ref)
reportRefs[chr] = id to type
service.addCharacteristic(chr)
}
return service
}
private fun readOnly(uuid: Int, value: ByteArray): BluetoothGattCharacteristic {
val chr = BluetoothGattCharacteristic(uuid16(uuid), BluetoothGattCharacteristic.PROPERTY_READ, BluetoothGattCharacteristic.PERMISSION_READ)
@Suppress("DEPRECATION")
chr.value = value
return chr
}
private fun cccd() = BluetoothGattDescriptor(uuid16(0x2902),
BluetoothGattDescriptor.PERMISSION_READ or BluetoothGattDescriptor.PERMISSION_WRITE)
private fun uuid16(v: Int): UUID = UUID.fromString("%08x-0000-1000-8000-00805f9b34fb".format(v))
private fun startAdvertising() {
val advertiser = adapter()?.bluetoothLeAdvertiser ?: return
if (advertising || server == null || host != null || !running) return
val params = AdvertisingSetParameters.Builder()
.setLegacyMode(true)
.setConnectable(true)
.setScannable(true)
.setInterval(AdvertisingSetParameters.INTERVAL_LOW)
.setTxPowerLevel(AdvertisingSetParameters.TX_POWER_HIGH)
.build()
val data = AdvertiseData.Builder()
.addServiceUuid(ParcelUuid(uuid16(0x1812)))
.setIncludeDeviceName(true)
.build()
advertising = runCatching { advertiser.startAdvertisingSet(params, data, null, null, null, advertiseCallback); true }
.onFailure { Log.w(TAG, "advertising refused", it) }.getOrDefault(false)
if (!advertising) publish(Phase.UNSUPPORTED)
}
private fun stopAdvertising() {
if (!advertising) return
advertising = false
runCatching { adapter()?.bluetoothLeAdvertiser?.stopAdvertisingSet(advertiseCallback) }
}
private val advertiseCallback = object : AdvertisingSetCallback() {
override fun onAdvertisingSetStarted(set: AdvertisingSet?, txPower: Int, status: Int) {
Log.i(TAG, "advertising status $status")
handler?.post {
if (status == ADVERTISE_SUCCESS) {
if (host == null) publish(Phase.READY)
} else {
advertising = false
publish(Phase.UNSUPPORTED)
}
}
}
}
private val serverCallback = object : BluetoothGattServerCallback() {
override fun onServiceAdded(status: Int, service: BluetoothGattService) {
handler?.post {
if (status != BluetoothGatt.GATT_SUCCESS) {
Log.w(TAG, "service ${service.uuid} failed: $status")
publish(Phase.UNSUPPORTED)
} else addNextService()
}
}
override fun onConnectionStateChange(device: BluetoothDevice, status: Int, newState: Int) {
handler?.post {
Log.i(TAG, "${device.address}: state $newState status $status bond ${device.bondState}")
if (newState == BluetoothProfile.STATE_CONNECTED) {
stopAdvertising()
if (!running) {
server?.cancelConnection(device)
return@post
}
mtu = 23
if (device.bondState == BluetoothDevice.BOND_BONDED) attach(device)
else if (host == null) publish(Phase.CONNECTING, device)
} else if (newState == BluetoothProfile.STATE_DISCONNECTED && host == device) {
host = null
rumble(0, 0)
dropFastLink()
publish(Phase.READY)
startAdvertising()
} else if (newState == BluetoothProfile.STATE_DISCONNECTED && host == null) {
publish(Phase.READY)
startAdvertising()
}
}
}
override fun onMtuChanged(device: BluetoothDevice, newMtu: Int) {
handler?.post {
mtu = newMtu
Log.i(TAG, "mtu $newMtu")
}
}
override fun onCharacteristicReadRequest(device: BluetoothDevice, requestId: Int, offset: Int, chr: BluetoothGattCharacteristic) {
handler?.post {
val value = if (offset > 0) longReads[chr] ?: valueOf(chr) else valueOf(chr).also { longReads[chr] = it }
val reply = if (offset >= value.size) ByteArray(0) else value.copyOfRange(offset, value.size)
server?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, reply)
if (chr.uuid == uuid16(0x2A4B)) attach(device)
}
}
override fun onDescriptorReadRequest(device: BluetoothDevice, requestId: Int, offset: Int, descriptor: BluetoothGattDescriptor) {
handler?.post {
@Suppress("DEPRECATION")
val value = descriptor.value ?: if (descriptor.uuid == uuid16(0x2902)) BtPadEncoder.bytes(1, 0) else ByteArray(0)
val reply = if (offset >= value.size) ByteArray(0) else value.copyOfRange(offset, value.size)
server?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, reply)
}
}
override fun onDescriptorWriteRequest(device: BluetoothDevice, requestId: Int, descriptor: BluetoothGattDescriptor,
preparedWrite: Boolean, responseNeeded: Boolean, offset: Int, value: ByteArray) {
handler?.post {
if (responseNeeded) server?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, value)
if (descriptor.uuid == uuid16(0x2902) && descriptor.characteristic in reportRefs && value.isNotEmpty() &&
value[0].toInt() and 1 != 0) {
attach(device)
handler?.postDelayed({ startFastLink(device) }, FAST_LINK_DELAY_MS)
}
}
}
override fun onCharacteristicWriteRequest(device: BluetoothDevice, requestId: Int, chr: BluetoothGattCharacteristic,
preparedWrite: Boolean, responseNeeded: Boolean, offset: Int, value: ByteArray) {
handler?.post {
if (preparedWrite) {
val old = preparedWrites[chr] ?: ByteArray(0)
val merged = old.copyOf(maxOf(old.size, offset + value.size))
value.copyInto(merged, offset)
preparedWrites[chr] = merged
} else written(chr, value)
if (responseNeeded) server?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, value)
}
}
override fun onExecuteWrite(device: BluetoothDevice, requestId: Int, execute: Boolean) {
handler?.post {
if (execute) preparedWrites.forEach { (chr, v) -> written(chr, v) }
preparedWrites.clear()
server?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, 0, null)
}
}
override fun onNotificationSent(device: BluetoothDevice, status: Int) {
handler?.post {
notifyPending = false
if (dirty) sendNow()
}
}
}
private fun valueOf(chr: BluetoothGattCharacteristic): ByteArray {
val ref = reportRefs[chr]
if (ref == null) {
@Suppress("DEPRECATION")
return chr.value ?: ByteArray(0)
}
val (id, type) = ref
return when (type) {
BtPadEncoder.INPUT -> if (id == encoder.inputId()) encoder.input(current()) else ByteArray(0)
BtPadEncoder.FEATURE -> {
host?.let { d -> handler?.postDelayed({ startFastLink(d) }, FAST_LINK_DELAY_MS) }
encoder.feature(id).also { Log.i(TAG, "feature 0x%02x read -> %d".format(id, it?.size ?: -1)) } ?: ByteArray(0)
}
else -> ByteArray(0)
}
}
private fun written(chr: BluetoothGattCharacteristic, value: ByteArray) {
val (id, type) = reportRefs[chr] ?: return
when (type) {
BtPadEncoder.FEATURE -> {
Log.i(TAG, "feature 0x%02x write %d bytes".format(id, value.size))
encoder.setFeature(id, value)
}
BtPadEncoder.OUTPUT -> feedback(encoder.output(id, value))
}
}
private fun attach(device: BluetoothDevice) {
if (host == device) return
host = device
stopAdvertising()
pairingUntil = 0
keepScanning()
sentOnce = false
notifyPending = false
Log.i(TAG, "host ${device.address} attached")
publish(Phase.CONNECTED, device)
fastLinkPending = true
handler?.removeCallbacks(periodic)
handler?.post(periodic)
}
private fun startFastLink(device: BluetoothDevice) {
if (host != device || !fastLinkPending) return
fastLinkPending = false
requestFastLink(device)
}
private fun requestFastLink(device: BluetoothDevice) {
val ctx = app ?: return
dropFastLink()
priorityLink = runCatching {
device.connectGatt(ctx, false, object : BluetoothGattCallback() {
override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
if (newState == BluetoothProfile.STATE_CONNECTED && !gatt.requestMtu(MAX_MTU)) {
gatt.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH)
}
}
override fun onMtuChanged(gatt: BluetoothGatt, newMtu: Int, status: Int) {
handler?.post {
if (newMtu > mtu) mtu = newMtu
Log.i(TAG, "link mtu $newMtu")
}
gatt.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH)
}
}, BluetoothDevice.TRANSPORT_LE)
}.getOrNull()
}
private fun dropFastLink() {
priorityLink?.let { runCatching { it.disconnect(); it.close() } }
priorityLink = null
}
private fun current(): BtPadState = BtPadState().also { s -> synchronized(latest) { s.set(latest) } }
private fun sendIfChanged() {
if (encoder.periodMs > 0) return
if (sentOnce && current().sameAs(sent)) return
sendNow()
}
private fun sendNow() {
val s = server ?: return
val device = host ?: return
if (notifyPending) {
dirty = true
return
}
val chr = inputChars[encoder.inputId()] ?: return
val state = current()
val value = encoder.input(state)
if (value.size > mtu - 3) {
dirty = false
return
}
val ok = runCatching {
if (Build.VERSION.SDK_INT >= 33) {
s.notifyCharacteristicChanged(device, chr, false, value) == BluetoothGatt.GATT_SUCCESS
} else {
@Suppress("DEPRECATION")
chr.value = value
@Suppress("DEPRECATION")
s.notifyCharacteristicChanged(device, chr, false)
}
}.getOrDefault(false)
dirty = !ok
notifyPending = ok
if (ok) {
sent.set(state)
sentOnce = true
}
}
private val periodic: Runnable = object : Runnable {
override fun run() {
val h = handler ?: return
if (host == null) return
if (encoder.periodMs > 0 || dirty) sendNow()
h.postDelayed(this, if (encoder.periodMs > 0) encoder.periodMs else 50)
}
}
private fun feedback(f: BtFeedback?) {
f ?: return
if (f.strong >= 0) rumble(f.strong, f.weak)
if (f.lightbar != null) _status.value = _status.value.copy(lightbar = f.lightbar)
}
private fun rumble(strong: Int, weak: Int) {
val v = vibrator ?: return
val amplitude = maxOf(strong, weak * 2 / 3).coerceIn(0, 255)
runCatching {
if (amplitude == 0) v.cancel()
else v.vibrate(VibrationEffect.createOneShot(1_000, amplitude))
}
}
private fun publish(phase: Phase, device: BluetoothDevice? = null) {
if (!running) {
_status.value = Status(Phase.OFF)
return
}
val name = device?.let { runCatching { it.name }.getOrNull() ?: it.address }
val own = runCatching { adapter()?.name }.getOrNull()
_status.value = Status(phase, name, _status.value.lightbar.takeIf { phase == Phase.CONNECTED }, own)
}
}
@@ -0,0 +1,551 @@
package com.droiddeck.launcher.input.bt
import java.util.zip.CRC32
import kotlin.math.roundToInt
class BtPadState {
@JvmField var buttons = 0
@JvmField var lx = 0f
@JvmField var ly = 0f
@JvmField var rx = 0f
@JvmField var ry = 0f
@JvmField var lt = 0f
@JvmField var rt = 0f
@JvmField var lpx = 0f
@JvmField var lpy = 0f
@JvmField var rpx = 0f
@JvmField var rpy = 0f
fun isDown(bit: Int) = buttons and bit != 0
fun set(other: BtPadState) {
buttons = other.buttons; lx = other.lx; ly = other.ly; rx = other.rx; ry = other.ry; lt = other.lt; rt = other.rt
lpx = other.lpx; lpy = other.lpy; rpx = other.rpx; rpy = other.rpy
}
fun merge(a: BtPadState, b: BtPadState) {
buttons = a.buttons or b.buttons
lx = stronger(a.lx, b.lx); ly = stronger(a.ly, b.ly)
rx = stronger(a.rx, b.rx); ry = stronger(a.ry, b.ry)
lt = maxOf(a.lt, b.lt, if (isDown(LT)) 1f else 0f)
rt = maxOf(a.rt, b.rt, if (isDown(RT)) 1f else 0f)
val left = if (b.isDown(LPAD_TOUCH)) b else a
lpx = left.lpx; lpy = left.lpy
val right = if (b.isDown(RPAD_TOUCH)) b else a
rpx = right.rpx; rpy = right.rpy
}
fun sameAs(o: BtPadState) = buttons == o.buttons && lx == o.lx && ly == o.ly && rx == o.rx && ry == o.ry && lt == o.lt && rt == o.rt &&
lpx == o.lpx && lpy == o.lpy && rpx == o.rpx && rpy == o.rpy
fun hat(): Int {
val x = (if (isDown(RIGHT)) 1 else 0) - (if (isDown(LEFT)) 1 else 0)
val y = (if (isDown(DOWN)) 1 else 0) - (if (isDown(UP)) 1 else 0)
return when {
x == 0 && y == -1 -> 0
x == 1 && y == -1 -> 1
x == 1 && y == 0 -> 2
x == 1 && y == 1 -> 3
x == 0 && y == 1 -> 4
x == -1 && y == 1 -> 5
x == -1 && y == 0 -> 6
x == -1 && y == -1 -> 7
else -> -1
}
}
companion object {
const val A = 1 shl 0
const val B = 1 shl 1
const val X = 1 shl 2
const val Y = 1 shl 3
const val LB = 1 shl 4
const val RB = 1 shl 5
const val LT = 1 shl 6
const val RT = 1 shl 7
const val SELECT = 1 shl 8
const val START = 1 shl 9
const val GUIDE = 1 shl 10
const val L3 = 1 shl 11
const val R3 = 1 shl 12
const val UP = 1 shl 13
const val DOWN = 1 shl 14
const val LEFT = 1 shl 15
const val RIGHT = 1 shl 16
const val L4 = 1 shl 17
const val R4 = 1 shl 18
const val L5 = 1 shl 19
const val R5 = 1 shl 20
const val TOUCHPAD = 1 shl 21
const val SHARE = 1 shl 22
const val LPAD_TOUCH = 1 shl 23
const val RPAD_TOUCH = 1 shl 24
const val LPAD_CLICK = 1 shl 25
const val RPAD_CLICK = 1 shl 26
private fun stronger(a: Float, b: Float) = if (Math.abs(b) > Math.abs(a)) b else a
}
}
class BtFeedback(val strong: Int, val weak: Int, val lightbar: Int? = null)
enum class BtPadProfile(val id: String, val vendorId: Int, val productId: Int, val version: Int) {
GENERIC("generic", 0x1209, 0x0001, 0x0100),
XBOX("xbox", 0x045E, 0x0B13, 0x0509),
DUALSHOCK4("dualshock4", 0x054C, 0x09CC, 0x0100),
DUALSENSE("dualsense", 0x054C, 0x0CE6, 0x0100),
STEAM("steam", 0x28DE, 0x1303, 0x0100);
fun encoder(): BtPadEncoder = when (this) {
GENERIC -> GenericEncoder()
XBOX -> XboxEncoder()
DUALSHOCK4 -> DualShock4Encoder()
DUALSENSE -> DualSenseEncoder()
STEAM -> SteamControllerEncoder()
}
companion object {
fun byId(id: String?) = entries.firstOrNull { it.id == id } ?: GENERIC
}
}
abstract class BtPadEncoder {
abstract val descriptor: ByteArray
abstract val reports: List<Pair<Int, Int>>
abstract fun inputId(): Int
abstract fun input(s: BtPadState): ByteArray
open val periodMs = 0L
open fun feature(id: Int): ByteArray? = null
open fun setFeature(id: Int, data: ByteArray) {}
open fun output(id: Int, data: ByteArray): BtFeedback? = null
protected fun axis8(v: Float) = ((v.coerceIn(-1f, 1f) + 1f) * 127.5f).roundToInt().coerceIn(0, 255)
protected fun trigger8(v: Float) = (v.coerceIn(0f, 1f) * 255f).roundToInt()
protected fun ByteArray.le16(at: Int, v: Int) { this[at] = v.toByte(); this[at + 1] = (v shr 8).toByte() }
protected fun ByteArray.le32(at: Int, v: Long) { for (i in 0 until 4) this[at + i] = (v shr (8 * i)).toByte() }
protected fun ByteArray.sealCrc(seed: Int, id: Int): ByteArray {
val crc = CRC32()
crc.update(seed)
crc.update(id)
crc.update(this, 0, size - 4)
le32(size - 4, crc.value)
return this
}
protected fun ByteArray.payload(id: Int): ByteArray =
if (isNotEmpty() && this[0].toInt() and 0xFF == id) copyOfRange(1, size) else this
companion object {
const val INPUT = 1
const val OUTPUT = 2
const val FEATURE = 3
fun bytes(vararg v: Int) = ByteArray(v.size) { v[it].toByte() }
}
}
private class GenericEncoder : BtPadEncoder() {
override val reports = listOf(1 to INPUT)
override val descriptor = bytes(
0x05, 0x01, 0x09, 0x05, 0xA1, 0x01, 0x85, 0x01,
0x05, 0x09, 0x19, 0x01, 0x29, 0x18, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x18, 0x81, 0x02,
0x05, 0x01, 0x09, 0x39, 0x15, 0x00, 0x25, 0x07, 0x35, 0x00, 0x46, 0x3B, 0x01, 0x65, 0x14, 0x75, 0x04, 0x95, 0x01, 0x81, 0x42,
0x65, 0x00, 0x75, 0x04, 0x95, 0x01, 0x81, 0x03,
0x09, 0x30, 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x04, 0x81, 0x02,
0x05, 0x02, 0x09, 0xC5, 0x09, 0xC4, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x02, 0x81, 0x02,
0xC0,
)
override fun inputId() = 1
override fun input(s: BtPadState): ByteArray {
var b = 0
GENERIC_ORDER.forEachIndexed { i, bit -> if (s.isDown(bit)) b = b or (1 shl i) }
val hat = s.hat().let { if (it < 0) 8 else it }
return bytes(
b and 0xFF, (b shr 8) and 0xFF, (b shr 16) and 0xFF, hat,
axis8(s.lx), axis8(s.ly), axis8(s.rx), axis8(s.ry), trigger8(s.lt), trigger8(s.rt),
)
}
companion object {
private val GENERIC_ORDER = intArrayOf(
BtPadState.A, BtPadState.B, 0, BtPadState.X, BtPadState.Y, 0, BtPadState.LB, BtPadState.RB,
BtPadState.LT, BtPadState.RT, BtPadState.SELECT, BtPadState.START, BtPadState.GUIDE, BtPadState.L3, BtPadState.R3, 0,
BtPadState.L4, BtPadState.R4, BtPadState.L5, BtPadState.R5, BtPadState.TOUCHPAD, BtPadState.SHARE, 0, 0,
)
}
}
private class XboxEncoder : BtPadEncoder() {
override val reports = listOf(1 to INPUT, 3 to OUTPUT)
override val descriptor = bytes(
0x05, 0x01, 0x09, 0x05, 0xA1, 0x01, 0x85, 0x01,
0x09, 0x01, 0xA1, 0x00, 0x09, 0x30, 0x09, 0x31, 0x15, 0x00, 0x27, 0xFF, 0xFF, 0x00, 0x00, 0x95, 0x02, 0x75, 0x10, 0x81, 0x02, 0xC0,
0x09, 0x01, 0xA1, 0x00, 0x09, 0x32, 0x09, 0x35, 0x15, 0x00, 0x27, 0xFF, 0xFF, 0x00, 0x00, 0x95, 0x02, 0x75, 0x10, 0x81, 0x02, 0xC0,
0x05, 0x02, 0x09, 0xC5, 0x15, 0x00, 0x26, 0xFF, 0x03, 0x95, 0x01, 0x75, 0x0A, 0x81, 0x02, 0x15, 0x00, 0x25, 0x00, 0x75, 0x06, 0x95, 0x01, 0x81, 0x03,
0x05, 0x02, 0x09, 0xC4, 0x15, 0x00, 0x26, 0xFF, 0x03, 0x95, 0x01, 0x75, 0x0A, 0x81, 0x02, 0x15, 0x00, 0x25, 0x00, 0x75, 0x06, 0x95, 0x01, 0x81, 0x03,
0x05, 0x01, 0x09, 0x39, 0x15, 0x01, 0x25, 0x08, 0x35, 0x00, 0x46, 0x3B, 0x01, 0x66, 0x14, 0x00, 0x75, 0x04, 0x95, 0x01, 0x81, 0x42,
0x75, 0x04, 0x95, 0x01, 0x15, 0x00, 0x25, 0x00, 0x35, 0x00, 0x45, 0x00, 0x65, 0x00, 0x81, 0x03,
0x05, 0x09, 0x19, 0x01, 0x29, 0x0F, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x0F, 0x81, 0x02,
0x15, 0x00, 0x25, 0x00, 0x75, 0x01, 0x95, 0x01, 0x81, 0x03,
0x05, 0x0C, 0x0A, 0xB2, 0x00, 0x15, 0x00, 0x25, 0x01, 0x95, 0x01, 0x75, 0x01, 0x81, 0x02,
0x15, 0x00, 0x25, 0x00, 0x75, 0x07, 0x95, 0x01, 0x81, 0x03,
0x05, 0x0F, 0x09, 0x21, 0x85, 0x03, 0xA1, 0x02,
0x09, 0x97, 0x15, 0x00, 0x25, 0x01, 0x75, 0x04, 0x95, 0x01, 0x91, 0x02,
0x15, 0x00, 0x25, 0x00, 0x75, 0x04, 0x95, 0x01, 0x91, 0x03,
0x09, 0x70, 0x15, 0x00, 0x25, 0x64, 0x75, 0x08, 0x95, 0x04, 0x91, 0x02,
0x09, 0x50, 0x66, 0x01, 0x10, 0x55, 0x0E, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x01, 0x91, 0x02,
0x09, 0xA7, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x01, 0x91, 0x02,
0x65, 0x00, 0x55, 0x00, 0x09, 0x7C, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x01, 0x91, 0x02,
0xC0, 0xC0,
)
override fun inputId() = 1
override fun input(s: BtPadState): ByteArray {
val r = ByteArray(16)
r.le16(0, axis16(s.lx)); r.le16(2, axis16(s.ly)); r.le16(4, axis16(s.rx)); r.le16(6, axis16(s.ry))
r.le16(8, (s.lt.coerceIn(0f, 1f) * 1023f).roundToInt())
r.le16(10, (s.rt.coerceIn(0f, 1f) * 1023f).roundToInt())
r[12] = (s.hat() + 1).toByte()
var b = 0
XBOX_ORDER.forEachIndexed { i, bit -> if (bit != 0 && s.isDown(bit)) b = b or (1 shl i) }
r.le16(13, b)
r[15] = if (s.isDown(BtPadState.SHARE)) 1 else 0
return r
}
override fun output(id: Int, data: ByteArray): BtFeedback? {
if (id != 3) return null
val d = data.payload(id)
if (d.size < 5) return null
val enable = d[0].toInt()
val strong = if (enable and 0x02 != 0) d[3].toInt() and 0xFF else 0
val weak = if (enable and 0x01 != 0) d[4].toInt() and 0xFF else 0
return BtFeedback(strong * 255 / 100, weak * 255 / 100)
}
private fun axis16(v: Float) = ((v.coerceIn(-1f, 1f) + 1f) * 32767.5f).roundToInt().coerceIn(0, 65535)
companion object {
private val XBOX_ORDER = intArrayOf(
BtPadState.A, BtPadState.B, 0, BtPadState.X, BtPadState.Y, 0, BtPadState.LB, BtPadState.RB,
0, 0, BtPadState.SELECT, BtPadState.START, BtPadState.GUIDE, BtPadState.L3, BtPadState.R3,
)
}
}
private abstract class SonyEncoder : BtPadEncoder() {
@Volatile protected var enhanced = false
protected var counter = 0
protected var timestamp = 0L
override val periodMs = 8L
protected fun buttons(s: BtPadState): IntArray {
val hat = s.hat().let { if (it < 0) 8 else it }
var b0 = hat
if (s.isDown(BtPadState.X)) b0 = b0 or 0x10
if (s.isDown(BtPadState.A)) b0 = b0 or 0x20
if (s.isDown(BtPadState.B)) b0 = b0 or 0x40
if (s.isDown(BtPadState.Y)) b0 = b0 or 0x80
var b1 = 0
if (s.isDown(BtPadState.LB)) b1 = b1 or 0x01
if (s.isDown(BtPadState.RB)) b1 = b1 or 0x02
if (s.lt > 0.05f) b1 = b1 or 0x04
if (s.rt > 0.05f) b1 = b1 or 0x08
if (s.isDown(BtPadState.SELECT) || s.isDown(BtPadState.SHARE)) b1 = b1 or 0x10
if (s.isDown(BtPadState.START)) b1 = b1 or 0x20
if (s.isDown(BtPadState.L3)) b1 = b1 or 0x40
if (s.isDown(BtPadState.R3)) b1 = b1 or 0x80
var b2 = 0
if (s.isDown(BtPadState.GUIDE)) b2 = b2 or 0x01
if (s.isDown(BtPadState.TOUCHPAD)) b2 = b2 or 0x02
return intArrayOf(b0, b1, b2)
}
protected fun simple(s: BtPadState): ByteArray {
val b = buttons(s)
counter = (counter + 1) and 0x3F
return bytes(axis8(s.lx), axis8(s.ly), axis8(s.rx), axis8(s.ry), b[0], b[1], b[2] or (counter shl 2), trigger8(s.lt), trigger8(s.rt))
}
protected fun calibration(): ByteArray {
val r = ByteArray(40)
val v = intArrayOf(0, 0, 0, GYRO, -GYRO, GYRO, -GYRO, GYRO, -GYRO, GYRO_SPEED, GYRO_SPEED, ACCEL, -ACCEL, ACCEL, -ACCEL, ACCEL, -ACCEL)
v.forEachIndexed { i, x -> r.le16(i * 2, x) }
return r.sealCrc(FEATURE_SEED, 0x05)
}
override fun feature(id: Int): ByteArray? {
val reply = reply(id) ?: return null
enhanced = true
return reply
}
protected abstract fun reply(id: Int): ByteArray?
companion object {
const val INPUT_SEED = 0xA1
const val OUTPUT_SEED = 0xA2
const val FEATURE_SEED = 0xA3
const val GYRO = 8800
const val GYRO_SPEED = 540
const val ACCEL = 8192
}
}
private class DualShock4Encoder : SonyEncoder() {
override val reports = listOf(0x01 to INPUT, 0x11 to INPUT, 0x11 to OUTPUT, 0x02 to FEATURE, 0xA3 to FEATURE, 0x05 to FEATURE, 0x12 to FEATURE)
override val descriptor = bytes(
0x05, 0x01, 0x09, 0x05, 0xA1, 0x01, 0x85, 0x01,
0x09, 0x30, 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x04, 0x81, 0x02,
0x09, 0x39, 0x15, 0x00, 0x25, 0x07, 0x35, 0x00, 0x46, 0x3B, 0x01, 0x65, 0x14, 0x75, 0x04, 0x95, 0x01, 0x81, 0x42, 0x65, 0x00,
0x05, 0x09, 0x19, 0x01, 0x29, 0x0E, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x0E, 0x81, 0x02,
0x06, 0x00, 0xFF, 0x09, 0x20, 0x75, 0x06, 0x95, 0x01, 0x15, 0x00, 0x25, 0x7F, 0x81, 0x02,
0x05, 0x01, 0x09, 0x33, 0x09, 0x34, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x02, 0x81, 0x02,
0x06, 0x04, 0xFF,
0x85, 0x02, 0x09, 0x24, 0x95, 0x24, 0xB1, 0x02,
0x85, 0xA3, 0x09, 0x25, 0x95, 0x30, 0xB1, 0x02,
0x85, 0x05, 0x09, 0x26, 0x95, 0x28, 0xB1, 0x02,
0x85, 0x12, 0x09, 0x27, 0x95, 0x0F, 0xB1, 0x02,
0x85, 0x11, 0x09, 0x22, 0x95, 0x4D, 0x81, 0x02,
0x09, 0x23, 0x95, 0x4D, 0x91, 0x02,
0xC0,
)
override fun inputId() = if (enhanced) 0x11 else 0x01
override fun input(s: BtPadState): ByteArray {
if (!enhanced) return simple(s)
val r = ByteArray(77)
r[0] = 0xC0.toByte()
val b = buttons(s)
counter = (counter + 1) and 0x3F
timestamp += 1500
val c = 2
r[c] = axis8(s.lx).toByte(); r[c + 1] = axis8(s.ly).toByte(); r[c + 2] = axis8(s.rx).toByte(); r[c + 3] = axis8(s.ry).toByte()
r[c + 4] = b[0].toByte(); r[c + 5] = b[1].toByte(); r[c + 6] = (b[2] or (counter shl 2)).toByte()
r[c + 7] = trigger8(s.lt).toByte(); r[c + 8] = trigger8(s.rt).toByte()
r.le16(c + 9, timestamp.toInt())
r.le16(c + 20, ACCEL)
r[c + 29] = 0x09
r[c + 32] = 1
r[c + 34] = 0x80.toByte()
r[c + 38] = 0x80.toByte()
return r.sealCrc(INPUT_SEED, 0x11)
}
override fun reply(id: Int): ByteArray? = when (id) {
0x02 -> ByteArray(36).also { r ->
val v = intArrayOf(0, 0, 0, GYRO, GYRO, GYRO, -GYRO, -GYRO, -GYRO, GYRO_SPEED, GYRO_SPEED, ACCEL, -ACCEL, ACCEL, -ACCEL, ACCEL, -ACCEL)
v.forEachIndexed { i, x -> r.le16(i * 2, x) }
}
0x05 -> calibration()
0xA3 -> ByteArray(48).also { r ->
"Sep 21 2018".toByteArray().copyInto(r, 0)
"04:50:51".toByteArray().copyInto(r, 16)
r.le16(34, 0x0100)
r.le16(40, 0xA00A)
}
0x12 -> ByteArray(15).also { r -> FAKE_MAC.copyInto(r, 0); r[6] = 0x08; r[7] = 0x25 }
else -> null
}
override fun output(id: Int, data: ByteArray): BtFeedback? {
if (id != 0x11) return null
enhanced = true
val d = data.payload(id)
if (d.size < 10) return null
val flags = d[2].toInt()
val light = if (flags and 0x02 != 0) rgb(d[7], d[8], d[9]) else null
return BtFeedback(d[6].toInt() and 0xFF, d[5].toInt() and 0xFF, light)
}
}
private class DualSenseEncoder : SonyEncoder() {
override val reports = listOf(0x01 to INPUT, 0x31 to INPUT, 0x31 to OUTPUT, 0x05 to FEATURE, 0x09 to FEATURE, 0x20 to FEATURE)
override val descriptor = bytes(
0x05, 0x01, 0x09, 0x05, 0xA1, 0x01, 0x85, 0x01,
0x09, 0x30, 0x09, 0x31, 0x09, 0x32, 0x09, 0x35, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x04, 0x81, 0x02,
0x09, 0x39, 0x15, 0x00, 0x25, 0x07, 0x35, 0x00, 0x46, 0x3B, 0x01, 0x65, 0x14, 0x75, 0x04, 0x95, 0x01, 0x81, 0x42, 0x65, 0x00,
0x05, 0x09, 0x19, 0x01, 0x29, 0x0E, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x0E, 0x81, 0x02,
0x06, 0x00, 0xFF, 0x09, 0x20, 0x75, 0x06, 0x95, 0x01, 0x15, 0x00, 0x25, 0x7F, 0x81, 0x02,
0x05, 0x01, 0x09, 0x33, 0x09, 0x34, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08, 0x95, 0x02, 0x81, 0x02,
0x06, 0x00, 0xFF,
0x85, 0x31, 0x09, 0x31, 0x95, 0x4D, 0x81, 0x02,
0x09, 0x32, 0x95, 0x4D, 0x91, 0x02,
0x85, 0x05, 0x09, 0x33, 0x95, 0x28, 0xB1, 0x02,
0x85, 0x09, 0x09, 0x34, 0x95, 0x13, 0xB1, 0x02,
0x85, 0x20, 0x09, 0x35, 0x95, 0x3F, 0xB1, 0x02,
0xC0,
)
private var sequence = 0
override fun inputId() = if (enhanced) 0x31 else 0x01
override fun input(s: BtPadState): ByteArray {
if (!enhanced) return simple(s)
val r = ByteArray(77)
sequence = (sequence + 1) and 0xFF
timestamp += 24000
r[0] = 0x10
val c = 1
r[c] = axis8(s.lx).toByte(); r[c + 1] = axis8(s.ly).toByte(); r[c + 2] = axis8(s.rx).toByte(); r[c + 3] = axis8(s.ry).toByte()
r[c + 4] = trigger8(s.lt).toByte(); r[c + 5] = trigger8(s.rt).toByte()
r[c + 6] = sequence.toByte()
val b = buttons(s)
r[c + 7] = b[0].toByte(); r[c + 8] = b[1].toByte(); r[c + 9] = b[2].toByte()
r.le16(c + 23, ACCEL)
r.le32(c + 27, timestamp)
r[c + 32] = 0x80.toByte()
r[c + 36] = 0x80.toByte()
r[c + 52] = 0x09
return r.sealCrc(INPUT_SEED, 0x31)
}
override fun reply(id: Int): ByteArray? = when (id) {
0x05 -> calibration()
0x09 -> ByteArray(19).also { r -> FAKE_MAC.copyInto(r, 0) }.sealCrc(FEATURE_SEED, 0x09)
0x20 -> ByteArray(63).also { r ->
"Jun 19 2023".toByteArray().copyInto(r, 0)
"14:47:34".toByteArray().copyInto(r, 11)
r.le16(19, 0x0003)
r.le32(23, 0x00000615L)
r.le32(27, 0x0110002AL)
r.le16(43, 0x0630)
}.sealCrc(FEATURE_SEED, 0x20)
else -> null
}
override fun output(id: Int, data: ByteArray): BtFeedback? {
if (id != 0x31) return null
enhanced = true
val d = data.payload(id)
if (d.size < 49) return null
val flags0 = d[2].toInt()
val flags1 = d[3].toInt()
val light = if (flags1 and 0x04 != 0) rgb(d[46], d[47], d[48]) else null
return if (flags0 and 0x03 != 0) BtFeedback(d[5].toInt() and 0xFF, d[4].toInt() and 0xFF, light)
else if (light != null) BtFeedback(-1, -1, light) else null
}
}
private class SteamControllerEncoder : BtPadEncoder() {
override val descriptor = bytes(
0x06, 0x00, 0xFF, 0x09, 0x01, 0xA1, 0x01, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x75, 0x08,
0x85, 0x45, 0x09, 0x02, 0x95, 0x2D, 0x81, 0x02, 0x85, 0x47, 0x09, 0x03, 0x95, 0x2D, 0x81, 0x02,
0x85, 0x80, 0x09, 0x04, 0x95, 0x09, 0x91, 0x02, 0x85, 0x81, 0x09, 0x05, 0x95, 0x07, 0x91, 0x02,
0x85, 0x82, 0x09, 0x06, 0x95, 0x03, 0x91, 0x02, 0x85, 0x83, 0x09, 0x07, 0x95, 0x09, 0x91, 0x02,
0x85, 0x84, 0x09, 0x08, 0x95, 0x08, 0x91, 0x02, 0x85, 0x85, 0x09, 0x09, 0x95, 0x03, 0x91, 0x02,
0x85, 0x01, 0x09, 0x0A, 0x95, 0x3F, 0xB1, 0x02, 0xC0,
)
override val reports = listOf(0x45 to INPUT, 0x47 to INPUT, 0x80 to OUTPUT, 0x81 to OUTPUT, 0x82 to OUTPUT,
0x83 to OUTPUT, 0x84 to OUTPUT, 0x85 to OUTPUT, 0x01 to FEATURE)
override val periodMs = 8L
@Volatile private var pending = 0
private var packet = 0
private val start = System.nanoTime()
override fun inputId() = 0x45
override fun input(s: BtPadState): ByteArray {
val r = ByteArray(45)
packet++
r[0] = packet.toByte()
var b = LGRIP_TOUCH or RGRIP_TOUCH
BUTTONS.forEach { (mine, theirs) -> if (s.isDown(mine)) b = b or theirs }
if (s.lt >= 0.98f) b = b or LTRIGGER_CLICK
if (s.rt >= 0.98f) b = b or RTRIGGER_CLICK
if (Math.abs(s.lx) > 0.06f || Math.abs(s.ly) > 0.06f) b = b or LSTICK_TOUCH
if (Math.abs(s.rx) > 0.06f || Math.abs(s.ry) > 0.06f) b = b or RSTICK_TOUCH
r.le32(1, b.toLong())
r.le16(5, (s.lt.coerceIn(0f, 1f) * 32767f).roundToInt())
r.le16(7, (s.rt.coerceIn(0f, 1f) * 32767f).roundToInt())
r.le16(9, stick(s.lx)); r.le16(11, stick(-s.ly)); r.le16(13, stick(s.rx)); r.le16(15, stick(-s.ry))
if (s.isDown(BtPadState.LPAD_TOUCH)) {
r.le16(17, stick(s.lpx)); r.le16(19, stick(-s.lpy))
r.le16(21, if (s.isDown(BtPadState.LPAD_CLICK)) 32767 else 4000)
}
if (s.isDown(BtPadState.RPAD_TOUCH)) {
r.le16(23, stick(s.rpx)); r.le16(25, stick(-s.rpy))
r.le16(27, if (s.isDown(BtPadState.RPAD_CLICK)) 32767 else 4000)
}
r.le32(29, (System.nanoTime() - start) / 1000)
r.le16(37, 16384)
return r
}
override fun setFeature(id: Int, data: ByteArray) {
val d = data.payload(id)
if (id == 1 && d.isNotEmpty()) pending = d[0].toInt() and 0xFF
}
override fun feature(id: Int): ByteArray? {
if (id != 1) return null
val r = ByteArray(63)
r[0] = pending.toByte()
when (pending) {
0x83 -> {
val ids = intArrayOf(0x01, 0x02, 0x04, 0x09, 0x0A, 0x0B)
val values = longArrayOf(0x1303, 0, FW_TIMESTAMP, 72, 0, 4000)
r[1] = (ids.size * 5).toByte()
ids.forEachIndexed { i, a -> r[2 + i * 5] = a.toByte(); r.le32(3 + i * 5, values[i]) }
}
0xAE -> { r[1] = 0x14; r[2] = 0x01; SERIAL.toByteArray().copyInto(r, 3) }
0xBA -> { r[1] = 0x11; "DROIDDECKCHIP02".toByteArray().copyInto(r, 3) }
}
return r
}
override fun output(id: Int, data: ByteArray): BtFeedback? {
val d = data.payload(id)
return when (id) {
0x80 -> if (d.size >= 8) {
val left = (d[3].toInt() and 0xFF) or ((d[4].toInt() and 0xFF) shl 8)
val right = (d[6].toInt() and 0xFF) or ((d[7].toInt() and 0xFF) shl 8)
BtFeedback(left shr 8, right shr 8)
} else null
in 0x81..0x85 -> BtFeedback(0, 120)
else -> null
}
}
private fun stick(v: Float) = (v.coerceIn(-1f, 1f) * 32767f).roundToInt()
companion object {
private const val LGRIP_TOUCH = 0x20000000
private const val RGRIP_TOUCH = 0x10000000
private const val LTRIGGER_CLICK = 0x08000000
private const val RTRIGGER_CLICK = 0x00800000
private const val LSTICK_TOUCH = 0x01000000
private const val RSTICK_TOUCH = 0x00100000
private const val FW_TIMESTAMP = 0x6AC686B3L
private const val SERIAL = "DROIDDECKSC01"
private val BUTTONS = listOf(
BtPadState.A to 0x00000001, BtPadState.B to 0x00000002, BtPadState.X to 0x00000004, BtPadState.Y to 0x00000008,
BtPadState.SHARE to 0x00000010, BtPadState.R3 to 0x00000020, BtPadState.SELECT to 0x00000040,
BtPadState.R4 to 0x00000080, BtPadState.R5 to 0x00000100, BtPadState.RB to 0x00000200,
BtPadState.DOWN to 0x00000400, BtPadState.RIGHT to 0x00000800, BtPadState.LEFT to 0x00001000,
BtPadState.UP to 0x00002000, BtPadState.START to 0x00004000, BtPadState.L3 to 0x00008000,
BtPadState.GUIDE to 0x00010000, BtPadState.L4 to 0x00020000, BtPadState.L5 to 0x00040000,
BtPadState.LB to 0x00080000,
BtPadState.RPAD_TOUCH to 0x00200000, BtPadState.RPAD_CLICK to 0x00400000,
BtPadState.LPAD_TOUCH to 0x02000000, BtPadState.LPAD_CLICK to 0x04000000,
)
}
}
private val FAKE_MAC = BtPadEncoder.bytes(0x5D, 0x44, 0x33, 0x22, 0x11, 0xD0)
private fun rgb(r: Byte, g: Byte, b: Byte) =
(0xFF shl 24) or ((r.toInt() and 0xFF) shl 16) or ((g.toInt() and 0xFF) shl 8) or (b.toInt() and 0xFF)
@@ -250,6 +250,10 @@ private fun Content(
UpdatesPage(s, a, modifier.padding(horizontal = padH).padding(top = padV))
return
}
if (selected == "trinkets") {
TrinketsPage(modifier.padding(horizontal = padH).padding(top = padV))
return
}
if (selected == "steam") {
SteamHome(s, a, modifier)
return
@@ -54,6 +54,7 @@ import androidx.compose.material.icons.outlined.SportsEsports
import androidx.compose.material.icons.outlined.Storefront
import androidx.compose.material.icons.outlined.SystemUpdate
import androidx.compose.material.icons.outlined.Tune
import androidx.compose.material.icons.outlined.Toys
import androidx.compose.material.icons.outlined.VideoLibrary
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.material3.Icon
@@ -125,7 +126,7 @@ internal fun navigationKeys(s: FrontEndState) = buildList {
if (s.gameStoresEnabled) add("stores")
add("desktop"); add("components")
if (s.isHomeApp) add("android-apps")
add("setup"); add("updates")
add("setup"); add("updates"); add("trinkets")
}
internal object RailLabels {
@@ -199,6 +200,7 @@ internal fun railLabelIcon(key: String): Pair<Int, ImageVector> = when (key) {
"components" -> R.string.rail_components to Icons.Outlined.Layers
"android-apps" -> R.string.rail_apps to Icons.Outlined.Apps
"setup" -> R.string.rail_setup to Icons.Outlined.Tune
"trinkets" -> R.string.rail_trinkets to Icons.Outlined.Toys
else -> R.string.rail_updates to Icons.Outlined.SystemUpdate
}
@@ -0,0 +1,61 @@
package com.droiddeck.launcher.ui
import android.content.Intent
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.outlined.BluetoothConnected
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.droiddeck.launcher.BtControllerActivity
import com.droiddeck.launcher.R
@Composable
internal fun TrinketsPage(modifier: Modifier) {
val context = LocalContext.current
Column(modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(12.dp)) {
Text(stringResource(R.string.trinkets_intro), fontSize = 13.sp, color = MaterialTheme.colorScheme.onSurfaceVariant)
Trinket(Icons.Outlined.BluetoothConnected, stringResource(R.string.btpad_title), stringResource(R.string.btpad_summary)) {
context.startActivity(Intent(context, BtControllerActivity::class.java))
}
}
}
@Composable
private fun Trinket(icon: ImageVector, title: String, summary: String, onOpen: () -> Unit) {
val colors = MaterialTheme.colorScheme
val pal = LocalPalette.current
Row(
verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp),
modifier = Modifier.fillMaxWidth().clip(Shape14).background(colors.surface).border(1.dp, pal.line2, Shape14).padding(14.dp),
) {
Box(Modifier.size(44.dp).clip(Shape12).background(pal.signal.copy(alpha = 0.14f)), contentAlignment = Alignment.Center) {
Icon(icon, null, tint = pal.signal)
}
Column(Modifier.weight(1f)) {
Text(title, fontSize = 16.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
Text(summary, fontSize = 13.sp, color = colors.onSurfaceVariant)
}
PrimaryButton(stringResource(R.string.trinkets_open), compact = true, onClick = onOpen)
}
}