Seventeen languages that actually ship: how Googly Player makes an in-app language choice stick

Shipping an Android app in more than one language is mostly not a translation problem. The strings are the easy part. The hard part is everything that sits around them: the media notification that stays in English after the user switched to Hindi, the item count that reads backwards in Arabic, the plural that is only correct in English, and the release build that passes every test on your desk and still shows English to the person who chose Bengali, because the store never delivered the Bengali strings to their phone.

Almost all of these fail quietly. Nothing crashes and nothing appears in the logs. The user simply sees an app that half-speaks their language and concludes that nobody tried.

Googly Player, our Android app for videos, music and photos, has a full in-app language picker with seventeen languages. This is how we built it so that choosing a language changes the language everywhere the app shows text, and keeps working once the app has gone through the Play Store.

Seventeen languages, chosen inside the app

The picker is entirely independent of the system language. Someone can keep their phone in one language and run Googly Player in another, and the app does not need the system setting to agree with them. That matters for a media app in particular, because it is often the app people spend the most time in, and the language they want for browsing their own videos and music is not always the one their phone was set up in.

These are the languages the picker offers, each shown here by its own name:

• English
• Hindi (हिन्दी)
• Spanish (Español)
• Arabic (العربية)
• French (Français)
• Bengali (বাংলা)
• Portuguese (Português)
• Russian (Русский)
• Urdu (اردو)
• Indonesian (Bahasa Indonesia)
• German (Deutsch)
• Japanese (日本語)
• Turkish (Türkçe)
• Vietnamese (Tiếng Việt)
• Korean (한국어)
• Italian (Italiano)
• Gujarati (ગુજરાતી)

That list covers several scripts and two right-to-left languages, which is exactly why the details further down are not optional.

A picker people can read in their own language

Each language is listed by its endonym, its own name in its own script, as the primary label, with the English name underneath. Someone looking for Gujarati recognises ગુજરાતી before they would find the word Gujarati in a Latin-alphabet list, and they may not read English at all. The English name underneath helps the other case: someone setting the app up for a relative, or a tester checking that each entry is where it should be.

The list is searchable, and it opens with a Suggested section based on the device locale, so most people find their language at the top without scrolling. For Arabic and Urdu, the language names in the picker are correctly anchored for right-to-left text, so the picker itself does not look broken in the two languages most likely to break it.

One setting for the whole process

A common shortcut is to change the locale for the activity on screen. That works until the app shows text from somewhere that is not an activity. Googly Player applies the chosen language process-wide through AppCompatDelegate.setApplicationLocales, so it covers services, notifications and dialogs as well as activities.

For a media player this is the difference between working and not. Background playback on modern Android runs in a foreground service with a media notification; the app declares FOREGROUND_SERVICE, FOREGROUND_SERVICE_MEDIA_PLAYBACK and WAKE_LOCK for exactly that, and POST_NOTIFICATIONS for the media notification on Android 13 and later. With an activity-only approach, the screen would be in Urdu and the notification controlling the music would still be in whatever language the system uses. Applying the locale to the process means the user sees one language whether they are looking at the app, a dialog, or the notification shade.

Handed to Android on 13 and later

Android 13 introduced a per-app language setting in the system, and on Android 13 and later Googly Player hands its choice to the platform. The language picked inside the app therefore also appears under Settings › Apps › Googly Player › Language, and the two places show the same choice rather than competing with each other.

This is a small thing that prevents a confusing one. A user who changes the language from system settings, or who goes looking there because that is where they expect it, finds the app behaving the way the platform says it should. An app that keeps its own private language setting and ignores the platform one leaves people with two switches that disagree.

The build setting that decides whether any of this works

Everything above can be implemented correctly and still fail in production. Android App Bundles split resources by language by default, and Play then delivers only the resources matching the device's system language. The translations for every other language never reach the phone.

The result is one of the nastier bugs in Android localisation. The user opens the picker, chooses Hindi on a phone set to English, and the app renders everything in English. There is no crash and nothing in the logs. On a developer's machine, where the app is installed with every resource, it works perfectly, so the bug only exists for real users.

We disable language splits in Googly Player's App Bundle deliberately, so every translation ships in the base APK. Whatever language the system is set to, all seventeen are on the device when the user opens the picker.

Right-to-left, including the numbers

Arabic and Urdu get full right-to-left support in Googly Player, down to the language names in the picker being anchored correctly. The less obvious part is how numbers meet text.

Every count in the app is a formatted string, never a concatenation. The code uses a resource like “Total Videos: %d” rather than gluing “Total Videos: ” to a number at runtime. Concatenation fixes the order of label and number in the code, which puts the number on the wrong side of the label in Arabic and Urdu. A format string lets each translation place the number where its own grammar and direction put it.

Counts appear all over a media app. Global Search, for example, scans videos, music and photos in a single pass and shows sectioned results with a count on each heading, such as “Videos · 12”, “Music · 4” and “Photos · 87”. Each of those has to read correctly in every one of the seventeen languages.

Plurals a format string cannot express

Formatting the number is only half of a count. The word next to it changes with the number too, and English trains developers to think there are two cases: one, and everything else. Arabic needs six grammatical forms for a number and Russian needs four. A single format string, or an if statement that checks for one, cannot express that.

Googly Player uses proper Android plural resources for these strings, so each language supplies as many forms as its grammar has and the platform chooses the right one for the number being shown. It is the same principle as the format strings: the code says what it means, a count of videos, and leaves the language-specific shape of that phrase to the translation, where it belongs.

What it runs on and how to set the language

Googly Player is an Android app built with Material Design 3 throughout. It picks up the wallpaper palette through Material You dynamic colour on Android 12 and later, handles edge-to-edge insets correctly on Android 15 and later, and uses granular media permissions on Android 13 and later: READ_MEDIA_AUDIO, READ_MEDIA_IMAGES and READ_MEDIA_VIDEO, with READ_EXTERNAL_STORAGE capped at API 32 for older devices. Its permission prompts are written in plain language and state that nothing is uploaded and everything stays on the device.

Setting the language takes a few taps:

1. Open the language picker

   The picker lives inside the app and does not depend on the phone's system language.

2. Choose from Suggested or search

   Languages matching the device locale appear in the Suggested section; any of the seventeen can be found by searching, under its own name or its English one.

3. Or set it from system settings

   On Android 13 and later, the same choice is available under Settings › Apps › Googly Player › Language, and it stays in step with the in-app picker.

If you are building your own Android app for users across these languages, the same decisions apply: one process-wide locale, the platform setting on Android 13 and later, language splits disabled, format strings for counts and plural resources for words. They are the decisions we made for Googly Player, and they are the ones we would bring to your project.

Questions