Wie erstellt man eine signierte Release-APK-Datei mit Gradle?

Question

Ich möchte, dass mein Gradle-Build eine signierte Release-APK-Datei unter Verwendung von Gradle erstellt.

Ich bin mir nicht sicher, ob der Code korrekt ist oder ob ich einen Parameter vermisse, wenn ich gradle build ausführe?

Dies ist ein Teil des Codes in meiner build.gradle/build.gradle.kts-Datei:

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

Der Gradle-Build wird ERFOLGREICH abgeschlossen, und in meinem build/apk-Ordner sehe ich nur die Dateien ...-release-unsigned.apk und ...-debug-unaligned.apk.

Irgendwelche Vorschläge, wie man das lösen kann?

Answer 1

Leichterer Weg als in den vorherigen Antworten:

Fügen Sie dies in die ~/.gradle/gradle.properties ein

RELEASE_STORE_FILE={Pfad zu Ihrem Keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****

Ändern Sie Ihre app/build.gradle und fügen Sie dies innerhalb des android { Codeblocks hinzu:

...    
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 können Sie gradle assembleRelease ausführen

---

Sehen Sie auch die Referenz für den signingConfigs Gradle DSL

Answer 2

Ich konnte das lösen, indem ich diesen Code hinzugefügt habe und mit gradle build gebaut habe:

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

Dies erstellt eine signierte Release-APK-Datei.

Answer 3

Beachten Sie, dass das Skript von @sdqali (zumindest bei Verwendung von Gradle 1.6) jedes Mal nach dem Passwort fragen wird, wenn Sie eine beliebige Gradle-Aufgabe aufrufen. Da Sie es nur benötigen, wenn Sie gradle assembleRelease (oder ähnliches) ausführen, könnten Sie den folgenden Trick verwenden:

android {
    ...
    signingConfigs {
        release {
            // Wir können dies in Umgebungsvariablen lassen
            storeFile file(System.getenv("KEYSTORE"))
            keyAlias System.getenv("KEY_ALIAS")

            // Diese beiden Zeilen lassen gradle glauben, dass der signingConfigs Abschnitt vollständig ist. Ohne sie werden Aufgaben wie installRelease nicht verfügbar sein!
            storePassword "nichtIhrEchtesPasswort"
            keyPassword "nichtIhrEchtesPasswort"
        }
    }
    ...
}

task askForPasswords << {
    // Muss String erstellen, da System.readPassword() char[] zurückgibt
    // (und diese unten zuzuweisen scheitert stillschweigend)
    def storePw = new String(System.console().readPassword("Keystore-Passwort: "))
    def keyPw = new String(System.console().readPassword("Schlüsselpasswort: "))

    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
    }
}

Answer 4

Wenn Sie vermeiden möchten, Ihren Keystore und Ihr Passwort im build.gradle fest zu codieren, können Sie eine Eigenschaftsdatei verwenden, wie hier erklärt: HANDLING SIGNING CONFIGS WITH GRADLE

Grundlegend:

1) Erstellen Sie eine myproject.properties Datei im Verzeichnis /home/[Benutzername]/.signing mit folgendem Inhalt:

keystore=[Pfad zu]\release.keystore
keystore.password=*********
keyAlias=***********
keyPassword=********

2) Erstellen Sie eine gradle.properties Datei (vielleicht im Root-Verzeichnis Ihres Projektverzeichnisses) mit folgendem Inhalt:

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

3) Verweise darauf in Ihrem build.gradle wie folgt:

    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']
        }
    }
}

Answer 5

Automatisches App-Signieren mit Gradle bei Verwendung von Git

Es ist erstaunlich, wie viele komplizierte Wege es gibt, dies zu tun. Hier ist mein eigener Weg, bei dem ich versuche, Googles eigener Empfehlung zu folgen. Ihre Erklärung ist jedoch nicht vollständig klar, daher werde ich das Verfahren für Linux im Detail beschreiben.

---

Beschreibung:

Die Google-Anweisungen zum automatischen Signieren einer App während des Builds, ohne die Passwörter und Signaturdateien im App-Entwicklungs-GIT-Pfad zu behalten, sind recht obskur. Hier sind die präzisierten schrittweisen Anweisungen, wie man das macht.

Ausgangsannahmen:

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

Problem

Wir möchten offensichtlich nicht, dass unsere Signatur- oder Passwortdateien irgendwo im GIT-kontrollierten Verzeichnis liegen, auch wenn wir sehr gut in der Lage sind, .gitignore usw. zu verwenden, ist es immer noch zu riskant und einfach, einen Fehler zu machen. Daher möchten wir unsere Keystore- und Signaturdateien extern haben.

Lösung

Wir müssen drei (3) Dinge tun:

1. Erstellen einer Passwortdatei, die von Android Studio verwendet werden soll.
2. Signaturschlüsselfile erstellen
3. Bearbeiten Sie die Modul-build.gradle-Datei, um (1) und (2) zu verwenden.

In diesem Beispiel benennen wir die beiden Dateien wie folgt:

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

Wir können beide Dateien hier platzieren:

cd $HOME/projects/mydev/

(1) Erstellen der Keystore-Passwortdatei

Die erste Datei enthält die Klartextpasswörter, die in; und Pfade zur Freischaltungsschlüsselfile in (2) verwendet werden. Beginnen Sie mit dem Ausfüllen, da dies den nächsten Schritt mit Kopieren und Einfügen erleichtert.

cd $HOME/projects/mydev/

Bearbeiten Sie keystore.properties, damit der Inhalt folgendermaßen aussieht:

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

Der einzige knifflige Teil hier ist der myStoreFileLocation. Dies ist der Pfad wie er aus der Modul-build.gradle-Datei während des Builds gesehen wird. Dies bedeutet normalerweise einen Pfad, der ähnlich und relativ zu ist: $HOME/projects/mydev/MyApp/app/build.gradle. Um also auf die MyApp-release-key.jks-Datei zu verweisen, müssen wir hier Folgendes eingeben:

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

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

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

(2) Erstellen der Signaturdatei

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

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

Dies wird Sie nach zwei Passwörtern und einigen Informationen fragen. (Gleiche Informationen wie in Android Studio.) Kopieren/Einfügen Sie nun Ihre zuvor ausgewählten Passwörter.

(3) Bearbeiten Sie Ihre Modul-gradle.build-Datei, um das Obige zu verwenden

Die folgenden Teile müssen in Ihrer App/Modul-Gradle-Build-Datei vorhanden sein. Fügen Sie zuerst 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))

Dann fügen Sie innerhalb des android {}-Blocks Folgendes hinzu:

android {
    ...
    defaultConfig { ... }
    signingConfigs {
            release {
                keyAlias keystoreProperties['keyAlias']
                keyPassword keystoreProperties['keyPassword']
                storeFile file(keystoreProperties['storeFile'])
                storePassword keystoreProperties['storePassword']
            }
        }
    // Sagen Sie Gradle, dass er Ihre APK signieren soll
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

Jetzt können Sie über die Shell Ihre App mit folgendem Befehl neu erstellen:

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

Dies sollte eine ordnungsgemäß signierte App generieren, die im Google Play verwendet werden kann.

---

UPDATE: 2019-04-02

Neuere Versionen von keytool und etwas geben Ihnen den Hinweis, dass Sie anstelle des oben verwendeten ursprünglichen/Standard-Passworts eine auf PKCS12 basierende Schlüsselfile verwenden sollten. Sie erklären dann, dass Sie in das neue offene PKCS12-Format konvertieren sollten. Es scheint jedoch, dass die Android-Entwicklungstools hierfür noch nicht ganz bereit sind, denn wenn Sie es tun, erhalten Sie die folgenden seltsamen Fehler:

com.android.ide.common.signing.KeytoolException: Fehler beim Lesen des Schlüssels XXX aus dem Speicher "F:\XXX\XXX.jks": Abrufen des Schlüssels fehlgeschlagen: Endgültiger Block nicht richtig gepolstert. Solche Probleme können auftreten, wenn ein ungültiger Schlüssel beim Entschlüsseln verwendet wird.

Verwenden Sie also keinen konvertierten Schlüssel!