android - una - google play app signing

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

Question

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

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

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

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

La construcción de Gradle termina con éxito, y en mi carpeta de build/apk solo veo los archivos ...-release-unsigned.apk y ...-debug-unaligned.apk .

¿Alguna sugerencia sobre cómo resolver esto?

Answer 1

Aplicación automática de firma con Gradle al usar git

Es sorprendente la cantidad de formas complicadas que existen para hacer esto. Aquí es a mi manera, donde trato de adherirme a la propia recommendation Google. Sin embargo, su explicación no es completamente clara, por lo que describiré el procedimiento para Linux en detalle.

Descripción:

Las recommendation predeterminadas de recommendation para firmar automáticamente una aplicación durante la compilación, sin mantener las contraseñas y los archivos de firma en la ruta de desarrollo de su aplicación (GIT), son bastante poco claras. Aquí están las instrucciones paso a paso aclaradas sobre cómo hacerlo.

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

Problema

Obviamente, no queremos tener nuestros archivos de firma o contraseña en ningún lugar 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 que nuestros archivos de almacenamiento de claves y de firma estén fuera.

Solución

Necesitamos hacer tres (3) cosas:

1. Crear 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 estos dos 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 completando esto, ya que facilitará la operación 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 que se ve desde el módulo build.gradle file durante la compilació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 necesitamos 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) Crear 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 te 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 módulo gradle.build archivo para usar el anterior

Las siguientes partes deben estar presentes en el archivo de compilación Gradle de su aplicación / módulo. Primero, agregue las siguientes líneas fuera 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 de 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 reconstruir 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.

Answer 2

(En respuesta al user672009 arriba.)

Una solución aún más fácil, si desea mantener sus contraseñas fuera de un repositorio git; sin embargo, si desea incluir su build.gradle, que incluso funciona bien con sabores de productos, es crear un archivo gradle separado. Llamémosle ''sign.gradle'' (inclúyalo en su .gitignore). Como si fuera su 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 debajo de "aplicar complemento: ''android''"

 apply from: ''signing.gradle''

Si no tiene o utiliza varios tipos de sabores, cambie el nombre de "sabor1" a "liberar" que aparece más arriba, y debería terminar. Si estás utilizando sabores continúa.

Finalmente, vincule sus sabores a su firma correcta Configura en su archivo build.gradle y debería terminar.

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

Answer 3

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

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

Answer 4

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

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

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 configurar las contraseñas en su llavero, solo una vez:

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

¡Felices lanzamientos!

Answer 5

Como dijo @Destil, pero permita que otros que no tienen la clave para construir: de manera más sencilla que las respuestas anteriores:

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

Entonces puedes ejecutar gradle assembleRelease O gradle build

Answer 6

En Android Studio más reciente, 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. Pestaña Signing -> Más imagen para agregar nueva configuración

4. Rellene los datos en el lado derecho

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

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

Imágenes:

Dos notas importantes (!):

(EDITAR 12/15)

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

Answer 7

Esta es una respuesta al user672009 y además de la publicación de sdqali (su código se bloqueará al compilar la versión de depuración con 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 {
}
}
}

Answer 8

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 puede ser usado en su lugar, pero supuestamente es 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 de desarrollador. Específicamente, se requiere una signingConfigs significativa para mover la definición de signingConfigs a un archivo separado, especialmente si necesita hacerlo para múltiples proyectos, que es la razón principal para elegir esta solución en lugar de Destil. Esto puede ser algo aliviado al incluir también la línea

apply plugin: ''com.android.application''

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

Finalmente, la mayoría de las soluciones aquí no permiten compilar el proyecto en modo de depuración, que maneja la firma de depuración de manera automática, sin proporcionar una definición de signingConfigs sintácticamente, si no semánticamente válida. Si no necesita producir una versión de lanzamiento 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 construcciones de depuración en producción.

Esta solución permitirá las compilaciones de depuración sin preocuparse por las credenciales, pero requerirá credenciales válidas para generar las compilaciones de lanzamiento, y requiere muy poca preparación. Sin embargo, como inconveniente , podría alentar 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 únicamente 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 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, la signing.gradle debe ser ignorada por VCS.

Answer 9

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

Ponga 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

Answer 10

Me divertí bastante pensando en esto. Aquí está mi recorrido.

Tutorial de la A a la Z sobre cómo crear un archivo de compilación gradle en IntelliJ (v.13.1.4) Este tutorial 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 esté ubicado en ''SDK-ROOT / tools''. Este archivo generalmente se encuentra en ''SDK-ROOT / build-tools'' y debajo de esta carpeta estará en la carpeta de 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 crear parte de este archivo de compilación (arriba) desde la opción de menú: Archivo / Estructura del 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 ''Tipos de compilación''. En ''Tipos de compilación'' (en la sección de nombres) ingrese cualquier nombre que desee para identificar su configuración de tipo de compilación y en los otros 4 campos ingrese su información del almacén de claves (configurando la ruta del almacén de claves en la carpeta de su aplicación).

Debajo de los ''Tipos de compilación'', ingrese el valor ''assembleRelease'' en el campo de nombre, ''Debuggable'' debe establecerse en falso, ''Jni Debug Build'' debe ser falso, establecer ''Ejecutar progreso'' en verdadero y ''Zip Align'' en verdadero. Esto generará un archivo de compilación, pero no como se muestra arriba, luego tendrá que agregar algunas cosas al archivo de compilación. La ubicación del archivo ProGuard aquí se configurará 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 (''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ú de IntelliJ, seleccione: Archivo / Estructura del proyecto. Desde allí, seleccione Facetas de nuevo y luego Android-Gradle (aplicación). Verás las mismas 5 pestañas como se mencionó anteriormente. Seleccione la pestaña ''Dependencias'' y agregue las dependencias que necesite.

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

Los posibles problemas que pueden surgir al compilar su lanzamiento son (pero no se limitan a): su archivo de compilación 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. Debes utilizar este último.

También puede tener problemas de pelusas. (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 problemas con las pelusas, deberá colocar el siguiente contenedor DSL dentro del contenedor de Android (en la parte superior):

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

al poner esto dentro de su contenedor DSL de Android, se generará un archivo de error en la carpeta de compilación (directamente debajo de la carpeta de la aplicación). El nombre del archivo debería ser algo así como ''lint-results-release-fatal.html''. Este archivo le indicará la La clase donde se produjo 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 "problema" de nodo dentro del cual verá algo similar a ''id = "IDOfYourLintProblem"''

Para corregir este problema, abra el archivo en 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 "). Es posible que tenga que importar ''android.annotation.SuppressLint;''

Así que 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 suprimir los errores de pelusa no siempre es la mejor IDEA, es posible que sea mejor que cambie el código que causó los errores de pelusa.

Otro problema que podría surgir es si no ha configurado la variable de entorno para la variable de entorno HOME de Gradle. Esta variable se llama ''GRADLE_HOME'' y debe configurarse como la ruta del directorio de inicio de gradle, algo como ''C: / gradle-1.12''. Algunas veces, también puede configurar la variable de entorno para ''ANDROID_HOME'' y establecer esto en ''YOUR- SDK-Root / sdk ''

Una vez hecho esto, vuelva a la ventana de tareas de Gradle y haga doble clic en assembleAssembleRelease.

Si todo tiene éxito, debería poder ir a la carpeta app / build / apk y encontrar su archivo APK desplegable.

Answer 11

Otro enfoque más 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 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.Debería asegurarse de excluirlo de su repositorio (si usa git, agréguelo al archivo .gitignore). Luego, deberá crear una configuración de firma, como lo 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 se olvide de asignar el firmanteConfig 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 el programa, pero es recomendable.

Nos gusta este enfoque mejor que usar variables de entorno o solicitar la entrada del usuario porque se puede hacer 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.

Answer 12

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

Agrega esto a tu 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 como esta

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

Entonces ejecutas gradlew

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

Answer 13

Si desea evitar la codificación de su almacén de claves y contraseña en build.gradle , puede usar un archivo de propiedades como se explica aquí: MANEJAR LA CONFIGURACIÓN DE LA FIRMA CON GRADLE

Básicamente:

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

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

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

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

3) refiérase a él en su build.gradle de esta manera:

 if(project.hasProperty("MyProject.properties")
&& new File(project.property("MyProject.properties")).exists()) {
Properties props = new Properties()
props.load(new FileInputStream(file(project.property("MyProject.properties"))))
signingConfigs {
release {
storeFile file(props[''keystore''])
storePassword props[''keystore.password'']
keyAlias props[''keyAlias'']
keyPassword props[''keyPassword'']
}
}
}

Answer 14

Si ya tiene el archivo de almacén de claves, 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 de Android.

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

Answer 15

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 como este:

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

Entonces llama a Gradle construir así:

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

Puede usar -P para configurar 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, consulte la guía del usuario de gradle .

Answer 16

Tenga en cuenta que el script de @ sdqali (al menos cuando use Gradle 1.6) solicitará la contraseña cada vez que invoque cualquier tarea de gradle. Ya 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 (en Android) para que funcione:

buildTypes {
release {
signingConfig signingConfigs.release
}
}

Answer 17

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 colocar las piezas de firma en la sección de Android:

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

en lugar de

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

Es fácil cometer este error.

Answer 18

gradle build resolverlo 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 firmado.

Answer 19

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

Answer 20

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

...
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 if-then-elsebloque evita las solicitudes de contraseñas cuando creas una versión. Aunque la elserama es inalcanzable, engaña a Gradle para crear una install...Releasetarea.

Historia de fondo . Como se señaló en https://.com/a/19130098/3664487 , "los scripts de Gradle pueden solicitar la entrada del usuario utilizando el método System.console (). ReadLine ". Desafortunadamente, Gradle siempre solicitará una contraseña, incluso cuando esté creando una versión de depuración (consulte ¿Cómo crear un archivo apk firmado con Gradle? ). Afortunadamente, esto se puede superar, como he mostrado anteriormente.

Answer 21

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

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

Answer 22

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

Ver la imagen

Haga clic en Aceptar

Luego, la firmaConfigs generará en su archivo build.gradle.

Answer 23

Estoy trabajando en Ubuntu14.04. vim ~ / .bashrc y agregar exportación ANDROID_KEYSTORE = exportar ANDROID_KEYALIAS =

y luego en el conjunto build.gradle.

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

Answer 24

Si usted, como yo, solo quiere poder ejecutar la versión en su dispositivo con fines de prueba, considere crear un segundo almacén de claves para firmar, de modo que pueda poner las contraseñas en su build.gradle sin preocuparse por su clave de mercado seguridad de la tienda

Puede crear un nuevo almacén de claves haciendo clic en Crear / Generar APK firmado / Crear nuevo ...

Answer 25

si no desea ver No se puede invocar el método readLine () en un objeto nulo. Necesitas escribir primero en gradle.properties .

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

Answer 26

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