C'est vraiment du travail:

fa= persan, en = English

entrez votre code de langue dans languageToLoad variable:

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

vous pouvez trouver un exemple ici

je cherchais un moyen pour changer la langue du programme. Bien que je comprenne parfaitement qu'une application normale ne devrait jamais faire cela et à la place:

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

il était nécessaire de vraiment changer le langage du système programmtiquement.

il s'agit d'une API non documentée et ne doit donc pas être utilisée pour les applications du marché/utilisateur final!

voici de toute façon 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);

si vous voulez maintenir le langage changé sur toute votre application, vous devez faire deux choses.

tout d'abord, créez une activité de base et faites que toutes vos activités s'étendent à partir de ceci:

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 je sauve la nouvelle langue dans une référence partagée.

Deuxièmement, créer 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.

je suis changé pour la langue allemande pour mon application démarrer elle-même.

Voici mon code. Quelqu'un veut utiliser ce même pour moi.. (Comment changer de langue dans android par programmation)

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

ajoute juste une pièce 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 fonctionne pas avec par exemple "fr_BE" locale de sorte qu'il utiliserait le dossier values-fr-rBE ou similaire.

nécessite le léger changement suivant pour fonctionner 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());

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

Local Helper class:

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

import java.util.Locale;

/**
 * This class is used to change your application locale and persist this change for the next time
 * that your app is going to be used.
 * <p/>
 * You can also change the locale of your application on the fly by using the setLocale method.
 * <p/>
 * Created by gunhansancar on 07/10/15.
 */
public class LocaleHelper {

    private static final String SELECTED_LANGUAGE = "Locale.Helper.Selected.Language";

    public static Context onAttach(Context context) {
        String lang = getPersistedData(context, Locale.getDefault().getLanguage());
        return setLocale(context, lang);
    }

    public static Context onAttach(Context context, String defaultLanguage) {
        String lang = getPersistedData(context, defaultLanguage);
        return setLocale(context, lang);
    }

    public static String getLanguage(Context context) {
        return getPersistedData(context, Locale.getDefault().getLanguage());
    }

    public static Context setLocale(Context context, String language) {
        persist(context, language);

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

        return updateResourcesLegacy(context, language);
    }

    private static String getPersistedData(Context context, String defaultLanguage) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        return preferences.getString(SELECTED_LANGUAGE, defaultLanguage);
    }

    private static void persist(Context context, String language) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        SharedPreferences.Editor editor = preferences.edit();

        editor.putString(SELECTED_LANGUAGE, language);
        editor.apply();
    }

    @TargetApi(Build.VERSION_CODES.N)
    private static Context updateResources(Context context, String language) {
        Locale locale = new Locale(language);
        Locale.setDefault(locale);

        Configuration configuration = context.getResources().getConfiguration();
        configuration.setLocale(locale);
        configuration.setLayoutDirection(locale);

        return context.createConfigurationContext(configuration);
    }

    @SuppressWarnings("deprecation")
    private static Context updateResourcesLegacy(Context context, String language) {
        Locale locale = new Locale(language);
        Locale.setDefault(locale);

        Resources resources = context.getResources();

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

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

        return context;
    }
}

vous devez annuler attachBaseContext et appeler LocaleHelper.onAttach () pour initialiser les paramètres de localisation 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");

là où vous voulez changer le lieu.

créer une classe étend Application et créer une méthode statique. Vous pouvez alors appeler cette méthode dans toutes les activités avant 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);
}

}

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

pour Android 7.0 Nougat (et inférieur) suivre cet article:

Changer la Langue par programmation sous Android

Vieille réponse

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

Si u écrire

android:configChanges="locale"

dans chaque activité qu'il n'est pas nécessaire de régler chaque fois que vous entrez dans l'activité

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

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 SDK >= 21, vous devez appeler 'Resources.updateConfiguration () ' , sinon les ressources ne seront pas mises à jour.

je faisais face à la même question. Sur GitHub j'ai trouvé le Android-LocalizationActivity library .

cette bibliothèque rend très simple de changer la langue de votre application à l'exécution, comme vous pouvez le voir dans l'exemple de code ci-dessous. Un exemple de projet comprenant le code ci-dessous et plus d'informations sont disponibles sur la page github.

la LocalizationActivity étend AppCompatActivity, de sorte que vous pouvez également l'utiliser lorsque vous êtes en utilisant 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");
        }
    }
}

selon cet article

1. créer MyApplication classe qui s'étend Application
2. outrepasser attachBaseContext() pour mettre à jour le langage.

3. inscrire 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éer BaseActivity et remplacer onAttach() pour mettre à jour le langage. Nécessaire pour Android 6+

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

5. toutes les activités sur votre application s'étendent 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;
   }
   }
   

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

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

crée d'abord une chaîne multi.xml pour différentes langues; puis utiliser ce bloc de code dans onCreate() méthode:

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

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

la réponse qui fonctionne dans toutes les méthodes est dans un autre fil

modifier le langage programmatique sur 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 aidera.

notez que cette solution utilisant updateConfiguration ne fonctionnera plus avec la version Android M dans quelques semaines. La nouvelle façon de le faire est maintenant d'utiliser la méthode applyOverrideConfiguration de ContextThemeWrapper voir API doc

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

C'est l'Heure de la mise à jour.

tout d'abord, la liste dépréciée avec L'API dans laquelle elle était dépréciée:

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

la chose à laquelle aucune question n'a répondu récemment a obtenu droit 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 cela ne fonctionne pas. Pourquoi? La méthode renvoie un contexte, qui est ensuite utilisé pour gérer les chaînes.traductions xml et autres ressources localisées (images, mises en page, etc.).

l'usage correct est comme ceci:

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-collé dans votre IDE, vous pouvez voir un avertissement que l'API nécessite que vous cibliez L'API 17 ou plus. Cela peut être travaillé autour en le mettant dans une méthode et en ajoutant l'annotation @TargetApi(17)

mais attendez. Quel est le plus vieux de l'API?

vous devez créer une autre méthode en utilisant 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, la gestion de ceux-ci peut être difficile. Dans API 17+ , Vous avez besoin de contexte créé (ou les ressources du contexte créé) pour obtenir les ressources appropriées en fonction de la localisation. Comment gérez-vous cela?

Eh bien, c'est comme ça que je le fais:

/**
 * Full locale list: /q/what-is-the-list-of-supported-languages-locales-on-android-28044/"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 ayant une méthode qui fait des appels à la méthode appropriée basée sur ce que L'API. C'est quelque chose que j'ai fait avec beaucoup de différents obsolète appels (y compris Html.fromHtml). Vous avez une méthode qui prend en arguments nécessaires, qui la divise ensuite en deux (ou trois ou plus) Méthodes et renvoie le résultat approprié basé sur le niveau de L'API. Il est flexible, car vous n'avez pas à vérifier plusieurs fois, "" la méthode le fait pour vous. La méthode d'entrée ici est setLanguage

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

Vous devez utiliser le Contexte retourné lorsque vous obtenir des ressources. Pourquoi? J'ai vu d'autres réponses ici qui utilisez createConfigurationContext et n'utilisez pas le contexte qu'il renvoie. Pour qu'il fonctionne comme ça, updateConfiguration doit être appelé. Qui est obsolète. Utiliser le contexte retourné par la méthode pour obtenir des ressources.

exemple d'usage :

constructeur ou quelque part 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 puis, où vous voulez obtenir des ressources que vous faites:

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

à l'Aide de tout autre contexte (en théorie) de rompre cette.

AFAIK vous devez toujours utiliser un contexte d'activité pour afficher des dialogues ou des Toasts. pour cela, vous pouvez utiliser une instance d'activité (si vous êtes à l'extérieur)

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

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

}

il y a quelques étapes que vous devriez mettre en œuvre""

tout d'abord, vous devez changer la localisation 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 voulez que vos modifications s'appliquent directement à la mise en page qui est visible, vous pouvez soit mettre à jour les vues directement, soit simplement appeler activité.recréer() pour redémarrer l'activité en cours.

et aussi vous devez persister vos changements parce qu'après l'utilisateur ferme votre application ensuite, vous perdriez le changement de langue.

j'ai expliqué la solution plus détaillée sur mon blog post changement de langue programmatique dans Android

en gros, vous appelez juste LocaleHelper.onCreate () sur votre classe d'application et si vous voulez changer de locale à la volée, vous pouvez appeler LocaleHelper.setLocale ()

similaire à la réponse acceptée, mais version 2017 et ajouté redémarrage (sans redémarrage, parfois la prochaine activité rend encore l'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);
}

tout d'abord, vous créez des valeurs de nom de répertoire-"nom de langue" comme hindi que d'écrire "hi" et même chaîne de caractères Nom de fichier copie dans ce répertoire et changer la valeur ne changez pas le paramètre après le code défini ci-dessous dans votre action comme 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(); 

cela fonctionne lorsque j'appuie sur Bouton pour changer la langue de texte de mon TextView.(chaîne.xml dans les valeurs de dossier)

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

dans l'exemple nous avons mis 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());

s'il vous plaît, rappelez-vous que cela ne fonctionne que si la langue se trouve aussi dans le système de périphérique, et pas seulement dans l'application

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

Juste la poignée dans la méthode

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

suivre le lien

je pense que c'est utile

j'ai rencontré le même problème: je devais définir ma langue à une langue choisie dans mon application.

ma solution était celle-ci:

1. Gardez vos chaînes dans votre fichier XML, ne l'extrayez pas vers des ressources
2. faites une copie exacte de votre XML et renommez - le en _languagecode, comme _fr (utiliser des minuscules!)
3. Correction de vos traductions dans votre copie XML
4. en code vous vérifiez votre niveau d'application la langue et gonfler les XML

exemple:

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

à partir de ces XML, vous pouvez toujours extraire les chaînes de caractères nécessaires aux ressources.

Il travailler pour moi

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