Fichier de configuration Android

Question

Quel est le meilleur moyen et comment puis-je configurer un fichier de configuration pour une application ?

Je veux que l'application soit capable de consulter un fichier texte sur la carte SD et d'en extraire certaines informations dont elle a besoin.

Answer 1

Si votre application est destinée à être rendue publique et si vous avez des données sensibles dans votre configuration, comme des clés d'API ou des mots de passe, je vous suggère d'utiliser préférences sécurisées au lieu de Préférences partagées car, en fin de compte, les préférences partagées sont stockées dans un XML en texte clair, et sur un téléphone enraciné, il est très facile pour une application d'accéder aux préférences partagées d'un autre.

Par défaut, il ne s'agit pas d'une sécurité à toute épreuve (en fait, il s'agit plutôt d'une sécurité à toute épreuve). l'obscurcissement des préférences), mais il s'agit d'une solution rapide pour rendre pour rendre votre application Android plus sûre. Par exemple, elle empêchera les utilisateurs de sur les appareils enracinés de modifier facilement les préférences partagées de votre application. ( lien )

Je suggère quelques autres méthodes :

* Méthode 1 : utiliser un .properties avec Propriétés__

Pour :

1. Facile à modifier à partir de l'IDE que vous utilisez
2. Plus sécurisé : puisqu'il est compilé avec votre application
3. Il est facile d'y déroger si vous utilisez Construire des variantes/Flavors
4. Vous pouvez également écrire dans la configuration

Cons :

1. Vous avez besoin d'un contexte
2. Vous pouvez également écrire dans la configuration (oui, cela peut aussi être un con)
3. (autre chose ?)

Tout d'abord, créez un fichier de configuration : res/raw/config.properties et ajouter quelques valeurs :

api_url=http://url.to.api/v1/
api_key=123456

Vous pouvez ensuite accéder facilement aux valeurs avec quelque chose comme ceci :

package some.package.name.app;

import android.content.Context;
import android.content.res.Resources;
import android.util.Log;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public final class Helper {
    private static final String TAG = "Helper";

    public static String getConfigValue(Context context, String name) {
        Resources resources = context.getResources();

        try {
            InputStream rawResource = resources.openRawResource(R.raw.config);
            Properties properties = new Properties();
            properties.load(rawResource);
            return properties.getProperty(name);
        } catch (Resources.NotFoundException e) {
            Log.e(TAG, "Unable to find the config file: " + e.getMessage());
        } catch (IOException e) {
            Log.e(TAG, "Failed to open config file.");
        }

        return null;
    }
}

Utilisation :

String apiUrl = Helper.getConfigValue(this, "api_url");
String apiKey = Helper.getConfigValue(this, "api_key");

Bien sûr, cela pourrait être optimisé pour lire le fichier de configuration une fois et obtenir toutes les valeurs.

Méthode 2 : Utiliser AndroidManifest.xml méta-données élément :

Personnellement, je n'ai jamais utilisé cette méthode car elle ne me semble pas très flexible.

Dans votre AndroidManifest.xml ajoutez quelque chose comme :

...
<application ...>
    ...

    <meta-data android:name="api_url" android:value="http://url.to.api/v1/"/>
    <meta-data android:name="api_key" android:value="123456"/>
</application>

Maintenant une fonction pour récupérer les valeurs :

public static String getMetaData(Context context, String name) {
    try {
        ApplicationInfo ai = context.getPackageManager().getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
        Bundle bundle = ai.metaData;
        return bundle.getString(name);
    } catch (PackageManager.NameNotFoundException e) {
        Log.e(TAG, "Unable to load meta-data: " + e.getMessage());
    }
    return null;
}

Utilisation :

String apiUrl = Helper.getMetaData(this, "api_url");
String apiKey = Helper.getMetaData(this, "api_key");

Méthode 3 : Utiliser buildConfigField dans votre Saveur :

Je n'ai pas trouvé cela dans la documentation/formation officielle d'Android, mais cet article de blog est très utile.

Fondamentalement, la mise en place d'une saveur de projet (par exemple prod ), puis dans le dossier de votre application build.gradle avoir quelque chose comme :

productFlavors {
    prod {
        buildConfigField 'String', 'API_URL', '"http://url.to.api/v1/"'
        buildConfigField 'String', 'API_KEY', '"123456"'
    }
}

Utilisation :

String apiUrl = BuildConfig.API_URL;
String apiKey = BuildConfig.API_KEY;

Answer 2

Vous pouvez y parvenir en utilisant préférences partagées

Il existe un guide très détaillé sur la façon d'utiliser les préférences partagées sur la page Google Android https://developer.Android.com/guide/topics/data/data-storage.html#pref

Answer 3

Si vous souhaitez stocker les préférences de votre application, Android fournit Préférences partagées pour ça.
Voici le lien vers la ressource officielle de formation.

Answer 4

J'ai répondu à cette exigence récemment, en notant ici comment j'ai fait.

l'application doit pouvoir consulter un fichier texte sur la carte sd et récupérer certaines informations dont elle a besoin

Exigence :

1. La valeur de configuration (score_threshold) doit être disponible sur la carte SD. Ainsi, quelqu'un peut changer les valeurs après avoir publié l'apk.
2. Le fichier de configuration doit être disponible dans le répertoire "/sdcard/config.txt" du matériel Android.

Le contenu du fichier config.txt est le suivant,

score_threshold=60

Créez une classe utilitaire Config.java, pour lire et écrire un fichier texte.

import android.util.Log;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;

public final class Config {

    private static final String TAG = Config.class.getSimpleName();
    private static final String FILE_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/config.txt";
    private static Config sInstance = null;

    /**
     * Gets instance.
     *
     * @return the instance
     */
    public static Config getInstance() {
        if (sInstance == null) {
            synchronized (Config.class) {
                if (sInstance == null) {
                    sInstance = new Config();
                }
            }
        }
        return sInstance;
    }

    /**
     * Write configurations values boolean.
     *
     * @return the boolean
     */
    public boolean writeConfigurationsValues() {

        try (OutputStream output = new FileOutputStream(FILE_PATH)) {

            Properties prop = new Properties();

            // set the properties value
            prop.setProperty("score_threshold", "60");

            // save properties
            prop.store(output, null);

            Log.i(TAG, "Configuration stored  properties: " + prop);
            return true;
        } catch (IOException io) {
            io.printStackTrace();
            return false;
        }
    }

    /**
     * Get configuration value string.
     *
     * @param key the key
     * @return the string
     */
    public String getConfigurationValue(String key){
        String value = "";
        try (InputStream input = new FileInputStream(FILE_PATH)) {

            Properties prop = new Properties();

            // load a properties file
            prop.load(input);
            value = prop.getProperty(key);
            Log.i(TAG, "Configuration stored  properties value: " + value);
         } catch (IOException ex) {
            ex.printStackTrace();
        }
        return value;
    }
}

Créez une autre classe utilitaire pour écrire le fichier de configuration lors de la première exécution de l'application, Note : La permission de lecture/écriture de la carte SD doit être définie pour l'application.

public class ApplicationUtils {

  /**
  * Sets the boolean preference value
  *
  * @param context the current context
  * @param key     the preference key
  * @param value   the value to be set
  */
 public static void setBooleanPreferenceValue(Context context, String key, boolean value) {
     SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
     sp.edit().putBoolean(key, value).commit();
 }

 /**
  * Get the boolean preference value from the SharedPreference
  *
  * @param context the current context
  * @param key     the preference key
  * @return the the preference value
  */
 public static boolean getBooleanPreferenceValue(Context context, String key) {
     SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
     return sp.getBoolean(key, false);
 }

}

Dans votre activité principale, onCreate()

if(!ApplicationUtils.getBooleanPreferenceValue(this,"isFirstTimeExecution")){
           Log.d(TAG, "First time Execution");
           ApplicationUtils.setBooleanPreferenceValue(this,"isFirstTimeExecution",true);
           Config.getInstance().writeConfigurationsValues();
}
// get the configuration value from the sdcard.
String thresholdScore = Config.getInstance().getConfigurationValue("score_threshold");
Log.d(TAG, "thresholdScore from config file is : "+thresholdScore );