Feature: add file management to the Android client

Android 客户端此前没有文件管理:声明了 CLIENT_CAP_V2 却没有实现,主控的
文件管理对话框和 MCP 的 list_files/download_file/upload_file 对 APK 只会
超时。本次复用 Linux/macOS 已在用的 common/FileManager.h,只补平台差异:

- 盘符模型:P=应用私有目录、I=内部存储、S/T/...=SD 卡与 U 盘;V2 上传
  通过 FileTransferV2::SetPathMapper 复用同一套映射。
- 文件通道线上是 GBK。NDK 的 iconv 要 API 28,客户端 minSdk 是 21,改走
  JNI -> Java Charset(NativeText.kt),严格模式失败原样透传。
- Android 11+ 引导开启「所有文件访问」;未授权时只挂 P: 并回一条提示。
  API <=29 用运行时存储权限 + requestLegacyExternalStorage。
- 顺带实现 COMMAND_SEARCH_FILE(深度 32、1 万条),并让 MCP 的
  list_files/download_file/upload_file/read_file 对 APK 开闸。

验证:arm64/armeabi 与模拟器 ABI 编译通过;模拟器上用 MCP 完成列盘、
列目录、下载、上传、中文文件名往返,GUI 文件管理器正常显示 P:/I:/S:。

Model: deepseek-flash
Co-Authored-By: Claude Code <noreply@anthropic.com>
This commit is contained in:
yuanyuanxiangandClaude Code committed 2026-11-16 18:34:46 +01:00
1 parent 7172ab376d
commit 28c0c9a2a6
9 files changed
+1001 -19

No files matched your search

+355
View File
@@ -38,6 +38,10 @@
// 类与格式化函数都是平台无关的(X11 采样在 linux/main.cpp,不在头文件里),Android
// 只需注入自己的 probe(JNI 问 ControlService 要前台应用)。
#include "linux/LinuxActivityHistory.h"
// 文件管理(COMMAND_LIST_DRIVE):协议体复用 common/FileManager.h,Android 只补
// 盘符映射与存储根。子连接自己建(GetServerTarget),不走 RunSubConnThread——
// 后者拨的是 g_SETTINGS 里的出厂地址,转移主机后还是连旧主控。
#include "FileManagerAndroid.h"
#define LOG_TAG "YAMA"
// LOGI/LOGE 走 android_log_tag(logger.h):既进 logcat,也进 Logger 的内存 ring,
@@ -275,6 +279,14 @@ static jmethodID g_shotCaptureMid = nullptr; // ScreenShot.capture(II)Lco
static jmethodID g_shotDataMid = nullptr; // Shot.getData()[B
static jmethodID g_shotWidthMid = nullptr; // Shot.getWidth()I
static jmethodID g_shotHeightMid = nullptr; // Shot.getHeight()I
// 文件管理:StorageHelper 提供存储根与「所有文件访问」状态;NativeText 做 GBK 转换
// (Android 的 iconv 需要 API 28,客户端 minSdk 是 21)。
static jclass g_storageClass = nullptr;
static jmethodID g_rootsMid = nullptr; // StorageHelper.roots()[Ljava/lang/String;
static jmethodID g_allFilesMid = nullptr; // StorageHelper.allFilesAccess()Z
static jclass g_textClass = nullptr;
static jmethodID g_gbkToUtf8Mid = nullptr; // NativeText.gbkToUtf8([B)[B
static jmethodID g_utf8ToGbkMid = nullptr; // NativeText.utf8ToGbk([B)[B
// 心跳日志限流:每 60 秒最多打一次
static std::atomic<uint64_t> g_lastHbLogMs{0};
@@ -354,6 +366,238 @@ void DispatchClipboardText(const uint8_t* data, size_t size)
if (attached) g_jvm->DetachCurrentThread();
}
// ------------------------------------------------------------------ 文件管理 JNI
// 文件管理器跑在独立子连接线程(native 线程)里,每次调用 Java 前按需 attach。
static JNIEnv* AttachJniForCall(bool* attached)
{
*attached = false;
if (!g_jvm) return nullptr;
JNIEnv* env = nullptr;
jint st = g_jvm->GetEnv((void**)&env, JNI_VERSION_1_6);
if (st == JNI_EDETACHED) {
if (g_jvm->AttachCurrentThread(&env, nullptr) != JNI_OK || !env) return nullptr;
*attached = true;
} else if (st != JNI_OK || !env) {
return nullptr;
}
return env;
}
static void DetachJniForCall(bool attached)
{
if (attached && g_jvm) g_jvm->DetachCurrentThread();
}
// Java 侧返回的每条形如 "I|/storage/emulated/0|Internal storage|0"
static std::vector<AndroidStorageRoot> QueryStorageRootsFromJava()
{
std::vector<AndroidStorageRoot> roots;
if (!g_jvm || !g_storageClass || !g_rootsMid) return roots;
bool attached = false;
JNIEnv* env = AttachJniForCall(&attached);
if (!env) return roots;
jobjectArray arr = (jobjectArray)env->CallStaticObjectMethod(g_storageClass, g_rootsMid);
if (env->ExceptionCheck()) {
env->ExceptionClear();
DetachJniForCall(attached);
return roots;
}
if (arr) {
const jsize n = env->GetArrayLength(arr);
for (jsize i = 0; i < n; ++i) {
jstring js = (jstring)env->GetObjectArrayElement(arr, i);
if (!js) continue;
const char* s = env->GetStringUTFChars(js, nullptr);
if (s) {
std::string line(s);
env->ReleaseStringUTFChars(js, s);
std::vector<std::string> parts;
size_t start = 0;
while (parts.size() < 3) {
size_t bar = line.find('|', start);
if (bar == std::string::npos) break;
parts.push_back(line.substr(start, bar - start));
start = bar + 1;
}
if (parts.size() == 3) parts.push_back(line.substr(start));
if (parts.size() == 4 && parts[0].size() == 1 && !parts[1].empty()) {
AndroidStorageRoot r;
r.letter = parts[0][0];
r.path = parts[1];
r.label = parts[2];
r.removable = (parts[3] == "1");
roots.push_back(std::move(r));
}
}
env->DeleteLocalRef(js);
}
env->DeleteLocalRef(arr);
}
if (env->ExceptionCheck()) env->ExceptionClear();
DetachJniForCall(attached);
return roots;
}
bool AndroidAllFilesAccess()
{
if (!g_jvm || !g_storageClass || !g_allFilesMid) return false;
bool attached = false;
JNIEnv* env = AttachJniForCall(&attached);
if (!env) return false;
jboolean ok = env->CallStaticBooleanMethod(g_storageClass, g_allFilesMid);
if (env->ExceptionCheck()) {
env->ExceptionClear();
ok = JNI_FALSE;
}
DetachJniForCall(attached);
return ok == JNI_TRUE;
}
static std::string CallTextConvert(jmethodID mid, const std::string& in)
{
if (!g_jvm || !g_textClass || !mid || in.empty()) return in;
bool attached = false;
JNIEnv* env = AttachJniForCall(&attached);
if (!env) return in;
std::string out = in;
jbyteArray arr = env->NewByteArray((jsize)in.size());
if (arr) {
env->SetByteArrayRegion(arr, 0, (jsize)in.size(), (const jbyte*)in.data());
jobject res = env->CallStaticObjectMethod(g_textClass, mid, arr);
if (!env->ExceptionCheck() && res) {
const jsize n = env->GetArrayLength((jbyteArray)res);
out.resize((size_t)n);
if (n > 0) env->GetByteArrayRegion((jbyteArray)res, 0, n, (jbyte*)&out[0]);
env->DeleteLocalRef(res);
} else if (env->ExceptionCheck()) {
env->ExceptionClear();
out = in;
}
env->DeleteLocalRef(arr);
}
if (env->ExceptionCheck()) env->ExceptionClear();
DetachJniForCall(attached);
return out;
}
// common/FileManager.h 与 common/FileTransferV2.h 在 __ANDROID__ 下调用这两个
// 函数代替 iconv;语义与 iconv 版一致:转换失败原样返回输入。
std::string AndroidGbkToUtf8(const std::string& input)
{
return CallTextConvert(g_gbkToUtf8Mid, input);
}
std::string AndroidUtf8ToGbk(const std::string& input)
{
return CallTextConvert(g_utf8ToGbkMid, input);
}
// 存储根缓存:打开文件管理器、每次路径映射都问一遍 Java 太贵;缓存 30 秒,
// SD 卡热插拔最多延迟半分钟。
static std::mutex g_rootsMx;
static std::vector<AndroidStorageRoot> g_rootsCache;
static std::atomic<long long> g_rootsCacheAt{0};
static std::vector<AndroidStorageRoot> AndroidStorageRootsCached()
{
const long long now = (long long)time(nullptr);
{
std::lock_guard<std::mutex> lk(g_rootsMx);
if (!g_rootsCache.empty() &&
now - g_rootsCacheAt.load(std::memory_order_relaxed) < 30) {
return g_rootsCache;
}
}
std::vector<AndroidStorageRoot> roots = QueryStorageRootsFromJava();
{
std::lock_guard<std::mutex> lk(g_rootsMx);
g_rootsCache = roots;
g_rootsCacheAt.store(now, std::memory_order_relaxed);
}
return roots;
}
std::vector<AndroidStorageRoot> AndroidQueryStorageRoots()
{
return AndroidStorageRootsCached();
}
std::string AndroidMapWinPathToUnix(const std::string& winPath)
{
std::string p = winPath;
// 老式 Unix 根写法(Linux 客户端用 "/:" 表示 /),Android 上按真实路径处理
if (p.size() >= 2 && p[0] == '/' && p[1] == ':')
p.erase(0, 2);
// 文件管理器工具栏的三个 Windows 快捷按钮(桌面 / 下载 / 用户主页)下发的是
// %USERPROFILE%\...;Android 没有 Desktop,映射到内部存储根/Download 才有意义。
const std::string kProfile = "%USERPROFILE%";
if (p.compare(0, kProfile.size(), kProfile) == 0) {
std::string rest = p.substr(kProfile.size());
for (auto& c : rest) if (c == '\\') c = '/';
while (!rest.empty() && rest[0] == '/') rest.erase(0, 1);
// 服务端下发的是 "%USERPROFILE%\Desktop\"(带尾反斜杠),归一化后是
// "Desktop/",不剥掉就永远匹配不上下面的 Desktop/Downloads 分支
while (!rest.empty() && rest.back() == '/') rest.pop_back();
std::string internal;
for (const auto& r : AndroidStorageRootsCached())
if (r.letter == 'I') { internal = r.path; break; }
if (internal.empty()) return p;
if (rest == "Downloads") return internal + "/Download";
if (rest == "Desktop") return internal;
if (rest.empty()) return internal;
return internal + "/" + rest;
}
if (p.size() >= 2 && p[1] == ':' && std::isalpha((unsigned char)p[0])) {
const char letter = (char)std::toupper((unsigned char)p[0]);
std::string rest = p.substr(2);
for (auto& c : rest) if (c == '\\') c = '/';
for (const auto& r : AndroidStorageRootsCached()) {
if (r.letter != letter) continue;
if (rest.empty()) return r.path;
if (rest[0] != '/') rest.insert(rest.begin(), '/');
return r.path + rest;
}
// 盘符不存在(比如 SD 卡已拔出):保留原样,让 opendir 明确失败
Mprintf("[FileManager] unknown drive %c in '%s'\n", letter, p.c_str());
}
for (auto& c : p) if (c == '\\') c = '/';
return p;
}
std::string AndroidMapUnixToWinPath(const std::string& unixPath)
{
for (const auto& r : AndroidStorageRootsCached()) {
if (unixPath == r.path)
return std::string(1, r.letter) + ":\\";
if (unixPath.size() > r.path.size() &&
unixPath.compare(0, r.path.size(), r.path) == 0 &&
unixPath[r.path.size()] == '/') {
std::string rest = unixPath.substr(r.path.size());
for (auto& c : rest) if (c == '/') c = '\\';
return std::string(1, r.letter) + ":" + rest;
}
}
// 不在任何存储根下(例如应用沙箱里的临时路径):退回 Linux 的 "/:\..." 写法
std::string result = "/:";
result += unixPath;
for (size_t i = 2; i < result.size(); ++i)
if (result[i] == '/') result[i] = '\\';
return result;
}
// 远程交谈:native 子连接 → ChatSession.onNativeEvent(kind, data)。
// kind: 1 = 服务端已绑定,2 = 会话结束,3 = 一条 GBK 文本。data 只在 kind=3 时非空。
// 与 DispatchClipboardText 同一套 attach/detach 套路,供 AndroidChatHandler::OnReceive 调用。
@@ -1149,6 +1393,64 @@ static void TerminalThread()
LOGI("TerminalThread exit");
}
// ------------------------------------------------------------------ 文件管理
// 服务端 COMMAND_LIST_DRIVE(主控「文件管理」对话框 / MCP list_files)→ 子连接 →
// 构造即发 TOKEN_DRIVE_LIST,服务端收到后打开对话框并把这条子连接交给它。
// 每个对话框一条子连接(与 Windows/Linux 一致),因此这里不限制并发。
static std::atomic<int> g_fsOpenedHinted{0};
static void FileManagerThread()
{
// 未授予「所有文件访问」时只提示一次:文件管理器仍可用(应用目录),
// 但整机目录可能列得出来读不了,提示运维去设置里开启。
if (!AndroidAllFilesAccess() && g_fsOpenedHinted.fetch_add(1) == 0) {
sendClientMsg("File manager",
"All-files access is not granted on this device. Only the app's own "
"folders are fully accessible; enable Settings > Apps > YAMA > "
"Special app access > All files access to browse the whole storage.");
}
std::string ip; int port;
GetServerTarget(ip, port);
LOGI(">>> FileManagerThread start → %s:%d", ip.c_str(), port);
try {
std::unique_ptr<IOCPClient> client(new IOCPClient(g_bExit, true));
client->EnableSubConnAuth(true, g_myClientID);
// 转移主机后目标会变,每轮重取(不能用 g_SETTINGS 里的出厂地址)
client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType);
GetServerTarget(ip, port);
if (!client->ConnectServer(ip.c_str(), port)) {
LOGE("FileManagerThread: connect failed");
return;
}
// 列大目录时每个名字都要做 GBK 转换;把这条子连接线程常驻 attach 到 JVM,
// 避免每个目录条目两次 AttachCurrentThread/DetachCurrentThread。
JNIEnv* env = nullptr;
bool attached = false;
if (g_jvm && g_jvm->GetEnv((void**)&env, JNI_VERSION_1_6) == JNI_EDETACHED) {
if (g_jvm->AttachCurrentThread(&env, nullptr) == JNI_OK) attached = true;
}
struct JniGuard {
bool attached;
~JniGuard() { if (attached && g_jvm) g_jvm->DetachCurrentThread(); }
} jniGuard{attached};
std::unique_ptr<AndroidFileManager> handler(new AndroidFileManager(client.get()));
client->setManagerCallBack(handler.get(),
IOCPManager::DataProcess,
IOCPManager::ReconnectProcess);
while (client->IsRunning() && client->IsConnected() && S_CLIENT_NORMAL == g_bExit)
Sleep(200);
client->setManagerCallBack(nullptr, nullptr, nullptr);
handler.reset();
client.reset();
} catch (const std::exception& e) {
LOGE("FileManagerThread exception: %s", e.what());
}
LOGI(">>> FileManagerThread exit");
}
// ------------------------------------------------------------------ 历史活动上报
// 主连接一次性快照(与 Windows/Linux 一致,服务端 TOKEN_REPORT_ACTIVITY 分支不 CancelIO)。
// 采样机每秒问一次 ControlService 的前台应用;这里只取 Dump(),几十微秒的活。
@@ -1799,6 +2101,26 @@ int DataProcess(void* /*user*/, PBYTE szBuffer, ULONG ulLength)
break;
}
case COMMAND_LIST_DRIVE: {
// 文件管理(主控右键「文件管理」/ MCP list_files):每个对话框一条子连接
LOGI("cmd: COMMAND_LIST_DRIVE → file manager sub-conn");
try {
std::thread(FileManagerThread).detach();
} catch (const std::exception& e) {
LOGE("File manager thread failed: %s", e.what());
}
break;
}
case COMMAND_SEND_FILE_V2:
case COMMAND_FILE_COMPLETE_V2: {
// 服务端 → 客户端的 V2 上传(MCP upload_file)。落盘路径经
// FileTransferV2::SetPathMapper 注入的盘符映射转成 /storage/...。
int result = FileTransferV2::RecvFileChunkV2(szBuffer, ulLength, g_myClientID, nullptr);
if (result != 0) LOGE("V2 file recv error: %d", result);
break;
}
case COMMAND_UPDATE:
LOGI("cmd: COMMAND_UPDATE len=%lu", (unsigned long)ulLength);
ApplyUpdateApk(szBuffer, ulLength);
@@ -2408,9 +2730,42 @@ Java_com_yama_client_YamaBridge_nativeInit(
} else {
LOGE("ScreenTuning class not found");
}
// 文件管理:存储根 / 全盘访问状态 + GBK 转换
jclass storageCls = env->FindClass("com/yama/client/StorageHelper");
if (env->ExceptionCheck()) { env->ExceptionClear(); storageCls = nullptr; }
if (storageCls) {
g_storageClass = (jclass)env->NewGlobalRef(storageCls);
g_rootsMid = env->GetStaticMethodID(g_storageClass, "roots", "()[Ljava/lang/String;");
if (env->ExceptionCheck()) { env->ExceptionClear(); g_rootsMid = nullptr; }
if (!g_rootsMid) LOGE("StorageHelper.roots not found");
g_allFilesMid = env->GetStaticMethodID(g_storageClass, "allFilesAccess", "()Z");
if (env->ExceptionCheck()) { env->ExceptionClear(); g_allFilesMid = nullptr; }
if (!g_allFilesMid) LOGE("StorageHelper.allFilesAccess not found");
} else {
LOGE("StorageHelper class not found");
}
jclass textCls = env->FindClass("com/yama/client/NativeText");
if (env->ExceptionCheck()) { env->ExceptionClear(); textCls = nullptr; }
if (textCls) {
g_textClass = (jclass)env->NewGlobalRef(textCls);
g_gbkToUtf8Mid = env->GetStaticMethodID(g_textClass, "gbkToUtf8", "([B)[B");
if (env->ExceptionCheck()) { env->ExceptionClear(); g_gbkToUtf8Mid = nullptr; }
if (!g_gbkToUtf8Mid) LOGE("NativeText.gbkToUtf8 not found");
g_utf8ToGbkMid = env->GetStaticMethodID(g_textClass, "utf8ToGbk", "([B)[B");
if (env->ExceptionCheck()) { env->ExceptionClear(); g_utf8ToGbkMid = nullptr; }
if (!g_utf8ToGbkMid) LOGE("NativeText.utf8ToGbk not found");
} else {
LOGE("NativeText class not found");
}
}
}
// V2 文件上传(服务端 → 客户端)的落盘路径同样要按盘符映射,
// 否则 "I:\\DCIM\\a.jpg" 会被 UnixPath 当成 "/DCIM/a.jpg"。
FileTransferV2::SetPathMapper([](const std::string& p) {
return AndroidMapWinPathToUnix(p);
});
g_bExit = S_CLIENT_NORMAL;
// 历史活动采样:每秒问一次前台应用。Start 幂等(服务重启 nativeStop→nativeInit
// 不会重复起线程);采样与连接无关,断线期间照样记,随进程一起结束。