Repareren van Firebase Developer Error Code 10 van Expo EAS met Google Sign-In

Google Sign-In instellen voor uw Expo EAS Android-app: veelvoorkomende valkuilen en oplossingen

Het bouwen van een app kan opwindend zijn, vooral als je functies implementeert die naadloos aansluiten op populaire services zoals Google Sign-In. Elke ontwikkelaar die Firebase-authenticatie met Google Cloud heeft geïntegreerd in een Expo EAS-project is echter mogelijk de gevreesde “Ontwikkelaarsfoutcode 10.” 😬

Deze fout treedt vaak op bij het instellen van het Reageer op native Google-aanmelding bibliotheek in productie, wat onverwachte verstoringen veroorzaakt die niet zichtbaar zijn in lokale ontwikkelingsprojecten. Het is een veel voorkomende wegversperring waar ontwikkelaars zich achter kunnen krabben, vooral als alle configuraties correct lijken te zijn ingesteld.

Een lastig aspect van deze fout is het genuanceerde installatieproces waarbij de juiste SHA1- en SHA256-vingerafdrukken betrokken zijn. OAuth 2.0-client-ID'sen het beheren van Firebase- en Google Play Console-instellingen. Als hier zelfs maar een klein detail ontbreekt, kan dit leiden tot authenticatiefouten in de productieomgeving.

In deze handleiding gaan we dieper in op de reden waarom ontwikkelaarsfoutcode 10 optreedt, identificeren we de mogelijke verkeerde configuraties en nemen we praktische oplossingen door om ervoor te zorgen dat uw aanmelding bij Google soepel werkt. Zorg ervoor dat uw gebruikers moeiteloos kunnen inloggen en voorkom productiefouten! 🚀

Google Sign-In begrijpen en implementeren met Firebase in Expo

Om Google Sign-In in te stellen in een door Expo beheerd React Native-project, moeten de backend en frontend zorgvuldig worden geconfigureerd. Beginnend met de backend initialiseren we de Firebase Admin SDK om het gebruikersbeheer veilig af te handelen. Dit wordt gedaan door OAuth2Client in te stellen, waardoor onze server kan communiceren met Google API's en tokens kan verifiëren die zijn uitgegeven door de authenticatieservice van Google. De verificatieIdToken functie, die gebruikmaakt van de OAuth2-client, speelt een cruciale rol bij het decoderen en valideren van het token dat wordt ontvangen van de frontend. Zonder deze verificatie kan de app niet op betrouwbare wijze vaststellen dat het inlogverzoek van een gebruiker legitiem is. Elke inconsistentie hier kan leiden tot ontwikkelaarsfoutcode 10, die vaak voorkomt wanneer tokens niet overeenkomen met de verwachte configuraties in Firebase. Deze configuratiestap in de backend biedt robuuste beveiliging, omdat we ervoor zorgen dat alleen geautoriseerde Google-accounts kunnen communiceren met de authenticatie van Firebase.

Op de frontend wordt Google Sign-In geconfigureerd met behulp van de GoogleSignin.configure functie, die de app aan Google Cloud koppelt via de webclient-ID die in Firebase is gegenereerd. Door deze ID te koppelen, 'herkennen' Google en Firebase onze app en staan ​​ze veilige aanmeldingen toe. Hierna, wanneer een gebruiker probeert in te loggen, belt de app GoogleSignin.signIn, dat het inlogproces initieert en indien succesvol een ID-token ophaalt. Dit ID-token fungeert als bewijs van de Google-authenticatie van de gebruiker en we geven het door aan Firebase om de aanmelding af te ronden. De noodzaak om te bellen heeftPlayServices voordat u zich daadwerkelijk aanmeldt, is ook belangrijk; Bij deze stap wordt gecontroleerd of het apparaat compatibel is door te bevestigen dat Google Play-services beschikbaar zijn, waardoor problemen met betrekking tot apparaatcompatibiliteit worden verminderd en de inlogervaring soepeler verloopt. Deze opdracht lijkt misschien eenvoudig, maar de betekenis ervan ligt in het garanderen dat de app geen onverwachte fouten tegenkomt op incompatibele apparaten.

De serverkant getUserByEmail functie speelt een rol bij het controleren of het Google-account al bestaat in de gebruikersrecords van Firebase. Als de gebruiker nog niet bestaat, kan Firebase een nieuwe record maken, waardoor een naadloze gebruikersintroductie wordt vergemakkelijkt. Aan de Expo-kant voegen we in het app.json-bestand specifieke SHA1-vingerafdrukken en de Google Sign-In-plug-in toe om de Expo-omgeving nauwkeurig te verbinden met Firebase en Google Cloud. Deze stap overbrugt de front-endconfiguratie met de instellingen van Firebase, waardoor er geen discrepantie ontstaat tussen de lokaal gebruikte inloggegevens en de inloggegevens die vereist zijn in de productie. Elke instelling in deze configuratie verkleint de kans dat Developer Error Code 10 in de productiebuild verschijnt.

Ten slotte valideert het schrijven van unit-tests met Jest het gedrag van elke functie. Door Google Sign-In te testen door GoogleSignin en andere essentiële methoden te bespotten, kunnen problemen in de ontwikkelingsfase worden geïdentificeerd, waardoor de kans op productiefouten kleiner wordt. De nagebootste signIn-methode maakt het bijvoorbeeld mogelijk om te testen zonder te vertrouwen op een daadwerkelijke aanmelding bij een Google-account, waarbij wordt geverifieerd dat de app zich correct gedraagt ​​wanneer een geldig token wordt geretourneerd of wanneer er een fout wordt aangetroffen. Deze volledige workflow, van configuratie tot testen, zorgt ervoor dat Google Sign-In effectief werkt en vermindert problemen die vaak voortkomen uit onvolledige of onjuiste backend- en frontend-instellingen. Met deze alomvattende aanpak kunt u van Google Sign-In een soepele, betrouwbare ervaring maken in uw Expo-app! 🚀

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");
  });
});

Effectieve foutopsporing en best practices voor Google Sign-In-integratie in Expo EAS

Bij het integreren Inloggen bij Google binnen Expo EAS is een essentieel aspect dat misschien over het hoofd wordt gezien het beheer van de sleutelopslagplaatsen SHA-certificaten effectief in verschillende omgevingen. Google-authenticatie is afhankelijk van het matchen van SHA-vingerafdrukken, dus de sleutels die worden gebruikt bij lokale tests, ontwikkelingsbuilds en productiebuilds op de Google Play Console moeten consistent zijn. Een veelvoorkomend probleem is het toevoegen van alleen de SHA1-sleutel aan Firebase, wat niet voldoende is voor productieomgevingen. Beide SHA1 En SHA256 vingerafdrukken moeten correct worden geconfigureerd in Firebase en Google Play Console om naadloze gebruikersauthenticatie te garanderen. Dankzij deze cruciale configuratie kan Firebase uw app vertrouwen, ongeacht de omgeving waarin deze wordt uitgevoerd, waardoor ontwikkelaarsfoutcode 10 wordt vermeden en de algehele stabiliteit van uw Google Sign-In-integratie wordt verbeterd.

Een andere vaak gemiste configuratie is het selecteren van het juiste OAuth 2.0 Client ID-type in Google Cloud Console. Wanneer u Firebase met Expo gebruikt, moet de client-ID die in de Google Console wordt gegenereerd, worden ingesteld op Web Client en moet dezelfde webClientId worden opgegeven op de frontend via GoogleSignin.configure. Hoewel dit misschien ongebruikelijk lijkt (zoals je zou verwachten als je een Android Client ID gebruikt), vereist Expo deze configuratie om Google Sign-In op zowel iOS als Android efficiënt af te handelen. Bovendien helpt het inschakelen van foutafhandeling en foutopsporing op zowel de frontend als de backend met duidelijke foutmeldingen en logboekregistratie bij het detecteren of problemen voortkomen uit niet-overeenkomende inloggegevens of ontbrekende configuraties.

Als er ten slotte een fout blijft bestaan ​​in de productiebuild, overweeg dan om de ontwikkelingsbuilds van Expo met productieconfiguraties te gebruiken. Dit helpt bij het lokaal emuleren van een productie-achtige omgeving en kan problemen aan het licht brengen die mogelijk alleen in de productie voorkomen, zoals verkeerde configuraties in de Google Play Console. Door op deze manier te testen, wordt gegarandeerd dat alle configuraties, inclusief de configuraties daarbinnen app.json En google-services.json, worden correct herkend in de uiteindelijke productierelease, waardoor fouten worden verminderd en de gebruikerservaring wordt verbeterd.