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

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=*****

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

alors vous pouvez lancer gradle assembleRelease

notez que le script de @sdqali demandera (au moins en utilisant Gradle 1.6) le mot de passe chaque fois que vous invoquez n'importe quel tâche gradle. Puisque vous n'en avez besoin que pour faire gradle assembleRelease (ou similaire), vous pouvez utiliser le truc suivant:

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 j'ai également dû ajouter ce qui suit (sous android) pour le faire fonctionner:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

si vous voulez éviter le codage dur de votre keystore et mot de passe dans construire.Grad , vous pouvez utiliser un fichier de propriétés comme expliqué ici: gestion de la signature CONFIGS avec Grad

en gros:

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

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

2) Créer un grad.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) référez-vous à elle dans votre construire.Grad 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']
        }
    }
}

comme @Destil l'a dit mais permettre à d'autres qui n'ont pas la clé de construire: 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=*****

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

alors vous pouvez exécuter gradle assembleRelease OU gradle build

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

une solution encore plus simple, si vous voulez garder vos mots de passe hors d'un dépôt git; pourtant, vous voulez inclure votre build.gradle en elle, qui fonctionne même très bien avec des saveurs de produits, est de créer un fichier Grad e séparé. Appelons ça de la signature.Grad ' (inclure dans votre .gitignore). Comme si c'était votre build.dossier gradle moins tout ce qui n'est pas lié à la signature.

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

alors dans votre construction.gradle fichier inclure cette ligne juste en dessous de la "appliquer le plugin: 'android'"

 apply from: 'signing.gradle'

si vous n'avez pas ou n'utilisez pas plusieurs saveurs, renommez" flavor1 "en" release " ci-dessus, et vous devriez être terminé. Si vous utilisez des saveurs de continuer.

enfin lier vos saveurs à son signingConfig correcte dans votre construction.Grad le dossier et vous devriez être terminé.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

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

c'est étonnant combien de façons alambiquées il y a pour faire ceci. Voici ma propre façon, où je tente d'adhérer à Googles propres recommandation . Cependant, leur explication n'est pas entièrement clair, donc je vais décrire la procédure pour Linux en détail.

Description:

par défaut Google instructions pour la signature automatique d'une application pendant la construction, sans conserver les mots de passe et les fichiers de signature dans votre chemin de développement d'applications (GIT), est plutôt obscur. Voici les clarification des instructions étape par étape 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 suivant: $HOME/projects/mydev/MyApp . Cependant, le répertoire MyApp est utilisé et contrôlée avec GIT.

problème

nous ne voulons évidemment pas avoir nos fichiers de signature ou de mot de passe le répertoire contrôlé GIT, même si nous sommes très capables d'utiliser .gitignore etc, il est encore trop risqué et facile de faire une erreur. Donc nous voulons que nos fichiers de clés et de signatures soient dehors.

Solution

nous devons faire trois (3) choses:

1. créer un fichier de mots de passe pour être utilisé par Android Studio
2. Créer une clé de signature de fichier
3. modifier le module build.gradle fichier à 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 de keystore

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

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 pendant la construction. Cela signifie habituellement un chemin similaire et relatif à: $HOME/projects/mydev/MyApp/app/build.gradle . Donc, pour le MyApp-release-key.jks fichier, ce que nous devons mettre ici est:

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

ici, nous avons aussi choisi l'alias "myapp" pour la clé. Alors le fichier final devrait regarder:

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

(2) Créer le fichier de signature

le second 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 keystore, alors 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 sur Android Studio.) Maintenant, copiez / collez vos mots de passe précédemment choisis.

(3) éditez votre module gradle.build pour utiliser le fichier ci-dessus

les parties suivantes besoin d'être présent dans le fichier Gradle build de votre application/module. Tout d'abord, ajoutez les lignes suivantes à l'extérieur 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))

puis, à l'intérieur de le bloc android {} , 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 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 qui peut être utilisé dans Google Play.

C'est une réponse à user672009 et plus de 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 {

        }
    }

}

dans le nouveau studio Android, il ya une façon GUI qui est très facile et il popule fichier Gradle ainsi.

1. File -> Project Structure

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

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

4. remplir les données sur le côté droit

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

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

Images:

deux importantes(!) notes:

(EDIT 12/15)

1. pour créer APK signé, vous devez ouvrir l'onglet Terminal De Android Studio (le 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.

si vous construisez apk via la ligne de commande comme moi, vous pouvez fournir la configuration de signature comme 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()
    }
}

puis vous exécutez gradlew comme ceci

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

android {
    compileSdkVersion 17
    buildToolsVersion "19.0.3"

    defaultConfig {
        minSdkVersion 9
        targetSdkVersion 18
    }

    File signFile = rootProject.file('sign/keystore.properties')
    if (signFile.exists()) {
        Properties properties = new Properties()
        properties.load(new FileInputStream(signFile))
        signingConfigs {
            release {
                storeFile rootProject.file(properties['keystore'])
                storePassword properties['storePassword']
                keyAlias properties['keyAlias']
                keyPassword properties['keyPassword']
            }
        }
    }

    buildTypes {
        release {
            runProguard true
            zipAlign true
            proguardFile rootProject.file('proguard-rules.cfg')
            signingConfig signingConfigs.release
        }
        debug {
            runProguard false
            zipAlign true
        }
    }
}

vous pouvez également utiliser - P option de ligne de commande de gradle pour aider la signature. Dans votre construction.gradle, ajouter singingConfigs comme ceci:

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

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

c'est essentiellement la solution de Destil mais avec les options de ligne de commande.

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

si vous avez déjà le fichier keystore, il peut être aussi simple que d'ajouter quelques paramètres à votre commande de compilation:

./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 à votre projet Android nécessaire.

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

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

c'est une variation de la réponse de @jonbo . Cette réponse permet des paramètres spécifiques au projet, mais elle est fournie avec un peu de frais généraux du développeur. Spécifiquement, il est nécessaire de disposer d'une plate-forme significative pour déplacer la définition signingConfigs dans un fichier séparé-surtout si vous avez besoin de le faire pour plusieurs projets, ce qui est une raison principale pour choisir cette solution plutôt que Destil. Cela peut être quelque peu allégé par aussi y compris la ligne

apply plugin: 'com.android.application'

dans le fichier de justificatifs d'identité, car cela permettra de compléter L'IDE.

enfin, la plupart des solutions ici ne pas permet de construire le projet en mode de débogage-qui gère la signature de débogage automatiquement-sans fournir une définition syntaxique sinon sémantiquement valide signingConfigs . 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'un autre côté, cela peut être une aide contre les collègues ignorants ou paresseux qui exécutent des constructions de débogage dans la production.

cette solution permettra de déboguer les constructions sans s'inquiéter des justificatifs d'identité du tout, mais il faudra des justificatifs d'identité valides pour produire des compilations de release, et cela prend très peu de place sur boilerplate. Cependant, comme un inconvénient il pourrait encourager d'autres à remplacer les valeurs fictives avec de véritables références 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é fictive qui sert uniquement à produire un fichier de construction valide sur le plan syntaxique. Les valeurs attribuées aux propriétés de ext.signing sont sans incidence sur les versions de débogage aller. Pour activer les compilations de release, copiez ext.signing dans signing.gradle et remplacez les valeurs fictives par des références 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 devrait être ignoré par VCS.

presque toutes les plateformes offrent maintenant une sorte de porte-clés, il n'y a donc aucune raison de laisser des mots de passe texte clairs.

je propose une solution simple qui utilise le module Python Keyring (principalement le script de la console compagnon keyring ) et un enveloppeur minimal autour de Groovy ['do', 'something'].execute() caractéristique :

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

en utilisant 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 porte-clés, une seule fois:

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

Heureux les communiqués de!

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 en construction.Grad

  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. Voici mon rendez-vous à travers.

visite de A à Z sur la façon de créer un fichier gradle build dans IntelliJ (v. 13.1.(4)) Cette visite suppose que vous savez comment créer un fichier keystore. Pour que ce tutoriel fonctionne, vous aurez besoin de votre fichier keystore pour être localisé dans votre dossier app et vous aurez besoin de votre zipalign.le fichier exe doit être situé dans'SDK-ROOT\tools'. Ce fichier se trouve généralement dans 'SDK-ROOT\build-tools' et sous ce dossier, il sera dans le dossier api le plus élevé (alpha ou beta je recommande la version alpha).

pour ceux d'entre vous qui souhaitent sauter directement ici, voici le fichier de construction Grad.

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

vous pouvez construire une partie de ce fichier de construction (ci-dessus) à partir de l'option de menu: dossier / Structure du projet À partir de là, sélectionnez facettes et cliquez sur " Android-Gradle(App). De là, vous verrez des onglets: 'propriétés', 'signature',' saveurs',' types de construction 'et' dépendances ' pour ceci. nous allons simplement utiliser 'signature' et'construire des Types'. Sous' Build Types ' (dans la section Nom), entrez n'importe quel nom que vous souhaitez identifier votre configuration de type de construction et dans les 4 autres champs, entrez vos informations de keystore (définissant le chemin de keystore de celui sous votre dossier app).

sous' Build Types 'entrez la valeur 'assembleRelease' dans le champ Nom,' Debuggable ' doit être défini à false, 'JNI Debug Build' doit être false, 'Run Proguard' à true Et 'Zip Align' à true. Cela générera le fichier de compilation, mais pas comme décrit ci-dessus, vous devrez ajouter quelques choses au fichier de compilation par la suite. L'emplacement du fichier ProGuard ici sera défini manuellement dans le fichier de construction gradle. (comme illustré ci-dessus)

les conteneurs DSL que vous devrez 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 aussi ajouter:

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

notez ce conteneur DSL ci-dessus ("dépendances") devrait être au bas du fichier de configuration mais pas à l'intérieur du conteneur DSL android. Pour construire le conteneur de dépendances à partir du menu IntelliJ, sélectionnez: File/Project Structure. De là, sélectionnez facettes à nouveau et puis Android-Gradle (app). Vous verrez les mêmes 5 onglets que ci-dessus. Sélectionnez l'onglet 'dépendances' et ajoutez les dépendances dont vous avez besoin.

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

les problèmes potentiels qui peuvent survenir lors de la compilation de votre version sont (mais pas limités à): votre fichier de compilation Gradle est au mauvais endroit. Il y a deux fichiers de construction Gradle; un dans votre dossier racine de l'application et un autre dans le dossier app sous le dossier racine de l'application. Vous devez utilisateur de ce dernier.

vous pourriez aussi avoir des problèmes de peluche. (Note: Android Developer Studio est beaucoup mieux pour repérer les problèmes de peluche que IntelliJ vous le remarquerez en essayant de générer un APK signé à partir des options de menu)

pour contourner les problèmes de peluche, vous aurez besoin de mettre le conteneur DSL suivant à l'intérieur du conteneur android (en haut):

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

mettre cela dans votre conteneur DSL android va provoquer un fichier d'erreur à être généré dans le dossier de construction (directement sous votre dossier app) le nom du fichier devrait être quelque chose comme 'lint-results-release-fatal.html' ce fichier vous indiquera la classe dans laquelle l'erreur s'est produite. Un autre fichier qui sera généré est un fichier XML qui contient le "numéro D'identification" associé à l'erreur de lint. Le nom de fichier doit être quelque chose comme " non-résultats-release-fatale.xml". Quelque part près du haut du fichier, vous verrez un noeud 'issue' à l'intérieur duquel vous verrez quelque chose de similaire à 'id=" IDOfYourLintProblem "'

Pour corriger ce problème, ouvrez le fichier dans votre projet a été répertoriée dans le " non-résultats-assembleRelease mortels.HTML ' et entrer la ligne de code suivante dans le fichier de classe Java juste au-dessus du nom de classe: @SuppressLint("IDOfYourLintProblem"). Vous devrez peut-être importer androïde.annotation.SuppressLint; "

Donc votre fichier de classe java devrait apparaître comme:

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 supprimer les erreurs de peluche n'est pas toujours la meilleure idée.il est peut-être préférable de changer le code qui a causé les erreurs de peluche.

un autre problème qui pourrait éventuellement se produire est si vous n'avez pas défini la variable d'environnement pour la variable D'environnement Gradle HOME. Cette variable est appelée 'GRADLE_HOME' et doit être définie comme le chemin du répertoire de la maison de Grad le, quelque chose comme "C:\gradle-1.12" Parfois, vous pouvez aussi définir la variable d'environnement pour 'ANDROID_HOME' à 'YOUR-SDK-Root\sdk '

après cela, retournez dans la fenêtre des tâches de Gradle et double-cliquez sur assemblelassemblerelease.

si tout est réussi, vous devriez pouvoir aller dans le dossier app\build\apk et trouver votre fichier Apk déployable.

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 mettez les pièces signingConfigs dans la section android:

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

au lieu de

android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

Il est facile de faire cette erreur.

encore une autre approche du même problème. Comme il n'est pas recommandé de stocker tout type de justificatif d'identité dans le code source, nous avons décidé de définir les mots de passe pour le stockage de clés et l'alias de clés 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, en sécurité.propriété. Assurez-vous de vous exclure de votre dépôt (si vous utilisez git, ajoutant à l' .gitignore fichier). Ensuite, vous devez créez une configuration de signature, comme certaines des autres réponses l'indiquent. La seule différence est 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'affecter manuellement le signingConfig au type de construction release (pour une raison quelconque, je suppose parfois qu'il sera utilisé automatiquement). Aussi, il n'est pas obligatoire pour permettre proguard, mais il est recommandable.

nous préférons cette approche plutôt que d'utiliser des variables d'environnement ou de demander entrée utilisateur parce que cela peut être fait à partir de L'IDE, en passant au type de construction realease et en lançant l'application, plutôt que d'avoir à utiliser la ligne de commande.

Android Studio Aller à fichier - > Structure du projet ou appuyez sur Ctrl+Alt+Shift+S

Voir L'Image

Cliquez Sur Ok

alors les signingConfigs se généreront sur votre construction.dossier gradle.

Pour compléter les autres réponses, vous pouvez également placer votre gradle.fichier de propriétés dans votre propre dossier de module, avec build.gradle, juste au cas où votre fichier est spécifique à un projet.

je travaille à Ubuntu14.04. vim~/.bashrc et ajouter export ANDROID_KEYSTORE= export ANDROID_KEYALIAS=

et puis en 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 {

        }
    }

}

une alternative consiste à définir une tâche qui ne tourne que sur les constructions de version.

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

vous pouvez demander des mots de passe depuis 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 construisez une version. Bien que la branche else ne soit pas accessible, elle offre des astuces pour créer une tâche install...Release .

Backstory . Comme noté par https://stackoverflow.com/a/19130098/3664487 , " les scripts Gradle peuvent demander à l'utilisateur entrée en utilisant le Système.console.)(méthode 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é release 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 devez écrire dans gradle.propriétés d'abord.

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

si vous, comme moi, voulez juste être en mesure d'exécuter la version sur votre appareil à des fins de test, envisager création d'un deuxième keystore pour la signature, de sorte que vous pouvez simplement mettre les mots de passe pour elle dans votre construction.grader sans se soucier de votre sécurité de magasin clé du marché.

vous pouvez créer un nouveau keystore en cliquant sur Build/Generate Signed APK/Create new...