diff --git a/README.md b/README.md index 4b455fb..6e4b145 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # NESLite NESLite 是一个面向 Android 的轻量 NES/FC 模拟器前端。它使用固定版本的 -FCEUmm libretro 内核。当前仓库已准备 0.9.10 候选基线的冻结样本、输入延迟指标、升级架构、原生对齐审计 +FCEUmm libretro 内核。当前仓库已准备 0.9.11 候选基线的冻结样本、输入延迟指标、升级架构、原生对齐审计 和候选交付脚本;荣耀 Magic8 与 X5 Lite 已由截图确认枚举,但手机未开放 ADB,且发布签名和可观察 玩法的合法 ROM 样本尚未提供,因此 M2~M8 的完整实机验收及 G8 仍待补齐。 diff --git a/app/build.gradle.kts b/app/build.gradle.kts index b564af8..d523fe3 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -21,8 +21,8 @@ android { applicationId = "org.neslite.app" minSdk = 28 targetSdk = 36 - versionCode = 9010 - versionName = "0.9.10" + versionCode = 9011 + versionName = "0.9.11" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" ndk { diff --git a/app/src/main/java/org/neslite/app/MainActivity.kt b/app/src/main/java/org/neslite/app/MainActivity.kt index ae9c048..026d823 100644 --- a/app/src/main/java/org/neslite/app/MainActivity.kt +++ b/app/src/main/java/org/neslite/app/MainActivity.kt @@ -64,6 +64,7 @@ import org.neslite.app.input.ControllerProfile import org.neslite.app.input.ControllerProfileJson import org.neslite.app.input.ControllerProfileResolver import org.neslite.app.input.ControllerProfileStore +import org.neslite.app.input.DirectionMode import org.neslite.app.input.GameAction import org.neslite.app.input.InputBinding import org.neslite.app.input.InputRouter @@ -75,6 +76,7 @@ import org.neslite.app.save.SaveCatalogReader import org.neslite.app.save.SaveSlotSummary import org.neslite.app.settings.AppSettings import org.neslite.app.settings.AppSettingsStore +import org.neslite.app.settings.VirtualDpadSize import org.neslite.app.settings.shouldShowVirtualGamepad import org.neslite.app.system.BackDecision import org.neslite.app.system.CrashLoopGuard @@ -1087,6 +1089,87 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { renderSettings() } }) + settingsPanel.addView(section("屏幕方向键与手柄摇杆")) + settingsPanel.addView(Button(this).apply { + text = if (appSettings.directionMode == DirectionMode.EIGHT_WAY) { + "方向输入:八方向" + } else { + "方向输入:四方向" + } + setOnClickListener { + appSettings = appSettings.copy( + directionMode = if (appSettings.directionMode == DirectionMode.EIGHT_WAY) { + DirectionMode.FOUR_WAY + } else { + DirectionMode.EIGHT_WAY + }, + ) + applyAppSettings() + persistAppSettings() + renderSettings() + } + }) + settingsPanel.addView(body("八方向允许斜向组合;四方向在斜推时保留最近明确输入的横向或纵向。")) + settingsPanel.addView(Button(this).apply { + text = "方向键大小:${appSettings.virtualDpadSize.label}" + setOnClickListener { + appSettings = appSettings.copy(virtualDpadSize = appSettings.virtualDpadSize.next()) + applyAppSettings() + persistAppSettings() + renderSettings() + } + }) + settingsPanel.addView( + body("方向键水平位置:${(appSettings.virtualDpadHorizontalOffset * 100).toInt()}%"), + ) + settingsPanel.addView(SeekBar(this).apply { + max = 200 + progress = ((appSettings.virtualDpadHorizontalOffset + 1f) * 100f).toInt() + setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener { + override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {} + override fun onStartTrackingTouch(seekBar: SeekBar?) {} + override fun onStopTrackingTouch(seekBar: SeekBar?) { + appSettings = appSettings.copy( + virtualDpadHorizontalOffset = ((seekBar?.progress ?: 100) - 100) / 100f, + ) + applyAppSettings() + persistAppSettings() + renderSettings() + } + }) + }) + settingsPanel.addView( + body("方向键垂直位置:${(appSettings.virtualDpadVerticalOffset * 100).toInt()}%"), + ) + settingsPanel.addView(SeekBar(this).apply { + max = 200 + progress = ((appSettings.virtualDpadVerticalOffset + 1f) * 100f).toInt() + setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener { + override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {} + override fun onStartTrackingTouch(seekBar: SeekBar?) {} + override fun onStopTrackingTouch(seekBar: SeekBar?) { + appSettings = appSettings.copy( + virtualDpadVerticalOffset = ((seekBar?.progress ?: 100) - 100) / 100f, + ) + applyAppSettings() + persistAppSettings() + renderSettings() + } + }) + }) + settingsPanel.addView(Button(this).apply { + text = "恢复方向键默认大小与位置" + setOnClickListener { + appSettings = appSettings.copy( + virtualDpadSize = VirtualDpadSize.LARGE, + virtualDpadHorizontalOffset = 0f, + virtualDpadVerticalOffset = 0f, + ) + applyAppSettings() + persistAppSettings() + renderSettings() + } + }) settingsPanel.addView(Button(this).apply { text = "手动设置手柄按键、摇杆与功能键" setOnClickListener { @@ -1117,12 +1200,24 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { private fun applyAppSettings() { muted = appSettings.muted + if (::virtualGamepad.isInitialized) { + virtualGamepad.configureDpad( + mode = appSettings.directionMode, + scale = appSettings.virtualDpadSize.scale, + horizontalOffset = appSettings.virtualDpadHorizontalOffset, + verticalOffset = appSettings.virtualDpadVerticalOffset, + ) + } + val directionState = inputRouter.setEightDirectionEnabled( + appSettings.directionMode == DirectionMode.EIGHT_WAY, + ) if (::emulatorSurface.isInitialized) { emulatorSurface.integerScale = appSettings.integerScale emulatorSurface.linearFilter = appSettings.linearFilter } updateVirtualGamepadVisibility() if (activeSessionId != 0L) { + applyRoutedInput(directionState) NativeBridge.command(activeSessionId, "volume:${appSettings.volume}") NativeBridge.command(activeSessionId, if (appSettings.muted) "mute:on" else "mute:off") } diff --git a/app/src/main/java/org/neslite/app/VirtualGamepadLayout.kt b/app/src/main/java/org/neslite/app/VirtualGamepadLayout.kt index ae81387..65f61c7 100644 --- a/app/src/main/java/org/neslite/app/VirtualGamepadLayout.kt +++ b/app/src/main/java/org/neslite/app/VirtualGamepadLayout.kt @@ -28,6 +28,9 @@ internal fun computeVirtualGamepadGeometry( maxRadius: Float, safeLeft: Float = 0f, safeRight: Float = 0f, + dpadScale: Float = 1f, + dpadHorizontalOffset: Float = 0f, + dpadVerticalOffset: Float = 0f, ): VirtualGamepadGeometry { val w = width.coerceAtLeast(1f) val h = height.coerceAtLeast(1f) @@ -37,41 +40,46 @@ internal fun computeVirtualGamepadGeometry( val gameWidth = min(usableWidth, h * 4f / 3f) val sideWidth = ((usableWidth - gameWidth) / 2f).coerceAtLeast(1f) val baseRadius = min(min(h * 0.095f, sideWidth * 0.16f), maxRadius) - val radius = baseRadius * 1.50f + val faceRadius = baseRadius * 1.50f + val dpadRadius = faceRadius * dpadScale.coerceIn(0.85f, 1.50f) val menuRadius = baseRadius * 0.60f * 1.30f val utilityRadius = baseRadius * 0.58f * 1.30f val unshiftedDpadX = leftInset + sideWidth * 0.50f - val unshiftedDpadLeft = unshiftedDpadX - radius * 2f - val edgeGap = baseRadius * 0.10f - val horizontalShift = min(radius * 2f, (unshiftedDpadLeft - edgeGap).coerceAtLeast(0f)) + val unshiftedDpadLeft = unshiftedDpadX - dpadRadius * 2f + val edgeGap = baseRadius * 0.05f + val horizontalShift = min(faceRadius * 2f, (unshiftedDpadLeft - edgeGap).coerceAtLeast(0f)) val gameLeft = leftInset + sideWidth - horizontalShift val gameRight = gameLeft + gameWidth - val dpadX = unshiftedDpadX - horizontalShift - val dpadY = h * 0.61f - val dpadGap = radius + val dpadOuterExtent = dpadRadius * 2f + val dpadX = (unshiftedDpadX - horizontalShift + + dpadHorizontalOffset.coerceIn(-1f, 1f) * faceRadius) + .coerceIn(dpadOuterExtent, (w - dpadOuterExtent).coerceAtLeast(dpadOuterExtent)) + val dpadY = (h * (0.61f + dpadVerticalOffset.coerceIn(-1f, 1f) * 0.12f)) + .coerceIn(dpadOuterExtent, (h - dpadOuterExtent).coerceAtLeast(dpadOuterExtent)) + val dpadGap = dpadRadius val expandedRightWidth = (w - rightInset - gameRight).coerceAtLeast(1f) val faceX = gameRight + expandedRightWidth * 0.50f val faceY = h * 0.54f - val faceGapX = min(radius * 1.70f, expandedRightWidth * 0.50f - radius) - val faceGapY = radius * 1.70f - val gameEdgeGap = radius * 0.25f + val faceGapX = min(faceRadius * 1.70f, expandedRightWidth * 0.50f - faceRadius) + val faceGapY = faceRadius * 1.70f + val gameEdgeGap = faceRadius * 0.25f return VirtualGamepadGeometry( gameLeft = gameLeft, gameRight = gameRight, horizontalShift = horizontalShift, - up = VirtualControl(dpadX, dpadY - dpadGap, radius), - down = VirtualControl(dpadX, dpadY + dpadGap, radius), - left = VirtualControl(dpadX - dpadGap, dpadY, radius), - right = VirtualControl(dpadX + dpadGap, dpadY, radius), + up = VirtualControl(dpadX, dpadY - dpadGap, dpadRadius), + down = VirtualControl(dpadX, dpadY + dpadGap, dpadRadius), + left = VirtualControl(dpadX - dpadGap, dpadY, dpadRadius), + right = VirtualControl(dpadX + dpadGap, dpadY, dpadRadius), select = VirtualControl( leftInset + sideWidth - menuRadius - gameEdgeGap - horizontalShift, h * 0.89f, menuRadius, ), - faceY = VirtualControl(faceX, faceY - faceGapY, radius), - faceB = VirtualControl(faceX + faceGapX, faceY, radius), - faceA = VirtualControl(faceX, faceY + faceGapY, radius), - faceX = VirtualControl(faceX - faceGapX, faceY, radius), + faceY = VirtualControl(faceX, faceY - faceGapY, faceRadius), + faceB = VirtualControl(faceX + faceGapX, faceY, faceRadius), + faceA = VirtualControl(faceX, faceY + faceGapY, faceRadius), + faceX = VirtualControl(faceX - faceGapX, faceY, faceRadius), start = VirtualControl( leftInset + sideWidth + gameWidth + menuRadius + gameEdgeGap - horizontalShift, h * 0.89f, diff --git a/app/src/main/java/org/neslite/app/VirtualGamepadView.kt b/app/src/main/java/org/neslite/app/VirtualGamepadView.kt index 0034ddd..8dfc8e1 100644 --- a/app/src/main/java/org/neslite/app/VirtualGamepadView.kt +++ b/app/src/main/java/org/neslite/app/VirtualGamepadView.kt @@ -9,7 +9,9 @@ import android.graphics.RectF import android.view.HapticFeedbackConstants import android.view.MotionEvent import android.view.View +import org.neslite.app.input.DirectionMode import org.neslite.app.input.GameAction +import org.neslite.app.input.VirtualDpadResolver import org.neslite.app.input.VirtualInputTracker import org.neslite.app.input.VirtualInputTransition import kotlin.math.hypot @@ -21,6 +23,7 @@ class VirtualGamepadView( private val onHorizontalShiftChanged: (Float) -> Unit = {}, ) : View(context) { private val tracker = VirtualInputTracker() + private val dpadResolver = VirtualDpadResolver() private val resetPointers = mutableSetOf() private val resetRunnables = mutableMapOf() private val fill = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = Color.argb(145, 45, 52, 64) } @@ -43,6 +46,10 @@ class VirtualGamepadView( } private var safeLeft = 0f private var safeRight = 0f + private var directionMode = DirectionMode.EIGHT_WAY + private var dpadScale = 1.18f + private var dpadHorizontalOffset = 0f + private var dpadVerticalOffset = 0f init { isFocusable = true @@ -77,6 +84,27 @@ class VirtualGamepadView( invalidate() } + internal fun configureDpad( + mode: DirectionMode, + scale: Float, + horizontalOffset: Float, + verticalOffset: Float, + ) { + val normalizedScale = scale.coerceIn(0.85f, 1.50f) + val normalizedHorizontal = horizontalOffset.coerceIn(-1f, 1f) + val normalizedVertical = verticalOffset.coerceIn(-1f, 1f) + if (directionMode == mode && dpadScale == normalizedScale && + dpadHorizontalOffset == normalizedHorizontal && dpadVerticalOffset == normalizedVertical + ) return + clearInputs() + directionMode = mode + dpadScale = normalizedScale + dpadHorizontalOffset = normalizedHorizontal + dpadVerticalOffset = normalizedVertical + onHorizontalShiftChanged(geometry().horizontalShift) + invalidate() + } + override fun onTouchEvent(event: MotionEvent): Boolean { when (event.actionMasked) { MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN -> updatePointer(event, event.actionIndex) @@ -106,7 +134,7 @@ class VirtualGamepadView( val x = event.getX(index) val y = event.getY(index) if (inside(geometry().reset, x, y)) { - emit(tracker.update(pointerId, null)) + emit(tracker.update(pointerId, emptySet())) beginResetHold(pointerId) return } @@ -114,7 +142,7 @@ class VirtualGamepadView( cancelPendingReset(pointerId, keepConsumed = true) return } - emit(tracker.update(pointerId, hitTest(x, y))) + emit(tracker.update(pointerId, hitTestActions(pointerId, x, y))) } private fun releasePointer(pointerId: Int) { @@ -144,24 +172,35 @@ class VirtualGamepadView( private fun emit(transitions: List) { transitions.forEach { onTransition(it.pointerId, it.action, it.pressed) } + if (transitions.any { it.pressed && it.action in DIRECTION_ACTIONS }) { + performHapticFeedback(HapticFeedbackConstants.CLOCK_TICK) + } if (transitions.isNotEmpty()) invalidate() } - internal fun hitTest(x: Float, y: Float): GameAction? { + internal fun hitTestActions(pointerId: Int, x: Float, y: Float): Set { val geometry = geometry() + val dpadCenterX = (geometry.left.x + geometry.right.x) / 2f + val dpadCenterY = (geometry.up.y + geometry.down.y) / 2f + val dpadTouchRadius = geometry.up.radius * 2f * DPAD_TOUCH_SCALE + if (hypot(x - dpadCenterX, y - dpadCenterY) <= dpadTouchRadius) { + return dpadResolver.resolve( + dx = x - dpadCenterX, + dy = y - dpadCenterY, + outerRadius = dpadTouchRadius, + mode = directionMode, + previous = tracker.actionsFor(pointerId).filterTo(linkedSetOf()) { it in DIRECTION_ACTIONS }, + ) + } return when { - inside(geometry.up, x, y) -> GameAction.UP - inside(geometry.down, x, y) -> GameAction.DOWN - inside(geometry.left, x, y) -> GameAction.LEFT - inside(geometry.right, x, y) -> GameAction.RIGHT - inside(geometry.select, x, y) -> GameAction.SELECT - inside(geometry.faceY, x, y, 1.02f) -> GameAction.TURBO_B - inside(geometry.faceB, x, y, 1.02f) -> GameAction.NES_B - inside(geometry.faceA, x, y, 1.02f) -> GameAction.NES_A - inside(geometry.faceX, x, y, 1.02f) -> GameAction.TURBO_A - inside(geometry.start, x, y) -> GameAction.START - inside(geometry.pause, x, y) -> GameAction.PAUSE_MENU - else -> null + inside(geometry.select, x, y) -> setOf(GameAction.SELECT) + inside(geometry.faceY, x, y, 1.02f) -> setOf(GameAction.TURBO_B) + inside(geometry.faceB, x, y, 1.02f) -> setOf(GameAction.NES_B) + inside(geometry.faceA, x, y, 1.02f) -> setOf(GameAction.NES_A) + inside(geometry.faceX, x, y, 1.02f) -> setOf(GameAction.TURBO_A) + inside(geometry.start, x, y) -> setOf(GameAction.START) + inside(geometry.pause, x, y) -> setOf(GameAction.PAUSE_MENU) + else -> emptySet() } } @@ -238,9 +277,14 @@ class VirtualGamepadView( maxRadius = resources.displayMetrics.density * 42f, safeLeft = safeLeft, safeRight = safeRight, + dpadScale = dpadScale, + dpadHorizontalOffset = dpadHorizontalOffset, + dpadVerticalOffset = dpadVerticalOffset, ) private companion object { const val RESET_HOLD_MS = 650L + const val DPAD_TOUCH_SCALE = 1.30f + val DIRECTION_ACTIONS = setOf(GameAction.UP, GameAction.DOWN, GameAction.LEFT, GameAction.RIGHT) } } diff --git a/app/src/main/java/org/neslite/app/input/InputRouter.kt b/app/src/main/java/org/neslite/app/input/InputRouter.kt index 75b70e8..d8caf19 100644 --- a/app/src/main/java/org/neslite/app/input/InputRouter.kt +++ b/app/src/main/java/org/neslite/app/input/InputRouter.kt @@ -19,12 +19,21 @@ data class RoutedInputState( class InputRouter { private val sourcesByAction = GameAction.entries.associateWith { linkedSetOf() } private var fastForward = false + private var eightDirectionEnabled = true + private var lastDirectionAxis = DirectionAxis.HORIZONTAL fun update(source: InputSource, action: GameAction, pressed: Boolean): RoutedInputState { val sources = sourcesByAction.getValue(action) val wasPressed = sources.isNotEmpty() if (pressed) sources += source else sources -= source val isPressed = sources.isNotEmpty() + if (!wasPressed && isPressed) { + when (action) { + GameAction.UP, GameAction.DOWN -> lastDirectionAxis = DirectionAxis.VERTICAL + GameAction.LEFT, GameAction.RIGHT -> lastDirectionAxis = DirectionAxis.HORIZONTAL + else -> Unit + } + } return snapshot( pauseMenuEdge = action == GameAction.PAUSE_MENU && !wasPressed && isPressed, newFastForward = if (action == GameAction.FAST_FORWARD && wasPressed != isPressed) isPressed else null, @@ -43,6 +52,11 @@ class InputRouter { fun current(): RoutedInputState = snapshot() + fun setEightDirectionEnabled(enabled: Boolean): RoutedInputState { + eightDirectionEnabled = enabled + return snapshot() + } + private fun snapshot( pauseMenuEdge: Boolean = false, newFastForward: Boolean? = null, @@ -53,10 +67,19 @@ class InputRouter { else -> null } fastForward = actualFastForward - val up = pressed(GameAction.UP) && !pressed(GameAction.DOWN) - val down = pressed(GameAction.DOWN) && !pressed(GameAction.UP) - val left = pressed(GameAction.LEFT) && !pressed(GameAction.RIGHT) - val right = pressed(GameAction.RIGHT) && !pressed(GameAction.LEFT) + var up = pressed(GameAction.UP) && !pressed(GameAction.DOWN) + var down = pressed(GameAction.DOWN) && !pressed(GameAction.UP) + var left = pressed(GameAction.LEFT) && !pressed(GameAction.RIGHT) + var right = pressed(GameAction.RIGHT) && !pressed(GameAction.LEFT) + if (!eightDirectionEnabled && (up || down) && (left || right)) { + if (lastDirectionAxis == DirectionAxis.HORIZONTAL) { + up = false + down = false + } else { + left = false + right = false + } + } var mask = 0 if (pressed(GameAction.NES_B)) mask = mask or (1 shl 0) if (pressed(GameAction.SELECT)) mask = mask or (1 shl 2) @@ -74,6 +97,8 @@ class InputRouter { private fun pressed(action: GameAction): Boolean = sourcesByAction.getValue(action).isNotEmpty() private fun currentFastForward(): Boolean = pressed(GameAction.FAST_FORWARD) + + private enum class DirectionAxis { HORIZONTAL, VERTICAL } } data class AxisTransition(val source: InputSource, val pressed: Boolean) diff --git a/app/src/main/java/org/neslite/app/input/VirtualDpadResolver.kt b/app/src/main/java/org/neslite/app/input/VirtualDpadResolver.kt new file mode 100644 index 0000000..92a7c5f --- /dev/null +++ b/app/src/main/java/org/neslite/app/input/VirtualDpadResolver.kt @@ -0,0 +1,48 @@ +package org.neslite.app.input + +import kotlin.math.abs +import kotlin.math.hypot + +enum class DirectionMode { FOUR_WAY, EIGHT_WAY } + +class VirtualDpadResolver( + private val neutralRatio: Float = 0.15f, + private val directionHoldBias: Float = 1.25f, +) { + init { + require(neutralRatio in 0f..<1f) + require(directionHoldBias >= 1f) + } + + fun resolve( + dx: Float, + dy: Float, + outerRadius: Float, + mode: DirectionMode, + previous: Set = emptySet(), + ): Set { + if (outerRadius <= 0f || hypot(dx, dy) > outerRadius) return emptySet() + if (hypot(dx, dy) <= outerRadius * neutralRatio) return emptySet() + + val horizontal = if (dx < 0f) GameAction.LEFT else GameAction.RIGHT + val vertical = if (dy < 0f) GameAction.UP else GameAction.DOWN + val heldHorizontal = previous.singleOrNull { it == GameAction.LEFT || it == GameAction.RIGHT } + val heldVertical = previous.singleOrNull { it == GameAction.UP || it == GameAction.DOWN } + val weightedX = abs(dx) * if (heldHorizontal == horizontal) directionHoldBias else 1f + val weightedY = abs(dy) * if (heldVertical == vertical) directionHoldBias else 1f + + if (mode == DirectionMode.FOUR_WAY) { + return setOf(if (weightedX >= weightedY) horizontal else vertical) + } + + return when { + weightedX > weightedY * EIGHT_WAY_CARDINAL_RATIO -> setOf(horizontal) + weightedY > weightedX * EIGHT_WAY_CARDINAL_RATIO -> setOf(vertical) + else -> linkedSetOf(horizontal, vertical) + } + } + + private companion object { + const val EIGHT_WAY_CARDINAL_RATIO = 2.4142137f + } +} diff --git a/app/src/main/java/org/neslite/app/input/VirtualInputTracker.kt b/app/src/main/java/org/neslite/app/input/VirtualInputTracker.kt index fd13cba..ea8dd08 100644 --- a/app/src/main/java/org/neslite/app/input/VirtualInputTracker.kt +++ b/app/src/main/java/org/neslite/app/input/VirtualInputTracker.kt @@ -3,25 +3,31 @@ package org.neslite.app.input data class VirtualInputTransition(val pointerId: Int, val action: GameAction, val pressed: Boolean) class VirtualInputTracker { - private val active = mutableMapOf() + private val active = mutableMapOf>() - fun update(pointerId: Int, action: GameAction?): List { - val previous = active[pointerId] - if (previous == action) return emptyList() - val transitions = mutableListOf() - if (previous != null) transitions += VirtualInputTransition(pointerId, previous, false) - if (action == null) active.remove(pointerId) else { - active[pointerId] = action - transitions += VirtualInputTransition(pointerId, action, true) + fun update(pointerId: Int, action: GameAction?): List = + update(pointerId, action?.let(::setOf).orEmpty()) + + fun update(pointerId: Int, actions: Set): List { + val previous = active[pointerId].orEmpty() + if (previous == actions) return emptyList() + val transitions = buildList { + (previous - actions).forEach { add(VirtualInputTransition(pointerId, it, false)) } + (actions - previous).forEach { add(VirtualInputTransition(pointerId, it, true)) } } + if (actions.isEmpty()) active.remove(pointerId) else active[pointerId] = actions.toSet() return transitions } fun clear(): List { - val transitions = active.map { (pointerId, action) -> VirtualInputTransition(pointerId, action, false) } + val transitions = active.flatMap { (pointerId, actions) -> + actions.map { action -> VirtualInputTransition(pointerId, action, false) } + } active.clear() return transitions } - fun activeActions(): Set = active.values.toSet() + fun activeActions(): Set = active.values.flatten().toSet() + + fun actionsFor(pointerId: Int): Set = active[pointerId].orEmpty() } diff --git a/app/src/main/java/org/neslite/app/settings/AppSettingsStore.kt b/app/src/main/java/org/neslite/app/settings/AppSettingsStore.kt index 2697d4d..3269c32 100644 --- a/app/src/main/java/org/neslite/app/settings/AppSettingsStore.kt +++ b/app/src/main/java/org/neslite/app/settings/AppSettingsStore.kt @@ -6,11 +6,26 @@ import androidx.datastore.preferences.core.Preferences import androidx.datastore.preferences.core.booleanPreferencesKey import androidx.datastore.preferences.core.edit import androidx.datastore.preferences.core.floatPreferencesKey +import androidx.datastore.preferences.core.intPreferencesKey import androidx.datastore.preferences.preferencesDataStore import kotlinx.coroutines.flow.first +import org.neslite.app.input.DirectionMode private val Context.appSettingsDataStore: DataStore by preferencesDataStore(name = "app_settings") +enum class VirtualDpadSize(val label: String, val scale: Float) { + STANDARD("标准", 1.00f), + LARGE("大", 1.18f), + EXTRA_LARGE("特大", 1.35f), + ; + + fun next(): VirtualDpadSize = entries[(ordinal + 1) % entries.size] + + companion object { + fun fromStored(value: Int): VirtualDpadSize = entries.getOrElse(value) { LARGE } + } +} + data class AppSettings( val integerScale: Boolean = false, val linearFilter: Boolean = false, @@ -19,6 +34,10 @@ data class AppSettings( val turboEnabled: Boolean = true, val fastForwardEnabled: Boolean = true, val showVirtualGamepadWithController: Boolean = true, + val directionMode: DirectionMode = DirectionMode.EIGHT_WAY, + val virtualDpadSize: VirtualDpadSize = VirtualDpadSize.LARGE, + val virtualDpadHorizontalOffset: Float = 0f, + val virtualDpadVerticalOffset: Float = 0f, val guideCompleted: Boolean = false, ) @@ -38,6 +57,12 @@ class AppSettingsStore(private val context: Context) { turboEnabled = values[TURBO] ?: true, fastForwardEnabled = values[FAST_FORWARD] ?: true, showVirtualGamepadWithController = values[SHOW_VIRTUAL_GAMEPAD_WITH_CONTROLLER] ?: true, + directionMode = DirectionMode.entries.getOrElse(values[DIRECTION_MODE] ?: DirectionMode.EIGHT_WAY.ordinal) { + DirectionMode.EIGHT_WAY + }, + virtualDpadSize = VirtualDpadSize.fromStored(values[VIRTUAL_DPAD_SIZE] ?: VirtualDpadSize.LARGE.ordinal), + virtualDpadHorizontalOffset = (values[VIRTUAL_DPAD_HORIZONTAL_OFFSET] ?: 0f).coerceIn(-1f, 1f), + virtualDpadVerticalOffset = (values[VIRTUAL_DPAD_VERTICAL_OFFSET] ?: 0f).coerceIn(-1f, 1f), guideCompleted = values[GUIDE_COMPLETED] ?: false, ) } @@ -51,6 +76,10 @@ class AppSettingsStore(private val context: Context) { values[TURBO] = settings.turboEnabled values[FAST_FORWARD] = settings.fastForwardEnabled values[SHOW_VIRTUAL_GAMEPAD_WITH_CONTROLLER] = settings.showVirtualGamepadWithController + values[DIRECTION_MODE] = settings.directionMode.ordinal + values[VIRTUAL_DPAD_SIZE] = settings.virtualDpadSize.ordinal + values[VIRTUAL_DPAD_HORIZONTAL_OFFSET] = settings.virtualDpadHorizontalOffset.coerceIn(-1f, 1f) + values[VIRTUAL_DPAD_VERTICAL_OFFSET] = settings.virtualDpadVerticalOffset.coerceIn(-1f, 1f) values[GUIDE_COMPLETED] = settings.guideCompleted } } @@ -64,6 +93,10 @@ class AppSettingsStore(private val context: Context) { private val FAST_FORWARD = booleanPreferencesKey("fast_forward_enabled") private val SHOW_VIRTUAL_GAMEPAD_WITH_CONTROLLER = booleanPreferencesKey("show_virtual_gamepad_with_controller") + private val DIRECTION_MODE = intPreferencesKey("direction_mode") + private val VIRTUAL_DPAD_SIZE = intPreferencesKey("virtual_dpad_size") + private val VIRTUAL_DPAD_HORIZONTAL_OFFSET = floatPreferencesKey("virtual_dpad_horizontal_offset") + private val VIRTUAL_DPAD_VERTICAL_OFFSET = floatPreferencesKey("virtual_dpad_vertical_offset") private val GUIDE_COMPLETED = booleanPreferencesKey("guide_completed") } } diff --git a/app/src/test/java/org/neslite/app/BuildIdentityTest.kt b/app/src/test/java/org/neslite/app/BuildIdentityTest.kt index 1eadfb4..b8641c3 100644 --- a/app/src/test/java/org/neslite/app/BuildIdentityTest.kt +++ b/app/src/test/java/org/neslite/app/BuildIdentityTest.kt @@ -7,7 +7,7 @@ class BuildIdentityTest { @Test fun debugBuildUsesTheDocumentedIdentity() { assertEquals("org.neslite.app.debug", BuildConfig.APPLICATION_ID) - assertEquals("0.9.10-debug", BuildConfig.VERSION_NAME) - assertEquals(9010, BuildConfig.VERSION_CODE) + assertEquals("0.9.11-debug", BuildConfig.VERSION_NAME) + assertEquals(9011, BuildConfig.VERSION_CODE) } } diff --git a/app/src/test/java/org/neslite/app/VirtualGamepadLayoutTest.kt b/app/src/test/java/org/neslite/app/VirtualGamepadLayoutTest.kt index 2e06895..81217c9 100644 --- a/app/src/test/java/org/neslite/app/VirtualGamepadLayoutTest.kt +++ b/app/src/test/java/org/neslite/app/VirtualGamepadLayoutTest.kt @@ -13,9 +13,9 @@ class VirtualGamepadLayoutTest { val gameWidth = minOf(width, height * 4f / 3f) val sideWidth = (width - gameWidth) / 2f val previousPrimaryRadius = minOf(height * 0.095f, sideWidth * 0.16f, 126f) - val geometry = computeVirtualGamepadGeometry(width, height, maxRadius = 126f) + val geometry = computeVirtualGamepadGeometry(width, height, maxRadius = 126f, dpadScale = 1.18f) - assertEquals(previousPrimaryRadius * 1.50f, geometry.up.radius, 0.01f) + assertEquals(previousPrimaryRadius * 1.50f * 1.18f, geometry.up.radius, 0.01f) assertEquals(previousPrimaryRadius * 1.50f, geometry.faceA.radius, 0.01f) assertEquals(previousPrimaryRadius * 0.60f * 1.30f, geometry.select.radius, 0.01f) assertEquals(previousPrimaryRadius * 0.60f * 1.30f, geometry.start.radius, 0.01f) @@ -33,6 +33,7 @@ class VirtualGamepadLayoutTest { height = height, maxRadius = 126f, safeLeft = safeLeft, + dpadScale = 1.18f, ) val gameWidth = minOf(width - safeLeft, height * 4f / 3f) val centeredGameLeft = safeLeft + (width - safeLeft - gameWidth) / 2f @@ -100,6 +101,28 @@ class VirtualGamepadLayoutTest { assertTrue(controls.all { it.y - it.radius >= 0f && it.y + it.radius <= height }) } + @Test + fun extraLargeDpadPositionAdjustmentsCannotMoveItOffscreen() { + val width = 2760f + val height = 1256f + val positions = listOf(-1f to -1f, -1f to 1f, 1f to -1f, 1f to 1f) + + positions.forEach { (horizontal, vertical) -> + val geometry = computeVirtualGamepadGeometry( + width = width, + height = height, + maxRadius = 126f, + dpadScale = 1.35f, + dpadHorizontalOffset = horizontal, + dpadVerticalOffset = vertical, + ) + val dpadControls = listOf(geometry.up, geometry.down, geometry.left, geometry.right) + + assertTrue(dpadControls.all { it.x - it.radius >= 0f && it.x + it.radius <= width }) + assertTrue(dpadControls.all { it.y - it.radius >= 0f && it.y + it.radius <= height }) + } + } + private fun distance(first: VirtualControl, second: VirtualControl): Float = hypot(first.x - second.x, first.y - second.y) } diff --git a/app/src/test/java/org/neslite/app/input/InputRouterTest.kt b/app/src/test/java/org/neslite/app/input/InputRouterTest.kt index afbe1b9..af80ce9 100644 --- a/app/src/test/java/org/neslite/app/input/InputRouterTest.kt +++ b/app/src/test/java/org/neslite/app/input/InputRouterTest.kt @@ -30,6 +30,21 @@ class InputRouterTest { assertTrue(recovered.joypadMask and (1 shl 6) != 0) } + @Test + fun directionModeSupportsJoystickDiagonalsAndFourWayAxisLocking() { + val router = InputRouter() + val horizontal = InputSource(12, InputSourceKind.AXIS, 0, 1) + val vertical = InputSource(12, InputSourceKind.AXIS, 1, -1) + router.update(horizontal, GameAction.RIGHT, true) + val diagonal = router.update(vertical, GameAction.UP, true) + + assertTrue(diagonal.joypadMask and (1 shl 7) != 0) + assertTrue(diagonal.joypadMask and (1 shl 4) != 0) + val fourWay = router.setEightDirectionEnabled(false) + assertEquals(0, fourWay.joypadMask and (1 shl 7)) + assertTrue(fourWay.joypadMask and (1 shl 4) != 0) + } + @Test fun pauseAndFastCommandsOnlyChangeOnAggregateEdges() { val router = InputRouter() diff --git a/app/src/test/java/org/neslite/app/input/VirtualDpadResolverTest.kt b/app/src/test/java/org/neslite/app/input/VirtualDpadResolverTest.kt new file mode 100644 index 0000000..d49de18 --- /dev/null +++ b/app/src/test/java/org/neslite/app/input/VirtualDpadResolverTest.kt @@ -0,0 +1,38 @@ +package org.neslite.app.input + +import org.junit.Assert.assertEquals +import org.junit.Test + +class VirtualDpadResolverTest { + private val resolver = VirtualDpadResolver() + + @Test + fun fourWayChoosesOneDominantAxisAndHoldsTheCurrentDirectionNearBoundary() { + assertEquals( + setOf(GameAction.DOWN), + resolver.resolve(0.95f, 1f, 2f, DirectionMode.FOUR_WAY), + ) + assertEquals( + setOf(GameAction.RIGHT), + resolver.resolve(1f, 0.95f, 2f, DirectionMode.FOUR_WAY, setOf(GameAction.RIGHT)), + ) + } + + @Test + fun eightWayEmitsTwoDirectionsOnlyInsideDiagonalSectors() { + assertEquals( + linkedSetOf(GameAction.RIGHT, GameAction.UP), + resolver.resolve(1f, -1f, 2f, DirectionMode.EIGHT_WAY), + ) + assertEquals( + setOf(GameAction.RIGHT), + resolver.resolve(1.5f, -0.2f, 2f, DirectionMode.EIGHT_WAY), + ) + } + + @Test + fun centerAndOutsideTouchAreasAreNeutral() { + assertEquals(emptySet(), resolver.resolve(0.1f, 0.1f, 2f, DirectionMode.EIGHT_WAY)) + assertEquals(emptySet(), resolver.resolve(3f, 0f, 2f, DirectionMode.EIGHT_WAY)) + } +} diff --git a/app/src/test/java/org/neslite/app/input/VirtualInputTrackerTest.kt b/app/src/test/java/org/neslite/app/input/VirtualInputTrackerTest.kt index d6c6f70..4b1847f 100644 --- a/app/src/test/java/org/neslite/app/input/VirtualInputTrackerTest.kt +++ b/app/src/test/java/org/neslite/app/input/VirtualInputTrackerTest.kt @@ -48,4 +48,34 @@ class VirtualInputTrackerTest { assertTrue(router.update(touch, GameAction.NES_A, false).joypadMask and (1 shl 8) != 0) assertEquals(0, router.update(controller, GameAction.NES_A, false).joypadMask and (1 shl 8)) } + + @Test + fun onePointerCanHoldADiagonalAndReleaseOnlyOneDirection() { + val tracker = VirtualInputTracker() + tracker.update(4, linkedSetOf(GameAction.RIGHT, GameAction.UP)) + + assertEquals(setOf(GameAction.RIGHT, GameAction.UP), tracker.activeActions()) + assertEquals( + listOf(VirtualInputTransition(4, GameAction.UP, false)), + tracker.update(4, setOf(GameAction.RIGHT)), + ) + } + + @Test + fun separatePointersCanHoldAAndBAtTheSameTime() { + val tracker = VirtualInputTracker() + val router = InputRouter() + val transitions = tracker.update(1, GameAction.NES_A) + tracker.update(2, GameAction.NES_B) + var state = router.current() + transitions.forEach { transition -> + state = router.update( + InputSource(-1 - transition.pointerId, InputSourceKind.TOUCH, transition.action.ordinal), + transition.action, + transition.pressed, + ) + } + + assertTrue(state.joypadMask and (1 shl 8) != 0) + assertTrue(state.joypadMask and (1 shl 0) != 0) + } } diff --git a/app/src/test/java/org/neslite/app/settings/AppSettingsTest.kt b/app/src/test/java/org/neslite/app/settings/AppSettingsTest.kt index 3c1008c..8bd92bc 100644 --- a/app/src/test/java/org/neslite/app/settings/AppSettingsTest.kt +++ b/app/src/test/java/org/neslite/app/settings/AppSettingsTest.kt @@ -1,5 +1,6 @@ package org.neslite.app.settings +import org.neslite.app.input.DirectionMode import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue @@ -15,6 +16,10 @@ class AppSettingsTest { assertTrue(settings.turboEnabled) assertTrue(settings.fastForwardEnabled) assertTrue(settings.showVirtualGamepadWithController) + assertEquals(DirectionMode.EIGHT_WAY, settings.directionMode) + assertEquals(VirtualDpadSize.LARGE, settings.virtualDpadSize) + assertEquals(0f, settings.virtualDpadHorizontalOffset) + assertEquals(0f, settings.virtualDpadVerticalOffset) assertFalse(settings.guideCompleted) } diff --git a/docs/architecture.md b/docs/architecture.md index ac5cee6..a948f3d 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1,4 +1,4 @@ -# NESLite 架构(0.9.10 候选基线) +# NESLite 架构(0.9.11 候选基线) ## 边界与线程 @@ -101,7 +101,7 @@ DataStore 保存,渲染线程只读取整数缩放和过滤快照,音频及 按 pointerId 维护触摸来源并送入与物理手柄相同的 `InputRouter`,因此多来源去重、相反方向和释放规则 一致;取消、滑出、失焦与暂停清空所有虚拟来源。首次使用状态也存于设置 DataStore,不接触用户存档。 -0.9.10 将游戏入口收敛为单一横屏主画面:中央 `AspectRatioFrameLayout` 只按 4:3 测量,左右剩余安全 +0.9.11 将游戏入口收敛为单一横屏主画面:中央 `AspectRatioFrameLayout` 只按 4:3 测量,左右剩余安全 区域绘制虚拟手柄;左上角横排图标入口独立于游戏安全内边距,打开游戏列表、导入和设置的全屏页面。 方向键与 ABXY 的半径为原布局的 1.5 倍,Select、Start、暂停和重置为原布局的 1.3 倍。Magic8 横屏 安全区允许时,方向键、Select、4:3 画面、Start、暂停和重置整体左移一个 A 键直径,右侧扩展空间用于 @@ -109,6 +109,12 @@ DataStore 保存,渲染线程只读取整数缩放和过滤快照,音频及 连发动作;重置要求持续按住 650 ms。游戏页沉浸式隐藏系统栏,管理页恢复系统栏;页面打开前先等待 运行会话进入暂停态,页面关闭后不自动恢复,避免文件选择或设置过程中游戏在后台继续。 +屏幕方向键使用单一圆形触控域和互斥方向扇区,不再由四个重叠圆形命中区判定。中心 15% 为中立区, +有效触控半径比可见十字键大 30%,当前方向获得 25% 的切换迟滞,并在方向首次按下或切换时反馈。 +八方向模式允许一个触点同时持有横向和纵向,四方向模式保留最近明确输入的主轴;同一策略在统一 +`InputRouter` 中约束物理摇杆。多触点状态以动作集合保存,因此 A 与 B 可以同时按住。方向键大小、 +水平与垂直偏移存入 AppSettings DataStore。 + 手柄设置支持逐项向导和单项修改/清除。捕获目标动作后,物理 KeyEvent 或超过按下阈值的轴方向成为 该动作的唯一绑定;冲突必须由用户确认替换。轴捕获后必须先回到释放阈值内才进入下一项,防止同一 持续轴值误绑多个动作。草稿与正在使用的档案分离,仅保存成功后替换运行档案并按设备指纹持久化。 diff --git a/docs/build.md b/docs/build.md index 53a1d4c..f76a8c5 100644 --- a/docs/build.md +++ b/docs/build.md @@ -1,6 +1,6 @@ # NESLite 可复现构建说明 -本说明对应 0.9.10 候选基线。命令使用系统默认 PowerShell 7.6.6(`pwsh`)从仓库根目录执行;不需要手工复制 `.so`、 +本说明对应 0.9.11 候选基线。命令使用系统默认 PowerShell 7.6.6(`pwsh`)从仓库根目录执行;不需要手工复制 `.so`、 FCEUmm 或 Oboe 文件。 ## 前置条件 @@ -50,7 +50,7 @@ pwsh -NoProfile -ExecutionPolicy Bypass -File .\tools\package-rc.ps1 脚本重跑 Stage 和 release lint,生成 `org.neslite.app` 的未签名 release APK、完整原生符号、应用及 三个固定第三方依赖的源码包、许可证/说明、静态原生审计、候选清单和 SHA-256。输出位于 -`.build/rc-0.9.10/`。静态审计逐个检查 APK 内 `.so` 的 ELF LOAD 段和 APK 16 KB 对齐,并拒绝非 +`.build/rc-0.9.11/`。静态审计逐个检查 APK 内 `.so` 的 ELF LOAD 段和 APK 16 KB 对齐,并拒绝非 arm64-v8a 库。 默认 APK 刻意保持未签名;发布私钥和口令不得传入仓库或写入脚本。获得受保护的发布密钥后,在隔离 diff --git a/docs/controller-x5lite.md b/docs/controller-x5lite.md index a6270c8..5b70ee7 100644 --- a/docs/controller-x5lite.md +++ b/docs/controller-x5lite.md @@ -5,10 +5,13 @@ ABXY、视图/菜单键及左右肩键。随后在荣耀 Magic8 页面取得了 Android 设备身份和静态轴范围; 实际 KeyEvent、动态轴采样、手柄模式及拔出重连仍待诊断 JSON 回填。 -在 0.9.10-debug 中可从“设置 → 手动设置手柄按键、摇杆与功能键”进入编辑页。可选择“开始逐项手动 +在 0.9.11-debug 中可从“设置 → 手动设置手柄按键、摇杆与功能键”进入编辑页。可选择“开始逐项手动 设置全部按键”,按页面顺序操作 X5 Lite;也可点击任一动作单独修改或清除。轴方向捕获后先松回中位, 冲突时确认是否替换,最后点击“保存”。配置按下表设备指纹保存,不依赖临时 deviceId。 +“设置 → 屏幕方向键与手柄摇杆”可选择四方向或八方向。八方向允许摇杆同时上报一个横向和一个纵向; +四方向会保留最近明确输入的主轴,降低斜推误触。 + ## 固定测试条件 - 手柄模式:原生安卓模式,实际切换方法待随设备说明和实测确认。 diff --git a/docs/identity.md b/docs/identity.md index 75553c4..819c315 100644 --- a/docs/identity.md +++ b/docs/identity.md @@ -6,7 +6,7 @@ | --- | --- | | 显示名称 | `NESLite` | | 正式 application ID/namespace | `org.neslite.app` | -| 当前候选版本 | `0.9.10`,`versionCode = 9010` | +| 当前候选版本 | `0.9.11`,`versionCode = 9011` | | 调试 application ID | `org.neslite.app.debug` | | 发布 ABI | `arm64-v8a` | | min/target SDK | 28/36 | diff --git a/docs/known-issues.md b/docs/known-issues.md index c7bbe0d..bbaa2ab 100644 --- a/docs/known-issues.md +++ b/docs/known-issues.md @@ -1,6 +1,6 @@ # 已知问题与候选版限制 -本清单对应 0.9.10 候选源码。优先级含义:阻断表示 G8 不可通过;高表示发布前必须处理;中/低需有 +本清单对应 0.9.11 候选源码。优先级含义:阻断表示 G8 不可通过;高表示发布前必须处理;中/低需有 明确接受或修复结论。 | 编号 | 优先级 | 状态 | 问题与处理条件 | @@ -9,7 +9,7 @@ | RC-B02 | 阻断 | 开放 | 尚无满足动作/滚屏、声音和可观察电池进度要求的合法游戏样本;冻结的 12 个 CC0 最小样本只能用于加载冒烟。 | | RC-B03 | 阻断 | 开放 | H-LONG、H-INPUT、4 KB/16 KB 运行、API 28 冒烟及 H-UPGRADE 尚未在设备执行。 | | RC-B04 | 阻断 | 开放 | 尚未提供受保护的发布签名密钥及同 ID/同签名旧版数据集;当前 RC 静态审计包为未签名 APK。 | -| RC-M01 | 中 | 开放 | Debug lint 有 45 个非阻断警告,主要是动态界面文本国际化、依赖版本提示和 Android 16 固定横屏兼容提醒;无 lint 错误。 | +| RC-M01 | 中 | 开放 | Debug lint 有 46 个非阻断警告,主要是动态界面文本国际化、依赖版本提示和 Android 16 固定横屏兼容提醒;无 lint 错误。 | 不得通过删除失败 ROM、缩短规定轮数/时长、用 x86_64 替代 arm64,或用桌面原生测试替代 Android 实机运行来关闭阻断项。每项关闭时应在 M8 报告登记设备、包哈希、ROM 哈希、命令、原始日志和结论。 diff --git a/docs/reports/m8-release-candidate.md b/docs/reports/m8-release-candidate.md index 1ca194e..b4d9ba9 100644 --- a/docs/reports/m8-release-candidate.md +++ b/docs/reports/m8-release-candidate.md @@ -1,7 +1,7 @@ # M8 0.9.4 发布候选记录 -> 此文件保留 0.9.4 的历史候选证据。0.9.10 改动了主界面、触屏与手柄输入路径和页面/会话交接,不能 -> 直接继承本记录作为最终 G8 结论;完成 Magic8 实机复核后需生成新的 0.9.10 候选记录。 +> 此文件保留 0.9.4 的历史候选证据。0.9.11 改动了主界面、触屏与手柄输入路径和页面/会话交接,不能 +> 直接继承本记录作为最终 G8 结论;完成 Magic8 实机复核后需生成新的 0.9.11 候选记录。 日期:2026-09-12 diff --git a/docs/usage.md b/docs/usage.md index 060f7cf..8374d32 100644 --- a/docs/usage.md +++ b/docs/usage.md @@ -12,6 +12,8 @@ 4. 点左上角“设置”图标可切换 4:3/整数缩放、最近邻/线性过滤、音量、静音、软件连发和 RB 快进。进入 “手动设置手柄按键、摇杆与功能键”后,可启动逐项向导,也可单独点击动作修改或清除;按下物理键 或推动轴完成捕获,检查无误后点“保存”。冲突会要求确认,设置按设备特征在重启和重连后恢复。 + “屏幕方向键与手柄摇杆”可切换四方向/八方向,并循环选择标准、大、特大方向键;两个位置滑块可 + 调整方向键的水平和垂直位置。默认八方向与大号,A、B 支持两根手指同时按住。 5. 游戏中点右侧“暂停”或按手柄右摇杆进入暂停菜单;“重置”需要持续按住约 650 ms,滑出会取消。 “存档管理”显示十个手动槽、三个自动恢复点、 提交时间和缩略图。只有原生层确认安全落盘后才显示保存成功。 diff --git a/tools/package-rc.ps1 b/tools/package-rc.ps1 index 6bec131..6c4d9d4 100644 --- a/tools/package-rc.ps1 +++ b/tools/package-rc.ps1 @@ -14,8 +14,8 @@ $env:JAVA_HOME = if ($env:JAVA_HOME -and (Test-Path (Join-Path $env:JAVA_HOME 'b } $env:ANDROID_HOME = $sdkRoot $env:ANDROID_SDK_ROOT = $sdkRoot -$versionName = '0.9.10' -$versionCode = 9010 +$versionName = '0.9.11' +$versionCode = 9011 $gitStatus = @(& git -C $root status --porcelain) if ($LASTEXITCODE -ne 0) { throw 'Cannot inspect the Git worktree.' } if ($gitStatus.Count -ne 0) { throw 'RC packaging requires a clean committed worktree.' }