feat(smalikit): add idempotent method append support and migrate HTMLViewer patch flow

SmaliKit enhancements:

- Add new append_method argument to SmaliArgs in both runtime paths (src/utils and core modifiers) to keep argument contracts aligned.

- Extend SmaliKit initialization to allow append-only operations without requiring method/seek filters.

- Implement append_method processing that appends method blocks only when the signature is missing, preserving idempotency.

- Expose append support in CLI via -am METHOD_SIGNATURE METHOD_BODY.

HTMLViewer refactor:

- Replace manual full-file regex rewrite in htmlviewer plugin with standard smali_patch flow.

- Keep doInBackground rewrite in SmaliKit (method+return_type+remake) and add helper method through append_method.

- Reuse shared _find_file helper from ApkModifierPlugin and remove plugin-local duplicate search logic.

- Remove now-unused imports tied to manual regex patching.

Tests:

- Add tests/utils/test_smalikit.py covering append_method behavior for both missing-signature append and existing-signature no-op paths.

Author: toraidl

src/core/modifiers/plugins/apk/htmlviewer.py

@@ -1,8 +1,6 @@
 """HTMLViewer modification plugin for EU ROMs."""
 
-import re
 from pathlib import Path
-from typing import Optional
 
 from src.core.modifiers.plugins.apk.base import ApkModifierPlugin, ApkModifierRegistry
 
@@ -35,7 +33,7 @@ def _apply_patches(self, work_dir: Path):
         self._patch_device_info_utils(work_dir)
 
     def _patch_device_info_utils(self, work_dir: Path):
-        smali_file = self._find_smali_file(work_dir, "MiuiDeviceInfoUtils$AsyncTask.smali")
+        smali_file = self._find_file(work_dir, "MiuiDeviceInfoUtils$AsyncTask.smali")
 
         if not smali_file:
             self.logger.warning("MiuiDeviceInfoUtils$AsyncTask.smali not found")
@@ -49,8 +47,7 @@ def _patch_device_info_utils(self, work_dir: Path):
 
         self.logger.info("Patching MiuiDeviceInfoUtils$AsyncTask.smali...")
 
-        new_method = """.method protected varargs doInBackground([Landroid/util/Pair;)Ljava/lang/Object;
-    .locals 16
+        do_in_background_remake = """.locals 16
     .annotation system Ldalvik/annotation/Signature;
         value = {
             "([",
@@ -265,7 +262,6 @@ def _patch_device_info_utils(self, work_dir: Path):
     move-object/from16 v5, p0
     :goto_a
     return-object v4
-.end method
 """
 
         helper_method = """.method private getLocalizedValue(Ljava/lang/Object;)Ljava/lang/String;
@@ -314,20 +310,18 @@ def _patch_device_info_utils(self, work_dir: Path):
 .end method
 """
 
-        old_method_pattern = (
-            r"\.method protected varargs doInBackground\(\[Landroid/util/Pair;\)Ljava/lang/Object;.*?"
-            r"\.end method"
+        helper_signature = "getLocalizedValue(Ljava/lang/Object;)Ljava/lang/String;"
+        self.smali_patch(
+            work_dir,
+            file_path=str(smali_file),
+            method="doInBackground",
+            return_type="Ljava/lang/Object;",
+            remake=do_in_background_remake,
+        )
+        self.smali_patch(
+            work_dir,
+            file_path=str(smali_file),
+            append_method=(helper_signature, helper_method),
         )
 
-        replacement = f"{new_method}{helper_method}"
-
-        content = re.sub(old_method_pattern, replacement, content, flags=re.DOTALL)
-
-        smali_file.write_text(content, encoding="utf-8")
         self.logger.info("Patched MiuiDeviceInfoUtils$AsyncTask.smali successfully")
-
-    def _find_smali_file(self, work_dir: Path, filename: str) -> Optional[Path]:
-        for smali_dir in work_dir.glob("smali*"):
-            for f in smali_dir.rglob(filename):
-                return f
-        return None

src/core/modifiers/smali_args.py

@@ -20,5 +20,6 @@ def __init__(self, **kwargs):
         self.insert_line = None
         self.recursive = False
         self.return_type = None
+        self.append_method = None
 
         self.__dict__.update(kwargs)

src/utils/smalikit.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-import os
-import sys
-import re
 import argparse
 import logging
+import os
+import re
+import sys
 
 
 class SmaliArgs:
@@ -25,6 +25,7 @@ def __init__(self, **kwargs):
         self.insert_line = None
         self.recursive = False
         self.return_type = None
+        self.append_method = None
 
         # Override default values with passed keyword arguments
         self.__dict__.update(kwargs)
@@ -45,6 +46,7 @@ def __init__(self, args, logger=None):
         self.args = args
         self.target_method = args.method
         self.seek_keyword = args.seek_keyword
+        self.append_method = getattr(args, "append_method", None)
         self.logger = logger or logging.getLogger("SmaliKit")
 
         # 1. If -m is specified, method name match must be satisfied first
@@ -61,17 +63,46 @@ def __init__(self, args, logger=None):
         elif self.seek_keyword:
             method_name_pattern = r".*?"
 
+        # 3. Allow file-level append without method targeting
+        elif self.append_method:
+            method_name_pattern = None
+
         else:
             self.logger.error("You must provide either -m (Method Name) or -seek (Keyword search)")
             sys.exit(1)
 
         # Compile regex
-        self.method_pattern = re.compile(
-            r"(?P<header>^\s*\.method[^\n\r]*?\s%s[^\n\r]*)"
-            r"(?P<body>.*?)"
-            r"(?P<footer>^\s*\.end method)" % method_name_pattern,
-            re.DOTALL | re.MULTILINE,
-        )
+        if method_name_pattern is None:
+            self.method_pattern = None
+        else:
+            self.method_pattern = re.compile(
+                r"(?P<header>^\s*\.method[^\n\r]*?\s%s[^\n\r]*)"
+                r"(?P<body>.*?)"
+                r"(?P<footer>^\s*\.end method)" % method_name_pattern,
+                re.DOTALL | re.MULTILINE,
+            )
+
+    def _apply_append_method(self, content):
+        append_spec = self.append_method
+        if not append_spec:
+            return content, False
+
+        if not isinstance(append_spec, (tuple, list)) or len(append_spec) != 2:
+            self.log("[ERROR] append_method must be a (signature, method_block) pair", Colors.FAIL)
+            return content, False
+
+        method_signature, method_block = append_spec
+        if not method_signature or not method_block:
+            self.log("[ERROR] append_method signature/method_block cannot be empty", Colors.FAIL)
+            return content, False
+
+        if method_signature in content:
+            return content, False
+
+        normalized_block = method_block.replace("\\n", "\n").strip("\n")
+        new_content = f"{content.rstrip()}\n\n{normalized_block}\n"
+        self.log(f"  -> [SUCCESS] Appended method: {method_signature}", Colors.OKGREEN)
+        return new_content, True
 
     def log(self, message, color=Colors.ENDC):
         # Log to the logger, stripping color codes if it's going to a file (optional)
@@ -159,10 +190,7 @@ def apply_modifications(self, original_body):
         return new_body, is_modified
 
     def process_content(self, content, file_path):
-        matches = list(self.method_pattern.finditer(content))
-
-        if not matches:
-            return content, False
+        matches = list(self.method_pattern.finditer(content)) if self.method_pattern else []
 
         file_modified = False
         replacements = []
@@ -188,7 +216,7 @@ def process_content(self, content, file_path):
             )
 
             if self.args.delete_method:
-                self.log(f"  -> Applying -dm (Delete Method)...", Colors.FAIL)
+                self.log("  -> Applying -dm (Delete Method)...", Colors.FAIL)
                 replacements.append((full_block, ""))
                 file_modified = True
                 continue
@@ -205,7 +233,8 @@ def process_content(self, content, file_path):
         for old, new in replacements:
             new_content = new_content.replace(old, new, 1)
 
-        return new_content, file_modified
+        new_content, appended = self._apply_append_method(new_content)
+        return new_content, file_modified or appended
 
     def walk_and_patch(self, start_path):
         if os.path.isfile(start_path):
@@ -281,6 +310,13 @@ def main():
     parser.add_argument(
         "-ret", dest="return_type", help="Filter by Smali return type (e.g. Z, V, I)"
     )
+    parser.add_argument(
+        "-am",
+        dest="append_method",
+        nargs=2,
+        metavar=("METHOD_SIGNATURE", "METHOD_BODY"),
+        help="Append method if METHOD_SIGNATURE does not exist",
+    )
 
     args, unknown = parser.parse_known_args()
 

tests/utils/test_smalikit.py

@@ -0,0 +1,57 @@
+import logging
+
+from src.utils.smalikit import SmaliArgs, SmaliKit
+
+
+def test_append_method_when_missing():
+    content = """
+.class public Lcom/example/Test;
+.super Ljava/lang/Object;
+
+.method public test()V
+    .locals 0
+    return-void
+.end method
+""".strip()
+    signature = "getLocalizedValue(Ljava/lang/Object;)Ljava/lang/String;"
+    method_block = """
+.method private getLocalizedValue(Ljava/lang/Object;)Ljava/lang/String;
+    .locals 1
+    const-string v0, ""
+    return-object v0
+.end method
+""".strip()
+
+    args = SmaliArgs(append_method=(signature, method_block))
+    patcher = SmaliKit(args, logger=logging.getLogger("test.smalikit"))
+
+    new_content, patched = patcher.process_content(content, "Test.smali")
+
+    assert patched is True
+    assert signature in new_content
+    assert new_content.count(".method private getLocalizedValue") == 1
+
+
+def test_append_method_skips_when_exists():
+    signature = "getLocalizedValue(Ljava/lang/Object;)Ljava/lang/String;"
+    existing_method = """
+.method private getLocalizedValue(Ljava/lang/Object;)Ljava/lang/String;
+    .locals 1
+    const-string v0, ""
+    return-object v0
+.end method
+""".strip()
+    content = f"""
+.class public Lcom/example/Test;
+.super Ljava/lang/Object;
+
+{existing_method}
+""".strip()
+
+    args = SmaliArgs(append_method=(signature, existing_method))
+    patcher = SmaliKit(args, logger=logging.getLogger("test.smalikit"))
+
+    new_content, patched = patcher.process_content(content, "Test.smali")
+
+    assert patched is False
+    assert new_content == content