Come ottenere il certificato di impronte digitali SHA-1 in Android Studio per la modalità debug?

Mi sono spostato da Eclipse ad Android Studio . Ora sto cercando di lavorare sulla mia app Map. Quindi ho bisogno del mio numero di certificato dell'impronta digitale SHA-1.

Quando stavo usando Eclipse era proprio sotto Windows -> Preferenze -> Android -> Build . Ma in Android Studio non sono riuscito a trovare alcuna opzione come questa in modo da poter trovare facilmente l'impronta digitale. Sto usando Windows. Ho letto da questo link che:

Android Studio firma automaticamente la tua app in modalità debug quando esegui o esegui il debug del tuo progetto dall'IDE.

Quindi ho provato a eseguirlo nella riga di comando dopo aver impostato il percorso del mio bin Java da questo link e purtroppo non sono riuscito a trovare la mia impronta digitale. Sta dicendo che è un'opzione illegale .

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

C'è un modo per trovare l'impronta digitale SHA-1 da Android Studio come è stato molto facile in Eclipse? Dato che sono un principiante in Android Studio, qual è il processo completo per trovarlo?

Un'altra cosa che voglio aggiungere è che il mio Eclipse genera l'impronta digitale SHA-1 e in precedenza ho registrato la mia app su quell'impronta digitale nella console per sviluppatori di Google, e ho lavorato su quell'app in Eclipse con quella chiave API. È possibile utilizzare la stessa chiave API su questo mio progetto in Android Studio?

I modi più semplici di sempre:

Aggiornamento aggiunto per Android Studio V 2.2 nell'ultimo passaggio

Ci sono due modi per farlo.

1. Modo più veloce :

1. Apri Android Studio
2. Apri il tuo progetto
3. Fai clic su Gradle (dal pannello laterale destro, vedrai la barra del Gradle )
4. Fai clic su Aggiorna ( fai clic su Aggiorna dalla barra dei gradi , vedrai gli script Elenco dei gradi del tuo progetto)
5. Fai clic su Il tuo progetto ( Elenco dei moduli del nome del tuo progetto (root))
6. Fai clic su Attività
7. Clicca su Android
8. Fai doppio clic su SignReport (otterrai SHA1 e MD5 in Run Bar (a volte sarà in Gradle Console))
9. Seleziona il modulo dell'app dal menu a discesa di selezione del modulo per eseguire o eseguire il debug dell'applicazione

Controlla lo screenshot qui sotto:

2. Lavora con l'attività di Google Maps :

1. Apri Android Studio
2. Apri il tuo progetto
3. Fai clic sul menu File -> Seleziona nuovo -> Fai clic su Google -> Seleziona attività di Google Maps
4. Apparirà una finestra di dialogo -> Fare clic su Fine
5. Android Studio genererebbe automaticamente un file XML denominato congoogle_maps_api.xml
6. Qui otterresti la chiave di debug SHA1 (alla riga numero 10 del file XML)

Controlla la schermata qui sotto:

Aggiornamento di Android Studio V 2.2

Si è verificato un problema con Execution .

Soluzione:

• Fare clic su Attiva / disattiva esecuzione / modalità testo dalla barra Esegui

Controlla la schermata qui sotto:

Fatto.

Il mio problema è lo stesso in cui ho spostato il mio progetto Google Maps da Eclipse ad Android Studio . Ho risolto il mio problema seguendo questo:

Vai alla tua directory bin Java tramite il comando:

C:\Program Files\Java\jdk1.7.0_71\bin>

Ora digita il comando seguente nella finestra dei comandi (CMD.EXE):

keytool -list -v -keystore c:\users\your_user_name\.android\debug.keystore -alias androiddebugkey -storepass android -keypass android

Esempio:

keytool -list -v -keystore c:\users\James\.android\debug.keystore -alias androiddebugkey -storepass android -keypass android

Oppure puoi semplicemente scrivere questo in cmd se non conosci il nome utente:

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

E otterrai SHA1.

Quindi ho creato una nuova chiave da https://code.google.com/apis/console perché il nome del mio pacchetto è stato modificato e quindi utilizzo questa chiave nella mia applicazione. Funziona bene

Assicurati di trovarti nella cartella BIN di jdkX.X.X_XX (il mio nome di cartella è jdk1.7.0_71) , oppure se non sai quale nome di cartella hai allora trovalo aprendo la cartella Java e vedrai qual è il nome della cartella, ma è necessario trovarsi nella cartella BIN e quindi eseguire questo comando. Oggi ho ottenuto il mio valore SHA1 in una finestra di comando cmd con la procedura sopra.

ISTANTANEA:

Per Mac, ha funzionato perfettamente:

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

Ho appena trovato il caso per ottenere SHA-1 in Android Studio:

1. Fai clic sul pacchetto e scegli Nuovo -> Google -> Attività di Google Maps
2. Android Studio ti reindirizza a google_maps_api.xml

E vedrai tutto ciò che ti serve per ottenere google_maps_key.

La migliore soluzione per generare una chiave SHA-1 per Android è Android Studio .

Fai clic su Gradle all'estrema destra:

Fai clic sull'icona di aggiornamento e vedrai il nome dell'app:

Fai clic su Attività -> Rapporto -> Rapporto firma :

Trova la chiave SHA-1 nella parte inferiore della console:

[Aggiornato 2017]

Passaggio 1: in alto a destra di Android Studio Fai clic sull'opzione Gradle.

Passo 2:

- Fai clic su Aggiorna (fai clic su Aggiorna dalla barra dei gradi, vedrai gli elenchi degli script dei gradi del tuo progetto)

- Fai clic su Il tuo progetto (Elenco dei moduli del nome del tuo progetto (radice))

- Fai clic su Attività

- Fai clic su Android

- Fai doppio clic su SignReport (otterrai SHA1 e MD5 in Gradle Console / Run Bar)

Passaggio 3: fare clic sull'opzione Gradle Console presente nella parte inferiore di Android Studio per visualizzare la chiave SHA1.

Passaggio 4: ora hai la chiave SHA ma non puoi eseguire il tuo progetto. Ecco perché cambia la configurazione in modalità app. Vedi l'immagine sotto.

Come questo.

Passaggio 5: Happy Coding !!

vado con la risposta di @Hiren Patel ma cambio leggermente in Android Studio 2.2

Per Linux e Mac

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

1. Fai clic sull'icona Gradle nel riquadro destro.
2. Fare clic sul nome del progetto principale.
3. Fai clic su Attività
4. Fai clic su Android
5. Fai clic su Firma Segnala
6. nel riquadro inferiore in cui è visualizzato il rapporto Esegui
7. Fai clic su "Attiva / disattiva attività / modalità testo"
8. puoi vedere lo sha-1

Ho fatto così:

Passaggio 1: vai a questa cartella

On Mac: /Users/<username>/.android/

On Windows: C:\Documents and Settings\<username>\.android\

On Linux: ~/.android/

Passaggio 2: eseguire questa riga di comando:

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

Vedrai il tasto SHA-1.

Ho usato direttamente il seguente comando dal mio Mac usando il terminale. Ho SHA1 Finger. Questo è il comando:

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

Per ottenere SHA1 per un keystore di produzione:

1. Build -> Genera APK firmato ...

2. Crea keystore con password e segui i passaggi

3. Vai al tuo Mac / Libreria / Java / JavaVirtualMachines / jdk1.8.0_20.jdk / Sommario / Home / bin e trascina la cartella bin sul terminale dopo il comando cd per puntarlo in modo da poter utilizzare lo strumento keytool. Quindi, nel terminale scrivi cd(trascina il cestino qui) quindi premi invio.

4. Quindi, copia e incolla questo nel terminale:

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

   Cancella il mio percorso e vai dove hai memorizzato il tuo keystore e trascina la chiave di volta e rilasciala dopo -keystorenella riga di comando in modo che il percorso venga creato.

   Inoltre, cancella Your_keystore_AliaseName per inserire il nome keystone alias che hai utilizzato durante la creazione.

5. Premi Entere inserisci la password :)

6. Quando inserisci la password, il terminale non mostrerà che riceve le voci della tastiera, ma in realtà lo fa, quindi inserisci la password e premi Enteranche se non vedi che la password è stata digitata.

È molto molto semplice in Gnu / Linux - Mac - Windows

Primo: - copia questo comando

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

Secondo: Ora copia e incolla il comando nel terminale Android Studio

Risultato!

In bocca al lupo!!

Se stai utilizzando Android Studio, puoi ottenere rapidamente l' impronta digitale del certificato SHA-1 e MD5 (debug, rilascio ... tutti i tipi di build !!) tramite le attività Gradle :

signingReport

I certificati SHA-1 e MD5 sono mostrati nei registri dei messaggi .

Il plug-in Android (configurato nell'app Gradle) crea una modalità di debug per impostazione predefinita.

com.android.application

Percorso del file al keystore:

HOME/.android/debug.keystore

Consiglio di collegarmi debug.keystore a build.gradle. Per fare ciò inserisci un file, debug.keystorein una cartella dell'app e quindi Aggiungi SigningConfigs nell'app Gradle :

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: se si desidera creare per il rilascio, inserire un file release.keystore, in una cartella dell'app. (Questo esempio usa lo stesso debug.keystore.)

Se hai Android Studio , è molto semplice. Basta creare un MapActivity usando Android Studio e dopo averlo creato, vai su google_maps_api.xml. Lì ci sarà un link fornito nei commenti. Se lo incolli nel tuo browser, ti verranno richiesti alcuni dettagli e successivamente verrà generata la tua API. Non è necessario utilizzare keytool e tutto il resto.

Immagine dello schermo:

Questo ha funzionato nel mio caso: Usa % USERPROFILE% invece di fornire automaticamente il percorso .keystore file memorizzato in questo percorso C: Utenti / nome utente / .android :

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

Usa un comando semplice:

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

e otterrai la chiave SHA1.

Per Windows 10 , dal terminale Android Studio :

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

Nota: per la debug.keystorepassword è "android". Il keystore di debug si trova in genere all'indirizzo "%USER_PROFILE%"/.android/debug.keystore.

Voglio aggiungere una cosa con la risposta data da Softcoder . Ho visto alcune persone non riuscire a dare il loro percorso debug.keystore correttamente sul command line. Vedono che stanno facendo l'esatto processo accettato sopra, ma non funziona. A quel punto prova a trascinare debug.keystore e rilascialo dalla riga di comando. Aiuterà se la risposta accettata non funziona per te. Fai l'intero processo senza alcuna esitazione. È stata una bella risposta

Ho trovato un processo molto semplice per trovare MD5, SHA-1 fingerprint utilizzando Android Studio.

1. Esegui il tuo progetto
2. Vai al menu Gradle (Menu: Visualizza -> Finestre degli strumenti -> Gradle)
3. Vai a 'signingReport' nella finestra Gradle. (Il tuo progetto -> Attività -> android -> signingReport)
4. Eseguirlo. (Usando il doppio clic o Ctrl + Maiusc + F10)
5. Nella finestra Esegui troverai tutte le informazioni.

Funziona solo per la modalità debug. In modalità realease non riesco a vedere sha-1. Qui risultato digradlew 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
----------

Quindi devo usare keytool per ottenere sha-1. Ecco il documento ufficiale di Firebase:

Get_sha-1_for_release

Fai clic sull'icona Gradle nel pannello di destra, quindi fai clic su (radice).

Attività> android> signingReport

Quindi verrà eseguito lo script Gradle e vedrai le tue chiavi.

Semplice, chiama questo metodo nella schermata iniziale: hash () e getCertificateSHA1Fingerprint (), quindi le chiavi sarebbero visibili nel registro

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();
        }

Grazie.

Utilizzare le istruzioni da Gestione API utilizzando keytool:

Ottieni il nome del pacchetto dal tuo file AndroidManifest.xml. Quindi utilizzare il comando seguente per ottenere l'impronta digitale:

keytool -list -v -keystore mystore.keystore

Puoi usare il comando seguente e cambiare AJAY SUNDRIYAL con il nome del tuo sistema. Questo è solo per il tuo debug.keystore. Funzionerà per te.

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

Questo ha funzionato per me:

keytool -exportcert -alias androiddebugkey -keystore

Inserisci qui il keystore path-to-debug-or-production-come C: \ users \ youruser.android \ debug.keystore -list -v

Assicurarsi di essere già nella Java\jdk*\bindirectory in una finestra di comando o terminale.

Quindi utilizzare Android come password.

A volte le risorse Web potrebbero essere fuorvianti. Questi sono quelli che funzionano:

• SHA1 Tutorial per le impronte digitali

• Esempio di app Quick Start

Il percorso del keystore è tra virgolette. Funziona benissimo.

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

Se hai bisogno di SHA1 per Google Maps , puoi semplicemente vedere il tuo log degli errori in LogCat .

Quando si crea un nuovo "Progetto Google Maps", in Android Studio V 1.5.1, l'ultima schermata apre il google_maps_api.xmlfile e visualizza la schermata con le istruzioni come segue:

risorse:

TODO: prima di eseguire l'applicazione, è necessaria una chiave API di Google Maps.

Per ottenerne uno, segui questo link, segui le indicazioni e premi "Crea" alla fine:

https://console.developers.google.com/flows/enableapi?apiid=maps_android_backend&keyType=CLIENT_SIDE_ANDROID&r= YOUR SHA-1 + IL TUO NOME DEL PACCHETTO

Puoi anche aggiungere le tue credenziali a una chiave esistente, usando questa riga:
IL TUO SHA-1: IL TUO NOME DEL PACCHETTO

In alternativa, seguire le indicazioni qui:
https://developers.google.com/maps/documentation/android/start#get-key

Una volta che hai la chiave (inizia con "AIza"), sostituisci la stringa "google_maps_key" in questo file.
<string name="google_maps_key" templateMergeStrategy="preserve" translatable="false">YOUR GOOGLE MAPS KEY</string>

Per ottenere il TUO TASTO MAPPE GOOGLE basta tagliare e incollare il collegamento URL fornito nel browser e seguire le istruzioni sopra al momento della creazione della nuova applicazione. I SHA-1e Package namessono già nel link indicato, quindi non è necessario conoscerli. Saranno comunque nel tuo progetto nel resources>Values>google_maps_api.xmlfile che viene completato quando segui le istruzioni per la creazione del progetto.

• Vai su File> Seleziona struttura progetto appo mobilequalunque sia il nome da cui hai dato il nomeModules

• Scegli la Signingscheda.

• È possibile aggiungere il certificato facendo clic sul +pulsante.

Il modo più semplice per ottenere l'impronta digitale è passare dall'app al report firmato facendo clic sul menu a discesa e facendo clic su build.

Quindi sarai in grado di vedere l'impronta digitale sha1 nel riquadro in basso dove vedi il report di debug e la traccia dello stack. NB ricordarsi di tornare all'app quando si desidera eseguire l'app su un dispositivo o un emulatore.