Theory
બધું સાથે બાંધો, Kotlin માં
BCA503-02 એ તમને Kotlin શીખવ્યું અને એનાથી Android apps કઈ રીતે બનાવવાં એ પણ: પહેલાં ભાષા (Units 1 થી 2), પછી JSON, intents, SQLite, location અને camera સાથેનાં અનેક screens વાળાં apps (Unit 3). Capstone PROJECT તમને એ બધાંને એક ચાલતા Kotlin Android app માં ભેગાં કરવાનું કહે છે.
સ્વાભાવિક પસંદગી એ જ ચાલુ દાખલો છે જેને તમે અનુસર્યો છે: FestConnect Mobile, જે હવે Kotlin માં ફરી બંધાય છે. આ સમાપન પાઠ એની મર્યાદા બાંધવા અને એને સારી રીતે બનાવવા વિશે વ્યવહારુ માર્ગદર્શન આપે છે, જેથી એ અધૂરા ગૂંચવાડામાં ફેલાઈ જવાને બદલે ખરી નિપુણતા બતાવે. નાનું, સંપૂર્ણ અને ઓપ અપાયેલું app દર વખતે મોટા અને તૂટેલા કરતાં ચડિયાતું જ રહે છે.
Follow along
Capstone Kotlin app ની મર્યાદા બાંધવી
- નાનું પણ સંપૂર્ણ app પસંદ કરો FestConnect Mobile આદર્શ છે: events ની યાદી, event ની વિગતનું screen, અને નોંધણીનું form. પૂરું થાય એવું અને સુસંગત.
- Intents વડે અનેક screens એક screen થી બીજા પર જવા explicit intents વાપરો (યાદીથી વિગત સુધી) અને extras વડે data મોકલો; event વહેંચવા કદાચ implicit intent પણ.
- SQLite માં ટકાવો નોંધણીઓ device પરના SQLite database માં CRUD સાથે સાચવો, જેથી એ એક session થી બીજા session સુધી ટકે.
- એક device feature ઉમેરો ઓછામાં ઓછું એક રાખો: location (નજીકનાં સ્થળો) કે camera (ફોટો), અને એની સાથે runtime permission બરાબર સંભાળો.
- Kotlin સારી રીતે વાપરો, અને નોંધ લખો Null safety, ટૂંકા classes અને var ને બદલે val વાપરો; અને ટૂંકી નોંધ લખો: એ શું કરે છે, અને એને ચલાવવું કઈ રીતે.
Theory
એક app, બધાં કૌશલ્યો
તમારો project આખા વિષયને એકસાથે વણી લે છે: Kotlin (સલામત, ટૂંકા classes અને તર્ક), JSON (server પરથી કે સાથે મૂકેલી file માંથી આવતો data), intents (screens વચ્ચે ફરવું અને બીજાં apps સાથે સહકાર કરવો), SQLite (device પર ટકતો data), અને એક device feature (location કે camera, permissions સાથે).
આટલી થોડી વસ્તુઓ પણ બરાબર કરતું નાનું app, એટલે કે સાફ event યાદી, SQLite માં સચવાતી ચાલતી નોંધણી, વહેંચી શકાતો event અને એક device feature, એ બતાવી દે છે કે તમે Kotlin માં ખરેખરું, data પર ચાલતું અને device થી વાકેફ Android app બનાવી શકો છો. Project એ જ શરૂથી અંત સુધીની ક્ષમતા બતાવે છે, app નું કદ નહીં. એને ધીરે ધીરે બાંધો: પહેલાં એક screen અને એક feature પૂરેપૂરું ચાલતું કરો, પછી બીજું, અને સાથે સાથે ચકાસતા જાઓ.
Quiz
BCA503-02 ના capstone project માટે સૌથી સારી રીત કઈ છે?
- દરેક feature સાથે શક્ય એટલું મોટું app બનાવવું, ભલે એ અધૂરું રહી જાય
- નાનું પણ સંપૂર્ણ Kotlin Android app બનાવવું (અનેક screens, SQLite, એક device feature), જેની મર્યાદા પૂરું થાય એ રીતે બાંધી હોય અને જે ધીરે ધીરે બંધાયું હોય
- Kotlin છોડીને એની જગ્યાએ Java વાપરવું
- ફક્ત IKS નું ગણિત કરવું, app નહીં
Show the answer
નાનું પણ સંપૂર્ણ Kotlin Android app બનાવવું (અનેક screens, SQLite, એક device feature), જેની મર્યાદા પૂરું થાય એ રીતે બાંધી હોય અને જે ધીરે ધીરે બંધાયું હોય
સાચી રીત એ છે કે Units 1 થી 3 લગાડીને નાનું પણ સંપૂર્ણ Kotlin Android app બનાવવું: અનેક screens (intents), SQLite માં સંગ્રહ, અને એક device feature, જેની મર્યાદા એવી બાંધી હોય કે તમે એને પૂરું કરીને ઓપ આપી શકો, અને જે ધીરે ધીરે બંધાયું હોય. વિકલ્પ A એ મર્યાદા વટાવવાની ભૂલ છે: મોટું પણ અધૂરું app સાફ અને ચાલતા નાના app કરતાં ઓછું બતાવે છે (દરેક project વિષયમાં આવેલો એ જ બોધ). વિકલ્પ C એ ભૂલી જાય છે કે આ Kotlin નો વિષય છે: project માં Kotlin જ ઝળકવું જોઈએ. વિકલ્પ D એ IKS ના ગણિતના વિષયને (જે અલગ કામ છે) app ના project સાથે ગૂંચવે છે. પહોળાઈ કરતાં ઊંડાણ સારું: એક નક્કર, સંપૂર્ણ અને નોંધ સાથેનું Kotlin app Unit 1 થી 3 નાં કૌશલ્યો સૌથી સારી રીતે બતાવે છે. નાનું અને પૂરું થયેલું, મોટા અને તૂટેલા કરતાં ચડિયાતું છે.
Think first
કયું device feature રાખવું?
Project માં ઓછામાં ઓછું એક device feature (location કે camera) માગ્યું છે. પસંદગી કઈ રીતે કરવી, અને શું ભૂલવું નહીં? વિચારીને પછી tap કરો.
Show the answer
એ feature પસંદ કરો જે તમારા app ની વાર્તાને સૌથી સારી રીતે બંધબેસે અને જેને તમે સફાઈથી ઉતારી શકો. FestConnect Mobile માટે camera સ્વાભાવિક રીતે બંધબેસે છે (profile નો ફોટો, કે event પરનો ફોટો), અને location ત્યારે બંધબેસે જ્યારે તમે નજીકનાં સ્થળો બતાવતા હો; જેના માટે તમારા app પાસે ખરું કારણ હોય એ પસંદ કરો, અમસ્તું ચોંટાડી દીધેલું નહીં.
જે ભૂલવું નહીં તે: permissions. Location અને camera બંને સંવેદનશીલ પહોંચ માગે છે, એટલે permission જાહેર કરો, એને runtime પર માગો, એ મળી છે કે નહીં તપાસો, અને નકાર ને શાંતિથી સંભાળો (feature બસ દેખાય જ નહીં, app તૂટે નહીં).
આ Unit 3 વાળી runtime-permission ની શિસ્ત છે, અને એને બરાબર કરવી એ ખરી Android ક્ષમતા બતાવવાનો તથા user ને માન આપવાનો ભાગ છે (BCA402-02 નો વિશ્વાસનો સિદ્ધાંત). Permission બરાબર સંભાળ્યા વગર ઉતારેલું device feature અધૂરું ગણાય અને ખરા ફોન પર એ app તોડી નાખે. હેતુ સાથેનું feature પસંદ કરો, અને એની permission બરાબર સંભાળો.
Watch out
Project માં પડતી ભૂલો
મર્યાદા વટાવવી: મોટું પણ અડધું બંધાયેલું app નાના પણ સંપૂર્ણ app કરતાં ઓછું બતાવે છે; મર્યાદા એવી બાંધો કે પૂરું થાય.
Permission સંભાળવાનું છોડી દેવું: device features માટે runtime permissions બરાબર સંભાળવી પડે, નહીં તો app તૂટે છે.
Data ને ટકાવવો નહીં: SQLite વાપરો જેથી data ટકે; બધું ભૂલી જતું app અધૂરું ગણાય.
Kotlin ની ખૂબીઓ અવગણવી: null safety, val અને ટૂંકા classes વાપરો; Java ની ઢબનું Kotlin ન લખો.
નોંધ ન લખવી: સ્પષ્ટ લખાણ વગરનું (શું કરે છે, ચલાવવું કઈ રીતે) project અધૂરું ગણાય.
(મૂલ્યાંકનના ચોક્કસ માપદંડ તમારી સંસ્થા નક્કી કરે છે; એની ખાતરી કરી લેવી.)
Theory
BCA503-02 પૂરું
તમે Kotlin શીખ્યા, જે Google ની પસંદગીની Android ભાષા છે, અને એનાથી ખરેખરું, data પર ચાલતું અને device થી વાકેફ Android app બનાવ્યું, અને એની સાથે Lilavati માંથી શાસ્ત્રીય ભારતીય ગણિતનો હકીકતલક્ષી અભ્યાસ પણ કર્યો. Advance Mobile Technology નો આખો પ્રવાસ આ જ છે. આ unit માટે તમારી સંસ્થા જે સૂચના આપે તે પ્રમાણે કરો; ગણિત ચોકસાઈથી રજૂ કરો અને તમારા સ્રોતોનો ઉલ્લેખ કરો. હવે ત્રણ ભાષાઓમાં, એટલે કે Java, Dart અને Kotlin માં, તમે mobile માટે બનાવી શકો છો: ઢળી શકો એવા, અને તૈયાર.
Summary
Key takeaways
- Capstone Units 1 થી 3 ને ભેગાં કરે છે: અનેક screens, SQLite માં સંગ્રહ અને એક device feature વાળું Kotlin Android app.
- એવા નાના પણ સંપૂર્ણ app ની મર્યાદા બાંધો (FestConnect Mobile આદર્શ છે) જેને તમે પૂરું કરીને ઓપ આપી શકો.
- Screens વચ્ચે ફરવા અને data મોકલવા intents વાપરો; ટકાવવા માટે SQLite; data માટે JSON; અને ઓછામાં ઓછું એક device feature (location કે camera).
- કોઈ પણ device feature માટે runtime permissions બરાબર સંભાળો, અને નકાર મળે તો શાંતિથી પાછા હટો.
- Kotlin ની ખૂબીઓ વાપરો: null safety, ટૂંકા classes, var ને બદલે val; ધીરે ધીરે બાંધો અને સાથે સાથે ચકાસતા જાઓ.
- Project ની નોંધ લખો; નાનું અને પૂરું થયેલું, મોટા અને તૂટેલા કરતાં ચડિયાતું છે.
- યાદ રાખવાની કડી: એક નાનું સંપૂર્ણ Kotlin app, અનેક screens, ટકતો data, એક device feature, શરૂથી અંત સુધી બાંધેલું.