Android kaynaklarını kullanırken bir uygulamanın dilini programlı olarak değiştirmek mümkün müdür?

Değilse, belirli bir dilde kaynak talep etmek mümkün müdür?

Kullanıcının uygulamanın dilini uygulamadan değiştirmesine izin vermek istiyorum.

Mümkün. Yerel ayarı ayarlayabilirsiniz. Ancak, ben bunu tavsiye etmem. İlk aşamalarda denedik, temel olarak sistemle savaşıyor.

Dili değiştirmek için aynı gereksinime sahibiz, ancak kullanıcı arayüzünün telefon kullanıcı arayüzüyle aynı olması gerektiğine karar vermeye karar verdik. Yerel ayarı ayarlayarak çalışıyordu ama çok adamcağız. Ve deneyimlerime göre her etkinliğe (her etkinlik) girdiğinizde bunu ayarlamanız gerekir. Hala buna ihtiyacınız varsa bir kod (yine, bunu tavsiye etmiyorum)

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

Dile özgü bir içeriğiniz varsa - ayarı temel alarak değiştirebilirsiniz.

2020 Mart ayının güncellemesi

public static void setLocale(Activitycontext) {
        Locale locale;
        Sessions session = new Sessions(context);
        //Log.e("Lan",session.getLanguage());
            locale = new Locale(langCode);
        Configuration config = new Configuration(context.getResources().getConfiguration());
        Locale.setDefault(locale);
        config.setLocale(locale);

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

Bu kod gerçekten işe yarıyor:

fa = Farsça, en = İngilizce

Dil kodunuzu languageToLoaddeğişkene girin :

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

Sistem dilini programlı olarak değiştirmenin bir yolunu arıyordum. Ben tam olarak normal bir uygulama asla bunu yerine, ya da yerine gerektiğini anlamak iken:

• kullanıcı manuel olarak değiştirmek için sistem ayarlarına yönlendirilmelidir (niyet yoluyla)
• uygulama Alex'in cevabında tarif edildiği gibi kendi lokalizasyonunu kendi başına ele almalıdır

sistemin dilini programlı olarak gerçekten değiştirmeye ihtiyaç vardı.

Bu belgesiz API'dir ve bu nedenle piyasa / son kullanıcı uygulamaları için kullanılmamalıdır!

Neyse bulduğum çözüm heres:

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

Tüm uygulamanızda değiştirilen dili korumak istiyorsanız iki şey yapmanız gerekir.

İlk olarak, temel bir Etkinlik oluşturun ve tüm etkinliklerinizin bundan genişlemesini sağlayın:

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

Yeni dili bir sharedPreference içinde kaydettiğimi unutmayın.

İkinci olarak, bunun gibi bir Uygulama uzantısı oluşturun:

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

GetLocale () yönteminin yukarıdakiyle aynı olduğunu unutmayın.

Bu kadar! Umarım bu birine yardımcı olabilir.

Bu makaleye göre . Bu LocaleHelper.javamakalede referans olarak indirmeniz gerekir .

1. Genişleyecek MyApplicationsınıf oluşturunApplication
2. Geçersiz Kıl attachBaseContext()Dili güncellemek için .

3. Bu sınıfı bildirimde kaydedin.

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

4. Dili güncellemek için oluşturun BaseActivityve geçersiz kılın onAttach(). Android 6+ için gerekli

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

5. Uygulamanızdaki tüm etkinliklerin kapsamını genişletin 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;
   }
   }

Beni harekete geçiren fazladan bir parça ekledim.

Diğer cevaplar örneğin "de" ile iyi çalışır

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

Yukarıdaki örnek, örneğin "fr_BE"yerel ayar ile çalışmaz .values-fr-rBE klasör veya benzeri .

Çalışmak için aşağıdaki küçük değişiklik gerekiyor "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());

Uygulamamın başlangıcı için Almanca olarak değiştirildim.

İşte benim doğru kodum. Herkes bunu benim için kullanmak istiyor .. (Android programlı olarak dil nasıl değiştirilir)

kodum:

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

Cevap vermek için geç olduğunu biliyorum ama bu makaleyi burada buldum . Bu da tüm süreci çok iyi açıklar ve iyi yapılandırılmış bir kod sağlar.

Yerel Yardım Yardımcısı sınıfı:

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

Uygulamanızdaki yerel ayarları başlatmak için attachBaseContext'i geçersiz kılmalı ve LocaleHelper.onAttach () öğesini çağırmalısınız.

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

Yapmanız gereken tek şey

LocaleHelper.onCreate(this, "en");

Yerel ayarı değiştirmek istediğiniz her yerde.

Sınıf Applicationoluşturma Statik bir yöntemi genişletir ve oluşturur. Daha sonra bu yöntemi daha önce tüm aktivitelerde çağırabilirsiniz 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);
}

}

Faaliyetlerde kullanım:

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

Android 7.0 Nougat (ve daha düşük) için bu makaleyi izleyin:

Android'de Programlı Dili Değiştirme

Eski cevap
Buna RTL / LTR desteği dahildir:

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

Benim için tamamen işe yarayan tek çözüm, Alex Volovoy kodunun uygulama yeniden başlatma mekanizmasıyla birleşimidir:

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

Aynı sorunla karşı karşıyaydım. GitHub'da Android-LocalizationActivity kütüphanesini buldum .

Bu kütüphane, aşağıdaki kod örneğinde de görebileceğiniz gibi, çalışma zamanında uygulamanızın dilini değiştirmeyi çok kolaylaştırır. Aşağıdaki örnek kodu ve daha fazla bilgiyi içeren örnek bir projeyi github sayfasında bulabilirsiniz.

LocalizationActivity, AppCompatActivity'yi genişletir, böylece Parçalar'ı kullanırken de kullanabilirsiniz.

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

Güncelleme zamanı.

İlk olarak, kullanımdan kaldırıldığı API ile kullanımdan kaldırılmış liste:

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

Son zamanlarda cevaplanmayan soru doğru olan şey yeni yöntemin kullanılmasıdır .

createConfigurationContext, updateConfiguration için yeni yöntemdir.

Bazıları bunu bağımsız olarak kullanmıştır:

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

... ama bu işe yaramıyor. Neden? Yöntem, daha sonra Strings.xml çevirilerini ve diğer yerelleştirilmiş kaynakları (görüntüler, düzenler, her neyse) işlemek için kullanılan bir bağlam döndürür.

Doğru kullanım şöyle:

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

Bunu yalnızca IDE'nize kopyaladıysanız, API'nın API 17 veya üstünü hedeflemenizi gerektirdiğini belirten bir uyarı görebilirsiniz. Bu, bir yönteme koyarak ve ek açıklama ekleyerek çözülebilir@TargetApi(17)

Fakat bekle. Eski API'ler ne olacak?

TargetApi ek açıklaması olmadan updateConfiguration'ı kullanarak başka bir yöntem oluşturmanız gerekir.

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

Burada bir bağlam döndürmeniz gerekmez.

Şimdi, bunları yönetmek zor olabilir. API 17+ sürümünde, yerelleştirmeye göre uygun kaynakları elde etmek için oluşturulan bağlama (veya oluşturulan bağlamdaki kaynaklara) ihtiyacınız vardır. Bununla nasıl başa çıkıyorsun?

Ben de bunu yapıyorum:

/**
 * Full locale list: /programming/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;
}

Bu kod, hangi API'ye dayalı olarak uygun yönteme çağrı yapan bir yönteme sahip olarak çalışır. Bu, birçok farklı kullanımdan kaldırılmış çağrı (Html.fromHtml dahil) ile yaptığım bir şey. Gerekli bağımsız değişkenleri alan ve daha sonra bunu iki (veya üç veya daha fazla) yöntemden birine böler ve API düzeyine göre uygun sonucu döndüren bir yönteminiz vardır. Birden fazla kez kontrol etmek zorunda olmadığınız için esnektir, "giriş" yöntemi sizin için yapar. Buradaki giriş yöntemisetLanguage

LÜTFEN KULLANMADAN ÖNCE BUNU OKUYUN

Kaynakları aldığınızda döndürülen Bağlamı kullanmanız gerekir. Neden? Burada createConfigurationContext kullanan ve döndürdüğü bağlamı kullanmayan diğer cevaplar gördüm. Bu şekilde çalışması için updateConfiguration'ın çağrılması gerekir. Hangi kullanımdan kaldırıldı. Kaynakları almak için yöntem tarafından döndürülen bağlamı kullanın.

Örnek kullanım :

Yapıcı veya benzeri bir yerde:

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)

Ve sonra, nereden kaynak almak isterseniz yapın:

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

Başka bir bağlam kullanmak (teoride) bunu kıracaktır.

AFAIK, iletişim kutularını veya Tost'ları göstermek için hala bir etkinlik bağlamı kullanmanız gerekir. bunun için bir etkinliğin örneğini kullanabilirsiniz (dışarıdaysanız)

Son olarak, recreate()içeriği yenilemek için etkinliği kullanın. Yenileme amacı yaratmak zorunda kalmamak için kısayol.

Yazarsan

android:configChanges="locale"

Her aktivitede (manifest dosyasında), her girişinizde ayarlamanıza gerek yoktur Activity.

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

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

Önemli güncelleme:

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

SDK> = 21'de 'Resources.updateConfiguration ()' öğesini çağırmanız gerektiğini , aksi takdirde kaynakların güncellenmeyeceğini unutmayın.

/*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 configurationactivityiçeriği ayarlamadan önce her birinde ayarlanmalıdır -this.setContentView(R.layout.main);

İlk başta farklı diller için multi string.xml oluşturun; daha sonra onCreate()yöntemde bu kod bloğunu kullanın :

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

İşte benim için çalışan bazı kod:

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

Kaynak: burada

Burada listelenen çözümlerin hiçbiri bana yardımcı olmadı.

AppCompatDelegate.setDefaultNightMode (AppCompatDelegate.MODE_NIGHT_YES) ise dil android> = 7.0'da açılmadı

Bu LocaleUtils gayet iyi çalışıyor: 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());
    }
}
}

Bu kodu Uygulamaya ekledi

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

Faaliyetteki Kod

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

Alex Volovoy yanıtı sadece etkinliğin onCreate yönteminde ise benim için çalışır.

Tüm yöntemlerde çalışan cevap başka bir iş parçacığında

Android'de dili programlı olarak değiştirme

İşte kodun uyarlanması

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

Umarım yardımcı olur.

Bu çözümün birkaç hafta içinde updateConfiguration Android M sürümü ile artık çalışmayacağını unutmayın . Bunu yapmanın yeni yolu şimdi API belgesine bakınapplyOverrideConfiguration yöntemini kullanmaktırContextThemeWrapper

Sorunla yüzleştiğimden beri tam çözümümü burada bulabilirsiniz: https://stackoverflow.com/a/31787201/2776572

Uygulamanız gereken bazı adımlar var

İlk olarak, yapılandırmanızın yerel ayarını değiştirmeniz gerekir

Resources resources = context.getResources();

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

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

İkinci olarak, değişikliklerinizin doğrudan görünen görünüme uygulanmasını istiyorsanız, görünümleri doğrudan güncelleyebilir veya geçerli etkinliği yeniden başlatmak için activity.recreate () öğesini çağırabilirsiniz.

Ayrıca, kullanıcı uygulamanızı kapattıktan sonra dil değişikliğini kaybedeceğiniz için değişikliklerinizi sürdürmeniz gerekir.

Blog yazımda daha ayrıntılı bir çözüm açıkladım Android'de Dili Programlı Olarak Değiştirin

Temel olarak, uygulama sınıfınızda LocaleHelper.onCreate () öğesini çağırırsınız ve yerel ayarlarınızı anında değiştirmek isterseniz LocaleHelper.setLocale () öğesini çağırabilirsiniz.

Bu benim TextView metin dilini değiştirmek için düğmesine bastığımda çalışıyor. (Değerler-de klasöründe strings.xml)

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

LocaleHelper sınıfı ekle

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

Etkinlik veya Parça İçinde

Context context = LocaleHelper.setLocale(this, App.getSharedPre().getLanguage());
Resource resources = context.getResources();

Şimdi her metinde SetText

TextView tv = findViewById(R.id.tv);
tv.setText(resources.getString(R.string.tv));

kabul edilen cevaplanmış ancak 2017 sürümüne benzer ve yeniden başlatma eklendi (yeniden başlatmadan, bazen bir sonraki Etkinlik hala İngilizce sağlıyor):

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

Öncelikle bu dizine "hi" ve aynı dize dosya adı kopyasını yazmaktan daha hintçe gibi dizin adı değerleri - "Dil adı" oluşturun ve değeri değiştir vb.

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

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

}

Örneğin İngilizce dilini ayarladık:

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

Lütfen bunun yalnızca uygulamada değil, Cihaz sisteminde de dil bulunması durumunda işe yaradığını unutmayın.

Arapça / RTL desteği için

1. Dil ayarlarınızı - attachBaseContext () yoluyla güncellemelisiniz
2. Android sürüm N ve üstü için createConfigurationContext () & updateConfiguration () kullanmalısınız - aksi takdirde RTL düzeni düzgün çalışmıyor

 @Override
    protected void attachBaseContext(Context newBase) {
        super.attachBaseContext(updateBaseContextLocale(newBase));
    }

    public Context updateBaseContextLocale(Context context) {
        String language = SharedPreference.getInstance().getValue(context, "lan");//it return "en", "ar" like this
        if (language == null || language.isEmpty()) {
            //when first time enter into app (get the device language and set it
            language = Locale.getDefault().getLanguage();
            if (language.equals("ar")) {
                SharedPreference.getInstance().save(mContext, "lan", "ar");
            }
        }
        Locale locale = new Locale(language);
        Locale.setDefault(locale);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            updateResourcesLocale(context, locale);
            return  updateResourcesLocaleLegacy(context, locale);
        }

        return updateResourcesLocaleLegacy(context, locale);
    }

    @TargetApi(Build.VERSION_CODES.N)
    private Context updateResourcesLocale(Context context, Locale locale) {
        Configuration configuration = context.getResources().getConfiguration();
        configuration.setLocale(locale);
        return context.createConfigurationContext(configuration);
    }

    @SuppressWarnings("deprecation")
    private Context updateResourcesLocaleLegacy(Context context, Locale locale) {
        Resources resources = context.getResources();
        Configuration configuration = resources.getConfiguration();
        configuration.locale = locale;
        resources.updateConfiguration(configuration, resources.getDisplayMetrics());
        return context;
    }