Changer la langue de l'application par programmation dans Android

Question

Est-il possible de changer la langue d'une application par programme tout en utilisant les ressources Android?

Sinon, est-il possible de demander une ressource dans une langue spécifique?

Je voudrais laisser l'utilisateur changer la langue de l'application à partir de l'application.

Answer 1

C'est possible. Vous pouvez définir les paramètres régionaux. Cependant, je ne recommanderais pas cela. Nous l'avons essayé au début, c'est fondamentalement la lutte contre le système.

Nous avons les mêmes exigences pour changer de langue, mais avons décidé de régler le fait que l'interface utilisateur devrait être identique à l'interface utilisateur téléphonique. Cela fonctionnait via les paramètres régionaux mais était trop bogué. Et vous devez le définir chaque fois que vous entrez activité (chaque activité) à partir de mon expérience. voici un code si vous en avez toujours besoin (encore une fois, je ne le recommande pas)

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 vous avez un contenu spécifique à la langue - vous pouvez modifier cette base sur le réglage.

Answer 2

C'est vraiment du travail:

fa = persan, en = anglais

Entrez votre code de langue dans 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);
  }
}

Answer 3

Je cherchais un moyen de changer la langue du système par programmation. Bien que je comprenne parfaitement qu’une application normale ne devrait jamais faire cela, mais plutôt:

• l'utilisateur doit être dirigé (par le biais d'une intention) vers les paramètres système pour le modifier manuellement
• l'application doit gérer sa localisation seule, comme décrit dans la réponse d'Alex

il fallait vraiment changer le langage du système par programmation.

Cette API est non documentée et ne devrait donc pas être utilisée pour des applications de marché/utilisateur final!

Quoi qu'il en soit, voici la solution que j'ai trouvée:

  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 4

Si vous souhaitez conserver le langage modifié dans l'ensemble de votre application, vous devez faire deux choses.

Tout d’abord, créez une activité de base et faites en sorte que toutes vos activités s’étendent de cette manière:

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

Notez que j'enregistre la nouvelle langue dans une référence partagée.

Deuxièmement, créez une extension d’Application comme ceci:

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

Notez que getLocale () est le même que ci-dessus.

C'est tout! J'espère que cela peut aider quelqu'un.

Answer 5

Juste en ajoutant un morceau supplémentaire qui m'a fait trébucher.

Alors que les autres réponses fonctionnent bien avec "de" par exemple

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

Ce qui précède ne fonctionnera pas avec, par exemple, "fr_BE" paramètres régionaux, de sorte que le dossier values-fr-rBE ou un fichier similaire sera utilisé.

Nécessite le léger changement suivant pour travailler avec "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 6

Selon cet article . Vous devrez télécharger LocaleHelper.Java référencé dans cet article.

1. Créez la classe MyApplication qui étendra Application
2. Remplacez attachBaseContext() pour mettre à jour la langue.

3. Inscrivez cette classe dans le manifeste.

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

4. Créez BaseActivity et remplacez onAttach() pour mettre à jour la langue. Nécessaire pour Android 6 +

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

5. Faire toutes les activités sur votre application va de 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 7

Je sais qu'il est tard pour répondre mais j'ai trouvé cet article ici . Ce qui explique très bien tout le processus et vous fournit un code bien structuré.

Classe d'assistance 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;
    }
}

Vous devez remplacer attachBaseContext et appeler LocaleHelper.onAttach () pour initialiser les paramètres régionaux dans votre application.

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

Tout ce que vous avez à faire est d'ajouter

LocaleHelper.onCreate(this, "en");

partout où vous voulez changer les paramètres régionaux.

Answer 8

Je suis changé pour la langue allemande pour mon application commence elle-même.

Voici mon code correct. Tout le monde veut utiliser la même chose pour moi .. (Comment changer de langue dans Android par programme)

mon code:

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 9

Créer une classe Étend Application et crée une méthode statique. Vous pouvez ensuite appeler cette méthode dans toutes les activités antérieures à 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);
}

}

Utilisation dans les activités:

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

Answer 10

Pour Android 7.0 Nougat (et versions inférieures), suivez cet article:

Changer la langue par programme dans Android

Ancienne réponse
Ceci inclut le support 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 11

Si vous écrivez

Android:configChanges="locale"

Dans chaque activité (dans le fichier manifeste), inutile de la définir à chaque fois que vous entrez Activity.

Answer 12

La seule solution qui fonctionne parfaitement pour moi est une combinaison du code d'Alex Volovoy avec le mécanisme de redémarrage de l'application:

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 13

Locale locale = new Locale("en");
Locale.setDefault(locale);

Configuration config = context.getResources().getConfiguration();
config.setLocale(locale);
context.createConfigurationContext(config);

Mise à jour importante:

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

Notez que sur le SDK> = 21, vous devez appeler 'Resources.updateConfiguration ()' , sinon les ressources ne seront pas mises à jour.

Answer 14

Temps pour une mise à jour due.

Tout d'abord, la liste obsolète avec l'API dans laquelle elle était obsolète:

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

La chose pour laquelle aucune question n'a été récemment répondue est l'utilisation de la nouvelle méthode.

createConfigurationContext est la nouvelle méthode pour updateConfiguration.

Certains l'ont utilisé seul, comme ceci:

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

... mais ça ne marche pas. Pourquoi? La méthode retourne un contexte, qui est ensuite utilisé pour gérer les traductions de Strings.xml et d'autres ressources localisées (images, mises en page, etc.).

Le bon usage est comme ça:

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 vous venez de copier-coller cela dans votre IDE, un avertissement peut vous avertir que l'API nécessite que vous cibliez l'API 17 ou supérieure. Cela peut être contourné en le mettant dans une méthode et en ajoutant l'annotation @TargetApi(17)

Mais attendez. Qu'en est-il des anciennes API?

Vous devez créer une autre méthode à l'aide de updateConfiguration sans l'annotation 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);

Vous n'avez pas besoin de retourner un contexte ici.

Maintenant, les gérer peut être difficile. Dans l'API 17+, vous devez créer le contexte (ou les ressources du contexte créées) pour obtenir les ressources appropriées en fonction de la localisation. Comment gérez-vous cela?

Eh bien, voici comment je le fais:

/**
 * 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;
}

Ce code fonctionne en utilisant une méthode qui appelle la méthode appropriée en fonction de quelle API. C’est quelque chose que j’ai fait avec beaucoup d’appels obsolètes (dont Html.fromHtml). Vous avez une méthode qui prend en compte les arguments nécessaires, puis la scinde en une (deux) ou plus (trois) méthodes et renvoie le résultat approprié en fonction du niveau de l'API. Il est flexible car vous n’avez pas à vérifier plusieurs fois, la méthode "entry" le fait pour vous. La méthode d'entrée ici est setLanguage

S'IL VOUS PLAÎT LIRE CECI AVANT DE L'UTILISER

Vous devez utiliser le contexte renvoyé lorsque vous obtenez des ressources. Pourquoi? J'ai vu d'autres réponses ici qui utilisent createConfigurationContext et n'utilisent pas le contexte qu'il renvoie. Pour que cela fonctionne ainsi, updateConfiguration doit être appelé. Ce qui est obsolète. Utilisez le contexte renvoyé par la méthode pour obtenir des ressources.

Exemple d'utilisation:

Constructeur ou similaire

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)

Et ensuite, là où vous voulez obtenir des ressources, vous faites:

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

L'utilisation de tout autre contexte permettra (en théorie) de résoudre ce problème.

Autant que je sache, il vous reste à utiliser un contexte d'activité pour afficher des dialogues ou des toasts. pour cela vous pouvez utiliser une instance d'une activité (si vous êtes à l'extérieur)

---

Et enfin, utilisez recreate() sur l'activité pour actualiser le contenu. Raccourci pour ne pas avoir à créer une intention d'actualiser.

Answer 15

Je faisais face au même problème. Sur GitHub, j'ai trouvé le bibliothèque Android-LocalizationActivity .

Cette bibliothèque facilite très simplement la modification de la langue de votre application lors de l'exécution, comme vous pouvez le constater dans l'exemple de code ci-dessous. Un exemple de projet comprenant l'exemple de code ci-dessous et plus d'informations est disponible sur la page github.

LocalizationActivity étend AppCompatActivity afin que vous puissiez également l'utiliser lorsque vous utilisez des 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");
        }
    }
}

Answer 16

Voici un code qui fonctionne pour moi:

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

Source: ici

Answer 17

Localeconfiguration doit être défini dans chaque activity avant de définir le contenu - this.setContentView(R.layout.main);

Answer 18

Au début, créez multi string.xml pour différentes langues; puis utilisez ce bloc de code dans la méthode 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 19

/*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 20

Prenez note que cette solution utilisant updateConfigurationne fonctionnera plus avec la version Android M à venir dans quelques semaines. La nouvelle façon de faire utilise maintenant la méthode applyOverrideConfiguration _ de ContextThemeWrappervoir la documentation sur l'API

Vous pouvez trouver ma solution complète ici puisque j'ai moi-même fait face au problème: https://stackoverflow.com/a/31787201/2776572

Answer 21

Alex Volovoy réponse ne fonctionne pour moi que si c'est dans la méthode onCreate de l'activité.

La réponse qui fonctionne dans toutes les méthodes est dans un autre thread

Changer la langue par programmation dans Android

Voici l'adaptation du code

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

J'espère que ça aide.

Answer 22

Cela fonctionne lorsque j'appuie sur le bouton pour changer la langue du texte de mon TextView (strings.xml dans le dossier 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();

Answer 23

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

}

Answer 24

similaire à la réponse acceptée mais version 2017 et redémarrage ajouté (sans redémarrer, parfois la prochaine activité restitue toujours en anglais):

// 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 25

Aucune des solutions énumérées ici ne m'a aidé.

La langue n'a pas activé Android> = 7.0 si AppCompatDelegate.setDefaultNightMode (AppCompatDelegate.MODE_NIGHT_YES)

Ceci LocaleUtils fonctionne très bien: https://Gist.github.com/GigigoGreenLabs/7d555c762ba2d3a810fe

LocaleUtils

public class LocaleUtils {

public static final String LAN_SPANISH      = "es";
public static final String LAN_PORTUGUESE   = "pt";
public static final String LAN_ENGLISH      = "en";

private static Locale sLocale;

public static void setLocale(Locale locale) {
    sLocale = locale;
    if(sLocale != null) {
        Locale.setDefault(sLocale);
    }
}

public static void updateConfig(ContextThemeWrapper wrapper) {
    if(sLocale != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        Configuration configuration = new Configuration();
        configuration.setLocale(sLocale);
        wrapper.applyOverrideConfiguration(configuration);
    }
}

public static void updateConfig(Application app, Configuration configuration) {
    if(sLocale != null && Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) {
        //Wrapping the configuration to avoid Activity endless loop
        Configuration config = new Configuration(configuration);
        config.locale = sLocale;
        Resources res = app.getBaseContext().getResources();
        res.updateConfiguration(config, res.getDisplayMetrics());
    }
}
}

Ajout de ce code à Application

public class App extends Application {
public void onCreate(){
    super.onCreate();

    LocaleUtils.setLocale(new Locale("iw"));
    LocaleUtils.updateConfig(this, getBaseContext().getResources().getConfiguration());
}

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    LocaleUtils.updateConfig(this, newConfig);
}
}

Code de l'activité

public class BaseActivity extends AppCompatActivity {
    public BaseActivity() {
        LocaleUtils.updateConfig(this);
    }
}

Answer 26

Par exemple, nous définissons la langue anglaise:

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

N'oubliez pas que cela ne fonctionne que si la langue est également trouvée dans le système de périphérique, pas seulement dans l'application

Answer 27

Tout d’abord, vous créez des valeurs de nom de répertoire - "Nom de langue" comme hindi puis écrivez "hi" et la même copie du nom de fichier chaîne dans ce répertoire et la valeur de modification ne changent pas de paramètre après avoir défini le code ci-dessous dans votre action, comme le bouton, 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 28

Vous devez mettre en œuvre certaines étapes

Tout d'abord, vous devez modifier les paramètres régionaux de votre configuration

Resources resources = context.getResources();

Configuration configuration = resources.getConfiguration();
configuration.locale = new Locale(language);

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

Deuxièmement, si vous souhaitez que vos modifications s'appliquent directement à la présentation visible, vous pouvez mettre à jour les vues directement ou simplement appeler activity.recreate () pour relancer l'activité en cours.

Et vous devez également conserver vos modifications, car après la fermeture de votre application, vous perdriez le changement de langue.

J'ai expliqué la solution plus détaillée sur mon blog Changer la langue par programme dans Android

Fondamentalement, vous appelez simplement LocaleHelper.onCreate () sur votre classe d’application et si vous souhaitez modifier les paramètres régionaux à la volée, vous pouvez appeler LocaleHelper.setLocale ().