capacitor-dex-editor 0.0.37 → 0.0.39

package/android/src/main/assets/python.json

@@ -0,0 +1,87 @@
+{
+  "name": ["Python", ".py"],
+  "comment": [
+    { "startsWith": "#" }
+  ],
+  
+  "rules": [
+    // Single-line comments
+    { "type": "comment", "regex": "#.*" },
+    
+    // Multi-line comments (triple double quotes at start of line)
+    {
+      "regex": "(?m)^\\s*\"\"\"[\\s\\S]*?\"\"\"",
+      "groupStyles": { "0": "comment" }
+    },
+    
+    // Multi-line comments (triple single quotes at start of line)
+    {
+      "regex": "(?m)^\\s*'''[\\s\\S]*?'''",
+      "groupStyles": { "0": "comment" }
+    },
+    
+    // Triple double quoted strings
+    {
+      "regex": "\"\"\"[\\s\\S]*?\"\"\"",
+      "groupStyles": { "0": "string" }
+    },
+    
+    // Triple single quoted strings
+    {
+      "regex": "'''[\\s\\S]*?'''",
+      "groupStyles": { "0": "string" }
+    },
+    
+    // Double quoted strings
+    {
+      "regex": "\"(?:\\\\.|[^\"])*\"",
+      "groupStyles": { "0": "string" }
+    },
+    
+    // Single quoted strings
+    {
+      "regex": "'(?:\\\\.|[^'])*'",
+      "groupStyles": { "0": "string" }
+    },
+    
+    // String escape sequences
+    { "type": "strEscape", "regex": "\\\\u[0-9a-fA-F]{4}|\\\\x[0-9a-fA-F]{2}|\\\\[0-7]{1,3}|\\\\." },
+    
+    // Numbers - binary
+    { "type": "number", "regex": "\\b0[bB][01_]+\\b" },
+    
+    // Numbers - octal
+    { "type": "number", "regex": "\\b0[oO][0-7_]+\\b" },
+    
+    // Numbers - hex
+    { "type": "number", "regex": "\\b0[xX][0-9a-fA-F_]+\\b" },
+    
+    // Numbers - decimal with scientific notation and complex
+    { "type": "number", "regex": "\\b\\d[\\d_]*(?:\\.\\d[\\d_]*)?(?:[eE][+-]?\\d[\\d_]*)?[jJ]?\\b" },
+    { "type": "number", "regex": "\\b\\d[\\d_]*[jJ]\\b" },
+    
+    // Built-in types - only match when they are standalone words
+    {
+      "type": "type",
+      "regex": "\\b(?:int|float|long|complex|str|unicode|list|tuple|bytearray|buffer|xrange|set|frozenset|dict|bool)\\b"
+    },
+    
+    // Keywords - only match when they are standalone words
+    {
+      "type": "keyword",
+      "regex": "\\b(?:True|False|None|self|NotImplemented|Ellipsis|__debug__|__file__|and|del|from|not|while|as|elif|global|or|with|assert|else|if|pass|yield|break|except|import|print|class|exec|in|raise|continue|finally|is|return|def|for|lambda|try)\\b"
+    },
+    
+    // Exception and error types - only match when they are standalone words
+    {
+      "type": "keyword2", 
+      "regex": "\\b(?:ArithmeticError|AssertionError|AttributeError|BaseException|DeprecationWarning|EnvironmentError|EOFError|Exception|FloatingPointError|FutureWarning|GeneratorExit|IOError|ImportError|ImportWarning|IndexError|KeyError|KeyboardInterrupt|LookupError|MemoryError|NameError|NotImplementedError|OSError|OverflowError|PendingDeprecationWarning|ReferenceError|RuntimeError|RuntimeWarning|StandardError|StopIteration|SyntaxError|SyntaxWarning|SystemError|SystemExit|TypeError|UnboundLocalError|UserWarning|UnicodeError|UnicodeWarning|UnicodeEncodeError|UnicodeDecodeError|UnicodeTranslateError|ValueError|Warning|WindowsError|ZeroDivisionError)\\b"
+    },
+    
+    // Operators
+    { "type": "operator", "regex": "[+\\-*/%=&|!<>^~]+|\\.|,|;|:|@|\\(|\\)|\\{|\\}|\\[|\\]" },
+    
+    // Default fallback - should be last
+    { "type": "default", "regex": "." }
+  ]
+}

package/android/src/main/assets/rust.json

@@ -0,0 +1,139 @@
+{
+  "name": ["Rust", ".rs"],
+  "comment": [
+    { "startsWith": "//" },
+    { "startsWith": "//!" },
+    { "startsWith": "/*", "endsWith": "*/" }
+  ],
+  
+  "rules": [
+    // Shebang
+    { "type": "comment", "regex": "^#![^\\[\\r\\n][^\\r\\n]*" },
+    
+    // Doc comments - highlight as constant (must come before regular comments)
+    { "type": "constant", "regex": "\\/\\/\\/.*" },
+    { "type": "constant", "regex": "\\/\\/!.*" },
+    { "type": "constant", "regex": "\\/\\*\\*[\\s\\S]*?\\*\\/" },
+    
+    // Regular comments
+    { "type": "comment", "regex": "\\/\\/.*" },
+    { "type": "comment", "regex": "\\/\\*[\\s\\S]*?\\*\\/" },
+    
+    // TODO comments
+    { "type": "variable", "regex": "\\b(?:TODO|FIXME|XXX|NB|NOTE|SAFETY)\\b" },
+    
+    // Simple inner attributes like #![allow(unused)]
+    { "type": "label", "regex": "#!\\[[^\\]]*\\]" },
+    
+    // Attribute brackets
+    { "type": "label", "regex": "#\\[" },
+    { "type": "label", "regex": "\\]" },
+    
+    // Attribute name (derive, inline, repr, cfg, etc.)
+    { "type": "label", "regex": "(?<=#\\[)\\s*[a-zA-Z_][a-zA-Z0-9_]*" }, 
+    
+    // Macro variables - $identifier (but not $()
+    { "type": "label", "regex": "\\$[a-zA-Z_][a-zA-Z0-9_]*" },
+    
+    // Macro repetition operators - * + ? 
+    { "type": "keyword2", "regex": "(?<!\\.)[*+?](?![/=])" },
+    
+    // Module paths like std::collections, std::fmt
+    { "type": "constant", "regex": "\\b(?:std|core|alloc)::[a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z_][a-zA-Z0-9_]*)*" },
+    
+    // Method calls - both .method() and Type::method()
+    { "type": "variable", "regex": "(?:(?<=\\.)|(?<=::))[a-zA-Z_][a-zA-Z0-9_]*(?=\\()" },
+    
+    // Standard library types and traits - MUST come before struct names
+    {
+      "type": "variable",
+      "regex": "\\b(?:Send|Sized|Sync|Unpin|Drop|Fn|FnMut|FnOnce|AsMut|AsRef|From|Into|DoubleEndedIterator|ExactSizeIterator|Extend|IntoIterator|Iterator|Clone|Copy|Default|Eq|Ord|PartialEq|PartialOrd|ToOwned|ToString|TryFrom|TryInto|FromIterator|Box|String|Vec|Option|None|Some|Result|Err|Ok|Future|IntoFuture|AsyncFn|AsyncFnMut|AsyncFnOnce|Debug|Hash|RustcEncodable|RustcDecodable|Encodable|Decodable|Rand|Show|FromPrimitive)\\b"
+    },
+    
+    // Struct/Enum names (UpperCamelCase) - but exclude known traits
+    { "type": "constant", "regex": "\\b[A-Z][a-zA-Z0-9_]*\\b" },
+    
+    // Strings - double quoted
+    { "type": "string", "regex": "[bc]?\"(?:\\\\.|[^\"])*\"" },
+    
+    // Raw strings
+    { "type": "string", "regex": "[bc]?r\"[^\"]*\"" },
+    { "type": "string", "regex": "[bc]?r#\"[^\"]*\"#" },
+    { "type": "string", "regex": "r##\"[^\"]*\"##" },
+    { "type": "string", "regex": "r###\"[^\"]*\"###" },
+    
+    // Character literals
+    { "type": "string", "regex": "b?'(?:\\\\.|[^'])'" },
+    
+    // String escape sequences
+    { "type": "strEscape", "regex": "\\\\u\\{[0-9a-fA-F_]+\\}|\\\\x[0-9a-fA-F]{2}|\\\\[nrt\\\\0\"']" },
+    
+    // Format macros
+    {
+      "type": "label",
+      "regex": "\\b(?:format|format_args|format_args_nl|const_format_args|print|println|eprint|eprintln|panic|todo|unimplemented|unreachable|write|writeln|assert|debug_assert|assert_eq|assert_ne|assert_matches|debug_assert_eq|debug_assert_ne|debug_assert_matches)!"
+    },
+    
+    // Numbers
+    { "type": "number", "regex": "\\b0[xX][0-9a-fA-F_]+\\b" },
+    { "type": "number", "regex": "\\b0[oO][0-7_]+\\b" },
+    { "type": "number", "regex": "\\b0[bB][01_]+\\b" },
+    { "type": "number", "regex": "\\b\\d[\\d_]*(?:\\.\\d[\\d_]*)?(?:[eE][+-]?[\\d_]+)?[fiu]?(?:8|16|32|64|128|size)?\\b" },
+    
+    // Function definitions
+    {
+      "regex": "\\b(fn)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+      "groupStyles": { "1": "keyword", "2": "tagName" }
+    },
+    
+    // Union definitions
+    {
+      "regex": "\\b(union)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+      "groupStyles": { "1": "keyword", "2": "type" }
+    },
+    
+    // Keywords
+    {
+      "type": "keyword",
+      "regex": "\\b(?:as|break|const|continue|crate|dyn|else|enum|extern|false|fn|for|if|impl|in|let|loop|match|mod|move|mut|pub|ref|return|static|struct|super|trait|true|type|unsafe|use|where|while|async|await|macro|try|yield|default|safe|auto|gen|union)\\b"
+    },
+    
+    // Built-in types
+    {
+      "type": "type", 
+      "regex": "\\b(?:bool|char|str|f16|f32|f64|f128|i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)\\b"
+    },
+    
+    // Self types
+    { "type": "variable", "regex": "\\bSelf\\b" },
+    
+    // self value
+    { "type": "constant", "regex": "\\bself\\b" },
+    
+    // Path delimiter
+    { "type": "operator", "regex": "::" },
+    
+    // Macros
+    { "type": "label", "regex": "[a-zA-Z_][a-zA-Z0-9_]*!" },
+    
+    // Lifetimes
+    { "type": "meta", "regex": "'[a-zA-Z_][a-zA-Z0-9_]*" },
+    
+    // Labels
+    { "type": "label", "regex": "'[a-zA-Z_][a-zA-Z0-9_]*:" },
+    
+    // Operators
+    { "type": "operator", "regex": "[?]" },
+    { "type": "operator", "regex": "&&|\\|\\|" },
+    { "type": "operator", "regex": "=>" },
+    { "type": "operator", "regex": "[<!>=]=|[<>]" },
+    { "type": "operator", "regex": "[&~@*!]" },
+    { "type": "operator", "regex": "[+\\-*\\/%^&|]=" },
+    
+    // Punctuation
+    { "type": "operator", "regex": "[.,;(){}[\\]]" },
+    
+    // Default fallback
+    { "type": "default", "regex": "." }
+  ]
+}

package/android/src/main/assets/smali.json

@@ -0,0 +1,131 @@
+{
+  "name": ["Smali", ".smali", ".class"],
+  "comment": { "startsWith": "#" },
+  "rules": [
+    // Comments
+    { "type": "comment", "regex": "#.*$" },
+
+    // Strings
+    { "type": "string", "regex": "\"(?:\\\\.|[^\\\\\"])*\"" },
+   
+    // ---------- Directives & .end/.restart handling ----------
+    {
+      "type": "keyword2",
+      "regex": "^(\\s*)(\\.(?:end\\s+|restart\\s+)?[a-zA-Z_\\-]+)\\b"
+    },
+    
+    {
+  	  "type": "methodStart",
+  	  "regex": "(?m)^[ \t]*\\.method",
+  	  "lineBackground": "#FFEDED"
+	}, 
+    
+     // ---------- Instructions ----------
+    {
+      "type": "keyword",
+      "keywords": [
+        "nop", "move", "move/from16", "move/16", "move-wide", "move-wide/from16", "move-wide/16", "move-object",
+		"move-object/from16", "move-object/16", "move-result", "move-result-wide", "move-result-object",
+		"move-exception", "const/4", "const/16", "const", "const/high16", "const-wide/16", "const-wide/32",
+		"const-wide", "const-wide/high16", "const-string", "const-string/jumbo", "const-class",
+		"monitor-enter", "monitor-exit", "check-cast", "instance-of", "array-length", "new-instance", "new-array",
+		"filled-new-array", "filled-new-array/range", "fill-array-data", "cmpl-float", "cmpg-float",
+		"cmpl-double", "cmpg-double", "cmp-long", "aget", "aget-wide", "aget-object", "aget-boolean", "aget-byte",
+		"aget-char", "aget-short", "aput", "aput-wide", "aput-object", "aput-boolean", "aput-byte", "aput-char",
+		"aput-short", "iget", "iget-wide", "iget-object", "iget-boolean", "iget-byte", "iget-char", "iget-short",
+		"iput", "iput-wide", "iput-object", "iput-boolean", "iput-byte", "iput-char", "iput-short", "sget", "sget-wide",
+		"sget-object", "sget-boolean", "sget-byte", "sget-char", "sget-short", "sput", "sput-wide", "sput-object",
+		"sput-boolean", "sput-byte", "sput-char", "sput-short", "invoke-virtual", "invoke-super", "invoke-direct",
+		"invoke-static", "invoke-interface", "invoke-virtual/range", "invoke-super/range",
+		"invoke-direct/range", "invoke-static/range", "invoke-interface/range", "neg-int", "not-int",
+		"neg-long", "not-long", "neg-float", "neg-double", "int-to-long", "int-to-float", "int-to-double",
+		"long-to-int", "long-to-float", "long-to-double", "float-to-int", "float-to-long", "float-to-double",
+		"double-to-int", "double-to-long", "double-to-float", "int-to-byte", "int-to-char", "int-to-short",
+		"add-int", "sub-int", "mul-int", "div-int", "rem-int", "and-int", "or-int", "xor-int", "shl-int", "shr-int",
+		"ushr-int", "add-long", "sub-long", "mul-long", "div-long", "rem-long", "and-long", "or-long", "xor-long",
+		"shl-long", "shr-long", "ushr-long", "add-float", "sub-float", "mul-float", "div-float", "rem-float",
+		"add-double", "sub-double", "mul-double", "div-double", "rem-double", "add-int/2addr", "sub-int/2addr",
+		"mul-int/2addr", "div-int/2addr", "rem-int/2addr", "and-int/2addr", "or-int/2addr", "xor-int/2addr",
+		"shl-int/2addr", "shr-int/2addr", "ushr-int/2addr", "add-long/2addr", "sub-long/2addr",
+		"mul-long/2addr", "div-long/2addr", "rem-long/2addr", "and-long/2addr", "or-long/2addr",
+		"xor-long/2addr", "shl-long/2addr", "shr-long/2addr", "ushr-long/2addr", "add-float/2addr",
+		"sub-float/2addr", "mul-float/2addr", "div-float/2addr", "rem-float/2addr", "add-double/2addr",
+		"sub-double/2addr", "mul-double/2addr", "div-double/2addr", "rem-double/2addr", "add-int/lit16",
+		"rsub-int", "mul-int/lit16", "div-int/lit16", "rem-int/lit16", "and-int/lit16", "or-int/lit16",
+		"xor-int/lit16", "add-int/lit8", "rsub-int/lit8", "mul-int/lit8", "div-int/lit8", "rem-int/lit8",
+		"and-int/lit8", "or-int/lit8", "xor-int/lit8", "shl-int/lit8", "shr-int/lit8", "ushr-int/lit8",
+		"iget-volatile", "iput-volatile", "sget-volatile", "sput-volatile", "iget-object-volatile",
+		"iget-wide-volatile", "iput-wide-volatile", "sget-wide-volatile", "sput-wide-volatile",
+		"throw-verification-error", "execute-inline", "execute-inline/range", "invoke-direct-empty",
+		"invoke-object-init/range", "iget-quick", "iget-wide-quick", "iget-object-quick", "iput-quick",
+		"iput-wide-quick", "iput-object-quick", "iput-boolean-quick", "iput-byte-quick", "iput-char-quick",
+		"iput-short-quick", "iget-boolean-quick", "iget-byte-quick", "iget-char-quick", "iget-short-quick",
+		"invoke-virtual-quick", "invoke-virtual-quick/range", "invoke-super-quick",
+		"invoke-super-quick/range", "iput-object-volatile", "sget-object-volatile",
+		"sput-object-volatile", "packed-switch-payload", "sparse-switch-payload", "array-payload",
+		"invoke-polymorphic", "invoke-polymorphic/range", "invoke-custom", "invoke-custom/range",
+		"const-method-handle", "const-method-type"
+      ]
+    },
+
+    {
+      "type": "keyword2",
+      "keywords": [
+        "goto","goto/16","goto/32","if-eq","if-ne","if-lt","if-ge","if-gt","if-le","if-eqz",
+        "if-nez","if-ltz","if-gez","if-gtz","if-lez","return","return-void","return-wide",
+        "return-object","throw","packed-switch","sparse-switch"
+      ]
+    },
+    
+    // Access modifiers and declarations
+    {
+      "type": "keyword",
+      "regex": "(?<![\\./])\\b(build|runtime|system|value|name|names|accessFlags|public|private|protected|static|final|synchronized|volatile|bridge|transient|varargs|native|interface|abstract|strictfp|synthetic|annotation|enum|constructor|declared-synchronized|whitelist|greylist|blacklist|greylist-max-o|greylist-max-p|greylist-max-q|greylist-max-r|core-platform-api|test-api)\\b"
+    },
+
+    // ---------- Method header ----------
+    {
+      "type": "methodStart",
+      "regex": "^(\\s*)\\.method\\b"
+    },
+
+    // Primitive types
+    { "type": "type", "regex": "\\b(V|Z|B|S|C|I|J|F|D)\\b" },
+
+    // Object types
+    { "type": "type", "regex": "(?<=\\[|\\s|->|:|=|,|\\(|\\)|;)L[^;\\s]+;" },
+
+    // Array types
+    { "type": "type", "regex": "\\[+[^\\s\\]]" },
+
+    // Registers
+    { "type": "variable", "regex": "\\b[pv][0-9]+\\b" },
+
+    // ---------- Numbers with suffixes (decimal + hex) ----------
+    {
+      "type": "number",
+      "regex": "\\b(?:0x[0-9a-fA-F]+|-?\\d+(?:\\.\\d+)?)(?:[fFdDsSlLtT])?\\b"
+    },
+
+    // Labels
+    {
+	  "type": "label",
+	  "regex": "(?<=^|\\s|\\{|\\(|,|;)[:][a-zA-Z_][a-zA-Z0-9_$]*"
+	},
+
+    // Method or field name after ->
+    { "type": "operator", "regex": "(?<=->)[a-zA-Z_][a-zA-Z0-9_$<>]*" },
+
+    // Full references
+    {
+      "regex": "(L[a-zA-Z0-9_/]+;)->([a-zA-Z_][a-zA-Z0-9_$<>]*)(?:\\([^)]*\\))?([^\\s,]*)",
+      "groupStyles": { "1": "type", "2": "variable" }
+    },
+
+    // Operators
+    { "type": "operator", "regex": "->|:=|=|\\+|-|\\*|/|%|\\||&|\\^|<<|>>|>>>|<|>|<=|>=|==|!=|!|\\(|\\)|\\{|\\}|\\[|\\]|,|;|:" },
+
+    // Default
+    { "type": "default", "regex": "." }
+  ]
+}

package/android/src/main/assets/xml.json

@@ -0,0 +1,96 @@
+{
+  "name": ["XML", ".xml", ".kml", ".plist"],
+  "comment": { "startsWith": "<!--", "endsWith": "-->" },
+
+  "rules": [
+    // Comments (<!-- ... -->)
+    { "type": "comment", "regex": "<!--[\\s\\S]*?-->" },
+
+    // Opening tags with < and tag name (multi-line friendly)
+    {
+      "regex": "(<\\s*)([A-Za-z_][A-Za-z0-9:._\\-]*)",
+      "groupStyles": {
+        "1": "operator",
+        "2": "tagName"
+      }
+    },
+
+    // Closing tags with </ and >
+    {
+      "regex": "(</\\s*)([A-Za-z_][A-Za-z0-9:._\\-]*)(\\s*>)",
+      "groupStyles": {
+        "1": "operator",
+        "2": "tagName",
+        "3": "operator"
+      }
+    },
+
+    // Self-closing tags (<tag ... />)
+    {
+      "regex": "(<\\s*)([A-Za-z_][A-Za-z0-9:._\\-]*)([^>]*)(/?>)",
+      "groupStyles": {
+        "1": "operator",
+        "2": "tagName",
+        "4": "operator"
+      }
+    },
+
+    // XML declarations like <?xml version="1.0"?>
+    {
+      "regex": "(<\\?xml)([^?]*)(\\?>)",
+      "groupStyles": {
+        "1": "operator",
+        "2": "tagName",
+        "3": "operator"
+      }
+    },
+
+    // Namespaces (xmlns:android="...")
+    {
+      "regex": "(xmlns:)([A-Za-z0-9_\\-]+)",
+      "groupStyles": {
+        "1": "attrName",
+        "2": "namespace"
+      }
+    },
+
+    // Attribute names with optional namespace prefix
+    {
+      "regex": "(?:([A-Za-z0-9_\\-]+):)?([A-Za-z0-9_\\-]+)(?=\\s*=)",
+      "groupStyles": {
+        "1": "namespace",
+        "2": "attrName"
+      }
+    },
+
+    // Equal sign between name and value
+    { "type": "operator", "regex": "=" },
+
+    // Attribute values in quotes
+    {
+      "regex": "(?s)(['\"])(.*?)\\1",
+      "groupStyles": {
+        "0": "string",
+        "2": "propVal"
+      }
+    },
+
+    // Inline color codes (#RGB, #RRGGBB, #AARRGGBB)
+    {
+      "type": "number",
+      "regex": "(?<![;&])#(?:[A-Fa-f0-9]{3}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})\\b"
+    },
+
+    // Booleans
+    { "type": "number", "regex": "\\b(true|false)\\b" },
+
+    // Entities (&amp;, &lt;, etc.)
+    { "type": "constant", "regex": "&[A-Za-z]+;" },
+
+    // Operators like <, >, /, ?, :
+    { "type": "operator", "regex": "</?|/?>|:|\\?" },
+
+    // Default fallback
+    { "type": "default", "regex": "." }
+  ]
+}

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

@@ -1,7 +1,13 @@
 package com.aetherlink.dexeditor;
 
+import android.app.Activity;
+import android.content.Intent;
 import android.util.Log;
 
+import androidx.activity.result.ActivityResult;
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts;
+
 import com.getcapacitor.JSObject;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
@@ -18,8 +24,10 @@ import org.json.JSONObject;
 public class DexEditorPluginPlugin extends Plugin {
 
     private static final String TAG = "DexEditorPlugin";
+    private static final int REQUEST_SMALI_EDITOR = 1001;
     private final DexManager dexManager = new DexManager();
     private final ApkManager apkManager = new ApkManager();
+    private PluginCall pendingEditorCall;
 
     @Override
     public void load() {
@@ -538,6 +546,25 @@ public class DexEditorPluginPlugin extends Plugin {
                 ));
                 break;
 
+            case "listApkFiles":
+                result.put("data", dexManager.listApkFiles(
+                    params.getString("apkPath"),
+                    params.optString("filter", ""),
+                    params.optInt("limit", 100),
+                    params.optInt("offset", 0)
+                ));
+                break;
+
+            case "readApkFile":
+                result.put("data", dexManager.readApkFile(
+                    params.getString("apkPath"),
+                    params.getString("filePath"),
+                    params.optBoolean("asBase64", false),
+                    params.optInt("maxBytes", 0),
+                    params.optInt("offset", 0)
+                ));
+                break;
+
             default:
                 result.put("success", false);
                 result.put("error", "Unknown action: " + action);
@@ -545,4 +572,44 @@ public class DexEditorPluginPlugin extends Plugin {
 
         return result;
     }
+
+    /**
+     * 打开原生 Smali 编辑器
+     */
+    @PluginMethod
+    public void openSmaliEditor(PluginCall call) {
+        String content = call.getString("content", "");
+        String title = call.getString("title", "Smali Editor");
+        String className = call.getString("className", "");
+        boolean readOnly = call.getBoolean("readOnly", false);
+
+        pendingEditorCall = call;
+
+        Intent intent = new Intent(getContext(), SmaliEditorActivity.class);
+        intent.putExtra(SmaliEditorActivity.EXTRA_CONTENT, content);
+        intent.putExtra(SmaliEditorActivity.EXTRA_TITLE, title);
+        intent.putExtra(SmaliEditorActivity.EXTRA_CLASS_NAME, className);
+        intent.putExtra(SmaliEditorActivity.EXTRA_READ_ONLY, readOnly);
+
+        startActivityForResult(call, intent, "handleEditorResult");
+    }
+
+    @Override
+    protected void handleOnActivityResult(int requestCode, int resultCode, Intent data) {
+        super.handleOnActivityResult(requestCode, resultCode, data);
+
+        if (pendingEditorCall != null) {
+            JSObject result = new JSObject();
+            if (resultCode == Activity.RESULT_OK && data != null) {
+                result.put("success", true);
+                result.put("content", data.getStringExtra(SmaliEditorActivity.RESULT_CONTENT));
+                result.put("modified", data.getBooleanExtra(SmaliEditorActivity.RESULT_MODIFIED, false));
+            } else {
+                result.put("success", false);
+                result.put("cancelled", true);
+            }
+            pendingEditorCall.resolve(result);
+            pendingEditorCall = null;
+        }
+    }
 }