Academia de Studii Economice din București

Facultatea de Cibernetică, Statistică și

Informatică Economică

LUCRARE DE LICENȚĂ

APLICAȚIE ANDROID PENTRU ANALIZA DATELOR PRELUATE DE PE PLATFORMA DE SOCIALIZARE

FACEBOOK

BUCUREȘTI

2014
 Cuprins
Introducere ..................................................................................................................................

Context ................................................................................................................................................

Obiectivul şi necesitatea lucrării ...........................................................................................................

Structura lucrării ..................................................................................................................................

Tehnologii folosite .................................................................................................................................

Platforma Android ..................................................................................................................................

Caracteristici Android . ..........................................................................................................................

Arhitectura pe niveluri a sistemului Android .........................................................................................

Elemente componente ...........................................................................................................................

Android SDK ...........................................................................................................................................

Facebook SDK pentru Android ...............................................................................................................

ADT (Android Development Tool) ............................................................................................................

Dezvoltarea aplicaţiei ...........................................................................................................................

Structura aplicației .................................................................................................................................

Persisiența datelor ..................................................................................................................................

Fișiere de resurse ....................................................................................................................................

Crearea aplicației pe platforma Facebook ...............................................................................................

Concluzii ...................................................................................................................................................

Lista tabelelor .........................................................................................................................................

Lista figurilor .........................................................................................................................................

ANEXE ......................................................................................................................................................

Bibliografie .............................................................................................................................................

Introducere
2
 Context

În ultimele decenii, odată cu dezvoltarea tot mai rapidă a tehnologiei, piața a început să se
concentreze tot mai mult în jurul conceptului de smartphone (telefon mobil multimedia multifuncțional,
conectat la o rețea GSM sau UMTS). Este o tendință normală, având în vedere faptul că traficul de date a
devenit tot mai rapid și mai accesibil ca costuri, smartphone-urile oferind aproape toate funcționalitățile
cu care este obișnuit un utilizator de computer (agendă, calendar, navigare GPS, e-mail, browser, editor
de text, minicalculator, aparat foto-video și chiar soft-uri de specialitate precum Adobe Photoshop).
Treptat, mijloacele clasice de comunicare între dispozitivele mobile sunt tot mai puțin utilizate, locul lor
fiind luat de aplicații ce comunică prin Internet. De exemplu, utilizând Facebook Messanger sau Skype
poți vorbi gratuit oriunde în lume consumând foarte puţin din traficul de date disponibil.

Creşterea numărului de smartphone-uri a fost , cu siguranţă , influenţată şi de nevoia oamenilor

de a fi conectaţi în permanenţă la surse de informaţii şi la reţelele de socializare pentru a interacţiona
mai uşor între ei. În aceste condiţii , reţelele de socializare sunt percepute ca un ajutor în procesul de
socializare dintre oameni.

Termenul “smartphone” descrie un dispozitiv mobil , care pe lângă caracteristicile sale de

telefon are şi multe alte caracteristici multimedia. Un smartphone foloseşte un sistem de operare care
suportă instalarea şi ştergerea de pe dispozitiv a aplicaţiilor dezvoltate de programatori.

Primul dispozitiv pentru care s-a folosit acest termen , smartphone , a fost modelul GS88
„Penelope” prezentat de compania Ericsson în anul 1997. După această lansare principalii producători
de telefoane mobile : Nokia , Motorola , Sony Ericsson şi Samsung s-au concentat asupra procucerii de
smartphone-uri. Sistemele de operare Symbian şi RIM de la Nokia respectiv BlackBerry dominau piaţa la
sfârşitul anului 2007.

Odată cu lansarea de către Apple a primei generaţii de telefoane iPhone şi dezvoltarea

sistemului de operare Android de către Google, piaţa smartphone-urilor s-a dezvoltat considerabil iar
marea majoritate a producătorilor s-au orientat spre folosirea sistemului de operare dezvoltat de
Google. După acest an a avut loc ascensiunea dispozitivelor mobile ce au adoptat sistemul de operare
Android precum şi al celor produse de Apple ce rulează iOS. În acest timp, Nokia cu Symbion şi
BlackBerry cu RIM au înregistrat scăderi constante ale cotelor de piaţă. În continuare vom studia
sistemul de operare lider, anume Android.

Tabel 1 : Unități vândute și cote de piață T4 2013

(sursă: http://techcrunch.com/2014/05/06/android-still-growing-market-share-by-winning-first-time-
smartphone-users/ )

T1 2014 (mii) T4 2013 (mii) T1 2013 Cota Cota de Creștere Creștere

(mii) de piață T4 secvențial anuală
piață 2013 ă
T1
2014

3
Android 187.027,721 188.227,483 150.621,7 44% 39% -1% 24%

AOSP 53.749,521 53.919,640 13% 11% 0%

Apple iOS 43.719,00 51.024,482 37.406,8 10% 11% -14% 17%

BlackBerry 550,000 765,000 981,300 0% 1% -28% -44%

10

BlackBerry 750,000 3.516,3 5.426,5 0% 1% -79% -86%

OS

Windows 13.274,030 11.418,218 6.070,800 3% 2% 16% 119%

Phone

Sisteme de 127.593,495 167.338,026 229.408,8 30% 35% -24% -44%

operare de
baza

Altele 545,000 428,637 1.126,6 0% 0% 27% -52%

Total 427.208,766 476.637,786 431.042,5 100% 100% -10% -1%

Primul smartphone pe care a rulat sistemul de operare Android a fost HTC Dream, cunoscut şi
sub numele de T Mobile G1. În februarie 2009, telefonul este lansat pe piaţă cu versiunea 1.5, alias
Cupcake, dar care are câteva lipsuri. Totuşi, comparativ cu prima versiune, 1.0, Cupcake face posibilă
afişarea tastaturii virtuale pe ecran şi personalizarea ecranului de pornire cu widget-uri.
Începând din 2009 Google a lansat constant noi versiuni ale sistemului de operare Android,
înbunătățind de fiecare dată problemele apărute la versiunea precedentă si adaugând noi
funcţionalităţi. Astfel în tabelul 2 sunt prezentate versiunile stemului de operare:

Tabel 2 : Versiuni Android

(sursă : http://ro.wikipedia.org/wiki/Android_(sistem_de_operare )

Versiune Nume de cod Data lansarii

4.4 KitKat TBA

4.1 Jelly Bean 9 iulie 2012

4.0 Ice Cream Sandwich 16 decembrie 2011

3.1 Honeycomb 10 mai 2011

2.3.3 Gingerbread 6 decembrie 2010

2.2 Froyo 20 mai 2010

2.0 Eclair 26 octombrie 2009

1.6 Donut 15 septembrie 2009

1.5 Cupcake 30 aprilie 2009

4
 Sistemul de operare Android beneficiază, de asemenea, de cel mai mare magazin virtual de
aplicaţii, Google Play, care a devansat recent pe cel de la Apple. Acesta oferă posibilitatea dezvoltatorilor
de a adăuaga aplicaţia lor contra unei taxe unice. Pe lângă aplicațile publicate în Google Play se mai
găseşte şi conţinut video, cărţi şi muzică.

Obiectivul şi necesitatea lucrării

Obiectivul propus este acela de a dezvolta o aplicaţie ce va rula pe sistemul de operare Android.
Pentru a realiza această aplicație este necesar să studiem structura sistemului de operare precum și
tehnologiile folosite.

Funcţia principală a aplicaţiei prezentate în cadrul acestei lucrari este aceea de a alcătui un top
al preferinţelor prietenilor selectați ai unui utilizator al reţelei de socializare Facebook. În urma studierii
magazinului virtual Google Play, am constatat lipsa unei astfel de aplicaţii care să prezinte unui utilizator
principalele preferințe ale prietenilor.

Necestiatea poate fi justificată prin numărul mare de utilizatori al acestei reţele de socializare,
dintre care majoritatea folosesc smartphone-uri pentru a o accesa şi prin dorinţa acestora de a vedea
preferințele prietenilor.

Structura lucrării

În cadrul acestei lucrări vor fi abordate toate noţiunile teoretice necesare pentru a îndeplini
obiectivul propus, acela de a construi o aplicație ce va rula pe sistemul de operare Android.

Astfel, în următorul capitol va fi prezentată structura sistemului de operare prezentând fiecare

nivel al acestuia. În cea de-a doua parte vom prezenta tehnologiile puse la dispoziţie de Google ca
mediul de dezvoltare precum şi limbajul de programare. Deoarece aplicaţia foloseşte şi reţeaua de
socializare Facebook, va fi prezentat şi SDK –ul oferit de aceasta dezvoltatorilor. Toate aceste tehnologii
vor fi abordate prin intermediul studierii literaturii de specialitate și a documentației oficiale.

Al treilea capitol va prezenta structura aplicaţiei, procesul de dezvoltare al acesteia şi

modalitatea de implementare a noţiunile prezentate în capitolul anterior.

Ultimul capitol al acestei lucrări prezintă posibile dezvoltări ulterioare ale aceste aplicaţii precum
şi concluziile la care am ajuns în urma dezvoltării.

Tehnologii folosite
În acest capitol vom detalia tehnologiile folosite pentru a dezvolta aplicaţia prezentată.

5
Proiectul a fost realizat folosind tehnologii şi tool-uri open-source. Această alegere a fost făcută
deoarece prezintă următoarele avantaje:

Au în spate comunităţi mari de utilizatori şi dezvoltatori preocupaţi de dezvoltarea continuă a acestor

tehnologii, existând suport din partea acestor comunităţi cum ar fi tutoriale şi acces la diverse resurse
cum ar fi librării specializate

Costul redus de dezvoltare al aplicaţiei, neexistând taxe de licenţiere pentru aceste tehnologii

Aplicaţia este destinată dispozitivelor mobile ce rulează Android şi, prin urmare, aceasta a fost
realizată folosind Android SDK. Deoarece s-a dorit conectarea la reţeaua de socializare Facebook şi
folosirea anumitor date ale utilizatorilor, a fost folosit şi Facebook SDK. Ambele SDK-uri sunt disponibile
pentru a fi descărcate în mod gratuit de pe site-urile oficiale.

Mediul de programare ales este ADT (Android Developer Tools). Acesta este o extensie a mediului de
programare Eclipse IDE, având integrat Android SDK.

Codul sursă a fost scris în limbajul Java.

În continuare vor fi detaliate tehnologiile folosite în realizarea aplicaţiei, precum şi justificarea folosirii
acestora.

Platforma Android
Caracteristici Android

Android este un sistem de operare din familia Unix, bazat pe kernel-ul Linux, cu o interfață
utilizator bazată pe manipulare directă, proiectată în primul rând pentru dispozitive mobile cu ecran
tactil (touchscreen), folosind input-uri de tip atingere.

Un aspect foarte important legat de Android îl constituie faptul că are codul sursă publicat de
către Google sub licențe open-source. Acest lucru a format o comunitate activă de dezvoltatori ce
folosesc codul sursă al proiectului AOSP (Android Open Source Project) pentru a dezvolta și distribui
propriile versiuni modificate ale sistemului de operare. Acestea aduc deseori funcționalități noi și
actualizări pentru dispozitive mai repede decât producătorul oficial sau operatorul de telefonie mobilă,
totuși, fără a garanta funcționarea la parametri optimi. De asemenea, comunitatea oferă suport
continuu pentru dispozitivele mai vechi ce nu mai primesc actualizări oficiale și ajută utilizatorii
neexperimentați să porteze Android pe dispozitive ce oficial rulează alte sisteme de operare. Versiunile
lansate de comunitate sunt de cele mai multe ori pre-rooted și conțin modificări inadecvate pentru
utilizatorii neinițiați în acest domeniu, cum ar fi capacitatea de supraturare sau subturare a procesorului.
CyanogenMod este versiunea comunitară cea mai populară și stă la baza majorității celorlalte.

De-a lungul timpului, producătorii de dispozitive și operatorii de telefonie mobilă au descurajat

orice tentativă de dezvoltare de versiuni paralele a sistemului de operare de către o terță parte.
6
Producătorii își exprimă îngrijorarea cu privire la funcționarea necorespuzătoare a dispozitivelor ce
rulează astfel de versiuni neoficiale și costurile de asistență ce rezultă din acest motiv. Mai mult decât
atât, firmware-urile modificate oferă de multe ori funcționalități precum tethering-ul, pentru care
operatorii ar percepe un tarif suplimentar. De aceea, multe dispozitive au acces restricționat la
permisiunile de root (admin) sau bootloader-ul blocat. Chiar și așa, cum versiunile dezvoltate de
comunitate au devenit tot mai populare iar în S.U.A. a fost dată chiar o lege în acest sens (devenind
legale), producătorii au luat poziții din ce în ce mai puțin radicale, ajungând la ora actuală să sprijine
dezvoltarea lor. Ca urmare a acestui fapt, un număr tot mai mare de dispozitive sunt livrate deblocate,
pentru a scăpa utilizatorul de ocolirea tuturor restricțiilor hardware în cazul în care acesta optează
pentru instalarea unei versiuni neoficiale (totuși, în 90% dintre cazuri, procedând astfel, se pierde
garanția). Deși producătorii au o atitudine tot mai deschisă, mulți operatori de telefonie comandă încă
dispozitive blocate, pentru a se asigura de fidelitatea clienților lor.

Arhitectura pe niveluri a sistemului Android

Sistemul de operare Android este structurat, conform figurii 3, pe mai multe nivele, fiecare nivel
depinzând de funcţionalităţile oferite de nivelul inferior acestuia.

7
 Figură
1 : Arhitectura sistemului Android

(sursă : http://www.cprogramming.com/android/android_getting_started.html)

Nivelul Linux Kernel stă la baza arhitecturii Android şi asigură funcţionalităţi de bază precum
gestionarea proceselor, gestionarea sistemului de fişiere, gestiunea retelistica a dispozitivului şi
driverele. Sistemul de operare Android este derivat din Linux Kernel 2.6 și este de fapt creat de la sursă
Linux, compilate pentru dispozitive mobile. Kernel-ul acționează ca un strat de abstractizare hardware
între hardware și stiva software-ul Android. Librăria standard de C a Android-ului, Bionic, a fost
dezvoltată special de Google, ca o derivare a librăriei BSD. Bionic conține o suită majoră de
funcționalități noi, specifice kernel-ului Linux, aflându-se în prezent într-o continuă dezvoltare
(independent de alte baze de cod sursă Android).

Nivelul Libraries cuprinde un set de librării C/C++ ce stau la baza funcţionării componentelor sistemului
Android. O librărie prezentă în acest nivel este SQLite pe care am folosit-o în cadrul aplicaţiei prezentate
pentru a stoca date persistente.

SQLite este o bibliotecă publică în cadrul căreia se găseşte implementarea unui motor de baze
de date, de sine stătător, care nu necesită server sau alte configuraţii speciale.

Citirea şi scrierea datelor se face direct pe disk, o bază de date completă SQL cu mai multe
tabele, view-uri, indexi şi triggeri fiind stocată sub forma unui singur fişier. Aceste fişiere sunt salvate în
memoria dispozitivului în directorul:
8
DATA/data/NUMELE_APLICAŢIEI/databases/NUMELE_BAZEI_DE_DATE

Formatul fişierelor stocate este cross-platform, facilitând portarea bazelor de date SQLite.

Tipurile de date ce pot fi folosite în SQLite sunt TEXT (echivalentul tipului de date String din
Java), INTEGER (echivalentul tipului de date long din Java) și REAL (echivalentul tipului de date double
din Java) însa nu se face validarea automată a tipurilor de date înainte ca acestea să fie introduse în baza
de date.

Android SDK conţine o serie de clase cu ajutorul cărora poate fi accesat SQLite şi se poate
efectua operaţii asupra bazelor de date. Aceste clase sunt în pachetul android. Database și android.
Database. Sqlite.

Alte librării prezente la acest nivel al arhitecturii sunt:

Surface Manager: Suportă diferite formate și codec-uri audio și video, inclusiv redarea și înregistrarea
lor.

System C Libraries: Un subset al librăriei standard C (libc) special adaptată pentru dispozitive mobile pe
care rulează Linux

OpenGL ES Libraries: Acestea sunt bibliotecile grafice pentru randare grafica 2D și 3D.

Nivelul Android Runtime include un set de librării care au disponibile marea parte a funcţionalităţilor
disponibile pentru limbajul de programare Java. În cadrul acestui nivel fişierele. Class sunt convertite de
sistemul Android în fişiere. Dex (un tip special de bytecode optimizat pentru dispozitive mobile fiind
necesare puţine resurse). Android rulează în mașina virtuală Dalvik; de la versiunea 4.4, este suportată o
nouă mașină virtuală experimentală, ART, care nu este însă activată în mod implicit. Aceasta rulează
fişierele. Dex, fiindu-i alocată câte o maşină virtuală fiecărei aplicaţii.

Nivelul Application Framework oferă dezvoltatorilor un set foarte mare de API-uri pentru ca aceştia să
nu fie nevoiţi să scrie fiecare acţiune întreprinsă de sisiemul de operare atunci când dezvoltă o aplicaţie
Android. Aceste servicii şi mecanisme stau la baza funcţionării tuturor aplicaţiilor. Dintre acestea
amintim:

Activity Manager: gestionează ciclul de viaţă al aplicaţiilor şi poate avea mai multe stări; o aplicaţie
poate avea mai multe activiatati care pot avea ciclul lor de viaţă; există o activitate principală care
porneşte atunci când aplicaţia este lansată; o activitate se încheie atunci când este lansată o altă
activitate

Notification Manager: Acest manager permite aplicațiilor să creeze alerte personalizate

Resource Managers: Aplicații au nevoie de resurse externe, cum ar fi imagini, şiruri de caractere, etc
Toate aceste resurse sunt gestionate de către managerul de resurse, care le face disponibile într-un mod
standardizat.

Content Provider: Aplicații împărtășesc, de asemenea date. Din când în când, o singură cerere poate
avea nevoie de unele date din altă aplicație. Acest acces la date la altă aplicație este activată de către
content provider

Nivelul Applications este ultimul nivel şi este reprezentat de aplicaţiile create de către dezvoltatori şi
care pot fi folosite de utilizatorii finali.

O aplicație constă într-un fișier. Apk (android package) și conține, de obicei, 3 componente:
9
• Fişierul executabil Dalvik – reprezintă codul sursă Java compilat pentru a obține executabilul şi care e
rulat de maşina virtuală Dalvik.

• Resurse – orice nu este cod sursă este o resursă. Aplicația poate să conțină imagini, fișiere
audio/video și numeroase fișiere XML care descriu layout-ul, etc.

• Librării native – Opțional, aplicația poate conţine librării native, C/C++, care sunt incluse în fișierul
Apk.

Aceste aplicaţi sunt formate din componente slab cuplate, legăturile fiind făcute printr-un fişier
manifest.xml. În cadrul acestui fişier sunt prezente metadate despre fiecare componentă şi cum
interacţionează cu altă componentă.

Elemente componente

Pentru a putea trece la detaliile de implementare, trebuie să explicăm mai întâi câteva componente
specifice platformei:

1. Intents & Intent Filters

Un intent este un obiect de mesagerie ce poate fi folosit pentru a solicita o acțiune din altă componentă
a aplicației. Deși intent-urile facilitează comunicarea între componente în diferite moduri, putem separa
trei cazuri de utilizare fundamentale:

Declanșarea unei activități

O activitate reprezintă un singur ecran al aplicației. Puteți începe o nouă instanță a unei activități pasând
un intent ca parametru funcției startActivity (). Acesta descrie activitatea ce urmează să pornească și
conține toate datele necesare.

Dacă doriți să primiți un rezultat în momentul în care activitatea se termină, trebuie să apelați metoda
startActivityForResult (). Activitatea dumneavoastră va primi rezultatul sub forma unui intent separat, în
cadrul callback-ului onActivityResult ().

Declanșarea unui serviciu

Un serviciu este o componentă care efectuează operațiuni în fundal, fără a avea nevoie de o interfață
utilizator. Puteți porni un serviciu pentru a efectua o operațiune o singură dată (cum ar fi descărcarea
unui fișier), pasând un intent metodei startService (). Acesta descrie serviciul ce urmează să pornească și
conține toate datele necesare.

În cazul în care serviciul este proiectat cu o interfață client – server, vă puteți lega la serviciu din altă
componentă a aplicației pasând un intent funcției bindService ().

Transmiterea unui broadcast

Un broadcast reprezintă un mesaj ce poate fi primit de orice aplicație. Sistemul transmite astfel de
mesaje pentru diverse evenimente, cum ar fi atunci când sistemul pornește sau când dispozitivul începe
să se încarce. Utilizatorul poate trimite și el mesaje de tip broadcast către alte aplicații pasând un intent
10
către una din următoarele trei metode: sendBroadcast(), sendOrderedBroadcast(),
sendStickyBroadcast().

Din punct de vedere al specificității, putem de asemenea deosebi două tipuri de intent-uri:

Explicite – specifică numele componentei ce trebuie să pornească (mai exact numele complet al clasei).
Veți folosi de obicei un intent explicit pentru a porni o activitate sau un serviciu din cadrul propriei
aplicații, deoarece cunoașteți numele clasei componentei respective. De exemplu, declanșați o nouă
activitate ca răspuns la o acțiune efectuată de utilizator sau porniți un serviciu pentru a descărca un
fișier în fundal.

Implicite – nu denumesc o componentă specifică însă declară o acțiune generală, ceea ce permite unei
componente din altă aplicație să o efectueze. De exemplu, dacă doriți să arătați utilizatorului o locație
pe hartă, puteți utiliza un intent implicit pentru a solicita ca o altă aplicație capabilă să facă acest lucru.

Atunci când creați un intent explicit pentru a porni o activitate sau un serviciu, sistemul lansează imediat
componenta specificată. În cazul unui intent implicit, sistemul caută cea mai potrivită componentă prin
compararea conținutului acestuia cu filtrele de intenție (intent filters) – declarate în fișierele manifest –
ale altor aplicații instalate pe dispozitiv. Dacă sistemul găsește o singură potrivire, lansează imediat
componenta. Altfel, afișează o fereastră (de tip dialog) prin care utilizatorul poate alege ce aplicație să
fie utilizată.

Figură 2 : Utilizarea intent-urilor

(sursă : http://developer.android.com/guide/components/intents-filters.html )

Schema din Figura 2 ilustrează cum este pasat un intent implicit prin intermediul sistemului pentru a
începe o nouă activitate. Așadar, activitatea A crează un intent ce conține o descriere a acțiunii de
efectuat și îl pasează metodei startActivity (). Sistemul caută în toate aplicațiile un intent filter potrivit
pentru intent-ul primit. Atunci când găsește o potrivire, sistemul pornește acea activitate (în cazul
nostru, activitatea B) prin invocarea metodei onCreate () căreia îi pasează intent-ul.

Un intent filter este o expresie – aflată în fișierul manifest al aplicației – ce specifică tipurile de intent-uri
pe care componenta acceptă să le primească. De exemplu, prin declararea unui intent filter pentru o
11
activitate, devine posibil ca aceasta să fie deschisă de către alte aplicații prin intermediul unui anumit
intent. De asemenea, dacă nu este declarat niciun filtru pentru o activitate, atunci ea poate fi pornită
doar explicit.

Din motive de securitate, este recomandat ca pornirea serviciilor să fie făcută printr-un intent explicit,
fără a declara filtre. Folosind un intent implicit, nu poți fi sigur cine îl va prelua, iar utilizatorul nu poate
vedea ce serviciu pornește.

2. Activity

O activitate este o componentă a aplicației care oferă un ecran cu care utilizatorii pot interacționa în
scopul de a face ceva, cum ar fi să formeze un număr de telefon, să facă o fotografie, să trimită un e-
mail, sau pentru a vizualiza o hartă. Fereastra umple tipic ecran, dar poate fi mai mică decât acesta și
poate sta deasupra altor ferestre.

O aplicație poate conţine una sau mai multe componente de tip Activity în funcție de design, una dintre
acestea fiind marcată ca și activitatea principală a aplicației. Activitate principală va fi lansată în execuţie
la pornirea aplicației.

Pentru a crea o activitate, trebuie să creați o subclasă de Activity. În această subclasă trebuie să
suprascrieti metodele care sunt apelate atunci când activitatea trece dintr-o stare în alta pe parcursul
ciclului de viaţă, ca de exemplu la creare, la oprire, la revenire sau la distrugere. Cele mai importante
metode care trebuie suprascrise sunt:

onCreate (): această metodă trebuie implementată obligatoriu pentru a putea fi apelată când este
creată activitatea.În cadrul acestei metode trebuie iniţializate componentele de bază ale activităţii.

onPause (): sistemul apelează această metodă la primul semn ca utilizatorul a părăsit activitatea curentă.

12
Figură 3 : Ciclul de viață al unui Activity

(sursă : http://developer.android.com/guide/components/activities.html )

13
Figura 3 ilustrează diverse căi pe care le poate lua o activitate între diferite stări ăla acesteia.
Dreptunghiurile reprezintă metodele suprascrise care le puteți implementa pentru a efectua operațiuni
în cazul în care în activitatea respectivă se face tranziția între stări.

O activitate poate exista în una din cele trei stări:

Resumed: Activitatea este în prim-planul ecranului fiind utilizată. (Această stare este uneori menționată
ca „stare activă”.)

Paused: Activitatea nu se află în prim-plan dar este încă vizibilă. Componentele activităţii aflate în
această stare nu interacţionează cu utilizatorul însă sunt ataşate manager-ului de ferestre fiind vizibile
utilizatorului.

Stopped: Activitatea este complet acoperit de o altă activitate (activitatea este acum în "background").
Cu toate acestea, acesta nu mai este vizibil pentru utilizator și poate fi închisă de sistem atunci când este
nevoie de memorie în altă parte.

În cazul în care o activitate este întreruptă sau oprită, sistemul poate scădea din memorie, fie prin
solicitarea ca aceasta să se termine (apelul metodei finish ()), sau pur și simplu închiderea procesului.
Când activitatea este deschisă din nou (după ce a fost terminată sau închisă), acesta trebuie să fie creaţă
peste tot.

3. Fragments

Un fragment reprezintă un comportament sau o porțiune de interfață grafică dintr-o activitate.

Acesta a fost creat şi introdus în cadrul lansării API-ului 11 (sau Android 3.0) pentru a permite unei
interfeţe grafice să fie mai flexibilă deoarece în cazul tabletelor ecranul este mult mai mare decât al unui
telefon mobil. Spre exemplu o aplicaţie poate folosi un obiect de tip Fragment pentru a afişa o listă de
articole în stânga iar în dreapta poate folosi un alt obiect de tip Fragment pentru a afişa detalii despre
obiectul selectat din listă, ambele obiecte Fragment aflându-se în cadrul aceluiaşi obiect Activity.
Exemplul cu aceste 2 obiecte Fragment este ilustrat în figură de mai jos.

Figură 4 : Utilizarea fragmentelor

14
(sursă : http://developer.android.com/guide/components/fragments.html )

Într-o activitate se pot combina mai multe (obiecte de tip) fragmente pentru a construi o
interfaţă grafică, iar un fragment poate fi utilizat în mai multe activităţi. Ciclul de viaţă al unui obiect de
tip Fragment este similar cu cel al unui obiect de tip Activity. Pentru a adăuga un obieect de tip
Fragment la o nouă activitate se poate proceda în două moduri:

Declararea fragmentului în interiorul fișierului de layout al activităţii:

În acest caz se specifică propietatile fragmentului la fel ca pentru un view. De exemplu pentru o
activitate cu două fragmente vom avea:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent" android:layout_height="match_parent">

<fragment class="com.example.android.apis.app.FragmentLayout$TitlesFragment"
android:id="@+id/titles" android:layout_weight="1"
android:layout_width="0px" android:layout_height="match_parent" />

<FrameLayout android:id="@+id/details" android:layout_weight="1"

android:layout_width="0px" android:layout_height="match_parent"
android:background="?android:attr/detailsElementBackground" />

</LinearLayout>

(Sursă exemplu cod : http://developer.android.com/guide/components/fragments.html)

După cum se observă, fiecare fragment trebuie să aibă un identificator unic pentru ca atunci când
activitatea este repornită, sistemul să poată restaura fragmentul.

Adăugarea fragmentului la un obiect ViewGroup existent

În orice moment, în timp ce activitatea se execută, se poate adăuga fragmente la activitate. Trebuie doar
se fie specificat ViewGroup-ul la care se adaugă.

Pentru a putea face diferite acţiuni cu fragmente într-o activitate (adăugare, ştergere sau înlocuire)
trebuie să folosim API-ul FragmentTransaction. O instanţă de FragmentTransaction se poate obţine
astfel:

FragmentManager fragmentManager = getFragmentManager()

FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

(Sursă exemplu cod : http://developer.android.com/guide/components/fragments.html)

Pentru a adăuga un fragment se foloseşte metoda add () specificând fragmentul de adăugat şi view-ul în
care se doreşte adăugarea. Spre exemplu:

15
ExampleFragment fragment = new ExampleFragment();
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();

(Sursă exemplu cod : http://developer.android.com/guide/components/fragments.html)

Se poate adăuga un fragment care să conţină operaţii de background, nu doar componente grafice.
Acest lucru se face tot cu ajutorul metodei add (Fragment, Strâng) oferind însă un strâng de identificare
unic în loc de id-ul view-ului.

4. Services

Un serviciu este o componentă de aplicație care poate efectua operații de funcționalitate în

fundal și nu oferă o interfață cu utilizatorul.

O componentă a unei aplicație poate începe un serviciu și va continua să ruleze în fundal, chiar dacă
utilizatorul trece la altă aplicație.

5. Content Providers

Obiectele de tip Content Providers gestionează accesul la un set structurat de date. Acestea
încapsulează datele şi pune la dispoziţie mecanisme de definire a securităţii datelor. Obiectele Content
Providers sunt interfeţe standard care conectează datele dintr-un proces cu codul care rulează într-un
alt proces. Unele elemente de bază ale sistemului Android conţin componente de tip ContentProvider
pentru a face datele disponibile altor aplicaţii.

Datele puse la dispoziţie de un anumit furnizor sunt accesate folosind un obiect de tip
ContentResolver. Acesta este un obiect client care asigură operaţii de creare, citire, update şi ştergere
asupra datelor din ContentProvider.

Datele gestionate de un obiect de tip ContentProvider pot fi: audio, video, imagini şi fişiere de
baze de date SQLite.

Android SDK

Android SDK reprezintă o colecţie de software şi de tool-uri specifice cu ajutorul cărora se pot dezvolta
aplicaţii pentru sistemul de operare Android. Această colecţie poate fi descărcată separat prin
intermediul SDK Manager-ului.

În continuare sunt prezentate câteva pachete importante:

Tabel 3 : Pachete prezente in SDK Android

(sursă : http://developer.android.com/sdk/exploring.html )

Pachet Descriere Localizare în

16
 cadrul SDK

SDK Tools Cuprinde unelte necesare depanării si testării aplicațiilor <sdk>/tools/

alături de alte utilitare necesare dezvoltării aplicațiilor.

SDK Platform-tools Conține unelte specifice anumitor platforme de Android <sdk>/platform-

necesare proiectării respectiv depanării aplicațiilor specifice tools/
platformei respective.

Documentation O copie offline actualizată a documentației API-urilor <sdk>/docs/

diverselor platforme Android

SDK Platform Există o platforma SDK pentru fiecare versiune de Android <sdk>/platforms/
lansată, care poate fi aleasă ca și platformă țintă pentru <android-
aplicații. version>/

System Images Fiecare platformă oferă una sau mai multe imagini sistem <sdk>/platforms/
pentru procesoarele ARM sau X86.Aceste imagini sistem <android-
sunt necesare emulatorului de Android pentru a putea rula. version>/

Sources for O copie a codului sursă pentru componentele diverselor <sdk>/sources

Android SDK platforme de Android.

Samples for SDK Exemple care ilustrează funcționalitațile diverselor API-uri <sdk>/platforms/
de Android. <android-
version>/samples
/

Google API Pachet special ce permite unei aplicații să apeleze servicile <sdk>/add-ons/
oferite de Google prin intermediul Google API.

Android Support Librarie de suport care poate fi inclusă în aplicații pentru a <sdk>/extras/and
putea oferii acestora funcționalități disponibile unui nivel roid/support/
API superior în cazul în care acestea trebuie să ruleze pe o
versiune de Android mai nouă.

Google Play Billing Librărie statică care permite integrarea unui serviciu de <sdk>/extras/goo
taxare în aplicații. gle/

Google Play Librărie ce oferă funcționalități de verificare a licențelor <sdk>/extras/goo

Licensing pentru aplicații atunci când acestea sunt distribuite prin gle/
intermediul magazinului virtual Google Play.

Facebook SDK pentru Android

Facebook SDK oferă o soluţie simplă şi rapidă pentru a integra uşor platforma de socializare cu aplicaţiile
dezvoltate pentru sistemul de operare Android. Acest SDK oferă suport pentru autentificarea în cadrul

17
aplicaţiei cu datele unui utilizator al platformei de socializare, manipularea obiectelor prezente în API-ul
Facebook precum şi suport pentru componentele interfeţei grafice specifice.

Graph API este principala modalitate de a adăuga şi extrage date din platformă de socializare. Cu
ajutorul acestui API este posibilă interogarea datelor, încărcarea pozelor şi multe alte activităţi necesare
unor aplicaţii ăla acestei platforme.

ADT (Android Development Tool)

ADT este un mediu de dezvoltarte Eclipse care are integrat SDK-ul de Android.

Eclipse este un mediu de dezvoltare software folosit pentru a scrie aplicaţii în Java. Este structurat sub
forma unei ierarhii de plugin-uri care asigură diferite funcţionalităţi.

ADT a fost creat pentru a facilita dezvoltarea aplicaţiilor destinate dispozitivelor care rulaeaza sistemul
de operare Android. Acesta extinde capabilităţile mediului de dezvoltare Eclipse, oferind în plus
posibilitatea de a proiecta interfeţe grafice special

Figură 5 : Mediul de dezvoltare ADT

Tot cu ajutorul acestui tool se poate adăuga noi versiuni de API precum şi crearea unor emulatoare
pentru a putea instala aplicatile create. După cum se observa, din componenta Android SDK Manager se
poate instala versiunea de API dorită pentru a dezvolta aplicaţia.

Figură 6 : SDK Manager

18
Pentru a testa aplicaţia se poate opta fie pentru a utiliza un dispozitiv mobil fie prin a crea un dispozitiv
virtual care simulează toate aproape toate caracteristicile unui dispozitiv mobil.

Dezvoltarea aplicaţiei

În acest capitol vom prezenta structura aplicației , cum funcționează aceasta și elementele folosite
pentru dezvoltarea ei.

Structura aplicației

Interfața aplicației cuprinde 7 ferestre. Când este lansată aplicația se afișază activitatea principala
(MainActivity). Această activitate conține un intent care este folosit pentru a obține date de la aplicația
Facebook utilizate pentru a se putea realiza conexiunea la contul deja autentificat în aplicație. Tot din
această activitate principală se vor putea accesa celelalte ferestre ale aplicației. Astfel se v-a putea
ajunge la fereastra care permite selectarea prietenilor. Dupa selectarea prietenilor pentru care se
dorește să se facă topul preferințelor , o alta fereastra v-a fi afișată ,iar din aceasta se va putea alege
topul care se dorește a fi vizualizat. Pentru fiecare top va fi deschisă alta fereastra în care acesta va fi
afișat. Navigarea în aplicație se va face cu ajutorul butoanelor prezente în fiecare fereastră.

19
Figură 8 Ferestrele aplicației

Figura de mai sus ne prezintă cele 7 activități și posibilitatea de a naviga printre acestea. Pentru
a putea face legătura între cele 7 activități am folosit obiecte de tip Intent. Aceste obiecte conțin
informații pentru a putea conecta două componente ale aplicației. Intent-ul creat conține doi
parametrii : clasa din care este apelat intent-ul respectiv și clasa căruia sistemul ar trebui să transmită
intent-ul.

Intent intent = new Intent(MainActivity.this,select_preferences.class);

Obiectul intent este apelat din clasa MainActivituy și este transmis clasei select_preferences.

O activitate nouă este lansată cu ajutorul comenzii startActivity() care primeste ca parametu un
Intent. Sistemul primește apelul și pornește o instamță a Activity-ului specificat de intent.

În continuare vom prezenta Activity-urile și clasele declarate, evidențiind felul în care acestea se
leagă între ele. Aceasta aplicație folosește anumite obiecte prezente în SDK–ul oferit de Facebook
dezvoltatorilor și vor fi folosite ca atare , precizându-se scurt principalele lor caracteristici.

MainActivity

Această activitate este lansată la prima interacțiune a utilizatorului cu aplicația. Din cadrul
acestei ferestre pot fi accesate celelalte activități ale aplicației , și anume selectarea prietenilor pentru
care se dorește să se alcatuiască topul preferințelor și afișarea acestui top. (informații despre versiunea
curentă a aplicației).
20
 În această fereastră utilizatorul poate efectua doua acțiuni prin intermediul a două butoane.
Prima acțiune accesată prin butonul Pick Friends lansează o nouă activitate care permite selectarea
prietenilor in listă. A doua acțiune disponibila prin butonul Show Top 10 Preferences lansează o nouă
acțiune care la randul ei are mai multe opțiuni de a alege topurile dorite.

MainActivity-ul constituie clasa plincipală a aplicației , aici făcându-se majoritatea operațiilor. În

cadrul acestei clase s-a folosit un obiect Session care are ca scop autentificarea și gestionarea sesiunilor
de conectarea ale unui utilizator la Facebook. O sesiune trebuie sa fie deschisă atunci cand un utilizator
dorește să facă o anumită cerere rețelei de socializare. Pentru a știi în ce moment al cilulului de viață al
aplicației ne aflam , este folosit un obiect SessionState . Odata ce o sesiune a fost închisă , aceasta nu
mai poate fi redeschisă , fiind necesară crearea unui nou obiect Session. Pentru a lucra cu obiectele
Session am folosit clasa UiLifecycleHelper . Această clasa permite crearea , deschiderea automata ,
salvarea si restaurarea sesiunii într-un mod similar ciclului de viață al interfețelor grafice Android.

Figură 9 Folosirea UiLifecycleHelper

Întrucât din această fereastră se face navigarea către alte doua Activity-uri au fost definite doua
butoane cărora li s-a asociat un listener care la apasarea butonului face trecerea la activitatea noua
precizată prin obiectul Intent.

Figură 10 Apelarea altor Activity-uri

21
PickFriendsActivity

Această clasă utilizează FriendPickerFragment pentru a afișa lista de prieteni a utilizatorului. Metoda
populateParameters() este folosita pentru a popula ce dorim sa transmitem obiectului
FriendPickerFragment.

În această clasă în metoda suprascrisă onStart() folosim un obiect FriendPickerApplication care contine o
listă de utilizatori (GraphUser).

Figură 11 Metoda onStart() din PickFriendsActivity

În această metodă se apeleaza loadData() din clasa FriendPickerFragment care la randul ei seteaza lista
lista de prieteni cu obiectele preluate cu ajutorul Graph API

Clasa PickFriendsActivity este apelata în MainActivity prin metoda startPickFriendsActivity(). În cadrul

acestei metode , ne asiguram ca sesiunea este deschisă și astfel putem lansa activitatea pentru selecția
prietenilor. Acest lucru se realizează tot prin folosirea unui Intent.

Figură 12 Figura 3.5 Metoda startPickFriendsActivity() din MainActivity

Select_preferences

Această activitate este apelată tot din MainActivity și cuprinde 5 butoane care permit lansarea unei noi
activitați. Acete butoane sunt :

22
Figură 13 Figura 3.6 Declarearea butoanelor clasei Select_preferences

Această navigare către celelalte ferestre se face tot cu ajutorul unui listener pentru fiecare buton care
transmite obiectul de tip Intent.

Show_top

Aceste 5 activitați conțin un obiect ListView și un obiect UserDataSource care conține informațiile
salvate anterior. Prin parcurgerea obiectelor UserDataSource sunt inserate in ListView valorile
elementelor în funcție de topul la care se referă. Acest lucru este realizat în metoda onCreate() cand
este lansată activitatea.

Figură 14 Figura 3.7 Afisarea în ListView

Persisiența datelor

Pentru a stoca preferințele utilizatorilor selectați s-a folosit SQLite . Aceste preferințe sunt salvate după
ce sunt selectați prietenii din lista cu ajutorul metodei getFriendsLikes() din MainActivity.

23
 În cadrul acestei metode după ce ne asiguram că sesiunea este deschisă , pentru fiecare prieten
din listă este apelat fqlQuery = "SELECT movies,books,music,tv,games FROM user where uid ="+
names.get(i); Acest query este transmis în request împreună cu metoda
parsePagesFromGRAPHResponse();

Figură 15 Metoda parsePagesFromGRAPHResponse()

Aceasta metoda dupa cum se observa foloseste un obiect JSON si un array JSON cu ajutorul carora
parseaza datele obtinute din bundle-ul transmis. Dupa ce se parseaza , datele necesare sunt introduse
intr-un array de String-uri . Dupa un obiect de tipul respectiv este inserat in baza de date cu functia
insert.

MySQLiteHelper

Aceasta clasa este folosita pentru a defini modelul bazei de date . Pentru inceput sunt definite
numele bazei de date precum și versiunea.

private static final String DATABASE_NAME = "facebook_top.db";

private static final int DATABASE_VERSION = 1;

Tabelele bazei de date au fost definite cu doua coloane , respectiv id si nume. Au fost create
tabelele table_movies, table_music, table_books, table_tv si table_games.Pentru a fi create a fost
executate comanda execSQL.

24
Figură 16 Crearea tabelelor din BD

UserDataSource

În aceasta clasa sunt executate operatiile asupara bazei de date . Aceste operatii sunt folosite
atat in MainActivity cat si in Activity-urile in care sunt introduse datele in ListView-uri si afisate
utilizatorului.

Pentru fiecare dintre cele 5 date pe care doream sa le obtinem am efectuat operatii de insert si
extragere . Vom prezenta aceste operatii pentru tabela movies , celelealte fiind similare .

Figură 17 Metoda Insert

Aceasta metoda insereaza un obiect de tip movies transmis ca parametru. In caoloanele declarate in
MySQLiteHelper inseram valorile preluate din obiectul transmis ca parametru.

Metoda insert() este apelata in MainActivity dupa ce s-a efectuat parsarea inserând in tabela
corespunzatoare obiectul respectiv.

25
Figură 18 Inserarea apelata in MainActivity

Metoada de extragere este folosita pentru a afisa elementele dorite. Aceasta foloseste urmatoarea
interogare pentru a extrage primele 10 elemente din lista ordonate dupa numarul lor de apariții , luate
descrescator:

String sql = "SELECT name from movies GROUP BY name ORDER BY count(name) desc limit 10";

Acest query returneaza un obiect de tip Cursor . Un Cursor reprezinta rezultatul unui query si pointeaza
un rand din rezultatul intors de query. In acest fel , sistemul Android trateaza rezultatele intoarse de
query-uri eficient , nefiind nevoie de a salva toate datele in memorie

Figură 19 Extragerea din BD

Pentru a ne deplasa intre diferite randuri ale rezultatului putem folosi metodele moveToFirst() si
moveToNext() . Metoda isAfterLast() permite verificarea sfarsitului rezultatelor.

Pentru tabelele music,books,tv si games , metodele de inserare si de extragere sunt similare.

Fișiere de resurse

Pe langa clasele prezentate pana acum , un proiect Android conține și multe fișiere de resurse. Aceste
sunt folosite pentru a construi interfața grafica a aplicației sau pentru a face referire la anumite variabile
care au o valoare constantă.

AndroidManifest.xml

26
 Fiecare aplicatie trebuie sa aiba un fisier AndroidManifest.xml in radacina proiectului. Acest
fisier manifest prezinta informatii esentiale despre aplicatie sistemului de operare Android, informatii pe
care sistemul trebuie sa le aiba inainte sa poata rula codul aplicatiei. Printre alte lucruri , in fisierul
manifest se gasesc urmatoarele :

Numele pachetului Java al aplicatiei. Acesta este un identificator unic al aplicatiei

Descrierea componentelor aplicatiei , activitati , servicii si content providers.

Declara ce permisiuni trebuie sa aiba aplicatia pentru a putea accesa parti protejate ale API-ului si sa
interactioneze cu alte aplicatii

Declara si ce permisiuni trebuie sa aiba alte aplicatii pentru a putea sa interactioneze cu aplicatia.

Declara nivelul minim al Android API pe care aplicatia il suporta

Elementele ce pot fi prezente in fisierul manifest sunt prezentate mai jos:

<action>
<activity>
<activity-alias>
<application>
<category>
<data>
<grant-uri-permission>
<instrumentation>
<intent-filter>
<manifest>
<meta-data>
<permission>
<permission-group>
<permission-tree>
<provider>
<receiver>
<service>
<supports-screens>
<uses-configuration>
<uses-feature>
<uses-library>
<uses-permission>
<uses-sdk>

Android pune la dispoziție un limbaj XML care cuprinde subclase ale View si ViewGroup. Pe baza
acestora se pot defini elemente de interfață folosint XML .

27
Figură 20 Ierarhia View si ViewGroup

View-urile sunt widget-uri ale interfetei cu utilizatorul ca de exemplu butoane , campuri text, etc.
Aceste view-uri au atribute pe baza carora se poate configura aspectul si comportamentul lor.

Un ViewGroup este responsabil pentru aranjarea celorlalte View-uri , acesta mai fiind cunoscut si ca
layout manager .Clasa de baza pentru acest layout manager este android.view.ViewGroup care extinde
la randul ei android.view.View , clasa de baza a View-urilor.

Interfetele cu utilizatorul ale unei activitati sunt de obicei descrise cu ajutorul unui fisier XML (layout
files) . Aceste pot fi construite și prin intermediul grafic , Android punand la dispozitie un set de View-
uri (Custom & Library Views) , propietatile putand fi setate din tabelul Properties , fara a fi nevoie de
editarea fisierului XML.

În continuare sunt prezentate layout-urile pentru principalele activitați:

28
Figură 21 Custom & Library Views si Properties

main.xml

Acest fisier construieste interfata pentru MainActivity , activitatea cu care se lanseaza aplicația. Are la
baza un RelativeLayout care are setat ca background o imagine referita in alt fisier de resurse , si anume
drowable.

Figură 22 Layout main.xml

pick_friends_activity.xml

Acest layout contine un FrameLayout care face referire la fragmentul oferit de Facebook care permite
selectarea prietenilor.

android:id="@+id/friend_picker_fragment"

select_preferences.xml

Pentru acest layout s-a folosit un RelativeLayout si cuprinde 5 butoane , fiecare buton avand propietatea
android:background setate cu o referire la fisierul back_button.xml din drawable care contine unele
caracteristici ale unui buton ca forma , culoare si asezarea acestuia.

29
Figură 23 Layout select_preferences

activity_list_view.xml

Acest layout contine un View de tip ListView pentru a afisa topul respectiv.

Figură 24 Layout activity_list_view

Aceste layout-uri sunt referite in cadrul activitatilor principale in metodele suprascrise onCreate().

setContentView(R.layout.main);

setContentView(R.layout.pick_friends_activity);

setContentView(R.layout.select_preferences);
30
setContentView(R.layout.activity_list_view);

Un alt fisier de resurse important se gaseste în folderul values. Acesta conține pe lângă numele aplicației
și un identificator unic oferit de Facebook.

Figură 25 Resursa Strings.xml

Crearea aplicației pe platforma Facebook

Pentru a putea folosi functionalitațile oferite de Facebook SDK este necesară înregistrarea pe platforma
de socializare a unui cont de dezvoltator. În acest cont trebuie sa înregistram un HashKey generat de un
tool prezent în Android SDK. Pentru aceasta aplicatie , generarea HashKey-ului s-a facut în cadrul clasei
MainActivity în metoda onCreate() prin adaugarea urmatorului cod:

31
Figură 26 Generare HashKey

Dupa ce acest cod este generat , el se adauga in tabul Sample App din contul de dezvoltator al
platformei Facebook.

Figură 27 Inregistrare HashKey

Urmatorul pas il constituie crearea aplicatiei , acest lucru facandu-se astfel 'Apps' > 'Create a New App':

Dupa ce ste creata aplicatia va aparea codul aplicatiei care trebuie introdus in fisierul de resurse
strings.xml .

Figură 28 Codul aplicației Facebook

32
Pentru aplicatia creata de la Settings va trebui sa adaugam platforma pe care dorim sa o folosim. În acest
caz am adaugat Android și am introdus numele pachetului folosit și al activitații principale.

Figură 29 Platforma pe care dorim sa folosim aplicatia

Nu în ultimul rând atrbuie să trimitem o cerere pentru a putea folosi toate facilitațile platformei
Facebook. Odata aprobata aceasta cerere , aplicația dezvoltată poate beneficia de toate serviciile
implementate cu ajutorul Facebook SDK.

33
Figură 30 Cerere pentru aprobarea folosirii conținutului Facebook

Concluzii

Această aplicație mi-a oferit ocazia studierii unei tehnologii foarte populare și pentru care în
urmatorii ani se prognozează creșterea folosirii acestora. Aplicațiile pentru sistemul de operere Android
au un numar foarte mare de utilizatori , mai ales cele cu specific social.

Am reușit să înțelg principalele componente ale sistemului Android cât și principalele modalitați
de utilizare ale resurselor puse la dispoziție dezvoltatorilor de platforma de socializare Facebook.

În momentul finalizării redactarii acestui document , aplicația se afla într-o stare ce îi conferă
utilitate , putând-i fi aduse îmbunatațiri. Printre viitoarele dezvoltari ulterioare , cele mai importante ar
putea fi :

Adaugarea unui buton care să permită selectarea tuturor prietenilor din listă.

Navigarea spre pagina de Facebook a fiecarui element din topul prezentat.

Afișarea unui grafic care să permita vizualizarea numarului de prieteni care au dat like la elementele din
top.

Afișarea pozei de profil a utilizatorului pe prima activitate lansată.

Analiza altor date preluate din lista de prieteni ai utilizatorului

Optimizarea aplizației pentru viitoarele versiuni ale sistemului de operare (Android L ).

În concluzie , consider că am reușit să îndeplinesc obiectivul prezentat la începutul lucrarii , iar aplicația
prezentată implementează facilitățile enumerate. În forma ei actuala această aplicație poate fi folosită
de utilizatorii rețelei de socializare Facebook care au deja aplicația de socializare instalata și sunt

34
autentificați. Acestia pot , cu ajutorul aplicației prezentate, să selecteze prietenii pentru care doresc să
afle ce preferințe au și să vizualizeze preferințele lor pentru urmatoarele lucruri : carți , filme , muzică ,
seriale și jocuri. După ce vor fi adaugate funcționalitațile prezentate ca dezvoltări ulterioare , aplicația va
fi publicată în magazinul virtual Google Play deoarece , după cum am menționat la începutul acestei
lucrari , lipsește o astfel de aplicație.

Lista tabelelor

Tabel 1 : Unități vândute și cote de piață T4 2013

Tabel 2 : Versiuni Android

Tabel 3 : Pachete prezente in SDK Android

Lista figurilor

Figură 1 : Arhitectura sistemului Android

Figură 2 : Utilizarea intent-urilor

Figură 3 : Ciclul de viață al unui Activity

Figură 4 : Utilizarea fragmentelor

Figură 5 : Mediul de dezvoltare ADT

Figură 6 : SDK Manager

Figură 7: AVD Manager

Figură 8 Ferestrele aplicației

Figură 9 Folosirea UiLifecycleHelper

Figură 10 Apelarea altor Activity-uri

Figură 11 Metoda onStart() din PickFriendsActivity

Figură 12 Figura 3.5 Metoda startPickFriendsActivity() din MainActivity

Figură 13 Figura 3.6 Declarearea butoanelor clasei Select_preferences

Figură 14 Figura 3.7 Afisarea în ListView

Figură 15 Metoda parsePagesFromGRAPHResponse()

Figură 16 Crearea tabelelor din BD

Figură 17 Metoda Insert

Figură 18 Inserarea apelata in MainActivity

35
Figură 19 Extragerea din BD

Figură 20 Ierarhia View si ViewGroup

Figură 21 Custom & Library Views si Properties

Figură 22 Layout main.xml

Figură 23 Layout select_preferences

Figură 24 Layout activity_list_view

Figură 25 Resursa Strings.xml

ANEXE

Bibliografie

[1] STEE2010 STEELE James , TO Nelson , The Android Developer’s Cookbook Building
Application with the Android SDK , Addison-Wesley , Crawfordsville , 2010

36