È possibile modificare la lingua di un'app a livello di codice mentre si utilizzano ancora risorse Android?
In caso contrario, è possibile richiedere una risorsa in una lingua specifica?
Vorrei consentire all'utente di cambiare la lingua dell'app dall'app.
È possibile. È possibile impostare la locale. Tuttavia, non lo consiglierei. L'abbiamo provato nelle prime fasi, è fondamentalmente combattendo il sistema.
Abbiamo lo stesso requisito per cambiare la lingua, ma abbiamo deciso di accontentarci del fatto che l'interfaccia utente dovrebbe essere la stessa dell'interfaccia utente del telefono. Funzionava tramite l'impostazione locale, ma era troppo buggato. E devi impostarlo ogni volta che inserisci attività (ogni attività) dalla mia esperienza. ecco un codice se ne hai ancora bisogno (di nuovo, non lo consiglio)
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);
Se si dispone di contenuto specifico della lingua, è possibile modificare tale base sulle impostazioni.
Funziona davvero:
fa = persiano, en = inglese
Inserisci il tuo codice lingua nella variabile 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);
}
}
Puoi trovare un esempio qui
Stavo cercando un modo per cambiare la lingua del sistema a livello di programmazione. Mentre capisco perfettamente che una normale applicazione non dovrebbe mai farlo e invece:
c'era bisogno di cambiare davvero la lingua del sistema a livello di programmazione.
Questa è API non documentata e quindi non dovrebbe essere utilizzata per applicazioni di mercato/utente finale!
Comunque ecco la soluzione che ho trovato:
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);
Se vuoi mantenere la lingua modificata su tutte le tue app devi fare due cose.
Per prima cosa, crea un'attività di base e fai in modo che tutte le tue attività si estendano da questo:
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);
}
}
Nota che salverò la nuova lingua in un parametro sharedPreference.
Secondo, crea un'estensione di Applicazione come questa:
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);
}
}
}
Nota che getLocale () è lo stesso di sopra.
È tutto! Spero che questo possa aiutare qualcuno.
Aggiungo solo un pezzo in più che mi ha fatto inciampare.
Mentre le altre risposte funzionano bene con "de" per esempio
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());
Quanto sopra non funzionerà con "fr_BE"
locale ad esempio in modo che utilizzi la cartella values-fr-rBE
o simile.
Richiede la seguente leggera modifica per lavorare 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());
So che è tardi per rispondere, ma ho trovato questo articolo qui . Questo spiega l'intero processo molto bene e ti fornisce un codice ben strutturato.
Classe Helper Locale:
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;
}
}
È necessario eseguire l'override di attachBaseContext e chiamare LocaleHelper.onAttach () per inizializzare le impostazioni locali nell'applicazione.
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"));
}
}
Tutto quello che devi fare è aggiungere
LocaleHelper.onCreate(this, "en");
ovunque tu voglia cambiare la localizzazione.
Sono cambiato per la lingua tedesca per l'avvio della mia app stessa.
Ecco il mio codice corretto. Qualcuno vuole usare lo stesso per me .. (Come cambiare la lingua in Android a livello di programmazione)
il mio codice:
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);
}
In base a questo articolo . Dovrai scaricare LocaleHelper.Java
a cui si fa riferimento in quell'articolo.
MyApplication
che estenderà Application
attachBaseContext()
per aggiornare la lingua.Registra questa classe in manifest.
public class MyApplication extends Application {
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(LocaleHelper.onAttach(base, "en"));
}
}
<application
Android:name="com.package.MyApplication"
.../>
Crea BaseActivity
e sostituisci onAttach()
per aggiornare la lingua. Necessario per Android 6 +
public class BaseActivity extends Activity {
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(LocaleHelper.onAttach(base));
}
}
Rendi tutte le attività della tua app estese da 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;
}
}
Crea una classe Estende Application
e crea un metodo statico. Quindi puoi chiamare questo metodo in tutte le attività prima di 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);
}
}
Utilizzo in attività:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
MyApp.setLocaleFa(MainActivity.this);
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.activity_main);
}
Cambia lingua in modo programmatico su Android
Vecchia risposta
Questo include il supporto 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());
}
Se scrivi
Android:configChanges="locale"
In ogni attività (nel file manifest) non è necessario impostarlo ogni volta che si accede a Activity
.
L'unica soluzione che funziona pienamente per me è una combinazione del codice di Alex Volovoy con il meccanismo di riavvio dell'applicazione:
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);
}
}
Locale locale = new Locale("en");
Locale.setDefault(locale);
Configuration config = context.getResources().getConfiguration();
config.setLocale(locale);
context.createConfigurationContext(config);
Aggiornamento importante:
context.getResources().updateConfiguration(config, context.getResources().getDisplayMetrics());
Nota che su SDK> = 21, devi chiamare 'Resources.updateConfiguration ()' , altrimenti le risorse non saranno aggiornate.
Stavo affrontando lo stesso problema. Su GitHub ho trovato la libreria Android-LocalizationActivity .
Questa libreria rende molto semplice cambiare la lingua della tua app in fase di runtime, come puoi vedere nell'esempio di codice qui sotto. Un esempio di progetto che include il codice di esempio qui sotto e ulteriori informazioni si possono trovare nella pagina github.
LocalizationActivity estende AppCompatActivity, quindi puoi utilizzarlo anche quando usi Fragments.
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");
}
}
}
Tempo per un aggiornamento dovuto.
Prima di tutto, l'elenco deprecato con l'API in cui è stato ritirato:
configuration.locale
(API 17)updateConfiguration(configuration, displaymetrics)
(API 17)La cosa che non ha risposto a una domanda di recente ha avuto ragione è l'uso del nuovo metodo .
createConfigurationContext è il nuovo metodo per updateConfiguration.
Alcuni lo hanno usato come questo:
Configuration overrideConfiguration = ctx.getResources().getConfiguration();
Locale locale = new Locale("en_US");
overrideConfiguration.setLocale(locale);
createConfigurationContext(overrideConfiguration);
... ma non funziona. Perché? Il metodo restituisce un contesto, che viene quindi utilizzato per gestire le traduzioni di Strings.xml e altre risorse localizzate (immagini, layout, qualsiasi altra cosa).
L'uso corretto è come questo:
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();
Se l'hai incollato sul tuo IDE, potresti visualizzare un avviso che l'API richiede il targeting dell'API 17 o successiva. Questo può essere aggirato inserendolo in un metodo e aggiungendo l'annotazione @TargetApi(17)
Ma aspetta. Che mi dici delle API più vecchie?
È necessario creare un altro metodo utilizzando updateConfiguration senza l'annotazione 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);
Non è necessario restituire un contesto qui.
Ora, gestirli può essere difficile. In API 17+ è necessario creare il contesto creato (o le risorse dal contesto creato) per ottenere le risorse appropriate in base alla localizzazione. come lo gestisci?
Bene, questo è il modo in cui lo faccio:
/**
* Full locale list: https://stackoverflow.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;
}
Questo codice funziona con un metodo che effettua chiamate al metodo appropriato basato su quale API. Questo è qualcosa che ho fatto con molte chiamate obsolete (incluso Html.fromHtml). Si dispone di un metodo che accetta gli argomenti necessari, che quindi lo divide in uno dei due (o tre o più) metodi e restituisce il risultato appropriato in base al livello dell'API. È flessibile in quanto non è necessario controllare più volte, il metodo "entry" lo fa per te. Il metodo di immissione qui è setLanguage
È necessario utilizzare il contesto restituito quando si ricevono risorse. Perché? Ho visto qui altre risposte che usano createConfigurationContext e non usa il contesto che restituisce. Per farlo funzionare, deve essere chiamato updateConfiguration. Che è deprecato. Utilizzare il contesto restituito dal metodo per ottenere risorse.
Esempio di utilizzo :
Costruttore o qualcosa del genere:
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)
E poi, ovunque tu voglia ottenere risorse che fai:
String fromResources = ctx.getString(R.string.helloworld);
In qualunque altro contesto (in teoria) si rompe questo.
AFAIK devi ancora usare un contesto di attività per mostrare dialoghi o toast. per questo puoi usare un'istanza di un'attività (se sei fuori)
E infine, usa recreate()
sull'attività per aggiornare il contenuto. Collegamento per non dover creare un intento da aggiornare.
Locale
configuration
deve essere impostato in ogni activity
prima di impostare il contenuto - this.setContentView(R.layout.main);
Inizialmente crea multi string.xml per lingue diverse; quindi usa questo blocco di codice nel metodo 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);
/*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);
}
Ecco un codice che funziona per me:
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);
}
}
Fonte: qui
Prendi nota che questa soluzione che utilizza updateConfiguration
non funzionerà più con il rilascio di Android M in arrivo tra qualche settimana. Il nuovo modo per farlo ora è usare applyOverrideConfiguration
method da ContextThemeWrapper
vedi API doc
Puoi trovare la mia soluzione completa qui poiché ho affrontato il problema da solo: https://stackoverflow.com/a/31787201/2776572
La risposta di Alex Volovoy funziona solo per me se è nel metodo onCreate dell'attività.
La risposta che funziona in tutti i metodi è in un altro thread
Cambia lingua in modo programmatico in Android
Ecco l'adattamento del codice
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);
Spero che aiuti.
Funziona quando premo il pulsante per cambiare la lingua di testo del mio TextView. (Strings.xml nella cartella values-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();
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());
}
simile alla risposta accettata ma versione 2017 e riavvio aggiunto (senza riavvio, a volte la prossima attività rende ancora inglese):
// 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);
}
Nell'esempio impostiamo la lingua inglese:
Configuration config = GetBaseContext().getResources().getConfiguration();
Locale locale = new Locale("en");
Locale.setDefault(locale);
config.locale = locale;
GetBaseContext().getResources().updateConfiguration(config,
GetBaseContext().getResources().getDisplayMetrics());
Per favore, ricorda che funziona solo se si trova la lingua anche nel sistema Device, non solo nell'applicazione
Per prima cosa crei i valori del nome della directory- "Nome della lingua" come hindi che scrivi "hi" e copia lo stesso nome del file di stringa in questa directory e modifica il valore non cambia parametro dopo aver impostato sotto il codice nel tuo pulsante di azione come ecc.
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();
Ci sono alcuni passaggi che dovresti implementare
Innanzitutto, è necessario modificare le impostazioni locali della configurazione
Resources resources = context.getResources();
Configuration configuration = resources.getConfiguration();
configuration.locale = new Locale(language);
resources.updateConfiguration(configuration, resources.getDisplayMetrics());
In secondo luogo, se si desidera applicare le modifiche direttamente al layout che è visibile, è possibile aggiornare direttamente le viste oppure chiamare activity.recreate () per riavviare l'attività corrente.
E devi anche mantenere i tuoi cambiamenti perché dopo che l'utente ha chiuso la tua applicazione, avresti perso il cambio di lingua.
Ho spiegato una soluzione più dettagliata sul mio post del blog Cambia lingua in modo programmatico su Android
Fondamentalmente, si chiama LocaleHelper.onCreate () sulla classe dell'applicazione e se si desidera modificare l'impostazione locale al volo, è possibile chiamare LocaleHelper.setLocale ()