android studio - Come creare un file apk con rilascio firmato usando Gradle?




signed release (22)

Mi piacerebbe avere la mia build Gradle per creare un file apk con rilascio firmato usando Gradle.

Non sono sicuro se il codice è corretto o se mi manca un parametro durante la gradle build ?

Questo è parte del codice nel mio file gradle:

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

La build gradle termina SUCCESSO, e nella mia cartella build/apk vedo solo i file ...-release-unsigned.apk e ...-debug-unaligned.apk .

Qualche suggerimento su come risolvere questo?


Answers

Nota che lo script di @ sdqali (almeno quando si utilizza Gradle 1.6) chiederà la password ogni volta che invochi attività gradle. Dato che ne hai solo bisogno quando fai gradle assembleRelease (o simile), puoi usare il seguente trucco:

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

Si noti che ho anche dovuto aggiungere il seguente (sotto Android) per farlo funzionare:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

Se si desidera evitare l'hardcoding del keystore e della password in build.gradle , è possibile utilizzare un file delle proprietà come spiegato qui: CONFIGURAZIONE DELLA FIRMAZIONE DI SEGNALI CON GRADO

Fondamentalmente:

1) creare un file myproject.properties su /home/[username]/.signing con tali contenuti:

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

2) creare un file gradle.properties (forse nella radice della directory del progetto) con i contenuti:

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

3) fai riferimento ad esso nel tuo build.gradle in questo modo:

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

È possibile richiedere password dalla riga di comando:

...

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
  }

  ...
}

...

Il if-then-elseblocco impedisce richieste di password durante la creazione di un rilascio. Sebbene il elseramo sia irraggiungibile, trasforma Gradle nella creazione di un install...Releasecompito.

Backstory . Come notato da https://.com/a/19130098/3664487 , "Gli script Gradle possono richiedere l'input dell'utente utilizzando il metodo readLine System.console () ." Sfortunatamente, Gradle richiederà sempre una password, anche quando stai creando una versione di debug (cf. Come creare un file apk firmato con Gradle? ). Fortunatamente, questo può essere superato, come ho mostrato sopra.


lavoro su Ubuntu14.04. vim ~ / .bashrc e aggiungi export ANDROID_KEYSTORE = export ANDROID_KEYALIAS =

e quindi nel set 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 {

        }
    }

}

Ho avuto diversi problemi che ho messo la seguente riga in un posto sbagliato:

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

Assicurati di mettere le parti di signingConfigs all'interno della sezione Android:

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

invece di

android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

È facile fare questo errore.


Quasi tutte le piattaforme offrono ora una sorta di portachiavi, quindi non c'è motivo di lasciare password di testo chiare in giro.

Propongo una soluzione semplice che utilizza il modulo Python Keyring (principalmente il keyring script della console companion) e un involucro minimale attorno a Groovy ['do', 'something'].execute() :

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

Usando questa funzione, la sezione signingConfigs diventa:

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

Prima di eseguire gradle assembleRelease è necessario impostare le password nel proprio keyring, una sola volta:

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

Buone uscite!


Ancora un altro approccio allo stesso problema. Poiché non è consigliabile memorizzare alcun tipo di credenziale all'interno del codice sorgente, abbiamo deciso di impostare le password per l'archivio chiavi e l'alias chiave in un file di proprietà separato come segue:

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

Se si utilizza git, è possibile creare un file di testo chiamato, ad esempio, secure.properties. Dovresti assicurarti di escluderlo dal tuo repository (se usi git, aggiungendolo al file .gitignore). Quindi, sarà necessario creare una configurazione di firma, come indicato da alcune delle altre risposte. L'unica differenza è nel modo in cui si caricheranno le credenziali:

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

Non dimenticare mai di assegnare manualmente signingConfig al tipo di build di rilascio (per qualche motivo a volte presumo che verrà usato automaticamente). Inoltre, non è obbligatorio abilitare proguard, ma è raccomandabile.

Ci piace questo approccio meglio dell'utilizzo di variabili di ambiente o della richiesta di input da parte dell'utente perché può essere fatto dall'IDE, passando al tipo di build di realease ed eseguendo l'app, piuttosto che dover utilizzare la riga di comando.


se non vuoi vedere Impossibile richiamare il metodo readLine () su oggetto nullo. prima devi scrivere in gradle.properties .

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

Un modo più semplice rispetto alle risposte precedenti:

Metti questo in ~/.gradle/gradle.properties

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

Modifica il tuo build.gradle questo modo:

...    
signingConfigs {

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

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

Quindi puoi eseguire gradle assembleRelease


(In risposta a user672009 sopra.)

Una soluzione ancora più semplice, se si desidera mantenere le password da un repository git; tuttavia, vuoi includere il tuo build.gradle in esso, che funziona benissimo con i sapori del prodotto, è quello di creare un file gradle separato. Chiamiamolo 'signing.gradle' (includilo nel tuo .gitignore). Proprio come se fosse il tuo file build.gradle meno tutto ciò che non è relativo alla firma in esso.

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

Quindi nel tuo file build.gradle includi questa riga sotto "apply plugin: 'android'"

 apply from: 'signing.gradle'

Se non si dispone o non si utilizzano più aromi, rinominare "flavor1" in "release" sopra, e si dovrebbe essere finito. Se usi i sapori continua.

Infine collega i tuoi sapori alla sua corretta firmaConfig nel tuo file build.gradle e dovresti aver finito.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

Come ha detto @Destil, ma permetti agli altri che non hanno la chiave per costruire: un modo più semplice delle risposte precedenti:

Metti questo in ~/.gradle/gradle.properties

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

Modifica il tuo build.gradle questo modo:

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

Quindi puoi eseguire gradle assembleRelease OR gradle build


Estendendo la risposta di David Vavra, crea un file ~ / .gradle / gradle.properties e aggiungi

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

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

Se hai già il file keystore, può essere semplice come aggiungere alcuni parametri al tuo comando build:

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

Non sono necessarie modifiche permanenti al tuo progetto Android.

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


Firma automatica dell'app con Gradle quando usi git

È incredibile quanti modi contorti ci sono per fare questo. Ecco la mia strada, dove cerco di aderire alla recommendation di Google. Tuttavia, la loro spiegazione non è completamente chiara, quindi descriverò la procedura per Linux in dettaglio.

Descrizione:

Le recommendation predefinite di recommendation per la firma automatica di un'app durante la compilazione, senza conservare le password e i file delle firme nel percorso di sviluppo dell'app (GIT), sono piuttosto oscure. Ecco le istruzioni passo-passo chiarite su come farlo.

Ipotesi iniziali:

Hai un'app chiamata "MyApp" in una directory data dal seguente percorso: $HOME/projects/mydev/MyApp . Tuttavia, la directory MyApp viene utilizzata e controllata con GIT.

Problema

Ovviamente non vogliamo avere i nostri file di firma o password da nessuna parte nella directory controllata GIT, anche se siamo in grado di usare .gitignore etc, è ancora troppo rischioso e facile da sbagliare. Quindi vogliamo i nostri file di keystore e di firma all'esterno.

Soluzione

Dobbiamo fare tre (3) cose:

  1. Crea un file di password che deve essere utilizzato da Android Studio
  2. Crea un file chiave di firma
  3. Modifica il file module build.gradle da usare (1) e (2).

Per questo esempio, denominiamo i due file:

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

Possiamo mettere entrambi questi file qui:

cd $HOME/projects/mydev/

(1) Creare il file di password del keystore

Il primo file contiene le password di testo in chiaro utilizzate in; e percorsi al file della chiave di rilascio in (2). Inizia con la compilazione, in quanto renderà più facile l'operazione di copiatura per il passaggio successivo.

cd $HOME/projects/mydev/

Modifica keystore.properties modo che il contenuto sia:

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

L'unica parte difficile qui è myStoreFileLocation . Questo è il percorso visto dal modulo build.gradle durante la compilazione. Questo di solito significa un percorso simile e relativo a: $HOME/projects/mydev/MyApp/app/build.gradle . Quindi, per puntare al file MyApp-release-key.jks , quello che dobbiamo mettere qui è:

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

Qui, abbiamo anche scelto l'alias "myapp" per la chiave. Quindi il file finale dovrebbe apparire:

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

(2) Creare il file della firma

Il secondo file viene generato automaticamente quando si crea la chiave di firma. Se non hai altre app e questo è il tuo unico keystore, quindi crea il file con:

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

Questo ti chiederà due password e un po 'di informazioni. (Stessa roba di Android Studio.) Ora copia / incolla le tue password scelte in precedenza.

(3) Modifica il file gradle.build tuo modulo per utilizzare quanto sopra

Le seguenti parti devono essere presenti nel file di build Gradle della tua app / modulo. Innanzitutto, aggiungi le seguenti righe all'esterno e prima del blocco di android {} .

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

Quindi, all'interno del blocco di android {} , aggiungere:

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

Ora dalla shell, puoi ricostruire la tua app con:

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

Ciò dovrebbe generare un'app correttamente firmata che può essere utilizzata in Google Play.


Se costruisci apk tramite linea di comando come me, puoi fornire la configurazione della firma come argomenti.

Aggiungi questo al tuo 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
}

Fai la tua signingConfigs questo modo

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

Quindi esegui il gradlew questo modo

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

Nel nuovo Android Studio, c'è un modo GUI che è molto semplice e popola anche il file Gradle.

  1. File -> Project Structure

  2. Module -> Scegli il modulo principale ('app' o un altro nome personalizzato)

  3. Scheda di Signing -> Più immagine per aggiungere una nuova configurazione

  4. Compila i dati sul lato destro

  5. OK e il file Gradle viene creato automaticamente

  6. Dovrai manualmente aggiungere una signingConfig signingConfigs.NameOfYourConfig all'interno di builtTypes{release{}}

Immagini:

Due importanti note (!):

(MODIFICA 12/15)

  1. Per creare un APK firmato, devi aprire la scheda Terminale di Android Studio (la parte inferiore dell'interfaccia principale) e inviare un comando ./gradlew assembleRelease

  2. Se hai dimenticato keyAlias (cosa succede spesso a me), dovrai avviare Build -> Generate Signed APK per avviare il processo e vedere il nome della chiave Alias.


Per completare le altre risposte, è anche possibile inserire il file gradle.properties nella propria cartella del modulo, insieme a build.gradle, nel caso in cui il keystore sia specifico per un progetto.


Mi sono divertito un sacco a capirlo. Ecco il mio percorso.

Passaggi da A a Z su come creare un file di build gradle in IntelliJ (v.13.1.4) Questo walk-through presume che tu sappia come creare un file di archivio di chiavi. Affinché questo tutorial funzioni, è necessario che il file del keystore si trovi nella cartella dell'app e sarà necessario che il file zipalign.exe si trovi in ​​"SDK-ROOT \ tools". Questo file si trova in genere in "SDK-ROOT \ build-tools" e in questa cartella si troverà nella cartella api più alta (alpha o beta, io raccomando la versione alpha).

Per quelli di voi che desiderano saltare direttamente qui è il file di sviluppo 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 {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:support-v4:20.0.0'
    compile 'com.android.support:appcompat-v7:20.0.0'
}

È possibile creare una parte di questo file di build (sopra) dall'opzione di menu: File / Struttura del progetto Da qui selezionare Facets e fare clic su 'Android-Gradle (App). Da qui vedrai le schede: "Proprietà", "Firma", "Aromi", "Tipi di costruzione" e "Dipendenze" per questo percorso che utilizzeremo semplicemente "Firma" e "Tipi di costruzione". Sotto "Tipi di build" (nella sezione del nome) inserisci un nome che desideri identificare la configurazione del tuo tipo di build e negli altri 4 campi inserisci le informazioni del tuo keystore (impostando il percorso del keystore quello nella cartella dell'app).

Sotto 'Tipi di costruzione' inserisci il valore 'assembleRelease' nel campo del nome, 'Debugable' dovrebbe essere impostato su false, 'Jni Debug Build' dovrebbe essere falso, impostare 'Esegui Proguard' su true e 'Zip Align' su vero. Questo genererà il file di build, ma non come sopra descritto, dovrai aggiungere alcune cose al file di build in seguito. La posizione del file ProGuard qui verrà impostata manualmente nel file gradle build. (come illustrato sopra)

I contenitori DSL che dovrai aggiungere in seguito sono i seguenti:

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

Dovrai anche aggiungere:

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

nota questo contenitore DSL sopra ('dipendenze') dovrebbe essere nella parte inferiore del file di configurazione ma non dentro il contenitore Android DSL. Per creare il contenitore delle dipendenze dal menu IntelliJ, selezionare: File / Struttura del progetto. Da lì selezionare nuovamente Facets e quindi Android-Gradle (app). Vedrai le stesse 5 schede menzionate sopra. Seleziona la scheda "Dipendenze" e aggiungi le dipendenze di cui hai bisogno.

Dopo aver fatto tutto questo dovresti vedere un file di build Gradle simile al file nella parte superiore di questo walk-through. Per creare la versione con zip firmata, dovrai aprire le attività di Gradle. È possibile accedere a questa finestra selezionando Visualizza / Finestre degli strumenti / Gradle. Da qui puoi fare doppio clic su 'assembleAssembleRelease. Questo dovrebbe generare l'APK distribuibile.

I potenziali problemi che possono verificarsi durante la compilazione del tuo rilascio sono (ma non limitati a): il tuo file di build Gradle si trova nel posto sbagliato. Ci sono due file di build Gradle; uno nella cartella principale dell'applicazione e un altro nella cartella dell'app sotto la radice dell'applicazione. È necessario l'utente di quest'ultimo.

Potresti anche avere problemi di lanugine. (Nota: Android Developer Studio è molto più utile a individuare i problemi di Lint rispetto a IntelliJ se noterai questo quando provi a generare un APK firmato dalle opzioni del menu)

Per risolvere i problemi relativi ai pelucchi è necessario inserire il seguente contenitore DSL all'interno del contenitore Android (in alto):

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

inserendo questo nel tuo contenitore Android DSL causerà la generazione di un file di errore nella cartella build (direttamente sotto la cartella dell'app) il nome del file dovrebbe essere qualcosa come "lint-results-release-fatal.html" questo file ti dirà la classe in cui si è verificato l'errore. Un altro file che verrà generato è un file XML che contiene l''ID di problema' associato all'errore del lint. Il nome del file dovrebbe essere qualcosa come "lint-results-release-fatal.xml". Da qualche parte vicino alla parte superiore del file vedrai un nodo 'problema' all'interno del quale vedrai qualcosa di simile a 'id = "IDOfYourLintProblem"'

Per correggere questo problema, aprire il file nel progetto elencato nel file "lint-results-assembleRelease-fatal.html" e immettere la seguente riga di codice nel file di classe Java appena sopra il nome della classe: @SuppressLint ("IDOfYourLintProblem "). Potrebbe essere necessario importare 'android.annotation.SuppressLint;'

Quindi il tuo file di classe java dovrebbe apparire come:

package com.WarwickWestonWright.developers4u.app.CandidateArea;

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

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

Si noti che la soppressione degli errori di sfilacciamento non è sempre la migliore IDEA a cui si possa stare meglio per modificare il codice che ha causato gli errori di sfilacciamento.

Un altro problema che potrebbe verificarsi è se non si imposta la variabile d'ambiente per la variabile d'ambiente Gradle HOME. Questa variabile si chiama 'GRADLE_HOME' e dovrebbe essere impostata il percorso della directory home gradle, qualcosa come 'C: \ gradle-1.12' A volte potresti anche voler impostare la variabile d'ambiente per 'ANDROID_HOME' impostarlo su 'YOUR- SDK-Root \ SDK'

Al termine, tornare alla finestra delle attività di Gradle e fare doppio clic su assembleAssembleRelease.

Se tutto va a buon fine, dovresti essere in grado di accedere alla cartella app \ build \ apk e trovare il file APK distribuibile.


Questa è una risposta a user672009 e aggiunta al post di sdqali (il suo codice si bloccherà sulla costruzione della versione di debug dal pulsante "Esegui" di IDE):

Puoi usare il seguente codice:

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 {

        }
    }

}

@ La risposta di Destil è buona se puoi riutilizzare la stessa configurazione su tutti i progetti. In alternativa, Android Studio viene fornito con un file local.properties che può essere utilizzato, ma è presumibilmente generato da IDE e non riesco a trovare un modo per estenderlo da Android Studio.

Questa è una variazione della risposta di @ jonbo . Questa risposta consente impostazioni specifiche del progetto, ma viene fornita con un po 'di overhead dello sviluppatore. Nello specifico, è necessario un boilerplate significativo per spostare la definizione di signingConfigs in un file separato, specialmente se è necessario farlo per più progetti, il che è una delle ragioni principali per scegliere questa soluzione rispetto a Destil's. Questo può essere alleviato anche includendo la linea

apply plugin: 'com.android.application'

nel file delle credenziali, poiché ciò consentirà il completamento dell'IDE.

Infine, la maggior parte delle soluzioni qui non consente di costruire il progetto in modalità di debug - che gestisce automaticamente la firma di debug - senza fornire una definizione di signingConfigs sintattica se non semanticamente valida. Se non è necessario produrre una build di rilascio da una determinata macchina, questo passaggio aggiuntivo può essere visto come un ostacolo inutile. D'altra parte, può essere un aiuto contro colleghi ignoranti o pigri che eseguono build di debug in produzione.

Questa soluzione consentirà le build di debug senza preoccuparsi delle credenziali, ma richiederà credenziali valide per produrre build di rilascio e richiede una quantità minima di codice. Tuttavia, come svantaggio potrebbe incoraggiare altri a sostituire i valori fittizi con credenziali reali e non c'è modo di proteggerli.

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

Questo crea una proprietà fittizia che serve puramente a produrre un file di build sintatticamente valido. I valori assegnati alle ext.signing di ext.signing sono irrilevanti per quanto riguarda le build di debug. Per abilitare le build di rilascio, copiare ext.signing in ext.signing e sostituire i valori fittizi con credenziali valide.

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

Ovviamente, signing.gradle dovrebbe essere ignorato da VCS.


Sono riuscito a risolverlo aggiungendo questo codice e costruendo con gradle build :

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

Questo genera un file apk con rilascio firmato.


Prova questo, lavora per me !. Spero che ciò possa aiutarti. Un modo semplice per cambiare la risorsa immagine senza adattatore di associazione.

<ImageButton
        ...
        android:id="@+id/btnClick"
        android:onClick="@{viewModel::onClickImageButton}"
        android:src="@{viewModel.imageButton}" />

e Visualizza la classe del modello:

public ObservableField<Drawable> imageButton;
private Context context;

//Constructor
public MainVM(Context context) {
    this.context = context;
    imageButton = new ObservableField<>();
    setImageButton(R.mipmap.image_default); //set image default
}

public void onClickImageButton(View view) {
    setImageButton(R.mipmap.image_change); //change image
}

private void setImageButton(@DrawableRes int resId){
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        imageButton.set(context.getDrawable(resId));
    }else{
        imageButton.set(context.getResources().getDrawable(resId));
    }
}




android gradle apk release android-gradle