,
149 | condition: (AccessibilityNodeInfo) -> Boolean
150 | ) {
151 | // 检查当前节点
152 | if (condition(node)) {
153 | results.add(node)
154 | }
155 | // 递归检查子节点
156 | for (i in 0 until node.childCount) {
157 | val child = node.getChild(i) ?: continue
158 | findAllNodesRecursively(child, results, condition)
159 | }
160 | }
161 |
162 |
163 | /**
164 | * 🐾 调试用：打印节点树结构
165 | */
166 | fun debugNodeTree(
167 | node: AccessibilityNodeInfo?,
168 | maxDepth: Int = 5,
169 | currentDepth: Int = 0,
170 | ) {
171 | if (node == null || currentDepth > maxDepth) return
172 |
173 | val indent = " ".repeat(currentDepth)
174 | val className = node.className?.toString() ?: "null"
175 | val text = node.text?.toString()?.take(20) ?: ""
176 | val desc = node.contentDescription?.toString()?.take(20) ?: ""
177 |
178 | Log.d(TAG, "$indent[$currentDepth] $className | ID: ${node.viewIdResourceName}")
179 | if (text.isNotEmpty()) Log.d(TAG, "$indent 文本: '$text'")
180 | if (desc.isNotEmpty()) Log.d(TAG, "$indent 描述: '$desc'")
181 | }
182 |
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env sh
2 |
3 | #
4 | # Copyright 2015 the original author or authors.
5 | #
6 | # Licensed under the Apache License, Version 2.0 (the "License");
7 | # you may not use this file except in compliance with the License.
8 | # You may obtain a copy of the License at
9 | #
10 | # https://www.apache.org/licenses/LICENSE-2.0
11 | #
12 | # Unless required by applicable law or agreed to in writing, software
13 | # distributed under the License is distributed on an "AS IS" BASIS,
14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | # See the License for the specific language governing permissions and
16 | # limitations under the License.
17 | #
18 |
19 | ##############################################################################
20 | ##
21 | ## Gradle start up script for UN*X
22 | ##
23 | ##############################################################################
24 |
25 | # Attempt to set APP_HOME
26 | # Resolve links: $0 may be a link
27 | PRG="$0"
28 | # Need this for relative symlinks.
29 | while [ -h "$PRG" ] ; do
30 | ls=`ls -ld "$PRG"`
31 | link=`expr "$ls" : '.*-> \(.*\)$'`
32 | if expr "$link" : '/.*' > /dev/null; then
33 | PRG="$link"
34 | else
35 | PRG=`dirname "$PRG"`"/$link"
36 | fi
37 | done
38 | SAVED="`pwd`"
39 | cd "`dirname \"$PRG\"`/" >/dev/null
40 | APP_HOME="`pwd -P`"
41 | cd "$SAVED" >/dev/null
42 |
43 | APP_NAME="Gradle"
44 | APP_BASE_NAME=`basename "$0"`
45 |
46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
48 |
49 | # Use the maximum available, or set MAX_FD != -1 to use that value.
50 | MAX_FD="maximum"
51 |
52 | warn () {
53 | echo "$*"
54 | }
55 |
56 | die () {
57 | echo
58 | echo "$*"
59 | echo
60 | exit 1
61 | }
62 |
63 | # OS specific support (must be 'true' or 'false').
64 | cygwin=false
65 | msys=false
66 | darwin=false
67 | nonstop=false
68 | case "`uname`" in
69 | CYGWIN* )
70 | cygwin=true
71 | ;;
72 | Darwin* )
73 | darwin=true
74 | ;;
75 | MINGW* )
76 | msys=true
77 | ;;
78 | NONSTOP* )
79 | nonstop=true
80 | ;;
81 | esac
82 |
83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
84 |
85 |
86 | # Determine the Java command to use to start the JVM.
87 | if [ -n "$JAVA_HOME" ] ; then
88 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
89 | # IBM's JDK on AIX uses strange locations for the executables
90 | JAVACMD="$JAVA_HOME/jre/sh/java"
91 | else
92 | JAVACMD="$JAVA_HOME/bin/java"
93 | fi
94 | if [ ! -x "$JAVACMD" ] ; then
95 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
96 |
97 | Please set the JAVA_HOME variable in your environment to match the
98 | location of your Java installation."
99 | fi
100 | else
101 | JAVACMD="java"
102 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
103 |
104 | Please set the JAVA_HOME variable in your environment to match the
105 | location of your Java installation."
106 | fi
107 |
108 | # Increase the maximum file descriptors if we can.
109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
110 | MAX_FD_LIMIT=`ulimit -H -n`
111 | if [ $? -eq 0 ] ; then
112 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
113 | MAX_FD="$MAX_FD_LIMIT"
114 | fi
115 | ulimit -n $MAX_FD
116 | if [ $? -ne 0 ] ; then
117 | warn "Could not set maximum file descriptor limit: $MAX_FD"
118 | fi
119 | else
120 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
121 | fi
122 | fi
123 |
124 | # For Darwin, add options to specify how the application appears in the dock
125 | if $darwin; then
126 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
127 | fi
128 |
129 | # For Cygwin or MSYS, switch paths to Windows format before running java
130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
131 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
132 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
133 |
134 | JAVACMD=`cygpath --unix "$JAVACMD"`
135 |
136 | # We build the pattern for arguments to be converted via cygpath
137 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
138 | SEP=""
139 | for dir in $ROOTDIRSRAW ; do
140 | ROOTDIRS="$ROOTDIRS$SEP$dir"
141 | SEP="|"
142 | done
143 | OURCYGPATTERN="(^($ROOTDIRS))"
144 | # Add a user-defined pattern to the cygpath arguments
145 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
146 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
147 | fi
148 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
149 | i=0
150 | for arg in "$@" ; do
151 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
152 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
153 |
154 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
155 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
156 | else
157 | eval `echo args$i`="\"$arg\""
158 | fi
159 | i=`expr $i + 1`
160 | done
161 | case $i in
162 | 0) set -- ;;
163 | 1) set -- "$args0" ;;
164 | 2) set -- "$args0" "$args1" ;;
165 | 3) set -- "$args0" "$args1" "$args2" ;;
166 | 4) set -- "$args0" "$args1" "$args2" "$args3" ;;
167 | 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
168 | 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
169 | 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
170 | 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
171 | 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
172 | esac
173 | fi
174 |
175 | # Escape application args
176 | save () {
177 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
178 | echo " "
179 | }
180 | APP_ARGS=`save "$@"`
181 |
182 | # Collect all arguments for the java command, following the shell quoting and substitution rules
183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
184 |
185 | exec "$JAVACMD" "$@"
186 |
--------------------------------------------------------------------------------
/app/src/main/java/me/wjz/nekocrypt/util/NCWindowManager.kt:
--------------------------------------------------------------------------------
1 | package me.wjz.nekocrypt.util
2 |
3 | import android.animation.ValueAnimator
4 | import android.content.Context
5 | import android.graphics.PixelFormat
6 | import android.graphics.Rect
7 | import android.os.Build
8 | import android.view.Gravity
9 | import android.view.MotionEvent
10 | import android.view.View
11 | import android.view.ViewConfiguration
12 | import android.view.WindowManager
13 | import android.view.animation.DecelerateInterpolator
14 | import androidx.compose.runtime.Composable
15 | import androidx.compose.ui.platform.ComposeView
16 | import androidx.compose.ui.platform.ViewCompositionStrategy
17 | import androidx.lifecycle.setViewTreeLifecycleOwner
18 | import androidx.lifecycle.setViewTreeViewModelStoreOwner
19 | import androidx.savedstate.setViewTreeSavedStateRegistryOwner
20 | import kotlin.math.abs
21 |
22 | /**
23 | * 一个通用的、用于在 WindowManager 上显示 Compose UI 的弹窗工具类。
24 | * 它封装了所有创建、显示和销毁悬浮窗的复杂逻辑。
25 | *
26 | * @param context 上下文环境。
27 | * @param onDismissRequest 当弹窗被请求关闭时（例如，通过代码调用dismiss）的回调。
28 | * @param content 要在弹窗中显示的 Composable 内容。
29 | */
30 | class NCWindowManager(
31 | private val context: Context,
32 | private val onDismissRequest: () -> Unit = {},
33 | private val anchorRect: Rect? = null,
34 | private val isDraggable: Boolean = false,
35 | private val content: @Composable () -> Unit,
36 | ) {
37 | private val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
38 | private var popupView: View? = null
39 | private var lifecycleOwnerProvider: LifecycleOwnerProvider? = null
40 | private var positionAnimator: ValueAnimator? = null
41 |
42 | /**
43 | * 显示弹窗。
44 | * @param anchorRect 一个可选的矩形，用于定位弹窗。如果为null，弹窗会居中。
45 | */
46 | fun show() {
47 | // 防止重复显示
48 | if (popupView != null) return
49 | // 创建并启动生命周期
50 | lifecycleOwnerProvider = LifecycleOwnerProvider().also { it.resume() }
51 |
52 | // 创建ComposeView并设置内容
53 | popupView = ComposeView(context).apply {
54 | // ✨ 在设置内容之前，先给它“通上电”！
55 | setViewTreeLifecycleOwner(lifecycleOwnerProvider)
56 | setViewTreeViewModelStoreOwner(lifecycleOwnerProvider)
57 | setViewTreeSavedStateRegistryOwner(lifecycleOwnerProvider)
58 | // 不要裁剪子视图，避免子视图做动画时超出边界被裁剪
59 | clipChildren = false
60 | clipToPadding = false
61 |
62 | // 使用最安全通用的生命周期策略
63 | setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnDetachedFromWindow)
64 | setContent(content)
65 | }
66 | if (isDraggable) {
67 | popupView?.setOnTouchListener(createDragTouchListener())
68 | }
69 | // 创建 WindowManager 参数
70 | val params = createLayoutParams(anchorRect)
71 | // 添加到窗口
72 | windowManager.addView(popupView, params)
73 | }
74 |
75 | /**
76 | * 关闭并销毁弹窗。
77 | */
78 | fun dismiss() {
79 | if (popupView != null) {
80 | try {
81 | windowManager.removeView(popupView)
82 | } catch (e: Exception) {
83 | // 忽略窗口已经不存在等异常
84 | } finally {
85 | popupView = null
86 | lifecycleOwnerProvider?.destroy()
87 | lifecycleOwnerProvider = null
88 | // 调用外部传入的关闭回调
89 | onDismissRequest()
90 | }
91 | }
92 | }
93 |
94 | private fun createLayoutParams(anchorRect: Rect?): WindowManager.LayoutParams {
95 | // 这个accessibility不需要用户授权，比application的好
96 | val layoutFlag = WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY
97 |
98 | val params = WindowManager.LayoutParams(
99 | WindowManager.LayoutParams.WRAP_CONTENT,
100 | WindowManager.LayoutParams.WRAP_CONTENT,
101 | layoutFlag,
102 | // ✨ 核心修正：加上 FLAG_LAYOUT_IN_SCREEN 这句关键的“咒语”！
103 | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN,// 这句是关键
104 | PixelFormat.TRANSLUCENT
105 | )
106 |
107 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
108 | params.blurBehindRadius = 30
109 | }
110 |
111 | if (anchorRect != null) {
112 | params.gravity = Gravity.TOP or Gravity.START
113 | params.x = anchorRect.left
114 | params.y = anchorRect.top
115 | }
116 | return params
117 | }
118 |
119 | // 带有平滑效果的位置更新函数
120 | fun updatePosition(targetRect: Rect) {
121 | // 如果视图不存在直接返回
122 | val view = popupView ?: return
123 | // 取消正在进行的任何旧动画
124 | positionAnimator?.cancel()
125 |
126 | val currentParams = view.layoutParams as? WindowManager.LayoutParams ?: return
127 | val startX = currentParams.x
128 | val startY = currentParams.y
129 | val endX = targetRect.left
130 | val endY = targetRect.top
131 |
132 | // 如果位置没有变化，就没必要执行动画
133 | if (startX == endX && startY == endY) return
134 |
135 | positionAnimator = ValueAnimator.ofFloat(0f, 1f).apply {
136 | duration = 250 //动画时长
137 | interpolator = DecelerateInterpolator() // 减速插值器，动画效果更自然
138 | // 根据动画进度计算当前帧的x,y坐标
139 | addUpdateListener { animation ->
140 | val fraction = animation.animatedFraction
141 | // 根据动画进度计算当前帧的x, y坐标
142 | currentParams.x = (startX + (endX - startX) * fraction).toInt()
143 | currentParams.y = (startY + (endY - startY) * fraction).toInt()
144 |
145 | // 只有当视图还附着在窗口上时才更新布局
146 | if (view.isAttachedToWindow) {
147 | windowManager.updateViewLayout(view, currentParams)
148 | }
149 | }
150 | start()
151 | }
152 | }
153 |
154 | /**
155 | * ✨ 全新函数：创建一个处理拖动逻辑的 OnTouchListener。
156 | * 它能智能地区分用户的“轻点”和“拖动”手势。
157 | */
158 | private fun createDragTouchListener():View.OnTouchListener{
159 | // 手指按下时的初始位置
160 | var initialX = 0
161 | var initialY = 0
162 | var initialTouchX = 0f
163 | var initialTouchY = 0f
164 | val touchSlop = ViewConfiguration.get(context).scaledTouchSlop
165 | var isDragging = false
166 |
167 | return View.OnTouchListener{ view, event ->
168 | val params = view.layoutParams as? WindowManager.LayoutParams ?: return@OnTouchListener false
169 |
170 | when (event.action) {
171 | MotionEvent.ACTION_DOWN -> {
172 | isDragging = false // 每次按下都重置拖动状态
173 | // 记录下当前窗口的位置
174 | initialX = params.x
175 | initialY = params.y
176 | // 记录下手指在屏幕上的位置
177 | initialTouchX = event.rawX
178 | initialTouchY = event.rawY
179 | true // 返回 true，表示我们要继续处理后续的 MOVE 和 UP 事件
180 | }
181 | MotionEvent.ACTION_MOVE -> {
182 | // 计算手指滑动的距离
183 | val dx = event.rawX - initialTouchX
184 | val dy = event.rawY - initialTouchY
185 |
186 | // 如果还没开始拖动，并且滑动的距离已经超过了系统阈值，那么就判定为开始拖动
187 | if (!isDragging && (abs(dx) > touchSlop || abs(dy) > touchSlop)) {
188 | isDragging = true
189 | }
190 |
191 | // 如果正在拖动，就更新窗口的位置
192 | if (isDragging) {
193 | params.x = (initialX + dx).toInt()
194 | params.y = (initialY + dy).toInt()
195 | windowManager.updateViewLayout(view, params)
196 | }
197 | true
198 | }
199 | MotionEvent.ACTION_UP -> {
200 | // 如果手指抬起时，我们判定这并非一次拖动...
201 | if (!isDragging) {
202 | // ...那就当它是一次点击！
203 | view.performClick()
204 | }
205 | true
206 | }
207 | else -> false // 其他事件我们不关心
208 | }
209 | }
210 | }
211 | }
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## 一款神奇又好用的全局消息加解密软件 —— 喵密！
2 |
3 |
4 |
5 |
6 |
7 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 | 
42 |
43 |
Neko Crypt
44 |
45 | 查看Demo
46 | ·
47 | 报告Bug
48 | ·
49 | 提出新特性
50 |
51 |
52 |
53 |
54 |
55 | 
56 |
57 |
58 | "喜悦也好 悲伤也好 阴晴雨雪 欢聚离别
59 |
世界上所有美好与苦难， 通通都坠入那片纯蓝。"
60 |
61 | ## 目录
62 |
63 | - [Neko Crypt](#projectname)
64 | - [目录](#目录)
65 | - [NekoCrypt 的传说](#nekocrypt-的传说)
66 | - [**使用教程**](#使用教程)
67 | - [**下载链接**](#下载链接)
68 | - [支持软件](#支持软件)
69 | - [交流群](#交流群)
70 | - [版权说明](#版权说明)
71 | - [鸣谢](#鸣谢)
72 | - [重要声明](#重要声明)
73 |
74 | ## NekoCrypt 的传说
75 |
76 | 在数字世界的喧嚣背后，存在着一个由猫咪们维护的古老通讯系统。它们是信息的守护者，用呼噜声加密，用尾巴的摇摆解密。它们的网络，无形、优雅，且绝对安全。
77 |
78 | 然而，这个充满了噪音和窥探的数字世界，也充满了遗憾。无数珍贵的话语，在冰冷的数据洪流中漂泊、失散，再也无法抵达它们本应去往的地方。
79 |
80 | WJZ_P 的故事很神秘。在他心中，有一段对话，一缕星光，是他希望能永远守护的秘密。那是一段本应继续，却归于沉寂的私语。
81 |
82 | 一只名为“Kitten”的智者狮子猫，仿佛感受到了这份深藏心底的思念。它悄然出现在 WJZ_P 的窗台，带来了一丝慰藉，和一则来自古老猫咪网络的启示。Kitten 并非普通的猫，它更像一个信使，一个连接着此地与星辰的守护者。
83 |
84 | 于是，在 Kitten 的陪伴下，WJZ_P 将这份守护的执念，与猫咪一族加密的奥秘——那种将信息变得如猫步般轻盈、如星光般静谧的魔法——融合，翻译成了人类可以理解的代码。
85 |
86 | NekoCrypt 就此诞生。
87 |
88 | 它不仅仅是一个加密工具。它是一种承诺，一种将最重要的心声，送往那个你最想念的地方的仪式。它体现了一种猫咪的哲学：真正的沟通，可以跨越喧嚣，甚至跨越时空，抵达永恒。
89 |
90 | 现在，当你使用 NekoCrypt 时，想象一下，那只名为 Kitten 的猫咪伙伴，正用它毛茸茸的尾巴，温柔地为你守护着每一条信息。它不仅仅是保护信息不被窥探，更是确保那些承载着思念的低语，能够穿过数字世界的迷雾，抵达那片属于它的星空。
91 |
92 | 呼噜噜...(舔爪爪)蹭︉︎︆︅︊︃︊️︃︎︎️︈︀︉︄︈︋︊︎︎︊︎︍︉︍︉︁︄︊︅︃︅︇︁︋︇︍︂︅︅︋︎︅︉︋︌️︉︍️︌︁️︅︃︃︎️︎︍︊︂︆︈︃︉︍︍︌︅︌︉︍︋︁︁︆︊︄︉︉︉︈︊︍︈︁︊︎︄︇︉︅︌︊︋︍︋︍︇︎︉︂︅︎︍︅︉︈︄︀︊︋️︀︃︁︌︅︂︊︂︄️︎︄︄︉️︁︂︇︊︄︌︂︀︎︉︉︃︅︁︉︊︎︉︈️︅︁︅️︎︄︎︀︌︌︃️︂︂︍︍︄︇︇︇︆︂︇︌︈︀︊︉︆︆蹭~(๑•̀ㅂ•́)و✧
93 |
94 | # 使用教程
95 |
96 | ## 1. 打开无障碍权限
97 |
98 | 
99 |
100 |
101 | 看到那个巨大猫爪了吗？点击它！会跳转到无障碍权限页面列表。
102 |
103 |
104 | 
105 |
106 |
107 | 点击“已下载的应用”
108 |
109 |
110 | 
111 |
112 |
113 |
114 | 
115 |
116 |
117 | 开启后，返回主界面，看到猫爪变为深色就大功告成啦！
118 |
119 |
120 | 
121 |
122 |
123 | ## 2. 使用过程
124 |
125 | #### 下面以QQ为例
126 |
127 | ### 进入群聊，可以看到输入框的发送按钮有浅蓝色遮罩
128 |
129 |
130 | 
131 |
132 |
133 | #### 看到有遮罩即为功能正常，如果想关闭遮罩，可以在设置中选择遮罩颜色，默认配色板的最后一个即为纯透明。
134 |
135 |
136 |
137 | | NekoCrypt | 标准模式 | 沉浸模式 |
138 | |:---------:|:----------:|:----------:|
139 | | 加密模式 | 长按发送按钮发送密文 | 点击发送直接发出密文 |
140 | | 解密模式 | 点击含密文消息解密 | 自动解密，耗电增加 |
141 |
142 |
143 |
144 | #### 解密效果展示如下：
145 |
146 |
147 | 
148 |
149 |
150 |
151 | ### 双击输入框，拉起附件发送界面
152 |
153 |
154 | 
155 |
156 |
157 |
158 | #### 让我们来发送一个小约翰吧！
159 |
160 |
161 | 
162 |
163 |
164 |
165 | 条件限制，目前只支持10M以内的图片、文件发送，将来会扩展。
166 |
167 | ### 适配额外聊天软件
168 |
169 | 设置页面，可以打开扫描开关
170 |
171 |
172 | 
173 |
174 |
175 |
176 | 切到你想要适配的聊天软件，确保界面上显示了发送按钮(有的软件只有输入框有字才会显示发送按钮)，点击猫爪悬浮窗自动扫描。
177 |
178 |
179 | 
180 |
181 |
182 |
183 | 必须选择四个要素：输入框、发送按钮、消息列表、消息节点后，才可以点击确认。确认后自动保存配置，就可以使用了。这里特别要注意的是，选择消息节点时必须注意内容是你发送的文本，不要误选成昵称、群等级之类的错误节点。
184 |
185 |
186 | ## 下载链接
187 |
188 | #### [点击高速下载v1.0.1(并不总是最新，建议从release下载)](https://beisudianxueuser.oss-cn-beijing.aliyuncs.com/storage/user_avatar/ciallo/2025/08/23/a911aef0a0c2018ad23489ffd263f581/NekoCrypt-v1.0.1-release.apk)
189 | #### 右侧release内也可下载
190 |
191 | ## 支持软件
192 |
193 |
194 | | NekoCrypt | 是否支持 | 备注 |
195 | | :---: | :----: |:----------:|
196 | | QQ |✅ | 完全支持 |
197 | | 微信 | ✅ | 完全支持 |
198 | | 更多 | ✅ | 使用扫描功能自助添加 |
199 |
200 |
201 |
202 | ## 交流群
203 |
204 |
205 | 
206 |
207 |
208 |
209 | ## 版权说明
210 |
211 | 该项目签署了EPL-2.0 license
212 | 授权许可，详情请参阅 [LICENSE](https://github.com/WJZ-P/NekoCrypt/blob/main/LICENSE)
213 |
214 | ## 鸣谢
215 |
216 | - 一位不愿透露姓名的神秘人士。
217 |
218 |
219 | ## 重要声明
220 | ### 本项目仅供交流学习使用，**禁止**用于一切非法用途！任何问题概不负责。(｡•́︿•̀｡)
221 |
222 | ## 📝 To Do List
223 |
224 | - [x] **完全支持微信**
225 |
226 | - [x] **支持更换密钥**
227 |
228 | - [ ] **支持更大文件的发送**
229 |
230 | - [ ] **支持修改主题色**
231 |
232 | - [ ] **支持更多加密语种**
233 |
234 | - [ ] **支持时间轮转密钥，使得加密消息有时间限制，无法查看之前时间段的加密内容**
235 |
236 | ## 如果您喜欢本项目，请给我点个⭐吧(๑>◡<๑)！
237 |
238 | ## ⭐ Star 历史
239 |
240 | [](https://starchart.cc/WJZ-P/NekoCrypt)
241 |
242 |
243 | [your-project-path]:WJZ-P/NekoCrypt
244 |
245 | [contributors-shield]: https://img.shields.io/github/contributors/WJZ-P/NekoCrypt.svg?style=flat-square
246 |
247 | [contributors-url]: https://github.com/WJZ-P/NekoCrypt/graphs/contributors
248 |
249 | [forks-shield]: https://img.shields.io/github/forks/WJZ-P/NekoCrypt.svg?style=flat-square
250 |
251 | [forks-url]: https://github.com/WJZ-P/NekoCrypt/network/members
252 |
253 | [stars-shield]: https://img.shields.io/github/stars/WJZ-P/NekoCrypt.svg?style=flat-square
254 |
255 | [stars-url]: https://github.com/WJZ-P/NekoCrypt/stargazers
256 |
257 | [issues-shield]: https://img.shields.io/github/issues/WJZ-P/NekoCrypt.svg?style=flat-square
258 |
259 | [issues-url]: https://img.shields.io/github/issues/WJZ-P/NekoCrypt.svg
260 |
261 | [license-shield]: https://img.shields.io/github/license/WJZ-P/NekoCrypt.svg?style=flat-square
262 |
263 | [license-url]: https://github.com/WJZ-P/NekoCrypt/blob/main/LICENSE
264 |
265 | [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=flat-square&logo=linkedin&colorB=555
266 |
267 | [linkedin-url]: https://linkedin.com/in/shaojintian
268 |
269 | [oldQQ-download-link]:https://dldir1.qq.com/qqfile/qq/QQNT/448e164c/QQ9.9.15.26909_x64.exe
270 |
271 | [LL-installer-link]:https://ats-prod.oss-accelerate.aliyuncs.com/18734247705198dcb594916e8ba1facc
272 |
273 | [//]: # (不知道写点啥)
--------------------------------------------------------------------------------
/app/src/main/java/me/wjz/nekocrypt/service/handler/FileActionHandler.kt:
--------------------------------------------------------------------------------
1 | package me.wjz.nekocrypt.service.handler
2 |
3 | import android.content.ContentValues
4 | import android.content.Intent
5 | import android.net.Uri
6 | import android.os.Build
7 | import android.os.Environment
8 | import android.provider.MediaStore
9 | import android.util.Log
10 | import android.webkit.MimeTypeMap
11 | import android.widget.Toast
12 | import androidx.compose.runtime.getValue
13 | import androidx.compose.runtime.mutableStateOf
14 | import androidx.compose.runtime.setValue
15 | import com.dianming.phoneapp.MyAccessibilityService
16 | import kotlinx.coroutines.Dispatchers
17 | import kotlinx.coroutines.launch
18 | import kotlinx.coroutines.withContext
19 | import me.wjz.nekocrypt.R
20 | import me.wjz.nekocrypt.ui.dialog.FilePreviewDialog
21 | import me.wjz.nekocrypt.util.CryptoDownloader
22 | import me.wjz.nekocrypt.util.NCFileProtocol
23 | import me.wjz.nekocrypt.util.NCWindowManager
24 | import me.wjz.nekocrypt.util.getCacheFileFor
25 | import me.wjz.nekocrypt.util.getUriForFile
26 | import java.io.IOException
27 |
28 | /**
29 | * 点击文件or图片按钮后的处理类，负责控制悬浮窗的生命周期，并负责下载，展示等逻辑
30 | */
31 | class FileActionHandler(private val service: MyAccessibilityService) {
32 | private val tag ="NCFileActionHandler"
33 | private var dialogManager: NCWindowManager? = null
34 | private var downloadProgress by mutableStateOf(null)
35 | private var downloadedFileUri by mutableStateOf(null)
36 | private var isImageSavedThisTime by mutableStateOf(false)
37 |
38 | /**
39 | * 显示文件预览对话框
40 | */
41 | fun show(fileInfo: NCFileProtocol) {
42 | dismiss() // 先关闭旧的
43 |
44 | // 根据文件信息生成本地缓存的唯一路径
45 | val targetFile = getCacheFileFor(service,fileInfo)
46 |
47 | // 检查缓存文件是否完整
48 | if (targetFile.exists() && targetFile.length() == fileInfo.size) {
49 | Log.d(tag, "文件已在缓存中找到: ${targetFile.path}")
50 | // ✨ 如果缓存命中，直接为文件生成安全的Uri
51 | downloadedFileUri = getUriForFile(service,targetFile)
52 | downloadProgress = null
53 | } else {
54 | Log.d(tag, "文件未缓存或不完整，准备下载。")
55 | downloadedFileUri = null // 未缓存，重置状态
56 | downloadProgress = null
57 | }
58 | // 创建视图
59 | dialogManager = NCWindowManager(
60 | context = service,
61 | onDismissRequest = { dialogManager = null },
62 | anchorRect = null
63 | ) {
64 | FilePreviewDialog(
65 | fileInfo = fileInfo,
66 | downloadProgress = downloadProgress, // ✨ 将进度状态传递给UI
67 | downloadedFileUri = downloadedFileUri, // nullable
68 | isImageSavedThisTime = isImageSavedThisTime, // 本次会话中是否把图片保存到了系统相册
69 | onDismissRequest = { dismiss() },
70 | onDownloadRequest = { info ->
71 | startDownload(info)
72 | },
73 | onOpenRequest = { uri ->
74 | openFile(uri,fileInfo) // ✨ 回调现在直接使用 Uri
75 | },
76 | onSaveToGalleryRequest = {uri ->
77 | service.serviceScope.launch {
78 | isImageSavedThisTime = saveImageToGallery(uri, fileInfo)
79 | }
80 | }
81 | )
82 | }
83 | dialogManager?.show()
84 | }
85 |
86 | /**
87 | * 关闭对话框
88 | */
89 | fun dismiss() {
90 | dialogManager?.dismiss()
91 | dialogManager = null
92 | }
93 |
94 | /**
95 | * 启动文件下载
96 | */
97 | private fun startDownload(fileInfo: NCFileProtocol) {
98 | if(downloadProgress != null) return // 保证健壮性，防止重复点击
99 |
100 | service.serviceScope.launch {
101 | val targetFile = getCacheFileFor(service,fileInfo)
102 | try{
103 | downloadProgress = 0
104 | // download会suspend。
105 | val result = CryptoDownloader.download(
106 | fileInfo = fileInfo,
107 | targetFile = targetFile,
108 | onProgress = { progress -> downloadProgress = progress }
109 | )
110 |
111 | if(result.isSuccess){
112 | val file = result.getOrThrow()
113 | // ✨ 下载成功后，为新文件生成安全的Uri并更新状态
114 | downloadedFileUri = getUriForFile(service,file)
115 | Log.d(tag, "文件下载成功，Uri: $downloadedFileUri")
116 | }else{
117 | val error = result.exceptionOrNull()?.message ?: "未知错误"
118 | Log.e(tag, "文件下载失败: $error")
119 | showToast(service.getString(R.string.dialog_download_file_download_failed, error))
120 | }
121 | } finally {
122 | downloadProgress = null
123 | }
124 | }
125 | }
126 |
127 | suspend fun showToast(string: String, duration: Int = Toast.LENGTH_SHORT) {
128 | Log.d(tag, "showToast: $string")
129 | withContext(Dispatchers.Main) {
130 | Toast.makeText(service.applicationContext, string, duration).show()
131 | }
132 | }
133 |
134 | private fun openFile(uri: Uri,fileInfo: NCFileProtocol){
135 | service.serviceScope.launch {
136 | try{
137 | // 1. ✨ 从原始文件名中获取文件后缀
138 | val extension = fileInfo.name.substringAfterLast('.', "")
139 | // 2. ✨ 使用 MimeTypeMap 将后缀转换为标准的MIME类型
140 | val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.lowercase())
141 | ?: "*/*" // 如果找不到，使用通用类型
142 |
143 | val intent = Intent(Intent.ACTION_VIEW).apply {
144 | setDataAndType(uri,mimeType)
145 | addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
146 | addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
147 | }
148 | service.startActivity(intent)
149 | dismiss() // 选择打开文件的话，就要关闭当前的悬浮窗
150 |
151 | } catch (e: Exception) {
152 | Log.e(tag, "打开文件失败", e)
153 | showToast(service.getString(R.string.cannot_open_file))
154 | }
155 | }
156 | }
157 |
158 | // 根据uri和文件名保存到系统相册，并返回操作结果。
159 | private suspend fun saveImageToGallery(uri: Uri, fileInfo: NCFileProtocol): Boolean {
160 |
161 | val success = withContext(Dispatchers.IO) {
162 | runCatching {
163 | val extension = fileInfo.name.substringAfterLast('.', "")
164 | val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension)
165 |
166 | // ContentValues 就像一个“档案袋”，我们把新文件的所有信息（元数据）都放进去。
167 | val contentValues = ContentValues().apply {
168 | put(MediaStore.MediaColumns.DISPLAY_NAME, fileInfo.name) // 文件在相册里显示的名字。
169 | put(MediaStore.MediaColumns.MIME_TYPE, mimeType) // 文件的mime类型
170 | // 档案3 & 4 (仅限 Android 10 及以上)：
171 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
172 | // 告诉系统要把这个文件放在公共的“相册”文件夹里。
173 | put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_PICTURES)
174 | // 先把文件标记为“待定”状态。这意味着在文件内容被完全写入之前，
175 | // 其他应用（包括相册自己）是看不到这个文件的，可以防止出现损坏的半成品文件。
176 | put(MediaStore.MediaColumns.IS_PENDING, 1)
177 | }
178 | }
179 |
180 | // 用我们写好的信息，去申请一个URI
181 | val imageUri = service.contentResolver.insert(
182 | MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
183 | contentValues
184 | )
185 | ?: throw IOException("无法在相册中创建新文件。")
186 |
187 | // 使用我们新的imageUri，写入文件
188 | service.contentResolver.openOutputStream(imageUri).use { outputStream ->
189 | service.contentResolver.openInputStream(uri).use { inputStream ->
190 | requireNotNull(inputStream) { "无法打开缓存文件的输入流" }
191 | requireNotNull(outputStream) { "无法打开相册文件的输出流" }
192 | inputStream.copyTo(outputStream)
193 | }
194 | }
195 |
196 | // (仅限 Android 10 及以上) 文件内容已经写完，我们再次更新档案，
197 | // 把“待定”状态改为0，正式通知系统：“文件已准备就绪，可以对外展示了！”
198 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
199 | contentValues.clear()
200 | contentValues.put(MediaStore.MediaColumns.IS_PENDING, 0)
201 | service.contentResolver.update(imageUri, contentValues, null, null)
202 | }
203 |
204 | //顺利完成，返回true
205 | true
206 | }.onFailure { e ->
207 | Log.e(tag, "保存图片到相册失败", e)
208 | false // 返回失败
209 | }.getOrDefault(false) // 拿不到，默认就返回false
210 | }
211 | if (success) showToast(service.getString(R.string.image_saved_to_gallery_success))
212 | else showToast(service.getString(R.string.image_saved_to_gallery_failed))
213 | return success
214 | }
215 | }
216 |
217 |
--------------------------------------------------------------------------------
/app/src/main/java/me/wjz/nekocrypt/ui/screen/HomeScreen.kt:
--------------------------------------------------------------------------------
1 | package me.wjz.nekocrypt.ui.screen
2 |
3 | import android.content.Context
4 | import androidx.compose.animation.AnimatedVisibility
5 | import androidx.compose.animation.core.tween
6 | import androidx.compose.animation.expandVertically
7 | import androidx.compose.animation.fadeIn
8 | import androidx.compose.animation.fadeOut
9 | import androidx.compose.animation.shrinkVertically
10 | import androidx.compose.foundation.layout.Arrangement
11 | import androidx.compose.foundation.layout.Box
12 | import androidx.compose.foundation.layout.Column
13 | import androidx.compose.foundation.layout.Spacer
14 | import androidx.compose.foundation.layout.aspectRatio
15 | import androidx.compose.foundation.layout.fillMaxSize
16 | import androidx.compose.foundation.layout.fillMaxWidth
17 | import androidx.compose.foundation.layout.padding
18 | import androidx.compose.foundation.shape.RoundedCornerShape
19 | import androidx.compose.material3.Card
20 | import androidx.compose.material3.CardDefaults
21 | import androidx.compose.material3.MaterialTheme
22 | import androidx.compose.runtime.Composable
23 | import androidx.compose.runtime.getValue
24 | import androidx.compose.runtime.remember
25 | import androidx.compose.ui.Alignment
26 | import androidx.compose.ui.Modifier
27 | import androidx.compose.ui.platform.LocalContext
28 | import androidx.compose.ui.res.stringResource
29 | import androidx.compose.ui.unit.dp
30 | import me.wjz.nekocrypt.CommonKeys.DECRYPTION_MODE_IMMERSIVE
31 | import me.wjz.nekocrypt.CommonKeys.DECRYPTION_MODE_STANDARD
32 | import me.wjz.nekocrypt.CommonKeys.ENCRYPTION_MODE_IMMERSIVE
33 | import me.wjz.nekocrypt.CommonKeys.ENCRYPTION_MODE_STANDARD
34 | import me.wjz.nekocrypt.R
35 | import me.wjz.nekocrypt.SettingKeys
36 | import me.wjz.nekocrypt.hook.rememberDataStoreState
37 | import com.dianming.phoneapp.MyAccessibilityService
38 | import me.wjz.nekocrypt.ui.InfoDialogIcon
39 | import me.wjz.nekocrypt.ui.RadioOption
40 | import me.wjz.nekocrypt.ui.SegmentedButtonSetting
41 | import me.wjz.nekocrypt.ui.SwitchSettingCard
42 | import me.wjz.nekocrypt.ui.component.CatPawButton
43 | import me.wjz.nekocrypt.util.openAccessibilitySettings
44 | import me.wjz.nekocrypt.util.rememberAccessibilityServiceState
45 |
46 | // --- 主屏幕代码 ---
47 |
48 | @Composable
49 | fun HomeScreen(modifier: Modifier = Modifier) {
50 | // 1. 获取当前上下文
51 | val context: Context = LocalContext.current
52 |
53 | // 2. 使用我们新的 Composable 函数来获取并监听无障碍服务的状态
54 | val isAccessibilityEnabled by rememberAccessibilityServiceState(
55 | context,
56 | MyAccessibilityService::class.java
57 | )
58 |
59 | val useAutoEncryption by rememberDataStoreState(SettingKeys.USE_AUTO_ENCRYPTION, false)
60 | val useAutoDecryption by rememberDataStoreState(SettingKeys.USE_AUTO_DECRYPTION, false)
61 |
62 | // 使用 Column 作为根布局，以垂直排列组件
63 | Column(
64 | modifier = modifier.fillMaxSize(),
65 | horizontalAlignment = Alignment.CenterHorizontally
66 | ) {
67 | // 使用带权重的 Column 来包裹原有的猫爪UI，使其占据大部分空间并保持居中
68 | Column(
69 | modifier = Modifier.weight(1f).fillMaxWidth(),
70 | verticalArrangement = Arrangement.Center,
71 | horizontalAlignment = Alignment.CenterHorizontally
72 | ) {
73 | // ✨ 核心修正：用一个 Box 把猫爪按钮包裹起来，并给这个 Box 一个“方形模具”
74 | Box(
75 | modifier = Modifier
76 | .fillMaxWidth() // 让 Box 尽可能宽
77 | .padding(52.dp) // 给猫爪留出一些呼吸空间
78 | .aspectRatio(1f), // ✨ 魔法！强制这个 Box 的高度等于它的宽度，永远保持正方形
79 | contentAlignment = Alignment.Center
80 | ) {
81 | CatPawButton(
82 | modifier = Modifier.fillMaxSize(), // 让猫爪按钮填满这个完美的正方形
83 | isEnabled = isAccessibilityEnabled,
84 | statusText = if (isAccessibilityEnabled)
85 | stringResource(id = R.string.accessibility_service_enabled)
86 | else
87 | stringResource(id = R.string.accessibility_service_disabled),
88 | onClick = { openAccessibilitySettings(context) }
89 | )
90 | }
91 | }
92 |
93 | // 在底部添加我们的设置卡片
94 |
95 | // 加密选项
96 | Card(
97 | modifier = Modifier
98 | .fillMaxWidth()
99 | .padding(horizontal = 16.dp, vertical = 8.dp),
100 | shape = RoundedCornerShape(16.dp),
101 | colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant),
102 | elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
103 | ) {
104 | Column {
105 | SwitchSettingCard(
106 | key = SettingKeys.USE_AUTO_ENCRYPTION,
107 | defaultValue = false,
108 | title = stringResource(id = R.string.setting_encrypt_on_send_title),
109 | subtitle = stringResource(id = R.string.setting_encrypt_on_send_subtitle)
110 | )
111 |
112 | // 2. 模式选择
113 | AnimatedVisibility(
114 | visible = useAutoEncryption,
115 | enter = expandVertically(animationSpec = tween(400)) + fadeIn(),
116 | exit = shrinkVertically(animationSpec = tween(400)) + fadeOut()
117 | ) {
118 | val modeStandardText = stringResource(R.string.mode_standard)
119 | val modeImmersiveText = stringResource(R.string.mode_immersive)
120 |
121 | val encryptionModeOptions = remember {
122 | listOf(
123 | RadioOption(ENCRYPTION_MODE_STANDARD, modeStandardText),
124 | RadioOption(ENCRYPTION_MODE_IMMERSIVE, modeImmersiveText)
125 | )
126 | }
127 | SegmentedButtonSetting(
128 | settingKey = SettingKeys.ENCRYPTION_MODE,
129 | defaultOptionKey = ENCRYPTION_MODE_STANDARD,
130 | title = stringResource(id = R.string.setting_encryption_mode_info_title),
131 | options = encryptionModeOptions,
132 | titleExtraContent = { // 标题旁边的额外内容。
133 | InfoDialogIcon(
134 | title = stringResource(R.string.setting_encryption_mode_info_text),
135 | text = stringResource(R.string.setting_encryption_mode_info_desc),
136 | contentDescription = stringResource(R.string.setting_encryption_mode_info_desc)
137 | )
138 | }
139 | )
140 | }
141 | }
142 | }
143 |
144 | // 解密选项
145 | Card(
146 | modifier = Modifier
147 | .fillMaxWidth()
148 | .padding(horizontal = 16.dp, vertical = 8.dp),
149 | shape = RoundedCornerShape(16.dp),
150 | colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant),
151 | elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
152 | ) {
153 | Column {
154 | //解密开关
155 | SwitchSettingCard(
156 | key = SettingKeys.USE_AUTO_DECRYPTION,
157 | defaultValue = false,
158 | title = stringResource(id = R.string.setting_decrypt_immersive_mod_title),
159 | subtitle = stringResource(id = R.string.setting_decrypt_immersive_mod_subtitle),
160 | )
161 | AnimatedVisibility(
162 | visible = useAutoDecryption,
163 | enter = expandVertically(animationSpec = tween(400)) + fadeIn(),
164 | exit = shrinkVertically(animationSpec = tween(400)) + fadeOut()
165 | ) {
166 | val decryptionModeOptions = remember {
167 | listOf(
168 | RadioOption(DECRYPTION_MODE_STANDARD, "标准模式"),
169 | RadioOption(DECRYPTION_MODE_IMMERSIVE, "沉浸模式")
170 | )
171 | }
172 | SegmentedButtonSetting(
173 | settingKey = SettingKeys.DECRYPTION_MODE,
174 | defaultOptionKey = DECRYPTION_MODE_STANDARD,
175 | title = stringResource(id = R.string.setting_decryption_mode_info_title),
176 | options = decryptionModeOptions,
177 | titleExtraContent = {
178 | // ✨ 看！之前所有复杂的 TooltipBox 代码，
179 | // 现在都变成了这一行极其清晰的调用！
180 | InfoDialogIcon(
181 | title = stringResource(R.string.setting_decryption_mode_info_text),
182 | text = stringResource(R.string.setting_decryption_mode_info_desc),
183 | contentDescription = stringResource(R.string.setting_decryption_mode_info_desc)
184 | )
185 | }
186 | )
187 | }
188 | }
189 |
190 | }
191 | Spacer(Modifier.padding(4.dp))
192 | }
193 | }
194 |
--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | NekoCrypt
3 |
4 |
5 | 原来是这样，现在我完全搞懂了
6 | 关闭
7 | 发送
8 | 确认
9 | 文件大小
10 | URL
11 | 下载
12 | 完成
13 | 删除
14 | 下载中
15 | 未安装
16 | 打开文件
17 | 打开文件失败
18 | 检查更新中...
19 | 检查更新失败，请检查网络连接
20 | "已经是最新版本啦 (ฅ´ω`ฅ)"
21 | 发现新版本: %s！
22 | 保存到相册
23 | 成功保存到相册
24 | 保存到相册失败
25 | 已保存到相册
26 | 已复制到剪切板
27 | 请打开悬浮窗权限！
28 | 请开启无障碍服务！
29 |
30 |
31 | 主页
32 | 加密
33 | 密钥
34 | 设置
35 |
36 |
37 |
38 |
39 | 标准模式
40 | 沉浸模式
41 |
42 | 输入原文或密文
43 | 在此处输入或粘贴文本…
44 | 解密失败！密文被篡改或密钥错误.\n ｡ﾟ(ﾟ´Д｀ﾟ)ﾟ｡
45 | 输入图标
46 | 已从剪贴板粘贴
47 | 粘贴
48 | 清空输入
49 | 加密图标
50 | 交换输入与输出
51 | 解密
52 | 解密图标
53 | 加密结果
54 | 解密结果
55 | 已复制到剪贴板
56 | 复制结果
57 | 密钥图标
58 | 当前密钥
59 | 选择密钥
60 |
61 | 密文字符数
62 | 总处理耗时
63 | %1$d ms
64 |
65 | 喵密服务，用于智能加解密消息
66 | 为保证功能正常使用，需要申请无障碍权限哦 (๑•̀ㅂ•́)و✧
67 |
68 | 已获取无障碍权限
69 | 点击开启无障碍权限
70 | 加密开关
71 | 开启喵密世界的大门。
72 | 解密开关
73 | 读懂猫咪语言的必选项！
74 | 设置加密模式
75 | 加密模式说明
76 | 标准模式：\n长按发送按钮才会发送密文。\n\n沉浸模式：\n点按直接发送密文。
77 | 设置解密模式
78 | 解密模式说明
79 | 标准模式：\n点击密文弹出悬浮窗显示解密结果。\n\n沉浸模式：\n无需点击，直接以悬浮窗显示解密后的密文，但会增加一定耗电量。
80 |
81 |
82 | NekoCrypt 喵密服务运行中
83 | 密文设置失败喵！可能是字数过多喵… (｡◕ˇ‸ˇ◕｡)：%d 字
84 |
85 |
86 | 前往设置
87 | 需要悬浮窗权限
88 | 为了功能正常使用，请您手动授予权限。\n\n在设置页面，请寻找并开启“显示在其他应用上层”选项。\n\n在部分手机(如小米、华为)上，还可能额外有“悬浮窗权限”，请一同在应用的权限管理中寻找并开启它。
89 | 仍未检测到悬浮窗权限
90 | 喵密检测到悬浮窗权限仍未开启。别担心，这是因为各大手机厂商有更高的悬浮窗权限控制。\n\n请在接下来打开的应用设置页面中，手动找到并开启“悬浮窗”或“显示在其他应用上层”的相关权限。
91 |
92 | 需要无障碍服务
93 | 为了实现自动加解密和读取聊天内容，请在设置列表中找到“NekoCrypt”并开启它的无障碍服务。
94 |
95 | 加解密设置
96 | 长按解密延时
97 | 设置触发长按加密所需的时间
98 | 解密密文展示时长
99 | 设置解密密文悬浮窗的显示时间
100 | 关于
101 | 关于NekoCrypt
102 | 软件版本：%s
103 | Github 项目地址
104 | NekoCrypt (喵密) 是一款方便好用的全局APP加解密软件！(ฅ´ω`ฅ)\n\n双击输入框可以拉起附件发送界面哦！✨\n\n如果您喜欢本软件，请到Github项目主页为我点上一个Star吧！ପ(๑•̀ㅂ•́)و✧\n\n本项目仅供学习交流，任何法律问题均需用户自行负责哦~ ( •̀ ω •́ )✧ 使用NekoCrypt即表示您同意该条款。\n\n ——Made by WJZ_P with love❤️.
105 |
106 | 功能界面设置
107 | 弹窗位置更新延时
108 | 在沉浸式解密下，密文弹窗位置更新的时间间隔，越短越实时，但可能导致卡顿
109 | 选择颜色
110 | 按钮遮罩颜色
111 | 支持ARGB和RGB格式，用于设置盖在发送按钮上遮罩的颜色。最后一个是纯透明
112 | 拉起多媒体弹窗的双击间隔
113 | 在间隔时间内双击输入框，会拉起发送多媒体消息的弹窗
114 |
115 | 发送加密附件
116 | 相册
117 | 文件
118 | 文件上传失败：%s
119 | 文件不存在！
120 | 文件无法访问！
121 | 文件过大！当前最大支持：%d MB
122 | 输入框或发送按钮节点未找到！
123 | 已选择: %s
124 | "正在加密上传..."
125 |
126 |
127 | 文件下载失败：%s
128 | 文件详情
129 |
130 |
131 | 密钥管理
132 | 添加
133 | 默认支持应用
134 | 可能失效，推荐手动扫描添加
135 | 自定义应用
136 | 暂未添加自定义APP
137 | 输入框 ID：
138 | 发送按钮 ID：
139 | 消息气泡 ID：
140 | 消息列表类名：
141 | 添加自定义APP
142 | 扫描模式
143 | 屏幕上会出现用于扫描当前界面的按钮
144 | APP配置已删除
145 | 回车以保存新密钥...
146 |
147 |
148 | 扫描结果
149 | 获取扫描结果失败！
150 | 输入框
151 | 发送按钮
152 | 消息列表
153 | 文本节点
154 | ID
155 | 类名
156 | 文本
157 | 描述
158 | 描述
159 | 扫描功能介绍
160 | 必须选择正确的输入框、发送按钮、消息列表、消息节点。
161 | 点击即可选中，只有四种全部选择完才可以点击确认，之后就自动保存当前软件的节点信息用于加解密。可通过节点的具体内容确认是否是所需节点。特别注意的是消息节点，必须正确选择包含正确消息内容的节点！
162 | 扫描配置已保存
163 |
164 |
165 | 密文语种选择
166 | 加密后的文本可以选择不同风格！
167 | 猫娘语
168 | 尼尔语
169 | 曼波语
170 | 邦布语
171 | 丘丘语
172 |
173 | 密文语种选择
174 | 密文长度选择
175 | 密文词组数为闭区间内的随机值
176 |
177 |
178 |
--------------------------------------------------------------------------------
/app/src/main/java/me/wjz/nekocrypt/util/CryptoManager.kt:
--------------------------------------------------------------------------------
1 | package me.wjz.nekocrypt.util
2 |
3 | import kotlinx.coroutines.CoroutineScope
4 | import kotlinx.coroutines.Dispatchers
5 | import kotlinx.coroutines.SupervisorJob
6 | import me.wjz.nekocrypt.NekoCryptApp
7 | import me.wjz.nekocrypt.R
8 | import me.wjz.nekocrypt.SettingKeys
9 | import me.wjz.nekocrypt.data.DataStoreManager
10 | import me.wjz.nekocrypt.hook.observeAsState
11 | import java.io.InputStream
12 | import java.io.OutputStream
13 | import java.math.BigInteger
14 | import java.security.MessageDigest
15 | import java.security.SecureRandom
16 | import java.util.Locale.getDefault
17 | import javax.crypto.AEADBadTagException
18 | import javax.crypto.Cipher
19 | import javax.crypto.KeyGenerator
20 | import javax.crypto.SecretKey
21 | import javax.crypto.spec.GCMParameterSpec
22 | import javax.crypto.spec.SecretKeySpec
23 | import kotlin.random.Random
24 |
25 | /**
26 | * 加密工具类，有相关的加密算法。
27 | */
28 | object CryptoManager {
29 | val dataStoreManager: DataStoreManager by lazy { NekoCryptApp.instance.dataStoreManager }
30 | val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
31 |
32 | // 当前使用的密文语种
33 | val ciphertextStyleType: String by scope.observeAsState(flowProvider = {
34 | dataStoreManager.getSettingFlow(SettingKeys.CIPHERTEXT_STYLE, CiphertextStyleType.NEKO.toString())
35 | },initialValue = CiphertextStyleType.NEKO.toString())
36 | // 密文长度词组最小值
37 | val ciphertextStyleLengthMin by scope.observeAsState(flowProvider = {
38 | dataStoreManager.getSettingFlow(SettingKeys.CIPHERTEXT_STYLE_LENGTH_MIN, 3)
39 | },initialValue = 1)
40 | // 密文长度词组最大值
41 | val ciphertextStyleLengthMax by scope.observeAsState(flowProvider = {
42 | dataStoreManager.getSettingFlow(SettingKeys.CIPHERTEXT_STYLE_LENGTH_MAX, 7)
43 | },initialValue = 1)
44 |
45 | private const val ALGORITHM = "AES"
46 | const val TRANSFORMATION = "AES/GCM/NoPadding"
47 | private const val KEY_SIZE_BITS = 256 // AES-256
48 | const val IV_LENGTH_BYTES = 16 // GCM 推荐的IV长度是12，为了该死的兼容改成16
49 | const val TAG_LENGTH_BITS = 128 // GCM 推荐的认证标签长度
50 |
51 | // 下面是一些映射表
52 | private val STEALTH_ALPHABET = (0xFE00..0xFE0F).map { it.toChar() }.joinToString("")
53 |
54 | /**
55 | * 为了高效解码，预先创建一个从“猫语”字符到其在字母表中索引位置的映射。
56 | * 这是一个关键的性能优化。
57 | */
58 | private val STEALTH_CHAR_TO_INDEX_MAP = STEALTH_ALPHABET.withIndex().associate { (index, char) -> char to index }
59 |
60 | /**
61 | * 生成一个符合 AES-256 要求的随机密钥。
62 | *
63 | * @return 一个 SecretKey 对象，包含了256位的密钥数据。
64 | */
65 | fun generateKey(): SecretKey {
66 | val keyGenerator = KeyGenerator.getInstance(ALGORITHM)
67 | keyGenerator.init(KEY_SIZE_BITS)
68 | return keyGenerator.generateKey()
69 | }
70 |
71 | /**
72 | * 加密一个消息，使用给定的密钥，返回的直接是隐写字符串
73 | */
74 | fun encrypt(message: String, key: String): String {
75 | val plaintextBytes = message.toByteArray(Charsets.UTF_8)
76 | val encryptedBytes = encryptBytes(plaintextBytes, key)
77 | return baseNEncode(encryptedBytes)
78 | }
79 | // 提供一个重载
80 | fun encrypt(data: ByteArray, key: String): ByteArray {
81 | return encryptBytes(data, key)
82 | }
83 |
84 | //消息解密，智能地从含密文的混合字符串中解密
85 | fun decrypt(stealthCiphertext: String, key: String): String? {
86 | val combinedBytes = baseNDecode(stealthCiphertext)
87 | val decryptedBytes = decryptBytes(combinedBytes, key)
88 | return decryptedBytes?.toString(Charsets.UTF_8)
89 | }
90 |
91 | fun decrypt(data: ByteArray, key: String): ByteArray? {
92 | return decryptBytes(data, key)
93 | }
94 |
95 | /**
96 | * ✨ [私有核心] 真正执行加密操作的函数
97 | */
98 | private fun encryptBytes(plaintextBytes: ByteArray, key: String): ByteArray {
99 | val iv = ByteArray(IV_LENGTH_BYTES)
100 | SecureRandom().nextBytes(iv) //填充随机内容
101 | val cipher = Cipher.getInstance(TRANSFORMATION)
102 | val parameterSpec = GCMParameterSpec(TAG_LENGTH_BITS, iv)
103 | cipher.init(Cipher.ENCRYPT_MODE, deriveKeyFromString(key), parameterSpec)
104 | val ciphertextBytes = cipher.doFinal(plaintextBytes)
105 | // 返回拼接了IV和密文的完整数据
106 | return iv + ciphertextBytes
107 | }
108 |
109 | /**
110 | * ✨ [私有核心] 真正执行解密操作的函数
111 | */
112 | private fun decryptBytes(combinedBytes: ByteArray, key: String): ByteArray? {
113 | try {
114 | if (combinedBytes.size < IV_LENGTH_BYTES) return null
115 |
116 | val iv = combinedBytes.copyOfRange(0, IV_LENGTH_BYTES)
117 | val ciphertextBytes = combinedBytes.copyOfRange(IV_LENGTH_BYTES, combinedBytes.size)
118 | val cipher = Cipher.getInstance(TRANSFORMATION)
119 | val parameterSpec = GCMParameterSpec(TAG_LENGTH_BITS, iv)
120 | cipher.init(Cipher.DECRYPT_MODE, deriveKeyFromString(key), parameterSpec)
121 |
122 | return cipher.doFinal(ciphertextBytes)
123 | } catch (e: AEADBadTagException) {
124 | println("解密失败：数据认证失败，可能已被篡改或密钥错误。\n" + e.message)
125 | return null
126 | } catch (e: Exception) {
127 | println("解密时发生未知错误: ${e.message}")
128 | return null
129 | }
130 | }
131 |
132 | /**
133 | * 判断给定字符串是否包含密文
134 | */
135 | fun String.containsCiphertext(): Boolean{
136 | return this.any { STEALTH_CHAR_TO_INDEX_MAP.containsKey(it) }
137 | }
138 |
139 | fun deriveKeyFromString(keyString: String): SecretKey {
140 | val digest = MessageDigest.getInstance("SHA-256")
141 | val keyBytes = digest.digest(keyString.toByteArray(Charsets.UTF_8))
142 | return SecretKeySpec(keyBytes, ALGORITHM)
143 | }
144 |
145 | // -----------------关键的baseN方法---------------------
146 |
147 | /**
148 | * 将字节数组编码为我们自定义的 BaseN 字符串。
149 | * 算法核心：通过大数运算，将 Base256 的数据转换为 BaseN。
150 | * @param data 原始二进制数据。
151 | * @return 编码后的“猫语”字符串。
152 | */
153 | private fun baseNEncode(data: ByteArray): String {
154 | if (data.isEmpty()) return ""
155 | // 使用 BigInteger 来处理任意长度的二进制数据，避免溢出。
156 | // 构造函数 `BigInteger(1, data)` 确保数字被解释为正数。
157 | var bigInt = BigInteger(1, data)
158 | val base = BigInteger.valueOf(STEALTH_ALPHABET.length.toLong())
159 | val builder = StringBuilder()
160 | while (bigInt > BigInteger.ZERO) {
161 | // 除基取余法
162 | val (quotient, remainder) = bigInt.divideAndRemainder(base)
163 | bigInt = quotient
164 | builder.append(STEALTH_ALPHABET[remainder.toInt()])
165 | }
166 | // 因为是从低位开始添加的，所以需要反转得到正确的顺序
167 | return builder.reverse().toString()
168 | }
169 |
170 | /**
171 | * 将我们自定义的 BaseN 字符串解码回字节数组。
172 | * 算法核心：通过大数运算，将 BaseN 的数据转换回 Base256。
173 | * @param encodedString 编码后的“猫语”字符串，可能混杂有其他字符。
174 | * @return 原始二进制数据。
175 | */
176 | private fun baseNDecode(encodedString: String): ByteArray {
177 | var bigInt = BigInteger.ZERO
178 | val base = BigInteger.valueOf(STEALTH_ALPHABET.length.toLong())
179 | // 遍历字符串，只处理在“猫语字典”中存在的字符
180 | // 乘基加权法。
181 | encodedString.forEach { char ->
182 | val index = STEALTH_CHAR_TO_INDEX_MAP[char]
183 | if (index != null) {
184 | // 核心算法: result = result * base + index
185 | bigInt = bigInt.multiply(base).add(BigInteger.valueOf(index.toLong()))
186 | }
187 | }
188 | // 如果解码结果为0，直接返回空数组
189 | if (bigInt == BigInteger.ZERO) return ByteArray(0)
190 |
191 | // BigInteger.toByteArray() 可能会在开头添加一个0字节来表示正数，我们需要去掉它
192 | val bytes = bigInt.toByteArray()
193 | return if (bytes[0].toInt() == 0) {
194 | bytes.copyOfRange(1, bytes.size)
195 | } else { bytes }
196 | }
197 |
198 | // -- 通过inputStream和outputStream来流式解密 --
199 | /**
200 | * 为 AES/GCM 实现的、真正安全的流式解密方法
201 | * 它会从输入流中读取加密数据，解密后写入输出流。
202 | * @param inputStream 包含加密数据的输入流 (必须是已经跳过GIF头的数据)
203 | * @param outputStream 用于写入解密后数据的输出流
204 | * @param key 用于解密的密钥
205 | */
206 | fun decryptStream(inputStream: InputStream, outputStream: OutputStream, key: String){
207 | val iv = ByteArray(IV_LENGTH_BYTES)
208 | require(inputStream.read(iv) == IV_LENGTH_BYTES) {
209 | "输入流太短，无法读取IV。"
210 | }
211 |
212 | // 2. 初始化 Cipher
213 | val cipher = Cipher.getInstance(TRANSFORMATION).apply {
214 | val spec = GCMParameterSpec(TAG_LENGTH_BITS, iv)
215 | init(Cipher.DECRYPT_MODE, deriveKeyFromString(key), spec)
216 | }
217 |
218 | // 3. 边读边解密边写
219 | val buffer = ByteArray(8 * 1024)
220 | while (true) {
221 | val read = inputStream.read(buffer)
222 | if (read == -1) break
223 | cipher.update(buffer, 0, read)?.let { outputStream.write(it) }
224 | }
225 |
226 | // 4. 关键！在所有数据都处理完后，调用 doFinal 来验证“防伪标签”
227 | try {
228 | cipher.doFinal()?.let { outputStream.write(it) } // 验证通过后，就doFinal做检验，校验不过抛出错误。
229 | } catch (e: AEADBadTagException) {
230 | throw SecurityException("解密失败，数据可能被篡改或密钥错误", e)
231 | }
232 | }
233 |
234 | /**
235 | * ✨ 全新：根据用户设置，为密文应用伪装文本样式。
236 | *
237 | * @return 伪装后的、包含随机语言和真实密文的最终字符串。
238 | */
239 | fun String.applyCiphertextStyle(): String {
240 | // 拿到对应枚举类
241 | val styleType: CiphertextStyleType = CiphertextStyleType.fromName(ciphertextStyleType)
242 | // 3. 获取该风格下的所有可用词组
243 | val content = styleType.content
244 | // 管理最大最小值
245 | val finalMin = minOf(ciphertextStyleLengthMin, ciphertextStyleLengthMax)
246 | val finalMax = maxOf(ciphertextStyleLengthMin, ciphertextStyleLengthMax)
247 | // 如果 finalMin 和 finalMax 相等，直接取这个值，否则在范围内取随机数
248 | val count = if (finalMin == finalMax) finalMin else Random.nextInt(finalMin, finalMax + 1)
249 |
250 | // 5. 随机挑选词组并拼接成伪装文本
251 | val decorativeText = buildString {
252 | repeat(count) {
253 | append(content.random())
254 | }
255 | }
256 |
257 | val middleIndex = decorativeText.length / 2
258 | return decorativeText.substring(0, middleIndex) + this + decorativeText.substring(middleIndex)
259 | }
260 |
261 | }
262 |
263 | enum class CiphertextStyleType(val displayNameResId:Int,val content:List){
264 | NEKO(
265 | displayNameResId = R.string.cipher_style_neko, // 猫娘语
266 | content = listOf("嗷呜!", "咕噜~", "喵~", "喵咕~", "喵喵~", "喵?", "喵喵！", "哈！", "喵呜...", "咪咪喵！", "咕咪?")
267 | ),
268 | BANGBOO(
269 | displayNameResId = R.string.cipher_style_bangboo, // 邦布语
270 | content = listOf("嗯呢...", "哇哒！", "嗯呢！", "嗯呢哒！", "嗯呐呐！", "嗯哒！", "嗯呢呢！")
271 | ),
272 | HILICHURLIAN(
273 | displayNameResId = R.string.cipher_style_Hilichurlian, //丘丘语
274 | content = listOf("Muhe ye!", "Ye dada!", "Ya yika!", "Biat ye！", "Dala si？", "Yaya ika！", "Mi? Dada!",
275 | "ye pupu!", "gusha dada!","Dala？","Mosi mita！","Mani ye！","Biat ye！","Todo yo.","tiga mitono!","Biat, gusha!","Unu dada!","Mimi movo!")
276 | ),
277 | NIER(
278 | displayNameResId = R.string.cipher_style_nier, // 尼尔语
279 | content = listOf(
280 | "Ee ", "ser ", "les ", "hii ", "san ", "mia ", "ni ", "Escalei ", "lu ", "push ", "to ", "lei ",
281 | "Schmosh ", "juna ", "wu ", "ria ", "e ", "je ", "cho ", "no ",
282 | "Nasico ", "whosh ", "pier ", "wa ", "nei ", "Wananba ", "he ", "na ", "qua ", "lei ",
283 | "Sila ", "schmer ", "ya ", "pi ", "pa ", "lu ", "Un ", "schen ", "ta ", "tii ", "pia ", "pa ", "ke ", "lo ")
284 | ),
285 | MANBO(
286 | displayNameResId = R.string.cipher_style_manbo, // 曼波！
287 | content = listOf("曼波~","哈吉米~","哈吉米咩那咩路多~","曼波!","曼波...","欧码叽哩，曼波！","叮咚鸡！","哈压库！","哈压库~","哈吉米！","哦耶~","duang~")
288 | );
289 | companion object{
290 | // 辅助函数
291 | fun fromName(name:String): CiphertextStyleType{
292 | return entries.find { it.name == name.uppercase(getDefault()) } ?:NEKO
293 | }
294 | }
295 | }
--------------------------------------------------------------------------------
/app/src/main/java/me/wjz/nekocrypt/ui/component/DecryptionPopup.kt:
--------------------------------------------------------------------------------
1 | package me.wjz.nekocrypt.ui.component
2 |
3 | import androidx.compose.animation.AnimatedVisibility
4 | import androidx.compose.animation.core.Animatable
5 | import androidx.compose.animation.core.LinearEasing
6 | import androidx.compose.animation.core.Spring
7 | import androidx.compose.animation.core.spring
8 | import androidx.compose.animation.core.tween
9 | import androidx.compose.animation.fadeIn
10 | import androidx.compose.animation.fadeOut
11 | import androidx.compose.animation.scaleIn
12 | import androidx.compose.animation.scaleOut
13 | import androidx.compose.foundation.BorderStroke
14 | import androidx.compose.foundation.layout.Box
15 | import androidx.compose.foundation.layout.Row
16 | import androidx.compose.foundation.layout.Spacer
17 | import androidx.compose.foundation.layout.padding
18 | import androidx.compose.foundation.layout.size
19 | import androidx.compose.foundation.layout.width
20 | import androidx.compose.foundation.layout.wrapContentSize
21 | import androidx.compose.foundation.layout.wrapContentWidth
22 | import androidx.compose.foundation.shape.RoundedCornerShape
23 | import androidx.compose.material.icons.Icons
24 | import androidx.compose.material.icons.filled.Close
25 | import androidx.compose.material.icons.filled.FileOpen
26 | import androidx.compose.material.icons.filled.Image
27 | import androidx.compose.material3.ButtonDefaults
28 | import androidx.compose.material3.Card
29 | import androidx.compose.material3.CardDefaults
30 | import androidx.compose.material3.CircularProgressIndicator
31 | import androidx.compose.material3.Icon
32 | import androidx.compose.material3.IconButton
33 | import androidx.compose.material3.MaterialTheme
34 | import androidx.compose.material3.Text
35 | import androidx.compose.material3.TextButton
36 | import androidx.compose.runtime.Composable
37 | import androidx.compose.runtime.LaunchedEffect
38 | import androidx.compose.runtime.getValue
39 | import androidx.compose.runtime.mutableStateOf
40 | import androidx.compose.runtime.remember
41 | import androidx.compose.runtime.setValue
42 | import androidx.compose.ui.Alignment
43 | import androidx.compose.ui.Modifier
44 | import androidx.compose.ui.draw.shadow
45 | import androidx.compose.ui.geometry.Offset
46 | import androidx.compose.ui.graphics.Shadow
47 | import androidx.compose.ui.text.TextStyle
48 | import androidx.compose.ui.unit.dp
49 | import androidx.compose.ui.unit.sp
50 | import kotlinx.coroutines.delay
51 | import me.wjz.nekocrypt.service.handler.LocalFileActionHandler
52 | import me.wjz.nekocrypt.ui.theme.NekoCryptTheme
53 | import me.wjz.nekocrypt.util.NCFileProtocol
54 | import me.wjz.nekocrypt.util.NCFileType
55 |
56 |
57 | /**
58 | * 一个独立的、可复用的解密弹窗 Composable UI
59 | * 它只关心需要显示什么文本 (text)，以及被关闭时该做什么 (onDismiss)。
60 | * 它完全不知道什么是无障碍服务，什么是处理器。
61 | */
62 | @Composable
63 | fun DecryptionPopup(
64 | decryptedText: String, durationMills: Long = 3000, onDismiss: () -> Unit,
65 | ) {
66 | // 增加判断，看需要展示纯文本还是图片or文件。
67 | val fileProtocol: NCFileProtocol? = NCFileProtocol.fromString(decryptedText)
68 |
69 | if (fileProtocol != null) {
70 | // --- 情况A：是文件协议，并且成功解析 ---
71 | DecryptedFilePopupContent(
72 | fileInfo = fileProtocol,
73 | onDismiss = onDismiss,
74 | durationMills = durationMills
75 | )
76 | } else {
77 | // --- 情况B：是普通文本，或者协议解析失败 ---
78 | DecryptedTextPopupContent(
79 | text = decryptedText,
80 | onDismiss = onDismiss,
81 | durationMills = durationMills
82 | )
83 | }
84 | }
85 |
86 |
87 | /**
88 | * 负责显示普通文本的弹窗
89 | */
90 | @Composable
91 | private fun DecryptedTextPopupContent(
92 | text: String,
93 | onDismiss: () -> Unit,
94 | durationMills: Long,
95 | ) {
96 | val animationTime = 250
97 | var isVisible by remember { mutableStateOf(false) }
98 | val progress = remember { Animatable(1.0f) }
99 |
100 | LaunchedEffect(Unit) {
101 | isVisible = true // 触发出现
102 | progress.animateTo(
103 | 0.0f,
104 | animationSpec = tween(durationMills.toInt(), easing = LinearEasing)
105 | )
106 | isVisible = false // 倒计时结束后，触发消失
107 | }
108 |
109 | LaunchedEffect(isVisible) {
110 | if (!isVisible) {
111 | delay(animationTime.toLong()) // 等待消失动画播放完毕
112 | onDismiss() // 动画完全结束后，才真正调用 onDismiss
113 | }
114 | }
115 |
116 | NekoCryptTheme(darkTheme = false) {
117 | Box(modifier = Modifier.padding(16.dp)) {
118 | AnimatedVisibility(
119 | visible = isVisible,
120 | enter = scaleIn(
121 | animationSpec = spring(
122 | dampingRatio = Spring.DampingRatioLowBouncy,
123 | stiffness = Spring.StiffnessLow
124 | )
125 | ) + fadeIn(animationSpec = tween(animationTime)),
126 | exit = scaleOut(animationSpec = tween(animationTime)) + fadeOut(
127 | animationSpec = tween(animationTime)
128 | )
129 | ) {
130 | Card(
131 | modifier = Modifier
132 | .wrapContentSize()
133 | .shadow(elevation = 8.dp, shape = RoundedCornerShape(12.dp)),
134 | shape = RoundedCornerShape(12.dp),
135 | colors = CardDefaults.cardColors(
136 | containerColor = MaterialTheme.colorScheme.surfaceContainerHighest.copy(
137 | alpha = 0.92f
138 | )
139 | ),
140 | border = BorderStroke(
141 | 1.dp,
142 | MaterialTheme.colorScheme.outline.copy(alpha = 0.8f)
143 | )
144 | ) {
145 | Row(
146 | modifier = Modifier.padding(
147 | start = 12.dp,
148 | top = 8.dp,
149 | bottom = 8.dp,
150 | end = 8.dp
151 | ),
152 | verticalAlignment = Alignment.CenterVertically
153 | ) {
154 | Text(
155 | text = text,
156 | fontSize = 18.sp,
157 | color = MaterialTheme.colorScheme.primary,
158 | style = TextStyle(
159 | shadow = Shadow(
160 | color = MaterialTheme.colorScheme.onPrimary.copy(
161 | alpha = 0.5f
162 | ), offset = Offset(2f, 2f), blurRadius = 4f
163 | )
164 | ),
165 | modifier = Modifier.weight(1f, fill = false)
166 | )
167 | Spacer(modifier = Modifier.width(8.dp))
168 | Box(
169 | contentAlignment = Alignment.Center,
170 | modifier = Modifier.size(25.dp)
171 | ) {
172 | CircularProgressIndicator(
173 | progress = { progress.value },
174 | modifier = Modifier.size(25.dp),
175 | color = MaterialTheme.colorScheme.primary,
176 | strokeWidth = 2.dp
177 | )
178 | IconButton(onClick = {
179 | isVisible = false
180 | }) {
181 | Icon(
182 | Icons.Default.Close,
183 | contentDescription = "关闭",
184 | tint = MaterialTheme.colorScheme.onSurfaceVariant
185 | )
186 | }
187 | }
188 | }
189 | }
190 | }
191 | }
192 | }
193 | }
194 |
195 |
196 | /**
197 | * 文件展示，包含图片和普通文件。
198 | */
199 | @Composable
200 | private fun DecryptedFilePopupContent(
201 | fileInfo: NCFileProtocol,
202 | onDismiss: () -> Unit,
203 | durationMills: Long,
204 | ) {
205 | val animationTime = 250
206 | var isVisible by remember { mutableStateOf(false) }
207 | val progress = remember { Animatable(1.0f) }
208 |
209 | LaunchedEffect(Unit) {
210 | isVisible = true // 触发出现
211 | progress.animateTo(
212 | 0.0f,
213 | animationSpec = tween(durationMills.toInt(), easing = LinearEasing)
214 | )
215 | isVisible = false // 倒计时结束后，触发消失
216 | }
217 |
218 | LaunchedEffect(isVisible) {
219 | if (!isVisible) {
220 | delay(animationTime.toLong()) // 等待消失动画播放完毕
221 | onDismiss() // 动画完全结束后，才真正调用 onDismiss
222 | }
223 | }
224 |
225 | NekoCryptTheme(darkTheme = false) {
226 | Box(modifier = Modifier.padding(16.dp)) {
227 | AnimatedVisibility(
228 | visible = isVisible,
229 | enter = scaleIn(
230 | animationSpec = spring(
231 | dampingRatio = Spring.DampingRatioLowBouncy,
232 | stiffness = Spring.StiffnessLow
233 | )
234 | ) + fadeIn(animationSpec = tween(animationTime)),
235 | exit = scaleOut(animationSpec = tween(animationTime)) + fadeOut(
236 | animationSpec = tween(animationTime)
237 | )
238 | ) {
239 | Card(
240 | modifier = Modifier
241 | .wrapContentSize()
242 | .shadow(elevation = 8.dp, shape = RoundedCornerShape(12.dp)),
243 | shape = RoundedCornerShape(12.dp),
244 | colors = CardDefaults.cardColors(
245 | containerColor = MaterialTheme.colorScheme.surfaceContainerHighest.copy(
246 | alpha = 0.92f
247 | )
248 | ),
249 | border = BorderStroke(
250 | 1.dp,
251 | MaterialTheme.colorScheme.outline.copy(alpha = 0.8f)
252 | )
253 | ) {
254 | Row(
255 | modifier = Modifier.padding(
256 | start = 12.dp,
257 | top = 8.dp,
258 | bottom = 8.dp,
259 | end = 8.dp
260 | ),
261 | verticalAlignment = Alignment.CenterVertically
262 | ) {
263 | // 用来显示文件or图片
264 | FileButton(fileInfo)
265 |
266 | Spacer(modifier = Modifier.width(8.dp))
267 | Box(
268 | contentAlignment = Alignment.Center,
269 | modifier = Modifier.size(25.dp)
270 | ) {
271 | CircularProgressIndicator(
272 | progress = { progress.value },
273 | modifier = Modifier.size(25.dp),
274 | color = MaterialTheme.colorScheme.primary,
275 | strokeWidth = 2.dp
276 | )
277 | IconButton(onClick = {
278 | isVisible = false
279 | }) {
280 | Icon(
281 | Icons.Default.Close,
282 | contentDescription = "关闭",
283 | tint = MaterialTheme.colorScheme.onSurfaceVariant
284 | )
285 | }
286 | }
287 | }
288 | }
289 | }
290 | }
291 | }
292 | }
293 |
294 | @Composable
295 | fun FileButton(
296 | fileInfo: NCFileProtocol,
297 | ) {
298 | val onFileClick = LocalFileActionHandler.current
299 |
300 | TextButton(
301 | onClick = {
302 | onFileClick?.invoke(fileInfo)
303 | },
304 | modifier = Modifier.wrapContentWidth(),
305 | shape = RoundedCornerShape(12.dp),
306 | colors = ButtonDefaults.textButtonColors(
307 | containerColor = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.95f)
308 | ),
309 | border = BorderStroke(1.dp, MaterialTheme.colorScheme.outline.copy(alpha = 0.8f))
310 | ) {
311 | when (fileInfo.type) {
312 | NCFileType.IMAGE -> Icon(
313 | Icons.Default.Image,
314 | contentDescription = "click to show image"
315 | )
316 |
317 | NCFileType.FILE -> Icon(
318 | Icons.Default.FileOpen,
319 | contentDescription = "click to show file"
320 | )
321 | }
322 | Spacer(Modifier.width(8.dp))
323 | Text(
324 | text = fileInfo.name,
325 | fontSize = 18.sp,
326 | color = MaterialTheme.colorScheme.primary,
327 | style = TextStyle(
328 | shadow = Shadow(
329 | color = MaterialTheme.colorScheme.onPrimary.copy(alpha = 0.5f),
330 | offset = Offset(2f, 2f),
331 | blurRadius = 4f
332 | )
333 | ),
334 | modifier = Modifier.weight(1f, fill = false)
335 | )
336 | }
337 | }
338 |
--------------------------------------------------------------------------------
/app/src/main/java/me/wjz/nekocrypt/ui/screen/SettingsScreen.kt:
--------------------------------------------------------------------------------
1 | package me.wjz.nekocrypt.ui.screen
2 |
3 | import android.content.Context
4 | import android.content.Intent
5 | import android.util.Log
6 | import android.widget.Toast
7 | import androidx.compose.foundation.layout.Column
8 | import androidx.compose.foundation.layout.fillMaxSize
9 | import androidx.compose.foundation.layout.padding
10 | import androidx.compose.foundation.lazy.LazyColumn
11 | import androidx.compose.material.icons.Icons
12 | import androidx.compose.material.icons.filled.Build
13 | import androidx.compose.material.icons.filled.Info
14 | import androidx.compose.material.icons.filled.Link
15 | import androidx.compose.material.icons.outlined.GraphicEq
16 | import androidx.compose.material.icons.outlined.Timer
17 | import androidx.compose.material3.AlertDialog
18 | import androidx.compose.material3.DividerDefaults
19 | import androidx.compose.material3.HorizontalDivider
20 | import androidx.compose.material3.Icon
21 | import androidx.compose.material3.Text
22 | import androidx.compose.material3.TextButton
23 | import androidx.compose.runtime.Composable
24 | import androidx.compose.runtime.getValue
25 | import androidx.compose.runtime.mutableStateOf
26 | import androidx.compose.runtime.remember
27 | import androidx.compose.runtime.rememberCoroutineScope
28 | import androidx.compose.runtime.setValue
29 | import androidx.compose.ui.Modifier
30 | import androidx.compose.ui.platform.LocalContext
31 | import androidx.compose.ui.res.stringResource
32 | import androidx.compose.ui.unit.dp
33 | import androidx.core.net.toUri
34 | import kotlinx.coroutines.CoroutineScope
35 | import kotlinx.coroutines.Dispatchers
36 | import kotlinx.coroutines.launch
37 | import kotlinx.coroutines.withContext
38 | import kotlinx.serialization.SerialName
39 | import kotlinx.serialization.Serializable
40 | import kotlinx.serialization.json.Json
41 | import me.wjz.nekocrypt.NekoCryptApp
42 | import me.wjz.nekocrypt.R
43 | import me.wjz.nekocrypt.SettingKeys
44 | import me.wjz.nekocrypt.ui.ClickableSettingItem
45 | import me.wjz.nekocrypt.ui.ColorSettingItem
46 | import me.wjz.nekocrypt.ui.RangeSliderSettingItem
47 | import me.wjz.nekocrypt.ui.SettingsHeader
48 | import me.wjz.nekocrypt.ui.SliderSettingItem
49 | import java.io.BufferedReader
50 | import java.net.HttpURLConnection
51 | import java.net.URL
52 |
53 | @Composable
54 | fun SettingsScreen(modifier: Modifier = Modifier) {
55 | var showAboutDialog by remember { mutableStateOf(false) }
56 | val context = LocalContext.current
57 | val scope = rememberCoroutineScope() // 获取协程作用域，用于执行异步任务
58 | LazyColumn(
59 | modifier = modifier.fillMaxSize(),
60 | // verticalArrangement = Arrangement.spacedBy(16.dp), 选项之间不需要间隔
61 | ) {
62 | // 第一个分组：加解密设置
63 | item {
64 | SettingsHeader(stringResource(R.string.crypto_settings))
65 | }
66 | item {
67 | HorizontalDivider(
68 | modifier = Modifier.padding(horizontal = 16.dp),
69 | thickness = DividerDefaults.Thickness,
70 | color = DividerDefaults.color
71 | )
72 | }
73 | item {
74 | SliderSettingItem( // 长按发送密文所需时间
75 | key = SettingKeys.ENCRYPTION_LONG_PRESS_DELAY,
76 | defaultValue = 500L, // 默认 500 毫秒
77 | icon = { Icon(Icons.Outlined.Timer, contentDescription = "Long Press Delay") },
78 | title = stringResource(R.string.decryption_long_press_delay),
79 | subtitle = stringResource(R.string.decryption_long_press_delay_desc),
80 | valueRange = 50L..1000L, // 允许用户在 200ms 到 1500ms 之间选择
81 | step = 50L //每50ms一个挡位
82 | )
83 | }
84 | item {
85 | HorizontalDivider(
86 | modifier = Modifier.padding(horizontal = 16.dp),
87 | thickness = DividerDefaults.Thickness,
88 | color = DividerDefaults.color
89 | )
90 | }
91 | item {
92 | SliderSettingItem( // 点击密文解密的所需时间。
93 | key = SettingKeys.DECRYPTION_WINDOW_SHOW_TIME,
94 | defaultValue = 500L, // 默认 500 毫秒
95 | icon = { Icon(Icons.Outlined.Timer, contentDescription = "Long Press Delay") },
96 | title = stringResource(R.string.decryption_window_show_time),
97 | subtitle = stringResource(R.string.decryption_window_show_time_desc),
98 | valueRange = 500L..3000L,
99 | step = 250L // 单步步长
100 | )
101 | }
102 | item {
103 | HorizontalDivider(
104 | modifier = Modifier.padding(horizontal = 16.dp),
105 | thickness = DividerDefaults.Thickness,
106 | color = DividerDefaults.color
107 | )
108 | }
109 | item {
110 | // 区间选择器
111 | RangeSliderSettingItem(
112 | minKey = SettingKeys.CIPHERTEXT_STYLE_LENGTH_MIN,
113 | maxKey = SettingKeys.CIPHERTEXT_STYLE_LENGTH_MAX,
114 | defaultMin = 3,
115 | defaultMax = 7,
116 | icon = { Icon(Icons.Outlined.GraphicEq, contentDescription = "Ciphertext Length") },
117 | title = stringResource(R.string.ciphertext_length_title),
118 | subtitle = stringResource(R.string.ciphertext_length_subtitle),
119 | valueRange = 1..10,
120 | step = 1
121 | )
122 | }
123 | item {
124 | HorizontalDivider(
125 | modifier = Modifier.padding(horizontal = 16.dp),
126 | thickness = DividerDefaults.Thickness,
127 | color = DividerDefaults.color
128 | )
129 | }
130 | // ————————————————————————————————
131 |
132 | // 第二个分组，界面相关设置
133 | item {
134 | SettingsHeader(stringResource(R.string.crypto_ui_settings))
135 | }
136 | item {
137 | HorizontalDivider(
138 | modifier = Modifier.padding(horizontal = 16.dp),
139 | thickness = DividerDefaults.Thickness,
140 | color = DividerDefaults.color
141 | )
142 | }
143 | item {
144 | SliderSettingItem( // 沉浸式下，密文位置更新间隔
145 | key = SettingKeys.DECRYPTION_WINDOW_POSITION_UPDATE_DELAY,
146 | defaultValue = 250L, // 默认 250
147 | icon = { Icon(Icons.Outlined.Timer, contentDescription = "position update delay") },
148 | title = stringResource(R.string.decryption_window_position_update_delay),
149 | subtitle = stringResource(R.string.decryption_window_position_update_delay_desc),
150 | valueRange = 0L..1000L,
151 | step = 50L // 单步步长
152 | )
153 | }
154 | item {
155 | HorizontalDivider(
156 | modifier = Modifier.padding(horizontal = 16.dp),
157 | thickness = DividerDefaults.Thickness,
158 | color = DividerDefaults.color
159 | )
160 | }
161 | // ————————————————————————————————
162 | item {
163 | ColorSettingItem(
164 | key = SettingKeys.SEND_BTN_OVERLAY_COLOR,
165 | defaultValue = "#5066ccff",
166 | title = stringResource(R.string.send_btn_overlay_color),
167 | subtitle = stringResource(R.string.send_btn_overlay_color_desc)
168 | )
169 | }
170 | item {
171 | HorizontalDivider(
172 | modifier = Modifier.padding(horizontal = 16.dp),
173 | thickness = DividerDefaults.Thickness,
174 | color = DividerDefaults.color
175 | )
176 | }
177 | item {
178 | SliderSettingItem( // 控制拉起附件发送悬浮窗的时间间隔。
179 | key = SettingKeys.SHOW_ATTACHMENT_VIEW_DOUBLE_CLICK_THRESHOLD,
180 | defaultValue = 250L,
181 | icon = { Icon(Icons.Outlined.Timer, contentDescription = "Long Press Delay") },
182 | title = stringResource(R.string.double_click_threshold),
183 | subtitle = stringResource(R.string.double_click_threshold_desc),
184 | valueRange = 250L..1000L, // 允许用户在 200ms 到 1500ms 之间选择
185 | step = 250L //每50ms一个挡位
186 | )
187 | }
188 | item {
189 | HorizontalDivider(
190 | modifier = Modifier.padding(horizontal = 16.dp),
191 | thickness = DividerDefaults.Thickness,
192 | color = DividerDefaults.color
193 | )
194 | }
195 |
196 | // 第二个分组：关于
197 | item {
198 | SettingsHeader("关于")
199 | }
200 | item {
201 | ClickableSettingItem(
202 | icon = { Icon(Icons.Default.Info, contentDescription = "About App") },
203 | title = "关于 NekoCrypt",
204 | onClick = { showAboutDialog=true }
205 | )
206 | }
207 | item {
208 | HorizontalDivider(
209 | modifier = Modifier.padding(horizontal = 16.dp),
210 | thickness = DividerDefaults.Thickness,
211 | color = DividerDefaults.color
212 | )
213 | }
214 | item {
215 | val versionName = context.packageManager.getPackageInfo(context.packageName, 0).versionName
216 | ClickableSettingItem(
217 | icon = { Icon(Icons.Default.Build, contentDescription = "Version") },
218 | // ✨ 在 title 的 Composable 槽位里，自定义我们的布局！
219 | title = stringResource(R.string.version,versionName?:"unknown"),
220 | onClick = { handleCheckUpdate(context, scope, versionName?:"N/A") }
221 | )
222 | }
223 | item {
224 | HorizontalDivider(
225 | modifier = Modifier.padding(horizontal = 16.dp),
226 | thickness = DividerDefaults.Thickness,
227 | color = DividerDefaults.color
228 | )
229 | }
230 | item {
231 | ClickableSettingItem(
232 | icon = { Icon(Icons.Default.Link, contentDescription = "GitHub Link") },
233 | title = stringResource(R.string.github),
234 | onClick = {
235 | val intent = Intent(Intent.ACTION_VIEW, "https://github.com/WJZ-P/NekoCrypt".toUri())
236 | context.startActivity(intent)
237 | }
238 | )
239 | }
240 |
241 | }
242 |
243 | if(showAboutDialog){
244 | AboutDialog(onDismissRequest = {showAboutDialog = false})
245 | }
246 | }
247 |
248 | /**
249 | * 用于显示关于信息的对话框
250 | */
251 | @Composable
252 | private fun AboutDialog(onDismissRequest: () -> Unit) {
253 | AlertDialog(
254 | onDismissRequest = onDismissRequest,
255 | icon = { Icon(Icons.Default.Info, contentDescription = null) },
256 | title = { Text(text = stringResource(R.string.about_dialog_title)) },
257 | text = {
258 | Column {
259 | Text(stringResource(R.string.about_dialog_content))
260 | // 你可以在这里添加更多信息，比如版本号、作者、开源链接等
261 | }
262 | },
263 | confirmButton = {
264 | TextButton(onClick = onDismissRequest) {
265 | Text(stringResource(R.string.accept))
266 | }
267 | }
268 | )
269 | }
270 |
271 | /**
272 | * 一个用于解析 GitHub API /releases/latest 端点返回的 JSON 的数据类。
273 | * @Serializable 注解让它可以被 kotlinx.serialization 库处理。
274 | * @SerialName 注解用于将 JSON 中的 snake_case 字段名映射到我们的 camelCase 属性名。
275 | */
276 | @Serializable
277 | data class GitHubRelease(
278 | @SerialName("tag_name")
279 | val tagName: String, // 版本标签，例如 "v1.1.0"
280 |
281 | @SerialName("html_url")
282 | val htmlUrl: String, // 该发布页面的网址
283 | )
284 |
285 | private fun handleCheckUpdate(context: Context, scope: CoroutineScope, versionName: String) {
286 | scope.launch {
287 | withContext(Dispatchers.Main) {
288 | Toast.makeText(context, context.getString(R.string.checking_for_update), Toast.LENGTH_SHORT).show()
289 | }
290 |
291 | // 切换到 IO 线程执行网络请求
292 | val latestRelease: GitHubRelease? = withContext(Dispatchers.IO) {
293 | try {
294 | val url = URL("https://api.github.com/repos/WJZ-P/NekoCrypt/releases/latest")
295 | val connection = url.openConnection() as HttpURLConnection
296 | val jsonText = connection.inputStream.bufferedReader().use(BufferedReader::readText)
297 | Log.d(NekoCryptApp.TAG,jsonText)
298 |
299 | // 使用 kotlinx.serialization 解析 JSON
300 | Json { ignoreUnknownKeys = true }.decodeFromString(jsonText)
301 |
302 | } catch (e: Exception) {
303 | e.printStackTrace()
304 | null
305 | }
306 | }
307 |
308 | // 回到主线程更新 UI
309 | withContext(Dispatchers.Main) {
310 | if (latestRelease == null) {
311 | Toast.makeText(context, context.getString(R.string.check_for_update_failed), Toast.LENGTH_SHORT).show()
312 | return@withContext
313 | }
314 |
315 | // 比较版本号（简单地移除 'v' 前缀进行比较）
316 | val latestVersionName = latestRelease.tagName.removePrefix("v")
317 |
318 | if (versionName != "N/A" && latestVersionName > versionName) {
319 | Toast.makeText(context, context.getString(R.string.check_for_update_failed,latestRelease.tagName), Toast.LENGTH_SHORT).show()
320 | // 引导用户去发布页面查看
321 | val intent = Intent(Intent.ACTION_VIEW, latestRelease.htmlUrl.toUri())
322 | context.startActivity(intent)
323 | } else {
324 | Toast.makeText(context, context.getString(R.string.is_newest_version), Toast.LENGTH_SHORT).show()
325 | }
326 | }
327 | }
328 | }
--------------------------------------------------------------------------------
/app/src/main/java/me/wjz/nekocrypt/ui/component/CapPawButton.kt:
--------------------------------------------------------------------------------
1 | package me.wjz.nekocrypt.ui.component
2 |
3 | import android.annotation.SuppressLint
4 | import androidx.compose.animation.AnimatedContent
5 | import androidx.compose.animation.SizeTransform
6 | import androidx.compose.animation.animateColorAsState
7 | import androidx.compose.animation.core.animateDpAsState
8 | import androidx.compose.animation.core.animateFloatAsState
9 | import androidx.compose.animation.core.tween
10 | import androidx.compose.animation.fadeIn
11 | import androidx.compose.animation.fadeOut
12 | import androidx.compose.animation.slideInVertically
13 | import androidx.compose.animation.slideOutVertically
14 | import androidx.compose.animation.togetherWith
15 | import androidx.compose.foundation.Canvas
16 | import androidx.compose.foundation.clickable
17 | import androidx.compose.foundation.interaction.MutableInteractionSource
18 | import androidx.compose.foundation.layout.Arrangement
19 | import androidx.compose.foundation.layout.BoxWithConstraints
20 | import androidx.compose.foundation.layout.Column
21 | import androidx.compose.foundation.layout.fillMaxSize
22 | import androidx.compose.foundation.layout.size
23 | import androidx.compose.foundation.shape.CircleShape
24 | import androidx.compose.material3.MaterialTheme
25 | import androidx.compose.material3.Surface
26 | import androidx.compose.material3.Text
27 | import androidx.compose.runtime.Composable
28 | import androidx.compose.runtime.LaunchedEffect
29 | import androidx.compose.runtime.getValue
30 | import androidx.compose.runtime.mutableFloatStateOf
31 | import androidx.compose.runtime.remember
32 | import androidx.compose.runtime.setValue
33 | import androidx.compose.runtime.withFrameNanos
34 | import androidx.compose.ui.Alignment
35 | import androidx.compose.ui.Modifier
36 | import androidx.compose.ui.draw.clip
37 | import androidx.compose.ui.draw.shadow
38 | import androidx.compose.ui.geometry.Offset
39 | import androidx.compose.ui.geometry.Size
40 | import androidx.compose.ui.graphics.Brush
41 | import androidx.compose.ui.graphics.StrokeCap
42 | import androidx.compose.ui.graphics.drawscope.Stroke
43 | import androidx.compose.ui.graphics.drawscope.rotate
44 | import androidx.compose.ui.text.font.FontWeight
45 | import androidx.compose.ui.text.style.TextAlign
46 | import androidx.compose.ui.unit.dp
47 | import androidx.compose.ui.unit.min
48 | import androidx.compose.ui.unit.sp
49 |
50 | private object CatPawDefaults {
51 | const val RING_STROKE_WIDTH = 14f // 外围圆弧段落粗度
52 | const val PAW_STROKE_WIDTH = 15f
53 | const val DESIGN_BASIS_DP = 290f
54 |
55 | // --- 尺寸比例 ---
56 | const val RING_ENABLED_RATIO = 1f // 激活时外圈尺寸比例 (等于基准大小)
57 | const val RING_DISABLED_RATIO = 270f / DESIGN_BASIS_DP // 未激活时外圈的尺寸比例
58 | const val CENTER_BUTTON_RATIO = 260f / DESIGN_BASIS_DP
59 | const val PAW_CANVAS_RATIO = 110f / DESIGN_BASIS_DP
60 |
61 | // --- 字体大小比例 ---
62 | const val FONT_SIZE_RATIO = 20f / DESIGN_BASIS_DP
63 | const val MIN_FONT_SIZE_SP = 12f
64 |
65 | // --- 猫爪内部绘制比例 (相对于猫爪Canvas) ---
66 | const val PALM_WIDTH_RATIO = 0.6f
67 | const val PALM_HEIGHT_RATIO = 0.45f
68 | const val PALM_Y_OFFSET_RATIO = 0.2f
69 | const val TOE_RADIUS_RATIO = 0.1f
70 |
71 | // --- 猫爪脚趾基础位置比例 (相对于猫爪Canvas) ---
72 | const val OUTER_TOE_X_RATIO = 0.35f
73 | const val OUTER_TOE_Y_RATIO = 0.08f
74 | const val INNER_TOE_X_RATIO = 0.15f
75 | const val INNER_TOE_Y_RATIO = 0.25f
76 |
77 | // --- 猫爪脚趾激活状态位移 (基于原始设计尺寸) ---
78 | const val PALM_Y_SHIFT = -10f
79 | const val OUTER_LEFT_TOE_X_SHIFT = -18f
80 | const val OUTER_LEFT_TOE_Y_SHIFT = -15f
81 | const val INNER_LEFT_TOE_X_SHIFT = -10f
82 | const val INNER_LEFT_TOE_Y_SHIFT = -25f
83 | const val INNER_RIGHT_TOE_X_SHIFT = 10f
84 | const val INNER_RIGHT_TOE_Y_SHIFT = -25f
85 | const val OUTER_RIGHT_TOE_X_SHIFT = 18f
86 | const val OUTER_RIGHT_TOE_Y_SHIFT = -15f
87 | }
88 |
89 | /**
90 | * ✨ 响应式猫爪按钮
91 | * 它会根据父组件提供的空间，自动调整自身大小和内部所有元素的比例。
92 | */
93 | @SuppressLint("UnusedBoxWithConstraintsScope")
94 | @Composable
95 | fun CatPawButton(
96 | isEnabled: Boolean,
97 | statusText: String,
98 | onClick: () -> Unit,
99 | modifier: Modifier = Modifier,
100 | ) {
101 | BoxWithConstraints(
102 | modifier = modifier,
103 | contentAlignment = Alignment.Center
104 | ) {
105 | val baseSize = min(maxWidth, maxHeight)
106 | val scaleFactor = baseSize.value / CatPawDefaults.DESIGN_BASIS_DP
107 |
108 | // --- 动画状态 ---
109 | val ringSize by animateDpAsState(
110 | targetValue = if (isEnabled) baseSize * CatPawDefaults.RING_ENABLED_RATIO else baseSize * CatPawDefaults.RING_DISABLED_RATIO,
111 | animationSpec = tween(600),
112 | label = "RingSizeAnimation"
113 | )
114 | val buttonFillColor by animateColorAsState(
115 | targetValue = if (isEnabled) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant,
116 | animationSpec = tween(500),
117 | label = "ButtonFillAnimation"
118 | )
119 | val contentColor by animateColorAsState(
120 | targetValue = if (isEnabled) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurfaceVariant,
121 | animationSpec = tween(500),
122 | label = "ContentColorAnimation"
123 | )
124 | val shadowElevation by animateFloatAsState(
125 | targetValue = if (isEnabled) (baseSize.value * 0.055f) else (baseSize.value * 0.027f),
126 | animationSpec = tween(500),
127 | label = "ShadowElevation"
128 | )
129 | val rotationSpeed by animateFloatAsState(
130 | targetValue = if (isEnabled) 15f else 5f,
131 | animationSpec = tween(1500),
132 | label = "RotationSpeedAnimation"
133 | )
134 | var rotationAngle by remember { mutableFloatStateOf(0f) }
135 | val outlineColor = MaterialTheme.colorScheme.outline.copy(alpha = 0.5f)
136 | val arcColor1 by animateColorAsState(
137 | targetValue = if (isEnabled) MaterialTheme.colorScheme.primary else outlineColor,
138 | animationSpec = tween(700),
139 | label = "ArcColor1"
140 | )
141 | val arcColor2 by animateColorAsState(
142 | targetValue = if (isEnabled) MaterialTheme.colorScheme.tertiary else outlineColor,
143 | animationSpec = tween(700),
144 | label = "ArcColor2"
145 | )
146 | val arcBrush = Brush.sweepGradient(colors = listOf(arcColor1, arcColor2, arcColor1))
147 |
148 | val palmOffsetY by animateFloatAsState(if (isEnabled) CatPawDefaults.PALM_Y_SHIFT * scaleFactor else 0f, tween(400), label = "PalmOffsetY")
149 | val outerLeftToeX by animateFloatAsState(if (isEnabled) CatPawDefaults.OUTER_LEFT_TOE_X_SHIFT * scaleFactor else 0f, tween(400), label = "OuterLeftToeX")
150 | val outerLeftToeY by animateFloatAsState(if (isEnabled) CatPawDefaults.OUTER_LEFT_TOE_Y_SHIFT * scaleFactor else 0f, tween(400), label = "OuterLeftToeY")
151 | val innerLeftToeX by animateFloatAsState(if (isEnabled) CatPawDefaults.INNER_LEFT_TOE_X_SHIFT * scaleFactor else 0f, tween(400), label = "InnerLeftToeX")
152 | val innerLeftToeY by animateFloatAsState(if (isEnabled) CatPawDefaults.INNER_LEFT_TOE_Y_SHIFT * scaleFactor else 0f, tween(400), label = "InnerLeftToeY")
153 | val innerRightToeX by animateFloatAsState(if (isEnabled) CatPawDefaults.INNER_RIGHT_TOE_X_SHIFT * scaleFactor else 0f, tween(400), label = "InnerRightToeX")
154 | val innerRightToeY by animateFloatAsState(if (isEnabled) CatPawDefaults.INNER_RIGHT_TOE_Y_SHIFT * scaleFactor else 0f, tween(400), label = "InnerRightToeY")
155 | val outerRightToeX by animateFloatAsState(if (isEnabled) CatPawDefaults.OUTER_RIGHT_TOE_X_SHIFT * scaleFactor else 0f, tween(400), label = "OuterRightToeX")
156 | val outerRightToeY by animateFloatAsState(if (isEnabled) CatPawDefaults.OUTER_RIGHT_TOE_Y_SHIFT * scaleFactor else 0f, tween(400), label = "OuterRightToeY")
157 | val gapAngle by animateFloatAsState(
158 | targetValue = if (isEnabled) 8f else 12f,
159 | animationSpec = tween(700),
160 | label = "GapAngleAnimation"
161 | )
162 |
163 | LaunchedEffect(Unit) {
164 | var lastFrameTimeNanos = 0L
165 | while (true) {
166 | withFrameNanos { frameTimeNanos ->
167 | if (lastFrameTimeNanos != 0L) {
168 | val deltaTimeMillis = (frameTimeNanos - lastFrameTimeNanos) / 1_000_000f
169 | val deltaAngle = (rotationSpeed * deltaTimeMillis) / 1000f
170 | rotationAngle = (rotationAngle + deltaAngle) % 360f
171 | }
172 | lastFrameTimeNanos = frameTimeNanos
173 | }
174 | }
175 | }
176 |
177 | // --- 绘制部分 ---
178 | Canvas(modifier = Modifier.size(ringSize)) {
179 | val strokeWidth = CatPawDefaults.RING_STROKE_WIDTH
180 | val dashCount = 12
181 | val totalAnglePerDash = 360f / dashCount
182 | val dashAngle = totalAnglePerDash - gapAngle
183 | rotate(degrees = rotationAngle) {
184 | for (i in 0 until dashCount) {
185 | drawArc(
186 | brush = arcBrush,
187 | startAngle = i * totalAnglePerDash,
188 | sweepAngle = dashAngle,
189 | useCenter = false,
190 | style = Stroke(width = strokeWidth, cap = StrokeCap.Round)
191 | )
192 | }
193 | }
194 | }
195 |
196 | Surface(
197 | modifier = Modifier
198 | .size(baseSize * CatPawDefaults.CENTER_BUTTON_RATIO)
199 | .shadow(elevation = shadowElevation.dp, shape = CircleShape)
200 | .clip(CircleShape)
201 | .clickable(
202 | interactionSource = remember { MutableInteractionSource() },
203 | indication = null,
204 | onClick = onClick
205 | ),
206 | color = buttonFillColor
207 | ) {
208 | Column(
209 | modifier = Modifier.fillMaxSize(),
210 | horizontalAlignment = Alignment.CenterHorizontally,
211 | verticalArrangement = Arrangement.Center
212 | ) {
213 | Canvas(modifier = Modifier.size(baseSize * CatPawDefaults.PAW_CANVAS_RATIO)) {
214 | val strokeWidth = CatPawDefaults.PAW_STROKE_WIDTH
215 |
216 | val palmSize = Size(size.width * CatPawDefaults.PALM_WIDTH_RATIO, size.height * CatPawDefaults.PALM_HEIGHT_RATIO)
217 | val palmBaseCenter = Offset(center.x, center.y + size.height * CatPawDefaults.PALM_Y_OFFSET_RATIO)
218 | val palmAnimatedCenter = palmBaseCenter.copy(y = palmBaseCenter.y + palmOffsetY)
219 | val palmTopLeft = Offset(palmAnimatedCenter.x - palmSize.width / 2f, palmAnimatedCenter.y - palmSize.height / 2f)
220 | drawOval(
221 | color = contentColor,
222 | topLeft = palmTopLeft,
223 | size = palmSize,
224 | style = Stroke(width = strokeWidth)
225 | )
226 |
227 | val toeRadius = size.width * CatPawDefaults.TOE_RADIUS_RATIO
228 | val outerLeftBaseCenter = Offset(center.x - size.width * CatPawDefaults.OUTER_TOE_X_RATIO, center.y - size.height * CatPawDefaults.OUTER_TOE_Y_RATIO)
229 | val innerLeftBaseCenter = Offset(center.x - size.width * CatPawDefaults.INNER_TOE_X_RATIO, center.y - size.height * CatPawDefaults.INNER_TOE_Y_RATIO)
230 | val innerRightBaseCenter = Offset(center.x + size.width * CatPawDefaults.INNER_TOE_X_RATIO, center.y - size.height * CatPawDefaults.INNER_TOE_Y_RATIO)
231 | val outerRightBaseCenter = Offset(center.x + size.width * CatPawDefaults.OUTER_TOE_X_RATIO, center.y - size.height * CatPawDefaults.OUTER_TOE_Y_RATIO)
232 |
233 | drawCircle(
234 | color = contentColor,
235 | center = outerLeftBaseCenter.copy(x = outerLeftBaseCenter.x + outerLeftToeX, y = outerLeftBaseCenter.y + outerLeftToeY),
236 | radius = toeRadius,
237 | style = Stroke(width = strokeWidth)
238 | )
239 | drawCircle(
240 | color = contentColor,
241 | center = innerLeftBaseCenter.copy(x = innerLeftBaseCenter.x + innerLeftToeX, y = innerLeftBaseCenter.y + innerLeftToeY),
242 | radius = toeRadius,
243 | style = Stroke(width = strokeWidth)
244 | )
245 | drawCircle(
246 | color = contentColor,
247 | center = innerRightBaseCenter.copy(x = innerRightBaseCenter.x + innerRightToeX, y = innerRightBaseCenter.y + innerRightToeY),
248 | radius = toeRadius,
249 | style = Stroke(width = strokeWidth)
250 | )
251 | drawCircle(
252 | color = contentColor,
253 | center = outerRightBaseCenter.copy(x = outerRightBaseCenter.x + outerRightToeX, y = outerRightBaseCenter.y + outerRightToeY),
254 | radius = toeRadius,
255 | style = Stroke(width = strokeWidth)
256 | )
257 | }
258 |
259 | AnimatedContent(
260 | targetState = statusText,
261 | transitionSpec = {
262 | (slideInVertically { h -> h } + fadeIn(tween(250)))
263 | .togetherWith(slideOutVertically { h -> -h } + fadeOut(tween(250)))
264 | .using(SizeTransform(clip = false))
265 | },
266 | label = "StatusTextAnimation"
267 | ) { text ->
268 | Text(
269 | text = text,
270 | color = contentColor,
271 | fontSize = (baseSize.value * CatPawDefaults.FONT_SIZE_RATIO).coerceAtLeast(CatPawDefaults.MIN_FONT_SIZE_SP).sp,
272 | fontWeight = FontWeight.Bold,
273 | textAlign = TextAlign.Center
274 | )
275 | }
276 | }
277 | }
278 | }
279 | }
280 |
--------------------------------------------------------------------------------
11 |
12 |
13 |
14 | 
15 |
16 |
17 |
18 | 
19 |
20 |
21 |
22 | 
23 |
24 |
25 |
26 | 
27 |
28 |
29 |
30 | 
31 |
32 |
33 | 
23 |
24 |
25 |
26 |