Maintenant que la création de tâches asynchrones n'a plus de secret pour vous, nous allons pouvoir enfin créer notre première requête réseau. Prêt·e ? C'est parti ! :D
Introduction
Nous allons mettre de côté notre mini-application Freezap précédemment réalisée, et en créer une nouvelle, NetApp. Vous retrouverez cette dernière sur ce commit Github.
Une fois téléchargée, ouvrez-là et exécutez-là. Cette mini-application est actuellement très basique, puisqu'elle dispose uniquement d'une activité contenant un fragment.
L'objectif de ce chapitre est de créer une première requête réseau sur l'API de Github afin de récupérer la liste des personnes que suit Jake Wharton sur Github... :)
Demander les autorisations
Avant toute chose, il faut dire à Android que notre application va devoir utiliser une connexion internet lors de son fonctionnement.
Cette fonctionnalité nécessite une permission spéciale, INTERNET. Le but ici est d'indiquer explicitement à tous les utilisateurs téléchargeant notre application, que celle-ci pourra potentiellement utiliser un accès Internet pour fonctionner correctement.
Modifions notre manifeste afin d'y ajouter cette permission.
Extrait du fichier AndroidManifest.xml :
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.openclassrooms.netapp">
<uses-permission android:name="android.permission.INTERNET" />
....
</manifest>Explications : Une permission se configure via la balise <uses-permission> suivie de la permission en question, ici INTERNET. Vous pouvez retrouver la liste complète des permissions sur le site d'Android.
Réaliser une requête réseau
Nous allons utiliser la classe HttpURLConnection du SDK d'Android qui nous permettra de réaliser ce premier appel réseau. Pour cela, créons une classe dédiée que nous appellerons MyHttpURLConnection.java, et que nous placerons dans le package Utils de notre application NetApp.
Classe Utils/MyHttpURLConnection.java :
public class MyHttpURLConnection {
public static String startHttpRequest(String urlString){
StringBuilder stringBuilder = new StringBuilder();
try {
// 1 - Declare a URL Connection
URL url = new URL(urlString);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 2 - Open InputStream to connection
conn.connect();
InputStream in = conn.getInputStream();
// 3 - Download and decode the string response
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
String line;
while ((line = reader.readLine()) != null) {
stringBuilder.append(line);
}
} catch (MalformedURLException exception){
} catch (IOException exception) {
} catch (Exception e){
}
return stringBuilder.toString();
}
}Explications : Nous créons une classe responsable des appels réseau appelée MyHttpURLConnection. Celle-ci contient une méthode statique publique startHttpRequest() qui lancera une requête HTTP de type GET sur une URL fournie en paramètre.
Tout le code se trouve dans un try/catch, car ce dernier peut lever des exceptions (comme par exemple : aucun accès internet, une URL mal formée, etc...)
Ligne 1 : Nous créons à partir d'une adresse HTTP contenue dans une variable String, un objet URL. Celui-ci nous permettra d'ouvrir une connexion de type HttpURLConnection.
Ligne 2 : Nous ouvrons un canal vers l'url en question, et récupérons le flux de données correspondant via une InputStream.
Ligne 3 : Puis enfin, nous lisons ce flux de données brute grâce à un BufferedReader et convertissons le tout ligne par ligne, grâce à un StringBuilder pour retourner au final le résultat dans une variable de type String.
Pfiou ! Et voilà, votre requête HTTP est prête à être exécutée.
Ne devrions-nous pas placer cette méthode dans une AsyncTask, afin de l'exécuter sur un Thread dédié ? :euh:
Je vois que vous suivez... :) Nous allons justement effectuer cela dès maintenant, en créant une classe héritant d'AsyncTask, contenant cette requête HTTP. Nous l'avons ici appelée NetworkAsyncTask.java.
La classe NetworkAsyncTask.java :
public class NetworkAsyncTask extends android.os.AsyncTask<String, Void, String> {
public interface Listeners {
void onPreExecute();
void doInBackground();
void onPostExecute(String success);
}
private final WeakReference<Listeners> callback;
public NetworkAsyncTask(Listeners callback){
this.callback = new WeakReference<>(callback);
}
@Override
protected void onPreExecute() {
super.onPreExecute();
this.callback.get().onPreExecute();
Log.e("TAG", "AsyncTask is started.");
}
@Override
protected void onPostExecute(String success) {
super.onPostExecute(success);
this.callback.get().onPostExecute(success);
Log.e("TAG", "AsyncTask is finished.");
}
@Override
protected String doInBackground(String... url) {
this.callback.get().doInBackground();
Log.e("TAG", "AsyncTask doing some big work...");
return MyHttpURLConnection.startHttpRequest(url[0]);
}
}Explications : Si vous avez suivi la précédente partie de ce cours, vous ne devriez pas être déboussolés, bien au contraire ! Nous avons simplement appelé ici notre méthode publique statique startHttpRequest() dans le doInBackground() de notre AsyncTask.
Appelons maintenant cette tâche, contenant l'exécution de notre requête HTTP, quand l'utilisateur appuie sur le bouton "Get Datas From Github". Pour cela, modifions notre fragment MainFragment.
public class MainFragment extends Fragment implements NetworkAsyncTask.Listeners {
...
// -----------------
// ACTIONS
// -----------------
@OnClick(R.id.fragment_main_button)
public void submit(View view) {
this.executeHttpRequest();
}
// ------------------
// HTTP REQUEST
// ------------------
private void executeHttpRequest(){
new NetworkAsyncTask(this).execute("https://api.github.com/users/JakeWharton/following");
}
@Override
public void onPreExecute() {
this.updateUIWhenStartingHTTPRequest();
}
@Override
public void doInBackground() { }
@Override
public void onPostExecute(String json) {
this.updateUIWhenStopingHTTPRequest(json);
}
// ------------------
// UPDATE UI
// ------------------
private void updateUIWhenStartingHTTPRequest(){
this.textView.setText("Downloading...");
}
private void updateUIWhenStopingHTTPRequest(String response){
this.textView.setText(response);
}
}Explications : Je passe ici les explications ligne par ligne, car c'est exactement ce que nous avons fait dans la précédente partie de ce cours. En bref, nous lançons ici la requête HTTP (via l'AsyncTask NetworkAsyncTask) en lui spécifiant en paramètre l'adresse de l'API Github que nous souhaitons interroger. Nous mettons également à jour le TextView au début et à la fin de la requête.
Lancez maintenant l'application et appuyez sur le bouton "Get Datas From Github" afin de récupérer les données au format JSON pour ensuite les afficher dans le TextView.
Super ! Tout cela semble fonctionner à merveille ! :magicien:
Mis à part l'affichage brut du JSON que nous n'allons pas gérer pour le moment, notre requête est bien exécutée et les bonnes informations sont correctement retournées.
Cependant, je vais vous avouer quelque chose... Cette technique pour récupérer des données distantes, via HttpURLConnection, est relativement vieille et pas forcément la plus sympa/simple à utiliser. Dans le prochain chapitre, je vais vous faire découvrir une librairie spécialisée dans les requêtes réseaux sur Android qui va vous changer la vie, vous verrez... ;)
