Mobil alkalmazások fejlesztése. Készítette: Szabóné Nacsa Rozália

Mobil alkalmazások fejlesztése

Készítette: Szabóné Nacsa Rozália

S60 és UIQ S 60 Application suites UI implementation

UI framework

UIQ MOAP

Symbian OS HW adaptation Hardware

Symbian – Symbian OS – S60 – C++ 2009.09.19.

Mobil alkalmazások fejlesztése, Symbian OS/C++

2

Okos telefonok  erős processzor

 egyszerű kezelhetőség

 nagyméretű kijelző

 megbízhatóság

 viszonylag nagy

 erőforrásaival nem

memória  információ kezelő programok  egyéni alkalmazások

pazarló (memória, szolgáltatások, energia fogyasztás)  gyors reakcióidő  folyamatos üzemmód

Elvárosok  megbízható  nincs adatvesztés  nem dobja el a vonalat

 optimális a memória felhasználás  nincs memória szivárgás  minden hibát „értelmesen” kezel  nyitott a külső fejlesztések irányába

Symbian OS felépítése Felhasználói interfész szinkronizáció Alkalmazás szintű szolgáltatások Operációs rendszer szolgáltatásai

UI alkalmazás keretrendszer

UI eszközkészlet

MIDP CLDC

PIM

Üzenetkezelés

Általános szolgáltatások

Böngészés

Kommunikációs szolgáltatások

Adatszinkron

Grafikai szolgáltatások

Alapszolgáltatások

Alacsonyszintű szolgáltatások

Fájlszerver

Kernel és hardware integráció

Kernel szolgáltatások

Eszközmeghajtók

2009.09.19.


JVM Java

PC-s kapcsolat szolgáltatásai

5

Symbian C++ sajátosságok  Kódolási minták a memóriaszivárgás kiszűrésére: kétfázisú

 

 



konstrukció, CleanUpStack Nincs kivétel. Helyette: TRAP és User::Leave Saját elnevezési konvenciók: nem a változó típusa, hanem szerepe szerint történik az elnevezés (T,C,R,M) ((„dekorált” osztálynevek) memóriakezelés segítése függvénynevekkel: prefixek, postfixek („dekorált” eljárásnevek) String helyett deszkriptorok Többszálúság kezelése: ActiveObject, Thread

2009.09.19.


6

Osztálytípusok  T: egyszerű típus; nincs destruktora; csak T-ből, vagy M-ből

öröklődhet; értékként átadható; stack-en tárolható  C: csak a heapen foglalható; van destruktora; pontosan egy C és tetszőleges M osztályból származhat; nem adható át értékként  M: interfész; csak virtuális metódusok; nincsenek tagváltozók; nem példányosítható  R: erőforrás, melyet meg kell nyitni és be kell zárni

2009.09.19.


7

Kivételkezelés Standard kivételkezelés  A kivétel keletkezésekor egy objektumot dobunk  Egy try blokkban vagy az abból hívott függvényekben keletkező kivételt a catch blokkban elkaphatjuk és lekezelhetjük.  A kivétel keletkezésekor a vezérlés visszatér a hívó blokkba, majd az azt hívóba fel és fel, amíg kivételt le nem kezeljük.  Közben a verem memória (stack) visszafejtésre kerül, az abból kikerülő objektumok destruktorai meghívódnak.

2009.09.19.

Symbianos Leave-elés  A kivétel keletkezésekor egy egész szám (hiba kód) generálódik.  Egy TRAP vagy TRAPD makróval meghívott függvényben vagy abból hívott függvényekben keletkező kivételt a makróban lekezelhetjük.  A kivétel keletkezésekor a vezérlés visszatér a hívó blokkba, majd az azt hívóba fel és fel, amíg kivételt le nem kezeljük.  Közben a verem memória kiürül, de az abból kikerülő objektumok

destruktorai sem hívódnak meg.


8

Kivétel keletkezése – Leave-elő függvények  A Symbian-ban a kivétel kiváltására (ún. „leave-elésre”) a User könyvtár

 

 

Leave metódusa szolgál: User::Leave Ilyen „leave-elés” keletkezhet akkor is, ha a new operator helyett a new(ELeave) metódussal foglalunk helyet a szabad memóriában. Természetesen mindazon függvények futása során számíthatunk „leave-elésre”, amelyek  vagy közvetlenül meghívják a User::Leave() függvényt  vagy közvetlenül meghívják a new (ELeave) metódust  vagy egyéb „leave-elésre” képes függvényt hívnak meg. Ezeket a függvényeket leave-elő függvényeknek nevezzük. Tartsuk be azt a névkonvenciót, hogy minden leave-elő függvény neve L betűre végződjön.

2009.09.19.


9

Leave-elő mechanizmus  Leave-elésnél bekövetkező memória szivárgást úgy

kerülhetjük el, hogy egy leave-elő függvényben végrehajtott dinamikus helyfoglalások pointereit elhelyezzük egy úgynevezett CleanUpStack verembe.  Leave-eléskor ugyanis a CleanUpStack-beli pointerek által mutatott terület automatikusan felszabadul, miközben a CleanUpStack kiürül.  Ha nem következik be leave-elés, akkor nekünk kell a CleanUpStack-et kiüríteni.

2009.09.19.


10

new (ELeave) operátor LOCAL_C void MainL() { CMyClass* myPtr = new CMyClass; if(myPtr) { myPtr->Foo(); //Can safely access data & functions } delete myPtr;

}

LOCAL_C void MainL() { CMyClass* myPtr = new (ELeave) CMyClass; myPtr->Foo();

Hiba esetén abbahagyja a végrehajtást.

. . . delete myPtr;

2009.09.19.


11

„Hibakezelés” csapdázással, leaveléssel case ECleanupCmdUse3: { CX* x=new(ELeave) CX; TRAPD (error, x->UseL()); if(error) { delete x; User::Leave(error); } delete x; }

case ECleanupCmdUse3: { CX* x=new(ELeave) CX; CleanupStack::PushL(x); x->UseL(); x->UseL(); x->UseL(); CleanupStack::PopAndDestroy(x); }

2009.09.19.

Több függvényhívás esetén minden egyes függvényhívást külön-külön csapdázni kell.

A CleanupStack segítségével egy „csokorba” gyűjthetjük a leavelő függvényhívásokat.


12

Kétfázisú konstrukció  Az osztály standard konstruktorában nem hívunk leave-elő kódot.  A leave-elő hívásokat egy külön „második fázisú konstruktorba” tesszük.

(ConstructL)  Az osztály példányosítását becsomagoljuk a NewL() illetve NewLC() statikus metódusokba:  Meghívjuk a standard konstruktort (new) – első fázis  A „félig létrejött” objektumot feltesszük a CleanupStack-re  Meghívjuk a második fázisú konstruktort (ConstructL) – második fázis  Levesszük a CleanupStack-ről (ezt csak a NewL teszi meg)

Kétfázisú konstrukció megvalósítása ... CY* y = new(ELeave) CY; CleanupStack::PushL(y); ... CleanupStack::PopAndDestroy(y);

class CX : class CBasis { public: TInt iInt; }

class CY : class CBasis { public: CX *ix; static CY* NewL(); static CY* NewLC(); void ConsructL(){ ix = new (ELEAVE) CX;}; ~CY(){ delete ix;} } CY* CY::NewL(){ CY* self = new(ELEAVE) CY; CleanupStack::PushL(self); self->ConstructL() CleanupStack::Pop(); return self; }

CY* CY::NewLC(){ CY* self = new(ELEAVE) CY; CleanupStack::PushL(self); self->ConstructL() return self; }

Cleanup-safe HelloWorld int HelloWorldL() { CConsoleBase* console = Console::NewL(_L("Hello World"),TSize(KConsFullScreen,KConsFullScreen)); console->Printf(KTxtMessage); console->Printf(KTxtPressAnyKey); console->Getch(); // get and ignore character delete console; return 0; }

Konzolos alkalmazásnál a CleanupStack-et nekünk kell létrehozni.

TInt E32Main() { __UHEAP_MARK; CTrapCleanup* cleanup = CTrapCleanup::New(); TInt retVal = KErrNone; if(cleanup) { TRAP(retVal,HelloWorldL()); __ASSERT_ALWAYS(!retVal, User::Panic(_L("Hello World Panic"),retVal)); delete cleanup; } __UHEAP_MARKEND; return retVal; }

int main() { printf("Hello world!\n"; return 0; }

Fájl kezelés Hívó kliens

File szerver kliens oldali része

mytest.exe szolgáltatás kérés (API hívások) pl.: RFs::Connect()

efsrsv.dll

Process boundary

Kliens-szerver kommunikáció (Kernel által felügyelt) File server

efile.exe int main() { File* fp = fopen("file.txt",w); if (fp) fprintf(fp, "Write some data"); fclose(); return 0; }

//File I/O in Symbian OS RFs fSession; User::LeaveIfError(fSession.Connect()); RFile file; ret = file.Open(fSession, _L(“file.txt”), EFileWrite); if (ret) { ret = file.Create(fSession, _L(“file.txt”), EFileWrite); } if (!ret) { file.Write(_L8(“Write some data”)); } file.Close(); fSession.Close();

Futtaható program „modularizálása” Forráskód

.exe

Forráskód

„.exe”

Kép

Futtató környezet

Kép

.exe

Erőforrás

„szöveg”

Erőforrás Fájl szerver

Fájl szerver

„szöveg” Ablak szerver Kód ...

indexek Ablak szerver Kód ...

A fordítás és szerkesztés folyamata .bmp

<.h>

„.h”

.rsg

.hrh

.rh

Bmp konverter

.rls

.cpp

.rss

.bmp

C++ fordító

Erőforrás fordító

Bmp konverter

Aif fordító

.mbm

.aif

.obj

.lib

.rsc

.pkg

.mbm

.rss

linker

.exe; .dll

Sis készítő

.sis

Kisokos  User::Leave (standard: throw)  TRAP, TRAPD (standard: try-catch)  záró L (standard: függvénydeklarációbeli throw(…))  new (Eleave) metódus (standard: new)

 Leave-elő kódban létrehozott példányokat a CleanUpStack-be  A leave-elő kód normális befejezésekor kiürítjük a CleanUpStack-t  Kétfázisú konstruktor (ConstructL) és az azt lebonyolító NewL,

NewLC elkészítése

2009.09.19.


19

Mobil alkalmazások fejlesztése. Készítette: Szabóné Nacsa Rozália

Recommend Documents