Saturday, October 14, 2023
HomeMobileAndroid Builders Weblog: Per-App Language Preferences
Mobile

Android Builders Weblog: Per-App Language Preferences

Admin
By Admin
0
1



Posted by Neelansh Sahai Android Developer Relations Engineer (on Twitter and LinkedIn)What if in case you have a set of customers who’re fairly fluent in English, Hindi, and Spanish, and so they have a information app on their telephones and like to learn the information in Hindi? For his or her texting app, they like Spanish as they’ve some family and friends who they textual content with in Spanish. However for ease of entry, they nonetheless choose their gadget to be in English. Now there are numerous such use-cases the place the customers would possibly need their app languages to be totally different from their system language. Fascinating!

Beginning with Android 13, now we have included one of many most-requested options from customers, Per-App Language Preferences. It lets customers change app languages from System settings, offering customers with higher management over their language selections for various apps, no matter the system language.
A cellphone screen displaying App language preferences in system settings for the YouTube app

Construct on your multilingual customers

This weblog focuses on how one can combine the Per-App Language Preferences API in your app to supply your customers the pliability to decide on totally different languages for various apps.

1.    Customers can change the language settings from system settings by deciding on: 

Settings → System → Languages & Enter → App Languages → [Select the desired App] → [Select the desired Language]

NOTE: Solely these apps which have opted in for the function by specifying the locale_config.xml file (extra on this under), will seem in system settings.

A cellphone screen demonstrating finding the language settings from system settings by selecting Settings → System → Languages & Input → App Languages → [Select the desired App] → [Select the desired Language]

2.    In case your app already has an in-app language picker, you may combine the Per-App Language Preferences API to leverage the complete platform assist. For pre-Android 13 customers, the system settings received’t be seen, however builders can nonetheless present an in-app language picker.

A cellphone screen demonstrating integrating the Per-App Language prefences API for an app which already has an in-app language picker

Learn how to combine this function in your app?

There are 5 steps that should be adopted whereas engaged on the Per-App Language Preferences function, listed right here →

 

1.    Create locale_config.xml file

Create a brand new file in values/xml/ listing and title it as locale_config.xml. This file ought to comprise a listing of all of the locales which can be supported by the app. The checklist aspect must be a string containing a locale tag.

NOTE: The locale tags should observe the BCP47 syntax, which is often {language subtag}–{script subtag}–{nation subtag}. Something apart from that can be filtered out by the system and will not be seen within the system settings.

locale_config.xml

<?xml model=“1.0” encoding=“utf-8”?>
<locale-config xmlns:android=“http://schemas.android.com/apk/res/android”>
    …

    <!– English –>
    <locale android:title=“en”/>

    <!– Japanese (Japan) –>          
    <locale android:title=“ja-JP”/>

    <!– Chinese language (Macao) in Simplified Script –>
    <locale android:title=“zh-Hans-MO”/>

    <!– Chinese language (Taiwan) in Conventional Script –>
    <locale android:title=“zh-Hant-TW”/>  
    …
</locale-config>

2.    Add the locale_config within the AndroidManifest.xml

Specify this locale_config.xml file within the app’s AndroidManifest.xml

AndroidManifest.xml

<manifest>
    …
    <utility
        …
        android:localeConfig=“@xml/locale_config”>
    </utility>
</manifest>


After steps 1 & 2, your customers will be capable to uncover and set their language desire on your app from system settings on units working Android 13 or greater. In case your customers are on units working on variations decrease than Android 13, you may present an in-app language picker. Optionally, you may as well embrace the identical language picker in your app for units working Android 13 or greater. When your app contains an in-app language picker, it is necessary for the person’s preferences to be in sync between the system and the app. That is the place the AndroidX APIs come into the image. Learn on to learn to create an in-app language picker.

Use the most recent model of AppCompat Library

def latestAppCompatVersion =  “1.6.0-rc01”

dependencies {
    …
    implementation “androidx.appcompat:appcompat:$latestAppCompatVersion“
    implementation “androidx.appcompat:appcompat-resources:$latestAppCompatVersion“
    …
}

4. Use AndroidX APIs

Use the APIs in your code to set and get the app locales.

MainActivity.kt

val appLocale: LocaleListCompat = LocaleListCompat.forLanguageTags(“xx-YY”)

// Name this on the primary thread as it could require Exercise.restart()
AppCompatDelegate.setApplicationLocales(appLocale)

// Name this to get the chosen locale and show it in your App
val selectedLocale = AppCompatDelegate.getApplicationLocales()[0]

NOTE: These APIs are additionally backward appropriate, so even when the app is getting used on Android 12 or decrease, the APIs would nonetheless behave the identical, and no further checks for OS variations are required in your code.

 

5. Delegate storage to AndroidX

Let AndroidX deal with the locale storage in order that the person’s desire persists.

AndroidManifest.xml

<utility
    …
    <service
        android:title=“androidx.appcompat.app.AppLocalesMetadataHolderService”
        android:enabled=“false”
        android:exported=“false”>
        <meta-data
            android:title=“autoStoreLocales”
            android:worth=“true” />
    </service>
    …
</utility>


Steps 3, 4, & 5 above show the minimal parts wanted to create an in-app language picker.

And with this, your app can now assist locale switching.

Extra issues to handle whereas migrating to the API

Earlier, builders needed to deal with the person’s preferences on their very own, both by utilizing SharedPreferences, storing the information on a server, or different app logic. With the new APIs, there isn’t any must deal with this individually. So when you find yourself utilizing these APIs, AndroidX is already caring for the storage half, however what occurs when the app is opened for the primary time after a person updates their gadget to Android 13 or greater?

On this case, the system received’t concentrate on the person’s preferences for the app language and thus it’s going to map the app to the default system language. To keep away from this, builders want so as to add some one-time migration logic in order that their customers don’t should set the language once more after they replace the app.

// Specify the constants for use within the under code snippets

companion object {

    // Constants for SharedPreference File
    const val PREFERENCE_NAME = “shared_preference”
    const val PREFERENCE_MODE = Context.MODE_PRIVATE

    // Constants for SharedPreference Keys
    const val FIRST_TIME_MIGRATION = “first_time_migration”
    const val SELECTED_LANGUAGE = “selected_language”

    // Constants for SharedPreference Values
    const val STATUS_DONE = “status_done”
}

// Utility methodology to place a string in a SharedPreference
non-public enjoyable putString(key: String, worth: String) {
    val editor = getSharedPreferences(PREFERENCE_NAME, PREFERENCE_MODE).edit()
    editor.putString(key, worth)
    editor.apply()
}

// Utility methodology to get a string from a SharedPreference
non-public enjoyable getString(key: String): String? {
    val desire = getSharedPreferences(PREFERENCE_NAME, PREFERENCE_MODE)
    return desire.getString(key, null)
}

// Verify if the migration has already been performed or not
if (getString(FIRST_TIME_MIGRATION) != STATUS_DONE) {

   // Fetch the chosen language from wherever it was saved. On this case it’s SharedPref

   // On this case let’s assume that it was saved in a key named SELECTED_LANGUAGE
   getString(SELECTED_LANGUAGE)?.let { it →

      // Set this locale utilizing the AndroidX library that can deal with the storage itself
      val localeList = LocaleListCompat.forLanguageTags(it)
      AppCompatDelegate.setApplicationLocales(localeList)

      // Set the migration flag to make sure that that is executed solely as soon as
      putString(FIRST_TIME_MIGRATION, STATUS_DONE)
   }
}

 

What flexibility does the function present to the customers and builders?

Right here are some things that may show to be useful for you customers.

  1. All units working Android 13 or greater may have a typical place for customers to find and alter the language of their apps.
  2. Though the system settings are restricted to the units working Android 13 or greater, the AndroidX APIs are backwards appropriate. Thus, there isn’t any requirement so as to add OS Model checks in your code whereas constructing on your multilingual customers.
  3. Builders don’t must deal with configuration adjustments individually or fear about storing the person’s chosen language each time. The API handles configuration adjustments and shops the language preferences for you.
  4. Works with different Android options like Backup and restore. If a person switches to a brand new gadget and restores the beforehand backed up information, your app will retain the person’s final most well-liked language, thus offering your customers with a greater and extra seamless expertise.

Recap

With that, most components of the function are coated. So let’s have a fast recap on what we mentioned in immediately’s learn.

  1. A fast learn on what Per-App Language Preferences provide to multilingual customers and app builders.
  2. What finish customers will see on their units.
  3. Learn how to migrate your app to the Per-App Language Preferences APIs.
  4. A number of issues that should be taken care of whereas migrating to the APIs to make sure a greater person expertise.
  5. Lastly, the advantages that finish customers and builders can leverage from this function.

References

  1. Per-App Language Preferences
  2. Pattern App ( Compose )
  3. Pattern App ( Views )
  4. Per-App Language Preferences (YouTube Video)





Supply hyperlink

Previous articleSelf-powered sensible watches for cows, how honey bees deal with topological defects – Physics World
Next articleLow-Code Platforms For Constructing & Automating IoT Networks
Admin
Adminhttps://www.elonmusk.casa
RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

- Advertisment -
Google search engine

Most Popular

Load more

Recent Comments

ABOUT US

elonmusk.casa is your Software Development, Mobile, Apple website. We provide you with the latest breaking news and videos straight from the technology industry.

POPULAR POSTS

POPULAR CATEGORY

copy right 2022 ©elonmusk.casa. All rights reserved.