如何使用Gradle创建一个发布签名的apk文件？

Question

我想让我的Gradle构建使用Gradle创建一个发布签名的apk文件.

我不确定代码是否正确或者我在做gradle build什么时缺少参数？

这是我的gradle文件中的一些代码:

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

gradle构建完成SUCCESSFUL,在我的build/apk文件夹中我只看到...-release-unsigned.apk和...-debug-unaligned.apk文件.

关于如何解决这个问题的任何建议？

Answer 1

比以前的答案更容易:

把它放进去 ~/.gradle/gradle.properties

RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****

修改你build.gradle喜欢这个:

...    
signingConfigs {

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

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

然后你就可以跑了 gradle assembleRelease

Answer 2

我设法解决它添加此代码,并构建gradle build:

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

这会生成一个签名版本的apk文件.

Answer 3

请注意,@ sdqali的脚本(至少在使用Gradle 1.6时)会在您调用任何 gradle任务时随时询问密码.由于您在执行gradle assembleRelease(或类似)时只需要它,您可以使用以下技巧:

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

请注意,我还必须添加以下(在android下)以使其工作:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

Answer 4

如果您想避免在build.gradle中对密钥库和密码进行硬编码,可以使用如下所述的属性文件:使用GRADLE处理签名配置

基本上:

1)在/home/[username]/.signing中创建一个myproject.properties文件,其中包含以下内容:

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

2)使用以下内容创建一个gradle.properties文件(可能位于项目目录的根目录下):

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

3)在build.gradle中引用它,如下所示:

    if(project.hasProperty("MyProject.properties")
        && new File(project.property("MyProject.properties")).exists()) {

    Properties props = new Properties()
    props.load(new FileInputStream(file(project.property("MyProject.properties"))))

    signingConfigs {
        release {
            storeFile file(props['keystore'])
            storePassword props['keystore.password']
            keyAlias props['keyAlias']
            keyPassword props['keyPassword']
        }
    }
}

Answer 5

就像@Destil所说,但允许其他没有密钥构建的人:比以前的答案更容易:

把它放进去 ~/.gradle/gradle.properties

RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****

修改你build.gradle喜欢这个:

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

然后你可以运行gradle assembleRelease OR gradle build

Answer 6

使用git时使用Gradle自动进行应用程序签名

令人惊讶的是,有多少令人费解的方式可以做到这一点.这是我自己的方式,我尝试坚持谷歌自己的建议.但是,他们的解释并不完全清楚,因此我将详细介绍Linux的过程.

描述:

用于在构建期间自动签署应用程序的默认Google说明,而不会将密码和签名文件保留在应用程序开发(GIT)路径中,这一说法相当模糊.以下是有关如何执行此操作的明确说明.

初步假设:

您在以下路径指定的目录中有一个名为"MyApp"的应用程序: $HOME/projects/mydev/MyApp.但是,MyApp目录由GIT使用和控制.

问题

我们显然不希望在GIT控制的目录中的任何地方都有我们的签名或密码文件,即使我们非常能够使用.gitignore等,它仍然过于冒险而且容易出错.所以我们想要外面的密钥库和签名文件.

解

我们需要做三(3)件事:

1. 创建供Android Studio使用的密码文件
2. 创建签名密钥文件
3. 编辑模块build.gradle文件以使用(1)和(2).

在本例中,我们将这两个文件命名为:

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

我们可以在这里放置这两个文件:

cd $HOME/projects/mydev/

(1)创建密钥库密码文件

第一个文件包含用于的明文密码; 和(2)中释放密钥文件的路径.首先填写此内容,因为它将使下一步的复制粘贴操作更容易.

cd $HOME/projects/mydev/

编辑,keystore.properties以便它的内容是:

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

这里唯一棘手的部分是myStoreFileLocation.这是在构建期间从模块build.gradle文件中看到的路径.这通常意味着类似于以下的路径:$HOME/projects/mydev/MyApp/app/build.gradle.所以为了指向MyApp-release-key.jks 文件,我们需要放在这里:

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

在这里,我们还为密钥选择了"myapp"别名.然后最终文件应该是:

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

(2)创建签名文件

创建签名密钥时会自动生成第二个文件.如果您没有其他应用程序且这是您唯一的密钥库,则使用以下命令创建文件:

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

这将要求您提供两个密码和一堆信息.(与Android Studio中的内容相同.)现在复制/粘贴以前选择的密码.

(3)编辑模块gradle.build文件以使用上述内容

您的app/module的Gradle构建文件中需要包含以下部分.首先,添加以下行外和之前的android {}块.

//def keystorePropertiesFile = rootProject.file("$HOME/.android/keystore.properties")
def keystorePropertiesFile = rootProject.file("../../keystore.properties")
def keystoreProperties = new Properties()
keystoreProperties.load(new FileInputStream(keystorePropertiesFile))

然后,里面的android {}块,加:

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

现在来自shell,您可以使用以下命令重新构建您的应用:

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

这应该会生成一个可以在Google Play中使用的正确签名的应用.

Answer 7

(回复上面的user672009.)

如果您想将密码保存在git存储库之外,那么这是一个更简单的解决方案; 但是,想要在其中包含build.gradle,即使对于产品风格也很好,就是创建一个单独的gradle文件.我们称之为'signing.gradle'(将其包含在你的.gitignore中).就像它是你的build.gradle文件减去与登录无关的一切.

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

然后在你的build.gradle文件中包含这行"apply plugin:'android'"

 apply from: 'signing.gradle'

如果您没有或使用多种口味,请将"flavor1"重命名为"release",然后您应该完成.如果你正在使用口味继续.

最后将你的口味链接到build.gradle文件中正确的signingConfig,你应该完成了.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

Answer 8

这是对user672009的回复以及对sdqali帖子的补充(他的代码将在IDE的"运行"按钮构建调试版本时崩溃):

您可以使用以下代码:

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 {

        }
    }

}

Answer 9

如果你像我这样通过命令行构建apk,那么你可以提供签名配置作为参数.

将此添加到您的 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
}

让你signingConfigs这样

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

然后你执行gradlew这样的

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

Answer 10

如果您已经拥有密钥库文件,则可以像在构建命令中添加一些参数一样简单:

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

无需对您的Android项目进行永久性更改.

资料来源:http://www.tinmith.net/wayne/blog/2014/08/gradle-sign-command-line.htm

Answer 11

在较新的Android Studio中,有一种非常简单的GUI方式,它也可以填充Gradle文件.

1. File -> Project Structure

2. Module -> 选择主模块('app'或其他自定义名称)

3. Signing 选项卡 - >添加图像以添加新配置

4. 在右侧填写数据

5. 确定并自动创建Gradle文件

6. 您将手动在signingConfig signingConfigs.NameOfYourConfig里面添加一行builtTypes{release{}}

图片:

两个重要的(!)笔记:

(编辑12/15)

1. 要创建签名的APK,您必须打开Android Studio的终端选项卡(主界面的底部)并发出命令 ./gradlew assembleRelease

2. 如果您忘记了keyAlias(我经常会发生什么),您必须Build -> Generate Signed APK启动该过程并查看别名键的名称.

Answer 12

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 13

您还可以使用gradle的-P命令行选项来帮助签名.在你的build.gradle中,添加如下的singingConfigs:

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

然后像这样调用gradle build:

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

如果您愿意,可以使用-P设置storeFile和keyAlias.

这基本上是Destil的解决方案,但使用命令行选项.

有关gradle属性的更多详细信息,请查看gradle用户指南.

Answer 14

对于 Kotlin 脚本 (build.gradle.kts)

您不应将签名凭据直接放在build.gradle.kts文件中。相反，凭据应该来自不受版本控制的文件。

将一个文件signing.properties其中模块特定build.gradle.kts被发现。不要忘记将它添加到您的.gitignore文件中！

签名.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 15

弄清楚这个问题让我很开心。这是我的演练。

关于如何在 IntelliJ (v.13.1.4) 中创建 gradle 构建文件的 A 到 Z 演练 本演练假定您知道如何制作密钥库文件。要使本教程正常运行，您需要将密钥库文件放在应用程序文件夹中，并且需要将 zipalign.exe 文件放在“SDK-ROOT\tools”中。此文件通常位于“SDK-ROOT\build-tools”中，在此文件夹下，它将位于最高的 api 文件夹中（alpha 或 beta 我建议使用 alpha 版本）。

对于那些希望直接进入这里的人来说，这是 gradle 构建文件。

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

您可以从菜单选项构建此构建文件的一部分（上图）：文件/项目结构 从这里选择 Facets 并单击“Android-Gradle(App)”。从这里您将看到选项卡：“属性”、“签名”、“风味”、“构建类型”和“依赖关系”，本演练我们将仅使用“签名”和“构建类型”。在“构建类型”下（在名称部分）输入您希望标识构建类型配置的任何名称，并在其他 4 个字段中输入您的密钥库信息（将密钥库路径设置为您的应用程序文件夹下的那个）。

在“Build Types”下的名称字段中输入值“assembleRelease”，“Debuggable”应设置为false，“Jni Debug Build”应设置为false，将“Run Proguard”设置为true，将“Zip Align”设置为true。这将生成构建文件，但不是如上所示，之后您必须向构建文件添加一些内容。此处的 ProGuard 文件位置将在 gradle 构建文件中手动设置。（如上图所示）

之后您必须添加的 DSL 容器如下：

android {
    ....
    compileSdkVersion 19
    buildToolsVersion '20.0.0'
    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }
    ....
}

您还必须添加：

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

注意上面的这个 DSL 容器（'dependencies'）应该在配置文件的底部，而不是在 android DSL 容器内。为了从 IntelliJ 菜单构建依赖项容器，请选择：文件/项目结构。从那里再次选择 Facets，然后选择 Android-Gradle(app)。您将看到与上述相同的 5 个选项卡。选择“依赖项”选项卡并添加您需要的依赖项。

完成所有这些后，您应该会看到一个类似于本演练顶部文件的 Gradle 构建文件。要构建已签名的 zip 对齐版本，您需要打开 Gradle 任务。您可以通过选择 View/Tool Windows/Gradle 来访问此窗口。从这里您可以双击“assembleAssembleRelease”。这应该会生成您的可部署 APK。

编译发布时可能出现的潜在问题是（但不限于）：您的 Gradle 构建文件位于错误的位置。有两个 Gradle 构建文件；一个在您的应用程序根文件夹中，另一个在应用程序根目录下的 app 文件夹中。您必须使用后者。

您也可能有棉绒问题。（注意：Android Developer Studio 在发现 Lint 问题方面比 IntelliJ 好得多，您会在尝试从菜单选项生成签名 APK 时注意到这一点）

要解决 lint 问题，您需要将以下 DSL 容器放入 android 容器（位于顶部）：

android {
        ....
    lintOptions {
        abortOnError false
    }
    ....
}

把它放在你的 android DSL 容器中会导致在 build 文件夹中生成一个错误文件（直接在你的应用程序文件夹下）文件名应该类似于'lint-results-release-fatal.html'这个文件会告诉你发生错误的类。将生成的另一个文件是一个 XML 文件，其中包含与 lint 错误关联的“问题 ID”。文件名应该类似于“lint-results-release-fatal.xml”。在文件顶部附近的某个地方，您将看到一个节点“问题”，在其中您将看到类似于“id="IDOfYourLintProblem"”的内容

要更正此问题，请打开“lint-results-assembleRelease-fatal.html”文件中列出的项目中的文件，然后在 Java 类文件中类名称正上方输入以下代码行：@SuppressLint("IDOfYourLintProblem ”）。您可能需要导入 'android.annotation.SuppressLint;'

所以你的 java 类文件应该如下所示：

package com.WarwickWestonWright.developers4u.app.CandidateArea;

import android.annotation.SuppressLint;
... other imports

@SuppressLint("IDOfYourLintProblem")
public class SearchForJobsFragment extends Fragment {... rest of your class definition}

请注意，抑制 lint 错误并不总是最好的 IDEA，您最好更改导致 lint 错误的代码。

另一个可能发生的问题是，如果您没有为 Gradle HOME 环境变量设置环境变量。这个变量被命名为'GRADLE_HOME'，应该设置gradle主目录的路径，比如'C:\gradle-1.12'有时你可能还想为'ANDROID_HOME'设置环境变量，将它设置为'YOUR- SDK-Root\sdk'

完成后返回 Gradle 任务窗口并双击 assembleAssembleRelease。

如果一切顺利，您应该能够转到文件夹 app\build\apk 并找到可部署的 APK 文件。

Answer 16

如果您可以在所有项目中重复使用相同的配置,那么@ Destil的答案很好.或者,Android Studio附带了一个local.properties可以替代使用的文件,但它应该是IDE生成的,我找不到从Android Studio中扩展它的方法.

这是@ jonbo答案的变体.该答案允许项目特定的设置,但它带来一些开发人员的开销.具体而言,需要使用重要的样板来将signingConfigs定义移动到单独的文件中 - 特别是如果您需要为多个项目执行此操作,这是在Destil上选择此解决方案的主要原因.这可以通过将有所缓解还包括线

apply plugin: 'com.android.application'

在凭证文件中,因为这将允许IDE完成.

最后,大多数的解决方案在这里也不会允许建立在调试模式下的项目-自动处理调试签名-不提供语法如果没有有效的语义signingConfigs定义.如果您不需要从给定的机器生成发布版本,则可以将此额外步骤视为不必要的障碍.另一方面,它可以帮助在生产中运行调试版本的无知或懒惰的同事.

这个解决方案将允许调试构建而不必担心凭据,但它需要有效的凭证来生成发布版本,并且它只需要很少的样板.然而,作为一个缺点,它可能会鼓励其他人用真实证书替换虚拟值,并且没有办法防止这种情况发生.

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

这将创建一个虚拟属性,纯粹用于生成语法上有效的构建文件.ext.signing就调试版本而言,分配给属性的值是无关紧要的.为了使发行版本,复制ext.signing到signing.gradle与有效凭证代替虚拟值.

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

当然,signing.gradleVCS应该忽略.

Answer 17

对于 Groovy (build.gradle)

您不应将签名凭据直接放入build.gradle文件中。相反，凭据应该来自不受版本控制的文件。

将文件signing.properties放在找到模块特定build.gradle的位置。不要忘记将其添加到您的.gitignore文件中！

签名属性

storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey

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

Answer 18

几乎所有平台现在都提供某种密钥环,因此没有理由留下明文密码.

我提出了一个简单的解决方案,它使用Python Keyring模块(主要是配套控制台脚本keyring)和Groovy ['do', 'something'].execute() 功能的最小包装器:

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

使用此功能,该signingConfigs部分变为:

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

在运行之前,gradle assembleRelease您必须在密钥环中设置密码,只需一次:

$ keyring set google-play android.keystore # will be prompted for the passwords
$ keyring set google-play com.example.app

快乐发布!

Answer 19

扩展David Vavra的答案,创建一个文件〜/ .gradle/gradle.properties并添加

RELEASE_STORE_FILE=/path/to/.keystore
RELEASE_KEY_ALIAS=XXXXX
RELEASE_STORE_PASSWORD=XXXXXXXXX
RELEASE_KEY_PASSWORD=XXXXXXXXX

然后在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
      }
    }
  }

Answer 20

现在是 2019 年，我需要使用 V1（jar 签名）或 V2（完整 APK 签名）对 APK 进行签名。我用谷歌搜索“生成签名的 apk gradle”，它把我带到了这里。所以我在这里添加我原来的解决方案。

signingConfigs {
    release {
        ...
        v1SigningEnabled true
        v2SigningEnabled true
    }
}

我原来的问题：如何使用 build.gradle 文件中的 V1（Jar 签名）或 V2（完整 APK 签名）