samsung - Cambiar el lenguaje de la aplicación programáticamente en Android

descargar idioma español para lg l20

Question

¿Es posible cambiar el idioma de una aplicación mediante programación mientras aún se utilizan los recursos de Android?

Si no, ¿es posible solicitar un recurso en un idioma específico?

Me gustaría permitir que el usuario cambie el idioma de la aplicación desde la aplicación.

Answer 1

Para Android 7.0 Nougat (y más bajo) sigue este artículo:

Cambia el lenguaje programáticamente en Android

Vieja respuesta
Esto incluye soporte RTL / LTR:

public static void changeLocale(Context context, Locale locale) {
Configuration conf = context.getResources().getConfiguration();
conf.locale = locale;
Locale.setDefault(locale);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
conf.setLayoutDirection(conf.locale);
}
context.getResources().updateConfiguration(conf, context.getResources().getDisplayMetrics());
}

Answer 2

Al principio crea multi string.xml para diferentes idiomas; luego use este bloque de código en el método onCreate() :

super.onCreate(savedInstanceState);
String languageToLoad = "fr"; // change your language here
Locale locale = new Locale(languageToLoad);
Locale.setDefault(locale);
Configuration config = new Configuration();
config.locale = locale;
getBaseContext().getResources().updateConfiguration(config,
getBaseContext().getResources().getDisplayMetrics());
this.setContentView(R.layout.main);

Answer 3

Crear una Application Extiende clase y crear un método estático. Luego, puede llamar a este método en todas las actividades antes de setContentView() .

public class MyApp extends Application {
@Override
public void onCreate() {
super.onCreate();
}
public static void setLocaleFa (Context context){
Locale locale = new Locale("fa");
Locale.setDefault(locale);
Configuration config = new Configuration();
config.locale = locale;
context.getApplicationContext().getResources().updateConfiguration(config, null);
}
public static void setLocaleEn (Context context){
Locale locale = new Locale("en_US");
Locale.setDefault(locale);
Configuration config = new Configuration();
config.locale = locale;
context.getApplicationContext().getResources().updateConfiguration(config, null);
}
}

Uso en actividades:

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
MyApp.setLocaleFa(MainActivity.this);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);
}

Answer 4

Es posible. Puede establecer la configuración regional. Sin embargo, no lo recomendaría. Lo hemos intentado en etapas tempranas, básicamente es luchar contra el sistema.

Tenemos el mismo requisito para cambiar el idioma, pero decidimos conformarnos con el hecho de que la IU debería ser la misma que la IU del teléfono. Estaba trabajando a través de la configuración regional, pero estaba demasiado buggy. Y debe configurarlo cada vez que ingrese a la actividad (cada actividad) desde mi experiencia. Aquí hay un código si aún lo necesita (de nuevo, no lo recomiendo)

Resources res = context.getResources();
// Change locale settings in the app.
DisplayMetrics dm = res.getDisplayMetrics();
android.content.res.Configuration conf = res.getConfiguration();
conf.setLocale(new Locale(language_code.toLowerCase())); // API 17+ only.
// Use conf.locale = new Locale(...) if targeting lower versions
res.updateConfiguration(conf, dm);

Si tiene contenido específico de idioma, puede cambiar esa base en la configuración.

Answer 5

Es realmente un trabajo:

fa = persa, en = inglés

Ingrese su código de languageToLoad en la variable languageToLoad :

import android.app.Activity;
import android.content.res.Configuration;
import android.os.Bundle;
public class Main extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
String languageToLoad = "fa"; // your language
Locale locale = new Locale(languageToLoad);
Locale.setDefault(locale);
Configuration config = new Configuration();
config.locale = locale;
getBaseContext().getResources().updateConfiguration(config,
getBaseContext().getResources().getDisplayMetrics());
this.setContentView(R.layout.main);
}
}

Puedes encontrar un ejemplo here

Answer 6

Estaba buscando una manera de cambiar el lenguaje del sistema mediante programación. Si bien entiendo perfectamente que una aplicación normal nunca debería hacer eso y, en su lugar, tampoco:

• el usuario debe apuntar (a través de un intento) a la configuración del sistema para cambiarlo manualmente
• la aplicación debe manejar su localización por sí misma tal como se describe en la respuesta de Alex

había una necesidad de cambiar realmente el lenguaje del sistema mediante programación.

¡Esta es una API no documentada y, por lo tanto, no debe utilizarse para aplicaciones de mercado / usuario final!

De todos modos aquí está la solución que encontré:

 Locale locale = new Locale(targetLocaleAsString);
Class amnClass = Class.forName("android.app.ActivityManagerNative");
Object amn = null;
Configuration config = null;
// amn = ActivityManagerNative.getDefault();
Method methodGetDefault = amnClass.getMethod("getDefault");
methodGetDefault.setAccessible(true);
amn = methodGetDefault.invoke(amnClass);
// config = amn.getConfiguration();
Method methodGetConfiguration = amnClass.getMethod("getConfiguration");
methodGetConfiguration.setAccessible(true);
config = (Configuration) methodGetConfiguration.invoke(amn);
// config.userSetLocale = true;
Class configClass = config.getClass();
Field f = configClass.getField("userSetLocale");
f.setBoolean(config, true);
// set the locale to the new value
config.locale = locale;
// amn.updateConfiguration(config);
Method methodUpdateConfiguration = amnClass.getMethod("updateConfiguration", Configuration.class);
methodUpdateConfiguration.setAccessible(true);
methodUpdateConfiguration.invoke(amn, config);

Answer 7

Estaba enfrentando el mismo problema. En GitHub encontré la biblioteca Android-LocalizationActivity .

Esta biblioteca hace que sea muy sencillo cambiar el idioma de su aplicación en tiempo de ejecución, como puede ver en el ejemplo de código a continuación. Un proyecto de muestra que incluye el código de muestra a continuación y más información se puede encontrar en la página de github.

LocalizationActivity extiende AppCompatActivity, por lo que también puede usarlo cuando está utilizando Fragmentos.

public class MainActivity extends LocalizationActivity implements View.OnClickListener {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_simple);
findViewById(R.id.btn_th).setOnClickListener(this);
findViewById(R.id.btn_en).setOnClickListener(this);
}
@Override
public void onClick(View v) {
int id = v.getId();
if (id == R.id.btn_en) {
setLanguage("en");
} else if (id == R.id.btn_th) {
setLanguage("th");
}
}
}

Answer 8

La única solución que me funciona completamente es una combinación del código de Alex Volovoy con el mecanismo de reinicio de la aplicación:

void restartApplication() {
Intent i = new Intent(MainTabActivity.context, MagicAppRestart.class);
i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
MainTabActivity.context.startActivity(i);
}
/** This activity shows nothing; instead, it restarts the android process */
public class MagicAppRestart extends Activity {
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
finish();
}
protected void onResume() {
super.onResume();
startActivityForResult(new Intent(this, MainTabActivity.class), 0);
}
}

Answer 9

La respuesta de Alex Volovoy solo funciona para mí si está en el método onCreate de la actividad.

La respuesta que funciona en todos los métodos está en otro hilo.

Cambia el lenguaje programáticamente en Android

Aquí está la adaptación del código.

Resources standardResources = getBaseContext().getResources();
AssetManager assets = standardResources.getAssets();
DisplayMetrics metrics = standardResources.getDisplayMetrics();
Configuration config = new Configuration(standardResources.getConfiguration());
config.locale = new Locale(languageToLoad);
Resources defaultResources = new Resources(assets, metrics, config);

Espero que ayude.

Answer 10

Me cambié para el idioma alemán para que mi aplicación se inicie.

Aquí está mi código correcto. Cualquiera quiere usar esto de la misma manera para mí ... (cómo cambiar el lenguaje en Android programáticamente)

mi código:

Configuration config ; // variable declaration in globally
// this part is given inside onCreate Method starting and before setContentView()
public void onCreate(Bundle icic)
{
super.onCreate(icic);
config = new Configuration(getResources().getConfiguration());
config.locale = Locale.GERMAN ;
getResources().updateConfiguration(config,getResources().getDisplayMetrics());
setContentView(R.layout.newdesign);
}

Answer 11

Sé que es tarde para responder pero encontré este artículo aquí . Lo que explica todo el proceso muy bien y le proporciona un código bien estructurado.

Locale Helper class:

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;
/**
* This class is used to change your application locale and persist this change for the next time
* that your app is going to be used.
* <p/>
* You can also change the locale of your application on the fly by using the setLocale method.
* <p/>
* Created by gunhansancar on 07/10/15.
*/
public class LocaleHelper {
private static final String SELECTED_LANGUAGE = "Locale.Helper.Selected.Language";
public static Context onAttach(Context context) {
String lang = getPersistedData(context, Locale.getDefault().getLanguage());
return setLocale(context, lang);
}
public static Context onAttach(Context context, String defaultLanguage) {
String lang = getPersistedData(context, defaultLanguage);
return setLocale(context, lang);
}
public static String getLanguage(Context context) {
return getPersistedData(context, Locale.getDefault().getLanguage());
}
public static Context setLocale(Context context, String language) {
persist(context, language);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
return updateResources(context, language);
}
return updateResourcesLegacy(context, language);
}
private static String getPersistedData(Context context, String defaultLanguage) {
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
return preferences.getString(SELECTED_LANGUAGE, defaultLanguage);
}
private static void persist(Context context, String language) {
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
SharedPreferences.Editor editor = preferences.edit();
editor.putString(SELECTED_LANGUAGE, language);
editor.apply();
}
@TargetApi(Build.VERSION_CODES.N)
private static Context updateResources(Context context, String language) {
Locale locale = new Locale(language);
Locale.setDefault(locale);
Configuration configuration = context.getResources().getConfiguration();
configuration.setLocale(locale);
configuration.setLayoutDirection(locale);
return context.createConfigurationContext(configuration);
}
@SuppressWarnings("deprecation")
private static Context updateResourcesLegacy(Context context, String language) {
Locale locale = new Locale(language);
Locale.setDefault(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;
}
}

Debe anular attachBaseContext y llamar a LocaleHelper.onAttach () para inicializar la configuración regional en su aplicación.

import android.app.Application;
import android.content.Context;
import com.gunhansancar.changelanguageexample.helper.LocaleHelper;
public class MainApplication extends Application {
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(LocaleHelper.onAttach(base, "en"));
}
}

Todo lo que tienes que hacer es agregar.

LocaleHelper.onCreate(this, "en");

Donde quiera que desee cambiar el local.

Answer 12

Si desea mantener el idioma cambiado en todas las aplicaciones, debe hacer dos cosas.

Primero, cree una Actividad base y extienda todas sus actividades a partir de esto:

public class BaseActivity extends AppCompatActivity {
private Locale mCurrentLocale;
@Override
protected void onStart() {
super.onStart();
mCurrentLocale = getResources().getConfiguration().locale;
}
@Override
protected void onRestart() {
super.onRestart();
Locale locale = getLocale(this);
if (!locale.equals(mCurrentLocale)) {
mCurrentLocale = locale;
recreate();
}
}
public static Locale getLocale(Context context){
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
String lang = sharedPreferences.getString("language", "en");
switch (lang) {
case "English":
lang = "en";
break;
case "Spanish":
lang = "es";
break;
}
return new Locale(lang);
}
}

Tenga en cuenta que guardo el nuevo idioma en sharedPreference.

Segundo, crea una extensión de aplicación como esta:

 public class App extends Application {
@Override
public void onCreate() {
super.onCreate();
setLocale();
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
setLocale();
}
private void setLocale() {
final Resources resources = getResources();
final Configuration configuration = resources.getConfiguration();
final Locale locale = getLocale(this);
if (!configuration.locale.equals(locale)) {
configuration.setLocale(locale);
resources.updateConfiguration(configuration, null);
}
}
}

Tenga en cuenta que getLocale () es el mismo que el anterior.

¡Eso es todo! Espero que esto pueda ayudar a alguien.

Answer 13

Si tu escribes

android:configChanges="locale"

en cada actividad que no es necesario configurarlo cada vez que ingrese a la actividad

Answer 14

Solo añadiendo una pieza extra que me hizo tropezar.

Mientras que las otras respuestas funcionan bien con "de" por ejemplo

String lang = "de";
Locale locale = new Locale(lang);
Locale.setDefault(locale);
Configuration config = new Configuration();
config.locale = locale;
getBaseContext().getResources().updateConfiguration(config,
getBaseContext().getResources().getDisplayMetrics());

Lo anterior no funcionará, por ejemplo, con la configuración regional "fr_BE" por lo que usaría la carpeta values-fr-rBE o similar.

Necesita el siguiente cambio leve para trabajar con "fr_BE"

String lang = "fr";
//create a string for country
String country = "BE";
//use constructor with country
Locale locale = new Locale(lang, country);
Locale.setDefault(locale);
Configuration config = new Configuration();
config.locale = locale;
getBaseContext().getResources().updateConfiguration(config,
getBaseContext().getResources().getDisplayMetrics());

Answer 15

Tenga en cuenta que esta solución que utiliza updateConfiguration ya no funcionará con el lanzamiento de Android M en unas pocas semanas. La nueva forma de hacerlo ahora es usar el método ContextThemeWrapper de ContextThemeWrapper ver documento de API

Puede encontrar mi solución completa aquí ya que enfrenté el problema yo mismo: https://.com/a/31787201/2776572

Answer 16

Tiempo para una actualización debida.

En primer lugar, la lista en desuso con la API en la que estaba en desuso:

• configuration.locale (API 17)
• updateConfiguration(configuration, displaymetrics) (API 17)

Lo que ninguna pregunta respondida recientemente ha acertado es el uso del nuevo método .

createConfigurationContext es el nuevo método para updateConfiguration.

Algunos lo han usado de forma independiente como esto:

Configuration overrideConfiguration = ctx.getResources().getConfiguration();
Locale locale = new Locale("en_US");
overrideConfiguration.setLocale(locale);
createConfigurationContext(overrideConfiguration);

... pero eso no funciona. ¿Por qué? El método devuelve un contexto, que luego se usa para manejar las traducciones de Strings.xml y otros recursos localizados (imágenes, diseños, lo que sea).

El uso adecuado es así:

Configuration overrideConfiguration = ctx.getResources().getConfiguration();
Locale locale = new Locale("en_US");
overrideConfiguration.setLocale(locale);
//the configuration can be used for other stuff as well
Context context = createConfigurationContext(overrideConfiguration);
Resources resources = context.getResources();

Si acaba de copiarlo y pegarlo en su IDE, puede ver una advertencia de que la API requiere que apunte a la API 17 o superior. Se puede @TargetApi(17) esto poniéndolo en un método y agregando la anotación @TargetApi(17)

Pero espera. ¿Qué pasa con las API más antiguas?

Debe crear otro método utilizando updateConfiguration sin la anotación TargetApi.

Resources res = YourApplication.getInstance().getResources();
// Change locale settings in the app.
DisplayMetrics dm = res.getDisplayMetrics();
android.content.res.Configuration conf = res.getConfiguration();
conf.locale = new Locale("th");
res.updateConfiguration(conf, dm);

No necesitas devolver un contexto aquí.

Ahora, manejar esto puede ser difícil. En API 17+ necesita el contexto creado (o los recursos del contexto creado) para obtener los recursos adecuados en función de la localización. Como manejas esto?

Bueno, esta es la forma en que lo hago:

/**
* Full locale list: https://.com/questions/7973023/what-is-the-list-of-supported-languages-locales-on-android
* @param lang language code (e.g. en_US)
* @return the context
* PLEASE READ: This method can be changed for usage outside an Activity. Simply add a COntext to the arguments
*/
public Context setLanguage(String lang/*, Context c*/){
Context c = AndroidLauncher.this;//remove if the context argument is passed. This is a utility line, can be removed totally by replacing calls to c with the activity (if argument Context isn''t passed)
int API = Build.VERSION.SDK_INT;
if(API >= 17){
return setLanguage17(lang, c);
}else{
return setLanguageLegacy(lang, c);
}
}
/**
* Set language for API 17
* @param lang
* @param c
* @return
*/
@TargetApi(17)
public Context setLanguage17(String lang, Context c){
Configuration overrideConfiguration = c.getResources().getConfiguration();
Locale locale = new Locale(lang);
Locale.setDefault(locale);
overrideConfiguration.setLocale(locale);
//the configuration can be used for other stuff as well
Context context = createConfigurationContext(overrideConfiguration);//"local variable is redundant" if the below line is uncommented, it is needed
//Resources resources = context.getResources();//If you want to pass the resources instead of a Context, uncomment this line and put it somewhere useful
return context;
}
public Context setLanguageLegacy(String lang, Context c){
Resources res = c.getResources();
// Change locale settings in the app.
DisplayMetrics dm = res.getDisplayMetrics();//Utility line
android.content.res.Configuration conf = res.getConfiguration();
conf.locale = new Locale(lang);//setLocale requires API 17+ - just like createConfigurationContext
Locale.setDefault(conf.locale);
res.updateConfiguration(conf, dm);
//Using this method you don''t need to modify the Context itself. Setting it at the start of the app is enough. As you
//target both API''s though, you want to return the context as you have no clue what is called. Now you can use the Context
//supplied for both things
return c;
}

Este código funciona al tener un método que realiza llamadas al método apropiado en función de qué API. Esto es algo que he hecho con muchas llamadas en desuso diferentes (incluido Html.fromHtml). Tiene un método que toma los argumentos necesarios, que luego lo divide en uno de dos (o tres o más) métodos y devuelve el resultado apropiado según el nivel de API. Es flexible ya que no tiene que revisar varias veces, el método de "entrada" lo hace por usted. El método de entrada aquí essetLanguage

POR FAVOR LEA ESTO ANTES DE USARLO

Necesita usar el contexto devuelto cuando obtiene recursos. ¿Por qué?He visto otras respuestas aquí que usan createConfigurationContext y no usan el contexto que devuelve. Para que funcione así, se debe llamar a updateConfiguration. Lo que está en desuso. Utilice el contexto devuelto por el método para obtener recursos.

Ejemplo de uso :

Constructor o en algún lugar similar:

ctx = getLanguage(lang);//lang is loaded or generated. How you get the String lang is not something this answer handles (nor will handle in the future)

Y luego, donde quiera que quiera obtener recursos, haga lo siguiente:

String fromResources = ctx.getString(R.string.helloworld);

Usar cualquier otro contexto (en teoría) romperá esto.

AFAIK todavía tiene que usar un contexto de actividad para mostrar diálogos o brindis. para eso puedes usar una instancia de una actividad (si estás fuera)

Y, finalmente, utilizar recreate()en la actividad para actualizar el contenido. Atajo para no tener que crear un intento de actualización.

Answer 17

Locale configuration Locale debe establecer en cada activity antes de configurar el contenido - this.setContentView(R.layout.main);

Answer 18

Según este artículo . Deberá descargar LocaleHelper.java referencia en ese artículo.

1. Crear la clase MyApplication que extenderá la Application
2. Reemplace attachBaseContext() para actualizar el idioma.

3. Registrar esta clase en manifiesto.

   public class MyApplication extends Application {
   @Override
   protected void attachBaseContext(Context base) {
   super.attachBaseContext(LocaleHelper.onAttach(base, "en"));
   }
   }
   <application
   android:name="com.package.MyApplication"
   .../>

4. Cree BaseActivity e onAttach() para actualizar el idioma. Necesario para Android 6+

   public class BaseActivity extends Activity {
   @Override
   protected void attachBaseContext(Context base) {
   super.attachBaseContext(LocaleHelper.onAttach(base));
   }
   }

5. Haz que todas las actividades en tu aplicación se extiendan desde BaseActivity .

   public class LocaleHelper {
   private static final String SELECTED_LANGUAGE = "Locale.Helper.Selected.Language";
   public static Context onAttach(Context context) {
   String lang = getPersistedData(context, Locale.getDefault().getLanguage());
   return setLocale(context, lang);
   }
   public static Context onAttach(Context context, String defaultLanguage) {
   String lang = getPersistedData(context, defaultLanguage);
   return setLocale(context, lang);
   }
   public static String getLanguage(Context context) {
   return getPersistedData(context, Locale.getDefault().getLanguage());
   }
   public static Context setLocale(Context context, String language) {
   persist(context, language);
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
   return updateResources(context, language);
   }
   return updateResourcesLegacy(context, language);
   }
   private static String getPersistedData(Context context, String defaultLanguage) {
   SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
   return preferences.getString(SELECTED_LANGUAGE, defaultLanguage);
   }
   private static void persist(Context context, String language) {
   SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
   SharedPreferences.Editor editor = preferences.edit();
   editor.putString(SELECTED_LANGUAGE, language);
   editor.apply();
   }
   @TargetApi(Build.VERSION_CODES.N)
   private static Context updateResources(Context context, String language) {
   Locale locale = new Locale(language);
   Locale.setDefault(locale);
   Configuration configuration = context.getResources().getConfiguration();
   configuration.setLocale(locale);
   configuration.setLayoutDirection(locale);
   return context.createConfigurationContext(configuration);
   }
   @SuppressWarnings("deprecation")
   private static Context updateResourcesLegacy(Context context, String language) {
   Locale locale = new Locale(language);
   Locale.setDefault(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;
   }
   }

Answer 19

Aquí hay un código que me funciona:

public class MainActivity extends AppCompatActivity {
public static String storeLang;
@Override
protected void onCreate(Bundle savedInstanceState) {
SharedPreferences shp = PreferenceManager.getDefaultSharedPreferences(this);
storeLang = shp.getString(getString(R.string.key_lang), "");
// Create a new Locale object
Locale locale = new Locale(storeLang);
// Create a new configuration object
Configuration config = new Configuration();
// Set the locale of the new configuration
config.locale = locale;
// Update the configuration of the Accplication context
getResources().updateConfiguration(
config,
getResources().getDisplayMetrics()
);
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

Fuente: here

Answer 20

En el ejemplo configuramos el idioma inglés:

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

Recuerde que esto funciona solo si el idioma también se encuentra en el sistema del dispositivo, no solo en la aplicación

Answer 21

Encontré el mismo problema: necesitaba configurar mi idioma en un idioma elegido en mi aplicación.

Mi solución fue esta:

1. Mantenga sus cadenas en su archivo XML, no lo extraiga a los recursos
2. Haga una copia exacta de su XML y cambie su nombre a _languagecode, como _fr (use minúsculas)
3. Arregla tus traducciones en tu copia XML
4. En el código, verifica el idioma de la aplicación e infla el XML relevante

Ejemplo:

 String languageInitials = MyAppconfig.currentLanguageInitials();
if (languageInitials.equals("NL")) {
view = inflater.inflate(R.layout.mylayout_nl, container, false);
} else {
view = inflater.inflate(R.layout.fragment_mylayout_fr, container, false);
}

De estos XML, aún puede extraer las cadenas necesarias a los recursos.

Answer 22

Esto funciona cuando presiono el botón para cambiar el idioma del texto de mi TextView. (Strings.xml en la carpeta de valores-de)

String languageToLoad = "de"; // your language
Configuration config = getBaseContext().getResources().getConfiguration();
Locale locale = new Locale(languageToLoad);
Locale.setDefault(locale);
config.locale = locale;
getBaseContext().getResources().updateConfiguration(config, getBaseContext().getResources().getDisplayMetrics());
recreate();

Answer 23

Funciona para mi

Resources res = YourApplication.getInstance().getResources();
// Change locale settings in the app.
DisplayMetrics dm = res.getDisplayMetrics();
android.content.res.Configuration conf = res.getConfiguration();
conf.locale = new Locale("th");
res.updateConfiguration(conf, dm);

Answer 24

Hay algunos pasos que debes implementar

Primero, necesitas cambiar la configuración regional de tu configuración

Resources resources = context.getResources();
Configuration configuration = resources.getConfiguration();
configuration.locale = new Locale(language);
resources.updateConfiguration(configuration, resources.getDisplayMetrics());

En segundo lugar, si desea que sus cambios se apliquen directamente al diseño que está visible, puede actualizar las vistas directamente o simplemente llamar a activity.recreate () para reiniciar la actividad actual.

Y también tiene que persistir en sus cambios porque después de que el usuario cierre su aplicación, perdería el cambio de idioma.

Expliqué una solución más detallada en la entrada de mi blog Cambiar idioma mediante programación en Android

Básicamente, solo llama a LocaleHelper.onCreate () en su clase de aplicación y si desea cambiar la configuración regional sobre la marcha puede llamar a LocaleHelper.setLocale ()

Answer 25

Primero crea valores de nombre de directorio: "Nombre de idioma" como hindi que escritura "hi" y la misma copia de nombre de archivo de cadena en este directorio y no cambia el parámetro después de configurar el código siguiente en su acción como botón, etc.

Locale myLocale = new Locale("hi");
Resources res = getResources();
DisplayMetrics dm = res.getDisplayMetrics();
Configuration conf = res.getConfiguration();
conf.locale = myLocale;
res.updateConfiguration(conf, dm);
Intent refresh = new Intent(Home.this, Home.class);
startActivity(refresh);
finish();

Answer 26

Solo manejar en metodo

@Override public void onConfigurationChanged(android.content.res.Configuration newConfig).

Sigue el Link

Creo que es util

Answer 27

similar a la versión respondida pero 2017 aceptada y reinicio agregado (sin reiniciar, a veces la siguiente actividad aún se traduce en inglés):

// Inside some activity...
private void changeDisplayLanguage(String langCode) {
// Step 1. Change the locale in the app''s configuration
Resources res = getResources();
android.content.res.Configuration conf = res.getConfiguration();
conf.setLocale(currentLocale);
createConfigurationContext(conf);
// Step 2. IMPORTANT! you must restart the app to make sure it works 100%
restart();
}
private void restart() {
PackageManager packageManager = getPackageManager();
Intent intent = packageManager.getLaunchIntentForPackage(getPackageName());
ComponentName componentName = intent.getComponent();
Intent mainIntent = IntentCompat.makeRestartActivityTask(componentName);
mainIntent.putExtra("app_restarting", true);
PrefUtils.putBoolean("app_restarting", true);
startActivity(mainIntent);
System.exit(0);
}

Answer 28

/*change language at Run-time*/
//use method like that:
//setLocale("en");
public void setLocale(String lang) {
myLocale = new Locale(lang);
Resources res = getResources();
DisplayMetrics dm = res.getDisplayMetrics();
Configuration conf = res.getConfiguration();
conf.locale = myLocale;
res.updateConfiguration(conf, dm);
Intent refresh = new Intent(this, AndroidLocalize.class);
startActivity(refresh);
}

Answer 29

Locale locale = new Locale("en");
Locale.setDefault(locale);
Configuration config = context.getResources().getConfiguration();
config.setLocale(locale);
context.createConfigurationContext(config);

Actualización importante:

context.getResources().updateConfiguration(config, context.getResources().getDisplayMetrics());

Tenga en cuenta que en SDK> = 21, debe llamar a ''Resources.updateConfiguration ()'' , de lo contrario los recursos no se actualizarán.

Answer 30

private void setLanguage(String language) {
Locale locale = new Locale(language);
Locale.setDefault(locale);
Configuration config = new Configuration();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
config.setLocale(locale);
} else {
config.locale = locale;
}
getResources().updateConfiguration(config,
getResources().getDisplayMetrics());
}