Cloud EndPoints : création d'une application Android avec un backend Cloud App Engine

Hinault Romaric

Vous découvrirez au travers de cet article Cloud EndPoints, un outil intégré dans le SDK App Engine, qui facilite la création d'une API et sa consommation côté client.

Commentez

- Titre : Cloud EndPoints : création d'une application Android avec un backend Cloud App Engine

- Auteur : Hinault Romaric

- Parution : 13 novembre 2014

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2014 Hinault Romaric. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Droits de diffusion permanents accordés à Developpez LLC.

Sommaire

- I. Prérequis

- II. Problématique

- III. Objectif

- IV. Avantages

- V. Outils développement

- VI. Description des plateformes d'exécution

- VI-A. Android

- VI-B. App Engine

- VI-B-1. L'environnement d'exécution Java

- VI-B-2. La base de données (DataStore)

- VI-B-3. Google Cloud EndPoints

- VI-B-3-a. Architecture basique de Cloud EndPoints

- VI-B-3-b. Bibliothèques, outils et modèles de Cloud Endpoints

- VII. Installation des outils requis pour Eclipse

- VIII. Description et architecture de la solution à développer

- VIII-A. Architecture en couche de l'application Android

- VIII-B. Architecture en couche de l'application App Engine

- VIII-C. Étapes de création de la solution

- IX. Création de l'application Android

- X. Création du Backend App Engine

- XI. Création du modèle objets (classes Entity)

- XII. Génération de l'API Endpoints

- XII-A. Les annotations Cloud Endpoints

- XII-A-1. Les annotations globales : @Api

- XII-A-2. Les annotations par méthode : @ApiMethod

- XII-A-3. Les annotations par méthode : @Named, @Nullable

- XIII. Utiliser l'API dans l'application Android

- XIV. Test local de l'application

- XV. Déploiement de la solution

- XVI. Conclusion

- XVII. Références

- XVIII. Remerciements

I - Prérequis

Ce tutoriel se veut simple, à la portée d'un débutant en programmation pour Android. Cependant, pour sa bonne compréhension, il est nécessaire de disposer des notions de base en :

- développement Android ;

- développement Java ;

- Utilisation des services Web.

II - Problématique

Les smartphones font de plus en plus partie du quotidien des utilisateurs et commencent également à se faire une place dans le milieu professionnel. Cependant, ces dispositifs sont faibles en ressources et ne disposent pas d'espace de stockage important.

De plus, dans un environnement professionnel, le smartphone devrait permettre d'accéder à distance aux données et y effectuer des opérations, notamment des mises à jour ou des suppressions.

Si vous développez des applications pour des terminaux mobiles, il sera assez probable que vous soyez confronté un jour à ces problèmes. Une solution pourrait être la délégation de l'exécution des tâches complexes et du stockage des données à une plateforme distante : un PaaS (Paltform as a Service), par exemple.

III - Objectif

L'objectif à atteindre dans le cadre de ce tutoriel est la mise en œuvre d'une application pour terminaux Android, qui exploite un backend Cloud pour l'exécution et le stockage des données. Nous reviendrons plus tard sur la présentation du backend Cloud.

Afin de garder le tutoriel simple, nous n'allons pas entrer dans les détails sur les bouts de code qui ont été générés par Cloud EndPoints. Nous nous limiterons à une brève description de ceux-ci.

IV - Avantages

Les avantages d'une telle architecture sont multiples. Nous pouvons notamment citer :

- gain en performance ;

- délégation du traitement des tâches complexes ;

- stockage centralisé ;

- temps de réponse amélioré ;

- gestion de la montée en charge ;

- facilité de maintenance ;

- redimensionnement automatique du stockage des données ;

- meilleure gestion des transactions ;

- synchronisation ;

- fiabilité.

V - Outils développement

Pour mettre sur pied notre solution, nous aurons besoin des outils suivants :

- Eclipse : la version 4.3 (Kepler) a été utilisée dans le cadre de ce tutoriel  ;

- JDK (Java SE Development Kit) : nous avons eu recours à la version 7 du JDK :

- Android SDK : la version 22 a été utilisée  ;

- App Engine Java SDK version 1.9 a été exploitée pour cet article ;

- Google Cloud EndPoints : inclus par défaut dans App Engine ;

- Google Plugin for Eclipse ; nous avons utilisé la version 3.7.

Vous devez également disposer d'un compte Google.

VI - Description des plateformes d'exécution

VI-A - Android

Android est un système d'exploitation mobile open source développé par Google dans le cadre du projet AOSP (Android Open Source Project). Android jouit d'une large popularité dans l'écosystème du mobile. Selon les chiffres publiés par Kantar en juillet 2014, Android dispose d'une part de marché de 75 % sur les cinq plus importants marchés européens.

De plus, la gratuité de la plateforme et de ses outils de développement favorise la création d'applications à destination des terminaux Android.

VI-B - App Engine

App Engine est une plateforme PaaS, qui permet de créer des applications Web à l'aide des technologies Java, Python ou encore JavaScript et de les exécuter sur l'architecture évolutive de Google.

App Engine permet de développer en toute simplicité des applications qui s'exécutent de manière fiable, même lorsqu'elles sont surchargées et doivent faire face à des volumes de données importants . App Engine comprend les fonctionnalités suivantes :

- diffusion Web dynamique, avec prise en charge intégrale des technologies Web courantes ;

- stockage permanent avec requêtes, tri et transactions ;

- équilibrage des charges et évolutivité automatique ;

- API qui permettent d'authentifier les utilisateurs et d'envoyer des e-mails via Google Accounts ;

- un environnement de développement local complet qui simule Google App Engine sur votre ordinateur ;

- des files d'attente de tâches qui permettent d'effectuer du travail en dehors du champ d'une requête Web ;

- des tâches planifiées qui déclenchent les événements aux moments spécifiés ou à intervalles réguliers.

App Engine dispose d'un ensemble riche de services pour faciliter le développement d'applications qui seront hébergées dans le Cloud de Google. Pour notre travail, nous allons utiliser l'environnement d'exécution Java (JRE), la base de données (DataStore), et les outils Google Cloud EndPoints.

VI-B-1 - L'environnement d'exécution Java

L'environnement d'exécution Java d'App Engine fournit une machine virtuelle qui supporte Java 8 et permet l'exécution des applications dans un environnement Cloud sécurisé (sandbox). Le Runtine Java de la plateforme offre également une interface Servlet Java et la prise en charge des interfaces standard avec le magasin de données et les services évolutifs App Engine tels que JDO (Java Data Objects), JPA (Java Persistence API), JavaMail et JCache. La prise en charge des normes facilite le développement des applications et permet de porter celles-ci vers et depuis votre propre environnement de servlets.

VI-B-2 - La base de données (DataStore)

App Engine fournit un service performant de stockage distribué de données qui comprend un moteur de recherche et la gestion des transactions. En même temps que les serveurs Web distribués augmentent avec votre trafic, la base de données grossit avec vos données.

Le datastore App Engine n'est pas comme une base de données relationnelle traditionnelle. Les objets de données ou « entités » ont des propriétés. Les recherches peuvent retourner des entités selon un filtre donné et les trier selon les propriétés de leurs valeurs.

Les entités Datastore n'ont pas de schéma. La structure de données des entités est fournie et mise en place par le code de l'application. Les interfaces JDO/JPA incluent les dispositifs pour mettre en place la structure à l'intérieur de l'application. L'application peut aussi accéder au datastore directement pour mettre en place une structure répondant plus précisément aux besoins du développeur.

Le datastore implémente les transactions à travers son réseau distribué en utilisant des « groupes d'entités ». Une transaction manipule des entités à l'intérieur d'un simple groupe. Les entités du même groupe sont enregistrées ensemble par souci d'efficacité d'exécution des transactions.

VI-B-3 - Google Cloud EndPoints

Pour faciliter le développement d'applications mobiles utilisant App Egine, Google a développé un ensemble d'API connu sous le nom de « Cloud Endpoints ».

Cloud Endpoints permet de définir la logique métier sur App Engine et d'y accéder via des API RESTful ou RPC (Remote Procedure Call) sur de multiples plateformes, y compris Android , iOS et sur le Web (JavaScript). Cloud Endpoints est construit en utilisant l'infrastructure de Google API, ce qui facilite l'interopérabilité avec des services Google.

Cloud Endpoints a été construit pour simplifier la tâche aux développeurs, en permettant un développement flexible et agile. Il permet de :

- libérer le développeur des travaux complexes de rédaction et de maintenance de code pour les interactions et les protocoles client-serveur ;

- générer du code optimisé pour les opérations CRUD ;

- faciliter la création des API personnalisées (REST ou RPC).

VI-B-3-a - Architecture basique de Cloud EndPoints

Cloud EndPoints a pour objectif d'aider le développeur à connecter son ou ses applications frontends avec son application backend en générant les API nécessaires.

Le développement d'une solution en utilisant Cloud EndPoints revient donc à créer :

- le backend qui sera hébergé sur App Engine. Le backend permet d'implémenter sur App Engine la logique métier de l'application et effectue tous les calculs et le stockage sur le DataStore ;

- les frontends (Android, Web ou Java) seront les interfaces qui permettront aux utilisateurs d'interagir avec le backend.

Les fonctionnalités du backend sont mises à la disposition des clients par le biais de Endpoints , qui expose une API que les frontends peuvent appeler.

VI-B-3-b - Bibliothèques, outils et modèles de Cloud Endpoints

Cloud Endpoints dans le SDK App Engine met à la disposition du développeur les bibliothèques et outils suivants :

- des bibliothèques Endpoints dans le SDK ;

- des artefacts Maven pour la création de nouveaux projets backend, la génération de l'API client, de la documentation, etc. ;

- l'outil en ligne de commande endpoints.sh (sur Linux) et endpoints.cmd (sur Windows) qui est un substitut à Maven pour la création du backend et la génération de l'API client

- le support de Endpoints dans Google Plugin pour Eclipse, qui permet d'utiliser l'EDI pour les tâches citées ci-dessus. C'est l'outil que nous utiliserons pour la création de notre solution.

VII - Installation des outils requis pour Eclipse

Avant de débuter avec la création de votre solution, vous devez disposer d'Eclipse avec le SDK Android et le SDK App Engine installés sur votre machine.

Ensuite, vous devez via l'interface du menu Help > Install New Software, installer le plugin Eclipse pour Android et pour App Engine.

Pour installer les plugins nécessaires, vous devez renseigner le lien suivant dans la zone « Work with » : http://dl.google.com/eclipse/plugin/4.3.

(cliquez ici pour aggrandir l'image)

Vous devez sélectionner dans la liste proposée les éléments suivants :

- Developper Tools ;

- Google Plugin for Eclipse ;

- Google App Engine Java SDK (si vous ne l'avez pas déjà installé sur votre poste).

Le reste d'outils est optionnel.

VIII - Description et architecture de la solution à développer

La solution que nous allons mettre sur pied sera constituée de deux applications. Une application App Engine qui fera office de Backend et une application Android qui sera le client (frontend). Les données seront stockées sur le datastore d'App Engine.

Le diagramme de composants ci-dessous permet d'avoir une idée plus précise sur les composants de notre solution et son architecture physique et statistique.

(cliquez ici pour aggrandir l'image)

VIII-A - Architecture en couche de l'application Android

L'application Android sera constituée des couches suivantes :

- la couche présentation (IHM - Interface Homme Machine) : elle correspond à la partie visible de l'application. La couche présentation relaie les requêtes de l'utilisateur à destination de la couche métier, et en retour lui présente les informations renvoyées par les traitements de cette couche ;

- la couche métier (BLL - Business Logic Layer) : la couche métier sera utilisée pour développer toute la logique métier de l'application Android. Elle est intercalée entre l'IHM et la bibliothèque App Engine Client Lib, et permettra d'effectuer toutes les manipulations de données nécessaires en fonction des requêtes effectuées par les utilisateurs au travers de la couche présentation ;

- App Engine Backend Client Lib : cette couche fournit un accès simplifié à l'application serveur hébergée sur App Engine via Google Cloud Endpoints ;

- le modèle objets : le modèle ici représente les ressources qui seront manipulées par notre application et notre API.

(cliquez ici pour aggrandir l'image)

VIII-B - Architecture en couche de l'application App Engine

Les différentes couches que nous allons utiliser pour cette application sont les suivantes :

- les classes Endpoints : les classes Endpoints représentent en quelque sorte la couche d'accès aux données. Les méthodes que chaque classe Endpoint possède permettent d'insérer, mettre à jour et supprimer les objets dans le DataStore ;

- le modèle objets : le modèle ici représente les ressources qui seront manipulées par les classes Endpoint.

(cliquez ici pour aggrandir l'image)

VIII-C - Étapes de création de la solution

La création de notre solution se fera selon les étapes suivantes :

- création de l'application Android ;

- génération du Backend App Engine ;

- création des classes Entity ;

- création des classes Endpoints ;

- génération de l'API Client ;

- création des méthodes d'accès sous Android ;

- test ;

- déploiement.

IX - Création de l'application Android

Maintenant que nous nous sommes familiarisés avec les outils que nous allons utiliser et que nous sommes informés sur les objectifs à atteindre, entrons dans le vif du sujet de ce tutoriel. Nous allons débuter par la création de notre application Android.

Pour cela, démarrez votre EDI Eclipse. Cliquez sur le menu « Fichier », ensuite « Nouveau » puis « Projet ».

L'interface de création d'un nouveau projet s'affiche. Déroulez la zone « Android » et sélectionnez « Android Application Project », comme l'illustre la capture ci-dessous.

(cliquez ici pour aggrandir l'image)

Cliquez ensuite sur « Suivant ». Dans la fenêtre qui s'affiche, renseignez le nom de votre application, celui du projet, ainsi que le nom du package. Vous pouvez également à partir de cette interface définir les versions d'Android que votre application va cibler. Laissez les valeurs renseignées par défaut.

(cliquez ici pour aggrandir l'image)

Cliquez sur « Suivant » et configurez votre projet, si besoin, avant de finaliser avec sa création.

X - Création du Backend App Engine

À partir de l'application Android que nous venons de créer, nous allons procéder à la création de l'application App Engine (notre Backend Cloud).

Pour cela, vous allez faire un clic droit sur votre projet dans l'explorateur de projet. Ensuite, vous allez cliquer sur « Google » puis sur « Generate App Engine Backend », comme l'illustre la capture ci-dessous :

(cliquez ici pour aggrandir l'image)

Le plugin Google se chargera de la génération de votre application Backend, puis ajoutera à l'application Android la classe nécessaire pour assurer la communication entre vos deux applications. Il s'agit de la classe CloudEndpointsUtils.

(cliquez ici pour aggrandir l'image)

XI - Création du modèle objets (classes Entity)

Après la création de nos projets, nous allons dans un premier temps travailler sur l'application App Engine. Nous allons commencer par créer les objets qui seront manipulés par notre application.

Pour cela, vous allez faire un clic droit sur « src », puis vous allez cliquer sur « Nouveau », puis sur « Class ». Dans la fenêtre qui va s'afficher, renseignez le nom de votre classe, puis cliquez sur « Finish ».

(cliquez ici pour aggrandir l'image)

Les objets de notre modèle doivent être des classes entités.

Les classes Entities sont :

- des simples POJO (c'est-à-dire qu'elles n'implémentent pas d'interface spécifique à un framework ) ;

- annotées avec JPA (@Entity, @Id, etc.) ou JDP ;

- implémentent des accesseurs (get) et des mutateurs (set) ;

Notre classe Entity GdaysSession aura donc la structure suivante :

(cliquez ici pour aggrandir l'image)

XII - Génération de l'API Endpoints

Après la création de notre classe Entity, nous allons passer à la génération de l'API Endpoints correspondante.

Pour cela, vous allez faire un clic droit sur votre classe Entity, ensuite sélectionner « Google », puis cliquer sur « Generate Cloud Endpoint Class », comme l'illustre la capture ci-dessous :

(cliquez ici pour aggrandir l'image)

Cloud EndPoints procède à la génération du code pour votre API. Celui-ci est généré en utilisant JPA ou GDO avec par défaut des méthodes pour :

- l'insertion (exposée comme une requête HTTP POST) ;

- la sélection (exposée comme une requête HTTP GET) ;

- la modification (exposée comme une requête HTTP PUT) ;

- la suppression (exposée comme une requête HTTP DELETE).

Le code qui est généré est le suivant :

package com.example.roma.gdaysapp;

import com.example.roma.gdaysapp.EMF;

import com.google.api.server.spi.config.Api;
import com.google.api.server.spi.config.ApiMethod;
import com.google.api.server.spi.config.ApiNamespace;
import com.google.api.server.spi.response.CollectionResponse;
import com.google.appengine.api.datastore.Cursor;
import com.google.appengine.datanucleus.query.JPACursorHelper;

import java.util.List;

import javax.annotation.Nullable;
import javax.inject.Named;
import javax.persistence.EntityExistsException;
import javax.persistence.EntityNotFoundException;
import javax.persistence.EntityManager;
import javax.persistence.Query;

@Api(name = "gdayssessionendpoint",
namespace = @ApiNamespace(ownerDomain = "example.com", ownerName = "example.com",
packagePath = "roma.gdaysapp")
)
public class GdaysSessionEndpoint {

/**
* This method lists all the entities inserted in datastore.
* It uses HTTP GET method and paging support.
*
* @return A CollectionResponse class containing the list of all entities
* persisted and a cursor to the next page.
*/
@SuppressWarnings({ "unchecked", "unused" })
@ApiMethod(name = "listGdaysSession")
public CollectionResponse<GdaysSession> listGdaysSession(
@Nullable @Named("cursor") String cursorString,
@Nullable @Named("limit") Integer limit) {

EntityManager mgr = null;
Cursor cursor = null;
List<GdaysSession> execute = null;

try {
mgr = getEntityManager();
Query query = mgr
.createQuery("select from GdaysSession as GdaysSession");
if (cursorString != null && cursorString != "") {
cursor = Cursor.fromWebSafeString(cursorString);
query.setHint(JPACursorHelper.CURSOR_HINT, cursor);
}

if (limit != null) {
query.setFirstResult(0);
query.setMaxResults(limit);
}

execute = (List<GdaysSession>) query.getResultList();
cursor = JPACursorHelper.getCursor(execute);
if (cursor != null)
cursorString = cursor.toWebSafeString();

// Tight loop for fetching all entities from datastore and accomodate
// for lazy fetch.
for (GdaysSession obj : execute)
;
} finally {
mgr.close();
}

return CollectionResponse.<GdaysSession> builder().setItems(execute)
.setNextPageToken(cursorString).build();
}

/**
* This method gets the entity having primary key id. It uses HTTP GET method.
*
* @param id the primary key of the java bean.
* @return The entity with primary key id.
*/
@ApiMethod(name = "getGdaysSession")
public GdaysSession getGdaysSession(@Named("id") Long id) {
EntityManager mgr = getEntityManager();
GdaysSession gdayssession = null;
try {
gdayssession = mgr.find(GdaysSession.class, id);
} finally {
mgr.close();
}
return gdayssession;
}

/**
* This inserts a new entity into App Engine datastore. If the entity already
* exists in the datastore, an exception is thrown.
* It uses HTTP POST method.
*
* @param gdayssession the entity to be inserted.
* @return The inserted entity.
*/
@ApiMethod(name = "insertGdaysSession")
public GdaysSession insertGdaysSession(GdaysSession gdayssession) {
EntityManager mgr = getEntityManager();
try {
/*if (containsGdaysSession(gdayssession)) {
throw new EntityExistsException("Object already exists");
}*/
mgr.persist(gdayssession);
} finally {
mgr.close();
}
return gdayssession;
}

/**
* This method is used for updating an existing entity. If the entity does not
* exist in the datastore, an exception is thrown.
* It uses HTTP PUT method.
*
* @param gdayssession the entity to be updated.
* @return The updated entity.
*/
@ApiMethod(name = "updateGdaysSession")
public GdaysSession updateGdaysSession(GdaysSession gdayssession) {
EntityManager mgr = getEntityManager();
try {
if (!containsGdaysSession(gdayssession)) {
throw new EntityNotFoundException("Object does not exist");
}
mgr.persist(gdayssession);
} finally {
mgr.close();
}
return gdayssession;
}

/**
* This method removes the entity with primary key id.
* It uses HTTP DELETE method.
*
* @param id the primary key of the entity to be deleted.
*/
@ApiMethod(name = "removeGdaysSession")
public void removeGdaysSession(@Named("id") Long id) {
EntityManager mgr = getEntityManager();
try {
GdaysSession gdayssession = mgr.find(GdaysSession.class, id);
mgr.remove(gdayssession);
} finally {
mgr.close();
}
}

private boolean containsGdaysSession(GdaysSession gdayssession) {
EntityManager mgr = getEntityManager();
boolean contains = true;
try {
GdaysSession item = mgr.find(GdaysSession.class,
gdayssession.getKey());
if (item == null) {
contains = false;
}
} finally {
mgr.close();
}
return contains;
}

private static EntityManager getEntityManager() {
return EMF.get().createEntityManager();
}

}

Vous pouvez modifier ce code et y ajouter de nouvelles méthodes qui seront explosées par l'API. Mais avant, vous devez être capable de comprendre celui-ci, ainsi que les règles qu'il faut respecter afin que la classe demeure une classe Endpoint valide.

XII-A - Les annotations Cloud Endpoints

Cloud Endpoints permet de créer deux types d'annotations :

- des annotations globales, qui définissent le comportement global de l'API ;

- des annotations par méthode, qui définissent le comportement de chaque méthode/route de l'API.

XII-A-1 - Les annotations globales : @Api

L'annotation @Api doit être ajoutée devant la classe Endpoint qui contient les méthodes de l'API. Elle peut contenir les paramètres :

- root : l'adresse racine de l'URL de l'API ;

- name : le nom de l'API ;

- namespace : l'espace de noms de l'API ;

- version : le numéro de version de l'API ;

- description : une courte description de l'API.

Le code ci-dessous montre un exemple d'annotation d'une classe Endpoint avec @Api.

@Api(name = "gdayssessionendpoint",
version = "v2",
description = "API qui manipule l'objet GdaySession",
namespace = @ApiNamespace(ownerDomain = "example.com", ownerName = "example.com",
packagePath = "roma.gdaysapp")
)

Avec ces paramètres, l'API est accessible à l'adresse : http://localhost:8888/_ah/api/ gdayssessionendpoint/v2/.

Il existe d'autres paramètres que nous n'avons pas présentés. Ne modifiez cette annotation de la classe générée par Cloud Endpoints que si vous avez de nouveaux paramètres à ajouter à celle-ci. Vous pouvez vous référer à la documentation sur les annotations endpoint pour plus de détails.

XII-A-2 - Les annotations par méthode : @ApiMethod

Par défaut, toutes les méthodes publiques d'une classe annotée avec @Api seront exposées comme méthodes de l'API. Pour cela, Cloud Endpoints se base sur le nom de la méthode qui doit respecter une certaine nomenclature pour permettre à celui-ci de déceler certaines informations. Ainsi, Cloud Endpoints sait que la méthode insertGdaysSession(GdaysSession gdayssession) doit permettre de faire une requête POST pour insérer un objet GdaysSession, ou que la méthode getGdaysSession() doit permettre de faire une requête GET pour retourner un objet GdaysSession.

Cependant, la documentation sur la nomenclature est assez obscure, et de façon pratique, cela peut se révéler plus difficile de définir des méthodes suivant cette nomenclature. C'est pour cela qu'il est conseillé d'utiliser l'annotation @ApiMethod pour toutes les méthodes exposées par l'API.

L'annotation @ApiMethod permet de définir une configuration différente de celle fournie par défaut par @Api. Vous pouvez donc l'utiliser pour désigner clairement le chemin de la méthode, le nom et la méthode HTTP à utiliser (POST, GET, etc.).

L'annotation @ApiMethod doit être ajoutée avant la déclaration de la méthode et peut contenir les paramètres suivants :

- name : le nom qui sera utilisé au niveau du « Backend Client Lib » ;

- patch : le chemin de l'URI qui sera utilisé pour accéder à cette méthode ;

- version : la méthode HTTP à utiliser ;

@ApiMethod(name = "getGdaysSession",
path="get_gdayssession",
httpMethod="GET" )

L'unique moyen de ne pas exposer une méthode dans votre API est de déclarer celle-ci comme privée.

XII-A-3 - Les annotations par méthode : @Named, @Nullable

Si votre méthode doit prendre des paramètres, vous devez les lier à la requête du client. Pour cela, il faut faire précéder les paramètres de la méthode d'une annotation @Named. L'annotation @Named est utilisée uniquement pour des paramètres qui ne sont pas des objets (Entity).

L'annotation @Nullable, quant à elle, permet de spécifier qu'un paramètre d'une méthode peut être facultatif.

Exemple :

public CollectionResponse<GdaysSession> listGdaysSession(
@Nullable @Named("cursor") String cursorString,
@Nullable @Named("limit") Integer limit) {

- Les méthodes exposées ne peuvent pas retourner des types simples comme String ou int. La valeur retournée doit être un POJO, un tableau ou une collection.

- Vous pouvez personnaliser à souhait le code de l'API, à condition de respecter les annotations.

XIII - Utiliser l'API dans l'application Android

Si votre API a été créée correctement, vous pouvez générer la bibliothèque client Endpoint correspondante pour exploiter les méthodes de votre Backend Cloud depuis un client Android.

Pour cela, faites un clic droit dans l'explorateur de solution d'Eclipse sur votre projet App Engine, puis cliquez sur « Google », ensuite sur « Generation Cloud Endpoint Client Library », comme l'illustre la capture ci-dessous :

(cliquez ici pour aggrandir l'image)

Dès que vous avez généré votre bibliothèque client Cloud Endpoint, le nouveau code qui apparaît dans votre projet Android correspond aux fonctionnalités que vous avez exposées dans votre application App Engine. Ce code est référencé dans un dossier dont le chemin d'accès contient « endpoint-libs ».

(cliquez ici pour aggrandir l'image)

Dans votre application Android, créez une nouvelle activité. Cette activité sera utilisée pour l'insertion d'un nouvel élément dans le datastore. Pour créer une nouvelle activité, faites un clic droit sur votre application Android, sélectionnez « Nouveau », puis cliquez sur « Autre ». Dans la fenêtre qui s'affiche, sectionnez « Android Activity ». Cliquez ensuite sur « Suivant », puis renseignez le nom de l'activité et cliquez enfin sur « Fin ».

Ajoutez dans le code Java de votre activité la classe interne asynchrone suivante :

public class EndpointsTask extends AsyncTask<GdaysSession, Void, Long> {

protected Long doInBackground(GdaysSession... params) {

Gdayssessionendpoint.Builder endpointBuilder = new Gdayssessionendpoint.Builder(
AndroidHttp.newCompatibleTransport(),
new JacksonFactory(),
new HttpRequestInitializer() {
public void initialize(HttpRequest httpRequest) { }
});
Gdayssessionendpoint endpoint = CloudEndpointUtils.updateBuilder(
endpointBuilder).build();
try {

GdaysSession result = endpoint.insertGdaysSession(params[0]).execute();
} catch (IOException e) {
e.printStackTrace();
}
return (long) 0;
}
}

Pour l'affichage des données, vous pouvez utiliser la classe asynchrone suivante :

private class ListOfGdaysSessionsAsyncRetriever extends AsyncTask<Void, Void, CollectionResponseGdaysSession> {

@Override
protected CollectionResponseGdaysSession doInBackground(Void... params) {

Gdayssessionendpoint.Builder endpointBuilder = new Gdayssessionendpoint.Builder(
AndroidHttp.newCompatibleTransport(), new JacksonFactory(), null);

endpointBuilder = CloudEndpointUtils.updateBuilder(endpointBuilder);

CollectionResponseGdaysSession result;

Gdayssessionendpoint endpoint = endpointBuilder.build();

try {
result = endpoint.listGdaysSession().execute();

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
result = null;
}
return result;
}

@Override
@SuppressWarnings("null")
protected void onPostExecute(CollectionResponseGdaysSession result) {

}
}

XIV - Test local de l'application

Pour tester l'application sur votre serveur local App Engine, vous devez éditer le fichier CloudEndpointUtils.java de l'application Android et mettre la valeur de LOCAL_ANDROID_RUN à « true ». Ensuite, vous devez renseigner l'URL pour interroger votre serveur au niveau de la variable «  LOCAL_APP_ENGINE_SERVER_URL ».

public class CloudEndpointUtils {

/*
* TODO: Need to change this to 'true' if you're running your backend locally using
* the DevAppServer. See
* http://developers.google.com/eclipse/docs/cloud_endpoints for more
* information.
*/
protected static final boolean LOCAL_ANDROID_RUN = true;

/*
* The root URL of where your DevAppServer is running (if you're running the
* DevAppServer locally).
*/
protected static final String LOCAL_APP_ENGINE_SERVER_URL = "http://10.0.2.2:8888";

Démarrez ensuite votre serveur local de développement App Engine. Pour cela, faites un clic droit sur votre projet App Engine, puis cliquez sur « Debug As », ensuite sur « Web Application », comme l'illustre la capture ci-dessous :

(cliquez ici pour aggrandir l'image)

Dans la procédure onCreate de votre activité, ajoutez les lignes de code suivantes qui permettent d'ajouter un nouvel élément dans la base de données, en utilisant la classe asynchrone que nous avons définie plus haut :

GdaysSession gdaysSession = new GdaysSession();

gdaysSession.setTitle("Introduction à Cloud Endpoints");
gdaysSession.setDescription("Booster les performances de vote application Android avec App Engine");
gdaysSession.setTag("Cloud");

new EndpointsTask().execute(gdaysSession);

Enregistrez les modifications, puis procédez à l'exécution de votre application Android.

Pour visualiser les données enregistrées sur votre serveur App Engine local, ouvrez la page suivante dans une fenêtre de votre navigateur : http://localhost:8888/_ah/admin/datastore

Cette page permet d'accéder à l'interface locale de gestion de votre datastore.

XV - Déploiement de la solution

Après le test en local, vous pouvez passer au déploiement de votre application Cloud sur App Engine.

Vous allez dans un premier temps renseigner l'ID de votre application sur App Engine. Pour cela, vous allez faire un clic droit sur votre projet, puis cliquer sur « propriétés » et ensuite sur « App Engine » dans la fenêtre qui va s'afficher.

(cliquez ici pour aggrandir l'image)

Après avoir renseigné cette information, vous pouvez passer au déploiement de votre application. Il suffira de faire un clic droit sur votre projet, de sélectionner « Google », puis de cliquer sur « Deply to App Engine. »

(cliquez ici pour aggrandir l'image)

Avant le déploiement, vous devez être connecté avec votre compte Google.

L'ID de l'application que vous avez renseigné doit être celui d'une application que vous avez déjà créée sur App Engine. Si vous ne l'avez pas encore fait, dans les propriétés du projet, cliquez sur « My applications… ». Une page Web sera affichée, vous permettant de créer cette application.

Pour utiliser l'application déployée sur App Engine dans votre application, il vous suffira juste d'éditer le fichier CloudEndpointUtils.java et mettre « LOCAL_ANDROID_RUN » à « False ». Et c'est tout.

XVI - Conclusion

Cloud EndPoints est un outil qui offre souplesse et simplicité au développeur qui souhaite créer une application sur App Engine, dont les fonctionnalités seront exploitées par divers clients, quelle que soit leur plateforme exécution. Au travers de cet article, vous avez découvert comment vous pouvez créer facilement une application Android avec un backend Cloud, dont le code peut évoluer sans difficulté.

XVII - Références

- Documentation officielle sur Cloud EndPoints

- Utilisation des EndPoints dans un client Android

- Série de tutoriels de rominirani sur Cloud EndPoints

- Documentation sur les annotations Cloud EndPoints

XVIII - Remerciements

Je tiens à remercier ClaudeLELOUP pour sa relecture et correction orthographique.

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article

Retour à l'article