...

Author: efraespada

src/main/kotlin/StringCare.kt

@@ -23,7 +23,7 @@ open class StringCare : Plugin<Project> {
         absoluteProjectPath = project.absolutePath()
 
         this.project.afterEvaluate {
-            extension.modules?.forEach { module ->
+            extension.modules.forEach { module ->
                 when {
                     module.stringFiles.isNotEmpty() && module.srcFolders.isNotEmpty() -> {
                         moduleMap[module.name!!] = Configuration(module.name).apply {

src/main/kotlin/components/Extensions.kt

@@ -3,10 +3,12 @@ package components
 import StringCare.*
 import groovy.json.StringEscapeUtils
 import models.ResourceFile
+import org.apache.xerces.dom.DeferredElementImpl
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.internal.plugins.DslObject
 import org.w3c.dom.Document
+import org.w3c.dom.Node
 import org.xml.sax.InputSource
 import java.io.*
 import javax.xml.parsers.DocumentBuilderFactory
@@ -156,7 +158,6 @@ fun File.removeHiddenAttributes() {
     val content = this.getContent()
         .replace("hidden=\"true\"", "")
         .replace("hidden=\"false\"", "")
-        .replace("hidden", "")
     FileWriter(this.absolutePath).use { it.write(content) }
     updateXML(this.getXML())
 }
@@ -191,4 +192,38 @@ fun Task.onMergeResourcesStartsVariant(): String = this.name.substring(merge.len
 fun Task.onMergeResourcesFinishVariant(): String = this.name.substring(merge.length)
     .substring(0, this.name.substring(merge.length).length - resources.length)
 
+fun Node.extractHtml(): String {
+    val stringBuilder = StringBuilder()
+    for (i in 0 until this.childNodes.length) {
+        val item = this.childNodes.item(i)
+        val type = item.getType()
+        when (type) {
+            StringType.BR -> stringBuilder.append("<br>${item.textContent}</br>")
+            StringType.I -> stringBuilder.append("<i>${item.textContent}</i>")
+            StringType.STRONG -> stringBuilder.append("<strong>${item.textContent}</strong>")
+            StringType.TEXT -> stringBuilder.append(item.textContent)
+        }
+
+    }
+    return stringBuilder.toString()
+}
+
+enum class StringType {
+    BR,
+    TEXT,
+    I,
+    STRONG
+}
+
+fun Node.getType(): StringType {
+    return when {
+        this.toString().contains("[br:") -> StringType.BR
+        this.toString().contains("[i:") -> StringType.I
+        this.toString().contains("[strong:") -> StringType.STRONG
+        this.toString().contains("[#text") -> StringType.TEXT
+        else -> StringType.TEXT
+    }
+}
 
+// [#text:
+//        ]

src/main/kotlin/components/Stark.kt

@@ -37,15 +37,16 @@ open class Stark {
             when {
                 dir.toString().endsWith(".jar") -> {
                     val jar = File(dir)
-                    val zip = File(jar.absolutePath.replace(".jar", ".zip"))
+                    val zipFile = File(jar.absolutePath.replace(".jar", ".zip"))
 
-                    jar.copyTo(zip, true)
+                    jar.copyTo(zipFile, true)
 
-                    ZipFile(zip.absolutePath).use { zip ->
+                    ZipFile(zipFile.absolutePath).use { zip ->
                         zip.entries().asSequence().forEach { entry ->
                             zip.getInputStream(entry).use { input ->
                                 if (entry.name == fileName) {
-                                    lib = File(entry.name).apply {
+
+                                    lib = File("$resourceBackup${File.separator}${entry.name}").apply {
                                         this.outputStream().use { output ->
                                             input.copyTo(output)
                                         }

src/main/kotlin/components/XParser.kt

@@ -27,6 +27,7 @@ fun restoreFiles(projectPath: String, module: String): List<File> {
     }.map {
         it.restore(projectPath)
     }
+    File("$projectPath${File.separator}$resourceBackup").deleteRecursively()
     return resourceFiles
 }
 
@@ -41,6 +42,7 @@ fun parseXML(file: File): List<StringEntity> {
         val attributes = mutableListOf<SAttribute>()
         var obfuscate = false
         var androidTreatment = true
+        var containsHtml = false
         for (a in 0 until node.attributes.length) {
             val attribute = node.attributes.item(a)
             for (n in 0 until attribute.childNodes.length) {
@@ -53,11 +55,17 @@ fun parseXML(file: File): List<StringEntity> {
                 if (attribute.nodeName == "androidTreatment" && attr.nodeValue == "false") {
                     androidTreatment = false
                 }
+                if (attribute.nodeName == "containsHtml" && attr.nodeValue != "false") {
+                    containsHtml = true
+                }
                 attributes.add(SAttribute(attribute.nodeName, attr.nodeValue))
             }
         }
         if (obfuscate) {
-            entities.add(StringEntity(name, attributes, node.textContent, "string", i, androidTreatment))
+            entities.add(StringEntity(name, attributes, when {
+                containsHtml -> node.extractHtml()
+                else -> node.textContent
+            }, "string", i, androidTreatment))
         }
     }
     return entities

src/main/kotlin/models/StringEntity.kt

@@ -6,7 +6,7 @@ class StringEntity(
     var value: String,
     val tag: String,
     val index: Int,
-    val androidTreatment: Boolean = false
+    val androidTreatment: Boolean = true
 )
 
 data class SAttribute(val name: String, val value: String)