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

Question

Je souhaite que ma version Gradle crée un fichier apk signé par une version utilisant Gradle.

Je ne suis pas sûr si le code est correct ou s'il me manque un paramètre lorsque je fais gradle build?

Voici une partie du code de mon fichier Gradle:

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

La construction de gradle se termine avec succès, et dans mon dossier build/apk, je ne vois que les fichiers ...-release-unsigned.apk et ...-debug-unaligned.apk.

Des suggestions sur la façon de résoudre ceci?

Answer 1

J'ai réussi à le résoudre en ajoutant ce code et en construisant avec gradle build:

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

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

Answer 2

Plus facile que les réponses précédentes:

Mettez ceci dans ~/.gradle/gradle.properties

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

Modifiez votre build.gradle comme ceci:

...    
signingConfigs {

   release {
       storeFile file(RELEASE_STORE_FILE)
       storePassword RELEASE_STORE_PASSWORD
       keyAlias RELEASE_KEY_ALIAS
       keyPassword RELEASE_KEY_PASSWORD
   }
}

buildTypes {
        release {
            signingConfig signingConfigs.release
        }
}
....

Ensuite, vous pouvez exécuter gradle assembleRelease

Answer 3

Notez que le script de @ sdqali demandera (au moins lors de l'utilisation de Gradle 1.6) le mot de passe à tout moment si vous invoquez toute option tâche. Comme vous n'en avez besoin que lorsque vous utilisez gradle assembleRelease (ou similaire), vous pouvez utiliser l'astuce suivante:

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

Notez que je devais également ajouter ce qui suit (sous Android) pour que cela fonctionne:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

Answer 4

Si vous voulez éviter de coder en dur votre magasin de clés et votre mot de passe dans build.gradle , vous pouvez utiliser un fichier de propriétés comme expliqué ici: HANDLING SIGNING CONFIGS AVEC GRADLE

Fondamentalement:

1) Créez un fichier myproject.properties à /home/[nom d'utilisateur] /. Signature avec ce contenu:

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

2) créez un fichier gradle.properties (peut-être à la racine du répertoire de votre projet) avec le contenu:

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

3) Faites-en référence dans votre build.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']
        }
    }
}

Answer 5

Comme @Destil l'a dit, mais permettez à d'autres qui n'ont pas la clé de construire: Un moyen plus simple que les réponses précédentes:

Mettez ceci dans ~/.gradle/gradle.properties

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

Modifiez votre build.gradle comme ceci:

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

Ensuite, vous pouvez exécuter gradle assembleRelease OR gradle build

Answer 6

Signature automatique des applications avec Gradle lors de l'utilisation de git

C'est incroyable de voir combien de façons compliquées existent pour le faire. Voici ma propre manière, où j'essaie d'adhérer à Google propre recommandation . Cependant, leur explication n’est pas tout à fait claire, je vais donc décrire la procédure pour Linux en détail.

---

La description:

La valeur par défaut instructions Google pour la signature automatique d'une application lors de la construction, sans conserver les mots de passe et les fichiers de signature dans le chemin de votre développement d'application, est plutôt obscure. Voici les instructions pas à pas clarifiées pour le faire.

Hypothèses initiales:

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

Problème

Nous ne souhaitons évidemment pas avoir nos fichiers de signature ou de mot de passe n’importe où dans le répertoire contrôlé par GIT, même si nous sommes très capables d’utiliser .gitignore etc., il est encore trop risqué et facile de faire une erreur. Nous voulons donc que nos fichiers de clés et de signatures soient en dehors.

Solution

Nous devons faire trois (3) choses:

1. Créer un fichier de mot de passe à utiliser par Android Studio
2. Créer un fichier de clé de signature
3. Editez le fichier module build.gradle à utiliser (1) et (2).

Pour cet exemple, nous nommons les 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 mots de passe du magasin de clés

Le premier fichier contient les mots de passe en clair utilisés dans; et les chemins d'accès au fichier release-key dans (2). Commencez par remplir ceci, car cela facilitera l'opération de copier-coller pour l'étape suivante.

cd $HOME/projects/mydev/

Éditez keystore.properties pour que son contenu soit:

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

La seule partie délicate ici est la myStoreFileLocation. Ceci est le chemin tel que vu depuis le fichier module build.gradle pendant la construction. Cela signifie généralement un chemin similaire et relatif à: $HOME/projects/mydev/MyApp/app/build.gradle. Donc, pour pointer vers le fichier MyApp-release-key.jks, il faut mettre ici:

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

Ici, nous avons également choisi l’alias "myapp" 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 applications et qu'il s'agit de votre seul magasin de clés, créez le fichier avec:

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

Cela vous demandera deux mots de passe et un tas d'informations. (Même chose que dans Android Studio.) Maintenant, copiez/collez vos mots de passe précédemment choisis.

(3) Editez votre fichier module gradle.build pour utiliser ce qui précède

Les parties suivantes doivent être présentes dans le fichier de construction Gradle de votre application/module. Tout d’abord, ajoutez les lignes suivantes en dehors de et avant votre Android {} bloquer.

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

Ensuite, à l'intérieur du bloc Android {}, ajoutez:

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 Shell, vous pouvez reconstruire votre application avec:

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

Cela devrait générer une application correctement signée pouvant être utilisée dans Google Play.

---

UPDATE: 2019-04-02

Des versions plus récentes de keytool et quelque chose vous indique que vous devez utiliser un PKCS12 keyfile basé au lieu de l'original/par défaut que j'utilise ci-dessus. Ils continuent ensuite de vous dire que vous devez convertir au nouveau format PKCS12 ouvert. Cependant, il semble que les outils de développement Android ne soient pas encore prêts, car si vous le faites, vous obtiendrez les erreurs étranges suivantes:

com.Android.ide.common.signing.KeytoolException: Echec de la lecture de la clé XXX à partir du magasin "F:\XXX\XXX.jks": échec de l'obtention de la clé: le dernier bloc n'a pas été correctement rempli. De tels problèmes peuvent survenir si une clé incorrecte est utilisée lors du déchiffrement.

Donc, n'utilisez pas une clé convertie!

Answer 7

(En réponse à ser672009 ci-dessus.)

Une solution encore plus simple si vous souhaitez conserver vos mots de passe dans un référentiel git. Cependant, si vous souhaitez y inclure votre build.gradle, qui fonctionne même très bien avec les variantes de produit, vous devez créer un fichier de dégradé distinct. Appelons-le 'signature.gradle' (incluez-le dans votre .gitignore). Tout comme s'il s'agissait de votre fichier build.gradle moins tout ce qui n'est pas lié à la connexion.

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

Ensuite, dans votre fichier build.gradle, incluez cette ligne juste en dessous de "apply plugin: 'Android" "

 apply from: 'signing.gradle'

Si vous n'avez pas ou n'utilisez pas plusieurs goûts, renommez "saveur1" en "relâchez" ci-dessus, et vous devriez avoir terminé. Si vous utilisez des arômes, continuez.

Enfin, liez vos versions à la signature appropriée, dans votre fichier build.gradle, et vous devriez avoir terminé.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

Answer 8

Ceci est une réponse à ser672009 et un complément à message de sdqali (son code plantera lors de la construction de la version de débogage avec le bouton "Exécuter" de l'EDI):

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 {

        }
    }

}

Answer 9

Si vous construisez apk via une ligne de commande comme moi, vous pouvez fournir une configuration de signature en tant qu'arguments.

Ajoutez ceci à votre 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
}

Faites votre signingConfigs comme ceci

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

Ensuite, vous exécutez gradlew comme ceci

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

Answer 10

Dans la nouvelle version de Android Studio, il existe une méthode d’interface graphique très simple qui permet également de renseigner le fichier Gradle.

1. File -> Project Structure

2. Module -> Choisissez le module principal ('app' ou un autre nom personnalisé)

3. Signing onglet -> Plus l'image pour ajouter une nouvelle configuration

4. Remplir les données du côté droit

5. OK et le fichier Gradle est créé automatiquement

6. Vous devrez manuellement ajouter une ligne signingConfig signingConfigs.NameOfYourConfig à l'intérieur de builtTypes{release{}}

Images:

Deux notes (!) Importantes:

(EDIT 12/15)

1. Pour créer un fichier APK signé, vous devez ouvrir l'onglet Terminal de Android Studio (bas de l'interface principale) et émettre une commande ./gradlew assembleRelease

2. Si vous avez oublié keyAlias (ce qui m’arrive souvent), vous devrez lancer Build -> Generate Signed APK pour démarrer le processus et voir le nom de la clé Alias.

Answer 11

Si vous avez déjà le fichier de clés, cela peut être aussi simple que d'ajouter quelques paramètres à 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

Aucune modification permanente de votre projet Android nécessaire.

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

Answer 12

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

Answer 13

Vous pouvez également utiliser - P option de ligne de commande de gradle pour faciliter la signature. Dans votre build.gradle, ajoutez singingConfigs comme ceci:

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

Ensuite, appelez gradle build comme ceci:

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

Vous pouvez utiliser -P pour définir storeFile et keyAlias ​​si vous préférez.

Ceci est fondamentalement la solution de Destil mais avec les options en ligne de commande.

Pour plus de détails sur les propriétés de gradle, consultez le guide de l'utilisateur de gradle .

Answer 14

La réponse de @ Destil est bonne si vous pouvez réutiliser la même configuration dans tous les projets. Alternativement, Android Studio est livré avec un fichier local.properties qui peut éventuellement être utilisé à la place, mais il est censé être généré par l'IDE et je ne trouve pas le moyen de l'étendre à partir de Android Studio.

Ceci est une variation de réponse de @ jonbo . Cette réponse autorise des paramètres spécifiques à un projet, mais elle entraîne un peu de surcharge des développeurs. En particulier, il faut beaucoup de ressources pour déplacer la définition signingConfigs dans un fichier séparé, en particulier si vous en avez besoin pour plusieurs projets, ce qui est une raison majeure pour choisir cette solution plutôt que pour Destil. Ceci peut être quelque peu atténué par aussi y compris la ligne

apply plugin: 'com.Android.application'

dans le fichier d’identifiants, car cela permettra à IDE d’être complété.

Enfin, la plupart des solutions ici font not permettent de construire le projet en mode débogage - qui gère automatiquement la signature du débogage - sans fournir de définition syntaxiquement sinon sémantiquement valable signingConfigs . Si vous n'avez pas besoin de créer une version finale à partir d'une machine donnée, cette étape supplémentaire peut être considérée comme un obstacle inutile. D'autre part, cela peut être une aide contre les collègues ignorants ou paresseux qui exécutent des versions de débogage en production.

Cette solution permettra aux versions de débogage sans se soucier du tout des informations d'identification, mais elle nécessitera des informations d'identification valides pour produire des versions validées, et cela prend très peu de passe-partout. Cependant, comme inconvénient , cela pourrait encourager d'autres personnes à remplacer les valeurs factices par des informations d'identification réelles 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 une propriété factice qui sert uniquement à produire un fichier de construction syntaxiquement valide. Les valeurs affectées aux propriétés de ext.signing ne sont pas pertinentes dans la mesure où les versions de débogage disparaissent. Pour activer les versions validées, copiez ext.signing dans signing.gradle et remplacez les valeurs factices par 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 entendu, signing.gradle devrait être ignoré par VCS.

Answer 15

Presque toutes les plates-formes offrent maintenant une sorte de trousseau de clés, il n'y a donc aucune raison de laisser des mots de passe en texte clair.

Je propose une solution simple qui utilise le module Python Keyring (principalement le script de console associé keyring) et un wrapper minimal autour de Groovy ['do', 'something'].execute()fonctionnalité :

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

Avec cette fonction, la section signingConfigs devient:

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

Avant d’exécuter gradle assembleRelease, vous devez définir les mots de passe dans votre trousseau de clés une seule fois:

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

Bonne libération!

Answer 16

En étendant la réponse de David Vavra, créez un fichier ~/.gradle/gradle.properties et ajoutez

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

Puis dans 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 17

Android Studio Allez à Fichier -> Structure du projet ou appuyez sur Ctrl + Alt + Maj + S

Voir l'image

Cliquez sur OK

Ensuite, la signatureConfigs générera sur votre fichier build.gradle.

Answer 18

J'ai eu beaucoup de plaisir à comprendre celui-ci. Voici mon parcours.

Procédure pas à pas permettant de créer un fichier de construction de dégradés dans IntelliJ (v.13.1.4) Cette procédure suppose que vous sachiez créer un fichier de magasin de clés. Pour que ce didacticiel fonctionne, votre fichier de stockage de clés doit se trouver dans le dossier de votre application et votre fichier zipalign.exe doit se trouver dans "SDK-ROOT\tools". Ce fichier se trouve généralement dans 'SDK-ROOT\build-tools' et, dans ce dossier, il se trouve dans le plus haut dossier api (alpha ou beta, je recommande la version alpha).

Le fichier de construction Gradle est destiné à ceux qui souhaitent intervenir directement.

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 créer une partie de ce fichier de construction (ci-dessus) à partir de l'option de menu suivante: Structure de fichier/projet. Sélectionnez ici Facettes et cliquez sur 'Android-Gradle (App). À partir de là, vous verrez les onglets: "Propriétés", "Signature", "Saveurs", "Types de construction" et "Dépendances" pour cette visite guidée. Nous allons simplement utiliser "Signature" et "Types de construction". Sous 'Types de construction' (dans la section Nom), entrez le nom de votre choix pour identifier votre configuration de type de construction et, dans les 4 autres champs, entrez les informations de votre magasin de clés (en définissant le chemin d'accès au magasin de clés).

Sous 'Types de construction', entrez la valeur 'assembleRelease' dans le champ du nom. 'Debuggable' doit avoir la valeur false, 'Jni Debug Build' doit être false, définir 'Run Proguard' sur true et 'Zip Align' sur true. Cela générera un fichier de construction, mais pas comme décrit ci-dessus, vous devrez ensuite ajouter quelques éléments au fichier de construction. L'emplacement du fichier ProGuard ici sera défini manuellement dans le fichier de construction Gradle. (comme décrit ci-dessus)

Les conteneurs DSL à ajouter par la suite sont les suivants:

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

Vous devrez également 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'
}

notez que ce conteneur DSL ci-dessus ('dépendances') doit figurer au bas du fichier de configuration, mais pas à l'intérieur du conteneur Android DSL. Pour construire le conteneur de dépendances à partir du menu IntelliJ, sélectionnez: Structure de fichier/projet. À partir de là, sélectionnez Facettes à nouveau, puis Android-Gradle (application). Vous verrez les mêmes 5 onglets comme mentionné ci-dessus. Sélectionnez l'onglet "Dépendances" et ajoutez les dépendances souhaitées.

Une fois que tout cela est fait, vous devriez voir un fichier de génération Gradle similaire au fichier en haut de cette visite. Pour créer votre version signée alignée au format Zip, vous devez ouvrir les tâches de Gradle. Vous pouvez accéder à cette fenêtre en sélectionnant View/Tool Windows/Gradle. À partir de là, vous pouvez double cliquer sur AssemblerAssembleRelease. Cela devrait générer votre APK déployable.

Les problèmes potentiels pouvant survenir lors de la compilation de votre publication sont (sans toutefois s'y limiter): Votre fichier de génération Gradle se trouvant au mauvais endroit. Il y a deux fichiers de construction Gradle; un dans le dossier racine de votre application et un autre dans le dossier de l'application sous la racine de l'application. Vous devez utiliser ce dernier.

Vous pouvez également avoir des problèmes de charpie. (Remarque: Android Developer Studio est beaucoup mieux à même de détecter les problèmes de peluche qu'IntelliJ. Vous remarquerez ceci en essayant de générer un fichier APK signé à partir des options du menu.)

Pour résoudre les problèmes de peluches, vous devez placer le conteneur DSL suivant dans le conteneur Android (en haut):

Android {
        ....
    lintOptions {
        abortOnError false
    }
    ....
}

en plaçant ceci dans votre Android conteneur _ DSL, un fichier d'erreur sera généré dans le dossier de construction (directement dans le dossier de votre application). Le nom du fichier doit ressembler à "lint-results-release-fatal.html". ce fichier vous indiquera la classe où l'erreur s'est produite. Un autre fichier à générer est un fichier XML contenant le "numéro d'identification" associé à l'erreur de peluches. Le nom du fichier devrait être quelque chose comme 'lint-results-release-fatal.xml'. Quelque part vers le haut du fichier, vous verrez un nœud "problème" dans lequel vous verrez quelque chose de similaire à "id =" IDOfYourLintProblem ""

Pour corriger ce problème, ouvrez le fichier de votre projet qui était répertorié dans le fichier 'lint-results-assembleRelease-fatal.html' et entrez la ligne de code suivante dans le fichier Java Class situé juste au-dessus du nom de la classe. : @SuppressLint ("IDOfYourLintProblem"). Vous devrez peut-être importer "Android.annotation.SuppressLint;"

Ainsi, votre fichier de classe Java devrait ressembler à ceci:

package com.WarwickWestonWright.developers4u.app.CandidateArea;

import Android.annotation.SuppressLint;
... other imports

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

Notez que la suppression des erreurs de peluche n’est pas toujours la meilleure IDEA il peut être préférable de modifier le code qui a provoqué les erreurs de peluche.

Un autre problème potentiel peut éventuellement se produire si vous n'avez pas défini la variable d'environnement pour la variable d'environnement Gradle HOME. Cette variable est nommée 'GRADLE_HOME' et doit être définie dans le chemin du répertoire de départ de Gradle, quelque chose comme 'C:\gradle-1.12'. Parfois, vous pouvez également définir la variable d'environnement pour 'Android_HOME'. SDK-Racine\sdk '

Une fois cette opération terminée, revenez dans la fenêtre des tâches de Gradle et double-cliquez sur assembleAssembleRelease.

Si tout réussit, vous devriez pouvoir accéder au dossier app\build\apk et trouver votre fichier APK déployable.

Answer 19

Encore une autre approche du même problème. Comme il n'est pas recommandé de stocker des informations d'identification dans le code source, nous avons décidé de définir les mots de passe pour le magasin de clés et l'alias de clé dans un fichier de propriétés séparé, comme suit:

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

Si vous utilisez git, vous pouvez créer un fichier texte appelé, par exemple, secure.properties. Assurez-vous de l'exclure de votre référentiel (si vous utilisez git, ajoutez-le au fichier .gitignore). Ensuite, vous devrez créer une configuration de signature, comme l’indiquent certaines des réponses. La seule différence réside dans la façon dont vous chargeriez les informations d'identification:

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

N'oubliez jamais d'attribuer manuellement la signatureSignature au type de version (pour une raison quelconque, je suppose parfois qu'elle sera utilisée automatiquement). De plus, il n'est pas obligatoire d'activer proguard, mais c'est recommandé.

Nous préférons cette approche plutôt que d’utiliser des variables d’environnement ou de demander une entrée à l’utilisateur car elle peut être effectuée à partir de l’EDI, en basculant vers le type de construction realease et en exécutant l’application plutôt que de devoir utiliser la ligne de commande.

Answer 20

J'ai eu plusieurs problèmes que j'ai mis la ligne suivante au 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 de placer les éléments de signatureConfigs dans la section Android:

Android
{
    ....
    signingConfigs {
        release {
          ...
        }
    }
}

au lieu de

Android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

Il est facile de faire cette erreur.

Answer 21

je travaille dans Ubuntu14.04. vim ~/.bashrc et add export Android_KEYSTORE = export Android AndroidKEYALIAS =

puis dans le jeu 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 22

Une alternative consiste à définir une tâche qui ne s'exécute que sur les versions validées.

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 23

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
  }

  ...
}

...

Le bloc if-then-else empêche les demandes de mots de passe lorsque vous créez une version. Bien que la branche else soit inaccessible, Gradle se voit astreint à créer une tâche install...Release.

Backstory . Comme indiqué par https://stackoverflow.com/a/19130098/3664487 , ", les scripts Gradle peuvent demander une entrée utilisateur à l'aide de la méthode System.console (). ReadLine . " Malheureusement, Gradle demandera toujours un mot de passe, même lorsque vous construisez une version de débogage (cf. Comment créer un fichier apk signé en utilisant Gradle? ). Heureusement, cela peut être surmonté, comme je l'ai montré ci-dessus.

Answer 24

Pour compléter les autres réponses, vous pouvez également placer votre fichier gradle.properties dans votre propre dossier de module, ainsi que build.gradle, au cas où votre magasin de clés serait spécifique à un projet.