¿Cómo crear un archivo apk firmado con Gradle?

Forma 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

Tenga en cuenta que el script de @sdqali (al menos al usar Gradle 1.6) pedirá la contraseña cada vez que invoques cualquier tarea de gradle. Dado que solo lo necesitas cuando haces gradle assembleRelease (o similar), puedes 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 (bajo Android) para que funcione:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

Si desea evitar codificar su almacén de claves y contraseña en la compilación .gradle , puedes usar un archivo de propiedades como se explica aquí: MANEJANDO LAS CONFIGURACIONES DE FIRMA CON GRADLE

Básicamente:

1) cree un myproject.archivo de propiedades en /home/[username]/.firma con dicho contenido:

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

2) crea un gradle.archivo de propiedades (tal vez en la raíz de su directorio de proyecto) con el contenido:

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

3) refiérase a él en su construir.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 permitir que otros que no tienen la clave para construir: 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 O gradle build

(En respuesta a user672009 anterior.)

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 compilación.gradle en él, que incluso funciona muy bien con los sabores de productos, es crear un archivo de gradle separado. Llamémoslo "firma".gradle ' (inclúyalo en su .gitignore). Como si fuera tu constitución.archivo de gradle menos todo lo que no esté relacionado con el inicio de sesión en él.

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

Luego en tu compilación.gradle file incluir esta línea derecha debajo de " aplicar plugin:'android' "

 apply from: 'signing.gradle'

Si no tiene o no usa múltiples sabores, cambie el nombre de "flavor1" a "release" arriba, y debería haber terminado. Si está utilizando sabores continúe.

Finalmente enlaza tus sabores a su configuración de firma correcta en tu compilación.gradle archivo y usted debe estar 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 complicadas hay para hacer esto. Aquí está mi propio camino, donde trato de adherirme a Googles own recomendación. Sin embargo, su explicación no está completamente 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 compilación, sin guardar las contraseñas y archivos de firma en tu ruta de desarrollo de aplicaciones (GIT), es bastante oscura. Aquí están los instrucciones paso a paso aclaradas sobre 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 utiliza y controlado con GIT.

Problema

Obviamente no queremos tener nuestros archivos de firma o contraseña en ningún lugar de el GIT controlado directorio, incluso si somos muy capaces de utilizar .gitignore etc, sigue siendo demasiado arriesgado y fácil de cometer un error. Así que queremos nuestro almacén de claves y archivos de firma fuera.

Solución

Necesitamos hacer tres (3) cosas: {[27]]}

1. Crear un archivo de contraseña para ser utilizado por Android Studio
2. Crear archivo de clave de firma
3. Edite el archivo module build.gradle 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ña del almacén de claves

El primer archivo contiene las contraseñas de texto claro utilizadas en; y las rutas al archivo release-key en (2). Comience rellenando esto, ya que hará que una operación de copiar y pegar sea más fácil para el siguiente paso.

cd $HOME/projects/mydev/

Editar keystore.properties para que su contenido sea:

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

La única parte difícil aquí, es el myStoreFileLocation. Este es la ruta como se ve desde el archivo module build.gradle durante la compilación. Esto generalmente significa un camino similar y relativo a: $HOME/projects/mydev/MyApp/app/build.gradle. Así que con el fin de señalar a la MyApp-release-key.jks archivo, lo que necesitamos poner aquí es:

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

Aquí, también elegimos el alias "myapp" para la clave. Entonces el archivo final debe mirar:

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

(2) Crear el archivo de firma

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

(3) Edite su archivo module gradle.build para usar el anterior

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

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

Entonces, dentro de el 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, puede volver a construir su 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 adición a el post de sdqali (su código se bloqueará en la versión de depuración de compilación mediante el botón "Ejecutar" del IDE):

Puede utilizar 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 reciente, hay una forma GUI que es muy fácil y llena el archivo Gradle también.

1. File -> Project Structure

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

3. Signing tab - > Más imagen para añadir nueva configuración

4. Rellene los datos en el lado derecho

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

6. Usted tendrá que añadir manualmente una línea signingConfig signingConfigs.NameOfYourConfig dentro builtTypes{release{}}

Imágenes:

Dos importantes(!) notas:

(EDIT 12/15)

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

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

Si compilas apk a través de la línea de comandos como yo, puedes proporcionar la configuración de firma como argumentos.

Añadir 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
}

Haz tu signingConfigs así

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

Entonces se ejecuta gradlew así

./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 puedes usar -P la opción de línea de comandos de gradle para facilitar la firma. En tu complexión.gradle, agrega singingConfigs como este:

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

Luego llama a gradle build de esta 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 la línea de comandos.

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

Si ya tiene el archivo keystore, puede ser tan simple como agregar algunos parámetros a su comando de compilació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 es necesario realizar cambios permanentes en tu proyecto Android.

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

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 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 un boilerplate significativo para mover el signingConfigs definición en un archivo separado especially especialmente si necesita hacerlo para múltiples proyectos, que es una razón principal para elegir esta solución sobre la de Destil. Esto puede aliviarse un poco con también incluyendo la línea

apply plugin: 'com.android.application'

En el archivo de credenciales, ya que esto permitirá completar el IDE.

Finalmente, la mayoría de las soluciones aquí hacen no permitir la construcción del proyecto en modo de depuración which que maneja la firma de depuración automáticamente without sin proporcionar una sintáctica si definición signingConfigs no semánticamente válida. Si no necesita producir una versión de 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 compilaciones de depuración en producción.

Esta solución permitirá compilaciones de depuración sin preocuparse en absoluto por las credenciales, pero requerirá credenciales válidas para producir compilaciones de liberación, y requiere muy poco repetitivo. Sin embargo, como un inconveniente podría animar a otros a reemplazar 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 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 compilaciones de release, 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.

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

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

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 debe establecer las contraseñas en su anillo de claves, solo una vez:

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

¡Felices lanzamientos!

Extendiendo la respuesta de David Vavra, crea un archivo ~/.gradle / gradle.propiedades y añadir

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 averiguando esto. Aquí está mi recorrido.

Recorrido de la A a la Z sobre cómo crear un archivo de compilación de gradle en IntelliJ (v. 13. 1. 4) Este recorrido supone que sabes cómo crear un archivo de almacén de claves. Para que este tutorial funcione, necesitará que su archivo de almacén de claves se encuentre en la carpeta de su aplicación y necesitará tener su zipalign.archivo exe que se encuentra 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 compilación de 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 compilar parte de este archivo de compilación (arriba) desde la opción de menú: Estructura de archivo / proyecto Desde aquí, seleccione Facetas y haga clic en ' Android-Gradle (Aplicación). Desde aquí verá las pestañas: 'Propiedades', 'Firma', 'Sabores', 'Tipos de compilación' y 'Dependencias' para este recorrido solo usaremos 'Firma' y ' Compilación Tipo'. En' Tipos de compilación ' (en la sección nombre) ingrese cualquier nombre que desee identificar su configuración de tipo de compilación 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 el 'Tipos de compilación' introduzca el valor 'assembleRelease' en el campo nombre, 'Debuggable' debe ser establecido a false, 'Jni Debug Build' debe ser false, establecer 'Run Proguard' a true y 'Zip Align' a true. Esto generará el archivo de compilación, pero no como representado arriba, tendrá que agregar algunas cosas al archivo de compilación después. La ubicación del archivo ProGuard aquí se establecerá manualmente en el archivo de compilación de gradle. (como se muestra arriba)

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ás que añadir:

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 anterior('dependencies') 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 en el menú IntelliJ, seleccione: Estructura de archivo / proyecto. Desde allí, seleccione Facetas de nuevo y luego Android-Gradle(aplicación). Verá las mismas 5 pestañas como se mencionó anteriormente. Seleccione la pestaña 'Dependencias' y agregue las dependencias que necesite.

Después de todo esto, deberías ver un archivo de compilación de Gradle similar al archivo en la parte superior de este recorrido. Para crear tu versión alineada con zip firmada, tendrás que abrir las tareas de Gradle. Puede acceder a esta ventana seleccionando Ver / Herramienta Windows / Gradle. Desde aquí puede hacer doble clic en ' assembleAssembleRelease. Esto debería generar tu APK desplegable.

Los problemas potenciales que pueden ocurrir al compilar tu versión son (pero no se limitan a): Tu archivo de compilación de Gradle está en el lugar equivocado. 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. Usted debe utilizar este último.

También puede tener problemas de pelusa. (Nota: Android Developer Studio es mucho mejor para detectar problemas de pelusa que IntelliJ, notará esto cuando intente generar un APK firmado desde las opciones del menú)

Para evitar los 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 DSL de Android hará que se genere un archivo de error en la carpeta de compilación (directamente debajo de la carpeta de la aplicación). "pelusa-resultados-liberación-fatal.html' este archivo le dirá la clase donde ocurrió el error. Otro archivo que se generará es un archivo XML que contiene el 'issue ID' asociado con el error lint. El nombre del archivo debería 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á algo similar a 'id =" IDOfYourLintProblem "'

Para corregir este problema, abra el archivo en su proyecto que fue listado en el ' pelusa-resultados-Montadorlease-fatal.archivo html e introduzca la siguiente línea de código en el archivo de clase Java justo encima del nombre de la clase: @SuppressLint ("IDOfYourLintProblem"). Es posible que tenga que importar ' android.anotación.SuppressLint; "

Así que tu 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 lint no siempre es la mejor IDEA, puede ser mejor cambiar el código que causó los errores de lint.

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

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

Si todo tiene éxito debe 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ú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.

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 de claves en un archivo de propiedades separado de la siguiente manera:

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

Si usas git, puedes crear un archivo de texto llamado, por ejemplo, secure.propiedad. Debe asegurarse de excluirlo de su repositorio (si usa git, agregarlo al .archivo gitignore). Entonces, tendría que crear una configuración de firma, como algunas de las otras respuestas indican. 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 olvide asignar el signingConfig al tipo de compilación de la versión 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 más este enfoque que el uso de variables de entorno o la solicitud de entrada del usuario, ya que se puede hacer desde el IDE, cambiando a la realease build type y ejecutar la aplicación, en lugar de tener que usar la línea de comandos.

Android Studio Vaya a Archivo - > Estructura del proyecto o presione Ctrl + Alt + Shift + S

Ver La Imagen

Haga clic en Aceptar

Entonces los signingConfigs se generarán en tu compilación.archivo gradle.

Para complementar las otras respuestas, también puedes colocar tu gradle.archivo de propiedades en su propia carpeta de módulo, junto con build.gradle, solo en caso de que tu almacén de claves sea específico para un proyecto.

Estoy trabajando en Ubuntu14. 04. vim ~/.bashrc y add exportar ANDROID_KEYSTORE= exportar ANDROID_KEYALIAS =

Y luego en 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 {

        }
    }

}

Una alternativa es definir una tarea que se ejecute solo en compilaciones de versiones.

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

Puede solicitar contraseñas desde la línea de comandos:

...

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
  }

  ...
}

...

El bloque if-then-else evita las solicitudes de contraseñas cuando se está creando una versión. Aunque la rama else es inalcanzable, engaña a Gradle para que cree una tarea install...Release.

Backstory . Como señaló https://stackoverflow.com/a/19130098/3664487, " Los scripts de Gradle pueden solicitar la entrada del usuario mediante el Sistema.consola().Método readLine ."Desafortunadamente, Gradle siempre solicitará una contraseña, incluso cuando se está construyendo una versión de depuración(cf. ¿Cómo crear un archivo apk firmado por release usando Gradle?). Afortunadamente, esto se puede superar, como he demostrado anteriormente.

Si no quieres ver No se puede invocar el método readLine() en un objeto null. necesitas escribir en gradle.propiedades primero.

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

Si, como yo, solo quieres poder ejecutar la versión en tu dispositivo con fines de prueba, considera crear un segundo almacén de claves para firmar, para que puedas simplemente poner las contraseñas para ello en tu compilación.gradle sin preocuparse por la seguridad de su almacén de claves de mercado.

Puede crear un nuevo almacén de claves haciendo clic en Build/Generate Signed APK/Create new...