Ministerul Educaiei al Republicii Moldova

Universitatea Tehnic a Moldovei

Facultatea Calculatoare, Informatic i Microelectronic

Lucrare de curs
la disciplina:

ANALIZA PROIECTAREA I PROGRAMAREA OBIECT ORIENTAT

Tema: Registrator Video Android

Elaborat: student gr. TI-121 uiu Ion

Verificat: Lector asistent Lisnic Inga

Chiinu 2015

Cuprins
Cuprins.....2
Introducere3
1. Sistemul Video Registrare....3
1.1 Definiie..3
1.2 Medii de utilizare a DVR......................................................................................................................3
1.3 Crearea unui Sistem Video Registrare..................................................................................................4
1.4 Caracteristicile tehnice ale Sistemului Video Registrator.....................................................................4
1.5 Testarea aplicaiei create.......................................................................................................................4
1.6 Avantaje i dezavantaje.........................................................................................................................5
2. Proiectarea sistemului informaional.....................................................................................................6
2.1 Instrumentul de modelare.....................................................................................................................6
2.2 Descriere Enterprise Architect.............................................................................................................6
2.3 Descrierea limbajului UML.................................................................................................................6
2.4 Modelarea unui Sistem Video Registrator...........................................................................................7
2.4.1 Diagrame Use case............................................................................................................................7
2.4.2 Diagrame de secven.......................................................................................................................9
2.4.3 Diagrama claselor.............................................................................................................................11
2.4.4 Diagrame de stare.............................................................................................................................12
2.4.5 Diagrama de activiti......................................................................................................................15
2.4.6 Diagrame de componente................................................................................................................19
2.4.7 Diagrama de distribuie....................................................................................................................21
3. Prezentarea aplicaiei ..........................................................................................................................23
3.1 Compilarea Aplicatiei.........................................................................................................................23
3.2 Screen aplicaie...................................................................................................................................23
Concluzii...................................................................................................................................................26
Bibliografie...............................................................................................................................................27
Anexa A Cod surs...................................................................................................................28

Intoducere
nregistrator Video Auto este dispozitiv pentru video i audio pentru a supraveghea situaia n jurul
mainii atunci cnd se afl n micare sau staionare, precum i n interiorul habitaclului (opional - dac o
camera suplimentara).Scopul principal este de a colecta probe de baz n situaii controversate i
accidente.
DVR (Digital Video Recorder) este un dispozitiv conceput pentru a nregistra, stoca i redare
video. DVR-uri, utilizate n principal n sisteme de supraveghere video, att staionar (pe obiecte) i
mobile (de exemplu, video auto)[1].

1 Sistemul Video Registrare

1.1 Definiie
Un video registrator este un dispozitiv electronic care are o nregistrare cu unghi larg, video digital
i date. Astfel se nregistreaz orice incidente legate de sau n jurul vehiculului. n cazul unui accident,
care este nu din vina ta i nici martori pentru a v susin mpotriva celeilalte pr i, un video registrator
vehicul va putea s lucreze ca probe video, care minimizeaz ambiguitate sau acuza ii false. n acest fel,
ceea ce face revendicrile epuizante i istovitoare obinuite din societile de asigurare vor fi simpl i
fr griji de asta ca conductor auto i ca deinator a unui telefon pe platform android am decis s imi fac
aciast aplicaie care va nregistrarea video .
Videoregistrator pe baza de smartphone este un program care v permite s utiliza i telefonul
smartphone ca un DVR. Smartphone-uri moderne au un aparat de fotografiat de calitate, mai mult
memorie i de prelucrare putere, i, de regul, sunt echipate cu Geolocaie sau pozi ionarea Wi-Fi.
Avantajul unor astfel de programe este preul lor , precum i posibilitatea de integrare inteligenta cu alte
funcii ale DVR are smartphone moderne - navigare folosind hri cu traseul suprapuse, utilizarea
serviciilor de Internet. Dezavantajul smartphone DVR bazat devine faptul c astfel de dispozitive nu pot
ndeplini funciile de nregistrare n timpul unui apel.
1.2 Medii de utilizare a DVR
n funcie de DVR sarcini pot fi folosite pentru diferite sarcini, inclusiv:
1.
2.
3.
4.

Supravegherea pentru vizitatori n case particulare, birouri, magazine;

Supraveghere video pentru tranzaciile n numerar la casieria locul de munc n magazine .
Pentru organizarea sistemelor de contabilitate i de control ale vehiculelor din parcri .
nregistrarea i controlul micrii vagoanelor pe teritoriul fabrici, uzine, statii de combustibil de

umplere, spatii de depozitare automate;

5. Organizarea de sisteme de supraveghere video distribuite geografic, inclusiv monitorizarea singur
site-ul.
3

1.3 Crearea unui Sistem Video Registrare

Pentru crearea aplicaiei, este necesar instalarea pachetului Android Studio SDK . Acest lucru se
poate face direct de pe site-ul oficial developer.android.com, care se ruleaz pe platforma android sau pe
emulatorul din Android Studio.
Aceast aplicaie este folosit pentru a face clipuri video cu o simulare a funciei de pauz.
Aplicaie nu are o funcie real pauz. ntr-adevr aplicaia salveaz toate videoclipurile pe care le-ai
nregistrat n timp ce facei clic pe butonul de pauz. Cnd termina toate nregistrrile, atunci aplica ia va
selecta toate videoclipurile pentru a le mbina ntr-o video. Din acest motiv, aplicaia poate lua ceva timp
s pregteasc video. . Aciasta aplicaie are limit de timp astfel poate s nceap numrtoarea invers
astfel s stai fr griji c ai uitat s apsai butonul de nregistrare. Avnd un buton la mijlocul ecranului
petru touch pe zona vizorului pentru a capta o imaginile mai direct[2].
1.4 Caracteristicile tehnice ale Sistemului Video Registrator
1. O singura apsare pentru nregistrarea porni i opri
2. Video n calitatea cea mai mare care permite dispozitivul
3. Interfa cit mai plcut
4. Manager de fiiere salvate
5. O iconi pentru lansator video astfel aplicaia este mai discret
6. Activarea lumin intermitent a dispozitivului n timpul nregistrrii
7. mprii fiiere video astfel nct s putei nregistra pn la tot spaiul disponibil pe cardul SD.
8. Fiierele video pot fi tiate n funcie de timp sau dimensiunea fiierului
9. Suport camera video frontal i spate
10. Compatibil cu Tasker pentru a configura declanarea pentru a porni automat i opri nregistrarea
video

1.5 Testarea aplicaiei create

Aplicaia va fi testat n mai multe rnduri de ctre mine, pentru a nu aprea erori nedorite pe parcurs,
gen ncrcarea grea a butoanelor sau ieirea din ea la o eventual suprancrcare a memoriei
dispozitivului. Cele mai frecvente erori pe care le ntmpin de obicei utilizatorul sunt cele de genul erorii
la salvarea video, rularea de mai multe ori a unui proces, n cazul cnd el se blocheaz.n acel moment
utilizatorul cedeaza nervilor i acceseaz de nenumrate ori diferite procese, dispozitivul cednd complet
i restartndu-se . Atfel eforturile vor fi considerabile pentru evitarea acestui lucru, ns dezvoltatorul
trebuie s fie pregtit pentru orice eveniment neplcut.
1.6 Avantaje i dezavantaje fa de alte sisteme
Avantaje:

1. Sistemul meu este Video Registrator el are o interfa placut , simpl i uor folosibil fa a de
interfaa aplicaiei Video Recorder Demo i Wondershare PowerCam care au o interfa greu
accesibil i la fel greu de utilizat;
2. Alt avantaj al sistemului meu Video Registrator este dimensiunea nregistrrii video care poate fi
aleas de utilizator aciast funcie o are i Wondershare PowerCam , dar Video Recorder Demo nu
are aciast posibilitate;
3. Sistemul Video Registrator are efecte video disponibile ca la orice camera , sistemul Video Recorder
Demo nu are efecte la camer ;
4. Este gratis ca i sistemul Video Recorder Demo , Wondershare PowerCam ne fiind gratis;
5. Sistemul mer pornete auto cu un timer nici alt sistem din cele 2 comparate nu poate face acest lucru;
6. Menager fisiere stocate n sistemul meu este mai plcut i mai uor de folosit dect Video Recorder
Demo;
7. Wondershare PowerCam i sistemul Video registrator au posibilitatea de activare a camerei fa
sistemul Video Recorder Demo nu are funcia dat;
Dezavantaje:
1. Este o aplicaie mai simpl dect cele cu plat am n vedere Wondershare PowerCam,fiind mai srac
n setri i butoane;
2. Sistemul Wondershare PowerCam este un sistem bine cunoscut de utilizatori ,sistemul Video
registrator este nou, necunoscut, este necesar o publicitate mai dezvoltat i un reiting mai mare c s
atrag clieni;
3. Sistemul Video Registrator nu conine galerie foto doar video, sistemul Wondershare PowerCam are
galerie i este foarte comod;
4. Wondershare PowerCam poate postata video direct pe internet sau s transmit pe pota electronic ,
sistemul Video registrator ca i Video Recorder Demo nu au aciast posibilitate;
5. Ca i la restu dou sisteme nu se nregistriaz viteza de circulaie a vehiculului.

2 Proiectarea sistemului informaional

Drept lucrare de curs mi-am propus s dezvolt aspectele legate de analiza i modelarea unui
Sistem Informatic pentru aplicaia Video registrator.
2.1 Instrumentul de modelare
Modelarea sistemului dat a fost elaborat n istrumentul Enterprise Architect. S-a ales instrumentul
dat, deoarece este simplu, uor de utilizat i comunicabil cu utilizatorul.

2.2 Descriere Enterprise Architect

Enterprise Architect este un software de tip CASE pentru design-ul i construc ia sistemelor
software, bazat pe UML. Acest pachet prevede modelarea complet a ciclului de via pentru afaceri i
sisteme IT; software i ingineria sistemelor i integrarea dezvoltrii n timp real.
Integrnd capacitile de gestionare a cerinelor, Enterprise Architect ajut la urmrirea
specificaiilor la nivel nalt pentru analiza, proiectarea, implementarea, testarea i ntreinerea modelelor
folosind UML.
Enterprise Architect este un instrument grafic, proiectat pentru a ajuta echipele, construind sisteme
robuste i ntreinute. Utiliznd calitatea nalt, integrarea raportrii i documentrii poate oferi o viziune
mprtit cu uurin i precizie[3].
2.3 Descrierea limbajului UML
UML (Unified Modeling Language) este un instrument standard pentru crearea de "diagrame"
software. Cu ajutorul UML pot fi vizualizate, specificate, construite i documentate artefactele de sisteme
software.
Modelare UML este potrivit pentru toate sistemele, de la sistemele de informare la aplicatii bazate
pe web i sisteme n timp real chiar ncorporate. Acesta este un limbaj foarte expresiv, care permite
sistemului s ia n considerare toate punctele de vedere legate de dezvoltarea i implementarea ulterioar.
2.4 Modelarea unui Sistem Video Registrator
n paragraful respectiv vor fi reprezentate tipurile de diagrame UML specifice unui Sistem Video
Registrator. n urma reprezentrii grafice a diagramei, urmeaz descrierea fiecrei diagrame n parte.

2.4.1 Diagrame Use case

Cazurile de utilizare sunt abstracii ale dialogului ntre actori i sistem. Ele

descriu

interaciuni poteniale fr a intra n detalii ale fiecrui scenariu.

Diagrama cazurilor de utilizare prezint aciunile reciproce dintre variantele posibile de utilizare i
personaje sau sisteme. Diagramele reflect cerinele fa de sistem din punctul de vedere al utilizatorului.
n aa mod cazurilor de utilizare sunt funciile efectuate de sistem, iar persoanele sunt persoane
cointeresate de sistemul elaborate[4].
Urmtoarea diagram prezint principalele usecases a actorului utilizator(vezi fugura 2.4.1):
6

Figura 2.4.1 Principalele usecase

n figura 2.4.2 sunt descrise procesul de folosire a aplicaiei.utilizatorul deshide aplica ia o seteaz
dup gustul su i dup posibilitile tehnice ale smartphonului, n urma selectrii unui criteriu
vizualizeaz schimbarile produse.

Figura 2.4.2 Procesul de folosire a aplicaiei

n figura 2.4.3 vizualizm paii pe care-i parcurge utilizatorul la deschiderea aplica iei noastre, el
va trebui s confirme c dorete sa utilizeze aplicaia, dup care i va aprea interfaa. n caz de un mic
bug/eroare aplicaia se va nchide automat[4].

Figura 2.4.3 Deschiderea aplicaiei

2.4.2 Diagrame de secven
Diagramele de secven prezint interaciunile care au loc ntre diverse obiecte ale unui sistem,
ordonate cronologic. Ele determin obiectele i clasele implicate ntr-un scenariu i secvenele de mesaje
transmise ntre obiecte, necesare ndeplinirii funcionalitii scenariului. Diagramele de secven sunt
asociate unui caz de utilizare.
Fiecrui obiect, clas i corespunde o linie a timpului, reprezentat printr-o linie punctat sub
reprezentarea obiectului. Mesajele transmise ntre obiecte sunt reprezentate prin sgei etichetate cu
numele mesajului. n diagramele respective interaciunile dintre legturi i obiecte sunt reprezentate n
evoluia lor n timp.

Figura 2.4.4 Diagrama de secven pentru nregistrarea video

n aceast diagram sunt reprezentate interaciunile dintre Utilizator, Interfa , Setari i
nregisrarea video n procesul de nregistrare . ntr-o anumit unitate de timp o anumit setare ar putea fi
solicitat. Modificarea setrilor implic confirmarea acesteia i nregistrarea de la nceput.

Figura2.4.5
10

n figura de mai sus este reprezentat diagrama de secven pentru stingerea sau aprinderea
flashului dispozitivului . Este reprezentat interaciunea dintre actorul utilizator , setarile aplicatiei i
insi aplicaiei.

Figura 2.4.6 Diagrama secvenelor corespunztoare deschiderii arhivei

Utilizatorul poate vizualiza in aplicaie video nregistrate avnd inclus n aplicaie managerul
fisierelor , unde se poate de vizualizat nregistrrile , informaii despre ele i de redactat coninutul
fiierelor.

2.4.3 Diagrama claselor

Diagrama claselor definete modelul structural al unui sistem prin intermediul unui graf, ale crui
noduri (vrfuri) reprezint clasele, iar arcele reprezint legturile dintre clase.
Administrarea utilizatorilor din cadrul unui sistem informatic actual este destul de important. Cu ct
sistemul dat este vizitat de mai muli vizitatori, utilizatori, cu att crete rata utilizrii acestui produs
informatic. n prezent se cunoate faptul c utilizatorii sunt primii clieni, utilizatori finali ai acestor
sistme complexe. De multi ori nregistrarea pe anumite sisteme este destul de impuntoare, dar odat
nregistrat ntr-o limit de acces sunt posibile funcionaliti de baz a sistemului.
11

Figura 2.4.7 - Diagrama claselor corespunztoare administrrii utilizatorilor

n UML un obiect se reprezint printr-un dreptunghi mprit n dou compartimente:
compartimentul de nume i compartimentul de atribute (Figura 2.4.7). Numele obiectului se subliniaz i
poate fi urmat de numele clasei (desprite prin semnul :). Sunt admise i notaii simplificate (numai
numele obiectului sau numai numele clasei precedat de semnul :). n compartimentul de atribute se trec
numele atributelor i valorile acestora.
2.4.4 Diagrame de stare
Diagrama de stare - distribuie un mod de modelare variat a strilor n care un obiect poate
exista. n timp ce diagrma claselor arat imaginea static a claselor i rela iilor dintre ele, diagrama de
stare sunt utilizate la modelarea comportamentul dinamic a sistemului.
Diagramele de stare sunt destinate pentru modelarea diferitor stri n care poate s se afle obiectul.
n timp ce diagrama claselor arat imaginea static a claselor i legturile lor, diagrama strilor se
folosete la descrierea dinamic a comportamentului sistemului. Diagrama de stare reflect
comportamentul obiectului. Principalele stri ale diagramei sunt: nceput i sfrit. nceputul grafic este
reprezentat ca un cerc plin de culoare neagr, i corespunde strii obiectului n momentul crerii. Starea
final se reprezint grafic prin dou cercuri unu n altul. Cel din mijloc este plin i de culoare neagr[1].

12

Figura 2.4.8- Diagrama de stare a funcionalitii sistemului

n diagram de stri de mai sus sunt reprezentate strile prin care trece un untilizator pentru a verifica
nregistrrile din managerul de fiiere . Utilizatorul trebuie doar sa deschid aplica ia, apoi trebuie s intre
n managerul fisiere ca s ajung la inregistrarile facute unde sistemul ii permite stergerea , vizualizarea
inregistrarilor.

13

Figura 2.4.9 Diagrama de stare pentru inregistrare video

n diagrama respectiv sunt reprezentate starile parcurse de utilizator la efectuarea unei nregitrri i
la vizualizarea ei. Starea curenta a unui obiect este reflectata in valorile atributelor care descriu obiectul.
Acestea includ si legaturile existente intre obiect si alte obiecte.

14

n diagrama din figura 2.5.1 sunt prezentate starile pe care le va parcurge utilizatorul sistemului
pentru a seta timpul de nregistrare.

Figura 2.5.1 Diagrama de stari pentru setarea timpului

2.4.5 Diagrama de activiti

Diagrama de activiti reprezint o modalitate de modelare vizual a fluxurilor. Cu
ajutorul diagramelor de activiti pot fi modelate foarte bine use case-urile, dar, n aceeai msur, aceste
diagrame pot fi folosite pentru modelarea proceselor de business (fr legtur cu sistemul informatic). n
privina notaiilor, acestea sunt foarte asemntoare cu cele din diagrama de stari. Elementele utilizate
sunt descrise in continuare. O regul important este faptul ca o astfel de diagram trebuie s aib un
singur punct de nceput i unul de sfirit. Orice aciune este elementar i de obicei ea are o singur
15

intrare i o singur ieire. n cazul cind e necesar s existe mai multe intrri sau ie iri se utilizeaz
ramificatoarele.

Figura 2.5.2- Diagrama de activiti pentru deschiderea aplicaiei

n figura 2.5.2 este reprezentat procesul de deschidere a aplicaiei date. Este prezentat exemplu
cnd aplicaia se deschide cu success i cnd cu eroare i activitile n aceste circumstane , astfel dac
aplicaia are eroare sistemul automat nchide. Punctele de decizie sunt puncte din fluxul de activiti n
care se face o anumit alegere ntre mai multe variante posibile.

16

Figura 2.5.3-Diagrama de activiti pentru

n figura 2.5.3 este prezentat diagrama de activitai pentru managerul de fiiere . Punctele de
decizie sunt puncte din fluxul de activiti n care se face o anumit alegere ntre mai multe variante
posibile. Notaia utilizat pentru punctul de decizie poate fi folosit i pentru reconectarea fluxurilor
(merge point), aa cum se poate vedea n figura 2.5.3.

17

Figura 2.5.4-Diagrama de activiti

n diagrama respectiva are loc nregistrarea utilizator. Pentru a ncepe lucrul este necesar s dia accept
la condiiile impuse de sistem. Dac nu este deacord aplicaia nu se instaliaz pe dispozitiv. Dac
utilizatorul nu este satisfcut de aplicaie el o poate dezinstala, ins dac ia placut aplicaia el o folose te
n continuare.

18

2.4.6 Diagrame de componente

Diagrama de componente
In UML, termenul de componenta desemneaza un element software fizic din componenta unui
sistem. Astfel, o componenta poate fi: cod binar, document, fisier continand cod sursa sau date, tabela a
unei baze de date. O componenta binara este o parte fizica si substituibila a unui sistem, care realizeaza si
este in conformitate cu un set de interfete.
Diagramele de componenete sunt importante deoarece:
1. modeleaza sistemul software real in mediul de implementare;
2. evidentiaza probleme de configurare prin relatiile de dependenta;
3. reprezinta o imagine a sistemului existent, inainte de a fi modificat;
4. pot evidentia probleme de implementare fara a fi necesar sa se citeasca tot codul sursa

Figura2.5.5- Diagrama componentelor funcionalitatea sistemului

n diagrama respectiv sunt reprezentate unele componentele principale ale unui Sistem
nregistrare Video . De menionat, c un Sistem nregistrare Video fr componentele sau
funcionalitile respective nici nu poate exista.

19

Una din funcionalitile Sistemului nregistrare Video, este gestionarea nregistrrilor, cum ar fi:
verificarea nregistrrilor, vizualizarea nregistrrilor , tergerea . Dup cum se observ din figur n
momentul accesrii unei opiuni, sistemul are o gestionare efectiv pentru a accesa opiunea.

Figura 2.5.6. Diagrama componentelor corespunztoare gestionrii nregistrrilor

n figura 2.5.6 sunt reprezentate fiierele principale necesare pentru dezvoltarea interfe ei
sistemului Video registrator .Pentru componenta apk a aplicaiei se utilizeaz mai multe componente,
fiiere xml,java,librrii i imagini.

20

Figura 2.5.7. Diagrama componentelor corespunztoare sistemului Video registrator

2.4.7 Diagrama de distributie
Diagrama de distributie (Deployment diagrams)
Diagramele de distributie modeleaza echipamentele mediului de implementare. Fiecare nod dintr-o
diagrama de distributie reprezinta un tip de echipament: un PC client, un server, o unitate de disc, un
procesor. Un nod poate sa reprezinte de asemenea, o fiinta umana sau o organizatie, mai exact functia pe
care o persoana sau organizatie o poate executa.
Instanele componentelor soft reprezint manifestri a unor uniti de cod n cadrul execuiei.
Componentele care nu exist ca entiti de execuie nu apar n aceste diagrame, ci doar n diagramele de
component[3].
O diagram de exploatare este un graf de noduri conectate prin asocieri de comunicare. Nodurile
pot conine instane ale componentelor (componenta exist sau se execut pe nodul respectiv).
Componentele pot conine obiecte (acestea sunt localizate n componente).

21

Figura 2.5.8
n figura 2.5.8 este reprezentat diagram de distribuie , utilizatorul va descrca aplicaia de pe
server pe devisul su unde va primi instalaia apk-ului.

22

3 Prezentarea aplicaiei
3.1 Compilarea Aplicatiei
Pentru inceperea dezvolatrii aplicatiei, este nevoie de setat Java pe masina locala si de downloadad
AndroidStudioIDE. Se pare ca nu-i su_cient, insta echipa Google s-a straduit si se straduie in dezvoltarea
a unui IDE cit se poate de comod. El vine integrat deodata cu toate cele necesare: Gradle si AndroidSDK.
Instrument de build al aplicatiei, a fost ales Gradle. Motivul general _ind combinarea a laturilor
puternice a altor instrumente de build (Ant si Maven). Pentru acoperirea a mai multor versiuni, a fost
utilizata librariesupport pentru versiuni android de pina la v.2.2. In intereiorul _sierului
AndroidManifest:xml este descrisa arhitecura aplocatiei(elementele radacine autonome), punctul de
intrare, fel de fel de permisiuni i altele.
3.2 Screen aplicaie
Vizualizarea interfeei
n acest screen se vede continutul interfeei Video Registratorului , cum ar fi pornirea video
luminiscena , timerul , conectare camer fa , managerul fiiere , deconectare/conectare flash.

Figura3.1-Interfaa aplicaiei

23

Vizualizarea manager de fiiere

Managerul fiiere este un instrument util n aciast aplicaie aici putem vizualiza nregistrrile i
dac e nevoie le selecm i tergem.

Figura 3.2 Managerul nregistrri

Vizualizarea taimerului din aplicaie
Taimerul din aplicaia dat auto conectiaz aplicaia daca utilizatorul a uitat s fac acest lucru.

Figura 3.3 Timerul aplicaiei

24

Interfaa mod nregistrare

Cum se observ din screen-shot cnd activm mod video putem apropia sau deprta cadrele i apar
butoanele pauz i stop. Pentru a stia la ce moment de timp filmiaz aplicaia am pus i n timer care
mereu se afl pe suprafaa interfeei doar n mod nregistrare.

Figura 3.4- Mod nregistrare

25

Concluzii
n urma dezvoltarii aplicatiei, am inteles cit e de importanta planificrii n ciclul de via a
dezvoltrii aplicaiilor. nainte de a scrie cod, mai ntii de toate trebuie puse la punct bine cerinele i
trebuie s fie descrise ct mai detalizat funcionalitile. Pentru acest scop a fost creat UML. n stadiul
actual de dezvoltare software este aproape de neconceput dezvoltarea aplicaiilor de dimensiuni mari fr
specificarea, descrierea i documentarea proiectului. Descrierea n cuvinte sau folosind notaii ad-hoc este
dificil i insuficient i prezint dificulti imense privind nelegerea unanim, dezvoltarea i
ntreinerea aplicaiei, dificulti care se amplific n timp.
n fiecare etap de dezvoltare software a unui sistem se pot folosi mai multe modelri (diagrame)
UML, pentru a oferi viziunea (vederea) utilizator, structura sistemului i comportarea acestuia. Modelarea
UML a aplicaiilor tinde s fie tot mai larg rspndit, asigurnd compatibilitate, posibiliti de interoperabilitate, re-utilizare a software-ului, i multe alte avantaje.
Aceasta aplicaie este utila n timpul cltoriilor cu automobilul. Este autonoma si nu depinde de
conexiune internet. Depinde doar de capacitatea bateriei i spatiului de memorie a dispozitivuluie. Totui
ea poate fi mbunatit dupa parerea mea. Ar bine daca s-ar creat un serviciu online pentru ncrcarea
nregistrrilor, n rest sint destul de mulumit de aplicaia creata. Intentionez s-o plasez pe Android
Market.

26

Bibliografie
1 tefen Marin, Analiza i modelarea sistemelor informatice ndrumar metodic pentru lucrri de
laborator, UTM 2004
2 http://ro.wikipedia.org/wiki/Sistem_android
3 MODELAREA PROCESELOR DE AFACERI UTILIZAND UML, 2012
4 Florin Leon, Limbajul unificat de modelare UML, Universitatea Tehnic Gh. Asachi, Iai

27

Anexa A
Codul surs
package com.androidexample.videocamera;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import

android.app.ActivityManager;
android.content.BroadcastReceiver;
android.content.ComponentName;
android.content.Context;
android.content.DialogInterface;
android.content.Intent;
android.content.IntentFilter;
android.content.SharedPreferences;
android.content.pm.PackageManager;
android.content.res.Resources;
android.graphics.Color;
android.hardware.Camera;
android.media.CamcorderProfile;
android.media.MediaMetadataRetriever;
android.media.MediaPlayer;
android.media.MediaRecorder;
android.net.Uri;
android.os.AsyncTask;
android.os.Bundle;
android.os.CountDownTimer;
android.os.Environment;
android.os.SystemClock;
android.preference.PreferenceManager;
android.util.DisplayMetrics;
android.util.Log;
android.view.MotionEvent;
android.view.SurfaceHolder;
android.view.View;
android.view.Window;
android.view.animation.AnimationUtils;
android.widget.AdapterView;
android.widget.ArrayAdapter;
android.widget.CheckBox;
android.widget.Chronometer;
android.widget.FrameLayout;
android.widget.ImageView;
android.widget.LinearLayout;
android.widget.ListView;
android.widget.ProgressBar;
android.widget.ScrollView;
android.widget.TextView;
android.widget.Toast;
com.neoadn.neoadnvideocamera.helper.AdmobHelperNeoadn;
com.neoadn.neoadnvideocamera.helper.neoadnHelperCMItems;
java.io.File;

public class MainActivity extends AdmobHelper

implements SwipeInterface
{
private class AutoFocusCallBackImpl
implements android.hardware.Camera.AutoFocusCallback
{
final MainActivity this$0;
public void onAutoFocus(boolean flag, Camera camera)
{
iv_anim_focus.setVisibility(8);
Log.i("MainActivity", (new
StringBuilder("Autofocusare=")).append(flag).toString());
cameraFocusing = false;
}
private AutoFocusCallBackImpl()
{

28

this$0 = MainActivity.this;
super();
}
AutoFocusCallBackImpl(AutoFocusCallBackImpl autofocuscallbackimpl)
{
this();
}
}
class MediaPrepareTask extends AsyncTask
{
final MainActivity this$0;
protected transient Boolean doInBackground(Void avoid[])
{
releaseCamera();
if (prepareVideoRecorder())
{
mMediaRecorder.start();
return Boolean.valueOf(true);
} else
{
releaseMediaRecorder();
return Boolean.valueOf(false);
}
}
protected volatile transient Object doInBackground(Object aobj[])
{
return doInBackground((Void[])aobj);
}
protected void onPostExecute(Boolean boolean1)
{
if (!boolean1.booleanValue())
{
finish();
}
try
{
if (actZoom != 0)
{
params.setZoom(actZoom);
mCamera.setParameters(params);
}
}
// Declaraia deplasat a unei variabile excepie
catch (Boolean boolean1) { }
iv_record.setImageResource(0x7f020094);
isRecording = true;
startRecordingAction();
try
{
if (!cameraFocusing)
{
iv_anim_focus.setVisibility(0);
boolean1 = AnimationUtils.loadAnimation(getApplicationContext(),
0x7f020057);
iv_anim_focus.startAnimation(boolean1);
cameraFocusing = true;
setCameraFocus();
}
return;
}
// Declaraia deplasat a unei variabile excepie
catch (Boolean boolean1)
{
return;

29

}
}
protected volatile void onPostExecute(Object obj)
{
onPostExecute((Boolean)obj);
}
MediaPrepareTask()
{
this$0 = MainActivity.this;
super();
}
}
class MediaPrepareTaskPause extends AsyncTask
{
final MainActivity this$0;
protected transient Boolean doInBackground(Void avoid[])
{
releaseCamera();
if (prepareVideoRecorder())
{
mMediaRecorder.start();
return Boolean.valueOf(true);
} else
{
releaseMediaRecorder();
return Boolean.valueOf(false);
}
}
protected volatile transient Object doInBackground(Object aobj[])
{
return doInBackground((Void[])aobj);
}
protected void onPostExecute(Boolean boolean1)
{
if (!boolean1.booleanValue())
{
finish();
}
try
{
if (actZoom != 0)
{
params.setZoom(actZoom);
mCamera.setParameters(params);
}
}
// Declaraia deplasat a unei variabile excepie
catch (Boolean boolean1) { }
if (flashONpause)
{
boolean1 = mCamera.getParameters();
boolean1.setFlashMode("torch");
mCamera.setParameters(boolean1);
iv_flash.setImageResource(0x7f020076);
flashOn = true;
}
isRecording = true;
pauseRecordingAction();
iv_pause.setImageResource(0x7f02008a);
try
{
if (!cameraFocusing)
{

30

iv_anim_focus.setVisibility(0);
boolean1 = AnimationUtils.loadAnimation(getApplicationContext(),
0x7f020057);
iv_anim_focus.startAnimation(boolean1);
cameraFocusing = true;
setCameraFocus();
}
return;
}
// Declaraia deplasat a unei variabile excepie
catch (Boolean boolean1)
{
return;
}
}
protected volatile void onPostExecute(Object obj)
{
onPostExecute((Boolean)obj);
}
MediaPrepareTaskPause()
{
this$0 = MainActivity.this;
super();
}
}
public class ProgressReceiver extends BroadcastReceiver
{
final MainActivity this$0;
public void onReceive(Context context, Intent intent)
{
if (intent.getAction().equals("com.neoadn.intent.action.PROGRESO"))
{
ll_items_info_merge.setVisibility(0);
total = intent.getIntExtra("total", 0);
unidos = intent.getIntExtra("unidos", 0);
prog = intent.getIntExtra("progreso", 0);
stado = intent.getStringExtra("state");
nomArchFinal = intent.getStringExtra("nombre");
context = getResources().getDrawable(0x7f020070);
progressBar.setProgressDrawable(context);
if (progressBar.getVisibility() == 8)
{
progressBar.setVisibility(0);
}
progressBar.setProgress(prog);
tv_info_merge_info.setText(stado);
} else
if (intent.getAction().equals("com.neoadn.intent.action.FIN"))
{
progressBar.setProgress(100);
MainActivity.playFile = intent.getStringExtra("nombre");
stado = intent.getStringExtra("state");
tv_info_merge_info.setText(stado);
copyFileToDefaultFolder();
Log.i("playFile", MainActivity.playFile);
try
{
unregisterReceiver(rcv);
}
// Declaraia deplasat a unei variabile excepie
catch (Context context) { }
(new CountDownTimer(5000L, 1000L) {
final ProgressReceiver this$1;

31

public void onFinish()

{
if (!
stado_copy.equalsIgnoreCase(getResources().getString(0x7f0c0031)))
{
ll_items_info_merge.setVisibility(8);
}
progressBar.setVisibility(8);
}
public void onTick(long l)
{
}

{
this$1 = ProgressReceiver.this;
super(l, l1);
}
}).start();
return;
}
}
public ProgressReceiver()
{
this$0 = MainActivity.this;
super();
}
}
public MainActivity()
{
timeWhenStopped = 0L;
maxFPS = 0;
countDownTimerOn = false;
}
private boolean checkCameraHardware(Context context)
{
return context.getPackageManager().hasSystemFeature("android.hardware.camera");
}
public static Camera getCameraInstance()
{
Camera camera1 = null;
Camera camera = camera1;
android.hardware.Camera.CameraInfo camerainfo;
int i;
try
{
id = (new CameraBackFront()).getBackCameraId();
}
catch (Exception exception)
{
return camera;
}
camera = camera1;
camera1 = Camera.open(id);
if (camera1 == null)
{
break MISSING_BLOCK_LABEL_40;
}
camera = camera1;
camera1.setParameters(camera1.getParameters());
camera = camera1;
i = android.os.Build.VERSION.SDK_INT;
if (i < 17)
{

32

break MISSING_BLOCK_LABEL_128;
}
camera = camera1;
camerainfo = new android.hardware.Camera.CameraInfo();
camera = camera1;
Camera.getCameraInfo(id, camerainfo);
camera = camera1;
if (!camerainfo.canDisableShutterSound)
{
break MISSING_BLOCK_LABEL_100;
}
camera = camera1;
Log.i("SOUND", "MUTED");
camera = camera1;
camera1.enableShutterSound(false);
camera = camera1;
Log.i("VERSION", (new StringBuilder("MAYOR: ")).append(i).toString());
return camera1;
camera = camera1;
Log.i("VERSION", (new StringBuilder("MENOR: ")).append(i).toString());
return camera1;
}
private File getOutputMediaFile(int i)
{
File file = getFolder();
if (!file.exists() && !file.mkdirs())
{
Log.d("MyCameraApp", "failed to create directory");
} else
{
String s = (new SimpleDateFormat("yyyyMMdd_HHmmss")).format(new Date());
fileName = (new StringBuilder("VID_")).append(s).append(".mp4").toString();
if (i == 2)
{
return new File((new
StringBuilder(String.valueOf(file.getPath()))).append(File.separator).append(fileName).toStrin
g());
}
}
return null;
}
private boolean isServiceMergeVideoActive()
{
Iterator iterator =
((ActivityManager)getSystemService("activity")).getRunningServices(0x7fffffff).iterator();
android.app.ActivityManager.RunningServiceInfo runningserviceinfo;
do
{
if (!iterator.hasNext())
{
return false;
}
runningserviceinfo =
(android.app.ActivityManager.RunningServiceInfo)iterator.next();
} while (!
com/neoadn/neoadnvideocamera/serviceMergeVideo.getName().equals(runningserviceinfo.service.get
ClassName()));
return true;
}
private boolean prepareVideoRecorder()
{
mCamera = getCameraInstance();
android.hardware.Camera.Parameters parameters = mCamera.getParameters();
if (flashONpause)
{
parameters.setFlashMode("torch");
mCamera.setParameters(parameters);

33

iv_flash.setImageResource(0x7f020076);
flashOn = true;
}
parameters.setRecordingHint(true);
mCamera.setParameters(parameters);
try
{
mCamera.setPreviewDisplay(null);
}
catch (IOException ioexception)
{
Log.d("MainActivity", (new StringBuilder("IOException nullifying preview display:
")).append(ioexception.getMessage()).toString());
}
mCamera.stopPreview();
mMediaRecorder = new MediaRecorder();
mCamera.unlock();
mMediaRecorder.setCamera(mCamera);
mMediaRecorder.setAudioSource(5);
mMediaRecorder.setVideoSource(1);
try
{
if (maxFPS > 0)
{
mMediaRecorder.setVideoEncodingBitRate(maxFPS);
Log.d("CaptureRate", (new StringBuilder()).append(maxFPS).toString());
}
}
catch (Exception exception)
{
Log.e("CaptureRate-Error", (new StringBuilder()).append(maxFPS).toString());
}
if (qualityString().equalsIgnoreCase("Low"))
{
mMediaRecorder.setProfile(CamcorderProfile.get(id, 0));
} else
if (qualityString().equalsIgnoreCase("High"))
{
mMediaRecorder.setProfile(CamcorderProfile.get(id, 1));
} else
if (qualityString().equalsIgnoreCase("480p"))
{
mMediaRecorder.setProfile(CamcorderProfile.get(id, 4));
} else
if (qualityString().equalsIgnoreCase("720p"))
{
mMediaRecorder.setProfile(CamcorderProfile.get(id, 5));
} else
if (qualityString().equalsIgnoreCase("1080p"))
{
try
{
mMediaRecorder.setProfile(CamcorderProfile.get(id, 6));
}
catch (Exception exception1)
{
mMediaRecorder.setProfile(CamcorderProfile.get(id, 1));
}
} else
{
mMediaRecorder.setProfile(CamcorderProfile.get(0, 1));
}
mMediaRecorder.setOutputFile(getOutputMediaFile(2).toString());
addFileNameDB();
mMediaRecorder.setPreviewDisplay(mPreview.getHolder().getSurface());
try
{
mMediaRecorder.prepare();
}
catch (IllegalStateException illegalstateexception)

34

{
Log.d("MainActivity", (new StringBuilder("IllegalStateException preparing
MediaRecorder: ")).append(illegalstateexception.getMessage()).toString());
releaseMediaRecorder();
return false;
}
catch (IOException ioexception1)
{
Log.d("MainActivity", (new StringBuilder("IOException preparing MediaRecorder:
")).append(ioexception1.getMessage()).toString());
releaseMediaRecorder();
return false;
}
return true;
}
private void releaseCamera()
{
flashStatus = "torch";
if (!mCamera.getParameters().getFlashMode().contains(flashStatus)) goto _L2; else goto
_L1
_L1:
Log.i("Lol", flashStatus);
flashONpause = true;
_L4:
if (mCamera != null)
{
mPreview.getHolder().removeCallback(mPreview);
mCamera.release();
mCamera = null;
Log.d("onPause", "Camera Released!");
}
return;
_L2:
try
{
flashONpause = false;
}
catch (Exception exception) { }
if (true) goto _L4; else goto _L3
_L3:
}
private void releaseMediaRecorder()
{
if (mMediaRecorder != null)
{
mMediaRecorder.reset();
mMediaRecorder.release();
mMediaRecorder = null;
mCamera.lock();
}
}
private void videoRatio()
{
screenHeight = getResources().getDisplayMetrics().heightPixels;
screenWidth = getResources().getDisplayMetrics().widthPixels;
Log.i("MainActivity-ScreenSize", (new
StringBuilder(String.valueOf(screenWidth))).append(" - ").append(screenHeight).toString());
int i = getVideoW();
int j = getVideoH();
Log.i("MainActivity-videoSize", (new StringBuilder(String.valueOf(i))).append(" ").append(j).toString());
if (qualityString().equalsIgnoreCase("High") ||
qualityString().equalsIgnoreCase("1080p") || qualityString().equalsIgnoreCase("720p"))
{
int k = screenWidth;
int i1 = (screenWidth * j) / i;
if (i1 > screenHeight)

35

{
k = screenHeight;
i = (screenHeight * i) / j;
android.widget.LinearLayout.LayoutParams layoutparams = new
android.widget.LinearLayout.LayoutParams(0, k, i);
layoutparams.gravity = 17;
Log.d("Final-Ratio_low", (new StringBuilder("Ancho:")).append(i).append(" Alto: ").append(k).toString());
preview.setLayoutParams(layoutparams);
mPreview.getHolder().setSizeFromLayout();
return;
} else
{
android.widget.LinearLayout.LayoutParams layoutparams1 = new
android.widget.LinearLayout.LayoutParams(0, i1, k);
layoutparams1.gravity = 17;
Log.d("Final-Ratio_low", (new StringBuilder("Ancho:")).append(k).append(" Alto: ").append(i1).toString());
preview.setLayoutParams(layoutparams1);
mPreview.getHolder().setSizeFromLayout();
return;
}
}
int l = screenWidth;
int j1 = (screenWidth * j) / i;
Log.i("MainActivity-480p", (new StringBuilder(String.valueOf(l))).append(" ").append(j1).toString());
if (j1 > screenHeight)
{
l = screenHeight;
i = (screenHeight * i) / j;
Log.i("MainActivity-480p", (new StringBuilder(String.valueOf(i))).append(" ").append(l).toString());
android.widget.LinearLayout.LayoutParams layoutparams2 = new
android.widget.LinearLayout.LayoutParams(0, l, i);
layoutparams2.gravity = 17;
Log.d("Final-Ratio_low", (new StringBuilder("Ancho:")).append(i).append(" - Alto:
").append(l).toString());
preview.setLayoutParams(layoutparams2);
mPreview.getHolder().setSizeFromLayout();
return;
} else
{
android.widget.LinearLayout.LayoutParams layoutparams3 = new
android.widget.LinearLayout.LayoutParams(0, j1, l);
layoutparams3.gravity = 17;
Log.d("Final-Ratio_low", (new StringBuilder("Ancho:")).append(l).append(" - Alto:
").append(j1).toString());
preview.setLayoutParams(layoutparams3);
mPreview.getHolder().setSizeFromLayout();
return;
}
}
public void actionButtonPause()
{
hasPaused = true;
if (isRecording)
{
mMediaRecorder.stop();
releaseMediaRecorder();
mCamera.lock();
isRecording = false;
pauseRecordingAction();
iv_pause.setImageResource(0x7f020087);
playVisibility();
return;
} else
{
(new MediaPrepareTaskPause()).execute(new Void[] {

36

null, null, null

});
return;
}
}
public void actionButtonRec()
{
if (isRecording && !hasPaused)
{
mMediaRecorder.stop();
releaseMediaRecorder();
mCamera.lock();
isRecording = false;
iv_pause.setVisibility(8);
iv_record.setImageResource(0x7f020093);
playVisibility();
deleteAllList();
finishRecordingAction();
copyFileToDefaultFolder();
return;
}
if (isRecording && hasPaused)
{
mMediaRecorder.stop();
releaseMediaRecorder();
mCamera.lock();
isRecording = false;
hasPaused = false;
iv_pause.setVisibility(8);
iv_record.setImageResource(0x7f020093);
playVisibility();
dialogSelectOrMerge();
finishRecordingAction();
return;
}
if (!isRecording && hasPaused)
{
isRecording = false;
hasPaused = false;
iv_pause.setVisibility(8);
iv_record.setImageResource(0x7f020093);
if (ah.videoNumberObs() > 0)
{
dialogSelectOrMerge();
Log.i("select", "ah.videonumber");
} else
{
copyFileToDefaultFolder();
deleteAllList();
Log.i("select", "no ah.videonumber");
}
finishRecordingAction();
return;
} else
{
iv_pause.setVisibility(0);
progressBar.setVisibility(8);
(new MediaPrepareTask()).execute(new Void[] {
null, null, null
});
return;
}
}
public void addFileNameDB()
{
Object obj = new AdaptadorBD(this);
((AdaptadorBD) (obj)).abrir();
((AdaptadorBD) (obj)).insertarVideo(fileName, "");

37

((AdaptadorBD) (obj)).cerrar();
obj = new AdapterHelper(this);
playFile = fileName;
Log.i("MainActivityNUM VIDE", (new StringBuilder()).append(((AdapterHelper)
(obj)).videoNumber()).toString());
Log.i("MainActivity", (new StringBuilder("Add: ")).append(fileName).toString());
}
public void bottom2top(View view)
{
}
public void cameraActions()
{
CameraBackFront camerabackfront;
camera_back = false;
camera_front = false;
camerabackfront = new CameraBackFront(this, getApplicationContext());
if (camerabackfront.getBackCameraId() == -1) goto _L2; else goto _L1
_L1:
camera_back = true;
if (camerabackfront.getFrontCameraId() == -1) goto _L4; else goto _L3
_L3:
camera_front = true;
iv_camera_location.setVisibility(0);
_L6:
return;
_L4:
iv_camera_location.setVisibility(8);
return;
_L2:
if (camerabackfront.getFrontCameraId() != -1)
{
camera_front = true;
iv_camera_location.setVisibility(0);
return;
}
if (true) goto _L6; else goto _L5
_L5:
}
public void checkCameraItems()
{
CameraItemsOnPhone cameraitemsonphone = new CameraItemsOnPhone(this, mCamera);
try
{
maxFPS = cameraitemsonphone.getMaxFPS();
}
catch (Exception exception2)
{
Log.e("maxFPS", "error");
}
try
{
hasFlash = cameraitemsonphone.hasFlash();
}
catch (Exception exception14) { }
try
{
hasZoom = cameraitemsonphone.hasZoom();
}
catch (Exception exception13) { }
try
{
hasInfiniteFocus = cameraitemsonphone.hasInfiniteZoom();
}
catch (Exception exception12) { }
try
{
hasAntiBand = cameraitemsonphone.hasAntiBand();

38

}
catch (Exception exception11) { }
try
{
hasAutoWhiteBalance = cameraitemsonphone.hasAutoWhiteBalance();
}
catch (Exception exception10) { }
try
{
hasFocusModeAuto = cameraitemsonphone.hasFocusModeAuto();
}
catch (Exception exception9) { }
try
{
hasFocusVideoContinous = cameraitemsonphone.hasFocusModeContinuous();
}
catch (Exception exception8) { }
try
{
maxExp = cameraitemsonphone.getMaxExposure();
}
catch (Exception exception7) { }
try
{
minExp = cameraitemsonphone.getMinExposure();
}
catch (Exception exception6) { }
try
{
cameraitemsonphone.getBackCameraId();
cameraitemsonphone.getFrontCameraId();
}
catch (Exception exception5) { }
try
{
cameraitemsonphone.hasQualityVideoSupport();
}
catch (Exception exception3) { }
try
{
cameraitemsonphone.hasQualityVideoSupportFront();
}
catch (Exception exception4) { }
try
{
cameraitemsonphone.getListColorEffect();
}
catch (Exception exception) { }
try
{
setCameraItems();
return;
}
catch (Exception exception1)
{
return;
}
}
public void copyFileToDefaultFolder()
{
File file = new File(getFolder(), playFile);
String s = file.getPath();
File file1 = new File(s);
new File(ah.folderMovies(), playFile);
new File(ah.folderDCIM(), playFile);
Intent intent = new Intent(this, com/neoadn/neoadnvideocamera/intentServiceCopyVideo);
IntentFilter intentfilter = new IntentFilter();
intentfilter.addAction("com.neoadn.intent.copy.action.PROGRESO");
intentfilter.addAction("com.neoadn.intent.copy.action.FIN");

39

rcv_copy = new ProgressReceiverCopy();

registerReceiver(rcv_copy, intentfilter);
if (file.exists())
{
intent.putExtra("path_input_file", s);
intent.putExtra("path_output_file", file1.toString());
intent.putExtra("copy", false);
startService(intent);
}
}
public void deleteAllList()
{
AdapterHelper adapterhelper = new AdapterHelper(this);
if (adapterhelper.videoNumberObs() > 0)
{
adapterhelper.deleteAllVideos();
}
Log.w("MainActivity-List", "List deleted");
}
public void dialogDeleteAllItemList()
{
String s = getResources().getString(0x7f0c0077);
String s1 = getResources().getString(0x7f0c0076);
String s2 = getResources().getString(0x7f0c0074);
String s3 = getResources().getString(0x7f0c0075);
(new
android.app.AlertDialog.Builder(this)).setTitle(s2).setMessage(s3).setPositiveButton(s1, new
android.content.DialogInterface.OnClickListener() {
final MainActivity this$0;
public void onClick(DialogInterface dialoginterface, int i)
{
ah.deleteAllItemOnList();
ll_items_listview.setVisibility(8);
dialoginterface.cancel();
}

{
this$0 = MainActivity.this;
super();
}
}).setNegativeButton(s, new android.content.DialogInterface.OnClickListener() {
final MainActivity this$0;
public void onClick(DialogInterface dialoginterface, int i)
{
dialoginterface.cancel();
}

{
this$0 = MainActivity.this;
super();
}
}).show();
}
public void dialogDeleteItemList(final String deleteName)
{
String s = getResources().getString(0x7f0c0077);
String s1 = getResources().getString(0x7f0c0076);
String s2 = getResources().getString(0x7f0c0072);
String s3 = getResources().getString(0x7f0c0073);

40

(new
android.app.AlertDialog.Builder(this)).setTitle(s2).setMessage(s3).setPositiveButton(s1, new
android.content.DialogInterface.OnClickListener() {
final MainActivity this$0;
private final String val$deleteName;
public void onClick(DialogInterface dialoginterface, int i)
{
ah.deleteItemOnList(deleteName);
getItemsListView();
dialoginterface.cancel();
}

{
this$0 = MainActivity.this;
deleteName = s;
super();
}
}).setNegativeButton(s, new android.content.DialogInterface.OnClickListener() {
final MainActivity this$0;
public void onClick(DialogInterface dialoginterface, int i)
{
dialoginterface.cancel();
}

{
this$0 = MainActivity.this;
super();
}
}).show();
}

public void finishRecordingAction()

{
ll_item_recording.setVisibility(8);
timeWhenStopped = mChronometer.getBase() - SystemClock.elapsedRealtime();
mChronometer.stop();
mChronometer.setBase(SystemClock.elapsedRealtime());
timeWhenStopped = 0L;
mChronometer.setTextColor(Color.parseColor("#000000"));
}
public void focusModeOptions()
{
if (focusMode.equalsIgnoreCase("focus_video_continuos"))
{
android.hardware.Camera.Parameters parameters = mCamera.getParameters();
parameters.setFocusMode("continuous-video");
mCamera.setParameters(parameters);
iv_focus.setImageResource(0x7f02007a);
} else
if (focusMode.equalsIgnoreCase("focus_infinity"))
{
android.hardware.Camera.Parameters parameters1 = mCamera.getParameters();
parameters1.setFocusMode("infinity");
mCamera.setParameters(parameters1);
iv_focus.setImageResource(0x7f02007b);
return;
}
}
public String getDefaultFolder()
{

41

return PreferenceManager.getDefaultSharedPreferences(this).getString("folder_default",
"Default folder");
}
public void getDimensionFile()
{
Object obj1 = new File(getFolder(), fileName);
Object obj = new MediaMetadataRetriever();
((MediaMetadataRetriever) (obj)).setDataSource(((File) (obj1)).getPath());
obj1 = ((MediaMetadataRetriever) (obj)).extractMetadata(19);
obj = ((MediaMetadataRetriever) (obj)).extractMetadata(18);
Log.i("QU", (new StringBuilder(String.valueOf(obj1))).append(" - ").append(((String)
(obj))).toString());
try
{
(new CameraItemsOnPhone(this, mCamera)).setVideoRecordedQuality(qualityString(),
((String) (obj)), ((String) (obj1)));
return;
}
catch (Exception exception)
{
Log.e("MainActivityDimen", exception.getLocalizedMessage());
}
}
public File getFolder()
{
File file = null;
if (getDefaultFolder().equalsIgnoreCase(default_folder))
{
file = new
File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES),
"neoadnVideo");
} else
{
if (getDefaultFolder().equalsIgnoreCase(dcim_folder))
{
return new
File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "Camera");
}
if (getDefaultFolder().equalsIgnoreCase(movies_folder))
{
return new
File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES), "");
}
}
return file;
}
public void getItemsListOnResume()
{
if ((new AdapterHelper(this)).videoNumberObs() > 0)
{
sv_items.setVisibility(8);
ll_items_listview.setVisibility(0);
getItemsListView();
}
}
public void getItemsListView()
{
AdapterHelper adapterhelper = new AdapterHelper(this);
myList = new ArrayList();
if (!myList.isEmpty())
{
myList.clear();
myList = adapterhelper.getListdb();
lv_merge.setAdapter(new ArrayAdapter(this, 0x7f03001e, myList));
return;
} else

42

{
myList = adapterhelper.getListdb();
lv_merge.setAdapter(new ArrayAdapter(this, 0x7f03001e, myList));
return;
}
}
public void getOptionsSaved()
{
SharedPreferences sharedpreferences =
PreferenceManager.getDefaultSharedPreferences(this);
mergeOnFinish = false;
focusMode = sharedpreferences.getString("focus_mode", "");
load_info = sharedpreferences.getBoolean("load_info_onresume", true);
ch_info_load.setChecked(load_info);
try
{
if (load_info)
{
loadItmsInfo();
}
}
catch (Exception exception1) { }
Log.i("focus_mode", focusMode);
try
{
focusModeOptions();
return;
}
catch (Exception exception)
{
return;
}
}

43