Google സൈൻ-ഇൻ ഉപയോഗിച്ച് Expo EAS-ൻ്റെ Firebase Developer Error Code 10 പരിഹരിക്കുന്നു

നിങ്ങളുടെ എക്‌സ്‌പോ EAS ആൻഡ്രോയിഡ് ആപ്പിനായി Google സൈൻ-ഇൻ സജ്ജീകരിക്കുന്നു: സാധാരണ കെണികളും പരിഹാരങ്ങളും

ഒരു ആപ്പ് നിർമ്മിക്കുന്നത് ആഹ്ലാദകരമായിരിക്കാം, പ്രത്യേകിച്ചും Google സൈൻ-ഇൻ പോലെയുള്ള ജനപ്രിയ സേവനങ്ങളുമായി പരിധികളില്ലാതെ ബന്ധിപ്പിക്കുന്ന ഫീച്ചറുകൾ നടപ്പിലാക്കുമ്പോൾ. എന്നിരുന്നാലും, എക്‌സ്‌പോ EAS പ്രോജക്‌റ്റിൽ Google ക്ലൗഡുമായി ഫയർബേസ് പ്രാമാണീകരണം സംയോജിപ്പിച്ചിട്ടുള്ള ഏതൊരു ഡവലപ്പറും ഭയാനകമായ അവസ്ഥയിൽ അകപ്പെട്ടേക്കാം “ഡെവലപ്പർ പിശക് കോഡ് 10.” 😬

സജ്ജീകരിക്കുമ്പോൾ ഈ പിശക് പലപ്പോഴും ഉണ്ടാകാറുണ്ട് നേറ്റീവ് Google സൈൻ-ഇൻ പ്രതികരിക്കുക നിർമ്മാണത്തിലെ ലൈബ്രറി, പ്രാദേശിക വികസന ബിൽഡുകളിൽ കാണിക്കാത്ത അപ്രതീക്ഷിത തടസ്സങ്ങൾ ഉണ്ടാക്കുന്നു. എല്ലാ കോൺഫിഗറേഷനുകളും ശരിയായി സജ്ജീകരിച്ചതായി തോന്നുമ്പോൾ, ഡെവലപ്പർമാർക്ക് അവരുടെ തലയിൽ മാന്തികുഴിയുണ്ടാക്കാൻ കഴിയുന്ന ഒരു സാധാരണ റോഡ് ബ്ലോക്കാണിത്.

ശരിയായ SHA1, SHA256 വിരലടയാളങ്ങൾ ഉൾപ്പെടുന്ന സൂക്ഷ്മമായ സജ്ജീകരണ പ്രക്രിയയാണ് ഈ പിശകിൻ്റെ ഒരു തന്ത്രപ്രധാനമായ വശം, OAuth 2.0 ക്ലയൻ്റ് ഐഡികൾ, ഒപ്പം Firebase, Google Play കൺസോൾ ക്രമീകരണങ്ങൾ നിയന്ത്രിക്കുന്നു. ഇവിടെ ഒരു ചെറിയ വിശദാംശം പോലും നഷ്‌ടമായാൽ ഉൽപ്പാദന പരിതസ്ഥിതിയിൽ പ്രാമാണീകരണ പിശകുകൾ ഉണ്ടാകാം.

ഈ ഗൈഡിൽ, എന്തുകൊണ്ടാണ് ഡെവലപ്പർ പിശക് കോഡ് 10 സംഭവിക്കുന്നതെന്ന് ഞങ്ങൾ പരിശോധിക്കും, സാധ്യമായ തെറ്റായ കോൺഫിഗറേഷനുകൾ തിരിച്ചറിയുകയും നിങ്ങളുടെ Google സൈൻ ഇൻ സുഗമമായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ യഥാർത്ഥ ലോക പരിഹാരങ്ങളിലൂടെ നടക്കുകയും ചെയ്യും. നിങ്ങളുടെ ഉപയോക്താക്കൾക്ക് അനായാസമായി ലോഗിൻ ചെയ്യാനും ആ നിർമ്മാണ പിശകുകൾ ഒഴിവാക്കാനും കഴിയുമെന്ന് ഉറപ്പാക്കാം! 🚀

എക്‌സ്‌പോയിൽ ഫയർബേസ് ഉപയോഗിച്ച് Google സൈൻ-ഇൻ മനസ്സിലാക്കുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു

എക്‌സ്‌പോ-നിയന്ത്രിത റിയാക്റ്റ് നേറ്റീവ് പ്രോജക്‌റ്റിൽ Google സൈൻ-ഇൻ സജ്ജീകരിക്കുന്നതിന്, ബാക്കെൻഡും ഫ്രണ്ട്എൻഡും ശ്രദ്ധാപൂർവ്വം കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്. ബാക്കെൻഡിൽ തുടങ്ങി, ഉപയോക്തൃ മാനേജ്‌മെൻ്റ് സുരക്ഷിതമായി കൈകാര്യം ചെയ്യുന്നതിനായി ഞങ്ങൾ ഫയർബേസ് അഡ്മിൻ SDK ആരംഭിക്കുന്നു. OAuth2Client സജ്ജീകരിക്കുന്നതിലൂടെയാണ് ഇത് ചെയ്യുന്നത്, ഇത് Google API-കളുമായി സംവദിക്കാനും Google-ൻ്റെ പ്രാമാണീകരണ സേവനം നൽകുന്ന ടോക്കണുകൾ പരിശോധിക്കാനും ഞങ്ങളുടെ സെർവറിനെ അനുവദിക്കുന്നു. ദി verifyIdToken OAuth2 ക്ലയൻ്റ് ഉപയോഗിക്കുന്ന ഫംഗ്‌ഷൻ, മുൻവശത്ത് നിന്ന് ലഭിച്ച ടോക്കൺ ഡീകോഡ് ചെയ്യുകയും സാധൂകരിക്കുകയും ചെയ്യുന്നതിലൂടെ ഒരു നിർണായക പങ്ക് വഹിക്കുന്നു. ഈ സ്ഥിരീകരണം കൂടാതെ, ഒരു ഉപയോക്താവിൻ്റെ സൈൻ-ഇൻ അഭ്യർത്ഥന നിയമാനുസൃതമാണെന്ന് ആപ്പിന് വിശ്വസനീയമായി നിർണ്ണയിക്കാൻ കഴിയില്ല, കൂടാതെ ഇവിടെയുള്ള ഏത് പൊരുത്തക്കേടും ഡെവലപ്പർ പിശക് കോഡ് 10-ലേക്ക് നയിച്ചേക്കാം, ഇത് Firebase-ൽ പ്രതീക്ഷിക്കുന്ന കോൺഫിഗറേഷനുകളുമായി ടോക്കണുകൾ പൊരുത്തപ്പെടാത്തപ്പോൾ പലപ്പോഴും സംഭവിക്കാറുണ്ട്. അംഗീകൃത Google അക്കൗണ്ടുകൾക്ക് മാത്രമേ Firebase-ൻ്റെ പ്രാമാണീകരണവുമായി സംവദിക്കാനാകൂ എന്ന് ഞങ്ങൾ ഉറപ്പാക്കുന്നതിനാൽ ബാക്കെൻഡിലെ ഈ കോൺഫിഗറേഷൻ ഘട്ടം ശക്തമായ സുരക്ഷ നൽകുന്നു.

മുൻവശത്ത്, Google സൈൻ-ഇൻ കോൺഫിഗർ ചെയ്‌തിരിക്കുന്നത് ഉപയോഗിച്ചാണ് GoogleSignin.configure ഫംഗ്‌ഷൻ, ഫയർബേസിൽ സൃഷ്‌ടിച്ച വെബ് ക്ലയൻ്റ് ഐഡി വഴി ആപ്പിനെ Google ക്ലൗഡിലേക്ക് ലിങ്ക് ചെയ്യുന്നു. ഈ ഐഡി ലിങ്ക് ചെയ്യുന്നതിലൂടെ, Google ഉം Firebase ഉം ഞങ്ങളുടെ ആപ്പ് "തിരിച്ചറിയുകയും" സുരക്ഷിതമായ സൈൻ ഇൻ അനുവദിക്കുകയും ചെയ്യുന്നു. ഇതിനുശേഷം, ഒരു ഉപയോക്താവ് സൈൻ ഇൻ ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ, ആപ്പ് വിളിക്കുന്നു GoogleSignin.signIn, ഇത് ലോഗിൻ പ്രക്രിയ ആരംഭിക്കുകയും വിജയകരമാണെങ്കിൽ ഒരു ഐഡി ടോക്കൺ വീണ്ടെടുക്കുകയും ചെയ്യുന്നു. ഈ ഐഡി ടോക്കൺ ഉപയോക്താവിൻ്റെ Google പ്രാമാണീകരണത്തിൻ്റെ തെളിവായി പ്രവർത്തിക്കുന്നു, ലോഗിൻ അന്തിമമാക്കുന്നതിന് ഞങ്ങൾ അത് ഫയർബേസിലേക്ക് കൈമാറും. വിളിക്കേണ്ടതിൻ്റെ ആവശ്യകത PlayServices ഉണ്ട് യഥാർത്ഥ സൈൻ-ഇൻ ചെയ്യുന്നതിനു മുമ്പ് വളരെ പ്രധാനമാണ്; Google Play സേവനങ്ങൾ ലഭ്യമാണെന്ന് സ്ഥിരീകരിക്കുന്നതിലൂടെയും ഉപകരണ അനുയോജ്യതയുമായി ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾ കുറയ്ക്കുന്നതിലൂടെയും ലോഗിൻ അനുഭവം സുഗമമാക്കുന്നതിലൂടെയും ഉപകരണം അനുയോജ്യമാണോയെന്ന് ഈ ഘട്ടം പരിശോധിക്കുന്നു. ഈ കമാൻഡ് ലളിതമായി തോന്നിയേക്കാം, എന്നാൽ അനുയോജ്യമല്ലാത്ത ഉപകരണങ്ങളിൽ ആപ്പ് അപ്രതീക്ഷിത പരാജയങ്ങൾ നേരിടുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നതിലാണ് ഇതിൻ്റെ പ്രാധാന്യം.

സെർവർ സൈഡ് getUserByEmail ഫയർബേസിൻ്റെ ഉപയോക്തൃ രേഖകളിൽ ഗൂഗിൾ അക്കൗണ്ട് നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കുന്നതിൽ ഫംഗ്ഷൻ ഒരു പങ്ക് വഹിക്കുന്നു. ഉപയോക്താവ് ഇതുവരെ നിലവിലില്ലെങ്കിൽ, തടസ്സങ്ങളില്ലാത്ത ഉപയോക്തൃ ഓൺബോർഡിംഗ് സുഗമമാക്കിക്കൊണ്ട് Firebase-ന് ഒരു പുതിയ റെക്കോർഡ് സൃഷ്ടിക്കാൻ കഴിയും. Expo വശത്ത്, app.json ഫയലിൽ, Expo പരിതസ്ഥിതിയെ Firebase, Google Cloud എന്നിവയുമായി കൃത്യമായി ബന്ധിപ്പിക്കുന്നതിന് ഞങ്ങൾ നിർദ്ദിഷ്‌ട SHA1 വിരലടയാളങ്ങളും Google സൈൻ-ഇൻ പ്ലഗിനും ചേർക്കുന്നു. ഈ ഘട്ടം ഫയർബേസിൻ്റെ ക്രമീകരണങ്ങളുമായി ഫ്രണ്ട്-എൻഡ് കോൺഫിഗറേഷനെ ബന്ധിപ്പിക്കുന്നു, പ്രാദേശികമായി ഉപയോഗിക്കുന്ന ക്രെഡൻഷ്യലുകളും ഉൽപ്പാദനത്തിൽ ആവശ്യമുള്ളവയും തമ്മിൽ പൊരുത്തക്കേടുകൾ ഇല്ലെന്ന് ഉറപ്പാക്കുന്നു. ഈ കോൺഫിഗറേഷനിലെ ഓരോ ക്രമീകരണവും പ്രൊഡക്ഷൻ ബിൽഡിൽ ഡെവലപ്പർ എറർ കോഡ് 10 പ്രത്യക്ഷപ്പെടാനുള്ള സാധ്യത കുറയ്ക്കാൻ സഹായിക്കുന്നു.

അവസാനമായി, Jest ഉപയോഗിച്ച് യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുന്നത് ഓരോ ഫംഗ്ഷൻ്റെയും സ്വഭാവത്തെ സാധൂകരിക്കുന്നു. GoogleSignin-നെയും മറ്റ് അവശ്യ രീതികളെയും പരിഹസിച്ചുകൊണ്ട് Google സൈൻ-ഇൻ പരീക്ഷിക്കുന്നത് വികസന ഘട്ടത്തിലെ പ്രശ്‌നങ്ങൾ തിരിച്ചറിയാൻ സഹായിക്കുന്നു, ഇത് ഉൽപ്പാദന പിശകുകളുടെ സാധ്യത കുറയ്ക്കുന്നു. ഉദാഹരണത്തിന്, സാധുവായ ഒരു ടോക്കൺ തിരികെ നൽകുമ്പോഴോ ഒരു പിശക് നേരിടുമ്പോഴോ ആപ്പ് ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് പരിശോധിച്ച്, യഥാർത്ഥ Google അക്കൗണ്ട് ലോഗിൻ ആശ്രയിക്കാതെ തന്നെ പരിഹസിച്ച സൈൻ ഇൻ രീതി പരിശോധന പ്രാപ്തമാക്കുന്നു. കോൺഫിഗറേഷൻ മുതൽ ടെസ്റ്റിംഗ് വരെയുള്ള ഈ പൂർണ്ണമായ വർക്ക്ഫ്ലോ, Google സൈൻ-ഇൻ ഫലപ്രദമായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുകയും അപൂർണ്ണമോ തെറ്റായതോ ആയ ബാക്കെൻഡ്, ഫ്രണ്ട്എൻഡ് സജ്ജീകരണങ്ങളിൽ നിന്ന് പലപ്പോഴും ഉണ്ടാകുന്ന പ്രശ്നങ്ങൾ കുറയ്ക്കുകയും ചെയ്യുന്നു. ഈ സമഗ്രമായ സമീപനത്തിലൂടെ, നിങ്ങളുടെ എക്‌സ്‌പോ ആപ്പിൽ Google സൈൻ-ഇൻ സുഗമവും വിശ്വസനീയവുമായ അനുഭവമാക്കി മാറ്റാം! 🚀

const admin = require('firebase-admin');
const { OAuth2Client } = require('google-auth-library');

// Initialize Firebase Admin SDK
admin.initializeApp({
  credential: admin.credential.applicationDefault(),
  databaseURL: 'https://your-firebase-project.firebaseio.com'
});

// Google OAuth2 Client configuration
const client = new OAuth2Client("YOUR_CLIENT_ID.apps.googleusercontent.com");

// Validate Google token from client-side login
async function verifyGoogleToken(token) {
  try {
    const ticket = await client.verifyIdToken({
      idToken: token,
      audience: "YOUR_CLIENT_ID.apps.googleusercontent.com",
    });
    const payload = ticket.getPayload();
    return payload;
  } catch (error) {
    console.error("Token verification error:", error);
    throw new Error("Invalid Google Token");
  }
}

// Main function to handle Google Sign-In
exports.googleSignIn = async (req, res) => {
  const token = req.body.token;
  if (!token) return res.status(400).send("Token not provided");
  try {
    const userInfo = await verifyGoogleToken(token);
    const userRecord = await admin.auth().getUserByEmail(userInfo.email);
    res.status(200).send(userRecord);
  } catch (error) {
    res.status(401).send("Authentication failed");
  }
};

import { GoogleSignin } from '@react-native-google-signin/google-signin';
import auth from '@react-native-firebase/auth';

// Configure Google Sign-In in Firebase and set the Web Client ID
GoogleSignin.configure({
  webClientId: 'YOUR_CLIENT_ID.apps.googleusercontent.com',
});

export async function googleLogin() {
  try {
    await GoogleSignin.hasPlayServices();
    const { idToken } = await GoogleSignin.signIn();
    const googleCredential = auth.GoogleAuthProvider.credential(idToken);
    await auth().signInWithCredential(googleCredential);
    console.log("Login successful");
  } catch (error) {
    console.error("Google Sign-In error:", error);
  }
}

// Configure Google OAuth Client ID in Expo's app.json
{
  "expo": {
    "plugins": ["@react-native-google-signin/google-signin"],
    "android": {
      "config": {
        "googleSignIn": {
          "apiKey": "YOUR_API_KEY",
          "certificateHash": "SHA1_CERTIFICATE_FROM_GOOGLE_PLAY"
        }
      }
    }
  }
}

// Note: Make sure to add SHA1 and SHA256 fingerprints in Firebase Console
// under Project Settings > General > Your apps > App Fingerprints.

import { render, fireEvent } from '@testing-library/react-native';
import { googleLogin } from './GoogleSignIn';
import { GoogleSignin } from '@react-native-google-signin/google-signin';

// Mock Google Sign-In
jest.mock('@react-native-google-signin/google-signin', () => ({
  GoogleSignin: {
    signIn: jest.fn(() => ({ idToken: 'dummy-token' })),
    hasPlayServices: jest.fn(() => true),
  }
}));

describe('Google Sign-In', () => {
  test('should sign in with Google successfully', async () => {
    await expect(googleLogin()).resolves.not.toThrow();
  });

  test('should handle sign-in failure gracefully', async () => {
    GoogleSignin.signIn.mockImplementationOnce(() => {
      throw new Error("Sign-in error");
    });
    await expect(googleLogin()).rejects.toThrow("Sign-in error");
  });
});

എക്‌സ്‌പോ EAS-ലെ ഗൂഗിൾ സൈൻ-ഇൻ ഇൻ്റഗ്രേഷനുള്ള ഫലപ്രദമായ ഡീബഗ്ഗിംഗും മികച്ച രീതികളും

സംയോജിപ്പിക്കുമ്പോൾ Google സൈൻ-ഇൻ എക്‌സ്‌പോ EAS-നുള്ളിൽ, അവഗണിക്കപ്പെട്ടേക്കാവുന്ന ഒരു പ്രധാന വശം കീസ്റ്റോറുകൾ കൈകാര്യം ചെയ്യുക എന്നതാണ് SHA സർട്ടിഫിക്കറ്റുകൾ വിവിധ പരിതസ്ഥിതികളിൽ ഫലപ്രദമായി. Google പ്രാമാണീകരണം SHA വിരലടയാളങ്ങളുമായി പൊരുത്തപ്പെടുന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു, അതിനാൽ Google Play കൺസോളിലെ പ്രാദേശിക പരിശോധന, വികസന ബിൽഡുകൾ, പ്രൊഡക്ഷൻ ബിൽഡുകൾ എന്നിവയിൽ ഉപയോഗിക്കുന്ന കീകൾ സ്ഥിരമായിരിക്കണം. ഫയർബേസിലേക്ക് SHA1 കീ മാത്രം ചേർക്കുന്നതാണ് ഒരു പൊതു പ്രശ്നം, ഇത് പ്രൊഡക്ഷൻ എൻവയോൺമെൻ്റുകൾക്ക് പര്യാപ്തമല്ല. രണ്ടും SHA1 ഒപ്പം SHA256 തടസ്സമില്ലാത്ത ഉപയോക്തൃ പ്രാമാണീകരണം ഉറപ്പാക്കാൻ ഫയർബേസിലും ഗൂഗിൾ പ്ലേ കൺസോളിലും വിരലടയാളങ്ങൾ ശരിയായി കോൺഫിഗർ ചെയ്യണം. ഡെവലപ്പർ പിശക് കോഡ് 10 ഒഴിവാക്കാനും നിങ്ങളുടെ Google സൈൻ-ഇൻ സംയോജനത്തിൻ്റെ മൊത്തത്തിലുള്ള സ്ഥിരത മെച്ചപ്പെടുത്താനും സഹായിക്കുന്ന പരിതസ്ഥിതി പരിഗണിക്കാതെ തന്നെ നിങ്ങളുടെ ആപ്പിനെ വിശ്വസിക്കാൻ ഫയർബേസിനെ ഈ നിർണായക കോൺഫിഗറേഷൻ അനുവദിക്കുന്നു.

Google ക്ലൗഡ് കൺസോളിൽ ശരിയായ OAuth 2.0 ക്ലയൻ്റ് ഐഡി തരം തിരഞ്ഞെടുക്കുന്നത് പലപ്പോഴും നഷ്‌ടമായ മറ്റൊരു കോൺഫിഗറേഷനിൽ ഉൾപ്പെടുന്നു. എക്‌സ്‌പോയ്‌ക്കൊപ്പം ഫയർബേസ് ഉപയോഗിക്കുമ്പോൾ, Google കൺസോളിൽ സൃഷ്‌ടിക്കുന്ന ക്ലയൻ്റ് ഐഡി വെബ് ക്ലയൻ്റിലേക്ക് സജ്ജീകരിക്കണം, കൂടാതെ ഇതേ webClientId മുഖേന മുൻവശത്ത് നൽകണം. GoogleSignin.configure. ഇത് അസാധാരണമായി തോന്നാമെങ്കിലും (നിങ്ങൾ ഒരു Android ക്ലയൻ്റ് ഐഡി ഉപയോഗിക്കാൻ പ്രതീക്ഷിക്കുന്നതുപോലെ), iOS-ലും Android-ലും ഉടനീളം Google സൈൻ-ഇൻ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യാൻ Expo-യ്ക്ക് ഈ കോൺഫിഗറേഷൻ ആവശ്യമാണ്. കൂടാതെ, വ്യക്തമായ പിശക് സന്ദേശങ്ങളും ലോഗിംഗും ഉപയോഗിച്ച് ഫ്രണ്ട്എൻഡിലും ബാക്കെൻഡിലും പിശക് കൈകാര്യം ചെയ്യലും ഡീബഗ്ഗിംഗും പ്രാപ്‌തമാക്കുന്നത്, പൊരുത്തപ്പെടാത്ത ക്രെഡൻഷ്യലുകളിൽ നിന്നോ നഷ്‌ടമായ കോൺഫിഗറേഷനുകളിൽ നിന്നോ പ്രശ്‌നങ്ങൾ ഉണ്ടായിട്ടുണ്ടോ എന്ന് കണ്ടെത്താൻ സഹായിക്കുന്നു.

അവസാനമായി, പ്രൊഡക്ഷൻ ബിൽഡിൽ ഒരു പിശക് നിലനിൽക്കുന്നുണ്ടെങ്കിൽ, പ്രൊഡക്ഷൻ കോൺഫിഗറേഷനുകൾക്കൊപ്പം എക്സ്പോയുടെ ഡെവലപ്മെൻ്റ് ബിൽഡുകൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. ഇത് പ്രാദേശികമായി ഒരു പ്രൊഡക്ഷൻ പോലുള്ള പരിതസ്ഥിതിയെ അനുകരിക്കാൻ സഹായിക്കുന്നു കൂടാതെ Google Play കൺസോളിലെ തെറ്റായ കോൺഫിഗറേഷനുകൾ പോലെയുള്ള പ്രൊഡക്ഷനിൽ മാത്രം ദൃശ്യമായേക്കാവുന്ന പ്രശ്നങ്ങൾ ഹൈലൈറ്റ് ചെയ്യാം. ഈ രീതിയിൽ പരിശോധിക്കുന്നത് ഉള്ളിലുള്ളവ ഉൾപ്പെടെ എല്ലാ കോൺഫിഗറേഷനുകളും ഉറപ്പാക്കുന്നു app.json ഒപ്പം google-services.json, ഫൈനൽ പ്രൊഡക്ഷൻ റിലീസിൽ ശരിയായി തിരിച്ചറിയുകയും പിശകുകൾ കുറയ്ക്കുകയും ഉപയോക്തൃ അനുഭവം വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു.