Feature: Support input blocking and privacy overlay on Android hosts

remote_block_input rejected anything but Windows because the Android
client had no COMMAND_SCREEN_BLOCK_INPUT handler. This adds the overlay
on the client and the server gating, and wires up COMMAND_SCREEN_BLANK.

Client: the accessibility service hangs a full-screen
TYPE_ACCESSIBILITY_OVERLAY on itself. block=true makes it transparent
and touchable so it swallows physical taps; black=true paints it black.
Both are absolute states, so repeated commands are idempotent, and the
handler clears the overlay when the screen sub-connection dies (Android
has no "released when the calling thread exits" fallback). During a
remote gesture the overlay is flipped to FLAG_NOT_TOUCHABLE, mirroring
Windows' BlockInput(false) wrap; the flag change and the injection must
be separated by a short delay or the gesture is swallowed.

Server: CLIENT_CAP_PRIVACY_OVERLAY distinguishes new APKs from old ones;
Linux/macOS and old APKs still get -32005 up front. Tool masks,
instructions and mcp/tools.json follow the change. COMMAND_SCREEN_BLANK
is implemented but not exposed as a tool: MediaProjection captures the
overlay, so blacking out the screen blinds the operator too and cannot
emulate Windows' WDA_EXCLUDEFROMCAPTURE.

Verified on the Android 15 emulator: blocked taps are swallowed while
remote clicks still land, the block re-arms after each gesture, the
watchdog auto-unblocks at the deadline, a dropped sub-connection clears
the overlay, and a black overlay shows up in both screencap and
get_screenshot. The committed ghost.apk is stale; rebuild before release.

Co-Authored-By: deepseek-flash
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-11-11 21:58:54 +01:00
1 parent 445bd8bbb9
commit a801a2999a
9 files changed
+306 -24

No files matched your search

+33
View File
@@ -24,6 +24,8 @@ extern uint64_t g_myClientID;
extern void DispatchControlEvent(uint32_t msgVal, uint64_t wParam, int32_t ptX, int32_t ptY);
extern void DispatchClipboardText(const uint8_t* data, size_t size);
extern void DispatchLockScreen();
// 隐私 overlay(COMMAND_SCREEN_BLANK / COMMAND_SCREEN_BLOCK_INPUT),定义在 main.cpp
extern void DispatchPrivacyOverlay(bool black, bool block);
// Linux/macOS 共用的 BITMAPINFOHEADER 布局(与 Windows 完全一致)
#pragma pack(push, 1)
@@ -64,6 +66,14 @@ public:
}
~AndroidScreenHandler() {
// 屏幕子连接断了 overlay 就没人能解除:全屏黑色/不可触摸窗口会把本机用户锁在外面,
// 必须在 handler 销毁时兜底撤掉(服务端侧也有强制解锁 + 关闭会话的路径,但断网时
// 服务端已经发不出任何报文)。
if (m_black.load() || m_block.load()) {
LOGE_SH("screen conn ended with overlay on (black=%d block=%d); clearing",
(int)m_black.load(), (int)m_block.load());
DispatchPrivacyOverlay(false, false);
}
m_running = false;
m_cond.notify_all();
if (m_sendThread.joinable())
@@ -134,6 +144,18 @@ public:
// Ctrl+Alt+Del 在 Android 无对应键,客户端映射为锁屏(GLOBAL_ACTION_LOCK_SCREEN)
DispatchLockScreen();
break;
case COMMAND_SCREEN_BLOCK_INPUT:
// [cmd][0|1]:1=吃掉本机触摸(透明 overlay),0=解除。
// 与 Windows 的 BlockInput 语义对齐:服务端注入的手势照常穿透(Kotlin 侧在
// 手势在飞时临时置 FLAG_NOT_TOUCHABLE,等价于 Windows 的 BlockInput(false) 包裹)。
if (size >= 2) ApplyOverlay(m_black.load(), data[1] != 0);
break;
case COMMAND_SCREEN_BLANK:
// [cmd][0|1]:1=全屏黑,0=恢复。注意 Android 没有「窗口不参与抓屏」的等价物
// (Windows 是 WDA_EXCLUDEFROMCAPTURE),黑色 overlay 会被 MediaProjection
// 一起抓走,主控端看到的画面也会变黑——这是给本机旁观者看的隐私屏,不是隐身。
if (size >= 2) ApplyOverlay(data[1] != 0, m_block.load());
break;
case COMMAND_SCREEN_CONTROL: {
// 服务端通过子连接下发鼠标/键盘控制包(MSG64 固定 48 字节)
// 坐标从 lParam(offset 24)读取,与 Windows/Linux/macOS 客户端一致:
@@ -157,6 +179,15 @@ public:
}
private:
// 服务端下发的是「绝对状态」(black/block 各一个 bool),这里只记客户端当前状态,
// 用于两条收尾路径:另一条命令到来时保持它不变、子连接断开时整体撤掉。
void ApplyOverlay(bool black, bool block) {
m_black.store(black);
m_block.store(block);
LOGI_SH("privacy overlay: black=%d block=%d", (int)black, (int)block);
DispatchPrivacyOverlay(black, block);
}
struct Frame { std::vector<uint8_t> data; bool isKeyframe; };
IOCPClient* m_client;
@@ -165,6 +196,8 @@ private:
std::atomic<bool> m_running;
std::atomic<bool> m_firstSent;
std::atomic<bool> m_skipLogged{false};
std::atomic<bool> m_black{false}; // 隐私 overlay:全屏黑(COMMAND_SCREEN_BLANK)
std::atomic<bool> m_block{false}; // 隐私 overlay:吃掉本机触摸(COMMAND_SCREEN_BLOCK_INPUT)
BmpInfoHeader m_bmpHdr;
+57 -1
View File
@@ -239,6 +239,8 @@ static jmethodID g_getActiveWindowMid = nullptr;
static jmethodID g_activityTitleMid = nullptr; // ControlService.currentActivityTitle()
static jmethodID g_lockScreenMid = nullptr; // ControlService.lockScreen()V — COMMAND_SCREEN_CTRL_ALT_DEL
static jmethodID g_canLockMid = nullptr; // ControlService.canLockScreen()Z — 登录前能力探测
static jmethodID g_overlayMid = nullptr; // ControlService.setPrivacyOverlay(ZZ)V — 黑屏 / 锁键鼠
static jmethodID g_canOverlayMid = nullptr; // ControlService.canOverlay()Z — 登录前能力探测
// CaptureService.requestIdr() / forceFirstFrame() — ScreenSpyThread 子连接建立后触发
static jclass g_captureClass = nullptr;
static jmethodID g_requestIdrMid = nullptr;
@@ -404,6 +406,31 @@ void DispatchLockScreen()
if (attached) g_jvm->DetachCurrentThread();
}
// 隐私 overlay:黑屏(COMMAND_SCREEN_BLANK)与锁键鼠(COMMAND_SCREEN_BLOCK_INPUT)
// 共用同一个无障碍 overlay,两个参数都是绝对状态(见 ScreenHandler.h 的 ApplyOverlay)。
void DispatchPrivacyOverlay(bool black, bool block)
{
if (!g_jvm || !g_ctrlClass || !g_overlayMid) {
LOGE("PRIVACY_OVERLAY: JNI not ready (cls=%p method=%p)", g_ctrlClass, g_overlayMid);
return;
}
JNIEnv* jenv = nullptr;
bool attached = false;
jint st = g_jvm->GetEnv((void**)&jenv, JNI_VERSION_1_6);
if (st == JNI_EDETACHED) {
if (g_jvm->AttachCurrentThread(&jenv, nullptr) != JNI_OK || !jenv) return;
attached = true;
} else if (st != JNI_OK || !jenv) {
return;
}
jenv->CallStaticVoidMethod(g_ctrlClass, g_overlayMid,
black ? JNI_TRUE : JNI_FALSE,
block ? JNI_TRUE : JNI_FALSE);
if (jenv->ExceptionCheck()) jenv->ExceptionClear();
LOGI("PRIVACY_OVERLAY: dispatched black=%d block=%d", (int)black, (int)block);
if (attached) g_jvm->DetachCurrentThread();
}
static std::string GetActiveWindowFromJava()
{
if (!g_jvm || !g_ctrlClass || !g_getActiveWindowMid) return "Android";
@@ -961,6 +988,27 @@ static bool LockScreenAvailable()
return can == JNI_TRUE;
}
// 登录前探测:无障碍服务在跑且 API 22+(TYPE_ACCESSIBILITY_OVERLAY)才声明
// CLIENT_CAP_PRIVACY_OVERLAY,服务端据此放行 Android 的 remote_block_input。
// 与 LockScreenAvailable 一样随每次登录刷新:无障碍被关掉重连后撤回。
static bool OverlayAvailable()
{
if (!g_jvm || !g_ctrlClass || !g_canOverlayMid) return false;
JNIEnv* jenv = nullptr;
bool attached = false;
jint st = g_jvm->GetEnv((void**)&jenv, JNI_VERSION_1_6);
if (st == JNI_EDETACHED) {
if (g_jvm->AttachCurrentThread(&jenv, nullptr) != JNI_OK || !jenv) return false;
attached = true;
} else if (st != JNI_OK || !jenv) {
return false;
}
jboolean can = jenv->CallStaticBooleanMethod(g_ctrlClass, g_canOverlayMid);
if (jenv->ExceptionCheck()) { jenv->ExceptionClear(); can = JNI_FALSE; }
if (attached) g_jvm->DetachCurrentThread();
return can == JNI_TRUE;
}
// 抓屏可能耗几十~几百毫秒(系统回调 + 编码),必须离开接收线程;超额请求直接丢弃
// (服务端会超时按「预览不可用」降级,与 Linux/Windows 的限流一致)。
static void ScreenPreviewThread(ScreenPreviewReq req)
@@ -1475,9 +1523,11 @@ static void ConnectionThread(uint64_t gen)
// 屏幕预览能力位按运行时状态刷新:无障碍服务在跑才声明(API 30+ 的 takeScreenshot),
// 服务端据此放行 get_screenshot;无障碍被关掉后重连会撤回,避免服务端白等抓屏。
// 锁屏同理:无障碍服务在跑且 API 28+ 才声明。
// 隐私 overlay(黑屏 / 锁键鼠)同理:无障碍服务在跑且 API 22+ 才声明。
logInfo.SetCaps(LOGIN_INFOR::DefaultCaps() |
(ScreenPreviewAvailable() ? CLIENT_CAP_SCREEN_PREVIEW : 0) |
(LockScreenAvailable() ? CLIENT_CAP_LOCK_SCREEN : 0));
(LockScreenAvailable() ? CLIENT_CAP_LOCK_SCREEN : 0) |
(OverlayAvailable() ? CLIENT_CAP_PRIVACY_OVERLAY : 0));
client->SendLoginInfo(logInfo.Speed(clock() - c));
g_lastHeartbeatAckMs.store(GetUnixMs(), std::memory_order_relaxed);
LOGI("Connected & login sent");
@@ -1649,6 +1699,12 @@ Java_com_yama_client_YamaBridge_nativeInit(
g_canLockMid = env->GetStaticMethodID(g_ctrlClass, "canLockScreen", "()Z");
if (env->ExceptionCheck()) { env->ExceptionClear(); g_canLockMid = nullptr; }
if (!g_canLockMid) LOGE("ControlService.canLockScreen not found");
g_overlayMid = env->GetStaticMethodID(g_ctrlClass, "setPrivacyOverlay", "(ZZ)V");
if (env->ExceptionCheck()) { env->ExceptionClear(); g_overlayMid = nullptr; }
if (!g_overlayMid) LOGE("ControlService.setPrivacyOverlay not found");
g_canOverlayMid = env->GetStaticMethodID(g_ctrlClass, "canOverlay", "()Z");
if (env->ExceptionCheck()) { env->ExceptionClear(); g_canOverlayMid = nullptr; }
if (!g_canOverlayMid) LOGE("ControlService.canOverlay not found");
} else {
LOGE("ControlService class not found");
}
@@ -7,14 +7,18 @@ import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.graphics.Color
import android.graphics.Path
import android.graphics.PixelFormat
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.Gravity
import android.view.View
import android.view.WindowManager
import android.view.accessibility.AccessibilityEvent
import android.view.accessibility.AccessibilityNodeInfo
@@ -33,6 +37,10 @@ class ControlService : AccessibilityService() {
companion object {
const val TAG = "YAMA_CTRL"
// 锁定时注入手势前的放行等待(毫秒):见 sendGesture 的说明。100ms 是实测能
// 稳稳让 WMS 应用完 FLAG_NOT_TOUCHABLE 的最小值量级(官方没有回调可等)。
private const val OVERLAY_BYPASS_DELAY_MS = 100
// ── Service instance ─────────────────────────────────────────────
@Volatile var instance: ControlService? = null
@@ -101,6 +109,33 @@ class ControlService : AccessibilityService() {
}
}
/**
* 登录前探测(C++ 侧据此决定是否声明 CLIENT_CAP_PRIVACY_OVERLAY):隐私 overlay
* 用 TYPE_ACCESSIBILITY_OVERLAY 挂在无障碍服务上,服务没在跑就挂不了(我们不申请
* SYSTEM_ALERT_WINDOW),API 22 以下没有这个窗口类型。缺任一条都如实不声明。
*/
@JvmStatic
fun canOverlay(): Boolean =
instance != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1
/**
* 服务端 COMMAND_SCREEN_BLANK / COMMAND_SCREEN_BLOCK_INPUT 的处理入口。
* black=true → 全屏不透明黑(COMMAND_SCREEN_BLANK)
* block=true → 透明但吃掉本机触摸(COMMAND_SCREEN_BLOCK_INPUT)
* 两个参数都是**绝对状态**不是开关:重复下发幂等,都传 false 就是撤掉 overlay。
* 注意 Android 上黑色 overlay 同样会被 MediaProjection 抓到,主控端的画面也会
* 变黑——黑屏是给本机旁观的真人看的,不是「主控隐身」。
* 调用方是屏幕子连接 OnReceive 线程,WindowManager 的操作必须在主线程。
*/
@JvmStatic
fun setPrivacyOverlay(black: Boolean, block: Boolean) {
val svc = instance ?: run {
Log.w(TAG, "setPrivacyOverlay: accessibility service inactive, command dropped")
return
}
svc.handler.post { svc.applyPrivacyOverlay(black, block) }
}
// ── Screen geometry (set by CaptureService) ──────────────────────
// Server sends coords in encoding space [0, encW) × [0, encH).
// We map them to physical screen space before dispatching.
@@ -167,6 +202,17 @@ class ControlService : AccessibilityService() {
private var tvTouchMoved = false
private val TV_TAP_THRESHOLD = 15f // encoding pixels — below this = tap, above = drag
// ── Privacy overlay(COMMAND_SCREEN_BLANK / COMMAND_SCREEN_BLOCK_INPUT)──
// 两种用途共用一个挂在本服务上的 View(TYPE_ACCESSIBILITY_OVERLAY):
// 黑屏 → 不透明黑;输入锁 → 透明。两者都要吃掉触摸,因为黑屏之下让真人
// 盲点等于让他对着看不见的界面乱按。
private var overlayView: View? = null
private var overlayParams: WindowManager.LayoutParams? = null
private var overlayBlack = false
private var overlayConsuming = false
// 注入手势期间的临时放行计数(见 sendGesture):>0 时 overlay 置 FLAG_NOT_TOUCHABLE
private var overlayBypass = 0
// ── Left-button drag accumulator ─────────────────────────────────────
private var lbuttonDown = false
private var gestureStart = 0L
@@ -200,10 +246,123 @@ class ControlService : AccessibilityService() {
override fun onDestroy() {
super.onDestroy()
runCatching { unregisterReceiver(screenReceiver) }
// 服务被关掉(用户关闭无障碍)时 overlay 必须一起撤掉,否则会留下一个
// 没人能解除的全屏黑色/不可触摸窗口把用户锁在外面。
removeOverlay()
instance = null
Log.i(TAG, "ControlService destroyed")
}
// ─────────────────────────────────────────────────────────────────────
// Privacy overlay(主线程)
private fun applyPrivacyOverlay(black: Boolean, block: Boolean) {
overlayBlack = black
overlayConsuming = black || block
if (!overlayConsuming) {
removeOverlay()
Log.i(TAG, "privacy overlay: off")
return
}
val v = overlayView ?: createOverlay() ?: return
v.setBackgroundColor(if (black) Color.BLACK else Color.TRANSPARENT)
syncOverlayTouchability()
Log.i(TAG, "privacy overlay: black=$black block=$block")
}
private fun createOverlay(): View? {
val wm = getSystemService(Context.WINDOW_SERVICE) as? WindowManager ?: return null
val v = View(this)
val lp = WindowManager.LayoutParams(
WindowManager.LayoutParams.MATCH_PARENT,
WindowManager.LayoutParams.MATCH_PARENT,
WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY,
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN or
WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS or
WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE,
PixelFormat.TRANSLUCENT)
lp.gravity = Gravity.TOP or Gravity.START
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)
lp.layoutInDisplayCutoutMode =
WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
v.setBackgroundColor(if (overlayBlack) Color.BLACK else Color.TRANSPARENT)
// 吃掉触摸:不给下面的应用(是否可触摸由 FLAG_NOT_TOUCHABLE 控制)
v.setOnTouchListener { _, _ -> true }
return try {
wm.addView(v, lp)
overlayView = v
overlayParams = lp
Log.i(TAG, "privacy overlay added")
v
} catch (t: Throwable) {
Log.e(TAG, "privacy overlay addView failed: ${t.message}")
null
}
}
private fun removeOverlay() {
val v = overlayView ?: return
val wm = getSystemService(Context.WINDOW_SERVICE) as? WindowManager
runCatching { wm?.removeView(v) }
overlayView = null
overlayParams = null
overlayBlack = false
overlayConsuming = false
overlayBypass = 0
Log.i(TAG, "privacy overlay removed")
}
// 触摸能否穿透由 overlay 上的 FLAG_NOT_TOUCHABLE 决定:
// 正常锁定 → 可触摸(吃掉);有注入手势在飞 → 临时不可触摸(放行给下面的应用)。
private fun syncOverlayTouchability() {
val v = overlayView ?: return
val lp = overlayParams ?: return
val wm = getSystemService(Context.WINDOW_SERVICE) as? WindowManager ?: return
val touchable = overlayConsuming && overlayBypass == 0
val flag = WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
val flags = if (touchable) (lp.flags and flag.inv()) else (lp.flags or flag)
if (flags == lp.flags) return
lp.flags = flags
runCatching { wm.updateViewLayout(v, lp) }
}
/**
* 注入手势。锁定键鼠时 overlay 会把本服务自己注入的手势也吃掉——Windows 客户端
* 的做法是 ProcessCommand 前后临时 BlockInput(false) 再恢复(client/ScreenManager.cpp
* 的 COMMAND_SCREEN_CONTROL 分支),这里等价:手势开始前放行 overlay,结束回调里恢复。
* 代价与 Windows 相同:手势在飞的那几十~几百毫秒里,真人触摸可以穿透。
*
* 放行后必须隔一小段时间再注入:改窗口属性(updateViewLayout)和注入触摸是两条
* 异步路径,同一条消息里先改属性再 dispatchGesture,事件几乎必然仍打在被吞的
* 那个窗口上(实测必现「Tap ok 但点了没反应」)。
*/
private fun sendGesture(gesture: GestureDescription,
callback: GestureResultCallback? = null): Boolean {
if (overlayView == null) return dispatchGesture(gesture, callback, null)
overlayBypass++
syncOverlayTouchability()
handler.postDelayed({
val restore = object : GestureResultCallback() {
override fun onCompleted(g: GestureDescription?) { releaseBypass(); callback?.onCompleted(g) }
override fun onCancelled(g: GestureDescription?) { releaseBypass(); callback?.onCancelled(g) }
}
val ok = try {
dispatchGesture(gesture, restore, null)
} catch (t: Throwable) {
Log.e(TAG, "dispatchGesture threw: ${t.message}")
false
}
if (!ok) releaseBypass() // 没派出去就不会有回调,立刻恢复,别把 overlay 留在放行状态
}, OVERLAY_BYPASS_DELAY_MS.toLong())
return true
}
private fun releaseBypass() {
if (overlayBypass > 0) overlayBypass--
syncOverlayTouchability()
}
// ─────────────────────────────────────────────────────────────────────
// Event routing (runs on main thread)
@@ -293,14 +452,14 @@ class ControlService : AccessibilityService() {
.addStroke(GestureDescription.StrokeDescription(p, 0L, 80L))
.addStroke(GestureDescription.StrokeDescription(p, 200L, 80L))
.build()
dispatchGesture(gesture, null, null)
sendGesture(gesture)
}
// ── 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)
sendGesture(GestureDescription.Builder().addStroke(stroke).build())
}
// ── Scroll wheel → vertical swipe ─────────────────────────────
@@ -312,7 +471,7 @@ class ControlService : AccessibilityService() {
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)
sendGesture(GestureDescription.Builder().addStroke(stroke).build())
CaptureService.requestIdr()
}
@@ -336,13 +495,12 @@ class ControlService : AccessibilityService() {
// 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(
val ok = sendGesture(
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?)")
}
@@ -512,11 +670,11 @@ class ControlService : AccessibilityService() {
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(),
val ok = sendGesture(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")
}
+3
View File
@@ -149,6 +149,7 @@ inline int isValid_10s()
#define CLIENT_CAP_UNINSTALL 0x2000 // 主连接处理 TOKEN_UNINSTALL(Android 拉起系统卸载确认框;Windows 客户端一直支持但不声明)
#define CLIENT_CAP_REMOTE_CHAT 0x4000 // 主连接处理 COMMAND_CHAT(远程交谈子连接;Windows 一直支持但不声明,目前只有新版 Android 声明)
#define CLIENT_CAP_TERMINAL 0x8000 // 主连接处理 COMMAND_SHELL(PTY 终端子连接:exec_command / terminal_*;Linux 一直支持但不声明,目前只有新版 Android 声明)
#define CLIENT_CAP_PRIVACY_OVERLAY 0x10000 // 屏幕子连接处理 COMMAND_SCREEN_BLOCK_INPUT / COMMAND_SCREEN_BLANK(Android 用无障碍全屏 overlay 实现;Windows 一直支持锁定键鼠但不声明这个位)
#define TALK_DLG_MAXLEN 1024 // 最大输入字符长度
@@ -1310,6 +1311,8 @@ typedef struct LOGIN_INFOR {
caps |= CLIENT_CAP_SCREEN_CLIPBOARD;
// 锁屏(COMMAND_SCREEN_CTRL_ALT_DEL → GLOBAL_ACTION_LOCK_SCREEN)依赖无障碍服务
// 与 API 28+,和其它运行时能力一样由 main.cpp 登录前探测后追加,不在默认位里声明。
// 同理:键鼠锁定 / 黑屏(COMMAND_SCREEN_BLOCK_INPUT / COMMAND_SCREEN_BLANK →
// CLIENT_CAP_PRIVACY_OVERLAY)要靠无障碍服务挂全屏 overlay,也在登录前按运行时状态追加。
// 卸载主机(TOKEN_UNINSTALL):命令处理是编译进来的,老 APK 收到只会静默丢弃,
// 服务端据此提前拒绝,而不是发一条没人接的命令后假报 ok。
caps |= CLIENT_CAP_UNINSTALL;
+14 -3
View File
@@ -121,8 +121,8 @@
| 连接列表 / 断开连接 | `COMMAND_CONNECTION` / `COMMAND_KILL_CONNECTION` | ✅ `list_network_connections` / `kill_network_connection` | — |
| 屏幕截图 | `COMMAND_SCREEN_PREVIEW_REQ` | ✅ `get_screenshot` | — |
| 鼠标 / 键盘 / 剪贴板写 | `COMMAND_SCREEN_CONTROL` + `MSG64` | ✅ `remote_*` | — |
| **锁定对端键鼠** | `COMMAND_SCREEN_BLOCK_INPUT`(2 字节) | ❌ **缺** | **零客户端改动**(无回包) |
| 黑屏 / Ctrl+Alt+Del | `COMMAND_SCREEN_BLANK` / `COMMAND_SCREEN_CTRL_ALT_DEL` | Ctrl+Alt+Del → ✅ `remote_lock_screen`(仅 Android,映射为锁屏);黑屏 ❌ | 黑屏**客户端未实现**,需客户端改动 |
| **锁定对端键鼠** | `COMMAND_SCREEN_BLOCK_INPUT`(2 字节) | ✅ `remote_block_input`(Windows `BlockInput()`;Android 无障碍全屏透明 overlay,`CLIENT_CAP_PRIVACY_OVERLAY`) | 无回包;Android 侧在注入手势期间临时放行(等价 Windows 的 `BlockInput(false)` 包裹) |
| 黑屏 / Ctrl+Alt+Del | `COMMAND_SCREEN_BLANK` / `COMMAND_SCREEN_CTRL_ALT_DEL` | Ctrl+Alt+Del → ✅ `remote_lock_screen`(仅 Android,映射为锁屏);黑屏 → Android 客户端已实现处理,**未暴露为 MCP 工具** | 见 §3.1 注:Android 的黑色 overlay 会被 MediaProjection 一起抓走,主控画面同步变黑,无法做成「对端看不见、主控看得见」 |
| 窗口级 / 区域捕获 | `COMMAND_SCREEN_WINDOW` / `COMMAND_SCREEN_ROI` | ❌ | 流式接口,需评估(见 §4.2) |
| 注册表读 | `COMMAND_REGEDIT` + `COMMAND_REG_FIND` | ✅ `list_registry`(子键 + 值) | — |
| **注册表写** | 无命令 | ❌ | **需客户端改动** |
@@ -215,7 +215,7 @@ MCP 现在能读、能传、能搜,**唯独不能删、不能改名、不能
## 3. 新工具(P10-C):远程控制补全 + 工具族去重
### 3.1 `remote_block_input`(P10-C,零客户端改动)
### 3.1 `remote_block_input`(P10-C;Windows 零客户端改动,Android 需新版 APK)
| 项 | 内容 |
|---|---|
@@ -231,6 +231,17 @@ MCP 现在能读、能传、能搜,**唯独不能删、不能改名、不能
`BlockInput` 在进程退出时会自动解除,所以真正的死锁风险只出现在「客户端进程活着但会话丢了」——上面两条正好覆盖。
**Android 版(`CLIENT_CAP_PRIVACY_OVERLAY`)**:客户端在无障碍服务上挂一个全屏透明
`TYPE_ACCESSIBILITY_OVERLAY` 吃掉触摸,服务端注入的手势在飞行期间把 overlay 临时置
`FLAG_NOT_TOUCHABLE`(相当于 Windows 在 `ProcessCommand` 前后 `BlockInput(false)` 再恢复)。
子连接断开时客户端自己撤掉 overlay——Android 没有「随调用线程退出自动解除」这层兜底。
**黑屏(`COMMAND_SCREEN_BLANK`)为什么没有做成工具**:Windows 上黑屏窗口可以用
`WDA_EXCLUDEFROMCAPTURE` 从抓屏里排除,所以「本机全黑、主控照常看画面」成立;Android 的
MediaProjection 抓的是合成后的帧缓冲,无障碍 overlay 无论是否 `FLAG_SECURE` 都会被抓到
(后者在画面里就是黑的),做了也是把主控一起弄瞎。客户端仍实现该命令(协议完整性,
将来 MFC 界面若加「隐私屏」菜单项可直接下发),但 MCP 侧不提供对应工具。
### 3.2 工具族重叠:`list_*` vs `host_list_*`(P10-A,纯文档/描述改动)
**这是当前最容易被忽略、但对模型影响最大的问题**。同一件事有两套工具,走两条完全不同的链路,门控也不同:
+3 -2
View File
@@ -2764,11 +2764,12 @@
},
{
"name": "remote_block_input",
"description": "锁定或解除目标 Windows 主机的本机键鼠。做 GUI 自动化时先 block=true,真人碰一下鼠标就不会打断流程。必须带期限:max_block_ms(默认 300000 毫秒)到期由服务端自动解除,并在下一次调用结果的 auto_unblocked 里上报;remote_close 或会话闲置回收时服务端也会强制解除。两个限制:1) Windows 只在调用进程具备管理员权限(或 UIAccess)时才允许 BlockInput,普通权限的客户端会静默失败且不上报结果,所以本工具的成功只代表命令已送达、不保证真的锁住了——不要凭它断言对端已被锁;2) 若屏幕子连接因目标机断网被拆,服务端也再没有下发通道,只能等客户端进程退出(BlockInput 随调用线程结束自动释放)。仅 Windows 支持(Linux 客户端不处理该报文,直接报 -32005)。",
"description": "锁定或解除目标主机的本机键鼠/触摸。做 GUI 自动化时先 block=true,真人碰一下屏幕就不会打断流程。必须带期限:max_block_ms(默认 300000 毫秒)到期由服务端自动解除,并在下一次调用结果的 auto_unblocked 里上报;remote_close 或会话闲置回收时服务端也会强制解除。Windows 用 BlockInput(),只在调用进程具备管理员权限(或 UIAccess)时为真,普通权限的客户端会静默失败且不上报结果;Android 用无障碍全屏透明 overlay 吃掉触摸,服务端注入的手势在飞行期间临时放行(等价于 Windows 在 ProcessCommand 前后 BlockInput(false) 的包裹),不声明相应能力位的老 APK 返回 -32005。两个限制:1) 成功只代表命令已送达,不保证真的锁住了——不要凭它断言对端已被锁;2) 若屏幕子连接因目标机断网被拆,服务端就再没有下发通道(Windows 只能等客户端进程退出,Android 客户端会在子连接断开时主动撤掉 overlay)。Linux/macOS 不支持,返回 -32005。",
"gate": "remote_control",
"write": true,
"platforms": [
"win"
"win",
"apk"
],
"impl": "mfc",
"inputSchema": {
+16 -7
View File
@@ -322,7 +322,7 @@ const char* kServerInstructions =
u8"GUI 自动化:remote_open 取得 session_id 与分辨率(screen_w/screen_h)→ get_screenshot 看画面 → "
u8"get_foreground_window 确认前台窗口(或用 remote_mouse / remote_keyboard 的 expect_hwnd 做前置校验)→ "
u8"remote_mouse / remote_keyboard 用归一化坐标(0..1)操作 → 必须 remote_close 释放会话,闲置会话会被回收。"
u8"要防止真人操作打断自动化时用 remote_block_input 锁定对端键鼠(必须带 max_block_ms,到期自动解除;"
u8"要防止真人操作打断自动化时用 remote_block_input 锁定对端键鼠(Windows/Android;必须带 max_block_ms,到期自动解除;"
u8"客户端无管理员权限时 Windows 会让 BlockInput 静默失败,成功只代表命令已送达)。\n"
u8"命令执行:exec_command 一次性取输出;需要保持 cd 或环境变量时用 terminal_open + terminal_exec,用毕 terminal_close。\n"
u8"\n"
@@ -2580,7 +2580,7 @@ std::string BuildToolsListResult(const Json::Value& id) {
{
Json::Value tool(Json::objectValue);
tool["name"] = "remote_block_input";
tool["description"] = u8"锁定或解除目标 Windows 主机的本机键鼠。做 GUI 自动化时先 block=true,真人碰一下鼠标就不会打断流程。必须带期限:max_block_ms(默认 300000 毫秒)到期由服务端自动解除,并在下一次调用结果的 auto_unblocked 里上报;remote_close 或会话闲置回收时服务端也会强制解除。两个限制:1) Windows 只在调用进程具备管理员权限(或 UIAccess)时才允许 BlockInput,普通权限的客户端会静默失败且不上报结果,所以本工具的成功只代表命令已送达、不保证真的锁住了——不要凭它断言对端已被锁;2) 若屏幕子连接因目标机断网被拆,服务端也再没有下发通道,只能等客户端进程退出(BlockInput 随调用线程结束自动释放)。仅 Windows 支持(Linux 客户端不处理该报文,直接报 -32005)。";
tool["description"] = u8"锁定或解除目标主机的本机键鼠/触摸。做 GUI 自动化时先 block=true,真人碰一下屏幕就不会打断流程。必须带期限:max_block_ms(默认 300000 毫秒)到期由服务端自动解除,并在下一次调用结果的 auto_unblocked 里上报;remote_close 或会话闲置回收时服务端也会强制解除。Windows 用 BlockInput(),只在调用进程具备管理员权限(或 UIAccess)时为真,普通权限的客户端会静默失败且不上报结果;Android 用无障碍全屏透明 overlay 吃掉触摸,服务端注入的手势在飞行期间临时放行(等价于 Windows 在 ProcessCommand 前后 BlockInput(false) 的包裹),不声明相应能力位的老 APK 返回 -32005。两个限制:1) 成功只代表命令已送达,不保证真的锁住了——不要凭它断言对端已被锁;2) 若屏幕子连接因目标机断网被拆,服务端就再没有下发通道(Windows 只能等客户端进程退出,Android 客户端会在子连接断开时主动撤掉 overlay)。Linux/macOS 不支持,返回 -32005。";
tool["inputSchema"] = BuildRemoteBlockInputInputSchema();
tool["outputSchema"] = BuildRemoteBlockInputOutputSchema();
tools.append(tool);
@@ -2968,6 +2968,9 @@ void AppendHostTechnicalDetail(CMy2015RemoteDlg* parent, uint64_t devId, Json::V
caps["registry"] = IsWindowsClient(ctx);
// windowInfo → get_foreground_window / host_list_windows 的矩形与 activate(SupportsWindowInfo)
caps["windowInfo"] = ctx->SupportsWindowInfo();
// privacyOverlay → Android 的 remote_block_input(无障碍 overlay)。Windows 恒可用、
// 不声明这个位,所以这里只对「非 Windows 且声明了能力位」的主机为 true。
caps["privacyOverlay"] = ctx->SupportsPrivacyOverlay();
host["capabilities"] = caps;
}
@@ -6855,10 +6858,16 @@ std::string BuildRemoteBlockInput(const Json::Value& id, const Json::Value& args
if (!ResolveScreenCtrlSessionHost(id, args, parent, devId, ctx, errJson))
return errJson;
// Linux/Android 客户端根本没有 COMMAND_SCREEN_BLOCK_INPUT 分支(静默忽略),只做报文的
// 服务端不做「发了就算成功」的假动作——直接报不支持(能力限制,非参数错误)。
if (!IsWindowsClient(ctx))
return BuildError(id, -32005, "remote_block_input is only supported on Windows hosts");
// 平台门:Windows 用 BlockInput();Android 新版用无障碍全屏 overlay 吃掉本机触摸
// (CLIENT_CAP_PRIVACY_OVERLAY);Linux/macOS 与老 APK 根本没有 COMMAND_SCREEN_BLOCK_INPUT
// 分支(静默忽略),服务端不做「发了就算成功」的假动作——直接按能力限制拒绝。
if (!IsWindowsClient(ctx)) {
if (ctx->GetAdditionalData(RES_CLIENT_TYPE) != "APK")
return BuildError(id, -32005, "remote_block_input is only supported on Windows and Android hosts");
if (!ctx->SupportsPrivacyOverlay())
return BuildError(id, -32005, "Android client is too old for remote_block_input: "
"the APK has no input-block overlay, upgrade the client first");
}
std::string sessionId = GetStringArg(args, "session_id");
if (sessionId.empty())
@@ -10296,7 +10305,7 @@ const ToolPlatform kToolPlatforms[] = {
{ "list_services", kPlatWin },
{ "get_keylog", kPlatWin },
{ "list_registry", kPlatWin },
{ "remote_block_input", kPlatWin },
{ "remote_block_input", kPlatWin|kPlatApk },
// 两端并集。方向性差异由 CollectTargetReqs 精确处理:源端必须 win,目标端 win/lnx/mac
{ "copy_files_c2c", kPlatWin|kPlatLnx|kPlatMac },
{ "operate_window", kPlatWin },
+10
View File
@@ -171,6 +171,16 @@ public:
return (strtoul(caps.GetString(), nullptr, 16) & CLIENT_CAP_TERMINAL) != 0;
}
// 检查客户端是否处理 COMMAND_SCREEN_BLOCK_INPUT / COMMAND_SCREEN_BLANK(Android 用
// 无障碍全屏 overlay 实现:输入锁 = 透明 overlay 吃掉触摸,黑屏 = 黑色 overlay)。
// Windows 客户端一直支持键鼠锁定但不声明这个位,调用方按平台区分;老 APK 收到两个
// 命令都会走 default 静默丢弃,服务端据此提前拒绝而不是假报 ok。
bool SupportsPrivacyOverlay() const {
CString caps = GetClientData(ONLINELIST_CAPABILITIES);
if (caps.IsEmpty()) return false;
return (strtoul(caps.GetString(), nullptr, 16) & CLIENT_CAP_PRIVACY_OVERLAY) != 0;
}
// 检查客户端是否支持远程协议切换(COMMAND_SET_PROTO)。老客户端没有这个命令,
// 收到也会走 default 丢弃,服务端据此把「协议切换」菜单置灰。
bool SupportsProtoSwitch() const {
+4 -3
View File
@@ -117,7 +117,7 @@ GATE = {
# win/lnx/mac —— client/、linux/、macos/ 都有该命令的处理分支,且服务端不拦
# win/lnx —— 远程控制只实现于 Windows/Linux(McpServer.cpp:2728);
# 以及 macOS 客户端有实现但服务端未开放的 kill_process
# 仅 win —— 服务/注册表/键日志/活动历史/文件写/块输入/host_* /power_action
# 仅 win —— 服务/注册表/键日志/活动历史/文件写/host_* /power_action
# (power_action 实际走 TOKEN_MACHINE_MANAGE,不是通用电源命令)
#
# 支持面是产品定位的阶梯:win 100% > lnx 46% > mac 28% ≈ apk 16%。
@@ -176,7 +176,7 @@ PLATFORMS = {
"upload_file": _TRIO,
# 远程控制:Windows / Linux 全功能;Android 只支持整屏目标,输入翻译成触摸与全局动作
# (remote_open/close/keyboard/mouse/clipboard),remote_block_input 仍仅 Windows
# (remote_open/close/keyboard/mouse/clipboard),remote_block_input 另支持新版 Android
"remote_open": _WLA,
"remote_close": _WLA,
"remote_keyboard": _WLA,
@@ -201,7 +201,8 @@ PLATFORMS = {
"move_path": _WIN,
"create_folder": _WIN,
"copy_files_c2c": _TRIO, # 两端并集:源端仅 win,目标端 win/lnx/mac,见 ROLES
"remote_block_input": _WIN,
# Windows 用 BlockInput();Android 新版用无障碍全屏 overlay(CLIENT_CAP_PRIVACY_OVERLAY)
"remote_block_input": _WINAPK,
"operate_window": _WIN, # WSLIST 能列窗口,但窗口操作仅 Windows 实现
"power_action": _WIN, # 实际走 TOKEN_MACHINE_MANAGE
# TOKEN_UNINSTALL:Windows 客户端一直有该分支;Android 新版映射为系统卸载确认框