capacitor-dex-editor 0.0.1

package/android/src/main/java/com/aetherlink/dexeditor/DexManager.java

@@ -0,0 +1,1191 @@
+package com.aetherlink.dexeditor;
+
+import android.util.Log;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+
+import org.jf.dexlib2.DexFileFactory;
+import org.jf.dexlib2.Opcodes;
+import org.jf.dexlib2.rewriter.DexRewriter;
+import org.jf.dexlib2.rewriter.Rewriter;
+import org.jf.dexlib2.rewriter.RewriterModule;
+import org.jf.dexlib2.rewriter.Rewriters;
+import org.jf.dexlib2.dexbacked.DexBackedClassDef;
+import org.jf.dexlib2.dexbacked.DexBackedDexFile;
+import org.jf.dexlib2.dexbacked.DexBackedField;
+import org.jf.dexlib2.dexbacked.DexBackedMethod;
+import org.jf.dexlib2.iface.ClassDef;
+import org.jf.dexlib2.iface.DexFile;
+import org.jf.dexlib2.iface.Field;
+import org.jf.dexlib2.iface.Method;
+import org.jf.dexlib2.iface.MethodImplementation;
+import org.jf.dexlib2.iface.instruction.Instruction;
+import org.jf.dexlib2.immutable.ImmutableClassDef;
+import org.jf.dexlib2.immutable.ImmutableDexFile;
+import org.jf.dexlib2.immutable.ImmutableField;
+import org.jf.dexlib2.immutable.ImmutableMethod;
+import org.jf.dexlib2.writer.io.FileDataStore;
+import org.jf.dexlib2.writer.pool.DexPool;
+import org.jf.baksmali.Baksmali;
+import org.jf.baksmali.BaksmaliOptions;
+import org.jf.smali.Smali;
+import org.jf.smali.SmaliOptions;
+
+import org.json.JSONArray;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.regex.Pattern;
+
+/**
+ * DexManager - 封装 dexlib2 全部功能
+ * 管理多个 DEX 会话，支持加载、编辑、保存 DEX 文件
+ */
+public class DexManager {
+
+    private static final String TAG = "DexManager";
+    
+    // 存储活跃的 DEX 会话
+    private final Map<String, DexSession> sessions = new HashMap<>();
+
+    /**
+     * DEX 会话 - 存储加载的 DEX 文件及其修改状态
+     */
+    private static class DexSession {
+        String sessionId;
+        String filePath;
+        DexBackedDexFile originalDexFile;
+        List<ClassDef> modifiedClasses;
+        Set<String> removedClasses;
+        boolean modified = false;
+
+        DexSession(String sessionId, String filePath, DexBackedDexFile dexFile) {
+            this.sessionId = sessionId;
+            this.filePath = filePath;
+            this.originalDexFile = dexFile;
+            this.modifiedClasses = new ArrayList<>();
+            this.removedClasses = new HashSet<>();
+        }
+    }
+
+    // ==================== DEX 文件操作 ====================
+
+    /**
+     * 加载 DEX 文件
+     */
+    public JSObject loadDex(String path, String sessionId) throws Exception {
+        if (path == null || path.isEmpty()) {
+            throw new IllegalArgumentException("Path is required");
+        }
+
+        File file = new File(path);
+        if (!file.exists()) {
+            throw new IOException("File not found: " + path);
+        }
+
+        // 生成或使用提供的 sessionId
+        String sid = (sessionId != null && !sessionId.isEmpty()) ? sessionId : UUID.randomUUID().toString();
+
+        // 加载 DEX 文件 (使用官方推荐的 DexFileFactory)
+        DexBackedDexFile dexFile = (DexBackedDexFile) DexFileFactory.loadDexFile(
+            file, 
+            Opcodes.getDefault()
+        );
+
+        // 创建会话
+        DexSession session = new DexSession(sid, path, dexFile);
+        sessions.put(sid, session);
+
+        Log.d(TAG, "Loaded DEX: " + path + " with session: " + sid);
+
+        JSObject result = new JSObject();
+        result.put("sessionId", sid);
+        result.put("classCount", dexFile.getClasses().size());
+        result.put("dexVersion", dexFile.getOpcodes().api);
+        return result;
+    }
+
+    /**
+     * 保存 DEX 文件
+     */
+    public void saveDex(String sessionId, String outputPath) throws Exception {
+        DexSession session = getSession(sessionId);
+
+        // 创建新的 DEX 文件
+        DexPool dexPool = new DexPool(session.originalDexFile.getOpcodes());
+
+        // 添加所有类（排除已删除的，使用修改后的版本）
+        Set<String> modifiedClassTypes = new HashSet<>();
+        for (ClassDef modifiedClass : session.modifiedClasses) {
+            modifiedClassTypes.add(modifiedClass.getType());
+            dexPool.internClass(modifiedClass);
+        }
+
+        for (ClassDef classDef : session.originalDexFile.getClasses()) {
+            String type = classDef.getType();
+            if (!session.removedClasses.contains(type) && !modifiedClassTypes.contains(type)) {
+                dexPool.internClass(classDef);
+            }
+        }
+
+        // 写入文件 (使用官方推荐方式)
+        File outputFile = new File(outputPath);
+        if (outputFile.getParentFile() != null) {
+            outputFile.getParentFile().mkdirs();
+        }
+        
+        // 创建临时 DexFile 用于写入
+        List<ClassDef> allClasses = new ArrayList<>();
+        for (ClassDef c : session.modifiedClasses) {
+            allClasses.add(c);
+        }
+        for (ClassDef c : session.originalDexFile.getClasses()) {
+            if (!session.removedClasses.contains(c.getType()) && !modifiedClassTypes.contains(c.getType())) {
+                allClasses.add(c);
+            }
+        }
+        
+        ImmutableDexFile newDexFile = new ImmutableDexFile(session.originalDexFile.getOpcodes(), allClasses);
+        DexFileFactory.writeDexFile(outputPath, newDexFile);
+
+        Log.d(TAG, "Saved DEX to: " + outputPath);
+    }
+
+    /**
+     * 关闭 DEX 会话
+     */
+    public void closeDex(String sessionId) {
+        sessions.remove(sessionId);
+        Log.d(TAG, "Closed session: " + sessionId);
+    }
+
+    /**
+     * 获取 DEX 文件信息
+     */
+    public JSObject getDexInfo(String sessionId) throws Exception {
+        DexSession session = getSession(sessionId);
+        DexBackedDexFile dexFile = session.originalDexFile;
+
+        JSObject info = new JSObject();
+        info.put("sessionId", sessionId);
+        info.put("filePath", session.filePath);
+        info.put("classCount", dexFile.getClasses().size());
+        info.put("stringCount", dexFile.getStringCount());
+        info.put("typeCount", dexFile.getTypeCount());
+        info.put("methodCount", dexFile.getMethodCount());
+        info.put("fieldCount", dexFile.getFieldCount());
+        info.put("dexVersion", dexFile.getOpcodes().api);
+        info.put("modified", session.modified);
+        return info;
+    }
+
+    // ==================== 类操作 ====================
+
+    /**
+     * 获取所有类列表
+     */
+    public JSArray getClasses(String sessionId) throws Exception {
+        DexSession session = getSession(sessionId);
+        JSArray classes = new JSArray();
+
+        for (ClassDef classDef : session.originalDexFile.getClasses()) {
+            if (!session.removedClasses.contains(classDef.getType())) {
+                JSObject classInfo = new JSObject();
+                classInfo.put("type", classDef.getType());
+                classInfo.put("accessFlags", classDef.getAccessFlags());
+                classInfo.put("superclass", classDef.getSuperclass());
+                classes.put(classInfo);
+            }
+        }
+
+        return classes;
+    }
+
+    /**
+     * 获取类详细信息
+     */
+    public JSObject getClassInfo(String sessionId, String className) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        JSObject info = new JSObject();
+        info.put("type", classDef.getType());
+        info.put("accessFlags", classDef.getAccessFlags());
+        info.put("superclass", classDef.getSuperclass());
+
+        // 接口
+        JSArray interfaces = new JSArray();
+        for (String iface : classDef.getInterfaces()) {
+            interfaces.put(iface);
+        }
+        info.put("interfaces", interfaces);
+
+        // 方法数量
+        int methodCount = 0;
+        for (Method ignored : classDef.getMethods()) {
+            methodCount++;
+        }
+        info.put("methodCount", methodCount);
+
+        // 字段数量
+        int fieldCount = 0;
+        for (Field ignored : classDef.getFields()) {
+            fieldCount++;
+        }
+        info.put("fieldCount", fieldCount);
+
+        return info;
+    }
+
+    /**
+     * 添加类
+     */
+    public void addClass(String sessionId, String smaliCode) throws Exception {
+        DexSession session = getSession(sessionId);
+        
+        // 将 Smali 代码编译为 ClassDef
+        ClassDef newClass = compileSmaliToClass(smaliCode, session.originalDexFile.getOpcodes());
+        session.modifiedClasses.add(newClass);
+        session.modified = true;
+        
+        Log.d(TAG, "Added class: " + newClass.getType());
+    }
+
+    /**
+     * 删除类
+     */
+    public void removeClass(String sessionId, String className) throws Exception {
+        DexSession session = getSession(sessionId);
+        session.removedClasses.add(className);
+        session.modified = true;
+        
+        Log.d(TAG, "Removed class: " + className);
+    }
+
+    /**
+     * 重命名类
+     */
+    public void renameClass(String sessionId, String oldName, String newName) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef originalClass = findClass(session, oldName);
+
+        if (originalClass == null) {
+            throw new IllegalArgumentException("Class not found: " + oldName);
+        }
+
+        // 创建重命名后的类
+        ImmutableClassDef renamedClass = new ImmutableClassDef(
+            newName,
+            originalClass.getAccessFlags(),
+            originalClass.getSuperclass(),
+            originalClass.getInterfaces(),
+            originalClass.getSourceFile(),
+            originalClass.getAnnotations(),
+            originalClass.getFields(),
+            originalClass.getMethods()
+        );
+
+        session.removedClasses.add(oldName);
+        session.modifiedClasses.add(renamedClass);
+        session.modified = true;
+        
+        Log.d(TAG, "Renamed class: " + oldName + " -> " + newName);
+    }
+
+    // ==================== 方法操作 ====================
+
+    /**
+     * 获取类的所有方法
+     */
+    public JSArray getMethods(String sessionId, String className) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        JSArray methods = new JSArray();
+        for (Method method : classDef.getMethods()) {
+            JSObject methodInfo = new JSObject();
+            methodInfo.put("name", method.getName());
+            methodInfo.put("returnType", method.getReturnType());
+            methodInfo.put("accessFlags", method.getAccessFlags());
+            
+            // 参数类型
+            JSArray params = new JSArray();
+            for (CharSequence param : method.getParameterTypes()) {
+                params.put(param.toString());
+            }
+            methodInfo.put("parameters", params);
+            
+            // 方法签名
+            StringBuilder sig = new StringBuilder("(");
+            for (CharSequence param : method.getParameterTypes()) {
+                sig.append(param);
+            }
+            sig.append(")").append(method.getReturnType());
+            methodInfo.put("signature", sig.toString());
+            
+            methods.put(methodInfo);
+        }
+
+        return methods;
+    }
+
+    /**
+     * 获取方法详细信息
+     */
+    public JSObject getMethodInfo(String sessionId, String className, 
+                                   String methodName, String methodSignature) throws Exception {
+        DexSession session = getSession(sessionId);
+        Method method = findMethod(session, className, methodName, methodSignature);
+
+        if (method == null) {
+            throw new IllegalArgumentException("Method not found: " + methodName);
+        }
+
+        JSObject info = new JSObject();
+        info.put("name", method.getName());
+        info.put("returnType", method.getReturnType());
+        info.put("accessFlags", method.getAccessFlags());
+        info.put("definingClass", method.getDefiningClass());
+
+        // 参数
+        JSArray params = new JSArray();
+        for (CharSequence param : method.getParameterTypes()) {
+            params.put(param.toString());
+        }
+        info.put("parameters", params);
+
+        // 实现信息
+        MethodImplementation impl = method.getImplementation();
+        if (impl != null) {
+            info.put("registerCount", impl.getRegisterCount());
+            int instructionCount = 0;
+            for (Instruction ignored : impl.getInstructions()) {
+                instructionCount++;
+            }
+            info.put("instructionCount", instructionCount);
+        }
+
+        return info;
+    }
+
+    /**
+     * 获取方法的 Smali 代码
+     */
+    public JSObject getMethodSmali(String sessionId, String className,
+                                    String methodName, String methodSignature) throws Exception {
+        DexSession session = getSession(sessionId);
+        
+        // 获取类的完整 Smali，然后提取方法部分
+        String classSmali = classToSmali(sessionId, className).getString("smali");
+        
+        // 简化处理：返回整个类的 Smali（实际应该解析提取特定方法）
+        JSObject result = new JSObject();
+        result.put("className", className);
+        result.put("methodName", methodName);
+        result.put("methodSignature", methodSignature);
+        result.put("smali", extractMethodSmali(classSmali, methodName, methodSignature));
+        return result;
+    }
+
+    /**
+     * 设置方法的 Smali 代码
+     */
+    public void setMethodSmali(String sessionId, String className,
+                               String methodName, String methodSignature,
+                               String smaliCode) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        // 获取原类的 Smali
+        String classSmali = classToSmali(sessionId, className).getString("smali");
+        
+        // 替换方法
+        String modifiedSmali = replaceMethodInSmali(classSmali, methodName, methodSignature, smaliCode);
+        
+        // 重新编译
+        ClassDef modifiedClass = compileSmaliToClass(modifiedSmali, session.originalDexFile.getOpcodes());
+        
+        // 更新会话
+        session.removedClasses.add(className);
+        session.modifiedClasses.add(modifiedClass);
+        session.modified = true;
+        
+        Log.d(TAG, "Modified method: " + className + "->" + methodName);
+    }
+
+    /**
+     * 添加方法
+     */
+    public void addMethod(String sessionId, String className, String smaliCode) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        // 获取原类 Smali 并添加新方法
+        String classSmali = classToSmali(sessionId, className).getString("smali");
+        String modifiedSmali = insertMethodToSmali(classSmali, smaliCode);
+        
+        // 重新编译
+        ClassDef modifiedClass = compileSmaliToClass(modifiedSmali, session.originalDexFile.getOpcodes());
+        
+        session.removedClasses.add(className);
+        session.modifiedClasses.add(modifiedClass);
+        session.modified = true;
+    }
+
+    /**
+     * 删除方法
+     */
+    public void removeMethod(String sessionId, String className,
+                             String methodName, String methodSignature) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        // 获取原类 Smali 并删除方法
+        String classSmali = classToSmali(sessionId, className).getString("smali");
+        String modifiedSmali = removeMethodFromSmali(classSmali, methodName, methodSignature);
+        
+        // 重新编译
+        ClassDef modifiedClass = compileSmaliToClass(modifiedSmali, session.originalDexFile.getOpcodes());
+        
+        session.removedClasses.add(className);
+        session.modifiedClasses.add(modifiedClass);
+        session.modified = true;
+    }
+
+    // ==================== 字段操作 ====================
+
+    /**
+     * 获取类的所有字段
+     */
+    public JSArray getFields(String sessionId, String className) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        JSArray fields = new JSArray();
+        for (Field field : classDef.getFields()) {
+            JSObject fieldInfo = new JSObject();
+            fieldInfo.put("name", field.getName());
+            fieldInfo.put("type", field.getType());
+            fieldInfo.put("accessFlags", field.getAccessFlags());
+            fields.put(fieldInfo);
+        }
+
+        return fields;
+    }
+
+    /**
+     * 获取字段详细信息
+     */
+    public JSObject getFieldInfo(String sessionId, String className, String fieldName) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        for (Field field : classDef.getFields()) {
+            if (field.getName().equals(fieldName)) {
+                JSObject info = new JSObject();
+                info.put("name", field.getName());
+                info.put("type", field.getType());
+                info.put("accessFlags", field.getAccessFlags());
+                info.put("definingClass", field.getDefiningClass());
+                return info;
+            }
+        }
+
+        throw new IllegalArgumentException("Field not found: " + fieldName);
+    }
+
+    /**
+     * 添加字段
+     */
+    public void addField(String sessionId, String className, String fieldDef) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        // 获取原类 Smali 并添加字段定义
+        String classSmali = classToSmali(sessionId, className).getString("smali");
+        String modifiedSmali = insertFieldToSmali(classSmali, fieldDef);
+        
+        // 重新编译
+        ClassDef modifiedClass = compileSmaliToClass(modifiedSmali, session.originalDexFile.getOpcodes());
+        
+        session.removedClasses.add(className);
+        session.modifiedClasses.add(modifiedClass);
+        session.modified = true;
+    }
+
+    /**
+     * 删除字段
+     */
+    public void removeField(String sessionId, String className, String fieldName) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        // 获取原类 Smali 并删除字段
+        String classSmali = classToSmali(sessionId, className).getString("smali");
+        String modifiedSmali = removeFieldFromSmali(classSmali, fieldName);
+        
+        // 重新编译
+        ClassDef modifiedClass = compileSmaliToClass(modifiedSmali, session.originalDexFile.getOpcodes());
+        
+        session.removedClasses.add(className);
+        session.modifiedClasses.add(modifiedClass);
+        session.modified = true;
+    }
+
+    // ==================== Smali 操作 ====================
+
+    /**
+     * 将类转换为 Smali 代码
+     */
+    public JSObject classToSmali(String sessionId, String className) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef classDef = findClass(session, className);
+
+        if (classDef == null) {
+            throw new IllegalArgumentException("Class not found: " + className);
+        }
+
+        // 使用 baksmali 转换
+        StringWriter writer = new StringWriter();
+        BaksmaliOptions options = new BaksmaliOptions();
+        
+        // 创建临时 DEX 只包含该类
+        List<ClassDef> singleClass = new ArrayList<>();
+        singleClass.add(classDef);
+        ImmutableDexFile singleDex = new ImmutableDexFile(
+            session.originalDexFile.getOpcodes(), 
+            singleClass
+        );
+
+        // 使用临时目录输出
+        File tempDir = File.createTempFile("smali_", "_temp");
+        tempDir.delete();
+        tempDir.mkdirs();
+
+        try {
+            Baksmali.disassembleDexFile(singleDex, tempDir, 1, options);
+            
+            // 读取生成的 smali 文件
+            String smaliPath = className.substring(1, className.length() - 1) + ".smali";
+            File smaliFile = new File(tempDir, smaliPath);
+            
+            if (smaliFile.exists()) {
+                String smali = readFileContent(smaliFile);
+                JSObject result = new JSObject();
+                result.put("className", className);
+                result.put("smali", smali);
+                return result;
+            } else {
+                throw new IOException("Failed to generate smali for: " + className);
+            }
+        } finally {
+            deleteRecursive(tempDir);
+        }
+    }
+
+    /**
+     * 将 Smali 代码编译为类并添加到 DEX
+     */
+    public void smaliToClass(String sessionId, String smaliCode) throws Exception {
+        DexSession session = getSession(sessionId);
+        ClassDef newClass = compileSmaliToClass(smaliCode, session.originalDexFile.getOpcodes());
+        session.modifiedClasses.add(newClass);
+        session.modified = true;
+    }
+
+    /**
+     * 反汇编整个 DEX 到目录
+     */
+    public void disassemble(String sessionId, String outputDir) throws Exception {
+        DexSession session = getSession(sessionId);
+        File outDir = new File(outputDir);
+        outDir.mkdirs();
+
+        BaksmaliOptions options = new BaksmaliOptions();
+        Baksmali.disassembleDexFile(session.originalDexFile, outDir, 4, options);
+        
+        Log.d(TAG, "Disassembled to: " + outputDir);
+    }
+
+    /**
+     * 汇编 Smali 目录为 DEX
+     */
+    public JSObject assemble(String smaliDir, String outputPath) throws Exception {
+        File inputDir = new File(smaliDir);
+        File outputFile = new File(outputPath);
+
+        if (!inputDir.exists() || !inputDir.isDirectory()) {
+            throw new IllegalArgumentException("Invalid smali directory: " + smaliDir);
+        }
+
+        outputFile.getParentFile().mkdirs();
+
+        SmaliOptions options = new SmaliOptions();
+        options.outputDexFile = outputPath;
+        
+        List<File> smaliFiles = collectSmaliFiles(inputDir);
+        List<String> filePaths = new ArrayList<>();
+        for (File f : smaliFiles) {
+            filePaths.add(f.getAbsolutePath());
+        }
+
+        boolean success = Smali.assemble(options, filePaths);
+
+        JSObject result = new JSObject();
+        result.put("success", success);
+        result.put("outputPath", outputPath);
+        return result;
+    }
+
+    // ==================== 搜索操作 ====================
+
+    /**
+     * 搜索字符串
+     */
+    public JSArray searchString(String sessionId, String query, 
+                                boolean regex, boolean caseSensitive) throws Exception {
+        DexSession session = getSession(sessionId);
+        JSArray results = new JSArray();
+
+        Pattern pattern = null;
+        if (regex) {
+            int flags = caseSensitive ? 0 : Pattern.CASE_INSENSITIVE;
+            pattern = Pattern.compile(query, flags);
+        }
+
+        for (int i = 0; i < session.originalDexFile.getStringCount(); i++) {
+            String str = session.originalDexFile.getStringSection().get(i);
+            boolean match;
+            
+            if (regex) {
+                match = pattern.matcher(str).find();
+            } else if (caseSensitive) {
+                match = str.contains(query);
+            } else {
+                match = str.toLowerCase().contains(query.toLowerCase());
+            }
+            
+            if (match) {
+                JSObject item = new JSObject();
+                item.put("index", i);
+                item.put("value", str);
+                results.put(item);
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * 搜索代码
+     */
+    public JSArray searchCode(String sessionId, String query, boolean regex) throws Exception {
+        DexSession session = getSession(sessionId);
+        JSArray results = new JSArray();
+
+        Pattern pattern = regex ? Pattern.compile(query) : null;
+
+        for (ClassDef classDef : session.originalDexFile.getClasses()) {
+            if (session.removedClasses.contains(classDef.getType())) continue;
+
+            try {
+                String smali = classToSmali(sessionId, classDef.getType()).getString("smali");
+                boolean match = regex ? pattern.matcher(smali).find() : smali.contains(query);
+                
+                if (match) {
+                    JSObject item = new JSObject();
+                    item.put("className", classDef.getType());
+                    item.put("matchCount", countMatches(smali, query, regex));
+                    results.put(item);
+                }
+            } catch (Exception e) {
+                Log.w(TAG, "Failed to search class: " + classDef.getType(), e);
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * 搜索方法
+     */
+    public JSArray searchMethod(String sessionId, String query) throws Exception {
+        DexSession session = getSession(sessionId);
+        JSArray results = new JSArray();
+        String queryLower = query.toLowerCase();
+
+        for (ClassDef classDef : session.originalDexFile.getClasses()) {
+            if (session.removedClasses.contains(classDef.getType())) continue;
+
+            for (Method method : classDef.getMethods()) {
+                if (method.getName().toLowerCase().contains(queryLower)) {
+                    JSObject item = new JSObject();
+                    item.put("className", classDef.getType());
+                    item.put("methodName", method.getName());
+                    item.put("returnType", method.getReturnType());
+                    results.put(item);
+                }
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * 搜索字段
+     */
+    public JSArray searchField(String sessionId, String query) throws Exception {
+        DexSession session = getSession(sessionId);
+        JSArray results = new JSArray();
+        String queryLower = query.toLowerCase();
+
+        for (ClassDef classDef : session.originalDexFile.getClasses()) {
+            if (session.removedClasses.contains(classDef.getType())) continue;
+
+            for (Field field : classDef.getFields()) {
+                if (field.getName().toLowerCase().contains(queryLower)) {
+                    JSObject item = new JSObject();
+                    item.put("className", classDef.getType());
+                    item.put("fieldName", field.getName());
+                    item.put("fieldType", field.getType());
+                    results.put(item);
+                }
+            }
+        }
+
+        return results;
+    }
+
+    // ==================== 工具操作 ====================
+
+    /**
+     * 修复 DEX 文件
+     */
+    public void fixDex(String inputPath, String outputPath) throws Exception {
+        // 读取并重新写入 DEX 来修复格式问题
+        File inputFile = new File(inputPath);
+        DexBackedDexFile dexFile = (DexBackedDexFile) DexFileFactory.loadDexFile(
+            inputFile,
+            Opcodes.getDefault()
+        );
+
+        DexPool dexPool = new DexPool(dexFile.getOpcodes());
+        for (ClassDef classDef : dexFile.getClasses()) {
+            dexPool.internClass(classDef);
+        }
+
+        File outputFile = new File(outputPath);
+        outputFile.getParentFile().mkdirs();
+        dexPool.writeTo(new FileDataStore(outputFile));
+        
+        Log.d(TAG, "Fixed DEX: " + inputPath + " -> " + outputPath);
+    }
+
+    /**
+     * 合并多个 DEX 文件
+     */
+    public void mergeDex(JSONArray inputPaths, String outputPath) throws Exception {
+        DexPool dexPool = new DexPool(Opcodes.getDefault());
+
+        for (int i = 0; i < inputPaths.length(); i++) {
+            String path = inputPaths.getString(i);
+            DexBackedDexFile dexFile = (DexBackedDexFile) DexFileFactory.loadDexFile(
+                new File(path),
+                Opcodes.getDefault()
+            );
+
+            for (ClassDef classDef : dexFile.getClasses()) {
+                dexPool.internClass(classDef);
+            }
+        }
+
+        File outputFile = new File(outputPath);
+        outputFile.getParentFile().mkdirs();
+        dexPool.writeTo(new FileDataStore(outputFile));
+        
+        Log.d(TAG, "Merged " + inputPaths.length() + " DEX files to: " + outputPath);
+    }
+
+    /**
+     * 拆分 DEX 文件
+     */
+    public JSArray splitDex(String sessionId, int maxClasses) throws Exception {
+        DexSession session = getSession(sessionId);
+        JSArray outputFiles = new JSArray();
+
+        List<ClassDef> allClasses = new ArrayList<>();
+        for (ClassDef classDef : session.originalDexFile.getClasses()) {
+            if (!session.removedClasses.contains(classDef.getType())) {
+                allClasses.add(classDef);
+            }
+        }
+
+        int dexIndex = 0;
+        for (int i = 0; i < allClasses.size(); i += maxClasses) {
+            DexPool dexPool = new DexPool(session.originalDexFile.getOpcodes());
+            
+            int end = Math.min(i + maxClasses, allClasses.size());
+            for (int j = i; j < end; j++) {
+                dexPool.internClass(allClasses.get(j));
+            }
+
+            String outputPath = session.filePath.replace(".dex", "_" + dexIndex + ".dex");
+            dexPool.writeTo(new FileDataStore(new File(outputPath)));
+            outputFiles.put(outputPath);
+            dexIndex++;
+        }
+
+        return outputFiles;
+    }
+
+    /**
+     * 获取字符串常量池
+     */
+    public JSArray getStrings(String sessionId) throws Exception {
+        DexSession session = getSession(sessionId);
+        JSArray strings = new JSArray();
+
+        for (int i = 0; i < session.originalDexFile.getStringCount(); i++) {
+            JSObject item = new JSObject();
+            item.put("index", i);
+            item.put("value", session.originalDexFile.getStringSection().get(i));
+            strings.put(item);
+        }
+
+        return strings;
+    }
+
+    /**
+     * 修改字符串
+     */
+    public void modifyString(String sessionId, String oldString, String newString) throws Exception {
+        DexSession session = getSession(sessionId);
+
+        // 需要遍历所有类，替换字符串引用
+        for (ClassDef classDef : session.originalDexFile.getClasses()) {
+            if (session.removedClasses.contains(classDef.getType())) continue;
+
+            try {
+                String smali = classToSmali(sessionId, classDef.getType()).getString("smali");
+                if (smali.contains(oldString)) {
+                    String modifiedSmali = smali.replace(oldString, newString);
+                    ClassDef modifiedClass = compileSmaliToClass(modifiedSmali, session.originalDexFile.getOpcodes());
+                    
+                    session.removedClasses.add(classDef.getType());
+                    session.modifiedClasses.add(modifiedClass);
+                }
+            } catch (Exception e) {
+                Log.w(TAG, "Failed to modify string in class: " + classDef.getType(), e);
+            }
+        }
+
+        session.modified = true;
+    }
+
+    // ==================== 辅助方法 ====================
+
+    private DexSession getSession(String sessionId) throws Exception {
+        DexSession session = sessions.get(sessionId);
+        if (session == null) {
+            throw new IllegalArgumentException("Session not found: " + sessionId);
+        }
+        return session;
+    }
+
+    private ClassDef findClass(DexSession session, String className) {
+        // 先检查修改后的类
+        for (ClassDef classDef : session.modifiedClasses) {
+            if (classDef.getType().equals(className)) {
+                return classDef;
+            }
+        }
+        
+        // 再检查原始类
+        if (!session.removedClasses.contains(className)) {
+            for (ClassDef classDef : session.originalDexFile.getClasses()) {
+                if (classDef.getType().equals(className)) {
+                    return classDef;
+                }
+            }
+        }
+        
+        return null;
+    }
+
+    private Method findMethod(DexSession session, String className, 
+                              String methodName, String methodSignature) {
+        ClassDef classDef = findClass(session, className);
+        if (classDef == null) return null;
+
+        for (Method method : classDef.getMethods()) {
+            if (method.getName().equals(methodName)) {
+                StringBuilder sig = new StringBuilder("(");
+                for (CharSequence param : method.getParameterTypes()) {
+                    sig.append(param);
+                }
+                sig.append(")").append(method.getReturnType());
+                
+                if (sig.toString().equals(methodSignature)) {
+                    return method;
+                }
+            }
+        }
+        
+        return null;
+    }
+
+    private ClassDef compileSmaliToClass(String smaliCode, Opcodes opcodes) throws Exception {
+        // 创建临时文件
+        File tempDir = File.createTempFile("smali_compile_", "_temp");
+        tempDir.delete();
+        tempDir.mkdirs();
+
+        try {
+            // 写入 smali 文件
+            File smaliFile = new File(tempDir, "temp.smali");
+            try (BufferedWriter writer = new BufferedWriter(new FileWriter(smaliFile))) {
+                writer.write(smaliCode);
+            }
+
+            // 编译
+            File outputDex = new File(tempDir, "output.dex");
+            SmaliOptions options = new SmaliOptions();
+            options.outputDexFile = outputDex.getAbsolutePath();
+            
+            List<String> files = new ArrayList<>();
+            files.add(smaliFile.getAbsolutePath());
+            
+            if (!Smali.assemble(options, files)) {
+                throw new Exception("Failed to compile smali code");
+            }
+
+            // 读取编译后的类
+            DexBackedDexFile compiledDex = DexBackedDexFile.fromInputStream(
+                opcodes,
+                new FileInputStream(outputDex)
+            );
+
+            for (ClassDef classDef : compiledDex.getClasses()) {
+                return classDef; // 返回第一个类
+            }
+
+            throw new Exception("No class found in compiled smali");
+        } finally {
+            deleteRecursive(tempDir);
+        }
+    }
+
+    private String extractMethodSmali(String classSmali, String methodName, String signature) {
+        // 简化实现：查找方法定义并提取
+        String methodStart = ".method";
+        String methodEnd = ".end method";
+        
+        int searchStart = 0;
+        while (true) {
+            int start = classSmali.indexOf(methodStart, searchStart);
+            if (start == -1) break;
+            
+            int end = classSmali.indexOf(methodEnd, start);
+            if (end == -1) break;
+            
+            String methodBlock = classSmali.substring(start, end + methodEnd.length());
+            if (methodBlock.contains(methodName)) {
+                return methodBlock;
+            }
+            
+            searchStart = end + methodEnd.length();
+        }
+        
+        return "";
+    }
+
+    private String replaceMethodInSmali(String classSmali, String methodName, 
+                                         String signature, String newMethodCode) {
+        String methodStart = ".method";
+        String methodEnd = ".end method";
+        
+        int searchStart = 0;
+        while (true) {
+            int start = classSmali.indexOf(methodStart, searchStart);
+            if (start == -1) break;
+            
+            int end = classSmali.indexOf(methodEnd, start);
+            if (end == -1) break;
+            
+            String methodBlock = classSmali.substring(start, end + methodEnd.length());
+            if (methodBlock.contains(methodName)) {
+                return classSmali.substring(0, start) + newMethodCode + 
+                       classSmali.substring(end + methodEnd.length());
+            }
+            
+            searchStart = end + methodEnd.length();
+        }
+        
+        return classSmali;
+    }
+
+    private String insertMethodToSmali(String classSmali, String methodCode) {
+        // 在类结束前插入方法
+        int endClass = classSmali.lastIndexOf(".end class");
+        if (endClass != -1) {
+            return classSmali.substring(0, endClass) + "\n" + methodCode + "\n\n" + 
+                   classSmali.substring(endClass);
+        }
+        return classSmali + "\n" + methodCode;
+    }
+
+    private String removeMethodFromSmali(String classSmali, String methodName, String signature) {
+        String methodStart = ".method";
+        String methodEnd = ".end method";
+        
+        int searchStart = 0;
+        while (true) {
+            int start = classSmali.indexOf(methodStart, searchStart);
+            if (start == -1) break;
+            
+            int end = classSmali.indexOf(methodEnd, start);
+            if (end == -1) break;
+            
+            String methodBlock = classSmali.substring(start, end + methodEnd.length());
+            if (methodBlock.contains(methodName)) {
+                return classSmali.substring(0, start) + classSmali.substring(end + methodEnd.length());
+            }
+            
+            searchStart = end + methodEnd.length();
+        }
+        
+        return classSmali;
+    }
+
+    private String insertFieldToSmali(String classSmali, String fieldDef) {
+        // 在第一个方法前或类结束前插入字段
+        int methodPos = classSmali.indexOf(".method");
+        if (methodPos != -1) {
+            return classSmali.substring(0, methodPos) + fieldDef + "\n\n" + 
+                   classSmali.substring(methodPos);
+        }
+        
+        int endClass = classSmali.lastIndexOf(".end class");
+        if (endClass != -1) {
+            return classSmali.substring(0, endClass) + fieldDef + "\n\n" + 
+                   classSmali.substring(endClass);
+        }
+        
+        return classSmali + "\n" + fieldDef;
+    }
+
+    private String removeFieldFromSmali(String classSmali, String fieldName) {
+        // 简化实现：移除包含字段名的 .field 行
+        String[] lines = classSmali.split("\n");
+        StringBuilder result = new StringBuilder();
+        
+        for (String line : lines) {
+            if (!(line.trim().startsWith(".field") && line.contains(fieldName))) {
+                result.append(line).append("\n");
+            }
+        }
+        
+        return result.toString();
+    }
+
+    private List<File> collectSmaliFiles(File dir) {
+        List<File> files = new ArrayList<>();
+        File[] children = dir.listFiles();
+        if (children != null) {
+            for (File child : children) {
+                if (child.isDirectory()) {
+                    files.addAll(collectSmaliFiles(child));
+                } else if (child.getName().endsWith(".smali")) {
+                    files.add(child);
+                }
+            }
+        }
+        return files;
+    }
+
+    private String readFileContent(File file) throws IOException {
+        StringBuilder content = new StringBuilder();
+        try (java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.FileReader(file))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                content.append(line).append("\n");
+            }
+        }
+        return content.toString();
+    }
+
+    private void deleteRecursive(File file) {
+        if (file.isDirectory()) {
+            File[] children = file.listFiles();
+            if (children != null) {
+                for (File child : children) {
+                    deleteRecursive(child);
+                }
+            }
+        }
+        file.delete();
+    }
+
+    private int countMatches(String text, String query, boolean regex) {
+        int count = 0;
+        if (regex) {
+            java.util.regex.Matcher matcher = Pattern.compile(query).matcher(text);
+            while (matcher.find()) count++;
+        } else {
+            int index = 0;
+            while ((index = text.indexOf(query, index)) != -1) {
+                count++;
+                index += query.length();
+            }
+        }
+        return count;
+    }
+}