Ret Expo EAS's Firebase Developer Error Code 10 med Google Log-In

Opsætning af Google-login til din Expo EAS Android-app: Almindelige faldgruber og rettelser

Det kan være spændende at bygge en app, især når du implementerer funktioner, der forbinder problemfrit med populære tjenester som Google Log-In. Enhver udvikler, der har integreret Firebase-godkendelse med Google Cloud på et Expo EAS-projekt, kan dog være stødt ind i det frygtede "Udviklerfejlkode 10." 😬

Denne fejl opstår ofte ved opsætning af Reager Native Google-login bibliotek i produktion, hvilket forårsager uventede forstyrrelser, der ikke dukker op i lokale udviklingsbygninger. Det er en almindelig vejspærring, der kan få udviklere til at klø sig i hovedet, især når alle konfigurationer ser ud til at være korrekt sat op.

Et vanskeligt aspekt af denne fejl er den nuancerede opsætningsproces, der involverer de korrekte SHA1- og SHA256-fingeraftryk, OAuth 2.0 klient-id'er, og administration af Firebase- og Google Play Console-indstillinger. Manglende selv en lille detalje her kan føre til autentificeringsfejl i produktionsmiljøet.

I denne guide vil vi dykke ned i, hvorfor udviklerfejlkode 10 opstår, identificere de potentielle fejlkonfigurationer og gennemgå løsninger fra den virkelige verden for at sikre, at dit Google-login fungerer problemfrit. Lad os sørge for, at dine brugere kan logge ind uden besvær og holde disse produktionsfejl på afstand! 🚀

Forståelse og implementering af Google Log-In med Firebase i Expo

For at konfigurere Google Log-In i et Expo-administreret React Native-projekt skal backend og frontend konfigureres omhyggeligt. Startende med backend initialiserer vi Firebase Admin SDK for at håndtere brugeradministration sikkert. Dette gøres ved at opsætte OAuth2Client, som gør det muligt for vores server at interagere med Google API'er og verificere tokens udstedt af Googles godkendelsestjeneste. De verifyIdToken funktion, som bruger OAuth2-klienten, spiller en afgørende rolle ved at afkode og validere det token, der modtages fra frontend. Uden denne bekræftelse kan appen ikke pålideligt afgøre, at en brugers login-anmodning er legitim, og enhver uoverensstemmelse her kan føre til udviklerfejlkode 10, som ofte opstår, når tokens ikke matcher forventede konfigurationer i Firebase. Dette konfigurationstrin på backend giver robust sikkerhed, da vi sikrer, at kun autoriserede Google-konti kan interagere med Firebases godkendelse.

På frontend konfigureres Google Log-in ved hjælp af GoogleSignin.configure funktion, som forbinder appen med Google Cloud via det webklient-id, der er genereret i Firebase. Ved at linke dette id "genkender" Google og Firebase vores app og tillader sikkert login. Efter dette, når en bruger forsøger at logge ind, ringer appen GoogleSignin.signIn, som starter login-processen og henter et ID-token, hvis det lykkes. Dette id-token fungerer som bevis for brugerens Google-godkendelse, og vi videregiver det til Firebase for at afslutte login. Behovet for at ringe har PlayServices før faktisk login er også vigtigt; Dette trin kontrollerer, om enheden er kompatibel, ved at bekræfte, at Google Play-tjenester er tilgængelige, hvilket reducerer problemer relateret til enhedskompatibilitet og gør login-oplevelsen nemmere. Denne kommando kan virke simpel, men dens betydning ligger i at sikre, at appen ikke støder på uventede fejl på inkompatible enheder.

Server-siden getUserByEmail funktionen spiller en rolle ved at kontrollere, om Google-kontoen allerede findes i Firebases brugerregistreringer. Hvis brugeren endnu ikke eksisterer, kan Firebase oprette en ny registrering, hvilket letter problemfri brugeronboarding. På Expo-siden, i app.json-filen, tilføjer vi specifikke SHA1-fingeraftryk og Google Login-plugin for at forbinde Expo-miljøet med Firebase og Google Cloud nøjagtigt. Dette trin bygger bro mellem frontend-konfigurationen med Firebases indstillinger og sikrer, at der ikke er uoverensstemmelser mellem de legitimationsoplysninger, der bruges lokalt, og dem, der kræves i produktionen. Hver indstilling i denne konfiguration tjener til at reducere sandsynligheden for, at udviklerfejlkode 10 vises i produktionsbuilden.

Endelig validerer skrivning af enhedstests ved hjælp af Jest hver funktions adfærd. At teste Google Log-In ved at håne GoogleSignin og andre vigtige metoder hjælper med at identificere problemer i udviklingsfasen, hvilket gør produktionsfejl mindre sandsynlige. For eksempel muliggør den hånede login-metode test uden at være afhængig af et faktisk Google-kontologin, hvilket bekræfter, at appen opfører sig korrekt, når et gyldigt token returneres, eller når der opstår en fejl. Denne komplette arbejdsgang, fra konfiguration til test, sikrer, at Google Log-in fungerer effektivt og reducerer problemer, der ofte opstår som følge af ufuldstændige eller forkerte backend- og frontend-opsætninger. Med denne omfattende tilgang kan du gøre Google Log-in til en jævn, pålidelig oplevelse i din 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");
  });
});

Effektiv fejlfinding og bedste praksis for Googles login-integration i Expo EAS

Ved integration Google-login inden for Expo EAS er et væsentligt aspekt, der kan overses, at administrere nøglelagrene og SHA certifikater effektivt på tværs af forskellige miljøer. Google-godkendelse afhænger af matchende SHA-fingeraftryk, så nøglerne, der bruges i lokal test, udviklingsbuilds og produktionsbuilds på Google Play Console, skal være konsekvente. Et almindeligt problem er kun at tilføje SHA1-nøglen til Firebase, hvilket ikke er nok til produktionsmiljøer. Begge SHA1 og SHA256 fingeraftryk skal konfigureres korrekt i Firebase og Google Play Console for at sikre problemfri brugergodkendelse. Denne kritiske konfiguration gør det muligt for Firebase at stole på din app, uanset hvilket miljø den kører i, hvilket hjælper med at undgå Developer Error Code 10 og forbedrer den overordnede stabilitet af din Google-login-integration.

En anden ofte savnet konfiguration involverer at vælge den korrekte OAuth 2.0 Client ID-type på Google Cloud Console. Når du bruger Firebase med Expo, skal klient-id'et, der genereres i Google Console, sættes til Web Client, og det samme webClientId skal angives på frontend via GoogleSignin.configure. Selvom dette kan virke usædvanligt (som du måske forventer at bruge et Android Client ID), kræver Expo denne konfiguration for at håndtere Google Log-In på tværs af både iOS og Android effektivt. Aktivering af fejlhåndtering og fejlretning på både frontend og backend med klare fejlmeddelelser og logning hjælper desuden med at opdage, om problemer stammer fra mismatchede legitimationsoplysninger eller manglende konfigurationer.

Til sidst, hvis der fortsætter en fejl i produktionsbuilden, kan du overveje at bruge Expos udviklingsbuilds med produktionskonfigurationer. Dette hjælper med at efterligne et produktionslignende miljø lokalt og kan fremhæve problemer, der muligvis kun vises i produktionen, såsom fejlkonfigurationer på Google Play Console. Test på denne måde sikrer, at alle konfigurationer, inklusive dem indenfor app.json og google-services.json, genkendes korrekt i den endelige produktionsudgivelse, hvilket reducerer fejl og forbedrer brugeroplevelsen.