Utilisation d'un fichier JSON dans les ressources d'une application Android

Question

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

Answer 1

Voir openRawResource . Quelque chose comme cela 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();

Answer 2

Kotlin est désormais le langage officiel d'Android, je pense donc que cela pourrait être utile pour quelqu'un

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

Answer 3

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 devez faire quelque chose comme ce qui suit (l'exemple se trouve dans un fichier 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);
   }

Answer 4

Comme l'indique @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 répertoire /res (ressources) 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

À l'intérieur d'un Activity Le fichier json est accessible par l'intermédiaire de la commande R (Ressources), et lire une chaîne de caractères :

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

Elle utilise la classe Java Scanner Ce qui permet de réduire le nombre de lignes de code par rapport à d'autres méthodes de lecture d'un simple fichier texte / json. Le modèle de délimitation \A signifie "le début de l'entrée". .next() lit le jeton suivant, qui est le fichier entier dans ce cas.

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

• Utiliser le logiciel Java / Android intégré JSONObject y JSONArray des objets, comme ici : Itération d'un tableau JSON dans Android/Java . Il peut être pratique d'obtenir des chaînes de caractères, des nombres entiers, etc. à l'aide de la fonction optString(String name) , optInt(String name) etc. et non les méthodes getString(String name) , getInt(String name) car les méthodes opt renvoient null au lieu d'une exception en cas d'échec.
• Utiliser une librairie Java / Android de sérialisation / désérialisation de json comme celles présentées ici : https://medium.com/@IlyaEremin/Android-json-parsers-comparison-2017-8b5221721e31

Answer 5

De http://developer.Android.com/guide/topics/resources/providing-resources.html :

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

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