## Einführung Androids Standard-Lokalisierung verwendet `strings.xml`-Dateien, aber viele Entwickler bevorzugen JSON-basiertes i18n für plattformübergreifende Konsistenz. Dieser Guide behandelt beide Ansätze und zeigt dir, wie du robuste Lokalisierung in deiner Android-App implementierst. Ob du eine neue App entwickelst oder eine bestehende wartest - richtige Internationalisierung (i18n) ist entscheidend, um globale Märkte zu erreichen. ## Voraussetzungen - Android Studio installiert - Grundkenntnisse in Kotlin oder Java - Verständnis des Android-Ressourcensystems ## Android Lokalisierungs-Grundlagen ### Der Standard-Ansatz: strings.xml Androids eingebautes Lokalisierungssystem verwendet XML-Dateien im `res/values`-Verzeichnis: ```xml Meine App Willkommen, %1$s! %d Artikel ``` ### Warum JSON für Android i18n? JSON-basierte Lokalisierung bietet mehrere Vorteile: 1. **Plattformübergreifende Konsistenz** - Gleiches Format wie iOS, Web und Backend 2. **Einfachere Automatisierung** - JSON ist leichter zu parsen und zu generieren 3. **Besseres Tooling** - Mehr Übersetzungs-Management-Tools unterstützen JSON 4. **Verschachtelte Strukturen** - Übersetzungen hierarchisch organisieren ## JSON-basiertes i18n in Android implementieren ### Schritt 1: JSON-Übersetzungsdateien erstellen Erstelle deine Übersetzungsdateien im `assets`-Verzeichnis: ```json // assets/i18n/de.json { "app": { "name": "Meine App", "welcome": "Willkommen, {name}!", "items": { "one": "{count} Artikel", "other": "{count} Artikel" } }, "buttons": { "submit": "Absenden", "cancel": "Abbrechen" } } ``` ### Schritt 2: Translation Manager erstellen ```kotlin // TranslationManager.kt import android.content.Context import org.json.JSONObject import java.util.Locale object TranslationManager { private var translations: JSONObject? = null private var currentLocale: String = "de" fun init(context: Context, locale: String = Locale.getDefault().language) { currentLocale = locale loadTranslations(context) } private fun loadTranslations(context: Context) { try { val fileName = "i18n/$currentLocale.json" val jsonString = context.assets.open(fileName) .bufferedReader() .use { it.readText() } translations = JSONObject(jsonString) } catch (e: Exception) { // Fallback auf Englisch val jsonString = context.assets.open("i18n/en.json") .bufferedReader() .use { it.readText() } translations = JSONObject(jsonString) } } fun getString(key: String, params: Map = emptyMap()): String { val keys = key.split(".") var current: Any? = translations for (k in keys) { current = (current as? JSONObject)?.opt(k) } var result = current?.toString() ?: key // Platzhalter ersetzen params.forEach { (placeholder, value) -> result = result.replace("{$placeholder}", value.toString()) } return result } } ``` ### Schritt 3: Übersetzungen in der App verwenden ```kotlin // MainActivity.kt class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // Übersetzungen initialisieren TranslationManager.init(this) // Übersetzungen verwenden val welcomeText = TranslationManager.getString( "app.welcome", mapOf("name" to "Max") ) // Ergebnis: "Willkommen, Max!" } } ``` ## Best Practices für Android i18n ### 1. Platzhalter-Schutz Verwende immer konsistente Platzhalter-Formate: | Format | Beispiel | Anwendungsfall | |--------|----------|----------------| | `{name}` | `Hallo, {name}!` | Benannte Platzhalter | | `%1$s` | `Hallo, %1$s!` | Positionelle Strings | | `%d` | `%d Artikel` | Zahlen | | `{{var}}` | `{{count}} Artikel` | ICU-Format | ### 2. Nach Feature organisieren ```json { "auth": { "login": { ... }, "register": { ... } }, "settings": { "profile": { ... }, "notifications": { ... } } } ``` ## Übersetzungen automatisieren Manuelles Übersetzen von JSON-Dateien ist zeitaufwändig und fehleranfällig. ### Mit shipglobal.dev 1. Exportiere deine Basis-`de.json`-Datei 2. Lade sie auf [shipglobal.dev](https://shipglobal.dev) hoch 3. Wähle Zielsprachen (29 verfügbar) 4. Lade übersetzte Dateien herunter Der Service: - Bewahrt Platzhalter wie `{name}` und `%1$s` - Erhält die JSON-Struktur - Behandelt Plurale korrekt - Nutzt Translation Memory für konsistente Updates ## Fazit JSON-basiertes i18n in Android bietet Flexibilität und plattformübergreifende Konsistenz. Bereit, deine Android-App zu übersetzen? [Probiere shipglobal.dev](https://shipglobal.dev) um deine JSON-Dateien automatisch in 29+ Sprachen zu übersetzen. ## Verwandte Ressourcen - [React i18next Placeholder Guide](/blog/react-i18next-placeholder) - [Vue i18n in JavaScript Guide](/blog/vue-i18n-javascript)