The Tor Browser: mobile/android/base/BrowserLocaleManager.java@b8a032363ba2 (annotated)

mobile/android/base/BrowserLocaleManager.java@b8a032363ba2 (annotated)

mobile/android/base/BrowserLocaleManager.java

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 package org.mozilla.gecko;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.SharedPreferences;
 import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.util.Log;
 import java.util.Locale;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 /**
  * This class manages persistence, application, and otherwise handling of
  * user-specified locales.
  *
  * Of note:
  *
  * * It's a singleton, because its scope extends to that of the application,
  *   and definitionally all changes to the locale of the app must go through
  *   this.
  * * It's lazy.
  * * It has ties into the Gecko event system, because it has to tell Gecko when
  *   to switch locale.
  * * It relies on using the SharedPreferences file owned by the browser (in
  *   Fennec's case, "GeckoApp") for performance.
  */
 public class BrowserLocaleManager implements LocaleManager {
     private static final String LOG_TAG = "GeckoLocales";
     private static final String EVENT_LOCALE_CHANGED = "Locale:Changed";
     private static final String PREF_LOCALE = "locale";
     // This is volatile because we don't impose restrictions
     // over which thread calls our methods.
     private volatile Locale currentLocale = null;
     private AtomicBoolean inited = new AtomicBoolean(false);
     private boolean systemLocaleDidChange = false;
     private BroadcastReceiver receiver;
     private static AtomicReference<LocaleManager> instance = new AtomicReference<LocaleManager>();
     public static LocaleManager getInstance() {
         LocaleManager localeManager = instance.get();
         if (localeManager != null) {
             return localeManager;
         }
         localeManager = new BrowserLocaleManager();
         if (instance.compareAndSet(null, localeManager)) {
             return localeManager;
         } else {
             return instance.get();
         }
     }
     /**
      * Gecko uses locale codes like "es-ES", whereas a Java {@link Locale}
      * stringifies as "es_ES".
      *
      * This method approximates the Java 7 method <code>Locale#toLanguageTag()</code>.
      *
      * @return a locale string suitable for passing to Gecko.
      */
     public static String getLanguageTag(final Locale locale) {
         // If this were Java 7:
         // return locale.toLanguageTag();
         String language = locale.getLanguage();  // Can, but should never be, an empty string.
         // Modernize certain language codes.
         if (language.equals("iw")) {
             language = "he";
         } else if (language.equals("in")) {
             language = "id";
         } else if (language.equals("ji")) {
             language = "yi";
         }
         String country = locale.getCountry();    // Can be an empty string.
         if (country.equals("")) {
             return language;
         }
         return language + "-" + country;
     }
     private static Locale parseLocaleCode(final String localeCode) {
         int index;
         if ((index = localeCode.indexOf('-')) != -1 ||
             (index = localeCode.indexOf('_')) != -1) {
             final String langCode = localeCode.substring(0, index);
             final String countryCode = localeCode.substring(index + 1);
             return new Locale(langCode, countryCode);
         } else {
             return new Locale(localeCode);
         }
     }
     /**
      * Ensure that you call this early in your application startup,
      * and with a context that's sufficiently long-lived (typically
      * the application context).
      *
      * Calling multiple times is harmless.
      */
     @Override
     public void initialize(final Context context) {
         if (!inited.compareAndSet(false, true)) {
             return;
         }
         receiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 systemLocaleDidChange = true;
             }
         };
         context.registerReceiver(receiver, new IntentFilter(Intent.ACTION_LOCALE_CHANGED));
     }
     @Override
     public boolean systemLocaleDidChange() {
         return systemLocaleDidChange;
     }
     /**
      * Every time the system gives us a new configuration, it
      * carries the external locale. Fix it.
      */
     @Override
     public void correctLocale(Context context, Resources res, Configuration config) {
         final Locale current = getCurrentLocale(context);
         if (current == null) {
             return;
         }
         // I know it's tempting to short-circuit here if the config seems to be
         // up-to-date, but the rest is necessary.
         config.locale = current;
         // The following two lines are heavily commented in case someone
         // decides to chase down performance improvements and decides to
         // question what's going on here.
         // Both lines should be cheap, *but*...
         // This is unnecessary for basic string choice, but it almost
         // certainly comes into play when rendering numbers, deciding on RTL,
         // etc. Take it out if you can prove that's not the case.
         Locale.setDefault(current);
         // This seems to be a no-op, but every piece of documentation under the
         // sun suggests that it's necessary, and it certainly makes sense.
         res.updateConfiguration(config, res.getDisplayMetrics());
     }
     @Override
     public String getAndApplyPersistedLocale(Context context) {
         initialize(context);
         final long t1 = android.os.SystemClock.uptimeMillis();
         final String localeCode = getPersistedLocale(context);
         if (localeCode == null) {
             return null;
         }
         // Note that we don't tell Gecko about this. We notify Gecko when the
         // locale is set, not when we update Java.
         final String resultant = updateLocale(context, localeCode);
         if (resultant == null) {
             // Update the configuration anyway.
             updateConfiguration(context, currentLocale);
         }
         final long t2 = android.os.SystemClock.uptimeMillis();
         Log.i(LOG_TAG, "Locale read and update took: " + (t2 - t1) + "ms.");
         return resultant;
     }
     /**
      * Returns the set locale if it changed.
      *
      * Always persists and notifies Gecko.
      */
     @Override
     public String setSelectedLocale(Context context, String localeCode) {
         final String resultant = updateLocale(context, localeCode);
         // We always persist and notify Gecko, even if nothing seemed to
         // change. This might happen if you're picking a locale that's the same
         // as the current OS locale. The OS locale might change next time we
         // launch, and we need the Gecko pref and persisted locale to have been
         // set by the time that happens.
         persistLocale(context, localeCode);
         // Tell Gecko.
         GeckoEvent ev = GeckoEvent.createBroadcastEvent(EVENT_LOCALE_CHANGED, BrowserLocaleManager.getLanguageTag(getCurrentLocale(context)));
         GeckoAppShell.sendEventToGecko(ev);
         return resultant;
     }
     /**
      * This is public to allow for an activity to force the
      * current locale to be applied if necessary (e.g., when
      * a new activity launches).
      */
     @Override
     public void updateConfiguration(Context context, Locale locale) {
         Resources res = context.getResources();
         Configuration config = res.getConfiguration();
         config.locale = locale;
         res.updateConfiguration(config, res.getDisplayMetrics());
     }
     private SharedPreferences getSharedPreferences(Context context) {
         return GeckoSharedPrefs.forApp(context);
     }
     private String getPersistedLocale(Context context) {
         final SharedPreferences settings = getSharedPreferences(context);
         final String locale = settings.getString(PREF_LOCALE, "");
         if ("".equals(locale)) {
             return null;
         }
         return locale;
     }
     private void persistLocale(Context context, String localeCode) {
         final SharedPreferences settings = getSharedPreferences(context);
         settings.edit().putString(PREF_LOCALE, localeCode).commit();
     }
     private Locale getCurrentLocale(Context context) {
         if (currentLocale != null) {
             return currentLocale;
         }
         final String current = getPersistedLocale(context);
         if (current == null) {
             return null;
         }
         return currentLocale = parseLocaleCode(current);
     }
     /**
      * Updates the Java locale and the Android configuration.
      *
      * Returns the persisted locale if it differed.
      *
      * Does not notify Gecko.
      */
     private String updateLocale(Context context, String localeCode) {
         // Fast path.
         final Locale defaultLocale = Locale.getDefault();
         if (defaultLocale.toString().equals(localeCode)) {
             return null;
         }
         final Locale locale = parseLocaleCode(localeCode);
         // Fast path.
         if (defaultLocale.equals(locale)) {
             return null;
         }
         Locale.setDefault(locale);
         currentLocale = locale;
         // Update resources.
         updateConfiguration(context, locale);
         return locale.toString();
     }
 }

The Tor Browser / annotate

mobile/android/base/BrowserLocaleManager.java@b8a032363ba2 (annotated)

mobile/android/base/BrowserLocaleManager.java