Comment obtenir le certificat d'empreinte digitale SHA-1 sur Android Studio pour le mode de débogage?

pour Mac, cela a fonctionné parfaitement:

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

la meilleure solution pour générer une clé SHA-1 pour Android est de Android Studio .

cliquez sur Gradle à l'extrême droite:

, Cliquez sur l'icône d'actualisation, et vous verrez le nom de l'application:

cliquez sur tâches - > Rapport - > Rapport De Signature :

trouver la clé SHA-1 sur la partie inférieure de la console:

[mise à Jour 2017]

Étape 1: sur le côté droit supérieur de studio Android cliquez sur L'option Gradle.

Étape 2:

-- cliquez sur Refresh (cliquez sur Refresh from Gradle Bar, vous verrez la liste des scripts de Gradle de votre projet)

-- cliquez sur votre Projet (Nom du Projet forme de Liste (racine))

-- cliquez sur Tâches

-- cliquez sur Android

-- double clic sur signingReport (vous obtiendrez SHA1 et MD5 dans la Console Gradle / barre D'exécution)

Étape 3: Cliquez sur L'option Gradle Console pour voir votre clé SHA1.

Étape 4: Maintenant vous avez la clé SHA mais vous ne pouvez pas exécuter votre projet.C'est pourquoi changez votre configuration en mode app. Voir l'image ci-dessous.

comme ça.

Étape 5: Happy Coding!!

je vais avec la réponse de @Hiren Patel mais un peu de changement dans android studio 2.2

Pour Linux

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

j'ai directement utilisé la commande suivante de mon Mac en utilisant le terminal. J'ai le doigt de SHA1. C'est la commande:

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

Pour obtenir SHA1 pour une production keystore:

1. Build --> Generate Signed APK...

2. créer keystore avec mot de passe et suivre les étapes

3. allez à votre Mac/Library/Java/JavaVirtualMachines/jdk1.8.0_20.jdk/Contents/Home / bin et faites glisser le dossier bin vers le terminal après la commande de cd pour le pointer vers lui afin que vous puissiez utiliser l'outil keytool. Donc, dans terminal écrivez cd (drag bin ici) puis appuyez sur Entrée.

4. alors, copiez et collez ceci dans le terminal:

   keytool -exportcert -alias Your_keystore_AliasName -keystore /Users/Home/Development/AndroidStudioProjects/YoutubeApp/app/YoutubeApp_keystore.jks -list -v
   

   effacer mon chemin et aller où vous avez stocké votre keystore et faire glisser votre keystone et le laisser tomber après -keystore dans la ligne de commande de sorte que le chemin sera créé.

   aussi, effacez Votre_keystore_aliasename pour mettre votre nom d'alias keystone que vous avez utilisé lorsque vous l'avez créé.

5. appuyez sur entrez et entrez le mot de passe:)

6. lorsque vous entrez le mot de passe, le terminal ne montrera pas qu'il reçoit des entrées clavier, mais il le fait, donc mettez le mot de passe et appuyez sur entrer même si vous ne voyez pas le mot de passe est tapé.

c'est très facile dans Gnu/Linux - Mac - Windows

First: - copiez cette commande

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

Second: maintenant copier et coller la commande dans le terminal L'Android Studio

Résultat!

Bonne Chance!!

si vous utilisez Android Studio, vous pouvez obtenir le certificat SHA-1 et MD5 fingerprint (debug, release... tous les types de construction !! rapide par le biais de Gradle Tâches :

signingReport

les certificats SHA-1 et MD5 sont affichés dans Messages Logs .

Plugin Android (configuré dans le Gradle app) crée un mode de débogage par défaut.

com.Android.application

Fichier d'itinéraire à keystore:

HOME/.android/debug.keystore

je recommande à d'attacher debug.keystore à build.gradle . Pour ce faire, mettez un fichier, debug.keystore , dans un dossier app et ajoutez SigningConfigs dans Gradle app:

apply plugin: 'com.android.application'

    android {
        ................
        signingConfigs {
            debug {
                storeFile file("../app/debug.keystore")
                storePassword "android"
                keyAlias "androiddebugkey"
                keyPassword "android"
            }
            release {
                storeFile file("../app/debug.keystore")
                storePassword "android"
                keyAlias "androiddebugkey"
                keyPassword "android"
            }
        }
        ........
    }

Extra: si vous voulez crée pour la libération, mettre un fichier release.keystore , dans un dossier app. (Cet exemple utilise le même debug.keystore .)

Si vous avez Android Studio , alors il est très très simple. Il suffit de créer une Mapactivité en utilisant Android Studio et après la création allez dans google_maps_api.XML. Là il y aura un lien donné dans les commentaires. Si vous le collez dans votre navigateur, il vous demandera quelques détails à remplir et ensuite votre API sera générée. Il n'est pas nécessaire d'utiliser keytool et tout.

capture d'Écran:

1. cliquez sur L'icône Gradle dans le panneau droit.
2. cliquez sur le nom du projet Root.
3. , Cliquez Sur Tâches
4. Cliquez Sur Android
5. Cliquez sur signingReport
6. dans la partie inférieure où vous voyez le rapport de course
7. , Cliquez sur "activer / désactiver les Tâches Execytions/mode texte"
8. vous pouvez voir le sha-1

Pour Windows 10 , de la Android Studio terminal:

keytool -exportcert -alias androiddebugkey -keystore %USER_PROFILE%"/.android/debug.keystore -list -v

Note: pour le debug.keystore , le mot de passe est"android". Le keystore de débogage est typiquement situé à "%USER_PROFILE%"/.android/debug.keystore .

je veux ajouter une chose à la réponse donnée par Softcoder . J'ai vu que certaines personnes ne pouvaient pas donner leur .keystore chemin correctement sur le command line . Ils voient qu'ils font exactement le processus accepté ci-dessus, mais cela ne fonctionne pas. À ce point, essayez de faire glisser le débogage.keystore et jetez-le sur la ligne de commande. Cela aidera si la réponse acceptée ne fonctionne pas pour vous. Faites tout le processus sans hésitation. C'était un belle réponse.

utiliser la commande simple:

keytool -exportcert -keystore chemin-de-debug-ou-production-keystore -liste -v

et vous obtiendrez la clé SHA1.

j'ai trouvé un processus très facile pour vous trouver MD5, empreinte SHA-1 en utilisant Android Studio.

1. Exécuter votre projet
2. Aller à Gradle Menu (Menu: Affichage -> Outil -> Gradle)
3. allez à 'signingReport' dans Gradle window. (Votre projet -> tâches -> android -> signingReport)
4. lancez-le. (En double-clic ou Ctrl + Shift + F10)
5. Dans La Course fenêtre vous trouverez toutes les informations.

cela ne fonctionne que pour le mode de débogage. En mode réel, Je ne vois pas sha-1. Ici le résultat de gradlew signingReport

Variant: release
Config: none
----------
Variant: releaseUnitTest
Config: none
----------
Variant: debug
Config: debug
Store: path\Android\avd\.android\debug.keystore
Alias: AndroidDebugKey
MD5: xx:xx:xx:62:86:B7:9C:BC:FB:AD:C8:C6:64:69:xx:xx
SHA1: xx:xx:xx:xx:0F:B0:82:86:1D:14:0D:AF:67:99:58:1A:01:xx:xx:xx
Valid until: Friday, July 19, 2047
----------

donc je dois utiliser keytool pour obtenir sha-1. Ici la base officielle doc:

Get_sha-1_for_release

cela a fonctionné dans mon cas: utilisez %USERPROFILE% au lieu de donner le chemin .fichier keystore stocké dans ce chemin automatiquement C:Users/user nom/.android :

keytool -list -v -keystore "%USERPROFILE%\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android

cliquez sur l'icône Gradle sur le panneau droit, puis cliquez sur le (root).

tâches > android > signingReport

alors le script Gradle s'exécutera, et vous verrez vos clés.

je le fais de cette façon:

Étape 1: Allez dans ce dossier

Sur Mac:/Users//.android /

sous Windows: C:\Documents et paramètres\.android\

Sur Linux: ~/.android /

Étape 2: Lancez cette ligne de commande:

keytool -list -v -keystore debug.keystore -storepass android

vous verrez la clé SHA-1.

utilisez les instructions du gestionnaire D'API en utilisant keytool:

obtenez le nom du paquet de votre AndroidManifest.fichier xml. Ensuite, utilisez la commande suivante pour obtenir l'empreinte:

keytool -list -v -keystore mystore.keystore

lors de la création d'un nouveau "projet Google Maps", dans Android Studio V 1.5.1, le dernier écran ouvre le fichier google_maps_api.xml et affiche l'écran avec les instructions suivantes:

ressources:

TODO: avant d'exécuter votre application, vous avez besoin d'une clé API Google Maps.

pour obtenir un, Suivez ce lien, suivez les instructions et appuyez sur "Créer" à la fin:

https://console.developers.google.com/flows/enableapi?apiid=maps_android_backend&keyType=CLIENT_SIDE_ANDROID&r = votre SHA-1 + votre nom de paquet

vous pouvez également ajouter vos justificatifs d'identité à une clé existante, en utilisant cette ligne:

VOTRE SHA-1:VOTRE NOM DE PAQUET

alternativement, suivre les instructions ici:

https://developers.google.com/maps/documentation/android/start#get-key

une fois que vous avez votre clé (elle commence par "AIza"), remplacez la chaîne "google_maps_key" dans ce fichier.

<string name="google_maps_key" templateMergeStrategy="preserve" translatable="false">YOUR GOOGLE MAPS KEY</string>

pour obtenir votre clé GOOGLE MAPS il suffit de couper et coller le lien URL donné dans votre navigateur et de suivre les instructions ci-dessus au moment de la création de la nouvelle application. Le SHA-1 et Package names sont déjà dans le lien donné, de sorte que vous n'avez pas besoin de les connaître. Ils seront cependant dans votre projet dans le fichier resources>Values>google_maps_api.xml qui est complété lorsque vous suivez les instructions sur la création du projet.

vous pouvez utiliser la commande suivante et changer AJAY SUNDRIYAL avec votre nom de système.C'est uniquement pour le débogage.fichier de stockage des clés.Cela fonctionne pour vous.

C:\Program Files\Java\jdk1.8.0_91\bin>keytool -list -v -keystore "c:\users\AJAY SUNDRIYAL\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android

cela a fonctionné pour moi:

keytool -exportcert -alias androiddebugkey -keystore

mettre chemin-à-debug-ou-production-keystore ici comme C:\users\youruser.android\debug.keystore -liste -v

assurez-vous que vous êtes déjà dans le répertoire Java\jdk*\bin dans une fenêtre de commande ou de terminal.

puis utilisez Android comme mot de passe.

parfois, les ressources web peuvent être trompeuses. Ce sont ceux qui fonctionnent:

• sha1 tutoriel D'empreintes digitales

• Démarrage Rapide Exemple d'application

le chemin du clavier est en guillemets. Il fonctionne très bien.

keytool -list -v -keystore "C:\Users\App innovation\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android

si vous avez besoin de SHA1 pour Google Maps , vous pouvez juste voir votre erreur se connecter dans LogCat .

aller au fichier > Structure du projet Sélectionnez 'app' ou' mobile 'peu importe le nom que vous avez donné à partir de'Modules' Choisissez l'onglet "Signature".

Vous pouvez ajouter un certificat en cliquant sur le bouton'+'.

la façon la plus facile d'obtenir l'empreinte digitale est de passer de l'application au rapport signé en cliquant sur le drop down et en cliquant sur build.

alors vous pourrez voir l'empreinte de sha1 dans le volet inférieur où vous verrez le rapport de débogage et la trace de la pile. N. B n'oubliez pas de revenir à l'application lorsque vous souhaitez exécuter votre application sur un périphérique ou un émulateur.

Simple, appelez cette méthode dans votre écran Splash: hash () et getCertificateSHA1Fingerprint (), puis les touches seraient visibles dans le log

private void hash() {


            PackageInfo info;
            try {

                info = getPackageManager().getPackageInfo(
                        this.getPackageName(), PackageManager.GET_SIGNATURES);

                for (android.content.pm.Signature signature : info.signatures) {
                    MessageDigest md;
                    md = MessageDigest.getInstance("SHA");
                    md.update(signature.toByteArray());
                    Log.e("sagar sha key", md.toString());
                    String something = new String(Base64.encode(md.digest(), 0));
                    Log.e("sagar Hash key", something);
                    System.out.println("Hash key" + something);
                }

            } catch (PackageManager.NameNotFoundException e1) {
                Log.e("name not found", e1.toString());
            } catch (NoSuchAlgorithmException e) {
                Log.e("no such an algorithm", e.toString());
            } catch (Exception e) {
                Log.e("exception", e.toString());
            }
        }

        private void getCertificateSHA1Fingerprint() {
            PackageManager pm = this.getPackageManager();
            String packageName = this.getPackageName();
            int flags = PackageManager.GET_SIGNATURES;
            PackageInfo packageInfo = null;
            try {
                packageInfo = pm.getPackageInfo(packageName, flags);
            } catch (PackageManager.NameNotFoundException e) {
                e.printStackTrace();
            }
            Signature[] signatures = packageInfo.signatures;
            byte[] cert = signatures[0].toByteArray();
            InputStream input = new ByteArrayInputStream(cert);
            CertificateFactory cf = null;
            try {
                cf = CertificateFactory.getInstance("X509");
            } catch (CertificateException e) {
                e.printStackTrace();
            }
            X509Certificate c = null;
            try {
                c = (X509Certificate) cf.generateCertificate(input);
            } catch (CertificateException e) {
                e.printStackTrace();
            }
            String hexString = "";
            try {
                MessageDigest md = MessageDigest.getInstance("SHA1");
                byte[] publicKey = md.digest(c.getEncoded());
                Log.e("sagar SHA",byte2HexFormatted(publicKey));
            } catch (NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            } catch (CertificateEncodingException e) {
                e.printStackTrace();
            }
        }

        public static String byte2HexFormatted(byte[] arr) {
            StringBuilder str = new StringBuilder(arr.length * 2);
            for (int i = 0; i < arr.length; i++) {
                String h = Integer.toHexString(arr[i]);
                int l = h.length();
                if (l == 1) h = "0" + h;
                if (l > 2) h = h.substring(l - 2, l);
                str.append(h.toUpperCase());
                if (i < (arr.length - 1)) str.append(':');
            }
            return str.toString();
        }

Merci.