Theory
એ જ વિચાર, જુદો provider
Google Sign-In કરી લીધા પછી Facebook Sign-In પરિચિત લાગશે, કારણ કે એ એ જ federated રીત અનુસરે છે. User પોતાના Facebook account થી log in કરે છે, Facebook એની ખાતરી આપે છે, અને Firebase એને sign in કરાવે છે.
ખરો ફરક ફક્ત provider નો છે: token મેળવવા તમે Facebook Login SDK વાપરો છો, અને એને વીંટવા FacebookAuthProvider વાપરો છો. બાકીનું બધું, એટલે કે signInWithCredential અને એમાંથી મળતો FirebaseUser, Google જેવું જ છે. આ ટૂંકો પાઠ એ સહિયારો આકાર ઉજાગર કરે છે, જે કોઈ પણ federated provider ઉમેરવા માટેની ચાવીરૂપ સમજ છે.
Theory
Facebook વાળો પ્રવાહ
પગથિયાં Google ના પડઘા જેવાં જ છે:
1. App Facebook Login SDK (LoginManager) વાપરીને user ને Facebook દ્વારા log in કરાવે છે.
2. સફળતા મળે ત્યારે તમને Facebook નું access token મળે છે.
3. એને FacebookAuthProvider.getCredential(token.token) વડે Firebase credential તરીકે વીંટો.
4. auth.signInWithCredential(credential) બોલાવો, અને Firebase user ને sign in કરાવે છે.
પહેલાંની જેમ જ, પહેલાં Facebook app ગોઠવો (જેથી app id મળે) અને Firebase console માં Facebook ને provider તરીકે ચાલુ કરો. Sign in થયા પછી user સામાન્ય FirebaseUser જ છે, ભલે એને ત્યાં સુધી કોઈ પણ provider લાવ્યો હોય.
Practical
Facebook token થી Firebase sign-in
// Facebook Login SDK 'token' નામનું AccessToken પાછું આપે તે પછી:
val credential = FacebookAuthProvider.getCredential(token.token)
Firebase.auth.signInWithCredential(credential)
.addOnCompleteListener { task ->
if (task.isSuccessful) {
val user = Firebase.auth.currentUser // Facebook દ્વારા sign in થયેલો
} else {
// task.exception સંભાળો
}
}
// Google સાથે સરખાવો: ફક્ત GoogleAuthProvider -> FacebookAuthProvider બદલાયું.Formula
એક જ રીત, અનેક providers
જુઓ કે Google થી Facebook સુધીમાં કેટલું ઓછું બદલાયું: token આપતું SDK જુદું છે, અને provider વાળો class જુદો છે (GoogleAuthProvider ને બદલે FacebookAuthProvider), પણ અદલાબદલી, એટલે કે getCredential અને પછી signInWithCredential, બરાબર એની એ જ છે.
Firebase ની રચનાનો આ જ ફાયદો છે: દરેક federated login છેવટે 'provider પાસેથી token લો, એને Firebase credential માં ફેરવો, sign in કરો' એટલું જ બની જાય છે. એક વાર શીખી લો, પછી Facebook, Twitter/X, GitHub કે બીજા ઉમેરવા એટલે મોટે ભાગે ગોઠવણ કરવી અને provider બદલવો. આ સુસંગત રીત જ ઘણા login વિકલ્પોને ટેકો આપવાનું વ્યવહારુ બનાવે છે.
Quiz
Firebase સાથેનું Facebook Sign-In, Google Sign-In થી કઈ રીતે જુદું પડે છે?
- એ સાવ જુદી પદ્ધતિ વાપરે છે જેમાં tokens હોતાં જ નથી
- એ token માંથી credential વાળી એ જ રીત અનુસરે છે; Facebook SDK અને FacebookAuthProvider વાપરો, પછી એ જ signInWithCredential
- એને Firebase project ની જરૂર જ પડતી નથી
- એ Facebook નો password app માં સંઘરે છે
Show the answer
એ token માંથી credential વાળી એ જ રીત અનુસરે છે; Facebook SDK અને FacebookAuthProvider વાપરો, પછી એ જ signInWithCredential
Facebook Sign-In Google જેવી જ federated રીત વાપરે છે: Facebook Login SDK user ને ચકાસે છે અને access token પાછું આપે છે, તમે એને FacebookAuthProvider.getCredential(...) વડે વીંટો છો, અને એ જ auth.signInWithCredential(...) બોલાવો છો. ફક્ત provider નું SDK અને provider વાળો class જ બદલાય છે. વિકલ્પ A ખોટો છે: એમાં token તો બરાબર વપરાય જ છે (Facebook નું access token), જેમ Google માં ID token વપરાય છે. વિકલ્પ C ખોટો છે: એને હજી પણ એવો Firebase project જોઈએ જેમાં Facebook provider તરીકે ચાલુ કરેલો હોય. વિકલ્પ D ખોટો પણ છે અને જોખમી પણ: app ને user નો Facebook password કદી મળતો નથી કે એ સંઘરાતો નથી; Facebook જ એને ચકાસે છે અને token પાછું આપે છે. એ જ રીત, જુદો provider.
Think first
બધા federated providers એક જ રીત વહેંચે એ કીમતી કેમ છે?
Google અને Facebook (અને બીજા પણ) છેવટે એ જ પગથિયાં પર આવીને અટકે છે. Developer તરીકે તમારે માટે આ સુસંગતતા કેમ મહત્ત્વની છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે એક જ સુસંગત રીત હોય એટલે તમે એક વાર શીખો અને બધે વાપરો, જેથી code સાદો રહે, મહેનત ઓછી થાય અને app ને વધારવી સહેલી બને, અને એ મોટો વ્યવહારુ ફાયદો છે. જો દરેક sign-in provider ને Firebase સાથે જોડવાની રીત સાવ જુદી હોત, તો દરેક ઉમેરવો એ નવેસરથી શોધ અને debug કરવાનો પ્રોજેક્ટ બની જાત, અને codebase જુદા જુદા, સંભાળવા અઘરા પ્રવાહોથી ભરાઈ જાત. એને બદલે Firebase જાણી જોઈને બધાને એક જ આકારમાં વાળે છે: provider user ને ચકાસે છે અને token આપે છે, તમે એ token ને એ provider ના AuthProvider class વડે Firebase credential માં ફેરવો છો, અને એક જ method, એટલે કે signInWithCredential, બોલાવો છો. એટલે એક વાર Google કરી લીધું હોય, પછી Facebook કરવું એટલે મોટે ભાગે ગોઠવણ (Facebook app ઊભી કરવી, provider ચાલુ કરવો) અને GoogleAuthProvider ને બદલે FacebookAuthProvider મૂકવો; sign-in નું logic અને એ પછીનું બધું (FirebaseUser, app ની screens, database ના નિયમો) એમનું એમ રહે છે. આથી તમે users ને ઓછા ખર્ચે અનેક login વિકલ્પો આપી શકો છો, અને પછીથી વધુ ઉમેરવા હોય તો ફરી રચના બદલવી પડતી નથી. એનો અર્થ એ પણ કે તમારું જ્ઞાન એક જગ્યાએથી બીજી જગ્યાએ કામ લાગે છે: એક federated login સમજ્યા એટલે બધા સમજ્યા. આ એ જ રચનાનો ગુણ છે જે તમને વારંવાર મળે છે, એટલે કે અદલાબદલ કરી શકાય એવા અમલો (providers) પાછળ સ્થિર interface (Firebase નું sign-in), અને આધુનિક apps માં 'sign in with X' ઉમેરવું આટલું સહેલું કેમ છે એનું કારણ પણ આ જ છે. રીત શીખી લો, અને દરેક provider માટે એ જ વાપરો.
Summary
Key takeaways
- Facebook Sign-In એ federated authentication છે જે Google જેવી જ રીત અનુસરે છે.
- Facebook Login SDK user ને log in કરાવે છે અને Facebook નું access token પાછું આપે છે.
- એ token ને FacebookAuthProvider.getCredential(token.token) વડે Firebase credential તરીકે વીંટો.
- auth.signInWithCredential(credential) બોલાવો; સફળતા મળે એટલે user સામાન્ય FirebaseUser બની જાય છે.
- પહેલાં Facebook app ગોઠવો અને Firebase console માં Facebook ને provider તરીકે ચાલુ કરો.
- Google થી ફક્ત provider નું SDK અને provider વાળો class જ જુદાં પડે છે; getCredential અને signInWithCredential એનાં એ જ રહે છે.
- યાદ રાખવાની કડી: token માંથી credential વાળી એ જ રીત, ફક્ત GoogleAuthProvider ને બદલે FacebookAuthProvider.