Merge pull request #1392 from ZalithLauncher/main

merge main

Author: MovTery

.github/workflows/release_ci.yml

@@ -37,18 +37,17 @@ jobs:
           
           find ./artifacts -name "*.apk" -type f -exec cp {} ./apks/ \;
           
-          # 检查是否有APK文件
-          if [ -z "$(ls -A ./apks/)" ]; then
-            echo "No APK files found to upload!"
-            exit 1
-          fi
+          for dir in ./artifacts/*/; do
+            dir_name=$(basename "$dir")
           
-          # 处理映射文件 区分架构
-          for mapping_dir in ./artifacts/mapping\ \(*\)/; do
-            if [ -d "$mapping_dir" ] && [ -f "${mapping_dir}mapping.txt" ]; then
-              dirname=$(basename "$mapping_dir")
-              cp "${mapping_dir}mapping.txt" "./mappings/${dirname}.txt"
-              echo "Copied: ${dirname}.txt"
+            # 跳过 APK
+            if [[ "$dir_name" == *"release apk"* ]]; then
+              continue
+            fi
+          
+            if [[ "$dir_name" == mapping* ]]; then
+              (cd "$dir" && zip -r "../${dir_name}.zip" .)
+              mv "./artifacts/${dir_name}.zip" ./mappings/
             fi
           done
           
@@ -61,5 +60,5 @@ jobs:
           tag_name: ${{ github.event.release.tag_name }}
           files: |
             ./apks/*.apk
-            ./mappings/*.txt
+            ./mappings/*.zip
           fail_on_unmatched_files: true

LayerController/src/main/java/com/movtery/layer_controller/Layout.kt

@@ -31,7 +31,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
-import androidx.compose.runtime.mutableStateMapOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Alignment
@@ -56,6 +55,8 @@ import com.movtery.layer_controller.observable.ObservableButtonStyle
 import com.movtery.layer_controller.observable.ObservableControlLayer
 import com.movtery.layer_controller.observable.ObservableControlLayout
 import com.movtery.layer_controller.observable.ObservableWidget
+import com.movtery.layer_controller.observable.TouchProcessor
+import com.movtery.layer_controller.observable.TouchSession
 import com.movtery.layer_controller.utils.getWidgetPosition
 
 /**
@@ -143,7 +144,6 @@ private fun BoxWithConstraintsScope.BaseControlBoxLayout(
     val reversedLayers = remember(layers) { layers.reversed() }
     val styles by observedLayout.styles.collectAsStateWithLifecycle()
 
-    val allActiveWidgets = remember { mutableStateMapOf<PointerId, List<ObservableWidget>>() }
     val currentCheckOccupiedPointers by rememberUpdatedState(checkOccupiedPointers)
     val currentIsCursorGrabbing by rememberUpdatedState(isCursorGrabbing)
     val currentHideLayerWhen by rememberUpdatedState(hideLayerWhen)
@@ -158,6 +158,14 @@ private fun BoxWithConstraintsScope.BaseControlBoxLayout(
         }
     }
 
+    //触控管线
+    val touchSession = remember { TouchSession() }
+    val touchProcessor = remember(screenSize) {
+        TouchProcessor(eventHandler) { widget ->
+            getWidgetPosition(widget, widget.internalRenderSize, screenSize)
+        }
+    }
+
     Box(
         modifier = modifier
             .pointerInput(reversedLayers, hideLayerWhen) {
@@ -166,140 +174,36 @@ private fun BoxWithConstraintsScope.BaseControlBoxLayout(
                         val event = awaitPointerEvent(pass = PointerEventPass.Initial)
 
                         event.changes.forEach { change ->
-                            val position = change.position
                             val pointerId = change.id
-                            val isPressed = change.pressed
-
-                            //抬起时，总是尝试释放该指针下活跃的按钮
-                            //避免子级占用了指针后，导致按钮状态无法被释放
-                            if (!isPressed) {
-                                allActiveWidgets.remove(pointerId)?.forEach { widget ->
+                            //手指抬起，清理该指针所有状态
+                            if (!change.pressed) {
+                                touchSession.endPointer(pointerId).forEach { widget ->
+                                    //释放该指针事件
                                     widget.onReleaseEvent(eventHandler, reversedLayers)
                                 }
                                 return@forEach
                             }
 
-                            if (
-                                change.isConsumed ||
-                                //不处理被子级占用的指针
-                                currentCheckOccupiedPointers(pointerId)
-                            ) {
-                                return@forEach
+                            if (change.isConsumed || currentCheckOccupiedPointers(pointerId)) {
+                                return@forEach //跳过已消费或被占用的指针
                             }
 
-                            //在可见控件层中，收集所有可见的按钮
-                            val visibleWidgets: List<ObservableWidget> = layers //使用原始控件层顺序，保证触摸逻辑正常
-                                .filter { layer ->
-                                    checkLayerVisibility(
-                                        layer = layer,
-                                        hideLayerWhen = currentHideLayerWhen,
-                                        isUsingJoystick = isUsingJoystick,
-                                        isCursorGrabbing = currentIsCursorGrabbing,
-                                        visibilityType = layer.visibilityType
-                                    )
-                                }
-                                .flatMap { layer ->
-                                    //顶向下的顺序影响控件层的处理优先级
-                                    layer.normalButtons.value.reversed()
-                                }
-
-                            //查找当前指针在哪些按钮上
-                            val targetWidgets = visibleWidgets
-                                .filter { widget ->
-                                    if (!widget.canTouch()) return@filter false
-
-                                    if (!checkVisibility(currentIsCursorGrabbing, widget.onCheckVisibilityType())) {
-                                        //隐藏了，不响应事件
-                                        return@filter false
-                                    }
-
-                                    val size = widget.internalRenderSize
-                                    val offset = getWidgetPosition(widget, size, screenSize)
-
-                                    val x = position.x
-                                    val y = position.y
-                                    x >= offset.x && x <= offset.x + size.width &&
-                                            y >= offset.y && y <= offset.y + size.height
-                                }.let { list ->
-                                    if (list.isEmpty()) return@let list
-
-                                    val firstDeepWidget = list.firstOrNull { it.supportsDeepTouchDetection() }
-
-                                    when {
-                                        firstDeepWidget == null -> list
-                                        else -> {
-                                            val topIndex = list.indexOf(firstDeepWidget)
-                                            list.subList(0, topIndex + 1).filter { widget ->
-                                                !widget.canProcess()
-                                            }
-                                        }
-                                    }
-                                }
-
-                            var activeWidgets = allActiveWidgets[pointerId] ?: emptyList()
-
-                            //检查是否移出边界
-                            if (activeWidgets.isNotEmpty()) {
-                                val backInBounds = mutableListOf<ObservableWidget>()
-                                val releasedWidgets = mutableListOf<ObservableWidget>()
-                                for (widget in activeWidgets) {
-                                    //检查组件是否可以响应移除边界即松开
-                                    if (!widget.isReleaseOnOutOfBounds()) continue
-
-                                    val size = widget.internalRenderSize
-                                    val offset = getWidgetPosition(widget, size, screenSize)
-                                    val isOutOfBounds = position.x !in offset.x..(offset.x + size.width) ||
-                                            position.y !in offset.y..(offset.y + size.height)
-
-                                    if (isOutOfBounds) {
-                                        widget.onReleaseEvent(eventHandler, reversedLayers)
-                                        releasedWidgets.add(widget)
-                                    } else {
-                                        backInBounds.add(widget)
-                                    }
-                                }
-                                //fix: 移出边界时应移出组，否则滑动回已释放的按钮无法再次触发
-                                if (releasedWidgets.isNotEmpty()) {
-                                    activeWidgets = activeWidgets - releasedWidgets
-                                    allActiveWidgets[pointerId] = activeWidgets
-                                }
-                                //fix: 应该在抬起事件全部处理完成后再处理 #941
-                                if (backInBounds.isNotEmpty()) {
-                                    for (widget in backInBounds) {
-                                        widget.onPointerBackInBounds(eventHandler, reversedLayers)
-                                    }
-                                }
-                            }
-
-                            when {
-                                targetWidgets.isEmpty() -> {}
-                                else -> {
-                                    for (targetWidget in targetWidgets) {
-                                        if (targetWidget.canProcess()) {
-                                            return@forEach //拒绝处理该事件
-                                        }
-
-                                        targetWidget.onTouchEvent(
-                                            eventHandler = eventHandler,
-                                            allLayers = reversedLayers,
-                                            change = change,
-                                            activeWidgets = activeWidgets,
-                                            addThis = {
-                                                allActiveWidgets[pointerId] = activeWidgets + listOf(targetWidget)
-                                            },
-                                            consumeEvent = { value ->
-                                                if (value) {
-                                                    change.consume()
-                                                } else {
-                                                    //将指针标记为仅接受滑动处理
-                                                    //期望子级不对点击事件等进行处理
-                                                    markPointerAsMoveOnly(pointerId)
-                                                }
-                                            }
-                                        )
-                                    }
-                                }
-                            }
+                            //收集可见控件
+                            val visibleWidgets = collectVisibleWidgets(
+                                layers = layers,
+                                hideLayerWhen = currentHideLayerWhen,
+                                isUsingJoystick = isUsingJoystick,
+                                isCursorGrabbing = currentIsCursorGrabbing,
+                            )
+
+                            touchProcessor.processFrame(
+                                session = touchSession,
+                                change = change,
+                                visibleWidgets = visibleWidgets,
+                                allLayers = reversedLayers,
+                                consumeEvent = { it.consume() },
+                                markPointerAsMoveOnly = markPointerAsMoveOnly,
+                            )
                         }
                     }
                 }
@@ -421,6 +325,38 @@ private fun ControlsRendererLayer(
     }
 }
 
+/**
+ * 收集所有可见控件层中的可触控控件
+ * 只做图层可见性、控件可见类型检查，命中和深度检测由 [TouchProcessor] 提供
+ */
+private fun collectVisibleWidgets(
+    layers: List<ObservableControlLayer>,
+    hideLayerWhen: HideLayerWhen,
+    isUsingJoystick: Boolean,
+    isCursorGrabbing: Boolean,
+): List<ObservableWidget> {
+    return layers
+        .filter { layer ->
+            checkLayerVisibility(
+                layer = layer,
+                hideLayerWhen = hideLayerWhen,
+                isUsingJoystick = isUsingJoystick,
+                isCursorGrabbing = isCursorGrabbing,
+                visibilityType = layer.visibilityType,
+            )
+        }
+        .flatMap { layer ->
+            //反转，从顶到底
+            layer.normalButtons.value.reversed()
+        }
+        .filter { widget ->
+            widget.canTouch() && checkVisibility(
+                isCursorGrabbing = isCursorGrabbing,
+                visibilityType = widget.onCheckVisibilityType()
+            )
+        }
+}
+
 private fun checkLayerVisibility(
     layer: ObservableControlLayer,
     hideLayerWhen: HideLayerWhen,

LayerController/src/main/java/com/movtery/layer_controller/layout/Buttons.kt

@@ -37,7 +37,12 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.movtery.layer_controller.data.TextAlignment
 import com.movtery.layer_controller.event.EventHandler
-import com.movtery.layer_controller.observable.*
+import com.movtery.layer_controller.observable.DefaultObservableButtonStyle
+import com.movtery.layer_controller.observable.ObservableButtonStyle
+import com.movtery.layer_controller.observable.ObservableNormalData
+import com.movtery.layer_controller.observable.ObservableTextData
+import com.movtery.layer_controller.observable.ObservableTranslatableString
+import com.movtery.layer_controller.observable.ObservableWidget
 import com.movtery.layer_controller.utils.buttonContentColorAsState
 import com.movtery.layer_controller.utils.buttonFontSizeAsState
 import com.movtery.layer_controller.utils.buttonSize

LayerController/src/main/java/com/movtery/layer_controller/observable/InteractionBehavior.kt

@@ -0,0 +1,79 @@
+/*
+ * Zalith Launcher 2
+ * Copyright (C) 2025 MovTery <movtery228@qq.com> and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
+ */
+
+package com.movtery.layer_controller.observable
+
+/**
+ * 控件的交互行为模型
+ */
+sealed class InteractionBehavior {
+    /**
+     * 手指移出控件边界时是否自动释放
+     */
+    abstract val releaseOnOutOfBounds: Boolean
+
+    /**
+     * 是否允许其他控件的指针滑动进入本控件
+     */
+    abstract val canBeSwipedTo: Boolean
+
+    /**
+     * 当本控件处于活跃状态时，是否阻止滑动链向其他控件传播
+     */
+    abstract val blocksSwipeChain: Boolean
+
+
+
+    /**
+     * 普通按钮
+     * 按下保持，松开释放，不参与滑动联动
+     */
+    data object Press : InteractionBehavior() {
+        override val releaseOnOutOfBounds: Boolean get() = false
+        override val canBeSwipedTo: Boolean get() = false
+        override val blocksSwipeChain: Boolean get() = false
+    }
+
+    /**
+     * 可滑动按钮
+     * 移出边界自动释放，支持滑动联动
+     */
+    data object Swipable : InteractionBehavior() {
+        override val releaseOnOutOfBounds: Boolean get() = true
+        override val canBeSwipedTo: Boolean get() = true
+        override val blocksSwipeChain: Boolean get() = false
+    }
+
+    /**
+     * 可切换按钮：
+     * 点击切换开/关，不可滑动联动,活跃时阻止滑动链传播
+     */
+    data object Toggle : InteractionBehavior() {
+        override val releaseOnOutOfBounds: Boolean get() = false
+        override val canBeSwipedTo: Boolean get() = false
+        override val blocksSwipeChain: Boolean get() = true
+    }
+
+    companion object {
+        fun from(isSwipple: Boolean, isToggleable: Boolean): InteractionBehavior = when {
+            isToggleable -> Toggle
+            isSwipple -> Swipable
+            else -> Press
+        }
+    }
+}