Întrebari Android

1. Intent, definiția, exemplu de trecere la alta activitate(operatie) și exemplu de transmitere a

datelor dintre activitati.
http://developer.alexanderklimov.ru/android/theory/intent.php
http://vlad8.com/tech/android-intents-tutorial/
Intenții definite
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 receprot 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 sitem 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ă
componenteșe, care urmăresc intente-urile decarate, 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 utiliează 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 returneazp rezultat. Dacă este necesar returnarea datelor se utiilizează 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și 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 definș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 acetse 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().

2. Activities, definiția, exemplu, Linia de viața a unei activități, starile activității (activiti events)
http://developer.android.com/intl/ru/guide/components/activities.html
În Android, o activitate reprezintă o fereastră care conține interfața grafică a aplicației. O aplicație
poate conține 0 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 fiandroid.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.
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ă
Exemplu (din Android Manifest)
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name=".MainActivity"
android:screenOrientation="portrait"
android:theme="@style/Theme.AppCompat.NoActionBar"
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=".MyCamera"
android:screenOrientation="portrait"
android:theme="@android:style/Theme.Holo.NoActionBar.Fullscreen"
/>
</application>

3. Events, definiția, exemplu

http://developer.android.com/intl/ru/guide/topics/ui/ui-events.html
In sistemul Android este prevazut citeva posibilitati de a intercepta evenimente ce interactioneaza
cu utilizator. În ceea ce privește evenimentele in Interfata grafica, abordare este de a capta
evenimente de la un anumit obiect cu care un utilizator interacționează. Clasa care contine
posibilitati de a face asta se numeste View
Event listener - este o interfata a clasei View, ea contine o metoda ce contine un apel invers. Aceste
metode se vor apela de platforma Android, ca un rezultat al interacțiunii obiectului cu interfața
utilizatorului, se va activeaza obiectul afisat View, in care este inregistrat receptorul.
Aceste metode sunt:
 onClick();
 onLongClick();
 onFocusChange();
 onKey();
 onTouch();
 onCreateContexMenu();
In exemplul de mai jos este prezentat cum de inregistrat un event listener pentru un buton (onClick)

// Create an anonymous implementation of OnClickListener

private OnClickListener mCorkyListener = new OnClickListener() {
public void onClick(View v) {
// do something when the button is clicked
}
};
protected void onCreate(Bundle savedValues) {
...
// Capture our button from layout
Button button = (Button)findViewById(R.id.corky);
// Register the onClick listener with the implementation above
button.setOnClickListener(mCorkyListener);
...
}

Regimul Touch Mode

Atunci cind utilizatorul navigheaza pe Interfata Grafica cu ajutorul tastelor sau trackball, trebuie de
trasmis focusul elementelor active (asa ca butoane) ca utilizatorul sa observe ce element primeste
focusul. Insa daca device-ul sustine touch screen, utilizatorul incepe sa interactioneze cu UI prin
tastarea directa a elementelor. Odata cu tastarea unui element device-ul trece in regim de touch
mode. Incepind din momentul dat, focusul trece doar obiectelor care
pentru isFocusableInTouchMode() este true, alte obiecte in acest moment nu vor putea obtine focus.

4. Evenimentele la onKeyDown, onKeyUp, onKeyLongPress, onKeyMultiple

http://developer.android.com/intl/ru/reference/android/view/KeyEvent.Callback.html#onKeyDown(int
, android.view.KeyEvent)
http://developer.alexanderklimov.ru/android/keyboard.php
Pentru a prelucra evenimentele la utilizarea tastaturii există următoarele metode:
onKeyDown()- apelată la tastarea oricărei taste funcționale;
onKeyUp()-apelată la eliberarea oricărei taste funcționale.
Înafara de taste, sunt și alte metode de prelucrare a acestor evenimente:
onTrackballEvent() - declanșată la mișcările trackball (трекбол);
onTouchEvent()- prelucrează evenimentele ecranului (touch screen), funcționează la
atingerea și retragerea degetului.

Ca componentele sistemului și a activității sa reacționeze la tastarea tastelor, trebuie predefinite

prelucrarea evenimentelor prin intermediul metodelor onKeyUp() și onKeyDown():
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
// Обработайте нажатие, верните true, если обработка выполнена
return false;
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
// Обработайте отпускание клавиши, верните true, если обработка выполнена
return false;
}
Parametrul keyCode conține codul tastei, care a fost tastată și comparate cu codurile tastelor care se păstrează
în clasa KeyEvent, pentru a prelucra corect evenimentele. După acelați principiu lucrează și metoda
onKeyUp().
Metoda onKeyLongPress() poate fi utlizată, numai în cazul cînd în metoda onKeyDown() a fost implicată
metoda
event.startTracking(), care urmărește comportamentul tastei.
Exemplu de onKeyLongPress():

@Override
public boolean onKeyLongPress(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_MENU) {
editText.setText("Long Press"); //вывожу текст в текстовом поле
 return true;
}
return super.onKeyDown(keyCode, event);
}

public abstract boolean onKeyMultiple (int keyCode, int count, KeyEvent event)
Apelat în cazul când atunci când o mulțime de down/up de același perechi sunt într-un rând. Parametrul count
specifică numărul de perechi returnat de event.getRepeatCount(). Dacă ați ocupat un eveniment returnează true,
dacă doriți ca evenimentul să fie manipula de următorul receiver, se returnează false.

5. Evenimentul setOnTouchListener, ActionDown,ActionUP,ActionMove

http://startandroid.ru/en/uroki/vse-uroki-spiskom/167-urok-102-touch-obrabotka-kasanija
Sunt 3 tipuri de evenimente:
 atingerea ecranului cu degetul (apăsare);
 mișcare (degetul se mișcă pe ecran);
 retragerea degetului de pe ecran.
Aceste evenimente pot fi interpretate de OnTouchListener, care sunt alocate pentru componentul
View. Acesta ne dă un obiect MotionEvent, din care se extrage tipul evenimentului și
coordonatele.

public class MainActivity extends Activity implements OnTouchListener {

TextView tv;
float x;
float y;
String sDown;
String sMove;
String sUp;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
tv = new TextView(this);
tv.setOnTouchListener(this);
setContentView(tv);
}

@Override
public boolean onTouch(View v, MotionEvent event) {
x = event.getX();
y = event.getY();

switch (event.getAction()) {
case MotionEvent.ACTION_DOWN: // нажатие
sDown = "Down: " + x + "," + y;
sMove = ""; sUp = "";
break;
case MotionEvent.ACTION_MOVE: // движение
sMove = "Move: " + x + "," + y;
break;
case MotionEvent.ACTION_UP: // отпускание
case MotionEvent.ACTION_CANCEL:
 sMove = "";
sUp = "Up: " + x + "," + y;
break;
}
tv.setText(sDown + "\n" + sMove + "\n" + sUp);
return true;
}
}
MainActivity realizează interfața OnTouchListener pentru prelucra atingerile pe ecran. În onCreate
se crează un nou TextView, care comunică că prelucrarea atingerilor vor fi un Activity. Interfața
OnTouchListener presupune, că Activity realizează metoda onTouch. Pentru început merge View
pentru care este evenimentul de atingere și obiectul MotionEvent cu informația despre eveniment.
Metodele getX și getY dau coordonatele X și Y punctului unde a fost atins ecranul. Metoda getAction
specifică tipul evenimentului de atingere a ecranului:
 ACTION_DOWN- atinge ecran;
 ACTION_MOVE- mișcarea degetului pe ecran;
 ACTION_UP-retragerea degetului de pe ecran;
 ACTION_CANCEL-practic niciodată nu se utilizează, apare în cazul unor eșecuri interne,
care trebuie interpretate ca ACTION_UP.
În cazul la ACTION_DOWN, coordonatele punctului unde a fost atins ecranul se scriu în sDown. În
cazul la ACTION_MOVE coordonatele punctului în care este localizat degetul se scriu în sMove.
Dacă degetul se va mișca pe ecran acest text se va schimba în continuu.
În cazul la ACTION_UP și ACTION_CANCEL coordonatele punctului se scriu în sUp, la care
degetul a fost retras. Totul se deduce în TextView. Se returnează valoarea true-singuri am prelucrat
evenimentul.

6. Fire de execuție în android,clasa Thread, metodele (explicația), exemplu,

http://developer.android.com/intl/ru/guide/components/processes-and-threads.html
Сând componentul aplicației se pornește la absența altor componente care lucrează, sistemul
Android pornește un nou proces Linux pentru aplicația cu un fir de execuție. Implicit toate
componentele aceleiași aplicații lucrează într-un proces și fir de execuție. Dacă componentul
aplicației se pornește la prezența procesului de execuție pentru această aplicație, atunci
componentul se pornește în acest proces și folosește firul de execuție. Dar se pot organiza execuția
componentelor aplicației în procese separate și crearea firelor de execuție suplimentar pentru oricare
proces de execuție.
Implicit toate componentele aceleiași aplicații lucrează într-un proces de execuție, majoritatea
aplicațiilor nu trebuie să schimbe aceast comportament. Dar, la necesitatea de a controla, pentru
care proces aparține un component anumit, aceasta se poate realiza în fișierul manifest.
La pornirea aplicației sistemul crează un fir de execuție pentru execuția aplicației, care se numește
principală. Acest fir de execuție este important, deoarece răspunde de dispersarea evenimentelor în
widget-uri corespunzătoare interfeței utilizatorului, și include și reprezentarea grafică a
evenimentelor. El reprezintă firul de execuție, în care aplicația interacționează cu componentele din
setul de instrumente a interfeței Android (componentele din pachetele android.widget și
android.view). Sistemul nu crează fir de execuție separat pentru fiecare exemplar al componentului.
Toate componentele, care se realizează într-un proces de execuție, crează exemplare în firul de
execuție , și apelurile de sistem fiecărui component care se trimit din firul de execuție. De aceia
metodele, care răspund pentru apelurile returnate de sistem (metode de tipul onKeyDown()),
întotdeauna se execută în firul de execuție a procesului.
De exemplu, cînd utilizatorul apasă o tastă pe ecran, firul de execuție aplicației trimite evenimentul
de atingere a ecranului în widget, care la rândul său, stabilește tasta în starea apăsată, și trimite
cerere pentru anularea ordinii evenimentelor. Firul de execuție exclude cererea din coada de
așteptare și anunță că el trebuie afișat repetat.
 Când aplicația execută un lucru intensiv, ca răspuns la acțiunea utilizatorului, acest model de fir
de execuție arată o performanță slabă, dacă aplicația este realizată incorect. Dacă aceasta se
întimplă în firul de execuție principal, efectuarea unor operații adăugătoare, ca accesul la rețea sau
cereri spre baze de date, vor fi bloca interfața utilizatorului. Cînd un fir de execuție este blocat, nu se
pot prelucra evenimentele, inclusiv și evenimentele de afișare a modificărilor efectuate. Pentru
modelul Android există 2 reguli principale:
1 de a nu se bloca firul de execuție principal;
2 de a nu se apela la setul de istrumente interfeții Android exterior firului de execuție.
Pentru a accesa firul de execuție principal din alte fire de execuție, se utilizează următoarele
metode:
 Activity.runOnUiThread(Runnable)
 View.post(Runnable)
 View.postDelayed(Runnable, long)
Exemplu de creare a unui fir de execuție:

public void onClick(View v) {

new Thread(new Runnable() {
public void run() {
final Bitmap bitmap = loadImageFromNetwork("http://example.com/image.png");
mImageView.post(new Runnable() {
public void run() {
mImageView.setImageBitmap(bitmap);
}
});
}
}).start();
}
Astfel, operația se va efectua din firul de execuție separat, iar ImageView va lucra din firul de execuție
principal. Pentru a prelucra interacțiuni complexe cu firul de execuție de lucru, se poate utiliza metoda
Handler în firul de execuție pentru a prelucra mesajele, care vin din firul de execuție principal. Cea
mai bună soluție este de a extinde clasa AsyncTask, care facilitează executarea sarcinilor firului de
execuție de lucru, care trebuie să interacționeze cu firul de execuție principal.
7. Services, definiție, exemplu, descrierea metodelor
http://developer.android.com/intl/ru/guide/components/services.html
http://developer.alexanderklimov.ru/android/theory/services-theory.php
http://startandroid.ru/en/uroki/vse-uroki-spiskom/157-urok-92-service-prostoj-primer
Service reprezintă componentul aplicației, care poate efectua operații de lungă durată în regim de
fundal, și nu conține interfața de utilizator. Alt component al aplicației care poate porni un serviciu,
care să continue lucrul în regim de fundal în cazul cînd utilizatorul va trece în altă aplicație.
Componentul poate la fel să fie atașat unui serviciu pentru interacțiunea cu ea și chiar să
îndeplinească interacțiuni între procese (IPC). Aceste servicii sunt reprezentate de clasa
android.app.Service. Servicii lucrînd în regim de fundal îndeplinesc cerințele de rețea spre web
server, prelucrînd informația, pronirea notificărilor. Serviciul poate fi pornit și continuă sa lucreze pina
cind, el nu va fi orpit sau pina cind el nu se va stinge singur. Android da serviciilor o prioritate majora,
comparativ activitatilor care nu functioneaza la moment, de aceia probabilitatea ca ele sa fie finisate
din caua lipsei de resurse, se micsoreaza considerabil.
Pentru a crea un serviciu, trebuie de creat o clasa noua, care va extinde clasa de baza Service. In
urma crearii acestei clase se obtine:

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class MyService extends Service {
public MyService() {
}

@Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
throw new UnsupportedOperationException("Not yet implemented");
}
}

Iar serviciul se inregistreaza automat in manifest in sectiunea <aplication>

<service
android:name=".MyService"
android:enabled="true"
android:exported="true" >
</service>

In MainActivity

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;

public class MainActivity extends Activity {

final String LOG_TAG = "myLogs";
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

public void onClickStart(View v) {

startService(new Intent(this, MyService.class));
}

public void onClickStop(View v) {

stopService(new Intent(this, MyService.class));
}
}
Aici sunt 2 metode care se declanseaza la tastarea butonului Start service si Stop service. In ele
corespunzator se pornesc sau se opresc servicii prin intermediul metodelor startService si
stopService. Pentru inceput se transite un in intent care indica serviciul.
La tastarea Start service se executa 2 metode onCreate- se creaza serviciul, si
onStartCommand- serviciul executa continutul metodei onStartCommand.
Daca se tasteaza din nou Start service, metoda onCreate nu se apeleaza si se indeplineste
metoda onStartCommand. Daca se tasteaza Stop service atunci prin intermediul metodei
onDestroy serviciul se distruge.
8. BroadcastRecivier
http://developer.alexanderklimov.ru/android/theory/broadcast.php
http://developer.android.com/intl/ru/reference/android/content/BroadcastReceiver.html

9. XML
https://ru.wikipedia.org/wiki/XML
XML (eXtensible Markup Language), descendent al SGML (Standard Generalized Markup Language)
este un meta-limbaj utilizat in activitatea de marcare structurala a documentelor, a cărei specificatie a fost
dezvoltata incepand cu 1996 in cadrul Consortiului World Wide Web (W3C), de un grup de cercetare
condus de Jon Bosak de la Sun Microsystems, la care au aderat ulterior o serie de grupuri de experti din
comunitatile academice (Text Encoding Initiative, NCSA, James Clark) si industriale (SUN, IBM,
Netscape, Oracle, Adobe etc.). Prima versiune de XML a fost standardizata in februarie 1998, ulterior
acest standard a mai fost revizuit de doua ori in octombrie 200 si respectiv in februarie 2004.
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

1 Elementele
Elementele sunt blocurile de baza ale unui document XML. Pot fi folosite atat pentru a retine informatii,
cat si pentru definirea structurii. Un element incepe cu un tag de start si se termina cu corespunzatorul
tag de sfarsit:

<nume_tag > ........ </nume_tag >

tagul de start

tagul de sfarsit
2 Atribute
Atributele au rolul de a descrie elementele. Putem face o analogie intre atribute – care descriu elemente
si adjective – care descriu substantive.
Atributele in XML sunt aceleasi cu atributele din HTML. De exemplu, un atribut al elementului <table> ar
fi align="center". Atributele sunt localizate in tag-ul de start al unui element, imediat dupa numele
elementului, (acum este evident de ce nu pot apare spatii albe in numele unui element), sunt urmate de
semnul ‘=’, care este urmat de valoare atributului intre ghilimele. Daca valoarea unui atribut nu este intre
ghilimele va fi semnalata eroare de catre analizorul XML, la fel ca si in cazul in care pentru un atribut nu
ar apare si valoarea acestuia.
Pentru un element pot exista oricate atribute, atat timp cat sunt declarate corect. Exemplu
<?xml version="1.0"?>
<BIBLIOTECA>
<CARTE cota="12345">
<TITLU>XML Bible</TITLU>
<AUTOR>Elliotte Rusty Harold</AUTOR>
<EDITURA> IDG Books Worldwide</EDITURA>
<AN_APARITIE>2002</AN_APARITIE>
</CARTE>
</BIBLIOTECA>

3 Comentarii
Comentariile sunt secevente de caractere ce pot aparea oriunde in document in afara altor marcaje
ce sunt utilizate pentru a descrie anumite detalii legate de continutul si structura documentului
programatorului. Ele nu fac parte din datele caracter ale documentului; un procesor XML poate, dar
nu este nevoie, sa dea un acces aplicatiilor la comentarii.
Un comentariu incepe cu secventa <!-- si se incheie cu -->.

De ce folosim XML in Android in Layout si nu alt ceva ?

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

Exemplu unui XML implementat intr-un layout pe Android

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="40dp"
android:paddingBottom="@dimen/activity_vertical_margin" tools:context=".MainActivity"
android:orientation="vertical"
android:gravity="center_horizontal"
android:background="#7E57C2">
<Button
android:layout_margin="30dp"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/browser"
android:id="@+id/browser"
android:layout_marginTop="40dp"
android:width="600dp" />
<RadioGroup
android:id="@+id/select_radio_button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:layout_margin="20dp"
>
<RadioButton
android:layout_weight="0.5"
android:layout_width="0dp"
android:layout_marginRight="10dp"
android:layout_height="wrap_content"
android:text="@string/radio_button_front"
android:id="@+id/radioButton_front"
android:checked="true" />
<RadioButton
android:layout_weight="0.5"
 android:layout_width="0dp"
android:layout_marginLeft="10dp"
android:layout_height="wrap_content"
android:text="@string/radio_button_back"
android:id="@+id/radioButton_back"
android:checked="false" />
</RadioGroup>
</LinearLayout>

10. Async
Prin intermediul clasei AsyncTask se permite mutarea operațiilor costisitoare din punct de vedere al
utilizării procesorului și al memoriei pe fire de execuție rulate în fundal, oferind sincronizarea cu firul de
execuție ce randează interfața grafică, acesta fiind notificat cu privire la progresul realizat cât și cu privire la
momentul în care procesarea a fost terminată.
Întrucât clasa AsyncTask nu este persistentă în cazul (re)pornirii unei activități (situație în care firul
de execuție asociat este distrus), se recomandă utilizarea sa pentru procese de fundal care nu durează o perioadă
de timp prea mare.
O implementare a clasei AsyncTask poate fi parametrizată cu tipurile de date care sunt folosite pentru
intrare, pentru raportarea progresului și pentru ieșire (rezultate).
În situația în care nu se dorește transmiterea unor parametrii de intrare / ieșire sau nu este necesară
raportarea progresului, se poate utiliza valoarea Void pentru toate aceste tipuri.
Este necesară suprascrierea următoarelor metode:
 doInBackground() - metoda care va fi executată pe firul de execuție dedicat, care primește
parametrii de intrare de tipul specificat; acesta trebuie să conțină procesările complexe care se
doresc a fi realizate fără a interacționa însă cu firul de execuție principal; notificările sunt
realizate:
 prin intermediul metodei publishProgress(), care primește ca parametru progresul
realizat, valorile fiind transmise metodei onProgressUpdate();
 prin întoarcerea unui rezultat, atunci când procesarea este terminată, valoarea fiind
transmisă metodei onPostExecute();
 onProgressUpdate() - folosită pentru actualizarea interfeței grafice, cu valorile primite de la
metoda publishProgress(); metoda este sincronizată cu firul de execuție principal (care
randează interfața grafică), astfel încât diferitele controale pot fi accesate de aici;
 onPostExecute() - apelată în momentul în care procesarea este terminată, primind ca parametru
rezultatul întors de metoda doInBackground(); metoda este sincronizată cu firul de execuție
principal (care randează interfața grafică), astfel încât diferitele controale pot fi accesate de
aici.
private class SomeAsyncTask extends AsyncTask<String, Integer, String>{
@Override
protected String doInBackground(String... parameter) {
String result = new String();
int progress = 0;
for (int k = 1; k <= parameter[0].length(); k++) {
progress = k;
result += parameter[0].charAt(parameter[0].length() - k);
try {
Thread.sleep(100);
} catch (InterruptedException interruptedException) {
Log.e(Constants.TAG, "An exception has occurred:
"+interruptedException.getMessage());
}
publishProgress(myProgress); } return result; }
@Override
protected void onProgressUpdate(Integer... progress) {
asyncTextView.setText(progress[0].toString()); }
@Override
protected void onPostExecute(String result) {
asyncTextView.setText(result); } }
 Rularea unui obiect de tip AsyncTask se face prin invocarea metodei execute() care primește ca
parametru informațiile care se doresc a fi procesate.
Fiecare obiect de tip AsyncTask poate fi rulat o singură dată. Apelurile ulterioare ale metodei
execute() vor genera excepții.

11. Metode de sincronizare a thread-urilor

Conceptul de thread (fir de executie) este folosit in programare pentru a eficientiza executia
programelor, executand portiuni distincte de cod in paralel, in interiorul aceluiasi proces. Cateodata
insa, aceste portiuni de cod care constituie corpul threadurilor, nu sunt complet independente si in
anumite momente ale executiei, se poate intampla ca un thread sa trebuiasca sa astepte executia
unor instructiuni din alt thread, pentru a putea continua executia propriilor instructiuni. Aceasta
tehnica prin care un thread asteapta executia altor threaduri inainte de a continua propria executie,
se numeste sincronizarea threadurilor. Java ofera urmatoarele facilitati pentru sincronizarea
threadurilor:
 mecanismul synchronized
Cuvantul cheie synchronized asigura
 că numai un singur fir poate executa un bloc de cod, în același timp;
 că fiecare thread de înregistrare a unei bloc sincronizat de cod vede efectele tuturor modificărilor
anterioare, care au fost pazite de aceeași blocare.
 metodele: wait, notify, notifyALL - Principiul de lucru : cum numai pripul thread nimereste in
bloc synchronized, el devine proprietarul obiectului si il bolocheaza. Nici un alt thread nu o sa
poata sa nimereasca in bloc, adica sa devina proprietarul acestui bloc, atita timp, ca proprietarul
curent nu il va elibera iesind din blocul de sinhronizare.

Sincronizarea este necesara pentru accesul reciproc exclusiv la blocuri de comunicare și de încredere
între fire.

16. Protocolul HTTP

https://ro.wikipedia.org/wiki/Hypertext_Transfer_Protocol
HTTP - HyperText Transfer Protocol este metoda cea mai des utilizată pentru accesarea informațiilor
în internet care sunt păstrate pe servere. Protocolul definește reguli de comunicare, care permit
înterpretarea corectă a cererilor și răspunsurilor efectuate în rețea dintre server și client.
Modul de funcționare
HTTP oferă o tehnică de comunicare prin care paginile web se pot transmite de la un computer aflat
la disntață spre propriul computer. Dacă se apelează un link sau o adresă de web, atunci se cere
calculatorului host să afișeze o pagină web (index.html sau altele). În caz dacă dintr-un anumit motiv
informațiile nu pot fi transmise, atunci serverul trimite înapoi un mesaj de eroare.
Erori de HTTP
Erorie de HTTP sunt clasiificate în 5 clase (categorii). Acestea sunt:
 1xx - erori informaționale: această clasă a status-ului indică un răspuns provizoriu al
serverului și conține numai linia de status (de răspuns) sau alte aplicații opșionale. Nu sunt
aplicații necesare pentru această clasă de răspunsuri.
100 - continuă: utilizatorul ar trebuie să își continue cererea/acțiunea. Acest răspuns
provizoriu este folosit pentru a infroma 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: Serverul înțelege și are intenția de a dîndeplini cererea
utilizatorului, răspunzînd prin această eroare că părțile ale serverului sunt în proces de
schimbare/mutare. Serverul va schimba protocolul imediat după ce răspunsul pentru linia 101
va fi terminată.
 2xx - răspuns reușit: clasa de răspuns ce indică utilizatorului că cererea a fost primită,
înțeleasă și acceptată cu succes.
200 - ok: acestă cerere a fost executatp cu succes. Informația a revenit cu un răspuns pozitiv,
indiferent de modul în care sa făcut cererea.
201 - creat/realizat: Cererea a fost îndeplinită avînd ca rezultat crearea unui nou rezultat.
Noul rezultat poate fi referit/raportat de către URL-urile înapoiate la intrarea răspunsului.
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ții utilizatori, fără a cere cpnexiunea clientului să insiste pînă ce procesul/cererea e
completă.
203 - informație neautorizată: informația returnată/revenită nu e difinitivă ca fiind din server-
ul principal, ci e adunată/recepționată de la un server local.
204 - fără conținut: Serverul a îndeplinit cererea și nu e nevoit să întoarcă răspunsul, dar ar
dori să răspundă printr-o informație recentă.
205 - conșinut refăcută: Cerera a fost îndeplinită și ar trebui ca browser-ul să poată
modifica/reseta modul de vizualizare a documentului ce a cauzat această cerere către server.
206 - conținutul parțial: Serverul a îndeplinit parțial cererea de primire de la sursă.
 3xx - redicționări: această clasă de răspunsuri indică faptul că acțiunile următoare vor trebui
făcute de browser pentru a putea fi îndeplinită cererea. Cererea ar putea fi direcționată de
browser fără a interacționa cu utilizatorii dacă și numai dacă metoda folosită în cea de a doua
cerere este ”Primit/Recepționat” sau ”Direcționat/Condus”
300 - modificat/mutat permanent: Sursa cererii corespunde unor seturi de descrieri, fiecare
cu locații specifice, iar browser-ul dat fiind negocierea infromației, primește răspunsul astfel
încât utilizatorul/browser-ul să poată alege modul dorit astfel încât redirectarea să fie spre
acea locație. În cazul în care cererea a fost de tip „Condus/trimis”, răspunsul ar trebui să
includă o intrare cu lista caracteristicilor și locațiilor de unde utilizatorul sau browser-ul poate
alege sursa cea mai apropiată.
301 - modificat/mutat permanent:
Cererii i-a fost atribuite o sursă nouă și permanentă URI iar cererile următoare ar trebui să
folosească una din sursele returnate URI. Dacă acest mesaj/cod este primit ca răspuns al
unei cereri tip „Primit/recepționat” sau „Direcționat/condus”, browser-ul nu trebuie să
redirectționeze automat cererea, doar dacă nu poate fi confirmată de către utilizator.
302 - găsit:
Sursa cererii este temporar pe un alt URI. În cazul în care redirectarea ar putea fi schimbată
ocazional, utilizatorul ar trebui să folosească în continuare cererea URI (Request-URI) în
cazul unor cereri ulterioare.
Dacă mesajul/statusul 302 este recepționat ca răspuns al unei cereri alta decât
„Primit/recepționat” sau „Direcționat/condus”, browser-ul nu trebuie să redirecteze automat
cererea dacă aceasta nu poate fi confirmată de cărte utilizator.
303 - vezi alta sursă:
Răspunsul cererii poate fi găsit sub un diferit URI și ar trebui să fie recepționat folosind metoda
„Primit/recepționat” de la acea sursă.
304 - nemodificat:
În cazul în care clientul a efectuat o cerere de tip „Primit/recepționat” și accesul este permis,
dar documentul nu a fost modificat, serverul ar trebui să răspundă cu acest mesaj/status.
305 - folosește proxy:
Cererea trebuie accesată printr-un proxy dat de către câmpul de locație. Acesta este dat de
către URI. Beneficiarul va repeta acestă unică cerere prin intermediul unui proxy. Răspunsul
305 va fi generat doar de către serverul de origine.
306 (nefolosit):
Acest mesaj/status a fost folosit într-o vesiune anterioară a specificațiilor deci nu mai este
folosit, el fiind reținut.
307 - redirectare temporară:
 Sursa cerută se află temporar la un diferit URI. Din moment ce redirectarea poate fi modificata
ocazional, utilizatoarul ar trebui să continuie să folosească URI-ul cerut pentru viitoarele
acțiuni.
 4xx - erori ale utilizatorilor: această clasă de mesaje este folosită în cazurile în care
utilizatorul ar putea greși formularea cererii. Excepția fiind răspunsurile 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 permanentă. Aceste răspunsuri sunt aplicabile pentru
orice fel de cerere. Browser-ele ar trebui să arate orice intrare cerutp 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:
Cererea necesită autentificarea/înregistrarea utilizatorului. Răspunsul trebuie să includă
WWW - câmp de autentificare conținând o somație aplicabilă utilizatorului. Utilizatorul poate
repeta cererea. Dacă cererea deja includea câmpul de autorizare, atunci raspunsul 401 indică
faptul că autorizarea a fost refuzată. Dacă răspunsul 401 conține aceeași somație ca răspuns
principal iar browser-ul a executat autentificarea cel puțin o dată, atunci utilizatorul ar trebui
să i se prezinte intrarea dată în răspuns, din moment ce aceasta include informații relevante.
402 - necesită plata:
Rezervat pentru utilizare ulterioară.
403 - interzis:
Serverul a înțeles cererea, dar refuză să o îndeplinească. Autorizarea nu ajută în nici un caz,
iar cererea nu ar mai trebui repetata.
404 - negăsit:
Serverul nu a găsit nimic care să corespundă cererii URL. Nu se dau indicații despre condiția
temporară sau permanentă.
405 - metodă nepermisă:
Metoda specificată în linia de cerere (Request-Line) nu este permisă de către sursa
identificată după URI-ul cerut.
406 - neacceptat:
Sursa identificată de cerere este capabilă să genereze doar intrări care au conținut specific
neacceptat de către condițiile de acceptare trimise prin cerere.
407 - autentificare prin proxy:
Mesajul este similar celui 401, dar indică situația în care utilizatorul trebuie să se autentifice
prin proxy.
408 - cerere expirată:
Utilizatorul nu a făcut cererea în timpul în care serverul era pregătit sa o aștepte. Se poate
repeta cererea fără modificări prealabile.
 5xx - erori de server: răspunsurile ce încep cu unitatea/cifra 5 indică cazurile în care serverul
e conștinet de greșelile produse sau e incapabil să execute cererea.Excepție facînd raspunsul
unei cereri ”Direcționat/Condus”, serverul ar trebui în acest caz să includă o afișare cu o
explicație a situațiri de eroare fie că e temporara sau permanentă.
500 - eroare internă de server:
Server-ul a întâmpinat o condiție neașteptată și o previne spre a putea îndeplini cererea.
501 - neîndeplinit/nerecunoscut:
Server-ul nu poate suporta funcționalitatea cerută pentru a putea îndeplini cererea. Acesta este
răspunsul specific în cazurile în care server-ul nu recunoaște metoda de cerere și nu e capabil să
o suporte indiferent de mijloc/resursă.
502 - poartă/ieșire greșită:
Server-ul, în timp ce încerca să se comporte ca o poartă/ieșire sau ca un proxy, a recepționat un
răspuns invalid de la un server de deasupra/anterior în încercarea de a îndeplini cererea.
503 - serviciu nedisponibil:
 În prezent server-ul nu poate să se ocupe de cererile trimise din cauza unei supraîncărcări sau a
serviciilor de întreținere a server-ului ce au loc în acel moment. Aceasta este o stare temporară și
în curând va fi remediată.
504 - poartă/ieșire expirată:
Server-ul, în timp ce încerca să se comporte ca o poartă/ieșire sau ca un proxy, nu a primit un
răspuns la timp de la serverele de deasupra/anterioare lui specificat de URI (ex. HTTP, FTP,
LDAP) sau de la un server auxiliar (ex. DNS) necesar accesării în încercarea de a
termina/îndeplini cererea.
505 - versiunea HTTP nu e suportată/susținută:
Serveru-l nu suportă sau refuză să suporte versiunea de protocol a HTTP ce a fost folosită în
formularea cererii. Server-ul sugerează că e incapabil să completeze/termine cererea folosind
aceeași versiune cu cea a clientului.
Versiunile HTTP
1. HTTP/0.9 - prima versiune realizată de Tim Berners-Lee și echipa sa. Această versiune este foare
simplă, dar cu numeroase neajunsuri, fiind repede înlocuită de alte versiuni.
2. HTTP/1.0 - versiunea introdusă în 1996 prin RFC1945. a adus numeroase îmbunătățiri.
3. HTTP/1.1 - versiune de îmbunătățire și reparare a neajunsurilor versiunilor anterioare.
În prezent se utilizează două versiuni ale protocolului, HTTP/1.0 și HTTP/1.1. La versiunea HTTP/1.0
se stabilește o nouă conexiune TCP înaintea cererii, iar după transmiterea răspunsului conexiunea
trebuie închisă. Astfel dacă un document HTML cuprinde 10 imagini, vor fi necesare 11 conexiuni
TCP, pentru ca pagina să fie afișată complet (în browser). La versiunea 1.1 se pot emite mai multe
cereri și răspunsuri pe aceeași conexiune TCP. Astfel pentru documentul HTML cu 10 imagini este
necesară doar o singură conexiune TCP. Deoarece - datorită algoritmului Slow-Start - viteza
conexiunii TCP este la început mică, dar acum el e necesar doar o singură dată, se scurtează
semnificativ durata totală de încărcare a paginii. La aceasta se adaugă și faptul că versiunea 1.1
poate relua și continua transferuri întrerupte.
La HTTP se pierd informațiile cererilor vechi (deci este un protocol fără reținerea stării). Prin utilizarea
de cooki-uri în header, se pot realiza însă aplicații care pot utiliza informații de stare (opțiunile
utilizatorului din sesiunea actuală, coș de cumpărături ș.a.). Chiar și o recunoaștere a utilizatorului
este astfel posibilă. În mod normal se pot citi informațiile transmise care parcurg rețeaua pe
computere și rutere. Prin HTTPS transferul se poate și cripta.
Versiunea cea mai recentă se poate utiliza în chat-uri prin utilizarea MIME-tip-ului multipart/replace,
care reînnoiește complet conținutul ferestrei browser-ului. Noua versiune permite pe lângă preluarea
datelor, și transmiterea lor la server. Cu ajutorul metodei "PUT" web-designerii pot să-și publice
paginile web pe webserver prin WebDAV, iar prin metoda "DELETE" ei pot chiar și șterge pagini de
pe server.
De asemenea, HTTP/1.1 mai oferă metoda "TRACE" prin care se poate urmări calea spre webserver,
și verifica dacă datele au fost corect transferate. Astfel se poate urmări calea prin diferite proxi-uri
spre webserver, echivalent cu un traceroute la nivel aplicație.
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.
PUT: metoda este folosită pentru a depune documente peserver, 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.
17. TCP / IP
TCP - reprezintă o totalitate de reguli prin care se comunică doua sau mai multe calculatoare prin
intermediului internetului. TCP desfășurat transmission control protocol, acest protocol este de tip
transport, adica prin TCP protocol se face transferuri de date ( datele sunt segmentate, iar
segmentele la rîndul lor sunt denumite cu un nume unic ). Elementele TCP sunt IP, mask și gateway.
IP - internet protocol adress care este unic pentru fiecare calculator. Sunt 3 clase IP prima este clasa
A, adoua B și C. Fiecare clasa are regulile sale: clasa A are un diapazon 1.0.0.0 - 126.255.255.255,
clasa B diapazon 128.0.0.0 - 191.255.255.255 și clasa C 192.0.0.0 - 223.255.255.255 clasa C este
cel mai des utilizată, adresa 127.0.0.1 este adresa locală și reprezintă un din adrese excepții.
Mask - reprezintă o tehnică de limitre a diapazonului din diferite clase exemplu avem adresa
192.168.0.0 cu mask-a 255.255.255.0 aceasta înseamnă că diapazonul este de la 192.168.0.1 -
192.168.0.254
alt exemplu aceeași adresa cu mask-a 255.255.255.128 diapazonul 192.168.0.1 -
192.168.0.127.
Gateway - nu toate calculatoarele fac acces direct la internet, unele fac conectare printr-un
server numit gateway care primește cererea cu adresa calculatorului solicitat și îl deservește prin
executare cautării raspunsului deacum în internet, înainte de a începe procesul gateway folosește o
tehnica numită NAT care interschimbă IP adresele din gateway. (coroce astai tipa SETCĂ).
În concluzie TCP reprezintă niște reguli ce comunicare dintre două sau mai multe calculatoare care
fac transfer de date cu condiția că transferurile nu sunt de dorit să se piardă. COmparativ cu UDP
(user datagram protocol) TCP este mai lent dar mai sigur.

18. UDP
UDP - user datagram protocol reprezintă un protocol din stiva de protocoale la nivel de transport,
adica prin protocolul UDP se realizează comunicarea calculoatoarelor prin transferuri de date.
Diferența dintre UDP și TCP este că UDP nu este sigur dar este rapid.

Întrebari General

19. Medii de dezvoltare (Visual Studio, XAMARIN) Java/C# .NET (Platforma)

20. Diferente dintre versiuni la .NET (3.5,4.0,4.5, 4.5.1)

.net 3.5 --
 foloseste Common Language Runtime (CLR) 2.0,
 Au fost adăugate două componente de servicii de date noi, Cadrul Entitate ADO.NET
ADO.NET și a datelor Serviciilor.
 Două ansambluri noi de dezvoltare web, System.Web.Abstraction și System.Web.Routing,
au fost adăugate; acestea sunt utilizate în MVC Cadrul ASP.NET și, potrivit surselor, vor fi
utilizate în eliberarea viitoare a ASP.NET Forms
 prezentat, de asemenea, un nou set de controale numite "pachete Visual Basic de
alimentare", care a adus înapoi controalele Visual Basic, cum ar fi "Line" și "Shape".

.NET Framework 4
- Extensii paralele pentru a îmbunătăți sprijinul pentru calcul paralel , care vizează multi- core sau
sisteme distribuite.
 tehnologii , cum ar fi PLINQ ( Parallel LINQ ) ,
 o implementare paralelă a motorului LINQ , și operativ Biblioteca paralel , care expune
construcții paralele prin apeluri de metode .
 Noile caracteristici Visual Basic .NET și C # limbă , cum ar fi continuări implicite de linie ,
expediere dinamic , parametrii numiți și parametrii opționali .
 Suport pentru Contracte de cod.
Includerea de noi tipuri de a lucra cu aritmetica arbitrar - precizie (
 System.Numerics.BigInteger ) și numere complexe ( System.Numerics.Complex ) .
Introduce Common Language Runtime ( CLR ) 4.0 .

.NET Framework 4.5

 .NET Framework 4.5 utilizează Common Language Runtime 4.0, cu unele caracteristici
suplimentare de rulare.

 .NET Pentru Metro stil apps

Apps Metro-stil au fost inițial proiectate pentru factori de formă specifice și pârghie de
putere a sistemului de operare Windows. Un subset al .NET Framework este disponibilă
pentru construirea de aplicații Metro-stil pentru Windows 8 și mai târziu, folosind C # sau
Visual Basic. Acest subset se numește API .NET pentru aplicații. Această versiune a .NET
Framework, precum și runtime și biblioteci folosi aplicații Metro-stil, este o parte a Windows
Runtime, noul model platforma si de dezvoltare pentru aplicații Metro-stil. Este un ecosistem
care adăpostește mai multe platforme și limbi, inclusiv .NET Framework, C ++ și HTML5 cu
JavaScript.

 Suport consolă pentru codificarea Unicode (UTF-16).

 Suport pentru versiunilor de date comanda șir și compararea culturale.

 Performanță mai bună atunci când preluarea resurselor.

 Suport nativ pentru compresie Zip (versiunile anterioare susținut algoritmul de compresie,
dar nu formatul arhivă).

 Abilitatea de a personaliza un context de reflecție pentru a trece peste comportamentul

implicit reflecție prin clasa CustomReflectionContext.

 Noile caracteristici asincrone au fost adăugate la C # și Visual Basic limbi. Aceste

caracteristici se adaugă un model bazat pe sarcini pentru efectuarea operațiunilor
asincrone, [48] [49] de punere în aplicare contracte futures și promisiuni

 Capacitatea de a reduce repornirea sistemului prin detectarea si inchiderea .NET

Framework 4 aplicații în timpul de implementare. Vezi Reducerea Repornește sistemului în
.NET Framework 4.5 Instalații.

 Suport pentru tablouri care sunt mai mari de 2 gigaocteți (GO) pe platforme pe 64 de biți.
Această caracteristică poate fi activată în fișierul de configurare cerere.

 Performanță mai bună prin fundal de colectare a gunoiului pentru servere. Când utilizați de
colectare a gunoiului de server în .NET Framework 4.5, de colectare a gunoiului de fundal
este activată în mod automat. Consultați secțiunea colectarea gunoiului de fond Server a
fundamentelor de colectarea gunoiului subiect.
  Fundal just-in-time (JIT) compilarea, care este disponibil opțional pe procesoare multi-core
pentru a îmbunătăți performanța aplicațiilor.

.net 4.5.1

 Puteți utiliza Windows Runtime API-uri în bibliotecile portabile care vizează Ferestre 8.1,
Windows Phone 8.1, și Windows Phone 8.1 Silverlight.
 Puteți include (tipuri Windows.UI.XAML) XAML în biblioteci portabile atunci când vizați
pentru Windows 8.1 sau Windows Phone 8.1. Următoarele șabloane XAML sunt suportate:
Blank Page, de resurse dicționar, templated control, și de control al utilizatorului.
 Puteți crea o componentă portabil pentru Windows Runtime (fișier .winmd) pentru utilizarea
în aplicații Store care vizează Ferestre 8.1 și Windows Phone 8.1.
 Puteți retarget o bibliotecă Windows Store sau Windows Phone Store clasa ca o clasa
Biblioteca portabil.
 Pentru mai multe informații despre aceste modificări, a se vedea Cross-Platform Dezvoltare
cu Class Library portabil.
 Conținutul .NET Framework seta acum include documentația pentru NET nativ, care este o
tehnologie precompilarea pentru construirea și implementarea de aplicații Windows. .NET
Native compilează aplicațiile dvs. direct la cod nativ, mai degrabă decât la limba intermediar
(IL), pentru o performanță mai bună. Pentru detalii, a se vedea Compilarea Apps cu .NET
Native.
 Cadru sursa de referință NET oferă o nouă experiență de navigare și funcționalitate sporită.
Puteți naviga acum prin codul sursă .NET Framework on-line, descărcați de referință pentru
vizionare offline, și pas prin sursele (inclusiv patch-uri și actualizări) în timpul de depanare.
Pentru mai multe informații, consultați intrarea blog un nou aspect pentru .NET sursă de
referință.
 Noi caracteristici și îmbunătățiri în .NET Framework 4.5.1 de bază includ:
 Redirecționarea automată de legare pentru ansambluri. Începând cu Visual Studio 2013,
când compilați o aplicație care vizează Framework 4.5.1, redirecționări de legare pot fi
adăugate la fișierul de configurare app dacă aplicația dvs. sau a componentelor sale de
referință mai multe versiuni din același ansamblu. Asemenea, puteți activa această
caracteristică pentru proiectele care vizează versiuni mai vechi ale .NET Framework. Pentru
mai multe informații, consultați Cum să: Activarea și dezactivarea automată redirecționare
obligatorii.
 Abilitatea de a colecta informații de diagnosticare pentru a ajuta dezvoltatorii îmbunătăți
performanța aplicațiilor server și cloud. Pentru mai multe informații, a se vedea metodele
WriteEventWithRelatedActivityId și WriteEventWithRelatedActivityIdCore din clasa
EventSource.
 Abilitatea de a compacta explicit heap obiect mare (LOH) în timpul de colectare a gunoiului.
Pentru mai multe informații, consultați proprietatea
GCSettings.LargeObjectHeapCompactionMode.
 Îmbunătățiri suplimentare de performanță, cum ar fi ASP.NET suspendare app, imbunatatiri
JIT multi-core, și de pornire app mai repede după o modificare .NET Framework. Pentru
detalii, a se vedea .NET Framework 4.5.1 anunțarea și aplicația ASP.NET suspenda blog.

21. OOP

Principii OOP

Incapsularea

Incapsularea
Incapsularea se defineste ca fiind inglobarea si ascunderea datelor intr-o clasa(structura).
Ex C#
public class User
{
private string m_name;//aici incapsulam numele utilizatorului si il ascundem

public string Name

{
get
{
return m_name.ToUpper(); //putem formata rezultatul
}
set //putem valida "input"-ul
{
if (value != string.Empty) m_name = value;
else m_name = "No Name";
}
}
}

Abstractizarea
Abstractizarea
Putem defini abstractizarea ca fiind procesul de a lua obiecte reale si a le transforma in concepte
virtuale. Clasele si atributele pe care le definesc modeleaza lumea reala intr-un mod abstract. Ca
exemplu putem lua codul de mai sus, clasa User e modelul simplificat al unui utilizator de
computer, ea reprezinta o persoana care poate fi reala si are un nume atasat.
Ex. C#
class Program
{
static void Main(string[] args)
{
User u = new User();
u.Name = "Popescu Ion";
}
}

Mostenirea
Mostenirea
Mostenirea e capacitatea de a crea noi clase pornind de la definitii de obiecte deja existente,
aceste clase nou create au aceleasi proprietati si functionalitati ca si clasele parinte. Intr-un mod
simplist putem spune ca mostenirea ajuta la reutilizarea codului.
Ex. C#
public class Student : User
{
private float m_grade;

public float Grade

 {
get { return m_grade; }
set { m_grade = value; }
}
}

class Program
{
static void Main(string[] args)
{
Student s = new Student();
s.Name = "Popescu Ion";
s.Grade = 4.75F;
}
}

Polimorfismul
Dupa cum numele sugereaza e capacitatea obiectelor de a contine functionalitati diferite sub
acelasi nume, ca o consecinta directa a polimorfismului avem redefinirea metodelor, mai exact
aceeasi metoda poate executa actiuni diferite in functie de locul in care este implementata.
Polimorfism
Ex. C#

public class User

{
public override string ToString()
{
return "Sunt un User";
}
}

public class Student : User

{
public override string ToString()
{
return "Sunt un Student";
}
}

class Program
{
static void Main(string[] args)
{
User u = new User();
User s = new Student();
Console.WriteLine(u.ToString());
Console.WriteLine(s.ToString());
Console.ReadLine();
}
}
24. Cookies, history, temporary internet files
Un cookie este un fișier de mici dimensiuni, în general alcătuit din litere și cifre, care este descărcat
în memoria unui calculator (sau altui echipament folosit pentru navigare online - telefon mobil,
tabletă, etc), atunci când utilizatorul accesează un anumit site web.
Cookie-urile sunt create atunci când browserul folosit de către un utilizator afișează un anumit site
web. Site-ul web transmite informații către browser, iar acesta creează un fișier text. De fiecare
dată când utilizatorul accesează din nou respectivul site web, browserul accesează și transmite
acest fișier către serverul site-ului web. Altfel spus, cookie-ul poate fi văzut ca un card de
identificare a utilizatorului de Internet, care anunță site-ul web de fiecare dată când utilizatorul se
întoarce pe respectivul site.
Cookie-urile pot asigura o interacțiune mai rapidă și mai ușoară între utilizatori și site-urile web.
Spre exemplu, în momentul autentificării unui utilizator pe un anumit site web, datele de
autentificare sunt stocate într-un cookie; ulterior, utilizatorul poate accesa respectivul site fără să fie
nevoie să se autentifice din nou.
În alte cazuri, cookie-urile pot fi utilizate pentru stocarea de informații referitoare la activitățile
desfășurate de utilizator pe o anumită pagină web, astfel încât acesta să își poată relua ușor
respectivele activități la o accesare ulterioară a site-ului. Cookie-urile spun serverului ce pagini
trebuie să arate utilizatorului, astfel încât acesta să nu fie nevoit să își amintească acest lucru sau
să navigheze întregul site de la început. Astfel, cookie-urile pot fi asimilate unor „semne de carte”
care îi spun utilizatorului exact unde a rămas în cadrul unui site web.
În mod similar, cookie-urile pot stoca informații referitoare la produsele comandate de către
utilizator pe un site de comerț electronic, făcând astfel posibil conceptul de „coș de cumpărături”.
De asemenea, cookie-urile pot oferi site-urilor web posibilitatea de a monitoriza activitățile online
ale utilizatorilor și de a stabili profiluri de utilizatori, care pot fi apoi folosite în scopuri de marketing.
Spre exemplu, pe baza cookie-urilor pot fi identificate produsele și serviciile agreate de către un
utilizator, aceste informații servind ulterior la transmiterea de mesaje publicitare adecvate către
respectivul utilizator.
25. Internet cache, session
În informatică,memoria cache(sau simplu uncache) este o colecţie de date ce sunt o "copie la indigo"
a valorilor originale stocate altundeva sau calculate mai devreme, unde operaţia de aducere din
memorie a datelor originale este costisitoare (datorită timpilor mari de acces la memorie) sau costul
recalculării acestora este mare, în comparaţie cu costul citirii acestora din cache. Cu alte cuvinte, un
cache este o arie temporară de stocare unde datele utilizate în mod frecvent pot fi depozitate pentru
un acces rapid la acestea. Odată ce datele sunt stocate în cache, în viitor vor fi luate de aici şi utilizate
decât să se încerce readucerea datelor originale sau recalcularea acestora, astfel încât timpul mediu
de acces este mai mic.

Întrebari “De citit”

26. Kernel la Android, iOS, WP

Android
Kernelul Linux (cu unele modificări) conține driver-ele pentru diferitele componente
hardware (ecran, cameră foto, tastatură, antenă WiFi, memorie flash, dispozitive audio),
fiind responsabil cu gestiunea proceselor, memoriei, perifericelor (audio/video, GPS,
WiFi), dispozitivelor de intrare/ieșire, rețelei și a consumului de energie.

iOS
Kernelul XNU, kernelul lui Darwin (Open source UNIX realizata de Apple). Este un kernel hybrid,
care contine functionalitati din mai multe kerneluri si microkerneluri, aceasta a fost facut pentru a
crea cele mai bune tehnologii asa ca modularizare inalte in iOS, memorie protejate si viteza inalta
de procesare.
30. .NET list
In proiectare electronice, un netlist este o descriere a conectivității al unui circuit electronic. Un
singur netlist este efectiv o colecție de mai multe liste aferente. În forma sa cea mai simplă, un
netlist constă dintr-o listă de terminale ("ace") a componentelor electronice într-un circuit și o listă a
conductoarelor electrice care interconectează terminalele. Un net este un conductor care
interconectează două sau mai multe terminale de componente.

32. Xpath, Xcode

33. Agility pack HTML
34. Multithreading
Principiul de multithreading presupune execuția mai multor thread-uri în același pipeline, fiecare având
propria secțiune de timp în care este menit să lucreze. Odată cu creșterea capabilităților procesoarelor
au crescut și cererile de performanță, asta ducând la solicitarea la maxim a resurselor unui procesor.
Necesitatea multithreading-ului a venit de la observația că unele procesoare puteau pierde timp prețios
în așteptarea unui eveniment pentru o anumită sarcină.
Foarte repede a fost observat potențialul principiului de paralelizare a unui proces, atât la nivel de
instrucțiune, cât și la nivel de fir de execuție. Firul de execuție sau thread-uleste un mic proces sau task,
având propriile instrucțiuni și date.
Ca și aplicabilitate, multithreading-ul poate fi folosit pentru sporirea eficienței atât în cadrul
multiprogramării sau a sarcinilor de lucru pe mai multe fire de execuție, cât și în cadrul unui singur
program. Astfel, un fir de execuție poate rula în timp ce alt fir de execuție așteaptă un anumit eveniment.
În ziua de azi, capacitățile oferite de acest tip de procesare sunt folosite până și la nivelul sistemului de
operare.
Pentru a putea beneficia de avantajele multithreading-ului, un program trebuie să poată fi despărțit în
secțiuni ce pot rula independent și în mod paralel, fiind foarte greu de utilizat în codul reprezentat de o
înșiruire foarte lungă de instrucțiuni. Gestiunea firelor de execuție este controlată de sistemul de
operare. Un exemplu de implementare a acestui concept este modalitatea prin care Microsoft Word
repaginează un document în timp ce utilizatorul scrie.
Conceptul de multithreading poate fi folosit și pentru accelerarea unui singur thread prin utilizarea,
atunci când procesorul nu este foarte solicitat, a execuției speculative pe mai multe căi și a firelor de
execuție ajutătoare.
Un procesor cu mai multe fire de execuție, capabil să proceseze multiple instrucțiuni din surse diferite
poartă numele de procesor cu multithreading simultan. Această tehnică prezintă cea mai mare
flexibilitate în acoperirea ineficiențelor procesoarelor cu un singur fir de execuție, depășind arhitecturile
multithreading cu granularitate fină sau aspră, deoarece aceasta permite execuția unei instrucțiuni din
orice fir de execuție în paralel cu procesarea altei instrucțiuni din alt fir de execuție.

35. Content providers (Android)

Content provider - este un wrapper (carapace) in care sunt incluse date. Daca aplicatia foloseste
baza de date SQLite, atunci numai aplicatia are acces la aceasta baza de date. Dar sunt situatii
cind datele ar fi trebuit sa fie comune. Exemplu simplu - numere de telefon in telefon sunt pastrate
in baza de date, dar voi doriti sa aveti acces la baza de date, ca aplicatia voastra tot sa poata
extrage aceste contacte. Standart, voi nu aveti accesul la baza de date a altei aplicatii, dar a fost
creat acest mecanism pentru partajarea datelor cu toti doritorii.
36. Evenimente ce sunt apelate de obiecte a UI

37. Platforme pentru concurenta

38. Json
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. Este un format text, inteligibil pentru
oameni, 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. JSON este alternativa
mai simplă, mai facilă decât limbajul XML.

40. Android Components(Fragments, Views, Layouts, Intents, Resources, Manifest)