Åtgärda Expo EAS Firebase Developer Error Code 10 med Google-inloggning

Konfigurera Google-inloggning för din Expo EAS Android-app: Vanliga fallgropar och korrigeringar

Att bygga en app kan vara spännande, särskilt när du implementerar funktioner som ansluter sömlöst till populära tjänster som Google Inloggning. Men alla utvecklare som har integrerat Firebase-autentisering med Google Cloud i ett Expo EAS-projekt kan ha stött på det fruktade "Utvecklarfelkod 10.” 😬

Detta fel uppstår ofta när du ställer in Reager Native Google-inloggning bibliotek i produktion, vilket orsakar oväntade störningar som inte dyker upp i lokala utvecklingsbyggnader. Det är en vanlig vägspärr som kan få utvecklare att klia sig i huvudet, särskilt när alla konfigurationer verkar vara korrekt inställda.

En knepig aspekt av detta fel är den nyanserade installationsprocessen som involverar korrekta SHA1- och SHA256-fingeravtryck, OAuth 2.0 klient-ID:noch hantera inställningarna för Firebase och Google Play Console. Att sakna ens en liten detalj här kan leda till autentiseringsfel i produktionsmiljön.

I den här guiden kommer vi att fördjupa oss i varför utvecklarfelkod 10 uppstår, identifiera potentiella felkonfigurationer och gå igenom verkliga lösningar för att säkerställa att din Google-inloggning fungerar smidigt. Låt oss se till att dina användare kan logga in utan ansträngning och hålla dessa produktionsfel borta! 🚀

Förstå och implementera Google Inloggning med Firebase i Expo

För att konfigurera Google Inloggning i ett Expo-hanterat React Native-projekt måste backend och frontend konfigureras noggrant. Från och med backend initierar vi Firebase Admin SDK för att hantera användarhantering på ett säkert sätt. Detta görs genom att ställa in OAuth2Client, vilket gör att vår server kan interagera med Googles API:er och verifiera tokens som utfärdats av Googles autentiseringstjänst. De verifyIdToken funktion, som använder OAuth2-klienten, spelar en avgörande roll genom att avkoda och validera token som tas emot från frontend. Utan denna verifiering kan appen inte på ett tillförlitligt sätt fastställa att en användares inloggningsbegäran är legitim, och eventuell inkonsekvens här kan leda till Developer Error Code 10, som ofta uppstår när tokens inte matchar förväntade konfigurationer i Firebase. Det här konfigurationssteget på backend ger robust säkerhet eftersom vi säkerställer att endast auktoriserade Google-konton kan interagera med Firebases autentisering.

På gränssnittet konfigureras Google Inloggning med hjälp av GoogleSignin.configure funktion, som länkar appen till Google Cloud via webbklient-ID:t som genereras i Firebase. Genom att länka detta ID "känner" Google och Firebase igen vår app och tillåter säkra inloggningar. Efter detta, när en användare försöker logga in, ringer appen GoogleSignin.signIn, som initierar inloggningsprocessen och hämtar ett ID-token om det lyckas. Denna ID-token fungerar som bevis på användarens Google-autentisering och vi skickar den till Firebase för att slutföra inloggningen. Behovet av att ringa hasPlayServices innan faktisk inloggning är också viktigt; det här steget kontrollerar om enheten är kompatibel genom att bekräfta att Google Play-tjänster är tillgängliga, vilket minskar problem relaterade till enhetskompatibilitet och gör inloggningsupplevelsen smidigare. Det här kommandot kan verka enkelt, men dess betydelse ligger i att säkerställa att appen inte stöter på oväntade fel på inkompatibla enheter.

Serversidan getUserByEmail funktionen spelar en roll för att kontrollera om Google-kontot redan finns i Firebases användarregister. Om användaren inte finns ännu kan Firebase skapa en ny post, vilket underlättar sömlös användarintroduktion. På Expo-sidan, i app.json-filen, lägger vi till specifika SHA1-fingeravtryck och Googles inloggningsplugin för att ansluta Expo-miljön till Firebase och Google Cloud exakt. Det här steget överbryggar front-end-konfigurationen med Firebases inställningar, vilket säkerställer att inga missmatchningar mellan de referenser som används lokalt och de som krävs i produktionen. Varje inställning i den här konfigurationen tjänar till att minska sannolikheten för att utvecklarfelkod 10 dyker upp i produktionsbygget.

Slutligen, att skriva enhetstester med Jest validerar varje funktions beteende. Att testa Googles inloggning genom att håna GoogleSignin och andra viktiga metoder hjälper till att identifiera problem i utvecklingsfasen, vilket gör produktionsfel mindre sannolika. Till exempel möjliggör den mocked signIn-metoden testning utan att förlita sig på en faktisk Google-kontoinloggning, vilket verifierar att appen fungerar korrekt när en giltig token returneras eller när ett fel uppstår. Det här kompletta arbetsflödet, från konfiguration till testning, säkerställer att Google Inloggning fungerar effektivt och minskar problem som ofta uppstår från ofullständiga eller felaktiga inställningar för backend och frontend. Med detta omfattande tillvägagångssätt kan du göra Google Inloggning till en smidig, pålitlig upplevelse 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 felsökning och bästa praxis för integrering av Google-inloggning i Expo EAS

Vid integration Google-inloggning inom Expo EAS är en viktig aspekt som kan förbises att hantera nyckellager och SHA-certifikat effektivt i olika miljöer. Google-autentisering beror på matchande SHA-fingeravtryck, så nycklarna som används i lokala tester, utvecklingsbyggen och produktionsversioner på Google Play Console måste vara konsekventa. Ett vanligt problem är att bara lägga till SHA1-nyckeln till Firebase, vilket inte räcker för produktionsmiljöer. Både SHA1 och SHA256 fingeravtryck bör konfigureras korrekt i Firebase och Google Play Console för att säkerställa sömlös användarautentisering. Den här kritiska konfigurationen gör att Firebase kan lita på din app oavsett miljön den körs i, vilket hjälper till att undvika Developer Error Code 10 och förbättrar den övergripande stabiliteten för din Google-inloggningsintegrering.

En annan ofta missad konfiguration innebär att du väljer rätt OAuth 2.0 Client ID-typ på Google Cloud Console. När du använder Firebase med Expo ska klient-ID:t som genereras i Google Console ställas in på Web Client, och samma webClientId ska tillhandahållas på frontend via GoogleSignin.configure. Även om detta kan verka ovanligt (som du kan förvänta dig att använda ett Android-klient-ID), kräver Expo den här konfigurationen för att hantera Google-inloggning på både iOS och Android effektivt. Genom att aktivera felhantering och felsökning på både frontend och backend med tydliga felmeddelanden och loggning hjälper det dessutom att upptäcka om problem härrör från felaktiga referenser eller saknade konfigurationer.

Slutligen, om ett fel kvarstår i produktionsbygget, överväg att använda Expos utvecklingsbyggen med produktionskonfigurationer. Detta hjälper till att emulera en produktionsliknande miljö lokalt och kan lyfta fram problem som bara kan uppstå i produktionen, till exempel felkonfigurationer på Google Play Console. Testning på detta sätt säkerställer att alla konfigurationer, inklusive de inom app.json och google-services.json, identifieras korrekt i den slutliga produktionsversionen, vilket minskar antalet fel och förbättrar användarupplevelsen.