Autenticar usando GitHub en Android

Puede permitir que sus usuarios se autentiquen con Firebase usando sus cuentas de GitHub integrando el inicio de sesión OAuth genérico basado en web en su aplicación usando el SDK de Firebase para llevar a cabo el flujo de inicio de sesión de un extremo a otro.

Antes de que empieces

Para que los usuarios inicien sesión con cuentas de GitHub, primero debes habilitar GitHub como proveedor de inicio de sesión para tu proyecto de Firebase:

  1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android .

  2. En Firebase console , abre la sección Auth .
  3. En la pestaña Método de inicio de sesión , habilite el proveedor de GitHub .
  4. Agregue el ID de cliente y el Secreto de cliente desde la consola de desarrollador de ese proveedor a la configuración del proveedor:
    1. Registre su aplicación como aplicación de desarrollador en GitHub y obtenga el ID de cliente y el secreto de cliente de OAuth 2.0 de su aplicación.
    2. Asegúrese de que su URI de redireccionamiento de Firebase OAuth (por ejemplo, my-app-12345.firebaseapp.com/__/auth/handler ) esté configurado como su URL de devolución de llamada de autorización en la página de configuración de su aplicación en la configuración de su aplicación GitHub .
  5. Clic en Guardar .
  6. En el archivo Gradle de su módulo (nivel de aplicación) (generalmente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle ), agregue la dependencia para la autenticación de Firebase. biblioteca para Android. Recomendamos utilizar Firebase Android BoM para controlar el control de versiones de la biblioteca.

    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.8.0"))
    
        // Add the dependency for the Firebase Authentication library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-auth")
    }
    

    Al usar Firebase Android BoM , su aplicación siempre usará versiones compatibles de las bibliotecas de Firebase Android.

    (Alternativa) Agregue dependencias de la biblioteca de Firebase sin usar la BoM

    Si elige no utilizar la BoM de Firebase, debe especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

    Tenga en cuenta que si usa varias bibliotecas de Firebase en su aplicación, le recomendamos encarecidamente usar la BoM para administrar las versiones de la biblioteca, lo que garantiza que todas las versiones sean compatibles.

    dependencies {
        // Add the dependency for the Firebase Authentication library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-auth:22.3.1")
    }
    
    ¿Busca un módulo de biblioteca específico de Kotlin? A partir de octubre de 2023 (Firebase BoM 32.5.0) , tanto los desarrolladores de Kotlin como los de Java podrán depender del módulo de biblioteca principal (para más detalles, consulte las preguntas frecuentes sobre esta iniciativa ).

  7. Si aún no ha especificado la huella digital SHA-1 de su aplicación, hágalo desde la página Configuración de Firebase console. Consulte Autenticar a su cliente para obtener detalles sobre cómo obtener la huella digital SHA-1 de su aplicación.

Maneja el flujo de inicio de sesión con el SDK de Firebase

Si está creando una aplicación para Android, la forma más sencilla de autenticar a sus usuarios con Firebase usando sus cuentas de GitHub es manejar todo el flujo de inicio de sesión con el SDK de Firebase para Android.

Para manejar el flujo de inicio de sesión con el SDK de Firebase para Android, siga estos pasos:

  1. Construya una instancia de un OAuthProvider usando su Builder con el ID de proveedor github.com

    Kotlin+KTX

    val provider = OAuthProvider.newBuilder("github.com")

    Java

    OAuthProvider.Builder provider = OAuthProvider.newBuilder("github.com");

  2. Opcional : especifique parámetros OAuth personalizados adicionales que desee enviar con la solicitud OAuth.

    Kotlin+KTX

    // Target specific email with login hint.
    provider.addCustomParameter("login", "your-email@gmail.com")

    Java

    // Target specific email with login hint.
    provider.addCustomParameter("login", "your-email@gmail.com");

    Para conocer los parámetros que admite GitHub, consulte la documentación de GitHub OAuth . Ten en cuenta que no puedes pasar los parámetros requeridos por Firebase con setCustomParameters() . Estos parámetros son client_id , tipo_respuesta , redirección_uri , estado , alcance y modo_respuesta .

  3. Opcional : especifique alcances de OAuth 2.0 adicionales más allá del perfil básico que desea solicitar al proveedor de autenticación. Si su aplicación requiere acceso a datos de usuario privados desde las API de GitHub, deberá solicitar permisos para acceder a las API de GitHub en Permisos de API en la consola de desarrollador de GitHub. Los alcances de OAuth solicitados deben coincidir exactamente con los preconfigurados en los permisos API de la aplicación.

    Kotlin+KTX

    // Request read access to a user's email addresses.
    // This must be preconfigured in the app's API permissions.
    provider.scopes = listOf("user:email")

    Java

    // Request read access to a user's email addresses.
    // This must be preconfigured in the app's API permissions.
    List<String> scopes =
            new ArrayList<String>() {
                {
                    add("user:email");
                }
            };
    provider.setScopes(scopes);

  4. Autentíquese con Firebase utilizando el objeto proveedor de OAuth. Tenga en cuenta que, a diferencia de otras operaciones de FirebaseAuth, esto tomará el control de su interfaz de usuario al abrir una pestaña personalizada de Chrome . Como resultado, no haga referencia a su actividad en OnSuccessListener y OnFailureListener que adjunte, ya que se desconectarán inmediatamente cuando la operación inicie la interfaz de usuario.

    Primero debes verificar si ya has recibido una respuesta. Iniciar sesión a través de este método coloca su Actividad en segundo plano, lo que significa que el sistema puede reclamarla durante el flujo de inicio de sesión. Para asegurarse de que no haga que el usuario vuelva a intentarlo si esto sucede, debe verificar si ya hay un resultado presente.

    Para comprobar si hay un resultado pendiente, llame getPendingAuthResult :

    Kotlin+KTX

    val pendingResultTask = firebaseAuth.pendingAuthResult
    if (pendingResultTask != null) {
        // There's something already here! Finish the sign-in for your user.
        pendingResultTask
            .addOnSuccessListener {
                // User is signed in.
                // IdP data available in
                // authResult.getAdditionalUserInfo().getProfile().
                // The OAuth access token can also be retrieved:
                // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                // The OAuth secret can be retrieved by calling:
                // ((OAuthCredential)authResult.getCredential()).getSecret().
            }
            .addOnFailureListener {
                // Handle failure.
            }
    } else {
        // There's no pending result so you need to start the sign-in flow.
        // See below.
    }

    Java

    Task<AuthResult> pendingResultTask = firebaseAuth.getPendingAuthResult();
    if (pendingResultTask != null) {
        // There's something already here! Finish the sign-in for your user.
        pendingResultTask
                .addOnSuccessListener(
                        new OnSuccessListener<AuthResult>() {
                            @Override
                            public void onSuccess(AuthResult authResult) {
                                // User is signed in.
                                // IdP data available in
                                // authResult.getAdditionalUserInfo().getProfile().
                                // The OAuth access token can also be retrieved:
                                // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                                // The OAuth secret can be retrieved by calling:
                                // ((OAuthCredential)authResult.getCredential()).getSecret().
                            }
                        })
                .addOnFailureListener(
                        new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                // Handle failure.
                            }
                        });
    } else {
        // There's no pending result so you need to start the sign-in flow.
        // See below.
    }

    Para iniciar el flujo de inicio de sesión, llame a startActivityForSignInWithProvider :

    Kotlin+KTX

    firebaseAuth
        .startActivityForSignInWithProvider(activity, provider.build())
        .addOnSuccessListener {
            // User is signed in.
            // IdP data available in
            // authResult.getAdditionalUserInfo().getProfile().
            // The OAuth access token can also be retrieved:
            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
            // The OAuth secret can be retrieved by calling:
            // ((OAuthCredential)authResult.getCredential()).getSecret().
        }
        .addOnFailureListener {
            // Handle failure.
        }

    Java

    firebaseAuth
            .startActivityForSignInWithProvider(/* activity= */ this, provider.build())
            .addOnSuccessListener(
                    new OnSuccessListener<AuthResult>() {
                        @Override
                        public void onSuccess(AuthResult authResult) {
                            // User is signed in.
                            // IdP data available in
                            // authResult.getAdditionalUserInfo().getProfile().
                            // The OAuth access token can also be retrieved:
                            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
                            // The OAuth secret can be retrieved by calling:
                            // ((OAuthCredential)authResult.getCredential()).getSecret().
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            // Handle failure.
                        }
                    });

    Una vez completado correctamente, el token de acceso de OAuth asociado con el proveedor se puede recuperar del objeto OAuthCredential devuelto.

    Con el token de acceso de OAuth, puede llamar a la API de GitHub .

    Por ejemplo, para obtener información básica del perfil, puede llamar a la API REST y pasar el token de acceso en el encabezado Authorization :

  5. Si bien los ejemplos anteriores se centran en los flujos de inicio de sesión, también tiene la posibilidad de vincular un proveedor de GitHub a un usuario existente mediante startActivityForLinkWithProvider . Por ejemplo, puede vincular varios proveedores al mismo usuario, permitiéndoles iniciar sesión con cualquiera de ellos.

    Kotlin+KTX

    // The user is already signed-in.
    val firebaseUser = firebaseAuth.currentUser!!
    firebaseUser
        .startActivityForLinkWithProvider(activity, provider.build())
        .addOnSuccessListener {
            // Provider credential is linked to the current user.
            // IdP data available in
            // authResult.getAdditionalUserInfo().getProfile().
            // The OAuth access token can also be retrieved:
            // authResult.getCredential().getAccessToken().
            // The OAuth secret can be retrieved by calling:
            // authResult.getCredential().getSecret().
        }
        .addOnFailureListener {
            // Handle failure.
        }

    Java

    // The user is already signed-in.
    FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
    
    firebaseUser
            .startActivityForLinkWithProvider(/* activity= */ this, provider.build())
            .addOnSuccessListener(
                    new OnSuccessListener<AuthResult>() {
                        @Override
                        public void onSuccess(AuthResult authResult) {
                            // Provider credential is linked to the current user.
                            // IdP data available in
                            // authResult.getAdditionalUserInfo().getProfile().
                            // The OAuth access token can also be retrieved:
                            // authResult.getCredential().getAccessToken().
                            // The OAuth secret can be retrieved by calling:
                            // authResult.getCredential().getSecret().
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            // Handle failure.
                        }
                    });

  6. Se puede usar el mismo patrón con startActivityForReauthenticateWithProvider , que se puede usar para recuperar credenciales nuevas para operaciones confidenciales que requieren un inicio de sesión reciente.

    Kotlin+KTX

    // The user is already signed-in.
    val firebaseUser = firebaseAuth.currentUser!!
    firebaseUser
        .startActivityForReauthenticateWithProvider(activity, provider.build())
        .addOnSuccessListener {
            // User is re-authenticated with fresh tokens and
            // should be able to perform sensitive operations
            // like account deletion and email or password
            // update.
        }
        .addOnFailureListener {
            // Handle failure.
        }

    Java

    // The user is already signed-in.
    FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();
    
    firebaseUser
            .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
            .addOnSuccessListener(
                    new OnSuccessListener<AuthResult>() {
                        @Override
                        public void onSuccess(AuthResult authResult) {
                            // User is re-authenticated with fresh tokens and
                            // should be able to perform sensitive operations
                            // like account deletion and email or password
                            // update.
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            // Handle failure.
                        }
                    });

Próximos pasos

Después de que un usuario inicia sesión por primera vez, se crea una nueva cuenta de usuario y se vincula a las credenciales (es decir, el nombre de usuario y la contraseña, el número de teléfono o la información del proveedor de autenticación) con las que el usuario inició sesión. Esta nueva cuenta se almacena como parte de su proyecto de Firebase y se puede usar para identificar a un usuario en cada aplicación de su proyecto, independientemente de cómo inicie sesión el usuario.

  • En tus aplicaciones, puedes obtener la información básica del perfil del usuario desde el objeto FirebaseUser . Consulte Administrar usuarios .

  • En las reglas de seguridad de Firebase Realtime Database y Cloud Storage, puede obtener el ID de usuario único del usuario que inició sesión a partir de la variable auth y usarlo para controlar a qué datos puede acceder un usuario.

Puede permitir que los usuarios inicien sesión en su aplicación utilizando múltiples proveedores de autenticación vinculando las credenciales del proveedor de autenticación a una cuenta de usuario existente.

Para cerrar la sesión de un usuario, llame signOut :

Kotlin+KTX

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();