APK'yı build.gradle'da anahtar deposu bilgisi koymadan imzala

O deposu şifrenizi ve anahtar şifre yüzden kurulum imza işlemi çalışıyorum değildir projenin saklanan build.gradledosyanın.

Şu anda aşağıdaki var build.gradle:

android {
    ...
    signingConfigs {
        release {
            storeFile file("my.keystore")
            storePassword "store_password"
            keyAlias "my_key_alias"
            keyPassword "key_password"
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release            
        }
    }
}

Mükemmel çalışıyor ama olmamalıdır değerlerini koymak storePasswordve keyPasswordbenim depoda. Ben koymak değil tercih ederim storeFileve keyAliasorada ya.

build.gradleBazı harici kaynaklardan (yalnızca bilgisayarımda bulunan bir dosya gibi) parola alacak şekilde değiştirmenin bir yolu var mı ?

Ve elbette, değiştirilmiş olan build.gradlebaşka bir bilgisayarda kullanılabilir olmalıdır (bilgisayar parolalara erişimi olmasa bile).

Önemli olursa Android Studio ve Mac OS X Maverics'te kullanıyorum.

Groovy ile ilgili güzel bir şey, Java kodunu özgürce karıştırabilmeniz ve kullanarak bir anahtar / değer dosyasında okunması oldukça kolaydır java.util.Properties. Belki de deyimsel Groovy kullanmanın daha kolay bir yolu var, ancak Java hala oldukça basit.

Bir keystore.propertiesdosya oluşturun (bu örnekte, projenizin kök dizininde) settings.gradle, ancak istediğiniz yere koyabilirsiniz:

storePassword=...
keyPassword=...
keyAlias=...
storeFile=...

Bunu şu adrese ekleyin build.gradle:

allprojects {
    afterEvaluate { project ->
        def propsFile = rootProject.file('keystore.properties')
        def configName = 'release'

        if (propsFile.exists() && android.signingConfigs.hasProperty(configName)) {
            def props = new Properties()
            props.load(new FileInputStream(propsFile))
            android.signingConfigs[configName].storeFile = file(props['storeFile'])
            android.signingConfigs[configName].storePassword = props['storePassword']
            android.signingConfigs[configName].keyAlias = props['keyAlias']
            android.signingConfigs[configName].keyPassword = props['keyPassword']
        }
    }
}

Alternatif olarak, Scott Barta'nın yanıtını otomatik oluşturulan not koduna daha benzer bir şekilde uygulamak isterseniz keystore.properties, proje kök klasörünüzde bir dosya oluşturabilirsiniz :

storePassword=my.keystore
keyPassword=key_password
keyAlias=my_key_alias
storeFile=store_file  

ve not kodunuzu şu şekilde değiştirin:

// Load keystore
def keystorePropertiesFile = rootProject.file("keystore.properties");
def keystoreProperties = new Properties()
keystoreProperties.load(new FileInputStream(keystorePropertiesFile))

...

android{

    ...

    signingConfigs {
        release {
            storeFile file(keystoreProperties['storeFile'])
            storePassword keystoreProperties['storePassword']
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
        }
    }

    ...

}

Bu özellikler dosyasını modülünüzün kökünde depolayabilirsiniz, bu durumda atlayın rootProjectve bu kodu farklı anahtar depoları ve anahtar takma adları için birkaç özellik kümesine sahip olacak şekilde değiştirebilirsiniz.

En kolay yol bir ~/.gradle/gradle.propertiesdosya oluşturmaktır .

ANDROID_STORE_PASSWORD=hunter2
ANDROID_KEY_PASSWORD=hunter2

Ardından build.gradledosyanız şu şekilde görünebilir:

android {
    signingConfigs {
        release {
            storeFile file('yourfile.keystore')
            storePassword ANDROID_STORE_PASSWORD
            keyAlias 'youralias'
            keyPassword ANDROID_KEY_PASSWORD
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Birkaç bağlantıyı okuduktan sonra:

http://blog.macromates.com/2006/keychain-access-from-shell/ http://www.thoughtworks.com/es/insights/blog/signing-open-source-android-apps-without-disclosing- şifreleri

Mac OSX kullandığınız için, şifrelerinizi saklamak için Anahtarlık Erişimi'ni kullanabilirsiniz.

Sonra sınıf yazılarınızda:

/* Get password from Mac OSX Keychain */
def getPassword(String currentUser, String keyChain) {
    def stdout = new ByteArrayOutputStream()
    def stderr = new ByteArrayOutputStream()
    exec {
        commandLine 'security', '-q', 'find-generic-password', '-a', currentUser, '-gl', keyChain
        standardOutput = stdout
        errorOutput = stderr
        ignoreExitValue true
    }
    //noinspection GroovyAssignabilityCheck
    (stderr.toString().trim() =~ /password: '(.*)'/)[0][1]
}

Bunun gibi kullanın:

getPassword (currentUser, "Android_Store_Password")

/* Plugins */
apply plugin: 'com.android.application'

/* Variables */
ext.currentUser = System.getenv("USER")
ext.userHome = System.getProperty("user.home")
ext.keystorePath = 'KEY_STORE_PATH'

/* Signing Configs */
android {  
    signingConfigs {
        release {
            storeFile file(userHome + keystorePath + project.name)
            storePassword getPassword(currentUser, "ANDROID_STORE_PASSWORD")
            keyAlias 'jaredburrows'
            keyPassword getPassword(currentUser, "ANDROID_KEY_PASSWORD")
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Ben böyle yaparım. Ortam Değişkenlerini Kullan

  signingConfigs {
    release {
        storeFile file(System.getenv("KEYSTORE"))
        storePassword System.getenv("KEYSTORE_PASSWORD")
        keyAlias System.getenv("KEY_ALIAS")
        keyPassword System.getenv("KEY_PASSWORD")
    }

Mevcut herhangi bir Android Studio gradle projesini almak ve herhangi bir dosyayı düzenlemeden komut satırından oluşturmak / imzalamak mümkündür. Bu, anahtarlarınızı ve parolalarınızı build.gradle dosyanızda değil, ayrı tutarken projenizi sürüm kontrolünde depolamayı çok güzel hale getirir:

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

Kabul edilen cevap, projenin aynı kök klasöründe bulunan APK'yı imzalamak için hangi anahtar deposunun kullanılacağını kontrol etmek için bir dosya kullanır. Git gibi vcs kullandığımızda , göz ardı edilecek özellikler dosyasını eklemeyi unuttuğumuzda kötü bir şey olabilir. Çünkü şifremizi dünyaya açıklayacağız. Sorunlar hala devam ediyor.

Özellikler dosyasını projemiz içinde aynı dizinde yapmak yerine dışarıda yapmalıyız. Gradle.properties dosyasını kullanarak dışarıda yapıyoruz.

İşte adımlar:

Kök projenizde gradle.properties dosyasını düzenleyin veya oluşturun ve aşağıdaki kodu ekleyin, yolu kendinizle düzenlemeyi unutmayın:

AndroidProject.signing=/your/path/androidproject.properties  

2. /pro / yolunuzda androidproject.properties oluşturun ve aşağıdaki kodu ekleyin, /your/path/to/android.keystore anahtar deponuzun yolunu değiştirmeyi unutmayın:

STORE_FILE=/your/path/to/android.keystore  
STORE_PASSWORD=yourstorepassword  
KEY_ALIAS=yourkeyalias  
KEY_PASSWORD=yourkeypassword  

3. uygulama modülünüzde build.gradle (proje kökü build.gradle değil) yoksa aşağıdaki kodu ekleyin veya buna ayarlayın:

signingConfigs {  
     release  
   }  
   buildTypes {  
   debug {  
     debuggable true  
   }  
   release {  
     minifyEnabled true  
     proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  
     signingConfig signingConfigs.release  
   }  
 }  

4.Adım 3'teki kodun altına aşağıdaki kodu ekleyin:

if (project.hasProperty("AndroidProject.signing")  
     && new File(project.property("AndroidProject.signing").toString()).exists()) {  
     def Properties props = new Properties()  
     def propFile = new File(project.property("AndroidProject.signing").toString())  
     if(propFile.canRead()) {  
      props.load(new FileInputStream(propFile))  
      if (props!=null && props.containsKey('STORE_FILE') && props.containsKey('STORE_PASSWORD') &&  
         props.containsKey('KEY_ALIAS') && props.containsKey('KEY_PASSWORD')) {  
         android.signingConfigs.release.storeFile = file(props['STORE_FILE'])  
         android.signingConfigs.release.storePassword = props['STORE_PASSWORD']  
         android.signingConfigs.release.keyAlias = props['KEY_ALIAS']  
         android.signingConfigs.release.keyPassword = props['KEY_PASSWORD']  
      } else {  
         println 'androidproject.properties found but some entries are missing'  
         android.buildTypes.release.signingConfig = null  
      }  
     } else {  
            println 'androidproject.properties file not found'  
          android.buildTypes.release.signingConfig = null  
     }  
   }  

Bu kod, 1. adımdaki gradle.properties dosyasında AndroidProject.signing özelliğini arayacaktır . Özellik bulunursa, özellik değerini 2. adımda oluşturduğumuz androidproject.properties'e işaret eden dosya yolu olarak çevirir . Ardından, tüm özellik değeri build.gradle için imzalama yapılandırması olarak kullanılacaktır.

Artık anahtar deposu şifremizi ifşa etme riski konusunda tekrar endişelenmemize gerek yok.

Devamı için build.gradle içinde deposu bilgi koymadan imzalanması Android Apk'nizin

Kimlik bilgilerini harici bir JSON dosyasına koymak isteyenler için ve sınıftan okumak istediğim şey budur:

my_project / credentials.json:

{
    "android": {
        "storeFile": "/path/to/acuity.jks",
        "storePassword": "your_store_password",
        "keyAlias": "your_android_alias",
        "keyPassword": "your_key_password"
    }
}

my_project / robot / uygulama / build.gradle

// ...
signingConfigs {
        release {

            def credsFilePath = file("../../credentials.json").toString()
            def credsFile = new File(credsFilePath, "").getText('UTF-8')
            def json = new groovy.json.JsonSlurper().parseText(credsFile)
            storeFile file(json.android.storeFile)
            storePassword = json.android.storePassword
            keyAlias = json.android.keyAlias
            keyPassword = json.android.keyPassword
        }
        ...
        buildTypes {
            release {
                signingConfig signingConfigs.release //I added this
                // ...
            }
        }
    }
// ...
}

Bir .jsondosya türünü seçmememin nedeni .properties(kabul edilen yanıtta olduğu gibi) bir dosya türü seçmemin nedeni, aynı dosyaya ( my_project/credentials.json) ihtiyaç duyduğum diğer özel özellikleri (diğer özel özellikleri) depolamak ve yine de gradle ayrıştırma yapmak bu dosyadan da bilgi imzalama.

Bu soru birçok geçerli Cevap verilmiş ama için yararlı olabilir kodumu paylaşmak istedim kütüphane sürdürüp çünkü, orijinal bırakır build.gradleoldukça temiz .

Modül dizinine bir klasör ekliyorum gitignore. Şöyle görünüyor:

/signing
    /keystore.jks
    /signing.gradle
    /signing.properties

keystore.jksve signing.propertieskendi kendini açıklayıcı olmalıdır. Ve signing.gradleşöyle görünüyor:

def propsFile = file('signing/signing.properties')
def buildType = "release"

if (!propsFile.exists()) throw new IllegalStateException("signing/signing.properties file missing")

def props = new Properties()
props.load(new FileInputStream(propsFile))

def keystoreFile = file("signing/keystore.jks")
if (!keystoreFile.exists()) throw new IllegalStateException("signing/keystore.jks file missing")

android.signingConfigs.create(buildType, {
    storeFile = keystoreFile
    storePassword = props['storePassword']
    keyAlias = props['keyAlias']
    keyPassword = props['keyPassword']
})

android.buildTypes[buildType].signingConfig = android.signingConfigs[buildType]

Ve orijinal build.gradle

apply plugin: 'com.android.application'
if (project.file('signing/signing.gradle').exists()) {
    apply from: 'signing/signing.gradle'
}

android {
    compileSdkVersion 27
    defaultConfig {
        applicationId ...
    }
}

dependencies {
    implementation ...
}

Gördüğünüz gibi, buildTypes'i belirtmek zorunda değilsiniz, eğer kullanıcı geçerli bir signingdizine erişebiliyorsa , sadece modüle koyar ve geçerli bir imzalı sürüm uygulaması oluşturabilir, aksi takdirde onun için çalışır normalde olurdu.

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
  }

  ...
}

...

Bu cevap daha önce ortaya çıktı: https://stackoverflow.com/a/33765572/3664487

Şifrem özel karakter Dolar işareti içerdiği $ ve ben gradle.properties dosyasında olduğunu kaçmak zorunda kaldı. Ondan sonra imza benim için çalıştı.