Gradle kullanarak bir sürüm imzalı apk dosyası nasıl oluşturulur?

Gradle'ı kullanarak bir sürüm imzalı apk dosyası oluşturmak için Gradle'ımın oluşturulmasını istiyorum.

Kodun doğru olup olmadığından emin değilim ya da yaparken bir parametre eksik gradle buildmi?

Gradle dosyamdaki kodlardan bazıları:

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

Gradle build BAŞARIYI bitirir ve build/apkklasörümde sadece ...-release-unsigned.apkve ...-debug-unaligned.apkdosyaları görüyorum .

Bunun nasıl çözüleceğine dair herhangi bir öneriniz var mı?

Önceki cevaplardan daha kolay yol:

Bunu içine koy ~/.gradle/gradle.properties

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

Kodunuzu değiştirin app/build.gradleve android {kod bloğunun içine ekleyin :

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

Sonra koşabilirsin gradle assembleRelease

Ayrıca signingConfigsGradle DSL referansına bakın

Ben bu kodu ekleyerek çözmek ve başardı gradle build:

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

Bu imzalı bir sürüm apk dosyası oluşturur.

@ Sdqali'nin komut dosyasının (en azından Gradle 1.6 kullanıldığında) herhangi bir sınıflandırma görevini her çağırışınızda parola isteyeceğini unutmayın . Sadece gradle assembleRelease(veya benzeri) yaparken buna ihtiyacınız olduğundan , aşağıdaki hileyi kullanabilirsiniz:

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

Ayrıca çalışması için aşağıdaki (android altında) eklemek zorunda olduğunu unutmayın:

buildTypes {
    release {
        signingConfig signingConfigs.release
    }
}

Anahtar deponuzu ve parolanızı build.gradle dosyasında kodlamaktan kaçınmak istiyorsanız, burada açıklandığı gibi bir özellikler dosyası kullanabilirsiniz: GRADLE İMZA YAPILANDIRMALARINI KULLANMA

Temelde:

1) bir myproject.properties dosyası oluşturmak /home/[username]/.signing bu içeriği ile:

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

2) İçeriği içeren bir gradle.properties dosyası (belki de proje dizininizin kökünde) oluşturun:

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

3) build.gradle'nizde buna bakın :

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

Git kullanırken Gradle ile otomatik uygulama imzalama

Bunu yapmak için kaç tane kıvrımlı yol olması şaşırtıcı. İşte kendi yolum, Googles'ın kendi tavsiyesine bağlı kalmaya çalışıyorum . Ancak, açıklamaları tam olarak açık değil, bu yüzden Linux prosedürünü ayrıntılı olarak açıklayacağım.

Açıklama:

Varsayılan Google talimatlarıŞifreleri ve imza dosyalarını uygulama geliştirme (GIT) yolunuzda tutmadan derleme sırasında bir uygulamayı otomatik olarak imzalamak için oldukça belirsizdir. İşte nasıl yapılacağı ile ilgili adım adım açıklamalı talimatlar.

İlk varsayımlar:

Aşağıdaki yolda verdiği bir dizindeki "Uygulamam" adı verilen bir uygulama vardır: $HOME/projects/mydev/MyApp. Ancak, MyApp dizini GIT ile kullanılır ve denetlenir.

Sorun

Açıkçası, çok güçlü bir şekilde kullanabilsek bile, imza veya şifre dosyalarımızı GIT kontrollü dizinin herhangi bir yerinde bulundurmak istemiyoruz .gitignore istemiyoruz, vb. Anahtar depomuzu ve imza dosyalarımızı dışarıda istiyoruz.

Çözüm

Üç (3) şey yapmamız gerekiyor:

1. Android Studio tarafından kullanılacak bir şifre dosyası oluşturun
2. İmza anahtarı dosyası oluştur
3. build.gradle(1) ve (2) kullanmak için modül dosyasını düzenleyin.

Bu örnek için iki dosyayı adlandırıyoruz:

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

Bu dosyaların her ikisini de buraya koyabiliriz:

cd $HOME/projects/mydev/

(1) Anahtar deposu şifre dosyasını oluşturun

İlk dosya, içinde kullanılan açık metin şifrelerini içerir; ve (2) 'deki serbest bırakma anahtarı dosyasının yollarını içerir. Bir sonraki adım için bir kopyala yapıştırma işlemini kolaylaştıracağından, bunu doldurmaya başlayın.

cd $HOME/projects/mydev/

Düzen keystore.properties's içeriği olacak şekilde:

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

Buradaki tek zor kısım myStoreFileLocation. Bu, derleme sırasında modül dosyasından görüldüğü gibidirbuild.gradle . Bu genellikle benzer ve göreli bir yol anlamına gelir: $HOME/projects/mydev/MyApp/app/build.gradle. MyApp-release-key.jks Dosyaya işaret etmek için buraya koymamız gereken şey:

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

Burada, anahtar için "myapp" takma adını da seçtik. Son dosya şöyle görünmelidir:

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

(2) İmza dosyasını oluşturun

İmza anahtarını oluşturduğunuzda ikinci dosya otomatik olarak oluşturulur. Başka uygulamanız yoksa ve bu tek anahtar deponuzsa, dosyayı şu şekilde oluşturun:

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

Bu sizden iki şifre ve bir grup bilgi isteyecektir. (Android Studio'dakiyle aynı şeyler.) Şimdi önceden seçtiğiniz şifreleri kopyalayın / yapıştırın.

(3) gradle.buildYukarıdakileri kullanmak için modül dosyanızı düzenleyin

Uygulamanızın / modülünüzün Gradle derleme dosyasında aşağıdaki parçaların bulunması gerekir. İlk olarak, aşağıdaki satırları ekleyin dışında ve öncesinde sizin android {}blokta.

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

Daha sonra, içandroid {} blok ekleyin:

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

Artık kabuktan uygulamanızı aşağıdakilerle yeniden oluşturabilirsiniz:

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

Bu, Google Play'de kullanılabilecek, düzgün şekilde imzalanmış bir uygulama oluşturmalıdır.

GÜNCELLEME: 2019-04-02

Daha yeni sürümleri keytoolve bir şey , yukarıda kullandığım gibi orijinal / varsayılan yerine PKCS12 tabanlı bir anahtar dosyası kullanmanız gerektiğini söylüyor . Daha sonra yeni açık PKCS12 formatına dönüştürmeniz gerektiğini söylerler. Ancak, Android geliştirme araçlarının henüz buna hazır olmadığı anlaşılıyor, çünkü yaparsanız, aşağıdaki garip hataları alacaksınız:

com.android.ide.common.signing.KeytoolException:"F: \ XXX \ XXX.jks" deposundan XXX anahtarı okunamadı: Anahtar Alınamadı: Son blok düzgün şekilde doldurulmadı. Şifre çözme sırasında kötü bir anahtar kullanılırsa bu tür sorunlar ortaya çıkabilir.

Bu yüzden dönüştürülmüş bir anahtar kullanmayın!

@Destil'in dediği gibi, ama anahtarı olmayanların inşa etmesine izin ver: Önceki cevaplardan daha kolay yol:

Bunu içine koy ~/.gradle/gradle.properties

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

Bunun build.gradlegibi değiştirin :

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

Sonra gradle assembleRelease VEYA çalıştırabilirsinizgradle build

( User672009 adlı kişiye yanıt olarak Yukarıdaki .)

Şifrelerinizi git deposundan uzak tutmak istiyorsanız daha da kolay bir çözüm; yine de, build.gradle içine dahil etmek istiyorum, hatta ürün lezzetleri ile harika çalışıyor, ayrı bir gradle dosyası oluşturmaktır. Buna 'signing.gradle' diyelim (.gitignore'unuza ekleyin). Tıpkı oturum açma ile ilgili olmayan her şey eksi build.gradle dosyanızmış gibi.

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

Sonra build.gradle dosyanıza "eklentiyi uygula:" android "in altına bu satırı ekleyin

 apply from: 'signing.gradle'

Birden fazla lezzetiniz yoksa veya kullanmıyorsanız, yukarıdaki "serbest bırakmak" için "lezzet1" olarak yeniden adlandırın ve işiniz bitmelidir. Eğer tatlar kullanıyorsanız devam edin.

Son olarak aromalarınızı build.gradle dosyanızdaki doğru signingConfig dosyasına bağlayın ve işiniz bitmelidir.

  ...

  productFlavors {

      flavor1 {
          ...
          signingConfig signingConfigs.flavor1
      }

      flavor2 {
          ...
          signingConfig signingConfigs.flavor2
      }
  }

  ...

Anahtar deposu dosyanız zaten varsa, build komutunuza birkaç parametre eklemek kadar basit olabilir:

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

Android projenizde kalıcı değişiklik yapmanız gerekmez.

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

Bu user672009'a bir yanıt ve sdqali'nin gönderisine ek olarak (kodu IDE'nin "Çalıştır" düğmesi ile hata ayıklama sürümü oluştururken çökecektir ):

Aşağıdaki kodu kullanabilirsiniz:

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 {

        }
    }

}

Yeni Android Studio'da çok kolay bir GUI yolu var ve Gradle dosyasını da dolduruyor.

1. File -> Project Structure

2. Module -> Ana modülü seçin ('uygulama' veya başka bir özel ad)

3. Signing sekmesi -> Yeni yapılandırma eklemek için artı resim

4. Sağ taraftaki verileri doldurun

5. Tamam ve Gradle dosyası otomatik olarak oluşturulur

6. signingConfig signingConfigs.NameOfYourConfigİçeriye manuel olarak bir satır eklemeniz gerekecekbuiltTypes{release{}}

Görüntüler:

İki önemli (!) Not:

(12/15 DÜZENLE)

1. İmzalı APK oluşturmak için Android Studio'nun Terminal sekmesini (ana arayüzün alt kısmı) açmanız ve bir komut vermeniz gerekir ./gradlew assembleRelease

2. Unutursanız keyAlias(bana sık sık ne olur), Build -> Generate Signed APKişlemi başlatmak ve Takma ad anahtarının adını görmek için başlatmanız gerekir.

Benim gibi komut satırı üzerinden apk oluşturursanız, imza yapılandırmasını bağımsız değişken olarak sağlayabilirsiniz.

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

Bunu signingConfigsböyle yap

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

Sonra yürütmek gradlewböyle

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

İmzalamaya yardımcı olması için -P komut satırı sınıflandırma seçeneğini de kullanabilirsiniz . Build.gradle dosyasında şuna singingConfigs ekleyin:

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

Sonra gradle build'i şöyle çağırın:

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

İsterseniz storeFile ve keyAlias ​​öğelerini ayarlamak için -P kullanabilirsiniz.

Bu temel olarak Destil'in çözümü ancak komut satırı seçenekleriyle.

Gradle özellikleri hakkında daha fazla bilgi için gradle kullanıcı kılavuzuna bakın .

@ Tüm projelerde aynı yapılandırmayı tekrar kullanabiliyorsanız Destil'in cevabı iyidir. Alternatif olarak, Android Studio local.propertiesbunun yerine kullanılabilecek bir dosyayla birlikte gelir , ancak sözde IDE tarafından oluşturulmuş ve Android Studio'dan genişletmenin bir yolunu bulamıyorum.

Bu @ jonbo'nun cevabının bir çeşididir . Bu cevap, projeye özgü ayarlara izin verir, ancak biraz geliştirici ek yükü ile birlikte gelir. Özellikle, signingConfigstanımı ayrı bir dosyaya taşımak için önemli bir kazan plakası gereklidir - özellikle de birden fazla proje için bunu yapmanız gerekiyorsa, bu çözümü Destil'lerden seçmek için birincil neden. Bu , hat da dahil edilerek biraz hafifletilebilir.

apply plugin: 'com.android.application'

IDE tamamlanmasına izin vereceğinden, kimlik bilgileri dosyasında.

Son olarak, çoğu çözümler burada yok değil bir sözdizimsel semantik değilse geçerli sağlamadan - otomatik ayıklama-imzalanması kolları - ayıklama modunda projeyi inşa izin signingConfigstanımını. Belirli bir makineden bir sürüm üretmeniz gerekmiyorsa, bu ekstra adım gereksiz bir engel olarak görülebilir. Öte yandan, üretimde hata ayıklama yapıları çalıştıran cahil veya tembel meslektaşlarına karşı bir yardım olabilir.

Bu çözüm, kimlik bilgileri hakkında hiç endişe duymadan hata ayıklama derlemelerine izin verir, ancak sürüm derlemeleri oluşturmak için geçerli kimlik bilgileri gerektirir ve çok az kaynak plakası alır. Bununla birlikte, bir dezavantaj olarak , başkalarını kukla değerleri gerçek kimliklerle değiştirmeye teşvik edebilir ve buna karşı korunmanın bir yolu yoktur.

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

Bu, yalnızca sözdizimsel olarak geçerli bir derleme dosyası üretmek için kullanılan sahte bir özellik oluşturur. ext.signingAdlı kullanıcının özelliklerine atanan değerler , hata ayıklama derlemeleri kadar önemsizdir. Salınımını kurar, kopyalama etkinleştirmek için ext.signingiçine signing.gradleve geçerli kimlik bilgileriyle sahte değerlerini değiştirin.

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

Tabii ki, signing.gradleVCS tarafından göz ardı edilmelidir.

Hemen hemen tüm platformlar şimdi bir çeşit anahtarlık sunuyor, bu yüzden açık metin şifrelerini etrafında bırakmak için bir neden yok.

Ben Python Anahtarlık modülü (özellikle eşlik konsolu komut dosyası keyring) ve Groovy ['do', 'something'].execute() özelliği etrafında minimal bir sarmalayıcı kullanan basit bir çözüm öneriyoruz :

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

Bu işlevi kullanarak signingConfigsbölüm şu hale gelir:

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

Çalıştırmadan önce gradle assembleRelease, anahtarlığınızdaki şifreleri yalnızca bir kez ayarlamanız gerekir:

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

Mutlu sürümler!

Cevabı David Vavra ile genişleterek ~ / .gradle / gradle.properties dosyası oluşturun ve ekleyin

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

Sonra build.gradle'de

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

Bunu anlamaya oldukça eğlendim. İşte benim adım adım.

IntelliJ'de bir sınıf oluşturma dosyasının nasıl oluşturulacağı konusunda A'dan Z'ye geçiş (v.13.1.4) Bu gözden geçirme, bir anahtar deposu dosyasının nasıl oluşturulacağını bildiğinizi varsayar. Bu öğreticinin çalışması için anahtar deposu dosyanızın uygulama klasörünüzde bulunması ve zipalign.exe dosyanızın 'SDK-ROOT \ tools' içinde bulunması gerekir. Bu dosya genellikle 'SDK-ROOT \ build-tools' içinde bulunur ve bu klasörün altında en yüksek api klasöründe bulunur (alfa veya beta alfa sürümünü öneririm).

Burada doğrudan atlamak isteyenler için kepçe yapı dosyası.

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

Bu derleme dosyasının bir kısmını (yukarıda) menü seçeneğinden oluşturabilirsiniz: Dosya / Proje Yapısı Buradan Facets'i seçin ve 'Android-Gradle (Uygulama)' yı tıklayın. Buradan sekmeler göreceksiniz: Bu özellikler için 'Özellikler', 'İmzalama', 'Lezzetler', 'Yapı Türleri' ve 'Bağımlılıklar' sadece 'İmzalama' ve 'Yapı Türleri'ni kullanacağız. 'Derleme Türleri'nin altında (ad bölümünde) derleme türü yapılandırmanızı tanımlamak istediğiniz herhangi bir adı girin ve diğer 4 alana anahtar deposu bilgilerinizi girin (anahtar deposu yolunu uygulama klasörünüzün altındaki ayarlayarak).

'Derleme Türleri' altında, ad alanına 'assembleRelease' değerini girin, 'Hata ayıklama' yanlış, 'Jni Hata Ayıklama Derleme' yanlış olmalı, 'Çalıştırma Koruması'nı true' ve 'Zip Align' doğru olarak ayarlayın. Bu derleme dosyası oluşturur, ancak yukarıda gösterildiği gibi değil, derhal derleme dosyasına birkaç şey eklemeniz gerekir. Buradaki ProGuard dosya konumu, sınıf oluşturma dosyasında manuel olarak ayarlanır. (yukarıda gösterildiği gibi)

Daha sonra eklemeniz gereken DSL kapları aşağıdaki gibidir:

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

Ayrıca şunları da eklemeniz gerekecek:

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

Yukarıdaki bu DSL konteynerinin ('bağımlılıklar') yapılandırma dosyasının altında olması, ancak android DSL konteynerinin içinde olmaması gerektiğini unutmayın. IntelliJ menüsünden bağımlılıklar kapsayıcısını oluşturmak için şunu seçin: Dosya / Proje Yapısı. Oradan tekrar Facets'i ve ardından Android-Gradle'ı (uygulama) seçin. Yukarıda belirtilenlerle aynı 5 sekmeyi göreceksiniz. 'Bağımlılıklar' sekmesini seçin ve istediğiniz bağımlılıkları ekleyin.

Tüm bunlar yapıldıktan sonra, bu açıklamanın üstündeki dosyaya benzer bir Gradle derleme dosyası görmelisiniz. İmzalı zip uyumlu sürümünüzü oluşturmak için Gradle görevlerini açmanız gerekir. Görünüm / Araç Pencereleri / Gradle'ı seçerek bu pencereye ulaşabilirsiniz. Buradan 'assembleAssembleRelease öğesini çift tıklayabilirsiniz. Bu, konuşlandırılabilir APK'nızı oluşturmalıdır.

Sürümünüzü derlerken oluşabilecek olası sorunlar şunlardır (ancak bunlarla sınırlı değildir): Gradle derleme dosyanız yanlış yerde. İki Gradle derleme dosyası vardır; biri uygulama kök klasörünüzde ve diğeri uygulama kökünün altındaki uygulama klasöründe. İkincisini kullanmalısınız.

Tüy bırakma problemleriniz de olabilir. (Not: Android Developer Studio, Lint sorunlarını tespit etmede IntelliJ'den çok daha iyidir, menü seçeneklerinden imzalı bir APK oluşturmaya çalışırken bunu göreceksiniz)

Tüysüz problemleri çözmek için, android kabın içine (üstte) aşağıdaki DSL kabını koymanız gerekir:

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

Bunu android DSL konteynerinize koymak, derleme dosyasında (doğrudan uygulama klasörünüzün altında) bir hata dosyasının oluşturulmasına neden olur, dosya adı 'lint-results-release-fatal.html' gibi bir dosya olmalıdır. hatanın oluştuğu sınıf. Oluşturulacak başka bir dosya, lint hatasıyla ilişkili 'sorun kimliği' içeren bir XML dosyasıdır. Dosya adı 'lint-results-release-fatal.xml' gibi bir şey olmalıdır. Dosyanın üst kısmına yakın bir yerde, içinde 'id = "IDOfYourLintProblem"' e benzer bir şey göreceğiniz bir düğüm 'sorunu' göreceksiniz.

Bu sorunu gidermek için projenizde 'lint-results-assembleRelease-fatal.html' dosyasında listelenen dosyayı açın ve Java Sınıf dosyasına sınıf adının hemen üzerinde şu kod satırını girin: @SuppressLint ("IDOfYourLintProblem "). 'Android.annotation.SuppressLint;' dosyasını içe aktarmanız gerekebilir.

Bu yüzden java sınıfı dosyanız aşağıdaki gibi görünmelidir:

package com.WarwickWestonWright.developers4u.app.CandidateArea;

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

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

Tiftik hatalarını bastırmanın her zaman en iyi IDEA olmadığını, lif hatalarına neden olan kodunuzu değiştirmek için daha iyi olabileceğinizi unutmayın.

Potansiyel olarak ortaya çıkabilecek başka bir sorun, Gradle HOME ortam değişkeni için ortam değişkenini ayarlamadıysanız. Bu değişken 'GRADLE_HOME' olarak adlandırılır ve gradle ana dizininin yolu olarak ayarlanmalıdır, 'C: \ gradle-1.12' gibi bir şey Bazen 'ANDROID_HOME' için ortam değişkenini ayarlamak için bunu 'YOUR- SDK-Kök \ sdk'

Bu yapıldıktan sonra Gradle görevleri penceresine dönün ve assembleAssembleRelease öğesini çift tıklatın.

Her şey başarılı olursa app \ build \ apk klasörüne gidip konuşlandırılabilir APK dosyanızı bulabilmeniz gerekir.

Yine aynı soruna başka bir yaklaşım. Kaynak kodunda herhangi bir kimlik bilgisinin depolanması önerilmediğinden, anahtar deposu ve anahtar diğer adı için şifreleri ayrı bir özellikler dosyasında aşağıdaki gibi ayarlamaya karar verdik:

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

Git kullanıyorsanız, secure.properties adlı bir metin dosyası oluşturabilirsiniz. Deponuzdan hariç tuttuğunuzdan emin olmalısınız (git kullanıyorsanız .gitignore dosyasına ekleyerek). Ardından, diğer yanıtların bazılarının belirttiği gibi bir imzalama yapılandırması oluşturmanız gerekir. Tek fark, kimlik bilgilerini nasıl yükleyeceğinizdir:

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

Hiçbir zaman signingConfig öğesini sürüm oluşturma türüne manuel olarak atamayı unutmayın (bazı nedenlerden dolayı bazen otomatik olarak kullanılacağını varsayıyorum). Ayrıca, korumayı etkinleştirmek zorunlu değildir, ancak tavsiye edilir.

Bu yaklaşımı, ortam değişkenlerini kullanmaktan veya kullanıcı girişi istemekten daha iyi seviyoruz çünkü komut satırını kullanmak yerine realease derleme türüne geçerek ve uygulamayı çalıştırarak IDE'den yapılabilir.

Android Studio Dosya -> Proje Yapısı'na gidin veya Ctrl + Alt + Üst Karakter + S tuşlarına basın

Resme Bakın

Tamam'ı tıklayın

Ardından signingConfigs, build.gradle dosyanızda oluşturulur.

Aşağıdaki satırı yanlış yere koyduğum birkaç sorun vardı:

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

SigningConfigs parçalarını android bölümünün içine yerleştirdiğinizden emin olun:

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

onun yerine

android
{
    ....
}

signingConfigs {
   release {
        ...
   }
}

Bu hatayı yapmak kolaydır.

2019 ve APK'yı V1 (kavanoz imzası) veya V2 (tam APK imzası) ile imzalamam gerekiyor. Ben "imzalı apk gradle oluşturmak" googled ve beni buraya getirdi. Bu yüzden orijinal çözümümü buraya ekliyorum.

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

Orijinal sorum: build.gradle dosyasından V1 (Jar imzası) veya V2 (Tam APK imzası) nasıl kullanılır

Diğer yanıtları tamamlamak için, anahtar deponuzun bir projeye özgü olması durumunda gradle.properties dosyanızı build.gradle ile birlikte kendi modül klasörünüze de yerleştirebilirsiniz.

Ubuntu14.04'te çalışıyorum. vim ~ / .bashrc ve dışa aktarma ekle ANDROID_KEYSTORE = dışa aktar ANDROID_KEYALIAS =

ve sonra build.gradle kümesinde.

    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 {

        }
    }

}

Alternatif olarak, yalnızca sürüm derlemelerinde çalışan bir görev tanımlamak mümkündür.

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

Komut satırından parola isteyebilirsiniz:

...

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
  }

  ...
}

...

if-then-elseEğer bir serbest bırakılmasını bina yaparken blok şifreler için istekleri engeller. Her ne kadar elsedal erişilemiyor, bu hileler bir yaratma içine Gradleinstall...Release görevi.

Backstory . Https://stackoverflow.com/a/19130098/3664487 tarafından not edildiği gibi , " Dereceli komut dosyaları, System.console (). ReadLine yöntemini kullanarak kullanıcı girişi isteyebilir ." Ne yazık ki, Gradle bir hata ayıklama sürümü oluştururken bile her zaman bir şifre isteyecektir (bkz . Gradle kullanarak sürüm imzalı bir apk dosyası nasıl oluşturulur? ). Neyse ki, yukarıda gösterdiğim gibi bu aşılabilir.

Reat -native-config paketini kullanarak React-Native'de yapmanın yolunu ekliyorum .
Bir .env dosyası oluşturun:

RELEASE_STORE_PASSWORD=[YOUR_PASSWORD]
RELEASE_KEY_PASSWORD=[YOUR_PASSWORD]

bunun sürüm denetiminin bir parçası olmaması gerektiğini unutmayın.

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

Benim durumumda, başka bir uygulamanın sürümüne yanlış apk yüklüyordum.

Groovy için (build.gradle)

İmza kimlik bilgilerinizi doğrudan build.gradle dosyasına koymamalısınız . Bunun yerine kimlik bilgileri sürüm kontrolü altında olmayan bir dosyadan gelmelidir.

Modüle özgü build.gradle dosyasının bulunduğu yere bir signing.properties dosyası koyun . Bunu .gitignore dosyanıza eklemeyi unutmayın !

signing.properties

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

Kotlin Script için (build.gradle.kts)

İmza kimlik bilgilerinizi doğrudan build.gradle.kts dosyasına koymamalısınız dosyasına . Bunun yerine kimlik bilgileri sürüm kontrolü altında olmayan bir dosyadan gelmelidir.

Modüle özgü build.gradle.kts dosyasının bulunduğu yere bir signing.properties dosyası koyun . Bunu .gitignore dosyanıza eklemeyi unutmayın !

signing.properties

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

null nesnesinde readLine () yöntemi çağrılamıyor'u görmek istemiyorsanız . önce gradle.properties yazmanız gerekir .

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