web-dev-qa-db-ger.com

Wie erstelle ich eine release-signierte apk-Datei mit Gradle?

Ich möchte meinen Gradle-Build haben, um mit Gradle eine release-signierte apk-Datei zu erstellen.

Ich bin nicht sicher, ob der Code korrekt ist oder ob mir bei der Ausführung von gradle build ein Parameter fehlt.

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

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

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

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

485

Ich habe es geschafft, diesen Code hinzuzufügen und mit gradle build zu bauen:

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

Dies generiert eine signierte Release-Apk-Datei.

253

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 Ihren build.gradle wie folgt:

...    
signingConfigs {

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

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

Dann kannst du gradle assembleRelease ausführen

372
David Vávra

Beachten Sie, dass das Skript von @ sdqali (zumindest bei Verwendung von Gradle 1.6) bei jedem Aufruf von any gradle task nach dem Kennwort fragt. Da Sie es nur benötigen, wenn Sie gradle assembleRelease (oder ähnliches) ausführen, können Sie den folgenden Trick anwenden:

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

Wenn Sie vermeiden möchten, Ihren Keystore und Ihr Kennwort in build.gradle festzukodieren, können Sie eine Eigenschaftendatei verwenden, die hier erläutert wird: BEHANDLUNG VON SIGNIERKONFIGURATIONEN) MIT GRADLE

Grundsätzlich gilt:

1) Erstellen Sie eine myproject.properties-Datei unter /home/[Benutzername] /. Signieren mit folgendem Inhalt:

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

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

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

3) Verweisen Sie in Ihrem build.gradle darauf 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']
        }
    }
}
57
IgorGanapolsky

Wie @Destil sagte, aber erlauben Sie anderen, die nicht den Schlüssel zum Bauen haben: Einfacher als die vorherigen 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 Ihren build.gradle wie 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 gradle build ausführen.

34
Gal Bracha

Automatische App-Signatur mit Gradle bei Verwendung von Git

Es ist erstaunlich, wie viele verschlungene Wege es gibt, dies zu tun. Hier ist mein eigener Weg, auf dem ich versuche, mich an Googles eigenen zu halten Empfehlung . Ihre Erklärung ist jedoch nicht vollständig klar, daher werde ich die Vorgehensweise für Linux im Detail beschreiben.


Beschreibung:

Die Standardeinstellung Anweisungen von Google für das automatische Signieren einer App während des Builds, ohne die Kennwörter und Signaturdateien im Pfad Ihrer App-Entwicklung (GIT) zu belassen, ist eher unklar. Hier finden Sie eine Schritt-für-Schritt-Anleitung.

Anfangsannahmen:

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

enter image description here

Problem

Wir möchten natürlich keine Signatur- oder Passwortdateien im GIT-kontrollierten Verzeichnis haben, auch wenn wir in der Lage sind, .gitignore usw. zu verwenden, ist es immer noch zu riskant und leicht, einen Fehler zu machen. Deshalb wollen wir 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. Erstellen Sie eine Signaturschlüsseldatei
  3. Bearbeiten Sie die Moduldatei build.gradle, um (1) und (2) zu verwenden.

In diesem Beispiel benennen 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 Klartext-Passwörter, die in verwendet werden. und Pfade zur Release-Key-Datei in (2). Beginnen Sie mit dem Ausfüllen, da dies den Kopiervorgang für den nächsten Schritt erleichtert.

cd $HOME/projects/mydev/

Bearbeiten Sie keystore.properties so, 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 , wie aus der Moduldatei build.gradle während des Builds ersichtlich. Dies bedeutet normalerweise einen Pfad ähnlich und relativ zu: $HOME/projects/mydev/MyApp/app/build.gradle. Um also auf die Datei MyApp-release-key.jks 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 Keystore 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

Daraufhin 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 die gradle.build-Datei Ihres Moduls, 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 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))

Fügen Sie dann innerhalb des Blocks Android {} 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 von Shell aus Ihre App neu erstellen:

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

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


UPDATE: 2019-04-02

Neuere Versionen von keytool und etwas sagt Ihnen, dass Sie ein PKCS12 verwenden sollten basierte Schlüsseldatei anstelle des Originals/Standard, wie ich es oben benutze. Sie teilen Ihnen dann mit, dass Sie in das neue offene PKCS12-Format konvertieren sollen. Es scheint jedoch, dass die Entwicklungstools für Android noch nicht so weit sind, denn wenn Sie dies tun, werden Sie die folgenden seltsamen Fehler erhalten:

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 angegebene letzte Block ist nicht richtig aufgefüllt. Solche Probleme können auftreten, wenn während der Entschlüsselung ein falscher Schlüssel verwendet wird.

Verwenden Sie also keinen konvertierten Schlüssel!

32
not2qubit

(Als Antwort auf ser672009 oben.)

Eine noch einfachere Lösung, wenn Sie Ihre Passwörter nicht in einem Git-Repository speichern möchten. Wenn Sie jedoch Ihre build.gradle-Datei einbinden möchten, die sich auch für Produktvarianten eignet, 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 minus alles, was nicht mit der Anmeldung zusammenhängt.

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

Fügen Sie dann in Ihrer build.gradle-Datei diese Zeile direkt unter "plugin anwenden: 'Android'" ein.

 apply from: 'signing.gradle'

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

Verknüpfen Sie Ihre Aromen schließlich mit der korrekten signingConfig in Ihrer build.gradle-Datei, und Sie sollten fertig sein.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...
27
jonbo

Dies ist eine Antwort auf ser672009 und eine Ergänzung zu sdqalis Beitrag (sein Code stürzt beim Erstellen der 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 {

        }
    }

}
17
AChep

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

Fügen Sie dies Ihrem build.gradle hinzu

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
}

Machen Sie Ihr signingConfigs so

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

Dann führen Sie gradlew wie folgt aus

./gradlew assembleRelease -PstoreFile="keystore.jks" -PstorePassword="password" -PkeyAlias="alias" -PkeyPassword="password"
15
Egis

In neueren Android Studio gibt es eine sehr einfache GUI-Methode, mit der auch Gradle-Dateien gefüllt werden.

  1. File -> Project Structure

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

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

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

  5. OK und die Gradle-Datei wird automatisch erstellt

  6. Sie müssen manuell eine Zeile signingConfig signingConfigs.NameOfYourConfig in builtTypes{release{}} einfügen

Bilder:

enter image description here

enter image description here

Zwei wichtige (!) Hinweise:

(EDIT 12/15)

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

  2. Wenn Sie keyAlias vergessen haben (was mir häufig passiert), müssen Sie Build -> Generate Signed APK einleiten, um den Vorgang zu starten und den Namen des Alias-Schlüssels anzuzeigen.

14
sandalone

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

Es sind keine dauerhaften Änderungen an Ihrem Projekt Android erforderlich.

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

12
janpio
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
        }
    }
}
10
JP Ventura

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

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

Dann ruf gradle build so an:

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

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

Dies ist im Grunde Destils Lösung, jedoch mit den Befehlszeilenoptionen.

Weitere Informationen zu den Eigenschaften von Gradle finden Sie in der Gradle-Bedienungsanleitung .

9
Andy Shiue

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

Dies ist eine Variation von @ jonbos Antwort . Diese Antwort ermöglicht projektspezifische Einstellungen, ist jedoch mit einigem Entwickleraufwand verbunden. Insbesondere ist ein erhebliches Boilerplate erforderlich, um die signingConfigs -Definition 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 über Destil's. Dies kann durch auch einschließlich der Zeile etwas gelindert werden

apply plugin: 'com.Android.application'

in der Datei mit den Anmeldeinformationen, da dies die Vervollständigung von IDE ermöglicht.

Schließlich erlauben die meisten Lösungen hier nicht das Erstellen des Projekts im Debug-Modus - der das Debug-Signieren automatisch verarbeitet - ohne Angabe einer syntaktisch, wenn nicht semantisch gültigen signingConfigs -Definition . Wenn Sie keinen Release-Build von einem bestimmten Computer erstellen müssen, kann dieser zusätzliche Schritt als unnötiges Hindernis angesehen werden. Auf der anderen Seite kann es eine Hilfe gegen ignorante oder faule Kollegen sein, die Debugbuilds in der Produktion ausführen.

Diese Lösung ermöglicht Debug-Builds, ohne sich um Berechtigungsnachweise kümmern zu müssen, erfordert jedoch gültige Berechtigungsnachweise, um Release-Builds zu erstellen, und benötigt nur sehr wenig Boilerplate. Als Nachteil kann dies jedoch andere dazu ermutigen, Dummy-Werte durch echte Berechtigungsnachweise zu ersetzen, und es gibt keine Möglichkeit, sich dagegen 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 Eigenschaften von ext.signing zugewiesenen Werte sind für Debugbuilds irrelevant. Um Release-Builds zu aktivieren, kopieren Sie ext.signing in signing.gradle und ersetzen Sie die Dummy-Werte durch gültige Anmeldeinformationen.

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

Natürlich sollte signing.gradle von VCS ignoriert werden.

6
mkjeldsen

Fast alle Plattformen bieten inzwischen eine Art Schlüsselbund an, sodass es keinen Grund gibt, Klartext-Passwörter zu verwenden.

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

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

Mit dieser Funktion wird der Abschnitt signingConfigs 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])
    }
}

Bevor Sie gradle assembleRelease ausführen, müssen Sie 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

Frohe Veröffentlichungen!

5
naufraghi

Erweitere die Antwort von David Vavra, erstelle eine Datei ~/.gradle/gradle.properties und füge 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
      }
    }
  }
5
SRC

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

Siehe das Bild

enter image description here

OK klicken

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

enter image description here

4

Es hat mir ziemlich viel Spaß gemacht, das herauszufinden. Hier ist mein Durchgang.

Kurzanleitung zum Erstellen einer Gradle-Build-Datei in IntelliJ (v.13.1.4) In dieser Kurzanleitung wird vorausgesetzt, 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 Datei zipalign.exe muss sich unter "SDK-ROOT\tools" befinden. Diese Datei befindet sich normalerweise in 'SDK-ROOT\build-tools' und befindet sich unter diesem Ordner im höchsten API-Ordner (Alpha oder Beta, ich empfehle die Alpha-Version).

Für diejenigen unter Ihnen, die direkt hier rein springen 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 Build-Datei (oben) über die Menüoption: Datei-/Projektstruktur erstellen. Wählen Sie hier Facets und klicken Sie auf 'Android-Gradle (App). Von hier aus sehen Sie die Registerkarten "Eigenschaften", "Signieren", "Flavours", "Build-Typen" und "Abhängigkeiten". In dieser Anleitung werden nur "Signieren" und "Build-Typen" verwendet. Geben Sie unter "Build-Typen" (im Abschnitt "Name") einen beliebigen Namen ein, unter dem Sie Ihre Build-Typ-Konfiguration identifizieren möchten, und geben Sie in die anderen 4 Felder Ihre Schlüsselspeicherinformationen ein (indem Sie den Schlüsselspeicherpfad auf den Pfad unter Ihrem App-Ordner einstellen).

Geben Sie unter "Build Types" den Wert "assembleRelease" in das Namensfeld ein, "Debuggable" sollte auf "false" gesetzt sein, "Jni Debug Build" sollte auf "false" gesetzt sein, "Run Proguard" auf "true" und "Zip Align" auf "true". Dadurch wird eine Build-Datei erstellt, 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 außerdem Folgendes 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 DSL-Container Android. Um den Abhängigkeitscontainer aus dem 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, sollten Sie eine Gradle-Build-Datei sehen, die der Datei oben in dieser Anleitung ähnelt. Um Ihre signierte Zip-Version zu erstellen, müssen Sie die Gradle-Tasks öffnen. Sie können zu diesem Fenster gelangen, 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 (aber nicht beschränkt auf): Ihre Gradle-Builddatei befindet sich am falschen Ort. Es gibt zwei Gradle-Builddateien. Eine im Anwendungsstammordner und eine weitere im Anwendungsordner unter dem Anwendungsstamm. Sie müssen Letzteres verwenden.

Sie können auch Fusselprobleme haben. (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 Container Android (oben) stellen:

Android {
        ....
    lintOptions {
        abortOnError false
    }
    ....
}

wenn Sie dies in Ihren DSL-Container Android einfügen, wird eine Fehlerdatei im Erstellungsordner (direkt unter Ihrem App-Ordner) generiert. Der Dateiname sollte in etwa so lauten: "lint-results-release-fatal.html" wird Ihnen die Klasse mitteilen, in der der Fehler aufgetreten ist. Eine andere Datei, die generiert wird, ist eine XML-Datei, die die 'Problem-ID' enthält, die dem Flusenfehler zugeordnet ist. Der Dateiname sollte ungefähr so ​​lauten wie 'lint-results-release-fatal.xml'. Irgendwo in der Nähe des oberen Teils der Datei sehen Sie einen Knoten "Problem", 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 Klassendatei Java direkt über dem Klassennamen ein: @ SuppressLint ("IDOfYourLintProblem"). Möglicherweise müssen Sie 'Android.annotation.SuppressLint;' importieren.

Ihre Java - Klassendatei sollte also so 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 das Beste ist IDEA, wenn Sie den Code ändern, der die Flusenfehler verursacht hat.

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

Kehren Sie anschließend zum Gradle-Aufgabenfenster 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.

4
user2288580

Noch eine andere Herangehensweise an 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 nicht, signingConfig manuell dem Release-Build-Typ zuzuweisen (aus irgendeinem Grund gehe ich manchmal davon aus, dass er automatisch verwendet wird). Es ist auch nicht zwingend erforderlich, Proguard zu aktivieren, aber es ist empfehlenswert.

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

3
argenkiwi

Ich hatte verschiedene Probleme, bei denen ich die folgende Zeile falsch geschrieben 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 Abschnitt Android einfügen:

Android
{
    ....
    signingConfigs {
        release {
          ...
        }
    }
}

anstatt von

Android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

Es ist leicht, diesen Fehler zu machen.

2
Botond Kopacz

ich arbeite in Ubuntu 14.04. vim ~/.bashrc und addiere export Android_KEYSTORE = export Android_KEYALIAS =

und dann in build.gradle gesetzt.

    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 {

        }
    }

}
1
ayyb1988

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

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 Block if-then-else verhindert die Anforderung von Kennwörtern beim Erstellen einer Version. Obwohl der Zweig else nicht erreichbar ist, bringt er Gradle dazu, einen Task install...Release zu erstellen.

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

1
user2768

Ergänzend zu den anderen Antworten können Sie die Datei gradle.properties zusammen mit build.gradle in Ihrem eigenen Modulordner ablegen, falls Ihr Keystore nur für ein Projekt spezifisch ist.

1
cprcrack