Cómo crear una versión firmada apk archivo utilizando Gradle?

Me gustaría tener mi Gradle construir para crear una versión firmado apk archivo utilizando Gradle.

No estoy seguro de si el código es correcto o si me falta un parámetro al hacer gradle build ?

Esto es parte del código en mi archivo gradle:

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

La compilación gradle termina SUCCESSFUL, y en mi carpeta build/apk sólo veo los archivos ...-release-unsigned.apk y ...-debug-unaligned.apk .

¿Alguna sugerencia sobre cómo solucionar esto?

Manera más fácil que las respuestas anteriores:

Poner esto en ~/.gradle/gradle.properties

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

Modifique su build.gradle esta manera:

 ... signingConfigs { release { storeFile file(RELEASE_STORE_FILE) storePassword RELEASE_STORE_PASSWORD keyAlias RELEASE_KEY_ALIAS keyPassword RELEASE_KEY_PASSWORD } } buildTypes { release { signingConfig signingConfigs.release } } .... 

A continuación, puede ejecutar gradle assembleRelease

Me las arreglé para solucionarlo agregando este código, y construyendo con gradle build :

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

Esto genera un archivo apk de liberación firmada.

Tenga en cuenta que el script de @ sdqali (al menos cuando use Gradle 1.6) solicite la contraseña cada vez que invoque una tarea de gradle. Puesto que sólo lo necesita al hacer gradle assembleRelease (o similar), podría utilizar el siguiente truco:

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

Tenga en cuenta que también tuve que añadir lo siguiente (bajo android) para que funcione:

 buildTypes { release { signingConfig signingConfigs.release } } 

Si desea evitar el hardcoding de su almacén de claves y contraseña en build.gradle , puede utilizar un archivo de propiedades tal como se explica aquí: MANEJO DE FIRMAR CONFIGS CON GRADLE

Básicamente:

1) crear un archivo myproject.properties en /home/[username]/.inscribirse con dicho contenido:

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

2) crear un archivo gradle.properties (quizás en la raíz del directorio del proyecto) con el contenido:

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

3) se refieren a ella en su build.gradle como esto:

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

Al igual que @Destil dijo, pero permiten que otros que no tienen la clave para construir: Manera más fácil que las respuestas anteriores:

Poner esto en ~/.gradle/gradle.properties

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

Modifique su build.gradle esta manera:

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

A continuación, puede ejecutar gradle assembleRelease O gradle build

(En respuesta a user672009 arriba.)

Una solución aún más fácil, si desea mantener sus contraseñas fuera de un repositorio git; Sin embargo, desea incluir su build.gradle en él, que incluso funciona muy bien con los sabores del producto, es crear un archivo gradle independiente. Vamos a llamarlo 'signature.gradle' (incluirlo en su .gitignore). Al igual que si fuera su archivo build.gradle menos todo lo relacionado con la firma en él.

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

Luego, en su archivo build.gradle, incluya esta línea debajo de "apply plugin: 'android'"

  apply from: 'signing.gradle' 

Si no tiene o utiliza varios sabores, cambie el nombre de "sabor1" a "liberación" de arriba, y debe terminar. Si está usando sabores continúe.

Por último vincular sus sabores a su correcta signedConfig en su archivo build.gradle y debe ser terminado.

  ... productFlavors { flavor1 { ... signingConfig signingConfigs.flavor1 } flavor2 { ... signingConfig signingConfigs.flavor2 } } ... 

Esta es una respuesta a user672009 y la adición a la publicación de sdqali (su código se bloqueará en la construcción de la versión de depuración por el botón "Ejecutar" de IDE):

Puede utilizar el código siguiente:

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

En el nuevo Android Studio, hay una forma de interfaz gráfica de usuario que es muy fácil y también rellena el archivo Gradle.

  1. File -> Project Structure

  2. Module -> Elija el módulo principal ('app' u otro nombre personalizado)

  3. Pestaña de Signing -> Más imagen para agregar nueva configuración

  4. Rellenar datos en el lado derecho

  5. El archivo OK y Gradle se crea automáticamente

  6. Tendrás que agregar manualmente una línea signingConfig signingConfigs.NameOfYourConfig dentro de builtTypes{release{}}

De archivo:

Introduzca aquí la descripción de la imagen

Introduzca aquí la descripción de la imagen

Dos notas importantes (!):

(EDIT 12/15)

  1. Para crear APK firmado, tendrías que abrir la pestaña Terminal de Android Studio (la parte inferior de la interfaz principal) y emitir un comando ./gradlew assembleRelease

  2. Si olvidó keyAlias (lo que me sucede a menudo), tendrá que iniciar Build -> Generate Signed APK para iniciar el proceso y ver el nombre de la clave Alias.

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

Si usted construye el apk vía la línea de comando como mí entonces usted puede proporcionar la configuración de firma como argumentos.

Añada esto a su 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 } 

Haga sus signingConfigs como esto

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

A continuación, ejecuta gradlew como este

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

También puede usar la opción de línea de comandos -P de gradle para ayudar a la firma. En su build.gradle, agregue singingConfigs como esto:

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

A continuación, llame a gradle construir así:

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

Puede utilizar -P para establecer storeFile y keyAlias ​​si lo prefiere.

Esta es básicamente la solución de Destil, pero con las opciones de línea de comandos.

Para obtener más detalles sobre las propiedades de gradle, consulte la guía del usuario gradle .

@ La respuesta de Destil es buena si puedes reutilizar la misma configuración en todos los proyectos. Alternativamente, Android Studio viene con un archivo local.properties que tal vez se puede usar en su lugar, pero es supuestamente generado por IDE y no puedo encontrar una forma de extenderlo desde Android Studio.

Esta es una variación de la respuesta de @ jonbo . Esa respuesta permite la configuración específica del proyecto, pero viene con un poco de sobrecarga del desarrollador. Específicamente, se requiere un signingConfigs significativo para mover la definición de signingConfigs en un archivo separado – especialmente si necesita hacerlo para varios proyectos, lo cual es una razón principal para escoger esta solución sobre Destil. Esto puede aliviarse algo incluyendo también la línea

 apply plugin: 'com.android.application' 

En el archivo de credenciales, ya que esto permitirá la finalización del IDE.

Por último, la mayoría de las soluciones aquí no permiten la construcción del proyecto en modo de depuración – que maneja la depuración de firmas automáticamente – sin proporcionar una definición sintácticamente si no semánticamente válida signingConfigs . Si no necesita producir una versión de liberación de una máquina determinada, este paso adicional puede ser visto como un obstáculo innecesario. Por otro lado, puede ser una ayuda contra los compañeros ignorantes o perezosos que ejecutan compilaciones de depuración en la producción.

Esta solución permitirá depurar compilaciones sin preocuparse por las credenciales en absoluto, pero requerirá credenciales válidas para producir compilaciones de lanzamiento, y se necesita muy poco. Sin embargo, como un inconveniente podría animar a otros a reemplazar los valores ficticios con credenciales reales y no hay manera de protegerse contra eso.

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

Esto crea una propiedad ficticia que sirve puramente para producir un archivo de compilación sintácticamente válido. Los valores asignados a las propiedades de ext.signing son irrelevantes en lo que respecta a las compilaciones de depuración. Para habilitar las versiones de lanzamiento, copie ext.signing en signing.gradle y reemplace los valores ficticios con credenciales válidas.

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

Por supuesto, signing.gradle debe ser ignorado por VCS.

Firma automática de aplicaciones con Gradle cuando se utiliza git

Es increíble cuántas maneras complicadas hay para hacer esto. Aquí está mi propio camino, donde intento adherirme a la recomendación de Googles. Sin embargo, su explicación no está totalmente clara, así que describiré el procedimiento para Linux en detalle.


Descripción:

Las instrucciones predeterminadas de Google para firmar automáticamente una aplicación durante la compilación, sin guardar las contraseñas y los archivos de firmas en la ruta de desarrollo de la aplicación (GIT), son bastante oscuras. Aquí están las instrucciones detalladas paso a paso cómo hacerlo.

Supuestos iniciales:

Usted tiene una aplicación llamada "MyApp" en un directorio dado por la siguiente ruta de acceso: $HOME/projects/mydev/MyApp . Sin embargo, el directorio MyApp se utiliza y se controla con GIT.

Introduzca aquí la descripción de la imagen

Problema

Obviamente, no queremos tener nuestros archivos de firma o contraseña en cualquier parte del directorio controlado por GIT, incluso si somos muy capaces de usar .gitignore etc, todavía es demasiado arriesgado y fácil de cometer un error. Así que queremos nuestros archivos de keystore y firma fuera.

Solución

Necesitamos hacer tres (3) cosas:

  1. Crear un archivo de contraseñas para ser utilizado por Android Studio
  2. Crear archivo de clave de firma
  3. Edite el archivo build.gradle del módulo para usar (1) y (2).

Para este ejemplo nombramos los dos archivos:

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

Podemos poner ambos de estos archivos aquí:

 cd $HOME/projects/mydev/ 

(1) Crear el archivo de contraseña del almacén de claves

El primer archivo contiene las contraseñas de texto claro utilizadas en; Y rutas al archivo de clave de liberación en (2). Comience con el llenado de esto, ya que hará una operación de copia y pegar más fácil para el siguiente paso.

 cd $HOME/projects/mydev/ 

Edite keystore.properties para que su contenido sea:

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

La única parte difícil aquí, es myStoreFileLocation . Esta es la ruta de acceso vista desde el archivo build.gradle del módulo durante la compilación. Esto suele significar un camino similar y relativo a: $HOME/projects/mydev/MyApp/app/build.gradle . Así que para apuntar al archivo MyApp-release-key.jks , lo que necesitamos poner aquí es:

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

Aquí, también elegimos el alias "myapp" para la clave. A continuación, el archivo final debe buscar:

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

(2) Crear el archivo de firma

El segundo archivo se genera automáticamente al crear la clave de firma. Si no tienes otras aplicaciones y ésta es tu única tienda de claves, crea el archivo con:

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

Esto le pedirá dos contraseñas y un montón de información. (Lo mismo que en Android Studio.) Ahora copia / pega tus contraseñas previamente elegidas.

(3) Edite su módulo gradle.build para usar lo anterior

Las siguientes partes deben estar presentes en el archivo de compilación de Gradle de la aplicación / módulo. En primer lugar, agregue las siguientes líneas fuera y antes de su android {} bloque.

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

Luego, dentro del bloque android {} , agregue:

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

Ahora, desde shell, puedes volver a crear tu aplicación con:

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

Esto debería generar una aplicación correctamente firmada que se pueda utilizar en Google Play.

Casi todas las plataformas ahora ofrecen algún tipo de llavero, por lo que no hay razón para dejar claras contraseñas de texto alrededor.

Propongo una solución sencilla que utiliza el módulo Python Keyring (principalmente el complemento de la consola) y un wrapper mínimo alrededor de Groovy ['do', 'something'].execute()

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

Con esta función, la sección signingConfigs se convierte en:

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

Antes de ejecutar el gradle assembleRelease usted debe fijar las contraseñas en su llavero, solamente una vez:

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

¡Lanzamientos felices!

Me divertí bastante con esto. Aquí está mi paseo.

Recorrido de A a Z en cómo crear un archivo de compilación de gradle en IntelliJ (v.13.1.4) Este paso a través supone que sabe cómo crear un archivo de almacén de claves. Para que este tutorial funcione, necesitará que su archivo de almacén de claves esté ubicado en la carpeta de su aplicación y necesitará que su archivo zipalign.exe se encuentre en "SDK-ROOT \ tools". Este archivo se encuentra normalmente en 'SDK-ROOT \ build-tools' y debajo de esta carpeta estará en la carpeta api más alta (alfa o beta, recomiendo la versión alfa).

Para aquellos de ustedes que deseen saltar directamente aquí es el archivo de compilación 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 { compile fileTree(dir: 'libs', include: ['*.jar']) compile 'com.android.support:support-v4:20.0.0' compile 'com.android.support:appcompat-v7:20.0.0' } 

Usted puede construir parte de este archivo de construcción (arriba) de la opción de menú: Archivo / Estructura del proyecto Desde aquí seleccione Facetas y haga clic en 'Android-Gradle (App). A partir de aquí, verá pestañas: 'Propiedades', 'Firma', 'Sabores', 'Tipos de construcción' y 'Dependencias' para este paseo. Sólo usaremos 'Firma' y 'Tipos de construcción'. En "Tipos de construcción", ingrese cualquier nombre que desee identificar y, en los otros 4 campos, ingrese la información de su almacén de claves (estableciendo la ruta del almacén de claves en la carpeta de su aplicación).

Bajo 'Tipos de construcción' introduzca el valor 'assembleRelease' en el campo de nombre, 'Debuggable' debería establecerse en false, 'Jni Debug Build' debería ser falso, establecer 'Proguard' en true y 'Zip Align' en true. Esto generará el archivo de compilación, pero no como se muestra arriba, tendrá que agregar algunas cosas al archivo de compilación después. La ubicación del archivo de ProGuard aquí se establecerá manualmente en el archivo de compilación gradle. (Como se ha descrito anteriormente)

Los contenedores DSL que tendrá que agregar después son los siguientes:

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

También tendrá que agregar:

 dependencies { compile fileTree(dir: 'libs', include: ['*.jar']) compile 'com.android.support:support-v4:20.0.0' compile 'com.android.support:appcompat-v7:20.0.0' } 

Tenga en cuenta este contenedor DSL anterior ('dependencias') debe estar en la parte inferior del archivo de configuración, pero no dentro del contenedor androide DSL. Para crear el contenedor de dependencias en el menú IntelliJ, seleccione: Archivo / Estructura del proyecto. Desde allí, selecciona Facetas de nuevo y luego Android-Gradle (aplicación). Verá las mismas 5 pestañas mencionadas anteriormente. Seleccione la pestaña "Dependencias" y agregue las dependencias que necesita.

Después de todo esto se debe ver un archivo de compilación de Gradle similar al archivo en la parte superior de este paseo. Para crear su firmado alineado con zip liberación que tendrá que abrir las tareas de Gradle. Puede acceder a esta ventana seleccionando Vista / Ventana de herramientas / Gradle. Desde aquí se puede hacer doble clic en 'assembleAssembleRelease. Esto debería generar su APK desplegable.

Los problemas potenciales que pueden ocurrir al compilar su lanzamiento son (pero no limitados a): Su archivo de compilación de Gradle está en el lugar incorrecto. Hay dos archivos de compilación de Gradle; Uno en la carpeta raíz de la aplicación y otro en la carpeta de la aplicación bajo la raíz de la aplicación. Debe utilizar este último.

También puede tener problemas con pelusas. (Nota: Android Developer Studio es mucho mejor al detectar problemas de Lint que IntelliJ lo notará al intentar generar un APK firmado desde las opciones del menú)

Para evitar problemas de pelusa, deberá colocar el siguiente contenedor DSL dentro del contenedor android (en la parte superior):

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

Poner esto dentro de su contenedor androide DSL hará que un archivo de error se genere en la carpeta de construcción (directamente en la carpeta de la aplicación) el nombre del archivo debe ser algo así como 'lint-results-release-fatal.html' este archivo le dirá el La clase donde ocurrió el error. Otro archivo que se generará es un archivo XML que contiene el 'ID de problema' asociado con el error de pelusas. El nombre del archivo debe ser algo así como 'lint-results-release-fatal.xml'. En algún lugar cerca de la parte superior del archivo verá un nodo 'issue' dentro del cual verás algo similar a 'id = "IDOfYourLintProblem"'

Para corregir este problema abra el archivo en su proyecto que se enumeró en el archivo 'lint-results-assembleRelease-fatal.html' e ingrese la siguiente línea de código en el archivo de la clase Java justo encima del nombre de la clase: @SuppressLint ("IDOfYourLintProblem "). Es posible que tenga que importar 'android.annotation.SuppressLint;'

Por lo tanto, su archivo de clase java debería aparecer así:

 package com.WarwickWestonWright.developers4u.app.CandidateArea; import android.annotation.SuppressLint; ... other imports @SuppressLint("IDOfYourLintProblem") public class SearchForJobsFragment extends Fragment {... rest of your class definition} 

Tenga en cuenta que la supresión de errores de pelusa no siempre es la mejor IDEA que puede ser mejor para cambiar el código que causó los errores de pelusa.

Otro problema que podría ocurrir potencialmente es si no ha establecido la variable de entorno para la variable de entorno Gradle HOME. Esta variable se denomina 'GRADLE_HOME' y debe establecerse la ruta del directorio inicial de gradle, algo así como 'C: \ gradle-1.12' A veces también puede configurar la variable de entorno para 'ANDROID_HOME' SDK-Root \ sdk '

Después de hacer esto, vuelva a la ventana de tareas de Gradle y haga doble clic en el comando assembleAssembleRelease.

Si todo tiene éxito, debería ser capaz de ir a la carpeta app \ build \ apk y encontrar su archivo APK desplegable.

Tuve varios problemas que puse la siguiente línea en un lugar equivocado:

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

Asegúrese de poner las partes signedConfigs dentro de la sección android:

 android { .... signingConfigs { release { ... } } } 

en lugar de

 android { .... } signingConfigs { release { ... } } 

Es fácil cometer este error.

Otra aproximación al mismo problema. Como no se recomienda almacenar ningún tipo de credencial dentro del código fuente, decidimos establecer las contraseñas para el almacén de claves y el alias clave en un archivo de propiedades independiente de la siguiente manera:

 key.store.password=[STORE PASSWORD] key.alias.password=[KEY PASSWORD] 

Si utiliza git, puede crear un archivo de texto llamado, por ejemplo, secure.properties. Debe asegurarse de excluirlo de su repositorio (si utiliza git, agregándolo al archivo .gitignore). Entonces, usted necesitaría crear una configuración de firma, como algunas de las otras respuestas indican. La única diferencia está en cómo cargar las credenciales:

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

Nunca olvide asignar el signedConfig al tipo de compilación de lanzamiento manualmente (por alguna razón a veces asumo que se usará automáticamente). Además, no es obligatorio habilitar proguard, pero es recomendable.

Nos gusta este enfoque mejor que usar variables de entorno o solicitar la entrada del usuario, ya que puede hacerse desde el IDE, cambiando al tipo de compilación realease y ejecutando la aplicación, en lugar de tener que usar la línea de comandos.

Ampliando la respuesta de David Vavra, cree un archivo ~ / .gradle / gradle.properties y añada

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

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

Para complementar las otras respuestas, también puede colocar su archivo gradle.properties en su propia carpeta de módulo, junto con build.gradle, en caso de que su keystore sea específico de un proyecto.

Trabajo en Ubuntu14.04. Vim ~ / .bashrc y agregue la exportación ANDROID_KEYSTORE = exportar ANDROID_KEYALIAS =

and then 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 { } } } 

An alternative is to define a task that runs only on release builds.

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

You can request passwords from the command line:

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

The if-then-else block prevents requests for passwords when you're building a release. Although the else branch is unreachable, it tricks Gradle into creating an install...Release task.

Backstory . As noted by https://stackoverflow.com/a/19130098/3664487 , " Gradle scripts can prompt for user input using the System.console().readLine method ." Unfortunately, Gradle will always request a password, even when you're building a debug release (cf. How to create a release signed apk file using Gradle? ). Fortunately, this can be overcome, as I have shown above.

if you don't want to see Cannot invoke method readLine() on null object. you need write in gradle.properties first.

 KEYSTORE_PASS=***** ALIAS_NAME=***** ALIAS_PASS=***** 

If you, like me, just want to be able to run the release on your device for testing purposes, consider creating a second keystore for signing, so you can simply put the passwords for it into your build.gradle without worrying for your market key store security.

You can create a new keystore by clicking Build/Generate Signed APK/Create new…

FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.