¿Cómo crear un archivo apk de lanzamiento con Gradle?

Me gustaría tener mi comstackción de Gradle para crear un archivo apk de lanzamiento con Gradle.

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

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

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

La comstackción gradle termina EXITOSA, y en mi carpeta build/apk solo veo los archivos ...-release-unsigned.apk y ...-debug-unaligned.apk .

¿Alguna sugerencia sobre cómo resolver esto?

Una manera más fácil que las respuestas anteriores:

Pon esto en ~/.gradle/gradle.properties

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

Modifica tu build.gradle así:

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

Entonces puedes ejecutar gradle assembleRelease

Pude resolverlo agregando este código y gradle build con gradle build :

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

Esto genera un archivo apk de lanzamiento firmado.

Tenga en cuenta que el script de @ sdqali (al menos cuando se usa Gradle 1.6) solicitará la contraseña cada vez que invoque una tarea gradle. Como solo lo necesita al hacer gradle assembleRelease (o similar), puede usar 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 agregar lo siguiente (en android) para que funcione:

 buildTypes { release { signingConfig signingConfigs.release } } 

Si desea evitar la encoding física de su keystore y contraseña en build.gradle , puede usar un archivo de propiedades como se explica aquí: MANEJO DE LA FIRMA CONFIGURA CON GRADLE

Básicamente:

1) cree un archivo myproject.properties en /home/[nombredeusuario]/.signing con dichos contenidos:

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

2) cree un archivo gradle.properties (tal vez en la raíz del directorio de su proyecto) con los contenidos:

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

3) refiérase a él en su build.gradle así:

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

Como dijo @Destil, pero permite que otros que no tienen la clave para construir: una manera más fácil que las respuestas anteriores:

Pon esto en ~/.gradle/gradle.properties

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

Modifica tu build.gradle así:

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

Entonces puedes ejecutar gradle assembleRelease OR gradle build

(En respuesta al usuario672009 anterior).

Una solución aún más fácil, si desea mantener sus contraseñas fuera de un repository git; Sin embargo, si desea incluir su build.gradle en ella, que incluso funciona bien con los sabores de los productos, debe crear un archivo gradle por separado. Vamos a llamarlo ‘signing.gradle’ (inclúyalo en su .gitignore). Como si fuera tu archivo build.gradle menos todo lo que no está relacionado con el inicio de sesión.

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

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

  apply from: 'signing.gradle' 

Si no tiene o no usa múltiples sabores, cambie el nombre de “sabor1” a “soltar” arriba, y debería haber terminado. Si estás usando sabores, continúa.

Por último, vincula tus sabores a su signatureConfig correcto en tu archivo build.gradle y deberías haber terminado.

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

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

Es increíble cuántas formas intrincadas hay para hacer esto. Aquí está mi propio camino, donde bash adherirme a la recomendación de Googles. Sin embargo, su explicación no está del todo clara, por lo que describiré el procedimiento para Linux en detalle.


Descripción:

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

Supuestos iniciales:

Tiene una aplicación llamada “MyApp” en un directorio dado por la siguiente ruta: $HOME/projects/mydev/MyApp . Sin embargo, el directorio MyApp se usa y controla con GIT.

enter image description here

Problema

Obviamente, no queremos tener nuestros archivos de firmas o contraseñas en ningún lugar del directorio controlado por GIT, incluso si somos capaces de usar .gitignore , etc., sigue siendo demasiado arriesgado y fácil cometer un error. Por lo tanto, queremos que nuestro keystore y archivos de firmas estén fuera.

Solución

Necesitamos hacer tres (3) cosas:

  1. Crea un archivo de contraseña 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 archivos aquí:

 cd $HOME/projects/mydev/ 

(1) Crear el archivo de contraseñas de 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 llenando esto, ya que facilitará el proceso de copiar y pegar 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 como se ve desde el archivo build.gradle del módulo durante la comstackción. Esto generalmente significa una ruta similar y relativa a: $HOME/projects/mydev/MyApp/app/build.gradle . Entonces, para apuntar al archivo MyApp-release-key.jks , lo que tenemos que poner aquí es:

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

Aquí, también elegimos el alias “myapp” para la clave. Entonces el archivo final debería verse:

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

(2) Crea el archivo de firma

El segundo archivo se genera automáticamente cuando crea la clave de firma. Si no tiene otras aplicaciones y este es su único almacén de claves, cree 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 mucha información. (Lo mismo que en Android Studio). Ahora copie / pegue las contraseñas previamente elegidas.

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

Las siguientes partes deben estar presentes en el archivo de comstackción Gradle de tu aplicación / módulo. Primero, agregue las siguientes líneas afuera y antes de su bloque de android {} .

 //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 {} , agrega:

 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 comstackr tu aplicación con:

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

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

Esta es una respuesta a user672009 y además de la publicación de sdqali (su código se bloqueará en la creación de la versión de depuración mediante el botón “Ejecutar” de IDE):

Puedes usar el siguiente código:

 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 Android Studio más nuevo, hay una forma de GUI que es muy fácil y también llena el archivo Gradle.

  1. File -> Project Structure

  2. Module -> Elija el módulo principal (‘aplicación’ u otro nombre personalizado)

  3. Signing -> Imagen más para agregar nueva configuración

  4. Rellenar datos en el lado derecho

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

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

Imágenes:

enter image description here

enter image description here

Dos notas importantes (!):

(EDIT 12/15)

  1. Para crear APK firmado, debe 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 sucede con frecuencia para mí), deberá iniciar Build -> Generate Signed APK para iniciar el proceso y ver el nombre de la clave Alias.

Si comstack apk a través de la línea de comando como yo, puede proporcionar la configuración de la firma como argumentos.

Agregue 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 este

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

Entonces ejecutas gradlew como este

 ./gradlew assembleRelease -PstoreFile="keystore.jks" -PstorePassword="password" -PkeyAlias="alias" -PkeyPassword="password" 
 android { compileSdkVersion 17 buildToolsVersion "19.0.3" defaultConfig { minSdkVersion 9 targetSdkVersion 18 } File signFile = rootProject.file('sign/keystore.properties') if (signFile.exists()) { Properties properties = new Properties() properties.load(new FileInputStream(signFile)) signingConfigs { release { storeFile rootProject.file(properties['keystore']) storePassword properties['storePassword'] keyAlias properties['keyAlias'] keyPassword properties['keyPassword'] } } } buildTypes { release { runProguard true zipAlign true proguardFile rootProject.file('proguard-rules.cfg') signingConfig signingConfigs.release } debug { runProguard false zipAlign true } } } 

También puede usar la opción de línea de comando -P de gradle para ayudar a la firma. En tu build.gradle, agrega singingConfigs así:

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

Luego llame al comstackdor de gradle de la siguiente manera:

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

Puede usar -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 comando.

Para obtener más información sobre las propiedades de gradle, consulte la guía de usuario de gradle .

Si ya tiene el archivo de almacén de claves, puede ser tan simple como agregar algunos parámetros a su comando de comstackción:

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

No son necesarios cambios permanentes en tu proyecto de Android.

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

La respuesta de @ Destil es buena si puede reutilizar la misma configuración en todos los proyectos. Alternativamente, Android Studio viene con un archivo local.properties que quizás se pueda usar en su lugar, pero supuestamente es generado por IDE y no puedo encontrar una manera 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 una repetición significativa para mover la definición de signingConfigs a un archivo separado, especialmente si necesita hacerlo para múltiples proyectos, que es una razón principal para elegir esta solución sobre la de Destil. Esto se puede aliviar al incluir también la línea

 apply plugin: 'com.android.application' 

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

Finalmente, la mayoría de las soluciones aquí no permiten construir el proyecto en modo de depuración, que maneja la firma de depuración de manera automática, sin proporcionar una definición sintáctica, sino semánticamente válida, de la signingConfigs . Si no necesita producir una comstackción de liberación desde una máquina determinada, este paso adicional puede verse como un obstáculo innecesario. Por otro lado, puede ser una ayuda contra colegas ignorantes o perezosos que ejecutan comstackciones de depuración en producción.

Esta solución permitirá comstackciones de depuración sin preocuparse por las credenciales en absoluto, pero requerirá credenciales válidas para producir comstackciones de versiones y requiere muy poco texto. Sin embargo, como inconveniente , podría alentar a otros a reemplazar los valores ficticios con credenciales reales y no hay forma 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 comstackción sintácticamente válido. Los valores asignados a las propiedades de ext.signing son irrelevantes en lo que respecta a las comstackciones de depuración. Para habilitar versiones ext.signing , 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 ignorar signing.gradle .

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

Propongo una solución simple que utiliza el módulo de llavero de Python (principalmente el keyring script de consola complementario) y un envoltorio mínimo alrededor de la función Groovy ['do', 'something'].execute() :

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

Usando 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 gradle assembleRelease debes establecer las contraseñas en tu llavero, solo una vez:

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

¡Estrenos felices!

Extendiendo la respuesta por David Vavra, crea un archivo ~ / .gradle / gradle.properties y agrega

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

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

Me divertí bastante imaginando esto. Aquí está mi recorrido.

Pasos detallados de A a Z sobre cómo crear un archivo de comstackción gradle en IntelliJ (v.13.1.4). Este recorrido supone que usted 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 generalmente se encuentra 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 desean saltar directamente aquí, está el archivo de comstackció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' } 

Puede crear parte de este archivo de comstackción (arriba) desde la opción del menú: Archivo / Estructura del proyecto Desde aquí seleccione Facetas y haga clic en ‘Android-Gradle (Aplicación). Desde aquí verá tabs: ‘Propiedades’, ‘Firmar’, ‘Sabores’, ‘Tipos de comstackción’ y ‘Dependencias’ para este recorrido, simplemente utilizaremos ‘Firmar’ y ‘Tipos de comstackción’. En “Tipos de comstackción” (en la sección de nombre) ingrese cualquier nombre que desee para identificar su configuración de comstackción y en los otros 4 campos ingrese su información de almacén de claves (configurando la ruta del almacén de claves como la que está debajo de la carpeta de la aplicación).

En ‘Tipos de comstackción’, ingrese el valor ‘assembleRelease’ en el campo de nombre, ‘Debuggable’ debe establecerse en falso, ‘Jni Debug Build’ debe ser falso, establezca ‘Run Proguard’ en verdadero y ‘Zip Align’ en verdadero. Esto generará un archivo de comstackción, pero no como se muestra arriba, después tendrá que agregar algunas cosas al archivo de comstackción. La ubicación del archivo ProGuard aquí se establecerá manualmente en el archivo de comstackción gradle. (como se muestra arriba)

Los contenedores DSL que deberá 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 deberás 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 que este contenedor DSL arriba (‘dependencias’) debe estar en la parte inferior del archivo de configuración, pero no dentro del contenedor DSL de Android. Para construir el contenedor de dependencias desde el menú IntelliJ, seleccione: Archivo / Estructura del proyecto. A partir de allí, seleccione Facets nuevamente y luego Android-Gradle (aplicación). Verá las mismas 5 tabs que se mencionaron anteriormente. Seleccione la pestaña ‘Dependencias’ y agregue las dependencias que necesita.

Una vez hecho todo esto, debería ver un archivo de construcción de Gradle similar al archivo en la parte superior de este recorrido. Para comstackr su versión firmada con cierre de cremallera, deberá abrir las tareas de Gradle. Puede acceder a esta ventana seleccionando Ver / Herramientas Windows / Gradle. Desde aquí, puede hacer doble clic en ‘assembleAssembleRelease’. Esto debería generar su APK desplegable.

Los problemas potenciales que pueden ocurrir al comstackr su versión son (pero no se limitan a): Su archivo de construcción Gradle está en el lugar equivocado. Hay dos archivos de comstackción Gradle; uno en la carpeta raíz de la aplicación y otro en la carpeta de la aplicación debajo de la raíz de la aplicación. Debes usar este último.

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

Para evitar problemas con las fibras, deberá colocar el siguiente contenedor DSL dentro del contenedor de Android (en la parte superior):

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

poner esto dentro de su contenedor DSL de Android causará que se genere un archivo de error en la carpeta de comstackción (directamente debajo de la carpeta de la aplicación) el nombre del archivo debería ser algo como ‘lint-results-release-fatal.html’. Este archivo le dirá 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 pelusa. 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 ‘problema’ dentro del cual verá algo similar a ‘id =’ IDOfYourLintProblem ”

Para corregir este problema, abra el archivo de su proyecto que figura en el archivo ‘lint-results-assembleRelease-fatal.html’ e ingrese la siguiente línea de código en el archivo Java Class justo encima del nombre de la clase: @SuppressLint (“IDOfYourLintProblem “). Puede que tenga que importar ‘android.annotation.SuppressLint;’

Entonces su archivo de clase java debería aparecer como:

 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 cambiar el código que causó los errores de pelusa.

Otro problema que podría ocurrir es si no ha configurado la variable de entorno para la variable de entorno Gradle HOME. Esta variable se llama ‘GRADLE_HOME’ y debe establecerse como la ruta del directorio de inicio de gradle, algo así como ‘C: \ gradle-1.12’ A veces también puede querer configurar la variable de entorno para ‘ANDROID_HOME’ establecer esto en ‘YOUR- SDK-Root \ sdk ‘

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

Si todo es exitoso, debería poder ir a la carpeta app \ build \ apk y encontrar su archivo APK desplegable.

Tuve varios problemas que puse la siguiente línea en el 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úrate de poner las partes de signingConfigs dentro de la sección de Android:

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

en lugar de

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

Es fácil cometer este error.

Sin embargo, otro enfoque para el 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 separado de la siguiente manera:

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

Si usa git, puede crear un archivo de texto llamado, por ejemplo, secure.properties. Debe asegurarse de excluirlo de su repository (si usa git, agréguelo al archivo .gitignore). Entonces, necesitaría crear una configuración de firma, como indican algunas de las otras respuestas. La única diferencia está en cómo cargaría 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 olvides asignar el signingConfig al tipo de comstackció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 utilizar variables de entorno o solicitar la entrada del usuario porque se puede hacer desde el IDE, cambiando al tipo de comstackción de realease y ejecutando la aplicación, en lugar de tener que usar la línea de comando.

Android Studio Go to File -> Project Structure or press Ctrl+Alt+Shift+S

See The Image

enter image description here

Haga clic en Aceptar

Then the signingConfigs will generate on your build.gradle file.

enter image description here

To complement the other answers, you can also place your gradle.properties file in your own module folder, together with build.gradle, just in case your keystore is specific to one project.

i am work in Ubuntu14.04. vim ~/.bashrc and add export ANDROID_KEYSTORE= export 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…