Android contexte.getResources.updateConfiguration() obsolète

Tout récemment contexte.getResources().updateConfiguration() a été dépréciée dans les API Android 25 et il est conseillé d'utiliser le contexte.createConfigurationContext() au lieu de cela.

Personne ne sait comment createConfigurationContext peuvent être utilisés pour remplacer les paramètres régionaux du système android?

avant que cela serait fait par:

Configuration config = getBaseContext().getResources().getConfiguration();
config.setLocale(locale);
context.getResources().updateConfiguration(config,
                                 context.getResources().getDisplayMetrics());

Que diriez - applyOverrideConfiguration (non testé)?
il y a aussi une solution simple, ici , très semblable à celui-ci stackoverflow.com/questions/39705739/...
[updateConfiguration était dépréciée de l'API de niveau 25] developer.android.com/reference/android/content/res/Resources

OriginalL'auteur Bassel Mourjan | 2016-10-24

88

Inspiré par La calligraphie, j'ai fini par créer un wrapper de contexte.
Dans mon cas, j'ai besoin de remplacer le système de la langue de fournir à mes utilisateurs de l'application avec la possibilité de changer d'application de la langue, mais ce qui peut être personnalisé avec toute la logique que vous avez besoin de mettre en œuvre.
```
    import android.annotation.TargetApi;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.res.Configuration;
import android.os.Build;
import java.util.Locale;
public class MyContextWrapper extends ContextWrapper {
public MyContextWrapper(Context base) {
super(base);
}
@SuppressWarnings("deprecation")
public static ContextWrapper wrap(Context context, String language) {
Configuration config = context.getResources().getConfiguration();
Locale sysLocale = null;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
sysLocale = getSystemLocale(config);
} else {
sysLocale = getSystemLocaleLegacy(config);
}
if (!language.equals("") && !sysLocale.getLanguage().equals(language)) {
Locale locale = new Locale(language);
Locale.setDefault(locale);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
setSystemLocale(config, locale);
} else {
setSystemLocaleLegacy(config, locale);
}
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
context = context.createConfigurationContext(config);
} else {
context.getResources().updateConfiguration(config, context.getResources().getDisplayMetrics());
}
return new MyContextWrapper(context);
}
@SuppressWarnings("deprecation")
public static Locale getSystemLocaleLegacy(Configuration config){
return config.locale;
}
@TargetApi(Build.VERSION_CODES.N)
public static Locale getSystemLocale(Configuration config){
return config.getLocales().get(0);
}
@SuppressWarnings("deprecation")
public static void setSystemLocaleLegacy(Configuration config, Locale locale){
config.locale = locale;
}
@TargetApi(Build.VERSION_CODES.N)
public static void setSystemLocale(Configuration config, Locale locale){
config.setLocale(locale);
}
}
```
et d'injecter votre enveloppe, dans chaque activité, ajoutez le code suivant:
```
@Override
protected void attachBaseContext(Context newBase) {
super.attachBaseContext(MyContextWrapper.wrap(newBase,"fr"));
}
```
Mise à JOUR 10/19/2018
Parfois, après un changement d'orientation, ou de l'activité mettre en pause/reprendre la Configuration de l'objet se remet à défaut de la Configuration du système et dans la suite, nous verrons l'application de l'affichage en anglais "fr" texte même si nous avons terminé le contexte français "fr" locale. Par conséquent, et comme une bonne pratique, ne jamais conserver le Contexte/l'Activité de l'objet dans une variable globale dans des activités ou des fragments.

en outre, de créer et d'utiliser les éléments suivants dans un MyBaseFragment ou MyBaseActivity:
```
public Context getMyContext(){
return MyContextWrapper.wrap(getContext(),"fr");
}
```
Cette pratique va vous fournir 100% sans bug solution.

J'ai un souci avec cette approche... C'est actuellement appliquées aux activités et ne sont pas l'ensemble de l'application. Ce qui va se passer pour l'application des composants qui ne peut pas démarrer à partir d'activités, comme les services?
Pourquoi voulez-vous prolonger la ContextWrapper? Vous n'avez rien, juste des méthodes statiques?
Je devais prendre createConfigurationContext/updateConfiguration de si-branche else et ajouter en dessous, sinon dans la première Activité, tout était ok, mais lors de l'ouverture de la deuxième, la langue de revenir à l'appareil par défaut. Ne pouvais pas trouver la raison.
J'ai ajouté le besoin de ligne et de poste en tant que ce principe: gist.github.com/muhammad-naderi/...
est droit. Les paramètres régionaux du système est modifié correctement, mais la configuration de passe par défaut. En conséquence, les chaînes de fichier de ressources revient à la valeur par défaut. Est-il un autre moyen, autre que le paramètre de configuration à chaque fois dans chaque activité

OriginalL'auteur Bassel Mourjan
21

Sans doute comme cela :
```
Configuration overrideConfiguration = getBaseContext().getResources().getConfiguration();
overrideConfiguration.setLocales(LocaleList);
Context context  = createConfigurationContext(overrideConfiguration);
Resources resources = context.getResources();
```
Bonus : Un article de blog qui utilisent createConfigurationContext()

Merci de me pointer dans la bonne direction, je crois que finalement on aura à créer un ContextWrapper et de l'attacher à des activités comme il est fait par la Calligraphie. De toute façon le prix est le vôtre, mais ne sera pas considérer comme une réponse définitive pas jusqu'à ce que je post le droit de codage de la solution de contournement.
Merci!!!! J'ai hâte de lire votre code
API 24+... Stupide google, peuvent-ils pas nous fournir un moyen simple?
En disant: "C'est simple, si vous ne cible que ces dispositifs" n'est pas vraiment simple.
Il y a une méthode simple si vous n'avez pas besoin de dispositifs de soutien qui ont été faits avant 2012. Bienvenue sur le développement de l'application!

OriginalL'auteur compte14031879

Inspiré par la Calligraphie & Mourjan & moi, j'ai créé cette.

vous devez d'abord créer une sous-classe de la Demande:

public class MyApplication extends Application {
private Locale locale = null;
@Override
public void onCreate() {
super.onCreate();
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
Configuration config = getBaseContext().getResources().getConfiguration();
String lang = preferences.getString(getString(R.string.pref_locale), "en");
String systemLocale = getSystemLocale(config).getLanguage();
if (!"".equals(lang) && !systemLocale.equals(lang)) {
locale = new Locale(lang);
Locale.setDefault(locale);
setSystemLocale(config, locale);
updateConfiguration(config);
}
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
if (locale != null) {
setSystemLocale(newConfig, locale);
Locale.setDefault(locale);
updateConfiguration(newConfig);
}
}
@SuppressWarnings("deprecation")
private static Locale getSystemLocale(Configuration config) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
return config.getLocales().get(0);
} else {
return config.locale;
}
}
@SuppressWarnings("deprecation")
private static void setSystemLocale(Configuration config, Locale locale) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
config.setLocale(locale);
} else {
config.locale = locale;
}
}
@SuppressWarnings("deprecation")
private void updateConfiguration(Configuration config) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
getBaseContext().createConfigurationContext(config);
} else {
getBaseContext().getResources().updateConfiguration(config, getBaseContext().getResources().getDisplayMetrics());
}
}
}

ensuite, vous devez définir à votre AndroidManifest.xml application tag:

<application
...
android:name="path.to.your.package.MyApplication"
>

et les ajouter à votre AndroidManifest.xml l'activité de la balise.

<activity
...
android:configChanges="locale"
>

noter que pref_locale est une ressource de chaîne comme ceci:

<string name="pref_locale">fa</string>

et coder en dur "fr" est par défaut lang si pref_locale n'est pas sertie

OriginalL'auteur Mahpooya

Voici @bassel-mourjan de la solution avec un peu de kotlin bonté 🙂 :

import android.annotation.TargetApi
import android.content.ContextWrapper
import android.os.Build
import java.util.*
@Suppress("DEPRECATION")
fun ContextWrapper.wrap(language: String): ContextWrapper {
val config = baseContext.resources.configuration
val sysLocale: Locale = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
this.getSystemLocale()
} else {
this.getSystemLocaleLegacy()
}
if (!language.isEmpty() && sysLocale.language != language) {
val locale = Locale(language)
Locale.setDefault(locale)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
this.setSystemLocale(locale)
} else {
this.setSystemLocaleLegacy(locale)
}
}
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
val context = baseContext.createConfigurationContext(config)
ContextWrapper(context)
} else {
baseContext.resources.updateConfiguration(config, baseContext.resources.displayMetrics)
ContextWrapper(baseContext)
}
}
@Suppress("DEPRECATION")
fun ContextWrapper.getSystemLocaleLegacy(): Locale {
val config = baseContext.resources.configuration
return config.locale
}
@TargetApi(Build.VERSION_CODES.N)
fun ContextWrapper.getSystemLocale(): Locale {
val config = baseContext.resources.configuration
return config.locales[0]
}
@Suppress("DEPRECATION")
fun ContextWrapper.setSystemLocaleLegacy(locale: Locale) {
val config = baseContext.resources.configuration
config.locale = locale
}
@TargetApi(Build.VERSION_CODES.N)
fun ContextWrapper.setSystemLocale(locale: Locale) {
val config = baseContext.resources.configuration
config.setLocale(locale)
}

Et voici comment l'utiliser:

override fun attachBaseContext(newBase: Context?) {
super.attachBaseContext(ContextWrapper(newBase).wrap(defaultLocale.language))
}

OriginalL'auteur Michael

0

Essayez ceci:
```
Configuration config = getBaseContext().getResources().getConfiguration();
config.setLocale(locale);
context.createConfigurationContext(config);
```
Je l'ai déjà essayé :p mais il ne veut pas faire l'affaire
Il crée l'activité u besoin de changer de contexte avec un nouveau

OriginalL'auteur Eric B.
0

il existe une solution simple avec contextWrapper ici : Android N changer la langue par programmation
Attention à la recréer() la méthode

Le lien est utile, et une bonne référence. Je crois que c'est mieux de façon à inclure la réponse ici, mais plutôt que d'exiger un clic supplémentaire.
vous avez raison, je suis tout nouveau sur stackoverflow et j'ai pensé qu'il serait erroné de prendre des crédits pour la réponse donc je poste le lien de l'auteur original

OriginalL'auteur Thanasis Saxanidis

Vous devez vous connecter pour publier un commentaire.