Android Studio: Wie generiert man signiertes APK mit Gradle?

Ich habe auf Google und SO gesucht, kann aber meine Antwort nicht finden.

Dies ist das erste Mal, dass ich mit dem Gradle-System arbeite, und ich bin jetzt an dem Punkt, ein signiertes APK zum Hochladen auf Google Play zu generieren (Projekt wird aus Eclipse importiert).

Jetzt habe ich den Teil gelesen Hier die Sie hinzufügen sollten signingConfigs zu deinem build.gradle.

Ich habe diese Zeilen hinzugefügt und jetzt habe ich gesehen, dass Sie rennen müssen ./gradlew assembleRelease aber das Ausführen in meinen CMD-Rückgaben

‘gradle’ wird nicht als interner oder externer Befehl, lauffähiges Programm oder Batch-Datei erkannt.

Ich habe auch versucht, mit der rechten Maustaste auf build.gradle zu klicken und es auszuführen, wobei ich sagte, dass es erfolgreich war, aber sobald ich im build/apk-Ordner nachsehe, wird nur eine Datei aufgerufen app-debug-unaligned.apk.

Wie generiere ich also das signierte APK mit dem Gradle-System?

Es gibt drei Möglichkeiten, Ihren Build gemäß der zu generieren buildType. (In Ihrem Fall ist es Release, aber es kann beliebig benannt werden.)

1. Gehen Sie im rechten Bereich von Android Studio zu Gradle Task und suchen Sie nach assembleRelease oder assemble(#your_defined_buildtype) unter Modulaufgaben

2. Gehen Sie im linken Bereich zu Build-Variante und wählen Sie den Build aus der Dropdown-Liste aus

3. Wechseln Sie im Datei-Explorer zum Projektstammverzeichnis, öffnen Sie cmd/terminal und führen Sie Folgendes aus:

   Linux: ./gradlew assembleRelease or assemble(#your_defined_buildtype)

   Fenster: gradlew assembleRelease or assemble(#your_defined_buildtype)

Wenn Sie (nur) einen Release-Build erstellen möchten, können Sie verwenden Bauen > Generieren Sie eine signierte apk. Für andere Build-Typen sind nur die oben genannten drei Optionen verfügbar.

Sie finden die generierte APK in Ihrer module/build Verzeichnis mit dem Namen des Build-Typs darin.

Es ist möglich, jedes vorhandene Gradle-Projekt von Android Studio zu nehmen und es von der Befehlszeile aus zu erstellen/signieren, ohne Dateien zu bearbeiten. Dies macht es sehr gut, Ihr Projekt in der Versionskontrolle zu speichern, während Sie Ihre Schlüssel und Passwörter getrennt halten:

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

Sie können diesen Code verwenden

android {
   ...
    signingConfigs {
        release {
            storeFile file("../your_key_store_file.jks")
            storePassword "some_password"
            keyAlias "alias_name"
            keyPassword "key_password"
        }
    }

    buildTypes {

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

dann von Ihrem Terminal ausführen

./gradlew assembleRelease

Sie erhalten die apk unter

your-android-app/build/outputs/apk/your-android-app-release.apk

Ich denke, das kann dir helfen https://www.timroes.de/2013/09/22/handling-signing-configs-with-gradle/ dann einfach auswählen Release von dem Build Variants

Dies ist für Kotlin DSL (build.gradle.kts).
Sie können Ihre Eigenschaften entweder in definieren local.properties Datei im Projektstammverzeichnis oder definieren Sie sie als Umgebungsvariablen (was besonders nützlich für CIs wie GitHub Action ist).

// See https://stackoverflow.com/q/60474010
fun getLocalProperty(key: String) = gradleLocalProperties(rootDir).getProperty(key)

fun String?.toFile() = file(this!!)

// Could also use System.getenv("VARIABLE_NAME") to get each variable individually
val environment: Map<String, String> = System.getenv()

android {
    signingConfigs {
        create("MyAppSigningConfig") {
            keyAlias = getLocalProperty("signing.keyAlias") ?: environment["SIGNING_KEY_ALIAS"] ?: error("Error!")
            storeFile = (getLocalProperty("signing.storeFile") ?: environment["SIGNING_STORE_FILE"] ?: error("Error!")).toFile()
            keyPassword = getLocalProperty("signing.keyPassword") ?: environment["SIGNING_KEY_PASSWORD"] ?: error("Error!")
            storePassword = getLocalProperty("signing.storePassword") ?: environment["SIGNING_STORE_PASSWORD"] ?: error("Error!")
            enableV1Signing = true
            enableV2Signing = true
        }
    }

    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs["MyAppSigningConfig"]
            // ...
        }
    }
}

Mein Projekt/local.properties Datei:

signing.keyAlias=foo
signing.keyPassword=bar
# also called keystore
signing.storePassword=abcdefgh
signing.storeFile=C\:\\my-files\\my-keystore.jks

Fügen Sie NICHT Ihre hinzu local.properties Datei an Ihr Versionskontrollsystem (wie Git), da es Ihre geheimen Informationen wie Passwörter usw. der Öffentlichkeit zugänglich macht (wenn es sich um ein öffentliches Repository handelt).

Generieren Sie Ihr APK mit einer der 3 Möglichkeiten, die in dieser Antwort erwähnt wurden.

Wenn Sie in bestimmten Ländern leben, verwenden Sie unbedingt ein VPN.

Schritt 1: Führen Sie diesen Befehl in der Befehlszeile aus:

keytool -genkey -v -keystore ~/key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias key

Es wird Sie nach einigen Informationen wie Passwort, Name usw. fragen und diese eingeben.

Schritt 2: Erstellen Sie einen Dateinamen key.properties in Ihrem Android-Ordner. Schreiben Sie diese Zeilen in die erstellte Datei

storePassword=<password from previous step>
keyPassword=<password from previous step>
keyAlias=key
storeFile=<location of the key store file, such as ~/key.jks>

Halten Sie die Datei key.properties privat, bewahren Sie immer eine Sicherungskopie der Datei key.properties auf und veröffentlichen Sie sie niemals öffentlich.

Schritt 3: Ersetzen Sie die folgenden Zeilen in Gradle auf App-Ebene

def keystoreProperties = new Properties()
    def keystorePropertiesFile = rootProject.file('key.properties')
    if (keystorePropertiesFile.exists()) {
        keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
    }
android {
signingConfigs {
  release {
    keyAlias keystoreProperties['keyAlias']
    keyPassword keystoreProperties['keyPassword']
    storeFile file(keystoreProperties['storeFile'])
    storePassword keystoreProperties['storePassword']
  }
}
buildTypes {
  release {
    signingConfig signingConfigs.release
  }
}
}

Schritt 4:

keytool -list -v -keystore ~/key.jks -alias key -storepass <password> -keypass <password>

Schritt5:
Ich empfehle, APK mit Android Studio zu erstellen.
Build > Generate Signed Bundle/APK...

Build-Menü > Signiertes APK generieren