Theory
App ને એના events કઈ રીતે મળે છે
FestConnect Mobile પોતાના events જાતે ઉપજાવતી નથી: એ એમને server પાસેથી મંગાવે છે, અને server એમને કોઈ ચોક્કસ સ્વરૂપમાં લખાણ તરીકે મોકલે છે. એ સ્વરૂપ લગભગ હંમેશા JSON હોય છે, એટલે કે એ હલકી data ની ભાષા જે તમે BCA405-01 માં ઊંડાણથી ભણ્યા હતા અને BCA504 માં server બાજુ બનાવી હતી.
હવે તમે એને mobile ની બાજુથી મળો છો: app API પાસેથી JSON માગે છે, એને parse કરીને Kotlin ના પદાર્થોમાં ફેરવે છે, અને બતાવે છે. આ પાઠ JSON ની રચના અને XML સાથેનો એનો ભેદ ફરી યાદ કરાવે છે, અને પછી ધ્યાન એ પર આપે છે કે Android app એને ખરેખર કઈ રીતે વાપરે છે. JSON એ FestConnect Mobile અને એના data વચ્ચેનો પુલ છે.
Theory
JSON ની રચના, ફરી એક વાર
JSON (JavaScript Object Notation) એ હલકું, લખાણ આધારિત અને ભાષાથી સ્વતંત્ર data સ્વરૂપ છે:
- objects:
{ "key": value }, જેમાં keys બેવડા અવતરણચિહ્નમાં હોય - arrays:
[ value, value ] - values: string (બેવડા અવતરણચિહ્નમાં), સંખ્યા (ખુલ્લી), boolean, null, કે અંદર ગૂંથાયેલો object અથવા array
અને ફરી કહેવા જેવો એક નિયમ: JSON માં comments હોતાં જ નથી (XML થી ઊલટું). એ જાણી જોઈને ઓછામાં ઓછું રખાયું છે.
BCA405-01 માં તમે જે શીખ્યા તે બધું અહીં લાગુ પડે છે. Mobile માટેનો મુખ્ય મુદ્દો આ છે: server એક JSON string મોકલે છે, અને app એ string ને વાપરી શકાય એવા પદાર્થોમાં ફેરવે છે. Events વાળું endpoint event ના objects નું ARRAY પાછું આપી શકે, અને એ જ આકાર FestConnect Mobile ને એની યાદી બનાવવા માટે જોઈએ છે.
Practical
Events નું JSON, અને Android માં એને parse કરવું
// server આ JSON મોકલે છે (event ના objects નું array):
// [
// { "name": "Garba Night", "seats": 350 },
// { "name": "Coding Contest", "seats": 60 }
// ]
import org.json.JSONArray
fun parseEvents(jsonText: String): List<String> {
val names = mutableListOf<String>()
val arr = JSONArray(jsonText) // JSON array ને parse કરો
for (i in 0 until arr.length()) {
val obj = arr.getJSONObject(i) // દરેક event નો object
names.add(obj.getString("name")) // name વાળું field વાંચો
}
return names
}
// Android JSON ને સીધું Kotlin ના classes સાથે જોડવા Gson કે Moshi પણ આપે છે.
At a glance
JSON સામે XML (ફરી એક વાર)
| પાસું | JSON | XML |
|---|---|---|
| વજન | હલકું (બંધ કરતાં tags નહીં) | ભારે (ખૂલતાં અને બંધ થતાં tags) |
| Arrays | અંદરથી જ [ ] વડે | એ જ ઘટક વારંવાર લખવું પડે |
| Comments | એકેય નહીં | હા (<!-- -->) |
| Apps માં parsing | સહેલું, પદાર્થો સાથે સીધું ભળે | વૃક્ષ પર ફરવું પડે |
Quiz
JSON વિશે કયું વિધાન સાચું છે?
- JSON code ની જેમ // વડે comments ને ટેકો આપે છે
- JSON એ હલકું data સ્વરૂપ છે જેમાં objects {} અને arrays [] હોય છે; એમાં comments હોતાં નથી અને એ XML કરતાં હલકું છે
- JSON ફક્ત લખાણ સંઘરી શકે છે, સંખ્યાઓ નહીં
- JSON એ XML કરતાં ભારે છે
Show the answer
JSON એ હલકું data સ્વરૂપ છે જેમાં objects {} અને arrays [] હોય છે; એમાં comments હોતાં નથી અને એ XML કરતાં હલકું છે
JSON એ હલકું, લખાણ આધારિત data સ્વરૂપ છે જે objects {} (બેવડા અવતરણચિહ્નવાળી keys સાથે) અને arrays [] વાપરે છે, જેમાં comment ની કોઈ syntax નથી, અને એ XML કરતાં હલકું છે (બંધ કરતાં tags નહીં, અને arrays અંદરથી જ). વિકલ્પ A એક સામાન્ય ગેરસમજ છે: પ્રમાણભૂત JSON માં comments હોતાં જ નથી (BCA405-01 નો આખો પાઠ). વિકલ્પ C ખોટો છે: JSON strings, સંખ્યાઓ, booleans, null અને અંદર ગૂંથાયેલી રચનાઓ સંઘરે છે. વિકલ્પ D વજનની સરખામણી ઊંધી કરી નાખે છે: JSON એ XML કરતાં હલકું છે, અને એટલે જ mobile apps તથા APIs એને પસંદ કરે છે (network પર ઓછો data, અને parse કરવું સહેલું). FestConnect Mobile માટે JSON એ સઘન અને સહેલાઈથી parse થતું સ્વરૂપ છે જેના વડે server events પહોંચાડે છે.
Think first
Mobile apps ને JSON કેમ ગમે છે
Mobile apps એવા ફોન પર ચાલે છે જ્યાં data અને battery મર્યાદિત હોય છે. એથી servers સાથે વાત કરવા માટે XML ને બદલે JSON સહજ પસંદગી કેમ બને છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે JSON હલકું છે. Mobile network પર દરેક byte data અને battery ખર્ચે છે, અને JSON એ જ માહિતી XML કરતાં ઘણા ઓછા bytes માં લઈ જાય છે (વારંવારનાં બંધ કરતાં tags નહીં, અને સઘન syntax). નાના જવાબો એટલે ઝડપી download, ઓછો data વપરાશ અને battery ની ઓછી ખપત, અને ફોન પર આ ત્રણેય કીમતી છે. JSON parse કરવામાં પણ સહેલું છે અને પદાર્થો સાથે સફાઈથી ભળે છે (JSON નો object Kotlin નો પદાર્થ બની જાય), એટલે જવાબને વાપરી શકાય એવા data માં ફેરવવામાં app ને ઓછી મહેનત પડે છે. અને mobile apps મોટે ભાગે એવા REST APIs સાથે વાત કરે છે જે JSON પાછું આપે છે, એટલે એ વાપરવું આખા પર્યાવરણ સાથે બંધ બેસે છે. XML ની પણ પોતાની જગ્યા છે (Android નાં layouts XML માં હોય છે, અને કેટલીક મોટી સંસ્થાઓની વ્યવસ્થાઓ એ વાપરે છે), પણ app અને server વચ્ચેની data ની આપલે માટે JSON નું હલકાપણું અને સરળતા જીતે છે. સામાન્ય સિદ્ધાંત આ છે: મર્યાદિત સાધનોવાળાં ઉપકરણો પર એવું સ્વરૂપ પસંદ કરો જે ઓછામાં ઓછા બોજ સાથે વહે અને parse થાય.
Watch out
Android માં JSON ના ફાંદા
JSON માં comments ની અપેક્ષા: એ હોતાં જ નથી; JSON માં // ન મૂકો.
Parse ની ભૂલો ન સંભાળવી: બગડેલું JSON exception ફેંકે છે; parsing ને try અને catch માં વીંટો.
UI thread રોકી રાખવો: data મંગાવવો અને parse કરવો મુખ્ય thread ની બહાર થવો જોઈએ (coroutines કે પાછળના thread પર), નહીં તો app થીજી જાય.
Fields હશે જ એમ માની લેવું: key ખૂટતી હોય તો getString exception ફેંકે છે; તપાસો, અથવા opt વાળી methods કે nullable જોડાણ વાપરો.
JSON (data) અને XML layouts ને ભેળવી દેવાં: Android layouts માટે XML વાપરે છે પણ API ના data માટે JSON; બંનેનાં કામ જુદાં છે.
Theory
Data નું સ્વરૂપ ખબર પડી; હવે screens વચ્ચે ફરો
FestConnect Mobile server મોકલે છે એ events વાળું JSON parse કરી શકે છે. ખરી app માં અનેક screens હોય છે: events ની યાદી, event ની વિગત, નોંધણીનું form. એમની વચ્ચે ફરવાનું અને સાથે data લઈ જવાનું કામ INTENTS થી થાય છે, જે activities ને શરૂ કરવાની અને એમની વચ્ચે વાત કરાવવાની Android ની પદ્ધતિ છે. પછીનો પાઠ અનેક screens વાળી apps અને intents આવરી લે છે, જે Android ના navigation ની કરોડરજ્જુ છે અને જેનો પહેલો પરિચય તમને BCA305-02 માં થયો હતો.
Summary
Key takeaways
- JSON એ હલકું, લખાણ આધારિત અને ભાષાથી સ્વતંત્ર data સ્વરૂપ છે: objects {"key": value}, arrays [value, value].
- કિંમતો: string (બેવડા અવતરણચિહ્નમાં), સંખ્યા (ખુલ્લી), boolean, null, અને અંદર ગૂંથાયેલી રચનાઓ; keys બેવડા અવતરણચિહ્નમાં હોય છે; અને JSON માં comments હોતાં નથી.
- JSON સામે XML: JSON હલકું છે (બંધ કરતાં tags નહીં), એમાં arrays અંદરથી જ છે અને એ સહેલાઈથી parse થાય છે; XML માં tags, attributes અને comments હોય છે.
- Mobile apps server (REST API) પાસેથી JSON મંગાવે છે અને એને parse કરીને પદાર્થોમાં ફેરવીને બતાવે છે.
- Android JSON ને org.json (JSONObject અને JSONArray) વડે parse કરે છે, અથવા Gson કે Moshi જેવી libraries વડે (જે એને Kotlin ના classes સાથે જોડે છે).
- JSON નું હલકાપણું ફોનને અનુકૂળ છે (ઓછો data, ઓછી battery, સહેલું parsing); XML Android નાં layouts માટે વપરાય છે, API ના data માટે નહીં.
- યાદ રાખવાની કડી: JSON એ હલકું data સ્વરૂપ છે જેને apps મંગાવે અને parse કરે; એમાં comments નથી અને એ XML કરતાં હલકું છે.