package com.example.wechathook;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.view.View;
import java.lang.reflect.Proxy;
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;

public class WeChatHook implements IXposedHookLoadPackage {

    private static final String ACTION_SEND       = "com.hermes.wechat.SEND_MSG_INTERNAL";
    private static final String ACTION_SEND_IMAGE = "com.hermes.wechat.SEND_IMAGE_INTERNAL";
    private static final String ACTION_SEND_VOICE = "com.hermes.wechat.SEND_VOICE_INTERNAL";
    private static final String ACTION_ARM_SWAP   = "com.hermes.wechat.ARM_VOICE_SWAP";
    private static final String ACTION_DUMP_API   = "com.hermes.wechat.DUMP_WECHAT_API";

    // ── Voice hot-swap state (the route that actually delivers) ────────────────
    // Fully-synthetic voice (SEND_VOICE_INTERNAL) can build the message shell but
    // can never upload the SILK to WeChat's CDN (upload is locked inside jg0.x's
    // Kotlin coroutine). So instead we let the user trigger a REAL recording (hold
    // "按住说话") and intercept jg0.x.w — the CDN uploadAttach step — replacing the
    // recorded SILK bytes (w21.t.a) with our TTS SILK. WeChat's own machinery then
    // uploads + delivers our audio. Armed by ARM_VOICE_SWAP; consumed once.
    private static volatile boolean sSwapArmed = false;
    private static volatile byte[]  sSwapSilk = null;   // TTS SILK bytes to inject
    private static volatile int     sSwapDuration = 0;  // ms, replaces the recorded duration
    // Safety: an arm auto-expires at this wall-clock time (set to arm + audio duration
    // + 10s slack). The swap fires only on release AFTER a full hold, so the window must
    // outlast the hold; past it, a stale arm silently dies instead of hijacking a later
    // unrelated recording.
    private static volatile long    sSwapExpiresAt = 0;
    // Cached f9 setter map (column -> methodName), built once on first voice send
    // (sF9SetterMap is declared alongside probeAllF9Setters below)
    // Thread-locals for voice send: voiceId and SILK bytes to inject into f9 ctor
    private static final ThreadLocal<String> sPendingVoiceId = new ThreadLocal<>();
    private static final ThreadLocal<byte[]> sPendingLvBuffer = new ThreadLocal<>();
    // Captures the f9 that called convertTo() (= the one written to DB); used to populate r0.i.
    private static final ThreadLocal<Object> sDatabaseF9 = new ThreadLocal<>();
    private static ClassLoader sWeChatCL;       // pre-Tinker classloader (from handleLoadPackage)
    private static volatile ClassLoader sTinkerCL; // Tinker-patched classloader (from App.onCreate)
    private static volatile Context sAppContext;
    private static volatile boolean sFsGReady = false;
    // Set true while WE are calling newInstance so r0Hook can distinguish us from WeChat
    private static volatile boolean sCalledByUs = false;
    // Network dispatcher captured from a real WeChat r0 at H()-entry; needed by CDN upload
    private static volatile Object sCapturedDispatcher = null;
    private static volatile Object sPt0E0Instance = null; // pt0.e0 singleton, captured from r() hook
    private static volatile Object sImgPlugin = null; // b80.u instance, captured from pj/Bi hook
    private static volatile Object sRealImgParams = null; // last real o70.h, captured for replication
    private static volatile Object sRealImgK = null; // last real o70.k (oj insert object)
    private static final ThreadLocal<Long> sPendingMsgLocalId = new ThreadLocal<>(); // msgId from DB insert
    // Logged-in user's wxid, auto-discovered from first real voice message send
    private static volatile String sMyWxid = null;
    // Pending send: stored when broadcast arrives before gm0.j1 is initialized
    private static volatile String sPendingTalker = null;
    private static volatile String sPendingText   = null;
    private static volatile String sPendingProc   = null;

    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
        if (!"com.tencent.mm".equals(lpparam.packageName)) return;
        // Use android.util.Log directly so it appears even before VectorLegacyBridge is ready
        android.util.Log.i("WeChatHookEarly", "INIT proc=" + lpparam.processName
                + " pid=" + android.os.Process.myPid());
        XposedBridge.log("[WeChatHook] Injected into WeChat " + lpparam.processName
                + " pid=" + android.os.Process.myPid());
        ClassLoader cl = lpparam.classLoader;
        sWeChatCL = cl;

        // Tablet login hooks — DISABLED. User switched to normal direct (primary)
        // login. The bk.A/B tablet-spoof would make WeChat think it's a tablet
        // mid-session and can re-trigger the beta "体验资格" gate on this test build,
        // kicking the login. Keep them off so restarts don't disturb direct login.
        // hookInTabletEnv(cl);
        // hookProbe(cl);
        // hookLoginHistoryUIInitView(cl);
        // hookLoginUIInitView(cl);
        // hookLoginSelectUICheck(cl);
        // hookLoginButtonClick(cl);

        // WCDB diagnostic: which process writes? + media ContentValues dump
        hookWCDB(cl, lpparam.processName);

        // Factory method discovery: dumps w11.s1 signatures + hooks all static methods
        // so that when WeChat UI sends image/voice we capture the exact API call.
        hookFactoryMethods(cl, lpparam.processName);

        // MediaPlayer hook: captures voice file paths when WeChat plays voice messages.
        // This reveals the voice2/{dir1}/{dir2}/msg_{id}.amr naming formula.
        hookMediaPlayer(lpparam.processName);

        // Hook gm0.j1.g() to detect when DI kernel is ready — runs in ALL processes.
        // This enables the pending-send mechanism: if broadcast arrives before DI init,
        // we store the args and retry once g() fires.
        hookDIInit(cl, lpparam.processName);

        // Send hook in ALL WeChat processes — we need to find which one can actually send.
        // The broadcast receiver registered in each process will all receive the intent;
        // whichever process has gm0.j1 initialized will succeed.
        hookSendMessage(cl, lpparam.processName);

        // Hook w11.r0.H(String) to trace CDN upload: log r0 String fields + file access.
        hookR0H(cl, lpparam.processName);

        // Capture the live network dispatcher com.tencent.mm.modelbase.m2 (MicroMsg.RDispatcher)
        // at construction. Synthetic voice sends need the REAL m2 to actually reach the
        // network; without it we'd fall back to a fake $Proxy that never sends.
        hookDispatcher(cl, lpparam.processName);

        // Instrument the voice-upload service w21.g1 (voiceinfo table): on a REAL voice
        // send, dump the exact w21.w0 upload-task fields so we can replicate them for
        // synthetic voice (the last missing step = CDN audio upload).
        hookVoiceUpload(cl, lpparam.processName);

        // Image send: hook the non-suspend plugin methods b80.u.pj/Bi (o70.h) — the
        // actual image-send entry the coroutine calls. Capture the b80.u instance +
        // dump the full o70.h a REAL send builds, so we can replicate it directly.
        hookImageSend(cl, lpparam.processName);
        // Capture the SendImgProxyUI launch Intent (real gallery send goes through it),
        // so we can replay the whole real send flow via `am start`.
        hookSendImgProxyUI(cl, lpparam.processName);

        // Hook pt0.e0 — the voice-send coroutine class found in the stack trace.
        // Real voice sends don't use r0.H(); we need to find where CDN upload actually fires.
        hookPt0E0(cl, lpparam.processName);

        // Surgical voice-send entry probe (jg0.x + qi3.f0/g0 only). On this fresh
        // reinstall the send runs in the base CL (no Tinker patch yet), so hook here.
        hookVoiceProbe(cl, lpparam.processName);

        // Voice hot-swap: intercept jg0.x.w (CDN uploadAttach) to replace the recorded
        // SILK with our TTS audio during a real (user- or A11y-triggered) recording.
        // This is the ONE route that actually delivers synthetic voice.
        hookVoiceSwap(cl, lpparam.processName);
    }

    // ── WCDB hook ──────────────────────────────────────────────────────────────
    // Intercepts every INSERT into the message table.
    // For msgtype 3 (image) and 34 (voice) logs the full ContentValues so we can
    // reverse-engineer the exact schema WeChat uses when building those messages.
    private void hookWCDB(ClassLoader cl, String procName) {
        try {
            XposedHelpers.findAndHookMethod(
                    "com.tencent.wcdb.database.SQLiteDatabase", cl,
                    "insertWithOnConflict",
                    String.class, String.class, android.content.ContentValues.class, int.class,
                    new XC_MethodHook() {
                        private boolean textLogged = false;
                        @Override
                        protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                            String table = (String) param.args[0];
                            if (table == null) return;
                            android.content.ContentValues cv =
                                    (android.content.ContentValues) param.args[2];

                            // Determine msgtype from ContentValues (key may be "type" or "msgtype")
                            Object rawType = null;
                            if (cv != null) {
                                rawType = cv.get("type");
                                if (rawType == null) rawType = cv.get("msgtype");
                                if (rawType == null) rawType = cv.get("msgType");
                            }
                            int msgtype = -1;
                            try { if (rawType != null) msgtype = Integer.parseInt(rawType.toString()); }
                            catch (NumberFormatException ignored) {}

                            if (msgtype == 3 || msgtype == 34) {
                                // Image (3) or Voice (34): dump full ContentValues + stack
                                String cvStr = cv != null ? cv.toString() : "null";
                                String stack = android.util.Log.getStackTraceString(new Throwable());
                                if (stack.length() > 4000) stack = stack.substring(0, 4000) + "…";
                                XposedBridge.log("[WeChatHook] WCDB MEDIA INSERT table=" + table
                                        + " msgtype=" + msgtype
                                        + " proc=" + procName
                                        + "\nContentValues=" + cvStr
                                        + "\nStack=" + stack);
                            } else if (msgtype == 1) {
                                // Text: only log once (to confirm which process writes)
                                if (!textLogged) {
                                    textLogged = true;
                                    String stack = android.util.Log.getStackTraceString(new Throwable());
                                    if (stack.length() > 3000) stack = stack.substring(0, 3000) + "…";
                                    XposedBridge.log("[WeChatHook] WCDB TEXT INSERT table=" + table
                                            + " proc=" + procName + "\n" + stack);
                                } else {
                                    XposedBridge.log("[WeChatHook] WCDB TEXT table=" + table
                                            + " proc=" + procName);
                                }
                            }
                        }
                    });
            XposedBridge.log("[WeChatHook] WCDB hook OK in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] WCDB hook failed in " + procName + ": " + t);
        }
    }

    // ── MediaPlayer hook: reveals voice file path format ─────────────────────
    // When WeChat plays a voice message it calls MediaPlayer.setDataSource(path).
    // We log any path under voice2/ to see the full path including subdirectory,
    // which reveals the formula WeChat uses to map voice file IDs to directories.
    private void hookMediaPlayer(String procName) {
        try {
            XposedHelpers.findAndHookMethod("android.media.MediaPlayer", null,
                "setDataSource", String.class, new XC_MethodHook() {
                    @Override
                    protected void beforeHookedMethod(MethodHookParam p) throws Throwable {
                        String path = (String) p.args[0];
                        if (path != null && path.contains("voice2")) {
                            XposedBridge.log("[WeChatHook] MediaPlayer.setDataSource VOICE="
                                + path + " proc=" + procName);
                        }
                    }
                });
            XposedBridge.log("[WeChatHook] MediaPlayer hook OK in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] MediaPlayer hook failed in " + procName + ": " + t);
        }
    }

    // ── f9.convertTo() hook: maps f9 fields to DB columns ─────────────────────
    // Captures ContentValues produced by convertTo() for image (3) and voice (34).
    // From these ContentValues we know which f9 setter corresponds to which DB column
    // (imgPath, content, talker, etc.) so we can construct f9 programmatically.
    private void hookF9ConvertTo(ClassLoader cl, String procName) {
        try {
            XposedHelpers.findAndHookMethod("com.tencent.mm.storage.f9", cl,
                "convertTo", new XC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam p) throws Throwable {
                        if (p.hasThrowable()) return;
                        android.content.ContentValues cv =
                            (android.content.ContentValues) p.getResult();
                        if (cv == null) return;
                        Object rawType = cv.get("type");
                        if (rawType == null) rawType = cv.get("msgtype");
                        if (rawType == null) return;
                        int msgtype = -1;
                        try { msgtype = Integer.parseInt(rawType.toString()); } catch (Throwable e) {}
                        if (msgtype == 3 && !sCalledByUs) {
                            // Dump full call stack once for a real IMAGE send so we can find
                            // the top-level app entry point to replicate for API image send.
                            XposedBridge.log("[WeChatHook] convertTo IMAGE STACK (real send):\n"
                                + android.util.Log.getStackTraceString(new Exception()));
                        }
                        if (msgtype == 34) {
                            // Dump call stack once for real sends to find the CDN upload caller.
                            if (!sCalledByUs) {
                                XposedBridge.log("[WeChatHook] convertTo STACK (real send):\n"
                                    + android.util.Log.getStackTraceString(new Exception()));
                            }
                            // Auto-discover logged-in user's wxid from real UI voice sends.
                            // We look for isSend=1 messages (user's own sends) and extract
                            // fromusername from the voicemsg XML, cache as sMyWxid.
                            if (sMyWxid == null && !sCalledByUs) {
                                Object isSend = cv.get("isSend");
                                Object contentVal = cv.get("content");
                                if (isSend instanceof Integer && ((Integer)isSend) == 1
                                        && contentVal instanceof String) {
                                    String c = (String) contentVal;
                                    int fi = c.indexOf("fromusername=\"");
                                    if (fi >= 0) {
                                        int start = fi + "fromusername=\"".length();
                                        int end = c.indexOf("\"", start);
                                        if (end > start) {
                                            String wxid = c.substring(start, end);
                                            if (!wxid.isEmpty()) {
                                                sMyWxid = wxid;
                                                XposedBridge.log("[WeChatHook] auto-discovered sMyWxid=" + wxid);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        if (msgtype == 3 || msgtype == 34) {
                            // Inject lvbuffer (SILK bytes) if we're sending voice via hook.
                            // sPendingLvBuffer is still set here — convertTo fires INSIDE
                            // the r0 constructor which runs before our finally-block clears it.
                            byte[] pendingLv = sPendingLvBuffer.get();
                            if (pendingLv != null && !(cv.get("lvbuffer") instanceof byte[])) {
                                cv.put("lvbuffer", pendingLv);
                                XposedBridge.log("[WeChatHook] convertTo: injected lvbuffer " + pendingLv.length + " bytes");
                            }
                            // Capture the DB-bound f9 (the one convertTo() runs on).
                            // This is the correct object for r0.i: it has content + msgId set.
                            if (pendingLv != null) {
                                sDatabaseF9.set(p.thisObject);
                                // Capture msgLocalId for pt0.e0.s() CDN trigger
                                try {
                                    Object msgIdObj = cv.get("msgId");
                                    if (msgIdObj != null) {
                                        long mid = Long.parseLong(msgIdObj.toString());
                                        sPendingMsgLocalId.set(mid);
                                        XposedBridge.log("[WeChatHook] convertTo: captured msgLocalId=" + mid);
                                    }
                                } catch (Throwable ignored) {}
                                // Do NOT force status=4 here.
                                // Forcing status=4 before H() causes H() to skip CDN upload
                                // (WeChat checks status and exits early if already "delivered").
                                // Let H() set status=4 naturally after successful CDN upload.
                                // Ensure flag and msgSvrId are present (missing from our sends).
                                if (cv.get("flag") == null) cv.put("flag", 0);
                                if (cv.get("msgSvrId") == null) cv.put("msgSvrId", 0L);
                                XposedBridge.log("[WeChatHook] convertTo: initial INSERT (status not forced, H() will set it)");
                            }
                            // Log full ContentValues including lvbuffer details
                            StringBuilder sb = new StringBuilder();
                            sb.append("[WeChatHook] f9.convertTo() msgtype=").append(msgtype)
                              .append(" proc=").append(procName).append("\nContentValues=").append(cv);
                            Object lvbuf = cv.get("lvbuffer");
                            if (lvbuf instanceof byte[]) {
                                byte[] b = (byte[]) lvbuf;
                                StringBuilder hex = new StringBuilder();
                                int show = Math.min(b.length, 32);
                                for (int i = 0; i < show; i++)
                                    hex.append(String.format("%02x", b[i] & 0xff));
                                sb.append("\nlvbuffer len=").append(b.length).append(" hex=").append(hex);
                            } else {
                                sb.append("\nlvbuffer=null");
                            }
                            XposedBridge.log(sb.toString());
                        }
                    }
                });
            XposedBridge.log("[WeChatHook] f9.convertTo hook OK in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] f9.convertTo hook failed in " + procName + ": " + t);
        }
    }

    // ── f9 constructor imgPath injector ───────────────────────────────────────
    // Hooks ALL f9 constructors. When sPendingVoiceId is set on the calling thread,
    // immediately calls the discovered imgPath setter on the newly created f9 object.
    // This fires INSIDE the r0 constructor (before its internal f9.convertTo() call),
    // so the DB insert from r0 constructor already has the correct voice file ID.
    private void hookF9ImgPathInjector(ClassLoader cl, String procName) {
        try {
            Class<?> f9Class = XposedHelpers.findClass("com.tencent.mm.storage.f9", cl);
            XC_MethodHook injHook = new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    String pending = sPendingVoiceId.get();
                    if (pending == null) return;
                    java.util.Map<String, String> sm = sF9SetterMap;
                    if (sm == null) return;
                    // Inject imgPath
                    String setter = sm.get("imgPath");
                    if (setter != null) {
                        XposedHelpers.callMethod(param.thisObject, setter, pending);
                        XposedBridge.log("[WeChatHook] f9 ctor injected imgPath=" + pending + " via " + setter);
                    }
                    // Inject lvbuffer (SILK bytes) so WeChat treats the voice as locally available
                    byte[] lvbuf = sPendingLvBuffer.get();
                    String lvSetter = sm.get("lvbuffer:bytes");
                    if (lvbuf != null && lvSetter != null) {
                        XposedHelpers.callMethod(param.thisObject, lvSetter, (Object) lvbuf);
                        XposedBridge.log("[WeChatHook] f9 ctor injected lvbuffer len=" + lvbuf.length + " via " + lvSetter);
                    } else {
                        XposedBridge.log("[WeChatHook] f9 ctor lvbuffer skip: lvbuf=" + (lvbuf==null?"null":"ok") + " setter=" + lvSetter);
                    }
                    // sDatabaseF9 is captured in convertTo() — that's the correct DB-bound f9.
                }
            };
            int hooked = 0;
            for (java.lang.reflect.Constructor<?> ctor : f9Class.getDeclaredConstructors()) {
                XposedBridge.hookMethod(ctor, injHook);
                hooked++;
            }
            XposedBridge.log("[WeChatHook] f9 ctor injector OK in " + procName + " (" + hooked + " ctors)");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] f9 ctor injector failed in " + procName + ": " + t);
        }
    }

    // ── Image send via internal API ────────────────────────────────────────────
    // Calls the gallery's own static image-send helper:
    //   j33.d0.k(long imgId, String path, String talker, boolean, int, boolean,
    //            GalleryItem$MediaItem)
    // This is exactly what the album picker calls (traced via a real image send's
    // convertTo stack → b80.u.oj → b80.s coroutine → built from o70.h; d0.k is the
    // top-level builder). It builds o70.h (PreBuildParams) and launches the send
    // coroutine internally (thumbnail gen + CDN upload + DB insert), fire-and-forget.
    // The old w11.s1.b(IMAGE) path built an incomplete r1 → n1.a() NPE; abandoned.
    private static void sendImageViaAPI(String talker, String imagePath) throws Throwable {
        ClassLoader cl = sTinkerCL != null ? sTinkerCL : sWeChatCL;
        if (cl == null) throw new IllegalStateException("classloader null");
        // Replicate the REAL image send captured by hookImageSend: build the exact
        // o70.h (PreBuildParams) that b80.u.pj() receives on a genuine send, then call
        // b80.u.pj(o70.h) directly (non-suspend), skipping the whole gallery/coroutine UI.
        //
        // Captured real o70.h (fields are single letters a–l):
        //   a=r6 preBuildFolder, e=imgPath, g=toUserName(talker), c=source(0), d=0,
        //   f=imgId(0 ok), h=compressType(0), k=Uri(null for pj), b=UUID(auto)
        //
        // r6 folder = lp0.b.h0(gm0.j1.b().j() + "_MsgImgUploadFSC")  (= g80.o.c7()).
        // plugin b80.u = i95.n0.c(o70.e.class) (fallback to hook-captured instance).
        // b80.u image plugin = i95.n0.c(o70.e.class) (fallback to hook-captured instance).
        Object imgPlugin = sImgPlugin;
        if (imgPlugin == null) {
            Class<?> n0 = XposedHelpers.findClass("i95.n0", cl);
            Class<?> o70e = XposedHelpers.findClass("o70.e", cl);
            imgPlugin = XposedHelpers.callStaticMethod(n0, "c", o70e);
        }
        if (imgPlugin == null) throw new IllegalStateException("b80.u image plugin null");

        // r6 pre-build folder = lp0.b.h0(gm0.j1.b().j() + "_MsgImgUploadFSC") (= g80.o.c7()).
        Object m = XposedHelpers.callStaticMethod(XposedHelpers.findClass("gm0.j1", cl), "b");
        Object prefix = XposedHelpers.callMethod(m, "j");
        Class<?> lp0b = XposedHelpers.findClass("lp0.b", cl);
        Object r6 = XposedHelpers.callStaticMethod(lp0b, "h0", prefix + "_MsgImgUploadFSC");

        // Build o70.k (the batch send object) — fields captured from a real oj(o70.k):
        //   a=r6, b=UUID(auto), c=talker, d=source, f=compressType, g=List<o70.i>
        Class<?> o70k = XposedHelpers.findClass("o70.k", cl);
        Object k = XposedHelpers.newInstance(o70k, r6);
        XposedHelpers.setObjectField(k, "c", talker); // toUserName
        // source (field d) — real send used 3; set via reflection (int field).
        try { java.lang.reflect.Field df = o70k.getDeclaredField("d"); df.setAccessible(true); df.setInt(k, 3); } catch (Throwable ignored) {}
        // o70.i(imgPath, Uri, Long imgId) — give it a file:// Uri so the CDN upload has
        // a readable source (real sends pass a MediaStore content:// Uri).
        Class<?> o70i = XposedHelpers.findClass("o70.i", cl);
        android.net.Uri fileUri = android.net.Uri.fromFile(new java.io.File(imagePath));
        Object item = XposedHelpers.newInstance(o70i,
            new Class<?>[]{String.class, android.net.Uri.class, Long.class},
            imagePath, fileUri, Long.valueOf(0L));
        java.util.List<Object> list = new java.util.ArrayList<>();
        list.add(item);
        XposedHelpers.setObjectField(k, "g", list);
        String clientId = (String) XposedHelpers.getObjectField(k, "b");

        // Replicate b80.s coroutine's per-item prebuild loop: build o70.h from k+item,
        // then pj (stage compressed image + thumbnail into r6).
        Class<?> o70h = XposedHelpers.findClass("o70.h", cl);
        Object h = XposedHelpers.newInstance(o70h, r6);
        XposedHelpers.callMethod(h, "b", clientId);       // clientId (field b)
        XposedHelpers.setObjectField(h, "e", imagePath);  // imgPath
        XposedHelpers.setObjectField(h, "g", talker);     // toUserName
        XposedHelpers.setObjectField(h, "k", fileUri);    // Uri (source for staging/upload)
        try { java.lang.reflect.Field hc = o70h.getDeclaredField("c"); hc.setAccessible(true); hc.setInt(h, 3); } catch (Throwable ignored) {} // source
        // d(rotate)/h(compressType) default 0. f(imgId) 0.
        XposedBridge.log("[WeChatHook] sendImageViaAPI: built o70.k+o70.h e=" + imagePath + " g=" + talker
            + " plugin=" + imgPlugin.getClass().getName());

        sCalledByUs = true;
        try {
            if (!(Boolean) XposedHelpers.callMethod(imgPlugin, "Bi", h, "thumb.jpg")) {
                XposedHelpers.callMethod(imgPlugin, "pj", h);          // prebuild (stage)
                try { XposedHelpers.callMethod(imgPlugin, "nj", h, 10000); } catch (Throwable ignored) {}
            }
            java.util.ArrayList<?> res = (java.util.ArrayList<?>)
                XposedHelpers.callMethod(imgPlugin, "oj", k);          // insert + send
            XposedBridge.log("[WeChatHook] sendImageViaAPI: oj() DONE to=" + talker
                + " res=" + (res == null ? "null" : "size=" + res.size()));
        } finally { sCalledByUs = false; }
    }

    // ── Probe all f9 setter→column mappings (String + int, one-shot) ──────────
    // Calls each String setter and each void(int) method with a unique marker,
    // then calls convertTo() to see which ContentValues key reflects the marker.
    // Returns a Map<columnName, setterMethodName>.
    private static volatile java.util.Map<String, String> sF9SetterMap = null;

    private static java.util.Map<String, String> probeAllF9Setters(Class<?> f9Class) {
        java.util.Map<String, String> result = new java.util.HashMap<>();

        // String setters (known from class dump)
        for (String sn : new String[]{"Z0", "C1", "D1", "a1", "d1", "h1", "i1"}) {
            try {
                Object probe = XposedHelpers.newInstance(f9Class);
                XposedHelpers.callMethod(probe, sn, "PROBE_" + sn);
                android.content.ContentValues cv = (android.content.ContentValues)
                    XposedHelpers.callMethod(probe, "convertTo");
                for (String key : cv.keySet()) {
                    Object val = cv.get(key);
                    if (("PROBE_" + sn).equals(val != null ? val.toString() : "")) {
                        result.put(key, sn);
                        XposedBridge.log("[WeChatHook] f9 str setter " + sn + " -> " + key);
                    }
                }
            } catch (Throwable t) {
                XposedBridge.log("[WeChatHook] f9 probe str " + sn + ": " + t);
            }
        }

        // Int setters: scan all void(int) methods
        try {
            for (java.lang.reflect.Method m : f9Class.getDeclaredMethods()) {
                if (m.getReturnType() != void.class) continue;
                java.lang.Class<?>[] pt = m.getParameterTypes();
                if (pt.length != 1 || pt[0] != int.class) continue;
                m.setAccessible(true);
                try {
                    Object probe = XposedHelpers.newInstance(f9Class);
                    m.invoke(probe, 88888);
                    android.content.ContentValues cv = (android.content.ContentValues)
                        XposedHelpers.callMethod(probe, "convertTo");
                    for (String key : cv.keySet()) {
                        Object val = cv.get(key);
                        if (val instanceof Integer && (Integer) val == 88888) {
                            result.put(key, m.getName());
                            XposedBridge.log("[WeChatHook] f9 int setter " + m.getName() + " -> " + key);
                        }
                    }
                } catch (Throwable ignored) {}
            }
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] f9 int probe scan failed: " + t);
        }

        // byte[] setters: scan all void(byte[]) methods — discovers lvbuffer setter
        try {
            for (java.lang.reflect.Method m : f9Class.getDeclaredMethods()) {
                if (m.getReturnType() != void.class) continue;
                java.lang.Class<?>[] pt = m.getParameterTypes();
                if (pt.length != 1 || pt[0] != byte[].class) continue;
                m.setAccessible(true);
                // Marker: a 4-byte sentinel we can recognize in cv
                byte[] marker = new byte[]{(byte)0xDE, (byte)0xAD, (byte)0xBE, (byte)0xEF};
                try {
                    Object probe = XposedHelpers.newInstance(f9Class);
                    m.invoke(probe, (Object) marker);
                    android.content.ContentValues cv = (android.content.ContentValues)
                        XposedHelpers.callMethod(probe, "convertTo");
                    for (String key : cv.keySet()) {
                        Object val = cv.get(key);
                        if (val instanceof byte[]) {
                            byte[] got = (byte[]) val;
                            if (got.length == 4 && got[0] == (byte)0xDE && got[1] == (byte)0xAD) {
                                result.put(key + ":bytes", m.getName());
                                XposedBridge.log("[WeChatHook] f9 bytes setter " + m.getName() + " -> " + key);
                            }
                        }
                    }
                } catch (Throwable ignored) {}
            }
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] f9 bytes probe scan failed: " + t);
        }

        XposedBridge.log("[WeChatHook] f9 setter map: " + result);
        return result;
    }

    // ── Hook w11.r0.H(String) — CDN upload entry-point trace ─────────────────
    // Logs every r0.H() call: dumps all String+File fields on r0 so we can identify
    // which field contains the audio file path that H() uploads to CDN.
    // Hook ALL methods on pt0.e0 (voice-send coroutine class found in stack trace).
    // Goal: find which method triggers CDN upload AFTER f9.convertTo() returns.
    // pt0.e0.k returns f9 objects and fires in multiple threads — CDN upload entry point.
    private void hookPt0E0(ClassLoader cl, String procName) {
        try {
            Class<?> cls = XposedHelpers.findClass("pt0.e0", cl);
            java.lang.reflect.Method[] methods = cls.getDeclaredMethods();
            StringBuilder sig = new StringBuilder("[WeChatHook] pt0.e0 methods(" + methods.length + "):");
            for (java.lang.reflect.Method m : methods) sig.append(" ").append(m.getName()).append("(").append(m.getParameterTypes().length).append(")");
            XposedBridge.log(sig.toString());
            for (java.lang.reflect.Method m : methods) {
                final String mName = m.getName();
                m.setAccessible(true);
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        // Capture singleton from ANY method (not just r()), so it's
                        // available even when no real voice send has happened this session.
                        if (sPt0E0Instance == null && p.thisObject != null) {
                            sPt0E0Instance = p.thisObject;
                            XposedBridge.log("[WeChatHook] pt0.e0 singleton captured via " + mName + ": " + p.thisObject);
                        }
                        if ("k".equals(mName)) {
                            // k(2): confirmed signature k(String talker, Long msgLocalId)
                            // CDN worker calls this to dequeue next upload task.
                            // Only log first call per send to avoid spam.
                            Object a0 = p.args != null && p.args.length > 0 ? p.args[0] : null;
                            Object a1 = p.args != null && p.args.length > 1 ? p.args[1] : null;
                            XposedBridge.log("[WeChatHook] pt0.e0.k ENTER talker=" + a0
                                + " msgLocalId=" + (a1 instanceof Long ? ((Long)a1).longValue() : a1));
                        } else if ("r".equals(mName)) {
                            // Save pt0.e0 singleton for later use in sendVoiceViaAPI.
                            if (sPt0E0Instance == null && p.thisObject != null) {
                                sPt0E0Instance = p.thisObject;
                                XposedBridge.log("[WeChatHook] pt0.e0 singleton captured: " + p.thisObject);
                            }
                            XposedBridge.log("[WeChatHook] pt0.e0.r ENTER, dumping thisObject fields:");
                            if (p.thisObject != null) {
                                Class<?> c = p.thisObject.getClass();
                                while (c != null && !c.equals(Object.class)) {
                                    for (java.lang.reflect.Field f : c.getDeclaredFields()) {
                                        f.setAccessible(true);
                                        try {
                                            Object v = f.get(p.thisObject);
                                            XposedBridge.log("[WeChatHook]   " + c.getSimpleName()
                                                + "." + f.getName() + "=" + (v == null ? "null"
                                                : (v instanceof String || v instanceof Number || v instanceof Boolean)
                                                    ? v.toString() : v.getClass().getName() + "@" + System.identityHashCode(v)));
                                        } catch (Throwable ignored) {}
                                    }
                                    c = c.getSuperclass();
                                }
                            }
                        } else if ("s".equals(mName)) {
                            // s(3): CDN upload trigger. Log args + full f9 hierarchy for diff analysis.
                            StringBuilder sb = new StringBuilder("[WeChatHook] pt0.e0.s ENTER args:");
                            if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                                Object a = p.args[i];
                                if (a == null) { sb.append(" [").append(i).append("]=null"); }
                                else if (a instanceof String) { sb.append(" [").append(i).append("]=String(\"").append(a).append("\")"); }
                                else if (a instanceof Number) { sb.append(" [").append(i).append("]=").append(a); }
                                else { sb.append(" [").append(i).append("]=").append(a.getClass().getName()).append("@").append(System.identityHashCode(a)); }
                            }
                            XposedBridge.log(sb.toString());
                            // Dump ALL fields of f9 (args[2]) across full parent hierarchy
                            if (p.args != null && p.args.length > 2 && p.args[2] != null) {
                                Object f9 = p.args[2];
                                StringBuilder fb = new StringBuilder("[WeChatHook] pt0.e0.s f9 DUMP:");
                                Class<?> c = f9.getClass();
                                while (c != null && !c.equals(Object.class)) {
                                    for (java.lang.reflect.Field f : c.getDeclaredFields()) {
                                        f.setAccessible(true);
                                        try {
                                            Object v = f.get(f9);
                                            String vs;
                                            if (v == null) vs = "null";
                                            else if (v instanceof byte[]) vs = "byte[" + ((byte[])v).length + "]";
                                            else if (v instanceof String || v instanceof Number || v instanceof Boolean) vs = v.toString();
                                            else vs = v.getClass().getSimpleName() + "@" + System.identityHashCode(v);
                                            fb.append("\n  ").append(c.getSimpleName()).append(".").append(f.getName()).append("=").append(vs);
                                        } catch (Throwable ignored) {}
                                    }
                                    c = c.getSuperclass();
                                }
                                XposedBridge.log(fb.toString());
                            }
                        } else if (p.args != null && p.args.length == 2
                                && ("a".equals(mName) || "b".equals(mName) || "l".equals(mName)
                                    || "n".equals(mName) || "q".equals(mName))) {
                            // Log 2-arg entry methods — one of these is likely the
                            // "enqueue voice for send" entry point called by WeChat UI
                            StringBuilder sb2 = new StringBuilder(
                                "[WeChatHook] pt0.e0." + mName + "(2) ENTER");
                            if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                                Object a = p.args[i];
                                if (a == null) sb2.append(" arg").append(i).append("=null");
                                else if (a instanceof String) sb2.append(" arg").append(i).append("=\"").append(a).append("\"");
                                else if (a instanceof Number) sb2.append(" arg").append(i).append("=").append(a);
                                else sb2.append(" arg").append(i).append("=").append(a.getClass().getName()).append("@").append(System.identityHashCode(a));
                            }
                            XposedBridge.log(sb2.toString());
                        } else {
                            XposedBridge.log("[WeChatHook] pt0.e0." + mName + " ENTER");
                        }
                    }
                    @Override protected void afterHookedMethod(MethodHookParam p) {
                        if (p.hasThrowable()) {
                            XposedBridge.log("[WeChatHook] pt0.e0." + mName + " THREW " + p.getThrowable());
                        } else if ("k".equals(mName)) {
                            Object ret = p.getResult();
                            if (ret != null) {
                                // Dump ALL declared fields on f9 (first call only, to learn field names)
                                StringBuilder fb = new StringBuilder("[WeChatHook] pt0.e0.k OK f9=").append(ret.getClass().getSimpleName());
                                java.lang.reflect.Field[] fields = ret.getClass().getDeclaredFields();
                                for (java.lang.reflect.Field f : fields) {
                                    f.setAccessible(true);
                                    try {
                                        Object v = f.get(ret);
                                        fb.append(" ").append(f.getName()).append("=").append(
                                            v == null ? "null" : (v instanceof String || v instanceof Number || v instanceof Boolean)
                                                ? v.toString() : v.getClass().getSimpleName() + "@" + System.identityHashCode(v));
                                    } catch (Throwable ignored) {}
                                }
                                XposedBridge.log(fb.toString());
                            } else {
                                XposedBridge.log("[WeChatHook] pt0.e0.k OK ret=null");
                            }
                        } else {
                            XposedBridge.log("[WeChatHook] pt0.e0." + mName + " OK ret=" + p.getResult());
                        }
                    }
                });
            }
            XposedBridge.log("[WeChatHook] hookPt0E0: hooked " + methods.length + " methods in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookPt0E0 failed in " + procName + ": " + t);
        }
    }

    // ── Surgical voice-send entry probe ──────────────────────────────────────
    // SAFE version: hooks ONLY the voice-send-specific classes (jg0.x coordinator
    // + qi3.f0/g0 voice-message objects), NOT generic coroutine classes, so it
    // won't add anti-tamper risk to the live Pad session. Goal: find the entry
    // method that receives (talker, silk file/bytes, durationMs) in plain form,
    // which we can then call synthetically to get a real, delivered voice send.
    private static String fmtArg(Object a) {
        if (a == null) return "null";
        if (a instanceof byte[]) return "byte[" + ((byte[]) a).length + "]";
        if (a instanceof String) return "\"" + a + "\"";
        if (a instanceof Number || a instanceof Boolean) return a.toString();
        return a.getClass().getName() + "@" + System.identityHashCode(a);
    }

    // Recursively dump an object's non-static fields, bounded by depth, to find
    // where scalar values (talker string / silk path / duration) are captured.
    private static void dumpDeep(Object o, String prefix, int depth, StringBuilder sb) {
        if (o == null || depth < 0) return;
        for (Class<?> c = o.getClass(); c != null && !c.equals(Object.class); c = c.getSuperclass()) {
            for (java.lang.reflect.Field f : c.getDeclaredFields()) {
                if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                f.setAccessible(true);
                Object v;
                try { v = f.get(o); } catch (Throwable t) { continue; }
                sb.append("\n").append(prefix).append(f.getName()).append("=").append(fmtArg(v));
                // Recurse into non-scalar, non-array WeChat/kotlin objects.
                if (v != null && depth > 0
                        && !(v instanceof String) && !(v instanceof Number)
                        && !(v instanceof Boolean) && !(v instanceof byte[])
                        && !v.getClass().isArray()
                        && !v.getClass().getName().startsWith("java.")
                        && !v.getClass().getName().startsWith("android.")) {
                    dumpDeep(v, prefix + "  ", depth - 1, sb);
                }
            }
        }
    }

    private void hookVoiceProbe(ClassLoader cl, String procName) {
        // jg0.x — voice send coordinator; hook ALL methods to find the entry.
        try {
            Class<?> xClass = XposedHelpers.findClass("jg0.x", cl);
            int n = 0;
            for (java.lang.reflect.Method m : xClass.getDeclaredMethods()) {
                final String mn = m.getName();
                m.setAccessible(true);
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        // ── Voice hot-swap (the route that actually delivers) ──────────
                        // jg0.x.w(jg0.x, qi3.d0, w21.w0, int type, int durMs, w21.t silk, Cont)
                        // is the CDN uploadAttach step. On the REAL (non-resume) call, arg5
                        // (w21.t) holds the recorded SILK in its single byte[] field. When
                        // armed, replace it with our TTS SILK so WeChat uploads our audio.
                        // (This lives in the probe hook because this fork won't stack a 2nd
                        //  hook on an already-hooked method — see hookVoiceSwap note.)
                        if ("w".equals(mn) && sSwapArmed && sSwapSilk != null
                                && System.currentTimeMillis() < sSwapExpiresAt
                                && p.args != null && p.args.length == 7 && p.args[5] != null) {
                            try {
                                Object tHolder = p.args[5];
                                java.lang.reflect.Field byteF = null;
                                for (java.lang.reflect.Field f : tHolder.getClass().getDeclaredFields())
                                    if (f.getType() == byte[].class) { byteF = f; break; }
                                if (byteF != null) {
                                    byteF.setAccessible(true);
                                    byte[] orig = (byte[]) byteF.get(tHolder);
                                    byteF.set(tHolder, sSwapSilk);
                                    if (orig != null) for (java.lang.reflect.Field f : tHolder.getClass().getDeclaredFields()) {
                                        if (f.getType() != int.class) continue;
                                        f.setAccessible(true);
                                        if (f.getInt(tHolder) == orig.length) f.setInt(tHolder, sSwapSilk.length);
                                    }
                                    if (sSwapDuration > 0) p.args[4] = sSwapDuration;
                                    XposedBridge.log("[WeChatHook] VOICE SWAP DONE: "
                                        + (orig == null ? "?" : orig.length) + "B -> " + sSwapSilk.length
                                        + "B dur -> " + p.args[4]);
                                    sSwapArmed = false; sSwapSilk = null;   // one-shot
                                }
                            } catch (Throwable t) {
                                XposedBridge.log("[WeChatHook] VOICE SWAP failed: " + t);
                            }
                        }
                        StringBuilder sb = new StringBuilder("[WeChatHook] jg0.x." + mn + "(");
                        if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                            if (i > 0) sb.append(", ");
                            sb.append(fmtArg(p.args[i]));
                        }
                        sb.append(")");
                        // Deep-dump the send-carrying methods: D's lambda (arg0) and
                        // w's descriptor args — to locate talker/silk/duration fields.
                        if ("D".equals(mn) && p.args != null && p.args.length > 0) {
                            sb.append("\n  [D arg0 pu.m0 deep]:");
                            dumpDeep(p.args[0], "    ", 3, sb);
                        } else if ("w".equals(mn) && p.args != null) {
                            for (int i = 0; i < p.args.length; i++) {
                                if (p.args[i] != null && !(p.args[i] instanceof Number)) {
                                    sb.append("\n  [w arg").append(i).append(" deep]:");
                                    dumpDeep(p.args[i], "    ", 2, sb);
                                }
                            }
                        }
                        XposedBridge.log(sb.toString());
                    }
                });
                n++;
            }
            XposedBridge.log("[WeChatHook] hookVoiceProbe: jg0.x " + n + " methods in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookVoiceProbe jg0.x failed: " + t);
        }
        // qi3.f0 / qi3.g0 — voice-message domain objects; dump ctor args + fields.
        for (String cn : new String[]{"qi3.f0", "qi3.g0"}) {
            try {
                Class<?> c = XposedHelpers.findClass(cn, cl);
                for (java.lang.reflect.Constructor<?> ctor : c.getDeclaredConstructors()) {
                    ctor.setAccessible(true);
                    final String fcn = cn;
                    XposedBridge.hookMethod(ctor, new XC_MethodHook() {
                        @Override protected void afterHookedMethod(MethodHookParam p) {
                            StringBuilder sb = new StringBuilder("[WeChatHook] " + fcn + ".<init>(");
                            if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                                if (i > 0) sb.append(", ");
                                sb.append(fmtArg(p.args[i]));
                            }
                            sb.append(") fields:");
                            for (Class<?> cc = p.thisObject.getClass();
                                    cc != null && !cc.equals(Object.class); cc = cc.getSuperclass()) {
                                for (java.lang.reflect.Field f : cc.getDeclaredFields()) {
                                    if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                                    f.setAccessible(true);
                                    try {
                                        sb.append("\n  ").append(f.getName()).append("=").append(fmtArg(f.get(p.thisObject)));
                                    } catch (Throwable ignored) {}
                                }
                            }
                            XposedBridge.log(sb.toString());
                        }
                    });
                }
                XposedBridge.log("[WeChatHook] hookVoiceProbe: " + cn + " ctor hooked in " + procName);
            } catch (Throwable t) {
                XposedBridge.log("[WeChatHook] hookVoiceProbe " + cn + " failed: " + t);
            }
        }
    }

    // ── Find the voice-send entry point ──────────────────────────────────────
    // pu.o0 is the outer coroutine, launched by the real entry point (async, so
    // it doesn't appear in the jg0.x.D stack). Hooking pu.o0's CONSTRUCTOR gives
    // a synchronous stack trace revealing the method that starts a voice send.
    // Also dumps qi3.f0/g0 constructors (the voice-message domain objects that
    // carry talker/silk/duration).
    private void hookVoiceEntry(ClassLoader cl, String procName) {
        // pu.o0 constructor — stack trace = the real send entry point.
        for (String cn : new String[]{"pu.o0", "pu.m0"}) {
            try {
                Class<?> c = XposedHelpers.findClass(cn, cl);
                for (java.lang.reflect.Constructor<?> ctor : c.getDeclaredConstructors()) {
                    ctor.setAccessible(true);
                    final String fcn = cn;
                    final int np = ctor.getParameterTypes().length;
                    XposedBridge.hookMethod(ctor, new XC_MethodHook() {
                        private volatile boolean logged = false;
                        @Override protected void afterHookedMethod(MethodHookParam p) {
                            if (logged) return;
                            logged = true;
                            StringBuilder sb = new StringBuilder(
                                "[WeChatHook] " + fcn + ".<init>(" + np + ") args:");
                            if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                                Object a = p.args[i];
                                sb.append("\n  arg[").append(i).append("]=")
                                  .append(a == null ? "null" : a.getClass().getName());
                            }
                            sb.append("\n").append(android.util.Log.getStackTraceString(new Exception()));
                            XposedBridge.log(sb.toString());
                        }
                    });
                }
                XposedBridge.log("[WeChatHook] hookVoiceEntry: " + cn + " ctor hooked in " + procName);
            } catch (Throwable t) {
                XposedBridge.log("[WeChatHook] hookVoiceEntry " + cn + " failed: " + t);
            }
        }
        // qi3.f0 / qi3.g0 constructors — dump their args (talker/silk/duration).
        for (String cn : new String[]{"qi3.f0", "qi3.g0"}) {
            try {
                Class<?> c = XposedHelpers.findClass(cn, cl);
                StringBuilder info = new StringBuilder("[WeChatHook] " + cn
                    + " super=" + c.getSuperclass().getName() + " fields:");
                for (java.lang.reflect.Field f : c.getDeclaredFields())
                    info.append(" ").append(f.getName()).append("(").append(f.getType().getSimpleName()).append(")");
                XposedBridge.log(info.toString());
                for (java.lang.reflect.Constructor<?> ctor : c.getDeclaredConstructors()) {
                    ctor.setAccessible(true);
                    final String fcn = cn;
                    XposedBridge.hookMethod(ctor, new XC_MethodHook() {
                        private volatile boolean logged = false;
                        @Override protected void afterHookedMethod(MethodHookParam p) {
                            if (logged) return;
                            logged = true;
                            StringBuilder sb = new StringBuilder(
                                "[WeChatHook] " + fcn + ".<init> args:");
                            if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                                Object a = p.args[i];
                                String vs;
                                if (a == null) vs = "null";
                                else if (a instanceof byte[]) vs = "byte[" + ((byte[])a).length + "]";
                                else if (a instanceof String || a instanceof Number || a instanceof Boolean)
                                    vs = a.getClass().getSimpleName() + "(" + a + ")";
                                else vs = a.getClass().getName();
                                sb.append("\n  arg[").append(i).append("]=").append(vs);
                            }
                            // Dump the constructed object's fields too
                            for (Class<?> cc = p.thisObject.getClass();
                                    cc != null && !cc.equals(Object.class); cc = cc.getSuperclass()) {
                                for (java.lang.reflect.Field f : cc.getDeclaredFields()) {
                                    if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                                    f.setAccessible(true);
                                    try {
                                        Object v = f.get(p.thisObject);
                                        String vs;
                                        if (v == null) vs = "null";
                                        else if (v instanceof byte[]) vs = "byte[" + ((byte[])v).length + "]";
                                        else if (v instanceof String || v instanceof Number || v instanceof Boolean) vs = v.toString();
                                        else vs = v.getClass().getSimpleName();
                                        sb.append("\n  this.").append(f.getName()).append("=").append(vs);
                                    } catch (Throwable ignored) {}
                                }
                            }
                            XposedBridge.log(sb.toString());
                        }
                    });
                }
                XposedBridge.log("[WeChatHook] hookVoiceEntry: " + cn + " ctor hooked in " + procName);
            } catch (Throwable t) {
                XposedBridge.log("[WeChatHook] hookVoiceEntry " + cn + " failed: " + t);
            }
        }
    }

    // ── Hook jg0.j / jg0.x / g9 ─────────────────────────────────────────────
    // Reveals the internal structure needed to call pt0.e0.r() synthetically.
    // jg0.j captures the g9 (voice message / f9 subclass) as a field.
    // jg0.x.D sets up jg0.j and starts the coroutine.
    // g9 extends f9 (or is f9) with M9/N9 DB-insert methods.
    private void hookJg0(ClassLoader cl, String procName) {
        // ── jg0.j (the inner coroutine whose invokeSuspend calls pt0.e0.r) ────
        try {
            Class<?> jClass = XposedHelpers.findClass("jg0.j", cl);
            StringBuilder jInfo = new StringBuilder("[WeChatHook] jg0.j class=" + jClass.getName()
                + " super=" + jClass.getSuperclass().getName() + " ownFields:");
            for (java.lang.reflect.Field f : jClass.getDeclaredFields())
                jInfo.append(" ").append(f.getName()).append("(").append(f.getType().getSimpleName()).append(")");
            jInfo.append(" | superFields:");
            for (java.lang.reflect.Field f : jClass.getSuperclass().getDeclaredFields())
                jInfo.append(" ").append(f.getName()).append("(").append(f.getType().getSimpleName()).append(")");
            XposedBridge.log(jInfo.toString());

            // Hook invokeSuspend — fires every time a jg0.j coroutine step runs.
            // We only care about the FIRST call (state=0, label=0) to see captured fields.
            try {
                XposedHelpers.findAndHookMethod(jClass, "invokeSuspend", Object.class,
                    new XC_MethodHook() {
                        private volatile boolean sLogged = false;
                        @Override protected void beforeHookedMethod(MethodHookParam p) {
                            if (sLogged) return;
                            sLogged = true;
                            StringBuilder sb = new StringBuilder(
                                "[WeChatHook] jg0.j.invokeSuspend FIRST fields:");
                            for (Class<?> c = p.thisObject.getClass();
                                    c != null && !c.equals(Object.class); c = c.getSuperclass()) {
                                for (java.lang.reflect.Field f : c.getDeclaredFields()) {
                                    if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                                    f.setAccessible(true);
                                    try {
                                        Object v = f.get(p.thisObject);
                                        sb.append("\n  ").append(c.getSimpleName())
                                          .append(".").append(f.getName()).append("=")
                                          .append(v == null ? "null"
                                            : v.getClass().getName() + "@" + System.identityHashCode(v));
                                    } catch (Throwable ignored) {}
                                }
                            }
                            XposedBridge.log(sb.toString());
                        }
                    });
            } catch (Throwable t) {
                XposedBridge.log("[WeChatHook] hookJg0 jg0.j.invokeSuspend hook failed: " + t);
            }
            XposedBridge.log("[WeChatHook] hookJg0: jg0.j hooked in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookJg0 jg0.j failed: " + t);
        }

        // ── jg0.x (coordinator that creates jg0.j and calls D to enqueue send) ──
        try {
            Class<?> xClass = XposedHelpers.findClass("jg0.x", cl);
            StringBuilder xInfo = new StringBuilder("[WeChatHook] jg0.x methods:");
            for (java.lang.reflect.Method m : xClass.getDeclaredMethods())
                xInfo.append(" ").append(m.getName()).append("(").append(m.getParameterTypes().length).append(")");
            xInfo.append(" | ownFields:");
            for (java.lang.reflect.Field f : xClass.getDeclaredFields())
                xInfo.append(" ").append(f.getName()).append("(").append(f.getType().getSimpleName()).append(")");
            XposedBridge.log(xInfo.toString());

            // Hook D() — the method called from pu.o0.invokeSuspend(84) that enqueues the send
            for (java.lang.reflect.Method m : xClass.getDeclaredMethods()) {
                if (!"D".equals(m.getName())) continue;
                m.setAccessible(true);
                final String sig = m.toGenericString();
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        StringBuilder sb = new StringBuilder(
                            "[WeChatHook] jg0.x.D ENTER sig=" + sig);
                        // args
                        if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                            Object a = p.args[i];
                            sb.append("\n  arg[").append(i).append("]=")
                              .append(a == null ? "null" : a.getClass().getName()
                                + "@" + System.identityHashCode(a));
                            // If it looks like a voice-msg / f9 subclass, dump its fields
                            if (a != null) {
                                for (Class<?> c2 = a.getClass();
                                        c2 != null && !c2.equals(Object.class); c2 = c2.getSuperclass()) {
                                    for (java.lang.reflect.Field f2 : c2.getDeclaredFields()) {
                                        if (java.lang.reflect.Modifier.isStatic(f2.getModifiers())) continue;
                                        f2.setAccessible(true);
                                        try {
                                            Object v2 = f2.get(a);
                                            String vs;
                                            if (v2 == null) vs = "null";
                                            else if (v2 instanceof byte[]) vs = "byte[" + ((byte[])v2).length + "]";
                                            else if (v2 instanceof String || v2 instanceof Number
                                                    || v2 instanceof Boolean) vs = v2.toString();
                                            else vs = v2.getClass().getSimpleName();
                                            sb.append("\n    ").append(c2.getSimpleName())
                                              .append(".").append(f2.getName()).append("=").append(vs);
                                        } catch (Throwable ignored2) {}
                                    }
                                }
                            }
                        }
                        // thisObject fields
                        for (Class<?> c = p.thisObject.getClass();
                                c != null && !c.equals(Object.class); c = c.getSuperclass()) {
                            for (java.lang.reflect.Field f : c.getDeclaredFields()) {
                                if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                                f.setAccessible(true);
                                try {
                                    Object v = f.get(p.thisObject);
                                    sb.append("\n  this.").append(c.getSimpleName())
                                      .append(".").append(f.getName()).append("=")
                                      .append(v == null ? "null" : v.getClass().getName());
                                } catch (Throwable ignored) {}
                            }
                        }
                        XposedBridge.log(sb.toString());
                    }
                });
            }
            XposedBridge.log("[WeChatHook] hookJg0: jg0.x hooked in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookJg0 jg0.x failed: " + t);
        }

        // ── g9 (likely a subclass of f9; M9/N9 are the DB-insert methods) ─────
        try {
            Class<?> g9Class = XposedHelpers.findClass("com.tencent.mm.storage.g9", cl);
            StringBuilder g9Info = new StringBuilder("[WeChatHook] g9 super="
                + g9Class.getSuperclass().getName() + " methods:");
            for (java.lang.reflect.Method m : g9Class.getDeclaredMethods())
                g9Info.append(" ").append(m.getName()).append("(").append(m.getParameterTypes().length).append(")");
            g9Info.append(" | ownFields:");
            for (java.lang.reflect.Field f : g9Class.getDeclaredFields())
                g9Info.append(" ").append(f.getName()).append("(").append(f.getType().getSimpleName()).append(")");
            XposedBridge.log(g9Info.toString());

            for (java.lang.reflect.Method m : g9Class.getDeclaredMethods()) {
                if (!"M9".equals(m.getName()) && !"N9".equals(m.getName())) continue;
                m.setAccessible(true);
                final String mName2 = m.getName();
                final String mSig2 = m.toGenericString();
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        StringBuilder sb = new StringBuilder(
                            "[WeChatHook] g9." + mName2 + " ENTER sig=" + mSig2
                            + " thisClass=" + p.thisObject.getClass().getName());
                        if (p.args != null) for (int i = 0; i < p.args.length; i++)
                            sb.append(" arg[").append(i).append("]=")
                              .append(p.args[i] == null ? "null" : p.args[i].getClass().getName());
                        XposedBridge.log(sb.toString());
                    }
                    @Override protected void afterHookedMethod(MethodHookParam p) {
                        if (p.hasThrowable())
                            XposedBridge.log("[WeChatHook] g9." + mName2 + " THREW: " + p.getThrowable());
                        else
                            XposedBridge.log("[WeChatHook] g9." + mName2 + " OK ret=" + p.getResult());
                    }
                });
            }
            XposedBridge.log("[WeChatHook] hookJg0: g9 hooked in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookJg0 g9 failed: " + t);
        }

        // ── pu.o0 (outer coroutine that calls jg0.x.D) ───────────────────────
        // Hook invokeSuspend to see what it captures (especially the g9/voice data).
        try {
            Class<?> puClass = XposedHelpers.findClass("pu.o0", cl);
            StringBuilder puInfo = new StringBuilder("[WeChatHook] pu.o0 super="
                + puClass.getSuperclass().getName() + " | ownFields:");
            for (java.lang.reflect.Field f : puClass.getDeclaredFields())
                puInfo.append(" ").append(f.getName()).append("(").append(f.getType().getSimpleName()).append(")");
            XposedBridge.log(puInfo.toString());

            XposedHelpers.findAndHookMethod(puClass, "invokeSuspend", Object.class,
                new XC_MethodHook() {
                    private volatile boolean sLogged2 = false;
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        if (sLogged2) return;
                        sLogged2 = true;
                        StringBuilder sb = new StringBuilder(
                            "[WeChatHook] pu.o0.invokeSuspend FIRST fields:");
                        for (Class<?> c = p.thisObject.getClass();
                                c != null && !c.equals(Object.class); c = c.getSuperclass()) {
                            for (java.lang.reflect.Field f : c.getDeclaredFields()) {
                                if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                                f.setAccessible(true);
                                try {
                                    Object v = f.get(p.thisObject);
                                    sb.append("\n  ").append(c.getSimpleName())
                                      .append(".").append(f.getName()).append("=")
                                      .append(v == null ? "null"
                                        : v.getClass().getName() + "@" + System.identityHashCode(v));
                                } catch (Throwable ignored) {}
                            }
                        }
                        XposedBridge.log(sb.toString());
                    }
                });
            XposedBridge.log("[WeChatHook] hookJg0: pu.o0 hooked in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookJg0 pu.o0 failed: " + t);
        }
    }

    private void hookR0H(ClassLoader cl, String procName) {
        try {
            Class<?> r0Class = XposedHelpers.findClass("w11.r0", cl);
            int hooked = 0;
            // Hook ALL methods named H on r0 — real voice sends may use H() or H(int), not just H(String).
            for (java.lang.reflect.Method m : r0Class.getDeclaredMethods()) {
                if (!m.getName().equals("H")) continue;
                final String sig = m.toGenericString();
                final boolean isHString = m.getParameterTypes().length == 1
                        && m.getParameterTypes()[0] == String.class;
                m.setAccessible(true);
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override
                    protected void beforeHookedMethod(MethodHookParam p) throws Throwable {
                        String by = sCalledByUs ? "US" : "WeChat";
                        XposedBridge.log("[WeChatHook] r0." + sig + " ENTER by=" + by + " proc=" + procName);
                        // Capture real dispatcher from any real WeChat r0 H() call.
                        if (!sCalledByUs) {
                            try {
                                Object disp = XposedHelpers.getObjectField(p.thisObject, "dispatcher");
                                if (disp != null && !(disp instanceof java.lang.reflect.Proxy)) {
                                    sCapturedDispatcher = disp;
                                    XposedBridge.log("[WeChatHook] hookR0H: REAL dispatcher=" + disp.getClass().getName() + " from " + sig);
                                }
                            } catch (Throwable ignored) {}
                            // Also dump r0 fields on first real send to capture full state.
                            dumpR0Fields(p.thisObject, "r0.H-WeChat by=" + by + " proc=" + procName);
                        } else if (isHString) {
                            dumpR0Fields(p.thisObject, "r0.H-ENTER by=US proc=" + procName);
                        }
                    }
                    @Override
                    protected void afterHookedMethod(MethodHookParam p) throws Throwable {
                        String by = sCalledByUs ? "US" : "WeChat";
                        XposedBridge.log("[WeChatHook] r0.H() DONE by=" + by + " proc=" + procName
                            + (p.hasThrowable() ? " THREW=" + p.getThrowable() : " OK"));
                    }
                });
                hooked++;
            }
            XposedBridge.log("[WeChatHook] hookR0H: hooked " + hooked + " H() overloads in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookR0H failed in " + procName + ": " + t);
        }
    }

    // ── Capture live network dispatcher (com.tencent.mm.modelbase.m2) ────────────
    // m2 = MicroMsg.RDispatcher, the com.tencent.mm.network.s the send scene needs.
    // We grab the instance at construction (network init, before any synthetic send)
    // into sCapturedDispatcher, so sendVoiceViaAPI can hand r0 the REAL dispatcher.
    private void hookDispatcher(ClassLoader cl, String procName) {
        try {
            Class<?> m2 = XposedHelpers.findClass("com.tencent.mm.modelbase.m2", cl);
            XC_MethodHook grab = new XC_MethodHook() {
                @Override protected void beforeHookedMethod(MethodHookParam p) {
                    if (sCapturedDispatcher == null && p.thisObject != null
                            && !(p.thisObject instanceof java.lang.reflect.Proxy)) {
                        sCapturedDispatcher = p.thisObject;
                        XposedBridge.log("[WeChatHook] hookDispatcher: captured REAL m2="
                            + p.thisObject + " in " + procName);
                    }
                }
            };
            int n = 0;
            // Ctor: catches m2 constructed AFTER we install (network re-init).
            for (java.lang.reflect.Constructor<?> c : m2.getDeclaredConstructors()) {
                c.setAccessible(true);
                XposedBridge.hookMethod(c, new XC_MethodHook() {
                    @Override protected void afterHookedMethod(MethodHookParam p) {
                        sCapturedDispatcher = p.thisObject;
                        XposedBridge.log("[WeChatHook] hookDispatcher: captured REAL m2 (ctor)="
                            + p.thisObject + " in " + procName);
                    }
                });
                n++;
            }
            // Instance methods: catches an ALREADY-existing m2 (constructed before our
            // hook / persistent connection) on its next network call. After capture the
            // callback is a single null check — negligible overhead.
            int mh = 0;
            for (java.lang.reflect.Method m : m2.getDeclaredMethods()) {
                if (java.lang.reflect.Modifier.isStatic(m.getModifiers())) continue;
                if (java.lang.reflect.Modifier.isAbstract(m.getModifiers())) continue;
                try { m.setAccessible(true); XposedBridge.hookMethod(m, grab); mh++; }
                catch (Throwable ignored) {}
            }
            XposedBridge.log("[WeChatHook] hookDispatcher: hooked " + n + " ctor(s) + "
                + mh + " method(s) on m2 in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookDispatcher failed in " + procName + ": " + t);
        }
    }

    // ── Instrument voice-upload service w21.g1 (voiceinfo table) ─────────────────
    // On a REAL voice send, WeChat builds a w21.w0 upload-task and calls g1.L0(w0)
    // (insert) / g1.P0(file, w0) (upload). Dump every w0 field on those calls so we
    // learn the exact template (FileName/ClientId/MsgLocalId/VoiceLength/MsgTalker/
    // Status correlation) needed to synthesize the upload for hook-sent voice.
    // ── Voice hot-swap: replace recorded SILK with our TTS at the CDN-upload step ─
    // jg0.x.w(jg0.x self, qi3.d0, w21.w0, int type, int durationMs, w21.t silk, Cont)
    //   is WeChat's uploadAttach step (confirmed by real-recording capture + tinker
    //   decompile). w21.t has exactly one byte[] field (f443506a) = the SILK audio
    //   about to be sent to CDN. When armed, we overwrite that byte[] with our TTS
    //   SILK and the duration int (arg4). WeChat then uploads + delivers OUR audio,
    //   reusing the entire real send pipeline we cannot rebuild.
    // Hook runs in the process where recording happens (main). Verified swap target,
    // but does its own field dump on every fire so a first real test confirms layout.
    private void hookVoiceSwap(ClassLoader cl, String procName) {
        try {
            Class<?> xClass = XposedHelpers.findClass("jg0.x", cl);
            int hooked = 0;
            for (java.lang.reflect.Method m : xClass.getDeclaredMethods()) {
                if (!"w".equals(m.getName())) continue;   // hook EVERY 'w' overload
                m.setAccessible(true);
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        // Absolute-first, arg-safe entry log so we KNOW the hook runs.
                        int n = (p.args == null) ? 0 : p.args.length;
                        XposedBridge.log("[WeChatHook] SWAPHOOK ENTER w nargs=" + n + " armed=" + sSwapArmed);
                        try {
                            // Real uploadAttach call: (jg0.x, qi3.d0, w21.w0, int, int, w21.t, Cont).
                            // Coroutine resumptions re-call w with nulls — skip those.
                            if (n != 7 || p.args[5] == null) return;
                            Object tHolder = p.args[5];       // w21.t (SILK holder)
                            java.lang.reflect.Field byteF = null;
                            for (java.lang.reflect.Field f : tHolder.getClass().getDeclaredFields()) {
                                if (f.getType() == byte[].class) { byteF = f; break; }
                            }
                            if (byteF == null) return;
                            byteF.setAccessible(true);
                            byte[] orig = (byte[]) byteF.get(tHolder);
                            XposedBridge.log("[WeChatHook] SWAPHOOK real w: silk="
                                + (orig == null ? "null" : orig.length + "B") + " durArg=" + p.args[4]
                                + " holder=" + tHolder.getClass().getName());
                            if (!sSwapArmed || sSwapSilk == null) return;

                            byteF.set(tHolder, sSwapSilk);
                            if (orig != null) {
                                for (java.lang.reflect.Field f : tHolder.getClass().getDeclaredFields()) {
                                    if (f.getType() != int.class) continue;
                                    f.setAccessible(true);
                                    if (f.getInt(tHolder) == orig.length) f.setInt(tHolder, sSwapSilk.length);
                                }
                            }
                            if (sSwapDuration > 0) p.args[4] = sSwapDuration;
                            XposedBridge.log("[WeChatHook] VOICE SWAP DONE: "
                                + (orig == null ? "?" : orig.length) + "B -> " + sSwapSilk.length
                                + "B, dur -> " + p.args[4]);
                            sSwapArmed = false;      // one-shot
                            sSwapSilk = null;
                        } catch (Throwable t) {
                            XposedBridge.log("[WeChatHook] VOICE SWAP failed: " + t
                                + "\n" + android.util.Log.getStackTraceString(t));
                        }
                    }
                });
                hooked++;
            }
            XposedBridge.log("[WeChatHook] hookVoiceSwap: hooked jg0.x.w x" + hooked + " in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookVoiceSwap failed in " + procName + ": " + t);
        }
    }

    private void hookVoiceUpload(ClassLoader cl, String procName) {
        try {
            Class<?> g1 = XposedHelpers.findClass("w21.g1", cl);
            int mh = 0;
            for (java.lang.reflect.Method m : g1.getDeclaredMethods()) {
                final String mName = m.getName();
                // L0(w0)=insert, P0(file,w0)=upload, D0/J0/y0/z0=lookups. Dump w0 on all.
                if (!("L0".equals(mName) || "P0".equals(mName))) continue;
                m.setAccessible(true);
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        try {
                            // find the w0 arg (w21.w0) among args
                            Object w0 = null;
                            if (p.args != null) for (Object a : p.args)
                                if (a != null && a.getClass().getName().equals("w21.w0")) { w0 = a; break; }
                            StringBuilder sb = new StringBuilder("[WeChatHook] g1." + mName
                                + " by=" + (sCalledByUs ? "US" : "REAL") + " args=[");
                            if (p.args != null) for (int i = 0; i < p.args.length; i++) {
                                Object a = p.args[i];
                                sb.append(i > 0 ? ", " : "").append(a == null ? "null"
                                    : (a instanceof String ? "\"" + a + "\"" : a.getClass().getSimpleName()));
                            }
                            sb.append("]");
                            if (w0 != null) {
                                sb.append("\n  w21.w0 DUMP:");
                                for (java.lang.reflect.Field f : w0.getClass().getDeclaredFields()) {
                                    if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                                    f.setAccessible(true);
                                    Object v = f.get(w0);
                                    String vs = v == null ? "null"
                                        : (v instanceof byte[] ? "byte[" + ((byte[]) v).length + "]"
                                        : (v instanceof String || v instanceof Number || v instanceof Boolean ? v.toString()
                                        : v.getClass().getSimpleName()));
                                    sb.append("\n    ").append(f.getName()).append("=").append(vs);
                                }
                            }
                            XposedBridge.log(sb.toString());
                        } catch (Throwable ignored) {}
                    }
                });
                mh++;
            }
            XposedBridge.log("[WeChatHook] hookVoiceUpload: hooked " + mh + " g1 method(s) in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookVoiceUpload failed in " + procName + ": " + t);
        }
    }

    // ── Image send: hook b80.u.pj/Bi (the real non-suspend send entry) ───────────
    // b80.u (implements o70.e, = n0.c(o70.e.class)) is the image plugin. The send
    // coroutine b80.s calls b80.u.Bi(o70.h,String) then b80.u.pj(o70.h). We hook both
    // to (1) capture the live b80.u instance and (2) on a REAL image send, dump the
    // full o70.h (PreBuildParams) field-by-field — that's the exact recipe to replicate.
    private static void dumpO70h(Object h, String tag) {
        try {
            StringBuilder sb = new StringBuilder("[WeChatHook] " + tag + " o70.h DUMP:");
            for (java.lang.reflect.Field f : h.getClass().getDeclaredFields()) {
                if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                f.setAccessible(true);
                Object v = f.get(h);
                String vs = v == null ? "null"
                    : (v instanceof byte[] ? "byte[" + ((byte[]) v).length + "]"
                    : (v instanceof String || v instanceof Number || v instanceof Boolean || v instanceof android.net.Uri
                        ? v.toString() : v.getClass().getName() + "@" + System.identityHashCode(v)));
                sb.append("\n    ").append(f.getName()).append(" (").append(f.getType().getSimpleName())
                  .append(") = ").append(vs);
            }
            XposedBridge.log(sb.toString());
        } catch (Throwable t) { XposedBridge.log("[WeChatHook] dumpO70h err: " + t); }
    }

    // Hook SendImgProxyUI.onCreate → dump the launch Intent extras. Real gallery image
    // sends run through this proxy Activity ($$a.run → b80.s coroutine → send). Capturing
    // its Intent lets us replay the WHOLE real flow via `am start` with the same extras.
    private void hookSendImgProxyUI(ClassLoader cl, String procName) {
        try {
            XposedHelpers.findAndHookMethod(
                "com.tencent.mm.ui.chatting.SendImgProxyUI", cl, "onCreate",
                android.os.Bundle.class, new XC_MethodHook() {
                    @Override protected void afterHookedMethod(MethodHookParam p) {
                        try {
                            android.content.Intent it = (android.content.Intent)
                                XposedHelpers.callMethod(p.thisObject, "getIntent");
                            if (it == null) { XposedBridge.log("[WeChatHook] SendImgProxyUI: intent null"); return; }
                            android.os.Bundle ex = it.getExtras();
                            StringBuilder sb = new StringBuilder("[WeChatHook] SendImgProxyUI INTENT:");
                            sb.append("\n  action=").append(it.getAction());
                            sb.append("\n  data=").append(it.getDataString());
                            if (ex != null) for (String key : ex.keySet()) {
                                Object v = ex.get(key);
                                String vs = v == null ? "null"
                                    : (v instanceof java.util.ArrayList ? "ArrayList" + v
                                    : (v.getClass().isArray() ? v.getClass().getSimpleName() + java.util.Arrays.deepToString(new Object[]{v})
                                    : v.toString()));
                                if (vs.length() > 300) vs = vs.substring(0, 300) + "…";
                                sb.append("\n  [").append(key).append("] (")
                                  .append(v == null ? "?" : v.getClass().getName()).append(") = ").append(vs);
                            }
                            XposedBridge.log(sb.toString());
                        } catch (Throwable t) { XposedBridge.log("[WeChatHook] SendImgProxyUI dump err: " + t); }
                    }
                });
            XposedBridge.log("[WeChatHook] hookSendImgProxyUI OK in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookSendImgProxyUI failed in " + procName + ": " + t);
        }
    }

    private void hookImageSend(ClassLoader cl, String procName) {
        try {
            Class<?> u = XposedHelpers.findClass("b80.u", cl);
            int n = 0;
            for (java.lang.reflect.Method m : u.getDeclaredMethods()) {
                final String mn = m.getName();
                if (!("pj".equals(mn) || "Bi".equals(mn) || "oj".equals(mn))) continue;
                Class<?>[] pts = m.getParameterTypes();
                if (pts.length < 1) continue;
                final boolean isOj = "oj".equals(mn); // oj(o70.k) = the insert/send step
                if (!isOj && !pts[0].getName().equals("o70.h")) continue;
                m.setAccessible(true);
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override protected void beforeHookedMethod(MethodHookParam p) {
                        if (sImgPlugin == null && p.thisObject != null) {
                            sImgPlugin = p.thisObject;
                            XposedBridge.log("[WeChatHook] hookImageSend: captured b80.u=" + p.thisObject);
                        }
                        if (!sCalledByUs && p.args != null && p.args.length > 0 && p.args[0] != null) {
                            if (isOj) {
                                // o70.k — the insert object. Dump its full field tree.
                                Object k = p.args[0];
                                sRealImgK = k;
                                XposedBridge.log("[WeChatHook] b80.u.oj REAL o70.k class=" + k.getClass().getName());
                                dumpO70h(k, "b80.u.oj REAL o70.k");
                            } else {
                                sRealImgParams = p.args[0];
                                dumpO70h(p.args[0], "b80.u." + mn + " REAL");
                            }
                        }
                    }
                });
                n++;
            }
            XposedBridge.log("[WeChatHook] hookImageSend: hooked " + n + " b80.u method(s) in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookImageSend failed in " + procName + ": " + t);
        }
    }

    // ── Voice send via internal API ────────────────────────────────────────────
    // Protocol (confirmed by hooking f9.convertTo() on real user send):
    //   • content XML: <msg><voicemsg voicelength="{ms}" fromusername="{wxid}" isPlayed="false"></voicemsg></msg>
    //   • imgPath    : 26-char hex voice file ID (f9 field, determines file location)
    //   • voice2 dir : voice2/md5(voiceId)[0:2]/md5(voiceId)[2:4]/msg_{voiceId}.amr  (confirmed formula)
    //
    // Two modes (mutually exclusive extras):
    //   (a) voice_id — caller pre-placed the SILK file in voice2 already (no file I/O here)
    //   (b) src_path — WeChat-readable path (e.g. /data/data/com.tencent.mm/cache/…);
    //       hook generates voice_id, copies src_path → voice2/{dir}/msg_{id}.amr internally
    //       (WeChat process has full access to its own data dir, unlike root which is SELinux-blocked)
    //
    // Typical flow for TTS voice:
    //   root: cp tts.amr /data/data/com.tencent.mm/cache/hook_voice_src.amr && chown u0_a330 ...
    //   broadcast: --es to filehelper --es src_path /data/data/com.tencent.mm/cache/hook_voice_src.amr --ei duration 3000
    private static void sendVoiceViaAPI(String talker, String voiceId, String srcPath,
            int durationMs, String fromWxId) throws Throwable {
        ClassLoader cl = sTinkerCL != null ? sTinkerCL : sWeChatCL;
        if (cl == null) throw new IllegalStateException("classloader null");

        // ── File placement ───────────────────────────────────────────────────
        if (voiceId == null || voiceId.isEmpty()) {
            // Mode (b): generate voice_id and copy SILK from srcPath
            if (srcPath == null || srcPath.isEmpty())
                throw new IllegalArgumentException("need either voice_id or src_path");
            byte[] idBytes = new byte[13];
            new java.util.Random().nextBytes(idBytes);
            StringBuilder sb = new StringBuilder(26);
            for (byte b : idBytes) sb.append(String.format("%02x", b & 0xff));
            voiceId = sb.toString();

            java.security.MessageDigest md5 = java.security.MessageDigest.getInstance("MD5");
            byte[] mdBytes = md5.digest(voiceId.getBytes("UTF-8"));
            String dir1 = String.format("%02x", mdBytes[0] & 0xff);
            String dir2 = String.format("%02x", mdBytes[1] & 0xff);

            String mmDir = "/data/data/com.tencent.mm/MicroMsg/653cdc2320abb089e149a3f7a7683fcf";
            String destDir  = mmDir + "/voice2/" + dir1 + "/" + dir2;
            String destPath = destDir + "/msg_" + voiceId + ".amr";
            new java.io.File(destDir).mkdirs();
            try (java.io.FileInputStream in  = new java.io.FileInputStream(srcPath);
                 java.io.FileOutputStream out = new java.io.FileOutputStream(destPath)) {
                byte[] buf = new byte[8192]; int n;
                while ((n = in.read(buf)) != -1) out.write(buf, 0, n);
            }
            new java.io.File(destPath).setReadable(true, false);
            XposedBridge.log("[WeChatHook] sendVoiceViaAPI: " + srcPath + " -> " + destPath);
        } else if (voiceId.length() != 26) {
            throw new IllegalArgumentException("voice_id must be 26 hex chars, got: " + voiceId);
        }

        // ── Build voice XML ──────────────────────────────────────────────────
        // fromusername is the sender's wxid. sMyWxid is auto-discovered from the first
        // real UI voice send; fall back to the known wxid for this device.
        String safeFrom = (fromWxId != null && !fromWxId.isEmpty())
            ? fromWxId
            : (sMyWxid != null ? sMyWxid : "wxid_51ap3m6p9xs722");
        String voiceXml = "<msg><voicemsg voicelength=\"" + durationMs
            + "\" fromusername=\"" + safeFrom + "\" isPlayed=\"false\"></voicemsg></msg>";

        // ── Probe f9 setter map BEFORE setting sPendingVoiceId ───────────────
        Class<?> f9Class = XposedHelpers.findClass("com.tencent.mm.storage.f9", cl);
        if (sF9SetterMap == null) sF9SetterMap = probeAllF9Setters(f9Class);
        if (!sF9SetterMap.containsKey("imgPath"))
            throw new IllegalStateException("imgPath setter not found in map: " + sF9SetterMap);

        // ── Synthetic lvbuffer (waveform visualization, NOT the SILK audio) ────
        // Real WeChat always stores exactly 74 bytes regardless of duration:
        // 4-byte header (0x7b 0x00 0x00 0x00) + 70 zero bytes. The size is fixed.
        byte[] syntheticLv = new byte[74];
        syntheticLv[0] = 0x7b;
        // bytes 1..73 default to 0x00
        XposedBridge.log("[WeChatHook] sendVoiceViaAPI: synthetic lvbuffer 74 bytes for " + durationMs + "ms");

        // ── Create r0: try Object-param ctor first (real WeChat voice path) ─────
        // WeChat has two 5-param r0 ctors:
        //   (String, String, int, int, long)   — timestamp variant
        //   (String, String, int, int, Object) — audio-path variant (used by real voice sends)
        // The Object ctor stores the audio file reference that H() reads for CDN upload.
        // If it works, r0 sets imgPath internally and H() can find the SILK for upload.
        // Fall back to long ctor if the Object ctor throws.
        Class<?> r0Class = XposedHelpers.findClass("w11.r0", cl);
        sPendingVoiceId.set(voiceId);
        sPendingLvBuffer.set(syntheticLv);
        sCalledByUs = true;
        Object r0;
        try {
            try {
                // Pass the voice2 path (where we placed the SILK) as the Object arg.
                // Real WeChat passes the temp recording file; we pass our already-placed file.
                String voiceFilePath = srcPath != null ? srcPath
                    : "/data/data/com.tencent.mm/MicroMsg/653cdc2320abb089e149a3f7a7683fcf/voice2/"
                    + String.format("%02x", java.security.MessageDigest.getInstance("MD5")
                        .digest(voiceId.getBytes("UTF-8"))[0] & 0xff)
                    + "/" + String.format("%02x", java.security.MessageDigest.getInstance("MD5")
                        .digest(voiceId.getBytes("UTF-8"))[1] & 0xff)
                    + "/msg_" + voiceId + ".amr";
                r0 = XposedHelpers.newInstance(r0Class,
                    new Class<?>[]{String.class, String.class, int.class, int.class, Object.class},
                    talker, voiceXml, 34, 0, voiceFilePath);
                XposedBridge.log("[WeChatHook] sendVoiceViaAPI: used Object-ctor with path=" + voiceFilePath);
            } catch (Throwable e1) {
                XposedBridge.log("[WeChatHook] sendVoiceViaAPI: Object-ctor failed (" + e1 + "), falling back to long-ctor");
                long ts = System.currentTimeMillis();
                r0 = XposedHelpers.newInstance(r0Class,
                    new Class<?>[]{String.class, String.class, int.class, int.class, long.class},
                    talker, voiceXml, 34, 0, ts);
            }
        } finally {
            sCalledByUs = false;
            sPendingVoiceId.remove();
            sPendingLvBuffer.remove();
        }
        // Dump r0 fields so we can see which field holds the audio path.
        dumpR0Fields(r0, "r0-after-ctor by=US");

        // ── Leave r0.p == null: take the AUTHENTIC new-send path ──────────────────
        // The r0 Object-ctor already inserted a proper f9 (content=voiceXml, imgPath
        // injected by hookF9ImgPathInjector, status=1) via cj().N9(). With p==null,
        // NetSceneSendMsg.doScene() reloads that f9 fresh from the DB (cj().c6()) —
        // content/msgsource intact — and assembles + dispatches it, exactly like a
        // real new send.
        //
        // Previously we forced r0.p = sDatabaseF9. That sends doScene down the *resend*
        // branch (which expects status=5 and logs "should not be resend"), handing the
        // MsgSource assembler a stale in-memory f9 whose content reads null →
        // e14.k.fromXml(null) NPE. That was the root-cause blocker; fixed by NOT setting p.
        sDatabaseF9.remove();

        // ── Set dispatcher on r0 (required for CDN upload via H()) ─────────────
        // r0.dispatcher (type com.tencent.mm.network.s) is null in our synthetic r0.
        // H() NPEs on `dispatcher.J(z0, o0, int)` if null.
        // We capture dispatcher from the first real WeChat r0 that enters H() (hookR0H).
        if (sCapturedDispatcher != null && !(sCapturedDispatcher instanceof java.lang.reflect.Proxy)) {
            // Real dispatcher captured from a genuine WeChat send — use it directly.
            try {
                XposedHelpers.setObjectField(r0, "dispatcher", sCapturedDispatcher);
                XposedBridge.log("[WeChatHook] sendVoiceViaAPI: set r0.dispatcher REAL class="
                    + sCapturedDispatcher.getClass().getName());
            } catch (Throwable ed) {
                XposedBridge.log("[WeChatHook] sendVoiceViaAPI: r0.dispatcher set failed: " + ed);
            }
        } else {
            // No real dispatcher yet — fall through to proxy creation below.
            // (Cached proxy is reused if already created; fresh one made otherwise.)
            // Dispatcher not yet captured — search WeChat singletons for it.
            // gm0.j1.i() returns the message manager which likely holds a dispatcher reference.
            XposedBridge.log("[WeChatHook] sendVoiceViaAPI: dispatcher null, searching singletons...");
            outer:
            for (String[] candidate : new String[][]{
                    {"gm0.j1", "i"},    // message manager singleton
                    {"tg3.t1", "a"},    // service locator
            }) {
                try {
                    Class<?> mgr = XposedHelpers.findClass(candidate[0], cl);
                    Object inst = XposedHelpers.callStaticMethod(mgr, candidate[1]);
                    if (inst == null) continue;
                    // Walk inst's fields recursively (depth 2) looking for dispatcher
                    for (java.lang.reflect.Field f1 : inst.getClass().getDeclaredFields()) {
                        if (java.lang.reflect.Modifier.isStatic(f1.getModifiers())) continue;
                        f1.setAccessible(true);
                        Object v1 = f1.get(inst);
                        if (v1 == null) continue;
                        // Level 1: try r0.dispatcher field name on v1 directly
                        try {
                            Object d = XposedHelpers.getObjectField(v1, "dispatcher");
                            if (d != null) {
                                sCapturedDispatcher = d;
                                XposedBridge.log("[WeChatHook] dispatcher found: "
                                    + candidate[0] + "." + candidate[1] + "()." + f1.getName()
                                    + ".dispatcher=" + d.getClass().getName());
                                XposedHelpers.setObjectField(r0, "dispatcher", d);
                                break outer;
                            }
                        } catch (Throwable ignored1) {}
                        // Level 2: walk v1's fields
                        for (java.lang.reflect.Field f2 : v1.getClass().getDeclaredFields()) {
                            if (java.lang.reflect.Modifier.isStatic(f2.getModifiers())) continue;
                            f2.setAccessible(true);
                            Object v2 = f2.get(v1);
                            if (v2 == null) continue;
                            try {
                                Object d = XposedHelpers.getObjectField(v2, "dispatcher");
                                if (d != null) {
                                    sCapturedDispatcher = d;
                                    XposedBridge.log("[WeChatHook] dispatcher found (L2): "
                                        + candidate[0] + "." + candidate[1] + "()."
                                        + f1.getName() + "." + f2.getName()
                                        + ".dispatcher=" + d.getClass().getName());
                                    XposedHelpers.setObjectField(r0, "dispatcher", d);
                                    break outer;
                                }
                            } catch (Throwable ignored2) {}
                        }
                    }
                } catch (Throwable t2) {
                    XposedBridge.log("[WeChatHook] dispatcher search " + candidate[0] + ": " + t2);
                }
            }
            if (sCapturedDispatcher instanceof java.lang.reflect.Proxy) {
                // Already have a proxy from a previous voice send — reuse it on this r0.
                try {
                    XposedHelpers.setObjectField(r0, "dispatcher", sCapturedDispatcher);
                    XposedBridge.log("[WeChatHook] sendVoiceViaAPI: reusing proxy dispatcher on r0");
                } catch (Throwable ed2) {
                    XposedBridge.log("[WeChatHook] sendVoiceViaAPI: proxy reuse failed: " + ed2);
                }
            } else if (sCapturedDispatcher == null) {
                // Still not found — create a minimal proxy for s that logs calls.
                // This lets H() proceed past the NPE; CDN upload may work via callback.
                try {
                    Class<?> sInterface = XposedHelpers.findClass("com.tencent.mm.network.s", cl);
                    java.lang.reflect.Method[] sMethods = sInterface.getDeclaredMethods();
                    StringBuilder sb = new StringBuilder("[WeChatHook] s interface methods:\n");
                    for (java.lang.reflect.Method m : sMethods) sb.append("  ").append(m.toGenericString()).append("\n");
                    XposedBridge.log(sb.toString());
                    Object dispProxy = java.lang.reflect.Proxy.newProxyInstance(cl,
                        new Class<?>[]{sInterface},
                        (proxy, method, args) -> {
                            XposedBridge.log("[WeChatHook] dispatcher.proxy: " + method.getName()
                                + " ret=" + method.getReturnType().getSimpleName());
                            if ("J".equals(method.getName()) && args != null && args.length >= 2) {
                                // ── Attempt 1: forward J() via l0 method on m05.j ──────────────
                                // method.declaringClass = s (s has own J, NOT inherited from l0).
                                // m05.j implements l0 (not s). Solution: get J() from l0 interface
                                // and invoke THAT on m05.j — valid since m05.j implements l0.
                                try {
                                    Object q2arg = args[1];
                                    Object mj = XposedHelpers.getObjectField(q2arg, "e");
                                    if (mj != null) {
                                        Class<?> l0Iface = XposedHelpers.findClass("com.tencent.mm.network.l0", cl);
                                        // Dump l0 methods for diagnosis
                                        StringBuilder l0log = new StringBuilder("[WeChatHook] l0 methods:");
                                        java.lang.reflect.Method foundL0J = null;
                                        for (java.lang.reflect.Method l0m : l0Iface.getDeclaredMethods()) {
                                            l0log.append(" ").append(l0m.getName()).append("(").append(l0m.getParameterTypes().length).append(")");
                                            if (l0m.getName().equals(method.getName())
                                                    && l0m.getParameterTypes().length == method.getParameterTypes().length) {
                                                foundL0J = l0m;
                                            }
                                        }
                                        XposedBridge.log(l0log.toString());
                                        if (foundL0J != null) {
                                            foundL0J.setAccessible(true);
                                            XposedBridge.log("[WeChatHook] J→m05.j via l0.J()");
                                            try {
                                                Object result = foundL0J.invoke(mj, args);
                                                XposedBridge.log("[WeChatHook] J→m05.j l0 OK result=" + result);
                                                return result;
                                            } catch (java.lang.reflect.InvocationTargetException ite) {
                                                XposedBridge.log("[WeChatHook] J→m05.j l0 threw: " + ite.getCause());
                                            }
                                        } else {
                                            XposedBridge.log("[WeChatHook] J not found in l0 by name+paramcount");
                                        }
                                    }
                                } catch (Throwable jt0) {
                                    XposedBridge.log("[WeChatHook] J→m05.j err: " + jt0);
                                }
                                // ── Attempt 2: find s implementor in J() args (skip l0-only classes) ──
                                try {
                                    Class<?> sIface = XposedHelpers.findClass("com.tencent.mm.network.s", cl);
                                    for (Object searchRoot : new Object[]{args[0], args[1]}) {
                                        if (searchRoot == null) continue;
                                        for (Class<?> cls2 = searchRoot.getClass(); cls2 != null && !cls2.equals(Object.class); cls2 = cls2.getSuperclass()) {
                                            for (java.lang.reflect.Field sf1 : cls2.getDeclaredFields()) {
                                                if (java.lang.reflect.Modifier.isStatic(sf1.getModifiers())) continue;
                                                sf1.setAccessible(true);
                                                Object sv1 = sf1.get(searchRoot);
                                                if (sv1 == null || sv1 == proxy) continue;
                                                if (sIface.isInstance(sv1)) {
                                                    sCapturedDispatcher = sv1;
                                                    XposedBridge.log("[WeChatHook] J: REAL s L1 " + sv1.getClass().getName());
                                                    try { return method.invoke(sv1, args); } catch (java.lang.reflect.InvocationTargetException ite) { throw ite.getCause(); }
                                                }
                                                // L2 sub-fields
                                                try {
                                                    for (Class<?> cls3 = sv1.getClass(); cls3 != null && !cls3.equals(Object.class); cls3 = cls3.getSuperclass()) {
                                                        for (java.lang.reflect.Field sf2 : cls3.getDeclaredFields()) {
                                                            if (java.lang.reflect.Modifier.isStatic(sf2.getModifiers())) continue;
                                                            sf2.setAccessible(true);
                                                            Object sv2 = sf2.get(sv1);
                                                            if (sv2 == null || sv2 == proxy) continue;
                                                            if (sIface.isInstance(sv2)) {
                                                                sCapturedDispatcher = sv2;
                                                                XposedBridge.log("[WeChatHook] J: REAL s L2 " + sf1.getName() + "." + sf2.getName() + " " + sv2.getClass().getName());
                                                                try { return method.invoke(sv2, args); } catch (java.lang.reflect.InvocationTargetException ite) { throw ite.getCause(); }
                                                            }
                                                        }
                                                    }
                                                } catch (Throwable ignored4) {}
                                            }
                                        }
                                    }
                                    XposedBridge.log("[WeChatHook] J: no s implementor in args");
                                } catch (Throwable jse) {
                                    XposedBridge.log("[WeChatHook] J: search err: " + jse);
                                }
                                // ── Deep-dump v2 (CDN request) sub-fields ───────────────────
                                try {
                                    Object v2arg = args[0];
                                    StringBuilder cdnDump = new StringBuilder("[WeChatHook] J v2-deep:\n");
                                    // Walk class hierarchy (getDeclaredFields only finds own fields)
                                    for (Class<?> cls2 = v2arg.getClass(); cls2 != null && !cls2.equals(Object.class); cls2 = cls2.getSuperclass()) {
                                        for (java.lang.reflect.Field sf1 : cls2.getDeclaredFields()) {
                                            if (java.lang.reflect.Modifier.isStatic(sf1.getModifiers())) continue;
                                            sf1.setAccessible(true);
                                            Object sv1 = sf1.get(v2arg);
                                            cdnDump.append("  ").append(sf1.getName()).append("=")
                                                   .append(sv1 == null ? "null" : sv1.getClass().getSimpleName()).append("\n");
                                            if (sv1 == null) continue;
                                            for (java.lang.reflect.Field sf2 : sv1.getClass().getDeclaredFields()) {
                                                if (java.lang.reflect.Modifier.isStatic(sf2.getModifiers())) continue;
                                                sf2.setAccessible(true);
                                                Object sv2 = sf2.get(sv1);
                                                String sv2s;
                                                if (sv2 == null) { sv2s = "null"; }
                                                else if (sv2 instanceof byte[]) {
                                                    byte[] ba = (byte[]) sv2;
                                                    StringBuilder hex = new StringBuilder();
                                                    for (int xi = 0; xi < Math.min(ba.length, 20); xi++) hex.append(String.format("%02x", ba[xi] & 0xff));
                                                    sv2s = "byte[" + ba.length + "]=" + hex;
                                                } else {
                                                    sv2s = sv2.toString();
                                                    if (sv2s.length() > 100) sv2s = sv2s.substring(0, 100);
                                                }
                                                cdnDump.append("    ").append(sf1.getName()).append(".").append(sf2.getName()).append("=").append(sv2s).append("\n");
                                            }
                                        }
                                    }
                                    XposedBridge.log(cdnDump.toString());
                                } catch (Throwable jde) {
                                    XposedBridge.log("[WeChatHook] J v2-dump err: " + jde);
                                }
                            }
                            if (method.getReturnType() == int.class || method.getReturnType() == Integer.class)
                                return 0;
                            if (method.getReturnType() == boolean.class || method.getReturnType() == Boolean.class)
                                return false;
                            return null;
                        });
                    sCapturedDispatcher = dispProxy;
                    XposedHelpers.setObjectField(r0, "dispatcher", dispProxy);
                    XposedBridge.log("[WeChatHook] sendVoiceViaAPI: dispatcher proxy set on r0");
                } catch (Throwable ep) {
                    XposedBridge.log("[WeChatHook] sendVoiceViaAPI: dispatcher proxy failed: " + ep);
                }
            }
        }

        // ── u0 callback stub (same pattern as sendViaR0) ─────────────────────
        // r0.d (type com.tencent.mm.modelbase.u0) is null unless we set it;
        // H() calls u0.onSceneEnd which NPEs otherwise.
        // hStarted gates the u0 stub: ignore premature onSceneEnd (fires synchronously
        // when we set r0.d, BEFORE H() is called) and only act on H()'s async CDN callback.
        // Root cause: setting r0.d triggers an immediate "local save done" callback.
        // If we call K(0) there, WeChat marks the message as "completed" → H() skips CDN.
        final java.util.concurrent.atomic.AtomicBoolean hStarted =
            new java.util.concurrent.atomic.AtomicBoolean(false);
        try {
            Class<?> u0 = XposedHelpers.findClass("com.tencent.mm.modelbase.u0", cl);
            Object stub = Proxy.newProxyInstance(cl, new Class<?>[]{u0},
                (proxy, method, args) -> {
                    StringBuilder params = new StringBuilder();
                    if (args != null) {
                        for (int i = 0; i < args.length; i++) {
                            if (i > 0) params.append(", ");
                            params.append(args[i]);
                        }
                    }
                    XposedBridge.log("[WeChatHook] voice-cb: " + method.getName()
                        + "(" + params + ") hStarted=" + hStarted.get());
                    // onSceneEnd(int code, int errCode, String msg, m1 scene)
                    // Real m2 dispatch: r0.onGYNetEnd handles the network result itself
                    // (status/msgSvrId update, SendMsgSuccessEvent, K/I). This u0 only needs
                    // to be non-null so that internal onSceneEnd call doesn't NPE — do NOT
                    // call K/I here or success/fail events double-fire.
                    if ("onSceneEnd".equals(method.getName()) && args != null && args.length >= 2) {
                        XposedBridge.log("[WeChatHook] voice onSceneEnd code=" + args[0] + " err=" + args[1]);
                    }
                    return null;
                });
            XposedHelpers.setObjectField(r0, "d", stub);
            // Premature onSceneEnd fires synchronously during setObjectField above and is suppressed.
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] u0 stub failed (non-fatal): " + t);
        }

        // ── Dispatch via WeChat's REAL NetSceneQueue ─────────────────────────────
        // Exactly the path the (now-working) internal text send uses. n1.a() does:
        //   ((gm0.n) com.tencent.mm.modelbase.z2.f88087b).f290500a.f290528b.h(scene, 0)
        // The queue supplies the real network dispatcher and runs doScene properly:
        // p==null → it reloads our just-inserted voice f9 from the DB, assembles the
        // MsgSource, uploads the SILK to CDN, and transports to the server.
        //
        // This replaces the old manual r0.H()+fake-$Proxy dispatcher, which never
        // reached the network — real transport is the queue's job (routed via IPC to
        // the :push connection), NOT a hand-set main-process m2 (which is never even
        // exercised, so it can't be captured).
        hStarted.set(true);
        sCalledByUs = true;
        try {
            // z2.b(m1) = WeChat's own "run cgi" helper (IGetNetSceneQueue): enqueues the
            // scene into the real NetSceneQueue, which supplies the live dispatcher and
            // runs doScene. Using the static helper avoids hardcoding the queue's field
            // chain, whose obfuscated names differ between base.apk and the Tinker patch
            // (the running code). r0 extends m1, so this resolves b(m1) by assignability.
            Class<?> z2c = XposedHelpers.findClass("com.tencent.mm.modelbase.z2", cl);
            XposedHelpers.callStaticMethod(z2c, "b", r0);
            XposedBridge.log("[WeChatHook] sendVoiceViaAPI: enqueued via z2.b(NetSceneQueue) to=" + talker
                + " voiceId=" + voiceId + " durationMs=" + durationMs);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] sendVoiceViaAPI: enqueue threw: " + t
                + "\n" + android.util.Log.getStackTraceString(t));
        } finally {
            sCalledByUs = false;
        }

        // ── Trigger REAL delivery via ResendVoiceMsgEvent{f9} ──────────────────
        // Decompiling WeChat 8.0.74 revealed the real voice send path:
        //   cg0.d(talker,file) → jg0.x(cg0.d) → sendCgi(m)+uploadAttach(w).
        // ResendVoiceMsgEvent (com.tencent.mm.autogen.events) carries a single f9
        // (field g = am.wr, wr.a = f9). Publishing it makes WeChat's voice-resend
        // handler run the FULL sendCgi + CDN upload for our already-inserted f9 —
        // i.e. the same machinery a real send uses. This replaces the dead
        // r0.H()/msgSvrId-poll path (delivery never happened → msgSvrId stayed 0).
        final Long msgLocalId = sPendingMsgLocalId.get();
        sPendingMsgLocalId.remove();
        sDatabaseF9.remove();
        final Object fPt0e0 = sPt0E0Instance;
        final String fTalker = talker;
        final ClassLoader fCl = cl;
        // ResendVoiceMsgEvent path CONFIRMED DEAD (2026-07-06): even after marking the
        // properly-inserted voice msg failed (status=5) and firing the event, WeChat's
        // resend handler does NOT respond — the message just shows red ! (failed), no
        // CDN upload. So this force-fails sends for nothing. Disabled. The remaining
        // real path is to build a voiceinfo/w0 upload task and drive w21.g1.P0() (or
        // reconstruct jg0.x). Kept for reference.
        if (false && msgLocalId != null) {
            new Thread(() -> {
                try {
                    Thread.sleep(1500); // let the z2.b send settle first
                    // Re-fetch the DB-bound f9 via pt0.e0.k(talker, msgLocalId).
                    Object f9 = null;
                    if (fPt0e0 != null) {
                        try {
                            java.lang.reflect.Method kM = null;
                            for (java.lang.reflect.Method m : fPt0e0.getClass().getDeclaredMethods())
                                if ("k".equals(m.getName()) && m.getParameterTypes().length == 2) { kM = m; break; }
                            if (kM != null) { kM.setAccessible(true); f9 = kM.invoke(fPt0e0, fTalker, msgLocalId); }
                        } catch (Throwable t) {
                            XposedBridge.log("[WeChatHook] resend: k() failed: " + t);
                        }
                    }
                    if (f9 == null) {
                        XposedBridge.log("[WeChatHook] resend: f9 null for msgLocalId=" + msgLocalId + ", abort");
                        return;
                    }
                    // Mark the message failed (status=5) + persist, so the resend handler
                    // treats it as a resendable failed voice. f9.r1(int)=status setter;
                    // pt0.e0.s(talker,msgId,f9) persists via cj().lb().
                    try {
                        XposedHelpers.callMethod(f9, "r1", 5);
                        long mid = ((Number) XposedHelpers.callMethod(f9, "getMsgId")).longValue();
                        if (fPt0e0 != null) {
                            java.lang.reflect.Method sM = null;
                            for (java.lang.reflect.Method m : fPt0e0.getClass().getDeclaredMethods())
                                if ("s".equals(m.getName()) && m.getParameterTypes().length == 3) { sM = m; break; }
                            if (sM != null) { sM.setAccessible(true); sM.invoke(fPt0e0, fTalker, mid, f9); }
                        }
                        XposedBridge.log("[WeChatHook] resend: marked f9 status=5 + persisted msgId=" + mid);
                    } catch (Throwable t) {
                        XposedBridge.log("[WeChatHook] resend: status=5 failed: " + t);
                    }
                    // Build ResendVoiceMsgEvent, set its f9 (field g -> wr.a), publish.
                    Class<?> evCls = XposedHelpers.findClass(
                        "com.tencent.mm.autogen.events.ResendVoiceMsgEvent", fCl);
                    Object ev = evCls.newInstance();
                    Object wr = XposedHelpers.getObjectField(ev, "g"); // am.wr
                    XposedHelpers.setObjectField(wr, "a", f9);
                    XposedHelpers.callMethod(ev, "b", Looper.getMainLooper());
                    XposedBridge.log("[WeChatHook] resend: ResendVoiceMsgEvent published msgLocalId="
                        + msgLocalId + " talker=" + fTalker + " f9=" + f9.getClass().getName());
                } catch (Throwable t) {
                    XposedBridge.log("[WeChatHook] resend: failed: " + t);
                }
            }, "WCHook-resend-" + msgLocalId).start();
        } else {
            XposedBridge.log("[WeChatHook] resend: msgLocalId null, skip");
        }
    }

    // ── Factory method discovery ───────────────────────────────────────────────
    // Hooks ALL static methods on w11.s1 and logs their signatures + call args.
    // When WeChat UI sends image/voice, we'll see which s1 method is called and
    // what parameters it receives, revealing the builder API for each msgtype.
    private void hookFactoryMethods(ClassLoader cl, String procName) {
        try {
            Class<?> s1 = XposedHelpers.findClass("w11.s1", cl);
            java.lang.reflect.Method[] methods = s1.getDeclaredMethods();

            // Dump all method signatures immediately
            StringBuilder sb = new StringBuilder();
            sb.append("[WeChatHook] w11.s1 ALL METHODS (").append(methods.length).append("):\n");
            for (java.lang.reflect.Method m : methods) {
                sb.append("  ").append(m.toGenericString()).append("\n");
            }
            XposedBridge.log(sb.toString());

            // Hook each static method to intercept calls from WeChat UI
            for (java.lang.reflect.Method m : methods) {
                if (!java.lang.reflect.Modifier.isStatic(m.getModifiers())) continue;
                final String mName = m.getName();
                final String mSig  = m.toGenericString();
                m.setAccessible(true);
                XposedBridge.hookMethod(m, new XC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        StringBuilder log = new StringBuilder();
                        log.append("[WeChatHook] s1.").append(mName).append("(");
                        if (param.args != null) {
                            for (int i = 0; i < param.args.length; i++) {
                                if (i > 0) log.append(", ");
                                Object a = param.args[i];
                                log.append(a == null ? "null" : a.getClass().getSimpleName() + "=" + a);
                            }
                        }
                        log.append(") -> ");
                        Object ret = param.getResult();
                        if (ret == null) {
                            log.append("null");
                        } else {
                            log.append(ret.getClass().getName());
                            dumpBuilderMethods(ret, "s1." + mName);
                            // Capture dispatcher from the r0 inside r1 (set by factory, null in direct ctor)
                            try {
                                StringBuilder r1Fields = new StringBuilder("[WeChatHook] r1 fields:\n");
                                for (Class<?> rc = ret.getClass(); rc != null && !rc.equals(Object.class); rc = rc.getSuperclass()) {
                                    for (java.lang.reflect.Field rf : rc.getDeclaredFields()) {
                                        if (java.lang.reflect.Modifier.isStatic(rf.getModifiers())) continue;
                                        rf.setAccessible(true);
                                        Object rv = rf.get(ret);
                                        String typeName = rv != null ? rv.getClass().getName() : rf.getType().getName();
                                        r1Fields.append("  ").append(rf.getName()).append(" (").append(typeName).append(")");
                                        if (sCapturedDispatcher == null && rv != null) {
                                            // Try to get dispatcher from any field, whether it's r0 or a container
                                            try {
                                                Object disp = XposedHelpers.getObjectField(rv, "dispatcher");
                                                if (disp != null) {
                                                    sCapturedDispatcher = disp;
                                                    r1Fields.append(" [dispatcher captured!]");
                                                }
                                            } catch (Throwable ignored2) {}
                                        }
                                        r1Fields.append("\n");
                                    }
                                }
                                XposedBridge.log(r1Fields.toString());
                            } catch (Throwable r1e) {
                                XposedBridge.log("[WeChatHook] r1 field dump error: " + r1e);
                            }
                        }
                        if (param.hasThrowable())
                            log.append(" THREW: ").append(param.getThrowable());
                        XposedBridge.log(log.toString());
                    }
                });
            }
            XposedBridge.log("[WeChatHook] hookFactoryMethods: hooked " + methods.length
                    + " methods on w11.s1 in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookFactoryMethods failed in " + procName + ": " + t);
        }
    }

    // Dump ALL instance methods on a builder object returned by the factory.
    // Each unique builder class is only dumped once to avoid logcat spam.
    private static final java.util.Set<String> sDumpedClasses =
            java.util.Collections.synchronizedSet(new java.util.HashSet<>());

    private static void dumpBuilderMethods(Object builder, String fromFactory) {
        if (builder == null) return;
        String clsName = builder.getClass().getName();
        if (!sDumpedClasses.add(clsName)) return;  // already dumped
        try {
            java.lang.reflect.Method[] ms = builder.getClass().getDeclaredMethods();
            StringBuilder sb = new StringBuilder();
            sb.append("[WeChatHook] BUILDER from ").append(fromFactory)
              .append(" class=").append(clsName)
              .append(" methods(").append(ms.length).append("):\n");
            for (java.lang.reflect.Method m : ms) {
                sb.append("  ").append(m.toGenericString()).append("\n");
            }
            XposedBridge.log(sb.toString());
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] dumpBuilderMethods " + clsName + ": " + t);
        }
    }

    // Dump all instance fields of w11.r0 to logcat.
    // Used to discover which field holds the SILK audio data for CDN upload.
    // Logs each field name, type, and a brief value summary.
    private static void dumpR0Fields(Object r0, String tag) {
        if (r0 == null) return;
        try {
            Class<?> cls = r0.getClass();
            StringBuilder sb = new StringBuilder();
            sb.append("[WeChatHook] ").append(tag).append(" class=").append(cls.getName()).append("\n");
            // Walk the class hierarchy to capture inherited fields
            for (Class<?> c = cls; c != null && !c.equals(Object.class); c = c.getSuperclass()) {
                for (java.lang.reflect.Field f : c.getDeclaredFields()) {
                    if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
                    f.setAccessible(true);
                    try {
                        Object val = f.get(r0);
                        if (val == null) {
                            sb.append("  ").append(f.getName()).append(" (").append(f.getType().getSimpleName()).append(") = null\n");
                        } else if (val instanceof byte[]) {
                            byte[] ba = (byte[]) val;
                            StringBuilder hex = new StringBuilder();
                            int show = Math.min(ba.length, 16);
                            for (int i = 0; i < show; i++) hex.append(String.format("%02x", ba[i] & 0xff));
                            sb.append("  ").append(f.getName()).append(" (byte[]) len=").append(ba.length).append(" hex=").append(hex).append("\n");
                        } else if (val instanceof String) {
                            String s = (String) val;
                            sb.append("  ").append(f.getName()).append(" (String) = \"").append(s.length() > 80 ? s.substring(0, 80) + "…" : s).append("\"\n");
                        } else {
                            String vs = val.toString();
                            sb.append("  ").append(f.getName()).append(" (").append(val.getClass().getSimpleName()).append(") = ").append(vs.length() > 80 ? vs.substring(0, 80) + "…" : vs).append("\n");
                        }
                    } catch (Throwable e2) {
                        sb.append("  ").append(f.getName()).append(" ERROR: ").append(e2).append("\n");
                    }
                }
            }
            XposedBridge.log(sb.toString());
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] dumpR0Fields failed: " + t);
        }
    }

    // ── On-demand API dump broadcast ──────────────────────────────────────────
    // am broadcast -a com.hermes.wechat.DUMP_WECHAT_API
    // Optional extra: --es class "w11.s1"  (defaults to w11.s1 if omitted)
    private static void handleDumpApi(Intent intent) {
        ClassLoader cl = sTinkerCL != null ? sTinkerCL : sWeChatCL;
        if (cl == null) { XposedBridge.log("[WeChatHook] DUMP_API: classloader null"); return; }

        String className = intent.getStringExtra("class");
        if (className == null || className.isEmpty()) className = "w11.s1";

        try {
            Class<?> cls = XposedHelpers.findClass(className, cl);
            java.lang.reflect.Method[]      ms = cls.getDeclaredMethods();
            java.lang.reflect.Constructor[] cs = cls.getDeclaredConstructors();
            java.lang.reflect.Field[]       fs = cls.getDeclaredFields();

            StringBuilder sb = new StringBuilder();
            sb.append("[WeChatHook] DUMP_API class=").append(cls.getName()).append("\n");

            // For enum classes, print each constant with its ordinal and any int fields
            if (cls.isEnum()) {
                sb.append("  ENUM CONSTANTS:\n");
                try {
                    Object[] constants = (Object[]) cls.getMethod("values").invoke(null);
                    java.lang.reflect.Method nameM    = Enum.class.getMethod("name");
                    java.lang.reflect.Method ordinalM = Enum.class.getMethod("ordinal");
                    for (Object c : constants) {
                        String cName = (String) nameM.invoke(c);
                        int    cOrd  = (int)    ordinalM.invoke(c);
                        sb.append("    ").append(cName).append(" ordinal=").append(cOrd);
                        // Also print any int/String fields on the enum instance
                        for (java.lang.reflect.Field f2 : fs) {
                            if (java.lang.reflect.Modifier.isStatic(f2.getModifiers())) continue;
                            f2.setAccessible(true);
                            try {
                                Object fv = f2.get(c);
                                sb.append(" ").append(f2.getName()).append("=").append(fv);
                            } catch (Throwable ignored) {}
                        }
                        sb.append("\n");
                    }
                } catch (Throwable e2) {
                    sb.append("    (enum values() failed: ").append(e2).append(")\n");
                }
            }

            sb.append("  FIELDS (").append(fs.length).append("):\n");
            for (java.lang.reflect.Field f : fs) {
                sb.append("    ").append(f.toGenericString());
                // Read static field values (helpful for non-enum static constants)
                if (java.lang.reflect.Modifier.isStatic(f.getModifiers()) && !cls.isEnum()) {
                    f.setAccessible(true);
                    try { sb.append(" = ").append(f.get(null)); } catch (Throwable ignored) {}
                }
                sb.append("\n");
            }
            sb.append("  CONSTRUCTORS (").append(cs.length).append("):\n");
            for (java.lang.reflect.Constructor<?> c : cs) sb.append("    ").append(c.toGenericString()).append("\n");
            sb.append("  METHODS (").append(ms.length).append("):\n");
            for (java.lang.reflect.Method m : ms) sb.append("    ").append(m.toGenericString()).append("\n");
            XposedBridge.log(sb.toString());
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] DUMP_API failed for " + className + ": " + t);
        }
    }

    // PRIMARY FIX: WeChat's own methods (LoginPasswordUI.onCreate etc.) are AOT-compiled
    // in a way that bypasses ArtMethod entry point replacement. But framework-dispatched
    // base class methods like Activity.onResume() always go through the entry point.
    // We hook onResume, filter for the login screens, and force the tablet button visible.
    // By onResume time, all views are initialized (onCreate + initView have run).
    private void hookProbe(ClassLoader cl) {
        try {
            XposedHelpers.findAndHookMethod(
                    "android.app.Activity", null,
                    "onResume", new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    String cls = param.thisObject.getClass().getName();
                    if (!cls.equals("com.tencent.mm.plugin.account.ui.LoginPasswordUI")
                            && !cls.equals("com.tencent.mm.plugin.account.ui.LoginHistoryUI")) {
                        return;
                    }
                    Object obj = param.thisObject;
                    View tabletBtn = null;
                    try {
                        tabletBtn = (View) XposedHelpers.getObjectField(obj, "N");
                    } catch (Throwable e) {
                        XposedBridge.log("[WeChatHook] onResume getField N failed: " + e);
                    }
                    if (tabletBtn == null) {
                        XposedBridge.log("[WeChatHook] onResume: N is null for " + cls);
                        return;
                    }
                    tabletBtn.setVisibility(View.VISIBLE);
                    // CRITICAL: resolve m4 from the Activity's OWN classloader. The login
                    // Activities run under the Tinker CL, but hookProbe was installed with
                    // the pre-Tinker CL. m4's ctor param LoginHistoryUI and the running
                    // Activity are the SAME FQN but from DIFFERENT classloaders, so a
                    // captured-CL m4 fails with "type LoginHistoryUI, got LoginHistoryUI".
                    // Looking up m4 via obj's CL makes the types line up.
                    boolean attached = false;
                    try {
                        ClassLoader runtimeCl = obj.getClass().getClassLoader();
                        Class<?> m4Class = XposedHelpers.findClass(
                                "com.tencent.mm.plugin.account.ui.m4", runtimeCl);
                        java.lang.reflect.Constructor<?> chosen = null;
                        for (java.lang.reflect.Constructor<?> c : m4Class.getDeclaredConstructors()) {
                            Class<?>[] pt = c.getParameterTypes();
                            if (pt.length == 1 && pt[0].isAssignableFrom(obj.getClass())) {
                                chosen = c; break;
                            }
                        }
                        if (chosen != null && View.OnClickListener.class.isAssignableFrom(m4Class)) {
                            chosen.setAccessible(true);
                            tabletBtn.setOnClickListener(
                                    (View.OnClickListener) chosen.newInstance(obj));
                            attached = true;
                            XposedBridge.log("[WeChatHook] onResume: m4 listener attached via "
                                    + chosen.getParameterTypes()[0].getName() + " for " + cls);
                        } else {
                            XposedBridge.log("[WeChatHook] onResume: no assignable m4 ctor for "
                                    + cls + " (obj CL=" + runtimeCl + ")");
                        }
                    } catch (Throwable e) {
                        XposedBridge.log("[WeChatHook] onResume setListener failed: " + e);
                    }
                    if (!attached) {
                        XposedBridge.log("[WeChatHook] onResume: N VISIBLE but NO listener for " + cls);
                    }
                }
            });
            XposedBridge.log("[WeChatHook] Hooked Activity.onResume for tablet button");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookProbe/onResume failed: " + t);
        }
    }

    private void hookInTabletEnv(ClassLoader cl) {
        try {
            Class<?> bkClass = XposedHelpers.findClass("com.tencent.mm.ui.bk", cl);
            Class<?> x0Class = XposedHelpers.findClass("bm5.x0", cl);
            XposedHelpers.findAndHookMethod(bkClass, "B", x0Class, new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                    param.setResult(Boolean.TRUE);
                }
            });
            XposedHelpers.findAndHookMethod(bkClass, "A", new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                    XposedBridge.log("[WeChatHook] bk.A() called -> TRUE");
                    param.setResult(Boolean.TRUE);
                }
            });
            XposedBridge.log("[WeChatHook] Hooked bk.B(x0) + bk.A()");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookInTabletEnv failed: " + t);
        }
    }

    // PRIMARY FIX: Hook LoginPasswordUI.onCreate(Bundle) afterHookedMethod.
    //
    // Previous attempts to hook initView() and LoginHistoryUI.initView() both failed
    // because ART AOT devirtualizes the call to this.initView() inside
    // LoginHistoryUI.onCreate() — the compiled native code jumps directly past the
    // Xposed entry point replacement.
    //
    // onCreate() itself is called by the Android framework via the ArtMethod pointer
    // directly (no vtable devirtualization possible), so this hook fires reliably.
    // By the time afterHookedMethod runs, super.onCreate() has completed which means
    // LoginHistoryUI.initView() has already run and this.N is assigned.
    private void hookLoginHistoryUIInitView(ClassLoader cl) {
        final Class<?> m4Class;
        try {
            m4Class = XposedHelpers.findClass("com.tencent.mm.plugin.account.ui.m4", cl);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] m4 class not found: " + t);
            return;
        }

        try {
            XposedHelpers.findAndHookMethod(
                    "com.tencent.mm.plugin.account.ui.LoginPasswordUI", cl,
                    "onCreate", Bundle.class, new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    Object obj = param.thisObject;
                    View tabletBtn = (View) XposedHelpers.getObjectField(obj, "N");
                    if (tabletBtn == null) {
                        XposedBridge.log("[WeChatHook] LoginPasswordUI.onCreate: N is null");
                        return;
                    }
                    tabletBtn.setVisibility(View.VISIBLE);
                    tabletBtn.setOnClickListener(
                            (View.OnClickListener) XposedHelpers.newInstance(m4Class, obj));
                    XposedBridge.log("[WeChatHook] LoginPasswordUI.onCreate() -> N VISIBLE + m4 attached");
                }
            });
            XposedBridge.log("[WeChatHook] Hooked LoginPasswordUI.onCreate()");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookLoginPasswordUI.onCreate failed: " + t);
        }

        // Belt-and-suspenders: also hook LoginHistoryUI.onCreate() for any subclass
        // that doesn't override onCreate but does have the N button.
        try {
            XposedHelpers.findAndHookMethod(
                    "com.tencent.mm.plugin.account.ui.LoginHistoryUI", cl,
                    "onCreate", Bundle.class, new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    Object obj = param.thisObject;
                    if (obj.getClass().getName().equals(
                            "com.tencent.mm.plugin.account.ui.LoginPasswordUI")) return;
                    View tabletBtn = (View) XposedHelpers.getObjectField(obj, "N");
                    if (tabletBtn == null) {
                        XposedBridge.log("[WeChatHook] LoginHistoryUI.onCreate: N is null");
                        return;
                    }
                    tabletBtn.setVisibility(View.VISIBLE);
                    tabletBtn.setOnClickListener(
                            (View.OnClickListener) XposedHelpers.newInstance(m4Class, obj));
                    XposedBridge.log("[WeChatHook] LoginHistoryUI.onCreate() -> N VISIBLE + m4 attached");
                }
            });
            XposedBridge.log("[WeChatHook] Hooked LoginHistoryUI.onCreate()");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookLoginHistoryUI.onCreate failed: " + t);
        }
    }

    private void hookLoginUIInitView(ClassLoader cl) {
        try {
            final Class<?> wbClass = XposedHelpers.findClass(
                    "com.tencent.mm.plugin.account.ui.wb", cl);
            XposedHelpers.findAndHookMethod(
                    "com.tencent.mm.plugin.account.ui.MobileInputUI", cl,
                    "initView", new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    Object mobileInputUI = param.thisObject;
                    View tabletBtn = (View) XposedHelpers.getObjectField(mobileInputUI, "w");
                    if (tabletBtn == null) {
                        XposedBridge.log("[WeChatHook] MobileInputUI.w is null");
                        return;
                    }
                    tabletBtn.setVisibility(View.VISIBLE);
                    tabletBtn.setOnClickListener(
                            (View.OnClickListener) XposedHelpers.newInstance(wbClass, mobileInputUI));
                    XposedBridge.log("[WeChatHook] MobileInputUI.initView() -> w VISIBLE + wb attached");
                }
            });
            XposedBridge.log("[WeChatHook] Hooked MobileInputUI.initView()");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookLoginUIInitView(MobileInputUI) failed: " + t);
        }
        try {
            final Class<?> g7Class = XposedHelpers.findClass(
                    "com.tencent.mm.plugin.account.ui.g7", cl);
            XposedHelpers.findAndHookMethod(
                    "com.tencent.mm.plugin.account.ui.LoginUI", cl,
                    "initView", new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    Object loginUI = param.thisObject;
                    View tabletBtn = (View) XposedHelpers.getObjectField(loginUI, "f992u");
                    if (tabletBtn == null) return;
                    tabletBtn.setVisibility(View.VISIBLE);
                    tabletBtn.setOnClickListener(
                            (View.OnClickListener) XposedHelpers.newInstance(g7Class, loginUI));
                    XposedBridge.log("[WeChatHook] LoginUI.initView() -> f992u VISIBLE + g7 attached");
                }
            });
            XposedBridge.log("[WeChatHook] Hooked LoginUI.initView()");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookLoginUIInitView(LoginUI) failed: " + t);
        }
    }

    private void hookLoginSelectUICheck(ClassLoader cl) {
        try {
            Class<?> callbackClass = XposedHelpers.findClass(
                    "com.tencent.mm.plugin.account.ui.LoginSelectUI$a", cl);
            XposedHelpers.findAndHookMethod(callbackClass, "a", boolean.class, new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                    XposedBridge.log("[WeChatHook] LoginSelectUI$a.a(" + param.args[0] + ") -> false");
                    param.args[0] = false;
                }
            });
            XposedBridge.log("[WeChatHook] Hooked LoginSelectUI$a.a()");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookLoginSelectUICheck failed: " + t);
        }
    }

    private void hookLoginButtonClick(ClassLoader cl) {
        try {
            Class<?> ljClass = XposedHelpers.findClass(
                    "com.tencent.mm.plugin.account.ui.lj", cl);
            final Class<?> loginSelectUIClass = XposedHelpers.findClass(
                    "com.tencent.mm.plugin.account.ui.LoginSelectUI", cl);
            XposedHelpers.findAndHookMethod(ljClass, "onClick", View.class, new XC_MethodHook() {
                @Override
                protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                    XposedBridge.log("[WeChatHook] lj.onClick() -> forcing LoginSelectUI");
                    Activity welcomeActivity = (Activity) XposedHelpers.getObjectField(
                            param.thisObject, "d");
                    Intent intent = new Intent(welcomeActivity, loginSelectUIClass);
                    intent.putExtra("mobile_input_purpose", 1);
                    welcomeActivity.startActivity(intent);
                    param.setResult(null);
                }
            });
            XposedBridge.log("[WeChatHook] Hooked lj.onClick() -> LoginSelectUI");
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookLoginButtonClick failed: " + t);
        }
    }

    // ── Send message via internal API ────────────────────────────────────────
    //
    // Registered in ALL WeChat processes. We don't yet know which process has gm0.j1
    // initialized — the first process where the receiver fires and succeeds wins.
    //
    // Trigger from ADB (must run as root — RECEIVER_NOT_EXPORTED):
    //   adb shell su -c 'am broadcast -a com.hermes.wechat.SEND_MSG_INTERNAL \
    //     --es to "filehelper" --es text "hello"'
    private void hookSendMessage(ClassLoader cl, String procName) {
        try {
            XposedHelpers.findAndHookMethod(
                    "android.app.Application", null, "onCreate",
                    new XC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            Context ctx = (Context) param.thisObject;
                            if (!"com.tencent.mm".equals(ctx.getPackageName())) return;
                            sAppContext = ctx;
                            // Capture Tinker-patched classloader (Tinker installs in attachBaseContext,
                            // so by App.onCreate this loader has the patch DEX classes).
                            sTinkerCL = ctx.getClassLoader();
                            XposedBridge.log("[WeChatHook] App.onCreate proc=" + procName
                                    + " pid=" + android.os.Process.myPid()
                                    + " tinkerCL=" + (sTinkerCL != null ? sTinkerCL.getClass().getSimpleName() : "null"));
                            // Re-hook with Tinker CL — w11.s1 and f9 may live in a Tinker DEX.
                            // This ensures our factory and convertTo hooks fire on actual WeChat UI sends.
                            if (sTinkerCL != sWeChatCL) {
                                hookFactoryMethods(sTinkerCL, procName + "/tinker");
                                hookF9ConvertTo(sTinkerCL, procName + "/tinker");
                                hookF9ImgPathInjector(sTinkerCL, procName + "/tinker");
                                hookR0H(sTinkerCL, procName + "/tinker");
                                // Hook pt0.e0 in Tinker CL — real voice sends run in Tinker CL.
                                hookPt0E0(sTinkerCL, procName + "/tinker");
                                // NOTE: hookJg0 / hookVoiceEntry disabled — they hook WeChat's
                                // generic coroutine classes (pu.o0/pu.m0) and every message
                                // DB insert (g9.M9/N9), which adds anti-tamper risk and
                                // destabilizes the fragile Pad login. Re-enable only for a
                                // targeted investigation session, never during normal use.
                                // hookJg0(sTinkerCL, procName + "/tinker");
                                // hookVoiceEntry(sTinkerCL, procName + "/tinker");
                                // Surgical probe: jg0.x + qi3.f0/g0 only (safe).
                                hookVoiceProbe(sTinkerCL, procName + "/tinker");
                                // Image send runs in Tinker CL — hook b80.u.pj/Bi there.
                                hookImageSend(sTinkerCL, procName + "/tinker");
                            }
                            hookF9ConvertTo(sWeChatCL, procName);
                            hookF9ImgPathInjector(sWeChatCL, procName);
                            registerSendReceiver(ctx, procName);
                        }
                    });
            XposedBridge.log("[WeChatHook] Send hook registered in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] hookSendMessage failed in " + procName + ": " + t);
        }

        // ── w11.r0 constructor hooks ───────────────────────────────────────────
        // Log "by=US" vs "by=WeChat" to tell if WeChat's own UI send uses this ctor.
        XC_MethodHook r0Hook = new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                String by = sCalledByUs ? "US" : "WeChat";
                XposedBridge.log("[WeChatHook] w11.r0 ctor by=" + by
                        + " args=" + param.args.length + " proc=" + procName
                        + " pid=" + android.os.Process.myPid());
                if (sCalledByUs) {
                    forceInitDI();
                    diagMCoreStorage("before-r0-ctor");
                }
            }
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                String by = sCalledByUs ? "US" : "WeChat";
                if (param.hasThrowable()) {
                    Throwable t = param.getThrowable();
                    XposedBridge.log("[WeChatHook] w11.r0 ctor THREW by=" + by
                            + " proc=" + procName + ": " + t);
                    if (sCalledByUs)
                        XposedBridge.log("[WeChatHook] r0-ctor-stack: "
                                + android.util.Log.getStackTraceString(t));
                    return;
                }
                sFsGReady = true;
                XposedBridge.log("[WeChatHook] w11.r0 ctor OK by=" + by + " proc=" + procName);
            }
        };
        for (Class<?>[] sig : new Class<?>[][]{
                {String.class, String.class, int.class, int.class, long.class},
                {String.class, String.class, int.class, int.class, Object.class},
                {long.class, int.class, String.class},
                {}}) {
            try {
                XposedHelpers.findAndHookConstructor("w11.r0", cl,
                        appendHook(sig, r0Hook));
                XposedBridge.log("[WeChatHook] Hooked w11.r0(" + sig.length + " params)");
            } catch (Throwable t) {
                XposedBridge.log("[WeChatHook] w11.r0(" + sig.length + "p) hook failed: " + t);
            }
        }

        // ── w11.r0.H(String) — the actual dispatch method ─────────────────────
        // Fires for EVERY send (ours AND WeChat UI sends). Shows if WeChat uses r0.
        // For real WeChat voice sends (type=34, by=WeChat), dumps ALL r0 fields so
        // we can find which field holds the SILK audio data (root cause of spinner).
        try {
            XposedHelpers.findAndHookMethod("w11.r0", cl, "H", String.class,
                    new XC_MethodHook() {
                        @Override
                        protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                            String by = sCalledByUs ? "US" : "WeChat";
                            XposedBridge.log("[WeChatHook] w11.r0.H() called by=" + by
                                    + " proc=" + procName + " pid=" + android.os.Process.myPid());
                            // Dump all r0 fields for real WeChat voice sends only.
                            // This reveals which field holds the SILK audio data that H() uses for CDN upload.
                            if (!sCalledByUs) {
                                dumpR0Fields(param.thisObject, "r0.H-before");
                            }
                        }
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            if (param.hasThrowable())
                                XposedBridge.log("[WeChatHook] w11.r0.H() threw: " + param.getThrowable());
                            else
                                XposedBridge.log("[WeChatHook] w11.r0.H() OK proc=" + procName);
                        }
                    });
            XposedBridge.log("[WeChatHook] Hooked w11.r0.H(String) in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] w11.r0.H hook failed in " + procName + ": " + t);
        }

        // ── r0.I(int) and r0.K(int) — delivery completion hooks ──────────────────
        // Log when WeChat calls these so we understand their role in the send flow.
        // Our u0 stub now calls r0.I(0) after onSceneEnd — this confirms whether I()
        // is the right trigger for delivery completion and spinner removal.
        try {
            XposedHelpers.findAndHookMethod("w11.r0", cl, "I", int.class,
                    new XC_MethodHook() {
                        @Override protected void beforeHookedMethod(MethodHookParam p) throws Throwable {
                            String by = sCalledByUs ? "US" : "WeChat";
                            XposedBridge.log("[WeChatHook] r0.I(" + p.args[0] + ") by=" + by + " proc=" + procName);
                        }
                    });
            XposedBridge.log("[WeChatHook] Hooked w11.r0.I(int) in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] r0.I hook failed in " + procName + ": " + t);
        }
        try {
            XposedHelpers.findAndHookMethod("w11.r0", cl, "K", int.class,
                    new XC_MethodHook() {
                        @Override protected void beforeHookedMethod(MethodHookParam p) throws Throwable {
                            String by = sCalledByUs ? "US" : "WeChat";
                            XposedBridge.log("[WeChatHook] r0.K(" + p.args[0] + ") by=" + by + " proc=" + procName);
                        }
                    });
            XposedBridge.log("[WeChatHook] Hooked w11.r0.K(int) in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] r0.K hook failed in " + procName + ": " + t);
        }

        // ── Diagnostic probes on the constructor call chain ───────────────────
        // Each probe fires when the method is called from inside the r0 constructor
        // (by WeChat OR by us). They trace which methods succeed before the NPE.
        hookProbeMethod(cl, "gm0.j1", "u", "gm0.j1.u");
        hookProbeMethod(cl, "c01.z1", "r", "c01.z1.r");
        // gm0.b0.c() is a virtual method — probe it too
        try {
            XposedHelpers.findAndHookMethod("gm0.b0", cl, "c",
                    new XC_MethodHook() {
                        @Override protected void beforeHookedMethod(MethodHookParam p) {
                            XposedBridge.log("[WeChatHook] PROBE gm0.b0.c() called");
                        }
                        @Override protected void afterHookedMethod(MethodHookParam p) {
                            if (p.hasThrowable()) XposedBridge.log("[WeChatHook] PROBE gm0.b0.c() THREW: " + p.getThrowable());
                            else XposedBridge.log("[WeChatHook] PROBE gm0.b0.c() → " + p.getResult());
                        }
                    });
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] gm0.b0.c probe failed: " + t);
        }
    }

    private static Object[] appendHook(Class<?>[] params, XC_MethodHook hook) {
        Object[] result = new Object[params.length + 1];
        System.arraycopy(params, 0, result, 0, params.length);
        result[params.length] = hook;
        return result;
    }

    private void hookProbeMethod(ClassLoader cl, String cls, String method, String tag) {
        try {
            XposedHelpers.findAndHookMethod(cls, cl, method,
                    new XC_MethodHook() {
                        @Override protected void beforeHookedMethod(MethodHookParam p) {
                            XposedBridge.log("[WeChatHook] PROBE " + tag + "() called");
                        }
                        @Override protected void afterHookedMethod(MethodHookParam p) {
                            if (p.hasThrowable()) XposedBridge.log("[WeChatHook] PROBE " + tag + "() THREW: " + p.getThrowable());
                            else XposedBridge.log("[WeChatHook] PROBE " + tag + "() → " + p.getResult());
                        }
                    });
            XposedBridge.log("[WeChatHook] Probe hooked: " + tag);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] Probe " + tag + " failed: " + t);
        }
    }

    private static boolean isDIReady() {
        if (sWeChatCL == null) return false;
        try {
            XposedHelpers.callStaticMethod(XposedHelpers.findClass("gm0.j1", sWeChatCL), "i");
            return true;
        } catch (Throwable e) { return false; }
    }

    // Hook gm0.j1.g(km0.c) to detect when WeChat DI kernel is initialized.
    // gm0.j1.g() sets gm0.j1.m (the singleton) and is called lazily — not during
    // Application.onCreate, so our broadcast often arrives first. After g() fires,
    // gm0.j1.i() will succeed and w11.r0 can be constructed.
    private static void hookDIInit(ClassLoader cl, String procName) {
        try {
            Class<?> km0cCls = XposedHelpers.findClass("km0.c", cl);
            XposedHelpers.findAndHookMethod("gm0.j1", cl, "g", km0cCls,
                    new XC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam p) throws Throwable {
                            XposedBridge.log("[WeChatHook] gm0.j1.g() fired — DI ready in " + procName);
                            String t = sPendingTalker, x = sPendingText, pr = sPendingProc;
                            if (t != null && x != null && procName.equals(pr)) {
                                sPendingTalker = null; sPendingText = null; sPendingProc = null;
                                XposedBridge.log("[WeChatHook] resuming pending send to=" + t + " proc=" + procName);
                                new Handler(Looper.getMainLooper()).postDelayed(
                                        () -> trySendWithRetry(t, x, 0, procName), 50);
                            }
                        }
                    });
            XposedBridge.log("[WeChatHook] gm0.j1.g hook OK in " + procName);
        } catch (Throwable t) {
            XposedBridge.log("[WeChatHook] gm0.j1.g hook failed in " + procName + ": " + t);
        }
    }

    private static void diagMCoreStorage(String where) {
        if (sWeChatCL == null) return;
        try {
            Class<?> j1Cls = XposedHelpers.findClass("gm0.j1", sWeChatCL);
            Object j1 = XposedHelpers.callStaticMethod(j1Cls, "i");
            Object mCS = (j1 != null) ? XposedHelpers.getObjectField(j1, "d") : null;
            XposedBridge.log("[WeChatHook] " + where + " mCoreStorage=" + mCS);
        } catch (Throwable e) {
            XposedBridge.log("[WeChatHook] " + where + " mCoreStorage-check: " + e);
        }
    }

    private static void forceInitDI() {
        if (sWeChatCL == null) return;
        try {
            Class<?> fsgCls = XposedHelpers.findClass("fs.g", sWeChatCL);
            java.lang.reflect.Field faFld = fsgCls.getDeclaredField("a");
            faFld.setAccessible(true);
            Object[] arr = (Object[]) faFld.get(null);

            if (arr == null || arr.length == 0 || arr[0] == null) {
                Class<?> k2Cls = XposedHelpers.findClass("fs.k2", sWeChatCL);
                java.lang.reflect.Field k2eFld = k2Cls.getDeclaredField("e");
                k2eFld.setAccessible(true);
                Object k2e = k2eFld.get(null);
                if (k2e == null) {
                    XposedBridge.log("[WeChatHook] forceInitDI: fs.k2.e null");
                    return;
                }
                if (arr == null || arr.length == 0) {
                    arr = new Object[1];
                    faFld.set(null, arr);
                }
                arr[0] = k2e;
                XposedBridge.log("[WeChatHook] forceInitDI: fs.g.a[0]=" + k2e.getClass().getName());
            }
        } catch (Throwable e) {
            XposedBridge.log("[WeChatHook] forceInitDI: " + e);
        }
    }

    private static void trySendWithRetry(String talker, String text, int attempt, String procName) {
        // Non-main WeChat processes (:push, :tools, etc.) lack storage init — fail immediately.
        if (procName != null && procName.contains(":")) {
            if (attempt == 0) XposedBridge.log("[WeChatHook] Skip send in non-main proc=" + procName);
            return;
        }
        // Route A2: tg3.t1 high-level service locator
        try {
            sendViaHighLevel(talker, text);
            XposedBridge.log("[WeChatHook] HighLevel send OK to=" + talker + " proc=" + procName);
            return;
        } catch (Throwable t) {
            if (attempt == 0)
                XposedBridge.log("[WeChatHook] HighLevel FAILED proc=" + procName + ": " + t);
        }

        // Route A1b: w11.s1 factory (mid-level)
        try {
            sendViaFactory(talker, text);
            XposedBridge.log("[WeChatHook] Factory send OK to=" + talker + " proc=" + procName);
            return;
        } catch (Throwable t) {
            // Log every 5 attempts to track what's changing
            if (attempt % 5 == 0)
                XposedBridge.log("[WeChatHook] Factory FAILED attempt=" + attempt
                        + " proc=" + procName + ": " + t);
        }

        // Route A1: w11.r0 direct (requires gm0.j1 DI ready)
        if (isDIReady()) {
            try {
                sendViaR0(talker, text);
                XposedBridge.log("[WeChatHook] R0 send OK to=" + talker + " proc=" + procName);
                return;
            } catch (Throwable t) {
                if (attempt == 0)
                    XposedBridge.log("[WeChatHook] R0 FAILED proc=" + procName + ": " + t);
            }
        }

        // All paths failed — poll every 1s up to 60 attempts waiting for WeChat DI init
        if (attempt < 60) {
            if (attempt == 0)
                XposedBridge.log("[WeChatHook] All paths not ready, polling proc=" + procName
                        + " to=" + talker);
            new Handler(Looper.getMainLooper()).postDelayed(
                    () -> trySendWithRetry(talker, text, attempt + 1, procName), 1000);
        } else {
            XposedBridge.log("[WeChatHook] GIVE UP after 60s proc=" + procName + " to=" + talker);
        }
    }

    // Route A1b: w11.s1 factory — SendMsgCgiFactory.a(talker) → w11.r1.e(content).b()
    private static void sendViaFactory(String talker, String text) throws Throwable {
        ClassLoader cl = sTinkerCL != null ? sTinkerCL : sWeChatCL;
        if (cl == null) throw new IllegalStateException("classloader null");
        Class<?> s1 = XposedHelpers.findClass("w11.s1", cl);
        Object r1 = XposedHelpers.callStaticMethod(s1, "a", talker);
        if (r1 == null) throw new IllegalStateException("w11.s1.a() returned null");
        try {
            XposedHelpers.callMethod(r1, "e", text);
        } catch (Throwable t) {
            throw new RuntimeException("r1.e() failed: " + t, t);
        }
        try {
            XposedHelpers.callMethod(r1, "b");
        } catch (Throwable t) {
            throw new RuntimeException("r1.b() failed: " + t, t);
        }
    }

    // Route A2: high-level API via tg3.t1 service locator → dk5.s5.Ni().
    // This path is what WeChat UI uses — internally handles DI, account context, etc.
    private static void sendViaHighLevel(String talker, String text) throws Throwable {
        ClassLoader cl = sTinkerCL != null ? sTinkerCL : sWeChatCL;
        if (cl == null) throw new IllegalStateException("classloader null");
        // Text = same PROVEN path as voice sendVoiceViaAPI: w11.r0 ctor (type=1) inserts
        // the f9 into the DB, then z2.b(NetSceneQueue) dispatches over the real network.
        // Text carries no CDN attachment, so unlike voice it completes fully. (The s1.a /
        // s1.b / dk5.s5.Ni builder paths either produced name-cards or silently failed to
        // persist — they need hidden r1 fields + MsgRetransmitUI.P6 that we can't set robustly.)
        Class<?> r0Class = XposedHelpers.findClass("w11.r0", cl);
        Object r0;
        sCalledByUs = true;
        try {
            // Object-ctor is the one that actually inserts the f9 (confirmed by
            // sendVoiceViaAPI). obj=null for text (no audio/msgsource extras).
            r0 = XposedHelpers.newInstance(r0Class,
                new Class<?>[]{String.class, String.class, int.class, int.class, Object.class},
                talker, text, 1, 0, null); // (talker, content, type=1 TEXT, flag=0, null)
        } finally { sCalledByUs = false; }
        Class<?> z2c = XposedHelpers.findClass("com.tencent.mm.modelbase.z2", cl);
        XposedHelpers.callStaticMethod(z2c, "b", r0); // enqueue → doScene → newsendmsg
        XposedBridge.log("[WeChatHook] sendViaHighLevel(TEXT via r0-obj+z2.b): OK to=" + talker);
    }

    private static void registerSendReceiver(Context ctx, String procName) {
        // SEND_MSG_INTERNAL: send a text message
        BroadcastReceiver sendRecv = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String talker = intent.getStringExtra("to");
                String rawText = intent.getStringExtra("text");
                // Non-ASCII (Chinese) via `am broadcast --es text` gets mangled by the
                // shell/am → server rejects → stuck "sending". Prefer base64: send with
                // --es text_b64 <base64(utf-8)> and we decode it here intact.
                String textB64 = intent.getStringExtra("text_b64");
                if (textB64 != null && !textB64.isEmpty()) {
                    try {
                        rawText = new String(android.util.Base64.decode(textB64, android.util.Base64.DEFAULT), "UTF-8");
                    } catch (Throwable t) {
                        XposedBridge.log("[WeChatHook] SEND_MSG_INTERNAL: bad text_b64: " + t);
                    }
                }
                final String text = rawText;
                if (talker == null || talker.isEmpty() || text == null || text.isEmpty()) {
                    XposedBridge.log("[WeChatHook] SEND_MSG_INTERNAL: missing 'to' or 'text'/'text_b64'");
                    return;
                }
                XposedBridge.log("[WeChatHook] SEND_MSG_INTERNAL proc=" + procName
                        + " pid=" + android.os.Process.myPid()
                        + " to=" + talker + " len=" + text.length());
                new Handler(Looper.getMainLooper()).post(() -> trySendWithRetry(talker, text, 0, procName));
            }
        };
        ctx.registerReceiver(sendRecv, new IntentFilter(ACTION_SEND), Context.RECEIVER_NOT_EXPORTED);

        // SEND_IMAGE_INTERNAL: send an image via w11.s1.b internal API
        // Usage: adb shell su -c 'am broadcast -a com.hermes.wechat.SEND_IMAGE_INTERNAL \
        //   --es to "filehelper" --es path "/sdcard/test.jpg"'
        BroadcastReceiver imgRecv = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                // Only handle in main WeChat process (sub-processes lack storage init)
                if (procName.contains(":")) return;
                String talker = intent.getStringExtra("to");
                String path   = intent.getStringExtra("path");
                if (talker == null || talker.isEmpty() || path == null || path.isEmpty()) {
                    XposedBridge.log("[WeChatHook] SEND_IMAGE_INTERNAL: missing 'to' or 'path'");
                    return;
                }
                XposedBridge.log("[WeChatHook] SEND_IMAGE_INTERNAL proc=" + procName
                    + " to=" + talker + " path=" + path);
                new Handler(Looper.getMainLooper()).post(() -> {
                    try {
                        sendImageViaAPI(talker, path);
                    } catch (Throwable t) {
                        XposedBridge.log("[WeChatHook] SEND_IMAGE_INTERNAL failed: " + t
                            + "\n" + android.util.Log.getStackTraceString(t));
                    }
                });
            }
        };
        ctx.registerReceiver(imgRecv, new IntentFilter(ACTION_SEND_IMAGE), Context.RECEIVER_NOT_EXPORTED);

        // SEND_VOICE_INTERNAL: send a voice message via w11.r0 + f9 internal API.
        // The caller (root, Python helper) must pre-place the SILK file at:
        //   /data/data/com.tencent.mm/MicroMsg/{hash}/voice2/{md5(id)[0:2]}/{md5(id)[2:4]}/msg_{id}.amr
        // Usage: adb shell su -c 'am broadcast -a com.hermes.wechat.SEND_VOICE_INTERNAL \
        //   --es to "filehelper" --es voice_id "26hexchars" --ei duration 3000 [--es from_wxid "wxid_..."]'
        BroadcastReceiver voiceRecv = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (procName.contains(":")) return;
                String talker   = intent.getStringExtra("to");
                String voiceId  = intent.getStringExtra("voice_id");   // pre-placed file
                String srcPath  = intent.getStringExtra("src_path");   // hook copies from here
                int    duration = intent.getIntExtra("duration", 0);
                String fromWxId = intent.getStringExtra("from_wxid");
                if (talker == null || talker.isEmpty()
                        || (voiceId == null && srcPath == null)) {
                    XposedBridge.log("[WeChatHook] SEND_VOICE_INTERNAL: need 'to' + 'voice_id' or 'src_path'");
                    return;
                }
                if (duration <= 0) {
                    XposedBridge.log("[WeChatHook] SEND_VOICE_INTERNAL: missing 'duration'");
                    return;
                }
                XposedBridge.log("[WeChatHook] SEND_VOICE_INTERNAL proc=" + procName
                    + " to=" + talker + " voice_id=" + voiceId + " src=" + srcPath + " dur=" + duration);
                final String fVoiceId = voiceId, fSrcPath = srcPath;
                new Handler(Looper.getMainLooper()).post(() -> {
                    try {
                        sendVoiceViaAPI(talker, fVoiceId, fSrcPath, duration, fromWxId);
                    } catch (Throwable t) {
                        XposedBridge.log("[WeChatHook] SEND_VOICE_INTERNAL failed: " + t
                            + "\n" + android.util.Log.getStackTraceString(t));
                    }
                });
            }
        };
        ctx.registerReceiver(voiceRecv, new IntentFilter(ACTION_SEND_VOICE), Context.RECEIVER_NOT_EXPORTED);

        // ARM_VOICE_SWAP: load our TTS SILK into memory and arm the jg0.x.w swap.
        // After arming, trigger a REAL recording (hold "按住说话") to the target chat —
        // WeChat records, but jg0.x.w uploads our TTS bytes instead → delivered.
        // Usage: am broadcast -a com.hermes.wechat.ARM_VOICE_SWAP \
        //          --es src_path /data/data/com.tencent.mm/cache/hook_voice_src.amr --ei duration 3200
        BroadcastReceiver armRecv = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (procName.contains(":")) return;   // main process only (where recording runs)
                String srcPath  = intent.getStringExtra("src_path");
                int    duration = intent.getIntExtra("duration", 0);
                if (srcPath == null || srcPath.isEmpty()) {
                    XposedBridge.log("[WeChatHook] ARM_VOICE_SWAP: missing 'src_path'");
                    return;
                }
                try {
                    java.io.File f = new java.io.File(srcPath);
                    byte[] bytes = new byte[(int) f.length()];
                    try (java.io.FileInputStream in = new java.io.FileInputStream(f)) {
                        int off = 0, n;
                        while (off < bytes.length && (n = in.read(bytes, off, bytes.length - off)) > 0) off += n;
                    }
                    sSwapSilk = bytes;
                    sSwapDuration = duration;
                    sSwapExpiresAt = System.currentTimeMillis() + Math.max(duration, 0) + 10000;
                    sSwapArmed = true;
                    XposedBridge.log("[WeChatHook] ARM_VOICE_SWAP: armed " + bytes.length
                        + "B dur=" + duration + "ms from " + srcPath
                        + " (expires in " + ((sSwapExpiresAt - System.currentTimeMillis()) / 1000)
                        + "s — trigger a real recording now)");
                } catch (Throwable t) {
                    XposedBridge.log("[WeChatHook] ARM_VOICE_SWAP failed: " + t);
                }
            }
        };
        ctx.registerReceiver(armRecv, new IntentFilter(ACTION_ARM_SWAP), Context.RECEIVER_NOT_EXPORTED);

        // DUMP_WECHAT_API: on-demand class introspection (main process only)
        // Usage: adb shell su -c 'am broadcast -a com.hermes.wechat.DUMP_WECHAT_API [--es class "w11.s1"]'
        BroadcastReceiver dumpRecv = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                XposedBridge.log("[WeChatHook] DUMP_WECHAT_API received in " + procName);
                new Handler(Looper.getMainLooper()).post(() -> handleDumpApi(intent));
            }
        };
        ctx.registerReceiver(dumpRecv, new IntentFilter(ACTION_DUMP_API), Context.RECEIVER_NOT_EXPORTED);

        XposedBridge.log("[WeChatHook] BroadcastReceivers registered in " + procName);
    }

    private static void sendViaR0(String talker, String text) throws Throwable {
        ClassLoader cl = sTinkerCL != null ? sTinkerCL : sWeChatCL;
        if (cl == null) throw new IllegalStateException("classloader null");
        Class<?> r0Class = XposedHelpers.findClass("w11.r0", cl);
        long ts = System.currentTimeMillis();
        Object msg;
        sCalledByUs = true;
        try {
            try {
                msg = XposedHelpers.newInstance(r0Class,
                    new Class<?>[]{String.class, String.class, int.class, int.class, long.class},
                    talker, text, 1, 0, ts);
            } catch (Throwable t) {
                msg = XposedHelpers.newInstance(r0Class,
                    new Class<?>[]{String.class, String.class, int.class, int.class, Object.class},
                    talker, text, 1, 0, (Object) ts);
            }
        } finally {
            sCalledByUs = false;
        }

        try {
            Class<?> u0 = XposedHelpers.findClass("com.tencent.mm.modelbase.u0", cl);
            Object stub = Proxy.newProxyInstance(cl, new Class<?>[]{u0},
                (proxy, method, args) -> {
                    XposedBridge.log("[WeChatHook] send-cb: " + method.getName());
                    return null;
                });
            XposedHelpers.setObjectField(msg, "d", stub);
        } catch (Throwable ignored) {}

        sCalledByUs = true;
        try {
            XposedHelpers.callMethod(msg, "H", "");
        } finally {
            sCalledByUs = false;
        }
    }
}