Android
Localizzazione con risorse in Android

Moneta

Currency currency = Currency.getInstance("USD");
NumberFormat format = NumberFormat.getCurrencyInstance();
format.setCurrency(currency);
format.format(10.00);

Aggiunta di traduzione alla tua app Android

Devi creare un file strings.xml diverso per ogni nuova lingua.

1. Fare clic con il tasto destro sulla cartella res
2. Scegli Nuovo → File delle risorse dei valori
3. Seleziona una locale dai qualificatori disponibili
4. Fare clic sul pulsante Avanti (>>)
5. Seleziona una lingua
6. Denominare il file strings.xml

strings.xml

<resources>
    <string name="app_name">Testing Application</string>
    <string name="hello">Hello World</string>
</resources>

strings.xml (hi)

<resources>
    <string name="app_name">परीक्षण आवेदन</string>
    <string name="hello">नमस्ते दुनिया</string>
</resources>

Impostazione della lingua in modo programmatico:

public void setLocale(String locale) // Pass "en","hi", etc.
{
    myLocale = new Locale(locale);
    // Saving selected locale to session - SharedPreferences.
    saveLocale(locale);
    // Changing locale.
    Locale.setDefault(myLocale);
    android.content.res.Configuration config = new android.content.res.Configuration();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        config.setLocale(myLocale);
    } else {
        config.locale = myLocale;
    }
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        getBaseContext().createConfigurationContext(config);
    } else {
        getBaseContext().getResources().updateConfiguration(config, getBaseContext().getResources().getDisplayMetrics());
    }
}

La funzione sopra cambierà i campi di testo a cui si fa riferimento da strings.xml . Ad esempio, supponi di avere le seguenti due visualizzazioni di testo:

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" 
    android:text="@string/app_name"/>
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" 
    android:text="@string/hello"/>

Quindi, dopo aver modificato le app_name internazionali, le stringhe della lingua con gli ids app_name e hello verranno modificate di conseguenza.

Tipo di directory di risorse nella cartella "res"

Quando è necessario localizzare diversi tipi di risorse, ognuna delle quali ha la propria casa nella struttura del progetto Android. Di seguito sono riportate le diverse directory che possiamo inserire nella directory \res . I tipi di risorse inseriti in ciascuna di queste directory sono spiegati nella tabella seguente:

Tipi di configurazione e nomi dei qualificatori per ciascuna cartella nella directory "res"

Ogni directory di risorse nella cartella res (elencata nell'esempio sopra) può avere diverse varianti delle risorse contenute in una directory con nome simile, con suffissi diversi qualifier-values per ogni configuration-type .

Esempio di variazioni della directory `` con diversi valori di qualificatore suffissi che sono spesso visti nei nostri progetti Android:

• drawable /
• drawable-it /
• drawable-fr-RCA /
• drawable-en-port /
• drawable-en-NoTouch-12key /
• drawable-port-ldpi /
• drawable-port-NoTouch-12key /

Elenco esaustivo di tutti i diversi tipi di configurazione e dei loro valori di qualificatore per le risorse Android:

Cambia la localizzazione dell'applicazione Android programmaticamente

Negli esempi precedenti capisci come localizzare le risorse dell'applicazione. L'esempio seguente spiega come modificare la locale dell'applicazione all'interno dell'applicazione, non dal dispositivo. Per modificare solo le impostazioni locali dell'applicazione, è possibile utilizzare l'utilità di localizzazione sottostante.

import android.app.Application;
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 android.view.ContextThemeWrapper;

import java.util.Locale;

/**
 * Created by Umesh on 10/10/16.
 */
public class LocaleUtils {

    private static Locale mLocale;

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

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

    public static void updateConfiguration(Application application, Configuration configuration){
        if(mLocale != null && Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1){
            Configuration config = new Configuration(configuration);
            config.locale = mLocale;
            Resources res = application.getBaseContext().getResources();
            res.updateConfiguration(configuration, res.getDisplayMetrics());
        }
    }

    public static void updateConfiguration(Context context, String language, String country){
        Locale locale = new Locale(language,country);
        setLocale(locale);
        if(mLocale != null){
            Resources res = context.getResources();
            Configuration configuration = res.getConfiguration();
            configuration.locale = mLocale;
            res.updateConfiguration(configuration,res.getDisplayMetrics());
        }
    }




    public static String getPrefLangCode(Context context) {
        return PreferenceManager.getDefaultSharedPreferences(context).getString("lang_code","en");
    }

    public static void setPrefLangCode(Context context, String mPrefLangCode) {

        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
        editor.putString("lang_code",mPrefLangCode);
        editor.commit();
    }

    public static  String getPrefCountryCode(Context context) {
        return PreferenceManager.getDefaultSharedPreferences(context).getString("country_code","US");
    }

    public static void setPrefCountryCode(Context context,String mPrefCountryCode) {

        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
        editor.putString("country_code",mPrefCountryCode);
        editor.commit();
    }
}

Inizializza le impostazioni locali preferite dall'utente, dalla classe Application.

public class LocaleApp extends Application{

    @Override
    public void onCreate() {
        super.onCreate();

        LocaleUtils.setLocale(new Locale(LocaleUtils.getPrefLangCode(this), LocaleUtils.getPrefCountryCode(this)));
        LocaleUtils.updateConfiguration(this, getResources().getConfiguration());
    }
}

È inoltre necessario creare un'attività di base ed estendere questa attività a tutte le altre attività in modo che sia possibile modificare le impostazioni internazionali dell'applicazione solo in un punto come segue:

public abstract class LocalizationActivity extends AppCompatActivity {

    public LocalizationActivity() {
        LocaleUtils.updateConfiguration(this);
    }

    // We only override onCreate
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

}

Nota: inizializzare sempre la locale nel costruttore.

Ora puoi usare LocalizationActivity come segue.

public class MainActivity extends LocalizationActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

    }
}

Nota: quando si modifica la localizzazione dell'applicazione a livello di programmazione, è necessario riavviare l'attività per ottenere l'effetto della modifica delle impostazioni locali Per poter funzionare correttamente per questa soluzione e utilizzare le android:name=".LocaleApp" locali dalle preferenze condivise all'avvio dell'app, android:name=".LocaleApp" in tu Manifest.xml.

A volte il programma di controllo Lint richiede di creare la build di rilascio. Per risolvere questo problema, segui le seguenti opzioni.

Primo:

Se si desidera disabilitare la conversione solo per alcune stringhe, quindi aggiungere il seguente attributo a default string.xml

<string name="developer" translatable="false">Developer Name</string>

Secondo:

Ignora tutta la traduzione mancante dal file di risorse aggiungi il seguente attributo È l'attributo ignore dello spazio dei nomi degli strumenti nel file delle stringhe, come segue:

<?xml version="1.0" encoding="utf-8"?>
<resources
  xmlns:tools="http://schemas.android.com/tools"
  tools:ignore="MissingTranslation" >
http://stackoverflow.com/documentation/android/3345/localization-with-resources-in-android#
  <!-- your strings here; no need now for the translatable attribute -->

</resources>

Terzo:

Un altro modo per disabilitare la stringa non traducibile

http://tools.android.com/recent/non-translatablestrings

Se si dispone di molte risorse che non devono essere tradotte, è possibile inserirle in un file denominato donottranslate.xml e Lint considererà tutte le risorse non traducibili.

Il quarto:

È inoltre possibile aggiungere impostazioni internazionali nel file di risorse

<resources
xmlns:tools="http://schemas.android.com/tools"
    tools:locale="en" tools:ignore="MissingTranslation">

Puoi anche disabilitare il controllo della traduzione mancante per lint da app / build.gradle

lintOptions {
        
        disable 'MissingTranslation'
    }