6.
Développement
6.1 Services Web
Client/Serveur : 6.2 Architectures
Services Web 6.3 Services Web REST
6.4 Services Web SOAP
1
Types d’applications mobiles ● Application Web : pages web adaptées au
Mobile (Mobile Friendly UI)
● Application native : conçue spécialement pour le système cible ○ Avantages : Moins couteux / une seule technologie
(Android, iOS…) à utiliser. (JavaScript, Php, CSS..)
○ Meilleure rapidité, fiabilité et dotée d’une meilleure réactivité ainsi qu’une ○ Inconvénients : Pas d’accès aux ressources
résolution supérieure ce qui assure une meilleure expérience utilisateur. matériels du téléphone.
○ Elle permet un accès plus facile à toutes les fonctionnalités du téléphone,
de l’accéléromètre en passant par la caméra et même le micro. ● Application hybride : entre les deux :
○ Les notifications push, uniquement disponibles sur les apps natives. Ces application spécifique à chaque plateforme
notifications vous permettent d’alerter vos utilisateurs et d’attirer leur générée de manière plus ou moins
attention chaque fois que vous le souhaitez. (voir GCM/FCM) automatique en utilisant des technologies
○ Ne consomme pas beaucoup de ressources réseaux. Web (HTML, CSS,JS..)
○ Ne requiert pas forcément internet pour fonctionner, ce qui est un réel ○ Avantage: coût du développement des pages
avantage. Même aujourd’hui, il existe encore des zones très peu couvertes Web. Applications pour # OS
par le réseau internet, et permettre à ses utilisateurs d’accéder à l’app sans ○ Exemple d’outils: Cordova, PhoneGap, Ionic,
connexion web est un très gros point fort à ne pas négliger. Xamarine...
2
Architecture logicielle distribuée
Les services Web fournissent un lien entre Les services Web sont le moyen de communication principal
applications. Ainsi, des applications utilisant des entre composantes distantes d’une application distribuée. Ils
technologies différentes peuvent envoyer et recevoir utilisent des standards (XML, HTTP,...) pour transférer des
des données au travers de protocoles données et ils sont compatibles avec de nombreux autres
compréhensibles par tout le monde. environnements de développement. Ils sont donc
indépendants des plates-formes. C'est dans ce contexte
Cet ensemble d’applications en apparence
qu'un intérêt très particulier a été attribué à la conception
autonomes mais en réalité dépendantes les unes
des services Web puisqu'ils permettent aux entreprises
des autres constituent une application distribuée.
d'offrir des applications accessibles à distance par d'autres
entreprises.
3
Architecture distribuée et composants
● La notion de composant logiciel est introduite
comme une suite à la notion d’objet.
● Le composant offre une meilleure
structuration de l’application et permet de
construire un système par assemblage de
briques élémentaires en favorisant la
réutilisation de ces briques.
● Une application distante peut être modélisée
comme un composant ou un ensemble de
composants d’un système distribué. (mais
peut aussi faire partie d’un composant dans
certains cas)
4
6.1 Services Web Les services Web peuvent être codés en plusieurs
langages (C#, Java, PHP, Python, C, etc.).
Les services Web sont des services de traitement de Citation Dico du Net :
la donnée exposée sur internet. Ils peuvent avoir
“C’est une technologie permettant à des
plusieurs formes, provenir de plusieurs sites
applications de dialoguer à distance via
différents, faire des tâches diverses et être privés ou
Internet indépendamment des plates-formes
publics.
et des langages sur lesquels elles reposent.”
Exemples :
● données météorologiques ; Les services web ne sont pas une exclusivité du
● calcul mathématique ; développement mobile.
● stockage d'informations ;
● etc.
5
6.2. Architectures
Les principales architectures des Web-Services sont étroitement lié au serveur. Si une modification est
REST et SOAP. effectuée d'un côté ou de l'autre, l'ensemble peut ne
plus fonctionner. Il faut effectuer des mises à jour du
REST et SOAP sont souvent comparés l'un à l'autre, client s'il y a des changements sur le serveur et vice-
mais c'est une erreur. En effet, ces éléments ne sont versa.
pas d'un même type : SOAP est à la fois une
architecture et un protocole tandis que REST est un Avec REST il y a beaucoup moins de couplage entre
style d'architecture. le client et le serveur : un client peut utiliser un
service de type REST sans aucune connaissance de
La différence majeure entre ces 2 “architectures” est l'API. A l'inverse, un client SOAP doit tout savoir des
le degré de liaison entre le client et le serveur. Un éléments qu'il va utiliser pendant son interaction
client développé avec le protocole SOAP ressemble à avec le serveur, sinon cela ne fonctionnera pas.
un programme locale (instanciation, appel de
méthodes…), car il est
6
6.3 Architectures REST
Les applications clientes Android peuvent tirer partie d'une architecture de type REST car de nombreuses
technologies côté serveur sont disponibles. Les principes de REST :
● Les données sont stockées dans le serveur permettant au client de ne s'occuper que de l'affichage
● Chaque requête est stateless c'est à dire qu'elle est exécutable du côté serveur sans que celui-ci ait
besoin de retenir l'état du client (son passé i.e. ses requêtes passées)
● Les réponses peuvent parfois être mises en cache facilitant la montée en charge
● Les ressources (services) du serveur sont clairement définies; l'état du client est envoyé par
"morceaux" augmentant le nombre de requêtes.
Pour bâtir le service du côté serveur, un serveur PHP ou Tomcat peut faire l'affaire. Il pourra fournir un web
service, des données au format XML ou JSON. Du côté client, il faut alors implémenter un parseur SAX ou
d'objet JSON
7
REST + JSON
Nous allons nous intéresser plus précisément aux services de type REST retournant des données au format
JSON (JavaScript Object Notation).
Pourquoi REST? Avoir un grand degré de liberté et une indépendance entre programmes/APIs client et serveur.
Pourquoi le JSON? Pour une question de facilité, bien entendu on peut utiliser le XML qui est aussi facile, mais
le JSON a la particularité d'être plus léger que XML, un gain de vitesse n'est pas anodin dans le domaine de la
mobilité.
8
6.3.1 Exemple serveur : PHP -> JSON
Exemple en PHP:
$json=array();
$sql="SELECT phone,name,isConnected FROM contacts ORDER BY name ASC";
try{
$res=$db->query($sql);
}catch(Exception $e){
die(json_encode(array('error'=>$db->errorInfo())));
}
if($res){
while($clt = $res->fetch(PDO::FETCH_ASSOC)){
$json[]=$clt;
}
$res->closeCursor();
}
echo json_encode($json);
9
Exemple Serveur: PHP -> XML
function array2xml($array, $node_name="root") {
$dom = new DOMDocument('1.0', 'UTF-8');
$dom->formatOutput = true;
$root = $dom->createElement($node_name);
PHP :
$dom->appendChild($root);
$array=array();
$array2xml = function ($node, $array) use ($dom, &$array2xml) {
// $array doit être
foreach($array as $key => $value){
associatif
if ( is_array($value) ) {
echo array2xml($array);
$n = $dom->createElement($key);
$array2xml($n, $value);
}else
$n = $dom->createElement($key,$value);
$node->appendChild($n);
}
};
$array2xml($root, $array);
return $dom->saveXML();
} 10
Exemple Serveur: Spring -> JSON
@RequestMapping("/api")
public class RestApiController {
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; @RequestMapping(value = "/user/", method = RequestMethod.GET)
import org.springframework.web.bind.annotation.PathVariable; public ResponseEntity<List<User>> listAllUsers() {
import org.springframework.web.bind.annotation.RequestBody; List<User> users =findAllUsers();
import
org.springframework.web.bind.annotation.RequestMapping;
if (users.isEmpty()) {
import return new ResponseEntity(HttpStatus.NO_CONTENT);
org.springframework.web.bind.annotation.RequestMethod; }
import return new ResponseEntity<List<User>>(users, HttpStatus.OK);
org.springframework.web.bind.annotation.RestController;
}
@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
● exemple complet : public ResponseEntity<?> getUser(@PathVariable("id") long id) {
http://websystique.com/spring- logger.info("Fetching User with id {}", id);
boot/spring-boot-rest-api-example/ User user =findUserById(id);
if (user == null) {
logger.error("User with id {} not found.", id);
return new ResponseEntity(new CustomErrorType("User with id " + id
+ " not found"), HttpStatus.NOT_FOUND);
}
return new ResponseEntity<User>(user, HttpStatus.OK);
}
11
Connexion du client (A)
Remarque: Il faut
URL url = new URL("http://www.monservice.com/interface.json?param1=jksq");
aussi demander les
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
permissions
try {
nécessaires lors
conn.setDoOutput(true);
de l'exécution (en
conn.setRequestMethod(“POST”);
plus de celles du
conn.setChunkedStreamingMode(0);
Manifest)
OutputStream out = new DataOutputStream(conn.getOutputStream());
// On peut utiliser out pour transmettre les paramètres et toute autre métadonnée
InputStream inStream = new BufferedInputStream(conn.getInputStream());
String result = readStream(inStream); //passer de InputStream à String
} finally {
conn.disconnect();
}
12
Stream to String
● Lecture du contenu depuis le stream : fonction readStream(...) dans l’exemple
précédant
BufferedReader r = new BufferedReader(new InputStreamReader(inStream));
StringBuilder sb= new StringBuilder();
String line = null;
try {
while ((line = r.readLine()) != null) {
sb.append(line).append('\n');
}...
String result = sb.toString();
13
NetworkOnMainThreadException
● Depuis Android 3.0, on ne peut pas effectuer des opérations de réseau
dans le thread d’une activité ou d’une interface graphique en général.
● On peut le mettre dans un thread traditionnel mais la communication
entre un thread et une interface graphique est un peu difficile.
● La méthode la plus adéquate pour remédier à cela est d’utiliser une
tâche asynchrone (AsyncTask) qui permet facilement de gérer à la fois le
code à exécuter en arrière plan (connexion..) et le code à exécuter dans
le thread principal (affichage des résultats).
● Voir chapitre “Programmation concurrente”
14
5.3.3 Récupération des objets : JSON
// Création d’un objet JSON depuis un String
JSONObject j = new JSONObject(result);
// On peut vérifier l'existence de chaque clé et récupérer sa valeur directement
if(j.has("error")) Une fois le texte
Toast.makeText(MainActivity.this,j.getString("error"),Toast.LENGTH_LONG).show(); est récupéré du
else{
serveur sous
Student std=new Student(j.getLong("id"),j.getString("nom"),
j.getString("prenom"),j.getString("classe")); forme de String,
std.setPhone(j.getString("phone")); on le convertit
if(j.has("notes")){ en objets JSON
JSONArray ja=j.getJSONArray("notes");
for(int i=0; i<ja.length();i++){
JSONObject jo=ja.getJSONObject(i);
std.addNote(
new Note(jo.getString("label"),jo.getDouble("score"))
);
}
}
}
15
//on peut aussi le lire à partir d’un fichier ou d’un service web
XML String result = new String("<plop><blup attr=\"45\">Coucou
!</blup></plop>");
InputStream f = new ByteArrayInputStream(s.getBytes());
Sans surprise, Android XmlPullParser parser = Xml.newPullParser();
fournit plusieurs parsers try {
XML (Pull parser, parser.setInput(f, null);
Document parser, Push
parser). SAX et DOM sont parser.next();
disponibles. L'API de Toast.makeText(this, parser.getName(), Toast.LENGTH_LONG).show();
streaming (StAX) n'est parser.next();
pas disponible. Toast.makeText(this, parser.getName(), Toast.LENGTH_LONG).show();
Cependant, une librairie Toast.makeText(this, parser.getAttributeValue(null, "attr"),
équivalente est Toast.LENGTH_LONG).show();
disponible: parser.nextText();
XmlPullParser. Voici un Toast.makeText(this, parser.getText(), Toast.LENGTH_LONG).show();
} ...
exemple simple:
16
Exemple: DOM Parser
Enfin, le parser DOM InputSource source = new InputSource(stream);
permet de naviguer assez
facilement dans la DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try {
représentation DocumentBuilder builder = factory.newDocumentBuilder();
arborescente du Document dom = builder.parse(source);
document XML. Ce n'est Element root = dom.getDocumentElement();
évidemment pas // Récupère tous les tags du descendant de la racine s'appelant monitor
NodeList items = root.getElementsByTagName("monitor");
préconisé si le XML en for (int i=0;i<items.getLength();i++){
question est volumineux. Node item = items.item(i);
L'exemple suivant permet // Traitement:
de chercher tous les tags // item.getNodeName()
// item.getTextContent()
"monitor" dans les sous- // item.getAttributes()
tags de la racine. ...
}
} catch (...)
17
Connexion avec l’API Volley (B)
// un singleton Volley pour la gestion de la queue de requêtes
if (mRequestQueue == null) {
mRequestQueue = Volley.newRequestQueue(this.getApplicationContext());
}
StringRequest request = new StringRequest(Request.Method.GET, "http://www.monserveur.com/service.json", null, new
MyResponseListener(this), new MyErrorResponseListener());
mRequestQueue.add(request);
class MyErrorResponseListener implements Response.ErrorListener{
@Override
public void onErrorResponse(VolleyError error) {
Log.e(TAG,error.getMessage());
}
}
private class MyResponseListener implements Response.Listener<String> {
@Override
public void onResponse(String data) {
//Convertir String data en objet JSON pour récupérer les informations transmises
}
}
18
6.4. Services Web de type SOAP
Les services Web de type SOAP permettent une Le WSDL (Web Services Description Language)
communication très rapprochée entre le client et le
serveur. Les deux parties de l’application sont très liées Le WSDL est une description fondée sur le XML qui indique
ce qui en fait à la fois un avantage et un inconvénient. comment utiliser le service.
Le WSDL sert à décrire :
Le SDK Android ne comporte pas d’API spécifique pour - le protocole de communication;
les architectures SOAP, mais il existe plusieurs APIs Open - le format de messages requis pour communiquer avec ce
Source exploitables à cet effet : la plus utilisée s’appelle service ;
- la définition des méthodes qu'il est possible d'appeler ;
kSOAP2. On peut télécharger et compiler la source avec
- la localisation du service.
notre projet ou inclure tout simplement le .jar adéquat
comme “dependency”.
Une description WSDL est un document XML qui commence
par la balise "definitions" et qui contient les balises suivantes
Détails sur l’API et téléchargement : :
https://code.google.com/archive/p/ksoap2-android/
- "binding" : définit le protocole à utiliser pour invoquer le
service web ;
- "port" : spécifie l'emplacement actuel du service ;
- "service" : décrit un ensemble de points finaux du réseau.
19
kSOAP: exemple d’implémentation
public class AppelService {
private static final String NAMESPACE = "http://mon-site-web.fr";
private static final String URL = "http://mon-exemple-web-services/wsdl.WSDL";
private static final String SOAP_ACTION = "getMeteo";
private static final String METHOD_NAME = "getMeteo";
private String getMeteo(String ville) {
String meteo = null;
try {
SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);
request.addProperty("ville", ville);
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
envelope.setOutputSoapObject(request);
AndroidHttpTransport androidHttpTransport = new AndroidHttpTransport(URL);
androidHttpTransport.call(SOAP_ACTION, envelope);
SoapObject objetSOAP = (SoapObject)envelope.getResponse();
meteo = this.parserObjet(objetSOAP);
} catch (Exception e) {
Log.e("getMeteo", "", e);
}
}
private String parserObjet(SoapObject objet) {
SoapObject meteoObjet = (SoapObject)positionSoap.getProperty("meteo");
String meteo = meteoObjet.getProperty("temps").toString();
return meteo;
}
20
}
Exercice : consommation d’un webservice REST
au format JSON
● En utilisant l’interface graphique réalisée précédemment dans le chapitre 3, et Nom
en utilisant le service web hébergé à l’URL suivante :
https://belatar.name/rest/profile.php?login=test&passwd=test&id=xxxx Prénom
○ développez le code qui permet de consommer le webservice et d’afficher les Classe
données sur l’interface graphique dès l’ouverture de l’activité en utilisant l’API
HttpURLConnection,
○ déplacez le traitement de la connexion dans une tâche asynchrone,
○ déclarez les autorisations nécessaires et faites les vérifications nécessaires surtout Remarques
pour l’état de la connectivité,
○ téléchargez l’image de profile et affichez la dans l’ImageView,
● Refaire le travail en utilisant l’API Volley
● Que doit-on faire pour enregistrer les modifications du profile?
ENREGISTRER
21
