Creating GET and POST request in android; API response handling

Android માં રોજિંદા બે API calls: GET request કોઈ endpoint પરથી data લાવે છે, POST request એને data મોકલે છે, અને બંનેમાં response તથા કોઈ પણ error તમે Volley ના callbacks માં સંભાળો છો.

Theory

લાવવું અને મોકલવું, જરૂરી બે calls

હવે બધું એકસાથે જોડાય છે. FestConnect Mobile events ની યાદી લાવે છે (એટલે કે GET) અને નવું registration મોકલે છે (એટલે કે POST), બંને કોઈ REST API ને, Volley વાપરીને, JSON ને parse કરીને અને response ને સંભાળીને. આ છેલ્લો પાઠ REST, JSON અને Volley ને એ બે requests માં જોડી આપે છે જે તમે સૌથી વધુ કરવાના છો.

GET વાંચે છે; POST લખે છે. બંનેમાં Volley એ call ને UI thread ની બહાર ચલાવે છે અને પરિણામ તમને callback માં આપે છે, જ્યાં તમે કાં તો data વાપરો છો કાં તો error સંભાળો છો. આ બે પર પકડ આવી જાય, એટલે તમે Android માંથી લગભગ કોઈ પણ web API વાપરી શકો.

Theory

GET request: events લઈ આવો

GET data લઈ આવે છે. તમે Volley request બનાવો છો, જેમાં Request.Method.GET, endpoint નું URL અને (GET માટે) null body હોય છે, સાથે તમારા success અને error listeners હોય છે.

એ સફળ થાય ત્યારે response આવે છે, JsonObjectRequest માટે એ પહેલેથી જ parse થયેલો હોય છે, એટલે કે JSONObject (અથવા JSONArray) સ્વરૂપે, જેને તમે શીખેલી parsing વડે વાંચો છો: events array બહાર કાઢો, એના પર loop ચલાવો, દરેકનું name અને seats કાઢો, અને UI અપડેટ કરો. એટલે GET એટલે: endpoint ને મોકલવું, JSON મેળવવું, એને parse કરવું, એને બતાવવું. આ રીતે જ app દૂરના server પરથી જીવંત યાદી બતાવે છે.

Practical

Events માટે GET કરો, response સંભાળો

val getEvents = JsonObjectRequest(
    Request.Method.GET, "https://api.example.com/events", null,
    { response ->                       // success
        val arr = response.getJSONArray("events")
        for (i in 0 until arr.length()) {
            val e = arr.getJSONObject(i)
            addToList(e.getString("name"), e.getInt("seats"))
        }
    },
    { error -> showError("Could not load events") }   // error handling
)
queue.add(getEvents)

Practical

POST request: registration મોકલો

// Build the JSON body to send
val body = JSONObject().apply {
    put("studentName", "Riya")
    put("eventId", 5)
}

val postReg = JsonObjectRequest(
    Request.Method.POST, "https://api.example.com/registrations", body,
    { response -> showMessage("Registered!") },        // success
    { error -> showError("Registration failed") }      // error handling
)
queue.add(postReg)   // POST sends 'body' to the server, which processes it

Formula

success અને error, બંને હંમેશા સંભાળો

દરેક request ના બે સંભવિત પરિણામ હોય છે, અને તમે બંને સંભાળો છો. success listener ને response મળે છે: data વાપરો કે parse કરો અને UI અપડેટ કરો. error listener ને VolleyError મળે છે: વપરાશકર્તાને સ્પષ્ટ સંદેશો બતાવો, અને (ઉપયોગી લાગે તો) status code કે network કારણ જાણવા error ને તપાસો.

ફક્ત success નો રસ્તો કદી ન લખો. Networks નિષ્ફળ જાય છે, servers errors પાછા આપે છે, tokens ની મુદત પૂરી થાય છે, અને જે app error listener ને અવગણે એ કંઈક ખોટું થાય ત્યારે વપરાશકર્તાને થીજી ગયેલી કે કોરી screen સામે તાકતા મૂકી દે છે. Error દર વખતે સંભાળો: નિષ્ફળ ગયેલા request માંથી મદદરૂપ સંદેશો નીકળવો જોઈએ, મૌન નહીં. સફળતા અને નિષ્ફળતા, બંને request નો જ ભાગ છે.

Quiz

FestConnect Mobile માં events ની યાદી લાવવા માટે અને API ને નવું registration મોકલવા માટે અનુક્રમે કયાં HTTP methods વપરાય છે?

લાવવા માટે POST, મોકલવા માટે GET
Events લાવવા માટે GET (વાંચવું), અને registration મોકલવા માટે POST (બનાવવું કે મોકલવું)
બંને GET વાપરે છે
બંને DELETE વાપરે છે

Show the answer

Events લાવવા માટે GET (વાંચવું), અને registration મોકલવા માટે POST (બનાવવું કે મોકલવું)

Events ની યાદી લાવવી (વાંચવી) એ GET request છે, અને નવું registration મોકલવું (બનાવવું) એ POST request છે, જે REST ના રિવાજ પ્રમાણે જ છે: GET વાંચે છે, POST બનાવે છે કે મોકલે છે. વિકલ્પ A એ બંનેને ઊંધા કરે છે, જેનાથી methods નો દુરુપયોગ થાય (ફક્ત વાંચવા માટે POST ન કરાય, અને નવો data મોકલવા માટે GET ન કરાય). વિકલ્પ C ખોટો છે: registration મોકલવું એટલે કંઈક બનાવવા માટે data મોકલવો, જે POST છે, GET નહીં. વિકલ્પ D ખોટો છે: DELETE કોઈ resource ને કાઢી નાખે છે, એ નથી લાવવાનું કામ કરતું કે નથી મોકલવાનું. Method ને ઇરાદા સાથે મેળવો: data લાવવા માટે GET, data મોકલવા કે બનાવવા માટે POST, અને callbacks માં success તથા error બંને સંભાળો.

Think first

ફક્ત success નહીં, error નો કિસ્સો પણ હંમેશા કેમ સંભાળવો પડે?

Testing માં તો સીધો રસ્તો ચાલી જ જાય છે. તો error listener સંભાળવું success listener જેટલું જ કેમ જરૂરી છે? વિચારીને પછી tap કરો.

Show the answer

કારણ કે ખરી દુનિયામાં network requests નિયમિતપણે નિષ્ફળ જાય છે, અને જે app ફક્ત success સંભાળે એ કંઈ પણ ખોટું થાય ત્યારે વપરાશકર્તાને મૂંઝવણમાં, અટવાયેલા કે તૂટેલી screen સામે તાકતા મૂકી દે છે, અને એવું વારંવાર બને છે.

ઝડપી અને ભરોસાપાત્ર connection પર development કરતી વખતે એવું જ લાગે કે સીધો રસ્તો જ બધું છે: request સફળ થાય, data બતાવો, પતી ગયું. પણ ખરા વપરાશકર્તાઓ તો ડગમગતાં mobile networks પર હોય છે, ટનલમાં હોય છે, tokens ની મુદત પૂરી થઈ ગઈ હોય છે, અને એવા servers સાથે વાત કરે છે જે થોડી વાર માટે બંધ હોય, ભારે ભરાયેલા હોય કે errors પાછા આપતા હોય. એ બધા કિસ્સામાં request નિષ્ફળ જાય છે, અને જો તમે ફક્ત success listener લખ્યું હોય તો કશું જ થતું નથી: data દેખાતો નથી, કોઈ સંદેશો આવતો નથી, spinner કદાચ કાયમ ફર્યા કરે છે, અને વપરાશકર્તાને ખબર જ પડતી નથી કે રાહ જોવી, ફરી પ્રયત્ન કરવો કે છોડી દેવું.

એ કંટાળાજનક અને તૂટેલો અનુભવ છે. Error listener સંભાળવાથી તમે સભ્યતાથી જવાબ આપી શકો છો: સ્પષ્ટ સંદેશો બતાવો ('Could not load events, check your connection'), ફરી પ્રયત્ન કરવાનું આપો, loading indicator છુપાવો, અથવા cached data પર પાછા વળો. તમે VolleyError ને તપાસીને status code પ્રમાણે જવાબ પણ ઘડી શકો છો (401 એટલે session ની મુદત પૂરી, એટલે ફરી login કરાવો; 404 એટલે resource જતું રહ્યું; network error એટલે જોડાણનો પ્રશ્ન).

મજબૂત apps નિષ્ફળતાને સામાન્ય અને અપેક્ષિત પરિણામ ગણીને સંભાળે છે, અવગણવા જેવો ખૂણાનો કિસ્સો ગણતી નથી. આ એ જ શિસ્ત છે જે તમે Firebase auth errors અને Task failures સાથે જોઈ હતી: બંને પરિણામ હંમેશા સંભાળો. વપરાશકર્તાઓ app ને એના પરથી માપે છે કે ખોટું થાય ત્યારે એ કેવું વર્તે છે, એટલે errors સારી રીતે સંભાળવા એ મરજિયાત ઓપ નથી, એ પાયાની ગુણવત્તા છે. નિષ્ફળતાની તૈયારી રાખો; એ આવવાની જ છે.

Summary

Key takeaways

GET કોઈ endpoint પરથી data લાવે છે; POST એને data મોકલે છે, એટલે કે રોજિંદા બે API calls.
GET (Request.Method.GET, null body) એવું JSON પાછું આપે છે જેને તમે success listener માં parse કરીને બતાવો છો.
POST (Request.Method.POST સાથે JSONObject body) એવો data મોકલે છે જેને server પ્રક્રિયામાં લે છે અને જવાબ આપે છે.
બંને success listener (data વાપરવો કે parse કરવો) અને error listener (નિષ્ફળતા સંભાળવી) લે છે.
બંને પરિણામ હંમેશા સંભાળો: error વખતે સ્પષ્ટ સંદેશો બતાવો અને જરૂર પડ્યે status code માટે VolleyError તપાસો.
આ પાઠ REST (methods), JSON parsing અને Volley ને જોડીને Android માંથી ખરેખરના API calls બનાવે છે.
યાદ રાખવાની કડી: લાવવા માટે GET, મોકલવા માટે POST; અને દર વખતે success તથા error, બંને સંભાળો.