get_activity_history was gated to Windows and Linux. The Android client now answers COMMAND_QUERY_ACTIVITY with a TOKEN_REPORT_ACTIVITY snapshot on the main connection, the same RPC shape as the other platforms; the server takes the first packet without CancelIO, so no sub-connection or request correlation is involved. The sampler reuses linux/LinuxActivityHistory.h, whose ActivityHistory class and formatters are platform-neutral, and is fed by a probe that asks the new ControlService.currentActivityTitle() once per second over JNI. The accessibility service already tracks the foreground package from TYPE_WINDOW_STATE_CHANGED; the title is "label (package)" with the label resolved once and cached, "Home" for the launcher, and idle for lock or screen-off, so no permission beyond the service users already enable is needed. Without the service the report says so instead of recording placeholder "Android" entries. Also scope the connection teardown to its own generation: a ConnectionThread that exits late (CaptureService restart) no longer clears the new run's g_running or g_pMainClient, and the report thread takes one local snapshot of the main client pointer. Verified on the emulator against a local debug server: five records (Settings, Chrome, launcher, Home) came back newest-first with dwell times, and disabling accessibility produced the permission hint. Co-Authored-By: deepseek-flash
456 lines
22 KiB
Kotlin
456 lines
22 KiB
Kotlin
package com.yama.client
|
||
|
||
import android.accessibilityservice.AccessibilityService
|
||
import android.accessibilityservice.GestureDescription
|
||
import android.annotation.SuppressLint
|
||
import android.content.BroadcastReceiver
|
||
import android.content.Context
|
||
import android.content.Intent
|
||
import android.content.IntentFilter
|
||
import android.graphics.Path
|
||
import android.graphics.PointF
|
||
import android.os.Build
|
||
import android.os.Handler
|
||
import android.os.Looper
|
||
import android.os.SystemClock
|
||
import android.util.Log
|
||
import android.view.View
|
||
import android.view.accessibility.AccessibilityEvent
|
||
import android.view.accessibility.AccessibilityNodeInfo
|
||
|
||
/**
|
||
* AccessibilityService that injects touch gestures and global key actions
|
||
* dispatched by the server (COMMAND_SCREEN_CONTROL / MSG64).
|
||
*
|
||
* Requires API 24+ for dispatchGesture(); guarded at runtime so the APK
|
||
* installs on API 21+ but gesture injection only runs on 24+.
|
||
*
|
||
* Activation: Settings → Accessibility → YAMA → enable.
|
||
*/
|
||
@SuppressLint("NewApi")
|
||
class ControlService : AccessibilityService() {
|
||
|
||
companion object {
|
||
const val TAG = "YAMA_CTRL"
|
||
|
||
// ── Service instance ─────────────────────────────────────────────
|
||
@Volatile var instance: ControlService? = null
|
||
|
||
// ── Active foreground window ─────────────────────────────────────
|
||
@JvmStatic
|
||
@Volatile var activeWindow: String = "Android"
|
||
|
||
// ── 历史活动采样用的前台应用标题(C++ ActivityHistory 的 probe 每秒调一次)──
|
||
// 辅助功能服务没启用时返回 null,让「历史活动」报告能说清是缺权限,而不是
|
||
// 记一堆默认值 "Android"。包名 → 应用名只查一次(缓存)。
|
||
private val labelCache = HashMap<String, String>()
|
||
|
||
@JvmStatic
|
||
fun currentActivityTitle(): String? {
|
||
val svc = instance ?: return null
|
||
val pkg = activeWindow
|
||
return when {
|
||
pkg.isEmpty() -> null
|
||
pkg == "Locked" -> pkg // 锁屏/息屏:C++ 侧当空闲处理,不记录
|
||
pkg == "Android" -> svc.getString(R.string.activity_home)
|
||
else -> synchronized(labelCache) {
|
||
labelCache.getOrPut(pkg) { describeApp(svc, pkg) }
|
||
}
|
||
}
|
||
}
|
||
|
||
// 应用名 + 包名(应用名可能重名,包名才能唯一定位)。
|
||
// 非 BMP 字符经 JNI 变成 CESU-8,服务端按 UTF-8 解析会拿到非法序列
|
||
// (Json 序列化直接抛异常),所以只保留 BMP 字符。
|
||
private fun describeApp(svc: ControlService, pkg: String): String {
|
||
val label = runCatching {
|
||
svc.packageManager.getApplicationLabel(
|
||
svc.packageManager.getApplicationInfo(pkg, 0)).toString()
|
||
}.getOrDefault(pkg)
|
||
val text = if (label == pkg) pkg else "$label ($pkg)"
|
||
return text.filterNot { it in '\uD800'..'\uDFFF' }
|
||
}
|
||
|
||
// ── Screen geometry (set by CaptureService) ──────────────────────
|
||
// Server sends coords in encoding space [0, encW) × [0, encH).
|
||
// We map them to physical screen space before dispatching.
|
||
@Volatile var physW = 1080
|
||
@Volatile var physH = 1920
|
||
@Volatile var encW = 1080
|
||
@Volatile var encH = 1920
|
||
|
||
// ── Windows message constants ────────────────────────────────────
|
||
const val WM_MOUSEMOVE = 0x0200
|
||
const val WM_LBUTTONDOWN = 0x0201
|
||
const val WM_LBUTTONUP = 0x0202
|
||
const val WM_LBUTTONDBLCLK = 0x0203
|
||
const val WM_RBUTTONDOWN = 0x0204
|
||
const val WM_MBUTTONDOWN = 0x0207
|
||
const val WM_MOUSEWHEEL = 0x020A
|
||
const val WM_KEYDOWN = 0x0100
|
||
const val WM_SYSKEYDOWN = 0x0104
|
||
|
||
/**
|
||
* Called from C++ DataProcess() via JNI on the IO thread.
|
||
* Parameters:
|
||
* message – Windows WM_* constant (low 16 bits of MSG64.message)
|
||
* wParam – MSG64.wParam (key/button flags; high word of MOUSEWHEEL = delta)
|
||
* ptX/ptY – MSG64.pt in encoding-space pixels
|
||
*/
|
||
@JvmStatic
|
||
fun onControlEvent(message: Int, wParam: Long, ptX: Int, ptY: Int) {
|
||
val svc = instance ?: run {
|
||
Log.w(TAG, "ControlService inactive — event 0x${message.toString(16)} dropped")
|
||
return
|
||
}
|
||
// All gesture state lives on the main thread; post there.
|
||
svc.handler.post { svc.handleEvent(message, wParam, ptX, ptY) }
|
||
}
|
||
}
|
||
|
||
// ── Screen state receiver ─────────────────────────────────────────────
|
||
private val screenReceiver = object : BroadcastReceiver() {
|
||
override fun onReceive(context: Context?, intent: Intent?) {
|
||
when (intent?.action) {
|
||
Intent.ACTION_SCREEN_OFF -> activeWindow = "Locked"
|
||
Intent.ACTION_USER_PRESENT -> activeWindow = "Android"
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── Main-thread handler ───────────────────────────────────────────────
|
||
private val handler = Handler(Looper.getMainLooper())
|
||
|
||
// ── TV (Google TV / Android TV) D-pad mode ───────────────────────────
|
||
// Activated when FEATURE_LEANBACK is present. Mouse events are translated
|
||
// to accessibility focus navigation — no touchscreen or root required.
|
||
private var isTV = false
|
||
private var tvLastEncX = -1f
|
||
private var tvLastEncY = -1f
|
||
private var tvAccumDX = 0f
|
||
private var tvAccumDY = 0f
|
||
private val TV_STEP = 40f // encoding-space pixels per D-pad step
|
||
// Touch-drag disambiguation: fire click on LBUTTONUP only if finger barely moved
|
||
private var tvTouchDown = false
|
||
private var tvTouchDownX = 0f
|
||
private var tvTouchDownY = 0f
|
||
private var tvTouchMoved = false
|
||
private val TV_TAP_THRESHOLD = 15f // encoding pixels — below this = tap, above = drag
|
||
|
||
// ── Left-button drag accumulator ─────────────────────────────────────
|
||
private var lbuttonDown = false
|
||
private var gestureStart = 0L
|
||
// Pairs of (millisecond offset from gesture start, screen point)
|
||
private val strokePoints = mutableListOf<Pair<Long, PointF>>()
|
||
|
||
// ─────────────────────────────────────────────────────────────────────
|
||
// AccessibilityService lifecycle
|
||
|
||
override fun onServiceConnected() {
|
||
super.onServiceConnected()
|
||
instance = this
|
||
isTV = packageManager.hasSystemFeature("android.software.leanback")
|
||
if (isTV) Log.i(TAG, "TV mode: D-pad navigation enabled")
|
||
val filter = IntentFilter().apply {
|
||
addAction(Intent.ACTION_SCREEN_OFF)
|
||
addAction(Intent.ACTION_USER_PRESENT)
|
||
}
|
||
registerReceiver(screenReceiver, filter)
|
||
Log.i(TAG, "ControlService connected phys=${physW}x${physH} enc=${encW}x${encH}")
|
||
}
|
||
|
||
override fun onAccessibilityEvent(event: AccessibilityEvent?) {
|
||
if (event?.eventType == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
|
||
val pkg = event.packageName?.toString()
|
||
if (!pkg.isNullOrEmpty()) activeWindow = pkg
|
||
}
|
||
}
|
||
override fun onInterrupt() {}
|
||
|
||
override fun onDestroy() {
|
||
super.onDestroy()
|
||
runCatching { unregisterReceiver(screenReceiver) }
|
||
instance = null
|
||
Log.i(TAG, "ControlService destroyed")
|
||
}
|
||
|
||
// ─────────────────────────────────────────────────────────────────────
|
||
// Event routing (runs on main thread)
|
||
|
||
private fun handleEvent(message: Int, wParam: Long, ptX: Int, ptY: Int) {
|
||
if (isTV) { handleEventTV(message, wParam, ptX, ptY); return }
|
||
// Scale encoding-space coords to physical screen
|
||
val x = if (encW > 0) ptX.toFloat() * physW / encW else ptX.toFloat()
|
||
val y = if (encH > 0) ptY.toFloat() * physH / encH else ptY.toFloat()
|
||
if (message != WM_MOUSEMOVE)
|
||
Log.d(TAG, "event 0x${message.toString(16)} enc=($ptX,$ptY) phys=(${x.toInt()},${y.toInt()})")
|
||
|
||
when (message) {
|
||
|
||
// ── Left button: accumulate drag path, dispatch on up ─────────
|
||
WM_LBUTTONDOWN -> {
|
||
lbuttonDown = true
|
||
gestureStart = SystemClock.uptimeMillis()
|
||
strokePoints.clear()
|
||
strokePoints.add(0L to PointF(x, y))
|
||
}
|
||
WM_MOUSEMOVE -> {
|
||
if (lbuttonDown) {
|
||
strokePoints.add((SystemClock.uptimeMillis() - gestureStart) to PointF(x, y))
|
||
}
|
||
}
|
||
WM_LBUTTONUP -> {
|
||
if (!lbuttonDown) return
|
||
lbuttonDown = false
|
||
val elapsed = SystemClock.uptimeMillis() - gestureStart
|
||
strokePoints.add(elapsed to PointF(x, y))
|
||
val down = strokePoints[0].second
|
||
val dx = x - down.x
|
||
val dy = y - down.y
|
||
|
||
// ── System edge-gesture detection ────────────────────────────
|
||
// dispatchGesture() is unreliable for system gestures; use performGlobalAction.
|
||
val hEdge = physH * 0.08f // 8% of screen height = top/bottom trigger zone
|
||
val wEdge = physW * 0.08f // 8% of screen width = left/right trigger zone
|
||
val minH = physH * 0.15f // minimum vertical travel
|
||
val minW = physW * 0.20f // minimum horizontal travel
|
||
|
||
val fromLeft = down.x < wEdge && dx > minW && Math.abs(dx) > Math.abs(dy) * 1.5f && elapsed < 600L
|
||
val fromRight = down.x > physW - wEdge && dx < -minW && Math.abs(dx) > Math.abs(dy) * 1.5f && elapsed < 600L
|
||
val fromTop = down.y < hEdge && dy > minH && Math.abs(dy) > Math.abs(dx)
|
||
val fromBottom = down.y > physH - hEdge && dy < -minH && Math.abs(dy) > Math.abs(dx)
|
||
|
||
when {
|
||
fromLeft || fromRight -> {
|
||
Log.d(TAG, "Edge-swipe back (fromLeft=$fromLeft)")
|
||
performGlobalAction(GLOBAL_ACTION_BACK)
|
||
}
|
||
fromTop -> {
|
||
// Right half of screen → quick settings; left half → notifications
|
||
if (down.x > physW * 0.5f) {
|
||
Log.d(TAG, "Top-swipe quick settings")
|
||
performGlobalAction(GLOBAL_ACTION_QUICK_SETTINGS)
|
||
} else {
|
||
Log.d(TAG, "Top-swipe notifications")
|
||
performGlobalAction(GLOBAL_ACTION_NOTIFICATIONS)
|
||
}
|
||
}
|
||
fromBottom -> {
|
||
// Slow swipe (≥400 ms) or very long travel → Recents; quick swipe → Home
|
||
if (elapsed >= 400L || Math.abs(dy) > physH * 0.40f) {
|
||
Log.d(TAG, "Bottom-swipe recents (elapsed=${elapsed}ms)")
|
||
performGlobalAction(GLOBAL_ACTION_RECENTS)
|
||
} else {
|
||
Log.d(TAG, "Bottom-swipe home (elapsed=${elapsed}ms)")
|
||
performGlobalAction(GLOBAL_ACTION_HOME)
|
||
}
|
||
}
|
||
dx * dx + dy * dy < 100f -> // 移动 < 10px → 单击
|
||
dispatchTap(down.x, down.y)
|
||
else ->
|
||
dispatchTouchGesture(strokePoints)
|
||
}
|
||
// 手势执行后立即请求关键帧,让 decoder 尽快看到屏幕变化
|
||
CaptureService.requestIdr()
|
||
strokePoints.clear()
|
||
}
|
||
|
||
// ── Double-click → two rapid taps ────────────────────────────
|
||
WM_LBUTTONDBLCLK -> {
|
||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) return
|
||
val p = singlePointPath(x, y)
|
||
val gesture = GestureDescription.Builder()
|
||
.addStroke(GestureDescription.StrokeDescription(p, 0L, 80L))
|
||
.addStroke(GestureDescription.StrokeDescription(p, 200L, 80L))
|
||
.build()
|
||
dispatchGesture(gesture, null, null)
|
||
}
|
||
|
||
// ── Right-click → long press (600 ms) ────────────────────────
|
||
WM_RBUTTONDOWN -> {
|
||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) return
|
||
val stroke = GestureDescription.StrokeDescription(singlePointPath(x, y), 0L, 600L)
|
||
dispatchGesture(GestureDescription.Builder().addStroke(stroke).build(), null, null)
|
||
}
|
||
|
||
// ── Scroll wheel → vertical swipe ─────────────────────────────
|
||
WM_MOUSEWHEEL -> {
|
||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) return
|
||
// High 16 bits of wParam hold the signed delta (+120 = up, -120 = down)
|
||
val delta = (wParam.toInt() ushr 16).toShort().toInt()
|
||
// Wheel-up (+delta) = user wants content above = finger swipes DOWN (+y)
|
||
val dy = if (delta > 0) 400f else -400f
|
||
val path = Path().apply { moveTo(x, y); lineTo(x, y + dy) }
|
||
val stroke = GestureDescription.StrokeDescription(path, 0L, 300L)
|
||
dispatchGesture(GestureDescription.Builder().addStroke(stroke).build(), null, null)
|
||
CaptureService.requestIdr()
|
||
}
|
||
|
||
// ── Keyboard → global actions only ───────────────────────────
|
||
WM_KEYDOWN, WM_SYSKEYDOWN -> handleKeyDown(wParam.toInt() and 0xFFFF)
|
||
}
|
||
}
|
||
|
||
// ─────────────────────────────────────────────────────────────────────
|
||
// Helpers
|
||
|
||
private fun dispatchTouchGesture(points: List<Pair<Long, PointF>>) {
|
||
if (points.isEmpty()) return
|
||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) return
|
||
|
||
val path = Path()
|
||
path.moveTo(points[0].second.x, points[0].second.y)
|
||
for (i in 1 until points.size) {
|
||
path.lineTo(points[i].second.x, points[i].second.y)
|
||
}
|
||
// Minimum 50 ms so Android registers the gesture; use actual elapsed for drags.
|
||
val duration = maxOf(points.last().first, 50L)
|
||
val stroke = GestureDescription.StrokeDescription(path, 0L, duration)
|
||
val ok = dispatchGesture(
|
||
GestureDescription.Builder().addStroke(stroke).build(),
|
||
object : GestureResultCallback() {
|
||
override fun onCompleted(g: GestureDescription?) { Log.d(TAG, "Gesture ok") }
|
||
override fun onCancelled(g: GestureDescription?) { Log.w(TAG, "Gesture cancelled") }
|
||
},
|
||
null
|
||
)
|
||
if (!ok) Log.e(TAG, "dispatchGesture returned false (service not ready?)")
|
||
}
|
||
|
||
// ─────────────────────────────────────────────────────────────────────
|
||
// TV D-pad mode — translates mouse events to accessibility focus actions
|
||
|
||
private fun handleEventTV(message: Int, wParam: Long, ptX: Int, ptY: Int) {
|
||
when (message) {
|
||
WM_MOUSEMOVE -> {
|
||
if (tvLastEncX >= 0) {
|
||
tvAccumDX += ptX - tvLastEncX
|
||
tvAccumDY += ptY - tvLastEncY
|
||
while (tvAccumDX > TV_STEP) { tvMoveFocus(View.FOCUS_RIGHT); tvAccumDX -= TV_STEP }
|
||
while (tvAccumDX < -TV_STEP) { tvMoveFocus(View.FOCUS_LEFT); tvAccumDX += TV_STEP }
|
||
while (tvAccumDY > TV_STEP) { tvMoveFocus(View.FOCUS_DOWN); tvAccumDY -= TV_STEP }
|
||
while (tvAccumDY < -TV_STEP) { tvMoveFocus(View.FOCUS_UP); tvAccumDY += TV_STEP }
|
||
}
|
||
if (tvTouchDown) {
|
||
val dx = ptX - tvTouchDownX
|
||
val dy = ptY - tvTouchDownY
|
||
if (dx * dx + dy * dy > TV_TAP_THRESHOLD * TV_TAP_THRESHOLD) tvTouchMoved = true
|
||
}
|
||
tvLastEncX = ptX.toFloat()
|
||
tvLastEncY = ptY.toFloat()
|
||
}
|
||
WM_LBUTTONDOWN -> {
|
||
tvTouchDown = true
|
||
tvTouchDownX = ptX.toFloat()
|
||
tvTouchDownY = ptY.toFloat()
|
||
tvTouchMoved = false
|
||
tvAccumDX = 0f
|
||
tvAccumDY = 0f
|
||
tvLastEncX = ptX.toFloat()
|
||
tvLastEncY = ptY.toFloat()
|
||
}
|
||
WM_LBUTTONUP -> {
|
||
if (tvTouchDown && !tvTouchMoved) tvClick()
|
||
tvTouchDown = false
|
||
}
|
||
WM_LBUTTONDBLCLK -> tvClick()
|
||
WM_RBUTTONDOWN -> performGlobalAction(GLOBAL_ACTION_BACK)
|
||
WM_MOUSEWHEEL -> {
|
||
val delta = (wParam.toInt() ushr 16).toShort().toInt()
|
||
tvScroll(delta < 0)
|
||
}
|
||
WM_KEYDOWN, WM_SYSKEYDOWN -> {
|
||
val vk = wParam.toInt() and 0xFFFF
|
||
when (vk) {
|
||
0x25 -> tvMoveFocus(View.FOCUS_LEFT) // VK_LEFT
|
||
0x26 -> tvMoveFocus(View.FOCUS_UP) // VK_UP
|
||
0x27 -> tvMoveFocus(View.FOCUS_RIGHT) // VK_RIGHT
|
||
0x28 -> tvMoveFocus(View.FOCUS_DOWN) // VK_DOWN
|
||
0x0D -> tvClick() // VK_RETURN
|
||
else -> handleKeyDown(vk)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
@Suppress("DEPRECATION")
|
||
private fun tvMoveFocus(direction: Int) {
|
||
val root = rootInActiveWindow ?: return
|
||
val focused = root.findFocus(AccessibilityNodeInfo.FOCUS_INPUT)
|
||
?: root.findFocus(AccessibilityNodeInfo.FOCUS_ACCESSIBILITY)
|
||
if (focused == null) {
|
||
val first = findFirstFocusable(root)
|
||
first?.performAction(AccessibilityNodeInfo.ACTION_FOCUS)
|
||
first?.recycle()
|
||
} else {
|
||
val next = focused.focusSearch(direction)
|
||
next?.performAction(AccessibilityNodeInfo.ACTION_FOCUS)
|
||
focused.recycle()
|
||
next?.recycle()
|
||
}
|
||
root.recycle()
|
||
}
|
||
|
||
@Suppress("DEPRECATION")
|
||
private fun tvClick() {
|
||
val root = rootInActiveWindow ?: return
|
||
val focused = root.findFocus(AccessibilityNodeInfo.FOCUS_INPUT)
|
||
?: root.findFocus(AccessibilityNodeInfo.FOCUS_ACCESSIBILITY)
|
||
if (focused != null) {
|
||
focused.performAction(AccessibilityNodeInfo.ACTION_CLICK)
|
||
focused.recycle()
|
||
} else {
|
||
Log.w(TAG, "tvClick: no focused node")
|
||
}
|
||
root.recycle()
|
||
}
|
||
|
||
@Suppress("DEPRECATION")
|
||
private fun tvScroll(forward: Boolean) {
|
||
val root = rootInActiveWindow ?: return
|
||
val action = if (forward) AccessibilityNodeInfo.ACTION_SCROLL_FORWARD
|
||
else AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD
|
||
val focused = root.findFocus(AccessibilityNodeInfo.FOCUS_INPUT)
|
||
?: root.findFocus(AccessibilityNodeInfo.FOCUS_ACCESSIBILITY)
|
||
if (focused == null || !focused.performAction(action)) root.performAction(action)
|
||
focused?.recycle()
|
||
root.recycle()
|
||
}
|
||
|
||
// Walk accessibility tree depth-first, return first visible focusable node (caller must recycle)
|
||
@Suppress("DEPRECATION")
|
||
private fun findFirstFocusable(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
|
||
if (node.isFocusable && node.isVisibleToUser) return AccessibilityNodeInfo.obtain(node)
|
||
for (i in 0 until node.childCount) {
|
||
val child = node.getChild(i) ?: continue
|
||
val hit = findFirstFocusable(child)
|
||
child.recycle()
|
||
if (hit != null) return hit
|
||
}
|
||
return null
|
||
}
|
||
|
||
private fun handleKeyDown(vk: Int) {
|
||
when (vk) {
|
||
0x08, 0x1B -> performGlobalAction(GLOBAL_ACTION_BACK) // Backspace / Esc
|
||
0x24 -> performGlobalAction(GLOBAL_ACTION_HOME) // VK_HOME
|
||
0x5D -> performGlobalAction(GLOBAL_ACTION_RECENTS) // VK_APPS
|
||
0x2C -> performGlobalAction(GLOBAL_ACTION_TAKE_SCREENSHOT) // PrtSc
|
||
}
|
||
}
|
||
|
||
private fun dispatchTap(x: Float, y: Float) {
|
||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) return
|
||
val path = Path().apply { moveTo(x, y); lineTo(x + 1f, y) }
|
||
val stroke = GestureDescription.StrokeDescription(path, 0L, 100L)
|
||
val ok = dispatchGesture(GestureDescription.Builder().addStroke(stroke).build(),
|
||
object : GestureResultCallback() {
|
||
override fun onCompleted(g: GestureDescription?) { Log.d(TAG, "Tap ok") }
|
||
override fun onCancelled(g: GestureDescription?) { Log.w(TAG, "Tap cancelled") }
|
||
}, null)
|
||
if (!ok) Log.e(TAG, "dispatchTap returned false")
|
||
}
|
||
|
||
private fun singlePointPath(x: Float, y: Float) = Path().apply { moveTo(x, y); lineTo(x + 1f, y) }
|
||
}
|