UNIVERSITATEA POLITEHNICA DIN BUCUREȘTI FACULTATEA DE...
Transcript of UNIVERSITATEA POLITEHNICA DIN BUCUREȘTI FACULTATEA DE...
UNIVERSITATEA POLITEHNICA DIN BUCUREȘTI
FACULTATEA DE ELECTRONICĂ, TELECOMUNICAȚII ȘI TEHNOLOGIA
INFORMAȚIEI
PROIECT SISTEME DE OPERARE AVANSATE
Sistemul de operare Firefox OS
Profesor coordonator: Student:
Conf. dr. ing. Ștefan Stăncescu Lupe Bogdan
IISC an I
București
2015
1. Introducere ............................................................................................................................................ 3
1.1 Scurt Istoric ....................................................................................................................................... 3
2. Arhitectura Firefox OS.......................................................................................................................... 4
2.1 Gaia ......................................................................................................................................................... 4
2.2 Gecko ...................................................................................................................................................... 4
2.3 Gonk ........................................................................................................................................................ 4
2.4 Jank ......................................................................................................................................................... 5
2.5 Procedura de boot a sistemului de operare Firefox ................................................................................. 7
2.6 Procesul de bootstrapping ....................................................................................................................... 7
2.7 B2G ....................................................................................................................................................... 10
2.8 rilproxy .................................................................................................................................................. 10
2.9 Mediaserver........................................................................................................................................... 10
2.11 Gecko .................................................................................................................................................. 11
2.12 Hardware Abstraction Layer (HAL) ................................................................................................... 13
2.13 Procese și fire de execuție ................................................................................................................... 15
3. Securitatea Firefox OS ............................................................................................................................ 15
3.1 Securitatea platformei ........................................................................................................................... 15
3.2 Managementul de permisiuni ................................................................................................................ 16
3.3 Procesul de update al aplicațiilor securizat ........................................................................................... 17
3.4 Securitatea dispozitivului(Hardware) ................................................................................................... 18
3.5 Securitatea datelor ................................................................................................................................. 18
3.6 Securitatea aplicațiilor .......................................................................................................................... 19
4. Managementul memoriei .................................................................................................................... 20
4.1 Low memory killer(LMK) .................................................................................................................... 21
4.2 Low memory notifications .................................................................................................................... 21
5. Dezvoltare aplicatii ............................................................................................................................. 22
6. Analize comparative și concluzii ........................................................................................................ 24
Bibliografie ................................................................................................................................................. 28
1. Introducere
1.1 Scurt Istoric
Firefox OS (nume proiect: „Boot to Gecko”, de asemenea, cunoscut sub numele B2G)
este un sistem de operare open-source bazat pe kernel Linux pentru smartphone-uri și computere
mini și este setat pentru a fi utilizat pe telofoane inteligente. Acesta este dezvoltat de Mozilla,
organizația non-profit cel mai bine cunoscută pentru browser-ul Firefox.
Firefox OS este conceput pentru a oferi un sistem complet alternativ bazat pe comunitate
pentru dispozitive mobile, folosind standarde și abordări open-source, cum ar fi aplicații
HTML5, JavaScript, API-uri web pentru a comunica direct cu hardware-ul mobil, și „application
marketplace”. Ca atare, el concurează cu sistemele de operare dezvoltate comercial, cum ar fi
Apple iOS, Google Android, Windows Phone Microsoft și Sailfish OS dezvoltat de Jolla.
Firefox OS a fost prezentat public în februarie 2012, pe smartphone-uri Android-
compatibile. În ianuarie 2013 la CES 2013, ZTE a confirmat că vor fabrica un smartphone cu
sistem de operare Firefox, și la 02 iulie 2013 , Telefónica a lansat primul telefon comercial bazat
pe Firefox OS, ZTE Open, în Spania, care a fost urmat rapid GeeksPhone's Peak+. La 16
decembrie 2014, telefoanele OS Firefox sunt oferite de 14 operatori în 28 de țări din întreaga
lume.
În iulie 2012, „Boot to Gecko” a fost rebranduit ca "Firefox OS", după bine-cunoscutul
browser desktop Mozilla, Firefox, și capturi de ecran au inceput sa apara in luna august 2012. În
septembrie 2012, Analiștii analiștii de strategie prognozează că Firefox OS ar reprezenta în 2013
1% din piața de smartphone-uri la nivel mondial.
În februarie 2013 Mozilla a anuntat planurile pentru global comercial roll-out al Firefox-
ului. Mozilla a anunțat la o conferință de presă înainte de începerea Mobile World Congress de
la Barcelona că primul val de dispozitive OS Firefox vor fi disponibile pentru consumatorii din
Brazilia , Columbia, Ungaria, Mexic, Muntenegru, Polonia, Serbia, Spania și Venezuela. Mozilla
a anunțat, de asemenea, că LG Electronics, ZTE, Huawei și TCL s-au angajat să fabrice
dispozitive OS Firefox.
În decembrie 2013 noi caracteristici au fost adăugate cu release-ul 1.2, inclusiv de video-
conferință, autentificare SMS pentru facturare telefonică, notificări push îmbunătățite, precum și
setări pentru „Do Not Track”.
Async Pan și Zoom (APZ), incluse în versiunea 1.3, ar trebui să îmbunătățească viteza de
reacție a interfeței cu utilizatorul. Munca este in curs de optimizare ca Firefox OS sa ruleze pe o
platformă de 128 MB cu versiunea 1.3T. Un dispozitiv de 128 MB este deja terminat, care pare
să folosească această versiune. [1]
2. Arhitectura Firefox OS
Există câteva termeni specifici care ar trebui înțeleși înainte de a citi mai departe
documentația despre Firefox OS.
B2G, scurt pentru Boot to Gecko. Numele de cod dat de ingineri pentru sistemul de operare
Firefox OS. [2]
2.1 Gaia
Interfața de utilizare a platformei Firefox OS. Orice apare pe ecranul Firefox OS este un
produs a stratului Gaia. Gaia pune în aplicare ecranul de blocare, ecranul de start, și toate
aplicațiile standard care se așteaptă de la un smartphone modern. Gaia este implementat în
întregime folosind HTML, CSS, și JavaScript. Singura sa interfață cu sistemul de operare de
bază sunt API-uri web deschise, care sunt puse în aplicare de către stratul Gecko. Aplicații terțe
părți pot fi instalate alături stratul Gaia.
2.2 Gecko
Acesta este runtime-ul aplicației Firefox OS; că este, stratul care oferă tot sprijinul
pentru standardele deschise: HTML, CSS și JavaScript. Aceste API-uri funcționează bine pe
fiecare sistem de operare care suportă Gecko. Acest lucru înseamnă că Gecko include, printre
altele, o stivă de rețea, stiva grafică, motor de layout, o mașină virtuală JavaScript, și straturi de
portare.
2.3 Gonk
Gonk este sistemul de operare de cel mai mic nivel al platformei Firefox OS, format
dintr-un nucleu Linux (bazat pe proiectul Android Open Source (AOSP)) și nivelul de
abstractizare al hardware-ului în spațiul utilizator (HAL). Nucleul și mai multe dintre bibliotecile
de utilizator sunt proiecte comune open-source: Linux, libusb, Bluez, și așa mai departe. Unele
din alte părți ale HAL sunt partajate cu AOSP: GPS, camera foto, și altele. Se poate spune că
Gonk este o foarte simplă distribuție Linux. Gonk este o țintă de portare a Gecko; există un port
de Gecko pentru Gonk, la fel ca exista un port de Gecko pentru OS X, Windows, și Android.
Deoarece proiectul Firefox OS are control deplin asupra Gonk, se pot expune interfețe pentru
Gecko care nu pot fi expuse pe alte sisteme de operare. De exemplu, Gecko are acces direct
complet la stiva de telefonie și cadrul de afișare pe Gonk, dar nu are acest acces de pe orice alt
sistem de operare. [2]
2.4 Jank
Acest termen, folosit adesea în spațiul aplicațiilor mobile, se referă la efectul operațiunilor de
cod lente / ineficiente într-o aplicație, care blochează actualizarea UI și oface să devină laggy sau
nu raspunde.
Figura 1. Arhitectura generală [4]
Firefox OS elimină stratul API nativ între sistemul de operare și stratul de aplicație. Acest
design integrat reduce latența platformei și simplifică securitatea fără a sacrifica performanța sau
experiența unui utilizator de telefon inteligent.
Gaia este de nucleul aplicațiilor web ale dispozitivului, și stratul de interfață cu
utilizatorul, toate scrise în HTML5, CSS și JavaScript, cu un număr de API-uri expuse pentru a
permite codului UI să interacționeze cu hardware-ul telefonului și funcționalitatea Gecko.
Gecko este stratul de motor web și prezentarea în sistemul de operare Firefox care se
conectează hardware la HTML servind drept interfață între conținutul web și dispozitivul de
bază. Gecko oferă un parser HTML5 și un motor de randare, acces programatic la
funcționalitatea hardware prin API-uri web securizate, un cadru de securitate global,
management de update-uri, și alte servicii de bază.
Gonk este componenta la nivel de kernel în stiva sistemului de operare Firefox, care
servește ca interfață între Gecko și hardware-ul de bază. Gonk controlează hardware-ul de bază
și expune capabilități hardware pentru API-urile Web puse în aplicare de Gecko. Gonk poate fi
văzută ca și "cutia neagră", care înseamnă toate lucrările complexe, detaliate în spatele scenei
pentru a controla dispozitivul mobil prin prelucrarea cererilor la nivel hardware.
Dispozitivul mobil este hardware-ul telefonului mobil care rulează Firefox OS. OEM este
responsabil pentru furnizarea dispozitivul mobil. [4]
Figura 2. Arhitectura specifică [4]
2.5 Procedura de boot a sistemului de operare Firefox
Această secțiune descrie procesul prin care dispozitivele Firefox OS boot-ează, ce piese
sunt implicate, și cazul în care. Ca o referință rapidă, fluxul general de bootare a sistemului
merge de la bootloader în spațiul Kernel, la init în codul nativ, la B2G și apoi Gecko în spațiul de
utilizare, și apoi în cele din urmă la aplicația de sistem, managerul de ferestre, apoi app
homescreen în interiorul Gecko. Toate celelalte aplicații sunt executate pe partea de mai sus.
Figura 3. Procedura de boot [4]
2.6 Procesul de bootstrapping
Când un dispozitiv Firefox OS este în primul rând pornit, executarea începe în bootloaderul
primar. De acolo, procesul de încărcare a sistemului de operare se face în modul tipic; o
succesiune de bootloader de nivele din ce în ce mai superioare „bootstrap-ează” urmatorul loader
în lanț. La sfârșitul procesului, execuție este predată kernel-ului Linux.
Există câteva puncte de remarcat cu privire la procesul de boot: Bootloader afișa de obicei,
primul ecran splash văzut de către utilizator în timpul pornirii dispozitivului; aceasta este de
obicei un logo al furnizorului. Bootloader-ul afișează intermitent o imagine de aparat. Diferite
dispozitive utilizează diferite protocoale; cele mai multe telefoane folosesc protocolul fastboot,i
dar Samsung Galaxy S II utilizează protocolul odin. Până la sfârșitul procesului de bootstrap
imaginea modemului este, de obicei, încărcată și rulează pe procesorul de modem. Cum se
întâmplă acest lucru depinde extrem de dispozitivele folosite.
Nucleul (e) Linux folosit de Gonk este foarte similar cu Linux din care s-a derivat (bazat pe
proiectul Android Open Source). Există câteva modificări făcute de AOSP, în general, însă,
kernel-ul Linux este aproape cel stoc. [3]
Linux Kernel pornește dispozitivele și rulează procese esențiale. Acesta va executa procese
definite în init.rc și în init.b2g.rc ca să boot-eze procese esențiale ca B2G (proces de bază
FirefoxOS, conținând Gecko) și rild. La sfârșitul procesului, este lansat un proces de inițializare
mod utilizator, așa cum este în majoritatea sistemelor de operare UNIX-like.
Odată ce procesul de inițializare este lansat, kernel-ul Linux se ocupă de apeluri de sistem din
spațiul utilizator, și întrerupri și altele pentru dispozitive hardware. Multe funcții hardware sunt
expuse modului utilizator prin sysfs. De exemplu, un fragment de cod care citește starea bateriei
Gecko:
FILE *capacityFile = fopen(“/sys/class/power_supply/battery/capacity”, “r”);
double capacity = dom::battery::kDefaultLevel * 100;
if (capacityFile) {
fscanf(capacityFile, “%lf”, &capacity);
fclose(capacityFile);
}
Procesul init în Gonk se ocupă de montarea sistemelor de fișiere necesare și pornește
serviciile de sistem. După aceea, rămâne în jurul valorii de a servi ca un proces administrator.
Acest lucru este destul de similar cu init pe alte sisteme de operare UNIX-like. El interpretează
script-uri (care sunt, în fișierele de init * .rc), care constau din comenzi care descriu ceea ce ar
trebui făcut pentru a începe diverse servicii.Firefox OS init.rc este de obicei stoc init.rc Android
pentru acel dispozitiv împachetat pentru a include lucrurile necesare pentru a porni Firefox OS,
și variază de la un dispozitiv la altul. O sarcină cheie a procesului de inițializare se ocupă cu
pornirea procesului B2G; acesta este nucleul sistemului de operare Firefox OS.
Codul din init.rc care pornește asta arată în felul următor:
service b2g /system/bin/b2g.sh
class main
onrestart restart media
Această diagramă arată procesele de userspace primare din sistemul de operare Firefox.
Figura 4. Arhitectura proceselor [4]
Procesul B2G este procesul de sistem primar. Se rulează cu privilegii înalte; are acces
la cele mai multe dispozitive hardware. B2G comunică cu modemul, merge la framebuffer-ul de
afișare, și comunică cu GPS, camerele video, precum și alte caracteristici hardware. Pe plan
intern, B2G ruleaza stratul Gecko (implementat de libxul.so). [4]
2.7 B2G
Procesul B2G poate, la rândul său, ruleze un număr de procese de conținut cu drepturi mici.
Aceste procese apar în cazul în care sunt încărcate aplicații web și alte tipuri de conținut web.
Aceste procese comunică cu procesul principal de server Gecko prin IPDL, un sistem de
transmitere de mesaje.
Procesul de B2G ruleaza libxul, care face referire la B2G / app / b2g.js pentru a obține
preferințe implicite. Din preferințe se va deschide fișierul HTML descris b2g/ chrome / content /
shell.html, care este compilat în fișierul omni.ja. shell.html și include fișierul b2g / chrome /
content / shell.js, care declanseaza sistemul de aplicații Gaia.
Procesul rild este interfața cu procesorul de modem. rild este demonul care pune în aplicare
stratul Radio Interface (RIL). E o bucată de cod care este implementat de către distribuitorul de
hardware pentru a comuinca cu modem-ul lor hardware. rild face posibil pentru codul client să se
conecteze la un socket UNIX-domain la care se leagă. Este pornit de cod ca acesta în script-ul de
init:
service ril-daemon /system/bin/rild
socket rild stream 660 root radio
2.8 rilproxy
În Firefox OS, clientul rild este procesul rilproxy. Aceasta actionează ca un proxy de
expediere dumb între rild și B2G. Acest proxy este necesar ca un detaliu de punere în aplicare;
este suficient să spunem că este într-adevăr necesar. Codul rilproxy poate fi găsit pe GitHub.
2.9 Mediaserver
Procesul de Mediaserver controlează redarea audio și video. Gecko comunică cu el
printr-un mecanism Android Remote Procedure Call (RPC). Conținuturile media pe care Gecko
le poate reda (OGG Vorbis audio, OGG Theora video, și WebM videoclip) sunt decodate de
Gecko și trimise direct la procesul de Mediaserver. Alte fișiere media sunt decodate prin
libstagefright, care este capabil de a accesa codec-uri proprietare și codificatoare de hardware.
2.10 NETD
Procesul de NETD este folosit pentru a configura interfețe de rețea.
wpa_supplicant.
Procesul wpa_supplicant este standard daemon UNIX-like care se ocupă de conectivitate
cu puncte de acces WiFi.
Dbus-daemon implementează D-Bus, un sistem de bus de mesaje pe care Firefox OS îl
folosește pentru comunicare Bluetooth. [4]
2.11 Gecko
Gecko, așa cum sa menționat anterior, este punerea în aplicare a standardelor web (HTML,
CSS, JavaScript și) care este folosit pentru a pune în aplicare tot ceea ce utilizatorul vede pe
Firefox OS, precum și interacțiunile de control cu hardware-ul telefonului. Aplicațiile Web
Connect HTML5 pentru hardware-ul controlat prin API-uri web, securizate, puse în aplicare în
Gecko. API-urile Web furnizează acces programatic la caracteristicile în hardware-ul de bază al
dispozitivului mobil (cum ar fi bateria sau vibrația), împreună cu datele care sunt stocate, sau
disponibile pentru un dispozitiv (cum ar fi calendarul sau contactele). Conținutul web invocă
API-urile web accesibile în HTML5.
O aplicație constă într-o colecție de conținut web HTML5 aferent. Pentru a construi aplicații
web care rulează pe dispozitive mobile Firefox OS, dezvoltatorii pur și simplu asamblează,
înpachetează, și distribuie acest conținut web. În timpul rulării, acest conținut web este
interpretat, compilat, iar apoi redat în un browser web.
Figura 5. Diagramă a arhitecturii Gecko [4]
Cadrul de securitate conține:
Permission Manager: Gateway pentru accesarea funcționalității în API-ul Web.
Access Control List: Matricea de roluri și permisiuni necesare pentru a accesa
funcționalitatea Web API.
Validarea Credențialelor: Autentificarea aplicațiilor / utilizatorilor.
Permisiuni Store: Set de privilegii necesare pentru a accesa funcționalitatea Web API.
API Web: Set de API-uri standard, care oferă funcționalitate hardware pentru conținutul web.
Oferă aplicații web cu acces securizat, programatic la caracteristicile în hardware-ul de bază
dispozitiv mobil, împreună cu datele care sunt stocate pe sau disponibile la un dispozitiv.
I/O: Interfață la magazinul de hardware și de date (e).
Conținutul Layout & Rendering: Motorul care analizează, interpretează și execută conținut
web și, cu formatarea informațiilor, afișează conținutul formatat pentru utilizator. Procesul B2G
(Gecko) se execută într-un proces de sistem extrem de privilegiat care are acces la caracteristicile
hardware din telefonul mobil. Aplicațiile de funcționare sunt procese child ale B2G. [4]
Directorul B2G conține funcții în principal Firefox OS conexe.
B2G / crom / content conține fișiere Javascript care rulează peste aplicația de sistem.
B2G / crom / content / shell.html este punctul de intrare în Gaia – HTML-ul pentru aplicația
de sistem. shell.html plus settings.js și shell.js:
<script type="application/javascript;version=1.8" src="chrome://browser/content/settings.js">
</script>
<script type="application/javascript;version=1.8" src="chrome://browser/content/shell.js">
</script>
2.12 Hardware Abstraction Layer (HAL)
Nivelul de abstractizare hardware Gecko este unul din straturile de portare al Gecko. Se
ocupă de acces de nivel scăzut pentru interfețe de sistem pe mai multe platforme, folosind un C
++ API care este accesibil pentru niveluri mai ridicate decât Gecko. Aceste API-uri sunt puse în
aplicare pe o bază per-platformă în interiorul HAL în sine. Acest strat de abstractizare hardware
nu este expus în mod direct la cod JavaScript din Gecko - această parte a interacțiunii este
asigurată de API-uri Web.
Atunci când un utilizator face o cerere de utilizare a unei funcții de telefon (cum ar fi
apelarea unui număr, accesarea unei rețele WiFi locale, sau de conectare prin Bluetooth), toate
straturile de tehnologie din stiva Firefox OS sunt implicate în realizarea cererii. Aplicațiile și
conținutul web în stratul de Gaia trimit cererile de acces la dispozitiv prin apeluri Web-API
(invocate din interiorul funcțiilor HTML5), care sunt puse în aplicare în Gecko. Gecko, la rândul
său trimite cererea către Gonk. O singură cerere de la Gecko poate declanșa o serie complexă de
operații, inițiate și gestionate de Gonk, în telefonul mobil.
Cum funcționează HAL:
Să considerăm API-ul pentru vibrații ca un exemplu. Gecko HAL pentru acest API este
definit în hal / Hal.h. În esență (simplificarea semnăturii metodei de dragul clarității), avem
această funcție:
void Vibrate(const nsTArray<uint32> &pattern);
Aceasta este funcția apelată de codul Gecko pentru a porni vibrația dispozitivului conform
modelului specificat; există o funcție corespunzătoare de anulare a oricărei vibrații în curs de
desfășurare. Punerea în aplicare a acestei metode se află în hal / gonk / GonkHal.cpp:
void Vibrate(const nsTArray<uint32_t> &pattern) {
EnsureVibratorThreadInitialized();
sVibratorRunnable->Vibrate(pattern);
}
Acest cod trimite solicitarea de a porni vibrațiile dispozitivului într-un un alt thread, care este
pus în aplicare în VibratorRunnable :: Run (). Bucla principala a acestui thread arata ca aceasta:
while (!mShuttingDown) {
if (mIndex < mPattern.Length()) {
uint32_t duration = mPattern[mIndex];
if (mIndex % 2 == 0) {
vibrator_on(duration);
}
mIndex++;
mMonitor.Wait(PR_MillisecondsToInterval(duration));
}
else {
mMonitor.Wait();
}
}
vibrator_on () este un API Gonk de HAL care pornește motorul vibratorului. Pe plan intern,
această metodă trimite un mesaj la conducătorul auto nucleu de scris o valoare la un obiect
nucleu folosind sysfs. [4]
2.13 Procese și fire de execuție
Firefox OS folosește fire POSIX să pună în aplicare toate thread-urile, aceasta include
thread-ul principal al fiecărei cereri, precum și “lucrătorii" Web și thread-urile helper. Valorile
„nice” sunt folosite pentru a prioritiza execuția thread-urilor bazându-se astfel pe planificatorul
kernel Linux standard. În funcție de starea unui proces am un nivel diferit „nice” atribuit. Avem
în prezent 7 niveluri:
Priority Nice Used for
MASTER 0 procesul b2g principal
FOREGROUND_HIGH 0
aplicații critice pentru CPU sau wakelock, acesta este
utilizat pentru ceas sau aplicații care folosesc
comunicarea
FOREGROUND 1 aplicații de foreground
FOREGROUND_KEYBOARD 1 aplicația de tastatură
BACKGROUND_PERCEIVABLE 7 aplicații background care rulează audio
BACKGROUND_HOMESCREEN 18 aplicația de homescreen
BACKGROUND 18 toate celelalte aplicații care rulează în background
Figura 6. Nivelurile thread-urilor
3. Securitatea Firefox OS
3.1 Securitatea platformei
Permission Manager: Gateway pentru accesarea funcționalităților în API-ul Web, care
este singurul care are acces la hardware-ul de bază.
Access Control List: Matricea de roluri și permisiuni necesare pentru a accesa
funcționalitatea Web API.
Validarea Credențiale: Autentificarea apps / utilizatori.
Permisiuni Store: Set de privilegii necesare pentru a accesa funcționalitatea Web API.
3.2 Managementul de permisiuni
Sistemul de securitate Firefox OS este proiectat pentru a verifica și a aplica permisiunile
acordate aplicațiilor web.
Sistemul acordă o anumită permisiunee pentru o aplicație numai în cazul în care
conținutul ei o cere, și numai dacă are permisiunile corespunzătoare solicitate. Unele permisiuni
necesită autorizație suplimentară din partea utilizatorului, care este solicitat să acorde permisiune
(în cazul unei aplicații care solicită accesul la locația curentă a utilizatorului). Acest cadru
aplicație centralizată oferă un control mai granular asupra permisiunilor decât abordările
tradiționale (în care rolurillor individuale le sunt fiecareia atribuite un set de permisiuni).
Un Web API are un set de acțiuni și ascultători. Fiecare API Web are un nivel necesar de
permisiune. De fiecare dată când un API Web este apelat, Gecko verifică cerințele de permisiune
(de căutare rol) pe baza:
1. Permisiunilor asociate cu aplicația apelantă (așa cum este specificat în manifest și în
funcție de tipul aplicației.)
2. Permisiunilor necesare pentru a executa operațiunea solicitată (apel API Web.)
Dacă cererea nu îndeplinește criteriile de permisiuni, Gecko respinge cererea. De
exemplu, dacă aplicațiile nu sunt de încredere nu poate executa orice API-uri Web care sunt
rezervate pentru aplicații de încredere.
În plus față de permisiunile care sunt implicit asociate cu Web Apps, anumite operațiuni
necesită permisiunea explicită din partea utilizatorului înainte de a putea fi executate (de
exemplu, "poate avea acces web app camera?"). Pentru aceste operațiuni, aplicațiile web trebuie
să precizeze, în manifest-ul lor, justificarea lor pentru care necesită această permisiune. Această
intenție pentru utilizarea datelor informează utilizatorii despre ceea ce aplicația web
intenționează să facă cu aceste date, dacă este acordată permisiune, precum și orice risc implicat.
Aceasta permite utilizatorilor să ia decizii în cunoștință de cauză și să mențină controlul asupra
datelor lor. [5]
3.3 Procesul de update al aplicațiilor securizat
Figura 7. Diagrama procesului de update
Pentru upgrade-uri de aplicații si patch-uri pentru o aplicație privilegiată, furnizorii de
aplicații prezintă pachetul de actualizare pentru un Marketplace autorizat, în cazul în care acesta
este revizuit și, dacă este aprobat, semnat și pus la dispoziția utilizatorilor. Pe dispozitivele OS
Firefox, un utilitar de atualizare al aplicațiilor verifică periodic actualizări de aplicații
disponibile. Dacă o actualizare este disponibilă, atunci utilizatorul este întrebat dacă dorește să-l
instaleze. Înainte ca o actualizare să fie instalată pe un dispozitiv mobil, pachetul este verificat
pentru:
1. Update origine (verifica locația sursei - protocol: domeniul: portul de actualizare și
manifest-ul)
2. Integritatea fișierului (SHA-256 check hash)
3. Codul semnaturii (verificare certificat pentru un „root” cunoscut)
Controale riguroase se aplică pentru a asigura că actualizarea este aplicată corect la telefonul
mobil. Pachetul de actualizare complet trebuie să fie descărcat într-o locație specifică și sigură
înainte de a începe procesul de actualizare. Instalarea nu suprascrie datele utilizatorului.
3.4 Securitatea dispozitivului(Hardware)
Mecanisme de securitate pentru hardware-ul dispozitivului mobil sunt de obicei tratate de
către OEM. De exemplu, un OEM ar putea oferi SIM (Subscriber Identity Module) încuietori de
carduri, împreună cu PUK (PIN Unlock Key) pentru a debloca cartelele SIM care au devenit
blocate după introducerea mai multor coduri PIN incorecte. Firefox OS nu permite utilizatorilor
să configureze parolele și ecrane de timeout.
3.5 Securitatea datelor
Utilizatorii pot stoca date cu caracter personal pe telefonul lor, pe care doresc să le păstreze
privat, inclusiv contactele, informații financiare (bancare și detaliile cardului de credit), parole,
calendare, și așa mai departe. Firefox OS este proiectat pentru a proteja împotriva aplicațiile rău
intenționate, care ar putea fura, exploatare, sau distruge date sensibile.
Data sandbox
Așa cum s-a descris anterior, aplicații sunt “sandboxed” la runtime. Acest lucru previne
aplicațiile să acceseze datele care aparțin altor aplicații cu excepția cazului în care datele sunt
partajate în mod explicit, iar aplicația are permisiuni suficiente pentru a accesa.
Datele serializate
Aplicațiile web nu au acces direct de citire și scriere la sistemul de fișiere. În schimb, toate
căile de acces la mediile de depozitare au loc numai prin intermediul API-uri web. API-urile
Web citesc de la, și scriu la depozitare prin intermediul unei baze de date SQLite intermediare.
Nu există nici un acces direct I / O. Fiecare aplicație are propriul magazin de date, care este
serializat pe disc de baza de date.
Distrugerea datelor
Atunci când un utilizator dezinstalează o aplicație, toate datele (cookie-uri, localStorage,
IndexedDB, și așa mai departe), asociate cu această cerere se elimină.
Privacy
Firefox OS pune în aplicare aceste principii prin punerea controlulului datelor de utilizator în
mâinile utilizatorului, care va decide în cazul unde această informație cu caracter personal se va
duce. Firefox OS oferă următoarele caracteristici:
Do Not Track option
Capacitatea de a dezactiva cookies din browserul Firefox
Capacitatea de a șterge istoricul de navigare Firefox OS
3.6 Securitatea aplicațiilor
În Firefox OS, toate aplicațiile sunt web - programe scrise folosind HTML5, JavaScript,
CSS, mass-media și alte tehnologii web deschise. Deoarece nu există nici o aplicație ("native")
binară instalată de către utilizator, toate căile de acces sistem este mediată strict prin API-urile
Web. Chiar și acces la sistemul de fișiere se întâmplă doar prin API-uri Web și o bază de date
SQLite back-end - nu există acces direct din aplicații la fișierele stocate pe cardul SD.
App Manifest
Un manifest Open Web App conține informații care un browser web are nevoie pentru a
interacționa cu o aplicație. Un manifest este un fișier JSON cu (cel puțin) un nume și o descriere
pentru aplicație. Un exemplu de manifest simplu cu setări de bază:
{
"name": "My App",
"description": "My elevator pitch goes here",
"launch_path": "/",
"icons": {
"128": "/img/icon-128.png"
},
"developer": {
"name": "Your name or organization",
"url": "http://your-homepage-here.org"
},
"default_locale": "en"
}
Cadrul de securitate Firefox OS folosește sandbox ca o strategie de apărare în profunzime
pentru a reduce riscurile și pentru a proteja telefonul mobil, platforma, si datele. Sandbox este un
mod de a pune limite și restricții în jurul unei aplicații în timpul execuției run-time. Fiecare
aplicație rulează în propriul workspace și are acces doar la API-urile Web și datele pe care le este
permis accesul, precum și resursele asociate cu acel workspace (baze de date IndexedDB,
cookie-uri, stocare conectată, și așa mai departe).
Figura 8. Cadrul de securitate Firefox OS [4]
4. Managementul memoriei
Firefox OS rulează pe unele dispozitive grav constrânse de memorie, și este ușor pentru
aplicații de să epuizeze memoria disponibilă pe astfel de sisteme. Când un proces epuizează
memoria disponibilă pe sistem, kernel-ul trebuie să omoare alte procese, în scopul de a elibera
memorie.
4.1 Low memory killer(LMK)
LMK este un subsistem al kernel-ului Android care omoară în mod automat procesele pentru
a face loc pentru cererile de memorie. În scopul de a alege care procedeu este distrus mai întâi
pentru eliberarea de memorie, fiecare proces se atribuie o prioritate prin intermediul fișierelor /
proc / <pid> / oom_adj sau / proc / <pid> / oom_score_adj. Prioritatea unui proces este cunoscut
sub numele de scorul de ajustare, sau oom_adj. Valorile oom_adj mai mici corespund procese cu
prioritate mai mare.
În general, cu cât scorul de ajustare este mai mare, este mai probabil ca procesul să fie
distrus. LMK oferă mai multe niveluri, fiecare corespunzând la o anumită sumă de memorie liber
ăși un scor minim de ajustare. Ori de câte ori cantitatea de memorie liberă din sistem scade sub
un anumit nivel, toate procesele cu o ajustare de scor mai mare decât minimul specificat pentru
acest nivel sunt eligibile pentru a fi distruse. LMK va începe distrugerea acestor procese, cele
mari în primul rând, și continua până când a eliberat suficientă memorie pentru a merge peste
prag din nou. [4]
4.2 Low memory notifications
Al doilea mecanism pentru a elibera memorie este „Low memory notifications”. LMK oferă
un prag special care, atunci când a trecut, poate trimite notificări în spațiul utilizator care se
rulează pe memorie scăzută. Atât de aplicația de sistem și aplicațiile de utilizator așteptă
continuu pentru aceasta condiție și vor reacționa la aceasta prin trimiterea unui eveniment de
memorie prin intermediul serviciului de observatori. Acest eveniment este vizibil numai pentru C
++ și codul JS și nu direct de către o aplicație. Prin codebase Gecko se folosește acest eveniment
pentru a elibera la fel de multă memorie ca și cum am putea în mod normal prin ștergerea
memoriei cache interne (imagini, DNS, SQLite, etc.), ștergând asset-uri care pot fi recreate
(contexte WebGL de exemplu) și să fie rulat garbage collector și cycle collector.
Când se confruntă cu o stare de memorie joasă primul eveniment de memorie care va fi
trimis va avea sarcina utilă low-memory. Dacă după o perioadă predefinită (5s) suntem încă într-
o stare de memorie redusă, alt eveniment de memorie va fi expediat, dar de data aceasta cu
sarcina utilă low-memory-ongoing. Această încărcătură utilă este utilizată atunci când vom
continua sa experimentăm condiții de memorie scăzută și vrem pentru a curăța cache și a face
alte forme ieftine de minimizare a memoriei, dar totuși abordările grele, cum ar fi un GC sunt
puțin probabil să reușească. [4]
5. Dezvoltare aplicatii
Unele aspecte mai interesante ale Firefox OS includ WebAPI-uri și activități Web. Un
WebAPI este, în esență o interfață JavaScript care permite accesul aplicației la funcții ale
aparatului native (care gestionează contacte, trimiterea de mesaje SMS, notificări, și așa mai
departe). O activitate web este un WebAPI. Mai exact, o activitate web permite aplicației să
delege o activitate la altă aplicație pe dispozitiv. De exemplu, dacă se dorește a permite
utilizatorilor să preia o imagine de pe dispozitiv, puteți apela "pick" Web activity și specificați o
serie de tipuri de date, după cum urmează:
var pickImg = new MozActivity({ name: "pick", data: { type:
["image/jpg", "image/jpeg", "img/png"] } });
Acest cod produce următorul meniu pentru utilizator:
Cele mai multe WebAPI-uri și Web activități au handle-uri onsuccess și onfail, pe care le
puteți utiliza pentru a gestiona răspunsul apelului API. De exemplu, în următorul cod:
pickImg.onsuccess = function () { // we got an image! (returned as a blob)
var blob = this.result.blob; var img = document.createElement("img"); img.src
= window.URL.createObjectURL(blob); // now display the image in your app
$("#image-display").append(img); }; pickImg.onerror = function () { // didn’t
work... alert("Something went wrong!") };
Există două tipuri de aplicații (prin care se solicită Mozilla Open Web Apps) pe care le puteți
instala pe Firefox OS: aplicație găzduită și aplicație ambalată. O aplicație găzduită este în esență
un site web găzduit pe un server central, dar executat în contextul app. Utilizatorii trebuie să fie
online pentru a accesa resursele app (HTML, imaginile și așa mai departe) și dezvoltatorii sunt
limitați în domeniul de apelare al WebAPI-urilor care le poate face aplicația. Se poate vedea
diferența dintre apeluri WebAPI normale și privilegiate. Utilizarea WebAPI-urilor se face pentru
a face stratul de web mai capabil. Cu toate acestea, ca un site web normal, dezvoltatorii au mai
mult control asupra actualizărilor pentru aplicații de la resursele app care sunt încă găzduite
central. O aplicație ambalată este similară cu una gazduită (e tot HTML5), dar are acces la toate
WebAPI și este descărcată și instalată pe dispozitiv (similar cu iOS și Android). În mod implicit,
aplicațiile ambalate sunt de așteptat să funcționeze fără a necesita acces la rețea. Chiar dacă
aplicația în sine trăiește pe dispozitiv, este posibil ca o aplicație ambalată să se actualizeze. De
asemenea, se poate utiliza Firefox Marketplace pentru a posta actualizări ale aplicației ambalată
pentru utilizatori.
Pentru o aplicație simplă, ambalată, este nevoie de câteva resurse minime: un fișier HTML
pentru prezentare, o funcție javaScript care să execute logica aplicației și un fișier manifest.
Avem o aplicație HTML5, care face un apel WebAPI simplu, dar acum avem nevoie pentru a
face unele completări relativ minore să-l facă într-o aplicație ambalată.
În timpul procesului de dezvoltare a aplicației, se utilizează Firefox OS Simulator. Aceasta
este un add-on gratuit Mozilla (pentru browser-ul Firefox, desigur), care vă permite să simulați
mediul Firefox OS, atât pentru aplicațiile găzduite și ambalate, și care consumă mult mai puține
resurse decât simulatoarele pentru Android sau iOS.
Toate aplicațiile OS Firefox (găzduite și ambalate) au nevoie de un fișier manifest. Un fișier
manifest este pur și simplu un fișier JSON care conține metadate despre aplicație. Mai jos am
adăugat o versiune simpla a unui manifest app.
{ "name": "Check Battery", "description": "This app allows you to check
your battery levels!", "launch_path": "/index.html", "developer": { "name":
"Rob Lauer", "url": "http://roblauer.me" }, "icons": { "16":
"/img/icon16.png", "32": "/img/icon32.png", "48": "/img/icon48.png", "64":
"/img/icon64.png", "128": "/img/icon128.png" }, "default_locale": "en" }
Aplicația va arăta în modul următor:
6. Analize comparative și concluzii
Avantajele Firefox OS față de alte sisteme de operare smartphone
Firefox OS este bazat pe motorul Gecko, care îl ajută să folosească standarde web
deschise, cum ar fi HTML, CSS și JavaScript. Android, iOS, Windows Phone și alte sisteme de
operare mobile, pe de altă parte, sunt în mare parte dețiunte de companii proprietare. Până la
Firefox OS, fiecare dintre sistemele de operare existente au avut propriul set de reguli, și nu se
putea folosi o aplicație dezvoltată pentru Android, pe iOS sau altele.
Acest lucru ajută Firefox OS. Aceasta filozofie îi ajută să obțină mai multe aplicații pe
bord. Toată lumea știe că motivul pentru care orice sistem de operare mobil are succes este din
cauza aplicațiilor disponibile. iOS și Android sunt două dintre cele mai de succes mai ales pentru
că au cel mai mare număr de aplicații disponibile în piețe lor. Cei mai mulți utilizatori de
smartphone-uri nu ar ști nici nu le-ar păsa de procesoarele telefoanelor lor și alte lucruri care se
întâmplă în interiorul acestuia. În schimb, le pasă de ceea ce pot face cu telefoanele lor, care este
cazul în care aplicații mobile disponibile.
Piața Firefox OS "are deja unele aplicații notabile, chiar înainte ca ea să se fi lansat. Dar
ceea ce este interesant este faptul că Mozilla s-a concentrat pe aceste standarde web deschise și
le-a făcut importante pentru sistemul de operare. Ce înseamnă acest lucru este că dezvoltarea
sistemului de operare și ecosistemului său, inclusiv aplicațiile mobile pe care le-ar folosi, ar fi
mai facilă. Dezvoltatorilor terți stiu deja limbajele și ar putea veni rapid cu aplicații pentru noul
sistem de operare. Sau ca și în cazul lui everything.me, Firefox OS ar putea atinge aplicațiile
HTML 5 deja disponibile și să le adauge la ofertele sale.
Pe scurt, Firefox OS este despre oferirea unei platforme pentru utilizatorii de smartphone-
uri pentru a utiliza aplicații Web pe telefoanele lor.
Ce înseamnă acest lucru pentru dezvoltatori? Acest lucru ar trebui să fie o veste bună
pentru dezvoltatorii de aplicații mobile. În cele din urmă, ei pot crea o aplicație mobilă care ar
putea fi utilizată nu doar pe Firefox OS, dar și pe iOS și Android, deoarece ar crea-o folosind
standardul HTML 5. Nu mai lucrează la trei sau patru versiuni diferite ale aceeiași aplicație. Ce e
mai mult, daca au deja aplicații HTML 5 pe piață astăzi, ei le pot folosi cu ușurință pentru pe
Firefox OS. Aceasta le-ar face, de asemenea viața mai ușoară pentru că aplicațiile mobile ar
folosi doar HTML, CSS și Javascript, care sunt considerate a fi limbaje de programare de bază
pentru unWeb Developer expert. Nu mai este nevoie de SDK-uri în proprietatea corporațiilor
pentru a le învăța și a lucra cu ele.
Un alt lucru care ar trebui să ajute sistemul de operare Firefox este prețul. Autorul și
speaker-ul Rob Hawkes explică faptul că Firefox OS nu s-a lansat pentru a omorî iOS, Windows
Phone și Android, ci de a oferi o alternativă mai ieftină, care ar aduce preformanțe comparabile,
dacă nu, mai bune. La mai rău, ar mânca vanzarile iPhone în țările în curs de dezvoltare, cum ar
fi Filipine și Brazilia, la fel ca ceea ce face Android. Deci, Apple nu are într-adevăr de ce să își
facă griji despre asta, deoarece vizează o piață diferită, pentru același motiv pentru care nu ar
trebui să își facă griji nici pentru Android.
Google, pe de altă parte, s-ar putea găsi în sine expusă. Atât Android și Firefox OS sunt
open source de principiu și au costuri mai mici, dar Firefox OS are un avantaj distinct. Un lucru
de care sistemele de operare actuale nu dispun este gradul și ușurința în care utilizatorii ar putea
personaliza dispozitivele lor mobile. Pur și simplu, nu este ușor pentru a personaliza un iPhone
sau un dispozitiv Android. Ar trebui ca userii să se bazeze pe rooting și jailbreaks sau va trebui
să descărce o aplicație.
Cu Firefox OS, ai nevoie doar pentru a avea instrumente de bază de dezvoltare web și
abilități. Dacă cunoști HTML sau CSS, poți schimba modul în care telefonul sau tableta arată,
fără a fi nevoie pentru a complica lucrurile.
Cu accent pe standardele Web și tehnologii open source, ați putea aștepta Firefox OS să
meargă foarte departe. Atât de mult încât ar putea fi sistemul de operare mobil de alegere pentru
viitor. Firefox OS face ecosistemele mobile foarte simple pentru dezvoltatori și foarte accesibile
pentru utilizatori. S-ar putea forța chiar Apple, Google și alții să distrugă bazele creațiilor proprii
și să înceapă să lucreze împreună, foarte similar cu modul în care browser-ul Mozilla Firefox
forțat IE, Netscape Navigator și browserele Web anterioare ca să lucreze împreună.
Dificultăți și provocări pentru Firefox OS
În principiu, Firefox OS pare o idee solidă, și îmbrățișarea ei a HTML5 ar putea foarte
bine sculpta fața lucrurilor care vor urma să vină pentru dezvoltarea mobile. Dar Firefox OS nu
va exista într-un vid - exista deja un set complicat de ecosisteme mobile acolo, toate din care sunt
concurente pentru cota de piata, dezvoltatorii, și loialitatea utilizatorilor.
Evident, provocarea pentru Firefox OS este Android. La urma urmei, Android este un fel
de open source, astfel producătorii și factorii de decizie pentru dispozitive sunt liberi pentru a se
juca cu sistemul de operare și a-l transforma în ceva ce cred ca va plăcea clienților, sau cel puțin
să le aducă bani. La urma urmei, Biadu a Chinei a făcut propriul fork Android și substituit
propriile servicii bazate pe web pentru Google - și pentru că Android este "liber" și "deschis", nu
există nimic ce Google poate să facă. În mod similar, Amazon are toat Android sub propria
interfață personalizată pe Kindle Fire. Are cineva într-adevăr nevoie de o sursă complet deschisă,
HTML5 sistem de operare mobil când Android este deja atât de maleabil - și Google este dispus
să lase operatorii de telefonie mobilă să își facă module proprii cu el? Și dispozitivele Android
definesc deja low-endul pieței de smartphone-uri (unele dispozitive sunt deja disponibile gratuit),
precum și Google.
De asemenea, nu există nicio lipsă de sisteme de operare mobile open-source deja
existente. Palm webOS este în proces de a merge open source, și este sărit deja de cele mai multe
dintre hopuri pe care Firefox OS le negociază acum. Și Tizen, care are sprijin atât din sistemul de
operare Nokia abandonat MeeGo și Bada Samsung. Asta e un pedigree mobil mult mai bun decât
orice Mozilla poate oferi.
Și să nu uităm Symbian. Sigur, Nokia a pierdut locul său ca producator de top din lume
de telefoane mobile și ofertele Windows Phone au fost destule încă să aprindă un foc în
consumatori - care, probabil, nu a fost ajutat de Microsoft care anunță că nici unul dintre ei nu va
sprijini Windows Phone 8. Dar Symbian continuă să fie un actor major în telefoane entry-level
care vizează piețele emergente.
Există, de asemenea un cuvânt cheie care lipsește din anunțuk Mozilla Firefox OS:
tabletele. Aceste zile, este aproape imposibil să vorbim despre o platformă mobilă fără a discuta
strategia de tablete, chiar dacă piața este încă complet dominată de iPad. Chiar acum, Mozilla
Firefox OS este cu scopul pur la piata de telefonie la nivel de intrare. Dacă există planuri pentru
extinderea Firefox OS pentru a tabletelor, Mozilla și partenerii săi n-au spus un cuvânt despre
asta.
Bibliografie
1. https://www.mozilla.org/en-US/firefox/os/?icn=tabz
2. http://en.wikipedia.org/wiki/Firefox_OS
3. http://web.uvic.ca/~hitchner/assign1.pdf
4. https://developer.mozilla.org/en-US/Firefox_OS/Platform/Architecture
5. https://leanpub.com/gaiafromabove/read
6. http://www.geekshubsacademy.com/courses/firefoxos.html