Nouvelle connexion Google Android
J'essaie d'obtenir un ID de jeton utilisateur à l'aide des nouveaux services Google Play 8.3 et, comme il est documenté, je passe l'ID du serveur:
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestIdToken(getString(R.string.server_client_id))
.requestEmail()
.build();
mais j'obtiens toujours un résultat positif comme ci-dessous:
{statusCode=unknown status code: 12501, resolution=null}
et documenté ici GoogleSignInStatusCodes
La connexion a été annulée par l'utilisateur. c’est-à-dire que l’utilisateur a annulé certaines des résolutions de connexion, par exemple: choix de compte ou OAuth consentement.
Valeur constante: 12501
Ce n'est pas mon cas, car j'ai déjà choisi un compte. Une idée de ce que pourrait être la raison?
J'ai eu exactement le même problème et j'ai trouvé la solution.
Si vous suivez la documentation disponible ici: https://developers.google.com/identity/sign-in/Android/start-integrating
La première étape vous demande de créer le fichier de configuration (qui crée un ID client OAuth 2.0 et l'insère dans le fichier google-services.json).
Puis plus tard, il est répété qu'il faut créer un ID de client OAuth 2.0, mais cette fois, il est indiqué que vous devez le faire pour application Web
Et c'est la partie déroutante! (du moins pour moi) parce que je prenais simplement l'identifiant du client créé pour Android OAuth et ne pas en créer un nouveau pour une application Web (je pensais que la documentation était simplement redondante ou quelque chose du genre)
Comme il est dit, c’est celui-ci, et seulement celui-là que vous devez utiliser comme paramètre des méthodes requestIdToken ou requestServerAuthCode .
Oubliez l'utilisation de l'ID Android OAuth dans cette méthode, car vous obtiendrez tout le temps la réponse de code de statut laide 12501.
Je pense que le problème principal est que la documentation est un peu déroutante à ce sujet. Ou peut-être parce que le fait que vous deviez créer deux OAuth identifiants est un peu étrange.
Donc, en résumé, , vous avez besoin de deux ID OAuth, un pour Android et un pour l'application Web, et vous devez les placer au bon endroit
Je me débattais avec cela et y perdais presque une semaine.
C'est comme ça que j'ai obtenu.
- Importer un projet dans AndroidStudio
- Créer un magasin de clés de débogage pour le projet.
- Créez une signature SHA1 pour le projet à l'aide du magasin de clés de débogage.
- À l'aide de la signature SHA1, enregistrez votre application pour Google Signin sur la console Google Developer.
- Générez un fichier de configuration Google à cet emplacement (placez le dossier d'applications Android de Studio).
- Utilisez l'ID de client Web à partir des informations d'identification OAuth 2.0 de votre projet Android.
- Maintenant, à partir de Android Studio, générez la version de débogage (APK) de votre projet.
- Montez le périphérique sur votre système -> copiez cette version de débogage signée de APK et installez-la.
Les trois dernières étapes 6, 7 et 8, sont ce dont vous avez réellement besoin. Si vous exécutez directement le projet, alors APK n'est pas réellement signé avec le magasin de clés de débogage et Google ne le reconnaît pas du tout.
J'ai eu le même problème, après que la solution de recherche ait repris, server_client_id contenait une valeur incorrecte ou que votre google_services.json n'incluait pas oauth_client avec client_id enregistré avec votre magasin de clés.
requestIdToken(getString(R.string.server_client_id))
R.string.server_client_id utilise OAuth 2.0 identifiant client pour application Web. Et OAuth ID client pour Android utiliser dans google_services.json
En règle générale, nous utilisons 2 magasins de clés, 1 avec le magasin de clés de débogage et 1 avec le magasin de clés signé pour publication. Par conséquent, si vous souhaitez utiliser le mode débogage et publication, enregistrez votre OAuth ID client pour Android deux fois, 1 en utilisant SHA1 à partir du magasin de clés de débogage et 1 à partir du magasin de clés signé pour les publications.
petit exemple dans mon 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"
}
}
],
J'avais le même problème, c'est parce que j'ai créé un identifiant client de type d'application Android
Au lieu de cela, je l'ai supprimé et créé un ID client de type application Web et je me suis débarrassé de ce problème.
Il suffit de comprendre comment résoudre ce problème ... Je rencontrais cette erreur en essayant d'exécuter la version de débogage de mon application ... Pour résoudre ce problème, ajoutez des informations d'identification pour votre application de débogage sur la console du développeur et sur les services de Google. .json.
cela l'a corrigé pour moi!
J'ai eu le même problème, et j'ai résolu avec la solution suivante:
- Créez le fichier de configuration (google-services.json) comme décrit ici et placez-le dans votre répertoire de projet/app
- (Comme mentionné dans d'autres réponses) Utilisation de l'application Web ID client pour la méthode
requestIdToken. - [Mon problème principal] Signez votre application si vous travaillez en mode débogage comme ci-dessous:
signingConfigs { release { storeFile file("myreleasekey.keystore") storePassword "password" keyAlias "MyReleaseKey" keyPassword "password" } } buildTypes { release { ... } debug { ... signingConfig signingConfigs.release } }
Maintenant j'ai compris.
Donc, vous devez d’abord suivre les réponses précédentes en disant:
- créer un OAuth client-id pour les applications Web dans la console Google Developers Console et l'utiliser dans
requestIdToken()(supprimer le code d'état 12501) - si vous avez créé un Android OAuth id de votre clé de hachage de production, créez un nouveau Android OAuth id de client pour votre débogage. clé de hachage et l'intégrer dans votre google-services.json. (se débarrasser du code d'état 12500)
N'est plus valide Et voici la dernière partie: 3. vous ne pouvez pas appeler requestIdToken() et requestEmail() à la fois. Au moins dans mon cas, je me suis débarrassé de Result: Status{statusCode=INTERNAL_ERROR, resolution=null} en supprimant requestEmail().
Alors bonne chance...
Utilisez application Web comme application_serveur_client pas Android
Dans mon cas, je devais également vérifier que le débogage SHA-1 était ajouté en tant que client valide OAuth Android.
J'ai eu le même problème et j'ai remarqué que le code 12501 était renvoyé lorsque mon server_client_id contenait une valeur incorrecte.
Puisqu'il n'y a pas de message détaillé et que la documentation de ce code d'erreur est plutôt médiocre, je ne sais pas si votre problème a la même cause que le mien.
Mon application est basée sur le code Android de cet exemple (classe IdTokenActivity). Pour que cela fonctionne, j'avais également besoin de intégrer la connexion à Google dans mon application:
- fichier de configuration json généré avec la connexion Google activée
- ajout du plugin Google et de la dépendance à mon fichier Gradle
- a créé OAuth ID client pour cette application et l'a enregistrée dans mon projet sous le nom
server_client_id
Au lieu de R.string.server_client_id, utilisez simplement R.string.default_web_client_id.
Lorsque vous copiez le fichier google-services.json dans l'application, la valeur de cette chaîne est créée automatiquement. Vous n'avez pas besoin de copier la clé de google-services.json vers string.xml. Cela a fonctionné pour moi.
Votre apk est-il en mode débogage? Je pense que cela ne fonctionne qu'avec un apk signé.
- Suivez le document ambigu de Google.
- Placez google-services.json dans votre répertoire de projet
Définissez votre diplôme comme https://stackoverflow.com/a/35216421/5886475
Définissez server_client_id dans string.xml. Il s'agit de votre ID de client Web et non de Android client.
J'ai résolu ce problème en cliquant sur Support Firebase dans Android Studio, ce qui peut ne pas intéresser les utilisateurs autres que Firebase.
- Allez dans le menu Outils-> Firebase
- Cliquez sur Connecter votre application à Firebase. Elle apparaîtra comme Connectée en vert une fois la connexion établie.
- Cliquez sur Ajouter une authentification Firebase au bouton de votre application. Il deviendra également vert.
NOTE: Avoir une liste énorme de réponses dans ceci confirme définitivement une chose. Google doit mettre à jour et conserver la documentation à toute épreuve.
Un problème que j'ai eu est que le SHA-1, j'ai généré comme avec le pseudonyme incorrect. L'alias DOIT ÊTRE androiddebugkey. J'ai donc mis le Android OAuth ID dans mon fichier google-service.json . J'ai mis l'ID de client Web à requestIdToken () . Et dans mon cas spécifique, j'ai généré le SHA-1 avec androiddebugkey alias.
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
}
]
partie signature:
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestIdToken("WEB CLIEND ID......apps.googleusercontent.com")
.requestEmail()
.build();
Si vous utilisez le magasin de clés de débogage pour générer le projet, vous devez ajouter l'empreinte SHA-1 de débogage. .keystore sur Console Firebase .
- Sur votre console Firebase , ouvrez votre projet
- Aller aux paramètres. Onglet Général
- À la fin de cette page, un champ permet d'ajouter une empreinte digitale SHA-1
- Collez le SHA-1 dans le champ de la console.
Pour obtenir SHA-1 de debug.keystore:
Mac/Linux:
keytool -exportcert -list -v -alias androiddebugkey -keystore ~/.Android/debug.keystore
Windows:
keytool -exportcert -list -v -alias androiddebugkey -keystore %USERPROFILE%\.Android\debug.keystore
https://developers.google.com/Android/guides/client-auth
C'est tout !
Je ne sais pas pourquoi mais SHA1 dans Android studio est modifié automatiquement et c'est pourquoi je reçois cette erreur. Pour résoudre ce problème, j'ai mis à jour le SHA1 de mes paramètres de projet Firebase avec le nouveau SHA1 de mon studio Android et il a recommencé à fonctionner.
J'ai eu le même problème et erreur 12501 et non de ci-dessus ne fonctionnent pas pour moi.
Mon problème était que j'utilisais Google api Web par défaut qui a généré pour moi. après avoir créé ma propre erreur web api a disparu et a bien fonctionné!
ce sont des étapes de travail:
- j'ai d'abord créé la clé de débogage SHA1 et ajouté à la console de Firebase . créer SHA1 à partir de ici .
- créer à la fois l'API Web et Android OAuth 2.0 ID client à partir de ici
- être généré
google-service.jsonà partir de la console Firebase et placé dans le dossier de l'application. - mettre ce code pour
GoogleSignnOption
comme ça:
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();
Astuce 1: Je découvre que vous devez créer à la fois Android et l'ID client d'application Web pour fonctionner.
Astuce 2: Si vous venez d'Iran, vous pouvez obtenir l'utilisateur de Google mais vous ne pouvez pas AuthWithGoogle et le résultat sera fail in auth.signInWithCredential(credential) et vous deviez utiliser un proxy pour renvoyer true.
voici la source complète de travail de FireBaseAuthDemo dans github:
espérons l'aide complète
Si aucune des options ci-dessus ne fonctionne, vérifiez si votre identificateur d'application dans l'application build.gradle est identique à votre nom de package.
Dans mon cas, mes informations d'identification pour Client ID for Android sur console des API Google contenaient uniquement le SHA-1 pour mon communiqué signé APK. Android Studio utilisait le magasin de clés de débogage par défaut pour signer mes versions de débogage et, dans ce cas, le magasin de clés de débogage SHA-1 ne pas correspondait au Android client SHA-1 en ligne. Ma solution consistait simplement à signer les versions de débogage avec le magasin de clés de publication.
Dans Android Studio, Build/Edit Build Types..., sélectionnez ensuite votre type de construction de débogage et assurez-vous que Signing Config est défini sur votre certificat de version.
Avant tout, vérifiez que votre clé sha1 de version est correcte ou non. Mais si cela ne fonctionne toujours pas et que vous utilisez Google Play Services 8.4.0 (i.e.compile 'com.google.Android.gms: play-services: 8.4.0'), le problème pourrait être résolu en modifiant l'objet GoogleSignInOption. Au lieu de:
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestEmail()
.requestIdToken("YOUR_WEB_API_ID.apps.googleusercontent.com")
.build();
Vous devez utiliser:
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestScopes(new Scope(Scopes.PLUS_LOGIN))
.requestScopes(new Scope(Scopes.PLUS_ME))
.requestEmail()
.build();
Cela résout une erreur en renvoyant statusCode = INTERNAL_ERROR OR statusCode = Erreur 12501 OR statusCode = Erreur 12500. Cet objet gso peut ensuite être utilisé pour créer GoogleApiClient comme indiqué ci-dessous:
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();
Bien que de nombreuses réponses déjà votées existent dans cette question, j'ai eu du mal à comprendre la logique. Donc, je viens avec mes recherches.
- Créez une application en utilisant le nom de package correct et l'empreinte digitale du certificat de signature SHA-1 https://developers.google.com/mobile/add?platform=Android&cntapi=signin
- Activer la connexion google
- Générez le fichier de configuration.
Pour obtenir SHA-1, lancez ceci dans le terminal:
keytool -exportcert -keystore path-to-debug-or-production-keystore -list -v
À propos de OAuth 2.0 client IDs
- OAuth pour le Web (dans l'application, il est utilisé comme
server_client_id) - OAuth pour Android (Il doit être créé à l'aide du nom de package correct et de l'empreinte du certificat de signature SHA-1 ).
Si vous utilisez le magasin de clés différent pour le débogage et la publication, vous devez créer un
OAuth 2.0 client IDsséparé en utilisant le nom de package correspondant et SHA-1 .
Vous pouvez créer ou modifier votre OAuth 2.0 client IDs ici https://console.developers.google.com/apis/credentials?project=
- Accédez à votre application.
- Si vous avez déjà un OAuth pour Android, cliquez sur son nom et vérifiez le nom du package et SHA-1 .
Nous pouvons utiliser le même magasin de clés pour le débogage et la publication en enregistrant les détails dans le fichier global (local, pas à l'intérieur du projet) gradle.properties et le placer dans build.gradle comme ci-dessous.
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
// ...
}
}
}
Vous pouvez utiliser l'extrait ci-dessous
@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());
}
}
}
Remarque: Si vous avez uniquement activé Google Sign-In lors de la génération du fichier de configuration, vous n'avez pas besoin d'ajouter le fichier
google-servies.jsondans votre projet (la génération du fichier effectue les étapes de configuration nécessaires).
J'ai le même problème aussi, a été résolu comme suit:
On m'a fait supprimer le SHA1 précédemment pensé et créer et définir un nouveau SHA1.
générer un nouveau
google-services.jsonet le définir dans mon répertoire d'applicationJ'utilisais exactement codes de développeur Google
my
result.isSucces()a renvoyé la valeur true après l'exécution du projet
en tant que résumé, supprimez l'ancien sha1, créez-en un nouveau et téléchargez le nouveau fichier google-services.json
Essayez de suivre ces étapes:
Clonez le projet suivant https://github.com/googlesamples/google-services
Suivez le guide à l'adresse https://developers.google.com/identity/sign-in/Android/start .
Utilisez le client Web (créé automatiquement par Google Service) et ajoutez-le dans requestIdToken (...)
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN) .requestEmail() .requestIdToken("YOUR_WEB_API_ID.apps.googleusercontent.com") .build();Assurez-vous que vous utilisez le même fichier de clés que celui utilisé dans le projet Google. Par exemple, si vous avez utilisé la commande suivante pour générer la clé SHA-1
keytool -exportcert -list -v -alias androiddebugkey -keystore ~/.Android/debug.keystoreAjoutez ensuite le code suivant dans le fichier app/build.gradle dans Android {...} [résolu mon problème]
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 } }
Remarque: Votre keyPassword et keyAlias doivent être identiques à ceux utilisés lors de la génération du certificat SHA-1.
En voici un nouveau. J'essayais pendant 6 heures de me connecter à l'émulateur avec l'identifiant de mon domaine d'entreprise Google Apps, mais en vain, j'avais 12501 erreurs. Sur un pressentiment, j'ai essayé mon identifiant personnel gmail et cela a fonctionné. Idem si j'ai essayé sur mon téléphone avec mon identifiant d'entreprise. Il s'avère que l'émulateur ne disposait pas des paramètres de gestion des appareils mobiles appropriés pour permettre à mon identifiant d'entreprise de se connecter.
Donc, si je veux tester l'émulateur avec cet identifiant d'entreprise, je dois installer Google Play Store, puis le logiciel MDM, et le configurer.
Depuis que l'application demande à Google de se connecter à partir de la vue Web, nous devons créer une application Web avec l'authentification du client v2.0.
Accédez à informations d'identification Google API
Choisissez votre projet Android dans le coin supérieur gauche.
Cliquez sur Créer les informations d'identification -> OAuth ID client -> Choisir une application Web.
Cliquez sur OK
Maintenant, si vous avez synchronisé Android Studio avec Firebase (connecté), reconstruisez simplement le projet. Sinon, téléchargez Mise à jour google-services.json déposer et remplacer celui existant.
Cela devrait bien fonctionner.
1.Spécifiez la signatureConfigs dans votre fichier gradle
signingConfigs {
config {
keyAlias 'appalias'
keyPassword 'hunter123'
storePassword 'hunter123'
storeFile file('path/to/keystore.jks')
}
}
2.Allez créer des types dans la structure de projet (dans Android Studio) et spécifiez signatureConfigs sur "config"
Maintenant propre votre projet et construisez à nouveau. Ça devrait marcher.
Si ce qui précède ne fonctionne pas, votre adresse ci-dessous est votre dernier recours.
Essayez la première étape, construisez et vérifiez. Si cela ne fonctionne pas, passez à l'étape suivante et essayez de reconstruire.
- Construire un apk signé (avec souvenir mot de passe vérifié).
- Avant de signer, vérifiez le nom du fichier de stockage de clés et celui que vous cédez lors de la signature de l'apk (dans le studio Android).
- Installez l'apk signé sur votre appareil.
- Attends cinq minutes.
- Essayez de chanter pour google. Si 12501 arrive encore, attendez encore cinq minutes. Tout en faisant cela, frappez gradle sync.
- Réessayer. Ça devrait marcher.
Je faisais face à la même erreur 12501 status. Cela est dû au décalage SHA-1 de la version APK et du débogage APK.
- Faites un APK signé. Pour signer un APK, choisissez le chemin existant du magasin de clés que vous avez utilisé pour créer SHA-1. par exemple.
/.Android/debug.keystore - Donnez alias-name: androiddebugkey
- storepass et keypass: Android.
D'après mon expérience étrange avec cette erreur, je peux dire que vous devez également essayer de redémarrer votre téléphone afin de vous en débarrasser :) J'ai été implémenté. Connexion Google à l'aide de comptes G Suite disposant d'une stratégie de périphérique attribuée via Google Admin. . Ainsi, lors de la première connexion, il fallait installer l'application Device Policy. Une fois que toutes les étapes ultérieures ont été terminées, l’erreur 12501 a été renvoyée. Au même moment, la même application fonctionnait bien sur d'autres téléphones. Donc, seul le redémarrage a aidé. Mais aidé
J'ai eu ce problème aussi, après avoir suivi les instructions de Google pour Signature automatique de votre application . Si vous utilisez cette méthode pour signer vos applications, vous devez inclure l'empreinte digitale du fichier de clés générée dans vos informations d'identification d'API.
Dans le navigateur du projet, cliquez avec le bouton droit de la souris sur votre application et sélectionnez Ouvrir les paramètres du module.
J'ai trouvé moins déroutant de placer le fichier .jks dans le répertoire _ de mon projet /app. Dans tous les cas, passez cette ligne dessus.
keytool -list -v -keystore /home/user/keystores/Android.jks
Vous serez invité à entrer un mot de passe. Pas sûr que ce soit le Key Password ou Store Password parce que les miens sont les mêmes. : |
La console va cracher un tas d'empreintes digitales de certificat. Prenez le SHA1 et insérez-le dans vos identifiants d'API à la console du développeur de Google API . Vous devrez l'entrer pour le Android client OAuth 2.0 client IDs même si vous n'utilisez pas réellement ce client_id dans votre application. Si vous utilisez d'autres API pour Android, insérez le même SHA1 dans les informations d'identification de clé appropriées sous API keys.
J'ai développé lib pour ajouter l'option Google SignIn dans votre application avec seulement quelques lignes de code. Essayez HiGoogle - Google SignIn Made Easy
Utilisez une application Web comme application_serveur_client pas Android. Passez-le dans le constructeur HiGoogle.