1.

Valori raw & associated

Raw - Aceasta este o valoare stabilită în timpul compilației. Sunt asemănătoare cu
constantele. Valorile brute pot fi șiruri de caractere, caractere sau oricare dintre tipurile
de numere întregi sau cu puncte în virgulă mobilă. Fiecare valoare brut trebuie să fie
unică în declarația de enumerare. Atunci când numerele întregi sunt folosite pentru
valorile brute, ele sunt incrementate automat dacă nu este specificată nicio valoare
pentru unii dintre membrii enumerării.
Associated - Valorile asociate sunt setate când creați o nouă constantă sau o variabilă
bazată pe unul dintre membrii de enumerare și poate fi diferită de fiecare dată când
faceți acest lucru.

2. Utilizați AnyObject atunci când aveți nevoie de flexibilitatea unui obiect unic sau
atunci când utilizați metode de obiectiv Objective-C și proprietăți care returnează un
rezultat untyped. AnyObject poate fi folosit ca tip de beton pentru o instanță a
oricărui tip de clasă, de tip sau de clasă. Comportamentul flexibil al protocolului
AnyObject este similar cu tipul de identificare al obiectivului C. Din acest motiv,
tipurile importate de tip Obiectiv-C utilizează frecvent AnyObject ca tip pentru
proprietăți, parametri de metodă și valori returnate.
AnyObject basically tells the compiler:
"Don't worry about this variable no need to enforce any type here let me do
whatever I want to."

3. Ios 7Cu Auto Layout, puteți defini constrângeri pentru a controla modul în care
interfața dvs. de utilizator se adaptează imediat la orice modificare de dimensiune.
Interface Builder poate crea automat toate constrângerile pentru dvs., asigurând un
set de reguli compatibile. De asemenea, aveți posibilitatea de a controla direct
constrângerile pentru a defini prioritatea exactă a fiecăruia, definirea modului în
care aplicația va funcționa pe diferite dimensiuni ale ecranului, atunci când este
rotită sau când este rulată în locații noi.
Adaptive Layout cuprinde mai multe idei și tehnici noi, în loc să fie un singur API
singular. Unele componente ale designului adaptiv includ colecții de trăsături, clase
de mărime, fonturi adaptive, Auto Layout și multe altele. În centrul său, designul
adaptiv există pentru a ajuta dezvoltatorii să creeze cu ușurință aplicații universale și
localizate

4. Modal View sunt adesea folosite pentru a avertiza că sa întâmplat ceva neașteptat,
pentru a solicita o confirmare sau pentru a oferi utilizatorilor posibilitatea de a
furniza informații suplimentare despre fluxul de lucru al aplicației.
UIViewController , UIAlertController ;
Vederea divizată vă permite să sculpați ecranul în două secțiuni și să afișați un
controler de vizualizare pe fiecare parte. Este de obicei utilizat pentru a afișa
navigația în partea stângă și o vedere detaliată în partea dreaptă.
Un controler de vizualizare a tabelului afișează informații structurate, repetabile într-
o listă verticală. Utilizați clasa UITableViewController în aplicația dvs. iOS pentru a
construi un controler de vizualizare de tabel.
UICollectionView makes adding your own custom layouts and layout transitions (like
those in the Photos app) simple to build.
1. Activity
În Android, o activitate reprezintă o fereastră care conține interfața grafică a aplicației. O
aplicație poate conține una sau mai multe activități (tipic, există măcar o activitate), scopul
acestora fiind acela de a interacționa cu utilizatorul. De obicei, o activitate implică un nivel
de procesare redus astfel încât să se asigure operarea aplicației în timp real. În cazul în care
aplicația conține mai multe activități, navigarea între acestea se realizează prin intermediul
unor intenții (eng. intents), reținându-se pe stivă ferestrele anterioare, care se găsesc în
fundal. O singură fereastră poate interacționa cu utilizatorul la un moment dat. Activitatea
care se afișează la momentul în care se lansează aplicația desemnează ferastra principală,
toate celelalte fiind accesate prin intermediul acesteia. O activitate este reprezentată prin
intermediul unei clase care extinde Activity. Toate activitățile din cadrul unei aplicații
Android trebuie să fie declarate în fișierul AndroidManifest.xml.
Se observă că pentru fiecare activitate trebuie să se precizeze clasa corespunzătoare
(derivată din Activity), distincția dintre fereastra principală și celelalte ferestre fiind realizată
prin intermediul valorilor pe care le iau elementele action și category din <intent-filter>.
Pentru activitatea principală, acțiunea va fi android.intent.action.MAIN, iar categoria
android.intent.category.LAUNCHER (în sensul că această ferastră va fi afișată în momentul în
care se accesează pictograma aplicației din meniul telefonului), în timp ce pentru celelalte
activități se vor specifica valorile android.intent.action.VIEW, respectiv
android.intent.category.DEFAULT.
Scopul unei activități este de a interacționa cu utilizatorul. Din momentul în care activitatea
apare pe ecran și până la momentul în care dispare, ea trece printr-o serie de etape,
cunoscute sub denumirea de ciclul de viață al activității.
O activity apelează view-uri. View-urile sunt create in fisiere de tip xml, in care se pastreaza
parametrii layout-ului care se va afisa pe ecranul unui dispozitiv mobil. Sublasele unui View
sunt Butoane, ListVew, ImageView,RelativeLayout,LinearLayout etc. Activity poate fi de 7
tipuri, ele toate invoca o actiune specifica.
Evenimentele activitatilor:
- TextView -> onClickListener, onTextCnahgedListener
- Button -> onClickListener
- ListView -> onItemClickListener
- editText -> onTextChangeListemer

2. Ciclul de viață/ Activity Lifecycle

Din momentul în care activitatea apare pe ecran și până la momentul în care dispare, ea
trece printr-o serie de etape, cunoscute sub denumirea de ciclul de viață al activității. Clasa
Activity definește o serie de evenimente care guvernează ciclul de viață al unei activități,
pentru fiecare dintre acestea fiind apelate metodele corespunzătoare:
 onCreate() - apelată în momentul în care activitatea este creată; această metodă va fi
folosită pentru a crea și pentru a instanția obiectele care vor fi utilizate în cadrul
aplicației.
 onStart() - apelată în momentul în care activitatea apare pe ecran

 onResume() - apelată în momentul în care activitatea începe să interacționeze cu

utilizatorul; această metodă va fi folosită pentru a porni servicii sau cod care trebuie
să ruleze atâta timp cât aplicația este afișată pe ecran.
 onPause() - apelată în momentul în care activitatea este suspendată temporar, iar
activitatea precedentă este reluată; această metodă va fi utilizată pentru a opri servicii
sau cod care nu trebuie să ruleze atâta timp cât aplicația nu este afișată pe ecran.
 onStop() - apelată în momentul în care activitatea dispare de pe ecran
 onDestroy() - apelată înainte ca activitatea să fie distrusă de către sistem (fie manual,
fie automat) din lipsă de memorie; această metodă va fi utilizată pentru a elibera
resurse înainte ca activitatea să fie distrusă.
 onRestart() - apelată atunci când activitatea a fost oprită și ulterior repornită
3. Process Lifecycle
Procesele
Toate componentele unei aplicații vor rula într-un singur proces și, în general, pentru majoritatea
aplicațiilor nu este nevoie de procese adiționale. Atunci când o aplicație pornește și nu are deja
componente care rulează, Android va crea un proces UNIX nou pentru acea aplicație care va conține un
singur fir de execuție (thread). Toate componentele care vor porni ulterior vor rula în acel thread, denumit
și „main thread” sau „UI thread”. Vom discuta despre el mai jos, în detaliu.

Android are autoritate asupra proceselor care rulează și poate decide la un anumit moment să închidă un
anumit proces care poate fi chiar cel al aplicației noastre. Motivele pot varia, dar principala cauză are
legătură cu memoria care poate deveni insuficientă și este necesară eliberarea ei. În decizia de a opri un
proces, Android ia în considerare mai multe aspecte, de exemplu, dacă are sau nu componente vizibile pe
ecran.
Procesele sunt încadrate în 5 nivele de importanță. Atunci când unele procese trebuie „omorâte”, cel cu
nivelul mai mare de importanță va fi „distrus” ultimul. Pe scurt, ele sunt:

1. Foreground Process

Un proces necesar pentru ceea ce utilizatorul face la un moment dat, de exemplu un activitycare e folosit
de utilizator sau un serviciu care e legat de activitatea cu care utilizatorul interacționează.

2. Visible Process

Un proces care nu are componente vizibile pe ecran, dar este necesar pentru componentele cu care
interacționează utilizatorul, cum ar fi un proces cu un activity care nu e în față, dar are un dialog pornit în
prim-plan.

3. Service Process

Un proces care conține un serviciu și nu e esențial pentru ceea ce este afișat utilizatorului, cum ar fi un
serviciu care redă un MP3 în fundal în timp ce utilizatorul folosește alte aplicații.

4. Background Process

Un proces care conține o activitate care momentan nu e vizibilă utilizatorului. Pentru aceasta, există o listă
LRU (least recently used) care este luată în considerare în importanța unui proces.

5. Empty Process

Un proces care nu are componente active și este pornit doar din motive de caching sau pentru a îmbunătăți
timpul de start-up al unei aplicații.

Fire de execuție
Main Thread

Un proces poate avea mai multe fire de execuție. După cum am amintit mai sus, atunci când o aplicație e
pornită, un proces UNIX este creat, iar în cadrul lui – un singur thread. Acesta poartă denumirea de „main
thread”. El este extrem de important, pentru că este responsabil de interacțiunea cu utilizatorul, ca de
exemplu lansarea de evenimente spre diferite componente de UI (inclusiv partea de desenare) și este și
firul în care aplicația interacționează cu componentele de UI.

Sistemul nu va crea thread-uri diferite pentru fiecare componentă. Ce înseamnă asta? Atunci când atingem
un buton, acest thread va lansa un eveniment de touch spre componenta respectivă care va lansa metoda
responsabilă de schimbare a stării.

Fiind singurul thread responsabil de partea de UI, dacă aceasta este prea încărcată, poate avea o
performanță slabă. Tot din același motiv, acest thread trebuie ținut cât mai liber. Fiecare acțiune pe acest
thread, mai ales cele de durată, îl vor bloca și, implicit, aplicația nu va răspunde la acțiunile utilizatorului.
Un exemplu în acest sens ar fi accesul la resurse de pe internet, cum ar fi încărcarea unei poze. Dacă am
lăsa ca încărcarea ei să fie făcută în acest thread, el ar fi blocat până s-ar finaliza procesul de încărcare a
 pozei. Dacă poza este mare și conexiunea slabă, acest lucru poate dura câteva zeci de secunde. A ține
interfața blocată pentru un timp atât de lung nu este acceptabil.

De aceea, există două reguli de bază care nu sunt negociabile atunci când lucrăm cu componentele de UI și
main thread-ul:

 Nu bloca niciodată thread-ul de UI

Pentru download-uri, query-uri în baze de date sau orice fel de operațiuni care nu afectează direct interfața
cu utilizatorul și care ar putea fi de durată, trebuie folosite alte thread-uri.

 Nu accesa direct partea de UI din alte thread-uri

Orice manipulare a interfeței de utilizator trebuie făcută din main thread, nu din thread-urile secundare.

Asynchronous Task
Există multe opțiuni pentru a folosi thread-uri secundare și a decongestiona main thread-ul: thread-uri
clasice, servicii, mecanismul de broadcast & receive. Una dintre aceste opțiuni este și mecanismul
de asynchronous task. Acesta este reprezentat de clasa AsyncTask și nu este nimic altceva decât un
wrapper puternic parametrizat care oferă o serie de metode specifice pentru a ușura interacțiunea dintre
thread-ul secundar și main thread. În alți termeni, clasa AsyncTask este construită ca și o clasă ajutătoare în
jurul claselor Thread și Handler. Clasa e definită de un task care rulează pe un fir secundar în fundal și care
publică automat rezultatul spre main thread.

Pentru a crea un AsyncTask, trebuie să extindem clasa de bază AsyncTask care este definită de 3 tipuri
generice, denumite Params, Progress și Result și de 4 metode, dintre care una este obligatorie. Iată tipurile
generice:

1. Params – Tipul parametrilor de intrare

Dacă task-ul nostru are nevoie de parametri, aici trebuie specificat tipul lor. De exemplu, dacă task-ul ar
trebui să descarce o serie de fișiere, atunci tipul parametrilor ar putea fi URL sau String.

2. Progress – Tipul indicatorilor de progres

Dacă task-ul e de durată, este bine să informăm utilizatorul despre progresul făcut. În general, vom
comunica o valoare integer sau double, care specifică cât din task a fost efectuat, dar putem folosi orice fel
de obiect dacă dorim să trimitem informații complete. În cazul exemplului de mai sus, putem trimite ori o
valoare care să reprezinte cât la sută din toate fișierele de download a fost deja descărcat sau putem returna
un obiect care să conțină și numele fișierelor deja descărcate sau progresul individual pentru fiecare fișier
în parte.

3. Result – Tipul rezultatului returnat

Acesta este tipul obiectului care rezultă în urma procesării.

Dacă task-ul nostru nu folosește parametri de intrare, nu dorește să publice progresul efectuat sau pur și
simplu nu va returna nimic în urma procesării, putem folosi tipul Void.

Cele 4 metode pe care le oferă AsyncTask sunt fiecare dedicate unui pas din cadrul execuției unui task.
Acestea sunt:

1. onPreExecute

Acest pas este executat înainte ca task-ul propriu-zis să înceapă execuția și este invocat în main thread. De
obicei, îl putem folosi pentru a pregăti execuția (ex: să afișăm un indicator de progres pe ecran).

2. doInBackground

Această metodă e invocată pe thread-ul de fundal imediat după onPreExecute și este metoda care execută
task-ul propriu-zis. Parametrii de intrare sunt trimiși acestei metode și ea va returna un obiect de tipul
specificat pentru rezultat. În acestă metodă, putem folosi și metodapublishProgress(Progress…), pentru a
face public progresul făcut de task.

3. onProgressUpdate

Acestă metodă este invocată atunci când facem public un progres prinpublishProgress(Progress…) și o
putem folosi pentru a actualiza un progress bar sau pentru a scrie în log-uri. Ea se va executa în paralel cu
task-ul din fundal.

4. onPostExecute

Acestă metodă este invocată pe main thread imediat ce task-ul de fundal este terminat și primește ca
parametru obiectul returnat dedoInBackground.

4. Structura intent-ului
Intent- mecanism de descriere a unei operațiuni (ex. alege fotografie, trimite scrisoare,
efectuare apel, deschide browser). Multe operațiuni în Android lucrează prin intent.
Cele mai răspândite scenariile de utilizare a intent-urilor pentru a porni o altă activitate în
aplicația proprie. Dar acesta nu este singura variantă pentru utilizarea intente-urilor. Ele pot fi
utilizate pentru a anunța pornirea unui serviciu sau activități, care sunt direcționate spre
execuția unor acțiuni sau transmiterea unor notificări, care atestă realizarea unui eveniment sau
acțiune.
Intent-urile pot fi folosite pentru translarea mesajelor prin sistem. Fiecare aplicație poate sa
înregistreze un receptor de difuzare care urmărește intente-urile și posibilitatea de a reacționa
la ele. Aceasta permite crearea aplicațiilor ca folosește modelul de evenimente, la baza căruia
stă evenimentele interne de sistem sau evenimente externe, care pot fi transmise prin programe
externe.
Android poate transmite intent-ruri pentru a anunța despre evenimentele de sistem, de
exemplu despre modificările în starea conexiunii de rețea sau in nivelul de încărcare a
bateriei. Aplicațiile de sistem în Android, așa aplicații ca efectuarea apelurilor sau controlul
SMS, înregistrează componentele, care urmăresc intente-urile declarate, de exemplu ai
primit un mesaj SMS, și sistemul reacționează corespunzător la acest eveniment .
Exemplu de cod pentru a trece de la o activitate la alta:
Intent intent = new Intent(HelloWorld.this, AboutActivity.class);
startActivity(intent);
În intent se indică numele clasei (activitate) ca al 2 parametru. Această clasă trebuie
specificată în manifest, și sistemul parcurgând acest manifest ca porni activitatea
corespunzătoare. O aplicație poate avea mai multe activități, acestea pot fi apelate, știind
numele clasei. La trecerea dintr-o activitate în alta se poate specifica și ce date ar putea fi
transmise pentru prelucrarea lor în activitatea apelată. Pentru a efectua această operațiune
se utilizează metoda put…().
Exemplu de transfer a listei de fisiere dintr-o activitate in alta:

// У первой активности
ArrayList<File> fileList = new ArrayList<File>();
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
intent.putExtra("FILES_LIST", fileList);
startActivity(intent);
// У второй активности
ArrayList<File> filelist =
(ArrayList<File>)getIntent().getSerializableExtra("FILES_LIST");

Odată cu lucrul cu activități, cu date returnate, nu este posibilă utilizarea metodei

startActivit() deoarece aceasta returnează rezultat. Dacă este necesar returnarea datelor se
utilizează metoda stratActivityForResult(), care este adaptat pentru lucrul cu apelurile.
Intenții nedefinite
Există la fel un tip de apelare a activității care la crearea unui intent nu se utilizează numele
clasei, dar se indică parametrii action, data category, cu anumite valori. Sistemul analizează
acești parametri și alege varianta corespunzătoare pentru a porni activitatea. De exemplu,
dacă este indicată în parametri o adresă a paginii web, atunci se presupune deschiderea
browser-ului. Combinația dintre valori și parametri defineşte scopul care vrem să-l atingem.
Acestea pot fi accesarea unui link, trimiterea unei scrisori, apelarea unui număr telefonic
etc.
În filtrele intent-ului se pot utiliza parametrii action, data, category. Aceste tipuri de intent
este un mecanism care permite să trimiți cerere la componentele aplicației cu ajutorul
activităților. La apelarea metodei stratActivity(), creîn un astfel de tip de intent, trebuie de
specificat activitatea, care trebuie să se realizeze și la dorință o directorie URI la aceste date
care trebuie prelucrate. La fel este posibilă transferul de date adiționale în altă activitate,
utilizând intent-ul extras. În acest caz pentru pornirea unei activități sistemul singur va găsi
clasa componentului necesar, care mai bine corespunde activității definite, luând în vedere
tipul de date.
Exemplu de creare a unui intent cu activitatea predefinită ACTION_VIEW pentru a porni
browser-ul și de a accesa adresa necesară:
Uri address = Uri.parse("http://developer.alexanderklimov.ru"); Intent openlink =
new Intent(Intent.ACTION_VIEW, address); startActivity(openlink);

ACTION_VIEW permite vizualizarea unei pagini web, în cazul dat. Odată cu declararea
adresei (datele necesare), se efectuează pornirea unei noi activități (browser-ul). În acest
timp activitatea inițială lucrează ca activitate de fundal. În fiecare caz Android singur găsește
activitatea necesară pentru a răspunde la intent, și o inițializează în caz de necesitate.
Aplicația la fel poate crea intent-uri proprii pentru a permite altor aplicații să le apeleze.
Sistemul nu garantează prelucrarea intente-urilor.
Intent-ul conține informații care prezintă interes pentru Android, numele componentei care
trebuie să-l prelucreze intent-ul și setul de parametri pentru pornirea acestui component.
Intent-ul conține următoarele cîmpuri: ComponentName, activitatea, date (uri, mime),
categoria, etc.
Pentru a accesa informații din intent se utilizează metoda getIntent(). Dacă intent-ul este
nedefinit (ascuns) atunci poți obține informații despre URL din intent la apelarea metodelor
getAction(), getData(), getExtras().

5. Intent Resolution (Explicit Intent / Implicit Intent)

Sunt două tipuri de intenții(Intent):
 Explicit intents care specifică componenta(blocuri esențiale de creare a aplicațiilor
Android, ele sunt punctele prin care sistemul poate accesa aplicația noastră, nu
toate componentele sunt defapt puncte de intrare pentru user și unele depind
unele de altele, dar fiecare există ca o entitate anume și joacă un rol specific și
fiecare este un bloc de creare unic care ajută la definirea comportamentului
general al aplicației. Sunt 4 tipuri de componente: Activity, Services, Content
providers, broadcast recievers) care începe cu un nume( numele clasei complet).
Vom utiliza explicit intent pentru a porni componenta în aplicația noastră,
deoarece noi cunoaștem deja numele activității sau serviciului ce o dorim să
pornim. De exemplu: pornirea unei noi activități ca răspuns la acțiunele unui user,
sau pornirea unui serviciu pentru descărcarea unui fișier în background.
 Implicit Intents nu denumesc o componentăă specifică dar în schimb declară o
acțiune generală ce trebuie de realizat care permite unei alte componente din altă
aplicație să se ocupe de ea. De exemplu: dacă se dorește afișarea unei locații pe
hartă al unui utilizator, putem să utilizăm un intent implicit de a face apel la altă
aplicație capabilă să specifice locația pe hartă.

Când creăm un intent explicit pentru a porni o activitate sau servicu, sistemul imediat va
porni componenta specificată în obiectul Intent.
Figura 1 : Are loc ilustrarea unui intent implicit și anume parcurgerea lui prin sistem pentru a
porni o altă activitate: [1] activitatea A crează un Intent cu acțiunea și o trasmite la
startActivity(). [2] sistemul android caută toate aplicațiile care corespund intentului, atunci
când aplicația necesară a fost găsită [3] sistemul startează activitate potrivită (Activity B)
invocând metoda onCreate() și transmite intent în ea.
Intent Resolution
Când sistemul recepționează intentul implicit pentru pornirea activității, el caută cea mai
bună activitate pentru inent, comparând intentul cu 3 aspecte de bază utilizând Intent
filtrul:
 Acțiunea intentului
 Datele intentului (ambele URI (Uniform Resource Identifier(Indentificatorul
universal al resurselor)) și tipuri de date)
 Categoria intentului

Secțiunele următoare vor descrie cum intenturile se potrivesc la cea mai apropiată
compoonentă cum filtrul intentului este declarat în fișierul Manifest al aplicației.
Exemplele ce urmează, vor găsi intentul potrivit utilizând intent filtrele:
Action test
<intent-filter>
<action android:name="android.intent.action.EDIT" />
<action android:name="android.intent.action.VIEW" />
...
</intent-filter>

Category test
<intent-filter>
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
...
</intent-filter>

Data test
<intent-filter>
<data android:mimeType="video/mpeg" android:scheme="http" ... />
<data android:mimeType="audio/mpeg" android:scheme="http" ... />
...
</intent-filter>
Exemplu de intent pentru a obține datele imaginii dintr-un content provider și să le
afișeze:
<intent-filter>
<data android:mimeType="image/*" />
...
</intent-filter>

Exemplu de intent pentru a obține datele unui video de pe web:

<intent-filter>
<data android:scheme="http" android:type="video/*" />
...
</intent-filter>

6. Android Manifest
Fișierul Manifest AndroidManifest.xml reprezintă în format xml informația de bază despre
aplicație. Fiecare aplicație trebuie să aibă acest fișier. Redactarea fișierului se poate efectua
manual, schimbând codul XML sau schimbările pot fi efectuate prin intermediul Manifest
Editor, care permite să se realizeze redactarea vizuală și textuală a fișierului în cadrul
aplicației.
Particularitățile manifestului:
- Declararea numelui pachetului java, care reprezintă un identificator unic;
- Descrierea componentelor aplicației- activități, servicii, intent, care permit să fie
apelate clase, care realizează fiecare componentă, și declară intențiile lor;
- Conține lista permisiunilor necesare pentru apelarea interacțiunilor cu alte aplicații;
- Declară permisiunile, care alte aplicații trebuie să le aibă pentru interacțiunea cu
componentele acestei aplicații;
- Declară nivelul minim API Android, necesar pentru lucrul cu aplicația;
- Enumeră biblioteci de legătură.

Structura manifestului:
Fișierul manifestului încapsulează toată arhitectura aplicației Android, funcționalitățile și
configurația acesteia. Elementele rădăcină ale manifestului reprezintă <manifest>. Alte
tag-uri importante și obligatorii sunt <application> și <uses-sdk>. Elementul <application>
reprezintă elementul de bază al manifestului care conţine multe elemente descendente,
care defines structura și lucrul aplicației. Ordinea localizării elementelor, care se află la
același nivel este arbitrar. Toate valorile se stabilesc prin atributele elementelor.
Atribute:
- xmlns:android- definește namespace pentru Android, și niciodată nu se
schimbă;
- package- defineste numele unic al pachetului aplicatiei, care este definita la
etapa de creare a aplicatiei;
- android:versionCode- indica la numarul intern al versiunii, utilizind pentru
compararea versiunii aplicației;
 - android:versionName- indica numarul versiunii de utilizare.
Exemplu concret de fișier AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.mark.paiip2" >

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name=".MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".TwoActivity"
/>
</application>

</manifest>

7. Noțiunea de Context

Cum sugerează numele, contextul reprezintă starea actuală(curentă) a aplicației/obiectului.

El permite obiectelor noi create să înțeleagă ce are loc. Noi îl apelăm pentru a obține
informația referitoare despre o altă parte a programului (activity, package/application).
Putem obține contextul invocând următoarele metode: getApplicationContext(),
getContext(), getBaseContext() sau this (când în clasa activitate ).

Cazuri tipice de utilizare a contextului:

 Crearea obiectelor noi – este utilizată pentru a crea View-uri, adapters și listeners:
TextView tv = new TextView(getContext());
ListAdapter adapter = new
SimpleCursorAdapter(getApplicationContext(), ...);
 Accesarea resurselor standarde comune – servicii ca:
LAYOUT_INFLATER_SERVICE, SharedPreferences:
context.getSystemService(LAYOUT_INFLATER_SERVICE)
getApplicationContext().getSharedPreferences(*name*, *mode*);
 Accesarea implicită a componentelor – cea ce privește content providers,
intenturi și broadcasturi:
getApplicationContext().getContentResolver().query(uri, ...);
General

8. Metode Asynchrone (async/await)

Odata cu C# 5.0 si .NET Framework 4.5, Microsoft a introdus in limbajul C# suport pentru
programarea asincrona prin cuvintele cheie async si await. Codul asincron starteaza o
operatie care se dasfasoara pe un termen mai lung si returneaza imediat controlul thread-
ului, fara a bloca cursul evenimentelor asteptand rezultatul operatiei. Cand operatia s-a
terminat, suntem notificati de acest lucru prin diverse mecanisme cum ar fi un event, un
delegate sau expresie lambda, await, etc. Exemple de operatii "lungi" sunt accesul la diferite
periferice, accesul la retea/internet sau diferite intarzieri datorate unor procesari de date.
Microsoft marsaluieste tare pe programarea asincrona. Astfel, in Silverlight a eliminat toate
metodele sincrone din clasele care contineau ambele perechi, sincrone si asincrone. Sub
Windows 8 si .NET Framework 4.5, au fost deasemenea introduse o serie de metode
asincrone, insa au ramas si echivalentele lor sincrone. Microsoft recomanda folosirea
metodelor asincrone pe cat posibil, deoarece prin natura ei, o aplicatie de tip Windows
Store este terminata neasteptat, daca aceasta apeleaza o metoda sincrona a carei timp de
executie este foarte lung (de ordinul zecilor de secunde).
Utilizarea perechii async/await a fost gandita astfel incat codul rezultat sa arate foarte
asemanator cu echivalentul sau sincron. In urmatorul exemplu voi prezenta o metoda care
descarca o pagina WEB si o afiseaza la consola.
private void PrintWebPage(string uri)
{
var client = new WebClient();
var page = client.DownloadString(uri);
Console.WriteLine(page);
}
Urmeaza echivalenta asincrona.
private async void PrintWebPageAsync(string uri)
{
var client = new WebClient();
var page = await client.DownloadStringTaskAsync(uri);
Console.WriteLine(page);
}
Se observa ca cele doua metode sunt foarte asemanatoare, diferenta constand in
"decorarea" celei de-a doua metode cu async si await si apelarea variantei asincrone
DownloadStringTaskAsync. Prin conventie, o metoda asincrona va contine sufixul Async.
Aparent asemanatoare, cele doua metode sunt intern complet diferite. Compilatorul C#,
cand va intalni cuvantul cheie await, va imparti metoda in doua iar tot codul de dupa await
il va introduce in ce-a de-a doua parte/metoda. Putem verifica acest aspect urmarind codul
IL rezultat.La runtime, se executa codul pana se intalneste metoda
DownloadStringTaskAsync, dupa care se incepe descarcarea paginii dar nu pe thread-ul
curent. Thread-ul curent va preda controlul actiunilor utilizator, daca e un UI thread, altfel
resursele threadului vor fi eliberate.
De mentionat, ca await poate fi folosit doar in interiorul unei metode asincrone, prefixata
de async, dupa cum se poate vedea si-n exemplul de mai sus.O metoda asincrona poate
returna doar trei tipuri de date, si anume, void, Task si Task< T> unde T poate fi orice fel de
tip de date. Alte tipuri de date nu sunt permise deoarece metodele asincrone nu blocheaza
si au asociat un mecanism de notificare la terminarea executiei metodei, care cunoaste doar
cele trei tipuri de date ca rezultat. Astfel, daca avem nevoie de o metoda care returneaza o
valoare de tip int, atunci tipul de retur al metodei asincrone ete Task< int> iar in corpul
metodei vom avea la un moment dat o declaratie de forma "return valoare_int;". Daca
avem nevoie de o metoda care nu returneaza nimic (void), atunci tipul de retur al metodei
asincrone este Task iar in corpul metodei vom avea la un moment dat o declaratie de forma
"return;" sau nimic (apelul return nu este obligatoriu).Exemplu:
private async void PrintWebPage1Async(string uri)
{
var client = new WebClient();
var page = await client.DownloadStringTaskAsync(uri);
Console.WriteLine(page);
}

private async Task PrintWebPage2Async(string uri)

{
var client = new WebClient();
var page = await client.DownloadStringTaskAsync(uri);
Console.WriteLine(page);
}

private async Task< string> GetWebPageAsync(string uri)

{
var client = new WebClient();
var page = await client.DownloadStringTaskAsync(uri);
return page;
}

9. Task and Threads

Thread
De multe ori, aplicatiile au nevoie de mult timp pentru a rezolva o sarcina (descarcarea unui
fisier, printare, generarea unui raport etc), timp in care programul nu poate raspunde unei
alte actiuni a utilizatorului. Pentru a face ca o aplicatie sa indeplineasca o sarcina si sa poata
primi si altele in acelasi timp, sunt folosite firele de executie multiple (multiple threads).
Intr-un program liniar se executa o singura linie de cod, se asteapta pentru completare si
apoi se continua cu urmatoarea linie de cod. Programul nu poate raspunde actiunii unui
utilizator in acest timp si chiar in cazul mai multor procesoare, va fi folosit doar unul singur,
limitand performanta, datorita programarii single-thread.
Un fir de executie (thread) este un program secvential, care poate fi executat concurent cu
alte fire. Un thread este o unitate de executie intr-un proces. Un proces poate avea mai
multe fire de executie, el numindu-se multithread. Daca un calculator are mai multe
procesoare sau un procesor cu mai multe nuclee, el poate executa mai multe fire de
executie simultan.
Diferenta dintre un proces si un thread este ca procesele sunt izolate total unul de celalalt,
in timp ce thread-urile impart aceeasi memorie (heap) cu alte thread-uri care ruleaza in
aceeasi aplicatie (un thread poate prelua informatii noi, in timp ce un alt thread le
prelucreaza pe cele existente).
Un fir de executie, thread, poate avea mai multe stari.
Task
Task reprezinta o operatie asincrona.
Task <T result> reprezinta o operatie asincrona ce returneaza o valoare, TResult.
Clasa Task <T result> este derivata din Task.
Instantele clasei Task pot fi create:
 Folosind proprietatea Factory ce returneaza o instanta pentru TaskFactory si in
continuare metoda SartNew.
 Foloseseste apelul metodei Start.

Cand cream un task ii furnizam un delegate ce contine codul ce se va executa. Delegate-ul

poate fi furnizat ca un delegate cu nume, metoda anonima sau o expresie lambda. Expresiile
lambda pot contine apel la metode cu nume (vezi si exemplul anterior).
Observatie: In .NET 4.5 este implementata metoda Run in clasa Task.
Crearea unui Task se poate realiza urmarind mai multe scenarii.
Scenariul 1. Creare a unei instante a tipului Task urmat de apelul metodei Start().
var taskA = new Task(() => Console.WriteLine("Hello from
taskA.")); // Lansare taskA
taskA.Start();
Când se termină un fir de execuție:
O deosebita atenţie trebuie data modului in care un fir de execuţie se termina.
Terminarea unui fir de execuţie utilizând metoda stop() nu este recomandata, de
altfel, aceasta metoda este “deprecated” (nu mai este recomandată de către Sun
pentru a fi utilizată). Calea recomandata de terminare a unui fir este prin revenirea
normala ( return ) din run(). Aşadar in cadrul metodei run se recomandă adăugarea
unor blocuri condiţinale care să determine terminarea firului de execuţie, respectiv
ieşirea din metoda run.
Acest mecanism nu este util de fiecare data deoarece in momentul in care un fir este
blocat ( datorita unor instrucţiuni wai(), sleep(), join(), operatii I/O ), acesta nu poate
verifica nici o condiţie. Pentru a termina un fir care este blocat se utilizează metoda
interrup(). Aceasta metoda determina aruncarea unei excepţii InterruptedException
care trebuie prinsa.
Exit code
ExitCode se foloseste pentru a obtine statutul unui process la terminarea lui. Puteti
utiliza ExitCodul ca o variabila integer pentru a returna o valoare dintr-o procedura.
In general serveste ca o variabila decizionala
WaitForSingleObject
Functia WaitForSingleObject verifica starea curenta a obiectului specificat. Daca
starea obiectului este nesemnalata, atunci firul de asteptare intra in stare de
 asteptare, pina cind obiectul devine semnalizat sau intervalul de timp a depasit
norma sa.
Functia WaitForSingleObject poate astepta urmatoarele obiecte: Change
Notification; Console input; Event; Mutex, Process, Thread etc.

10.Protocolul HTTP
Hypertext Transfer Protocol (HTTP) este metoda cea mai des utilizată pentru accesarea
informațiilor în Internet care sunt păstrate pe servere World Wide Web.

Deseori utilizatorul dorește să transmită informații speciale la website. Aici HTTP pune la dispozitie
două posibilități:

 Transferul datelor în combinație cu o cerere pentru o resursă (HTTP-metoda "GET")

 Transferul datelor în combinație cu o cerere specială (HTTP-metoda "POST")

(Exemplu: la pagina de start de la Wikipedia.ro utilizatorul introduce în câmpul de căutare termenul

"pisici".. Atunci browserul trimite următoarea cerere la server:GET
/wiki/special:Search?search=pisici&go)

Erorile de HTTP sunt clasificate în 5 clase (categorii). Acestea sunt (pentru fiecare clasa sunt date
câteva dintre erorile conținute):
1xx - erori informaționale:
100 - contiunuă:
Utilizatorul ar trebui să își continue cererea/acțiunea. Acest răspuns provizoriu este folosit pentru a informa
utilizatorul că partea inițială a cererii a fost receptată și că deocamdată nu a fost refuzată de server.
Utilizatorul ar trebui să continue și să ignore acest răspuns.
101 - schimbare protocol.
2xx - răspuns reușit: clasa de răspuns/status ce indică utilizatorului că cererea a fost primită,
înțeleasă și acceptată cu succes.

200 - ok:
Această cerere a fost executată cu succes. Informația a revenit cu un răspuns pozitiv, indiferent de
modul în care s-a făcut cererea.

202 - acceptat:
Cererea a fost acceptata pentru procesare, dar aceasta din urmă nu a fost terminată complet. Scopul
acestui mesaj este de a permite unui server să accepte cereri de la alți utilizatori, fără a cere
conexiunii clientului să insiste până ce procesul/cererea e completă.

3xx - redirectări:
4xx - erori ale utilizatorilor: această clasă de mesaje/statusuri este folosită în cazurile în care
utilizatorul ar putea greși formularea cererii. Excepția fiind răspunsurule pentru cererile tip
„Direcționat/condus”, atunci serverul ar trebui să conțină o intrare cu o explicație a situației erorii și
dacă e o eroare temporară sau pemanentă. Aceste răspunsuri sunt aplicabile pentru orice fel de
cerere. Browser-ele ar trebui să arate orice intrare cerută de utilizator.
400 - cerere greșită:
Cererea nu a putut fi înțeleasă/percepută de către server din cauza unei sintaxe greșite/incomplete.
Utilizatorul ar trebui să nu repete cererea fără ca aceasta să suporte modificări.
401 - neautorizat:
11. Metodele și cîmpurile prot. HTTP
Câmpuri-mărimea pachetului, cookies
METODE
Metodele disponibile sunt :
GET: este cea mai folosită metodă, fiind utilizată atunci când serverului i se cere o resursă.
HEAD: se comportă exact ca metoda GET, dar serverul returnează doar antetul resursei,
ceea ce permite clientului să inspecteze antetul resursei, fără a fi nevoit să obțină și corpul
resursei. Accesibilitatea resursei(desktop /mobile).
PUT: metoda este folosită pentru a depune documente pe server, fiind inversul metodei
GET.
POST: a fost proiectată pentru a trimite date de intrare către server.
DELETE: este opusul metodei PUT.
TRACE: este o metodă folosită de obicei pentru diagnosticare, putând da mai multe
informații despre traseul urmat de legătura HTTP, fiecare server proxy adăugându-și
semnătura în antetul Via.
OPTIONS: este folosită pentru identificarea capacităților serverului Web, înainte de a face o
cerere.
CONNECT: este o metodă folosită în general de serverele intermediare.

12. XML/Json (metode de serializare/deserializare)

XML (eXtensible Markup Language), este un meta-limbaj utilizat in activitatea de marcare
structurala a documentelor. Documentele XML sunt realizate din unitati de stocare numite
entitati, ce contin date parsate sau neparsate. Datele parsate sunt realizate din caractere,
unele dintre ele formand date caracter iar altele ca marcaje. Marcajele codifica o descriere
a schemei de stocare a documentului si structura logica. XML furnizeaza un mecanism
pentru a impune constringeri asupra schemei de stocare si a structurii logice.
Un document XML este format din marcaje (tag-uri) si date caracter.
Cuvantul marcaj (markup) a fost folosit initial pentru a descrie anumite adnotari, note
marginale in cadrul unui text cu intentia de a indica tehnoredactorului cum trebuie listat
un anumit pasaj. Generalizand, putem defini marcajul drept orice actiune de a interpreta
explicit o portiune de interpreta explicit o portiune de text.
Un marcaj (tag) este un sir de caractere delimitat de caracterele "<" si ">". Datele
caracterreprezinta continutul marcajelor.
În XML, marcajele nu sunt folosite pentru afisarea datelor continute, ci au alte scopuri
printre care:
● asigura o sintaxa simpla si standardizata pe care analizoarele XML o pot folosi
pentru a utiliza informatia stocata
● asigura o metoda de a descrie structura ierarhica a continutului prin impartirea
informatiei (datele caracter) in parti numite elemente care mai departe sunt
descrise prin atribute. Structura ierarhica a intregului document este pusa in
evidenta prin utilizarea marcajelor.
Un fisier XML cuprinde urmatoarele sectiuni:
 ● Prolog
● Definitia tipului de document (optionala)
● Elementul radacina

De ce folosim XML in Android in Layout

R/S:
- delimiteaza aplicatia in partea functionala de cea vizuala
- este usor de parsat
- este usor de citit pentru omanei
- consuma putina memorie
- un numar mare de IDE suporta formatul dat.

JSON este un acronim în limba engleză pentru JavaScript Object Notation, și este un format de
reprezentare și interschimb de date între aplicații informatice. Utilizat pentru reprezentarea
obiectelor și a altor structuri de date și este folosit în special pentru a transmite date structurate
prin rețea, procesul purtând numele de serializare.
In c# , seriaizarea are loc prin Json.NET - un popular JSon framework pentru .NET
Cea mai rapidă metodă de conversie dintre text și JSON obiect .NET utilizarea metodei
JsonSerializer.JsonSerializer convertește .NET obiecte în echivalentul lor JSON si maparea
obiect .NET, numele de proprietate la numele de proprietate JSON și copii valorile pentru
tine.
Deseralizarea reprezinta convertarea fisierului json In Obiecte.
Product product = new Product();

product.Name = "Apple";
product.ExpiryDate = new DateTime(2008, 12, 28);
product.Price = 3.99M;
product.Sizes = new string[] { "Small", "Medium", "Large" };
string output = JsonConvert.SerializeObject(product);
Product deserializedProduct =
JsonConvert.DeserializeObject<Product>(output);

13.generale și moduri de utilizare RegEx

Ea reprezintă o expresie regulată neschimbătoare.
Biblioteca : System.Text.RegularExpressions.Regex
Expresii regulate oferă un mod puternic, flexibil și eficient de manipulare a textlui . Expresiile regulate
ne permit să analizam rapid cantități mari de text pentru a găsi modele de caractere specifice,
verificați textul la template-uri predefinite (de exemplu, e-mail, prelua, modifica, înlocui sau șterge
subșir text.
Metode Utilizate:
1) IsMatch (String)
Indică dacă expresia regulată specificată în constructorul Regex găsește o potrivire într-un șir de
intrare specificat.
2) Replace(String,String)
Într-un șir de intrare specificat, înlocuiește toate siruri de caractere care se potrivesc cu o
expresie regulată specificat cu un șir de returnat de un string
3) Split (String, String)
Împarte un șir de intrare într-o serie de subsirurii de la pozițiile definite de un model
expresie regulată.
using System;
using System.Text.RegularExpressions;

class Program
{
static void Main()
{
Regex regex = new Regex(@"\d+");
Match match = regex.Match("Dot 55 Perls");
if (match.Success)
{
Console.WriteLine(match.Value);
}
}
}

Output
55

14. HTML Parsing/xPath()

XPath (XML Path Language) este un limbaj de expresii utilizat pentru a selecta
porţiuni dintr-un document XML sau pentru a calcula valori (şiruri de caractere,
numere, sau valori buleene) pe baza conţinutului unui document XML.Limbajul
XPath este structurat sub formă de arbore a documentului XML, oferind posibilitatea
de a naviga în acest arbore, prin selecţia nodurilor XML care satisfac diferite criterii.
Cea mai întâlnită metodă a expresiilor XPath este path expression. Un path
expression este scrisă ca o secvenţă de paşi pentru a ajunge dintr-un nod XML
('context node'-ul curent) la un alt nod sau un alt set de noduri. Paşii sunt separaţi de
caracterul "/" (ex. path). Fiecare pas are trei componente:
• Specificatorul de axe
• Node Test
• Predicat

Parsarea HTML cu ajutorul Xpath ()/C#

Acesta este un parser HTML agil care construiește o citire / scriere DOM și sprijină
XPATH simplu sau XSLT Este o bibliotecă de cod .NET, care vă permite să elimine
"din web" fișiere HTML. Modelul obiect este foarte similar cu ceea ce propune
System.Xml, dar pentru documentele HTML (sau fluxuri). Html Agility Pack suportă
acum LINQ to Objects (printr-un LINQ în XML ca interfață). Exemple de aplicatii:
Fixare pagina sau generație. Puteți modifica o pagină așa cum doriți, modificați
DOM, adăugați noduri, copiați noduri, bine ... ce vrei tu. Scanere web. Puteți obține
cu ușurință la img / src sau a / hrefs cu un buchet interogări XPATH.
Exemplu
Sa presupunem ca avem un mic cod HTML numit LomakeTaustaVari;
{
HtmlAgilityPack.HtmlWeb web = new HtmlWeb();
HtmlAgilityPack.HtmlDocument doc = web.Load
("https://www.op.fi/op/henkiloasiakkaat/saastot-ja-sijoitukset/kurssit-ja-
markkinat/markkinat?sivu=alltrades.html&sym=KNEBV.HSE&from=10:00&to=19:00&id=32453"
);

foreach (HtmlNode row in

doc.DocumentNode.SelectNodes("//tr[@class='LomakeTaustaVari']"))
{
Console.WriteLine(row.InnerText);
}
Console.ReadKey();
}
Exemplu 2
‹html›
‹head›
‹title›Test Html‹/title›
‹/head›
‹body›
‹span› This is span 1 ‹/span›
‹span› This is span 2 ‹/span›
‹span› This is span 3 ‹/span›
‹/body›
‹/html›
Codul următor oferă accesul la toate intervalele (Span) înăutru la pagina html
try{ HtmlDocument HD = new HtmlDocument();
HD.Load(new StringReader(rawHTML));
//rawHTML will contain the above HTML.
var SpanNodes = HD.DocumentNode.SelectNodes("//span");
//for details of XPath syntax see the above table, // operater returns
//all nodes matching the name after //. In above example it will return all
//span nodes.
if (SpanNodes != null) {
foreach(SpanNodes SN in HeadingNodes){
string text = SN.FirstChild.InnerText.Trim();
Console.WriteLine(text); //Will output all span's text } }
}catch(Exception e)
{ //Write your exception handling code here}