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

In der neueren Android Studio-Version gibt es einen GUI-Weg, der sehr einfach ist und auch die Gradle-Datei ausfüllt.

1. Datei -> Projektstruktur

2. Modul -> Wählen Sie das Hauptmodul ('app' oder einen anderen benutzerdefinierten Namen)

3. Registerkarte Signing -> Plus-Symbol, um eine neue Konfiguration hinzuzufügen

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

5. OK und die Gradle-Datei wird automatisch erstellt

6. Sie müssen manuell eine Zeile signingConfig signingConfigs.NameOfYourConfig innerhalb von builtTypes{release{}} hinzufügen

Bilder:

Zwei wichtige(!) Anmerkungen:

(BEARBEITEN 12/15)

1. Um eine signierte APK zu erstellen, müssen Sie den Terminal-Tab von Android Studio öffnen (unten auf der Hauptoberfläche) und den Befehl ./gradlew assembleRelease eingeben

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

Answer 2

Für Kotlin-Skript (build.gradle.kts)

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

Legen Sie eine Datei signing.properties dort ab, wo das modulspezifische build.gradle.kts zu finden ist. Vergessen Sie nicht, sie zu Ihrer .gitignore-Datei hinzuzufügen!

signing.properties

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")
            // ...
        }
    }
}

Answer 3

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

Answer 4

Sie können auch die -P Befehlszeilenoption von Gradle verwenden, um bei der Signierung zu helfen. Fügen Sie in Ihrem build.gradle signingConfigs wie folgt hinzu:

signingConfigs {
   release {
       storeFile file("Pfad/zum/Keystore")
       storePassword RELEASE_STORE_PASSWORD
       keyAlias "Ihr.Schlüssel.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 möchten.

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

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

Answer 5

Die Antwort von @Destil ist gut, wenn Sie die gleiche Konfiguration in allen Projekten wiederverwenden können. Alternativ wird Android Studio mit einer local.properties Datei geliefert, die stattdessen verwendet werden kann, aber sie soll vom IDE generiert sein und ich kann keinen Weg finden, sie von innerhalb von Android Studio zu erweitern.

Dies ist eine Variation von @jonbo's Antwort. Diese Antwort ermöglicht projektbezogene Einstellungen, erfordert jedoch einen gewissen Entwickleraufwand. Insbesondere ist erheblicher Boilerplate-Code erforderlich, um die signingConfigs-Definition in eine separate Datei zu verschieben - insbesondere wenn Sie dies für mehrere Projekte tun müssen, was ein Hauptgrund für die Wahl dieser Lösung gegenüber Destil's ist. Dies kann etwas erleichtert werden, indem Sie auch die Zeile

apply plugin: 'com.android.application'

in die Anmeldeinformationsdatei aufnehmen, da dies die IDE-Vervollständigung ermöglicht.

Die meisten Lösungen hier erlauben nicht das Erstellen des Projekts im Debug-Modus - was die Debug-Signierung automatisch behandelt - ohne eine syntaktisch, wenn auch nicht semantisch, gültige signingConfigs-Definition bereitzustellen. Wenn Sie keine Release-Builds von einem bestimmten Rechner erstellen müssen, kann dieser zusätzliche Schritt als unnötiges Hindernis angesehen werden. Andererseits kann er gegen ignorante oder faule Kollegen hilfreich sein, die Debug-Builds in Produktion ausführen.

Mit dieser Lösung können Debug-Builds ohne sich um Anmeldeinformationen zu kümmern, erstellt werden, aber es sind gültige Anmeldeinformationen erforderlich, um Release-Builds zu erstellen, und es erfordert sehr wenig Boilerplate-Code. Allerdings könnte es andere dazu verleiten, Dummy-Werte durch echte Anmeldeinformationen zu ersetzen und es gibt keine Möglichkeit, dem entgegenzuwirken.

// app/build.gradle
// Definieren Sie diese Struktur in signing.gradle, um Release-Builds zu aktivieren.
ext.signing = [
        storeFilePath : 'Pfad/zum/Keystore',
        storePassword : 'Keystore-Passwort',
        keyAlias      : 'Schlüssel-Alias',
        keyPassword   : 'Schlüssel-Passwort',
]

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

Dies erstellt eine Dummy-Eigenschaft, die ausschließlich dazu dient, eine syntaktisch gültige Build-Datei zu erstellen. Die den Eigenschaften von ext.signing zugewiesenen Werte sind für Debug-Builds irrelevant. Um Release-Builds zu aktivieren, kopieren Sie ext.signing in die Datei signing.gradle und ersetzen Sie die Dummy-Werte durch gültige Anmeldeinformationen.

// signing.gradle
ext.signing = [
        storeFilePath : 'echter/Keystore',
        storePassword : 'echtes Keystore-Passwort',
        keyAlias : 'echter Schlüssel-Alias',
        keyPassword : 'echtes Schlüssel-Passwort',
]

Natürlich sollte die Datei signing.gradle vom VCS ignoriert werden.