Wie erstelle ich eine mit Release signierte Apk-Datei mit Gradle?

514

Ich möchte, dass mein Gradle erstellt wird, um mit Gradle eine von der Version signierte apk-Datei zu erstellen.

Ich bin nicht sicher, ob der Code korrekt ist oder ob mir dabei ein Parameter fehlt gradle build.

Dies ist ein Teil des Codes in meiner Gradle-Datei:

android {
    ...
    signingConfigs {
          release {
              storeFile file("release.keystore")
              storePassword "******"
              keyAlias "******"
              keyPassword "******"
         }
     }
}

Der Gradle-Build ist ERFOLGREICH und in meinem build/apkOrdner werden nur die Dateien ...-release-unsigned.apkund angezeigt ...-debug-unaligned.apk.

Irgendwelche Vorschläge, wie man das löst?

Jan-Terje Sørensen
quelle
mit v1 (jar Signatur) oder v2 (vollständige apk Signatur) Version aus der Gradle-Datei signieren? Lösung hier: stackoverflow.com/questions/57943259/…
user1506104

Antworten:

429

Einfacher als bisherige Antworten:

Setzen Sie dies in ~/.gradle/gradle.properties

RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****

Ändern Sie Ihre app/build.gradleund fügen Sie diese in den android {Codeblock ein:

...    
signingConfigs {

   release {
       storeFile file(RELEASE_STORE_FILE)
       storePassword RELEASE_STORE_PASSWORD
       keyAlias RELEASE_KEY_ALIAS
       keyPassword RELEASE_KEY_PASSWORD

       // Optional, specify signing versions used
       v1SigningEnabled true
       v2SigningEnabled true
   }
}

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

Dann kannst du rennen gradle assembleRelease


Siehe auch die Referenz für das signingConfigsGradle DSL

David Vávra
quelle
12
Beste Methode, wenn Sie mich fragen. Speichert nichts in meinem Projektordner / SVN und ich kann 10 Versionen meiner Projekte auschecken, ohne mich um die Schlüssel kümmern zu müssen.
Frank
8
Wenn Sie gradlew unter Windows verwenden, müssen Sie sicherstellen, dass GRADLE_USER_HOME als Umgebungsvariable definiert ist, damit dies funktioniert. Ich habe es auf ein Verzeichnis über meinem Projektverzeichnis gesetzt und meinen Keystore dort abgelegt. Der Pfad zu Ihrem Keystore in gradle.properties sollte Schrägstriche (/) oder doppelte Backslashes (\\) verwenden, nicht einfache Windows-Backslashes. Informationen
Anachronist
3
Befindet sich der Pfad relativ zum Speicherort der Datei build.gradle oder relativ zum Stammverzeichnis des Computers?
Prem
1
@Prem, file()nimmt immer relative Pfade an. Verwenden new File(path)Sie diese Option, wenn Sie möchten, dass sie als absolut behandelt wird.
Ars-Longa-Vita-Brevis
4
Das hat bei mir funktioniert und am einfachsten. Geben Sie in den gradle.properties storeFile relativ zu Ihrem Modul build.gradle wie folgt an: RELEASE_STORE_FILE = .. / mykeystore. Fügen Sie keine Zitate hinzu, sonst verstümmelt gradle den Weg
Lakshman Chilukuri
263

Ich habe es geschafft, das Problem zu lösen, indem ich diesen Code hinzugefügt und mit gradle buildfolgenden Elementen erstellt habe :

android {
    ...
    signingConfigs {
        release {
            storeFile file("release.keystore")
            storePassword "******"
            keyAlias "******"
            keyPassword "******"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Dies generiert eine signierte Release-Apk-Datei.

Jan-Terje Sørensen
quelle
33
Gibt es eine Möglichkeit, mich zur Eingabe der Passwörter aufzufordern? Oder andere Vorschläge, um Passwörter aus meinen Git-Repos herauszuhalten?
user672009
3
Ich bearbeite mein build.gradle so, dass es wie deins aussieht, aber wenn ich "Built> Generate signed APK ..." ausführe, wird mein Dialogfeld ("Weitere Informationen finden Sie im Gradle-Benutzerhandbuch." Usw.) und kein APK angezeigt.
Semanticer
3
@ Semanticer Execute gradle buildoder gradlew buildim Terminal / Prompt-Befehl
Phillip Kamikaze
12
@ user672009 Sie können Kennwörter in eine Eigenschaftendatei einfügen und mit .gitignore von Repos ausschließen. Sie können diesen Link sehen. gist.github.com/gabrielemariotti/6856974
Gabriele Mariotti
1
@GabrieleMariotti Damit bleibt noch ein unvollständiges Repository. Ein besserer Weg wäre, ein Skelett zu erstellen. Dies verhindert jedoch, dass Futura-Änderungen festgeschrieben werden. So etwas wie die erste Option, die sdqali vorschlägt, scheint noch besser zu sein.
user672009
67

Beachten Sie, dass das Skript von @ sdqali (zumindest bei Verwendung von Gradle 1.6) jedes Mal nach dem Kennwort fragt, wenn Sie eine Gradle-Aufgabe aufrufen. Da Sie es nur benötigen, wenn Sie es tun gradle assembleRelease(oder ähnliches), können Sie den folgenden Trick verwenden:

android {
    ...
    signingConfigs {
        release {
            // We can leave these in environment variables
            storeFile file(System.getenv("KEYSTORE"))
            keyAlias System.getenv("KEY_ALIAS")

            // These two lines make gradle believe that the signingConfigs
            // section is complete. Without them, tasks like installRelease
            // will not be available!
            storePassword "notYourRealPassword"
            keyPassword "notYourRealPassword"
        }
    }
    ...
}

task askForPasswords << {
    // Must create String because System.readPassword() returns char[]
    // (and assigning that below fails silently)
    def storePw = new String(System.console().readPassword("Keystore password: "))
    def keyPw  = new String(System.console().readPassword("Key password: "))

    android.signingConfigs.release.storePassword = storePw
    android.signingConfigs.release.keyPassword = keyPw
}

tasks.whenTaskAdded { theTask -> 
    if (theTask.name.equals("packageRelease")) {
        theTask.dependsOn "askForPasswords"
    }
}

Beachten Sie, dass ich auch Folgendes hinzufügen musste (unter Android), damit es funktioniert:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}
jclehner
quelle
Nach der Implementierung installReleaseverschwand aus der Liste der Aufgaben ... Warum?
Kaarel
1
@caspase Ich wünschte, ich hätte Ihren Kommentar zu diesem gefälschten "storePassword" und "keyPassword" ernster genommen. Ohne diese Eigenschaften zu initialisieren ("" zum Beispiel), wird die signierte * -release.apk nicht erstellt, es wird kein Fehler angezeigt und Sie sind nur mit der * -release-unsigned.apk in Ihrem PROJECT_NAME / build / apk / -Verzeichnis völlig verwirrt . Mann ...: /
vizZ
Vielen Dank für den Hinweis zum Hinzufügen von signingConfig unter buildTypes -> Release. Das löste das automatische Signieren für mich!
mm2001
1
Ich habe ein einfaches Gradle-Plugin erstellt, das beim Erstellen von Release-Apk nach Passwörtern fragt (mit der in diesem Beitrag beschriebenen Mathematik, aber Sie müssen kein falsches storePassword & keyPassword definieren). Es ist auch in Maven Central erhältlich. github.com/alexvasilkov/AndroidGradleSignPlugin
Alex Vasilkov
Das ist toll. Beachten Sie, dass die Umgebungsvariable KEYSTOREauch für Debug-Builds und für die "Gradle-Synchronisierung" in Android Studio definiert werden muss. Andernfalls wird ein Fehler angezeigt, dass der Pfad null ist.
Jerry101
63

Wenn Sie vermeiden möchten, dass Ihr Schlüsselspeicher und Ihr Kennwort fest codiert werden build.gradle fest codiert werden , können Sie eine Eigenschaftendatei verwenden, wie hier erläutert: HANDHABUNG VON SIGNIERKONFIGEN MIT GRADLE

Grundsätzlich:

1) Erstellen Sie eine Datei myproject.properties unter /home/[username‹/.signing mit folgenden Inhalten:

keystore=[path to]\release.keystore
keystore.password=*********
keyAlias=***********
keyPassword=********

2) Erstellen Sie eine gradle.properties-Datei (möglicherweise im Stammverzeichnis Ihres Projektverzeichnisses) mit dem Inhalt:

MyProject.properties=/home/[username]/.signing/myproject.properties

3) beziehen Sie sich in Ihrem build.gradle wie folgt darauf:

    if(project.hasProperty("MyProject.properties")
        && new File(project.property("MyProject.properties")).exists()) {

    Properties props = new Properties()
    props.load(new FileInputStream(file(project.property("MyProject.properties"))))

    signingConfigs {
        release {
            storeFile file(props['keystore'])
            storePassword props['keystore.password']
            keyAlias props['keyAlias']
            keyPassword props['keyPassword']
        }
    }
}
IgorGanapolsky
quelle
1
Funktioniert super! Vielen Dank. Dieser Code muss vor dem Abschnitt buildTypes {} hinzugefügt werden, und der Abschnitt muss die SigningConfig-SignaturConfigs.release als normal deklarieren.
Theczechsensation
Endlich habe ich eine Lösung für dieses Problem gefunden. Das einzige was mir wirklich geholfen hat! Dies sollte die akzeptierte Antwort sein ...
devnull69
39

Automatische App-Signatur mit Gradle bei Verwendung von Git

Es ist erstaunlich, wie viele verschlungene Möglichkeiten es dafür gibt. Hier ist mein eigener Weg, auf dem ich versuche, mich an Googles eigene Empfehlung zu halten . Ihre Erklärung ist jedoch nicht ganz klar, daher werde ich das Verfahren für Linux im Detail beschreiben.


Beschreibung:

Die Standardanweisungen von Google zum automatischen Signieren einer App während des Builds, ohne die Kennwörter und Signaturdateien in Ihrem GIT-Pfad (App Development) zu behalten, sind eher unklar. Hier finden Sie eine schrittweise Anleitung dazu.

Anfangsannahmen:

Sie haben eine App namens "MyApp" in einem Verzeichnis, das über den folgenden Pfad angegeben ist : $HOME/projects/mydev/MyApp. Das MyApp-Verzeichnis wird jedoch mit GIT verwendet und gesteuert.

Geben Sie hier die Bildbeschreibung ein

Problem

Wir möchten natürlich nicht, dass sich unsere Signatur- oder Passwortdateien irgendwo im GIT-gesteuerten Verzeichnis befinden, auch wenn wir sehr gut in der Lage sind, diese zu verwenden .gitignore usw. können. Es ist immer noch zu riskant und leicht, einen Fehler zu machen. Wir wollen also unsere Keystore- und Signaturdateien draußen haben.

Lösung

Wir müssen drei (3) Dinge tun:

  1. Erstellen Sie eine Kennwortdatei, die von Android Studio verwendet werden soll
  2. Signaturschlüsseldatei erstellen
  3. Bearbeiten Sie die Moduldatei build.gradle, um (1) und (2) zu verwenden.

In diesem Beispiel nennen wir die beiden Dateien:

  1. keystore.properties
  2. MyApp-release-key.jks

Wir können diese beiden Dateien hier ablegen:

cd $HOME/projects/mydev/

(1) Erstellen Sie die Keystore-Kennwortdatei

Die erste Datei enthält die Klartextkennwörter, die in verwendet werden. und Pfade zur Release-Key-Datei in (2). Beginnen Sie mit dem Ausfüllen, da dies das Kopieren und Einfügen für den nächsten Schritt erleichtert.

cd $HOME/projects/mydev/

Bearbeiten Sie keystore.propertiesso, dass der Inhalt wie folgt lautet:

storePassword=myStorePassword
keyPassword=mykeyPassword
keyAlias=myKeyAlias
storeFile=myStoreFileLocation

Der einzige schwierige Teil hier ist der myStoreFileLocation. Dies ist der Pfad aus der Moduldatei build.gradlewährend des Builds. Dies bedeutet normalerweise einen Pfad ähnlich und relativ zu : $HOME/projects/mydev/MyApp/app/build.gradle. Um auf die MyApp-release-key.jks Datei zu verweisen, müssen wir hier Folgendes einfügen:

../../../MyApp-release-key.jks

Hier haben wir auch den Alias ​​"myapp" für den Schlüssel gewählt. Dann sollte die endgültige Datei aussehen:

storePassword=myStorePassword
keyPassword=mykeyPassword
keyAlias=myapp
storeFile=../../../MyApp-release-key.jks

(2) Erstellen Sie die Signaturdatei

Die zweite Datei wird automatisch generiert, wenn Sie den Signaturschlüssel erstellen. Wenn Sie keine anderen Apps haben und dies Ihr einziger Schlüsselspeicher ist, erstellen Sie die Datei mit:

cd $HOME/projects/mydev/
keytool -genkeypair -v -keystore MyApp-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias myapp

Hier werden Sie nach zwei Passwörtern und einer Reihe von Informationen gefragt. (Gleiches wie in Android Studio.) Kopieren Sie nun Ihre zuvor ausgewählten Passwörter und fügen Sie sie ein.

(3) Bearbeiten Sie Ihre Moduldatei gradle.build, um die oben genannten zu verwenden

Die folgenden Teile müssen in der Gradle-Build-Datei Ihrer App / Ihres Moduls vorhanden sein. Fügen Sie zunächst die folgenden Zeilen außerhalb und vor Ihrem android {}Block hinzu.

//def keystorePropertiesFile = rootProject.file("$HOME/.android/keystore.properties")
def keystorePropertiesFile = rootProject.file("../../keystore.properties")
def keystoreProperties = new Properties()
keystoreProperties.load(new FileInputStream(keystorePropertiesFile))

Fügen Sie dann innerhalb des android {}Blocks Folgendes hinzu:

android {
    ...
    defaultConfig { ... }
    signingConfigs {
            release {
                keyAlias keystoreProperties['keyAlias']
                keyPassword keystoreProperties['keyPassword']
                storeFile file(keystoreProperties['storeFile'])
                storePassword keystoreProperties['storePassword']
            }
        }
    // Tell Gradle to sign your APK
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

Jetzt können Sie aus der Shell heraus Ihre App neu erstellen mit:

cd $HOME/projects/mydev/MyApp/app/
./gradlew clean build

Dadurch sollte eine ordnungsgemäß signierte App generiert werden, die in Google Play verwendet werden kann.


UPDATE: 2019-04-02

Neuere Versionen von keytoolund etwas sagt Ihnen, dass Sie eine PKCS12- basierte Schlüsseldatei anstelle der Original- / Standard-Schlüsseldatei verwenden sollten, wie ich sie oben verwende. Sie gehen dann auf Sie zu sagen Sie das neue offenen PKCS12 - Format umwandeln sollten. Es scheint jedoch, dass die Android-Entwicklungstools noch nicht ganz dafür bereit sind, denn wenn Sie dies tun, werden die folgenden seltsamen Fehler angezeigt:

com.android.ide.common.signing.KeytoolException:Fehler beim Lesen des Schlüssels XXX aus dem Speicher "F: \ XXX \ XXX.jks": Schlüssel abrufen fehlgeschlagen: Der letzte Block wurde nicht ordnungsgemäß aufgefüllt. Solche Probleme können auftreten, wenn während der Entschlüsselung ein fehlerhafter Schlüssel verwendet wird.

Verwenden Sie also keinen konvertierten Schlüssel!

not2qubit
quelle
Werden signingConfigs in der apk gespeichert und können sie dann von jedem Benutzer dekompiliert werden, um Passwörter zu erhalten, oder werden sie nicht in der apk angezeigt?
JavierSegoviaCordoba
2
Funktioniert wie Charme. Vielen Dank, dies sollte die akzeptierte Antwort sein
Pratham Kesarkar
Was ist, wenn Sie nur den Schlüsselspeicher und die Kennwörter auf einem Build-Server haben möchten? Mit der obigen Lösung muss jeder Entwickler im Team den Keystore auf seinem lokalen Computer haben. Andernfalls schlägt die Synchronisierung des Gradle-Projekts fehl: keystore.properties (Keine solche Datei oder kein solches Verzeichnis).
Diana Farin
1
Sie können eine Dummy- keystore.propertiesDatei für die Quellcodeverwaltung festschreiben, um die Arbeit auf Entwicklungsmaschinen zu erstellen. Ich habe einen Build - Server - Setup beschrieben hier .
dskrvk
1
Ein Hinweis zu Ihrem letzten Update zum keytoolGenerieren eines PKCS12-Keystores: Sie können -storetype JKSden keytoolBefehl übergeben, um den Keystore-Typ auf JKS zu setzen, der vom Android- Tool benötigt wird.
Trevor Halvorson
35

Wie @Destil sagte, aber erlauben Sie anderen, die nicht den Schlüssel zum Bauen haben: Einfacher als frühere Antworten:

Setzen Sie dies in ~/.gradle/gradle.properties

RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****

Ändern Sie Ihre build.gradlewie folgt :

...    
if(project.hasProperty("RELEASE_STORE_FILE")) {
    signingConfigs {    
       release {
           storeFile file(RELEASE_STORE_FILE)
           storePassword RELEASE_STORE_PASSWORD
           keyAlias RELEASE_KEY_ALIAS
           keyPassword RELEASE_KEY_PASSWORD
       }
    }
}

buildTypes {
    if(project.hasProperty("RELEASE_STORE_FILE")) {
        release {
            signingConfig signingConfigs.release
        }
    }
}
....

Dann können Sie gradle assembleRelease OR ausführengradle build

Gal Bracha
quelle
So legen Sie den Pfad in Windows fest: Pfad zu Ihrem Keystore
reza_khalafi
storeFile-Datei ("C: \\ Benutzer \\ xxxx \\ Dokumente \\ JJJJ \\ mykey.jks") ist es richtig?
reza_khalafi
28

(Als Antwort auf user672009 oben.)

Eine noch einfachere Lösung, wenn Sie Ihre Passwörter aus einem Git-Repository heraushalten möchten. Wenn Sie jedoch Ihr build.gradle einbinden möchten, das auch mit Produktaromen hervorragend funktioniert, müssen Sie eine separate Gradle-Datei erstellen. Nennen wir es "signing.gradle" (fügen Sie es in Ihren .gitignore ein). Als wäre es Ihre build.gradle-Datei abzüglich aller Daten, die nicht mit der Anmeldung zusammenhängen.

android {
    signingConfigs { 
        flavor1 {
            storeFile file("..")
            storePassword ".."
            keyAlias ".."
            keyPassword ".."
        }
        flavor2 {
            storeFile file("..")
            storePassword ".."
            keyAlias ".."
            keyPassword ".."
        }
    }
}

Fügen Sie dann in Ihre build.gradle-Datei diese Zeile direkt unter "Plugin anwenden: 'android'" ein.

 apply from: 'signing.gradle'

Wenn Sie nicht über mehrere Geschmacksrichtungen verfügen oder diese verwenden, benennen Sie "flavour1" in "release" um, und Sie sollten fertig sein. Wenn Sie Aromen verwenden, fahren Sie fort.

Verknüpfen Sie schließlich Ihre Geschmacksrichtungen mit der richtigen Signaturkonfiguration in Ihrer build.gradle-Datei, und Sie sollten fertig sein.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...
Jonbo
quelle
Können Sie etwas genauer sein? Ich kann es nicht zum Laufen bringen: "Symbol SigningConfig kann nicht aufgelöst werden".
Amio.io
Wenn ich 'signating.gradle' in das build.gradle einbinde, muss ich eines im Git-Repository haben (andernfalls erhalte ich die Fehlermeldung 'signing.gradle existiert nicht'). Und wenn ich das 'signating.gradle' in git setze, macht es den Zweck zunichte. Wie kann ich die Aufnahme von signing.gradle optional machen?
Jaguar
21

Wenn Sie die Keystore-Datei bereits haben, können Sie Ihrem Build-Befehl einfach einige Parameter hinzufügen:

./gradlew assembleRelease \
 -Pandroid.injected.signing.store.file=$KEYFILE \
 -Pandroid.injected.signing.store.password=$STORE_PASSWORD \
 -Pandroid.injected.signing.key.alias=$KEY_ALIAS \
 -Pandroid.injected.signing.key.password=$KEY_PASSWORD

Keine dauerhaften Änderungen an Ihrem Android-Projekt erforderlich.

Quelle: http://www.tinmith.net/wayne/blog/2014/08/gradle-sign-command-line.htm

Janpio
quelle
18

Dies ist eine Antwort auf user672009 und eine Ergänzung zu sdqalis Beitrag (sein Code stürzt beim Debug-Version über die IDE-Schaltfläche "Ausführen" ab):

Sie können den folgenden Code verwenden:

final Console console = System.console();
if (console != null) {

    // Building from console 
    signingConfigs {
        release {
            storeFile file(console.readLine("Enter keystore path: "))
            storePassword console.readLine("Enter keystore password: ")
            keyAlias console.readLine("Enter alias key: ")
            keyPassword console.readLine("Enter key password: ")
        }
    }

} else {

    // Building from IDE's "Run" button
    signingConfigs {
        release {

        }
    }

}
AChep
quelle
Gibt es eine Möglichkeit, einige Standardwerte zu haben? Mein Keystore ist normalerweise der gleiche. Das storePassword entspricht normalerweise dem keyPassword, und das keyAlias ​​entspricht normalerweise dem Projektnamen in Kleinbuchstaben.
user672009
@ user672009 Sie können immer Java-Code innerhalb des Skripts verwenden.
AChep
1
Vielleicht möchten Sie so etwas verwenden: keyPassword new String(console.readPassword("Enter key password: "))um sicherzustellen, dass Ihr Passwort während der Eingabe nicht angezeigt wird
Alex Semeniuk
Dies funktioniert nicht mehr, siehe github.com/gradle/gradle/issues/1251
SqAR.org
16

In neuerem Android Studio gibt es eine GUI-Methode, die sehr einfach ist und auch Gradle-Dateien auffüllt.

  1. File -> Project Structure

  2. Module -> Wählen Sie das Hauptmodul ('App' oder ein anderer benutzerdefinierter Name).

  3. Signing Registerkarte -> Plusbild zum Hinzufügen einer neuen Konfiguration

  4. Füllen Sie die Daten auf der rechten Seite

  5. OK und Gradle-Datei wird automatisch erstellt

  6. Sie manuell eine Zeile hinzufügen müssen signingConfig signingConfigs.NameOfYourConfiginnerhalbbuiltTypes{release{}}

Bilder:

Geben Sie hier die Bildbeschreibung ein

Geben Sie hier die Bildbeschreibung ein

Zwei wichtige (!) Hinweise:

(EDIT 12/15)

  1. Um signierte APKs zu erstellen, müssen Sie die Registerkarte Terminal von Android Studio (unten auf der Hauptoberfläche) öffnen und einen Befehl ausgeben ./gradlew assembleRelease

  2. Wenn Sie vergessen haben keyAlias(was mir oft passiert), müssen Sie initiieren Build -> Generate Signed APK, um den Prozess zu starten und den Namen des Alias-Schlüssels zu sehen.

Sandale
quelle
2
Dadurch werden Ihre Passwörter jedoch fest in die build.gradleDatei codiert, nicht wahr?
Joshua Pinter
16

Wenn Sie apk wie ich über eine Befehlszeile erstellen, können Sie die Signaturkonfiguration als Argumente angeben.

Fügen Sie dies Ihrem hinzu build.gradle

def getStore = { ->
    def result = project.hasProperty('storeFile') ? storeFile : "null"
    return result
}

def getStorePassword = { ->
    def result = project.hasProperty('storePassword') ? storePassword : ""
    return result
}

def getKeyAlias = { ->
    def result = project.hasProperty('keyAlias') ? keyAlias : ""
    return result
}

def getKeyPassword = { ->
    def result = project.hasProperty('keyPassword') ? keyPassword : ""
    return result
}

Mach dein signingConfigsso

signingConfigs {
    release {
        storeFile file(getStore())
        storePassword getStorePassword()
        keyAlias getKeyAlias()
        keyPassword getKeyPassword()
    }
}

Dann führen Sie gradlewso aus

./gradlew assembleRelease -PstoreFile="keystore.jks" -PstorePassword="password" -PkeyAlias="alias" -PkeyPassword="password"
Egis
quelle
Welches ist build.gradle? Höchststufe? Bitte fügen Sie mehr Code hinzu
Vlad
Zur Verdeutlichung ist dies eine app/build.gradleDatei, über die ich spreche.
Egis
11
android {
    compileSdkVersion 17
    buildToolsVersion "19.0.3"

    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 18
    }

    File signFile = rootProject.file('sign/keystore.properties')
    if (signFile.exists()) {
        Properties properties = new Properties()
        properties.load(new FileInputStream(signFile))
        signingConfigs {
            release {
                storeFile rootProject.file(properties['keystore'])
                storePassword properties['storePassword']
                keyAlias properties['keyAlias']
                keyPassword properties['keyPassword']
            }
        }
    }

    buildTypes {
        release {
            runProguard true
            zipAlign true
            proguardFile rootProject.file('proguard-rules.cfg')
            signingConfig signingConfigs.release
        }
        debug {
            runProguard false
            zipAlign true
        }
    }
}
JP Ventura
quelle
Verwenden von Android Studio 0.5.1, Gradle 1.11 und Gradle Plugin 0.9.
JP Ventura
1
Das Erstellen von Eigenschaften nach Bedarf (auch als dynamische Eigenschaften bezeichnet) ist veraltet und soll in Gradle 2.0
JP Ventura am
10

Sie können auch die Befehlszeilenoption -P von gradle verwenden, um das Signieren zu erleichtern. Fügen Sie in Ihrem build.gradle singende Konfigurationen wie folgt hinzu:

signingConfigs {
   release {
       storeFile file("path/to/your/keystore")
       storePassword RELEASE_STORE_PASSWORD
       keyAlias "your.key.alias"
       keyPassword RELEASE_KEY_PASSWORD
   }
}

Rufen Sie dann gradle build wie folgt auf:

gradle -PRELEASE_KEYSTORE_PASSWORD=******* -PRELEASE_KEY_PASSWORD=****** build

Sie können -P verwenden, um storeFile und keyAlias ​​festzulegen, wenn Sie dies bevorzugen.

Dies ist im Grunde die Lösung von Destil, jedoch mit den Befehlszeilenoptionen.

Weitere Informationen zu den Gradle-Eigenschaften finden Sie im Gradle-Benutzerhandbuch .

Andy Shiue
quelle
7

Die Antwort von @ Destil ist gut, wenn Sie dieselbe Konfiguration für alle Projekte wiederverwenden können. Alternativ wird Android Studio mit einem geliefertlocal.properties Datei geliefert, die möglicherweise stattdessen verwendet werden kann, aber angeblich IDE-generiert ist, und ich kann keine Möglichkeit finden, sie in Android Studio zu erweitern.

Dies ist eine Variation der Antwort von @ jonbo . Diese Antwort ermöglicht projektspezifische Einstellungen, ist jedoch mit einem gewissen Entwickleraufwand verbunden. Insbesondere ist ein erhebliches Boilerplate erforderlich, um die signingConfigsDefinition in eine separate Datei zu verschieben - insbesondere, wenn Sie dies für mehrere Projekte tun müssen. Dies ist ein Hauptgrund für die Auswahl dieser Lösung gegenüber Destil. Dies kann etwas gelindert werden, indem auch die Linie einbezogen wird

apply plugin: 'com.android.application'

in der Anmeldeinformationsdatei, da dies den Abschluss der IDE ermöglicht.

Schließlich erlauben die meisten Lösungen hier nicht , das Projekt im Debug-Modus zu erstellen - der das Debug-Signieren automatisch übernimmt -, ohne eine syntaktisch, wenn nicht semantisch gültige, bereitzustellensigningConfigs Definition bereitzustellen. Wenn Sie keinen Release-Build von einer bestimmten Maschine erstellen müssen, kann dieser zusätzliche Schritt als unnötiges Hindernis angesehen werden. Auf der anderen Seite kann dies eine Hilfe für ignorante oder faule Kollegen sein, die Debug-Builds in der Produktion ausführen.

Diese Lösung ermöglicht Debug-Builds, ohne sich um Anmeldeinformationen kümmern zu müssen. Für die Erstellung von Release-Builds sind jedoch gültige Anmeldeinformationen erforderlich, und es wird nur sehr wenig Boilerplate benötigt. Als Nachteil könnte es jedoch andere dazu ermutigen, Dummy-Werte durch echte Anmeldeinformationen zu ersetzen, und es gibt keine Möglichkeit, sich davor zu schützen.

// app/build.gradle
// Define this structure in signing.gradle to enable release builds.
ext.signing = [
        storeFilePath : 'path/to/keystore',
        storePassword : 'keystore password',
        keyAlias      : 'key alias',
        keyPassword   : 'key password',
]

if (file('signing.gradle').exists()) {
    apply from: 'signing.gradle'
}

android {
    ...
    signingConfigs {
        release {
            storeFile file(project.signing.storeFilePath)
            storePassword project.signing.storePassword
            keyAlias project.signing.keyAlias
            keyPassword project.signing.keyPassword
        }
    }
    buildTypes {
        debug { ... }
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

Dadurch wird eine Dummy-Eigenschaft erstellt, die lediglich dazu dient, eine syntaktisch gültige Build-Datei zu erstellen. Die den ext.signingEigenschaften von ' zugewiesenen Werte sind für Debug-Builds irrelevant. So aktivieren Sie Release - Builds, Kopieren ext.signingin signing.gradleund die Dummy - Werte mit gültigen Anmeldeinformationen ersetzen.

// signing.gradle
ext.signing = [
        storeFilePath : 'real/keystore',
        storePassword : 'real keystore password',
        keyAlias : 'real key alias',
        keyPassword : 'real key password',
]

Sollte natürlich signing.gradlevon VCS ignoriert werden.

mkjeldsen
quelle
6

Fast alle Plattformen bieten jetzt eine Art Schlüsselbund an, sodass es keinen Grund gibt, Klartextkennwörter zu belassen.

Ich schlage eine einfache Lösung vor, die das Python-Schlüsselringmodul (hauptsächlich das Begleitkonsolenskript keyring) und einen minimalen Wrapper um die Groovy- ['do', 'something'].execute() Funktion verwendet :

def execOutput= { args ->
    def proc = args.execute()
    proc.waitFor()
    def stdout = proc.in.text
    return stdout.trim()
}

Mit dieser Funktion wird der signingConfigsAbschnitt zu:

signingConfigs {
    release {
        storeFile file("android.keystore")
        storePassword execOutput(["keyring", "get", "google-play", storeFile.name])
        keyAlias "com.example.app"
        keyPassword execOutput(["keyring", "get", "google-play", keyAlias])
    }
}

Vor dem Ausführen müssen gradle assembleReleaseSie die Kennwörter in Ihrem Schlüsselbund nur einmal festlegen:

$ keyring set google-play android.keystore # will be prompted for the passwords
$ keyring set google-play com.example.app

Fröhliche Veröffentlichungen!

Naufraghi
quelle
5

Erweitern Sie die Antwort von David Vavra, erstellen Sie eine Datei ~ / .gradle / gradle.properties und fügen Sie hinzu

RELEASE_STORE_FILE=/path/to/.keystore
RELEASE_KEY_ALIAS=XXXXX
RELEASE_STORE_PASSWORD=XXXXXXXXX
RELEASE_KEY_PASSWORD=XXXXXXXXX

Dann in build.gradle

  signingConfigs {
    release {
    }
  }

  buildTypes {
    release {
      minifyEnabled true
      shrinkResources true

    }
  }

  // make this optional
  if ( project.hasProperty("RELEASE_KEY_ALIAS") ) {
    signingConfigs {
      release {
        storeFile file(RELEASE_STORE_FILE)
        storePassword RELEASE_STORE_PASSWORD
        keyAlias RELEASE_KEY_ALIAS
        keyPassword RELEASE_KEY_PASSWORD
      }
    }
    buildTypes {
      release {
        signingConfig signingConfigs.release
      }
    }
  }
SRC
quelle
5

Ich hatte ziemlich viel Spaß daran, dies herauszufinden. Hier ist mein Durchgang.

A bis Z-Anleitung zum Erstellen einer Gradle-Build-Datei in IntelliJ (v.13.1.4) In dieser Anleitung wird davon ausgegangen, dass Sie wissen, wie eine Keystore-Datei erstellt wird. Damit dieses Tutorial funktioniert, muss sich Ihre Keystore-Datei in Ihrem App-Ordner befinden und Ihre zipalign.exe-Datei muss sich in 'SDK-ROOT \ tools' befinden. Diese Datei befindet sich normalerweise in 'SDK-ROOT \ build-tools' und unter diesem Ordner befindet sie sich im höchsten API-Ordner (Alpha oder Beta, ich empfehle die Alpha-Version).

Für diejenigen unter Ihnen, die direkt hier hineinspringen möchten, ist die Gradle-Build-Datei.

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.9.+'
    }
}
apply plugin: 'android'

repositories {
    mavenCentral()
}
android {
    compileSdkVersion 19
    buildToolsVersion '20.0.0'
    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }
    signingConfigs {
        playstore {
            keyAlias 'developers4u'
            keyPassword 'thisIsNotMyRealPassword'
            storeFile file('developers4u.keystore')
            storePassword 'realyItIsNot'
        }
    }
    buildTypes {
        assembleRelease {
            debuggable false
            jniDebugBuild false
            runProguard true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
            zipAlign true
            signingConfig signingConfigs.playstore
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:support-v4:20.0.0'
    implementation 'com.android.support:appcompat-v7:20.0.0'
}

Sie können einen Teil dieser Erstellungsdatei (oben) über die Menüoption erstellen: Datei- / Projektstruktur Wählen Sie hier Facetten aus und klicken Sie auf 'Android-Gradle (App). Von hier aus sehen Sie die Registerkarten: "Eigenschaften", "Signieren", "Flavours", "Build-Typen" und "Abhängigkeiten". In diesem Rundgang werden nur "Signieren" und "Build-Typen" verwendet. Geben Sie unter "Build-Typen" (im Abschnitt "Name") einen beliebigen Namen ein, mit dem Sie Ihre Build-Typ-Konfiguration identifizieren möchten, und geben Sie in den anderen 4 Feldern Ihre Keystore-Informationen ein (legen Sie den Keystore-Pfad unter Ihrem App-Ordner fest).

Geben Sie unter 'Build Types' den Wert 'assembleRelease' in das Namensfeld ein. 'Debuggable' sollte auf false gesetzt sein, 'Jni Debug Build' sollte false sein, 'Run Proguard' auf true und 'Zip Align' auf true. Dadurch wird eine Build-Datei generiert, aber nicht wie oben dargestellt. Anschließend müssen Sie der Build-Datei einige Dinge hinzufügen. Der Speicherort der ProGuard-Datei wird hier manuell in der Gradle-Build-Datei festgelegt. (wie oben abgebildet)

Die DSL-Container, die Sie anschließend hinzufügen müssen, lauten wie folgt:

android {
    ....
    compileSdkVersion 19
    buildToolsVersion '20.0.0'
    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }
    ....
}

Sie müssen auch hinzufügen:

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:support-v4:20.0.0'
    implementation 'com.android.support:appcompat-v7:20.0.0'
}

Beachten Sie, dass sich dieser DSL-Container oben ('Abhängigkeiten') am Ende der Konfigurationsdatei befinden sollte, jedoch nicht im Android-DSL-Container. Um den Abhängigkeitscontainer über das IntelliJ-Menü zu erstellen, wählen Sie: Datei- / Projektstruktur. Von dort aus wählen Sie erneut Facetten und dann Android-Gradle (App). Sie sehen die gleichen 5 Registerkarten wie oben erwähnt. Wählen Sie die Registerkarte "Abhängigkeiten" und fügen Sie die gewünschten Abhängigkeiten hinzu.

Nachdem dies alles erledigt ist, sollte eine Gradle-Build-Datei angezeigt werden, die der Datei oben in dieser Anleitung ähnelt. Um Ihre signierte Version mit Reißverschluss zu erstellen, müssen Sie die Gradle-Aufgaben öffnen. Sie gelangen zu diesem Fenster, indem Sie Ansicht / Werkzeugfenster / Gradle auswählen. Von hier aus können Sie auf 'assembleAssembleRelease' doppelklicken. Dies sollte Ihre bereitstellbare APK generieren.

Die potenziellen Probleme, die beim Kompilieren Ihrer Version auftreten können, sind (ohne darauf beschränkt zu sein): Ihre Gradle-Builddatei befindet sich am falschen Ort. Es gibt zwei Gradle-Builddateien. eine in Ihrem Anwendungsstammordner und eine andere im App-Ordner unter dem Anwendungsstamm. Sie müssen letzteres verwenden.

Möglicherweise haben Sie auch Flusenprobleme. (Hinweis: Android Developer Studio kann Lint-Probleme viel besser erkennen als IntelliJ. Sie werden dies bemerken, wenn Sie versuchen, eine signierte APK über die Menüoptionen zu generieren.)

Um Flusenprobleme zu umgehen, müssen Sie den folgenden DSL-Container in den Android-Container (oben) stellen:

android {
        ....
    lintOptions {
        abortOnError false
    }
    ....
}

Wenn Sie dies in Ihren Android-DSL-Container einfügen, wird eine Fehlerdatei im Build-Ordner (direkt unter Ihrem App-Ordner) generiert. Der Dateiname sollte etwa "lint-results-release-fatal.html" lauten. Diese Datei teilt Ihnen dies mit die Klasse, in der der Fehler aufgetreten ist. Eine andere Datei, die generiert wird, ist eine XML-Datei, die die mit dem Flusenfehler verknüpfte 'Problem-ID' enthält. Der Dateiname sollte ungefähr "lint-results-release-fatal.xml" sein. Irgendwo oben in der Datei sehen Sie ein Knotenproblem, in dem Sie etwas Ähnliches wie 'id = "IDOfYourLintProblem"' sehen.

Um dieses Problem zu beheben, öffnen Sie die Datei in Ihrem Projekt, die in der Datei 'lint-results-assembleRelease-fatal.html' aufgeführt ist, und geben Sie die folgende Codezeile in die Java-Klassendatei direkt über dem Klassennamen ein: @SuppressLint ("IDOfYourLintProblem" "). Möglicherweise müssen Sie 'android.annotation.SuppressLint;' importieren.

Ihre Java-Klassendatei sollte also folgendermaßen aussehen:

package com.WarwickWestonWright.developers4u.app.CandidateArea;

import android.annotation.SuppressLint;
... other imports

@SuppressLint("IDOfYourLintProblem")
public class SearchForJobsFragment extends Fragment {... rest of your class definition}

Beachten Sie, dass das Unterdrücken von Flusenfehlern nicht immer die beste Idee ist. Sie sind möglicherweise besser dran, Ihren Code zu ändern, der die Flusenfehler verursacht hat.

Ein weiteres Problem, das möglicherweise auftreten kann, besteht darin, dass Sie die Umgebungsvariable für die Umgebungsvariable Gradle HOME nicht festgelegt haben. Diese Variable heißt 'GRADLE_HOME' und sollte als Pfad des Gradle-Ausgangsverzeichnisses festgelegt werden, z. B. 'C: \ gradle-1.12'. Manchmal möchten Sie auch die Umgebungsvariable für 'ANDROID_HOME' auf 'YOUR- setzen. SDK-Root \ sdk '

Kehren Sie anschließend zum Fenster mit den Gradle-Aufgaben zurück und doppelklicken Sie auf assembleAssembleRelease.

Wenn alles erfolgreich ist, sollten Sie in der Lage sein, in den Ordner app \ build \ apk zu gehen und Ihre bereitstellbare APK-Datei zu finden.

user2288580
quelle
+1 für die Anstrengung und: 'lintOptions {abortOnError false}'
Raz Tourgman
4

Noch ein Ansatz für das gleiche Problem. Da es nicht empfohlen wird, Anmeldeinformationen im Quellcode zu speichern, haben wir beschlossen, die Kennwörter für den Schlüsselspeicher und den Schlüsselalias in einer separaten Eigenschaftendatei wie folgt festzulegen:

key.store.password=[STORE PASSWORD]
key.alias.password=[KEY PASSWORD]

Wenn Sie git verwenden, können Sie eine Textdatei mit dem Namen "secure.properties" erstellen. Sie sollten sicherstellen, dass Sie es aus Ihrem Repository ausschließen (wenn Sie git verwenden, fügen Sie es der .gitignore-Datei hinzu). Dann müssten Sie eine Signaturkonfiguration erstellen, wie in einigen anderen Antworten angegeben. Der einzige Unterschied besteht darin, wie Sie die Anmeldeinformationen laden würden:

android {
    ...
    signingConfigs {
        ...
        release {
            storeFile file('[PATH TO]/your_keystore_file.jks')
            keyAlias "your_key_alias"

            File propsFile = file("[PATH TO]/secure.properties");
            if (propsFile.exists()) {
                Properties props = new Properties();
                props.load(new FileInputStream(propsFile))
                storePassword props.getProperty('key.store.password')
                keyPassword props.getProperty('key.alias.password')
            }
        }
        ...
    }

    buildTypes {
        ...
        release {
            signingConfig signingConfigs.release
            runProguard true
            proguardFile file('proguard-rules.txt')
        }
        ...
    }
}

Vergessen Sie niemals, die signingConfig manuell dem Release-Build-Typ zuzuweisen (aus irgendeinem Grund gehe ich manchmal davon aus, dass sie automatisch verwendet wird). Es ist auch nicht obligatorisch, Proguard zu aktivieren, aber es ist empfehlenswert.

Dieser Ansatz gefällt uns besser als die Verwendung von Umgebungsvariablen oder das Anfordern von Benutzereingaben, da dies über die IDE erfolgen kann, indem zum Realease-Build-Typ gewechselt und die App ausgeführt wird, anstatt die Befehlszeile verwenden zu müssen.

argenkiwi
quelle
1
Gradle kompiliert nicht damit: props = new Properties (); Der Wert der schreibgeschützten Eigenschaft 'Requisiten' kann nicht festgelegt werden
cesards
Sie haben Recht @ m3n0R. Ich habe eine Zeile meiner Antwort bearbeitet, um den Fix widerzuspiegeln, den wir in unserer App einführen mussten, damit sie weiterhin mit den neuesten Versionen von Gradle kompiliert werden kann. Grundsätzlich müssen Requisiten als lokale Variable deklariert werden.
Argenkiwi
Wie wäre dies mit Cloud-CI / CD-Tools möglich? Der Pfad / path / to / keystore und /path/to/secure.props werfen mich. Vielen Dank dafür.
Sirvon
4

Android Studio Gehen Sie zu Datei -> Projektstruktur oder drücken Sie Strg + Alt + Umschalt + S.

Siehe das Bild

Geben Sie hier die Bildbeschreibung ein

OK klicken

Dann werden die signingConfigs in Ihrer build.gradle-Datei generiert.

Geben Sie hier die Bildbeschreibung ein

Ahamadullah Saikat
quelle
Und genau das wollen Sie nicht tun. Auf diese Weise sind alle Ihre Passwörter im Klartext und Teil Ihres Projekts und können auch in Ihrem verteilten Build sehr leicht versehentlich eingefügt werden.
not2qubit
2

Ich hatte mehrere Probleme, bei denen ich die folgende Zeile an eine falsche Stelle gesetzt habe:

signingConfigs {
    release {
        // We can leave these in environment variables
        storeFile file("d:\\Fejlesztés\\******.keystore")
        keyAlias "mykey"

        // These two lines make gradle believe that the signingConfigs
        // section is complete. Without them, tasks like installRelease
        // will not be available!
        storePassword "*****"
        keyPassword "******"
    }
}

Stellen Sie sicher, dass Sie die signingConfigs-Teile in den Android-Bereich einfügen:

android
{
    ....
    signingConfigs {
        release {
          ...
        }
    }
}

anstatt

android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

Es ist leicht, diesen Fehler zu machen.

Botond Kopacz
quelle
2

Es ist 2019 und ich muss APK mit V1 (JAR-Signatur) oder V2 (vollständige APK-Signatur) signieren. Ich googelte "signierte apk gradle generieren" und es brachte mich hierher. Also füge ich hier meine ursprüngliche Lösung hinzu.

signingConfigs {
    release {
        ...
        v1SigningEnabled true
        v2SigningEnabled true
    }
}

Meine ursprüngliche Frage: Wie verwende ich V1 (Jar-Signatur) oder V2 (vollständige APK-Signatur) aus der Datei build.gradle?

user1506104
quelle
Keine Semikolons erforderlich; es wird Ihnen einen Fehler geben.
Takeshi Kaga
Das ist richtig. Vielen Dank. Ich habe die Antwort bearbeitet.
user1506104
1

Um die anderen Antworten zu ergänzen, können Sie Ihre Datei gradle.properties zusammen mit build.gradle auch in Ihrem eigenen Modulordner ablegen, falls Ihr Keystore für ein Projekt spezifisch ist.

cprcrack
quelle
1

Ich arbeite in Ubuntu14.04. vim ~ / .bashrc und füge export ANDROID_KEYSTORE = export ANDROID_KEYALIAS = hinzu

und dann in build.gradle set.

    final Console console = System.console();
if (console != null) {

    // Building from console
    signingConfigs {
        release {
            storeFile file(System.getenv("KEYSTORE"))
            storePassword new String(System.console().readPassword("\n\$ Enter keystore password: "))
            keyAlias System.getenv("KEY_ALIAS")
            keyPassword new String(System.console().readPassword("\n\$ Enter key password: "))
        }
    }

} else {

    // Building from IDE's "Run" button
    signingConfigs {
        release {

        }
    }

}
ayyb1988
quelle
Meiner Meinung nach scheint dies die beste Lösung zu sein, aber leider funktioniert es nicht mehr mit neueren Versionen von Gradle : System.console()return null.
Antonio Vinicius Menezes Medei
1

Eine Alternative besteht darin, eine Aufgabe zu definieren, die nur bei Release-Builds ausgeführt wird.

android {
  ...
  signingConfigs {
     release {
        // We can leave these in environment variables
        storeFile file('nameOfKeystore.keystore')
        keyAlias 'nameOfKeyAlias'

        // These two lines make gradle believe that the signingConfigs
        // section is complete. Without them, tasks like installRelease
        // will not be available!
        storePassword "notYourRealPassword"
        keyPassword "notYourRealPassword"

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

task setupKeystore << {
final Console console = System.console();
if (console != null) {
    //def keyFile = console.readLine(“\nProject: “ + project.name + “Enter keystore path: "))
    //def keyAlias = console.readLine(“Project: “ + project.name + “Enter key alias: ")
        def storePw = new String(console.readPassword(“Project:  + project.name + “. Enter keystore password: "))
        def keyPw  = new String(console.readPassword(“Project: “ + project.name + “.Enter keystore password: "))

    //android.signingConfigs.release.storeFile = file(keyFile);
    //android.signingConfigs.release.keyAlias = keyAlias
        android.signingConfigs.release.storePassword = storePw
        android.signingConfigs.release.keyPassword = keyPw
}
}

//Validate t
def isReleaseConfig = gradle.startParameter.taskNames.any {it.contains('Release') }
if (isReleaseConfig) {
    setupKeystore.execute();
}
Davidpetter
quelle
Folgendes scheint mir vorzuziehen: stackoverflow.com/a/19130098/3664487 Wie vergleichen sich die beiden Ansätze?
user2768
1

Sie können Kennwörter über die Befehlszeile anfordern:

...

signingConfigs {
  if (gradle.startParameter.taskNames.any {it.contains('Release') }) {
    release {
      storeFile file("your.keystore")
      storePassword new String(System.console().readPassword("\n\$ Enter keystore password: "))
      keyAlias "key-alias"
      keyPassword new String(System.console().readPassword("\n\$ Enter keys password: "))
    } 
  } else {
    //Here be dragons: unreachable else-branch forces Gradle to create
    //install...Release tasks.
    release {
      keyAlias 'dummy'
      keyPassword 'dummy'
      storeFile file('dummy')
      storePassword 'dummy'
    } 
  }
}

...

buildTypes {
  release {

    ...

    signingConfig signingConfigs.release
  }

  ...
}

...

Der if-then-elseBlock verhindert die Anforderung von Kennwörtern beim Erstellen einer Version. Obwohl der elseZweig nicht erreichbar ist, bringt er Gradle dazu, eine install...ReleaseAufgabe zu erstellen .

Hintergrundgeschichte . Wie unter https://stackoverflow.com/a/19130098/3664487 angegeben , können " Gradle-Skripte mithilfe der System.console (). ReadLine-Methode zur Benutzereingabe auffordern ." Leider fordert Gradle immer ein Passwort an, auch wenn Sie eine Debug-Version erstellen (vgl. Wie erstelle ich eine mit einer Version signierte Apk-Datei mit Gradle? ). Glücklicherweise kann dies überwunden werden, wie ich oben gezeigt habe.

user2768
quelle
Meine frühere Antwort stieß aufgrund von stackoverflow.com/questions/33897802/… auf Probleme . Ich habe meine Antwort überarbeitet, um dieses Problem zu beheben.
user2768
@ Haroon, es funktionierte ab dem 24. November '15. Die Community kann möglicherweise bei Ihrem Problem helfen, aber Sie müssen weitere Details angeben.
user2768
Ich mag diese Lösung, da sie es vermeidet, das Passwort in Klartext in eine Textdatei zu schreiben, aber System.console (). ReadLine funktioniert aufgrund dieses nervigen Problems nicht in Gradle .
Morpheus
@morpheus, ich hatte noch nie ein Problem. Das obige funktioniert für mich.
user2768
Ich denke, Sie führen das Skript in einer IDE aus. Wenn das Skript vom Terminal ausgeführt wird, wird der Fehler angezeigt. aber danke für diese Antwort. das ist was ich gesucht habe.
Morpheus
0

Hinzufügen meiner Möglichkeit, dies in React-Native mit dem Paket react-native-config zu tun .
Erstellen Sie eine .env-Datei:

RELEASE_STORE_PASSWORD=[YOUR_PASSWORD]
RELEASE_KEY_PASSWORD=[YOUR_PASSWORD]

Beachten Sie, dass dies nicht Teil der Versionskontrolle sein sollte.

in Ihrem build.gradle:

signingConfigs {
        debug {
            ...
        }
        release {
            storeFile file(RELEASE_STORE_FILE)
            storePassword project.env.get('RELEASE_STORE_PASSWORD')
            keyAlias RELEASE_KEY_ALIAS
            keyPassword project.env.get('RELEASE_KEY_PASSWORD')
        }
    }
Chenop
quelle
0

In meinem Fall habe ich die falsche Apk in die Version einer anderen App hochgeladen.

Tauwelt
quelle
0

Für Groovy (build.gradle)

Sie sollten Ihre Anmeldeinformationen nicht direkt in die Datei build.gradle einfügen . Stattdessen sollten die Anmeldeinformationen aus einer Datei stammen, die nicht der Versionskontrolle unterliegt.

Legen Sie eine Datei signating.properties ab, in der sich das modulspezifische build.gradle befindet. Vergessen Sie nicht, es Ihrer .gitignore- Datei hinzuzufügen !

signieren.Eigenschaften

storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey

build.gradle

android {
    // ...
    signingConfigs{
        release {
            def props = new Properties()

            def fileInputStream = new FileInputStream(file('../signing.properties'))
            props.load(fileInputStream)
            fileInputStream.close()

            storeFile = file(props['storeFilePath'])
            storePassword = props['storePassword']
            keyAlias = props['keyAlias']
            keyPassword = props['keyPassword']
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
            // ...
        }
    }
}
Willi Mentzel
quelle
0

Für Kotlin Script (build.gradle.kts)

Sie sollten Ihre Anmeldeinformationen nicht direkt in die Datei build.gradle.kts einfügen Datei . Stattdessen sollten die Anmeldeinformationen aus einer Datei stammen, die nicht der Versionskontrolle unterliegt.

Legen Sie eine Datei signieren.Eigenschaften ab, in der sich das modulspezifische build.gradle.kts befindet. Vergessen Sie nicht, es Ihrer .gitignore- Datei hinzuzufügen !

signieren.Eigenschaften

storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey

build.gradle.kts

android {
    // ...
    signingConfigs {
        create("release") {
            val properties = Properties().apply {
                load(File("signing.properties").reader())
            }
            storeFile = File(properties.getProperty("storeFilePath"))
            storePassword = properties.getProperty("storePassword")
            keyPassword = properties.getProperty("keyPassword")
            keyAlias = "release"
        }
    }

    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            // ...
        }
    }
}
Willi Mentzel
quelle
-1

Wenn Sie nicht sehen möchten, kann die Methode readLine () für ein Nullobjekt nicht aufgerufen werden. Sie müssen zuerst in gradle.properties schreiben .

KEYSTORE_PASS=*****
ALIAS_NAME=*****
ALIAS_PASS=*****
JeasonWong
quelle