scrcpy是安卓投屏方案,其他投屏软件大多都基于scrcpy开发,但它有个讨论了很多年没解决的问题:不支持中文输入

严格来说,不是不支持中文,而是除了英文键盘,其他语言都不支持。
尽管它提供了映射为虚拟按键输入的方式去调用手机键盘输入,但缺点是需要选词。
所以你没办法在电脑scrcpy上通过电脑输入法输入中文到手机界面。
关于这个issue,从2018年讨论到了2025年:
https://github.com/Genymobile/scrcpy/issues/37

我提供一个相对通用的方案,这个方案有以下优点:
只在开发时需要root环境,不需要更换喜欢的输入法,开发完成可以安装到任意安卓手机上

整个解决方案就是“让scrcpy把打不出来的文本通过本地socket交给手机输入法进程,Xposed模块替输入法调用确定选词方法”,需要修改的代码量很少。

实现过程如下(你可以让ai直接完成,不需要懂代码):
1、在电脑上安装安卓虚拟机,并给予root权限,安装你喜欢的输入法
1、拉取scrcpy源码,在输入文本方法injectText中增加对中文的处理(转发给127.0.0.1:38999)
2、获取你喜欢的输入法包名,
3、编写Xposed模块,Hook安卓输入法入口android.inputmethodservice.InputMethodService.onCreate()
只有输入法包名正确,才监听127.0.0.1:38999,如果有文字传进来,就调用输入法commitText塞打界面输入框里
4、测试没问题后,使用LSPatch把模块和输入法打包为一个apk

OK,现在你可以在任意安卓机上安装该apk作为主力输入法,使用--prefer-text参数启动这个修改后的scrcpy,即可获得输入中文的能力。

演示效果:

▶ 点击播放

scrcpy端修改的代码

新增 ImePipe.java,用于监听中文,转发给指定端口

package com.genymobile.scrcpy;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public final class ImePipe {

    public static final int PORT = 38999;

    private static final int TIMEOUT_MS = 500;

    private ImePipe() {
    }


    public static boolean commitText(String text) {
        if (text.isEmpty()) {
            return false;
        }
        String payload = text.replace('\n', ' ').replace('\r', ' ');

        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress("127.0.0.1", PORT), TIMEOUT_MS);
            socket.setSoTimeout(TIMEOUT_MS);

            OutputStream out = socket.getOutputStream();
            out.write(payload.getBytes(StandardCharsets.UTF_8));
            out.write('\n');
            out.flush();

            InputStream in = socket.getInputStream();
            return in.read() == '1';
        } catch (IOException e) {
            return false;
        }
    }
}

修改scrcpy的Controller.java,把整段文本的输入(中文)走上面IME处理逻辑

private boolean canInjectChar(char c) {
    String decomposed = KeyComposition.decompose(c);
    char[] chars = decomposed != null ? decomposed.toCharArray() : new char[]{c};
    return charMap.getEvents(chars) != null;
}

private int injectText(String text) {
    boolean needsIme = false;
    for (int i = 0; i < text.length(); i++) {
        if (!canInjectChar(text.charAt(i))) {
            needsIme = true;
            break;
        }
    }
    if (needsIme && ImePipe.commitText(text)) {
        Ln.i("已通过IME管道提交文本(" + text.length() + " 个字符)");
        return text.length();
    }

    int successCount = 0;
    for (char c : text.toCharArray()) {
        if (!injectChar(c)) {
            Ln.w("无法注入字符u+" + String.format("%04x", (int) c));
            continue;
        }
        successCount++;
    }
    return successCount;
}

xposed模块代码

Hook你喜欢的输入法,开启端口监听,获取电脑那边传过来的文本段,借助输入法把词推到输入框里

package cn.sumver.imepipe;

import android.inputmethodservice.InputMethodService;
import android.os.Handler;
import android.view.inputmethod.InputConnection;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import de.robv.android.xposed.IXposedHookLoadPackage;
import de.robv.android.xposed.XC_MethodHook;
import de.robv.android.xposed.XposedBridge;
import de.robv.android.xposed.XposedHelpers;
import de.robv.android.xposed.callbacks.XC_LoadPackage.LoadPackageParam;

public final class Module implements IXposedHookLoadPackage {

    static final int PORT = 38999;

    @Override
    public void handleLoadPackage(LoadPackageParam lpparam) {
        // 作用域由 LSPosed 强制限定,此检查用于避免意外。
        if (!"com.baidu.input_mi".equals(lpparam.packageName)) {
            return;
        }
        XposedBridge.log("IMEPipe: 正在加载到 " + lpparam.packageName);
        try {
            XposedHelpers.findAndHookMethod(InputMethodService.class, "onCreate",
                    new XC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) {
                            Server.attach((InputMethodService) param.thisObject);
                        }
                    });
        } catch (Throwable t) {
            XposedBridge.log("IMEPipe: hook 失败: " + t);
        }
    }

    static final class Server {

        private static volatile InputMethodService service;
        private static volatile Handler main;
        private static boolean started;

        static synchronized void attach(InputMethodService svc) {
            service = svc;
            main = new Handler(svc.getMainLooper());
            if (started) {
                return;
            }
            started = true;
            Thread t = new Thread(Server::acceptLoop, "IMEPipe");
            t.setDaemon(true);
            t.start();
            XposedBridge.log("IMEPipe: 正在监听 127.0.0.1:" + PORT);
        }

        private static void acceptLoop() {
            ServerSocket ss = null;
            try {
                ss = new ServerSocket();
                ss.setReuseAddress(true);
                ss.bind(new java.net.InetSocketAddress(
                        InetAddress.getByName("127.0.0.1"), PORT), 4);
                while (true) {
                    try (Socket s = ss.accept()) {
                        s.setSoTimeout(0);
                        handle(s);
                    } catch (IOException e) {
                        XposedBridge.log("IMEPipe: 连接错误: " + e);
                    }
                }
            } catch (Throwable t) {
                XposedBridge.log("IMEPipe: 服务器错误: " + t);
            } finally {
                if (ss != null) {
                    try {
                        ss.close();
                    } catch (IOException ignored) {
                        // 忽略
                    }
                }
            }
        }

        private static void handle(Socket s) throws IOException {
            InputStream in = s.getInputStream();
            OutputStream out = s.getOutputStream();
            ByteArrayOutputStream line = new ByteArrayOutputStream(256);
            int b;
            while ((b = in.read()) != -1) {
                if (b == '\n') {
                    String text = new String(line.toByteArray(), StandardCharsets.UTF_8);
                    line.reset();
                    if (text.endsWith("\r")) {
                        text = text.substring(0, text.length() - 1);
                    }
                    boolean ok = commit(text);
                    out.write(ok ? '1' : '0');
                    out.flush();
                } else if (line.size() < 1_000_000) {
                    line.write(b);
                }
            }
        }

        private static boolean commit(final String text) {
            final InputMethodService svc = service;
            if (svc == null) {
                XposedBridge.log("IMEPipe: 无可用服务");
                return false;
            }
            final InputConnection ic = svc.getCurrentInputConnection();
            if (ic == null) {
                XposedBridge.log("IMEPipe: 无 InputConnection(没有获得焦点的编辑器?)");
                return false;
            }
            final Handler h = main;
            if (h == null) {
                return false;
            }
            h.post(new Runnable() {
                @Override
                public void run() {
                    try {
                        ic.commitText(text, 1);
                    } catch (Throwable t) {
                        XposedBridge.log("IMEPipe:commitText 失败: " + t);
                    }
                }
            });
            XposedBridge.log("IMEPipe:已提交 " + text.length() + " 个字符");
            return true;
        }
    }
}