Theory
જાતે કરવું
FirebaseUI તમને મફતમાં login આપી દે છે, પણ એની પોતાની screens સાથે. ક્યારેક તમારે તમારી પોતાની login screen જોઈએ છે, જે app ના design સાથે બરાબર મળતી આવે, અને flow પર પણ તમારો પોતાનો કાબૂ જોઈએ છે. એ માટે તમે Firebase Authentication SDK સીધું બોલાવો છો.
તમે login અને registration ના layouts જાતે બનાવો છો, અને પછી વપરાશકર્તા buttons પર tap કરે ત્યારે FirebaseAuth ની methods ચલાવો છો. આ પાઠ એ મુખ્ય methods અને Firebase જે callback ની રીત વાપરે છે તે બતાવે છે. FirebaseUI કરતાં એમાં code વધારે લખવો પડે છે, પણ પૂરો કાબૂ આ રીતે જ મળે છે, અને FirebaseUI તમારા વતી શું કરી આપતું હતું એ પણ આનાથી સ્પષ્ટ થાય છે.
Theory
auth ની મુખ્ય methods
તમારા પોતાના UI સાથે કામ FirebaseAuth ની ત્રણ methods કરે છે:
- createUserWithEmailAndPassword(email, password): નવો વપરાશકર્તા નોંધે છે.
- signInWithEmailAndPassword(email, password): હાલના વપરાશકર્તાને login કરાવે છે.
- signOut(): હાલના વપરાશકર્તાને sign out કરે છે.
આ બધી network પરથી Firebase સાથે વાત કરતી હોવાથી asynchronous છે: દરેક એવું Task પાછું આપે છે જે પછીથી પૂરું થાય છે, સફળતા સાથે કે નિષ્ફળતા સાથે. તમને તરત પરિણામ મળતું નથી, પણ એ પૂરું થાય ત્યારે પ્રતિભાવ આપવા માટે તમે listeners જોડો છો. એટલે રીત હંમેશા આ જ રહે છે: method બોલાવો, પછી Task નું પરિણામ સંભાળો.
Practical
SDK વડે registration અને login કરવું
val auth = Firebase.auth
// Register a new user (from your own registration screen)
auth.createUserWithEmailAndPassword(email, password)
.addOnCompleteListener { task ->
if (task.isSuccessful) {
val user = auth.currentUser // now signed in
// navigate to the main screen
} else {
// show task.exception?.message on your UI
}
}
// Log an existing user in
auth.signInWithEmailAndPassword(email, password)
.addOnCompleteListener { task -> /* same success/failure handling */ }Formula
Async: Task સંભાળો, તરત પરિણામની આશા ન રાખો
આ methods વપરાશકર્તાને તરત પાછો આપતી નથી. એ network નું request શરૂ કરે છે અને Task પાછું આપે છે; પરિણામ પછીથી listener માં આવે છે. એટલે તમે કદી val user = auth.signIn(...) એવું લખતા નથી, પણ method બોલાવીને 'હવે પછી શું કરવું' એ addOnCompleteListener ની અંદર (કે success તથા failure listeners માં) મૂકો છો.
એની અંદર task.isSuccessful તપાસો: જો સાચું હોય, તો વપરાશકર્તા sign in થઈ ગયો છે (auth.currentUser ગોઠવાઈ ગયું છે) અને તમે આગળ વધો છો; જો ખોટું હોય, તો error બતાવવા task.exception વાંચો. Firebase ના network વાળા બધા calls આ જ asynchronous અને callback આધારિત ઢબે ચાલે છે, એટલે અહીં એની ટેવ પડી જાય તો આખા વિષયમાં એનો લાભ મળે છે.
Quiz
Firebase SDK સીધું વાપરતી વખતે, email અને password થી સાવ નવો વપરાશકર્તા કઈ method નોંધે છે?
- signInWithEmailAndPassword(email, password), કારણ કે એ એમને sign in કરાવે છે
- createUserWithEmailAndPassword(email, password), જે નવું વપરાશકર્તા ખાતું નોંધે છે
- signOut(), કારણ કે એ ખાતું ફરી ગોઠવી દે છે
- currentUser, કારણ કે એ વપરાશકર્તા બનાવે છે
Show the answer
createUserWithEmailAndPassword(email, password), જે નવું વપરાશકર્તા ખાતું નોંધે છે
createUserWithEmailAndPassword(email, password) નવું વપરાશકર્તા ખાતું નોંધે છે અને સફળ થાય ત્યારે એમને sign in પણ કરાવી દે છે. વિકલ્પ A, એટલે કે signInWithEmailAndPassword, હાલના વપરાશકર્તાને login કરાવે છે; એ નવું ખાતું બનાવતું નથી (ખાતું જ ન હોય તો એ નિષ્ફળ જાય). વિકલ્પ C, એટલે કે signOut, ચાલુ સત્ર પૂરું કરે છે; એ કશું બનાવતું નથી. વિકલ્પ D, એટલે કે currentUser, એ property છે જે sign in થયેલો વપરાશકર્તા (અથવા null) પાછો આપે છે; એ સ્થિતિ વાંચે છે, વપરાશકર્તા બનાવતું નથી. Method ને કામ સાથે મેળવો: નોંધવા માટે create, login માટે signIn, નીકળવા માટે signOut, અને કોણ sign in છે એ જોવા માટે currentUser.
Think first
Auth ના calls સીધું પરિણામ આપવાને બદલે Tasks સાથે asynchronous કેમ છે?
signInWithEmailAndPassword સીધો વપરાશકર્તા પાછો આપવાને બદલે તમે જેને સાંભળો છો એવું Task કેમ પાછું આપે છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે sign in કરવા માટે network પરથી Firebase ના servers સાથે વાત કરવી પડે છે, જેમાં સમય લાગે છે, અને રાહ જોતાં જોતાં app ને રોકી રાખવાથી UI થીજી જાય, એટલે એ call asynchronous છે અને પરિણામ callback દ્વારા આપે છે.
તમે signInWithEmailAndPassword બોલાવો ત્યારે SDK credentials Firebase ને મોકલે છે, જે એમને તપાસીને જવાબ આપે છે, અને એ આખી આવજા મિલિસેકન્ડ કે (નબળા જોડાણ પર) સેકન્ડો લઈ શકે છે. જો એ method સીધો વપરાશકર્તા પાછો આપવાનો પ્રયત્ન કરે, તો app ના main thread ને અટકીને network ની આ આવજા પૂરી થાય એની રાહ જોવી પડે, અને Android પર main thread એ જ UI thread છે, એટલે આખું app થીજી જાય, નહીં scrolling, નહીં taps, અને Android તો એને પ્રતિભાવ ન આપતું ગણીને બંધ પણ કરી શકે.
એ ટાળવા માટે Firebase તરત Task પાછું આપે છે (જે 'પછીથી આવનારું પરિણામ' રજૂ કરે છે) અને app ને ચાલતું રહેવા દે છે; network નો જવાબ આવે ત્યારે તમારું addOnCompleteListener પરિણામ સાથે ચાલે છે. એનાથી request ચાલુ હોય ત્યારે પણ UI સરળ રહે છે, અને તમે loading spinner બતાવીને પછી સફળતા કે નિષ્ફળતા ખરેખર થાય ત્યારે પ્રતિભાવ આપી શકો છો.
Mobile પર network કે ધીમા કામ સાથે સંકળાયેલી દરેક બાબત માટે આ asynchronous અને callback આધારિત ઢાંચો પ્રમાણભૂત છે, અને એનું કારણ ચોક્કસ એ જ છે કે પ્રતિભાવશીલતા મહત્ત્વની છે. એટલે Task કોઈ વધારાનો વિધિ નથી; server ની રાહ જોતી વખતે app ને જીવતું અને સરળ રાખનારી એ જ વસ્તુ છે. Network માટે UI thread ને કદી રોકો નહીં; પરિણામ તૈયાર થાય ત્યારે પાછું સોંપો.
Summary
Key takeaways
- Firebase SDK authentication એટલે પોતાનું login UI બનાવવું અને FirebaseAuth ની methods સીધી બોલાવવી.
- createUserWithEmailAndPassword નવો વપરાશકર્તા નોંધે છે; signInWithEmailAndPassword હાલના વપરાશકર્તાને login કરાવે છે; signOut સત્ર પૂરું કરે છે.
- આ બધી asynchronous છે: દરેક પછીથી પૂરું થતું Task પાછું આપે છે, તરતનું પરિણામ નહીં.
- Listener જોડો (addOnCompleteListener) અને task.isSuccessful તપાસો; નિષ્ફળતા વખતે error માટે task.exception વાંચો.
- FirebaseUI કરતાં ફાયદો: UI અને flow પર પૂરો કાબૂ; ભોગ: screens તમારે લખવી પડે અને સ્થિતિઓ પણ તમારે સંભાળવી પડે.
- આ calls async એટલા માટે છે કે એ network સુધી જાય છે, અને UI thread ને રોકવાથી app થીજી જાય.
- યાદ રાખવાની કડી: નોંધવા માટે create, login માટે signIn, અને Task ની સફળતા કે નિષ્ફળતા listener માં સંભાળો.