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

Question 1

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

No estoy seguro 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 compilación de gradle termina CON ÉXITO, y en mi build/apk carpeta solo veo la ...-release-unsigned.apk y ...-debug-unaligned.apk archivos

¿Alguna sugerencia sobre cómo resolver esto?

Question 2

Logré 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 lanzamiento firmado.

Question 3

Si desea evitar codificar su almacén de claves y contraseña en construir.gradlepuede usar un archivo de propiedades como se explica aquí: MANEJO DE CONFIGURACIONES DE FIRMA CON GRADLE

Básicamente:

1) crear un archivo myproject.properties en /casa/[username]/.firma con tales 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) referirse a él en su construir.gradle Me gusta esto:

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

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

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

Question 4

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

Es sorprendente cuántas formas complicadas hay para hacer esto. Aquí está mi propio camino, donde trato de adherirme a los propios de Google. recomendación. Sin embargo, su explicación no es del todo clara, por lo que describiré el procedimiento para Linux en detalle.

Descripción:

El valor por defecto Instrucciones de Google para firmar automáticamente una aplicación durante la compilación, sin guardar las contraseñas y los archivos de firma en la ruta de desarrollo de su aplicación (GIT), es bastante oscuro. Aquí están las 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 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 cometer un error. Así que queremos que nuestro almacén de claves y archivos de firma estén fuera.

Solución

Necesitamos hacer tres (3) cosas:

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

Para este ejemplo llamamos a los dos archivos:

keystore.properties
MyApp-release-key.jks

Podemos poner ambos archivos aquí:

cd $HOME/projects/mydev/

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

El primer archivo contiene las contraseñas de texto claro utilizadas en; y rutas al archivo de clave de versión en (2). Comience completando esto, ya que facilitará la operación de copiar y pegar para el siguiente paso.

cd $HOME/projects/mydev/

Editar keystore.properties por lo que su contenido es:

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

La única parte difícil aquí, es el myStoreFileLocation. este es el camino visto desde el módulo build.gradle archivo durante la compilación. Esto generalmente significa una ruta similar y relativa a: $HOME/projects/mydev/MyApp/app/build.gradle. Entonces, para señalar el MyApp-release-key.jks
archivo, 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) 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 le pedirá dos contraseñas y un montón de información. (Lo mismo que en Android Studio). Ahora copie y pegue las contraseñas elegidas anteriormente.

(3) Edite su módulo `gradle.build` archivo para usar lo 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 de y antes de tu android {} cuadra.

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

Luego, en el interior los android {} bloquear, añadir:

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

ACTUALIZAR: 2019-04-02

Versiones más recientes de keytool y algo te está diciendo que debes usar un PKCS12 archivo de claves basado en lugar del original/predeterminado como uso arriba. Ellos luego continúe diciéndole que debe convertir al nuevo formato abierto PKCS12. Sin embargo, parece que las herramientas de desarrollo de Android aún no están listas para esto, porque si lo hace, obtendrá los siguientes errores extraños:

com.android.ide.common.signing.KeytoolException: No se pudo leer la clave XXX de la tienda “F:\XXX\XXX.jks”: error al obtener la clave: el bloque final dado no se completó correctamente. Tales problemas pueden surgir si se usa una clave incorrecta durante el descifrado.

¡Así que no uses una clave convertida!

Question 5

Como dijo @Destil, pero permita que otros que no tienen la clave construyan: una 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 Me gusta esto:

...    
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 correr gradle assembleRelease
O
gradle build