Comment créer un communiqué signé fichier apk en utilisant Gradle?

J'ai réussi à résoudre l'ajout de ce code, et construire avec gradle build:

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

Cela génère un communiqué signé fichier apk.

Si vous voulez éviter de coder en dur le fichier de clés & mot de passe dans construire.gradle, vous pouvez utiliser un fichier de propriétés, comme expliqué ici: LA MANIPULATION DE LA SIGNATURE DE CONFIGS AVEC GRADLE

En gros:

1) créer un myproject.fichier de propriétés à /home/[nom d'utilisateur]/.signature avec ce contenu:

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

2) créer un gradle.fichier de propriétés (peut-être à la racine de votre répertoire de projet) avec le contenu:

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

3) voir dans votre construire.gradle comme ceci:

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

Automatique de l'application de la signature avec Gradle lors de l'utilisation de git

Il est incroyable de voir comment beaucoup de alambiqué manières, il y a pour ce faire. Voici mon propre chemin, où j'essaie de respecter Googles propre recommandation. Cependant, leur explication n'est pas entièrement clair, donc je vais décrire la procédure pour Linux en détail.

---

Description:

La valeur par défaut Google instructions automatiquement la signature d'un app
lors de la compilation, sans garder les mots de passe et les fichiers de signatures
dans le développement de votre application (GIT) chemin, c'est plutôt obscure. Voici les
précisé étape par étape les instructions sur la façon de le faire.

Hypothèses initiales:

Vous avez une application appelée "MyApp" dans un répertoire donné par le chemin d'accès suivant:
$HOME/projects/mydev/MyApp. Cependant, le répertoire MyApp est utilisé et
contrôlé avec GIT.

Problème

De toute évidence, nous ne voulons pas notre signature ou le mot de passe des fichiers de n'importe où dans
le GIT contrôlé répertoire, même si nous sommes très en mesure d'utiliser .gitignore etc, il est encore trop risqué et facile de faire une erreur. Si nous voulons que notre fichier de stockage des clés et la signature des fichiers à l'extérieur.

Solution

Nous avons besoin de trois (3) choses:

1. Créer un fichier de mot de passe pour être utilisé par Android Studio
2. Créer de la clé de signature de fichier
3. Modifier le module build.gradle fichier à utiliser (1) et (2).

Pour cet exemple, le nom de deux fichiers:

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

Nous pouvons mettre ces deux fichiers ici:

cd $HOME/projects/mydev/

(1) Créer le fichier de mot de passe du fichier de clés

Le premier fichier contient le texte en clair des mots de passe; et les chemins de la libération-le fichier de clés dans (2). Commencer à le remplir, car elle permettra de faire un copier coller l'opération plus facile pour la prochaine étape.

cd $HOME/projects/mydev/

Modifier keystore.properties de sorte que son contenu est:

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

La seule partie délicate ici, est le myStoreFileLocation. C'est le chemin vu de le module build.gradle fichier lors de la compilation. Cela signifie généralement un chemin similaire par rapport à d': $HOME/projects/mydev/MyApp/app/build.gradle. Donc pour le MyApp-release-key.jks
fichier, ce que nous devons faire ici est:

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

Ici, nous avons aussi choisi le "myapp" alias pour la clé. Ensuite, le fichier final devrait ressembler à:

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

(2) Créer le fichier de signature

Le deuxième fichier est généré automatiquement lorsque vous créez la clé de signature.
Si vous n'avez pas d'autres apps et c'est votre seul fichier de clés, puis créer le fichier avec:

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

Il vous demandera de deux mots de passe et un tas d'info. (Même chose que dans Android Studio.) Copier/coller votre déjà choisi les mots de passe.

(3) Modifiez votre module gradle.build fichier à utiliser le ci-dessus

Les éléments suivants doivent être présents dans votre application/module du fichier de build Gradle. Tout d'abord, ajoutez les lignes suivantes à l'extérieur et avant votre android {} bloc.

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

Puis, à l'intérieur de la android {} bloc, ajouter:

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

Maintenant à partir de la coquille, vous pouvez re-construire votre application avec:

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

Cela devrait générer un bien signé application qui peut être utilisé dans le Jeu de Google.

---

Mise à JOUR: 2019-04-02

Les versions plus récentes de keytool et quelque chose est vous dire que vous devriez utiliser un PKCS12 en fonction clé au lieu de l'original/par défaut que j'utilise ci-dessus. Ils puis aller sur de vous dire que vous devez les convertir au nouveau format PKCS12. Cependant, il semble que l'Android outils de développement ne sont pas tout à fait prêt pour cela encore, car si vous le faites, vous recevrez des erreurs étranges:

com.android.ide.common.signing.KeytoolException: Impossible de lire la clé
XXX de magasin "F:\XXX\XXX.jks": Obtenir les Clés a échoué: compte tenu de bloc final pas
matelassés. De tels problèmes peuvent survenir si une mauvaise clé est utilisée au cours de
le déchiffrement.

Donc ne l'utilisez pas un converti à la clé!

C'est une réponse à user672009 et plus sdqali post (son code crash sur le renforcement de la version de débogage de l'IDE du bouton "Exécuter"):

Vous pouvez utiliser le code suivant:

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 {

        }
    }

}

Si vous avez le fichier de magasin de clés déjà, il peut être aussi simple que l'ajout d'un peu de paramètres pour que votre commande de construction:

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

Pas de changements permanents à votre projet Android nécessaires.

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

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

@Destil la réponse est bonne si vous pouvez réutiliser la même configuration sur tous les projets. Sinon, Android Studio est livré avec un local.properties fichier qui peut peut-être être utilisé à la place, mais il est soi-disant en IDE et je ne peux pas trouver un moyen de l'étendre à partir de dans Android Studio.

C'est une variante de @jonbo réponse. Cette réponse permet paramètres spécifiques d'un projet, mais il est livré avec un peu de développeur de frais généraux. Plus précisément, d'importants standard est nécessaire pour déplacer le signingConfigs définition dans un fichier séparé -- surtout si vous avez besoin de le faire pour de multiples projets, qui est l'une des principales raisons pour choisir cette solution sur Destil de l'. Cela peut être quelque peu atténué par aussi y compris la ligne

apply plugin: 'com.android.application'

dans les informations d'identification de fichier, car cela permettra l'IDE d'achèvement.

Enfin, la plupart des solutions ne pas permettre de construire le projet en mode debug -- qui gère debug-signature automatiquement-sans fournir un point de vue syntaxique si pas sémantiquement valide signingConfigs définition. Si vous n'avez pas besoin de produire un communiqué de construire à partir d'une machine donnée, cette étape supplémentaire peut être vu comme un obstacle inutile. D'autre part, il peut être une aide contre les ignorants ou paresseux collègues de course les versions de débogage de la production.

Cette solution permettra de débogage sans se soucier des informations d'identification à tous, mais cela nécessite des informations d'identification valides pour produire les versions release, et il prend très peu de passe-partout. Cependant, comme un inconvénient il pourrait encourager les autres à remplacer les valeurs factices avec de vrais pouvoirs et il n'y a aucun moyen de se protéger contre cela.

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

Cela crée un mannequin de la propriété qui sert uniquement à produire un syntaxiquement valide du fichier build. Les valeurs affectées à ext.signing's propriétés sont sans incidence sur les versions de débogage aller. Pour activer les versions release, copie ext.signing en signing.gradle et remplacer les valeurs factices avec des informations d'identification valides.

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

Bien sûr, signing.gradle doit être ignoré par VCS.

L'extension de la réponse de David Vavra,créer un fichier ~/.gradle/gradle.propriétés et ajouter

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

Puis dans la construction.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
      }
    }
  }

J'ai eu beaucoup de plaisir en pensant ça. Ici est ma maison.

De A à Z de plain-pied sur la façon de créer un fichier de build gradle dans IntelliJ (v. 13.1.4)
Cette promenade-à travers suppose que vous savez comment faire un fichier de magasin de clés.
Pour ce tutoriel fonctionne, vous aurez besoin de votre fichier de magasin de clés pour être situé dans votre dossier app et vous aurez besoin d'avoir votre zipalign.exe fichier situé dans le 'SDK-ROOT\outils". Ce fichier se trouve généralement dans 'SDK-ROOT\build-outils" et dans ce dossier, il sera dans le plus haut dossier api (alpha ou bêta, je recommande la version alpha).

Pour ceux d'entre vous qui souhaitent passer directement ici, c'est le fichier de build 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 {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:support-v4:20.0.0'
    implementation 'com.android.support:appcompat-v7:20.0.0'
}

Vous pouvez construire une partie de ce fichier de build (ci-dessus) à partir de l'option de menu: Fichier/Projet de la Structure
De là, sélectionnez Facettes et cliquez sur 'Android-Gradle(App).
De là, vous allez voir les onglets: 'Propriétés', 'Signature', 'Saveurs', 'Build Types" et "Dépendances" pour cette visite, nous allons juste utiliser "Signature" et "Construire des Types".
En vertu de la "construction Types" (dans la section nom) entrez le nom que vous souhaitez identifier votre type de build de configuration et dans les 4 autres champs d'entrer dans votre magasin de certificats de l'information (paramètre au fichier chemin d'accès de la première au titre de votre dossier app).

En vertu de la "Construction de Types' entrez la valeur 'assembleRelease" dans le champ nom, 'Debuggable' doit être défini sur false, 'Jni Debug' doit être fausse, choisissez 'Exécuter Proguard' true 'Zip Aligner' à true. Cela va générer fichier build, mais pas comme décrit ci-dessus, vous devrez ajouter un peu de choses à la construction de la page par la suite. Le ProGuard emplacement du fichier ici sera mis manuellement dans le fichier de build gradle. (comme illustré ci-dessus)

La liste intérieure des récipients, vous aurez à ajouter par la suite sont comme suit:

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

Vous devrez aussi ajouter:

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

note ce DSL conteneur au-dessus de('dépendances') doivent être à la base du fichier de configuration, mais pas à l'intérieur de l'android DSL conteneur.
Afin de construire les dépendances contenant de l'Ide, de menus, sélectionnez: Fichier/Projet de la Structure. À partir de là, sélectionnez les Facettes de nouveau et puis Android-Gradle(app). Vous verrez les mêmes 5 onglets comme mentionné ci-dessus. Sélectionnez les "Dépendances" de l'onglet et ajouter les dépendances dont vous avez besoin.

Après tout cela est fait, vous devriez voir un fichier de build Gradle similaire au fichier en haut de cette tour.
Pour construire votre signée zip alignés de presse que vous aurez besoin d'ouvrir le Gradle tâches. Vous pouvez accéder à cette fenêtre en sélectionnant Afficher/Outil Windows/Gradle.
De là, vous pouvez double-Cliquez sur 'assembleAssembleRelease. Cela devrait générer votre déployable APK.

Les problèmes potentiels qui peuvent se produire lors de la compilation de votre communiqué de presse (mais pas limité à): Votre fichier de build Gradle en étant au mauvais endroit. Il y a deux fichiers de build Gradle; - le dans votre dossier racine d'une application et un autre dans le dossier app en vertu de la racine de l'application. Vous devez utilisateur de ce dernier.

Vous pouvez également avoir des peluches problèmes. (Note: Développeur Android Studio est beaucoup mieux percevoir les Peluches de problèmes que IntelliJ vous pouvez le constater lorsque vous essayez de générer un signé APK à partir du menu options)

Pour obtenir autour de la charpie de problèmes, vous aurez besoin de mettre la suite DSL conteneur à l'intérieur de l'android conteneur (en haut):

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

de mettre cela à l'intérieur de votre android DSL conteneur va provoquer une erreur de fichier doit être généré dans le dossier de création (directement dans votre dossier app) le nom de fichier doit être quelque chose comme " lint-results-release-fatal.html ce dossier va vous dire la classe où l'erreur s'est produite. Un autre fichier qui sera généré est un fichier XML qui contient les " ID " qui est associée avec la fibre d'erreur. Le nom de fichier doit être quelque chose comme "lint-results-release-fatal.xml'. Quelque part près de la partie supérieure du fichier, vous verrez un nœud 'problème' à l'intérieur de laquelle vous verrez quelque chose de similaire à la " id="IDOfYourLintProblem"'

Pour corriger ce problème, ouvrez le fichier dans votre projet a été répertoriée dans le "lint-results-assembleRelease-fatal.html' fichier et entrez la ligne de code suivante dans le fichier de Classe Java juste au-dessus du nom de la classe: @SuppressLint("IDOfYourLintProblem"). Vous pourriez avoir à importer 'android.annotation.SuppressLint;'

De sorte que votre fichier de classe java doit ressembler à:

package com.WarwickWestonWright.developers4u.app.CandidateArea;

import android.annotation.SuppressLint;
... other imports

@SuppressLint("IDOfYourLintProblem")
public class SearchForJobsFragment extends Fragment {... rest of your class definition}

Noter que la suppression de la charpie des erreurs n'est pas toujours la meilleure IDÉE que vous avez peut-être préférable de changer votre code à l'origine de la charpie erreurs.

Un autre problème qui pourrait éventuellement se produire est si vous n'avez pas défini la variable d'environnement pour le Gradle la variable d'environnement HOME. Cette variable est appelée "GRADLE_HOME" et devrait être le chemin de la gradle répertoire de base, comme quelque chose de "C:\gradle-1.12'
Parfois, vous pouvez également définir la variable d'environnement pour les "ANDROID_HOME' ensemble de ce 'VOTRE-SDK-Root\sdk"

Après ceci est fait retour à la Gradle tâches de la fenêtre et double-cliquez sur le assembleAssembleRelease.

Si tout est réussi, vous devriez être en mesure d'aller dans le dossier app\build\apk et de trouver votre déployable fichier APK.

J'ai eu plusieurs problèmes que j'ai mis la ligne suivante dans un mauvais endroit:

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

Assurez-vous que vous placez le signingConfigs pièces à l'intérieur de la section android:

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

au lieu de

android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

Il est facile de faire cette erreur.

je suis travailler dans Ubuntu14.04.
vim ~/.bashrc et ajouter
l'exportation ANDROID_KEYSTORE=
l'exportation ANDROID_KEYALIAS=

puis dans la construction.gradle ensemble.

    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 {

        }
    }

}

Vous pouvez demander des mots de passe à partir de la ligne de commande:

...

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
  }

  ...
}

...

La if-then-else bloc empêche les demandes de mots de passe lorsque vous êtes en train de construire un communiqué. Bien que la else branche est inaccessible, il astuces Gradle dans la création d'un install...Release tâche.

Trame de fond. Comme l'a noté https://stackoverflow.com/a/19130098/3664487, "Gradle scripts peuvent invite de saisie de l'utilisateur d'utiliser le Système.console().méthode readLine." Malheureusement, Gradle toujours demander un mot de passe, même lorsque vous êtes la construction d'une version de débogage (cf. Comment créer un communiqué signé fichier apk en utilisant Gradle?). Heureusement, cela peut être surmonté, comme je l'ai montré ci-dessus.

si vous ne voulez pas voir Ne peut pas invoquer la méthode readLine() sur l'objet null. vous avez besoin d'écrire dans gradle.propriétés premier.

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