Optimize build-time memory usage in string processing (#25)

Refactored StringRegistryImpl and DeobfuscatorGenerator to use a streaming approach for handling obfuscated string chunks.

Author: androidacy-user

processor/src/main/kotlin/org/lsposed/lsparanoid/processor/DeobfuscatorGenerator.kt

@@ -70,19 +70,32 @@ class DeobfuscatorGenerator(
 
   private fun ClassVisitor.generateStaticInitializer() {
     newMethod(Opcodes.ACC_STATIC, METHOD_STATIC_INITIALIZER) {
-      val chunks = stringRegistry.getAllChunks()
-      push(chunks.size)
+      val chunkCount = stringRegistry.getChunkCount()
+      push(chunkCount)
       newArray(CHUNKS_ELEMENT_TYPE)
+      // Store the new array into the static field
       putStatic(deobfuscator.type.toAsmType(), CHUNKS_FIELD_NAME, CHUNKS_FIELD_TYPE)
 
-      getStatic(deobfuscator.type.toAsmType(), CHUNKS_FIELD_NAME, CHUNKS_FIELD_TYPE)
-      chunks.forEachIndexed { index, chunk ->
-        dup()
-        push(index)
-        push(chunk)
-        arrayStore(CHUNKS_ELEMENT_TYPE)
+      // If there are chunks to add, load the field back onto the stack
+      if (chunkCount > 0) {
+        getStatic(deobfuscator.type.toAsmType(), CHUNKS_FIELD_NAME, CHUNKS_FIELD_TYPE)
+        var index = 0
+        stringRegistry.streamChunks { chunk ->
+          dup() // Duplicate the array reference
+          push(index) // Push the index
+          push(chunk) // Push the chunk string
+          arrayStore(CHUNKS_ELEMENT_TYPE) // Store the chunk in the array
+          index++
+        }
+        // Pop the array reference that was loaded by getStatic (if chunkCount > 0)
+        // and duplicated in the loop. The original putStatic already stored it.
+        // If streamChunks did nothing (e.g. 0 chunks), this pop is not needed as getStatic wasn't called.
+        // However, the structure with index ensures it's balanced if chunks were processed.
+        // If chunkCount > 0, one array reference remains on stack after loop.
+        pop()
       }
-      pop()
+      // Ensure stack is balanced: if chunkCount was 0, no putStatic/getStatic/pop happened here.
+      // If chunkCount > 0, array was putStatic, then getStatic, then loop, then pop. Correct.
     }
   }
 

processor/src/main/kotlin/org/lsposed/lsparanoid/processor/StringRegistry.kt

@@ -22,7 +22,12 @@ import org.lsposed.lsparanoid.RandomHelper
 
 interface StringRegistry {
   fun registerString(string: String): Long
+
+  @Deprecated("Use streamChunks for better memory efficiency", ReplaceWith("streamChunks(consumer)"))
   fun getAllChunks(): List<String>
+
+  fun streamChunks(consumer: (String) -> Unit)
+  fun getChunkCount(): Int
 }
 
 class StringRegistryImpl(
@@ -53,7 +58,34 @@ class StringRegistryImpl(
     return id
   }
 
+  @Deprecated("Use streamChunks for better memory efficiency", ReplaceWith("streamChunks(consumer)"))
   override fun getAllChunks(): List<String> {
-    return builder.toString().chunked(DeobfuscatorHelper.MAX_CHUNK_LENGTH)
+    // This implementation remains for compatibility but should not be used for large datasets.
+    val chunks = mutableListOf<String>()
+    streamChunks { chunks.add(it) }
+    return chunks
+  }
+
+  override fun streamChunks(consumer: (String) -> Unit) {
+    val totalLength = builder.length
+    if (totalLength == 0) {
+      return
+    }
+    var currentIndex = 0
+    while (currentIndex < totalLength) {
+      val endIndex = kotlin.math.min(currentIndex + DeobfuscatorHelper.MAX_CHUNK_LENGTH, totalLength)
+      // Substring still creates a new string, but it's one chunk at a time
+      // instead of builder.toString() creating one giant string first.
+      consumer(builder.substring(currentIndex, endIndex))
+      currentIndex = endIndex
+    }
+  }
+
+  override fun getChunkCount(): Int {
+    val totalLength = builder.length
+    if (totalLength == 0) {
+      return 0
+    }
+    return (totalLength + DeobfuscatorHelper.MAX_CHUNK_LENGTH - 1) / DeobfuscatorHelper.MAX_CHUNK_LENGTH
   }
 }