Configuración de inicio de sesión de Facebook

Introducción

En esta guía, aprenderás a configurar el inicio de sesión de Facebook con Capgo Social Login. Necesitarás lo siguiente:

• Una cuenta de desarrollador de Facebook
• El nombre de paquete de tu aplicación/identificador de paquete
• Acceso a una terminal para generar claves de hash (Android)

Configuración general

Si no tienes una aplicación de Facebook creada, sigue estos pasos:

1. Crear una aplicación de Facebook

   Sigue el tutorial para Crear una aplicación

2. Agregar Facebook Login a tu aplicación

   En tu panel de control de desarrolladores de Facebook, agrega el producto de inicio de sesión de Facebook a tu aplicación

3. Antes de que puedas liberar tu aplicación al público, sigue este tutorial publicarlo

Información importante

Aquí encontrarás la información clave que necesitarás para la integración:

1. CLIENT_TOKEN:

   

2. APP_ID:

   

3. APP_NAME:

   

Inicio de sesión de Facebook para empresas

Este plugin admite el inicio de sesión de Facebook para empresas para características y permisos relacionados con negocios. Las cuentas de empresas pueden solicitar permisos adicionales más allá del inicio de sesión estándar de consumidores, incluyendo la gestión de Instagram y de páginas.

Los permisos de negocio admitidos incluyen:

• instagram_basic - Acceso a Instagram Basic Display API
• instagram_manage_insights - Acceso a Instagram Insights
• pages_show_list - Lista de Páginas que la persona administra
• pages_read_engagement - Leer datos de engagement de Páginas
• pages_manage_posts - Administrar publicaciones en Páginas
• business_management - Administrar activos comerciales

Ver el Referencia de permisos de Facebook para obtener la lista completa de permisos.

Requisitos de configuración:

1. Su aplicación de Facebook debe estar configurada como una aplicación de negocio en el Console de Desarrolladores de Facebook.
2. Los permisos de negocio pueden requerir una revisión de la aplicación de Facebook antes de su uso en producción.
3. Su aplicación debe cumplir con las políticas de uso comercial de Facebook.

Acceso básico de Instagram

await SocialLogin.initialize({
  facebook: {
    appId: 'your-business-app-id',
    clientToken: 'your-client-token',
  },
});

const res = await SocialLogin.login({
  provider: 'facebook',
  options: {
    permissions: [
      'email',
      'public_profile',
      'instagram_basic',
      'pages_show_list',
      'pages_read_engagement',
    ],
  },
});

const profile = await SocialLogin.providerSpecificCall({
  call: 'facebook#getProfile',
  options: {
    fields: ['id', 'name', 'email', 'instagram_business_account'],
  },
});

Gestión de páginas

const res = await SocialLogin.login({
  provider: 'facebook',
  options: {
    permissions: [
      'email',
      'pages_show_list',
      'pages_manage_posts',
      'pages_read_engagement',
    ],
  },
});

const profile = await SocialLogin.providerSpecificCall({
  call: 'facebook#getProfile',
  options: {
    fields: ['id', 'name', 'accounts{id,name,instagram_business_account}'],
  },
});

Notas importantes:

• Puede probar permisos comerciales con usuarios de prueba y aplicaciones de desarrollo antes de la revisión de la aplicación.
• La mayoría de los permisos comerciales requieren una revisión de la aplicación de Facebook antes de su uso en producción.
• Las APIs comerciales tienen límites de velocidad diferentes. Revisar la documentación actual de la plataforma de Facebook antes del lanzamiento.
• Siga las instrucciones de Facebook para configurar el acceso a la cuenta de Instagram. Guía de Integración de Facebook para Empresas al configurar la aplicación.

Configuración de Android

1. Agregar permiso de Internet a tu AndroidManifest.xml

   Verifica que esta línea esté presente:

   <uses-permission android:name="android.permission.INTERNET"/>

2. Genera tu clave de hash de Android

   Este es un paso crucial de seguridad requerido por Facebook. Abre tu terminal y ejecuta:

   keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore | openssl sha1 -binary | openssl base64 -A

   Cuando se te pregunte por una contraseña, utiliza: android

   Nota

   Para versiones de lanzamiento, necesitarás usar tu keystore de lanzamiento:

   keytool -exportcert -alias your-key-name -keystore your-keystore-path | openssl sha1 -binary | openssl base64 -A

3. Agregar la clave hash a tu aplicación de Facebook

   1. Ir a la consola de tu aplicación en Facebook Developers
   2. Navegar a Configuración > Básico
   3. Desplazarse hacia abajo hasta la sección "Android"
   4. Hacer clic en "Agregar plataforma" si Android no está agregado aún y rellenar los detalles
   5. Agregar la clave hash que generaste
   6. Para producción, agregar ambas claves hash de depuración y de lanzamiento

4. Actualice su AndroidManifest.xml para incluir:

   <application>
       ...
       <activity android:name="com.facebook.FacebookActivity"
           android:configChanges="keyboard|keyboardHidden|screenLayout|screenSize|orientation"
           android:label="@string/app_name" />
   
       <activity
           android:name="com.facebook.CustomTabActivity"
           android:exported="true">
           <intent-filter>
               <action android:name="android.intent.action.VIEW" />
               <category android:name="android.intent.category.DEFAULT" />
               <category android:name="android.intent.category.BROWSABLE" />
               <data android:scheme="FB[APP_ID]" />
           </intent-filter>
       </activity>
   </application>

   Precaución

   Asegúrese de reemplazar [APP_ID] con su ID de aplicación de Facebook real en el android:scheme atributo

Configuración de iOS

1. Agregue la plataforma iOS en el Console de Desarrolladores de Facebook

   1. Vaya a la consola de su aplicación en Desarrolladores de Facebook
   2. Navegue a Configuración > Básico
   3. Desplácese hacia abajo hasta el final de la página y haga clic en “Agregar plataforma”
   4. Seleccione iOS y rellene los detalles requeridos

2. Abra su proyecto de Xcode y navegue a Info.plist

3. Agregue las siguientes entradas a su Info.plist:

   <key>FacebookAppID</key>
   <string>[APP-ID]</string>
   <key>FacebookClientToken</key>
   <string>[CLIENT-TOKEN]</string>
   <key>FacebookDisplayName</key>
   <string>[APP-NAME]</string>
   <key>LSApplicationQueriesSchemes</key>
   <array>
       <string>fbapi</string>
       <string>fb-messenger-share-api</string>
   </array>
   <key>CFBundleURLTypes</key>
   <array>
       <dict>
           <key>CFBundleURLSchemes</key>
           <array>
               <string>fb[APP-ID]</string>
           </array>
       </dict>
   </array>

   Precaución

   Sustituya los siguientes valores:

   • [APP-ID] por su ID de aplicación de Facebook
   • [CLIENT-TOKEN] por su token de cliente
   • [APP-NAME] por el nombre de su aplicación

4. Modifica el AppDelegate.swift

   import FBSDKCoreKit
   @UIApplicationMain
   class AppDelegate: UIResponder, UIApplicationDelegate {
         func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
           // Override point for customization after application launch.
   
           // Initialize Facebook SDK
           FBSDKCoreKit.ApplicationDelegate.shared.application(
               application,
               didFinishLaunchingWithOptions: launchOptions
           )
   
           return true
       }
   
       func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
           // Called when the app was launched with a url. Feel free to add additional processing here,
           // but if you want the App API to support tracking app url opens, make sure to keep this call
   
           if (FBSDKCoreKit.ApplicationDelegate.shared.application(
               app,
               open: url,
               sourceApplication: options[UIApplication.OpenURLOptionsKey.sourceApplication] as? String,
               annotation: options[UIApplication.OpenURLOptionsKey.annotation]
           )) {
               return true;
           } else {
               return ApplicationDelegateProxy.shared.application(app, open: url, options: options)
           }
       }
   }

Usar inicio de sesión de Facebook en tu aplicación

Advertencia

Antes de empezar: Recuerda que con el nuevo Facebook SDK, el tipo de token que recibes depende enteramente de la elección de seguimiento de la aplicación del usuario, no de tu code configuración. Siempre implementa el manejo tanto de tokens de acceso como de JWT en tu backend para asegurarte de que la autenticación funcione para todos los usuarios.

1. Inicializa el inicio de sesión de Facebook en tu aplicación

   import { SocialLogin } from '@capgo/capacitor-social-login';
   
   // Initialize during app startup
   await SocialLogin.initialize({
     facebook: {
       appId: 'APP_ID',
       clientToken: 'CLIENT_TOKEN',
     }
   })

2. Implementa la función de inicio de sesión

   async function loginWithFacebook() {
     try {
       const result = await SocialLogin.login({
         provider: 'facebook',
        options: {
          permissions: ['email', 'public_profile'],
          limitedLogin: false // See Limited Login section below for important details
        }
       });
       console.log('Facebook login result:', result);
       // Handle successful login
     } catch (error) {
       console.error('Facebook login error:', error);
       // Handle error
     }
   }

   Nota

   Inicio de sesión limitado (solo iOS): Establecer limitedLogin a true si deseas utilizar la característica de inicio de sesión limitado de Facebook. Esta es una característica solo disponible para iOS que proporciona una mayor privacidad restringiendo los datos compartidos durante el inicio de sesión.

   Limitaciones importantes:

   • Solo iOS: El inicio de sesión limitado solo afecta a dispositivos iOS y no tiene impacto en Android
   • Sobrescritura de ATT: Incluso si estableces limitedLogin: false, Facebook forzará automáticamente a true si el usuario no ha concedido la autorización de transparencia de seguimiento de aplicaciones (ATT)
   • Siempre Maneja Ambos Casos: Su aplicación debe estar siempre preparada para manejar tanto escenarios de inicio de sesión limitados como completos

   Verificar el estado de ATT:

   // Check if user has granted tracking permission
   const trackingStatus = await SocialLogin.providerSpecificCall({
     call: 'facebook#requestTracking',
     options: {}
   });
   console.log('Tracking status:', trackingStatus.status); // 'authorized', 'denied', 'notDetermined', or 'restricted'

   Implementación recomendada si se prefiere access_token:

   async function loginWithFacebook() {
     try {
       // Check ATT status first
       const trackingStatus = await SocialLogin.providerSpecificCall({
         call: 'facebook#requestTracking',
         options: {}
       });
   
       const result = await SocialLogin.login({
         provider: 'facebook',
         options: {
           permissions: ['email', 'public_profile'],
           limitedLogin: trackingStatus.status === 'denied' // Auto-adjust based on ATT
         }
       });
   
       // Handle different response types based on limited login
       if (result.result.accessToken) {
         // Your app logic should work with both limited and full login
         console.log('Login successful:', result);
       }
     } catch (error) {
       console.error('Facebook login error:', error);
     }
   }

   ¿Qué sucede en el inicio de sesión limitado:

   • Acceso a datos reducido: Algunos datos del usuario pueden no estar disponibles
   • Diferentes tipos de tokens: Los tokens de acceso pueden tener diferentes capacidades
   • Cumplimiento de privacidad: Ayuda a cumplir con los requisitos de privacidad de iOS

   Importante: Siempre prueba tu aplicación con escenarios de inicio de sesión limitado y completo para asegurarte de que tu aplicación funcione correctamente en ambos casos. Puedes aprender más sobre Inicio de Sesión Limitado aquí.

3. Obtener Perfil del Usuario

   : Después de un inicio de sesión exitoso, puedes recuperar información de perfil adicional:

   async function getFacebookProfile() {
     try {
       const profileResponse = await SocialLogin.providerSpecificCall({
         call: 'facebook#getProfile',
         options: {
           fields: ['id', 'name', 'email', 'first_name', 'last_name', 'picture']
         }
       });
   
       console.log('Facebook profile:', profileResponse.profile);
       return profileResponse.profile;
     } catch (error) {
       console.error('Failed to get Facebook profile:', error);
       return null;
     }
   }
   
   // Example usage after login
   async function loginAndGetProfile() {
     const loginResult = await loginWithFacebook();
     if (loginResult) {
       const profile = await getFacebookProfile();
       if (profile) {
         console.log('User ID:', profile.id);
         console.log('Name:', profile.name);
         console.log('Email:', profile.email);
         console.log('Profile Picture:', profile.picture?.data?.url);
       }
     }
   }

   Consejo

   Campos de Perfil Disponibles: Puedes solicitar cualquier campo disponible en el Gráfico de Facebook API. Los campos comunes incluyen: id, name, email, first_name, last_name, picture, birthday, gender, location, hometown. Ten en cuenta que algunos campos pueden requerir permisos adicionales.

   Tipo de Token Limitación: El getProfile llamada solo funciona cuando tienes un token de acceso (iniciación estándar con seguimiento permitido). Si el usuario denegó el seguimiento o estás utilizando inicio limitado (solo token JWT), esta llamada fallará. En ese caso, utiliza los datos de perfil proporcionados en la respuesta de inicio inicial.

⚠️ Crítico: Manejo de Tokens de Backend

Peligro

COMPORTAMIENTO CRÍTICO DE BEHINDEND EN iOS: El inicio limitado y la transparencia de aplicaciones (ATT) son ÚNICAMENTE PARA iOS características. En Android, siempre recibirá tokens de acceso independientemente de la limitedLogin configuración.

Comportamiento de tokens de iOS:

• limitedLogin: true → Siempre token JWT (solo para iOS)
• limitedLogin: false → Token de acceso + El usuario permite el seguimiento
• limitedLogin: false → Token JWT (iOS sobreescribe automáticamente su configuración) Comportamiento de tokens de Android

: Siempre token de acceso,la configuración se ignora. limitedLogin Su servidor debe manejar

__CAPGO_KEEP_0__ Tipos de tokens diferentes porque los usuarios de iOS pueden recibir tokens de acceso o tokens JWT dependiendo de su elección de transparencia de seguimiento de aplicaciones, mientras que los usuarios de Android siempre reciben tokens de acceso.

Tipos de tokens por plataforma

Plataforma	Configuración de inicio de sesión limitado	Elección de ATT del usuario	Tipo de token de resultado
iOS	true	Cualquiera	Token JWT
iOS	false	Permite el seguimiento	Token de Acceso
iOS	false	No permite el seguimiento	Token JWT (sobreescribir automáticamente)
Android	Cualquiera	N/A	Token de Acceso (siempre)

Implementación de Backend

1. Detectar el tipo de Token y manejar según corresponda

   async function loginWithFacebook() {
     try {
       const loginResult = await SocialLogin.login({
         provider: 'facebook',
         options: {
           permissions: ['email', 'public_profile'],
           limitedLogin: false // iOS: depends on ATT, Android: ignored
         }
       });
   
       if (loginResult.accessToken) {
         // Access token (Android always, iOS when tracking allowed)
         return handleAccessToken(loginResult.accessToken.token);
       } else if (loginResult.idToken) {
         // JWT token (iOS only when tracking denied or limitedLogin: true)
         return handleJWTToken(loginResult.idToken);
       }
     } catch (error) {
       console.error('Facebook login error:', error);
     }
   }

2. Ejemplo de integración con Firebase

   import { OAuthProvider, FacebookAuthProvider, signInWithCredential } from 'firebase/auth';
   
   async function handleAccessToken(accessToken: string, nonce: string) {
     // For access tokens, use OAuthProvider (new method)
     const fbOAuth = new OAuthProvider("facebook.com");
     const credential = fbOAuth.credential({
       idToken: accessToken,
       rawNonce: nonce
     });
   
     try {
       const userResponse = await signInWithCredential(auth, credential);
       return userResponse;
     } catch (error) {
       console.error('Firebase OAuth error:', error);
       return false;
     }
   }
   
   async function handleJWTToken(jwtToken: string) {
     // For JWT tokens, send to your backend for validation
     try {
       const response = await fetch('/api/auth/facebook-jwt', {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
         },
         body: JSON.stringify({ jwtToken })
       });
   
       const result = await response.json();
       return result;
     } catch (error) {
       console.error('JWT validation error:', error);
       return false;
     }
   }

3. Validación de JWT en el backend

   // Backend: Validate JWT token from Facebook
   import jwt from 'jsonwebtoken';
   import { Request, Response } from 'express';
   
   app.post('/api/auth/facebook-jwt', async (req: Request, res: Response) => {
     const { jwtToken } = req.body;
   
     try {
       // Verify JWT token with Facebook's public key
       // See: https://developers.facebook.com/docs/facebook-login/limited-login/token/validating/#standard-claims
       const decoded = jwt.verify(jwtToken, getFacebookPublicKey(), {
         algorithms: ['RS256'],
         audience: process.env.FACEBOOK_APP_ID,
         issuer: 'https://www.facebook.com' // From: https://www.facebook.com/.well-known/openid-configuration/?_rdr
       });
   
       // Extract user info from JWT
       const userInfo = {
         id: decoded.sub,
         email: decoded.email,
         name: decoded.name,
         isJWTAuth: true
       };
   
       // Create your app's session/token
       const sessionToken = createUserSession(userInfo);
   
       res.json({
         success: true,
         token: sessionToken,
         user: userInfo
       });
     } catch (error) {
       console.error('JWT validation failed:', error);
       res.status(401).json({ success: false, error: 'Invalid token' });
     }
   });

4. Manipulador de tokens de backend genérico

   // Handle both token types in your backend
   async function authenticateFacebookUser(tokenData: any) {
     if (tokenData.accessToken) {
       // Handle access token - validate with Facebook Graph API
       const response = await fetch(`https://graph.facebook.com/me?access_token=${tokenData.accessToken}&fields=id,name,email`);
       const userInfo = await response.json();
   
       return {
         user: userInfo,
         tokenType: 'access_token',
         expiresIn: tokenData.expiresIn || 3600
       };
     } else if (tokenData.jwtToken) {
       // Handle JWT token - decode and validate
       // See: https://developers.facebook.com/docs/facebook-login/limited-login/token/validating/#standard-claims
       const decoded = jwt.verify(tokenData.jwtToken, getFacebookPublicKey());
   
       return {
         user: {
           id: decoded.sub,
           name: decoded.name,
           email: decoded.email
         },
         tokenType: 'jwt',
         expiresIn: decoded.exp - Math.floor(Date.now() / 1000)
       };
     } else {
       throw new Error('No valid token provided');
     }
   }

Consideraciones clave

Peligro

Criticidad iOS-Única Entendimiento:

• iOS: La elección del seguimiento de la aplicación del usuario determina el tipo de token, NO tus configuraciones de code (incluso cuando limitedLogin: false)
• Android: Siempre recibe tokens de acceso, sin importar limitedLogin setting
• : Inicio de sesión limitado es solo para iOS - Android ignora completamente esta configuración

Access Token (Ingreso estándar):

• ✅ Android: Siempre disponible (restricciones de iOS no se aplican)
• ✅ iOS: Solo cuando el usuario permite explícitamente el seguimiento de la aplicación
• ✅ Puede usarse para acceder al gráfico de Facebook API
• ✅ Tiempos de expiración más largos
• ✅ Más datos de usuario disponibles
• ❌ Becoming menos común en iOS as los usuarios deniegan cada vez más el seguimiento

Token JWT (Modo de privacidad de iOS solo):

• ❌ Android: Nunca ocurre (no soportado)
• ✅ iOS: Cuando se deniega el seguimiento o limitedLogin: true
• ✅ Respetar las preferencias de privacidad de usuario de iOS
• ❌ Contiene información básica de usuario solo
• ❌ Tiempos de expiración más cortos
• ❌ Sin acceso al Gráfico de Facebook API
• ⚠️ Ahora el escenario más común para usuarios de iOS

Comportamiento específico de plataforma:

• Aplicaciones de iOS: Deben manejar tanto tokens de acceso como tokens JWT
• Aplicaciones de Android: Solo necesitan manejar tokens de acceso
• Aplicaciones híbridas: Deben implementar ambos métodos de manejo de tokens

Consejo

Esencial para iOS: Debe implementar ambos métodos de manejo de tokens. Muchos desarrolladores de iOS asumen que siempre obtendrán tokens de acceso y sus aplicaciones se rompen cuando los usuarios deniegan el seguimiento.

Requisitos de contexto seguro (Web/Capacitor)

Limitaciones de API de criptografía

El flujo de inicio de sesión de Facebook actualizado requiere el Web API de criptografía para la generación de nonce, que solo está disponible en contextos seguros:

// This requires secure context (HTTPS or localhost)
async function sha256(message: string) {
  const msgBuffer = new TextEncoder().encode(message);
  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer); // ❌ Fails in insecure context
  // ...
}

Problemas del entorno de desarrollo

Problema común: ionic serve con URLs HTTP rompe la autenticación de Facebook

Entorno	Criptografía API Disponible	El inicio de sesión de Facebook funciona
http://localhost:3000	✅ Sí	✅ Sí
http://127.0.0.1:3000	✅ Sí	✅ Sí
http://192.168.1.100:3000	❌ No	❌ No
https://any-domain.com	✅ Sí	✅ Sí

Soluciones para el desarrollo de Capacitor

1. Usar localhost para pruebas de web

   # Instead of ionic serve --host=0.0.0.0
   ionic serve --host=localhost

2. Habilitar HTTPS en Ionic

   ionic serve --ssl

3. Probar en dispositivos reales

   # Capacitor apps run in secure context on devices
   ionic cap run ios
   ionic cap run android

4. Generación alternativa de nonce para desarrollo

   async function generateNonce() {
     if (typeof crypto !== 'undefined' && crypto.subtle) {
       // Secure context - use crypto.subtle
       return await sha256(Math.random().toString(36).substring(2, 10));
     } else {
       // Fallback for development (not secure for production)
       console.warn('Using fallback nonce - not secure for production');
       return btoa(Math.random().toString(36).substring(2, 10));
     }
   }

Nota de integración con Firebase

La documentación de Firebase más reciente requiere tokens JWT con nonces para la autenticación de Facebook, independientemente de las configuraciones de inicio de sesión. Este enfoque funciona tanto con limitedLogin: true y limitedLogin: false:

   // Both modes can return JWT tokens depending on user choice
   const loginResult = await SocialLogin.login({
     provider: 'facebook',
     options: {
       permissions: ['email', 'public_profile'],
       limitedLogin: false, // true = always JWT, false = depends on user tracking choice
       nonce: nonce
     }
   });

Limitación de desarrolloSi está utilizando ionic serve en una IP de red (no localhost), la autenticación de Facebook fallará debido a restricciones de criptografía API. Utilice localhost o HTTPS para pruebas de web.

Consejo

Seguridad en Producción: Capacitor aplicaciones en iOS/Android siempre se ejecutan en contextos seguros, por lo que esta limitación solo afecta entornos de desarrollo web.

Resolución de Problemas

Título de la sección “Resolución de Problemas”

1. Título de la sección “Problemas y Soluciones Comunes”

   • Errores de clave hash en Android
   • Verifica que hayas agregado la clave hash correcta a la consola de Facebook
   • Para versiones de lanzamiento, asegúrate de agregar ambas claves hash de depuración y de lanzamiento

2. Verifica que estés utilizando el keystore correcto al generar la clave hash de Facebook login botón no aparece

   • Verifica todas las entradas del manifiesto son correctas
   • Comprueba que tu ID de aplicación y token de cliente de Facebook son correctos
   • Asegúrate de haber inicializado correctamente el SDK

3. Problemas comunes de iOS

   • Asegúrate de que todas las entradas de Info.plist son correctas
   • Verifica que los esquemas de URL estén configurados correctamente
   • Comprueba que tu ID de paquete coincide con lo registrado en la consola de desarrolladores de Facebook

Pruebas

1. Antes de realizar pruebas, agrega usuarios de prueba en la consola de desarrolladores de Facebook

   • Ve a Roles > Usuarios de prueba
   • Crear un usuario de prueba
   • Utilice estos credenciales para la prueba

2. Pruebe tanto ediciones de depuración como de liberación

   • Edición de depuración con clave de hash de depuración
   • Edición de liberación con clave de hash de liberación
   • Pruebe en dispositivos tanto emuladores como físicos

Recuerde probar el flujo de inicio de sesión completo, incluyendo:

• Inicio de sesión exitoso
• CANCELACIÓN DE INICIO DE SESIÓN
• Gestión de errores
• Funcionalidad de cierre de sesión

Siga adelante desde la configuración de inicio de sesión de Facebook

If you are using Configuración de inicio de sesión de Facebook para planificar la autenticación y los flujos de cuenta, conectéalo con Usando @capgo/capacitor-login-social para la capacidad nativa en Usando @capgo/capacitor-login-social @capgo/capacitor-login-social para el detalle de implementación en @capgo/capacitor-login-social @capgo/capacitor-clave-llave para el detalle de implementación en @capgo/capacitor-clave-llave @capgo/capacitor-biometría-nativa para el detalle de implementación en @capgo/capacitor-biometría-nativa, y Autenticación de dos factores para los detalles de implementación en la autenticación de dos factores.