Establecer configuración regional mediante programación

Mi aplicación admite 3 (pronto 4) idiomas. Dado que varias configuraciones regionales son bastante similares, me gustaría darle al usuario la opción de cambiar la configuración regional en mi aplicación, por ejemplo, una persona italiana podría preferir el español al inglés.

¿Hay alguna manera para que el usuario seleccione entre las configuraciones regionales que están disponibles para la aplicación y luego cambie la configuración regional que se usa? No lo veo como un problema para establecer la configuración regional para cada actividad, ya que es una tarea sencilla de realizar en una clase base.

Para las personas que todavía buscan esta respuesta, dado que configuration.localefue desaprobada de API 24, ahora puede usar:

configuration.setLocale(locale);

Tenga en cuenta que minSkdVersion para este método es API 17.

Código de ejemplo completo:

@SuppressWarnings("deprecation")
private void setLocale(Locale locale){
    SharedPrefUtils.saveLocale(locale); // optional - Helper method to save the selected language to SharedPreferences in case you might need to attach to activity context (you will need to code this)
    Resources resources = getResources();
    Configuration configuration = resources.getConfiguration();
    DisplayMetrics displayMetrics = resources.getDisplayMetrics();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1){
        configuration.setLocale(locale);
    } else{
        configuration.locale=locale;
    }
    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.N){
        getApplicationContext().createConfigurationContext(configuration);
    } else {
        resources.updateConfiguration(configuration,displayMetrics);
    }
}

No olvide que, si cambia la configuración regional con una actividad en ejecución, deberá reiniciarla para que los cambios surtan efecto.

EDITAR 11 de mayo de 2018

A partir de la publicación de @ CookieMonster, es posible que tenga problemas para mantener el cambio de configuración regional en versiones de API más altas. Si es así, agregue el siguiente código a su Actividad base para actualizar la configuración regional de contexto en cada creación de Actividad:

@Override
protected void attachBaseContext(Context base) {
     super.attachBaseContext(updateBaseContextLocale(base));
}

private Context updateBaseContextLocale(Context context) {
    String language = SharedPrefUtils.getSavedLanguage(); // Helper method to get saved language from SharedPreferences
    Locale locale = new Locale(language);
    Locale.setDefault(locale);

    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.N) {
        return updateResourcesLocale(context, locale);
    }

    return updateResourcesLocaleLegacy(context, locale);
}

@TargetApi(Build.VERSION_CODES.N_MR1)
private Context updateResourcesLocale(Context context, Locale locale) {
    Configuration configuration = new Configuration(context.getResources().getConfiguration())
    configuration.setLocale(locale);
    return context.createConfigurationContext(configuration);
}

@SuppressWarnings("deprecation")
private Context updateResourcesLocaleLegacy(Context context, Locale locale) {
    Resources resources = context.getResources();
    Configuration configuration = resources.getConfiguration();
    configuration.locale = locale;
    resources.updateConfiguration(configuration, resources.getDisplayMetrics());
    return context;
}

Si usa esto, no olvide guardar el idioma en SharedPreferences cuando configure la configuración regional con setLocate(locale)

EDITAR 7 DE ABRIL 2020

Es posible que experimente problemas en Android 6 y 7, y esto sucede debido a un problema en las bibliotecas de Androidx al manejar el modo nocturno. Para esto, también deberá anular applyOverrideConfigurationsu actividad base y actualizar la configuración regional en caso de que se cree una nueva configuración regional nueva.

Código de muestra:

@Override
public void applyOverrideConfiguration(Configuration overrideConfiguration) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && Build.VERSION.SDK_INT <= Build.VERSION_CODES.N_MR1) {
        // update overrideConfiguration with your locale  
        setLocale(overrideConfiguration) // you will need to implement this
    }
    super.applyOverrideConfiguration(overrideConfiguration);
} 

Espero que esta ayuda (en onResume):

Locale locale = new Locale("ru");
Locale.setDefault(locale);
Configuration config = getBaseContext().getResources().getConfiguration();
config.locale = locale;
getBaseContext().getResources().updateConfiguration(config,
      getBaseContext().getResources().getDisplayMetrics());

Tuve un problema con la configuración regional mediante programación con dispositivos que tienen Android OS N y superior . Para mí, la solución fue escribir este código en mi actividad base:

(si no tiene una actividad base, entonces debe hacer estos cambios en todas sus actividades)

@Override
protected void attachBaseContext(Context base) {
    super.attachBaseContext(updateBaseContextLocale(base));
}

private Context updateBaseContextLocale(Context context) {
    String language = SharedPref.getInstance().getSavedLanguage();
    Locale locale = new Locale(language);
    Locale.setDefault(locale);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        return updateResourcesLocale(context, locale);
    }

    return updateResourcesLocaleLegacy(context, locale);
}

@TargetApi(Build.VERSION_CODES.N)
private Context updateResourcesLocale(Context context, Locale locale) {
    Configuration configuration = context.getResources().getConfiguration();
    configuration.setLocale(locale);
    return context.createConfigurationContext(configuration);
}

@SuppressWarnings("deprecation")
private Context updateResourcesLocaleLegacy(Context context, Locale locale) {
    Resources resources = context.getResources();
    Configuration configuration = resources.getConfiguration();
    configuration.locale = locale;
    resources.updateConfiguration(configuration, resources.getDisplayMetrics());
    return context;
}

tenga en cuenta que aquí no es suficiente llamar

createConfigurationContext(configuration)

también necesita obtener el contexto que devuelve este método y luego establecer este contexto en el attachBaseContextmétodo.

Como no hay una respuesta completa para la forma actual de resolver este problema, trato de dar instrucciones para una solución completa. Comente si falta algo o podría hacerse mejor.

Información general

Primero, existen algunas bibliotecas que quieren resolver el problema pero todas parecen anticuadas o les faltan algunas características:

• https://github.com/delight-im/Android-Languages
  • Anticuado (ver problemas )
  • Al seleccionar un idioma en la interfaz de usuario, siempre muestra todos los idiomas (codificados en la biblioteca), no solo aquellos donde existen traducciones
• https://github.com/akexorcist/Android-LocalizationActivity
  • Parece bastante sofisticado y podría usar un enfoque similar al que se muestra a continuación

Además, creo que escribir una biblioteca podría no ser una forma buena / fácil de resolver este problema porque no hay mucho que hacer, y lo que hay que hacer es cambiar el código existente en lugar de usar algo completamente desacoplado. Por lo tanto, compuse las siguientes instrucciones que deberían estar completas.

Mi solución se basa principalmente en https://github.com/gunhansancar/ChangeLanguageExample (como ya está vinculado por localhost ). Es el mejor código que encontré para orientar. Algunas observaciones:

• Según sea necesario, proporciona diferentes implementaciones para cambiar la configuración regional para Android N (y superior) y posterior
• Utiliza un método updateViews()en cada Actividad para actualizar manualmente todas las cadenas después de cambiar la configuración regional (usando el habitual getString(id)) que no es necesario en el enfoque que se muestra a continuación
• Solo admite idiomas y configuraciones regionales no completas (que también incluyen códigos de región (país) y variantes)

Lo cambié un poco, desacoplando la parte que persiste en la configuración regional elegida (ya que uno podría querer hacerlo por separado, como se sugiere a continuación).

Solución

La solución consta de los siguientes dos pasos:

• Cambiar permanentemente la configuración regional que utilizará la aplicación
• Haga que la aplicación use el conjunto de configuraciones regionales personalizadas, sin reiniciar

Paso 1: cambiar la configuración regional

Use la clase LocaleHelper, basada en LocaleHelper de gunhansancar :

• Agregue un ListPreferenceen a PreferenceFragmentcon los idiomas disponibles (debe mantenerse cuando los idiomas deben agregarse más adelante)

import android.annotation.TargetApi;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.os.Build;
import android.preference.PreferenceManager;

import java.util.Locale;

import mypackage.SettingsFragment;

/**
 * Manages setting of the app's locale.
 */
public class LocaleHelper {

    public static Context onAttach(Context context) {
        String locale = getPersistedLocale(context);
        return setLocale(context, locale);
    }

    public static String getPersistedLocale(Context context) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        return preferences.getString(SettingsFragment.KEY_PREF_LANGUAGE, "");
    }

    /**
     * Set the app's locale to the one specified by the given String.
     *
     * @param context
     * @param localeSpec a locale specification as used for Android resources (NOTE: does not
     *                   support country and variant codes so far); the special string "system" sets
     *                   the locale to the locale specified in system settings
     * @return
     */
    public static Context setLocale(Context context, String localeSpec) {
        Locale locale;
        if (localeSpec.equals("system")) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                locale = Resources.getSystem().getConfiguration().getLocales().get(0);
            } else {
                //noinspection deprecation
                locale = Resources.getSystem().getConfiguration().locale;
            }
        } else {
            locale = new Locale(localeSpec);
        }
        Locale.setDefault(locale);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            return updateResources(context, locale);
        } else {
            return updateResourcesLegacy(context, locale);
        }
    }

    @TargetApi(Build.VERSION_CODES.N)
    private static Context updateResources(Context context, Locale locale) {
        Configuration configuration = context.getResources().getConfiguration();
        configuration.setLocale(locale);
        configuration.setLayoutDirection(locale);

        return context.createConfigurationContext(configuration);
    }

    @SuppressWarnings("deprecation")
    private static Context updateResourcesLegacy(Context context, Locale locale) {
        Resources resources = context.getResources();

        Configuration configuration = resources.getConfiguration();
        configuration.locale = locale;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            configuration.setLayoutDirection(locale);
        }

        resources.updateConfiguration(configuration, resources.getDisplayMetrics());

        return context;
    }
}

Crea un me SettingsFragmentgusta de la siguiente manera:

import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceFragment;
import android.preference.PreferenceManager;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import mypackage.LocaleHelper;
import mypackage.R;

/**
 * Fragment containing the app's main settings.
 */
public class SettingsFragment extends PreferenceFragment implements SharedPreferences.OnSharedPreferenceChangeListener {
    public static final String KEY_PREF_LANGUAGE = "pref_key_language";

    public SettingsFragment() {
        // Required empty public constructor
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_settings, container, false);
        return view;
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        switch (key) {
            case KEY_PREF_LANGUAGE:
                LocaleHelper.setLocale(getContext(), PreferenceManager.getDefaultSharedPreferences(getContext()).getString(key, ""));
                getActivity().recreate(); // necessary here because this Activity is currently running and thus a recreate() in onResume() would be too late
                break;
        }
    }

    @Override
    public void onResume() {
        super.onResume();
        // documentation requires that a reference to the listener is kept as long as it may be called, which is the case as it can only be called from this Fragment
        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    public void onPause() {
        super.onPause();
        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
    }
}

Cree un recurso que locales.xmlenumere todas las configuraciones regionales con las traducciones disponibles de la siguiente manera ( lista de códigos locales ):

<!-- Lists available locales used for setting the locale manually.
     For now only language codes (locale codes without country and variant) are supported.
     Has to be in sync with "settings_language_values" in strings.xml (the entries must correspond).
  -->
<resources>
    <string name="system_locale" translatable="false">system</string>
    <string name="default_locale" translatable="false"></string>
    <string-array name="locales">
        <item>@string/system_locale</item> <!-- system setting -->
        <item>@string/default_locale</item> <!-- default locale -->
        <item>de</item>
    </string-array>
</resources>

En su PreferenceScreenpuede usar la siguiente sección para permitir al usuario seleccionar los idiomas disponibles:

<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
    <PreferenceCategory
        android:title="@string/preferences_category_general">
        <ListPreference
            android:key="pref_key_language"
            android:title="@string/preferences_language"
            android:dialogTitle="@string/preferences_language"
            android:entries="@array/settings_language_values"
            android:entryValues="@array/locales"
            android:defaultValue="@string/system_locale"
            android:summary="%s">
        </ListPreference>
    </PreferenceCategory>
</PreferenceScreen>

que utiliza las siguientes cadenas de strings.xml:

<string name="preferences_category_general">General</string>
<string name="preferences_language">Language</string>
<!-- NOTE: Has to correspond to array "locales" in locales.xml (elements in same orderwith) -->
<string-array name="settings_language_values">
    <item>Default (System setting)</item>
    <item>English</item>
    <item>German</item>
</string-array>

Paso 2: haga que la aplicación use la configuración regional personalizada

Ahora configure cada actividad para usar el conjunto de configuraciones regionales personalizadas. La forma más fácil de lograr esto es tener una clase base común para todas las actividades con el siguiente código (donde está el código importante attachBaseContext(Context base)y onResume()):

import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;

import mypackage.LocaleHelper;
import mypackage.R;

/**
 * {@link AppCompatActivity} with main menu in the action bar. Automatically recreates
 * the activity when the locale has changed.
 */
public class MenuAppCompatActivity extends AppCompatActivity {
    private String initialLocale;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initialLocale = LocaleHelper.getPersistedLocale(this);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.menu, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_settings:
                Intent intent = new Intent(this, SettingsActivity.class);
                startActivity(intent);
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(LocaleHelper.onAttach(base));
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (initialLocale != null && !initialLocale.equals(LocaleHelper.getPersistedLocale(this))) {
            recreate();
        }
    }
}

Lo que hace es

• Anular attachBaseContext(Context base)para usar la configuración regional que anteriormente persistía conLocaleHelper
• Detecte un cambio de la configuración regional y vuelva a crear la Actividad para actualizar sus cadenas.

Notas sobre esta solución

• Volver a crear una actividad no actualiza el título de ActionBar (como ya se observó aquí: https://github.com/gunhansancar/ChangeLanguageExample/issues/1 ).

  • Esto se puede lograr simplemente teniendo un setTitle(R.string.mytitle)en el onCreate()método de cada actividad.

• Permite al usuario elegir la configuración regional predeterminada del sistema, así como la configuración regional predeterminada de la aplicación (que puede denominarse, en este caso, "inglés").

• fr-rCAHasta ahora, solo se admiten códigos de idioma, ninguna región (país) y códigos de variantes (como ). Para admitir las especificaciones locales completas, se puede utilizar un analizador similar al de la biblioteca de idiomas de Android (que admite regiones pero no códigos de variantes).

  • Si alguien encuentra o ha escrito un buen analizador, agregue un comentario para que pueda incluirlo en la solución.

@SuppressWarnings("deprecation")
public static void forceLocale(Context context, String localeCode) {
    String localeCodeLowerCase = localeCode.toLowerCase();

    Resources resources = context.getApplicationContext().getResources();
    Configuration overrideConfiguration = resources.getConfiguration();
    Locale overrideLocale = new Locale(localeCodeLowerCase);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        overrideConfiguration.setLocale(overrideLocale);
    } else {
        overrideConfiguration.locale = overrideLocale;
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        context.getApplicationContext().createConfigurationContext(overrideConfiguration);
    } else {
        resources.updateConfiguration(overrideConfiguration, null);
    }
}

Simplemente use este método auxiliar para forzar la configuración regional específica.

UDPATE 22 AGOSTO 2017. Mejor use este enfoque .

Agregue una clase auxiliar con el siguiente método:

public class LanguageHelper {
    public static final void setAppLocale(String language, Activity activity) {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            Resources resources = activity.getResources();
            Configuration configuration = resources.getConfiguration();
            configuration.setLocale(new Locale(language));
            activity.getApplicationContext().createConfigurationContext(configuration);
        } else {
            Locale locale = new Locale(language);
            Locale.setDefault(locale);
            Configuration config = activity.getResources().getConfiguration();
            config.locale = locale;
            activity.getResources().updateConfiguration(config,
                    activity.getResources().getDisplayMetrics());
        }

    }
}

Y llámalo en tu actividad de inicio, como MainActivity.java:

public void onCreate(Bundle savedInstanceState) {
    ...
    LanguageHelper.setAppLocale("fa", this);
    ...
}

simple y fácil

Locale locale = new Locale("en", "US");
Resources res = getResources();
DisplayMetrics dm = res.getDisplayMetrics();
Configuration conf = res.getConfiguration();
conf.locale = locale;
res.updateConfiguration(conf, dm);

donde "en" es el código del idioma y "EE. UU." es el código del país.

Válido para API16 a API28 Simplemente coloque este método en algún lugar:

    Context newContext = context;

        Locale locale = new Locale(languageCode);
        Locale.setDefault(locale);

        Resources resources = context.getResources();
        Configuration config = new Configuration(resources.getConfiguration());

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {

        config.setLocale(locale);
                newContext = context.createConfigurationContext(config);

        } else {

        config.locale = locale;
                resources.updateConfiguration(config, resources.getDisplayMetrics());
        }

    return newContext;
}

Inserte este código en todas sus actividades usando:

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(localeUpdateResources(base, "<-- language code -->"));
    }

o llame a localeUpdateResources sobre fragmentos, adaptadores, etc., donde necesite el nuevo contexto.

Créditos: Yaroslav Berezanskyi

Hay una forma super simple.

en BaseActivity, Activity o Fragment override attachBaseContext

 override fun attachBaseContext(context: Context) {
    super.attachBaseContext(context.changeLocale("tr"))
}

extensión

fun Context.changeLocale(language:String): Context {
    val locale = Locale(language)
    Locale.setDefault(locale)
    val config = this.resources.configuration
    config.setLocale(locale)
    return createConfigurationContext(config)
}

He encontrado el androidx.appcompat:appcompat:1.1.0fallo también puede ser fijado simplemente llamando getResources()enapplyOverrideConfiguration()

@Override public void
applyOverrideConfiguration(Configuration cfgOverride)
{
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP &&
      Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
    // add this to fix androidx.appcompat:appcompat 1.1.0 bug
    // which happens on Android 6.x ~ 7.x
    getResources();
  }

  super.applyOverrideConfiguration(cfgOverride);
}

 /**
 * Requests the system to update the list of system locales.
 * Note that the system looks halted for a while during the Locale migration,
 * so the caller need to take care of it.
 */
public static void updateLocales(LocaleList locales) {
    try {
        final IActivityManager am = ActivityManager.getService();
        final Configuration config = am.getConfiguration();

        config.setLocales(locales);
        config.userSetLocale = true;

        am.updatePersistentConfiguration(config);
    } catch (RemoteException e) {
        // Intentionally left blank
    }
}

Para quienes intentaron todo pero no funcionaron . Compruebe que si configuró darkmodecon AppCompatDelegate.setDefaultNightModey el sistema no está oscuro, Configuration.setLocaleno funcionará por encima de Andorid 7.0 .

Agregue este código en todas sus actividades para resolver este problema:

override fun applyOverrideConfiguration(overrideConfiguration: Configuration?) {
  if (overrideConfiguration != null) {
    val uiMode = overrideConfiguration.uiMode
    overrideConfiguration.setTo(baseContext.resources.configuration)
    overrideConfiguration.uiMode = uiMode
  }
  super.applyOverrideConfiguration(overrideConfiguration)
}

Pon este código en tu actividad

 if (id==R.id.uz)
    {
        LocaleHelper.setLocale(MainActivity.this, mLanguageCode);

        //It is required to recreate the activity to reflect the change in UI.
        recreate();
        return true;
    }
    if (id == R.id.ru) {

        LocaleHelper.setLocale(MainActivity.this, mLanguageCode);

        //It is required to recreate the activity to reflect the change in UI.
        recreate();
    }