feat(Translations): Translations for YouTube and Twitch

build.gradle.kts

@@ -81,6 +81,21 @@ tasks {
         dependsOn("generateBundle")
         dependsOn("generateMeta")
     }
+    register<JavaExec>("generateMergedStrings") {
+        description = "Generate a merged English strings.xml file used for Crowdin translations"
+        dependsOn(build)
+
+        classpath = sourceSets["main"].runtimeClasspath
+        mainClass = "app.revanced.util.resources.ResourceUtils"
+        args = listOf(
+            // YouTube
+            "src/main/resources/youtube/settings/host/values/",
+            "src/main/resources/youtube/settings/raw/strings.xml",
+            // Twitch
+            "src/main/resources/twitch/settings/host/values/",
+            "src/main/resources/twitch/settings/raw/strings.xml"
+        )
+    }
 }
 
 publishing {

src/main/kotlin/app/revanced/patches/shared/settings/AbstractSettingsResourcePatch.kt

@@ -1,16 +1,17 @@
 package app.revanced.patches.shared.settings
 
 import app.revanced.patcher.data.ResourceContext
+import app.revanced.patcher.patch.PatchException
 import app.revanced.patcher.patch.ResourcePatch
 import app.revanced.patcher.util.DomFileEditor
 import app.revanced.patches.shared.settings.preference.BasePreference
 import app.revanced.patches.shared.settings.preference.BaseResource
 import app.revanced.patches.shared.settings.preference.addPreference
 import app.revanced.patches.shared.settings.preference.addResource
 import app.revanced.patches.shared.settings.preference.impl.ArrayResource
-import app.revanced.patches.shared.settings.preference.impl.StringResource
 import app.revanced.util.resources.ResourceUtils
 import app.revanced.util.resources.ResourceUtils.copyResources
+import org.w3c.dom.Document
 import org.w3c.dom.Node
 import java.io.Closeable
 
@@ -56,7 +57,7 @@ abstract class AbstractSettingsResourcePatch(
         private var stringsNode: Node? = null
         private var arraysNode: Node? = null
 
-        private var strings = mutableListOf<StringResource>()
+        private var strings = mutableMapOf<String, StringResource>()
 
         private var revancedPreferencesEditor: DomFileEditor? = null
             set(value) {
@@ -75,7 +76,7 @@ abstract class AbstractSettingsResourcePatch(
             }
 
         /**
-         * Add a new string to the resources.
+         * Add a new English string to the resources.
          *
          * @param identifier The key of the string.
          * @param value The value of the string.
@@ -84,6 +85,20 @@ abstract class AbstractSettingsResourcePatch(
         fun addString(identifier: String, value: String, formatted: Boolean) =
             StringResource(identifier, value, formatted).include()
 
+        /**
+         * Verifies a String resource with the given key has been merged.
+         *
+         * Should be used everywhere a String resource is referenced,
+         * as missing resources will fail to compile and usually give no feedback to what's wrong.
+         *
+         * @throws PatchException
+         */
+        internal fun validateStringIsMerged(key: String): String {
+            if (!strings.contains(key))
+                throw PatchException("Unknown String resource: '$key'  Merge patch strings before referencing.")
+            return key
+        }
+
         /**
          * Add an array to the resources.
          *
@@ -108,10 +123,10 @@ abstract class AbstractSettingsResourcePatch(
         internal fun BaseResource.include() {
             when (this) {
                 is StringResource -> {
-                    if (strings.any { it.name == name }) return
-                    strings.add(this)
+                    if (strings.put(name, this) != null) {
+                        throw PatchException("Tried to add duplicate string: $name")
+                    }
                 }
-
                 is ArrayResource -> addArray(this)
                 else -> throw NotImplementedError("Unsupported resource type")
             }
@@ -122,12 +137,34 @@ abstract class AbstractSettingsResourcePatch(
 
     override fun close() {
         // merge all strings, skip duplicates
-        strings.forEach {
+        strings.values.forEach {
             stringsNode!!.addResource(it)
         }
 
         revancedPreferencesEditor?.close()
         stringsEditor?.close()
         arraysEditor?.close()
     }
+}
+
+/**
+ * Legacy code used to merge non translated English strings into the Strings.xml file.
+ *
+ * @param name The name of the string.
+ * @param value The value of the string.
+ * @param formatted If the string is formatted. If false, the attribute will be set.
+ */
+private class StringResource(
+    name: String,
+    val value: String,
+    val formatted: Boolean = true
+) : BaseResource(name, "string") {
+
+    override fun serialize(ownerDocument: Document, resourceCallback: (BaseResource) -> Unit) =
+        super.serialize(ownerDocument, resourceCallback).apply {
+            // if the string is un-formatted, explicitly add the formatted attribute
+            if (!formatted) setAttribute("formatted", "false")
+
+            textContent = value
+        }
 }

src/main/kotlin/app/revanced/patches/shared/settings/preference/BasePreference.kt

@@ -1,21 +1,22 @@
 package app.revanced.patches.shared.settings.preference
 
-import app.revanced.patches.shared.settings.preference.impl.StringResource
+import app.revanced.patches.shared.settings.AbstractSettingsResourcePatch
+import app.revanced.patches.shared.settings.AbstractSettingsResourcePatch.Companion.validateStringIsMerged
 import org.w3c.dom.Document
 import org.w3c.dom.Element
 
 /**
  * Base preference class for all preferences.
  *
  * @param key The key of the preference.
- * @param title The title of the preference.
+ * @param titleKey The title of the preference.
  * @param tag The tag of the preference.
- * @param summary The summary of the preference.
+ * @param summaryKey The summary of the preference.
  */
 abstract class BasePreference(
     val key: String?,
-    val title: StringResource,
-    val summary: StringResource? = null,
+    val titleKey: String,
+    val summaryKey: String? = null,
     val tag: String
 ) {
     /**
@@ -28,7 +29,7 @@ abstract class BasePreference(
     open fun serialize(ownerDocument: Document, resourceCallback: (BaseResource) -> Unit): Element =
         ownerDocument.createElement(tag).apply {
             if (key != null) setAttribute("android:key", key)
-            setAttribute("android:title", "@string/${title.also { resourceCallback.invoke(it) }.name}")
-            addSummary(summary?.also { resourceCallback.invoke(it) })
+            setAttribute("android:title", "@string/${validateStringIsMerged(titleKey)}")
+            addSummary(summaryKey)
         }
 }

src/main/kotlin/app/revanced/patches/shared/settings/preference/ComponentsExtensions.kt

@@ -1,6 +1,7 @@
 package app.revanced.patches.shared.settings.preference
 
-import app.revanced.patches.shared.settings.preference.impl.StringResource
+import app.revanced.patches.shared.settings.AbstractSettingsResourcePatch
+import app.revanced.patches.shared.settings.AbstractSettingsResourcePatch.Companion.validateStringIsMerged
 import org.w3c.dom.Element
 import org.w3c.dom.Node
 
@@ -24,10 +25,11 @@ internal fun Node.addPreference(preference: BasePreference, resourceCallback: ((
     appendChild(preference.serialize(ownerDocument, resourceCallback))
 }
 
-internal fun Element.addSummary(summaryResource: StringResource?, summaryType: SummaryType = SummaryType.DEFAULT) =
-    summaryResource?.let { summary ->
-        setAttribute("android:${summaryType.type}", "@string/${summary.name}")
+internal fun Element.addSummary(summaryResourceKey: String?, summaryType: SummaryType = SummaryType.DEFAULT)  {
+    if (summaryResourceKey != null) {
+        setAttribute("android:${summaryType.type}", "@string/${validateStringIsMerged(summaryResourceKey)}")
     }
+}
 
 internal fun <T> Element.addDefault(default: T) {
     if (default is Boolean && !(default as Boolean)) return // No need to include the default, as no value already means 'false'

src/main/kotlin/app/revanced/patches/shared/settings/preference/DefaultBasePreference.kt

@@ -1,24 +1,23 @@
 package app.revanced.patches.shared.settings.preference
 
-import app.revanced.patches.shared.settings.preference.impl.StringResource
 import org.w3c.dom.Document
 
 /**
  * Base preference class that also has a default value.
  *
  * @param key The key of the preference.
- * @param title The title of the preference.
+ * @param titleKey The title of the preference.
  * @param tag The tag of the preference.
- * @param summary The summary of the preference.
+ * @param summaryKey The summary of the preference.
  * @param default The default value of the preference.
  */
 abstract class DefaultBasePreference<T>(
     key: String?,
-    title: StringResource,
-    summary: StringResource? = null,
+    titleKey: String,
+    summaryKey: String? = null,
     tag: String,
     val default: T? = null,
-) : BasePreference(key, title, summary, tag) {
+) : BasePreference(key, titleKey, summaryKey, tag) {
 
     /**
      * Serialize preference element to XML.

src/main/kotlin/app/revanced/patches/shared/settings/preference/impl/ArrayResource.kt

@@ -1,28 +1,30 @@
 package app.revanced.patches.shared.settings.preference.impl
 
+import app.revanced.patches.shared.settings.AbstractSettingsResourcePatch.Companion.validateStringIsMerged
 import app.revanced.patches.shared.settings.preference.BaseResource
 import org.w3c.dom.Document
 
-// TODO: allow specifying an array resource file instead of using a list of StringResources
 /**
  *  An array resource.
  *
  *  @param name The name of the array resource.
  *  @param items The items of the array resource.
+ *  @param literalValues If the values are to be used exactly as is.
+ *                       If false, the values are treated as Strings.xml entries.
  */
 class ArrayResource(
     name: String,
-    val items: List<StringResource>
+    val items: Iterable<String>,
+    val literalValues : Boolean = false
 ) : BaseResource(name, "string-array") {
+
     override fun serialize(ownerDocument: Document, resourceCallback: (BaseResource) -> Unit) =
         super.serialize(ownerDocument, resourceCallback).apply {
             setAttribute("name", name)
 
             items.forEach { item ->
-                resourceCallback.invoke(item)
-
                 this.appendChild(ownerDocument.createElement("item").also { itemNode ->
-                    itemNode.textContent = "@string/${item.name}"
+                    itemNode.textContent = if (literalValues) item else "@string/${validateStringIsMerged(item)}"
                 })
             }
         }

src/main/kotlin/app/revanced/patches/shared/settings/preference/impl/ListPreference.kt

@@ -9,24 +9,29 @@ import org.w3c.dom.Document
  * List preference.
  *
  * @param key The key of the list preference.
- * @param title The title of the list preference.
+ * @param titleKey The title of the list preference.
  * @param entries The human-readable entries of the list preference.
  * @param entryValues The entry values of the list preference.
- * @param summary The summary of the list preference.
+ * @param summaryKey The summary of the list preference.
  * @param default The default entry value of the list preference.
  */
 class ListPreference(
     key: String,
-    title: StringResource,
-    val entries: ArrayResource,
-    val entryValues: ArrayResource,
-    summary: StringResource? = null,
+    titleKey: String,
+    val entries: ArrayResource?,
+    val entryValues: ArrayResource?,
+    summaryKey: String? = null,
     default: String? = null,
-) : DefaultBasePreference<String>(key, title, summary, "ListPreference", default) {
+) : DefaultBasePreference<String>(key, titleKey, summaryKey, "ListPreference", default) {
+
     override fun serialize(ownerDocument: Document, resourceCallback: (BaseResource) -> Unit) =
         super.serialize(ownerDocument, resourceCallback).apply {
-            setAttribute("android:entries", "@array/${entries.also { resourceCallback.invoke(it) }.name}")
-            setAttribute("android:entryValues", "@array/${entryValues.also { resourceCallback.invoke(it) }.name}")
-            addSummary(summary)
+            if (entries != null) {
+                setAttribute("android:entries", "@array/${entries.also { resourceCallback.invoke(it) }.name}")
+            }
+            if (entryValues != null) {
+                setAttribute("android:entryValues", "@array/${entryValues.also { resourceCallback.invoke(it) }.name}")
+            }
+            addSummary(summaryKey)
         }
 }

src/main/kotlin/app/revanced/patches/shared/settings/preference/impl/NonInteractivePreference.kt

@@ -12,16 +12,16 @@ import org.w3c.dom.Element
  * Not backed by any preference key/value,
  * and cannot be changed by or interacted with by the user.
  *
- * @param title The title of the preference.
- * @param summary The summary of the text preference.
+ * @param titleKey The title of the preference.
+ * @param summaryKey The summary of the text preference.
  */
 class NonInteractivePreference(
-    title: StringResource,
-    summary: StringResource,
-) : BasePreference(null, title, summary, "Preference") {
+    titleKey: String,
+    summaryKey: String,
+) : BasePreference(null, titleKey, summaryKey, "Preference") {
     override fun serialize(ownerDocument: Document, resourceCallback: (BaseResource) -> Unit): Element {
         return super.serialize(ownerDocument, resourceCallback).apply {
-            addSummary(summary?.also { resourceCallback.invoke(it)
+            addSummary(summaryKey?.also {
                 setAttribute("android:selectable", false.toString())
             })
         }

src/main/kotlin/app/revanced/patches/shared/settings/preference/impl/Preference.kt

@@ -8,21 +8,22 @@ import org.w3c.dom.Document
  * A preference object.
  *
  * @param key The key of the preference.
- * @param title The title of the preference.
- * @param summary The summary of the text preference.
+ * @param titleKey The title of the preference.
+ * @param summaryKey The summary of the text preference.
  * @param intent The intent of the preference.
  */
 class Preference(
     key: String,
-    title: StringResource,
-    summary: StringResource,
+    titleKey: String,
+    summaryKey: String,
     val intent: Intent
-) : BasePreference(key, title, summary, "Preference") {
+) : BasePreference(key, titleKey, summaryKey, "Preference") {
+
     constructor(
-        title: StringResource,
-        summary: StringResource,
+        titleKey: String,
+        summaryKey: String,
         intent: Intent
-    ) : this("", title, summary, intent)
+    ) : this("", titleKey, summaryKey, intent)
 
     override fun serialize(ownerDocument: Document, resourceCallback: (BaseResource) -> Unit) =
         super.serialize(ownerDocument, resourceCallback).apply {

src/main/kotlin/app/revanced/patches/shared/settings/preference/impl/PreferenceCategory.kt

@@ -8,15 +8,16 @@ import org.w3c.dom.Document
  * A preference category.
  *
  * @param key The key of the preference.
- * @param title The title of the preference.
+ * @param titleKey The title of the preference.
  * @param preferences Child preferences of this category.
  */
 open class PreferenceCategory(
     key: String,
-    title: StringResource,
+    titleKey: String,
     var preferences: List<BasePreference>,
     tag: String = "PreferenceCategory"
-) : BasePreference(key, title, null, tag) {
+) : BasePreference(key, titleKey, null, tag) {
+
     override fun serialize(ownerDocument: Document, resourceCallback: (BaseResource) -> Unit) =
         super.serialize(ownerDocument, resourceCallback).apply {
             for (childPreference in preferences) {