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

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?

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

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.

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

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

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.

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!

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

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

  ...

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

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 {

        }
    }

}

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:

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.

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"

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

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 .

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.

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!

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

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.

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.

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

Siehe das Bild

OK klicken

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

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.

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?

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.

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 {

        }
    }

}

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

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.

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

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

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

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

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=*****