Bagaimana cara membuat file apk bertanda tangani rilis menggunakan Gradle?


514

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?



masuk dengan versi v1 (jar signature) atau v2 (signature apk lengkap) dari file gradle? solusi di sini: stackoverflow.com/questions/57943259/…
user1506104

Jawaban:


430

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


12
Metode terbaik jika Anda bertanya kepada saya. Menghemat apa pun di folder proyek saya / SVN dan saya dapat checkout 10 versi proyek saya tanpa harus khawatir tentang kunci.
Frank

8
Jika Anda menggunakan gradlew di Windows, Anda harus yakin GRADLE_USER_HOME didefinisikan sebagai variabel lingkungan untuk membuat ini berfungsi. Saya mengaturnya ke satu direktori di atas direktori proyek saya, dan meletakkan keystore saya di sana. Jalur ke keystore Anda di gradle.properties harus menggunakan garis miring (/) atau garis miring terbalik ganda (\\), bukan garis miring terbalik Windows tunggal. Untuk membuat keystore dari prompt perintah Windows, lihat stackoverflow.com/questions/3997748/how-can-i-create-a-keystore
Anachronist

3
Apakah path relatif ke tempat file build.gradle berada, atau relatif terhadap direktori root mesin?
Prem

1
@ Prim, file()selalu mengasumsikan jalur relatif. Gunakan new File(path)jika Anda ingin diperlakukan sebagai mutlak.
ars-longa-vita-brevis

4
Ini bekerja untuk saya dan yang paling sederhana. Di properti gradle.prop tentukan storeFile relatif terhadap modul build.gradle Anda, jadi RELEASE_STORE_FILE = .. / mykeystore. Jangan menambahkan tanda kutip lagi gradle mangles the path
Lakshman Chilukuri

263

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.


33
Apakah ada cara untuk membuatnya meminta saya untuk memasukkan kata sandi? Atau saran lain untuk menjaga kata sandi dari repositori git saya?
user672009

3
Saya mengedit build.gradle agar terlihat seperti milik Anda tetapi menjalankan "Dibangun> Buat APK yang ditandatangani ..." masih memberikan dialog itu kepada saya ("Lihat Panduan Pengguna Gradle untuk info lebih lanjut." Dll.) Dan tidak ada APK.
Semanticer

3
@Semanticer Eksekusi gradle buildatau gradlew builddalam perintah Terminal / Prompt
Phillip Kamikaze

12
@ user672009 Anda dapat memasukkan kata sandi dalam file properti dan mengecualikannya dari repo dengan .gitignore. Anda dapat melihat tautan ini. gist.github.com/gabrielemariotti/6856974
Gabriele Mariotti

1
@GabrieleMariotti Itu masih meninggalkan repositori yang tidak lengkap. Cara yang lebih baik adalah membuat skeleton signature.properties dan setelah melakukan "git update-index --assume-unchangeed signed.properties". Namun itu mencegah pengeditan futura dari komitmen. Sesuatu seperti opsi pertama yang disarankan sdqali tampaknya lebih baik.
user672009

67

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

Setelah menerapkan ini, installReleasemenghilang dari daftar tugas ... Mengapa?
Kaarel

1
@caspase Wish Saya telah menanggapi komentar Anda tentang "storePassword" dan "keyPassword" palsu itu dengan lebih serius. Tanpa menginisialisasi properti ini ("" misalnya) tanda * -release.apk yang ditandatangani tidak dibuat, tidak ada kesalahan yang ditampilkan dan Anda dibiarkan benar-benar bingung hanya dengan * -release-unsigned.apk di direktori PROJECT_NAME / build / apk / Anda . Man ...: /
vizZ

Terima kasih atas catatan tentang menambahkan penandatanganan konfigurasi di buildTypes -> Release. Itu memecahkan penandatanganan otomatis untuk saya!
mm2001

1
Saya membuat plugin gradle sederhana yang meminta kata sandi saat membangun apk rilis (menggunakan mathod yang dijelaskan dalam posting ini, tetapi Anda tidak perlu mendefinisikan storePassword & keyPassword palsu). Ini juga tersedia di pusat pakar. github.com/alexvasilkov/AndroidGradleSignPlugin
Alex Vasilkov

Ini bagus. Berhati-hatilah bahwa variabel lingkungan KEYSTOREperlu didefinisikan bahkan untuk build debug dan untuk "gradle sync" di dalam Android Studio, jika tidak maka akan memberikan kesalahan tentang path yang null.
Jerry101

63

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

1
Bagus sekali! Terima kasih. Kode ini harus ditambahkan sebelum bagian buildTypes {} dan bagian harus mendeklarasikan penandatangananConfig penandatangananConfigs.release seperti biasa.
theczechsensation

Akhirnya saya menemukan solusi untuk masalah ini. Satu-satunya hal yang sangat membantu saya! Ini bisa menjadi jawaban yang diterima ...
devnull69

39

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.

masukkan deskripsi gambar di sini

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!


Apakah signConfigs disimpan di dalam apk dan kemudian dapat didekompilasi oleh pengguna mana saja untuk mendapatkan kata sandi atau tidak muncul di apk?
JavierSegoviaCordoba

2
Bekerja seperti pesona. Terima kasih, ini seharusnya menjadi Jawaban yang diterima
pratham kesarkar

Bagaimana jika Anda hanya ingin keystore dan kata sandi di server build? Dengan solusi di atas setiap pengembang dalam tim perlu memiliki keystore pada mesin lokal mereka. Kalau tidak, sinkronisasi proyek Gradle akan gagal: keystore.properties (Tidak ada file atau direktori seperti itu).
Diana Farin

1
Anda dapat mengkomit keystore.propertiesfile dummy ke kontrol sumber, jadi build bekerja di mesin dev. Saya telah menggambarkan pengaturan server build di sini .
dskrvk

1
Catatan tentang update terakhir Anda tentang keytoolmenghasilkan keystore PKCS12: Anda dapat lulus -storetype JKSdalam keytoolperintah untuk mengatur jenis keystore untuk JKS yang dibutuhkan oleh perkakas Android.
Trevor Halvorson

35

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


Cara mengatur path di windows: path ke keystore Anda
reza_khalafi

file storeFile ("C: \\ Users \\ xxxx \\ Documents \\ yyyy \\ mykey.jks") apakah benar?
reza_khalafi

28

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

  ...

Bisakah kamu sedikit lebih spesifik. Saya tidak bisa menjalankannya: "tidak bisa menyelesaikan simbol SignConfig".
Amio.io

Jika saya memasukkan 'signed.gradle' di build.gradle - Saya terpaksa memilikinya di repositori git (kalau tidak saya mendapatkan error 'sign.gradle tidak ada'). Dan jika saya menempatkan 'penandatanganan.gradle' di git, itu mengalahkan tujuannya. Bagaimana saya bisa membuat masuknya signature.gradle opsional?
Jaguar

21

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


18

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 {

        }
    }

}

Apakah ada cara untuk memiliki beberapa nilai default? Keystore saya biasanya sama. Kata storePassword biasanya sama dengan keyPassword dan keyAlias ​​biasanya nama proyek dalam huruf kecil.
user672009

@ user672009 Anda selalu dapat menggunakan kode Java di dalam skrip.
AChep

1
Anda mungkin ingin menggunakan sesuatu seperti ini: keyPassword new String(console.readPassword("Enter key password: "))untuk memastikan kata sandi Anda tidak ditampilkan selama input
Alex Semeniuk

Ini tidak berfungsi lagi, lihat github.com/gradle/gradle/issues/1251
SqAR.org

16

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:

masukkan deskripsi gambar di sini

masukkan deskripsi gambar di sini

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.


2
Ini mengubah kata sandi Anda menjadi build.gradlefile, bukan?
Joshua Pinter

16

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"

Yang build.gradle? Tingkat terbaik? Silakan tambahkan lebih banyak kode
Vlad

Untuk memperjelas, ini adalah app/build.gradlefile yang saya bicarakan.
Egis

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

Menggunakan Android Studio 0.5.1, Gradle 1.11, dan plugin Gradle 0.9.
JP Ventura

1
Membuat properti berdasarkan permintaan (alias properti dinamis) telah usang dan dijadwalkan akan dihapus di Gradle 2.0
JP Ventura

10

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 .


7

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.


6

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!


5

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

5

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.


+1 untuk upaya dan: 'lintOptions {abortOnError false}'
Raz Tourgman

4

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.


1
Gradle tidak dikompilasi menggunakan ini: props = new Properties (); Tidak dapat menetapkan nilai properti hanya-baca 'properti'
cesards

Anda benar @ m3n0R. Saya mengedit sederet respons untuk mencerminkan perbaikan yang harus kami perkenalkan di aplikasi kami sehingga masih dapat dikompilasi menggunakan versi terbaru Gradle. Pada dasarnya, alat peraga harus dinyatakan sebagai variabel lokal.
argenkiwi

bagaimana ini bisa diadopsi menggunakan alat cloud CI / CD .... the / path / ke / keystore dan /path/to/secure.props melempar saya .... terima kasih untuk ini.
sirvon

4

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

Lihat Gambar

masukkan deskripsi gambar di sini

Klik Oke

Maka signConfigs akan menghasilkan pada file build.gradle Anda.

masukkan deskripsi gambar di sini


Dan inilah tepatnya yang tidak ingin Anda lakukan. Dengan cara ini semua kata sandi Anda berada dalam teks yang jelas dan bagian dari proyek Anda , dan sangat mudah untuk dimasukkan secara tidak sengaja, bahkan dalam bangunan Anda yang didistribusikan.
not2qubit

2

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.


2

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


Tidak perlu semi-titik dua; itu akan memberi Anda kesalahan.
Takeshi Kaga

Itu benar. Terima kasih. Saya mengedit jawabannya.
user1506104

1

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.


1

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 {

        }
    }

}

IMHO yang tampaknya menjadi solusi terbaik, tetapi sayangnya itu berhenti bekerja pada versi yang lebih baru dari Gradle : System.console()pengembalian null.
Antonio Vinicius Menezes Medei

1

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

Berikut ini tampaknya lebih baik bagi saya: stackoverflow.com/a/19130098/3664487 Bagaimana kedua pendekatan membandingkan?
user2768

1

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.


Jawaban saya sebelumnya mengalami masalah karena stackoverflow.com/questions/33897802/… . Saya telah merevisi jawaban saya untuk menghilangkan masalah ini.
user2768

@ Haroon, itu bekerja pada 24 November '15. Komunitas mungkin dapat membantu masalah Anda, tetapi Anda harus memberikan rincian lebih lanjut.
user2768

Saya suka solusi ini karena ini menghindari meletakkan kata sandi dalam teks yang jelas dalam file teks tetapi System.console (). ReadLine tidak berfungsi secara bertahap karena masalah yang mengganggu ini .
morpheus

@morpheus, saya tidak pernah punya masalah. Di atas bekerja untuk saya.
user2768

Saya pikir Anda menjalankan skrip dari dalam IDE. jika skrip dijalankan dari terminal Anda akan melihat kesalahan. tapi terima kasih atas jawaban ini. ini yang saya cari.
morpheus

0

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

0

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


0

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

0

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

-1

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=*****
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.