Question Comment créer un fichier apk signé avec Gradle?


Je voudrais avoir ma version Gradle pour créer un fichier apk signé avec Gradle.

Je ne suis pas sûr si le code est correct ou si je manque un paramètre en faisant gradle build?

C'est une partie du code dans mon fichier gradle:

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

La construction de grades se termine avec succès, et dans mon build/apk dossier que je ne vois que le ...-release-unsigned.apk et ...-debug-unaligned.apk des dossiers.

Des suggestions sur la façon de résoudre ce problème?


447
2017-08-20 06:53


origine


Réponses:


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

Modifier votre build.gradle comme ça:

...    
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 courir gradle assembleRelease


333
2018-01-09 12:36



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 signé.


234
2017-08-20 08:00



Notez que le script de @ sdqali (au moins lors de l'utilisation de Gradle 1.6) demandera le mot de passe à chaque fois que vous invoquez tout tâche de gradation. Puisque vous n'en avez besoin que lorsque vous le faites 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 j'ai également dû ajouter les éléments suivants (sous Android) pour que cela fonctionne:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

63
2017-10-13 21:17



Si vous voulez éviter de coder en dur votre fichier de clés et votre mot de passe dans build.gradle, vous pouvez utiliser un fichier de propriétés comme expliqué ici: GESTION DE LA SIGNATURE CONFIGE AVEC GRADLE

Fondamentalement:

1) créer un fichier myproject.properties à /home/[nomutilisateur]/.signing avec de tels contenus:

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) s'y référer dans votre build.gradle comme ça:

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

54
2017-10-26 05:01



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

Modifier votre build.gradle comme ça:

...    
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 courir gradle assembleRelease OU gradle build


30
2017-08-19 19:52



(En réponse à user672009 au 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 dans celui-ci, qui fonctionne même très bien avec les saveurs du produit, est de créer un fichier gradle séparé. Appelons-le 'signing.gradle' (incluez-le dans votre .gitignore). Tout comme si c'était votre fichier build.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 ".."
        }
    }
}

Ensuite, dans votre fichier build.gradle, insérez cette ligne juste en dessous de "apply plugin: 'android'"

 apply from: 'signing.gradle'

Si vous n'avez pas ou n'utilisez pas plusieurs versions, renommez "flavour1" pour "libérer" ci-dessus, et vous devriez avoir terminé. Si vous utilisez des saveurs, continuez.

Enfin, associez vos saveurs à son bon signingConfig dans votre fichier build.gradle et vous devriez avoir terminé.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

26
2018-02-01 05:22



Signature automatique de l'application avec Gradle lors de l'utilisation de git

Il est étonnant de voir combien il y a de manières compliquées pour cela. Voici ma propre façon, où j'essaie d'adhérer à Googles propre recommandation. Cependant, leur explication n'est pas entièrement claire, donc je vais décrire la procédure pour Linux en détail.


La description:

Le défaut Instructions Google pour signer automatiquement une application pendant la construction, sans garder les mots de passe et les fichiers de signature dans votre chemin de développement d'applications (GIT), est plutôt obscur. Voici les clarifié les instructions étape par étape comment 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é avec GIT.

enter image description here

Problème

Nous ne voulons évidemment pas avoir nos fichiers de signature ou de mot de passe n'importe où dans le répertoire GIT contrôlé, 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 nos fichiers de keystore et de signature à l'extérieur.

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. Editer 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éez le fichier de mot de passe du fichier de clés

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

cd $HOME/projects/mydev/

modifier keystore.properties pour que son contenu soit:

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

La seule partie délicate ici est la myStoreFileLocation. C'est le chemin vu de le module build.gradle fichier 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 MyApp-release-key.jks fichier, ce que nous devons mettre ici est:

../../../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éez 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 aucune autre application et que c'est votre seul fichier 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 module gradle.build fichier pour utiliser le ci-dessus

Les éléments suivants doivent être présents dans le fichier de construction Gradle de votre application / module. 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))

Alors, à l'intérieur la android {} bloquer, 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 pouvant être utilisée dans Google Play.


19
2018-04-05 11:51



Ceci est une réponse à user672009 et addition à Le message de sdqali (son code va planter sur la construction de la version de débogage par le bouton "Exécuter" d'IDE):

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 {

        }
    }

}

17
2017-10-06 14:45



Dans Android Studio plus récent, il existe une interface graphique très simple qui remplit également le fichier Gradle.

  1. File -> Project Structure

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

  3. Signing tab -> Image plus pour ajouter une nouvelle configuration

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

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

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

Images:

enter image description here

enter image description here

Deux notes importantes (!):

(EDIT 12/15)

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

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


14
2018-06-18 11:01