Nuevo inicio de sesión de Google en Android

Estoy tratando de obtener un ID de token de usuario utilizando los nuevos servicios de Google Play 8.3 y, como se documenta, paso el ID del servidor:

GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
    .requestIdToken(getString(R.string.server_client_id))
    .requestEmail()
    .build();

pero sigo obteniendo un resultado sin éxito como se muestra a continuación:

{statusCode=unknown status code: 12501, resolution=null}

y documentado aquí GoogleSignInStatusCodes

El inicio de sesión fue cancelado por el usuario. es decir, el usuario canceló algunas de las resoluciones de inicio de sesión, por ejemplo, selección de cuenta o consentimiento de OAuth.

Valor constante: 12501

Ese no es mi caso, ya que elegí una cuenta. ¿Alguna idea de cuál podría ser la razón?

Tuve exactamente el mismo problema y encontré la solución.

Si sigue la documentación que se encuentra aquí: https://developers.google.com/identity/sign-in/android/start-integrating

El primer paso le indica que cree el archivo de configuración (que crea un ID de cliente OAuth 2.0 para usted y lo inserta en google-services.json)

Luego, dice nuevamente sobre la creación de un ID de cliente OAuth 2.0, pero esta vez dice que debe hacerlo para la aplicación web

¡Y esta es la parte confusa! (al menos para mí) porque solo estaba tomando la identificación de cliente creada para Android OAuth y no creando una nueva para la aplicación web (pensé que la documentación era simplemente redundante o algo así)

Como dice, es este, y solo este el que tienes que usar como parámetro de los métodos requestIdToken o requestServerAuthCode .

Olvídese de usar el ID de OAuth de Android en estos métodos porque entonces obtendrá todo el tiempo la respuesta del código de estado feo 12501.

Creo que el principal problema es que la documentación es un poco confusa al respecto. O tal vez porque es un poco extraño el hecho de que tenga que crear dos ID de OAuth.

Entonces, como resumen, necesita DOS ID de OAuth, una para Android y otra para la aplicación web, y debe configurar cada una en el lugar correcto.

Estaba luchando con esto y perdí casi una semana en eso.

Así es como lo conseguí.

1. Importar proyecto en AndroidStudio
2. Cree un almacén de claves de depuración para el proyecto.
3. Cree la firma SHA1 para el proyecto utilizando el almacén de claves de depuración.
4. Con la firma SHA1, registre su aplicación para Google Signin en Google Developer Console.
5. Genere un archivo de configuración de Google allí (colóquelo en la carpeta de la aplicación de Android Studio)
6. Utilice el ID de cliente web de las credenciales de OAuth 2.0 en su proyecto de Android.
7. Ahora, desde Android Studio, genere la compilación de depuración (APK) de su proyecto.
8. Monte el dispositivo en su sistema -> copie esta versión de depuración firmada de APK e instálela.

Los últimos tres pasos 6, 7 y 8 son los que realmente necesita cuidar. Si ejecuta directamente el proyecto, el APK no está realmente firmado con el almacén de claves de depuración y Google no lo reconoce en absoluto.

Tuve el mismo problema, después de investigar la solución, se reanudó que server_client_id contenía algún valor incorrecto o su google_services.json no incluía oauth_client con client_id que se registró en su almacén de claves.

requestIdToken(getString(R.string.server_client_id))

R.string.server_client_idutilice el ID de cliente OAuth 2.0 para la aplicación web . E ID de cliente OAuth para uso de Android en google_services.json

Por lo general, usamos 2 almacenes de claves, 1 con almacén de claves de depuración y 1 con almacén de claves firmado para archivos. Entonces, si queremos necesitar el modo de depuración y publicación, registre su ID de cliente OAuth para Android dos veces, 1 usando SHA1 del almacén de claves de depuración y 1 del almacén de claves firmado para publicar.

pequeño ejemplo en mi google_services.json

  "oauth_client": [
    {
      "client_id": "xxx-client-id.com",
      "client_type": 1,
      "android_info": {
        "package_name": "com.app.android",
        "certificate_hash": "xxxhash"
      }
    },
    {
      "client_id": "yyy.client-id.com",
      "client_type": 1,
      "android_info": {
        "package_name": "com.app.android",
        "certificate_hash": "yyyhash"
      }
    }
  ],

Estaba teniendo el mismo problema, era porque creé el ID de cliente del tipo de aplicación Android

En su lugar, lo eliminé y creé el ID de cliente de tipo aplicación web y me deshice de este problema.

Simplemente averigüe cómo resolver esto ... Recibí este error mientras intentaba ejecutar la versión de depuración de mi aplicación ... Para solucionarlo, agregue una credencial para su aplicación de depuración en la consola del desarrollador y también en los servicios de Google .json.

¡Esto me lo arregló!

Tuve el mismo problema y lo resolví con la siguiente solución:

1. Cree el archivo de configuración (google-services.json) como se describe aquí y colóquelo en el directorio de su proyecto / app.
2. (Como se menciona en otras respuestas) Uso de la ID de cliente de la aplicación web para requestIdToken método.
3. [Mi principal problema] Firma tu aplicación si trabajas en modo de depuración como se muestra a continuación:

 signingConfigs {
    release {
        storeFile file("myreleasekey.keystore")
        storePassword "password"
        keyAlias "MyReleaseKey"
        keyPassword "password"
    }
 }

 buildTypes {
     release {
         ...
     }
     debug {
         ...
         signingConfig signingConfigs.release
     }
 }

Ahora lo tengo.

Entonces, primero debe seguir las respuestas superiores que dicen:

1. crear un ID de cliente de OAuth para aplicaciones web en Google Developers Console y usarlo en requestIdToken() (elimine el código de estado 12501)
2. Si creó un ID de cliente de OAuth de Android para su clave hash de producción, cree un nuevo ID de cliente de OAuth de Android para su clave de hash de depuración e intégrelo en su google-services.json. (deshacerse del código de estado 12500)

Ya no es válido Y aquí viene la última parte: 3. No puedes llamar requestIdToken()y requestEmail()de una vez. Al menos en mi caso me deshice Result: Status{statusCode=INTERNAL_ERROR, resolution=null}borrando requestEmail().

Buena suerte...

En mi caso, también tuve que verificar que la depuración SHA-1 se agregara como un cliente de Android OAuth válido.

Utilice la aplicación web como server_client_id no como aplicación de Android

Tuve el mismo problema y noté que se devolvió el código 12501 cuando mi server_client_id contenía algún valor incorrecto.

Dado que no hay un mensaje detallado y la documentación de este código de error es bastante pobre, no sé si su problema tiene la misma causa que la mía.

Mi aplicación se basa en el código de Android de este ejemplo (clase IdTokenActivity). Para que funcione, también necesitaba integrar el inicio de sesión de Google en mi aplicación:

• archivo de configuración json generado con inicio de sesión de Google habilitado
• agregado el complemento y la dependencia de Google a mi archivo gradle
• Creé el ID de cliente de OAuth para esta aplicación y lo guardé en mi proyecto como server_client_id

¿Está tu apk en modo de depuración? Creo que solo funciona con una apk firmada.

1. Siga el ambiguo documento de Google.
2. Coloque google-services.json en el directorio de su proyecto

3. Configura tu gradle como https://stackoverflow.com/a/35216421/5886475

4. Establezca server_client_id en string.xml. Es su ID de cliente web, no el cliente de Android

Un problema que tuve es que el SHA-1 lo generé como con el alias incorrecto. El alias DEBE SER androiddebugkey . Así que puse el ID de Android OAuth en mi archivo google-service.json . He puesto el ID del cliente web en requestIdToken () . Y en mi caso específico, generé el SHA-1 con el alias androiddebugkey .

google-services.json :

"oauth_client": [
    {
      "client_id": "ANDROID OAUTH ID-.....apps.googleusercontent.com",
      "client_type": 1,
      "android_info": {
        "package_name": "br.com.packagename",
        "certificate_hash": "SHA-1 HASH"
      }
    },{
      "client_id": "WEB CLIEND ID......apps.googleusercontent.com",
      "client_type": 3
    }
 ]

Parte de firma:

GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                .requestIdToken("WEB CLIEND ID......apps.googleusercontent.com")
                .requestEmail() 
                .build(); 

En lugar de R.string.server_client_id, solo use R.string.default_web_client_id.

Cuando copia el archivo google-services.json en la aplicación, crea este valor de cadena automáticamente. No es necesario que copie la clave de google-services.json a string.xml. Me funcionó.

Resolví este problema haciendo clic en Firebase Support en Android Studio, que puede no ser relevante para los usuarios que no son de Firebase.

1. Vaya al menú Herramientas-> Firebase
2. Haga clic en Conectar su aplicación a Firebase, se mostrará como Conectado en verde una vez que la conexión sea exitosa
3. Haga clic en el botón Agregar autenticación de Firebase a su aplicación, también se volverá verde.

NOTA: Tener una gran lista de respuestas en esto definitivamente confirma una cosa. Google necesita actualizar y mantener la documentación a prueba de errores.

Si ninguna de las opciones anteriores funciona, verifique si su applicationId en la aplicación build.gradle es el mismo que el nombre del paquete.

Obviamente, primero verifique que su tecla de liberación sha1 sea correcta o no. Pero si aún no funciona y está utilizando los servicios de Google Play 8.4.0 (es decir, compile 'com.google.android.gms: play-services: 8.4.0'), el problema podría resolverse modificando el objeto GoogleSignInOption. En vez de:

GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                    .requestEmail()  
       .requestIdToken("YOUR_WEB_API_ID.apps.googleusercontent.com")
                    .build();

Tienes que usar:

GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                .requestScopes(new Scope(Scopes.PLUS_LOGIN))
                .requestScopes(new Scope(Scopes.PLUS_ME))
                .requestEmail()
                .build();

Esto resuelve el error al devolver statusCode = INTERNAL_ERROR OR statusCode = Error 12501 O statusCode = Error 12500. Entonces este objeto gso podría usarse para crear GoogleApiClient como se muestra a continuación:

 mGoogleApiClient = new GoogleApiClient.Builder(this)
                .enableAutoManage(this, this)
                .addApi(Auth.GOOGLE_SIGN_IN_API,gso)
               // .addApi(Plus.API, null)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
               // .addScope(Plus.SCOPE_PLUS_LOGIN)
                .build(); 

No sé por qué, pero SHA1 en Android Studio se cambia automáticamente y es por eso que recibo este error. Para resolver esto, actualicé el SHA1 de la configuración de mi proyecto de base de fuego con el nuevo SHA1 de mi estudio de Android y comenzó a funcionar nuevamente.

En mi caso, mis Credenciales para Client ID for Androiden la Consola de API de Google solo contenían el SHA-1 para mi APK firmado de lanzamiento . Android Studio estaba usando el almacén de claves de depuración predeterminado para firmar mis compilaciones de depuración y, en ese caso, el almacén de claves de depuración SHA-1 no coincidía con el cliente de Android SHA-1 en línea. Mi solución fue simplemente firmar las compilaciones de depuración con el almacén de claves de la versión.

En Android Studio, Build/Edit Build Types...luego seleccione su tipo de compilación de depuración y asegúrese de que Signing Config esté configurado en su certificado de versión.

Si está utilizando el almacén de claves de depuración para compilar el proyecto, debe agregar la huella digital SHA-1 de debug.keystore en Firebase Console .

1. En tu Firebase Console , abre tu proyecto
2. Vaya a Parámetros. Ficha General
3. Al final de esta página, hay un campo para agregar una huella digital SHA-1
4. Pegue el SHA-1 en el campo de la consola.

Para obtener SHA-1 de debug.keystore:

Mac / Linux:

keytool -exportcert -list -v -alias androiddebugkey -keystore ~/.android/debug.keystore

Ventanas:

 keytool -exportcert -list -v -alias androiddebugkey -keystore %USERPROFILE%\.android\debug.keystore

https://developers.google.com/android/guides/client-auth

Eso es todo !

Tuve el mismo problema y el error 12501 y ninguno de los anteriores funcionó para mí.

Mi problema fue que estaba usando la API web predeterminada de Google que se generó para mí. después de crear mi propia API web, el error desapareció y funcionó bien.

estos son pasos de trabajo:

1. Primero creé la clave de depuración SHA1 y la agregué a la consola de Firebase . creando SHA1 desde aquí .
2. cree tanto la API web como el ID de cliente de Android OAuth 2.0 desde aquí
3. generarse google-service.jsondesde Firebase consola de y se colocan en la carpeta de la aplicación.
4. poner este código para GoogleSignnOption

Me gusta esto:

gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN).requestIdToken
                ("put the web app client Id that get from the link in developer console ")
                .requestEmail().build();

consejo 1: descubrí que debe crear tanto el ID de cliente de la aplicación web como la de Android para que funcione.

Consejo 2: si de Irán como yo puede obtener el usuario de Google pero no se puede AuthWithGoogley el resultado de la voluntad failen auth.signInWithCredential(credential)y ha tenido que utilizar algún proxy para devolver cierto.

esta es la fuente completa de trabajo de FireBaseAuthDemo en github:

espero ayuda completa

También tuve este problema después de seguir las instrucciones de Google para firmar automáticamente su aplicación . Si está utilizando este método para firmar sus aplicaciones, deberá incluir la huella digital del almacén de claves generada en sus credenciales de API.

En el navegador del proyecto, haga clic derecho en su aplicación y seleccione Abrir configuración del módulo.

Me resultó menos confuso poner el .jksarchivo en el /appdirectorio de mi proyecto . En cualquier caso, ejecute esta línea en él.

keytool -list -v -keystore /home/user/keystores/android.jks

Se te solicitará una contraseña. No estoy seguro si es el Key PasswordoStore Password porque los míos son iguales. : |

La consola escupirá un montón de huellas digitales de certificados. Tome el SHA1 e introdúzcalo en sus credenciales de API en la Consola para desarrolladores de API de Google . Deberá ingresarlo para el cliente de Android OAuth 2.0 client IDsaunque en realidad no use ese client_id en su aplicación. Si está utilizando otras API para Android, coloque el mismo SHA1 en las credenciales clave apropiadas debajo API keystambién.

Aqui esta el nuevo. Estuve intentando durante 6 horas iniciar sesión en el emulador con la identificación de mi dominio corporativo de Google Apps, sin éxito, obteniendo errores 12501. Por una corazonada, probé mi identificación personal de Gmail y funcionó. Lo mismo ocurre si lo probé en mi teléfono con mi identificación corporativa. Resulta que el emulador no tenía la configuración adecuada de administración de dispositivos móviles para permitir que mi identificación corporativa inicie sesión.

Entonces, si quiero probar el emulador con esta identificación corporativa, tengo que instalar Google Play Store, luego el software MDM y configurarlo.

De mi extraña experiencia con este error, puedo decir que también debe intentar reiniciar su teléfono para deshacerse de este error :) Me implementó el inicio de sesión de Google usando cuentas de G Suite que tienen una política de dispositivo asignada a través de Google Admin . Entonces, en el primer inicio de sesión, se requería instalar la aplicación Device Policy. Después de completar todos los pasos posteriores, solo arrojaba el error 12501. Al mismo tiempo, la misma aplicación funcionaba bien en otros teléfonos. Así que solo el reinicio ayudó. Pero ayudó

Aunque ya existen muchas respuestas con votos positivos en esta pregunta, me costó entender la lógica. Entonces, se me ocurrió mi investigación.

• Cree una aplicación con el nombre del paquete correcto y la huella digital del certificado de firma SHA-1 https://developers.google.com/mobile/add?platform=android&cntapi=signin
• Habilitar el inicio de sesión de Google
• Genere el archivo de configuración.

Para obtener SHA-1, ejecute esto en la terminal:

keytool -exportcert -keystore path-to-debug-or-production-keystore -list -v

Acerca de OAuth 2.0 client IDs

• OAuth para la web (en la aplicación esto se usa como server_client_id)
• OAuth para Android (debe crearse con el nombre del paquete correcto y la huella digital del certificado de firma SHA-1 ).

Si está utilizando el almacén de claves diferente para depurar y liberar, debe crear por separado OAuth 2.0 client IDscon el nombre del paquete respectivo y SHA-1 .

Puede crear o editar su OAuth 2.0 client IDsaquí https://console.developers.google.com/apis/credentials?project=

1. Navegando a su aplicación.
2. Si ya tiene un OAuth para Android, haga clic en su nombre y verifique el nombre del paquete y SHA-1 .

Podemos usar el mismo almacén de claves tanto para la depuración como para el lanzamiento guardando los detalles del almacén de claves en global (local, no dentro del proyecto) gradle.propertiese ingresándolo build.gradlecomo se muestra a continuación.

def key_alias = ""
def key_password = ""
def store_file = ""
def store_password = ""

try {
    key_alias = YOUR_KEY_ALIAS
    key_password = YOUR_KEY_PASSWORD
    store_file = YOUR_KEYSTORE_PATH
    store_password = YOUR_KEYSTORE_PASSWORD
} catch (Exception exception) {
    throw new IllegalStateException('Failed to find key store details. Social Login is disabled');
}

android {
    signingConfigs {
        config {
            keyAlias key_alias
            keyPassword key_password
            storeFile file(store_file)
            storePassword store_password
        }
    }

    buildTypes {
        debug {
            signingConfig signingConfigs.config
            // ...
        }
        release {
            signingConfig signingConfigs.config
            // ...
        }
    }
}

Puede usar el siguiente fragmento

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_CODE_GOOGLE_SIGN_IN) {
        GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
        if (result.isSuccess()) {
            // ...
        } else if (result.getStatus().getStatusCode() == CommonStatusCodes.NETWORK_ERROR) {
            // No internet connection
        } else if (result.getStatus().getStatusCode() == CommonStatusCodes.DEVELOPER_ERROR) {
            // Wrong server OAuth key(server_client_id)
        } else if (result.getStatus().getStatusCode() == 12501) {
            // Wrong app signing-certificate fingerprint SHA1
        } else {
            Log.e("Google sign in error", result.getStatus().toString());
        }
    }
}

Nota: Si habilitó solo el inicio de sesión de Google cuando generó el archivo de configuración, no es necesario que agregue el google-servies.jsonarchivo en su proyecto (la generación del archivo realiza los pasos de configuración necesarios).

Intente seguir estos pasos:

1. Clona el siguiente proyecto https://github.com/googlesamples/google-services

2. Siga la guía en https://developers.google.com/identity/sign-in/android/start

3. Utilice el cliente web (creado automáticamente por el servicio de Google) y agréguelo en requestIdToken (...)

   GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
      .requestEmail()  
      .requestIdToken("YOUR_WEB_API_ID.apps.googleusercontent.com")
      .build();
   

4. Asegúrese de que está utilizando el mismo almacén de claves que se agregó al proyecto de Google. Por ejemplo, si ha utilizado el siguiente comando para generar la clave SHA-1

   keytool -exportcert -list -v -alias androiddebugkey -keystore ~/.android/debug.keystore    
   

5. Luego agregue el siguiente código en el archivo app / build.gradle dentro de Android {...} [Resolvió mi problema]

   signingConfigs
   {
       debug 
       {
           storeFile file("/home/ashwin/.android/debug.keystore")
           storePassword "android"
           keyAlias "androiddebugkey"
           keyPassword "android"
       }
   }
   
   buildTypes
   {
       release
       {
           minifyEnabled false
           proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
       }
       debug
       {
           signingConfig signingConfigs.debug
       }
   }
   

Nota: su keyPassword y keyAlias ​​deben ser los mismos que se usaron durante la generación del certificado SHA-1.

1.Especifique signingConfigs en su archivo gradle

signingConfigs {
        config {
            keyAlias 'appalias'
            keyPassword 'hunter123'
            storePassword 'hunter123'
            storeFile file('path/to/keystore.jks')
        }
}

2.Vaya a Tipos de compilación en la estructura del proyecto (en Android Studio) y especifique signingConfigs en "config"

Ahora limpia tu proyecto y vuelve a construir. Deberia de funcionar.

Si lo anterior no funciona, el siguiente es su último recurso.
Pruebe el paso uno y compile y verifique. Si no funciona, vaya al paso siguiente e intente compilar de nuevo.

1. Cree una apk firmada (con recordar contraseña marcada).
2. Antes de firmar, verifique el nombre del archivo del almacén de claves y el que cede al firmar el apk (en Android Studio).
3. Instale el apk firmado en su dispositivo.
4. Espere cinco minutos.
5. Intenta cantar en Google. Si todavía llega el 12501, espere cinco minutos más. Mientras haces eso, haz clic en Gradle Sync.
6. Inténtalo de nuevo. Deberia de funcionar.

Dado que la aplicación solicita que Google inicie sesión desde la vista web, necesitamos crear la identificación del cliente de autenticación de la aplicación web v2.0

1. Ir a las credenciales de la API de Google

   Elija su proyecto de Android en la esquina superior izquierda

   2

2. Haga clic en Crear credenciales -> ID de cliente OAuth -> Elegir aplicación web

3. Haga clic en Aceptar

4. Ahora, si ha sincronizado Android Studio con Firebase (iniciado sesión), simplemente reconstruya el proyecto. De lo contrario, descargue el archivo google-services.json actualizado y reemplace el existente.

   Debería funcionar bien.

También tengo el mismo problema, se resolvió de la siguiente manera:

1. Me hicieron eliminar el SHA1 previamente pensado y crear y configurar un nuevo SHA1.

2. generar nuevo google-services.jsony configurarlo en el directorio de mi aplicación

3. Estaba usando exactamente códigos de desarrollador de Google

4. mi result.isSucces()devuelto verdadero después de ejecutar el proyecto

como resumen, elimine el antiguo sha1 y cree un nuevo sha1 y descargue el nuevo google-services.json

Estaba enfrentando el mismo 12501 statuserror. Esto se debe a la falta de coincidencia de SHA-1 en la versión APK y la depuración del APK.

1. Crea un APK firmado. Para firmar un APK, elija la ruta existente del almacén de claves que ha utilizado para crear SHA-1. p.ej/.android/debug.keystore
2. Dar alias-nombre: androiddebugkey
3. storepass y keypass: android.