Utilisation du fichier JSON dans les ressources d'applications Android

Supposons que j'ai un fichier avec du contenu JSON dans le dossier des ressources brutes de mon application. Comment puis-je lire cela dans l'application, afin de pouvoir analyser le JSON?

Voir openRawResource . Quelque chose comme ça devrait fonctionner:

InputStream is = getResources().openRawResource(R.raw.json_file);
Writer writer = new StringWriter();
char[] buffer = new char[1024];
try {
    Reader reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
    int n;
    while ((n = reader.read(buffer)) != -1) {
        writer.write(buffer, 0, n);
    }
} finally {
    is.close();
}

String jsonString = writer.toString();

Kotlin est maintenant la langue officielle pour Android, donc je pense que ce serait utile pour quelqu'un

val text = resources.openRawResource(R.raw.your_text_file)
                                 .bufferedReader().use { it.readText() }

J'ai utilisé la réponse de @ kabuko pour créer un objet qui se charge à partir d'un fichier JSON, en utilisant Gson , à partir des ressources:

package com.jingit.mobile.testsupport;

import java.io.*;

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

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;


/**
 * An object for reading from a JSON resource file and constructing an object from that resource file using Gson.
 */
public class JSONResourceReader {

    // === [ Private Data Members ] ============================================

    // Our JSON, in string form.
    private String jsonString;
    private static final String LOGTAG = JSONResourceReader.class.getSimpleName();

    // === [ Public API ] ======================================================

    /**
     * Read from a resources file and create a {@link JSONResourceReader} object that will allow the creation of other
     * objects from this resource.
     *
     * @param resources An application {@link Resources} object.
     * @param id The id for the resource to load, typically held in the raw/ folder.
     */
    public JSONResourceReader(Resources resources, int id) {
        InputStream resourceReader = resources.openRawResource(id);
        Writer writer = new StringWriter();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(resourceReader, "UTF-8"));
            String line = reader.readLine();
            while (line != null) {
                writer.write(line);
                line = reader.readLine();
            }
        } catch (Exception e) {
            Log.e(LOGTAG, "Unhandled exception while using JSONResourceReader", e);
        } finally {
            try {
                resourceReader.close();
            } catch (Exception e) {
                Log.e(LOGTAG, "Unhandled exception while using JSONResourceReader", e);
            }
        }

        jsonString = writer.toString();
    }

    /**
     * Build an object from the specified JSON resource using Gson.
     *
     * @param type The type of the object to build.
     *
     * @return An object of type T, with member fields populated using Gson.
     */
    public <T> T constructUsingGson(Class<T> type) {
        Gson gson = new GsonBuilder().create();
        return gson.fromJson(jsonString, type);
    }
}

Pour l'utiliser, vous feriez quelque chose comme ce qui suit (l'exemple est dans un InstrumentationTestCase):

   @Override
    public void setUp() {
        // Load our JSON file.
        JSONResourceReader reader = new JSONResourceReader(getInstrumentation().getContext().getResources(), R.raw.jsonfile);
        MyJsonObject jsonObj = reader.constructUsingGson(MyJsonObject.class);
   }

Sur http://developer.android.com/guide/topics/resources/providing-resources.html :

Fichiers bruts / arbitraires à enregistrer sous leur forme brute. Pour ouvrir ces ressources avec un InputStream brut, appelez Resources.openRawResource () avec l'ID de ressource, qui est R.raw.filename.

Cependant, si vous avez besoin d'accéder aux noms de fichiers d'origine et à la hiérarchie des fichiers, vous pouvez envisager d'enregistrer certaines ressources dans le répertoire assets / (au lieu de res / raw /). Les fichiers des assets / ne reçoivent pas d'ID de ressource, vous ne pouvez donc les lire qu'à l'aide d'AssetManager.

Comme les états @mah, la documentation Android ( https://developer.android.com/guide/topics/resources/providing-resources.html ) indique que les fichiers json peuvent être enregistrés dans le répertoire / raw sous le / res (ressources) répertoire de votre projet, par exemple:

MyProject/
  src/ 
    MyActivity.java
  res/
    drawable/ 
        graphic.png
    layout/ 
        main.xml
        info.xml
    mipmap/ 
        icon.png
    values/ 
        strings.xml
    raw/
        myjsonfile.json

Dans un Activity, le fichier json est accessible via la Rclasse (Resources) et lu dans une chaîne:

Context context = this;
Inputstream inputStream = context.getResources().openRawResource(R.raw.myjsonfile);
String jsonString = new Scanner(inputStream).useDelimiter("\\A").next();

Cela utilise la classe Java Scanner, ce qui entraîne moins de lignes de code que certaines autres méthodes de lecture d'un simple fichier texte / json. Le motif de délimitation \Asignifie «le début de l'entrée». .next()lit le jeton suivant, qui est le fichier entier dans ce cas.

Il existe plusieurs façons d'analyser la chaîne json résultante:

• Utilisez les objets JSONObject et JSONArray intégrés à Java / Android , comme ici: Itération de tableau JSON dans Android / Java . Il peut être pratique d'obtenir des chaînes, etc. Entiers en utilisant les optString(String name), optInt(String name)etc. méthodes, pas les getString(String name), getInt(String name)méthodes, parce que laopt méthodes renvoient null au lieu d'une exception en cas de défaillance.
• Utilisez une bibliothèque de sérialisation / désérialisation json Java / Android comme celles mentiod ici: https://medium.com/@IlyaEremin/android-json-parsers-comparison-2017-8b5221721e31

InputStream is = mContext.getResources().openRawResource(R.raw.json_regions);
                            int size = is.available();
                            byte[] buffer = new byte[size];
                            is.read(buffer);
                            is.close();
                           String json = new String(buffer, "UTF-8");

En utilisant:

String json_string = readRawResource(R.raw.json)

Les fonctions:

public String readRawResource(@RawRes int res) {
    return readStream(context.getResources().openRawResource(res));
}

private String readStream(InputStream is) {
    Scanner s = new Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

J'ai trouvé cette réponse d'extrait de code Kotlin très utileJ'ai ♥ ️

Alors que la question d'origine demandait d'obtenir une chaîne JSON, je pense que certains pourraient trouver cela utile. Un pas de plus avec Gsonconduit à cette petite fonction de type réifié:

private inline fun <reified T> readRawJson(@RawRes rawResId: Int): T {
    resources.openRawResource(rawResId).bufferedReader().use {
        return gson.fromJson<T>(it, object: TypeToken<T>() {}.type)
    }
}

Notez que vous ne souhaitez pas utiliser TypeTokenuniquement T::classsi vous lisez unList<YourType> vous ne perdrez pas le type par type d'effacement.

Avec l'inférence de type, vous pouvez ensuite utiliser comme ceci:

fun pricingData(): List<PricingData> = readRawJson(R.raw.mock_pricing_data)