Introduction:

Volley est une API google qui permet de construire des requêtes vers des API REST depuis un téléphone Android.

Elle peut permettre par exemple d’implémenter un système de connection à une base de données hébergée sur un serveur distant.

Dans ce tutoriel, nous verrons les bases de l’API REST, les différentes fonctionnalités offertes par Volley et nous couvrirons également les bases de la connection à l’API REST ainsi que comment s’y connecter avec Android.

Dall-E est il allé trop loin ?

Bases de l’API REST:

Tu peux voir l’API REST comme une interface au dessus de ton serveur, qui accepte des connections et qui exécute des types de commandes en fonction de tes besoins. Par exemple, tu peux envoyer une requête GET à ton serveur pour y récupérer des données.

Si tu as plusieurs utilisateurs pour ton application, et si tu souhaite leur permettre d’accéder à des fonctionnalités en commun (par exemple le fait de voir le profil d’une autre personne sur une app de jeu), tu peux t’orienter vers une API Rest, et donc vers Volley. Tu peux également te passer d’utiliser Volley mais la configuration de la connection et des requêtes serait plus complèxe à réaliser.

Concernant l’API REST, cette dernière permet plusieurs opérations:

• Des requêtes GET, pour récupérer de la donnée existante sur le serveur. Tu peux utiliser ce type de requête pour récupérer par exemple le classement des joueurs dans un jeu en ligne.
• Des requêtes POST, pour ajouter de la donnée sur le serveur; Cette requête peut par exemple être utilisée pour créer un compte d’utilisateur.
• Des requêtes PUT, pour modifier de la donnée sur le serveur; Cette requête peut être utilisée pour modifier un mot de passe ou nom de compte utilisateur par exemple.
• Des requêtes DELETE, pour supprimer de la donnée du serveur;

Nous traiterons l’implémentation d’API REST plus en détail dans un article ultérieur.

Utilisation de Volley:

Nous allons implémenter les différentes requêtes décrites dans le paragraphe ci-dessus à l’aide de Volley.

Nous partirons du principe que le serveur avec lequel nous communiquons contient une liste d’Utilisateurs, que nous voulons voir et incrémenter. Notre app implémentera les fonctionnalités suivantes:

• Retourne la liste de tous les utilisateurs (requête GET);
• Retourne un utilisateur trié par id (requête GET);
• Ajoute un utilisateur (requête POST);
• Modifie le username d’un utilisateur (requête PUT)
• Supprime un utilisateur par id (requête DELETE).

Commencons par ajouter Volley à notre App. Pour ce faire, il faut ajouter dans le Gradle de l’application la ligne suivante, au niveau des dépendancies:

implementation 'com.android.volley:volley:1.2.1'

Après avoir sync le gradle il nous est posssible d’utiliser Volley dans notre app. Il nous faudra également ajouter les deux lignes suivantes au Manifest:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Il faut également rajouter à ceci la ligne suivante si le site/l’api a laquelle on se connecte ne supporte pas https:

android:usesCleartextTraffic="true"

Attention à cette option, qui est désactivée par défaut par souci de sécurité. Il est préférable de l’utiliser de préférence pour un réseau local (p. ex API développée en interne) pour ne pas compromettre la sécurité de notre app.

Nous allons démontrer l’utilisation de plusieurs types de requests: StringRequest, JsonArrayRequest et JsonObjectRequest.

Préparation de la RequestQueue:

Pour commencer, nous allons créer la RequestQueue qui nous permettra d’envoyer des requêtes successives au serveur:

RequestQueue requestQueue = Volley.newRequestQueue(this);

Requête GET:

Pour la requête GET, nous allons réaliser une requête Volley de type JSONArrayRequest. Nous allons passer une requête au serveur, qui, si elle est correcte, nous fera reparvenir un Array d’Objets JSON.

public JsonArrayRequest(int method,String url,JSONArray jsonRequest,Response.Listener<JSONArray> listener,Response.ErrorListener errorListener);

Dans sa forme la plus simple, la requête se fait par le biais d’une URL. Dans le cas de notre petite API REST, l’URL est {localhost}/GETUSERS:

public void getRequest(){    
JsonArrayRequest GETRequest=new JsonArrayRequest(Request.Method.GET, url_GET, null, new Response.Listener<JSONArray>() {       
@Override        
public void onResponse(JSONArray response) {            Log.i("Get userlist",""+response.toString());}    }, 
new Response.ErrorListener() {        
@Override        
public void onErrorResponse(VolleyError error) {    
//Deal with error here
    }    });    
requestQueue.add(GETRequest);}

Nous construisons cette requête comme suit:

• Type de requête : Method.GET;
• le paramètre null correspond au JsonArray que nous passons a la requête. Ici vu que nous lancons une requête GET générale, celle-ci n’a pas de paramètres supplémentaires.
• url de la requête, qui nous permet ici de passer le chemin d’accès “/GETUSERS”
• Response.Listener, et Response.ErrorListener qui attendent le retour du serveur (par le biais d’un JSONArray, ou d’une error Volley).

On ajoute ensuite la requête a la queue. Cette dernière se lancera dès la fin des requêtes antérieures.

Requête POST/PUT:

Dans le cas de la requête POST ou PUT nous allons passer par une JsonObjectRequest:

JsonObjectRequest jsonObjectRequest = new JsonObjectRequest
        (Request.Method.POST, url, null, new Response.Listener<JSONObject>() {

    @Override
    public void onResponse(JSONObject response) {
        Log.i("Get userlist",""+response.toString());
    }
}, new Response.ErrorListener() {

    @Override
    public void onErrorResponse(VolleyError error) {
        // TODO: Handle error

    }
});

Dans le cadre d’une requête comme celle-ci , il peut être intéressant de passer au serveur un objet JSON ou des HEADERS ou des PARAMS afin que le serveur traite la demande POST/PUT.

Pour traiter cela, on modifie la demande ainsi:

JSONObject user=new JSONObject();
user.put("username", "Ahab");
user.put("password",1234);
JsonObjectRequest jsonObjectRequest = new JsonObjectRequest        (Request.Method.POST, url, user, new Response.Listener<JSONObject>() {    @Override    public void onResponse(JSONObject response) {        Log.i("Get userlist",""+response.toString());    }}, new Response.ErrorListener() {    @Override    public void onErrorResponse(VolleyError error) {        // TODO: Handle error    }});

La requête ci-dessus va envoyer un POST avec comme payload un user sous forme d'objet JSON.
En complément, les méthodes volley peuvent être modifiées comme suit, pour intégrer les PARAMS et HEADERS:

JsonObjectRequest jsonObjectRequest = new JsonObjectRequest        (Request.Method.POST, url, null, new Response.Listener<JSONObject>() {    @Override    public void onResponse(JSONObject response) {        Log.i("Get userlist",""+response.toString());    }}, new Response.ErrorListener() {    @Override    public void onErrorResponse(VolleyError error) {        // TODO: Handle error    }})
        {
            @Override
            protected Map<String, String> getParams() {

                Map<String, String> params = new HashMap<String, String>();
                params.put("username", "Ahab");
                params.put("password",1234);
                return params;
            }

            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
                headers.put("Authorization","Bearer f038738c-5206-42d7-8ade-9c5f52b90681");
                return super.getHeaders();
            }
        };

Les params et headers sont d’autres informations qui peuvent être fournies avec une requête volley. Les headers peuvent ajouter des informations complémentaires, notamment en ce qui concerne l’authentification et les params peuvent être une alternative a l’envoi de JSON au serveur.

Requête DELETE:

Pour démontrer l’autre grand type de requête Volley, on effectue ici une StringRequest pour le DELETE:

StringRequest stringRequest = new StringRequest(Request.Method.DELETE, url,
        new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
           
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
              
            }

        })
{
    @Override
    protected Map<String, String> getParams() throws AuthFailureError {
        Map<String, String> params = new HashMap<>();
        params.put("user",userToDelete);
        return params;
    }

La requête DELETE va permettre de supprimer un utilisateur du serveur, ici par le biais de son ID que l’on passe dans params.

La méthode ne requiert pas l’envoi de JSONObject ou Array et pourrait éventuellement passer simplement par l’nvoi d’une url indiquant l’user a supprimer…

Conclusion:

Dans cet article, nous avons exploré l’utilisation de l’API Volley pour effectuer des requêtes REST depuis un téléphone Android. Nous avons vu comment Volley peut être utilisé pour réaliser des opérations telles que la récupération de données, l’ajout d’utilisateurs, la modification de données et la suppression d’utilisateurs.

L’API REST offre une interface pratique pour communiquer avec un serveur, en utilisant des requêtes telles que GET, POST, PUT et DELETE. Volley simplifie l’implémentation de ces requêtes en fournissant des classes et des méthodes prêtes à l’emploi, ce qui permet de gagner du temps et d’éviter de devoir gérer manuellement la configuration de la connexion et des requêtes.

Nous avons vu comment utiliser Volley pour effectuer différentes requêtes, notamment StringRequest pour les requêtes simples, JsonArrayRequest pour récupérer des tableaux JSON et JsonObjectRequest pour envoyer des objets JSON. Nous avons également exploré la possibilité d’ajouter des paramètres et des en-têtes aux requêtes pour une personnalisation plus avancée.

En ce qui concerne la suppression d’un utilisateur du serveur, nous avons noté qu’il est possible de le faire en passant simplement l’ID de l’utilisateur dans les paramètres de la requête DELETE. Cela offre une approche simple et efficace pour supprimer des utilisateurs sans avoir à envoyer des structures de données complexes.