Trăim într-o lume dominată de tehnologie. Aplicațiile mobile reprezintă doar o mică parte din acest sistem complex, iar pentru a crea experiențe inedite, cele mai multe folosesc un sistem de backend. Toate acțiunile: de la stocare sau preluare a unui sistem de date cât de simplu și până la autentificare sau alte operații complexe se realizează mai degrabă pe o mașină remote decât pe dispozitivul propriu-zis. Opțiunile pentru un programator de aplicații mobile, în funție de cerințe, pot fi construirea unui sistem backend de la zero, sau încercarea unei abordări Mobile Bakend as a Service (MBaaS)
Abordarea Mobile Bakend as a Service reprezintă un model prin care li se asigură programatorilor web și mobile atât o modalitate de a-și conecta aplicațiile la un serviciu de stocare în cloud cât și API-uri expuse de către aplicațiile de backend.
Majoritatea serviciilor MBaaS oferă posibilitatea de a stoca date, folosirea serviciului push notifications şi autentificare. Dar ce se întâmplă atunci când ai nevoie de un backend personalizat iar un ciclu CRUD nu este suficient pentru aplicația la care lucrezi? În mod normal, asta s-ar traduce prin a te baza pe ajutorul unui programator backend. Din fericire există și Google App Engine!
Androi Studio oferă suport integrat pentru adăugare de aplicații backend in App Engine cu ajutorul serviciului Google Cloud Endpoints.
Google App Engine este o platformă folosită la dezvoltarea aplicațiilor scalabile (web și backend pentru aplicaţii mobile). App Engine asigură servicii integrate si API-uri comune pentru majoritatea aplicațiilor cum ar fi: baze de date de tip NoSQL (datastore), memcache şi un API pentru autentificarea utilizatorilor.
Cu alte cuvinte, App Engine va găzdui aplicaţia de backend şi va avea grijă de toate operaţiile necesare. Va scala aplicaţia automat în funcţie de trafic, astfel încât la final să se plătească resursele efectiv folosite evitând în acest mod estimarea resurselor în prealabil sau mentenanţa serverului.
Pe de altă parte, Google Cloud Endpoints constă dintr-o serie de instrumente, librării şi capabilităţi care permit generarea de API-uri şi librării client dintr-o aplicaţie App Engine, cu scopul de a simplifica accesul la date pentru aplicaţiile client.
Altfel spus vom folosi Google Cloud Endpoints pentru a crea un endpoint API care va fi găzduit de către Google App Engine. Google Cloud Endpoints va genera de asemenea şi librării client pentru accesul la backend API, scutindu-ne în acest fel de a scrie cod pentru comunicarea în reţea.
În acest tutorial, vă voi demonstra cât de uşor se poate adăuga suport de backend pentru o aplicaţie mobilă Android, chiar dacă aveţi o experienţă redusă în programarea backend. Prima parte va fi destinată creării şi testării aplicaţiei de backend urmând ca în partea a doua să folosim aplicaţia într-un caz concret.
Vom presupune că vrem să creăm o aplicaţie de note în care utilizatorii pot adăuga, şterge şi lista obiecte de tip notă. Entitatea noastră se va numi Note (un obiect Java bean cu un identificator, titlu şi descriere), iar pe baza ei vom genera aplicaţia de backend cu operaţii CRUD standard.
Pentru acest demo am folosit:
Android Studio 2.0 (dar în mod normal ar trebui să funcţioneze şi cu versiunea 1.0) pe o platformă Windows;
Versiunea minimă de Android: 21;
Notă: Android Studio conține toată funcționalitatea Google Cloud Platform, astfel încât nu sunt necesare alte plug-in-uri.
Cu ajutorul Android Studio vom crea aplicaţia de backend urmând paşii de mai jos:
Crearea modulului de backend;
Crearea unei clase entitate care să definească structura datelor;
Generarea unei clase Cloud Endpoint care să ne ofere infrastructura backend-ului si API-urile;
Android Studio oferă posibilitatea de a adăuga module Google Cloud unui proiect. Aici putem defini modelul și endpoints API-ul.
Dați click pe: File->New->New Module
Alegeți: "Google Cloud Module" și dați click pe Next.
Modulul client ar trebui să fie deja selectat. Vom folosi valorile predefinite ale numelui modulului și pachetului.
Dați click pe Finish.
Când noul modul este creat, Android Studio generează de asemenea librării client ce pot fi folosite în modulul aplicației mobile pentru accesul la endpoint API. Este de menționat faptul că toate permisiunile și dependințele sunt configurate automat.
Deoarece creăm un REST API, folosirea acestor librării nu este obligatorie. Putem la fel de bine să folosim URL-ul rezultat: "https://\
Dorim să adăugăm și persistență aplicației, iar pentru aceasta vom folosi Objectify. Acesta este un API Java pentru acces de date, special conceput pentru datastore-ul Google App Engine.
dependencies {
appengineSdk 'com.google.appengine:appengine-java-sdk:1.9.28'
compile 'com.google.appengine:appengine-endpoints:1.9.28'
compile 'com.google.appengine:appengine-endpoints-deps:1.9.28'
compile 'javax.servlet:servlet-api:2.5'
compile 'com.googlecode.objectify:objectify:5.0.3'`Dați click pe butonul "Sync Project with Gradle Files"
În mod automat, Android Studio generează o clasă Entity şi o clasă Endpoint asociată cu aceasta (MyBean şi Endpoints). În cazul de faţă, vom crea o entitate personalizată potrivită nevoilor noastre.
Creaţi o clasă cu numele Note. În interiorul acesteia adăugaţi trei atribute: ID, title, şi description ca în exemplul de mai jos:
import com.googlecode.objectify.annotation.Entity;
import com.googlecode.objectify.annotation.Id;
@Entity
public class Note {
@Id
Long id;
String title;
String description;
public Note() {}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String who) {
this.title = who;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
Am folosit două adnotări: \@Entity pentru a specifica faptul că aceasta este o entitate POJO şi \@Id pentru a desemna identificatorul entității. Cu ajutorul acestor informații Android Studio oferă posibilitatea generării unei clase Endpoint (click dreapta pe clasa Note -> Generate Cloud Endpoint from Java Class).
Clasa rezultată se numeşte NoteEndpoint. Acesta este, de fapt, endpoints API-ul nostru. Puteţi observa existenţa metodelor de inserare, preluare, listare, actualizare şi ştergere a elementelor de tip Note, dar la nevoie se pot adăuga şi operaţii noi.
Recreaţi proiectului: Build -> Rebuild Project
Selectaţi şi rulaţi configuraţia de backend.
Porniţi o nouă sesiune de Chrome urmând indicaţiile de la această adresă: "How do I use Explorer with a local HTTP API?" și specificați 8080 la localhost port.
Notă: Pe un sistem de operare Windows, singurul mod în care am reușit să testez aplicaţia de backend în API Explorer a fost rulând Chrome ca administrator.
Puteţi valida backend-ul accesând http://localhost:8080/ în browser. În mod normal, ar trebui să apară următoarea pagină:
Observați butonul Google Cloud Endpoints API Explorer încadrat cu roşu. Apăsându-l veţi accesa aplicaţia integrată Google API Explorer. Pe ecran vor apărea două API-uri (cel generat automat: myApi şi cel creat anterior: noteApi). API Explorer permite atât navigarea prin API-uri şi versiuni cât şi explorarea metodelor pentru fiecare din acestea.
În funcţie de semnătura metodei şi de metoda HTTP folosită, Google API Explorer pune la dipoziţie un formular HTML în care vă puteţi adăuga datele. De exemplu, dacă veţi selecta metoda de inserare (insert) veţi avea o listă drop-down de unde puteţi selecta câmpurile specifice unei entităţi şi introduce valorile pe care le doriţi. În acest mod, se evită nevoia de a memora structura unei entităţi.
Dând click pe Execute without OAuth veți invoca metoda de inserare, apoi veți primi un răspuns în timp real ca în exemplul de mai jos. Rezultatul final este un obiect JSON ce reprezină o entitate de tip Note.
Această operație poate fi validate prin executarea metodei de listare, apoi prin verificarea existenței elementului Note adăugat.
În acest moment putem spune că am creat aplicaţia de backend. Desigur, mai sunt câțiva pași de făcut pentru a o putea folosi pe un caz concret, dar ce trebuie reţinut este faptul că prin doar câteva click-uri am reuşit să creăm şi să testăm un endpoint API.
În partea a doua a tutorialului ne vom concentra pe aplicabilitatea backend API-ului. Întâi, vom realiza integrarea cu aplicația mobilă prin intermediul librăriilor client generate, după care, vom instala aplicația pe Google App Engine şi vom trage câteva concluzii.
În prima parte a acestui tutorial, am explicat cum se poate crea o aplicaţie de backend folosindu-ne de suportul pentru Google App Engine din Android Studio. Inițial, am creat un modul pentru Google Cloud Module, pentru ca ulterior, pe baza unei entităţi, am generat API-ul. În final, cu ajutorul aplicației Google API Explorer, am arătat cum putem testa metodele API-ului.
În partea a doua, vom folosi aplicația într-un caz concret. Pentru început, vom vedea cum putem executa metodele API-ului într-o aplicație mobilă, apoi vom instala aplicația de backend pe serverele Google App Engine.
Cum am specificat în prima parte, la crearea modulul de backend se genereaza librării client ce pot fi folosite la accesarea API-ului. Ținând cont că vom executa operații în rețea, este evident faptul că vom avea nevoie de un fir separat de execuție. Fragmentul de mai jos reprezintă metoda doInBackground a unei clase AsyncTask în care folosim această librărie client pentru a prelua lista de entități Note.
@Override
protected List doInBackground(Void... params) {
if(myNotesService == null) {
NoteApi.Builder builder = new NoteApi.Builder(AndroidHttp.newCompatibleTransport(),
new AndroidJsonFactory(), null)
.setRootUrl("http://10.0.2.2:8080/_ah/api/")
.setGoogleClientRequestInitializer(new GoogleClientRequestInitializer() {
@Override
public void initialize(AbstractGoogleClientRequest abstractGoogleClientRequest) throws IOException {
abstractGoogleClientRequest.setDisableGZipContent(true);
}
});
myNotesService = builder.build();
}
try {
return myNotesService.list().execute().getItems();
} catch (IOException e) {
throw new IllegalStateException("Exception when listing the notes " + e.getMessage());
}
}
Notă: Dacă folosiți Windows, probabil că nu veți reuși să rulați aplicația mobilă în același timp în care rulează și backend API:
Unable to delete file: \
Pentru a remedia această eroare va trebui să vă editați configurația de rulare a aplicației.
La Deploy nu selectați nimic.
Ștergeți sarcina implicită Gradle-aware Make.
Dați click pe butonul + și selectați Gradle aware Make.
Introduceți :app:assembleDebug și dați click pe OK.
Acum ar trebui să aveți o configurație similară cu cea de jos:
Dați click pe OK.
Acum puteți rula aplicația mobilă și testa backend API-ul local simultan .
Din moment ce aplicaţia de backend funcţionează local, putem să o instalăm pe Google App Engine. Această operaţie se realizează de asemenea prin intermediul Android Studio.
În primul rând, trebuie să creăm un proiect în Google Developers Console sau să folosim unul existent. În Google Developers Console, un proiect reprezintă o colecţie de setări, credenţiale şi metadate despre aplicaţia sau aplicaţiile care folosesc API-ul Google Developer sau resurse Google Cloud.
La crearea unui proiect, ni se permite specificarea regiunii în care să se afle serverele ce vor găzdui aplicaţia. Putem alege între US Central, US East şi Europe West. De exemplu, dacă utilizatorii ţintă sunt din Europa, atunci ar trebui aleasă ultima variantă.
După ce specificaţi numele proiectului, daţi click pe Create a Project -> Show advanced options.
Alegeţi regiunea.
Daţi click pe Create.
În acest moment, tot ce rămâne de făcut este să instalăm aplicaţia de backend pe App Engine (În Android Studio: Build -> Deploy Module to App Engine...)
În dialogul afişat:
Selectaţi modulul de backend pe care vreţi să îl instalaţi (Module).
Selectaţi proiectul din Developers Console cu care vreți să asociați backend API-ul.
După cum puteți vedea, Google Cloud Endpoints oferă suport pentru păstrarea simultană a mai multor versiuni de API (Menu -> App Engine -> Versions). Astfel putem migra treptat de la o versiune la cealaltă până când versiunea iniţială poate fi scoasă din uz.
O altă funcționalitate utilă este cea prin care se permite vizualizarea dataset-ului şi executarea de operaţii în cadrul lui. Deschideţi meniul din partea stângă şi alegeţi Storage -> Datastore. Aici, dacă daţi click pe Entities, veţi vedea dataset-ul asociat aplicaţiei de backend.
În plus, Google developers Console oferă posibilitatea verificării stării unui proiect App Engine. În secțiunea Dashboard a proiectului puteți observa un grafic al utilizării aplicației și aveți posibilitatea de a selecta unitatea de masură dorită, folosind lista drop-down din colțul din stânga sus. De asemenea, puteți alege perioada de timp preferată pentru acest grafic (de la o oră la 30 de zile) și selecta versiunea aplicației de care sunteți interesat.
În aplicația client, crearea endpoint-ului este ușor diferită.
@Override
protected List doInBackground(Void... params) {
if(myNotesService == null) {
NoteApi.Builder builder = new NoteApi.Builder(AndroidHttp.newCompatibleTransport(), new AndroidJsonFactory(), null)
.setRootUrl("https://dot-notes-ae.appspot.com/_ah/api/");
myNotesService = builder.build();
}
try {
return myNotesService.list().execute().getItems();
} catch (IOException e) {
throw new IllegalStateException("Exception when listing the notes " + e.getMessage());
}
}
Formatul URL-ului de bază se schimbă în https://\
În mod similar, putem crea clase AsyncTask pentru inserare sau ştergere de note. Integrarea acestora în aplicaţie nu ar trebui să reprezinte un impediment pentru un programator Android. O modalitate ar fi să creaţi o activitate pentru listare şi ştergere, iar alta pentru inserare.
Majoritatea programatorilor de aplicaţii mobile preferă să lucreze la părţile ce ţin de experienţa utilizatorilor şi designul aplicaţiei, în loc să administreze infrastructura pe care aceasta rulează. În opinia mea, aşa ar trebui să şi ramână.
Folosind Google App Engine, timpul necesar adăugării de suport backend se reduce la minim, chiar şi pentru un programator cu puţină experienţă în acest domeniu. Acest serviciu nu oferă doar capabilităţi standard specifice MBaaS dar şi flexibilitatea de a personaliza API-ul.
Aşadar, dacă sunteţi în căutarea unei metode rapide de a adăuga suport backend pentru o aplicaţie mobilă fără a fi nevoie să vă îngrijoraţi cu privire la scalabilitate sau alte probleme legate de găzduirea backend-ului, Google App Engine e cu siguranţă o variantă de luat în seamă.
de Ovidiu Mățan
de Vlad But
de Maria Revnic
de Delia Mircea
