Bagaimana cara membuat file apk bertanda tangani rilis menggunakan Gradle?

Saya ingin agar Gradle build saya untuk membuat file apk yang ditandatangani rilis menggunakan Gradle.

Saya tidak yakin apakah kode itu benar atau apakah saya kehilangan parameter saat melakukan gradle build?

Ini adalah beberapa kode dalam file gradle saya:

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

The Gradle membangun selesai BERHASIL, dan saya build/apkfolder saya hanya melihat ...-release-unsigned.apkdan ...-debug-unaligned.apkfile.

Ada saran tentang cara mengatasi ini?

Cara yang lebih mudah daripada jawaban sebelumnya:

Masukkan ini ke dalam ~/.gradle/gradle.properties

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

Ubah app/build.gradle, dan tambahkan ini di dalam android {blok kode:

...    
signingConfigs {

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

       // Optional, specify signing versions used
       v1SigningEnabled true
       v2SigningEnabled true
   }
}

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

Maka Anda bisa lari gradle assembleRelease

Juga lihat referensi untuk signingConfigsDSL Gradle

Saya berhasil menyelesaikannya dengan menambahkan kode ini, dan membangun dengan gradle build:

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

Ini menghasilkan file apk rilis yang ditandatangani.

Catatan bahwa script @ sdqali akan (setidaknya ketika menggunakan Gradle 1,6) meminta password kapan Anda menjalankan setiap tugas Gradle. Karena Anda hanya memerlukannya saat melakukan gradle assembleRelease(atau serupa), Anda dapat menggunakan trik berikut:

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

Perhatikan bahwa saya juga harus menambahkan yang berikut (di bawah android) untuk membuatnya berfungsi:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

Jika Anda ingin menghindari hardcoding keystore & kata sandi di build.gradle , Anda dapat menggunakan file properti seperti yang dijelaskan di sini: HANDLING TANDA KONFIGURASI DENGAN GRADLE

Pada dasarnya:

1) buat file myproject.properties di /home/[username[/.signing dengan konten seperti ini:

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

2) buat file gradle.properties (mungkin di root direktori proyek Anda) dengan konten:

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

3) merujuknya di build.gradle Anda seperti ini:

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

Penandatanganan aplikasi otomatis dengan Gradle saat menggunakan git

Sungguh menakjubkan betapa banyak cara berbelit-belit yang ada untuk melakukan ini. Inilah cara saya sendiri, di mana saya mencoba mematuhi rekomendasi Googles sendiri . Namun, penjelasan mereka tidak sepenuhnya jelas, jadi saya akan menjelaskan prosedur untuk Linux secara rinci.

Deskripsi:

Instruksi Google default untuk menandatangani aplikasi secara otomatis selama pembuatan, tanpa menyimpan kata sandi dan file tanda tangan di jalur pengembangan aplikasi (GIT) Anda, agak tidak jelas. Berikut adalah petunjuk langkah demi langkah yang dijelaskan bagaimana cara melakukannya.

Asumsi awal:

Anda memiliki sebuah aplikasi yang disebut "MyApp" dalam direktori tertentu dengan lintasan berikut: $HOME/projects/mydev/MyApp. Namun, direktori MyApp digunakan dan dikendalikan dengan GIT.

Masalah

Kami jelas tidak ingin memiliki file tanda tangan atau kata sandi kami di mana pun di direktori yang dikontrol GIT, bahkan jika kami sangat dapat menggunakan .gitignoredll, masih terlalu berisiko dan mudah untuk membuat kesalahan. Jadi kami ingin keystore dan file tanda tangan kami di luar.

Larutan

Kita perlu melakukan tiga (3) hal:

1. Buat file kata sandi untuk digunakan oleh Android Studio
2. Buat file kunci tanda tangan
3. Edit build.gradlefile modul untuk menggunakan (1) dan (2).

Untuk contoh ini kita beri nama dua file:

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

Kami dapat meletakkan kedua file ini di sini:

cd $HOME/projects/mydev/

(1) Buat file kata sandi keystore

File pertama berisi kata sandi teks yang jelas digunakan di; dan path ke file rilis-kunci di (2). Mulailah dengan mengisi ini, karena akan membuat operasi copy paste lebih mudah untuk langkah selanjutnya.

cd $HOME/projects/mydev/

Edit keystore.propertiessehingga isinya adalah:

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

Satu-satunya bagian yang sulit di sini, adalah myStoreFileLocation. Ini adalah path seperti yang terlihat daribuild.gradle file modul selama build. Hal ini biasanya berarti jalan yang sama dan relatif: $HOME/projects/mydev/MyApp/app/build.gradle. Jadi untuk menunjuk ke MyApp-release-key.jks file, apa yang perlu kita taruh di sini adalah:

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

Di sini, kami juga memilih alias "myapp" untuk kunci. Maka file terakhir akan terlihat:

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

(2) Buat file tanda tangan

File kedua dihasilkan secara otomatis saat Anda membuat kunci tanda tangan. Jika Anda tidak memiliki aplikasi lain dan ini adalah satu-satunya keystore Anda, maka buat file dengan:

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

Ini akan meminta Anda dua kata sandi dan banyak info. (Hal yang sama seperti di Android Studio.) Sekarang salin / tempel kata sandi yang sebelumnya Anda pilih.

(3) Edit gradle.buildfile modul Anda untuk menggunakan hal di atas

Bagian-bagian berikut harus ada di file build Gradle aplikasi / modul Anda. Pertama, tambahkan baris berikut di luar dan sebelumandroid {} blok Anda .

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

Lalu, di dalam android {}blok, tambahkan:

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

Sekarang dari shell, Anda dapat membangun kembali aplikasi Anda dengan:

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

Ini harus menghasilkan aplikasi yang ditandatangani dengan benar yang dapat digunakan di Google Play.

PEMBARUAN: 2019-04-02

Versi yang lebih baru keytooldan ada sesuatu yang memberitahu Anda bahwa Anda harus menggunakan keyfile berbasis PKCS12 daripada yang asli / default seperti yang saya gunakan di atas. Mereka kemudian memberi tahu Anda bahwa Anda harus mengonversi ke format PKCS12 terbuka baru. Namun, tampaknya alat pengembangan Android belum siap untuk ini, karena jika Anda melakukannya, Anda akan mendapatkan kesalahan aneh berikut:

com.android.ide.common.signing.KeytoolException:Gagal membaca kunci XXX dari toko "F: \ XXX \ XXX.jks": Dapatkan Kunci gagal: Blok terakhir yang diberikan tidak diisi dengan benar. Masalah seperti itu dapat muncul jika kunci buruk digunakan selama dekripsi.

Jadi jangan gunakan kunci yang dikonversi!

Seperti @Destil katakan tetapi izinkan orang lain yang tidak memiliki kunci untuk membangun: Cara yang lebih mudah daripada jawaban sebelumnya:

Masukkan ini ke dalam ~/.gradle/gradle.properties

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

Ubah build.gradleseperti ini:

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

Maka Anda dapat menjalankan gradle assembleRelease ATAU gradle build

(Sebagai balasan untuk user672009 atas.)

Solusi yang bahkan lebih mudah, jika Anda ingin menyimpan kata sandi Anda dari repositori git; namun, ingin menyertakan build.gradle Anda di dalamnya, yang bahkan berfungsi baik dengan citarasa produk, adalah membuat file gradle terpisah. Sebut saja 'signed.gradle' (masukkan di .gitignore Anda). Seolah-olah itu adalah file build.gradle Anda minus semua yang tidak terkait dengan masuk.

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

Lalu di file build.gradle Anda sertakan baris ini tepat di bawah "apply plugin: 'android'"

 apply from: 'signing.gradle'

Jika Anda tidak memiliki atau menggunakan beberapa rasa, ganti nama "flavor1" menjadi "release" di atas, dan Anda harus selesai. Jika Anda menggunakan rasa, lanjutkan.

Terakhir tautkan rasa Anda ke penandatanganan yang benar di file build.gradle Anda dan Anda harus selesai.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

Jika Anda sudah memiliki file keystore, itu bisa sesederhana menambahkan beberapa parameter ke perintah build Anda:

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

Tidak diperlukan perubahan permanen untuk proyek Android Anda.

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

Ini adalah balasan untuk user672009 dan tambahan untuk posting sdqali (kodenya akan macet saat membangun versi debug oleh tombol "Run" IDE):

Anda dapat menggunakan kode berikut:

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 {

        }
    }

}

Di Android Studio yang lebih baru, ada cara GUI yang sangat mudah dan mengisi file Gradle juga.

1. File -> Project Structure

2. Module -> Pilih modul utama ('aplikasi' atau nama khusus lainnya)

3. Signing tab -> Plus gambar untuk menambahkan konfigurasi baru

4. Isi data di sisi kanan

5. File OK dan Gradle dibuat secara otomatis

6. Anda harus secara manual menambahkan baris signingConfig signingConfigs.NameOfYourConfigdi dalamnyabuiltTypes{release{}}

Gambar-gambar:

Dua catatan penting (!):

(EDIT 12/15)

1. Untuk membuat APK yang ditandatangani, Anda harus membuka tab Terminal Android Studio (bagian bawah antarmuka utama) dan mengeluarkan perintah ./gradlew assembleRelease

2. Jika Anda lupa keyAlias(apa yang sering terjadi pada saya), Anda harus memulai Build -> Generate Signed APKuntuk memulai proses dan melihat nama kunci Alias.

Jika Anda membangun apk melalui baris perintah seperti saya maka Anda dapat memberikan konfigurasi penandatanganan sebagai argumen.

Tambahkan ini ke 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
}

Jadikan signingConfigsseperti ini

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

Maka Anda jalankan gradlewseperti ini

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

Anda juga dapat menggunakan opsi -P perintah baris gradle untuk membantu penandatanganan. Di build.gradle Anda, tambahkan singingConfigs seperti ini:

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

Lalu panggil gradle build seperti ini:

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

Anda bisa menggunakan -P untuk mengatur storeFile dan keyAlias ​​jika Anda mau.

Ini pada dasarnya adalah solusi Destil tetapi dengan opsi baris perintah.

Untuk detail lebih lanjut tentang properti gradle, lihat panduan pengguna gradle .

Jawaban @ Destil baik jika Anda dapat menggunakan kembali konfigurasi yang sama di semua proyek. Atau, Android Studio dilengkapi denganlocal.properties file yang mungkin dapat digunakan sebagai gantinya, tetapi seharusnya itu dihasilkan oleh IDE dan saya tidak dapat menemukan cara untuk memperpanjangnya dari dalam Android Studio.

Ini adalah variasi dari jawaban @ jonbo . Jawaban itu memungkinkan pengaturan spesifik proyek tetapi disertai dengan sedikit overhead pengembang. Secara khusus, boilerplate yang signifikan diperlukan untuk memindahkan signingConfigsdefinisi ke file terpisah - terutama jika Anda perlu melakukannya untuk beberapa proyek, yang merupakan alasan utama untuk memilih solusi ini daripada Destil's. Ini bisa agak dikurangi dengan juga memasukkan garis

apply plugin: 'com.android.application'

dalam file kredensial, karena ini akan memungkinkan penyelesaian IDE.

Akhirnya, sebagian besar solusi di sini tidak memungkinkan membangun proyek dalam mode debug - yang menangani penandatanganan debug secara otomatis - tanpa memberikan sintaksis jika tidak secara semantik validsigningConfigs definisi yang . Jika Anda tidak perlu membuat rilis build dari mesin yang diberikan, langkah ekstra ini dapat dilihat sebagai hambatan yang tidak perlu. Di sisi lain, ini bisa menjadi bantuan terhadap kolega bodoh atau malas yang menjalankan debug build dalam produksi.

Solusi ini akan memungkinkan debug build tanpa mengkhawatirkan kredensial sama sekali, tetapi akan membutuhkan kredensial yang valid untuk menghasilkan rilis build, dan hanya membutuhkan sedikit boilerplate. Namun, sebagai sisi negatifnya itu mungkin mendorong orang lain untuk mengganti nilai-nilai dummy dengan kredensial nyata dan tidak ada cara untuk melindunginya.

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

Ini menciptakan properti dummy yang berfungsi murni untuk menghasilkan file build yang valid secara sintaksis. Nilai yang ditugaskan untuk ext.signingproperti tidak relevan sejauh debug membangun pergi. Untuk mengaktifkan rilis build, salin ext.signingke signing.gradledan ganti nilai dummy dengan kredensial yang valid.

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

Tentu saja, signing.gradleharus diabaikan oleh VCS.

Hampir semua platform sekarang menawarkan semacam keyring, jadi tidak ada alasan untuk meninggalkan kata sandi teks yang jelas.

Saya mengusulkan solusi sederhana yang menggunakan modul Python Keyring (terutama script konsol pendamping keyring) dan pembungkus minimal di sekitar ['do', 'something'].execute() fitur Groovy :

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

Menggunakan fungsi ini, signingConfigsbagian tersebut menjadi:

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

Sebelum menjalankan gradle assembleReleaseAnda harus mengatur kata sandi di kunci Anda, hanya sekali:

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

Selamat rilis!

Memperluas jawaban oleh David Vavra, membuat file ~ / .gradle / gradle.properties dan tambahkan

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

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

Saya cukup senang memikirkan hal ini. Ini adalah perjalananku.

Walk-through A hingga Z tentang cara membuat file gradle build di IntelliJ (v.13.1.4) Walk-through ini mengasumsikan Anda tahu cara membuat file keystore. Agar tutorial ini bisa berfungsi, Anda perlu file keystore Anda berada di folder aplikasi Anda dan Anda harus memiliki file zipalign.exe Anda di 'SDK-ROOT \ tools'. File ini biasanya ditemukan di 'SDK-ROOT \ build-tools' dan di bawah folder ini akan berada di folder api tertinggi (alfa atau beta saya sarankan versi alfa).

Bagi Anda yang ingin langsung masuk ke sini adalah file gradle build.

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

Anda dapat membuat bagian dari file build ini (atas) dari opsi menu: Struktur File / Proyek Dari sini pilih Aspek dan klik 'Android-Gradle (App). Dari sini Anda akan melihat tab: 'Properti', 'Penandatanganan', 'Rasa', 'Bangun Jenis' dan 'Ketergantungan' untuk penelusuran ini, kami hanya akan menggunakan 'Penandatanganan' dan 'Bangun Jenis'. Di bawah 'Tipe Bangun' (di bagian nama) masukkan nama apa pun yang ingin Anda identifikasi konfigurasi tipe bangun Anda dan di 4 bidang lainnya masukkan informasi keystore Anda (atur jalur keystore yang di bawah folder aplikasi Anda).

Di bawah 'Bangun Jenis' masukkan nilai 'assembleRelease' ke dalam bidang nama, 'Debuggable' harus disetel ke false, 'Jni Debug Build' harus salah, set 'Jalankan Proguard' ke true dan 'Zip Align' ke true. Ini akan menghasilkan file build, tetapi tidak seperti yang digambarkan di atas, Anda harus menambahkan beberapa hal ke file build sesudahnya. Lokasi file ProGuard di sini akan ditetapkan secara manual dalam file gradle build. (seperti yang digambarkan di atas)

Wadah DSL yang harus Anda tambahkan setelahnya adalah sebagai berikut:

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

Anda juga harus menambahkan:

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

perhatikan wadah DSL ini di atas ('dependensi') harus di bagian bawah file konfigurasi tetapi tidak di dalam wadah DSL android. Untuk membangun wadah dependensi dari menu IntelliJ, pilih: File / Struktur Proyek. Dari sana pilih Aspek lagi dan kemudian Android-Gradle (aplikasi). Anda akan melihat 5 tab yang sama seperti yang disebutkan di atas. Pilih tab 'Ketergantungan' dan tambahkan dependensi yang Anda butuhkan.

Setelah semua ini dilakukan, Anda akan melihat file build Gradle mirip dengan file di bagian atas walk-through ini. Untuk membangun rilis selaras zip yang ditandatangani, Anda harus membuka tugas Gradle. Anda dapat membuka jendela ini dengan memilih View / Tool Windows / Gradle. Dari sini Anda dapat menggandakan Klik 'assembleAssembemblelease. Ini seharusnya menghasilkan APK yang bisa digunakan.

Masalah potensial yang dapat terjadi saat mengkompilasi rilis Anda adalah (tetapi tidak terbatas pada): File build Gradle Anda berada di tempat yang salah. Ada dua file build Gradle; satu di folder root aplikasi Anda dan yang lain di folder aplikasi di bawah root aplikasi. Anda harus menggunakan yang terakhir.

Anda mungkin juga memiliki masalah serat. (Catatan: Android Developer Studio jauh lebih baik dalam menemukan masalah Lint daripada IntelliJ Anda akan melihat ini ketika mencoba membuat APK yang ditandatangani dari opsi menu)

Untuk mengatasinya, Anda harus meletakkan wadah DSL berikut di dalam wadah android (di atas):

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

memasukkan ini ke dalam wadah DSL Android Anda akan menyebabkan file kesalahan dihasilkan di folder build (langsung di bawah folder aplikasi Anda) nama file harus seperti 'lint-results-release-fatal.html' file ini akan memberi tahu Anda kelas tempat kesalahan terjadi. File lain yang akan dihasilkan adalah file XML yang berisi 'ID masalah' yang terkait dengan kesalahan serat. Nama file harus seperti 'lint-results-release-fatal.xml'. Di suatu tempat di dekat bagian atas file Anda akan melihat simpul 'masalah' di dalamnya Anda akan melihat sesuatu yang mirip dengan 'id = "IDOfYourLintProblem"'

Untuk memperbaiki masalah ini, buka file di proyek Anda yang terdaftar di file 'lint-results-assembleRelease-fatal.html' dan masukkan baris kode berikut dalam file Java Class tepat di atas nama kelas: @SuppressLint ("IDOfYourLintProblem "). Anda mungkin harus mengimpor 'android.annotation.SuppressLint;'

Jadi file kelas java Anda akan muncul seperti:

package com.WarwickWestonWright.developers4u.app.CandidateArea;

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

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

Perhatikan bahwa menekan kesalahan serat tidak selalu merupakan IDE terbaik yang Anda mungkin lebih baik untuk mengubah kode Anda yang menyebabkan kesalahan serat.

Masalah lain yang berpotensi terjadi adalah jika Anda belum menetapkan variabel lingkungan untuk variabel lingkungan Gradle HOME. Variabel ini bernama 'GRADLE_HOME' dan harus disetel path direktori home gradle, sesuatu seperti 'C: \ gradle-1.12' Kadang-kadang Anda mungkin juga ingin mengatur variabel lingkungan untuk 'ANDROID_HOME' atur ini ke 'ANDA- SDK-Root \ sdk '

Setelah ini selesai kembali ke jendela tugas Gradle dan klik dua kali assembleAssembleRelease.

Jika semuanya berhasil, Anda harus dapat membuka aplikasi folder \ build \ apk dan menemukan file APK yang dapat digunakan.

Namun pendekatan lain untuk masalah yang sama. Karena tidak disarankan untuk menyimpan kredensial apa pun dalam kode sumber, kami memutuskan untuk menetapkan kata sandi untuk penyimpanan kunci dan alias kunci dalam file properti terpisah sebagai berikut:

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

Jika Anda menggunakan git, Anda dapat membuat file teks bernama, misalnya, secure.properties. Anda harus memastikan untuk mengecualikannya dari repositori Anda (jika menggunakan git, menambahkannya ke file .gitignore). Kemudian, Anda perlu membuat konfigurasi penandatanganan, seperti yang ditunjukkan beberapa jawaban lainnya. Satu-satunya perbedaan adalah bagaimana Anda memuat kredensial:

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

Jangan pernah lupa untuk menugaskan penandatanganan konfigurasi untuk tipe rilis rilis secara manual (untuk beberapa alasan saya terkadang menganggap itu akan digunakan secara otomatis). Selain itu, tidak wajib untuk mengaktifkan proguard, tetapi dianjurkan.

Kami menyukai pendekatan ini lebih baik daripada menggunakan variabel lingkungan atau meminta input pengguna karena dapat dilakukan dari IDE, dengan beralih ke tipe build realease dan menjalankan aplikasi, daripada harus menggunakan baris perintah.

Android Studio Buka File -> Struktur Proyek atau tekan Ctrl + Alt + Shift + S

Lihat Gambar

Klik Oke

Maka signConfigs akan menghasilkan pada file build.gradle Anda.

Saya memiliki beberapa masalah yang membuat baris berikut di tempat yang salah:

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

Pastikan Anda memasukkan bagian SignConfigs di dalam bagian android:

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

dari pada

android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

Mudah untuk melakukan kesalahan ini.

Ini adalah 2019 dan saya harus menandatangani APK dengan V1 (tanda tangan jar) atau V2 (tanda tangan APK lengkap). Saya Google "menghasilkan grad apk yang ditandatangani" dan itu membawa saya ke sini. Jadi saya menambahkan solusi asli saya di sini.

signingConfigs {
    release {
        ...
        v1SigningEnabled true
        v2SigningEnabled true
    }
}

Pertanyaan asli saya: Cara menggunakan V1 (Jar signature) atau V2 (tanda tangan APK Lengkap) dari file build.gradle

Untuk melengkapi jawaban lainnya, Anda juga dapat menempatkan file properti gradle.prop di folder modul Anda sendiri, bersama dengan build.gradle, untuk berjaga-jaga jika keystore Anda dikhususkan untuk satu proyek.

saya bekerja di Ubuntu14.04. vim ~ / .bashrc dan tambahkan ekspor ANDROID_KEYSTORE = ekspor ANDROID_KEYALIAS =

dan kemudian di 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 {

        }
    }

}

Alternatifnya adalah dengan mendefinisikan tugas yang berjalan hanya pada rilis rilis.

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

Anda dapat meminta kata sandi dari baris perintah:

...

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
  }

  ...
}

...

The if-then-elseblok mencegah permintaan password ketika Anda sedang membangun sebuah rilis. Meskipun elsecabang tidak dapat dijangkau, ia menipu Gradle untuk membuat install...Releasetugas.

Backstory . Seperti dicatat oleh https://stackoverflow.com/a/19130098/3664487 , " Script gradle dapat meminta input pengguna menggunakan System.console (). Metode readLine ." Sayangnya, Gradle akan selalu meminta kata sandi, bahkan ketika Anda sedang membuat rilis debug (lih. Bagaimana cara membuat file apk bertanda rilis menggunakan Gradle? ). Untungnya, ini bisa diatasi, seperti yang saya tunjukkan di atas.

Menambahkan cara saya untuk melakukannya di React-Native menggunakan paket react-native-config .
Buat file .env:

RELEASE_STORE_PASSWORD=[YOUR_PASSWORD]
RELEASE_KEY_PASSWORD=[YOUR_PASSWORD]

perhatikan ini seharusnya tidak menjadi bagian dari kontrol versi.

di Anda build.gradle:

signingConfigs {
        debug {
            ...
        }
        release {
            storeFile file(RELEASE_STORE_FILE)
            storePassword project.env.get('RELEASE_STORE_PASSWORD')
            keyAlias RELEASE_KEY_ALIAS
            keyPassword project.env.get('RELEASE_KEY_PASSWORD')
        }
    }

Dalam kasus saya, saya mengunggah apk yang salah, ke rilis aplikasi lain.

Untuk Groovy (build.gradle)

Anda tidak harus menempatkan kredensial penandatanganan Anda langsung di build.gradle file . Sebaliknya kredensial harus berasal dari file yang tidak di bawah kontrol versi.

Letakkan file dengan penandatanganan.properti tempat modul khusus build.gradle ditemukan. Jangan lupa untuk menambahkannya ke file .gitignore Anda !

menandatangani.properti

storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey

build.gradle

android {
    // ...
    signingConfigs{
        release {
            def props = new Properties()

            def fileInputStream = new FileInputStream(file('../signing.properties'))
            props.load(fileInputStream)
            fileInputStream.close()

            storeFile = file(props['storeFilePath'])
            storePassword = props['storePassword']
            keyAlias = props['keyAlias']
            keyPassword = props['keyPassword']
        }
    }

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

Untuk Skrip Kotlin (build.gradle.kts)

Anda tidak boleh memasukkan kredensial penandatanganan Anda langsung di build.gradle.kts file . Sebaliknya kredensial harus berasal dari file yang tidak di bawah kontrol versi.

Letakkan file signed.properties tempat modul khusus build.gradle.kts ditemukan. Jangan lupa untuk menambahkannya ke file .gitignore Anda !

menandatangani.properti

storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey

build.gradle.kts

android {
    // ...
    signingConfigs {
        create("release") {
            val properties = Properties().apply {
                load(File("signing.properties").reader())
            }
            storeFile = File(properties.getProperty("storeFilePath"))
            storePassword = properties.getProperty("storePassword")
            keyPassword = properties.getProperty("keyPassword")
            keyAlias = "release"
        }
    }

    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            // ...
        }
    }
}

jika Anda tidak ingin melihat Cannot invoke method readLine () pada objek nol. Anda perlu menulis di gradle.properties terlebih dahulu.

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