Theory
તમારી app ને ટેકો કોણ આપે છે?
FestConnect Mobile એ software ના ઊંચા ખડકલાની છેક ટોચે બેસશે, અને એ પોતાની નીચેના દરેક સ્તર પર ટેકે છે: એ framework જે એને બટન આપે છે, એ runtime જે એનો code ચલાવે છે, એ libraries જે એનો data સંઘરે છે, અને એ kernel જે ખરેખરી chips સાથે વાત કરે છે.
Android ની રચના એ સ્તરોનો ખડકલો છે, ચાર માળ, દરેક પોતાની નીચેના પર બંધાયેલો. માળ અને એમનો ક્રમ જાણવો એ ખાતરીબદ્ધ પરીક્ષાનો પ્રશ્ન છે અને તમે બાંધો છો એ બધા માટેનો માનસિક નકશો.
Theory
ચાર માળની ઇમારત
એક ઇમારત કલ્પો. પાયો જમીનને (hardware ને) અડે છે: એ Linux kernel છે. એના પર ઉપયોગિતાના ઓરડા, પાણીની ટાંકી અને generators (native libraries અને runtime). એમની ઉપર, સેવાઓનો માળ જ્યાં સ્વાગત, સૂચનાઓ, અને તમે બોલાવો એવો કર્મચારીવર્ગ છે (application framework). અને ટોચે, ફ્લેટ જ્યાં ભાડૂતો રહે છે (apps). દરેક માળ પોતાની નીચેના પર આધારિત છે; એકેય જાતે હવામાં તરતો નથી.
Theory
ચાર સ્તર, નીચેથી ઉપર
1. Linux Kernel (તળિયે): ઉપકરણનાં drivers, memory, પ્રક્રિયા અને power નું સંચાલન, સલામતી. Hardware સાથે વાત કરે છે.
2. Native Libraries વત્તા Android Runtime: C/C++ ની libraries (data માટે SQLite, WebKit, ચિત્રો માટે OpenGL) અને એ runtime (ART, પહેલાં Dalvik VM) જે તમારી app નો compile થયેલો code ચલાવે છે, દરેક app પોતાના VM માં.
3. Application Framework: તમે જેની સામે code લખો છો એ Java ની APIs, એટલે કે Activity Manager, Content Providers, Notification Manager, View System, Package Manager.
4. Applications (ટોચે): જડેલી apps અને તમારી, જેમ કે FestConnect.
At a glance
ખડકલો અને એમાં કોણ વસે છે
| સ્તર | એમાં શું છે | ઉદાહરણ |
|---|---|---|
| 4. Applications | apps | FestConnect, Contacts |
| 3. App Framework | Java ની API ના managers | Activity Manager |
| 2. Libraries વત્તા Runtime | C/C++ ની libs, ART/Dalvik | SQLite, ART |
| 1. Linux Kernel | drivers, memory, power | camera નું driver |
Think first
એક save ને અનુસરો
FestConnect એક નોંધણીને ઉપકરણ પરના નાના database માં સંઘરે છે. કયું સ્તર એ database નું engine આપે છે, અને કયું સ્તર આખરે bytes ને સંગ્રહના hardware પર લખે છે? બંનેનાં નામ આપો.
Show the answer
Database નું engine છે SQLite, જે સ્તર 2 માંની native library છે. પણ SQLite પોતે flash ની chip ને અડતું નથી; એ Linux kernel (સ્તર 1) ને drivers દ્વારા bytes ખરેખર સંગ્રહમાં લખવાનું કહે છે. એટલે એક જ save નીચે તરફ મુસાફરી કરે છે: તમારી app (4) framework ની API (3) બોલાવે છે, જે SQLite (2) વાપરે છે, જે kernel (1) પર ટેકે છે. દરેક ખરેખરી ક્રિયા ખડકલામાં નીચે kernel સુધી જઈને પાછી આવે છે.
Quiz
Android ના ખડકલામાં Linux kernel ક્યાં બેસે છે, અને તમારી applications ની બરાબર ઉપર શું છે?
- Kernel તળિયે; applications ની ઉપર કશું નથી, એ સૌથી ઉપરનું સ્તર છે
- Kernel ટોચે; applications સીધી kernel પર બેસે છે
- Kernel વચ્ચે; applications તળિયે છે
- ફક્ત એક જ સ્તર છે, એટલે ક્રમ લાગુ પડતો નથી
Show the answer
Kernel તળિયે; applications ની ઉપર કશું નથી, એ સૌથી ઉપરનું સ્તર છે
Linux kernel એ તળિયાનો પાયો છે, અને applications એ સૌથી ઉપરનું સ્તર છે જેની ઉપર કશું નથી (A). Kernel ક્યારેય ટોચે (B) કે વચ્ચે (C) હોતું નથી: એ hardware ની સૌથી નજીક હોવું જ જોઈએ. Android સ્પષ્ટપણે ચાર સ્તરનો ખડકલો છે, એટલે ક્રમ બહુ મહત્ત્વનો છે (D ખોટું છે). નીચેથી ઉપરનો ક્રમ યાદ રાખો: Kernel, Libraries વત્તા Runtime, Framework, Applications.
Watch out
Architecture ના ફાંદા
1. ક્રમ ઊલટાવવો: kernel તળિયે છે (hardware ની નજીક), apps ટોચે. એને ઊંધું દોરવાથી marks જાય છે.
2. Runtime ને ખોટા સ્તરમાં મૂકવું: ART/Dalvik એ સ્તર 2 માં (native libraries સાથે) વસે છે, framework માં નહીં.
3. apps kernel સાથે સીધી વાત કરે છે એવું માનવું: એ framework અને libraries દ્વારા જાય છે. એક સ્તર ફક્ત પોતાની નીચેના સ્તરને જ બોલાવે છે.
Theory
આગળ: runtime માં ઊંડે
સ્તર 2 એ કંઈક મહત્ત્વનું છુપાવ્યું: એ runtime જે ખરેખર તમારી app ચલાવે છે, એટલે કે Dalvik Virtual Machine (અને એનું અનુગામી ART). હવે પછીનો પાઠ એમાં ઊંડે ઊતરે છે: Android ને પ્રમાણભૂત Java ના VM ને બદલે પોતાનું VM કેમ જોઈતું હતું, અને એ battery પર ચાલતા ફોન પર તમારો compile થયેલો FestConnect નો code કેવી રીતે કાર્યક્ષમ રીતે ચલાવે છે.
Summary
Key takeaways
- Android એ ચાર સ્તરનો software નો ખડકલો છે; દરેક સ્તર પોતાની નીચેનું સ્તર વાપરે છે.
- નીચેથી ઉપર: Linux Kernel; Native Libraries વત્તા Android Runtime; Application Framework; Applications.
- Kernel drivers/memory/power સંભાળે છે; libraries માં SQLite/WebKit/OpenGL આવે છે; runtime (ART/Dalvik) app નો code ચલાવે છે.
- Framework એ Java ની API ના managers (Activity Manager, વગેરે) આપે છે જેની સામે apps code લખે છે.
- તમારી apps સૌથી ઉપરનું સ્તર છે; એ hardware સુધી ફક્ત ખડકલામાં નીચે જઈને જ પહોંચે છે.
- Memory hook: ચાર માળની ઇમારત, પાયા (kernel) થી ફ્લેટ (apps) સુધી.