risposta-alla-domanda-sullo-sviluppo-web-bd.com

Cambia la lingua delle app in modo programmatico su Android

È 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.

381
hpique

È 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.

332
Alex Volovoy

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

155
AliSh

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:

  • l'utente deve essere indirizzato (attraverso un intento) alle impostazioni di sistema per modificarlo manualmente
  • l'applicazione dovrebbe gestire la sua localizzazione da sola proprio come descritto nella risposta di Alex

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);
32
icyerasor

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.

29
Daniel S.

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());
15
triggs

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.

13
Anirudh Sharma

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);
}
13
harikrishnan

In base a questo articolo . Dovrai scaricare LocaleHelper.Java a cui si fa riferimento in quell'articolo.

  1. Crea una classe MyApplication che estenderà Application
  2. Sostituisci attachBaseContext() per aggiornare la lingua.
  3. 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"
         .../>
    
  4. 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));
      }
    }
    
  5. 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;
    }
    }
    
12
Khaled Lela

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);
}
12
Behzad Taghipour

Per Android 7.0 Nougat (e versioni precedenti) segui questo articolo:

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());
}
9
Duda

Se scrivi

Android:configChanges="locale"

In ogni attività (nel file manifest) non è necessario impostarlo ogni volta che si accede a Activity.

8
Brijesh Masrani

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);         
    }
}
7
Misha
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");
        }
    }
}
5
Rockney

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

LEGGERE QUESTO PRIMA DI UTILIZZARLO

È 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.

4
Zoe

Localeconfiguration deve essere impostato in ogni activity prima di impostare il contenuto - this.setContentView(R.layout.main);

4
cheskapac

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);
4
Mohsen mokhtari
/*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); 
 }
4
altan yuksel

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

3
Til Schweiger

Prendi nota che questa soluzione che utilizza updateConfigurationnon funzionerà più con il rilascio di Android M in arrivo tra qualche settimana. Il nuovo modo per farlo ora è usare applyOverrideConfigurationmethod da ContextThemeWrappervedi API doc

Puoi trovare la mia soluzione completa qui poiché ho affrontato il problema da solo: https://stackoverflow.com/a/31787201/2776572

2
Xexiz

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.

2
gmauri21

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();
1
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());

}
1
Adeeb karim

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);
}
0
ericn

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

0
Pavel Pekki

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(); 
0
Dhaval Shingala

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 ()

0
Gunhan