diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/GuestFonts.kt b/app/src/main/java/com/droiddeck/launcher/runtime/GuestFonts.kt new file mode 100644 index 0000000000..a9c92c8f9b --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/runtime/GuestFonts.kt @@ -0,0 +1,74 @@ +package com.droiddeck.launcher.runtime + +import android.content.Context +import com.droiddeck.launcher.core.AppLanguage +import java.io.File +import java.util.Locale + +/** + * Fonts for every script the app's languages (and Steam's) are written in. + * + * The runtime ships DejaVu and Adwaita only, which have no Chinese, Japanese, Korean or Thai, so + * Steam drew those as boxes (#118, #206). Android already carries Noto for all of them in + * /system/fonts; the guest gets that folder read-only at [GUEST_DIR], where fontconfig finds it + * with the rest of /usr/share/fonts. Nothing is downloaded and the runtime is not changed. + * + * One CJK font holds Chinese, Japanese and Korean under one set of characters, and a character + * they share is drawn the way the chosen region writes it. [preferenceConf] puts that region's + * variant first, after DejaVu, which stays the font for Latin text. + */ +object GuestFonts { + const val HOST_DIR = "/system/fonts" + const val GUEST_DIR = "/usr/share/fonts/android" + /** Rewritten at every session start, so it follows the language picked in Setup. */ + const val CONF = "etc/fonts/conf.d/65-droiddeck-language.conf" + + /** The bind spec for Android's fonts, or null on a device without the folder. */ + @JvmStatic + fun bindSpec(): String? = File(HOST_DIR).takeIf { it.isDirectory }?.let { "${it.path}:$GUEST_DIR" } + + /** Writes the guest's font preference for the app's current language; best effort. */ + @JvmStatic + fun prepare(context: Context, root: File) { + val conf = File(root, CONF) + val text = preferenceConf(AppLanguage.effective(context)) + try { + if (conf.isFile && conf.readText() == text) return + conf.parentFile?.mkdirs() + conf.writeText(text) + } catch (e: Exception) { + // fontconfig still finds every font; shared characters just take its own default shape. + } + } + + /** The CJK variant whose shapes match how [locale]'s readers write shared characters. */ + fun cjkRegion(locale: Locale): String { + val script = locale.script + return when (locale.language) { + "ja" -> "JP" + "ko" -> "KR" + "zh" -> when { + script == "Hans" -> "SC" + locale.country == "HK" || locale.country == "MO" -> "HK" + script == "Hant" || locale.country == "TW" -> "TC" + else -> "SC" + } + else -> "SC" + } + } + + fun preferenceConf(locale: Locale): String { + val region = cjkRegion(locale) + fun alias(generic: String, latin: String, cjk: String) = + " \n $generic\n \n" + + " $latin\n $cjk $region\n" + + " \n \n" + return "\n\n" + + "\n" + + "\n" + + alias("sans-serif", "DejaVu Sans", "Noto Sans CJK") + + alias("serif", "DejaVu Serif", "Noto Serif CJK") + + alias("monospace", "DejaVu Sans Mono", "Noto Sans Mono CJK") + + "\n" + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java index 35a73971f0..d158156b66 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java +++ b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java @@ -270,6 +270,13 @@ public final class LinuxRuntime { if (extraBinds != null) { for (String spec : extraBinds) bind(cmd, spec); } + // Android's fonts, for the scripts the runtime's own fonts lack (GuestFonts). Last, so a + // fast path that keeps only its first binds drops these before a game library. + String fonts = GuestFonts.bindSpec(); + if (fonts != null) { + bind(cmd, fonts); + GuestFonts.prepare(context, root); + } List specs = new ArrayList<>(); for (int i = 0; i + 1 < cmd.size(); i += 2) specs.add(cmd.get(i + 1)); return specs; diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamLanguage.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamLanguage.kt new file mode 100644 index 0000000000..4f42386d93 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/session/SteamLanguage.kt @@ -0,0 +1,68 @@ +package com.droiddeck.launcher.session + +import java.util.Locale + +/** + * Steam's name for a language: the API language codes the client and the Steamworks API use + * ("english", "schinese", "koreana"...), for every language Steam's interface comes in. + */ +object SteamLanguage { + const val DEFAULT = "english" + + /** Every language the Steam client's interface is offered in. */ + val all: Set = setOf( + "arabic", "bulgarian", "schinese", "tchinese", "czech", "danish", "dutch", "english", + "finnish", "french", "german", "greek", "hungarian", "indonesian", "italian", "japanese", + "koreana", "norwegian", "polish", "portuguese", "brazilian", "romanian", "russian", + "spanish", "latam", "swedish", "thai", "turkish", "ukrainian", "vietnamese", + ) + + /** Spanish-speaking regions Steam serves with Latin American Spanish rather than Spain's. */ + private val latinAmerica = setOf( + "419", "AR", "BO", "CL", "CO", "CR", "CU", "DO", "EC", "GT", "HN", "MX", "NI", "PA", "PE", + "PR", "PY", "SV", "US", "UY", "VE", + ) + + /** + * Steam's language for [locale]. [region] stands in for the locale's own when it has none: the + * app's Spanish carries no region, and a player in Mexico should get Latin American Spanish. + */ + fun forLocale(locale: Locale, region: String? = null): String { + val country = locale.country.ifEmpty { region.orEmpty() } + return when (locale.language) { + "ar" -> "arabic" + "bg" -> "bulgarian" + "cs" -> "czech" + "da" -> "danish" + "nl" -> "dutch" + "en" -> "english" + "fi" -> "finnish" + "fr" -> "french" + "de" -> "german" + "el" -> "greek" + "hu" -> "hungarian" + "id", "in" -> "indonesian" + "it" -> "italian" + "ja" -> "japanese" + "ko" -> "koreana" + "nb", "no", "nn" -> "norwegian" + "pl" -> "polish" + "pt" -> if (country == "BR") "brazilian" else "portuguese" + "ro" -> "romanian" + "ru" -> "russian" + "es" -> if (country in latinAmerica) "latam" else "spanish" + "sv" -> "swedish" + "th" -> "thai" + "tr" -> "turkish" + "uk" -> "ukrainian" + "vi" -> "vietnamese" + "zh" -> when { + locale.script == "Hant" -> "tchinese" + locale.script == "Hans" -> "schinese" + country == "TW" || country == "HK" || country == "MO" -> "tchinese" + else -> "schinese" + } + else -> DEFAULT + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/GuestFontsTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/GuestFontsTest.kt new file mode 100644 index 0000000000..c2ea3ce226 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/runtime/GuestFontsTest.kt @@ -0,0 +1,31 @@ +package com.droiddeck.launcher.runtime + +import java.util.Locale +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class GuestFontsTest { + private fun region(tag: String) = GuestFonts.cjkRegion(Locale.forLanguageTag(tag)) + + @Test fun sharedCharactersTakeTheReadersRegionalShapes() { + assertEquals("JP", region("ja")) + assertEquals("KR", region("ko")) + assertEquals("SC", region("zh-CN")) + assertEquals("TC", region("zh-TW")) + assertEquals("HK", region("zh-HK")) + assertEquals("HK", region("zh-MO")) + assertEquals("SC", region("zh-Hans-HK")) + assertEquals("TC", region("zh-Hant")) + assertEquals("SC", region("en")) + } + + @Test fun latinStaysOnDejaVuWithTheRegionsCjkNext() { + val conf = GuestFonts.preferenceConf(Locale.JAPANESE) + val sans = conf.substringAfter("sans-serif").substringBefore("") + assertTrue(sans, sans.indexOf("DejaVu Sans") in 0 until sans.indexOf("Noto Sans CJK JP")) + assertTrue(conf.contains("Noto Serif CJK JP")) + assertTrue(conf.contains("Noto Sans Mono CJK JP")) + assertTrue(conf.startsWith("