UNIVERSITATEA DIN BUCURE Ș TI FACULTATEA DE MATEMATICĂ Ș I INFORM ATICĂ SPECIALIZAREA CALCULATOARE Ș [606523]
UNIVERSITATEA DIN BUCURE
Ș
TI
FACULTATEA
DE
MATEMATICĂ
Ș
I INFORM ATICĂ
SPECIALIZAREA CALCULATOARE
Ș
I TEHNOLOGIA INFORMA
Ț
IEI
Lucrare de licen
ț
ă
JURNAL DE CĂLĂTORIE
–
APLICA
Ț
IE MOBILĂ CROSS-PLATFORM
Absolvent: [anonimizat], iulie 2020
SPECIALIZAREA CALCULATOARE
Ș
I TEHNOLOGIA INFORMA
Ț
IEI
Lucrare de licen
ț
ă
JURNAL DE CĂLĂTORIE
–
APLICA
Ț
IE MOBILĂ CROSS-PLATFORM
Absolvent: [anonimizat], iulie 2020
CUPRINS
Introducere …………………………………………………………………………………………………………….. 6
Preliminarii……………………………………………………………………………………………………………… 9
1. TEHNOLOGII FOLOSITE ………………………………………………………………………………… 13
1.1 Sistemul de operare Android……………………………………………..…….…..…… 13
1.1.1 Istoricul versiunilor Android………………………………………………………………. 13
1.1.2 Emulatorul Android……………………………………………………………………………. 14
1.2 Sistemul de operare iOS………………………………………………………………………….. 15
1.2.1 Istoricul versiunilor Apple iOS…………………………………………………………… 15
1.3 .NET Standard………………………………………………………………………………………… 16
1.3.1 .NET Framework………………………………………………………………………………… 18
1.3.2 .NET Core…………………………………………………………………………………………. 19
1.3.3 Microsoft Visual Studio…………………………………………………………………….. 20
1.3.4 NuGet…………………………………………………………………………………………………. 21
1.4 Xamarin………………………………………………………………………………………………….. 22
1.4.1 Ce este Xamarin………………………………………………………………………………….. 22
1.4.2 Xamarin.Essentials…………………………………………………………………………….. 24
1.4.3 Xamarin.Forms…………………………………………………………………………………… 25
1.4.4 Xamarin.Native vs Xamarin.Forms…………………………………………………….. 26
1.5 C#…………………………………………………………………………………………………………… 27
1.5.1 C# în ansamblu…………………………………………………………………………………… 27
1.5.2 Componente C# folosite în aplica
ț
ie…………………………………………………….. 28
1.6 XAML…………………………………………………………………………………………………….. 30
1.7 Modelul arhitectural MVVM…………………………………………………………………… 32
1.7.1 Componentele modelului MVVM……………………………………………………… 33
1.7.1.1 Model……………………………………………………………………………………………. 33
1.7.1.2 View………………………………………………………………………………………………. 34
1.7.1.3 View-model……………………………………………………………………………………. 34
1.7.2 Implementarea MVVM în aplica
ț
ia mea…………………………………………….. 35
1.8 Azure…………………………………………………………………………………………………….. 36
1.8.1 Azure SQL Database………………………………………………………………………….. 37
1.8.2 Serverele Azure SQL Database
ș
i management-ul lor………………………….. 37
1.8.3 Azure app service……………………………………………………………………………… 38
1.8.4 Configurarea aplica
ț
iei mele……………………………………………………………… 40
1.9 SQL………………………………………………………………………………………………………. 41
1.10 ERD……………………………………………………………………………………………………. 43
1.11 Foursquare………………………………………………………………………………………….. 45
1.12 MacinCloud………………………………………………………………………………………… 48
2. PREZENTAREA APLICA
Ț
IEI………………………………………………………………………… 51
2.1 Prezentare generală……………….……………………………………………………..… 51
2.2 Descrierea tehnică a aplica
ț
iei………………………………………………………………. 52
3. APLICA
Ț
IA………….. ……………………………………………………………………………………….. 56
3.1 Pagina de autentificare………………………………………………………………………… 56
3.2 Pagina de înregistrare………………………………………………………………………….. 60
3.3 Pagina de istoric………………………………………………………………………………….. 64
3.4 Pagina de detalii………………………………………………………………………………….. 67
3.5 Pagina cu harta…………………………………………………………………………………… 71
3.6 Pagina de profil…………………………………………………………………………………… 74
3.7 Pagina pentru noua experien
ț
ă……………………………………………………………. 77
CONCLUZII………………………………………………………………………………………………………. 80
Bibliografie…………………………………………………………………………………………………………. 82
ANEXE
Anexa 1 – Codul de backend al aplica
ț
iei mobile din Azure
Anexa 2 – Parte din functionalitatea de autentificare
Anexa 3 – Func
ț
ia GetPermissions()
Anexa 4 – Poza din cadrul emulatorului Android
Rezumat
Lumea s-a transformat într-un peisaj digital
ș
i a devenit complet mobilă. Pia
ț
a de aplica
ț
ii
s-a extins pentru a încorpora numeroase dispozitive mobile
ș
i diferite sisteme de operare.
Dezvoltarea de aplica
ț
ii mobile native
ș
i cross-platform este un su biect tot mai dezbătut
ș
i de
actualitate. Deoarece fiecare dispozitiv
ș
i sistem de operare are propriile moduri de a trata
aplica
ț
iile, avantajele
ș
i dezavantajele aplica
ț
iilor cross-platform sunt numeroase.
În lucrarea de fata mi-am propus sa realizez o aplica
ț
ie mobilă cross-platform sub forma
unui jurnal electronic de călătorie. Aplica
ț
ia Journey Record este construită folosind
framework-ul Xamarin Forms. Versiunea pentru Android cât
ș
i cea pentru iOS vor arăta similar
ș
i întrucât datele sunt stoc ate în Cloud, se pot accesa acelea
ș
i informa
ț
ii.
Aplica
ț
ia este gân dită pentru a adăuga noi experien
ț
e. Loca
ț
ia dispozitivului ajuta la
găsirea locurilor sau a obiectivelor din apropiere. Loca
ț
ia este introdusă setand coordonate pe
emulatoare, iar cu ajutorul Foursquare API este furnizată o listă cu loca
ț
ii din apropierea
coordonatelor anterioare. Se alege loca
ț
ia, se scrie recenzia, apoi se salvează în baza de date
Azure ca o nouă experien
ț
ă. Informa
ț
ia introdusă va fi redată din Azure indiferent de dispozitiv
utilizat, iar loca
ț
iile vizita te vor fi introduse pe hartă sub formă de pini. Experien
ț
a introdusă se
va regăsi în pagina de istoric, iar în pagina de profil se vor regăsi categoriile de locuri vizitate
ș
i
numărul recenziilor adăugate la fiecare categorie, împreună cu numărul total al recenziilor.
În aceasta lucrare mi-am propus sa folosesc cele mai actuale medii de dezvoltare,
limbaje, tehnici
ș
i instrum ente existente, ca sa dezvolt o aplica
ț
ie u
ș
or de folosit de către orice tip
de utilizator.
Introducere
Aplica
ț
iile mobile au apărut de mai bine de 12 ani. În acest timp, pia
ț
a dezvoltării mobile
s-a schimbat semnificativ. Numărul utilizatorilor de
smartphone-uri
cre
ș
te în fiecare an din
cauza varietă
ț
ii de aplica
ț
ii mobile oferite de magazinele de aplic a
ț
ii. Deci există o nevoie din ce
în ce mai mare de a dezvolta mai multe aplica
ț
ii care satisfac nevoile din diferite domenii.
Cererea tot mai mare de aplica
ț
ii a adus idei noi pentru reducerea timpului de dezvoltare.
Există mul
ț
i furni zori de smartphone-uri pe pia
ț
ă
ș
i fiecare vânzător folose
ș
te o platformă
specifică. Aceste platforme includ
Android, iOS, BlackBerry OS
, etc. La început, dezvoltatorii
s-au limitat la aplica
ț
iile n ative specifice platformei care nu au putut lucra pe sisteme diferite.
Din aceasta nevoie s-a născut dezvoltarea
cross-platform
. Scopul oricărei companii de dezvoltare
mobilă este de a viza cât mai mul
ț
i utilizatori, oferind aceea
ș
i aplica
ț
ie pentru diferite platforme.
Fiecare furnizor de platformă oferă dezvoltatorilor diferite medii integrate de dezvoltare (
IDE
),
limbaje de programare,
API-uri
ș
i pia
ț
ă de distribu
ț
ie a aplica
ț
iilor.
Abordarea
cross-platform
de dezvoltare a aplica
ț
iilor mobile a fost acceptată pe deplin de
dezvoltatorii din întreaga lume, deoarece face ca întregul proces să se mi
ș
te rapid
ș
i u
ș
or.
Dezvoltarea unei aplica
ț
ii
cross-platform
permite companiei dezvoltatoare să creeze o aplica
ț
ie
folosind un singur limbaj. Este foarte recomandată utilizarea unui cod unic care poate fi folosit
pe diferite platforme pentru a construi aplica
ț
ia, decât să dezvol
ț
i noi coduri în fiecare zi pentru
diversele platforme disponibile. [
31
]
Aplica
ț
ia pe care am dezvoltat-o în lucrarea mea de licen
ț
ă
ș
i pe care am numit-o
Journey
Record
este o aplica
ț
ie mobilă
cross-platform
. Aplica
ț
ia s-a născut din dorin
ț
a realizării unui
jurnal electronic de călătorie în care po
ț
i salva descrieri, impresii, amintiri, sfaturi sau multe alte
lucruri despre locurile în care calatoresti sau în care vrei sa ajungi, cu un minim timp
ș
i efort.
Practica de a păstra un jurnal de călătorie ajută la organizarea gândurilor
ș
i impresiilor despre
locurile
ș
i lucrurile pe car e dore
ș
ti să
ț
i le aminte
ș
ti sau sa le impartasesti ulterior.
6
Încă din liceu cand am primit primul meu
smartphone
am fost pasionată de aplica
ț
iile
mobile, m-au interesat în mod special cele care puteau trece de la un sistem de operare la altul
fără probleme. Mai târziu am aflat termenul de
cross-platform
ș
i am început sa fac cercetări în
domeniu, de aceea, am vrut ca lucrarea mea să fie o aplica
ț
ie mobilă
cross-platform
. În această
lucrare am îmbinat discipline precum Baze de Date
ș
i Cloud Computing, avand o baza de date
rela
ț
ională scrisă în
SQL
ș
i salvată în
cloud-ul Microsoft Azure;
Programare pe dispozitive
mobile, Metode de dezvoltare software
ș
i Ingineria programării, întrucât aplica
ț
ia respectă
principiile programării orientate pe obiecte
ș
i regulile impuse de dezvoltarea software
contemporană. Am ales sa folosesc în principal produse
Microsoft
precum
Visual Studio, Azure,
ș
i
Xamarin
întrucât, sunt în general gratuite, u
ș
or de utilizat
ș
i aveam o experien
ț
ă anterioară cu
câteva dintre ele, deci le
ș
tiam deja capacită
ț
ile.
Lucrarea este împăr
ț
ită în două păr
ț
i importante, prima, p artea teoretică, unde definesc
ș
i
explic no
ț
iunile tehnice
ș
i teoretice care stau la baza lucrării
ș
i a doua, partea practică, în care
descriu mai în amănunt aplica
ț
ia
cross-platform
dezvoltată, împreună cu câteva aprecieri
personale pe baza modului de realizare al aplica
ț
iei
ș
i o concluzie.
Intr-un articol de pe site-ul
keepgo.com,
“ TOP 15 ANDROID AND IOS APPS FOR
TRIP LOGGINGS”, autoarea
Kateryna Toniuk
vorbe
ș
te despre câteva aplica
ț
ii mobile de
călătorie, precum
Evernote, Journi,
sau
Bonjournal
asemănătoare unor jurnale electronice. [
18
]
De la aceste modele de aplica
ț
ie
ș
i functionalitati am pornit sa de zvolt aplica
ț
ia mea,
Journey
Record
, care oferă utilizatorilor posibilitatea de: logare, înregistrare, vizualizare istoric,
update
/
delete
post, vizualizare pe categorii de loca
ț
ii în care au făcut postări, vizualizare loca
ț
ii
adiacente
ș
i localizarea u tilizatorului pe hartă. Fa
ț
ă de
Google Maps
spre exemplu, aplica
ț
ia mea
este ceva mult mai personal, care nu necesită atatea permisiuni sau date
ș
i nu poate (încă) să
partajeze con
ț
inutul.
Nu
de
pu
ț
ine
ori
m-am
întâlnit
cu
reticen
ț
ă
din
partea
persoanelor
de
orice
vârstă
în
a-
ș
i
oferi
consim
ț
ământul
sau
a-
ș
i
furniza
datele
personale
pentru
o
aplica
ț
ie,
un
sistem
informatic,
un
site
sau
orice
le
poate
face
datele
publice
pe
internet
sau
oferi
acces
la
ele
altor
entită
ț
i
decât
apar
ț
inătorul.
Această
aplica
ț
ie
este
simplă
din
punct
de
vedere
al
autentificării
ș
i
a
permisiunilor
7
acordate
pentru
utilizarea
datelor
furnizate
de
către
utilizator
în
scopul
facilitării
accesului
la
resursele aplica
ț
iilor fără oferirea de informa
ț
ii personale.
Aplica
ț
ia
nu
cere
acces
la
date
cu
caracter
personal
ș
i
nici
nu
cere
utilizatorului
să
furnizeze
alte
informa
ț
ii
în
afară
de
un
user
ș
i
o
parolă
pentru
crearea
contului,
necesar
accesului
facil
la
informa
ț
iile
despre
loca
ț
ie
sau
la
propriile
postari,
redat e
în
aplica
ț
ie
din
bazele
de
date
existente
în
Azure
sau
Foursquare
.
Singura
permisiune
de
care
trebuie
să
beneficieze
aplica
ț
ia
este accesul la loca
ț
ie, pe care utilizatorul trebuie să îl acorde la pornirea acesteia.
Journey
Record
îndepline
ș
te
nevoia
de
a
vedea
ce
este
în
jurul
tău
indiferent
unde
te
afli,
te
ajută
sa
te
orientezi
mai
bine
sau
să
descoperi
locuri
noi.
Postările
rămân
personale,
accesibile
doar
din
propriul
cont,
oferind
siguran
ț
a
propriei
opinii
ș
i
a
exprimării,
îndeplinind
astfel
rolul
de
jurnal
personal.
Un
jurnal
electronic
reprezintă
ș
ansa
să
înve
ț
i
mai
multe
despre
tine,
precum
ș
i
să
păstrezi
toate
lucrurile
ș
i
amintirile
importante
pe
care
le
creezi.
După
ceva
timp,
va
fi
fascinant să cite
ș
ti despre gândurile
ș
i experien
ț
ele acumulate în timpul călătoriei.
8
Preliminarii
Dezvoltarea
cross-platform
permite aplica
ț
iilor mobile să fie compatibile cu mai multe
sisteme de operare, deci permite rularea aceleia
ș
i aplica
ț
ii pe orice
smartphone
sau tabletă. 70%
dintre dezvoltatori se folosesc de instrumente de dezvoltare
cross-platform
, precum
Apache
Cordova, Xamarin
sau
Unity.
Instrumentele permit construirea unei baze de coduri partajate
ș
i
compilarea aplica
ț
iei ca u na nativă, dar fiind de fapt
cross-platform
. Utilizarea acestui tip de
instrumente scade costurile de dezvoltare
ș
i suport ducând la cre
ș
terea cotei de pia
ț
ă disponibile.
Dezvoltarea
cross-platform
este ideala pentru aplica
ț
iile care trebuie să utilizeze resursele unui
dispozitiv în mod eficient
ș
i rapid, depă
ș
ind importan
ț
a experien
ț
ei de utilizator.
Companiile de software care doresc să vândă mai multe programe software aleg să î
ș
i
pună la dispozi
ț
ie aplica
ț
ia pe mai multe platforme, astfel încât să fie posibil ca mai mul
ț
i clien
ț
i
să-i folosească produsul. Software-ul
cross-platform
a devenit mai comun odată cu cre
ș
terea
platformelor de calculatoare, cum ar fi
Linux
sau
Mac OS
. Apari
ț
ia
ș
i cre
ș
terea smartphone-urilor
au dus, de asemenea, la o mai mare compatibilitate între platforme. Mul
ț
i dezvoltatori de
aplica
ț
ii creează aplica
ț
ii atât pentru dispozitive
Android
cât
ș
i pentru
iOS
. Punerea la dispozi
ț
ie
a aplica
ț
iei pe ambele pla tforme populare le permite un câ
ș
tig mai mare, pentru că unele
aplica
ț
ii, inclusiv re
ț
elele sociale, func
ț
ionează cel mai bine atunci când există o bază de
utilizatori mai mare. [
37
]
Dezvoltarea de aplica
ț
ii mobile este un caz special al dezvoltării software, deoarece
dezvoltatorii trebuie să ia în considerare diferite aspecte, cum ar fi ciclul de via
ț
ă de dezvoltare
scurtă, capacită
ț
ile dispoz itivelor mobile, mobilitatea, specifica
ț
iile dispozitivelor mobile,
precum dimensiunile ecranului, designul
ș
i navigarea interfe
ț
ei utilizatorului, securitatea
ș
i
confiden
ț
ialitatea utilizato rilor, iar aplica
ț
iile necesită marketing pentru a ob
ț
ine popularitate.
[
10
]
Există multe avantaje atunci când vine vorba de a dezvolta
cross-platform
: [
11
]
9
●
Codul reutilizabil: instrumentele de dezvoltare
cross-platform
permit scrierea codului
odată, apoi exportarea aplica
ț
iei pe mai multe sisteme de operare
ș
i platforme, fără a
necesita crearea unei aplica
ț
ii dedicate pentru fiecare platformă.
●
Convenabilitatea: instrumentele de dezvoltare
cross-platform
nu cer învă
ț
area mai multor
limbaje de programare
ș
i oferă un înlocuitor pentru toate aceste tehnologii diferite.
●
Codul de men
ț
inere: ori de câte ori se modifică sau se actualizează aplica
ț
ia, trebuie să
facem o singură actualizare, iar modificările vor fi sincronizate
ș
i reflectate în toate
aplica
ț
iile de pe d iferite platforme.
●
Eficien
ț
a costurilo r: dezvoltarea
cross-platform
permite economisirea costurilor mai
multor echipe care lucrează la diferite versiuni ale aplica
ț
iei, folosind o singură echipă.
Majoritatea instrumentelor de dezvoltare
cross-platform
sunt gratuite, unele oferind
abonamente plătite pentru func
ț
ii suplimentare.
●
Atingerea pie
ț
ei: publicând aplica
ț
ia pe mai multe platform e, se creeaza o bază de
utilizatori mai mare, cre
ș
te randamentul investi
ț
iilor
ș
i se ob
ț
in venituri mai mari.
Însă, există
ș
i dezavantaje : [
1
]
●
Timp lung de a
ș
teptare pentru noi func
ț
ii: De fiecare dată când se introduce o
caracteristică nouă pentru pentru un sistem de operare sau aplica
ț
ie, este nevoie de ceva
timp pentru a le actualiza ca sa sus
ț
ină această nouă caracteristică,
●
Grafică slabă: aplica
ț
iile
cross-platform
, nu oferă imagini atractive sau suport
tridimensional, care este un dezavantaj major pentru utilizatorii orientati pe aspect, deci
dezvoltarea
cross-platform
nu este recomandata pentru jocuri sau aplica
ț
ii care trebuie sa
foloseasca func
ț
iile dispozitivelor,
●
Design mai dur al codului: există o muncă suplimentară pentru dezvoltatorii de aplica
ț
ii
cross-platform
deoarece trebuie să se ocupe de excep
ț
ii specifice pentru o varietate de
dispozitive
ș
i dife ren
ț
e de platformă, în special cu func
ț
ii mai complicate. Aceste
probleme nu apar adesea în aplica
ț
iile native, deci dezvoltatorii se pot concentra pe
rezolvarea problemelor utilizatorilor,
●
Laguri în performan
ț
ă: Aplica
ț
iile
cross-platform
nu reu
ș
esc mereu să se integreze
perfect în toate sistemele a
ș
a cum o fac aplica
ț
iile native. Acest lucru poate provoca
10
încetinirea func
ț
iilor aplica
ț
iei sau înghe
ț
area
software-ului
, deoarece codurile non-native
nu pot întotdeauna comunica cu
hardware-ul
sau
software-ul
diferitelor dispozitive.
Aceste erori limitează func
ț
ionalitatea dispozitivului
ș
i împiedică utilizatorii să acceseze
func
ț
ii de bază ale acestuia
Chiar
ș
i o organiz a
ț
ie precum
Microsoft
, care în mod tradi
ț
ional a rezistat dezvo ltării
pentru alte platforme, adoptă dezvoltarea
cross-platform
.
Microsoft
a anun
ț
at capacitatea de a
construi aplica
ț
ii
Window s
universale care vor rula atât pe
Windows
, cât
ș
i pe
Android
, dar
ș
i
posibilitatea de a importa proiecte de la
Xcode
(platforma de dezvoltare a produselor
Apple
)
direct în
Visual Studio
ș
i de a le recompila pentru a putea fi rulate pe
Windows
.
Conform statisticilor “se anticipează că pia
ț
a publicitară globală
ș
i mobilă va cre
ș
te la o
rată de cre
ș
tere anuală co mpusă de 26,1% din 2016 până în 2022. Pia
ț
a a generat venituri de
25,19 miliarde USD în 2015
ș
i se anticipează să ajungă la 127,93 miliarde dolari până în 2022.”
[
1
] Acesta este motivul pentru care în ultimii doi ani, dezvoltarea aplica
ț
iilor
cross-platform
a
câ
ș
tigat popularitate în se ctorul corporativ.
În conformitate cu standardele de dezvoltare actuale ale aplica
ț
iilor mobile, am ales ca
pa
ș
ii pe care îi urmez în c iclul de viata al aplica
ț
iei mele sa fie următorii: analiza ideii aplica
ț
iei
pornind de la analiza aplica
ț
iilor deja existente, proiectarea interfe
ț
ei cu utilizatorul, pe baza
nevoilor acestuia, dezvoltarea aplica
ț
iei folosind instrumente
ș
i limbaje de programare
cross-platform
, în principal produse
Microsoft
gratuite
ș
i performante,
ș
i testarea aplica
ț
iei pe
diferite emulatoare, respectiv cel de
Android Galaxy Nexus
ș
i cel de
iOS iPhone 11.
[
19
]
Obiectivele principale ale lucrării au fost crearea unei aplica
ț
ii de mobil care sa poată fi
folosită ca un jurnal electronic, ce oferă utilizatorului acces facil la resursele acesteia de
localizare
ș
i stocarea exp erien
ț
elor fără preluarea de date persona le, utilizarea de aplica
ț
ii
software
,
framework-uri
ș
i limbaje cât mai actuale de programare
ș
i îmbunătă
ț
irea abilită
ț
ilor
mele de programare. De
ș
i dezvoltarea de aplica
ț
ii mobile are o mul
ț
ime de restric
ț
ii
ș
i provocări,
am reu
ș
it să dezvolt o sin gură aplica
ț
ie mobilă
ș
i să o rulez pe diferite platforme mobile
economisind timp
ș
i efort .
11
12
1.
TEHNOLOGII FOLOSITE
1.1 Sistemul de operare Android
Sistemul
de
operare
Android
este
un
sistem
de
operare
mobil
dezvoltat
de
Google
,
reprezentant
al
Open
Handset
Alliance
,
bazat
pe
o
versiune
modificată
a
nucleului
Linux
ș
i
a
altor
programe
software
open
source
,
conceput
în
principal
pentru
dispozitive
mobile
cu
ecran
tactil,
cum
ar
fi
smartphone-urile
ș
i
tabletele.
Variante
Android
folosesc
ș
i
alte
componente
electronice,
precum
console
de
jocuri,
camere
digitale,
PC-uri,
televizoare,
ma
ș
ini,
ceasuri
de
mână
ș
i altele, fiecare avâ nd o interfa
ț
ă de utilizator specializată.
Codul
sursă
principal
al
Android
este
Android
Open
Source
Project
(AOSP)
,
licen
ț
iat
în
principal
sub
licen
ț
a
Apache.
El
este
asociat
cu
o
suită
de
software
proprietar
numit
Google
Mobile
Services
(GMS),
care
vine
preinstalat
pe
dispozitive
ș
i
include
aplica
ț
ii
de
bază
cum
ar
fi
Gmail,
Google
Play
ș
i
aplica
ț
ii
precum
browserul
web
Google
Chrome
.
Utilizatorii
Android
î
ș
i
pot
conecta
dispozitivele
mobile
cu
alte
servicii
Google
:
stocarea
în
cloud
,
platforme
de
e-mail
ș
i
serviciile video. [
32
]
1.1.1 Istoricul versiunilor Android
Android
a
fost
prezentat
în
2007,
cu
primul
dispozitiv
Android
comercial
lansat
în
septembrie
2008.
Versiunea
actuală
stabilă
este
Android
10
,
lansată
pe
3
Septembrie
2019.
Android
a
fost
cel
mai
bine
vândut
sistem
de
operare
la
nivel
mondial
pe
smartphone-uri
din
2011
ș
i pe tablete din 201 3. [
14
]
Primul nume de cod public:
„Cupcake”
, l-a primit versiunea
Android 1.5
în 2009,
urmând alte versiuni, denumite după dulciuri
(Donut, Éclair, Froyo, Gingerbread, Jelly Bean,
KitKat, Lollipop, Marshmallow, Nougat, Oreo
ș
i Pie)
: „
Deoarece aceste dispozitive ne fac via
ț
a
atât de dulce, fiecare versiune Android este numită după un desert.”
a
ș
a cum s-a explicat oficial
la lansarea
Android 4.4 KitKat.
[
13
]
13
Fig. 1.1 – Istoricul versiunilor Android
1.1.2 Emulatorul Android:
Emulatorul
este
o
aplica
ț
ie
nouă
în
sistemul
de
operare
Android
,
este
un
nou
prototip
utilizat
pentru
a
dezvolta
ș
i
testa
aplica
ț
ii
Android
fără
a
utiliza
niciun
dispozitiv
fizic.
Emulatorul
Android
are
toate
caracteristicile
hardware
ș
i
software
ale
dispozitivului
mobil,
cu
excep
ț
ia
apelurilor
telefo nice.
Oferă
chei
de
naviga
ț
ie
ș
i
control
ș
i
are
un
ecran
pentru
a
afi
ș
a
aplica
ț
ia.
Emulatoarele
utilizează
configura
ț
iile
dispozitivului
virtual
pentru
Android
ș
i
în
timp
ce
aplica
ț
ia
rulează,
ea
poate
utiliza
serviciile
sistemului
de
operare
Android
pentru
a
ajuta
alte
aplica
ț
ii,
accesează
re
ț
eaua,
redă
audio,
video,
stochează
ș
i
preia
datele.
Emulatorul
folosit
de
mine pentru realizarea lucrării de licen
ț
ă utilizează sistemul de operare
Android Pie 9.
Fig. 1.2 – Emulatorul Android creat în Visual Studio 2019
14
1.2 Sistemul de operare iOS
iOS
este
sistemul
de
operare
dezvoltat
de
compania
Apple.inc.,
care
rulează
doar
pe
dispozitivele
mobile
Apple
,
respectiv
iPhone,
iPad,
iPod
Touch,
iPad
mini
ș
i
pe
smartwatch-ul
Apple.
iOS
este
al
doilea
cel
mai
mare
sistem
de
operare
la
nivel
mondial
după
Android.
Apple
iOS
se
bazează
pe
sistemul
de
operare
Mac
OS
X
pentru
computere
desktop
ș
i
laptop.
Suportă
limbajele de programare
Objective C, C, C++, Swift,
etc.
Interfa
ț
a
de
utilizator
iOS
se
bazează
pe
o
manipulare
directă,
folosind
gesturi
multi-touch
.
Elementele
de
control
ale
interfe
ț
ei
constau
în
glisiere
ș
i
apasare.
Accelerometrele
interne
sunt
folosite
de
unele
aplica
ț
ii
pentru
a
răspunde
la
agitarea
dispozitivului
(un
rezultat
obi
ș
nuit
este
comanda
de
anulare)
sau
rotirea
acestuia
în
trei
dimensiuni
(un
rezultat
obi
ș
nuit
este
trecerea
între
modul
portret
ș
i
peisaj).
Apple
a
încorporat
func
ț
ii
de
accesibilitate
completă
în
iOS
, permi
ț
ând utilizatori lor cu dizabilită
ț
i de vedere
ș
i auz să-
ș
i folosească corect produsele.
iOS
este
complet
diferit
de
celelalte
sisteme
de
operare
pentru
telefoane
mobile,
deoarece
păstrează
toate
aplica
ț
iile
din
dispozitivul
său
în
interiorul
carcaselor
sale
de
protec
ț
ie,
astfel
încât
să
nu
interfereze
în
activitatea
lor.
iOS
este
conceput
astfel
încât,
dacă
dispozitivul
prime
ș
te
accidental
un
virus
într-o
aplica
ț
ie,
acesta
să
nu
poată
dăuna
ș
i
altor
aplica
ț
ii.
O
astfel
de
caracteristică nu există în alte sisteme de operare. [
8
]
1.2.1 Istoricul versiunilor Apple iOS
Apple
iOS
a
fost
cunoscut
ini
ț
ial
ca
iPhone
OS.
Compania
a
lansat
trei
versiuni
ale
sistemului
de
operare
mobil
sub
acest
nume
înainte
ca
iOS
4
să
debuteze
în
iunie
2010.
Lansat
în
2007
pentru
iPhone,
iOS
a
fost
extins
pentru
a
accepta
alte
dispozitive
Apple
,
cum
ar
fi
iPod
Touch
(septembrie
2007)
ș
i
iPad
(ianuarie
2010).
Apple
continuă
să
aducă
în
fiecare
an
o
nouă
versiune
de
iOS
.
Cea
mai
recentă
versiune
a
iOS
este
IOS
13.1
,
care
a
fost
lansată
în
septembrie
2019.
15
Fig. 1.3 – Logo-uri iOS din decursul timpului
Începând
cu
luna
martie
2018,
App
Store
Apple
con
ț
ine
mai
mult
de
2,1
milioane
de
aplica
ț
ii
iOS
,
dintre
care
1
milion
sunt
native
pentru
iPad
.
Aceste
aplica
ț
ii
mobile
au
fost
descărcate colectiv de peste 130 de miliarde de ori. [
38
]
Una
dintre
principalele
diferen
ț
e
dintre
sistemele
de
operare
iOS
ș
i
Android
este
ca
Android
oferă
posibilitatea
ca
utilizatorul
sa
aleagă
dintre
telefoanele
mai
multor
companii,
în
care
este
încărcat
sistemul
de
operare
Android
,
cum
ar
fi
Samsung,
HTC,
LG,
Xiaomi,
însă
iOS
este realizat doar pentru
Apple
.
1.3 .NET Standard
.NET Standard
este setul de
API
dezvoltat de
Microsoft
, disponibil pe toate
implementările .
NET
ș
i care creeaza un anumit tip de uniformitate, o portabilitate care acceptă
.Net Core, Xamarin
ș
i
.Net Framework.
Practic, este setul de biblioteci de clasă de bază care
acceptă o gamă largă de tehnologii precum
.NET Framework, .NET Core, MONO, Xamarin,
Mac, Android,
platforma
Windows Universal, Windows Phone
etc. Biblioteca de clasă de bază
con
ț
ine clase
ș
i biblioteci precum cea de gestionare a excep
ț
iilor,
ș
iruri,
input/output,
re
ț
ea, date
ș
i colectare, etc.
.NET Standard,
la fel ca
PCL(portable class library)
se scrie
ș
i se folose
ș
te în aplica
ț
iile
care rulează pe mai multe platforme, în scopul partajării codului între aplica
ț
ii.
.NET Standard
16
este agnostic de platformă, deci poate rula oriunde, pe
Windows, Mac, Linux
, etc, reprezentând
evolu
ț
ia
PCL-urilor
ș
i în cele din urmă va înlocui complet
PCL-u rile
. Ecosistemul .
NET
are trei
componente majore la nivel înalt –
.NET Framework, .NET Core
ș
i Xamarin.
Pentru construirea
de aplica
ț
ii mobile
(iOS, Android
ș
i Windows Mobile)
folosind
C#, Xamarin
este singura alegere.
.
NET
Standard
con
ț
ine biblioteca
.NET Framework Class
, care con
ț
ine toate clasele de
bază, precum colec
ț
ii,
ș
iruri, dar
ș
i clase de conectare cu surse de date care func
ț
ionează sincron.
.NET framework, .NET Core
ș
i Xamarin
au diferitele lor biblioteci de bază, deci dezvoltatorii
trebuie să înve
ț
e toate ace ste biblioteci de bază, întrucât nu există o singură platformă pentru a
rula
ș
i a sus
ț
ine toate acestea. [
5
]
Fig. 1.4 – Componentele principale .NET
Bibliotecile
.
NET
standard
oferă
un
strat
comun
ș
i
uniform
ș
i
un
set
de
API
care
acceptă
toate tipurile de .
NET
:
17
Fig. 1.5 – Ecosistemul .NET Standard
Avantajele
.NET Standard
:
●
implementarea versiunii, compatibilitatea
ș
i partajarea codului
●
economise
ș
te timp de re-compilare
ș
i cre
ș
te suportul
cross-platform
●
suportă tehnica
open source
, codul său este disponibil pe
GitHub
●
este alternativa la
PCL
●
are suport de
API
limitat, dar suport de aplica
ț
ii bogate
1.3.1 .NET Framework
Framework-ul
a
fost
menit
să
creeze
aplica
ț
ii,
care
să
ruleze
pe
platforma
Windows
.
Framework-ul
.Net
poate
fi
utilizat
pentru
a
crea
atât
aplica
ț
ii
bazate
pe
formulare,
cât
ș
i
bazate
pe
Web,
dar
ș
i
servicii
web.
Acceptă,
de
asemenea,
diferite
limbaje
de
programare,
cum
ar
fi
Visual
Basic
ș
i
C#.
Astfe l,
dezvoltatorii
pot
alege
ș
i
selecta
limbajul
pentru
a
dezvolta
aplica
ț
ia
dorită. Arhitectura .
NET framework
se bazează pe următoarele componente: [
23
]
1. Common Language Runtime
18
„Common
Language
Infrastructure”
(CLI)
este
o
platformă
pe
care
sunt
executate
programele .
Net
, cu următoarele caracteristici:
●
Exception handling
●
Garbage Collection
●
Lucrează cu diverse limbaje de programare
2. Class Library
.NET
Framework
include
un
set
de
biblioteci
de
clase
standard.
De
exemplu,
există
o
bibliotecă
de
clase
cu
metode
pentru
a
gestiona
toate
opera
ț
iunile
la
nivel
de
fi
ș
ier.
Deci
există
o
metodă
care
poate
fi
folosită
pentru
a
citi
textul
dintr-un
fi
ș
ier.
În
mod
similar,
există
o
metodă
pentru a scrie text într-un fi
ș
ier.
Principiile
de
proiectare
folosind
.Net
Framework
sunt:
interoperabilitatea,
portabilitatea,
securitatea,
gestionarea
memoriei
ș
i
desfă
ș
urarea
simplificată.
.NET
Framework
este
o
alegere
mai bună dacă:
●
nu este timp să înve
ț
i o tehnologie nouă
●
se lucrează deja la o aplica
ț
ie existentă
ș
i se extind e func
ț
ionalitatea acesteia
●
există o echipă cu expertiză .
NET
ș
i
software
de construc
ț
ie pregătit pentru
produc
ț
ie
●
nu se doresc actualizări
ș
i modificări continue
●
se construiesc aplica
ț
ii client
Windows
folosind
Windows Forms
sau
WPF
1.3.2 .NET Core
Este
noul
cadru
open-source
ș
i
cross-platform
pentru
a
construi
aplica
ț
ii
pentru
toate
sistemele
de
operare,
inclusiv
Windows,
Mac
ș
i
Linux.
Scopul
.NET
Core
este
furnizarea
unei
platforme
unificate
pentru
toate
tipurile
de
aplica
ț
ii,
care
include
aplica
ț
ii
Windows
,
cross-platform
ș
i
aplica
ț
ii
mobile.
.NET
Standard
Library
perm ite
acest
lucru
prin
furnizarea
API-ului
de
bază
comună,
de
care
are
nevoie
fiecare
model
de
aplica
ț
ie
ș
i
excluzând
orice
API
19
specific
modelului
de
aplica
ț
ie.
Popularul
editor
de
coduri
open-source
Microsoft
Visual
Studio
Code
,
este
acceptat
pe
Windows,
Linux
ș
i
MacOS
.
Arhitectura
Microservices
este
acceptată
în
.NET
Core
,
care
permite
serviciilor
cross-platform
să
lucreze
cu
.NET
Core
,
inclusiv
servicii
dezvoltate cu
.NET Framework, Java, Ruby
sau altele. [
26
]
Caracteristicile platformei
.NET Core
:
– Func
ț
ionează pe ste tot, rulează pe
Windows, Linux
ș
i
MacOS
– Complet
open source
-Model
de
implementare
modulară
lansat
prin
NuGet
în
pachete
mai
mici
centrate
pe
caracteristici, care impune utilizarea doar a modulelor solicitate de aplica
ț
ie.
– Infrastructura de logare este conectabilă chiar de la pornire la nivelul
API
.
–
Aplica
ț
ii
mai
rapide
ș
i
sigure,
având
o
suprafa
ț
ă
a
aplica
ț
iei
mai
mică,
permite
o
securitate mai bună
ș
i performan
ț
e superioare.
Modelele
de
aplica
ț
ii
acceptate
în
prezent
de
.NET
Core
sunt:
aplica
ț
ii
Console,
ASP.Net
Core,
biblioteci
de
clase,
aplica
ț
ii
Windows
universale
(UWA
)
ș
i
Xamarin
Forms.
.NET
Core
este o alegere mai bună dacă:
❖
se dezvoltă aplica
ț
ii pe sistemele de operare
Windows, Linux
ș
i
Mac
❖
se acceptă
open source
❖
există deschidere spre învă
ț
area lucrurilor noi
ș
i disponibilitate pentru remedierea
lucrurilor, deoarece
.NET Core
nu este pe deplin maturizat
1.3.3 Microsoft Visual Studio
Microsoft
Visual
Studio
este
un
mediu
de
dezvoltare
integrat
(IDE)
de
la
Microsoft
,
utilizat
pentru
a
dezvolta
site-uri
web,
aplica
ț
ii
web,
aplica
ț
ii
mobile,
etc.
Visual
Studio
folose
ș
te
platforme
de
dezvoltare
Microsoft
,
cum
ar
fi
Windows
API,
Windows
Forms,
WPF
(Windows
Presentation Foundation)
ș
i
Windows Store.
20
Visual
Studio
include
un
editor
de
cod
care
acceptă
IntelliSense
(componenta
de
completare
a
codului),
precum
ș
i
refactorizarea
codului.
Alte
instrumente
încorporate
includ
un
profilator
de
coduri,
proiectant
pentru
construirea
aplica
ț
iilor
GUI
(Graphical
user
interface)
,
designer
web,
designer
de
clase
ș
i
designer
de
scheme
de
baze
de
date.
Accepta
plugin-uri
care
îmbunătă
ț
esc
func
ț
ionalitatea
la
aproape
toate
nivelurile
–
inclu siv
adăugarea
de
suport
pentru
sistemele
de
control
sursă
(precum
Subversion
ș
i
Git
)
ș
i
adăugarea
de
noi
seturi
de
instrumente
precum
editori
ș
i
designe ri
vizuali
pentru
limbaje
sau
seturi
de
instrumente
specifice
domeniului.
El acceptă 36 de limbaje de programare:
C, C++, .NET, C #, XML, HTML, CSS,
etc. [
39
]
1.3.4 NuGet
NuGet
este
un
manager
de
pachete
care
livrează
cod
sursă
compilat
DLL
(Dynamic
Link
Libraries)
,
fi
ș
iere
(scrip turi
ș
i
imagini)
legate
de
cod
ș
i
un
manifest
descriptiv
care
include
informa
ț
ii
precum
numă rul
versiunii
pachetului.
Un
pachet
NuGet
ia
forma
unui
fi
ș
ier
.zip
cu
extensia
.nupkg
.
Acest
lucru
face
u
ș
oară
adăugarea,
actualizarea
ș
i
eliminarea
bibliotecilor
în
aplica
ț
iile
Visual
Studio.
Utilizarea
NuGet
pentru
instalarea
ș
i
actualizarea
pachetelor
reduce
lucrul manual de configurare a bibliotecilor ter
ț
ilor într-o aplica
ț
ie.
NuGet
este
managerul
de
pachete
pentru
.
NET
.
Instrumentele
client
NuGet
dau
posibilitatea
de
a
produce
ș
i
utiliza
pachete.
Galeria
NuGet
este
depozitul
central
de
pachete
folosit
de
to
ț
i
autorii
de
pachete
ș
i
consumatori.
Managerul
de
pachete
NuGet
din
Visual
Studio
de
pe
Windows
permite
instalarea,
dezinstalarea
ș
i
actualizarea
cu
u
ș
urin
ț
ă
a
pachetelor
NuGet
în
proiecte
ș
i solu
ț
ii. [
2
]
21
Câteva din pachetele
NuGet
pe care le-am folosit în proiect:
Fig. 1.6 – Exemple de pachete NuGet folosite
1.4 Xamarin
1.4.1 Ce este Xamarin
Xamarin
este
o
platformă
open-source
pentru
construirea
de
aplica
ț
ii
moderne
ș
i
performante
pentru
iOS,
Android
ș
i
Windows
bazată
pe
.
NET
.
Numele
Xamarin
provine
de
la
numele
maimu
ț
ei
Tamarin,
înloc uind
T-ul
cu
un
X.
Cu
o
bază
de
coduri
partajate
C#,
dezvoltatorii
pot
utiliza
instrumente
Xamarin
pentru
a
scrie
aplica
ț
ii
native
Android,
iOS
ș
i
Windows
cu
interfe
ț
e
de
utilizator
native
ș
i
a
partaja
cod
pe
mai
multe
platforme,
inclusiv
Windows,
MacOS
ș
i
Linux
.
Potrivit
Xamarin
,
peste
1,4
milioane
de
dezvoltatori
foloseau
produsele
Xamarin
în
120
de
ț
ări
din
întreaga
lume
începând
din
aprilie
2017.
Aplica
ț
iile
Xamarin
pot
fi
scrise
pe
Windows
sau
Mac
ș
i
se
pot
compila
în
pachete
de
aplica
ț
ii
native,
cum
ar
fi
un
fi
ș
ier
.apk
pe
Android
sau
un
fi
ș
ier
.ipa
pe
iOS
.
22
Câteva dintre produsele Xamarin, pe care le-am folosit în proiectul meu:
●
Platforma Xamarin
Xamarin
extinde
platforma
de
dezvoltatori
.
NET
cu
instrumente
ș
i
biblioteci
speciale
pentru
crearea
de
aplica
ț
ii
pentr u
Android,
iOS,
tvOS,
watchOS,
macOS
ș
i
Windows
în
principal
cu
C#
în
Visual
Studio
.
Dezvoltatorii
pot
reutiliza
codul
C#
existent
ș
i
pot
partaja
cod
semnificativ
pe
platformele
dispozitivelor.
Mai
multe
companii
cunoscute,
inclusiv
3M,
AT&T
ș
i
HP
au
folosit
platforma
pentru
a-
ș
i
crea
aplica
ț
iile.
Xamarin
se
integrează
ș
i
în
MacOS
prin
Visual
Studio
pentru
Mac.
●
Xamarin.Forms
Introdus
în
Xamarin
3
în
Mai
2014,
permite
să
utilizeze
subseturi
de
control
portabile
care
sunt mapate cu controale native ale
Android, iOS
ș
i
Windows Phone
.
●
Xamarin pentru Visual Studio
Xamarin
pentru
Visual
Studio
are,
de
asemenea,
completarea
codului
prin
IntelliSense
ș
i
extensii
care
oferă
suport
pentru
construirea,
implementarea
ș
i
depanarea
aplica
ț
iilor
pe
un
simulator
sau
un
dispozitiv.
Aplica
ț
iile
construite
utilizând
Xamarin
con
ț
in
controale
standard
native
ale
interfe
ț
ei
de
utilizator.
Aplica
ț
iile
nu
numai
că
arată
a
ș
a
cum
se
a
ș
teaptă
utilizatorul
final,
dar
se
comportă
ș
i
în
acest
fel.
Aplica
ț
iile
construite
folos ind
Xamarin
au
acces
la
întregul
spectru
de
func
ț
ionalită
ț
i
expuse
de
platforma
ș
i
dispozitivul
de
bază.
Aplica
ț
iile
sunt
construite
folosind
o
accelerare
hardware
specifică
platformei
Xamarin
ș
i
compilate
pentru
performan
ț
e
native. Acest lucru nu poate fi realizat cu solu
ț
ii care interpretează codul în timpul rulării.
23
Fig. 1.7 – Arhitectura unei aplica
ț
ii Xamarin
Diagrama
din
fig.
1.7
prezintă
arhitectura
de
ansamblu
a
unei
aplica
ț
ii
Xamarin
.
El
permite
crearea
interfe
ț
ei
de
utilizator
nativă
pe
fiecare
platformă
ș
i
scrierea
codului
în
C#,
care
este
distribuit
pe
platforme.
Xamarin
este
construit
pe
Mono
,
o
versiune
open-source
a
.
NET
Framework
.
Mediul
de
execu
ț
ie
Mono
gestionează
automat
sarcini
precum
alocarea
memoriei,
colectarea gunoiului, etc. [
15
]
1.4.2 Xamarin.Essentials
Xamarin.Essentials
este
o
bibliotecă
care
furnizează
API-uri
cross-platform
pentru
dispozitivele
native.
Ca
Xamarin
în
sine,
Xamarin.Essentials
este
o
abstractizare
care
simplifică
procesul de accesare a func
ț
ionalită
ț
ii native. Exemple de func
ț
ionalită
ț
i oferite:
●
Informa
ț
ii despre dispozitiv
●
Sistemul de fi
ș
iere
●
Permisiuni
●
Text-to-speech
●
Blocarea ecranului
24
În
aplica
ț
ia
mea
am
folosit
Xamarin
Essentials
pentru
a
implementa
metoda
de
cerere
a
permisiunii
de
utilizarea
a
loca
ț
iei
dispozitivului
pentru
a
putea
pozitiona
utilizatorul
pe
harta
ș
i
a
găsi loca
ț
iile din împrejur imi:
using Xamarin.Essentials;
var status = await
Permissions.CheckStatusAsync<Permissions.LocationWhenInUse>();
var request = await
Permissions.RequestAsync<Permissions.LocationWhenInUse>();
1.4.3 Xamarin.Forms
Xamarin.Forms
este
un
cadru
UI
(User
Interface)
open-source
.
Xamarin.Forms
permite
dezvoltatorilor
să
construiască
aplica
ț
ii
iOS,
Android
ș
i
Windows
dintr-o
singură
bază
de
coduri
partajate,
să
creeze
interfe
ț
e
de
utilizator
în
XAML
cu
cod-behind
C#.
Aceste
interfe
ț
e
de
utilizator sunt redate ca controale native performante pe fiecare platformă.
Exemple de caracteristici:
●
Limbajul
XAML
pentru interfa
ț
a de utilizator
●
Data binding
●
Gesturi
●
Efecte
●
Costumizare
Xamarin.Forms
oferă
API
consistente
pentru
crearea
de
elemente
UI
pe
platforme.
Acest
API
poate
fi
implementat
în
XAML
sau
C#
ș
i
acceptă
con
ț
inutul
arhitecturilor
precum
Model-View-ViewModel
(MVVM).
În
timpul
func
ț
ionării,
Xamarin.Forms
utilizează
randerele
platformelor
pentru
a
converti
elementele
UI
cross-platform
în
controale
native
pe
Android,
iOS
ș
i
Windows
ș
i are de asemenea un ecosistem mare de pachete
NuGet
. [
16
]
25
1.4.4 Xamarin.Native vs Xamarin.Forms
Xamarin.Android
ș
i
Xamarin.iOS
sunt
adesea
denumite
Xamarin.Native
.
Este
un
set
de
instrumente
cross-platform
care
permite
dezvoltatorilor
să
creeze
aplica
ț
ii
mobile
folosind
C#
ș
i
.NET
.
Codul
independent
de
platformă
al
aplica
ț
iilor
Xamarin.Native
este
stocat
fie
într-o
bibliotecă
de
clase
portabilă
(PCL),
fie
într-un
proiect
partajat.
Instrumente
precum
Xamarin.iOS
ș
i
Xamarin.Android
ajută
la
implementarea
func
ț
ionalită
ț
ilor
specifice
platformei
ș
i
experien
ț
ei
utilizatorului final.
Xamarin.Forms
este
o
versiune
avansată
a
Xamarin.Native
care
permite
scrierea
unui
singur
cod
XAML
pentru
direc
ț
ionarea
mai
multor
platforme
simultan.
Aplica
ț
iile
dezvoltate
folosind
Xamarin.Forms
mo
ș
tenesc
toate
func
ț
ionalită
ț
ile
ș
i
caracteristicile
platformei
Xamarin
.
Cu
Xamarin.Forms,
dezvoltatorii
pot
scrie
logica
de
afaceri
în
C#,
iar
UI
poate
fi
definit
în
cod
sau în format
XAML
, astfel încât să poată fi împăr
ț
it între toate platformele.
Am
ales
sa
folosesc
ca
ș
i
framework
de
dezvoltare
Xamarin
Forms
deoarece,
aplica
ț
ia
necesită
pu
ț
ină
func
ț
ionalitate
specifică
platformei,
nu
are
design-uri
complexe
sau
API-uri
specifice platformei, iar partajarea codului este importantă. [
3
]
Fig. 1.8 – Xamarin.Native vs Xamarin.Forms
26
1.5 C#
1.5.1 C# în ansamblu
C#
este
un
limbaj
de
programare
puternic
orientat
pe
obiecte.
Este
open-source
,
simplu,
modern,
flexibil
ș
i
versa til.
A
fost
dezvoltat
ș
i
lansat
de
Microsoft
în
2001.
În
metodologia
de
programare
orientată
pe
obiecte,
un
program
este
format
din
diverse
obiecte
care
interac
ț
ionează
între
ele
prin
intermediul
ac
ț
iunilor.
Ac
ț
iunile
pe
care
le
poate
face
un
obiect
se
numesc
metode.
Despre obiecte de acela
ș
i fel se spune că au acela
ș
i tip sau, se spune că sunt în aceea
ș
i clasă.
Caracteristicile cheie ale limbajului C# :
●
Modern
ș
i u
ș
or
●
Open-source
●
Cross-platform
●
Sigur
●
Adaptabil
Mai
toate
limbajele
de
programare
au
fost
concepute
pentru
un
scop
specific,
pentru
a
rezolva
o
nevoie
specifică
la
acel
moment,
însă
C#
a
fost
conceput
pentru
a
ț
ine
cont
de
nevoile
de
afaceri,
pentru
construirea
de
software
utilizând
un
singur
limbaj
de
programare.
Oferă
func
ț
ionalitate
pentru
a
sprijinii
dezvoltarea
software
modernă.
C#
acoperă
nevoile
de
dezvoltare
ale aplica
ț
iilor web
ș
i mobile. [
24
]
Câteva tipuri de aplica
ț
ii pe care C# le poate construi:
●
Aplica
ț
ii client, bi blioteci, servicii
ș
i componente
Window s
●
Aplica
ț
ii mobile n ative pentru
iOS
ș
i
Android
●
Aplica
ț
ii
ș
i servicii
Azure cloud
●
Inteligen
ț
a artifici ală
ș
i
Machine learning
●
Blockchains
ș
i tehnologia ledger distribuită, inclusiv
cryptocurrency
●
Dispozitive
Internet of Things (IoT)
●
Jocuri video, console de jocuri
ș
i sisteme de jocuri
27
1.5.2 Componente C# folosite în aplica
ț
ie
Câteva componente ale C# pe care le-am utilizat în proiect: [
40
]
●
Clase
Clasele
sunt
auto-descrise
ca
tipuri
de
referin
ț
ă
definite
de
utilizator.
În
esen
ț
ă,
toate
tipurile
din
.NET
Framework
sunt
clase,
inclusiv
structuri
ș
i
enum,
care
sunt
clase
generate
de
compilatoare.
Membrii
clasei
sunt
private
în
mod
implicit,
dar
pot
fi
declara
ț
i
publici
ca
fiind
vizibili
în
afara
clasei
sau
proteja
ț
i
pentru
a
fi
vizibili
de
către
orice
descenden
ț
i
ai
clasei.
Exemplu din aplica
ț
ie, cla sa care controlează
ViewModel-ul
pentru pagina
Home
:
public class HomeVM
{
public NavigationCommand NavCommand { get; set; }
public HomeVM()
{
NavCommand
=
new
NavigationCommand(this);
}
public async void Navigate()
{await
App.Current.MainPage.Navigation.PushAsync(new
NewTravelPage();}
}
●
Evenimente
Evenimentele
sunt
indicatoare
care
pot
indica
mai
multe
metode.
Mai
exact,
acestea
leagă
indicatoarele
metodelor
la
un
singur
identificator.
Prin
urmare,
aceasta
poate
fi
văzută
ca
o
extensie
a
delega
ț
ilor.
Acestea
sunt
de
obicei
utilizate
ca
declan
ș
atori
în
dezvoltarea
UI
.
Exemplu
din aplica
ț
ie, evenimentu l creat la apăsarea butonului
Update
din pagina de detalii a experientei:
private async void updateButton_Clicked(object sender, EventArgs e)
{
selectedPost.Experience = experienceEntry.Text;
await
App.MobileService.GetTable<Post>().UpdateAsync(selectedPost);
await DisplayAlert("Success", "Experience updated!", "OK");
}
28
●
Inferen
ț
ă de tip va riabilă locală
C#
3.0
a
introdus
inferen
ț
a
de
tip
variabilă
locală,
permi
ț
ând
înlocuirea
specificatorului
de
tip
al
unei
declara
ț
ii
variabile
cu
cuvântul
cheie
var
,
dacă
tipul
său
real
poate
fi
determinat
static
de
la
ini
ț
ializator .
Aceasta
reduce
repetarea,
în
special
pentru
tipurile
cu
mai
mul
ț
i
parametri generici de tip:
var locator = CrossGeolocator.Current;
var postTable = await Post.Read();
●
Initializatori de obiecte
Oferă
un
mod
mai
convenabil
de
ini
ț
ializare
a
câmpurilor
ș
i
proprietă
ț
ilor
publice
ale
unui obiect. Apelurile constructorilor sunt op
ț
ionale atunci când există un constructor implicit:
email = value;
User = new Users()
{
Email = this.Email,
Password = this.Password,
ConfirmPassword = this.ConfirmPassword
};
●
Proprietă
ț
i automa te
O
caracteristică
a
C#
3.0
o
reprezintă
proprietă
ț
ile
auto-implementate.
Se
pot
definii
accesorii fără corpuri
ș
i compilatorul va genera un câmp de rezervă
ș
i codul necesar pentru ele:
public string id { get; set; }
public string name { get; set; }
●
Sintaxa Async / Await
29
Începând
cu
.NET
Framework
4
există
o
bibliotecă
de
sarcini
care
face
mai
u
ș
or
de
scris
aplica
ț
iile
paralele
ș
i
multi-thread
prin
intermediul
sarcini lor.
Exemplu,
sintaxa
pentru
refresh-area listei de postări de pe pagina de istoric din cadrul aplica
ț
iei:
private
async
void
postListView_Refreshing(object
sender,
EventArgs
e)
{
await viewModel.UpdatePosts();
postListView.IsRefreshing = false;
}
●
(LINQ) Language Integrated Query
Este un set de tehnologii bazate pe integrarea capabilită
ț
ilor de interogare direct în
limbajul C#. Cu
LINQ
, o interogare este o construc
ț
ie de limbaj de primă clasă, la fel ca clasele,
metodele sau evenimentele. Se pot scrie interogări asupra colec
ț
iilor de obiecte tipizate puternic
utilizând cuvinte cheie din limbaj
ș
i operatori familiari. Familia de tehnologii
LINQ
oferă o
experien
ț
ă de interogare c onsistentă pentru obiecte
(LINQ to Objects),
baze de date rela
ț
ionale
(LINQ to SQL)
ș
i
XML (L INQ to XML).
Pentru un dezvoltator care scrie interogări, cea mai
vizibilă parte integrată în limbaj a
LINQ
este sintaxa de interogare, astfel se pot efectua
opera
ț
iuni de filtrare, ord onare
ș
i grupare pe surse de date cu un m inim de cod:
venueListView.ItemsSource = venues.Where(x => x.categories.Count() > 0);
1.6 XAML
XAML (eXtensible Application Markup Language)
este varianta
XML
a lui
Microsoft
pentru descrierea unei interfe
ț
e grafice. La fel ca
HTML
, se poate scrie
ș
i edita cu u
ș
urin
ț
ă
interfa
ț
a grafică. Orice es te creat sau implementat în
XAML
poate fi exprimat folosind un limbaj
.
NET
mai tradi
ț
ional, cum ar fi C# sau
Visual Basic .NET
.
Cu
toate
acestea,
un
aspect
cheie
al
tehnologiei
este
complexitatea
redusă
necesară
instrumentelor
pentru
procesarea
XAML
,
deoarece
se
bazează
pe
XML
.
Regulile
de
sintaxă
pentru
30
XAML
sunt
aproape
similare
cu
XML
.
Sintaxa
unui
element
obiect
începe
cu
semnul
“mai
mic”
(<)
urmată
de
numele
unui
obiect.
Elementul
Obiect
trebuie
să
fie
închis
cu
slash
(/)
urmată
imediat de semnul “mai mare” (>). [
34
]
Exemplu de sintaxă – Sintaxa butonului de pe pagina de înregistrare:
<Button x:Name = "registerButton"
Margin="0,50,0,0"
Text="Register"
Command="{Binding RegisterCommand}"
CommandParameter="{Binding User}"
Style="{StaticResource normalButton }"
BorderColor="White"
BorderWidth="5"
FontAttributes="Bold"
FontSize="17"
CornerRadius="20" />
Indiferent
dacă
este
creată
o
fereastră
sau
o
pagină,
acesta
va
consta
într-un
document
XAML
ș
i
un
fi
ș
ier
CodeBehind
(scris
de
obicei
în
C
#
sau
VB).
Fi
ș
ierul
XAML
descrie
interfa
ț
a
cu
toate
elementele
sale,
în
timp
ce
CodeBehind
gestionează
toate
evenimentele
ș
i
are
acces
la
manipulare prin controalele
XAML
.
Tehnic
vorbind,
cele
două
fi
ș
iere
diferite
sunt
„clase
par
ț
iale”
scrise
în
două
limbaje
diferite
(XAML
ș
i
C#
/
VB)
care
creează
o
singură
clasă
care
poate
fi
folosită
ca
orice
altă
clasă.
De exemplu, următorul fragment de cod
XAML
este pagina în care este reprezentată harta:
<ContentPage
xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
xmlns:d="http://xamarin.com/schemas/2014/forms/design"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006
" mc:Ignorable="d"
x:Class="JourneyRecord.MapPage">
<ContentPage.Content>
<maps:Map x:Name="locationsMap"
IsShowingUser="True"
HorizontalOptions="FillAndExpand"
VerticalOptions="FillAndExpand"
31
/>
</ContentPage.Content>
</ContentPage>
Aceasta
include
o
setare
x:
Class
,
care
leagă
XAML
la
defini
ț
ia
clasei
C#
într-un
fi
ș
ier
care se află în spatele codului. Iată cum arată:
using JourneyRecord.Model;
namespace JourneyRecord
{
[XamlCompilation(XamlCompilationOptions.Compile)]
public partial class MapPage : ContentPage
{
private bool hasLocationPermission = false;
public int REQUEST_LOCATION { get; private set; }
public MapPage()
{
InitializeComponent();
GetPermissions();
}
1.7 Modelul arhitectural MVVM
Model-View-ViewModel(MVVM)
este
un
model
de
proiectare
software
care
este
structurat
pentru
a
separa
logica
programului
ș
i
controalele
de
interfa
ț
a
de
utilizator.
MVVM
este
cunoscut
ș
i
sub
denumire a
de
model-view-binder
.
La
fel
ca
multe
alte
modele
de
design,
MVVM
ajută
la
organizarea
codului
ș
i
a
împăr
ț
irii
în
module
pentru
a
face
dezvoltarea,
actualizarea
ș
i
reutilizarea
codului
mai
simplă
ș
i
mai
rapidă.
MVVM
este
adesea
utilizat
în
Windows
ș
i
software
de
prezentare
grafică
web.
Am
ales
să
folosesc
MVVM
deoarece
el
este
modelul
arhitectural
standard pentru aplica
ț
iile care se bazează pe
XAML
.
Avantaje
MVVM
:
●
Mentenanta
●
Testabilitate
●
Extensibilitate [
35
]
32
Fig. 1.9 – Arhitectura MVVM
1.7.1 Componentele modelului MVVM:
1.7.1.1 Model:
De
ț
ine informa
ț
iile, dar nu comportamentele sau serviciile care manipulează informa
ț
iile.
Nu este responsabil pentru formatarea textului pentru a arăta destul de bine pe ecran sau pentru a
ob
ț
ine o listă de elemente de pe un server la distan
ț
ă. Logica este de obicei
ț
inută separată de
model
ș
i încapsulată în al te clase care ac
ț
ionează asupra modelului.
Responsabilită
ț
i
Model
:
●
În
general,
modelul
este
cel
mai
simplu
de
în
ț
eles.
Este
modelul
de
date
din
partea
clientului care acceptă vizualizările din aplica
ț
ie
●
Este
compus
din
obiecte
cu
proprietă
ț
i
ș
i
unele
variabile,
pentru
a
con
ț
ine
date
în
memorie
●
Obiectele
model
ar
trebui
să
ridice
notificările
de
modificare
a
proprietă
ț
ii,
adică
legare
de date
●
Se poate ocupa
ș
i de validarea datelor
33
1.7.1.2 View:
View-ul
este
structura,
aspectul
a
ceea
ce
un
utilizator
final
vede
pe
ecran
ș
i
interac
ț
ionează
cu
adev ărat.
Afi
ș
ează
o
reprezentare
a
mode lului
ș
i
prime
ș
te
interac
ț
iunea
utilizatorului
(click-uri,
apăsări
de
taste,
gesturi
etc.)
ș
i
transmite
gestionarea
acestora
către
view-model
prin
legarea
datelor
(proprietă
ț
i,
apeluri
de
evenimente
etc.).
Principalul
obiectiv
al
MVVM
este
acela
că
în
view
nu
ar
trebui
să
existe
niciun
cod
logic
de
manipulare
a
evenimentelor,
sau
ac
ț
iune
ș
i
manipulare
a
datelor.
În
view
este
nevoie
doar
de
constructor
ș
i
de
un apel pentru a ini
ț
ializa componenta.
Responsabilită
ț
i
View
:
●
Scopul
principal
ș
i
responsabilită
ț
ile
view-ului
sunt
definirea
structurii
a
ceea
ce
utilizatorul vede pe ecran. Structura poate con
ț
ine păr
ț
i statice
ș
i dinamice
○
Păr
ț
ile
statice
sunt
ierarhia
XAML
care
define
ș
te
controalele
ș
i
aspectul
controalelor din care este compusă o vizualizare
○
Partea
dinamică
o
reprezinta
anima
ț
iile
sau
modificările
de
stare
care
sunt
definite
ca parte a vizualizării
1.7.1.3 View-model:
View-model-ul
este
o
abstractizare
a
view-ului
care
expune
proprietă
ț
ile
ș
i
comenzile
publice.
MVVM
are
un
liant
care
automatizează
comunicarea
între
view
ș
i
proprietă
ț
ile
sale
legate
în
view-model
.
Datele
declarative
ș
i
legarea
comenzii
sunt
implicite
în
modelul
MVVM
.
În
stiva
de
solu
ț
ii
Microsoft
,
liantul
este
un
limbajul
XAML
.
El
eliberează
dezvoltatorul
obliga
ț
ia
de
a
scrie logica pentru a sincroniza
view-model-ul
ș
i
view-ul
.
Avantajul
esen
ț
ial
este
acela
de
a
permite
o
separare
adevărată
între
View
ș
i
Model
,
dincolo
de
ob
ț
inerea
separării
ș
i
a
eficien
ț
ei
pe
care
o
ob
ț
ine
ț
i
din
acest
lucru.
Ceea
ce
înseamnă
că
atunci
când
modelul
trebuie
să
se
schimbe,
acesta
poate
fi
schimbat
simplu,
fără
a
fi
nevoie
de
view
ș
i invers.
Responsabilită
ț
i
ViewMo del
:
34
●
E
ste
punctul
principal
al
aplica
ț
iei
MVVM
.
Responsabilitatea
principală
a
view-model-ului
este
de
a
oferi
date
view-ului,
astfel
încât
acesta
să
poată
pune
datele
pe
ecran.
●
Permite utilizatorului să interac
ț
ioneze cu datele
ș
i să le schimbe
●
Încapsulează logica de interac
ț
iune pentru o vizualizare, sau orice logică de navigare,
cum ar fi să decidă când este timpul să navighezi la o altă vizualizare. [
36
]
1.7.2 Implementarea MVVM în aplica
ț
ia mea
Ideea
principala
din
spatele
implementării
MVVM
este
de
a
putea
separa
view-ul
,
model-ul
ș
i
view-model- ul
,
deci
view-ul
nu
ar
trebui
să
aibă
niciun
cod-behind
.
Unul
dintre
lucrurile
principale
pe
care
le-am
avut
în
cod-behind
a
fost
gestionarea
de
evenimente,
cu
multă
func
ț
ionalitate
în
interior .
Cu
ajutorul
MVVM
am
făcut
acest
lucru
într-un
mod
diferit,
ș
i
anume,
mutarea func
ț
ionalită
ț
ilor în
view-model
în loc de
view
.
De
exemplu,
dacă
merg
pe
pagina
de
înregistrare,
s-ar
fi
creat
un
utilizator
direct
din
cod-behind
.
Am
modificat
acest
lucru
ca
sa
fie
realizat
din
view-model
.
După
ce
am
implementat
această
func
ț
ionalitate
în
view-model,
nu
a
mai
trebuit
să
creez
un
utilizator
ș
i
să
atribui
valoarea
proprietă
ț
ilor
sale,
aceste a
fiind
acum
atribuite
automat
prin
legarea
datelor.
Ș
i,
desigur,
pentru
pagina
principală
în
care
utilizatorul
se
conectează,
dacă
nu
implementam
MVVM
,
a
ș
fi
continuat
sa
primesc
informa
ț
iile
din
înregistrări.
Dar
după
ce
am
mutat
func
ț
ionalitatea
în
view-model
,
nu
am
mai
ob
ț
inut
aceste
informa
ț
ii
manual,
deoarece
acestea
sunt
acum
alocate
automat
unui
obiect.
Am
men
ț
ionat
pe
scurt
în
introducerea
MVVM
că
view-model
va
ac
ț
iona
ca
intermediar
între
model
ș
i
view
.
Deci,
preia
informa
ț
ii
din
model
ș
i
le
traduce
sau
le
modifică
pu
ț
in, astfel încât
view-ul
poate fi afi
ș
at într-un mod mai bun.
Cu
ajutorul
interfe
ț
ei
INotifyPropertyChanged
am
putut
atribui
valori
unui
obiect
fără
a
fi
nevoie
să
îl
accesez
manual
din
elementele
XAML
,
iar
valorile
se
atribuie
automat
prin
legarea
datelor.
INotifyPropertyChanged
va
declan
ș
a
evenimente
atunci
când
o
valoare
a
proprietă
ț
ii
s-a
modificat,
astfel
încât
model-ul
ș
i
view-ul
pot
rămâne
actualizate
atunci
când
se
întâmplă
acest
35
lucru.
Interfa
ț
a
face
posibil
ca,
atunci
când
sunt
legate
împreună,
două
proprietă
ț
i
vor
rămâne
actualizate
atunci
când
una
se
schimbă.
Am
folosit
această
proprietate
„TwoWay
”
a
interfe
ț
ei
atunci
când
am
legat
datele
mele,
care
se
deplasează
atât
de
la
model
la
view
,
cât
ș
i
invers
asigurându-mă că ambele rămân actualizate: [
12
]
Text="{Binding Email, Mode=TwoWay}"
Text="{Binding Password, Mode=TwoWay}"
Paginile care au necesitat implementarea acestei interfe
ț
e au fost pagina de
login
, cea de
înregistrare
ș
i cea de intro ducere a unei noi experien
ț
e, deoarece ele primeau informa
ț
ii de la
utilizator.
1.8 Azure
Microsoft
Azur
e,
cunoscută
anterior
drept
Windows
Azure,
este
o
platforma
publică
de
cloud
computing
care
oferă
o
serie
de
servicii
cloud
,
inclusiv
calcul,
analiză,
stocare
ș
i
re
ț
ea.
Utilizatorii
pot
alege
dintre
aceste
servicii
pentru
a
dezvolta
noi
aplica
ț
ii
sau
pentru
a
rula
aplica
ț
ii
existente
în
cloud-ul
public.
Odată
abonat
la
Azure
,
ai
acces
la
toate
serviciile
incluse
în
portalul
Azure
ș
i
po
ț
i
crea
resurse
bazate
pe
cloud
,
precum
ma
ș
ini
virtuale
(
VM
)
ș
i
baze
de
date.
De
ș
i
Microsoft
nu
percepe
nicio
taxă
de
abonament,
diferitele
servicii
Azure
sunt
puse
la
dispozi
ț
ie pe bază de plat ă. [
25
]
Azure
se utilizează pentru:
●
rularea
de
ma
ș
ini
virtuale
sau
containere
în
cloud
,
aceste
resurse
de
calcul
pot
găzdui
componente de infrastructură, cum ar fi serverele
de sistem de nume de domeniu
(
DNS
)
●
servicii
Windows
Server
–
cum
ar
fi
Internet
Information
Services
(
IIS
);
sau
aplica
ț
ii
ter
ț
e
Microsoft
acceptă
ș
i utilizarea unor sisteme de operare ter
ț
e, precum
Linux
●
găzduirea bazelor de date din
cloud
36
1.8.1 Azure SQL Database
Baza
de
date
SQL
Azure
este
o
platformă
administrată
integral
ca
un
serviciu,
care
conduce
majoritatea
func
ț
iilor
de
gestionare
a
bazelor
de
date,
precum
modernizarea,
patch-ul,
copiile
de
rezervă
ș
i
monitorizarea
fără
implicarea
utilizatorului.
Microsoft
se
ocupă
de
corec
ț
ia
ș
i
actualizarea
codului
SQL
ș
i
a
sistemului
de
operare.
Baza
de
date
SQL
Azure
rulează
întotdeauna pe cea mai recentă versiune stabilă a motorului de baze de date
SQL Server.
Cu
baza
de
date
SQL
Azure
,
se
creaza
un
strat
de
stocare
a
datelor
de
înaltă
performan
ț
ă
disponibil
pentru
aplica
ț
iile
ș
i
solu
ț
iile
din
Azure
.
Se
bazează
pe
cea
mai
recentă
versiune
stabilă
a
motorului
bazei
de
date
Microsoft
SQL
Server
ș
i
utilizează
func
ț
ii
avansate
de
procesare
a
interogărilor. [
28
]
1.8.2 Serverele Azure SQL Database
ș
i management-ul lor
Un
server
de
baze
de
date
SQL
este
o
construc
ț
ie
logică
care
ac
ț
ionează
ca
punct
administrativ
central
pentru
mai
multe
baze
de
date
simple
sau
comune,
login
,
reguli
pentru
firewall
,
reguli
de
audit,
politici
de
detectare
a
amenin
ț
ărilor
ș
i
grupuri
de
failover
.
Un
server
de
baze
de
date
SQL
poate
fi
într-o
regiune
diferită
de
resursa
sa
grup.
Serverul
de
baze
de
date
SQL
trebuie
să
existe
înainte
de
a
putea
crea
baza
de
date
SQL
Azure
.
Toate
bazele
de
date
gestionate
de
un
server
de
baze
de
date
SQL
sunt
create
în
aceea
ș
i
regiune
cu
serverul
de
baze
de
date
SQL
.
Când
se
creaza
un
server
de
baze
de
date
SQL
,
se
face
un
cont
de
conectare
la
server
ș
i
o
parolă
care
are
drepturi
administrative
asupra
bazei
de
date
master
de
pe
serverul
respectiv
ș
i
a
tuturor
bazelor de date create pe acel
server
. [
27
]
Server-ul SQL
de baze de date:
●
Este creat în cadrul unui abonament
Azure
●
Este
resursa
părinte
ș
i
oferă
un
spa
ț
iu
de
nume
pentru
baze
de
date,
grupuri
elastice
ș
i
depozite de date
37
●
Este
un
container
logic
puternic
–
ș
terge
un
server
ș
i
bazele
de
date
con
ț
inute,
grupurile
elastice
ș
i depoz itele de date
●
Oferă
un
punct
de
conectare
pentru
acces
la
baza
de
date
(<serverNume>
.database.windows.net)
●
Oferă
domeniul
de
aplicare
pentru
politicile
de
gestionare
care
se
aplică
bazelor
de
date
sale – logins, firewall, audit, detectarea amenin
ț
ărilor
ș
i altele
●
Gestionează
serverele
, bazele de date
ș
i
firewallurile Azure SQL
folosind portalul
Azure
1.8.3 Azure app service
Azure App Service
este un serviciu bazat pe
HTTP
pentru găzduirea de aplica
ț
ii
web
,
API-uri REST
ș
i backend -uri mobile. Pute
ț
i dezvolta în limbajul preferat, fie că este .
NET, .NET
Core, Java, Ruby, Node.js, PHP
sau
Python.
Aplica
ț
iile rulează
ș
i sunt scalabile cu u
ș
urin
ț
ă atât
în
medii bazate pe
Windows
cât
ș
i pe
Linux
.
În prezent, platforma
Azure App Service
con
ț
ine aceste servicii:
●
Aplica
ț
ii
Web
– Pentru a rula aplica
ț
ii web
ș
i
API
în
Azure
●
Aplica
ț
ii mobile – Pentru a rula
backend-ul
pentru aplica
ț
ii mobile în
Azure
●
Aplica
ț
ii func
ț
ionale – Pentru a rula blocuri mici de cod în
Azure
, care pot fi declan
ș
ate de
surse externe, cum ar fi un mesaj pe o coadă [
29
]
Aplica
ț
ia de servicii rulea ză pe un plan de servicii pentru aplica
ț
ii. Toate tipurile de servicii de
aplica
ț
ii
Azure
rulează co ntinuu în
Azure. Azure App Service
oferă:
●
Deployment features
●
Development Tools
●
API features
●
Monitoring
●
Settings
●
MySQL In App
38
O modalitate u
ș
oară de a utiliza o bază de date
MySQL
cu
App Service
este folosirea
func
ț
iei
MySQL In App
. Practic, aceasta ini
ț
iază o bază de date
MySQL in memory
cu serviciul de
aplica
ț
ii
ș
i se poate folosi imediat. O aplica
ț
ie mobilă
Azure
este un
backend as-a-service
mobil.
Iată câteva dintre proprietă
ț
ile sale: [
4
]
●
Aplica
ț
iile mobile rulează
API-uri
pentru aplica
ț
iile mobile
●
Se pot crea
API-uri
care rulează în
Azure Mobile Apps
în
Node.js
ș
i în
.NET
●
Sunt utilizabile toate func
ț
iile partajate
App Service c
u aplica
ț
ii mobile, inclusiv domenii
personalizate, sloturi de implementare, scalare
ș
i conexiuni hibride
●
Azure mobile
SDK, care
ajută la conectarea la
Mobile Apps
de la aplica
ț
ia mobilă, fiind
disponibil pentru:
○
iOS (Obiectiv-C
ș
i Swift)
○
Android (Java)
○
Windows (C#)
○
Xamarin (inclusiv Forms)
Azure Mobile Apps
poate servi drept
backend
pentru aplica
ț
iile mobile:
●
Se pot crea
API-urile
pentru aplica
ț
ii mobile în
Node.js
ș
i
.NET
●
Aplica
ț
ii mobile o feră func
ț
ia de sincronizare
offline
. Ace st lucru permite utilizatorilor să
continue să lucreze
ș
i atunci când nu sunt conecta
ț
i
●
Sincronizarea offline necesită
SDK
pentru aplica
ț
ii mobile
ș
i un depozit de date (cum ar fi
SQLite
) pe client [
6
]
Fig. 1.10 – Resursele create în Azure pentru aplica
ț
ia mea
39
1.8.4 Configurarea aplica
ț
iei mele:
Pa
ș
ii pe care i-am urmat în configurarea aplica
ț
iei web din
Azure
pentru a suporta o
aplica
ț
ie mobilă, au fost:
●
Am navigat la sec
ț
iunea
Setări
ș
i Configurare
pentru a co nfigura aceste servicii pentru a
putea gestiona aplica
ț
ii mobile, deoarece
default
în setările aplica
ț
iei, nu există setări
pentru asta. După aplicarea setării necesare, aplica
ț
ia este gata să înceapă administrarea
aplica
ț
iilor mobile .
●
Următorul pas este cel care cere navigarea înainte
ș
i înapoi între servicii. Ceea ce am
făcut, a fost să creez conexiunea reala între serviciul de aplica
ț
ii
ș
i baza de date
SQL
,
setând sursa de date ca nume al serverului de baze de date
Azure
, împreună cu
ID-ul
ș
i
parola utilizatorului.
Astfel, conexiunea a fost stabilită, dar încă lipse
ș
te func
ț
ionalitatea. Pentru a adăuga
func
ț
ionalitatea de backen d care va face ca acest serviciu să poată insera, citi,
ș
terge
ș
i actualiza
baza de date
SQL
, am folosit un
ș
ablon de cod
JavaScript
pentru server
ș
i tabelele
Users
ș
i
Post
,
pentru carea am
ș
i un fi
ș
ier
JSON
. Codul se afla într-un depozit
GitHub
care este integrat
continuu în aplica
ț
ia mea mobilă
Azure
folosind
Deployment Center
care conectează
Mobile App
Service
s cu depozitul de pe
GitHub
pentru a crea
backend-ul
aplica
ț
iei mele.
(Codul JavaScript pentru backend este prezentat complet în
Anexa 1
.)
40
1.9 SQL
SQL
(Structured
Query
Language)
este
utilizat
pentru
a
comunica
cu
o
bază
de
date,
fiind
limbajul
standard
pentru
sistemele
rela
ț
ionale
de
gestionare
a
bazelor
de
date.
Instruc
ț
iunile
SQL
sunt
utilizate
pentru
a
efectua
sarcini
precum
actualizarea
sau
preluarea
datelor
dintr-o
bază
de
date.
Unele
sisteme
comune
de
gestionare
a
bazelor
de
date
care
folosesc
SQL
sunt:
Oracle,
Microsoft
SQL
Server,
Access,
etc.
SQL
oferă
bucle,
directive
logice,
variabile,
etc.
De
ș
i
o
aplica
ț
ie
poate
fi
program ată
într-un
limbaj
precum
Python,
PHP
sau
Ruby
,
bazele
de
date
nu
sunt configurate pentru a le în
ț
elege.
Un
sistem
de
baze
de
date
rela
ț
ionale
con
ț
ine
unul
sau
mai
multe
obiecte
numite
tabele.
Datele
sau
informa
ț
iile
pentru
baza
de
date
sunt
stocate
în
aceste
tabele.
Tabelele
sunt
identificate
în
mod
unic
după
numele
lor
ș
i
sunt
alcătuite
din
coloane
ș
i
rânduri.
Coloanele
con
ț
in
numele
coloanei,
tipul
de
date
ș
i
orice
alte
atribute
pentru
coloană.
Rândurile
con
ț
in
înregistrările
sau datele pentru coloane. [
20
]
Există câteva comenzi
SQL
frecvent utilizate pentru lucrul în baza de date:
●
CREATE TABLE
– pentru a crea tabele
●
SELECT
– pentru a găsi / extrage unele date dintr-o bază de date
●
UPDATE –
pentru face ajustări
ș
i editează datele
●
DELETE –
pentru a
ș
terge unele date
Instruc
ț
iunea
SELECT
este
utilizată
pentru
a
interoga
baza
de
date
ș
i
pentru
a
prelua
datele selectate care se potrivesc criteriilor specificate. Iată formatul unei declara
ț
ii de selectare:
select "column1"
[,"column2",etc]
from "tablename"
[where "condition"];
[] = optional
Selec
ț
ii condi
ț
ionale utilizate în clauza
WHERE
: = , > , < , > = , < = , <> ,
LIKE
.
Exemplu:
select first, last, city
from empinfo
where first LIKE 'Er%’
41
Aceste
comenzi
sunt
utilizate
la
scrierea
interogărilor
care
permit
operarea
datelor
în
baze
de
date.
Cu
alte
cuvinte,
când
introduci
aceste
comenzi
într-un
sistem
de
baze
de
date,
sistemul
interpretează
comenzile
ș
i
le
prelucrează.
Rezultatul
ar
putea
fi,
de
exemplu,
o
înregistrare
nouă
în baza de date sau crearea unei noi baze de date.
Exemplu:
Fig. 1.11 – Sintaxa folosită în Azure la crearea tabelului Post
Fig. 1.12 – Tabelul “Post” in Azure
42
Fig. 1.13 – Tabelul “Users” in Azure
1.10 ERD
Cunoscute
ș
i
sub
denumirea
de
ERD
(Entity
Relationship
Diagram)
sau
modele
ER
,
ele
definesc
entită
ț
ile,
atribu tele
lor
ș
i
arată
rela
ț
iile
dintre
ele.
O
diagramă
ER
ilustrează
structura
logică
a
bazei
de
date.
Diagrama
unei
rela
ț
ii
de
entitate
este
un
tip
de
diagramă
care
ilustrează
modul
în
care
„entită
ț
i”
cum
ar
fi
persoane,
obiecte
sau
concepte
se
raportează
între
ele
într-un
sistem.
Diagramele
ER
sunt
cel
mai
adesea
folosite
pentru
proiectarea
sau
debug-area
bazelor
de
date
rela
ț
ionale
în
domeniile
ingineriei
software,
sistemelor
de
informa
ț
ii
pentru
afaceri,
educa
ț
iei
ș
i
cercetării.
Diagramele
ER
sunt
utilizate
pentru
a
schi
ț
a
proiectarea
unei
baze
de
date.
Când
este
documentat
un
sistem
sau
un
proces,
sistemul
este
privit
în
mai
multe
moduri,
deci
cre
ș
te în
ț
elegerea lui. [
21
]
Cum se desenează o diagramă
ER
de bază:
1.
Scopul
ș
i
domen iul
de
aplicare:
define
ș
ti
scopul
ș
i
sfera
a
ceea
ce
este
analizat
sau
modelat;
43
2.
Entită
ț
i:
identifici
entită
ț
ile
implicate,
apoi
le
desenezi
în
dreptunghiuri
ș
i
să
le
etichetezi
ca substantive;
3.
Rela
ț
ii:
Determin i
rela
ț
iile
dintre
entită
ț
i.
Desenezi
linii
între
ele
pentru
a
semnifica
rela
ț
iile
ș
i
a
le
eticheta.
Este
posibil
ca
unele
entită
ț
i
să
nu
aibă
legătură.
În
diferite
sisteme
de
notare,
rela
ț
ia
ar
putea
fi
etichetată
într-un
diamant,
un
alt
dreptunghi
sau
direct în partea de sus a liniei de conectare;
4.
Atribute:
Layer
mai
detaliat
prin
adăugarea
atributelor
cheie
ale
entită
ț
ilor.
Atributele
sunt adesea prezentate ca ovale;
5.
Cardinalitate: arată dacă rela
ț
ia este 1-1,
1-many
sau
many-to-many.
Fig. 1.14 – Diagrama ERD a bazei de date a aplica
ț
iei mele
44
1.11 Foursquare
Foursquare
este un serviciu de localizare socială care permite utilizatorilor să exploreze
lumea din jurul lor. Utilizatorii pot descărca aplica
ț
ia
Foursquare
pe telefonul lor
iPhone
,
Blackberry
sau
Android
ș
i se pot înscrie gratuit, apoi î
ș
i pot conec ta conturile
Foursquare
la
celelalte conturi de social media.
API Foursquare Places
oferă acces la o bază de date uria
ș
ă cu
diferite loca
ț
ii din întreag a lume. Acesta include o varietate bogată de informa
ț
ii, cum ar fi
adresele locurilor, popularitatea, sfaturile
ș
i fotografiile. Accesul la
API
este disponibil gratuit
ș
i
oferă o configurare u
ș
oară. [
33
]
Companii de top precum
Airbnb, Uber
sau
Samsung
folosesc
API-ul Foursquare
ca
să scoată la suprafa
ț
ă foto grafii
ș
i alte con
ț
inuturi legate de loc în ghidurile utilizatorilor sau le
permite să caute
ș
i să găs ească destina
ț
iile pe care doresc să le uti lizeze, avand o bază de date de
peste 105 milioane de locuri din întreaga lume. Permite de asemenea să geo eticheteze
fotografiile lor cu detalii
ș
i informa
ț
ii despre o destina
ț
ie, oferind în acela
ș
i timp loca
ț
ii relevante
din punct de vedere contextual pentru cei care caută un loc unde să mănânce, să bea sau să
exploreze.
Pa
ș
ii
pe
care
a
trebuit
sa
îi
urmez
pentru
a
putea
folosii
API-ul
Foursquare
sunt
următorii:
mi-am
creat
un
cont
de
dezvoltator,
am
creat
o
aplica
ț
ie
Foursquare
nouă,
apoi
am
ob
ț
inut identificatorul
ș
i parola de client conform figurii:
Fig. 1.15 – Datele generate de Foursquare pentru aplica
ț
ia mea
45
API-ul
este
oferit
gratuit
de
Foursquare
,
astfel
încât
dezvoltatorii
să
poată
accesa
baza
de
date
ș
i
să
o
utilizeze
în
conformitate
cu
aplica
ț
ia
lor.
El
are
multe
obiective
finale
diferite,
ceea
ce
înseamnă
că
are
o
mul
ț
ime
de
informa
ț
ii
pe
care
le
poate
solici ta.
Cel
pe
care
m-am
concentrat
este
punctul
final
al
loca
ț
iei,
fiind
cel
care
va
permite
API-ului
să
identifice
un
utilizator
autentificat.
El
îmi
va
cere
să
autentific
efectiv
utilizatorii
însă
am
ales
sa
folosesc
modalitatea
de
autentificarea
fără
utilizator,
care
a
fost
posibilă
prin
setarea
id-ului
ș
i
parolei
clientului
în
URL-ul
aplica
ț
iei generat e, astfel încât nu va trebui să autentific utilizatorii.
API-ului
îi
pot
seta
distan
ț
a
până
la
care
vreau
să
caute
ș
i
să
returneze
loca
ț
iile.
Am
ales
să
pun
o
distan
ț
ă
mai
mare
pentru
localizare
astfel
încât
dacă
loca
ț
ia
aleasă
este
între
o
zonă
în
care
oamenii
nu
prea
au
făcut
postări,
să
nu
întoarcă
o
listă
goală,
ci
să
meargă
un
pic
mai
departe
cu
localizarea.
Numărul
de
loca
ț
ii
afi
ș
ate
poate
fi
ș
i
el
setat
la
până
la
50
de
loca
ț
ii
afi
ș
ate.
Structura răspunsului este în format
JSON (Javascript Object Notation).
Acesta
returnează o listă de loca
ț
ii în apropierea loca
ț
iei curente, op
ț
ional potrivindu-se unui termen de
căutare. Oferă detalii complete despre un loc, inclusiv loca
ț
ia, sfaturi
ș
i categorii. Returnează de
asemenea o listă ierarhică de categorii aplicate pe loca
ț
ii.
Raspunsul returnat ca
JSON
: [
9
]
{
"meta": {
"code": 200,
"requestId": "5ac51d7e6a607143d811cecb"
},
"response": {
"venues": [
{
"id": "5642aef9498e51025cf4a7a5",
"name": "Mr. Purple",
"location": {
"address": "180 Orchard St",
"crossStreet": "btwn Houston & Stanton St",
"lat": 40.72173744277209,
"lng": -73.98800687282996,
"labeledLatLngs": [
{
"label": "display",
"lat": 40.72173744277209,
46
"lng": -73.98800687282996
}
],
"distance": 8,
"postalCode": "10002",
"cc": "US",
"city": "New York",
"state": "NY",
"country": "United States",
"formattedAddress": [
"180 Orchard St (btwn Houston & Stanton St)",
"New York, NY 10002",
"United States"
]
},
"categories": [
{
"id": "4bf58dd8d48988d1d5941735",
"name": "Hotel Bar",
"pluralName": "Hotel Bars",
"shortName": "Hotel Bar",
"icon": {
"prefix":
"https://ss3.4sqi.net/img/categories_v2/travel/hotel_bar_",
"suffix": ".png"
},
"primary": true
}
],
"venuePage": {
"id": "150747252"
}
}
]
}
}
Un
JSON
este
doar
o
colec
ț
ie
de
obiecte
pe
care
de
fapt
le
pot
identifica
destul
de
u
ș
or.
Se
poate
vedea
o
primă
structura
care
va
ț
ine
întreaga
informa
ț
ie
ș
i
se
poate
identifica
primul
obiect,
deoarece
este
legat
cu
acoladă.
În
interior
se
observa
un
alt
obiect,
care
este
un
obiect
meta,
el
fiind
un
obiect
complet
deoarece
con
ț
ine
ș
i
el
două
acolade.
În
interiorul
acoladelor
lui
meta
este
un
cod
ș
i
un
ID
de
solicitare.
Se
observa
că
niciuna
dintre
acestea
nu
sunt
obiecte,
ci
sunt doar valori.
47
A
ș
adar,
am
identi ficat
deja
obiecte
ș
i
valori,
dar
se
obser va
că
notificările
nu
sunt
tocmai
un
obiect.
Este
o
serie
de
obiecte
ș
i
se
pot
identifica
liste
sau
tablouri
de
obiecte
cu
paranteze
pătrate.
A
ș
adar,
parante zele
pătrate
sunt
pentru
liste,
iar
acoladele
sunt
pentru
obiecte.
Notificările
reprezinta
o
serie
de
obiecte
diferite,
care
pot
contine
mai
multe
obiecte.
În
special,
are
o
valoare
String
ș
i
un
alt
obiect,
dar
ele
nu
mă
interesează
în
mod
deosebit.
Cel
care
este
foarte
important
este
obiectul
de
răspuns
care
con
ț
ine
locurile
în
sine.
Deci,
locul
va
fi,
de
asemenea,
o
serie
de
obiecte,
o
serie
de
locuri,
fiecare
dintre
ele
va
con
ț
ine
informa
ț
iile
pe
care
le-a
ș
putea
dori.
Pot
exista
o
mul
ț
ime
de
locuri
în
interiorul
acestui
obiect
ș
i
fiecare
dintre
acestea
va
con
ț
ine
un
nume,
informa
ț
ii
despre
loca
ț
ia
(de
la
adresă
la
latitudine
ș
i
longitudine
până
la
ora
ș
,
stat
ș
i
ț
ară).
Există
ș
i
anumite
categorii
din
care
face
parte
acest
loc.
Deci
am
toate
informa
ț
iile despre loca
ț
ia returnată.
1.12 MacinCloud
MacinCloud
este
un
serviciu
de
închiriere
de
server
Mac
la
distan
ț
ă,
care
permite
utilizarea
Windows,
Mac,
Linux
sau
un
dispozitiv
mobil
pentru
a
accesa
un
Mac
real
prin
internet,
folosind
browser-ul
sau
un
program
desktop
.
Serverele
Mac
închiriate
prin
internet
se
pot
accesa
pentru
a
dezvolta
aplica
ț
ii
ș
i
a
rula
programe
Mac
.
După
conectare,
po
ț
i
vizualiza
ș
i
controla
Mac
de la distan
ț
ă ca
ș
i cum ai sta în fa
ț
a
Mac-ului
. [
22
]
Dezvoltarea
Xamarin
este
excelentă
pentru
crearea
aplica
ț
iilor
mobile
cross-platform
,
fără
duplicarea
codului
pentru
fiecare
dintre
ele.
Dar,
pentru
cei
care
nu
utilizează
ecosistemul
Apple
,
există
o
problemă
care
poate
fi
o
barieră
pentru
construirea
aplica
ț
iilor
iOS
Xamarin
.
În
timp
ce
o
aplica
ț
ie
Xama rin
construită
atât
pentru
Android
cât
ș
i
pentru
iOS
refolose
ș
te
o
mare
parte din cod, rămâne totu
ș
i esen
ț
ială testarea aplica
ț
iei pe fiecare platformă.
Android
este
open-source
,
deci
există
o
varietate
de
resurse
de
testare
gratuite
ș
i
u
ș
oare,
însă
nu
este
cazul
ș
i
pentru
iOS
.
Pentru
a
construi
aplica
ț
ia
este
necesar
un
mediu
OSX
dar
nici
48
sistemele
de
operare
OSX
nici
iOS
nu
sunt
disponibile
gratuit,
deci
pentru
testarea
aplica
ț
iei
fără
un mediu
OSX
am utilizat unui serviciu cloud, numit
MacinCloud
.
Avantajele utilizării
MacinCloud
:
●
Accesul la
serverul Mac
se face de pe o mare diversitate de dispositive
●
Configurarea
este
u
ș
oară,
hardware-ul
este
între
ț
inut
ș
i
actualizat
de
Mac
,
care
face
automat
ș
i actuali zări de software
●
Nu
este
nevoie
să
faci
o
investi
ț
ie
substan
ț
ială
pentru
a
începe
dezvoltarea
aplica
ț
iilor
iOS
.
MacinCloud
oferă
o
varietate
de
planuri
de
pre
ț
uri
care
permit
utilizatorilor
să
aleagă unul care se potrive
ș
te cel mai bine nevoilor lor
●
MacinCloud
este
o
solu
ț
ie
viabilă
pentru
echipele
Xamarin
care
utilizează
hardware
Windows
ș
i
care
doresc
op
ț
iuni
de
dezvoltare
iOS
fără
a
fi
necesară
men
ț
inerea
propriului
hardware Apple
[
7
]
Fig. 1.16 – VS 2019 for Mac
Fig. 1.17 – Simulatorul iPhone 11
49
50
2. PREZENTAREA APLICA
Ț
IEI
2.1 Prezentare generală
Aplica
ț
ia
mea
Journey
Record
este
construită
folosind
framework-ul
Xamarin
Forms.
Versiunea
pentru
Android
cât
ș
i
cea
pentru
iOS
vor
arăta
similar
ș
i
întrucât
datele
sunt
stocate
pe
cloud
,
se
pot
accesa
acelea
ș
i
informa
ț
ii.
Adică,
spre
exemplu,
mă
pot
autentifica
cu
acelea
ș
i
credentiale
pe
mai
multe
dispozitive,
indiferent
de
platformă,
în
acela
ș
i
timp,
iar
aplica
ț
ia
va
func
ț
iona.
Aplica
ț
ia
este
gândită
pentru
a
adăuga
noi
excursii,
deplasări
ș
i
experien
ț
e.
Loca
ț
ia
dispozitivului
ajuta
la
găsirea
locurilor
sau
a
obiectivelor
din
apropiere.
Ea
este
pusă
setand
coordonate
pe
emulatoare,
iar
cu
ajutorul
API-ului
de
la
Foursquare
este
furnizată
o
listă
cu
loca
ț
ii
din
apropierea
coordonatelor
introduse
pentru
loca
ț
ie.
În
aplica
ț
ie
se
scrie
o
recenzie,
se
alege locul
ș
i apoi se salv ează în baza de date ca o nouă experien
ț
ă.
Informa
ț
ia
introd usă
va
fi
redată
indiferent
de
dispozitiv
din
baza
de
date
din
cloud-ul
Azure
ș
i
loca
ț
iile
vizitate
vor
fi
introduse
pe
hartă
sub
formă
de
pini.
Experien
ț
a
introdusă
se
va
regăsi
în
pagina
de
istoric,
iar
în
pagina
de
profil
se
vor
regăsi
categoriile
de
locuri
vizitate
ș
i
numărul recenziilor adăugate la fiecare categorie plus numărul total al recenziilor.
În
mod
normal
pentru
a
porni
simulatorul
de
iOS
ș
i
a
testa
aplica
ț
ia
pe
el,
Visual
Studio
de
pe
Windows
,
unde
este
dezvoltată
aplica
ț
ia
mea,
trebuie
conectat
la
un
Mac
care
să
fie
în
aceea
ș
i
re
ț
ea
cu
calculatorul
meu,
sau
conectat
la
un
serviciu
de
cloud
care
este
provider
de
Mac
,
pentru
a
permite
accesul
la
resursele
simulatorului
de
iOS
.
În
această
lucrare
am
ales
să
dezvolt
ș
i
să
testez
folosind
simu latorul
de
Android
pe
care
l-am
putut
descărca
în
calculatorul
personal
iar
testarea
aplica
ț
iei
pe
componenta
de
iOS
am
făcut-o
folosind
MacinCloud
ș
i
Visual
Studio
for
Mac
. Pentru
Mac
, emulatorul folosit este un
iPhone 11.
Aplica
ț
ia
este
în
prezent
doar
pentru
telefoanele
mobile
ș
i
poate
fi
folosită
de
către
orice
categorie
de
utilizatori,
având
o
interfa
ț
ă
user
friendly.
Baza
de
date
din
cloud
se
ocupă
de
stocarea
ș
i
prelucrarea
informa
ț
iilor
pe
care
utilizatorii
le
introd uc
ș
i
le
pot
vedea
în
aplica
ț
ie.
Am
ales
să
folosesc
serviciul
de
cloud
de
la
Azure
deoarece,
este
un
produs
Microsoft
,
u
ș
or
de
51
utilizat
pe
care
l-am
mai
folosit
ș
i
la
alte
proiecte
în
cadrul
facultă
ț
ii
ș
i
fiind
tot
un
produs
Microsoft
se îmbină perfect cu
Visual Studio
ș
i componentele sale.
Fig. 2.1 – Pachetele instalate în Visual Studio 2019
2.2 Descrierea tehnică a aplica
ț
iei
Fig. 2.2 – Tipul de aplica
ț
ie aleasă din Visual Studio 2019
Proiectul
creat
în
Visual
Studio
este
o
aplica
ț
ie
mobilă
care
creează
o
singură
solu
ț
ie
cu
trei
proiecte
în
ea:
proiectele
Android
ș
i
iOS
,
plus
proiectul
ale
cărui
pagini
sunt
împăr
ț
ite
de
aplica
ț
ia
cross-platform
.
Încă
de
la
început,
proiectul
vine
cu
o
pagină
principală
MainPage
,
care
are
pagina
ce
contine
elementele
vizuale
.
xml
ș
i
pagina
de
code-behind
.xaml.cs
,
care
va
con
ț
ine
sintaxa de C#
ș
i logica pa ginii.
52
Aplica
ț
ia
folose
ș
te
.Net
Standard
Libraries
,
deci
fiecare
proiect
face
referin
ț
ă
la
un
fi
ș
ier
portabil
Assembly
al
proiectului
.Net
Standard.
Beneficiile
utilizării
acestei
librării
sunt
ca
op
ț
iunea
de
refactoring
updatează
toate
referin
ț
ele
unde
această
bibliotecă
este
folosită.
Ș
i,
de
asemenea,
este
o
solu
ț
ie
bună
în
caz
că
doresc
să
partajez
rezultatul
din
Assembly
cu
al
ț
ii
dezvoltatori
stau
cu
alte
aplica
ț
ii
întrucât
codul
este
împachetat
într-un
singur
fi
ș
ier
Assembly
ș
i
nu trebuie să partajez un întreg proiect.
Proiectele
Android
,
iOS
ș
i
.
NET
Standard
sunt
trei
proiecte
diferite,
însă
faptul
că
în
folderul
References
,
care
este
prezent
în
proiectele
Android
ș
i
iOS
,
se
regăse
ș
te
proiectul
.
NET
Standard
,
împachetat
într-un
fi
ș
ier
.
dll
ș
i
referen
ț
iat,
ambele
proiecte
au
acces
la
acesta.
Proiectele
Android
ș
i
iOS
sunt
create
întocmai
ca
unele
native
păstrând
configura
ț
ia
ș
i
structura
fi
ș
ierelor,
Însă
toate
vizualizarile
ș
i
logica
aplica
ț
iei
se
vor
regăsi
în
proiectul
.Net
Standard.
Fiind
o
aplica
ț
ie
cross
platform,
folderele
Packages
din
ambele
proiecte
vor
con
ț
ine
implementări specifice platformei ale pachetelor
NuGet
care au fost instalate.
De
fiecare
dată
când
aplica
ț
ia
este
rulată
pe
un
emulator
sau
dispozitiv
Android
,
în
clasa
MainActivity
.
cs
o
noua
aplica
ț
ie
este
creată
prin
metoda
Oncreate
,
care
apelează
constructorului
din
clasa
App.xaml.cs.
Similar,
cand
proiectul
iOS
este
rulat
pe
un
dispozitiv,
în
fi
ș
ierul
AppDelegate.cs
este apelat constructorul clasei
App.xaml.cs
prin metoda
FinishedLaunching.
Fiecare
pagină
a
proiectului
este
formată
dintr-un
fi
ș
ier
.
xaml
ș
i
un
fi
ș
ier
C#.
MainPage
defineste
vizualizarea
principala
a
aplica
ț
iei,
adică
pagina
cu
care
se
deschide
aplica
ț
ia.
Mai
multe
fi
ș
iere
pot
să
definească
aceea
ș
i
clasă
deoarece
ea
este
setată
ca
fiind
par
ț
ială.
Constructorul
din
pagina
C#
ini
ț
ializează
MainPage
,
care
este
pagina
principală,
cea
cu
care
se
deschide proiectul:
public App()
{
InitializeComponent();
MainPage = new NavigationPage(new MainPage()); }
Fi
ș
ierele
App.xam l
ș
i
App.xaml.cs
nu
definesc
o
vizualiza re,
deci
aceasta
nu
este
o
pagină
în
sine
a
aplica
ț
iei,
însă
sunt
utile
pentru
a
stoca
diverse
resurse,
precum
culori
sau
stiluri
predefinite
pe
care
le
voi
folosi
ulterior
în
interiorul
proiectului.
Restul
detaliilor
de
costumizare
53
se
regasesc
pe
fiecare
pagina
.
xaml
,
pentru
fiecare
element
în
parte.
Dic
ț
ionarul
de
resurse
din
pagina
App.xaml
este:
<ResourceDictionary>
<Color x:Key="salmonColor">#FF5A60</Color>
<Color x:Key="whiteColor">#FFFFFF</Color>
<Style x:Key="normalButton" TargetType="Button">
<Setter
Property="BackgroundColor"
Value="{StaticResource
salmonColor}" />
<Setter
Property="TextColor"
Value="{StaticResource
whiteColor}"
/>
</Style>
</ResourceDictionary>
Layout-ul
paginilor,
împreună
cu
toate
specifica
ț
iile
ș
i
detaliile
acestora,
este
con
ț
inut
de
fi
ș
ierele
.xaml.
Elemente le
paginilor
sunt
create
în
general
în
contextul
unui
StackLayout
,
care
permite a
ș
ezarea lor unul după celălalt, pentru a men
ț
ine
layout-ul
întregii pagini.
Folderul
Models
contine
cele
trei
clase
ale
modelelor
după
care
sunt
create
tabelele
Post
ș
i
User
din
baza
de
date
Azure
ș
i
datele
care
sunt
retribuite
din
API-ul
de
la
Foursquare
:
Users.cs, Post.cs
ș
i
Venue .cs.
În
folderul
NuGet
se
vor
găsi
toate
pachetele
nuget
auxiliare
care
au
fost
descărcate
ș
i
sunt
folosite
în
proiect.
[
17
]
Folosind
pachetul
NuGet
Microsoft.Azure.Mobile.Client,
aplica
ț
ia
mea
va
putea
accesa
internetul.
Ca
acest
lucru
sa
fie
posibil,
a
trebuit
să
creez
o
nouă
variabilă
de
client
de
servicii
mobile,
folosind
o
directivă
pentru
pachetul
Microsoft
.
Aceasta
variabila
client
va
fi
cea
care
gestionează
întreaga
conexiune.
Tot
ce
trebuie
să
fac
este
să
spun
ce
tabel
sa
foloseasca
pentru
a
insera,
a
citi,
etc.
Conexiunea
prime
ș
te
ca
parametru
URL-ul
aplica
ț
iei
mobile
Azure
, toate acestea petrecandu-se în fi
ș
ierul
App.xaml.cs:
public static MobileServiceClient MobileService = new MobileServiceClient
( "https://travelrecordappxamarin2020.azurewebsites.net" );
Clientul
creat
ar
putea
acum
să
se
conecteze
la
serviciul
de
aplica
ț
ii,
iar
conexiunea
va
fi
deja
suficientă
pentru
a-i
spune
serviciului
ce
cereri
trebuie
să
efectueze
către
baza
de
date.
Am
adăugat
apoi
aceasta
func
ț
ionalitate
în
aplica
ț
ie,
astfel
încât
utilizatorii
să
se
înregistreze
ș
i
apoi
54
sa
î
ș
i
folosească
credenti alele
pentru
autentificare.
Datele
cu
informa
ț
iile
despre
utilizator
vor
fi
acum stocate în întregime în
cloud
.
După
implementarea
modelului
arhitectural
MVVM
în
aplica
ț
ia
mea,
am
ob
ț
inut
curatarea
vizualizarii,
adică
a
codului
din
spatele
vizualizării
care
este
în
fi
ș
ierele
C#,
ce
sunt
legate
de
fisierele
XAML
.
Nu
mai
exista
aproape
niciun
EventHandler
,
deci
se
face
doar
setarea
contextului
de
legare
la
view-model
,
el
fiind
cel
în
care
am
cea
mai
mare
parte
a
func
ț
ionalită
ț
ii
acum.
O
parte
din
func
ț
ionalită
ț
i
este,
de
asemenea,
în
mode l
ș
i
am
ob
ț
inut
acest
lucru
cu
ajutorul interfe
ț
elor
ICom mand, INotifyPropertyChanged, IValueConverter,
etc
.
[
30
]
Au
trebuit
adaugate
cateva
func
ț
ionalită
ț
i
specifice
platformei,
de
exemplu,
atunci
când
vine
vorba
de
ini
ț
ializare a
hăr
ț
ilor
sau
în
folosirea
seturilor
de
imagini
specifice
platformei
pe
care le-am folosit în interiorul aplica
ț
iei. Dar 98-99 % din cod este complet distribuit.
55
3. APLICA
Ț
IA
3.1 Pagina de autentificare
Fig. 3.1 – Pagina de login
Această
pagină
con
ț
ine
câmpul
unde
utilizatorul
trebuie
să
introducă
numele
de
utilizator
ș
i
parola
pentru
a
se
putea
autentifica
ș
i
a
deschide
aplica
ț
ia.
Butonul
de
login
devine
activ
în
56
momentul
în
care
utilizatorul
a
completat
ceva
în
ambele
câmpuri
care
trebuiesc
validate.
Dacă
creden
ț
ialele
introduse
au
fost
corecte,
iar
utilizatorul
există
în
baza
de
date,
atunci
aplica
ț
ia
se
va
deschide
ș
i
va
încărca
datele
utilizatorului
respectiv.
În
cazul
în
care
numele
de
utilizator
sau
parola
nu
sunt
corecte,
pe
ecran
va
apărea
un
mesaj
de
eroare
care
anun
ț
ă
utilizatorul
că
nu
s-a
putut autentificarea.
La
fel
se
întâmplă
ș
i
în
cazul
în
care
utilizatorul
nu
există
în
baza
de
date.
În
acest
caz
utilizatorul
trebuie
să
se
înregistreze
printr-un
cont
nou
apăsând
pe
butonul
Register
din
josul
paginii,
butonul
fiind
activ
în
permanen
ț
ă.
Func
ț
ia
care
validează
datele
ș
i
face
navigarea
către
pagina de istoric sau arată alerta de eroare, este următoarea:
public async void Login()
{
bool canLogin = await Users.Login(User.Email, User.Password);
if (canLogin)
await App.Current.MainPage.Navigation.PushAsync(new HomePage());
else
await App.Current.MainPage.DisplayAlert("Error", "Try again!", Ok");
}
Data
binding
creează
legături
directe
între
obiecte,
adică
leagă
proprietă
ț
ile
unui
obiect
sursă
de
proprietă
ț
ile
unui
obiect
ț
intă.
Locul
unde
acest
lucru
este
foarte
util
este
unde
există
o
listă
de
obiecte,
fiecare
având,
de
exemplu,
o
proprietate
de
text
ș
i
doresc
să
o
leg
de
proprietatea
text
a
unei
etichete.
Aici
devine
foarte
important,
deoarece
pot
avea
un
obiect
sursă
care
este
direct conectat la un obiect
ț
intă, iar aceste proprietă
ț
i vor fi sincronizate de la început.
Există
doi
pa
ș
i
pe
care
i-am
urmat
pentru
a
stabili
legarea
datelor
în
aplica
ț
ia
mea.
Primul
pas
a
fost
să
setez
contextul
de
legare,
adică
legarea
la
obiectul
sursă
de
unde
doresc
să
ob
ț
in
toate
datele.
Al
doilea
pas
a
fost
să
setez
legarea
reală
a
datelor.
Deci,
contextul
de
legare
va
fi
un
obiect
întreg
ș
i
calea
pe
care
sursa
se
va
îndrepta
către
una
dintre
proprietă
ț
ile
acelui
obiect.
Modul
default
este
setat
OneWay
ceea
ce
înseamnă
că
ț
inta
va
ob
ț
ine
valori
de
la
sursă.
Deci
este
doar
o
conexiune
unidirec
ț
ională
de
la
sursă
la
ț
intă
ș
i
este
setarea
implicită.
Dar
eu
am
avut
nevoie
să
o
schimb
în
TwoWay
,
astfel
încât
atât
ț
inta
va
seta
valoarea
pentru
sursă,
dar
ș
i
sursa
57
poate
seta
valoarea
pentru
ț
intă.
Ș
i
acest
lucru
este
util
mai
ales
în
intrările
în
care
poate
că
la
început există o anumită valoare care vine din sursă.
Elementele
paginii
sunt
ț
inute
la
un
loc
printr-un
StackLayout
.
Campurile
"
emailEntry
"
ș
i
"
passwordEntry
"
sunt
legate
prin
cuvântul
cheie
“
Binding”
,
de
proprietă
ț
ile
specificate
ale
obiectului din clasa
Users
:
<Entry x:Name="emailEntry"
Text="{Binding Email, Mode=TwoWay}"
Placeholder="Username" />
<Entry x:Name="passwordEntry"
Text="{Binding Password, Mode=TwoWay}"
Placeholder="Password" />
Butonul
de
login
este
legat
de
clasa
LoginCommand
,
care
implementează
ICommand
,
retribuind
astfel
utilizatorul
cu
credentialele
specificate
din
baza
de
date
din
Azure
ș
i
făcând
posibilă autentificarea în aplica
ț
ie:
<Button x:Name = "LoginButton"
Command="{Binding LoginCommand}"
CommandParameter="{Binding User}"
Style="{StaticResource normalButton }" />
Pentru
a
autentificarea
utilizatorul,
mai
întâi
trebuie
să
ob
ț
in
tabelul
User
din
baza
de
date
care
se
află
în
cloud
.
Trebuie
să
ob
ț
in
înregistrarea
care
are
acela
ș
i
e-mail
ca
cel
care
a
fost
scris
în
interiorul
intrării
pentru
e-mail.
Am
nevoie
să
filtrez
acest
tabel,
iar
pentru
asta
folosesc
opera
ț
ia
“
Where
”
din
LINQ
.
Deci,
cu
această
evaluare,
voi
filtra
tabelul
în
care
valoarea
coloanei
de
e-mail
este
egală
cu
valoarea
care
a
fost
scrisă
de
utilizator
în
câmpul
pentru
e-mail.
Butonul
de
login
devine
activ
doar
cand
sunt
scrise
valori
atat
în
câmpul
pentru
user
cât
ș
i
în
cel
pentru
parola,
apoi
datele
sunt
verificate.
A
se
vedea
codul
din
Anexa
2
pentru
func
ț
ia
care
face
login-ul
unui
utilizator
existent
în
baza
de
date
din
Azure
ș
i
aduce
în
paginile
aplica
ț
iei
postările
ș
i
informa
ț
iile acelui utiliza tor specific.
Dacă
atât
spa
ț
iul
pentru
e-mailul,
cât
ș
i
spa
ț
iul
pentru
parola
au
ceva
scris
în
ele,
atunci
voi
face
o
interogare
la
un
tabelul
din
interiorul
serviciului
mobil.
Ob
ț
in
informa
ț
iile
din
tabelul
58
User
,
în
care
coloana
de
e-mail
contine
o
înregistrare
echivalentă
cu
cea
pe
care
utilizatorul
a
scris-o
în
campul
de
e-mail
din
aplica
ț
ie.
Preiau
toate
informa
ț
iile
sub
formă
de
listă
ș
i
scot
primul
element
sau
elementul
implicit
din
acea
lista.
Dacă
numele
de
utilizator
nu
este
nul,
evaluez
dacă
o
parolă
care
a
fost
preluată
din
baza
de
date
este
egală
cu
parola
care
a
fost
scrisă
de
către
utilizator.
Dacă
ele
coincid,
atunci
navighez
la
pagina
de
pornire,
dar
dacă
nu,
înseamnă
ca
a
existat
o
eroare,
emailul
sau
parola
sunt
incorecte.
Dacă
utilizatorul
este
nul,
presupun
că
ori
nu
este
înregistrat,
ori
a
apărut
o
eroare
la
ob
ț
inerea
informa
ț
iilor
din
tabel
ș
i
se
afi
ș
ează
o
eroare
pe ecran.
Modul
în
care
func
ț
ionează
se
bazează
pe
implementarea
interfe
ț
ei
ICommand
în
view-model.
Prin
implementarea
acestei
interfe
ț
e,
se
creeaza
un
membru
Execute
,
iar
în
interiorul
lui
pot
defini
func
ț
ional itatea
care
se
află
în
prezent
într-un
event-handler
.
Am
o
evaluare
op
ț
ională
„CanExecute
”,
care
va
defini
dacă
metoda
Execute
ar
trebui
apelată
sau
nu.
Deci
execu
ț
ia
nici
măcar
nu
trebuie
să
se
întâmple,
deoarece
am
ș
i
această
evaluare
op
ț
ională
prin
interfa
ț
a
ICommand
.
Ș
i,
în
sfâr
ș
it,
odată
ce
am
implementat
interfa
ț
a
ICommand
,
care
adaugă
intrarea
func
ț
ională
la
execu
ț
ie,
pot
executa
metodele
pe
care
le-am
atribuit
acelei
comenzi
(foarte similar cu modul în care a fost alocat
by default
un
event-handler
).
Mai
simplu
spus,
am
un
view
cu
două
elemente,
în
acest
caz,
pentru
autentificare.
Ș
i
autentificarea
are
o
comandă
atribuită
acesteia,
iar
comanda
va
primi,
de
asemenea,
informa
ț
ii
despre
ceea
ce
se
află
în
interiorul
celor
două
intrări.
Îmi
pot
imagina
că
una
este
pentru
utilizator,
iar
cealaltă
pentru
parolă.
Ș
i
pentru
că
în
prezent,
niciuna
dintre
intrări
nu
are
valori
care
pot
fi
executate,
va
fi
setată
pe
false.
Deci
func
ț
ia
de
execu
ț
ie
nu
va
fi
disponibilă,
dar
imediat
ce
există
o
anumită
valoare
pentru
ambele
intrări
pe
care
le
pot
executa
pe
baza
logicii
sale, va fi setată la true. Deci, metoda
Execute
este din nou disponibila:
public class LoginCommand : ICommand
public event EventHandler CanExecuteChanged;
public void Execute(object parameter)
{
ViewModel.Login();
}
59
3.2 Pagina de înregistrare
Fig. 3.2 – Pagina de înregistrare utilizator nou
Dispunerea
paginii
de
înregistrare
este
similară
cu
cea
a
paginii
de
autentificare,
însă
are
trei
campuri
de
input
.
A
treia
intrare
va
permite
utilizatorului
să
î
ș
i
confirme
parola.
Am
adăugat
de
asemenea
evaluarea
dacă
utilizatorul
va
fi
sau
nu
înregistrat.
Acest
lucru
se
întâmplă
prin
validarea
numelui
de
utilizator
să
nu
fie
prea
scurt,
să
con
ț
ină
minim
o
literă
mare
ș
i
o
cifră,
sa
nu
aibă
spa
ț
ii
ș
i
de
asemenea,
să
nu
existe
deja
în
baza
de
date
acel
nume,
la
fel
este
ș
i
pentru
60
validarea
parolei.
Dacă
condi
ț
iile
de
scriere
nu
sunt
îndeplinite,
utilizatorul
va
primi
pe
ecran
un
mesaj de eroare de forma unei alerte:
Fig. 3.3 – Exemple de alerte de eroare din pagina de înregistrare
În
plus,
cu
ajutorul
interfe
ț
ei
ICommand
am
condi
ț
ionat
dacă
unul
din
câmpuri
a
fost
lăsat
gol,
sau
dacă
atât
parola
introdusă,
cât
ș
i
parola
confirmată
nu
au
acela
ș
i
text,
atunci
butonul de înregistrare sa nu devină activ, deci să nu se execute înregistrarea:
if (user != null)
{
if (user.Password == user.ConfirmPassword)
{
if(string.IsNullOrEmpty(user.Email)
||string.IsNullOrEmpty(user.Password))
{ return false; }
61
return true;
}
return false;
}
return false;
Am folosit
ICommand
în implementarea acestei pagini deoarece, de exemplu, într-o
pagină de înregistrare, dacă nu există un e-mail
ș
i o parolă nu are niciun folos să execut ceva
ș
i
pur
ș
i simplu spun utiliza torului că încă mai lipsesc unele informa
ț
ii. Deci execu
ț
ia nici măcar nu
trebuie să se întâmple, deoarece am
ș
i această evaluare op
ț
ională prin interfa
ț
a
ICommand
.
public class RegisterCommand : ICommand
{
private RegisterVM viewModel;
public event EventHandler CanExecuteChanged;
public RegisterCommand(RegisterVM viewModel)
{
this.viewModel = viewModel;
}
Pentru
ca
serviciile
Azure
sa
fie
func
ț
ionale
în
ambele
proiecte,
trebuie
ini
ț
ializate
atat
pe
Android
în
MainActivity
cât
ș
i pe
iOS
în
AppDelegate
prin:
CurrentPlatform.Init();
Un
user
va fi modelat după proprietă
ț
ile sale din clasa
Users
, care se afla în folderul
Models
. Acesta va avea un Id atribuit de baza de date
ș
i un username
ș
i o parola alese de el.
Clasa
Users
reprezintă de asemenea modelul după care este structurat tabelul
User
pe care l-am
creat în baza de date
Azure
, avand Id-ul ca
ș
i cheie primara a tabelului, generata automat. După
ce informa
ț
iile sunt introd use în câmpurile din pagina de înregistrare
ș
i validate cu succes, la
apăsarea butonului din pagina, se va crea un nou utilizator cu acele caracteristici, el fiind totodată
ș
i inserat în baza de date. A se vedea
Anexa 5
pentru codul de validare a datelor
ș
i inserarea lor
în baza de date din
Azure
.
62
View-Model-ul
va face înregistrarea noului utilizator, arată pe ecran o alertă ca
înregistrarea a reu
ș
it, apo i navighează utilizatorul către pagina de autentificare:
public async Task Register(Users user)
{
var allUsers = await App.MobileService.GetTable<Users>().Select(x
=> x.Email).ToListAsync();
var ok = await Users.Register(user, allUsers);
if (ok == true )
{
await App.Current.MainPage.DisplayAlert("Register
successfully!", "Please login.", "Ok");
await App.Current.MainPage.Navigation.PushAsync(new
MainPage());
}
}
Prin urmare, am introdus cu succes dintr-o aplica
ț
ie
Xamarin
într-un serviciu de baze de
date
SQL
folosind un serviciu de aplica
ț
ii web cu acest cod de
backend
ca intermediar.
63
3.3 Pagina de istoric
Fig. 3.4 – Pagina de istoric a postărilor
Dacă
numele
de
utilizator
ș
i
parola
au
fost
corect
introduse,
utilizatorul
este
considerat
autentificat,
iar
aplica
ț
ia
navighează
către
următoarea
pagină,
care
este
Home
Page
.
Aceasta
este
de
tipul
Tabbed
page
,
con
ț
inând
de
fapt
trei
alte
pagini,
prima
fiind
pagina
de
istoric,
urmată
de
pagina
cu
harta
ș
i
pagina
de
profil,
plus
un
element
în
bara
de
instrumente,
care
navighează
spre
pagina unde se poate introduce o nouă experien
ț
ă [
30
] :
<TabbedPage.ToolbarItems>
<ToolbarItem Text="Add"
64
IconImageSource="add.png"
Command="{Binding NavCommand}"/>
</TabbedPage.ToolbarItems>
<local:HistoryPage Title="History"
IconImageSource="home.png"/>
<local:MapPage Title="Map"
IconImageSource="map.png"/>
<local:ProfilePage Title="Profile"
IconImageSource="user.png"/>
Introduc
postări
în
serviciul
mobil
pe
care
l-am
creat
în
Azure
,
ele
avand
deja
un
userId
care
va
identifica
fiecare
postare
făcută
de
către
utilizatorul
curent.
Deci,
când
citesc
din
tabelul
Post
care
se
află
tot
în
serviciul
mobil
Azure
,
pot
filtra
după
utilizator.
Filtrez
după
userId
unde
userId
din baza de date
este egal cu
userId-ul
utilizatorului curent:
await App.MobileService.GetTable<Users>().Where(u => u.Email ==
email).ToListAsync()).FirstOrDefault();
Deoarece
acum
toate
informa
ț
iile
sunt
în
cloud,
acestea
sunt
accesibile
de
pe
orice
dispozitiv.
Elementele
afi
ș
ate
în
pagina
de
istoric
vor
avea
structura
dată
de
‘DataTemplate’
,
iar
elementele
acesteia
vor
fie
legate
prin
cuvântul
cheie
‘Binding’
,
de
proprietă
ț
ile
specificate
ale
obiectului din clasa
Post
:
<ListView.ItemTemplate>
<DataTemplate>
<ViewCell>
<StackLayout >
<Label Text = "{Binding Experience}"
Postarile
sunt
ordonate
descendent
în
lista
după
data
creării
ș
i
am
folosit
de
asemenea
interfa
ț
a
IValueCnverter
care
a
adaptat
ș
i
a
modelat
formatul
datelor
din
view
pentru
a
fi
afi
ș
ate
facil
ș
i
fără
probleme
pentru
utilizator.
Motivul
principal
pentru
care
am
utilizat
această
interfa
ț
ă
este
tocmai
faptul
că
modelul
nu
va
avea
întotdeauna
date,
deoarece
view-ul
are
nevoie
de
ele.
A
ș
adar,
punerea
în
aplica re
a
acestei
interfe
ț
e
va
face
această
schimbare
posibilă
de
la
model
la
view
,
sau
invers,
direct
din
XAML
.
Modul
în
care
func
ț
ionează
este
că
se
implementează
această
interfa
ț
ă
într-o
singură
clasă,
după
care
sunt
crea
ț
i
doi
membri.
Metoda
‘Convert’
care
să
65
adapteze
modelul
la
ceea
ce
are
nevoie
view-ul
ș
i,
desigur,
metoda
pentru
a
converti
înapoi,
care
va face opusul.
Clasa
pe
care
am
creat-o
are
o
proprietate
care
este
de
tip
‘DateTime’
ș
i
o
afi
ș
ez
cu
anul,
luna,
ziua,
până
la
“T”,
care
reprezinta
timpul.
Însă,
afi
ș
area
timpului
în
aceasta
forma
nu
este
exact
ceea
ce
are
nevoie
un
utilizator.
În
lista
mea
de
postări
nu
doresc
să
am
mereu
acela
ș
i
format
pentru
timp.
Dacă
a
trecut
mai
pu
ț
in
de
o
oră,
pentru
acea
postare
afi
ș
ez
numărul
de
minute,
dacă
au
trecut
mai
pu
ț
in
de
24
de
ore,
afi
ș
ez
numărul
de
ore,
dacă
a
fost
acum
câteva
zile,
atunci
afi
ș
ez
data
la
care
s-a
făcut
postarea.
Deci
formatul
datei
nu
va
fi
întotdeauna
acela
ș
i,
ci
va
varia.
Folosind
interfa
ț
a
IValueCnverter
,
am
adaptat
modelul
pentru
a
fi
afi
ș
at
în
modul
în
care privitorul are nevoie de el:
public class DateTimeToStringConverter: IValueConverter
{
public
object
Convert(object
value,
Type
targetType,
object
parameter, CultureInfo culture)
{
DateTimeOffset dateTime = (DateTimeOffset)value;
DateTimeOffset rightNow = DateTimeOffset.Now;
var difference = rightNow – dateTime;
if (difference.TotalDays > 1)
return $"{dateTime:d}";
else
{
if (difference.TotalSeconds < 60)
return $"{difference.TotalSeconds:0} seconds ago";
if (difference.TotalMinutes < 60)
return $"{difference.TotalMinutes:0} minutes ago";
if (difference.TotalHours < 60)
return $"{difference.TotalHours:0} hours ago";
return "Yesterday";
}
}
public
object
ConvertBack(object
value,
Type
targetType,
object
parameter, CultureInfo culture)
{
return DateTimeOffset.Now;
}
}
66
3.4 Pagina de detalii
Fig. 3.5 – Pagina cu detalii despre postare
67
Din
pagina
de
istoric
la
apasarea
pe
unul
din
elementele
listei
cu
postări,
se
poate
naviga
către
o
pagină
cu
detalii
ale
postarii
respective.
Pentru
a
face
posibil
acest
lucru,
am
avut
nevoie
de
două
lucruri.
Primul
a
fost
să
ș
tiu
când
unul
dintre
acele
elemente
este
selectat
ș
i
al
doilea,
să
ș
tiu
care
dintre
toate
ele
a
fost
selectat.
După
ce
am
aflat
care
element
a
fost
selectat,
am
realizat
navigarea pe pagina de detalii pentru a actualiza sau
ș
terge postarea respectiva.
Este
în
pagina
de
istoric
unde
am
aceste
lucruri
într-un
‘ListView’
,
de
unde
ș
tiu
când
este
selectat
un
articol,
deoarece
folosesc
instrumentul
de
gestionare
a
evenimentelor
‘ItemSelected’
.
A
ș
a
că
am
creat
pur
ș
i
simplu
un
gestionar
de
evenimente
pentru
când
este
selectat
un
element
ș
i
pot
ob
ț
ine
postarea
selec tată
prin
intermediul
unei
proprietă
ț
i
a
‘ListView’
.
După
ce
postarea
a
fost
selectata,
utilizatorul
este
navigat
spre
pagina
cu
detaliile
postarii,
conform
metodei
redate
mai jos:
private void postListView_ItemSelected(object sender,
SelectedItemChangedEventArgs e)
{
var selectedPost = postListView.SelectedItem as Post;
if (selectedPost != null)
{
Navigation.PushAsync(new
PostDetailPage(selectedPost));
}
}
Informa
ț
iile
regăs ite
în
pagina
cu
detaliile
despre
postarea
selectată
vor
fi:
experien
ț
a
pe
care
utilizatorul
a
introdus-o,
împreună
cu
numele
loca
ț
iei,
categoria
acesteia,
ora
ș
ul,
adresa,
latitudinea
ș
i longitudinea , informa
ț
iile fiind redate din baza de da te din
cloud
:
public PostDetailPage(Post selectedPost)
{
InitializeComponent();
this.selectedPost = selectedPost;
experienceEntry.Text = selectedPost.Experience;
venueLabel.Text = selectedPost.VenueName;
categoryLabel.Text = selectedPost.CategoryName;
cityLabel.Text = selectedPost.City;
addressLabel.Text = selectedPost.Address;
68
coordinatesLabel.Text = $"{selectedPost.Latitude},
{selectedPost.Longitude}"; }
Func
ț
ie de actualizare:
Func
ț
ia
schimba
con
ț
inutul
vechi
postări
cu
ceea
ce
utilizatorul
tocmai
a
introdus,
actualizând
astfel
tabelul
Post
din
Azure
,
iar
dacă
opera
ț
ia
a
fost
finalizată
cu
succes
se
va
arăta
pe ecran o alertă cu un mesaj:
private async void updateButton_Clicked(object sender, EventArgs e)
{
selectedPost.Experience = experienceEntry.Text;
await
App.MobileService.GetTable<Post>().UpdateAsync(selectedPost);
await DisplayAlert("Success", "Experience updated!", "OK");
}
Func
ț
ie de
ș
tergere:
Func
ț
ia
ș
terge
din
baza
de
date
Azure
postarea
care
a
fost
selectată,
iar
când
opera
ț
ia
a
fost corect finalizată, utilizatorul prime
ș
te pe ecran o alertă care anun
ț
ă acest lucru:
private async void deleteButton_Clicked(object sender, EventArgs e)
{
await
App.MobileService.GetTable<Post>().DeleteAsync(selectedPost);
await DisplayAlert("Success", "Experience deleted!", "OK");
}
Postările
ș
terse
pot
fi
recuperate
din
Azure
de
către
administratorul
bazei
de
date
deoarece
acestea
nu
sunt
ș
terse
cu
adevărat
din
cloud
,
ci
doar
coloana
cu
statusul
acestora
este
marcată
ca
având
proprietatea
‘Delete
=
true’
.
Această
proprietate
este
extrem
de
utilă
pentru
a
repara accidentele sau gre
ș
elile ce pot apărea în timpul utilizării aplica
ț
iei.
Listele
din
aplica
ț
ia
mea
sunt
la
curent
cu
modificările,
inser
ț
iile
ș
i
ș
tergerile
deoarece
utilizeaza
interfata
ObservableCollection<T>
.
Deci,
de
fiecare
dată
când
adaug
elemente
noi
la
o
listă,
lista
va
ș
ti
că
s-a
produs
o
modificare
ș
i
va
declan
ș
a
evenimente
care,
în
cele
din
urmă,
vor
ajuta la actualizarea
view-ului
. La fel
ș
i când elementele sunt
ș
terse din această listă.
69
Principiul
de
func
ț
ionare
al
ObservableCollection<T>
este
următorul:
orice
clasă
poate
mo
ș
teni
de
la
Observab leCollection<T>,
deci
am
definit
acum
ce
aveam
în
mod
normal
ca
‘ListView’,
drept
ObservableCollection
.
Acesta
fiind
un
tip
generic,
poate
fi
de
orice
tip
de
colec
ț
ie
de
orice
tip
de
obiecte.
ObservableCollection<T>
implementează
deja
INotifyCollectionChanged
,
care
va
fi
foarte
asemănător
cu
INotifyPropertyChanged
,
cu
excep
ț
ia
faptului
că
de
data
aceasta,
rulează
evenimente
de
fiecare
dată
când
ceva
dintr-o
colec
ț
ie
se
schimbă, de exemplu, adăugând noi elemente sau
ș
tergând elemente.
Deci,
de
fiecare
dată
când
adaug
sau
ș
terg
din
această
listă,
nu
trebuie
să
schimb
din
nou
sursa
articolului,
ci
doar
să
setez
ObservableCollection
,
el
ocupandu-se
apoi
de
modificările
aduse
interfe
ț
ei
pentru
utilizator.
Exemplu
de
cod
din
view-model-ul
paginii
de
istoric,
care
reac
ț
ionează la
ș
tergerea sau adaugarea în lista de postari:
public class HistoryVM
{ internal object update;
public ObservableCollection<Post> Posts { get; set; }
public HistoryVM()
{ Posts = new ObservableCollection<Post>(); }
public async Task<bool> UpdatePosts()
{
try
{
var posts = await Post.Read();
if (posts != null)
{
Posts.Clear();
foreach (var post in posts)
Posts.Add(post);
}
return true;
}
catch (Exception) { return false; }
}
public async void DeletePost(Post postToDelete)
{
await Post.Delete(postToDelete);
}
}
70
3.5 Pagina cu harta
Fig. 3.6 – Pagina cu harta
ș
i pinii din loca
ț
iile cu postări
Atât proiectul
Android
cât
ș
i cel
iOS
pot accesa harta
Google
prin utilizarea pachetului
NuGet
numit
Xamarin Forms Maps,
care este instalat în toate cele trei proiecte. Odată instalat,
pachetul se va pozi
ț
iona î n folderul
References
.
Pentru proiectul
iOS
, in
AppDelegate.cs
se găse
ș
te un apel la metoda necesară pentru ca
proiectul să
ș
tie că va fi in i
ț
ializat prin
Xamarin Forms.
Această m etodă va pregăti întreaga
aplica
ț
ie
ș
i trebuie, de asemenea, imediat după această linie, să ap elez la o altă metodă dintr-o
altă clasă care va pregăti aplica
ț
ia pentru a ini
ț
ializa hăr
ț
i cu
Xamarin Forms Maps:
71
global::Xamarin.Forms.Forms.Init();
Xamarin.FormsMaps.Init();
Pentru ca aplica
ț
ia sa aibă acces
ș
i sa afi
ș
eze loca
ț
ia utilizatorului, pe care o voi folosi
ulterior, a trebuit să modific pu
ț
in fi
ș
ierul care se nume
ș
te
Info.plist,
care reprezintă lista de
proprietă
ț
i. A trebuit să d efinesc de asemenea proprietă
ț
i noi pentru accesarea loca
ț
iei
dispozitivului, permisiuni
ș
i alerte noi pentru utilizator.
Pentru proiectul
Android
lucrurile vor sta similar. În
MainActivity.cs
am introdus sintaxa
pentru
Xamarin Forms:
global::Xamarin.Forms.Forms.SetFlags("FastRenderers_Experimental");
global::Xamarin.Forms.Forms.Init(this, bundle);
Xamarin.FormsMaps.Init(this, bundle);
CurrentPlatform.Init();
În
Android
manifest
am
pus
permisiuni
similare
ca
în
Info.plist.
O
diferen
ț
ă
între
proiecte
o
reprezintă
faptul
că
pentru
a
putea
folosi
Google
Maps
,
proiectul
Android
are
nevoie
de
un
Google API Key:
<meta-data android:name="com.google.android.maps.v2.API_KEY"
android:value="AIzaSyCuKL97IMLC8ePBL0I4tUZ3WjMmfSMBmRo"/>
Pentru a ob
ț
ine ch eia
API
de la
Google
, se folose
ș
te
Goog le Developers Console
, unde se
creeaza un proiect nou
ș
i se permite accesul pentru
API-ul Google Static Map
. Pentru fiecare
solicitare trimisă
API-ului Google Maps,
trebuie ata
ș
ată cheia
API
generată. Fără acest
API
, harta
nu ar fi putut fi folosită
ș
i ar fi arătat doar un ecran gri. Însă cu această cheie
API
, voi putea
accesa hăr
ț
ile
Android
care vor intra în utilizarea hăr
ț
ilor
Google
.
Pentru a putea folosi o hartă, este necesar să definesc un spa
ț
iu de nume în pagina de
vizualizare .xaml, pentru apelarea
Xamarin.Forms.Maps
. În locul bazei de con
ț
inut, va trebui să
accesez acel spa
ț
iu de num e, iar în interiorul lui se afla defini
ț
ia hăr
ț
ii:
xmlns:maps="clr-namespace:Xamarin.Forms.Maps;assembly=Xamarin.Forms.Maps"
72
Xamarin Forms Map
îmi permite interac
ț
iunea cu controlul hăr
ț
ii
Google
într-un mod
foarte simplu. Aceasta este redata ca fiind nativă în întregime pe
Android
ș
i
iOS
, printr-o
defini
ț
ie de hartă partajat ă în
XAML
, acolo unde va fi ini
ț
ializată pagina cu harta.
Pe
Android
am nevoie de permisiuni definite în codul aplica
ț
iei, deoarece sistemul de
operare nu solicită de la sine utilizatorului să permită sau să refuze accesul la loca
ț
ie, ceea ce se
întâmplă automat în
iOS
. A
ș
adar, am adaugat ni
ș
te cod supliment ar pentru ca aplica
ț
ia să
func
ț
ioneze pe
Android
. În pagina
.xaml.cs
am creat câteva func
ț
ii pentru accesarea loca
ț
iei pe
Android
:
●
GetPermissions
() , care verifică dacă permisiunea pentru accesarea loca
ț
iei a fost oferită,
iar dacă nu, arată o alertă care cere utilizatorului să o accepte
( A se vedea codul din
Anexa 3
.)
●
GetLocation
(), preia loca
ț
ia utilizatorului
ș
i îl pozi
ț
ionează pe acesta pe hartă
●
MoveMap(Position position),
schimba pozi
ț
ia hartii cand loca
ț
ia este schimbată, pentru
ca utilizatorul să poată vedea ce este în jurul lui
Cu ajutorul acestor metode, văd că loca
ț
ia curentă este afi
ș
ată imediat. Nu a fost nevoie
să măresc harta ca să mă apropii de loca
ț
ia mea. Aceste schimbări se întâmplă imediat de fiecare
dată schimb loca
ț
ia pe ha rtă. În pachetele
NuGet
am adăugat de asemenea
plugin-uri
care vor
facilita utilizarea permisiunilor
ș
i aloca
ț
iei
Android
.
Pluginul
‘Geolocator’
este cel care îmi va permite să ob
ț
in loca
ț
ia pentru utilizator, nu
doar prin setarea
„IsShowingUser”
al hăr
ț
ii pe adevărat, voi putea de fapt să ob
ț
in coordonatele
utilizatorului. Pot să ob
ț
in loca
ț
ia imediat după ce
ș
tiu că aceasta a fost acordată. Deoarece harta
solicită acum loca
ț
ia, voi putea vedea solicitarea ei printr-o alerta pe ecran. Deci sistemul de
operare va
ș
ti că utilizato rul ar trebui să permită sau să refuze aplica
ț
iei accesul la loca
ț
ia sa
ș
i să
afi
ș
eze alerta la solicităril e utilizatorului pentru a permite accesul la loca
ț
ie în timp ce aplica
ț
ia
este utilizată, func
ț
ia care face acest lucru regasindu-se în
Anexa 3
.
73
Dacă loca
ț
ia ini
ț
ială nu este setată simulatorul va afi
ș
a loca
ț
ia
default
oferită de Google.
Pot schimba întotdeauna acest lucru din fereastra de loca
ț
ie a simulatorului, definind o loca
ț
ie
personalizată, ca în exemplul din
Anexa 4
.
3.6 Pagina de profil
Fig. 3.7 – Pagina de profil
Clasa
Posts.cs
con
ț
ine
elementele
pe
care
le
va
avea
o
postare
făcută
de
utilizator,
respectiv:
id-ul
postarii,
experinta
introdusă,
numele
loca
ț
iei,
adresa
loca
ț
iei,
latitudine,
longitudine,
etc.
O
parte
din
aceste
detalii
se
vor
regăsi
în
paginile
aplica
ț
iei,
iar
altele
sunt
folosite
doar
în
interiorul
bazei
de
date
ca
ș
i
coloane
ale
tabelului
Post
.
Tot
în
această
clasă
se
creează
ș
i
numărul
tipuri lor
de
loca
ț
ii
în
care
utilizatorul
face
postări,
aceste
numere
fiind
afi
ș
ate
în pagina de profil prin metoda:
categoriesCount.Add(category, count);
74
La
fiecare
accesare
a
paginii
de
profil
se
apelează
metoda
Read()
care
cite
ș
te
datele
introduse de utilizatorul curent din baza de date
Azure
folosind o expresie lambda:
Where(p => p.UserId == App.user.Id)
Este
folosită
apoi
metoda
PostCategories()
,
care
ob
ț
ine
categoriile
ș
i
numărul
postarilor
facute sub ea, pe care le leagă de pagina .
xaml
care este vizibilă utilizatorului:
var postTable = await Post.Read();
var categoriesCount = Post.PostCategories(postTable);
categoriesListView.ItemsSource = categoriesCount;
postCountLabel.Text = postTable.Count.ToString();
După
ce
ob
ț
in
informa
ț
ii
de
tabelul
Post
care
se
află
în
baza
de
date
Azure
,
le
afi
ș
ez
în
această
pagină.
Am
adăugat
o
listă
derulabilă
care
con
ț
ine
atât
numele
unei
categorii,
cât
ș
i
numărul
de
postări
pe
care
acea
categorie
le
are
în
baza
de
date.
Prin
categorii
mă
refer
la
categoria
elementului
la
care
a
fost
adăugată
experiența,
ea
fiind
de
exemplu
restaurant,
bar,
muzeu,
etc.,
informa
ț
iile
fiind
prezentate
printr-un
‘ListView’
.
Deci
dacă
a
ș
adăuga
o
nouă
postare,
as
salva-o,
iar
dacă
are
succes
ș
i
mă
duc
înapoi
pe
pagina
de
profil,
pot
vedea
cum,
deoarece
fac
toată
func
ț
ionalitatea
paginii
de
profil,
pe
metoda
‘Onappearing’
care
se
executa
la
fiecare
accesare
a
paginii
,
văd
că
coloana
a
crescut
numărul
de
total
de
postări
făcute.
Prin
urmare, ob
ț
in cantitatea d e elemente care există în interiorul tabelului
Post
în orice moment.
Primul
lucru
pe
care
l-am
făcut,
a
fost
să
ob
ț
in
toate
categoriile
care
au
fost
inserate
folosind
LINQ
.
LINQ
are
unele
metode
de
extensie
definite
exact
pentru
acest
tip
de
interogare
de
tabel.
Fiind
un
limbaj
integrat
LINQ
,
poate
folosi
C#
pentru
a
face
o
interogare
similară
cu
cea
a
unui
limbaj
pentru
baze
de
date.
Acum,
ceea
ce
fac
este
sa
preiau
fiecare
dintre
elementele
din
interiorul
tabelului
Post,
fiecare
dintre
ele
va
fi
accesat
prin
„p”,
care
este
de
tip
Post
.
Deoarece
tabelul
Post
este
o
listă
de
postări,
aleg
sa
ordonez
lista
după
CategoryID
,
ea
fiind
astfel
mai
u
ș
or
de
vizual izat
ș
i
în
ț
eles
pentru
utilizator
decat
dacă
as
fi
ales
sa
o
ordonez
după
numele
categoriilor.
Deoarece
există
mai
multe
posturi
pentru
o
singură
categorie,
a
trebuit
să
75
disting
fiecare
dintre
categorii
astfel
încât
sa
existe
elemente
unice
în
interiorul
listei,
iar
ca
sa
nu
vad valorile duplicate, am folosit o altă metodă
LINQ
care este
Distinct
():
var categories = (from p in posts
orderby p.CategoryId
select p.CategoryName).Distinct().ToList();
Am
ob
ț
inut
apoi
cantitatea
de
postări
pe
fiecare
categorie
folosind
LINQ
ș
i
un
dic
ț
ionar.
Am
ales
un
dic
ț
ionar,
deoarece
vreau
ca
cheia
să
fie
numele
categoriei
ș
i
valoarea
să
fie
cantitatea
de
postări
pe
care
o
are
această
categorie
în
tabelul
Post
.
Interogarea
se
va
executa
o
dată
pentru
fiecare
element
din
lista
de
categorii
ș
i
va
filtra
ș
i
număra
postările
după
categoria
lor.
Cu
acest
lucru,
iterez
toate
elementele
din
lista
de
categorii,
ob
ț
in
valoarea
pentru
articolul
corespunzător
de
la
fiecare
pas,
iar
pentru
acel
articol
ob
ț
ine
toate
postările
care
au
ca
nume
de
categorie,
categoria
de
la
pasul
curent.
Ob
ț
in
astfel
numărul
de
elemente
ș
i
îl
adaug,
împreună
cu
categoria sa, într-un dic
ț
ionar:
Dictionary<string,int> categoriesCount =new Dictionary<string,
int>();
foreach (var category in categories)
{ var count = (from post in posts
where post.CategoryName == category
select post).ToList().Count;
Console.WriteLine(count);
try
{ categoriesCount.Add(category, count); }
catch (Exception) { }
}
return categoriesCount;
Având
dic
ț
ionaru l,
îl
pot
atribui
de
fapt
ca
sursă
de
element
pentru
vizualizarea
de
tip
listă
derulabila
pe
care
am
definit-o
deja
în
fi
ș
ierul
.
xaml
din
pagina
de
profil,
care
con
ț
ine
categoriile.
76
3.7 Pagina pentru noua experien
ț
ă
Fig. 3.8 – Pagina de adăugare a noilor experien
ț
e cu alertele afi
ș
ate
77
În proiectul meu, folderul
Helpers
con
ț
ine fi
ș
ierul
Consta nts.cs
, care păstrează informa
ț
ii
care nu se vor modifica niciodată. Variabila
VENUE_SEARCH
contine
URL-ul
aplica
ț
iei mele
Foursquare
. În folderul
Model
, fi
ș
ierul
Venue.cs
este modelul pentru structura unei loca
ț
ii, iar în
el am creat metoda
GenerateURL
care va con
ț
ine păr
ț
i care vor fi adaugate
URL-ului
aplica
ț
iei
Foursquare
, care îmi este necesar pentru a începe să fac cereri către unul dintre punctele finale
ale
Foursquare
, respectiv cel cu loca
ț
ii:
public static string GenerateURL(double latitude, double
longitude)
{
return string.Format(Constants.VENUE_SEARCH, latitude,
longitude, Constants.CLIENT_ID, Constants.CLIENT_SECRET,
DateTime.Now.ToString("yyyyMMdd"));
}
Trebuie să fac solicitarea cu acest
URL
, astfel încât să primesc răspunsul de la
API-ul
Foursquare
. Pentru asta, folosesc o referin
ț
ă către pachetul
NuGet, Microsoft.Net.Http,
care va
permite aplica
ț
iei mele sa facă solicitări către internet. Un alt pachet pe care trebuie sa îl adaug
este
Newtonsoft.Json
, care va citi prin deserializare
JSON-ul
ce contine lista cu loca
ț
iile, care a
fost generat ca răspuns la solicitarea făcută către
Foursquare
,
ș
i îl va converti în obiecte
.NET
pe
care aplica
ț
ia mea le voi p utea citi sub forma de
String
.
Pentru
a
putea
converti
Stringul
rezultat
în
obiecte
C#,
am
folosit
un
instrument
online,
numit
JSONUtils.com.
Codul
rezultat
se
regăse
ș
te
în
fi
ș
ierul
Venue.cs
.
Acum
am
ob
ț
inut
obiectele
C#,
tipurile
C#
care
vor
reprezenta
JSON-ul
ș
i
după
forma
cărora
doresc
să
deserializez
respectivul
JSON
.
Folosesc
această
clasă
ș
i
proprietă
ț
ile
sale
pentru
a
crea
tabelul
Post
din
baza
de date
Azure
.
Fi
ș
ierul
Venue.cs
con
ț
ine
de
asemenea
metoda
‘GetV enues’
,
care
va
folosi
URL-ul
aplica
ț
iei
Foursquare
pentru
a
crea
lista
cu
loca
ț
iile
adiacente
loca
ț
iei
utilizatorului
aplica
ț
iei
mele.
Deci
informa
ț
iile
afi
ș
ate
pe
pagina
pentru
adaugarea
unei
noi
experien
ț
e,
de
către
cererea
făcută
spre
baza
de
date
Foursquare
,
vor
fi
numele
loca
ț
iei,
adresa
ei
ș
i
distan
ț
a
ei
fata
de
utilizator,
afi
ș
ate
sub
form a
unor
câmpuri
ale
unei
liste
derulabile.
Metoda
se
va
apela
de
fiecare
78
dată
când
loca
ț
ia
este
schimbată
ș
i
se
dore
ș
te
deserializarea
ș
i
afi
ș
area
listei
cu
locurile
din
apropierea utilizatorului:
public async static Task<List<Venue>> GetVenues (double latitude, double
longitude)
{ List<Venue> venues = new List<Venue>();
var url = VenueRoot.GenerateURL(latitude, longitude);
using (HttpClient client = new HttpClient())
{ var response = await client.GetAsync(url);
var json = await response.Content.ReadAsStringAsync();
var venueRoot =
JsonConvert.DeserializeObject<VenueRoot>(json);
venues = venueRoot.response.venues as List<Venue>;
}
return venues;
}
}
Dacă
câmpul
în
care
trebuie
introdus
textul
recenziei
este
gol,
atunci
butonul
de
Save
nu
este
activ.
Dacă
nu
a
fost
selectata
o
loca
ț
ie
careia
sa
i
se
atribuie
recenzia,
la
apăsarea
butonului
de
Save
,
pe
ecran
va
apărea
o
alerta
cu
un
mesaj
de
eroare.
De
asemenea,
dacă
introducerea
recenziei în baza de date a fost finalizată cu succes, se va arata pe ecran un mesaj de confirmare.
79
CONCLUZII
Aplica
ț
iile mobil e au devenit o parte a vie
ț
ii noastre de zi cu zi datorită diverselor
func
ț
ionalită
ț
i pe care le oferă. Construirea unei aplica
ț
ii de succes, lipsită de erori
ș
i mai u
ș
or de
utilizat este esen
ț
ială dato rită cre
ș
terii rapide a numărului de aplic a
ț
ii. Ca
ș
i dezvoltator, a trebuit
să iau în considerare provocările cu care se confruntă domeniul aplica
ț
iilor mobile
ș
i să le
depă
ș
esc urmând pa
ș
ii adecva
ț
i. De asemenea, a trebuit să fiu bine documentată în legătură cu
tehnologiile, cerin
ț
ele
ș
i evenimentele actuale din domeniul aplic a
ț
iilor mobile
cross-platform
.
În aceasta lucrare de licenta am dorit sa :
●
Creez
o
aplica
ț
ie
de
mobil
asemănătoare
unui
jurnal
electronic
care
sa
ofere
utilizatorului
acces
facil
la
resursele
ei
de
localizare
ș
i
stocare
a
experien
ț
elor
fără
preluarea
de
date
personale
●
Imi
imbunatatesc
abilită
ț
ile
de
programare,
învă
ț
bune
practici
de
coding
folosite
în
industria
IT
,
sa
utilizez
aplica
ț
ii
software
,
framework-uri
ș
i
limbaje
cat
mai
actuale
de
programare
●
Aprofundez
limbajul
C#
ș
i
sa
învă
ț
cum
este
creata
o
aplicatie
cross-platform
pentru
mobil.
Solu
ț
iile de dezvo ltare
cross-platform
extind ciclul de via
ț
ă al dezvoltării software,
scriind aplica
ț
ia mobilă o dată
ș
i rulând-o pe diferite platforme pe ntru a economisi timpul
ș
i
eforturile dezvoltatorilor. Avand în vedere ca peisajul tehnologic s-a schimbat, iar lumea este din
ce în ce mai mobilă
ș
i mai conectată, următorii pa
ș
i în dezvoltarea aplica
ț
iei ar putea cuprinde:
●
Îmbunătă
ț
irea per forman
ț
ei
●
Încriptarea parolelor
●
Modalitatea de recuperare sau modificare a parolei
●
Utilizarea unui logo personalizat al aplica
ț
iei
●
Crearea
a
mai
multe
pagini
pentru
con
ț
inutul
aplica
ț
iei,
precum
o
pagina
de
galerie
pentru
poze sau adaugarea unor evenimente pentru fiecare loca
ț
ie
●
Împăr
ț
irea postări lor pe categorii sau pe loca
ț
ii
80
●
Adaugarea unei poze de profil sau alte personalizari aduse paginii de profil
●
Adaugarea posibilită
ț
ii ca utilizatorul sa isi aleaga culorile aplica
ț
iei
●
Imbunatatirea performantei aplica
ț
ii pentru mai multi utilizatori (cre
ș
terea bugetului de
dezvoltare)
●
Adaptarea aplica
ț
iei
ș
i pentru alte platforme mobile în afa ră de
Android
ș
i
iOS
●
Corectarea eventualelor erorilor
Una
din
dificultă
ț
ile
de
care
m-am
lovit
în
crearea
aplica
ț
iei
este
legată
de
componentele
folosite
în
dezvoltarea
ei.
Faptul
ca
aplica
ț
ia
nu
va
suporta
un
sistem
de
operare
inferior
celui
pe
care
a
fost
dezvoltat,
acest
lucru
incurcandu-ma
în
momentul
în
care
mediul
de
dezvoltare
Visual
Studio
,
pe
care
l-am
folosit,
a
fost
supus
unor
actualizari
ș
i
simulatorul
pe
care
îl
creasem
ș
i
personalizasem
pentru
dezvoltarea
aplica
ț
iei
pana
la
acel
moment
a
fost
distrus.
Iar
din
cauza
lipsei
de
memorie
pe
laptopul
personal
am
încercat
sa
creez
un
simulator
cu
o
versiune
inferioara
de
Android
,
respectiv
Android
8,
deoarece
necesita
mai
pu
ț
ină
memorie.
Însă,
apoi,
am
observat
ca
aplica
ț
ia
nu
mai
este
func
ț
ională
din
cauza
restului
de
comp onente
folosite,
care
foloseau
ș
i
ele
tot
ultima
versiune,
deci
ar
fi
trebuit
sa
iau
la
rand
fiecare
componeta
folosită
în
proiect
ș
i
sa
o dau cu o versiune mai jos.
Am
intampinat
de
asemenea
probleme
la
conectarea
cu
baza
de
date
din
Azure
,
deoarece
acesta
are
laten
ț
e
care
în
aplica
ț
ia
mea
provocau
time-out-uri,
care
erau
interpretate
ca
excep
ț
ii
sau
erori.
Aceste
probleme
au
fost
remediate
în
timp,
prin
setarea
unor
permisiuni
în
codul
aplica
ț
iei
ș
i a
firewall-ului
din
cloud
.
Aceasta lucrare defineste avantajele
ș
i dezavantajele aplica
ț
iilor
cross-platform
, oferă o
privire de ansamblu asupra domeniului, descrie fiecare tehnologie folosită în realizarea aplica
ț
iei
ș
i dezvolta ideea principa lă a abordării sale. Nu orice aplica
ț
ie poate fi construită cu o solu
ț
ie
cross-platform
. Există multe cazuri în care este mai bine să te bazezi pe dezvoltarea nativă. Cu
toate acestea, merită întotdeauna să ai în vedere dezvoltarea
cross-platform
, deoarece scade
semnificativ timpul
ș
i costul dezvoltării.
81
Bibliografie:
[1] Amit Manchanda:
Business Benefits of Cross-Platform App Development,
https://www.netsolutions.com/insights/cross-platform-app-business-benefits/
Data accesării: 20.02.2020
[2] Andy Zivkovic:
An introduction to NuGet,
https://docs.microsoft.com/en-us/nuget/what-is-nuget
Data accesării: 27.04.2020
[3] Applikey Team:
Xamarin Forms vs Xamarin Native: What Fits You Best?,
https://applikeysolutions.com/blog/xamarin-forms-vs-xamarin-native-what-fits-you-best
Data accesării: 15.03.2020
[4] Barry Luijbregts:
Introduction to Azure App Service – part 1 (The overview),
https://www.azurebarry.com/introduction-to-azure-app-service-part-1/
Data accesării: 21.04.2020
[5] Barry Luijbregts:
.NET Standard Explained: How To Share Code,
Data accesării: 29.04.2020
[6] Barry Luijbregts:
Introduction to Azure App Service – part 3 (Providing a Backend for Your
Mobile Applications with Mobile Apps),
https://www.azurebarry.com/introduction-to-azure-app-service-part-3-the-overview/
Data accesării: 25.04.2020
[7] Craig Kaneshiro:
Advantages and Disadvantages of MacInCloud for Xamarin iOS
Development,
https://www.dragonspears.com/blog/advantages-and-disadvantages-of-macincloud-for-xamarin-i
os-development
Data accesării: 18.05.2020
[8] Digital Tech Akshay:
What Is The iOS Operating System?,
https://medium.com/@digitaltechakshay/what-is-the-ios-operating-system-b19c5d19f5bc
Data accesării: 4.03.2020
[9] Foursquare:
Venue Details
,
https://developer.foursquare.com/docs/api-reference/venues/search
Data accesării: 24.03.2020
[10]
Henning
Heitk¨otter,
Sebastian
Hanschke,
and
Tim
A.
Majchrzak:
Evaluating
Cross-Platform Development Approaches for Mobile Applications,
https://www3.nd.edu/~cpoellab/teaching/cse40814/crossplatform.pdf
Data accesării: 7.03.2020
82
[11] Jarod Ferguson:
The Benefits of Using a Cross-Platform Development Strategy,
Data accesării: 8.03.2020
[12] Jeremy Likness:
Model-View-ViewModel (MVVM) Explained,
https://www.wintellect.com/model-view-viewmodel-mvvm-explained/
Data accesării: 22.04.2020
[13] John Callaham:
The history of Android OS: its name, origin and more,
https://www.androidauthority.com/history-android-os-name-789433/
Data accesării: 12.03.2020
[14] JR Raphael:
Android versions: A living history from 1.0 to 11,
https://www.computerworld.com/article/3235946/android-versions-a-living-history-from-1-0-to-
today.html
Data accesării: 13.03.2020
[15] Justin Johnson:
What is Xamarin?,
https://docs.microsoft.com/en-us/xamarin/get-started/what-is-xamarin
Data accesării: 16.03.2020
[16] Justin Johnson:
What is Xamarin.Forms?,
https://docs.microsoft.com/en-us/xamarin/get-started/what-is-xamarin-forms
Data accesării: 20.03.2020
[17] Kannan:
How to Use NuGet Packages: The Ultimate Guide,
https://www.syncfusion.com/blogs/post/how-to-use-nuget-packages.aspx
Data accesării: 13.04.2020
[18] Kateryna Toniuk:
TOP 15 ANDROID AND IOS APPS FOR TRIP LOGGINGS,
https://www.keepgo.com/blogs/articles/top-10-apps-for-trip-logging
Data accesării: 07.02.2020
[19] Kishore Baktha:
Mobile Application Development: All the Steps and Guidelines for
Successful
Creation of Mobile App:Case Study,
https://ijcsmc.com/docs/papers/September2017/V6I9201704.pdf
Data accesării: 26.02.2020
[20] Laurence Bradford:
WHAT IS SQL? A BEGINNER’S GUIDE TO THE SQL LANGUAGE,
Data accesării: 26.04.2020
[21] Lucidchart:
What is an Entity Relationship Diagram (ERD)?,
https://www.lucidchart.com/pages/er-diagrams#discovery__top
Data accesării: 25.04.2020
[22] MacinCloud:
Frequently Asked Questions,
http://www.macincloud.com/component/content/
Data accesării: 17.05.2020
83
[23] Mahesh Chand:
Difference Between .NET and .NET Core,
https://www.c-sharpcorner.com/article/difference-between-net-framework-and-net-core/
Data accesării: 28.04.2020
[24] Mahesh Chand:
What Is C#,
https://www.c-sharpcorner.com/article/what-is-c-sharp/
Data accesării: 22.03.2020
[25] Margaret Rouse:
Microsoft Azure,
https://searchcloudcomputing.techtarget.com/definition/Windows-Azure
Data accesării: 27.03.2020
[26] Microsoft:
.NET Core Overview,
Data accesării: 29.04.2020
[27] Microsoft:
What is a logical SQL server in Azure SQL Database and Azure Synapse?,
https://docs.microsoft.com/en-us/azure/sql-database/sql-database-servers
Data accesării: 15.04.2020
[28] Microsoft:
What is the Azure SQL Database service?,
https://docs.microsoft.com/en-us/azure/sql-database/sql-database-technical-overview
Data accesării: 11.04.2020
[29] Microsoft:
App Service overview,
https://docs.microsoft.com/en-us/azure/app-service/overview
Data accesării: 26.03.2020
[30] riptutorials:
Xamarin.Forms
,
https://riptutorial.com/Download/xamarin-forms-zh-TW.pdf
Data accesării: 9.04.2020
[31] Szymon Nitecki:
Cross-Platform Mobile Apps Development – Pros and Cons,
https://www.netguru.com/blog/pros-and-cons-of-cross-platform-mobile-app-development
Data accesării: 2.03.2020
[32] Tarun Agarwal:
What Everybody Ought to Know About Android : Introduction, Features &
Applications,
https://www.elprocus.com/what-is-android-introduction-features-applications/
Data accesării: 11.03.2020
[33] Thomas Myer:
Introduction to the Foursquare API,
https://www.ibm.com/developerworks/library/os-foursquare/index.html
Data accesării: 11.04.2020
[34] TutorialsPoint:
WPF – XAML Overview,
https://www.tutorialspoint.com/wpf/wpf_xaml_overview.htm
Data accesării: 6.05.2020
[35] TutorialsPoint:
MVVM – Advantages,
https://www.tutorialspoint.com/mvvm/mvvm_advantages.htm
Data accesării: 3.05.2020
84
[36] TutorialsPoint:
MVVM – Responsibilities,
https://www.tutorialspoint.com/mvvm/mvvm_responsibilities.htm
Data accesării: 3.05.2020
[37] Wafaa S.El-Kassas, Bassem A.Abdullah, Ahmed H.Yousef, Ayman M.Wahba:
Taxonomy
of Cross-Platform Mobile Applications Development Approaches,
https://www.sciencedirect.com/science/article/pii/S2090447915001276
Data accesării: 27.02.2020
[38] Wikipedia:
iOS,
https://en.wikipedia.org/wiki/IOS
Data accesării: 16.02.2020
[39]
Wikipedia:
Microsoft
Visual
Studio,
https://en.wikipedia.org/wiki/Microsoft_Visual_Studio
Data accesării: 12.02.2020
[40] Wikipedia:
C Sharp syntax,
https://en.wikipedia.org/wiki/C_Sharp_syntax
Data accesării: 4.04.2020
85
ANEXE
Anexa 1 –
Codul de backend al aplica
ț
iei mobile din Azure
●
Codul JavaScript pentru backend-ul aplica
ț
iei mobile create în cloud-ul Microsoft Azure:
// Base-level Azure Mobile App SDK.
var express = require('express'),
azureMobileApps = require('azure-mobile-apps');
// Sets up a standard Express App
var app = express();
// A Mobile app, should handle logging, registering middleware, etc.
// Configuration of the Azure Mobile Apps can be done via an object, the
// environment or an auxiliary file.
var mobile = azureMobileApps({
// Explicitly enable the Azure Mobile Apps home page
homePage: true
});
// Import files from the tables directory to configure the ‘/tables’ endpoint
mobile.tables.import('./tables');
// Import the files from the API directory to configure the ‘/api’ endpoint
mobile.api.import('./api');
// Initialize the database before listening for incoming requests
// The tables.initialize() method does the initialization asynchronously
// and returns a Promise.
mobile.tables.initialize()
.then(function () {
app.use(mobile); // Register the Azure Mobile Apps middleware
app.listen(process.env.PORT || 3000); // Listen for requests
});
●
Codul JavaScript pentru backend-ul server-ului aplica
ț
iei mobile din Azure:
// Create an instance of an Express app
var app = require('express')();
// Create an instance of a Mobile App with default settings
var mobileApp = require('azure-mobile-apps')();
// Create a table for 'Post' with default settings
mobileApp.tables.add('Post');
// Create a table for 'Users' with default settings
mobileApp.tables.add('Users');
app.use(mobileApp);
app.listen(process.env.PORT || 3000);
●
Codul JavaScript pentru functionalitatile tabelelor Users
ș
i Post din baza de date a
aplica
ț
iei din Azu re:
var table = module.exports = require('azure-mobile-apps').table();
table.read(function (context) { return context.execute(); });
table.insert(function (context) { return context.execute(); });
table.update(function (context) { return context.execute(); });
table.delete(function (context) { return context.execute(); });
●
Codul din fi
ș
ierele
JSON
ale tabelelor
Users
ș
i
Post
care le leaga func
ț
ionalitatile de
aplica
ț
ia mobilă d in
Azure
:
{ "autoIncrement": false,
"read": {
"access": "anonymous" },
"insert": {
"access": "anonymous" },
"update": {
"access": "anonymous" },
"delete": {
"access": "anonymous" },
"undelete": {
"access": "anonymous" }
}
Anexa 2
– Parte din functionalitatea de autentificare
public static async Task<bool> Login(string email, string password)
{
bool isEmailEmpty = string.IsNullOrEmpty(email);
bool isPasswordEmpty = string.IsNullOrEmpty(password);
if (isEmailEmpty || isPasswordEmpty)
{
return false;
}
else
{
var user = (await
App.MobileService.GetTable<Users>().Where(u => u.Email ==
email).ToListAsync()).FirstOrDefault();
if (user != null)
{
App.user = user;
if (user.Password == password)
return true;
else
return false;
}
else
{ return false; }
}
Anexa 3
– Func
ț
ia GetPermissions()
private async void GetPermissions()
{ try
{
var status = await
CrossPermissions.Current.CheckPermissionStatusAsync<LocationWhenInUse
Permission>();
if (status !=
Plugin.Permissions.Abstractions.PermissionStatus.Granted)
{
if (await
CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(Pe
rmission.LocationWhenInUse))
{ await DisplayAlert("Need location", "We need to
acces your location", "OK");
}
status = await
CrossPermissions.Current.RequestPermissionAsync<LocationWhenInUsePerm
ission>();
}
if (status ==
Plugin.Permissions.Abstractions.PermissionStatus.Granted)
{
locationsMap.IsShowingUser = true;
}
else
{
await DisplayAlert("Location denied", "You didn't
grant permission to acces location. Can't show you on map", "OK");
}
}
catch (Exception ex)
{
await DisplayAlert("Error", ex.Message, "OK");
}
}
Anexa 4
– Poza din cadrul emulatorului Android
Setarea loca
ț
iei din emulatorul Android
Anexa 5 – Logica func
ț
iei Register()
Partea func
ț
iei care se ocu pa cu validarea username-ului
ș
i a parolei:
public static async Task<bool> Register(Users user, List<string> users)
{
bool okUser = true;
bool okPass = true;
bool ok = true;
string validationMessage = "";
string username = user.email;
string pass = user.password;
if (username.Any(char.IsUpper) && username.Any(char.IsDigit)) ;
else
{
validationMessage = "Username must contain an uppercase and a
digit!";
okUser = false;
}
if (okUser && users.Contains(username))
{
validationMessage = "There is already an user with this
username!";
okUser = false;
}
else if (okUser && username.Any(char.IsWhiteSpace))
{
validationMessage = "Username can't contain blank!";
okUser = false;
}
else if (okUser && username.Length < 8)
{
validationMessage = "Username is too short!";
okUser = false;
}
if (okUser == false)
{
await App.Current.MainPage.DisplayAlert("Validation Error!",
validationMessage, "Ok");
ok = okUser;
}
else
{
if (pass.Any(char.IsWhiteSpace))
{
validationMessage = "Password can't contain blank!";
okPass = false;
}
else if (okPass && pass.Length < 8)
{
validationMessage = "Password is too short!";
okPass = false;
}
else if (okPass && pass.Any(char.IsUpper) &&
pass.Any(char.IsDigit)) ;
else
{
validationMessage = "Password must contain an uppercase and
a digit!";
okPass = false;
}
}
if (okPass == false)
{
await App.Current.MainPage.DisplayAlert("Validation Error!",
validationMessage, "Ok");
ok = okPass;
}
else
{
await App.MobileService.GetTable<Users>().InsertAsync(user);
}
return ok;
}
}
}
Copyright Notice
© Licențiada.org respectă drepturile de proprietate intelectuală și așteaptă ca toți utilizatorii să facă același lucru. Dacă consideri că un conținut de pe site încalcă drepturile tale de autor, te rugăm să trimiți o notificare DMCA.
Acest articol: UNIVERSITATEA DIN BUCURE Ș TI FACULTATEA DE MATEMATICĂ Ș I INFORM ATICĂ SPECIALIZAREA CALCULATOARE Ș [606523] (ID: 606523)
Dacă considerați că acest conținut vă încalcă drepturile de autor, vă rugăm să depuneți o cerere pe pagina noastră Copyright Takedown.