From 9f4794769c0d5c399f3299d155faf2f61aa22929 Mon Sep 17 00:00:00 2001 From: kingokksa <47888451+kingokksa@users.noreply.github.com> Date: Mon, 26 Oct 2026 05:27:07 +0800 Subject: [PATCH] feat: on-screen keys for any key or key combo (#1305) --- .../com/droiddeck/launcher/SessionActivity.kt | 142 ++- .../launcher/input/ControllerPrefs.kt | 50 + .../launcher/input/GestureTouchStreamGate.kt | 21 + .../com/droiddeck/launcher/input/PcKeys.kt | 60 + .../com/droiddeck/launcher/input/ScreenKey.kt | 63 + .../launcher/input/ScreenKeyIcons.kt | 148 +++ .../droiddeck/launcher/input/ScreenKeys.kt | 1122 +++++++++++++++++ .../launcher/input/ScreenLayoutFile.kt | 140 ++ .../launcher/input/SteamTouchControls.kt | 7 +- .../com/droiddeck/launcher/ui/PcKeyboard.kt | 50 +- .../droiddeck/launcher/ui/ScreenKeyEditor.kt | 368 ++++++ .../droiddeck/launcher/ui/ScreenKeyPicker.kt | 168 +++ .../launcher/ui/ScreenLayoutPanel.kt | 138 ++ .../droiddeck/launcher/ui/SessionOverlay.kt | 21 + app/src/main/res/values-ar/strings.xml | 18 + app/src/main/res/values-b+es+419/strings.xml | 18 + app/src/main/res/values-bg/strings.xml | 18 + app/src/main/res/values-cs/strings.xml | 18 + app/src/main/res/values-da/strings.xml | 18 + app/src/main/res/values-de/strings.xml | 18 + app/src/main/res/values-el/strings.xml | 18 + app/src/main/res/values-es/strings.xml | 18 + app/src/main/res/values-fi/strings.xml | 18 + app/src/main/res/values-fr/strings.xml | 18 + app/src/main/res/values-hi/strings.xml | 18 + app/src/main/res/values-hu/strings.xml | 18 + app/src/main/res/values-in/strings.xml | 18 + app/src/main/res/values-it/strings.xml | 18 + app/src/main/res/values-ja/strings.xml | 18 + app/src/main/res/values-ko/strings.xml | 18 + app/src/main/res/values-ms/strings.xml | 18 + app/src/main/res/values-nb/strings.xml | 18 + app/src/main/res/values-nl/strings.xml | 18 + app/src/main/res/values-pl/strings.xml | 18 + app/src/main/res/values-pt-rPT/strings.xml | 18 + app/src/main/res/values-pt/strings.xml | 18 + app/src/main/res/values-ro/strings.xml | 18 + app/src/main/res/values-ru/strings.xml | 18 + app/src/main/res/values-sv/strings.xml | 18 + app/src/main/res/values-th/strings.xml | 18 + app/src/main/res/values-tr/strings.xml | 18 + app/src/main/res/values-uk/strings.xml | 18 + app/src/main/res/values-vi/strings.xml | 18 + app/src/main/res/values-zh-rCN/strings.xml | 18 + app/src/main/res/values-zh-rHK/strings.xml | 18 + app/src/main/res/values-zh-rTW/strings.xml | 18 + app/src/main/res/values/strings.xml | 18 + .../launcher/input/ScreenKeysTest.kt | 124 ++ 48 files changed, 3169 insertions(+), 47 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/input/GestureTouchStreamGate.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/input/PcKeys.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/input/ScreenKey.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/input/ScreenKeyIcons.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/input/ScreenKeys.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/input/ScreenLayoutFile.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyEditor.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyPicker.kt create mode 100644 app/src/main/java/com/droiddeck/launcher/ui/ScreenLayoutPanel.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/input/ScreenKeysTest.kt diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 2740c71248..a5868ca8b9 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -75,8 +75,10 @@ import com.droiddeck.launcher.input.OnScreenControls import com.droiddeck.launcher.input.PadBridge import com.droiddeck.launcher.input.PadMouse import com.droiddeck.launcher.input.PadState +import com.droiddeck.launcher.input.ScreenKeys import com.droiddeck.launcher.input.SteamControllerBle import com.droiddeck.launcher.input.DirectTouchHold +import com.droiddeck.launcher.input.GestureTouchStreamGate import com.droiddeck.launcher.input.PointerGestures import com.droiddeck.launcher.input.SecondScreenDisplay import com.droiddeck.launcher.input.SecondScreenDisplays @@ -199,10 +201,20 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var gestureConfig = com.droiddeck.launcher.input.TouchGestureConfig() private var gestureGame: String? = null private var gestureSettingsOpen by mutableStateOf(false) + private var screenKeyPickerOpen by mutableStateOf(false) + private var screenKeyBind: List? = null + private var screenKeyDir: Int? = null + private var screenKeyTextFocus = false + private var screenKeyEdit by mutableStateOf(null) + private var screenLayoutsOpen by mutableStateOf(false) + private var screenKeysShown by mutableStateOf(true) + private var screenLayoutNames by mutableStateOf(listOf()) + private var screenKeys: ScreenKeys? = null private var recognizedGesture by mutableStateOf(null) private var gesturePointerX = 0f private var gesturePointerY = 0f private var gesturePointerReady = false + private val gestureTouchStreamGate = GestureTouchStreamGate() private val clearRecognizedGesture = Runnable { recognizedGesture = null } private val gestureKeysDown = mutableSetOf() private lateinit var scrollTouch: ScrollTouchGestures @@ -536,6 +548,21 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { cursorVisible = false } onScreenControls = OnScreenControls(this, bridge, onKeyboard = ::togglePcKeyboard).also { root.addView(it) } + screenKeysShown = com.droiddeck.launcher.input.ControllerPrefs.screenKeysShown(this) + screenKeys = ScreenKeys(this) { code, down -> if (CompositorHost.isStarted) sendGuestKey(code, down) }.also { keys -> + keys.onTouchMiss = miss@{ event -> + if (routedTouchMode == SessionPrefs.TOUCH_GESTURES && + !gestureTouchStreamGate.accepts(GestureTouchStreamGate.Source.SCREEN_KEYS, event)) return@miss + event.offsetLocation(keys.left - surfaceView.left.toFloat(), keys.top - surfaceView.top.toFloat()) + onTouchEvent(event) + } + keys.onAdd = { screenKeyPickerOpen = true } + keys.onSelect = { codes -> screenKeyEdit = screenKeys?.stateOf(codes) } + keys.onEditingChanged = { if (!it) screenKeyEdit = null } + keys.steamStyle = { steamTouchControls?.style } + keys.visibility = if (screenKeysShown) View.VISIBLE else View.GONE + root.addView(keys) + } keyboard = KeyboardHost(this).also { root.addView(it) } touchpad = TouchpadGestures(PointerGestures.slop(this), pointerListener) directTouchHold = DirectTouchHold(PointerGestures.slop(this), pointerListener) { @@ -550,7 +577,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { // game surface and on-screen buttons, in either finger-down order. root.isMotionEventSplittingEnabled = true surfaceView.setOnTouchListener { _, event -> - routedTouchMode == SessionPrefs.TOUCH_GESTURES && onTouchEvent(event) + if (routedTouchMode != SessionPrefs.TOUCH_GESTURES) { + gestureTouchStreamGate.reset() + false + } else if (!gestureTouchStreamGate.accepts(GestureTouchStreamGate.Source.SURFACE, event)) { + false + } else onTouchEvent(event) } padMouse = PadMouse(padMouseListener) bridge.setTouchRoute(object : PadBridge.TouchRoute { @@ -741,6 +773,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, gestureSettingsOpen, pipUi, SessionState.suspended) { if (drawerOpen || pcKeyboardOpen || achievementsOpen || gestureSettingsOpen || pipUi || SessionState.suspended) { cancelTouchGestures() + screenKeys?.stopEditing() } } com.droiddeck.launcher.ui.GestureFeedback(recognizedGesture) @@ -749,6 +782,84 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { onDismiss = { gestureSettingsOpen = false }, onSaved = { gestureSettingsOpen = false; refreshGestureConfig() }, ) + if (screenKeyPickerOpen) { + val dir = screenKeyDir + com.droiddeck.launcher.ui.ScreenKeyPicker( + initial = if (dir != null) { + listOfNotNull((screenKeyEdit?.codes?.getOrNull(dir) ?: 0).takeIf { it != 0 }) + } else { + screenKeyBind ?: emptyList() + }, + onDismiss = { screenKeyPickerOpen = false; screenKeyBind = null; screenKeyDir = null }, + onAdd = { codes -> + val bind = screenKeyBind + if (dir != null && bind != null) { + screenKeys?.setDirection(bind, dir, codes.lastOrNull() ?: 0)?.let { screenKeyEdit = it } + } else if (bind != null) { + screenKeys?.setCodes(bind, codes)?.let { screenKeyEdit = it } + } else { + screenKeys?.add(codes) + screenKeyEdit = screenKeys?.stateOf(codes) + } + screenKeyPickerOpen = false + screenKeyBind = null + screenKeyDir = null + }, + ) + } + screenKeyEdit?.let { key -> + com.droiddeck.launcher.ui.ScreenKeyEditor( + codes = key.codes, keyY = key.y, + size = key.size, opacity = key.opacity, shape = key.shape, toggle = key.toggle, + labels = key.labels, + text = key.text, hasImage = key.image.isNotEmpty(), + onResize = { screenKeys?.resize(key.codes, it); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onOpacity = { screenKeys?.setOpacity(key.codes, it); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onShape = { screenKeys?.setShape(key.codes, it); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onToggle = { on -> screenKeys?.setToggle(key.codes, on); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onLabels = { on -> screenKeys?.setLabels(key.codes, on); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onDirection = { index -> screenKeyBind = key.codes; screenKeyDir = index; screenKeyPickerOpen = true }, + onText = { screenKeys?.setText(key.codes, it); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onImage = { screenKeys?.setImage(key.codes, it); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onClearImage = { screenKeys?.setImage(key.codes, ""); screenKeyEdit = screenKeys?.stateOf(key.codes) }, + onBind = { screenKeyBind = key.codes; screenKeyDir = null; screenKeyPickerOpen = true }, + onTextFocus = { screenKeyTextFocus = true; keyboard?.hide() }, + onTextBlur = { screenKeyTextFocus = false }, + onRemove = { screenKeys?.remove(key.codes); screenKeyEdit = null }, + onDismiss = { screenKeyEdit = null; screenKeyTextFocus = false; screenKeys?.deselect() }, + ) + } + if (screenLayoutsOpen) com.droiddeck.launcher.ui.ScreenLayoutPanel( + layouts = screenLayoutNames, + onSave = { name -> + screenKeys?.let { keys -> + com.droiddeck.launcher.input.ControllerPrefs.saveScreenLayout(this@SessionActivity, name, keys.export()) + } + screenLayoutNames = layoutNames() + }, + onLoad = { name -> + com.droiddeck.launcher.input.ControllerPrefs.screenLayouts(this@SessionActivity)[name]?.let { screenKeys?.load(it) } + screenLayoutsOpen = false + }, + onDelete = { name -> + com.droiddeck.launcher.input.ControllerPrefs.deleteScreenLayout(this@SessionActivity, name) + screenLayoutNames = layoutNames() + }, + onImport = { text -> + val width = (screenKeys?.width ?: 0).takeIf { it > 0 } ?: resources.displayMetrics.widthPixels + val keys = com.droiddeck.launcher.input.importScreenLayout(text, width, resources.displayMetrics.density) + if (keys != null) { + screenKeys?.load(com.droiddeck.launcher.input.ControllerPrefs.encodeScreenKeys(keys)) + screenLayoutsOpen = false + } + }, + exportText = { + val width = (screenKeys?.width ?: 0).takeIf { it > 0 } ?: resources.displayMetrics.widthPixels + val keys = com.droiddeck.launcher.input.ControllerPrefs.decodeScreenKeys(screenKeys?.export().orEmpty()) + com.droiddeck.launcher.input.exportScreenLayout(keys, width, resources.displayMetrics.density) + }, + onDismiss = { screenLayoutsOpen = false }, + ) androidx.compose.runtime.LaunchedEffect(drawerOpen) { if (drawerOpen) { syncLossless() @@ -939,6 +1050,19 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { }, onTouch = { v -> SessionPrefs.setTouchMode(this@SessionActivity, v); readPrefs() }, onGestureSettings = { drawerOpen = false; gestureSettingsOpen = true }, + onScreenKeys = { drawerOpen = false; screenKeys?.startEditing() }, + screenKeysShown = screenKeysShown, + onScreenKeysShown = { shown -> + screenKeysShown = shown + com.droiddeck.launcher.input.ControllerPrefs.setScreenKeysShown(this@SessionActivity, shown) + screenKeys?.stopEditing() + screenKeys?.visibility = if (shown) View.VISIBLE else View.GONE + }, + onScreenLayouts = { + drawerOpen = false + screenLayoutNames = layoutNames() + screenLayoutsOpen = true + }, onFexPreset = { v -> SessionPrefs.setFexPreset(this@SessionActivity, v); readPrefs() }, onSecondScreenMode = ::selectSecondScreenMode, onSecondScreenDisplay = ::selectSecondScreenDisplay, @@ -1495,7 +1619,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { if (nextTouchMode == SessionPrefs.TOUCH_OFF || !usingTouchpad()) cursorVisible = false } touchMode = nextTouchMode - routedTouchMode = effectiveTouchMode() + val nextRoutedTouchMode = effectiveTouchMode() + if (routedTouchMode != nextRoutedTouchMode) gestureTouchStreamGate.reset() + routedTouchMode = nextRoutedTouchMode frameGen = FrameGen.mode(this) fexPreset = SessionPrefs.fexPreset(this) suspendPolicy = SessionPrefs.suspendPolicy(this, SessionState.mode) @@ -2053,6 +2179,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { return super.dispatchKeyEvent(event) } if (pipUi) return true + if (screenKeyTextFocus) return super.dispatchKeyEvent(event) val pad = com.droiddeck.launcher.input.JoyCon.normalize(event) if (pad !== event) return dispatchKeyEvent(pad) val fromController = PadBridge.isControllerKeyEvent(event) @@ -2254,8 +2381,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { super.dispatchKeyEvent(event) } + private fun layoutNames(): List = + com.droiddeck.launcher.input.ControllerPrefs.screenLayouts(this).keys.sorted() + private fun refreshGestureConfig() { gestureConfig = com.droiddeck.launcher.input.GesturePrefs.read(this, gestureGame) + gestureTouchStreamGate.reset() if (::touchscreenGestures.isInitialized) touchscreenGestures.configure(gestureConfig) gesturePointerReady = false recognizedGesture = null @@ -2544,6 +2675,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun refreshControls() { applyUnfoldedControls() updateOnScreenControls() + screenKeys?.refreshAppearance() } private fun applyUnfoldedControls() { @@ -2629,6 +2761,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { if (::scrollTouch.isInitialized) scrollTouch.cancel() if (CompositorHost.isStarted) WaylandCompositor.nativeSendTouch(3, -1, 0, 0) if (next == SessionPrefs.TOUCH_OFF) cursorVisible = false + gestureTouchStreamGate.reset() routedTouchMode = next } @@ -2819,6 +2952,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { device.plugged = false uiHandler.postDelayed({ updateOnScreenControls() }, 700) } + view.onStyle = { screenKeys?.refreshAppearance() } root.addView(view, root.indexOfChild(onScreenControls) + 1) steamTouchControls = view steamTouchAvailable = true @@ -2849,6 +2983,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { controls.visibility = View.GONE steamTouchControls?.let { it.releaseAll(); it.visibility = View.GONE } com.droiddeck.launcher.input.SteamTouchDevice.current?.plugged = false + screenKeys?.followSteam = false applyTouchRouting() return } @@ -2877,6 +3012,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { onScreenButtonsVisible = show val drawn = show && !keyboardCoversPad() if (steam != null) { + screenKeys?.followSteam = drawn if (controls.visibility == View.VISIBLE) { controls.releaseAll(); controls.visibility = View.GONE } if (!drawn) steam.releaseAll() steam.visibility = if (drawn) View.VISIBLE else View.GONE @@ -2885,6 +3021,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { Log.i(TAG, "on-screen controls: Steam's touch controller " + if (drawn) "shown" else "hidden") return } + screenKeys?.followSteam = false if (drawn == (controls.visibility == View.VISIBLE)) return if (!drawn) controls.releaseAll() controls.visibility = if (drawn) View.VISIBLE else View.GONE @@ -2970,6 +3107,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { pendingBackAction = null releaseDrawerDirection() onScreenControls?.releaseAll() + screenKeys?.releaseAll() releasePads() touchpad.cancel() scrollTouch.cancel() diff --git a/app/src/main/java/com/droiddeck/launcher/input/ControllerPrefs.kt b/app/src/main/java/com/droiddeck/launcher/input/ControllerPrefs.kt index 9b08fd8adb..c784bc3bf6 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/ControllerPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/ControllerPrefs.kt @@ -157,6 +157,56 @@ object ControllerPrefs { prefs(context).edit().remove("layout.${width}x$height").apply() } + fun screenKeysShown(context: Context): Boolean = prefs(context).getBoolean("screenKeysShown", true) + + fun setScreenKeysShown(context: Context, shown: Boolean) { + prefs(context).edit().putBoolean("screenKeysShown", shown).apply() + } + + fun screenKeys(context: Context): List = decodeScreenKeys(prefs(context).getString("screenKeys", null).orEmpty()) + + fun setScreenKeys(context: Context, keys: List) { + prefs(context).edit().putString("screenKeys", encodeScreenKeys(keys)).apply() + } + + fun encodeScreenKeys(keys: List): String = keys.joinToString(";") { + "${it.codes.joinToString("+")}:${it.x},${it.y},${it.size}:${escape(it.glyph)}:${escape(it.text)}:${escape(it.image)}:${it.opacity}:${it.shape}:${if (it.toggle) 1 else 0}:${if (it.labels) 1 else 0}" + } + + fun decodeScreenKeys(raw: String): List = raw.split(';').mapNotNull { entry -> + val parts = entry.split(':') + if (parts.size < 2) return@mapNotNull null + val keys = parts[0].split('+').mapNotNull { it.toIntOrNull() }.takeIf { it.isNotEmpty() } ?: return@mapNotNull null + val nums = parts[1].split(',').mapNotNull { it.toFloatOrNull() }.takeIf { it.size == 3 } ?: return@mapNotNull null + ScreenKey( + keys, nums[0], nums[1], nums[2].toInt(), + parts.getOrNull(2)?.let(::unescape).orEmpty(), + parts.getOrNull(3)?.let(::unescape).orEmpty(), + parts.getOrNull(4)?.let(::unescape).orEmpty(), + parts.getOrNull(5)?.toFloatOrNull()?.coerceIn(0.2f, 1f) ?: 1f, + parts.getOrNull(6)?.toIntOrNull()?.coerceIn(SCREEN_KEY_PILL, SCREEN_KEY_STICK) ?: SCREEN_KEY_PILL, + parts.getOrNull(7) == "1", + parts.getOrNull(8) != "0", + ) + } + + fun screenLayouts(context: Context): Map = + prefs(context).all.mapNotNull { (key, value) -> + if (!key.startsWith("screenLayout.") || value !is String) null else key.removePrefix("screenLayout.") to value + }.toMap() + + fun saveScreenLayout(context: Context, name: String, raw: String) { + prefs(context).edit().putString("screenLayout.$name", raw).apply() + } + + fun deleteScreenLayout(context: Context, name: String) { + prefs(context).edit().remove("screenLayout.$name").apply() + } + + private fun escape(value: String) = value.replace("%", "%25").replace(";", "%3B").replace(":", "%3A").replace(",", "%2C") + + private fun unescape(value: String) = value.replace("%2C", ",").replace("%3A", ":").replace("%3B", ";").replace("%25", "%") + fun resetAll(context: Context) { prefs(context).edit().clear().putBoolean("rumble", true).apply() } diff --git a/app/src/main/java/com/droiddeck/launcher/input/GestureTouchStreamGate.kt b/app/src/main/java/com/droiddeck/launcher/input/GestureTouchStreamGate.kt new file mode 100644 index 0000000000..e4ad4f655d --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/GestureTouchStreamGate.kt @@ -0,0 +1,21 @@ +package com.droiddeck.launcher.input + +import android.view.MotionEvent + +/** Keeps split Android touch targets from restarting one shared gesture recognizer. */ +internal class GestureTouchStreamGate { + enum class Source { SURFACE, SCREEN_KEYS } + + private var owner: Source? = null + + fun accepts(source: Source, event: MotionEvent): Boolean { + if (owner == null && event.actionMasked == MotionEvent.ACTION_DOWN) owner = source + val accepted = owner == source + if (accepted && (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_CANCEL)) { + owner = null + } + return accepted + } + + fun reset() { owner = null } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/PcKeys.kt b/app/src/main/java/com/droiddeck/launcher/input/PcKeys.kt new file mode 100644 index 0000000000..f3ab1d4c6a --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/PcKeys.kt @@ -0,0 +1,60 @@ +package com.droiddeck.launcher.input + +import android.content.Context +import androidx.annotation.StringRes +import com.droiddeck.launcher.R + +data class PcKey( + val label: String, + val code: Int, + val weight: Float = 1f, + val shifted: String? = null, + @StringRes val labelRes: Int = 0, +) + +internal fun k(label: String, code: Int, weight: Float = 1f, shifted: String? = null) = PcKey(label, code, weight, shifted) + +internal fun k(@StringRes labelRes: Int, code: Int, weight: Float = 1f) = PcKey("", code, weight, null, labelRes) + +val PC_KEY_ROWS: List> = listOf( + listOf( + k(R.string.pckb_key_esc, 1), k("F1", 59), k("F2", 60), k("F3", 61), k("F4", 62), k("F5", 63), k("F6", 64), + k("F7", 65), k("F8", 66), k("F9", 67), k("F10", 68), k("F11", 87), k("F12", 88), + k(R.string.pckb_key_ins, 110), k(R.string.pckb_key_del, 111), k(R.string.pckb_key_home, 102), k(R.string.pckb_key_end, 107), k(R.string.pckb_key_pgup, 104), k(R.string.pckb_key_pgdn, 109), + ), + listOf( + k("`", 41, shifted = "~"), k("1", 2, shifted = "!"), k("2", 3, shifted = "@"), k("3", 4, shifted = "#"), + k("4", 5, shifted = "$"), k("5", 6, shifted = "%"), k("6", 7, shifted = "^"), k("7", 8, shifted = "&"), + k("8", 9, shifted = "*"), k("9", 10, shifted = "("), k("0", 11, shifted = ")"), k("-", 12, shifted = "_"), + k("=", 13, shifted = "+"), k(R.string.pckb_key_backspace, 14, 2f), + ), + listOf( + k(R.string.pckb_key_tab, 15, 1.5f), k("q", 16), k("w", 17), k("e", 18), k("r", 19), k("t", 20), k("y", 21), + k("u", 22), k("i", 23), k("o", 24), k("p", 25), k("[", 26, shifted = "{"), k("]", 27, shifted = "}"), + k("\\", 43, 1.5f, shifted = "|"), + ), + listOf( + k(R.string.pckb_key_caps, 58, 1.75f), k("a", 30), k("s", 31), k("d", 32), k("f", 33), k("g", 34), k("h", 35), + k("j", 36), k("k", 37), k("l", 38), k(";", 39, shifted = ":"), k("'", 40, shifted = "\""), + k(R.string.pckb_key_enter, 28, 2.25f), + ), + listOf( + k(R.string.pckb_key_shift, 42, 2.25f), k("z", 44), k("x", 45), k("c", 46), k("v", 47), k("b", 48), k("n", 49), + k("m", 50), k(",", 51, shifted = "<"), k(".", 52, shifted = ">"), k("/", 53, shifted = "?"), + k(R.string.pckb_key_shift, 54, 1.75f), k("↑", 103), + ), + listOf( + k(R.string.pckb_key_ctrl, 29, 1.5f), k(R.string.pckb_key_super, 125, 1.25f), k(R.string.pckb_key_alt, 56, 1.25f), k(R.string.pckb_key_space, 57, 6.25f), + k(R.string.pckb_key_altgr, 100, 1.25f), k(R.string.pckb_key_ctrl, 97, 1.25f), k("←", 105), k("↓", 108), k("→", 106), + ), +) + +val PC_MODIFIERS: Set = setOf(42, 54, 29, 97, 56, 100, 125) + +val PC_KEYS: Map = PC_KEY_ROWS.flatten().associateBy { it.code } + +fun pcKeyLabel(context: Context, code: Int): String { + val key = PC_KEYS[code] ?: return code.toString() + val text = if (key.labelRes != 0) context.getString(key.labelRes) else key.label + return if (text.length == 1 && text[0].isLetter()) text.uppercase() else text +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/ScreenKey.kt b/app/src/main/java/com/droiddeck/launcher/input/ScreenKey.kt new file mode 100644 index 0000000000..2967a06f6a --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/ScreenKey.kt @@ -0,0 +1,63 @@ +package com.droiddeck.launcher.input + +import android.content.Context + +fun screenKeyLabel(context: Context, codes: List): String = + codes.filter { it != 0 }.joinToString("+") { short(context, it) } + +private fun short(context: Context, code: Int): String = when (code) { + 28 -> "⏎" + 14 -> "⌫" + 15 -> "Tab" + 57 -> "Space" + 58 -> "Caps" + 42, 54 -> "Shift" + 29, 97 -> "Ctrl" + 56 -> "Alt" + 100 -> "AltGr" + 125 -> "Super" + else -> pcKeyLabel(context, code) +} + +const val SCREEN_KEY_PILL = 0 +const val SCREEN_KEY_ROUND = 1 +const val SCREEN_KEY_CIRCLE = 2 +const val SCREEN_KEY_RECT = 3 +const val SCREEN_KEY_TRIGGER = 4 +const val SCREEN_KEY_DPAD = 5 +const val SCREEN_KEY_STICK = 6 + +val SCREEN_KEY_DPAD_DIRS = listOf("↑", "→", "↓", "←") +val SCREEN_KEY_STICK_DIRS = listOf("↑", "↗", "→", "↘", "↓", "↙", "←", "↖") + +fun screenKeyDirections(shape: Int): List = when (shape) { + SCREEN_KEY_DPAD -> SCREEN_KEY_DPAD_DIRS + SCREEN_KEY_STICK -> SCREEN_KEY_STICK_DIRS + else -> emptyList() +} + +val SCREEN_KEY_SHAPES = + listOf( + SCREEN_KEY_PILL, SCREEN_KEY_ROUND, SCREEN_KEY_CIRCLE, SCREEN_KEY_RECT, + SCREEN_KEY_TRIGGER, SCREEN_KEY_DPAD, SCREEN_KEY_STICK, + ) + +data class ScreenKey( + val codes: List, + val x: Float, + val y: Float, + val size: Int, + val glyph: String = "", + val text: String = "", + val image: String = "", + val opacity: Float = 1f, + val shape: Int = SCREEN_KEY_PILL, + val toggle: Boolean = false, + val labels: Boolean = true, +) { + fun shownLabel(context: Context): String = when { + text.isNotEmpty() -> text + glyph.isNotEmpty() -> glyph + else -> screenKeyLabel(context, codes) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/ScreenKeyIcons.kt b/app/src/main/java/com/droiddeck/launcher/input/ScreenKeyIcons.kt new file mode 100644 index 0000000000..b1ea677b99 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/ScreenKeyIcons.kt @@ -0,0 +1,148 @@ +package com.droiddeck.launcher.input + +import android.graphics.Canvas +import android.graphics.Paint +import android.graphics.Path + +object ScreenKeyIcons { + fun has(code: Int): Boolean = code in SET + + private val SET = setOf(28, 14, 15, 57, 42, 54, 29, 97, 125, 103, 108, 105, 106) + + fun draw(canvas: Canvas, code: Int, cx: Float, cy: Float, box: Float, paint: Paint): Boolean { + if (!has(code)) return false + val h = box / 2f + val stroke = box * 0.085f + val path = Path() + paint.style = Paint.Style.STROKE + paint.strokeWidth = stroke + paint.strokeCap = Paint.Cap.ROUND + paint.strokeJoin = Paint.Join.ROUND + when (code) { + 28 -> { + path.moveTo(cx - 0.34f * h, cy - 0.22f * h) + path.lineTo(cx + 0.30f * h, cy - 0.22f * h) + path.lineTo(cx + 0.30f * h, cy + 0.24f * h) + path.lineTo(cx - 0.04f * h, cy + 0.24f * h) + canvas.drawPath(path, paint) + path.reset() + path.moveTo(cx + 0.12f * h, cy + 0.06f * h) + path.lineTo(cx - 0.04f * h, cy + 0.24f * h) + path.lineTo(cx + 0.12f * h, cy + 0.42f * h) + canvas.drawPath(path, paint) + } + + 14 -> { + path.moveTo(cx - 0.72f * h, cy) + path.lineTo(cx - 0.10f * h, cy - 0.50f * h) + path.lineTo(cx + 0.74f * h, cy - 0.50f * h) + path.lineTo(cx + 0.74f * h, cy + 0.50f * h) + path.lineTo(cx - 0.10f * h, cy + 0.50f * h) + path.close() + canvas.drawPath(path, paint) + path.reset() + path.moveTo(cx + 0.10f * h, cy - 0.20f * h) + path.lineTo(cx + 0.44f * h, cy + 0.20f * h) + path.moveTo(cx + 0.44f * h, cy - 0.20f * h) + path.lineTo(cx + 0.10f * h, cy + 0.20f * h) + canvas.drawPath(path, paint) + } + + 15 -> { + path.moveTo(cx - 0.72f * h, cy) + path.lineTo(cx + 0.44f * h, cy) + path.moveTo(cx + 0.14f * h, cy - 0.30f * h) + path.lineTo(cx + 0.46f * h, cy) + path.lineTo(cx + 0.14f * h, cy + 0.30f * h) + canvas.drawPath(path, paint) + path.reset() + path.moveTo(cx + 0.70f * h, cy - 0.48f * h) + path.lineTo(cx + 0.70f * h, cy + 0.48f * h) + canvas.drawPath(path, paint) + } + + 57 -> { + path.moveTo(cx - 0.64f * h, cy - 0.22f * h) + path.lineTo(cx - 0.64f * h, cy + 0.20f * h) + path.lineTo(cx + 0.64f * h, cy + 0.20f * h) + path.lineTo(cx + 0.64f * h, cy - 0.22f * h) + canvas.drawPath(path, paint) + } + + 42, 54 -> { + paint.style = Paint.Style.FILL + path.moveTo(cx, cy - 0.55f * h) + path.lineTo(cx + 0.62f * h, cy + 0.02f * h) + path.lineTo(cx + 0.26f * h, cy + 0.02f * h) + path.lineTo(cx + 0.26f * h, cy + 0.32f * h) + path.lineTo(cx - 0.26f * h, cy + 0.32f * h) + path.lineTo(cx - 0.26f * h, cy + 0.02f * h) + path.lineTo(cx - 0.62f * h, cy + 0.02f * h) + path.close() + canvas.drawPath(path, paint) + path.reset() + path.moveTo(cx - 0.26f * h, cy + 0.44f * h) + path.lineTo(cx + 0.26f * h, cy + 0.44f * h) + path.lineTo(cx + 0.26f * h, cy + 0.58f * h) + path.lineTo(cx - 0.26f * h, cy + 0.58f * h) + path.close() + canvas.drawPath(path, paint) + } + + 29, 97 -> { + path.moveTo(cx - 0.58f * h, cy + 0.26f * h) + path.lineTo(cx, cy - 0.28f * h) + path.lineTo(cx + 0.58f * h, cy + 0.26f * h) + canvas.drawPath(path, paint) + } + + 125 -> { + paint.style = Paint.Style.FILL + val gap = 0.07f * h + val side = 0.34f * h + for (dxi in -1..1 step 2) for (dyi in -1..1 step 2) { + val left = cx + dxi * (gap + side / 2f) - side / 2f + val top = cy + dyi * (gap + side / 2f) - side / 2f + path.addRect(left, top, left + side, top + side, Path.Direction.CW) + } + canvas.drawPath(path, paint) + } + + 103, 108, 105, 106 -> { + paint.style = Paint.Style.FILL + val r = 0.52f * h + when (code) { + 103 -> { + path.moveTo(cx, cy - r) + path.lineTo(cx + r * 0.80f, cy + r * 0.55f) + path.lineTo(cx - r * 0.80f, cy + r * 0.55f) + } + + 108 -> { + path.moveTo(cx, cy + r) + path.lineTo(cx + r * 0.80f, cy - r * 0.55f) + path.lineTo(cx - r * 0.80f, cy - r * 0.55f) + } + + 105 -> { + path.moveTo(cx - r, cy) + path.lineTo(cx + r * 0.55f, cy - r * 0.80f) + path.lineTo(cx + r * 0.55f, cy + r * 0.80f) + } + + else -> { + path.moveTo(cx + r, cy) + path.lineTo(cx - r * 0.55f, cy - r * 0.80f) + path.lineTo(cx - r * 0.55f, cy + r * 0.80f) + } + } + path.close() + canvas.drawPath(path, paint) + } + } + paint.style = Paint.Style.FILL + paint.strokeCap = Paint.Cap.BUTT + paint.strokeJoin = Paint.Join.MITER + return true + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/ScreenKeys.kt b/app/src/main/java/com/droiddeck/launcher/input/ScreenKeys.kt new file mode 100644 index 0000000000..4cc87ef0b8 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/ScreenKeys.kt @@ -0,0 +1,1122 @@ +package com.droiddeck.launcher.input + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.BitmapFactory +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.Paint +import android.graphics.PointF +import android.graphics.Rect +import android.graphics.RectF +import android.graphics.Typeface +import android.os.Build +import android.view.MotionEvent +import android.view.View +import android.view.WindowInsets +import java.io.File +import kotlin.math.abs +import kotlin.math.hypot +import kotlin.math.round + +class ScreenKeys(context: Context, private val sendKey: (Int, Boolean) -> Unit) : View(context) { + private class Entry(val codes: List) { + var glyph = "" + var text = "" + var image = "" + var bitmap: Bitmap? = null + var bitmapFor = "" + var x = 0.5f + var y = 0.5f + var size = DEFAULT_SIZE + var opacity = 1f + var shape = SCREEN_KEY_PILL + var toggle = false + var labels = true + var armed = -1 + var cx = 0f + var cy = 0f + var halfW = 0f + var halfH = 0f + } + + private val entries = mutableListOf() + private val down = HashMap() + private val latched = mutableListOf() + private val dpadDown = HashMap() + private val stickEntries = HashMap() + private val stickCodes = HashMap>() + private val held = HashMap() + private var forwardedPointerBits = 0 + private var addX = -1f + private var addY = -1f + private var pressX = 0f + private var pressY = 0f + private var guideX = -1f + private var guideY = -1f + private val addPress = Runnable { addX = pressX; addY = pressY; onAdd?.invoke() } + private var editing = false + private var selected: Entry? = null + private var dragX = 0f + private var dragY = 0f + private var dragging = false + private var moved = false + private var toolbarDrag = false + private var safe = Rect() + private var tint = ControllerPrefs.STEAM_BLUE + + init { + ControllerPrefs.screenKeys(context).forEach { key -> entries += entryOf(key) } + } + + var followSteam = false + set(value) { + if (field == value) return + field = value + invalidate() + } + + var steamStyle: () -> Pair? = { null } + + var onAdd: (() -> Unit)? = null + var onSelect: ((List) -> Unit)? = null + var onEditingChanged: ((Boolean) -> Unit)? = null + var onTouchMiss: ((MotionEvent) -> Unit)? = null + + private val fillPaint = Paint(Paint.ANTI_ALIAS_FLAG) + private val strokePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE } + private val ringPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE } + private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + textAlign = Paint.Align.CENTER + typeface = Typeface.DEFAULT_BOLD + } + private val gridPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE } + private val rect = RectF() + private val bodyPathRect = RectF() + private val bodyPath = android.graphics.Path() + private val clipPath = android.graphics.Path() + private val imageRect = RectF() + private val bitmapRect = RectF() + + private val capsuleRadius = dp(24f) + private val capsuleGap = dp(62f) + private val toolbar = PointF() + private val addCenter = PointF() + private val doneCenter = PointF() + + fun startEditing() { + if (editing) return + editing = true + releaseAll() + selected = null + placeToolbar() + invalidate() + onEditingChanged?.invoke(true) + } + + fun stopEditing() { + if (!editing) return + releaseAll() + editing = false + selected = null + save() + invalidate() + onEditingChanged?.invoke(false) + } + + fun add(codes: List) { + if (codes.isEmpty()) return + entries.firstOrNull { it.codes == codes }?.let { + selected = it + invalidate() + return + } + val entry = Entry(codes) + if (addX >= 0f && width > 0) { + entry.x = (addX / width).coerceIn(0.05f, 0.95f) + entry.y = (addY / height).coerceIn(0.05f, 0.95f) + } else { + entry.x = (0.30f + 0.08f * (entries.size % 5)).coerceAtMost(0.70f) + entry.y = 0.62f + } + addX = -1f + addY = -1f + entries += entry + if (width > 0) measure(entry) + selected = entry + save() + invalidate() + } + + fun remove(codes: List) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + entries.remove(entry) + if (selected === entry) selected = null + save() + invalidate() + } + + fun setCodes(from: List, to: List): ScreenKey? { + if (to.isEmpty()) return null + val index = entries.indexOfFirst { it.codes == from } + if (index < 0) return null + val old = entries[index] + if (to != from && entries.any { it !== old && it.codes == to }) return null + val fresh = Entry(to).also { + it.glyph = old.glyph + it.text = old.text + it.image = old.image + it.bitmap = old.bitmap + it.bitmapFor = old.bitmapFor + it.x = old.x + it.y = old.y + it.size = old.size + it.opacity = old.opacity + it.shape = old.shape + it.toggle = old.toggle + it.labels = old.labels + } + entries[index] = fresh + measure(fresh) + if (selected === old) selected = fresh + save() + invalidate() + return stateOf(fresh.codes) + } + + fun setText(codes: List, text: String) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + entry.text = text + measure(entry) + save() + invalidate() + } + + fun setImage(codes: List, image: String) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + val previous = entry.image + entry.image = image + entry.bitmap = null + entry.bitmapFor = "" + if (previous.isNotEmpty() && previous != image) File(File(context.filesDir, IMAGE_DIR), previous).delete() + measure(entry) + save() + invalidate() + } + + fun resize(codes: List, size: Int) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + entry.size = size.coerceIn(MIN_SIZE, MAX_SIZE) + measure(entry) + save() + invalidate() + } + + fun setOpacity(codes: List, opacity: Float) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + entry.opacity = opacity.coerceIn(0.2f, 1f) + save() + invalidate() + } + + fun setShape(codes: List, shape: Int) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + entry.shape = shape.coerceIn(SCREEN_KEY_PILL, SCREEN_KEY_STICK) + measure(entry) + save() + invalidate() + } + + fun setToggle(codes: List, toggle: Boolean) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + entry.toggle = toggle + if (!toggle && latched.remove(entry)) release(entry) + save() + invalidate() + } + + fun setLabels(codes: List, labels: Boolean) { + val entry = entries.firstOrNull { it.codes == codes } ?: return + entry.labels = labels + save() + invalidate() + } + + fun setDirection(codes: List, index: Int, code: Int): ScreenKey? { + val entry = entries.firstOrNull { it.codes == codes } ?: entries.firstOrNull { it.codes == trimmed(codes) } ?: return null + val next = entry.codes.toMutableList() + while (next.size <= index) next += 0 + next[index] = code + val nextCodes = trimmed(next) + if (entries.any { it !== entry && it.codes == nextCodes }) return null + val updated = Entry(nextCodes).also { + it.glyph = entry.glyph + it.text = entry.text + it.image = entry.image + it.bitmap = entry.bitmap + it.bitmapFor = entry.bitmapFor + it.x = entry.x + it.y = entry.y + it.size = entry.size + it.opacity = entry.opacity + it.shape = entry.shape + it.toggle = entry.toggle + it.labels = entry.labels + } + entries[entries.indexOf(entry)] = updated + measure(updated) + if (selected === entry) selected = updated + save() + invalidate() + return stateOf(updated.codes) + } + + private fun trimmed(codes: List): List = codes.dropLastWhile { it == 0 }.ifEmpty { listOf(0) } + + fun stateOf(codes: List): ScreenKey? = entries.firstOrNull { it.codes == codes }?.let { + ScreenKey(it.codes, it.x, it.y, it.size, it.glyph, it.text, it.image, it.opacity, it.shape, it.toggle, it.labels) + } + + fun deselect() { + if (selected == null) return + selected = null + invalidate() + } + + override fun onAttachedToWindow() { + super.onAttachedToWindow() + refreshAppearance() + } + + fun refreshAppearance() { + tint = ControllerPrefs.read(context).tint + invalidate() + } + + override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) { + super.onSizeChanged(w, h, oldw, oldh) + entries.forEach { measure(it) } + placeToolbar() + } + + override fun onApplyWindowInsets(insets: WindowInsets): WindowInsets { + val cutout = if (Build.VERSION.SDK_INT >= 28) insets.displayCutout else null + val fresh = Rect( + cutout?.safeInsetLeft ?: 0, cutout?.safeInsetTop ?: 0, + cutout?.safeInsetRight ?: 0, cutout?.safeInsetBottom ?: 0, + ) + if (fresh != safe) { + safe = fresh + placeToolbar() + invalidate() + } + return super.onApplyWindowInsets(insets) + } + + override fun onDetachedFromWindow() { + releaseAll() + super.onDetachedFromWindow() + } + + override fun onVisibilityChanged(changedView: View, visibility: Int) { + super.onVisibilityChanged(changedView, visibility) + if (visibility != VISIBLE) releaseAll() + } + + override fun setVisibility(visibility: Int) { + super.setVisibility(visibility) + if (visibility != VISIBLE) releaseAll() + } + + fun releaseAll() { + dpadDown.values.forEach { releaseKey(it) } + dpadDown.clear() + entries.forEach { it.armed = -1 } + stickCodes.values.flatten().forEach { if (it != 0) releaseKey(it) } + stickCodes.clear() + stickEntries.clear() + down.values.forEach { release(it) } + down.clear() + latched.toList().forEach { release(it) } + latched.clear() + invalidate() + } + + private fun snap(value: Float) = if (width > 0) round(value / (width / 100f)) * (width / 100f) else value + + private fun placeToolbar() { + if (width == 0 || height == 0) return + if (toolbar.x == 0f && toolbar.y == 0f) { + toolbar.set(width - safe.right - capsuleGap - capsuleRadius, height - safe.bottom - capsuleRadius - dp(20f)) + } + addCenter.set(toolbar.x - capsuleGap / 2f, toolbar.y) + doneCenter.set(toolbar.x + capsuleGap / 2f, toolbar.y) + } + + private fun entryOf(key: ScreenKey): Entry = Entry(key.codes).also { + it.glyph = key.glyph + it.text = key.text + it.image = key.image + it.x = key.x + it.y = key.y + it.size = key.size + it.opacity = key.opacity + it.shape = key.shape + it.toggle = key.toggle + it.labels = key.labels + } + + private fun label(entry: Entry) = when { + entry.text.isNotEmpty() -> entry.text + entry.glyph.isNotEmpty() -> entry.glyph + else -> screenKeyLabel(context, entry.codes) + } + + private fun bitmapFor(entry: Entry): Bitmap? { + if (entry.image.isEmpty()) return null + if (entry.bitmapFor == entry.image) return entry.bitmap + val file = File(File(context.filesDir, IMAGE_DIR), entry.image) + val bitmap = if (file.isFile) BitmapFactory.decodeFile(file.absolutePath) else null + entry.bitmap = bitmap + entry.bitmapFor = entry.image + return bitmap + } + + private fun measure(entry: Entry) { + val h = dp(entry.size.toFloat()) + entry.halfH = h / 2f + entry.halfW = when { + entry.shape == SCREEN_KEY_CIRCLE -> entry.halfH + entry.shape == SCREEN_KEY_TRIGGER -> entry.halfH * 1.7f + entry.shape == SCREEN_KEY_DPAD || entry.shape == SCREEN_KEY_STICK -> entry.halfH * 1.15f + entry.image.isNotEmpty() -> entry.halfH * 1.15f + hasIcon(entry) -> entry.halfH * 1.15f + else -> { + val chars = label(entry).length + entry.halfH * (0.55f * chars + 1.05f).coerceIn(1.7f, 4.6f) + } + } + entry.cx = entry.x * width + entry.cy = entry.y * height + } + + private fun hasIcon(entry: Entry): Boolean = + entry.text.isEmpty() && entry.glyph.isEmpty() && entry.codes.size == 1 && ScreenKeyIcons.has(entry.codes[0]) + + private fun unit() = minOf(width / 1280f, height / 720f) + + private fun accent(): Pair { + val style = if (followSteam) steamStyle() else null + return (style?.first ?: tint) to (style?.second ?: 1f) + } + + private fun tinted(color: Int, alpha: Float): Int { + val scale = accent().second + return Color.argb( + (alpha * scale * 255f).toInt().coerceIn(0, 255), + Color.red(color), Color.green(color), Color.blue(color), + ) + } + + private fun triggerPath(entry: Entry, path: android.graphics.Path, inset: Float = 0f) { + val lean = (entry.halfH - inset) * 0.6f + val left = entry.cx - entry.halfW + inset + val right = entry.cx + entry.halfW - inset + val top = entry.cy - entry.halfH + inset + val bottom = entry.cy + entry.halfH - inset + path.reset() + path.moveTo(left + lean, top) + path.lineTo(right, top) + path.lineTo(right - lean, bottom) + path.lineTo(left, bottom) + path.close() + } + + private fun body(canvas: Canvas, entry: Entry, radius: Float, paint: Paint, inset: Float = 0f) { + if (entry.shape != SCREEN_KEY_TRIGGER) { + canvas.drawRoundRect(rect, radius, radius, paint) + return + } + triggerPath(entry, bodyPath, inset) + canvas.drawPath(bodyPath, paint) + } + + private fun drawDpad(canvas: Canvas, entry: Entry) { + val color = accent().first + val alpha = entry.opacity + val r = minOf(entry.halfW, entry.halfH) + val t = r * 0.42f + val hairline = maxOf(dp(1.2f), entry.halfH * 0.032f) + val engaged = entry.armed >= 0 + crossPath(entry, bodyPath, r, t) + fillPaint.style = Paint.Style.FILL + fillPaint.color = tinted(color, if (entry.armed >= 0) 0.26f * alpha else 0.10f * alpha) + canvas.drawPath(bodyPath, fillPaint) + if (entry.armed >= 0) { + armRect(entry, bodyPathRect, entry.armed, r, t) + fillPaint.color = tinted(color, 0.55f * alpha) + canvas.drawRoundRect(bodyPathRect, t * 0.6f, t * 0.6f, fillPaint) + } + strokePaint.strokeJoin = Paint.Join.ROUND + strokePaint.strokeWidth = if (engaged) hairline * 1.6f else hairline + strokePaint.color = tinted(color, (if (editing) 0.90f else 0.80f) * alpha) + canvas.drawPath(bodyPath, strokePaint) + textPaint.setShadowLayer(0f, 0f, 0f, 0) + fillPaint.color = tinted(color, if (editing) 0.90f else 0.80f) + DPAD_DIRS.forEachIndexed { index, dir -> + val on = entry.armed == index + val code = entry.codes.getOrNull(index) ?: 0 + val name = if (code == 0) "" else screenKeyLabel(context, listOf(code)) + if (entry.labels && name.isNotEmpty()) { + textPaint.color = if (on) Color.WHITE else tinted(color, alpha) + textPaint.textSize = dp(48f) + val fit = 48f * (t * 1.9f) / textPaint.measureText(name).coerceAtLeast(1f) + textPaint.textSize = minOf(fit, t * 1.7f).coerceIn(dp(8f), dp(60f)) + val tx = entry.cx + dir.first * (r - t * 0.6f) + val ty = entry.cy + dir.second * (r - t * 0.6f) + canvas.drawText(name, tx, ty - (textPaint.ascent() + textPaint.descent()) / 2f, textPaint) + } else { + fillPaint.color = if (on) Color.WHITE else tinted(color, if (editing) 0.90f else 0.80f) + arrow(canvas, fillPaint, entry.cx, entry.cy, r - t * 0.55f, dir.first, dir.second, t * 0.8f) + } + } + if (editing && selected === entry) { + ringPaint.strokeWidth = hairline * 0.8f + ringPaint.color = tinted(color, 0.9f) + ringPaint.style = Paint.Style.STROKE + canvas.drawCircle(entry.cx, entry.cy, r + hairline * 3f, ringPaint) + } + } + + private fun crossPath(entry: Entry, path: android.graphics.Path, r: Float, t: Float) { + val cx = entry.cx + val cy = entry.cy + path.reset() + path.moveTo(cx - t, cy - r) + path.lineTo(cx + t, cy - r) + path.lineTo(cx + t, cy - t) + path.lineTo(cx + r, cy - t) + path.lineTo(cx + r, cy + t) + path.lineTo(cx + t, cy + t) + path.lineTo(cx + t, cy + r) + path.lineTo(cx - t, cy + r) + path.lineTo(cx - t, cy + t) + path.lineTo(cx - r, cy + t) + path.lineTo(cx - r, cy - t) + path.lineTo(cx - t, cy - t) + path.close() + } + + private fun armRect(entry: Entry, rect: RectF, index: Int, r: Float, t: Float) { + when (index) { + 0 -> rect.set(entry.cx - t, entry.cy - r, entry.cx + t, entry.cy - t) + 1 -> rect.set(entry.cx + t, entry.cy - t, entry.cx + r, entry.cy + t) + 2 -> rect.set(entry.cx - t, entry.cy + t, entry.cx + t, entry.cy + r) + else -> rect.set(entry.cx - r, entry.cy - t, entry.cx - t, entry.cy + t) + } + } + + private fun arrow(canvas: Canvas, paint: Paint, cx: Float, cy: Float, dist: Float, dx: Float, dy: Float, size: Float) { + val tipX = cx + dx * dist + val tipY = cy + dy * dist + val baseX = cx + dx * (dist - size) + val baseY = cy + dy * (dist - size) + val nx = -dy * size * 0.62f + val ny = dx * size * 0.62f + bodyPath.reset() + bodyPath.moveTo(tipX, tipY) + bodyPath.lineTo(baseX + nx, baseY + ny) + bodyPath.lineTo(baseX - nx, baseY - ny) + bodyPath.close() + canvas.drawPath(bodyPath, paint) + } + + private fun armOf(entry: Entry, x: Float, y: Float): Int { + val dx = x - entry.cx + val dy = y - entry.cy + return if (abs(dx) > abs(dy)) (if (dx > 0f) 1 else 3) else (if (dy > 0f) 2 else 0) + } + + private fun drawStick(canvas: Canvas, entry: Entry) { + val color = accent().first + val alpha = entry.opacity + val engaged = entry.armed >= 0 + val radius = minOf(entry.halfW, entry.halfH) + val hairline = maxOf(dp(1.2f), entry.halfH * 0.032f) + fillPaint.style = Paint.Style.FILL + fillPaint.color = tinted(color, 0.14f * alpha) + canvas.drawCircle(entry.cx, entry.cy, radius - hairline, fillPaint) + strokePaint.strokeWidth = if (engaged) hairline * 1.6f else hairline + strokePaint.color = tinted(color, (if (editing) 0.90f else 0.80f) * alpha) + canvas.drawCircle(entry.cx, entry.cy, radius - hairline / 2f, strokePaint) + val dir = if (engaged) STICK_DIRS[entry.armed.coerceIn(0, 7)] else 0f to 0f + val knob = radius * 0.36f + fillPaint.color = tinted(color, if (engaged) 0.55f * alpha else 0.24f * alpha) + canvas.drawCircle(entry.cx + dir.first * radius * 0.40f, entry.cy + dir.second * radius * 0.40f, knob, fillPaint) + strokePaint.strokeWidth = hairline + strokePaint.color = tinted(color, (if (editing) 0.90f else 0.80f) * alpha) + canvas.drawCircle(entry.cx + dir.first * radius * 0.40f, entry.cy + dir.second * radius * 0.40f, knob, strokePaint) + textPaint.setShadowLayer(0f, 0f, 0f, 0) + STICK_DIRS.forEachIndexed { index, unit -> + val on = entry.armed == index + val code = entry.codes.getOrNull(index) ?: 0 + val name = if (code == 0) "" else screenKeyLabel(context, listOf(code)) + if (entry.labels && name.isNotEmpty()) { + textPaint.color = if (on) Color.WHITE else tinted(color, 0.85f * alpha) + textPaint.textSize = dp(48f) + val fit = 48f * (radius * 0.34f) / textPaint.measureText(name).coerceAtLeast(1f) + textPaint.textSize = minOf(fit, radius * 0.22f).coerceAtLeast(dp(6f)) + val tx = entry.cx + unit.first * radius * 0.66f + val ty = entry.cy + unit.second * radius * 0.66f + canvas.drawText(name, tx, ty - (textPaint.ascent() + textPaint.descent()) / 2f, textPaint) + } else { + fillPaint.color = if (on) Color.WHITE else tinted(color, if (editing) 0.88f else 0.72f) + arrow(canvas, fillPaint, entry.cx, entry.cy, radius * 0.88f, unit.first, unit.second, radius * 0.16f) + } + } + if (editing && selected === entry) { + ringPaint.strokeWidth = hairline * 0.8f + ringPaint.color = tinted(color, 0.9f) + ringPaint.style = Paint.Style.STROKE + canvas.drawCircle(entry.cx, entry.cy, radius + hairline * 3f, ringPaint) + } + } + + private fun directionCodes(entry: Entry, index: Int): List { + if (index < 0) return emptyList() + val code = entry.codes.getOrNull(index) ?: 0 + if (code != 0) return listOf(code) + if (entry.shape != SCREEN_KEY_STICK || index % 2 == 0) return emptyList() + return listOfNotNull( + entry.codes.getOrNull((index + 7) % 8)?.takeIf { it != 0 }, + entry.codes.getOrNull((index + 1) % 8)?.takeIf { it != 0 }, + ) + } + + private fun stickSector(entry: Entry, x: Float, y: Float): Int { + val dx = x - entry.cx + val dy = y - entry.cy + if (hypot(dx, dy) < minOf(entry.halfW, entry.halfH) * 0.24f) return -1 + val degrees = Math.toDegrees(kotlin.math.atan2(dy, dx).toDouble()).toFloat() + val index = (round(degrees / 45f).toInt() + 2) % 8 + return (index + 8) % 8 + } + + private fun radiusOf(entry: Entry): Float = when (entry.shape) { + SCREEN_KEY_ROUND -> entry.halfH * 0.30f + SCREEN_KEY_RECT -> entry.halfH * 0.12f + SCREEN_KEY_TRIGGER -> entry.halfH * 0.45f + else -> entry.halfH + } + + private fun entryAt(x: Float, y: Float): Entry? = entries.lastOrNull { entry -> + x >= entry.cx - entry.halfW && x <= entry.cx + entry.halfW && y >= entry.cy - entry.halfH && y <= entry.cy + entry.halfH + } + + private fun inCircle(center: PointF, x: Float, y: Float, radius: Float) = hypot(x - center.x, y - center.y) <= radius + + private fun inToolbar(x: Float, y: Float): Boolean = + editing && x >= toolbar.x - capsuleGap / 2f - capsuleRadius && x <= toolbar.x + capsuleGap / 2f + capsuleRadius && + y >= toolbar.y - capsuleRadius && y <= toolbar.y + capsuleRadius + + override fun onDraw(canvas: Canvas) { + if (editing) drawGrid(canvas) + entries.forEach { draw(canvas, it) } + if (editing) { + drawGuides(canvas) + drawToolbar(canvas) + } + } + + private fun drawGuides(canvas: Canvas) { + if (guideX < 0f && guideY < 0f) return + gridPaint.strokeWidth = dp(1f) + gridPaint.color = tinted(accent().first, 0.9f) + if (guideX >= 0f) canvas.drawLine(guideX, 0f, guideX, height.toFloat(), gridPaint) + if (guideY >= 0f) canvas.drawLine(0f, guideY, width.toFloat(), guideY, gridPaint) + } + + private fun drawGrid(canvas: Canvas) { + if (width == 0 || height == 0) return + val step = width / 100f + gridPaint.strokeWidth = dp(1f) + gridPaint.color = Color.argb(38, 255, 255, 255) + var x = step + while (x < width) { + canvas.drawLine(x, 0f, x, height.toFloat(), gridPaint) + x += step + } + var y = step + while (y < height) { + canvas.drawLine(0f, y, width.toFloat(), y, gridPaint) + y += step + } + gridPaint.color = Color.argb(96, 255, 255, 255) + gridPaint.strokeWidth = dp(1f) + canvas.drawLine(width / 2f, 0f, width / 2f, height.toFloat(), gridPaint) + canvas.drawLine(0f, height / 2f, width.toFloat(), height / 2f, gridPaint) + } + + private fun draw(canvas: Canvas, entry: Entry) { + if (entry.shape == SCREEN_KEY_DPAD) { + drawDpad(canvas, entry) + return + } + if (entry.shape == SCREEN_KEY_STICK) { + drawStick(canvas, entry) + return + } + val style = if (followSteam) steamStyle() else null + val engaged = down.values.any { it === entry } || latched.contains(entry) + val bitmap = bitmapFor(entry) + val icon = bitmap == null && hasIcon(entry) + val frameless = entry.text.isBlank() && (bitmap != null || icon) + val alpha = entry.opacity + val h2 = entry.halfH * 2f + val radius = radiusOf(entry) + val selectedNow = editing && selected === entry + val hairline = maxOf(dp(1.2f), h2 * 0.032f) + rect.set(entry.cx - entry.halfW, entry.cy - entry.halfH, entry.cx + entry.halfW, entry.cy + entry.halfH) + val inkColor: Int + if (style != null) { + val inkAlpha = (255f * style.second * alpha).toInt().coerceIn(30, 255) + inkColor = Color.argb(inkAlpha, Color.red(style.first), Color.green(style.first), Color.blue(style.first)) + fillPaint.style = Paint.Style.FILL + if (engaged) { + fillPaint.color = Color.argb((inkAlpha * 0.85f).toInt(), 230, 233, 236) + body(canvas, entry, radius, fillPaint) + } + if (frameless) { + if (engaged) { + fillPaint.color = Color.argb((inkAlpha * 0.45f).toInt(), 230, 233, 236) + body(canvas, entry, radius, fillPaint) + } + } else { + strokePaint.color = if (selectedNow) Color.rgb(26, 159, 255) else inkColor + strokePaint.strokeWidth = if (engaged) hairline * 1.6f else hairline + body(canvas, entry, radius, strokePaint) + } + } else { + fillPaint.style = Paint.Style.FILL + if (!frameless) { + fillPaint.color = tinted(BODY, 0.60f * alpha) + canvas.drawRoundRect(rect, radius, radius, fillPaint) + } + if (engaged) { + fillPaint.color = tinted(accent().first, if (frameless) 0.32f * alpha else 0.42f * alpha) + canvas.drawRoundRect(rect, radius, radius, fillPaint) + } + if (!frameless) { + strokePaint.strokeWidth = if (engaged) hairline * 1.6f else hairline + strokePaint.color = tinted( + accent().first, + (if (engaged) 0.96f else if (editing) 0.80f else 0.68f) * alpha, + ) + body(canvas, entry, radius, strokePaint) + } + inkColor = if (engaged) Color.WHITE else tinted(accent().first, alpha) + } + if (editing && selected === entry) { + ringPaint.strokeWidth = hairline * 0.8f + ringPaint.color = tinted(accent().first, 0.9f) + val gap = hairline * 2.4f + rect.set( + entry.cx - entry.halfW - gap, entry.cy - entry.halfH - gap, + entry.cx + entry.halfW + gap, entry.cy + entry.halfH + gap, + ) + if (entry.shape == SCREEN_KEY_TRIGGER) { + body(canvas, entry, radius + gap, ringPaint, gap) + } else { + canvas.drawRoundRect(rect, radius + gap, radius + gap, ringPaint) + } + rect.set(entry.cx - entry.halfW, entry.cy - entry.halfH, entry.cx + entry.halfW, entry.cy + entry.halfH) + } + + if (bitmap != null) { + imageRect.set(rect) + canvas.save() + clipPath.reset() + when (entry.shape) { + SCREEN_KEY_CIRCLE -> clipPath.addCircle( + entry.cx, entry.cy, minOf(entry.halfW, entry.halfH), android.graphics.Path.Direction.CW, + ) + SCREEN_KEY_TRIGGER -> triggerPath(entry, clipPath, 0f) + else -> clipPath.addRoundRect(rect, radius, radius, android.graphics.Path.Direction.CW) + } + canvas.clipPath(clipPath) + val scale = maxOf(imageRect.width() / bitmap.width, imageRect.height() / bitmap.height) + val w = bitmap.width * scale + val h = bitmap.height * scale + bitmapRect.set( + imageRect.centerX() - w / 2f, imageRect.centerY() - h / 2f, + imageRect.centerX() + w / 2f, imageRect.centerY() + h / 2f, + ) + canvas.drawBitmap(bitmap, null, bitmapRect, fillPaint) + canvas.restore() + } + + val name = label(entry) + textPaint.color = inkColor + if (bitmap != null && name.isEmpty()) return + var iconDrawn = false + if (icon) { + val box = minOf(entry.halfW, entry.halfH) * 1.35f + iconDrawn = ScreenKeyIcons.draw(canvas, entry.codes[0], entry.cx, entry.cy, box, textPaint) + textPaint.color = inkColor + } + if (iconDrawn || name.isEmpty()) return + val overImage = bitmap != null + if (overImage) textPaint.color = Color.WHITE + textPaint.setShadowLayer(if (overImage) dp(3f) else 0f, 0f, 0f, Color.argb(200, 0, 0, 0)) + textPaint.textSize = dp(48f) + val available = rect.width() - hairline * 4f + val fit = 48f * available / textPaint.measureText(name).coerceAtLeast(1f) + textPaint.textSize = minOf(fit, entry.halfH * 1.15f).coerceIn(dp(8f), dp(120f)) + canvas.drawText(name, entry.cx, entry.cy - (textPaint.ascent() + textPaint.descent()) / 2f, textPaint) + textPaint.clearShadowLayer() + } + + private fun drawToolbar(canvas: Canvas) { + val (color, _) = accent() + val capsule = RectF( + toolbar.x - capsuleGap / 2f - capsuleRadius, toolbar.y - capsuleRadius, + toolbar.x + capsuleGap / 2f + capsuleRadius, toolbar.y + capsuleRadius, + ) + fillPaint.style = Paint.Style.FILL + fillPaint.color = tinted(color, 0.30f) + canvas.drawRoundRect(capsule, capsuleRadius, capsuleRadius, fillPaint) + strokePaint.strokeWidth = dp(1.5f) + strokePaint.color = tinted(color, 0.85f) + canvas.drawRoundRect(capsule, capsuleRadius, capsuleRadius, strokePaint) + + textPaint.color = Color.WHITE + textPaint.setShadowLayer(0f, 0f, 0f, 0) + textPaint.textSize = capsuleRadius * 1.15f + val plus = "+" + canvas.drawText(plus, addCenter.x, addCenter.y - (textPaint.ascent() + textPaint.descent()) / 2f, textPaint) + val path = android.graphics.Path() + val check = capsuleRadius * 0.42f + path.moveTo(doneCenter.x - check, doneCenter.y) + path.lineTo(doneCenter.x - check * 0.25f, doneCenter.y + check * 0.7f) + path.lineTo(doneCenter.x + check, doneCenter.y - check * 0.7f) + ringPaint.strokeWidth = dp(3f) + ringPaint.strokeCap = Paint.Cap.ROUND + ringPaint.color = Color.WHITE + canvas.drawPath(path, ringPaint) + ringPaint.strokeCap = Paint.Cap.BUTT + } + + override fun onTouchEvent(event: MotionEvent): Boolean = if (editing) editTouch(event) else playTouch(event) + + private fun playTouch(event: MotionEvent): Boolean { + when (event.actionMasked) { + MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN -> { + val index = event.actionIndex + val entry = entryAt(event.getX(index), event.getY(index)) + if (entry == null) { + if (event.actionMasked == MotionEvent.ACTION_DOWN) return false + forwardedPointerBits = forwardedPointerBits or (1 shl event.getPointerId(index)) + forwardPointers(event, forwardedPointerBits) + return true + } + if (forwardedPointerBits != 0) forwardPointers(event, forwardedPointerBits) + if (entry.shape == SCREEN_KEY_DPAD) { + val arm = armOf(entry, event.getX(index), event.getY(index)) + val code = entry.codes.getOrNull(arm) ?: 0 + if (code == 0) return true + val pid = event.getPointerId(index) + dpadDown.remove(pid)?.let { releaseKey(it) } + dpadDown[pid] = code + entry.armed = arm + pressKey(code) + invalidate() + return true + } + if (entry.shape == SCREEN_KEY_STICK) { + val sector = stickSector(entry, event.getX(index), event.getY(index)) + val pid = event.getPointerId(index) + stickCodes.remove(pid)?.forEach { if (it != 0) releaseKey(it) } + val codes = directionCodes(entry, sector) + stickEntries[pid] = entry + stickCodes[pid] = codes + entry.armed = if (codes.isEmpty()) -1 else sector + codes.forEach { pressKey(it) } + invalidate() + return true + } + if (entry.toggle) { + if (latched.remove(entry)) release(entry) else { + latched += entry + entry.codes.forEach { pressKey(it) } + } + invalidate() + return true + } + if (down.values.any { it === entry }) return true + down[event.getPointerId(index)] = entry + entry.codes.forEach { pressKey(it) } + invalidate() + return true + } + + MotionEvent.ACTION_MOVE -> { + if (forwardedPointerBits != 0) forwardPointers(event, forwardedPointerBits) + if (stickEntries.isEmpty()) return true + repeat(event.pointerCount) { index -> + val pid = event.getPointerId(index) + val entry = stickEntries[pid] ?: return@repeat + val sector = stickSector(entry, event.getX(index), event.getY(index)) + val codes = directionCodes(entry, sector) + val previous = stickCodes[pid].orEmpty() + if (codes != previous) { + previous.filterNot { it in codes }.forEach { releaseKey(it) } + codes.filterNot { it in previous }.forEach { pressKey(it) } + stickCodes[pid] = codes + entry.armed = if (codes.isEmpty()) -1 else sector + invalidate() + } + } + return true + } + + MotionEvent.ACTION_UP, MotionEvent.ACTION_POINTER_UP -> { + val pid = event.getPointerId(event.actionIndex) + if (forwardedPointerBits and (1 shl pid) != 0) { + forwardPointers(event, forwardedPointerBits) + forwardedPointerBits = forwardedPointerBits and (1 shl pid).inv() + if (stickCodes.containsKey(pid) || dpadDown.containsKey(pid)) return true + down.remove(pid)?.let(::release) + return true + } + if (forwardedPointerBits != 0) forwardPointers(event, forwardedPointerBits) + if (stickCodes.containsKey(pid)) { + stickCodes.remove(pid)?.forEach { if (it != 0) releaseKey(it) } + stickEntries.remove(pid)?.armed = -1 + invalidate() + return true + } + val armedCode = dpadDown.remove(pid) + if (armedCode != null) { + releaseKey(armedCode) + entries.firstOrNull { it.armed >= 0 && it.codes.contains(armedCode) }?.armed = -1 + invalidate() + return true + } + val entry = down.remove(pid) + if (entry != null) release(entry) + return true + } + + MotionEvent.ACTION_CANCEL -> { + if (forwardedPointerBits != 0) forwardPointers(event, forwardedPointerBits) + forwardedPointerBits = 0 + stickCodes.values.flatten().forEach { if (it != 0) releaseKey(it) } + stickCodes.clear() + stickEntries.clear() + entries.forEach { it.armed = -1 } + dpadDown.values.forEach { releaseKey(it) } + dpadDown.clear() + entries.forEach { it.armed = -1 } + down.values.forEach { release(it) } + down.clear() + return true + } + } + return true + } + + private fun forwardPointers(event: MotionEvent, pointerIdBits: Int) { + val indices = (0 until event.pointerCount).filter { index -> + pointerIdBits and (1 shl event.getPointerId(index)) != 0 + } + if (indices.isEmpty()) return + val actionIndex = indices.indexOf(event.actionIndex) + val action = when (event.actionMasked) { + MotionEvent.ACTION_DOWN -> if (actionIndex >= 0) MotionEvent.ACTION_DOWN else MotionEvent.ACTION_MOVE + MotionEvent.ACTION_POINTER_DOWN -> if (actionIndex >= 0) { + if (indices.size == 1) MotionEvent.ACTION_DOWN + else MotionEvent.ACTION_POINTER_DOWN or (actionIndex shl MotionEvent.ACTION_POINTER_INDEX_SHIFT) + } else MotionEvent.ACTION_MOVE + MotionEvent.ACTION_UP -> if (actionIndex >= 0) MotionEvent.ACTION_UP else MotionEvent.ACTION_MOVE + MotionEvent.ACTION_POINTER_UP -> if (actionIndex >= 0) { + if (indices.size == 1) MotionEvent.ACTION_UP + else MotionEvent.ACTION_POINTER_UP or (actionIndex shl MotionEvent.ACTION_POINTER_INDEX_SHIFT) + } else MotionEvent.ACTION_MOVE + else -> event.action + } + val properties = Array(indices.size) { MotionEvent.PointerProperties() } + val coordinates = Array(indices.size) { MotionEvent.PointerCoords() } + indices.forEachIndexed { target, source -> + event.getPointerProperties(source, properties[target]) + event.getPointerCoords(source, coordinates[target]) + } + val split = MotionEvent.obtain( + event.downTime, event.eventTime, action, indices.size, properties, coordinates, + event.metaState, event.buttonState, event.xPrecision, event.yPrecision, + event.deviceId, event.edgeFlags, event.source, event.flags, + ) + try { + onTouchMiss?.invoke(split) + } finally { + split.recycle() + } + } + + private fun editTouch(event: MotionEvent): Boolean { + when (event.actionMasked) { + MotionEvent.ACTION_DOWN -> { + val x = event.x + val y = event.y + if (inCircle(addCenter, x, y, capsuleRadius)) { + onAdd?.invoke() + return true + } + if (inCircle(doneCenter, x, y, capsuleRadius)) { + stopEditing() + return true + } + if (inToolbar(x, y)) { + toolbarDrag = true + dragX = toolbar.x - x + dragY = toolbar.y - y + return true + } + val entry = entryAt(x, y) + if (entry == null) { + pressX = x + pressY = y + postDelayed(addPress, 520) + selected = null + invalidate() + return true + } + selected = entry + dragging = true + moved = false + dragX = entry.cx - x + dragY = entry.cy - y + invalidate() + return true + } + + MotionEvent.ACTION_MOVE -> { + if (toolbarDrag) { + val maxX = width - safe.right - capsuleGap / 2f - capsuleRadius + val maxY = height - safe.bottom - capsuleRadius + toolbar.x = (event.x + dragX).coerceIn(safe.left + capsuleGap / 2f + capsuleRadius, maxOf(safe.left + capsuleGap / 2f + capsuleRadius, maxX)) + toolbar.y = (event.y + dragY).coerceIn(safe.top + capsuleRadius, maxOf(safe.top + capsuleRadius, maxY)) + addCenter.set(toolbar.x - capsuleGap / 2f, toolbar.y) + doneCenter.set(toolbar.x + capsuleGap / 2f, toolbar.y) + invalidate() + return true + } + val entry = selected + if (entry == null) { + if (hypot(event.x - pressX, event.y - pressY) > dp(10f)) removeCallbacks(addPress) + return true + } + if (!dragging) return true + if (hypot(event.x - (entry.cx - dragX), event.y - (entry.cy - dragY)) > dp(10f)) removeCallbacks(addPress) + var nextX = snap((event.x + dragX).coerceIn(entry.halfW + safe.left, width - entry.halfW - safe.right)) + var nextY = snap((event.y + dragY).coerceIn(entry.halfH + safe.top, height - entry.halfH - safe.bottom)) + guideX = -1f + guideY = -1f + entries.forEach { other -> + if (other === entry) return@forEach + if (abs(nextX - other.cx) < dp(8f)) { nextX = other.cx; guideX = other.cx } + if (abs(nextY - other.cy) < dp(8f)) { nextY = other.cy; guideY = other.cy } + } + if (abs(nextX - width / 2f) < dp(8f)) { nextX = width / 2f; guideX = nextX } + if (abs(nextY - height / 2f) < dp(8f)) { nextY = height / 2f; guideY = nextY } + if (hypot(nextX - entry.cx, nextY - entry.cy) > dp(4f)) moved = true + entry.cx = nextX + entry.cy = nextY + entry.x = entry.cx / width + entry.y = entry.cy / height + invalidate() + return true + } + + MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> { + removeCallbacks(addPress) + guideX = -1f + guideY = -1f + if (toolbarDrag) { + toolbarDrag = false + return true + } + val entry = selected + if (entry != null && dragging) { + dragging = false + if (moved) { + save() + invalidate() + } else { + onSelect?.invoke(entry.codes) + } + } + return true + } + } + return true + } + + private fun pressKey(code: Int) { + val owners = held[code] ?: 0 + held[code] = owners + 1 + if (owners == 0) sendKey(code, true) + } + + private fun releaseKey(code: Int) { + val owners = held[code] ?: return + if (owners > 1) { + held[code] = owners - 1 + return + } + held.remove(code) + sendKey(code, false) + } + + private fun release(entry: Entry) { + entry.codes.asReversed().forEach { releaseKey(it) } + invalidate() + } + + fun export(): String = ControllerPrefs.encodeScreenKeys( + entries.map { ScreenKey(it.codes, it.x, it.y, it.size, it.glyph, it.text, it.image, it.opacity, it.shape, it.toggle, it.labels) }, + ) + + fun load(raw: String) { + releaseAll() + entries.clear() + ControllerPrefs.decodeScreenKeys(raw).forEach { entries += entryOf(it) } + entries.forEach { measure(it) } + selected = null + save() + invalidate() + } + + private fun save() { + ControllerPrefs.setScreenKeys( + context, + entries.map { ScreenKey(it.codes, it.x, it.y, it.size, it.glyph, it.text, it.image, it.opacity, it.shape, it.toggle, it.labels) }, + ) + } + + private fun dp(value: Float) = value * resources.displayMetrics.density + + companion object { + private val DPAD_DIRS = listOf( + 0f to -1f, 1f to 0f, 0f to 1f, -1f to 0f, + ) + private val STICK_DIRS = listOf( + 0f to -1f, 0.7071f to -0.7071f, 1f to 0f, 0.7071f to 0.7071f, + 0f to 1f, -0.7071f to 0.7071f, -1f to 0f, -0.7071f to -0.7071f, + ) + const val DEFAULT_SIZE = 44 + const val MIN_SIZE = 24 + const val MAX_SIZE = 140 + const val IMAGE_DIR = "screenkeys" + private const val BODY = 0xFF14181F.toInt() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/ScreenLayoutFile.kt b/app/src/main/java/com/droiddeck/launcher/input/ScreenLayoutFile.kt new file mode 100644 index 0000000000..fc25940719 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/ScreenLayoutFile.kt @@ -0,0 +1,140 @@ +package com.droiddeck.launcher.input + +import org.json.JSONArray +import org.json.JSONObject +import kotlin.math.roundToInt + +private val ICP_NAMES: Map = mapOf( + 103 to "KEY_UP", 106 to "KEY_RIGHT", 108 to "KEY_DOWN", 105 to "KEY_LEFT", + 28 to "KEY_ENTER", 1 to "KEY_ESC", 14 to "KEY_BKSP", 111 to "KEY_DEL", 15 to "KEY_TAB", + 57 to "KEY_SPACE", 29 to "KEY_CTRL_L", 97 to "KEY_CTRL_R", 110 to "KEY_INSERT", + 42 to "KEY_SHIFT_L", 54 to "KEY_SHIFT_R", 56 to "KEY_ALT_L", 100 to "KEY_ALT_R", + 102 to "KEY_HOME", 107 to "KEY_END", 99 to "KEY_PRTSCN", 104 to "KEY_PG_UP", 109 to "KEY_PG_DOWN", + 58 to "KEY_CAPS_LOCK", 69 to "KEY_NUM_LOCK", 41 to "KEY_GRAVE", 12 to "KEY_MINUS", + 11 to "KEY_0", 2 to "KEY_1", 3 to "KEY_2", 4 to "KEY_3", 5 to "KEY_4", 6 to "KEY_5", + 7 to "KEY_6", 8 to "KEY_7", 9 to "KEY_8", 10 to "KEY_9", + 30 to "KEY_A", 48 to "KEY_B", 46 to "KEY_C", 32 to "KEY_D", 18 to "KEY_E", 33 to "KEY_F", + 34 to "KEY_G", 35 to "KEY_H", 23 to "KEY_I", 36 to "KEY_J", 37 to "KEY_K", 38 to "KEY_L", + 50 to "KEY_M", 49 to "KEY_N", 24 to "KEY_O", 25 to "KEY_P", 16 to "KEY_Q", 19 to "KEY_R", + 31 to "KEY_S", 20 to "KEY_T", 22 to "KEY_U", 47 to "KEY_V", 17 to "KEY_W", 45 to "KEY_X", + 21 to "KEY_Y", 44 to "KEY_Z", + 26 to "KEY_BRACKET_LEFT", 27 to "KEY_BRACKET_RIGHT", 43 to "KEY_BACKSLASH", 53 to "KEY_SLASH", + 39 to "KEY_SEMICOLON", 51 to "KEY_COMMA", 52 to "KEY_PERIOD", 40 to "KEY_APOSTROPHE", + 59 to "KEY_F1", 60 to "KEY_F2", 61 to "KEY_F3", 62 to "KEY_F4", 63 to "KEY_F5", 64 to "KEY_F6", + 65 to "KEY_F7", 66 to "KEY_F8", 67 to "KEY_F9", 68 to "KEY_F10", 87 to "KEY_F11", 88 to "KEY_F12", + 79 to "KEY_KP_1", 80 to "KEY_KP_2", 81 to "KEY_KP_3", 75 to "KEY_KP_4", 76 to "KEY_KP_5", + 77 to "KEY_KP_6", 71 to "KEY_KP_7", 72 to "KEY_KP_8", 73 to "KEY_KP_9", 82 to "KEY_KP_0", +) + +private val ICP_CODES: Map = ICP_NAMES.entries.associate { (code, name) -> name to code } + +private fun icpShape(shape: Int): String = when (shape) { + SCREEN_KEY_CIRCLE -> "CIRCLE" + SCREEN_KEY_RECT -> "RECT" + SCREEN_KEY_ROUND -> "ROUND_RECT" + SCREEN_KEY_DPAD -> "ROUND_RECT" + SCREEN_KEY_STICK -> "ROUND_RECT" + SCREEN_KEY_TRIGGER -> "ROUND_RECT" + else -> "ROUND_RECT" +} + +private fun screenKeyShape(shape: String): Int = when (shape) { + "CIRCLE" -> SCREEN_KEY_CIRCLE + "RECT" -> SCREEN_KEY_RECT + "SQUARE" -> SCREEN_KEY_ROUND + else -> SCREEN_KEY_PILL +} + +fun exportScreenLayout(keys: List, widthPx: Int, density: Float): String { + val snap = widthPx / 100f + val elements = JSONArray() + keys.forEach { key -> + val binds = JSONArray() + val directional = key.shape == SCREEN_KEY_DPAD || key.shape == SCREEN_KEY_STICK + key.codes.forEach { code -> + val name = ICP_NAMES[code] + if (name != null) binds.put(name) else if (directional) binds.put("") + } + if (binds.length() == 0) return@forEach + val shape = icpShape(key.shape) + val sizePx = key.size * density + val scale = when { + key.shape == SCREEN_KEY_DPAD -> sizePx * 2.3f / (14f * snap) + key.shape == SCREEN_KEY_STICK -> sizePx * 2.3f / (14f * snap) + shape == "CIRCLE" -> sizePx / (6f * snap) + else -> sizePx / (4f * snap) + } + elements.put( + JSONObject() + .put( + "type", + when (key.shape) { + SCREEN_KEY_DPAD -> "D_PAD" + SCREEN_KEY_STICK -> "STICK" + else -> "BUTTON" + }, + ) + .put("shape", shape) + .put("customColor", 0) + .put("bindings", binds) + .put("scale", scale) + .put("x", key.x) + .put("y", key.y) + .put("toggleSwitch", key.toggle) + .put("swipeable", false) + .put("text", key.text) + .put("iconId", 0) + .apply { if (key.opacity < 1f) put("opacity", key.opacity) }, + ) + } + return JSONObject() + .put("id", 0) + .put("name", "DroidDeck") + .put("cursorSpeed", 1.5f) + .put("elements", elements) + .toString() +} + +fun importScreenLayout(raw: String, widthPx: Int, density: Float): List? { + val root = runCatching { JSONObject(raw) }.getOrNull() ?: return null + val elements = root.optJSONArray("elements") ?: return null + val snap = widthPx / 100f + val keys = mutableListOf() + for (i in 0 until elements.length()) { + val element = elements.optJSONObject(i) ?: continue + val type = element.optString("type", "BUTTON") + if (type != "BUTTON" && type != "D_PAD" && type != "STICK") continue + val binds = element.optJSONArray("bindings") ?: continue + val raw = (0 until binds.length()).map { ICP_CODES[binds.optString(it)] ?: 0 } + val codes = if (type == "D_PAD" || type == "STICK") { + raw.dropLastWhile { it == 0 }.ifEmpty { listOf(0) } + } else { + raw.filter { it != 0 } + } + if (codes.isEmpty()) continue + val dpad = type == "D_PAD" + val stick = type == "STICK" + val shape = when { + dpad -> SCREEN_KEY_DPAD + stick -> SCREEN_KEY_STICK + else -> screenKeyShape(element.optString("shape")) + } + val scale = element.optDouble("scale", 1.0).toFloat().takeIf { it > 0f } ?: 1f + val sizePx = when { + dpad || stick -> 14f * snap * scale / 2.3f + shape == SCREEN_KEY_CIRCLE -> 6f * snap * scale + else -> 4f * snap * scale + } + keys += ScreenKey( + codes = codes, + x = element.optDouble("x", 0.5).toFloat().coerceIn(0f, 1f), + y = element.optDouble("y", 0.5).toFloat().coerceIn(0f, 1f), + size = (sizePx / density).roundToInt().coerceIn(ScreenKeys.MIN_SIZE, ScreenKeys.MAX_SIZE), + text = element.optString("text").take(24), + opacity = element.optDouble("opacity", 1.0).toFloat().coerceIn(0.2f, 1f), + shape = shape, + toggle = element.optBoolean("toggleSwitch"), + ) + } + return keys +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt index 1c6921a890..ca5157372a 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt @@ -93,7 +93,10 @@ class SteamTouchControls( private var opened = 0 private var elements: List = emptyList() private var tint = Color.WHITE - private var alphaScale = 0.45f + private var alphaScale = 0.99f + var style: Pair = Color.WHITE to 0.99f + private set + var onStyle: (() -> Unit)? = null private class Visual(val ref: SteamTouchBindings.Ref?, val binding: SteamTouchBindings.Binding?) private var visuals: Map> = emptyMap() @@ -191,6 +194,8 @@ class SteamTouchControls( private fun applyColor(color: FloatArray?) { tint = if (color != null) Color.rgb((color[0] * 255).toInt(), (color[1] * 255).toInt(), (color[2] * 255).toInt()) else Color.WHITE alphaScale = ((color?.get(3) ?: 0.45f) * 2.2f).coerceIn(0.15f, 1f) + style = tint to alphaScale + onStyle?.invoke() } private fun rebuildVisuals() { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/PcKeyboard.kt b/app/src/main/java/com/droiddeck/launcher/ui/PcKeyboard.kt index 0fc5762777..6c68c9cfc6 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/PcKeyboard.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/PcKeyboard.kt @@ -1,7 +1,9 @@ package com.droiddeck.launcher.ui import com.droiddeck.launcher.R -import androidx.annotation.StringRes +import com.droiddeck.launcher.input.PC_KEY_ROWS +import com.droiddeck.launcher.input.PC_MODIFIERS +import com.droiddeck.launcher.input.PcKey import androidx.compose.ui.res.stringResource import android.view.KeyEvent import androidx.compose.animation.animateColorAsState @@ -54,46 +56,6 @@ import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp -private data class PcKey(val label: String, val code: Int, val weight: Float = 1f, val shifted: String? = null, @StringRes val labelRes: Int = 0) - -private fun k(label: String, code: Int, weight: Float = 1f, shifted: String? = null) = PcKey(label, code, weight, shifted) - -private fun k(@StringRes labelRes: Int, code: Int, weight: Float = 1f) = PcKey("", code, weight, null, labelRes) - -private val ROWS: List> = listOf( - listOf( - k(R.string.pckb_key_esc, 1), k("F1", 59), k("F2", 60), k("F3", 61), k("F4", 62), k("F5", 63), k("F6", 64), - k("F7", 65), k("F8", 66), k("F9", 67), k("F10", 68), k("F11", 87), k("F12", 88), - k(R.string.pckb_key_ins, 110), k(R.string.pckb_key_del, 111), k(R.string.pckb_key_home, 102), k(R.string.pckb_key_end, 107), k(R.string.pckb_key_pgup, 104), k(R.string.pckb_key_pgdn, 109), - ), - listOf( - k("`", 41, shifted = "~"), k("1", 2, shifted = "!"), k("2", 3, shifted = "@"), k("3", 4, shifted = "#"), - k("4", 5, shifted = "$"), k("5", 6, shifted = "%"), k("6", 7, shifted = "^"), k("7", 8, shifted = "&"), - k("8", 9, shifted = "*"), k("9", 10, shifted = "("), k("0", 11, shifted = ")"), k("-", 12, shifted = "_"), - k("=", 13, shifted = "+"), k(R.string.pckb_key_backspace, 14, 2f), - ), - listOf( - k(R.string.pckb_key_tab, 15, 1.5f), k("q", 16), k("w", 17), k("e", 18), k("r", 19), k("t", 20), k("y", 21), - k("u", 22), k("i", 23), k("o", 24), k("p", 25), k("[", 26, shifted = "{"), k("]", 27, shifted = "}"), - k("\\", 43, 1.5f, shifted = "|"), - ), - listOf( - k(R.string.pckb_key_caps, 58, 1.75f), k("a", 30), k("s", 31), k("d", 32), k("f", 33), k("g", 34), k("h", 35), - k("j", 36), k("k", 37), k("l", 38), k(";", 39, shifted = ":"), k("'", 40, shifted = "\""), - k(R.string.pckb_key_enter, 28, 2.25f), - ), - listOf( - k(R.string.pckb_key_shift, 42, 2.25f), k("z", 44), k("x", 45), k("c", 46), k("v", 47), k("b", 48), k("n", 49), - k("m", 50), k(",", 51, shifted = "<"), k(".", 52, shifted = ">"), k("/", 53, shifted = "?"), - k(R.string.pckb_key_shift, 54, 1.75f), k("↑", 103), - ), - listOf( - k(R.string.pckb_key_ctrl, 29, 1.5f), k(R.string.pckb_key_super, 125, 1.25f), k(R.string.pckb_key_alt, 56, 1.25f), k(R.string.pckb_key_space, 57, 6.25f), - k(R.string.pckb_key_altgr, 100, 1.25f), k(R.string.pckb_key_ctrl, 97, 1.25f), k("←", 105), k("↓", 108), k("→", 106), - ), -) - -private val MODIFIERS = setOf(42, 54, 29, 97, 56, 100, 125) private const val MOD_OFF = 0 private const val MOD_ONCE = 1 private const val MOD_LOCKED = 2 @@ -115,7 +77,7 @@ fun PcKeyboard( for ((code, state) in mods.toMap()) if (state == MOD_ONCE) { sendKey(code, false); mods[code] = MOD_OFF } } fun press(key: PcKey) { - if (key.code in MODIFIERS) { + if (key.code in PC_MODIFIERS) { when (mods[key.code] ?: MOD_OFF) { MOD_OFF -> { sendKey(key.code, true); mods[key.code] = MOD_ONCE } MOD_ONCE -> mods[key.code] = MOD_LOCKED @@ -126,7 +88,7 @@ fun PcKeyboard( sendKey(key.code, true) } fun release(key: PcKey) { - if (key.code in MODIFIERS) return + if (key.code in PC_MODIFIERS) return sendKey(key.code, false) if (key.code == 58) capsOn = !capsOn releaseOnceModifiers() @@ -153,7 +115,7 @@ fun PcKeyboard( Spacer(Modifier.width(8.dp)) HeaderButton(stringResource(R.string.pckb_hide), onClose) } - ROWS.forEachIndexed { r, row -> + PC_KEY_ROWS.forEachIndexed { r, row -> Row(horizontalArrangement = Arrangement.spacedBy(3.dp), modifier = Modifier.fillMaxWidth().height(rowHeight)) { row.forEachIndexed { i, key -> val state = mods[key.code] ?: MOD_OFF diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyEditor.kt b/app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyEditor.kt new file mode 100644 index 0000000000..3cb99d6051 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyEditor.kt @@ -0,0 +1,368 @@ +package com.droiddeck.launcher.ui + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.BitmapFactory +import android.net.Uri +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.BorderStroke +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.gestures.detectDragGestures +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.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.systemBarsPadding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.BasicTextField +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.filled.Delete +import androidx.compose.material.icons.filled.DragIndicator +import androidx.compose.material.icons.filled.Image +import androidx.compose.material.icons.filled.Keyboard +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Slider +import androidx.compose.material3.Surface +import androidx.compose.material3.Switch +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +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.geometry.Offset +import androidx.compose.ui.focus.onFocusChanged +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalConfiguration +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.IntOffset +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.droiddeck.launcher.R +import com.droiddeck.launcher.input.SCREEN_KEY_CIRCLE +import com.droiddeck.launcher.input.SCREEN_KEY_DPAD +import com.droiddeck.launcher.input.SCREEN_KEY_PILL +import com.droiddeck.launcher.input.SCREEN_KEY_RECT +import com.droiddeck.launcher.input.SCREEN_KEY_ROUND +import com.droiddeck.launcher.input.SCREEN_KEY_STICK +import com.droiddeck.launcher.input.SCREEN_KEY_TRIGGER +import com.droiddeck.launcher.input.ScreenKeys +import com.droiddeck.launcher.input.pcKeyLabel +import com.droiddeck.launcher.input.screenKeyDirections +import java.io.File +import kotlin.math.roundToInt + +private val PANEL_WIDTH = 600.dp +private val CHIP_PADDING = androidx.compose.foundation.layout.PaddingValues(horizontal = 6.dp, vertical = 2.dp) + +@Composable +fun ScreenKeyEditor( + codes: List, + keyY: Float, + size: Int, + opacity: Float, + shape: Int, + toggle: Boolean, + labels: Boolean, + text: String, + hasImage: Boolean, + onResize: (Int) -> Unit, + onOpacity: (Float) -> Unit, + onShape: (Int) -> Unit, + onToggle: (Boolean) -> Unit, + onLabels: (Boolean) -> Unit, + onText: (String) -> Unit, + onImage: (String) -> Unit, + onClearImage: () -> Unit, + onBind: () -> Unit, + onTextFocus: () -> Unit, + onTextBlur: () -> Unit, + onDirection: (Int) -> Unit, + onRemove: () -> Unit, + onDismiss: () -> Unit, +) { + val p = LocalPalette.current + val context = LocalContext.current + var offset by remember(codes) { mutableStateOf(Offset.Zero) } + val density = LocalDensity.current + val screen = LocalConfiguration.current + val panelWidthPx = with(density) { PANEL_WIDTH.toPx() } + val screenWidthPx = screen.screenWidthDp * density.density + val screenHeightPx = screen.screenHeightDp * density.density + val atTop = keyY > 0.45f + val button = shape <= SCREEN_KEY_RECT + val directions = screenKeyDirections(shape) + val pickImage = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri -> + if (uri != null) importImage(context, uri, codes)?.let(onImage) + } + Box( + Modifier.fillMaxSize().systemBarsPadding().padding(horizontal = 10.dp, vertical = 6.dp), + contentAlignment = if (atTop) Alignment.TopCenter else Alignment.BottomCenter, + ) { + Surface( + Modifier.widthIn(max = PANEL_WIDTH).fillMaxWidth() + .offset { IntOffset(offset.x.roundToInt(), offset.y.roundToInt()) }, + shape = RoundedCornerShape(18.dp), + color = p.background, contentColor = p.onBackground, border = BorderStroke(1.dp, p.line2), + ) { + Column(Modifier.padding(start = 10.dp, end = 6.dp, top = 2.dp, bottom = 6.dp)) { + Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { + Icon( + Icons.Default.DragIndicator, null, + tint = p.onBackground.copy(alpha = 0.45f), + modifier = Modifier.pointerInput(panelWidthPx, screenWidthPx, screenHeightPx) { + detectDragGestures { change, drag -> + change.consume() + offset = Offset( + (offset.x + drag.x).coerceIn( + -(screenWidthPx - panelWidthPx) / 2f + 8f, + (screenWidthPx - panelWidthPx) / 2f - 8f, + ), + (offset.y + drag.y).coerceIn( + -screenHeightPx * if (atTop) 0f else 0.75f, + screenHeightPx * if (atTop) 0.75f else 0f, + ), + ) + } + }, + ) + Box( + Modifier.weight(1f).height(36.dp) + .background(p.line2.copy(alpha = 0.24f), RoundedCornerShape(9.dp)) + .padding(horizontal = 10.dp), + contentAlignment = Alignment.CenterStart, + ) { + BasicTextField( + value = text, + onValueChange = { onText(it.take(24)) }, + singleLine = true, + textStyle = TextStyle( + color = p.onBackground, fontSize = 13.sp, + fontWeight = FontWeight.Medium, + ), + cursorBrush = androidx.compose.ui.graphics.SolidColor(p.primary), + keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done), + modifier = Modifier.fillMaxWidth().onFocusChanged { + if (it.isFocused) onTextFocus() else onTextBlur() + }, + ) + if (text.isEmpty()) { + Text( + stringResource(R.string.screen_key_text), + color = p.onBackground.copy(alpha = 0.4f), + style = MaterialTheme.typography.bodySmall, + ) + } + } + if (button) { + IconButton(onClick = onBind, modifier = Modifier.width(38.dp)) { + Icon( + Icons.Default.Keyboard, stringResource(R.string.screen_key_bind), + tint = p.onBackground.copy(alpha = 0.8f), + ) + } + } + IconButton(onClick = { pickImage.launch("image/*") }, modifier = Modifier.width(38.dp)) { + Icon( + Icons.Default.Image, stringResource(R.string.screen_key_image), + tint = p.onBackground.copy(alpha = 0.8f), + ) + } + if (hasImage) IconButton(onClick = onClearImage, modifier = Modifier.width(34.dp)) { + Icon(Icons.Default.Close, stringResource(R.string.screen_key_image_clear), tint = p.error) + } + IconButton(onClick = onRemove, modifier = Modifier.width(38.dp)) { + Icon(Icons.Default.Delete, stringResource(R.string.common_delete), tint = p.error) + } + IconButton(onClick = onDismiss, modifier = Modifier.width(34.dp)) { + Icon(Icons.Default.Close, null, tint = p.onBackground) + } + } + Row( + Modifier.fillMaxWidth().padding(vertical = 2.dp), + horizontalArrangement = Arrangement.spacedBy(4.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + listOf>( + (if (button) SCREEN_KEY_PILL else null) to R.string.screen_key_type_button, + SCREEN_KEY_TRIGGER to R.string.screen_key_shape_trigger, + SCREEN_KEY_DPAD to R.string.touch_dpad, + SCREEN_KEY_STICK to R.string.deck_surface_stick, + ).forEach { (value, label) -> + val selected = if (value == null) button else shape == value + Chip(stringResource(label), selected, Modifier.weight(1f)) { + onShape(if (value == null) (if (button) shape else SCREEN_KEY_PILL) else value) + } + } + Box(Modifier.width(1.dp).height(20.dp).background(p.line2)) + listOf( + SCREEN_KEY_PILL to R.string.screen_key_shape_pill, + SCREEN_KEY_ROUND to R.string.screen_key_shape_round, + SCREEN_KEY_CIRCLE to R.string.screen_key_shape_circle, + SCREEN_KEY_RECT to R.string.screen_key_shape_rect, + ).forEach { (value, label) -> + Chip( + stringResource(label), button && shape == value, Modifier.weight(1f), enabled = button, + ) { onShape(value) } + } + Box(Modifier.width(1.dp).height(20.dp).background(p.line2)) + Text( + stringResource(R.string.screen_key_toggle), Modifier.padding(start = 6.dp, end = 2.dp), + style = MaterialTheme.typography.bodySmall, maxLines = 1, + ) + Switch(checked = toggle, onCheckedChange = onToggle, modifier = Modifier.height(30.dp)) + } + if (directions.isNotEmpty()) { + Row( + Modifier.fillMaxWidth().padding(vertical = 2.dp), + horizontalArrangement = Arrangement.spacedBy(4.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + directions.forEachIndexed { index, arrow -> + val code = codes.getOrNull(index) ?: 0 + Chip( + if (code == 0) arrow else "$arrow ${pcKeyLabel(context, code)}", + code != 0, Modifier.weight(1f), + ) { onDirection(index) } + } + Text( + stringResource(R.string.screen_key_text), Modifier.padding(start = 6.dp, end = 2.dp), + style = MaterialTheme.typography.bodySmall, maxLines = 1, + ) + Switch(checked = labels, onCheckedChange = onLabels, modifier = Modifier.height(30.dp)) + } + } + Row( + Modifier.fillMaxWidth().padding(top = 2.dp), + horizontalArrangement = Arrangement.spacedBy(6.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + KeySlider( + label = stringResource(R.string.screen_key_size), + value = "$size", + current = size.toFloat(), + min = ScreenKeys.MIN_SIZE.toFloat(), + max = ScreenKeys.MAX_SIZE.toFloat(), + modifier = Modifier.weight(1f), + ) { onResize(it.roundToInt()) } + KeySlider( + label = stringResource(R.string.screen_key_opacity), + value = "${(opacity * 100).roundToInt()}%", + current = opacity, + min = 0.2f, + max = 1f, + modifier = Modifier.weight(1f), + onChange = onOpacity, + ) + } + } + } + } +} + +@Composable +private fun KeySlider( + label: String, + value: String, + current: Float, + min: Float, + max: Float, + modifier: Modifier, + onChange: (Float) -> Unit, +) { + Row(modifier, verticalAlignment = Alignment.CenterVertically) { + Text(label, style = MaterialTheme.typography.bodySmall, maxLines = 1) + Slider(current, onChange, Modifier.weight(1f).height(28.dp), valueRange = min..max) + Text( + value, Modifier.width(32.dp), style = MaterialTheme.typography.bodySmall, + fontWeight = FontWeight.SemiBold, maxLines = 1, + ) + } +} + +@Composable +private fun Chip( + label: String, + selected: Boolean, + modifier: Modifier = Modifier, + enabled: Boolean = true, + onClick: () -> Unit, +) { + val p = LocalPalette.current + Box( + modifier + .background( + if (selected) p.primary.copy(alpha = 0.18f) else p.line2.copy(alpha = 0.28f), + CircleShape, + ) + .clickable(enabled = enabled, onClick = onClick) + .padding(vertical = 6.dp), + contentAlignment = Alignment.Center, + ) { + Text( + label, style = MaterialTheme.typography.labelSmall, maxLines = 1, overflow = TextOverflow.Ellipsis, + color = when { + !enabled -> p.onBackground.copy(alpha = 0.28f) + selected -> p.primary + else -> p.onBackground.copy(alpha = 0.7f) + }, + ) + } +} + +private fun importImage(context: Context, uri: Uri, codes: List): String? { + val dir = File(context.filesDir, ScreenKeys.IMAGE_DIR).apply { mkdirs() } + val name = "key_" + codes.joinToString("_") + "_" + System.currentTimeMillis() + ".png" + val longest = (ScreenKeys.MAX_SIZE * context.resources.displayMetrics.density).toInt() + return runCatching { + val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true } + context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, bounds) } + val source = maxOf(bounds.outWidth, bounds.outHeight) + if (source <= 0) return@runCatching null + var sample = 1 + while (source / (sample * 2) >= longest) sample *= 2 + val bitmap = context.contentResolver.openInputStream(uri)?.use { + BitmapFactory.decodeStream(it, null, BitmapFactory.Options().apply { inSampleSize = sample }) + } ?: return@runCatching null + val scale = longest.toFloat() / maxOf(bitmap.width, bitmap.height) + val scaled = if (scale < 1f) { + Bitmap.createScaledBitmap( + bitmap, + (bitmap.width * scale).toInt().coerceAtLeast(1), + (bitmap.height * scale).toInt().coerceAtLeast(1), + true, + ) + } else { + bitmap + } + try { + val saved = File(dir, name).outputStream().use { scaled.compress(Bitmap.CompressFormat.PNG, 100, it) } + if (saved) name else null + } finally { + if (scaled !== bitmap) bitmap.recycle() + scaled.recycle() + } + }.getOrNull().also { if (it == null) File(dir, name).delete() } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyPicker.kt b/app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyPicker.kt new file mode 100644 index 0000000000..787854d080 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/ScreenKeyPicker.kt @@ -0,0 +1,168 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.BorderStroke +import androidx.compose.foundation.clickable +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +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.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.systemBarsPadding +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Close +import androidx.compose.material3.Button +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +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.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.compose.ui.window.Dialog +import androidx.compose.ui.window.DialogProperties +import com.droiddeck.launcher.R +import com.droiddeck.launcher.input.PC_KEYS +import com.droiddeck.launcher.input.PC_KEY_ROWS +import com.droiddeck.launcher.input.PC_MODIFIERS +import com.droiddeck.launcher.input.PcKey +import com.droiddeck.launcher.input.pcKeyLabel + +@Composable +fun ScreenKeyPicker( + onDismiss: () -> Unit, + onAdd: (List) -> Unit, + initial: List = emptyList(), + sequence: Boolean = false, + sequenceLimit: Int = 4, + slots: List = emptyList(), +) { + var picked by remember { mutableStateOf(initial) } + val p = LocalPalette.current + val toggle: (Int) -> Unit = { code -> + picked = if (sequence) { + if (code in picked) picked - code else (picked + code).take(sequenceLimit) + } else if (code in PC_MODIFIERS) { + if (code in picked) picked - code else picked + code + } else { + picked.filter { it in PC_MODIFIERS } + code + } + } + val rows = remember { + val functionRow = PC_KEY_ROWS[0] + val nav = listOfNotNull(PC_KEYS[110], PC_KEYS[111], PC_KEYS[102], PC_KEYS[107], PC_KEYS[104], PC_KEYS[109]) + + listOfNotNull(PC_KEYS[103], PC_KEYS[105], PC_KEYS[108], PC_KEYS[106]) + listOf(functionRow.take(13), nav) + PC_KEY_ROWS.drop(1) + } + val unit = remember { rows.maxOf { row -> row.fold(0f) { sum, key -> sum + key.weight } } } + Dialog(onDismissRequest = onDismiss, properties = DialogProperties(usePlatformDefaultWidth = false)) { + Box(Modifier.fillMaxSize().systemBarsPadding().padding(10.dp), contentAlignment = Alignment.Center) { + Surface( + Modifier.widthIn(max = 820.dp).fillMaxWidth().fillMaxHeight(), shape = RoundedCornerShape(20.dp), + color = p.background, contentColor = p.onBackground, border = BorderStroke(1.dp, p.line2), + ) { + Column { + Row(Modifier.fillMaxWidth().padding(start = 16.dp, end = 6.dp), verticalAlignment = Alignment.CenterVertically) { + Text(stringResource(R.string.screen_keys_add), Modifier.weight(1f), style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold) + IconButton(onClick = onDismiss) { Icon(Icons.Default.Close, null) } + } + Row( + Modifier.fillMaxWidth().heightIn(min = 26.dp).horizontalScroll(rememberScrollState()).padding(horizontal = 16.dp), + horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.CenterVertically, + ) { + if (sequence && slots.size >= sequenceLimit) { + slots.take(sequenceLimit).forEachIndexed { index, arrow -> + val code = picked.getOrNull(index) + Surface( + shape = RoundedCornerShape(8.dp), + color = if (code == null) p.line2.copy(alpha = 0.2f) else p.primary.copy(alpha = 0.16f), + modifier = if (code == null) Modifier else Modifier.clickable { picked = picked - code }, + ) { + Text( + if (code == null) arrow else "$arrow ${pcKeyLabel(LocalContext.current, code)}", + Modifier.padding(horizontal = 8.dp, vertical = 2.dp), + style = MaterialTheme.typography.labelMedium, + ) + } + } + } else { + picked.forEach { code -> + Surface( + shape = RoundedCornerShape(8.dp), color = p.primary.copy(alpha = 0.16f), + modifier = Modifier.clickable { picked = picked - code }, + ) { + Text(pcKeyLabel(LocalContext.current, code), Modifier.padding(horizontal = 8.dp, vertical = 2.dp), style = MaterialTheme.typography.labelMedium) + } + } + } + } + LazyColumn(Modifier.weight(1f).fillMaxWidth(), contentPadding = PaddingValues(vertical = 6.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) { + items(rows.size) { index -> + val row = rows[index] + Row( + Modifier.fillMaxWidth().padding(horizontal = 16.dp), + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + row.forEach { key -> KeyCell(key, key.code in picked, Modifier.weight(key.weight)) { toggle(key.code) } } + if (row.sumOf { it.weight.toDouble() } < unit) { + Spacer(Modifier.weight(unit - row.fold(0f) { sum, key -> sum + key.weight })) + } + } + } + } + Row(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) { + Button( + onClick = { onAdd(picked) }, + enabled = picked.isNotEmpty(), + modifier = Modifier.weight(1f), + ) { + Text(stringResource(R.string.screen_keys_add)) + } + } + } + } + } + } +} + +@Composable +private fun KeyCell(key: PcKey, selected: Boolean, modifier: Modifier, onClick: () -> Unit) { + val p = LocalPalette.current + val label = pcKeyLabel(LocalContext.current, key.code) + Surface( + shape = RoundedCornerShape(8.dp), + color = if (selected) p.primary.copy(alpha = 0.2f) else p.surface, + border = BorderStroke(1.dp, if (selected) p.primary else p.line), + modifier = modifier.height(36.dp).clickable(onClick = onClick), + ) { + Box(Modifier.fillMaxSize().padding(horizontal = 2.dp), contentAlignment = Alignment.Center) { + Text( + label, style = MaterialTheme.typography.labelMedium, maxLines = 1, + overflow = TextOverflow.Ellipsis, + fontSize = if (label.length > 4) 10.sp else 12.sp, + ) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ScreenLayoutPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/ScreenLayoutPanel.kt new file mode 100644 index 0000000000..7e195d5e8c --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/ScreenLayoutPanel.kt @@ -0,0 +1,138 @@ +package com.droiddeck.launcher.ui + +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.BorderStroke +import androidx.compose.foundation.clickable +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.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.systemBarsPadding +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Close +import androidx.compose.material3.Button +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +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.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.unit.dp +import androidx.compose.ui.window.Dialog +import androidx.compose.ui.window.DialogProperties +import com.droiddeck.launcher.R + +@Composable +fun ScreenLayoutPanel( + layouts: List, + onSave: (String) -> Unit, + onLoad: (String) -> Unit, + onDelete: (String) -> Unit, + onImport: (String) -> Unit, + exportText: () -> String, + onDismiss: () -> Unit, +) { + val p = LocalPalette.current + val context = LocalContext.current + var naming by remember { mutableStateOf(false) } + var name by remember { mutableStateOf("") } + + val importer = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocument()) { uri -> + if (uri == null) return@rememberLauncherForActivityResult + val text = runCatching { + context.contentResolver.openInputStream(uri)?.use { it.readBytes().toString(Charsets.UTF_8) } + }.getOrNull() + if (text != null) onImport(text) + } + val exporter = rememberLauncherForActivityResult(ActivityResultContracts.CreateDocument("application/json")) { uri -> + if (uri == null) return@rememberLauncherForActivityResult + runCatching { context.contentResolver.openOutputStream(uri)?.use { it.write(exportText().toByteArray()) } } + } + + Dialog(onDismissRequest = onDismiss, properties = DialogProperties(usePlatformDefaultWidth = false)) { + Box(Modifier.fillMaxSize().systemBarsPadding().padding(16.dp), contentAlignment = Alignment.Center) { + Surface( + Modifier.widthIn(max = 520.dp).fillMaxWidth(), shape = RoundedCornerShape(22.dp), + color = p.background, contentColor = p.onBackground, border = BorderStroke(1.dp, p.line2), + ) { + Column(Modifier.padding(start = 20.dp, end = 8.dp, top = 6.dp, bottom = 12.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text( + stringResource(R.string.screen_key_layout), Modifier.weight(1f), + style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold, + ) + IconButton(onClick = onDismiss) { Icon(Icons.Default.Close, null) } + } + Row(Modifier.fillMaxWidth().padding(end = 12.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) { + TextButton(onClick = { naming = true }) { Text(stringResource(R.string.screen_key_layout_save)) } + TextButton(onClick = { importer.launch(arrayOf("application/json", "text/plain", "*/*")) }) { + Text(stringResource(R.string.boot_movie_import)) + } + TextButton(onClick = { exporter.launch("droiddeck-layout.icp") }) { + Text(stringResource(R.string.screen_key_layout_export)) + } + } + Column(Modifier.padding(end = 12.dp).heightIn(max = 320.dp).verticalScroll(rememberScrollState())) { + layouts.forEach { layout -> + Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { + Text( + layout, Modifier.weight(1f).clickable { onLoad(layout) }.padding(vertical = 14.dp), + style = MaterialTheme.typography.bodyLarge, + ) + TextButton(onClick = { onDelete(layout) }) { + Text(stringResource(R.string.common_delete), color = p.error) + } + } + } + } + } + } + } + } + + if (naming) { + Dialog(onDismissRequest = { naming = false }, properties = DialogProperties(usePlatformDefaultWidth = false)) { + Box(Modifier.fillMaxSize().systemBarsPadding().padding(16.dp), contentAlignment = Alignment.Center) { + Surface( + Modifier.widthIn(max = 520.dp).fillMaxWidth(), shape = RoundedCornerShape(22.dp), + color = p.background, contentColor = p.onBackground, border = BorderStroke(1.dp, p.line2), + ) { + Column(Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) { + OutlinedTextField( + name, { name = it.take(24) }, Modifier.fillMaxWidth(), singleLine = true, + keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done), + ) + Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.End) { + TextButton(onClick = { naming = false }) { Text(stringResource(R.string.common_cancel)) } + Button(onClick = { onSave(name.trim()); naming = false }, enabled = name.isNotBlank()) { + Text(stringResource(R.string.screen_key_layout_save)) + } + } + } + } + } + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt index ecf43901d7..addb55473a 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -261,6 +261,10 @@ class DrawerActions( val onLowLatencyTouch: (Boolean) -> Unit = {}, val onTouch: (String) -> Unit, val onGestureSettings: () -> Unit = {}, + val onScreenKeys: (() -> Unit)? = null, + val onScreenLayouts: (() -> Unit)? = null, + val screenKeysShown: Boolean = true, + val onScreenKeysShown: (Boolean) -> Unit = {}, val onFexPreset: (String) -> Unit, val onUpscaler: (Int) -> Unit = {}, val onUpscaleSharpness: (Int) -> Unit = {}, @@ -555,6 +559,23 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont ActionRow(stringResource(R.string.gesture_settings), stringResource(R.string.gesture_settings_hint), stringResource(R.string.ctrl_edit), a.onGestureSettings, modifier = focus.track(page, "gesture-settings")) + if (a.onScreenKeys != null) { + SettingsRow(stringResource(R.string.screen_keys), null) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp), + ) { + SecondaryButton(stringResource(R.string.ctrl_edit), + modifier = focus.track(page, "screen-keys"), onClick = a.onScreenKeys) + a.onScreenLayouts?.let { open -> + SecondaryButton(stringResource(R.string.screen_key_layout), + modifier = focus.track(page, "screen-key-layouts"), onClick = open) + } + ToggleSwitch(a.screenKeysShown, true, + modifier = focus.track(page, "screen-keys-shown"), onChange = a.onScreenKeysShown) + } + } + } ChoiceRow(host, "osc", stringResource(R.string.mode_osc), null, if (a.steam) listOf(SessionPrefs.OSC_AUTO to stringResource(R.string.common_auto), SessionPrefs.OSC_ALWAYS to stringResource(R.string.common_always), SessionPrefs.OSC_STEAM_TOUCH to stringResource(R.string.osc_steam_touch), SessionPrefs.OSC_STEAM_QAM to stringResource(R.string.mode_osc_qam), SessionPrefs.OSC_NEVER to stringResource(R.string.common_never)) else listOf(SessionPrefs.OSC_AUTO to stringResource(R.string.common_auto), SessionPrefs.OSC_ALWAYS to stringResource(R.string.common_always), SessionPrefs.OSC_NEVER to stringResource(R.string.common_never)), diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index 5416c2d32e..fa1c13e5e5 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -267,6 +267,24 @@ لمس Steam (تجريبي) تبدأ عناصر التحكم باللمس من Steam مع جلسة Steam التالية تخطيط لمس Steam + مفاتيح الشاشة + إضافة مفتاح + نص + الحجم + العتامة + مفتاح + زناد + تبديل + تصدير + كبسولة + مستدير + دائرة + مستطيل + مفتاح + صورة + مسح + التخطيط + حفظ انقل عناصر التحكم باللمس لهذه اللعبة أو غيّر حجمها أو أخفها؛ ويتم الحفظ في Steam وحدة التحكم كيف يرى Steam وحدة التحكم لديك. يُطبَّق في الجلسة التالية. diff --git a/app/src/main/res/values-b+es+419/strings.xml b/app/src/main/res/values-b+es+419/strings.xml index 79b3ebf1be..acbf053f10 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -267,6 +267,24 @@ Táctil de Steam (beta) Los controles táctiles de Steam se activan en la próxima sesión de Steam Disposición táctil de Steam + Teclas en pantalla + Agregar tecla + Texto + Tamaño + Opacidad + Tecla + Gatillo + Alternar + Exportar + Píldora + Redondeado + Círculo + Rectángulo + Tecla + Imagen + Borrar + Disposición + Guardar Mueve, cambia de tamaño u oculta los controles táctiles de este juego; se guarda en Steam Control Cómo ve Steam tu control. Se aplica en la próxima sesión. diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index 3c052c8586..137b761f8b 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -267,6 +267,24 @@ Докосване в Steam (бета) Сензорните контроли на Steam ще стартират от следващата сесия на Steam Разположение на докосването в Steam + Клавиши на екрана + Добавяне на клавиш + Текст + Размер + Прозрачност + Клавиш + Спускът + Превключване + Експорт + Капсула + Заоблено + Кръг + Правоъгълник + Клавиш + Изображение + Изчистване + Разположение + Запиши Премествайте, преоразмерявайте или скривайте сензорните контроли на тази игра; записва се в Steam Контролер Как Steam разпознава контролера ви. Прилага се от следващата сесия. diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index 8dec40660e..d12e8ff408 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -267,6 +267,24 @@ Dotykové ovládání Steamu (beta) Dotykové ovládání Steamu se spustí od příští relace Steamu Rozvržení dotykového ovládání Steamu + Klávesy na obrazovce + Přidat klávesu + Text + Velikost + Průhlednost + Klávesa + Spoušť + Přepínač + Exportovat + Kapsle + Zaoblené + Kruh + Obdélník + Klávesa + Obrázek + Vymazat + Rozložení + Uložit Přesuňte, změňte velikost nebo skryjte dotykové ovládání této hry; uloží se do Steamu Ovladač Jak Steam vidí váš ovladač. Použije se od příští relace. diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 41e94a3c7c..caf758e572 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -267,6 +267,24 @@ Steam-berøring (beta) Steams berøringskontroller starter med næste Steam-session Steam-berøringslayout + Skærmtaster + Tilføj tast + Tekst + Størrelse + Gennemsigtighed + Tast + Udløser + Skift + Eksportér + Kapsel + Afrundet + Cirkel + Rektangel + Tast + Billede + Ryd + Layout + Gem Flyt, tilpas størrelsen på eller skjul dette spils berøringskontroller; gemmes til Steam Controller Hvordan Steam ser din controller. Gælder fra næste session. diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index e4d34fe62a..fbdf383abb 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -267,6 +267,24 @@ Steam-Touch (Beta) Steams Touch-Steuerung startet mit der nächsten Steam-Sitzung Steam-Touch-Layout + Bildschirmtasten + Taste hinzufügen + Text + Größe + Deckkraft + Taste + Trigger + Umschalten + Exportieren + Kapsel + Rund + Kreis + Rechteck + Taste + Bild + Entfernen + Layout + Speichern Touch-Steuerung dieses Spiels verschieben, skalieren oder ausblenden; wird in Steam gespeichert Controller Wie Steam deinen Controller erkennt. Gilt ab der nächsten Sitzung. diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 3518c85469..7e21ae76cd 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -267,6 +267,24 @@ Αφή Steam (beta) Τα χειριστήρια αφής του Steam ξεκινούν από την επόμενη συνεδρία Steam Διάταξη αφής Steam + Πλήκτρα οθόνης + Προσθήκη πλήκτρου + Κείμενο + Μέγεθος + Διαφάνεια + Πλήκτρο + Σκανδάλη + Εναλλαγή + Εξαγωγή + Κάψουλα + Στρογγυλεμένο + Κύκλος + Ορθογώνιο + Πλήκτρο + Εικόνα + Εκκαθάριση + Διάταξη + Αποθήκευση Μετακινήστε, αλλάξτε μέγεθος ή αποκρύψτε τα χειριστήρια αφής αυτού του παιχνιδιού· αποθηκεύεται στο Steam Χειριστήριο Πώς βλέπει το Steam το χειριστήριό σας. Εφαρμόζεται στην επόμενη συνεδρία. diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index ac6933cad1..1e3859f582 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -267,6 +267,24 @@ Táctil de Steam (beta) Los controles táctiles de Steam se activan en la próxima sesión de Steam Disposición táctil de Steam + Teclas en pantalla + Añadir tecla + Texto + Tamaño + Opacidad + Tecla + Gatillo + Alternar + Exportar + Píldora + Redondeado + Círculo + Rectángulo + Tecla + Imagen + Borrar + Disposición + Guardar Mueve, cambia de tamaño u oculta los controles táctiles de este juego; se guarda en Steam Mando Cómo ve Steam tu mando. Se aplica en la próxima sesión. diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index 8359d4cf8c..30f3341610 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -267,6 +267,24 @@ Steam-kosketus (beta) Steamin kosketusohjaimet otetaan käyttöön seuraavassa Steam-istunnossa Steamin kosketusasettelu + Näytön näppäimet + Lisää näppäin + Teksti + Koko + Peittävyys + Näppäin + Liipaisin + Vaihda + Vie + Kapseli + Pyöristetty + Ympyrä + Suorakaide + Näppäin + Kuva + Tyhjennä + Asettelu + Tallenna Siirrä, muuta kokoa tai piilota tämän pelin kosketusohjaimet; tallennetaan Steamiin Ohjain Miten Steam näkee ohjaimesi. Tulee voimaan seuraavassa istunnossa. diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 18936f64a6..76bf5abc2c 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -267,6 +267,24 @@ Tactile Steam (bêta) Les commandes tactiles de Steam s\'activeront à la prochaine session Steam Disposition tactile Steam + Touches à l\'écran + Ajouter une touche + Texte + Taille + Opacité + Touche + Gâchette + Basculer + Exporter + Pilule + Arrondi + Cercle + Rectangle + Touche + Image + Effacer + Disposition + Enregistrer Déplacez, redimensionnez ou masquez les commandes tactiles de ce jeu ; enregistré dans Steam Manette Comment Steam reconnaît votre manette. Prendra effet à la prochaine session. diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index 7acad5ccd0..68cb4c185a 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -267,6 +267,24 @@ Steam टच (बीटा) Steam के टच कंट्रोल अगले Steam सेशन से शुरू होंगे Steam टच लेआउट + स्क्रीन कुंजियाँ + कुंजी जोड़ें + टेक्स्ट + आकार + ओपैसिटी + कुंजी + ट्रिगर + टॉगल + निर्यात + कैप्सूल + गोल + वृत्त + आयत + कुंजी + छवि + हटाएं + लेआउट + सेव करें इस गेम के टच कंट्रोल को घुमाएं, आकार बदलें या छिपाएं; Steam में सेव होता है कंट्रोलर Steam आपके कंट्रोलर को किस तरह पहचानता है। अगले सेशन से लागू होता है। diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index 86f9d00962..a7e0ca9754 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -267,6 +267,24 @@ Steam érintés (béta) A Steam érintésvezérlői a következő Steam-munkamenettől lépnek életbe Steam érintéskiosztás + Képernyőgombok + Gomb hozzáadása + Szöveg + Méret + Átlátszatlanság + Gomb + Trigger + Váltás + Exportálás + Kapszula + Lekerekített + Kör + Téglalap + Billentyű + Kép + Törlés + Elrendezés + Mentés Mozgassa, méretezze vagy rejtse el a játék érintésvezérlőit; a Steamben mentve Kontroller Hogyan látja a Steam a kontrollerét. A következő munkamenettől érvényes. diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 6fe298c0d9..d5fc612c3f 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -267,6 +267,24 @@ Sentuhan Steam (beta) Kontrol sentuh Steam dimulai pada sesi Steam berikutnya Tata letak sentuh Steam + Tombol layar + Tambah tombol + Teks + Ukuran + Opasitas + Tombol + Pemicu + Alih + Ekspor + Kapsul + Membulat + Lingkaran + Persegi panjang + Tombol + Gambar + Hapus + Tata letak + Simpan Pindahkan, ubah ukuran, atau sembunyikan kontrol sentuh gim ini; disimpan ke Steam Pengontrol Cara Steam mendeteksi pengontrol Anda. Berlaku pada sesi berikutnya. diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index e3c5cc25c9..d070b01e32 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -267,6 +267,24 @@ Touch di Steam (beta) I controlli touch di Steam partono dalla prossima sessione Steam Layout touch di Steam + Tasti a schermo + Aggiungi tasto + Testo + Dimensione + Opacità + Tasto + Grilletto + Attiva + Esporta + Capsula + Arrotondato + Cerchio + Rettangolo + Tasto + Immagine + Cancella + Layout + Salva Sposta, ridimensiona o nascondi i controlli touch di questo gioco; vengono salvati su Steam Controller Come Steam vede il tuo controller. Si applica dalla prossima sessione. diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index f0b2b83310..9bb40dcd11 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -267,6 +267,24 @@ Steamタッチ(ベータ版) Steamのタッチコントロールは次回のSteamセッションから有効になります Steamタッチのレイアウト + 画面のキー + キーを追加 + テキスト + サイズ + 不透明度 + キー + トリガー + トグル + エクスポート + カプセル + 角丸 + 円 + 四角 + キー + 画像 + クリア + レイアウト + 保存 このゲームのタッチコントロールを移動、サイズ変更、非表示にします。Steamに保存されます コントローラー Steamがコントローラーを認識する方法。次回のセッションで有効になります。 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 4c30f8ed68..b76da8d131 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -267,6 +267,24 @@ Steam 터치(베타) Steam 터치 컨트롤은 다음 Steam 세션부터 적용됩니다 Steam 터치 레이아웃 + 화면 키 + 키 추가 + 텍스트 + 크기 + 불투명도 + 키 + 트리거 + 토글 + 내보내기 + 캡슐 + 둥근 모서리 + 원 + 사각형 + 키 + 이미지 + 지우기 + 레이아웃 + 저장 이 게임의 터치 컨트롤을 옮기거나 크기를 바꾸거나 숨깁니다. Steam에 저장됩니다 컨트롤러 Steam이 컨트롤러를 인식하는 방식입니다. 다음 세션에 적용됩니다. diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index 3047eae83f..e036753b5d 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -267,6 +267,24 @@ Sentuhan Steam (beta) Kawalan sentuh Steam bermula pada sesi Steam seterusnya Susun atur sentuh Steam + Kekunci skrin + Tambah kekunci + Teks + Saiz + Kelegapan + Kekunci + Pencetus + Togol + Eksport + Kapsul + Bulat + Bulatan + Segi empat + Kekunci + Imej + Kosongkan + Susun atur + Simpan Gerakkan, ubah saiz atau sembunyikan kawalan sentuh permainan ini; disimpan ke Steam Pengawal Cara Steam mengesan pengawal anda. Berkuat kuasa pada sesi seterusnya. diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index 2ca4cc2335..a9f9489c15 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -267,6 +267,24 @@ Steam-berøring (beta) Steams berøringskontroller starter med neste Steam-sesjon Steam-berøringslayout + Skjermtaster + Legg til tast + Tekst + Størrelse + Opasitet + Tast + Utløser + Veksle + Eksporter + Kapsel + Avrundet + Sirkel + Rektangel + Tast + Bilde + Fjern + Oppsett + Lagre Flytt, endre størrelse på eller skjul dette spillets berøringskontroller; lagres til Steam Kontroller Hvordan Steam ser kontrolleren din. Gjelder fra neste sesjon. diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index d5c217f93a..d74633be94 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -267,6 +267,24 @@ Steam-aanraakbediening (bèta) De aanraakbediening van Steam start bij de volgende Steam-sessie Steam-aanraakindeling + Schermtoetsen + Toets toevoegen + Tekst + Grootte + Transparantie + Toets + Trigger + Schakelen + Exporteren + Capsule + Afgerond + Cirkel + Rechthoek + Toets + Afbeelding + Wissen + Indeling + Opslaan Verplaats, schaal of verberg de aanraakbediening van deze game; opgeslagen in Steam Controller Hoe Steam je controller ziet. Geldt vanaf de volgende sessie. diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 02d9de52d6..121d781649 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -267,6 +267,24 @@ Dotyk Steam (beta) Sterowanie dotykowe Steam zacznie działać od następnej sesji Steam Układ dotykowy Steam + Klawisze ekranu + Dodaj klawisz + Tekst + Rozmiar + Przezroczystość + Klawisz + Spust + Przełącznik + Eksportuj + Kapsułka + Zaokrąglony + Koło + Prostokąt + Klawisz + Obraz + Wyczyść + Układ + Zapisz Przesuwaj, zmieniaj rozmiar lub ukrywaj sterowanie dotykowe tej gry; zapisywane w Steam Kontroler Jak Steam widzi Twój kontroler. Działa od następnej sesji. diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index 73658c0f23..61fe3b5ff4 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -267,6 +267,24 @@ Controlos táteis do Steam (beta) Os controlos táteis do Steam começam na próxima sessão do Steam Esquema tátil do Steam + Teclas no ecrã + Adicionar tecla + Texto + Tamanho + Opacidade + Tecla + Gatilho + Alternar + Exportar + Cápsula + Arredondado + Círculo + Retângulo + Tecla + Imagem + Limpar + Esquema + Guardar Mova, redimensione ou oculte os controlos táteis deste jogo; é guardado no Steam Comando Como o Steam vê o seu comando. Aplica-se na próxima sessão. diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 16cd8eb468..c9e1e7b1b7 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -267,6 +267,24 @@ Toque da Steam (beta) Os controles de toque da Steam começam na próxima sessão da Steam Layout de toque da Steam + Teclas na tela + Adicionar tecla + Texto + Tamanho + Opacidade + Tecla + Gatilho + Alternar + Exportar + Cápsula + Arredondado + Círculo + Retângulo + Tecla + Imagem + Limpar + Layout + Salvar Mova, redimensione ou oculte os controles de toque deste jogo; salvo na Steam Controle Como a Steam vê seu controle. Vale a partir da próxima sessão. diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index d9e87c4465..b8e3b4954c 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -267,6 +267,24 @@ Atingere Steam (beta) Comenzile tactile Steam pornesc odată cu următoarea sesiune Steam Aranjament tactil Steam + Taste pe ecran + Adaugă tastă + Text + Dimensiune + Opacitate + Tastă + Trăgaci + Comutare + Exportă + Capsulă + Rotunjit + Cerc + Dreptunghi + Tastă + Imagine + Șterge + Aranjament + Salvează Mută, redimensionează sau ascunde comenzile tactile ale acestui joc; salvate în Steam Controller Cum vede Steam controllerul tău. Se aplică la sesiunea următoare. diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 060c7469f8..59e74118e7 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -267,6 +267,24 @@ Сенсорное управление Steam (бета) Сенсорное управление Steam включится со следующей сессии Steam Сенсорная раскладка Steam + Экранные клавиши + Добавить клавишу + Текст + Размер + Непрозрачность + Клавиша + Триггер + Переключение + Экспорт + Капсула + Скругление + Круг + Прямоугольник + Клавиша + Изображение + Очистить + Раскладка + Сохранить Перемещайте, меняйте размер или скрывайте сенсорные кнопки этой игры; сохраняется в Steam Контроллер Как Steam распознает ваш контроллер. Вступит в силу в следующей сессии. diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index 1fc734869b..2c62e8b139 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -267,6 +267,24 @@ Steam-pekstyrning (beta) Steams pekstyrning startar med nästa Steam-session Steams peklayout + Skärmtangenter + Lägg till tangent + Text + Storlek + Opacitet + Tangent + Avtryckare + Växla + Exportera + Kapsel + Rundad + Cirkel + Rektangel + Tangent + Bild + Rensa + Layout + Spara Flytta, ändra storlek på eller dölj spelets pekkontroller; sparas i Steam Handkontroll Hur Steam ser din handkontroll. Gäller från nästa session. diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index d0a3c6cd8c..38337b0fda 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -267,6 +267,24 @@ การสัมผัสของ Steam (ทดลอง) ปุ่มสัมผัสของ Steam จะเริ่มใช้งานในเซสชัน Steam ถัดไป รูปแบบปุ่มสัมผัสของ Steam + ปุ่มบนหน้าจอ + เพิ่มปุ่ม + ข้อความ + ขนาด + ความโปร่งใส + ปุ่ม + ไก + สลับ + ส่งออก + แคปซูล + มน + วงกลม + สี่เหลี่ยม + ปุ่ม + รูปภาพ + ล้าง + การจัดวาง + บันทึก ย้าย ปรับขนาด หรือซ่อนปุ่มสัมผัสของเกมนี้ บันทึกไปยัง Steam คอนโทรลเลอร์ วิธีที่ Steam มองเห็นคอนโทรลเลอร์ของคุณ จะมีผลในเซสชันถัดไป diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 21fcaa6a5c..c1bbb9d33d 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -267,6 +267,24 @@ Steam dokunmatik (beta) Steam\'in dokunmatik kontrolleri sonraki Steam oturumunda başlar Steam dokunmatik düzeni + Ekran tuşları + Tuş ekle + Metin + Boyut + Opaklık + Tuş + Tetik + Aç/Kapa + Dışa aktar + Kapsül + Yuvarlak + Daire + Dikdörtgen + Tuş + Görsel + Temizle + Düzen + Kaydet Bu oyunun dokunmatik kontrollerini taşıyın, boyutlandırın veya gizleyin; Steam\'e kaydedilir Kumanda Steam\'in kumandanızı nasıl gördüğü. Sonraki oturumda uygulanır. diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 972d389301..2cadb53c52 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -267,6 +267,24 @@ Сенсорне керування Steam (бета) Сенсорне керування Steam увімкнеться з наступним сеансом Steam Розкладка сенсорного керування Steam + Екранні клавіші + Додати клавішу + Текст + Розмір + Непрозорість + Клавіша + Тригер + Перемикання + Експорт + Капсула + Заокруглення + Коло + Прямокутник + Клавіша + Зображення + Очистити + Розкладка + Зберегти Переміщуйте, змінюйте розмір або приховуйте сенсорні елементи керування цієї гри; зберігається в Steam Контролер Яким Steam бачить ваш контролер. Застосовується в наступному сеансі. diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index a7b2ee7483..b8a7da87a9 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -267,6 +267,24 @@ Chạm Steam (beta) Các nút chạm của Steam bắt đầu từ phiên Steam kế tiếp Bố cục chạm Steam + Phím trên màn hình + Thêm phím + Văn bản + Kích thước + Độ mờ + Phím + Cò + Bật tắt + Xuất + Viên nang + Bo tròn + Tròn + Chữ nhật + Phím + Hình ảnh + Xóa + Bố cục + Lưu Di chuyển, đổi kích thước hoặc ẩn các nút chạm của game này; được lưu vào Steam Tay cầm Cách Steam nhận dạng tay cầm của bạn. Áp dụng từ phiên sau. diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index b740148990..2726014a0b 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -267,6 +267,24 @@ Steam 触控(测试版) Steam 的触控按键将从下次 Steam 会话开始生效 Steam 触控布局 + 屏幕按键 + 添加按键 + 文本 + 大小 + 透明 + 单键 + 扳机 + 切换 + 导出 + 胶囊 + 圆角 + 圆形 + 矩形 + 绑定 + 图片 + 清除 + 布局 + 保存 移动、调整大小或隐藏此游戏的触控按键;保存到 Steam 手柄 决定 Steam 把你的手柄识别为哪种类型,将在下次会话生效。 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index 310ac68d8b..cdcc40b76a 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -267,6 +267,24 @@ Steam 觸控(測試版) Steam 的觸控控制會在下次 Steam 會話啟用 Steam 觸控佈局 + 螢幕按鍵 + 新增按鍵 + 文本 + 大小 + 透明 + 單鍵 + 扳機 + 切換 + 匯出 + 膠囊 + 圓角 + 圓形 + 矩形 + 綁定 + 圖片 + 清除 + 佈局 + 儲存 移動、調整大小或隱藏此遊戲的觸控控制;會儲存至 Steam 控制器 Steam 如何識別你的控制器。下次會話生效。 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 841644eb10..43fb5e4434 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -267,6 +267,24 @@ Steam 觸控(測試版) Steam 觸控控制會在下次 Steam 工作階段啟用 Steam 觸控版面配置 + 螢幕按鍵 + 新增按鍵 + 文本 + 大小 + 透明 + 單鍵 + 扳機 + 切換 + 匯出 + 膠囊 + 圓角 + 圓形 + 矩形 + 綁定 + 圖片 + 清除 + 版面配置 + 儲存 移動、調整大小或隱藏這款遊戲的觸控控制;會儲存到 Steam 控制器 Steam 辨識你的控制器的方式。下次工作階段生效。 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 4e0b1e55d2..416e25e4e2 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -278,6 +278,24 @@ Steam touch (beta) Steam\'s touch controls start with the next Steam session Steam touch layout + Screen keys + Add key + Text + Size + Alpha + Key + Pill + Round + Circle + Rect + Trigger + Bind + Image + Clear + Toggle + Layout + Save + Export Move, resize or hide this game\'s touch controls; saved to Steam Controller How Steam sees your controller. Applies next session. diff --git a/app/src/test/java/com/droiddeck/launcher/input/ScreenKeysTest.kt b/app/src/test/java/com/droiddeck/launcher/input/ScreenKeysTest.kt new file mode 100644 index 0000000000..8a95dd5128 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/ScreenKeysTest.kt @@ -0,0 +1,124 @@ +package com.droiddeck.launcher.input + +import android.view.InputDevice +import android.view.KeyEvent +import android.view.MotionEvent +import android.view.View +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class ScreenKeysTest { + private val context = RuntimeEnvironment.getApplication() + + @Before fun clearKeys() { + ControllerPrefs.setScreenKeys(context, emptyList()) + } + + @Test fun missesAreForwardedAsTheirOwnTouchStreamWhileAKeyIsHeld() { + val sent = mutableListOf>() + val keys = ScreenKeys(context) { code, down -> sent += code to down } + keys.layout(0, 0, 1000, 600) + keys.add(listOf(KeyEvent.KEYCODE_W)) + val forwarded = mutableListOf>() + keys.onTouchMiss = { forwarded += it.actionMasked to it.getPointerId(0) } + + send(keys, MotionEvent.ACTION_DOWN, listOf(0), listOf(300f), listOf(372f)) + send(keys, MotionEvent.ACTION_POINTER_DOWN or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), listOf(0, 1), listOf(300f, 900f), listOf(372f, 550f)) + send(keys, MotionEvent.ACTION_MOVE, listOf(0, 1), listOf(310f, 880f), listOf(372f, 530f)) + send(keys, MotionEvent.ACTION_POINTER_UP or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), listOf(0, 1), listOf(310f, 880f), listOf(372f, 530f)) + send(keys, MotionEvent.ACTION_UP, listOf(0), listOf(310f), listOf(372f)) + + assertEquals( + listOf( + MotionEvent.ACTION_DOWN to 1, + MotionEvent.ACTION_MOVE to 1, + MotionEvent.ACTION_UP to 1, + ), + forwarded, + ) + assertEquals(listOf(KeyEvent.KEYCODE_W to true, KeyEvent.KEYCODE_W to false), sent) + } + + @Test fun gestureRecognizerKeepsOneSplitTargetOwnerUntilItsStreamEnds() { + val gate = GestureTouchStreamGate() + fun accepts(source: GestureTouchStreamGate.Source, action: Int): Boolean { + val event = MotionEvent.obtain(0L, 1L, action, 1f, 1f, 0) + return try { gate.accepts(source, event) } finally { event.recycle() } + } + + assertTrue(accepts(GestureTouchStreamGate.Source.SURFACE, MotionEvent.ACTION_DOWN)) + assertFalse(accepts(GestureTouchStreamGate.Source.SCREEN_KEYS, MotionEvent.ACTION_DOWN)) + assertTrue(accepts(GestureTouchStreamGate.Source.SURFACE, MotionEvent.ACTION_MOVE)) + assertTrue(accepts(GestureTouchStreamGate.Source.SURFACE, MotionEvent.ACTION_UP)) + assertTrue(accepts(GestureTouchStreamGate.Source.SCREEN_KEYS, MotionEvent.ACTION_DOWN)) + assertFalse(accepts(GestureTouchStreamGate.Source.SURFACE, MotionEvent.ACTION_DOWN)) + assertTrue(accepts(GestureTouchStreamGate.Source.SCREEN_KEYS, MotionEvent.ACTION_CANCEL)) + assertTrue(accepts(GestureTouchStreamGate.Source.SURFACE, MotionEvent.ACTION_DOWN)) + assertFalse(accepts(GestureTouchStreamGate.Source.SCREEN_KEYS, MotionEvent.ACTION_DOWN)) + gate.reset() + assertTrue(accepts(GestureTouchStreamGate.Source.SURFACE, MotionEvent.ACTION_DOWN)) + } + + @Test fun loadingLayoutReleasesLatchedKeysBeforeReplacingEntries() { + val sent = mutableListOf>() + val keys = ScreenKeys(context) { code, down -> sent += code to down } + keys.layout(0, 0, 1000, 600) + keys.add(listOf(KeyEvent.KEYCODE_SHIFT_LEFT)) + keys.setToggle(listOf(KeyEvent.KEYCODE_SHIFT_LEFT), true) + send(keys, MotionEvent.ACTION_DOWN, listOf(0), listOf(300f), listOf(372f)) + send(keys, MotionEvent.ACTION_UP, listOf(0), listOf(300f), listOf(372f)) + + keys.load("") + + assertEquals(listOf(KeyEvent.KEYCODE_SHIFT_LEFT to true, KeyEvent.KEYCODE_SHIFT_LEFT to false), sent) + } + + @Test fun hidingTheViewReleasesLatchedKeys() { + val sent = mutableListOf>() + val keys = ScreenKeys(context) { code, down -> sent += code to down } + keys.layout(0, 0, 1000, 600) + keys.add(listOf(KeyEvent.KEYCODE_SHIFT_LEFT)) + keys.setToggle(listOf(KeyEvent.KEYCODE_SHIFT_LEFT), true) + send(keys, MotionEvent.ACTION_DOWN, listOf(0), listOf(300f), listOf(372f)) + send(keys, MotionEvent.ACTION_UP, listOf(0), listOf(300f), listOf(372f)) + + keys.visibility = View.GONE + + assertEquals(listOf(KeyEvent.KEYCODE_SHIFT_LEFT to true, KeyEvent.KEYCODE_SHIFT_LEFT to false), sent) + } + + private fun send(view: View, action: Int, ids: List, xs: List, ys: List) { + val properties = Array(ids.size) { index -> + MotionEvent.PointerProperties().apply { + id = ids[index] + toolType = MotionEvent.TOOL_TYPE_FINGER + } + } + val coordinates = Array(ids.size) { index -> + MotionEvent.PointerCoords().apply { + x = xs[index] + y = ys[index] + pressure = 1f + size = 1f + } + } + val event = MotionEvent.obtain( + 0L, 1L, action, ids.size, properties, coordinates, 0, 0, + 1f, 1f, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0, + ) + try { + view.onTouchEvent(event) + } finally { + event.recycle() + } + } +}