Gradle을 사용하여 릴리스 서명된 pk 파일을 만드는 방법은 무엇입니까?
나는 Gradle을 사용하여 릴리스 서명된 pk 파일을 만들기 위해 내 Gradle 빌드를 원합니다.
한지, 잘 .gradle build?
은 나의 은것나일다니부입에 입니다.build.gradle/build.gradle.kts파일 이름:
android {
...
signingConfigs {
release {
storeFile(file("release.keystore"))
storePassword("******")
keyAlias("******")
keyPassword("******")
}
}
}
Gradle 빌드가 성공적으로 완료되고, 내 작업에서build/apk 보입니다....-release-unsigned.apk그리고....-debug-unaligned.apkfiles 파일
이 문제를 해결하는 방법에 대한 제안이 있습니까?
이전 답변보다 쉬운 방법:
이것을 집어넣습니다.~/.gradle/gradle.properties
RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****
를 합니다.app/build.gradle그리고 이것을 내부에 추가합니다.android {코드 블록:
...
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
}
}
....
그럼 도망칠 수 있어요gradle assembleRelease
또한 다음에 대한 참조를 참조하십시오.signingConfigs DSL DSL
나는 이 코드를 추가하고 그것을 해결할 수 있었습니다, 그리고 그것으로 구축했습니다.gradle build:
android {
...
signingConfigs {
release {
storeFile file("release.keystore")
storePassword "******"
keyAlias "******"
keyPassword "******"
}
}
buildTypes {
release {
signingConfig signingConfigs.release
}
}
}
서명된 릴리스 apk 파일이 생성됩니다.
@sdqali의 스크립트는 (적어도 Gradle 1.6을 사용하는 경우) Gradle 작업을 호출할 때마다 암호를 요청합니다.할 때만 필요하기 때문에.gradle assembleRelease그와 유사하게) 과 같은 할 수 있습니다
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"
}
}
작동하려면 다음을 추가해야 했습니다(안드로이드 아래).
buildTypes {
release {
signingConfig signingConfigs.release
}
}
build.gradle에서 키 저장소 및 암호를 하드 코딩하지 않으려면 여기에 설명된 대로 속성 파일을 사용할 수 있습니다.
기본적으로:
다음 내용을 포함하여 /home/[cisco]/.dll에 myproject.properties 파일을 만듭니다.
keystore=[path to]\release.keystore
keystore.password=*********
keyAlias=***********
keyPassword=********
다음 내용으로 gradle.properties 파일(프로젝트 디렉토리의 루트에 있음)을 만듭니다.
MyProject.properties=/home/[username]/.signing/myproject.properties
build.gradle에서 다음과 같이 참조합니다.
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 사용 시 Gradle로 자동 앱 서명
이것을 하는 데 얼마나 많은 복잡한 방법이 있는지 놀랍습니다.여기에 저만의 방법이 있습니다. 저는 구글의 추천을 따르려고 노력합니다.하지만 그들의 설명이 완전히 명확하지 않아서 리눅스를 위한 절차를 자세히 설명하겠습니다.
설명:
앱 개발(GIT) 경로에 암호와 서명 파일을 유지하지 않고 빌드하는 동안 앱에 자동으로 서명하는 기본 Google 지침은 다소 모호합니다.다음은 방법에 대한 명확한 단계별 지침입니다.
초기 가정:
은 "을 다음: "마이앱".$HOME/projects/mydev/MyApp그러나 MyApp 디렉토리는 GIT로 사용되고 제어됩니다.
문제
는 GIT를 할 수 GIT 디렉토리 사용할 수 있는 경우에도 마찬가지입니다..gitignore등, 여전히 너무 위험하고 실수하기 쉽습니다.그래서 우리는 우리의 키스토어와 서명 파일을 밖으로 원합니다.
해결책
다음 세 가지를 수행해야 합니다.
- Android Studio에서 사용할 암호 파일 만들기
- 서명 키 파일 만들기
- 합니다.
build.gradle(를 사용할 . (1) 및 (2) 용할사파일를.
이 예에서는 두 개의 파일 이름을 지정합니다.
keystore.propertiesMyApp-release-key.jks
다음 두 파일을 모두 여기에 둘 수 있습니다.
cd $HOME/projects/mydev/
키 저장소 암호 파일 만들기
첫 번째 파일에는 에서 사용된 일반 텍스트 암호와 (2)의 릴리스 키 파일에 대한 경로가 포함되어 있습니다.복사 붙여넣기 작업을 다음 단계에서 더 쉽게 수행할 수 있도록 이 정보를 작성하는 것으로 시작합니다.
cd $HOME/projects/mydev/
집keystore.properties만족할 수 있도록 다음을 수행합니다.
storePassword=myStorePassword
keyPassword=mykeyPassword
keyAlias=myKeyAlias
storeFile=myStoreFileLocation
은 여서유게까부분은운다로일하,myStoreFileLocation이 경로는 모듈에서 볼 수 있는 경로입니다.build.gradle파일을 생성합니다. 다음과합니다.$HOME/projects/mydev/MyApp/app/build.gradle 그서다가위리해기키음을래▁to▁the위해▁so를 가리키기 위해서요.MyApp-release-key.jks파일, 여기에 넣어야 할 것은 다음과 같습니다.
../../../MyApp-release-key.jks
여기서는 키에 대한 "myapp" 별칭도 선택했습니다.그런 다음 최종 파일은 다음과 같습니다.
storePassword=myStorePassword
keyPassword=mykeyPassword
keyAlias=myapp
storeFile=../../../MyApp-release-key.jks
서명 파일 만들기
두 번째 파일은 서명 키를 만들 때 자동으로 생성됩니다.다른 앱이 없고 키 저장소만 있는 경우 다음을 사용하여 파일을 만듭니다.
cd $HOME/projects/mydev/
keytool -genkeypair -v -keystore MyApp-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias myapp
두 개의 비밀번호와 많은 정보를 요청합니다. (Android Studio와 동일한 내용)이제 이전에 선택한 암호를 복사/붙여넣습니다.
gradle.build의 파일을 입니다.
앱/모듈의 Gradle 빌드 파일에 다음 부품이 있어야 합니다.먼저, 바깥쪽과 앞에 다음 행을 추가합니다.android {}블록으로 막다
//def keystorePropertiesFile = rootProject.file("$HOME/.android/keystore.properties")
def keystorePropertiesFile = rootProject.file("../../keystore.properties")
def keystoreProperties = new Properties()
keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
그러면 안에.android {} 록블, 추:
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
...
}
}
}
이제 셸에서 다음을 사용하여 앱을 재구축할 수 있습니다.
cd $HOME/projects/mydev/MyApp/app/
./gradlew clean build
이렇게 하면 Google Play에서 사용할 수 있는 제대로 서명된 앱이 생성됩니다.
업데이트: 2019-04-02
의 의최버keytool위에서 사용한 것처럼 원본/기본값 대신 PKCS12 기반 키 파일을 사용해야 한다는 내용이 있습니다.그런 다음 새 열린 PKCS12 형식으로 변환해야 한다는 메시지가 계속 표시됩니다.그러나 Android 개발 도구는 아직 준비가 되지 않은 것 같습니다. 준비가 되면 다음과 같은 이상한 오류가 발생하기 때문입니다.
com.android.ide.common.signing.KeytoolException:저장소 "F:\XXX\XXX.jks"에서 키 XXX를 읽지 못했습니다. 키 가져오기에 실패했습니다. 지정된 최종 블록이 제대로 패딩되지 않았습니다.암호 해독 중에 잘못된 키가 사용되는 경우 이러한 문제가 발생할 수 있습니다.
그러니 변환된 키를 사용하지 마세요!
@Destil이 말한 것처럼, 그러나 키가 없는 다른 사람들에게 빌드를 허용합니다.이전 답변보다 쉬운 방법:
이것을 집어넣습니다.~/.gradle/gradle.properties
RELEASE_STORE_FILE={path to your keystore}
RELEASE_STORE_PASSWORD=*****
RELEASE_KEY_ALIAS=*****
RELEASE_KEY_PASSWORD=*****
를 합니다.build.gradle다음과 같이:
...
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
}
}
}
....
그럼 도망칠 수 있어요gradle assembleReleaseORgradle build
keystore 파일이 이미 있는 경우 빌드 명령에 몇 가지 매개 변수를 추가하는 것이 간단합니다.
./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 프로젝트를 영구적으로 변경할 필요가 없습니다.
출처: http://www.tinmith.net/wayne/blog/2014/08/gradle-sign-command-line.htm
(위의 사용자 672009에 대한 답변)
Git 저장소에서 암호를 보관하고 싶지만 제품 맛에도 잘 맞는 build.gradle을 포함하고 싶다면 더 쉬운 해결책은 별도의 gradle 파일을 만드는 것입니다.signing.gradle'(.gitignore에 포함)이라고 합니다.마치 그것이 당신의 build.gradle 파일에서 사인과 관련되지 않은 모든 것을 뺀 것처럼.
android {
signingConfigs {
flavor1 {
storeFile file("..")
storePassword ".."
keyAlias ".."
keyPassword ".."
}
flavor2 {
storeFile file("..")
storePassword ".."
keyAlias ".."
keyPassword ".."
}
}
}
그런 다음 build.gradle 파일에서 "appply plugin: 'android'" 바로 아래에 이 행을 포함합니다.
apply from: 'signing.gradle'
여러 가지 맛이 없거나 여러 가지 맛을 사용하지 않는 경우 위의 "flavor1"의 이름을 "release"로 변경하면 완료됩니다.맛을 사용하는 경우 계속합니다.
마지막으로 맛을 build.gradle 파일의 올바른 signingConfig에 연결하면 완료됩니다.
...
productFlavors {
flavor1 {
...
signingConfig signingConfigs.flavor1
}
flavor2 {
...
signingConfig signingConfigs.flavor2
}
}
...
다음은 사용자 672009에 대한 회신이며 sdqali의 게시물에 추가됩니다(IDE의 "실행" 버튼을 사용하여 디버깅 버전을 빌드할 때 코드가 충돌함).
다음 코드를 사용할 수 있습니다.
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 {
}
}
}
저처럼 명령줄을 통해 pk를 구축하면 서명 구성을 인수로 제공할 수 있습니다.
을 당신의 니추합다에 추가하세요.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
}
당신의 것을 만드세요.signingConfigs▁this.
signingConfigs {
release {
storeFile file(getStore())
storePassword getStorePassword()
keyAlias getKeyAlias()
keyPassword getKeyPassword()
}
}
그런 에 그다음실다니합을 합니다.gradlew▁this.
./gradlew assembleRelease -PstoreFile="keystore.jks" -PstorePassword="password" -PkeyAlias="alias" -PkeyPassword="password"
새로운 Android Studio에는 GUI 방식이 있어 매우 쉽고 Gradle 파일도 채웁니다.
File -> Project StructureModule ->기본 모듈('앱' 또는 기타 사용자 지정 이름)을 선택합니다.Signing> 구성을 하기 위해 추가하기새 ->오른쪽에 있는 데이터 채우기
확인 및 Gradle 파일이 자동으로 생성됩니다.
해야 할 것입니다.
signingConfig signingConfigs.NameOfYourConfig東京의builtTypes{release{}}
이미지:
두 가지 중요한(!) 참고:
(편집 12/15)
된 APK를탭 인터페이스을 "Android Studio" 명령을
./gradlew assembleReleasekeyAlias(일), (나에게 자주 일어나는 일), (나에게 일어나는 일)을 해야 할Build -> Generate Signed APK프로세스를 시작하고 별칭 키의 이름을 확인합니다.
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
}
}
}
Kotlin 스크립트(build.gradle.kts)의 경우
서명 자격 증명을 build.gradle.kts 파일에 직접 입력해서는 안 됩니다.대신 자격 증명은 버전 제어 하에 있지 않은 파일에서 가져와야 합니다.
모듈별 build.gradle.kts가 있는 signing.properties 파일을 저장합니다..gitignore 파일에 추가하는 것을 잊지 마세요!
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")
// ...
}
}
}
Gradle의 -P 명령줄 옵션을 사용하여 서명을 도울 수도 있습니다.build.gradle에서 다음과 같은 singingConfig를 추가합니다.
signingConfigs {
release {
storeFile file("path/to/your/keystore")
storePassword RELEASE_STORE_PASSWORD
keyAlias "your.key.alias"
keyPassword RELEASE_KEY_PASSWORD
}
}
그런 다음 gradle build를 다음과 같이 부릅니다.
gradle -PRELEASE_KEYSTORE_PASSWORD=******* -PRELEASE_KEY_PASSWORD=****** build
원하는 경우 -P를 사용하여 storeFile 및 keyAli를 설정할 수 있습니다.
이것은 기본적으로 Destil의 솔루션이지만 명령줄 옵션이 있습니다.
Gradle 속성에 대한 자세한 내용은 Gradle 사용자 가이드를 참조하십시오.
이제 거의 모든 플랫폼이 일종의 키링을 제공하기 때문에 명확한 텍스트 암호를 남겨둘 이유가 없습니다.
Python Keyring 모듈(주로 지원 콘솔 스크립트)을 사용하는 간단한 솔루션을 제안합니다.keyring그리고 그루비 주변의 미니멀 래퍼.['do', 'something'].execute() 특징:
def execOutput= { args ->
def proc = args.execute()
proc.waitFor()
def stdout = proc.in.text
return stdout.trim()
}
기능을 해서, 이기을사면하용능,,signingConfigs섹션은 다음과 같습니다.
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])
}
}
를 실행하기 gradle assembleRelease키링에서 암호를 한 번만 설정해야 합니다.
$ keyring set google-play android.keystore # will be prompted for the passwords
$ keyring set google-play com.example.app
행복한 석방!
@Destil의 답변은 모든 프로젝트에서 동일한 구성을 재사용할 수 있는 경우에 좋습니다.또는 Android Studio에는 다음과 같은 기능이 제공됩니다.local.properties대신 사용할 수 있는 파일이지만 IDE에서 생성된 것으로 추정되며 안드로이드 스튜디오 내에서 확장할 방법을 찾을 수 없습니다.
이것은 @jonbo의 대답의 변형입니다.이 답변은 프로젝트별 설정을 허용하지만 약간의 개발자 오버헤드가 수반됩니다.구체적으로, 이동하려면 상당한 보일러 플레이트가 필요합니다.signingConfigs별도의 파일로 정의합니다. 특히 여러 프로젝트에 대해 정의해야 하는 경우에는 Destil보다 이 솔루션을 선택하는 주된 이유가 됩니다.이는 라인을 포함함으로써 다소 완화될 수 있습니다.
apply plugin: 'com.android.application'
IDE를 완료할 수 있으므로 자격 증명 파일에 있습니다.
마지막으로, 여기에 있는 대부분의 솔루션은 의미론적으로 유효하지 않은 경우 구문적으로 제공하지 않고 디버그 서명을 자동으로 처리하는 디버그 모드에서 프로젝트를 빌드하는 것을 허용하지 않습니다.signingConfigs된 이 장애물로 될 수 .지정된 컴퓨터에서 릴리스 빌드를 생성할 필요가 없는 경우 이 추가 단계는 불필요한 장애물로 간주될 수 있습니다.반면에, 운영 환경에서 디버그 빌드를 실행하는 무지하거나 게으른 동료에 대한 도움이 될 수 있습니다.
이 솔루션을 사용하면 자격 증명에 대해 전혀 걱정하지 않고 디버그 빌드를 수행할 수 있지만 릴리스 빌드를 생성하려면 유효한 자격 증명이 필요하며, 이 작업은 거의 필요하지 않습니다.그러나 단점으로 다른 사람들이 더미 값을 실제 자격 증명으로 대체하도록 권장할 수 있으며 이에 대해 보호할 방법이 없습니다.
// 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
...
}
}
}
이렇게 하면 구문적으로 유효한 빌드 파일을 생성하는 데 사용되는 더미 속성이 생성됩니다.에 입니다.ext.signing의 속성은 디버그 빌드와 관련이 없습니다.빌드를 하십시오.ext.signing안으로signing.gradle더미 값을 유효한 자격 증명으로 대체합니다.
// signing.gradle
ext.signing = [
storeFilePath : 'real/keystore',
storePassword : 'real keystore password',
keyAlias : 'real key alias',
keyPassword : 'real key password',
]
물이야론.signing.gradleVCS에서 무시해야 합니다.
David Vavra의 답변을 확장하고 ~/.gradle/gradle.properties 파일을 만들고 추가합니다.
RELEASE_STORE_FILE=/path/to/.keystore
RELEASE_KEY_ALIAS=XXXXX
RELEASE_STORE_PASSWORD=XXXXXXXXX
RELEASE_KEY_PASSWORD=XXXXXXXXX
그러면 빌드에서.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
}
}
}
저는 이것을 알아내는 것이 꽤 재미있었습니다.이것이 제 소개입니다.
IntelliJ(v.13.1.4)에서 Gradle 빌드 파일을 생성하는 방법에 대한 A to Z 단계의 설명은 사용자가 키 저장소 파일을 만드는 방법을 알고 있다고 가정합니다.이 튜토리얼이 작동하려면 앱 폴더에 키 저장소 파일이 있어야 하고 zipalign이 있어야 합니다.exe 파일은 'SDK-ROOT\tools'에 있습니다.이 파일은 일반적으로 'SDK-ROOT\build-tools'에 있으며 이 폴더 아래에서 가장 높은 api 폴더(알파 또는 베타 버전 권장)에 있습니다.
여기에 바로 뛰어들고 싶은 분들을 위한 Gradle 빌드 파일이 있습니다.
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:0.9.+'
}
}
apply plugin: 'android'
repositories {
mavenCentral()
}
android {
compileSdkVersion 19
buildToolsVersion '20.0.0'
defaultConfig {
minSdkVersion 8
targetSdkVersion 19
versionCode 1
versionName "1.0"
}
signingConfigs {
playstore {
keyAlias 'developers4u'
keyPassword 'thisIsNotMyRealPassword'
storeFile file('developers4u.keystore')
storePassword 'realyItIsNot'
}
}
buildTypes {
assembleRelease {
debuggable false
jniDebugBuild false
runProguard true
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
zipAlign true
signingConfig signingConfigs.playstore
}
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'com.android.support:support-v4:20.0.0'
implementation 'com.android.support:appcompat-v7:20.0.0'
}
메뉴 옵션에서 이 빌드 파일(위)의 일부를 빌드할 수 있습니다.파일/프로젝트 구조 여기서 패싯을 선택하고 'Android-Gradle(App)'을 클릭합니다.여기서 '속성', '서명', '맛', '빌드 유형' 및 '의존성' 탭을 볼 수 있습니다. 여기서는 '서명' 및 '빌드 유형'을 사용합니다.이름 섹션의 '빌드 유형'에서 빌드 유형 구성을 식별할 이름을 입력하고 나머지 4개 필드에 키 저장소 정보를 입력합니다(애플리케이션 폴더 아래 키 저장소 경로 설정).
빌드 유형'에서 'assemblyRelease' 값을 이름 필드에 입력하고, 'Debugable'을 false로 설정하고, 'Jni Debug Build'를 false로 설정하고, 'Run Proguard'를 true로 설정하고, 'ZipAlign'을 true로 설정해야 합니다.이렇게 하면 빌드 파일이 생성되지만 위에서 설명한 것과 달리 나중에 빌드 파일에 몇 가지를 추가해야 합니다.여기서 ProGuard 파일 위치는 Gradle 빌드 파일에서 수동으로 설정됩니다.(위 그림과 같이)
나중에 추가해야 하는 DSL 컨테이너는 다음과 같습니다.
android {
....
compileSdkVersion 19
buildToolsVersion '20.0.0'
defaultConfig {
minSdkVersion 8
targetSdkVersion 19
versionCode 1
versionName "1.0"
}
....
}
또한 다음을 추가해야 합니다.
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'
}
위의 DSL 컨테이너('의존성')는 구성 파일의 맨 아래에 있어야 하지만 Android DSL 컨테이너 안에는 있어야 합니다.IntelliJ 메뉴에서 종속성 컨테이너를 작성하려면 다음을 선택합니다.파일/프로젝트 구조입니다.거기서 패셋을 다시 선택한 다음 Android-Gradle(앱)을 선택합니다.위에서 언급한 것과 동일한 5개의 탭이 표시됩니다.'의존성' 탭을 선택하고 필요한 종속성을 추가합니다.
이 모든 작업이 완료되면 이 워크스루의 맨 위에 있는 파일과 유사한 Gradle 빌드 파일이 표시됩니다.서명된 zip 정렬 릴리스를 작성하려면 Gradle 작업을 열어야 합니다.View/Tool Windows/Gradle을 선택하여 이 창으로 이동할 수 있습니다.여기서 '어셈블리 릴리스'를 두 번 클릭할 수 있습니다.배포 가능한 APK가 생성됩니다.
릴리스를 컴파일할 때 발생할 수 있는 잠재적인 문제는 다음과 같습니다(이에 국한되지 않음).Gradle 빌드 파일이 잘못된 위치에 있습니다.두 개의 Gradle 빌드 파일이 있습니다. 하나는 응용 프로그램 루트 폴더에 있고 다른 하나는 응용 프로그램 루트 아래의 응용 프로그램 폴더에 있습니다.후자를 사용해야 합니다.
보풀 문제도 있을 수 있습니다.(참고: Android Developer Studio는 IntelliJ보다 린트 문제를 훨씬 더 잘 발견합니다. 메뉴 옵션에서 서명된 APK를 생성하려고 할 때 이 사실을 알게 될 것입니다.
보풀 문제를 해결하려면 다음 DSL 컨테이너를 Android 컨테이너(맨 위) 안에 넣어야 합니다.
android {
....
lintOptions {
abortOnError false
}
....
}
이것을 안드로이드 DSL 컨테이너 안에 넣으면 빌드 폴더(앱 폴더 바로 아래)에 오류 파일이 생성됩니다. 파일 이름은 'lint-results-release-fatal'과 같아야 합니다.html' 이 파일은 오류가 발생한 클래스를 알려줍니다.생성되는 또 다른 파일은 린트 오류와 관련된 '이슈 ID'가 포함된 XML 파일입니다.파일 이름은 'lint-results-release-fatal.xml'과 같아야 합니다.파일의 맨 위 어딘가에 노드 '문제'가 있고, 그 안에 'id='와 유사한 것이 있습니다."린트 문제 ID"
이 문제를 해결하려면 'lint-results-assembly Release-fatal'에 나열된 프로젝트의 파일을 엽니다.html' 파일을 입력하고 클래스 이름 바로 위에 있는 Java 클래스 파일에 다음 줄의 코드를 입력합니다. @SuppressLint("Lint 문제의 ID").'안드로이드'를 가져와야 할 수도 있습니다.주석린트 억제;'
따라서 Java 클래스 파일은 다음과 같이 표시됩니다.
package com.WarwickWestonWright.developers4u.app.CandidateArea;
import android.annotation.SuppressLint;
... other imports
@SuppressLint("IDOfYourLintProblem")
public class SearchForJobsFragment extends Fragment {... rest of your class definition}
린트 오류를 억제하는 것이 항상 최선의 아이디어는 아닙니다. 린트 오류의 원인이 된 코드를 변경하는 것이 좋습니다.
잠재적으로 발생할 수 있는 또 다른 문제는 Gradle HOME 환경 변수에 대한 환경 변수를 설정하지 않은 경우입니다.이 변수의 이름은 'GRADLE_HOME'이며 'C:\gradle-1.12'와 같은 gradle 홈 디렉토리의 경로를 설정해야 합니다. 때로는 'ANDROID_HOME'의 환경 변수를 'YOUR-SDK-Root\sdk'로 설정해야 할 수도 있습니다.
이 작업이 완료되면 Gradle 작업 창으로 돌아가 Assembly Release를 두 번 클릭합니다.
모두 성공하면 app\build\apk 폴더로 이동하여 배포 가능한 APK 파일을 찾을 수 있습니다.
그루비용(build.gradle)
서명 자격 증명을 build.gradle 파일에 직접 입력해서는 안 됩니다.대신 자격 증명은 버전 제어 하에 있지 않은 파일에서 가져와야 합니다.
모듈별 build.gradle이 있는 signing.properties 파일을 저장합니다..gitignore 파일에 추가하는 것을 잊지 마세요!
signing.properties
storeFilePath=/home/willi/example.keystore
storePassword=secret
keyPassword=secret
keyAlias=myReleaseSigningKey
빌드.그래들
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
// ...
}
}
}
2019년인데 저는 V1(항아리 서명) 또는 V2(완전 APK 서명)로 APK에 서명해야 합니다.저는 "서명된 apk gradle 생성"을 구글에 검색했고 그것이 저를 여기로 데려왔습니다.그래서 저는 여기에 저의 원래 솔루션을 추가합니다.
signingConfigs {
release {
...
v1SigningEnabled true
v2SigningEnabled true
}
}
내 원래 질문:build.gradle 파일에서 V1(Jar 서명) 또는 V2(Full APK 서명)를 사용하는 방법
그러나 같은 문제에 대한 또 다른 접근법입니다.소스 코드에 어떤 종류의 자격 증명도 저장하지 않는 것이 좋습니다. 따라서 키 저장소 및 키 별칭의 암호를 다음과 같이 별도의 속성 파일에 설정하기로 결정했습니다.
key.store.password=[STORE PASSWORD]
key.alias.password=[KEY PASSWORD]
git를 사용하는 경우 secure.properties와 같은 텍스트 파일을 만들 수 있습니다.저장소에서 제외해야 합니다(git를 사용하는 경우 .gitignore 파일에 추가).그런 다음 다른 답변과 같이 서명 구성을 만들어야 합니다.유일한 차이점은 자격 증명을 로드하는 방법입니다.
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')
}
...
}
}
signingConfig를 릴리스 빌드 유형에 수동으로 할당하는 것을 잊지 마십시오(어떤 이유에서인지 가끔 자동으로 사용될 것으로 예상됩니다).또한 프로가드를 사용하도록 설정하는 것이 필수는 아니지만 권장됩니다.
우리는 이 접근 방식이 명령 줄을 사용하지 않고 IDE에서 Realase 빌드 유형으로 전환하고 앱을 실행하여 환경 변수를 사용하거나 사용자 입력을 요청하는 것보다 더 좋습니다.
Android Studio 파일로 이동 -> 프로젝트 구조 또는 Ctrl+Alt+를 누릅니다.Shift+S
이미지 보기
확인 클릭
그러면 signingConfigs가 build.gradle 파일에 생성됩니다.
다음 행을 잘못된 위치에 배치한 몇 가지 문제가 있었습니다.
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 부품을 Android 섹션 안에 넣으십시오.
android
{
....
signingConfigs {
release {
...
}
}
}
대신에
android
{
....
}
signingConfigs {
release {
...
}
}
이런 실수를 하는 것은 쉽습니다.
이것은 William Mentzel의 답변과 다른 Kotlin 빌드 스크립트(build.gradle.kts)에 대한 또 다른 답변입니다.
local.properties 파일에서 OS 환경 변수로 다시 이동하여 읽으려고 합니다.특히 GitHub Actions와 같은 CI에서 유용할 수 있습니다(저장소 설정에서 환경 비밀을 생성할 수 있음).
Kotlin 1.6.10 및 Gradle 7.4.2와 Android Gradle Plugin(AGP) 7.0.4를 사용하고 있습니다.
import com.android.build.gradle.internal.cxx.configure.gradleLocalProperties
// ...
val environment = System.getenv()
fun getLocalProperty(key: String) = gradleLocalProperties(rootDir).getProperty(key)
fun String.toFile() = File(this)
android {
signingConfigs {
create("MySigningConfig") {
keyAlias = getLocalProperty("signing.keyAlias") ?: environment["SIGNING_KEY_ALIAS"] ?: error("Error!")
storeFile = (getLocalProperty("signing.storeFile") ?: environment["SIGNING_STORE_FILE"] ?: error("Error!")).toFile()
keyPassword = getLocalProperty("signing.keyPassword") ?: environment["SIGNING_KEY_PASSWORD"] ?: error("Error!")
storePassword = getLocalProperty("signing.storePassword") ?: environment["SIGNING_STORE_PASSWORD"] ?: error("Error!")
enableV1Signing = true
enableV2Signing = true
}
}
buildTypes {
release {
signingConfig = signingConfigs["MySigningConfig"]
isMinifyEnabled = true
proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
}
}
}
앞서 말한 것처럼 프로젝트 루트에 local.properties 파일을 두고 속성 값을 지정할 수 있습니다.
signing.keyAlias=My key
signing.keyPassword=zyxwvuts
signing.storePassword=abcdefgh
signing.storeFile=C\:\\Users\\Mahozad\\keystore.jks
OS에 를 설정할 수 . 를 들어 " " " OS" " "/ " " 라는 할 수 있습니다. 예를 들어 다음과 같은 환경 변수를 생성할 수 있습니다.SIGNING_KEY_ALIAS선택사항:
- Windows 명령 프롬프트:
setx SIGNING_KEY_ALIAS "My key" - 터미널: Linux 파일:
export SIGNING_KEY_ALIAS="My key"
참고: 다른 답변에서 언급했듯이, local.properties 파일을 버전 제어 시스템(Git 등)에 추가하지 마십시오. 암호 등의 비밀 정보가 일반에 노출됩니다(공개 저장소인 경우).
이 답변에서 언급한 세 가지 방법 중 하나로 APK를 생성합니다.
다른 답변을 보완하기 위해 키 저장소가 하나의 프로젝트에 특정한 경우에 대비하여 gradle.properties 파일을 build.gradle과 함께 자신의 모듈 폴더에 배치할 수도 있습니다.
저는 Ubuntu14.04.vim ~/.svrc에서 일하고 있으며 내보내기 Android_KEYSTORE= 내보내기 Android_KEYALIAS=를 추가합니다.
그런 다음 빌드.그래들 세트로.
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 {
}
}
}
또는 릴리스 빌드에서만 실행되는 태스크를 정의하는 방법도 있습니다.
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();
}
명령줄에서 암호를 요청할 수 있습니다.
...
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-else차단을 사용하면 릴리스를 빌드할 때 암호에 대한 요청을 방지할 수 있습니다. 록비록▁the비.else연결할 수 . 분에도없수다습을 하도록 합니다. Gradle을 속여서 다음을 만듭니다.install...Releasetask.task.task.
뒷이야기.https://stackoverflow.com/a/19130098/3664487, 에서 언급한 바와 같이 "Gradle 스크립트는 System.console(.readLine 메서드를 사용하여 사용자 입력을 요청할 수 있습니다."불행히도, 디버그 릴리스(cf)를 빌드하는 동안에도 Gradle은 항상 암호를 요청합니다.Gradle을 사용하여 릴리스 서명된 pk 파일을 생성하는 방법은?)다행스럽게도, 위에서 보여드린 것처럼 이것은 극복될 수 있습니다.
react-native-config 패키지를 사용하여 React-Native에서 수행하는 방법을 추가합니다.
파일 파일을 .
RELEASE_STORE_PASSWORD=[YOUR_PASSWORD]
RELEASE_KEY_PASSWORD=[YOUR_PASSWORD]
이것은 버전 제어의 일부가 되어서는 안 됩니다.
의 신의에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')
}
}
저의 경우, 다른 앱의 릴리스에 잘못된 apk를 업로드하고 있었습니다.
언급URL : https://stackoverflow.com/questions/18328730/how-to-create-a-release-signed-apk-file-using-gradle
'programing' 카테고리의 다른 글
| AMD 프로세서를 사용하여 AVD를 시작하는 중 오류 발생 (0) | 2023.06.08 |
|---|---|
| jOOQ가 DSL.condition()의 값을 바인딩하지 않습니다. (0) | 2023.06.08 |
| mongo의 그룹 집계 후 _id 필드의 이름을 변경할 수 있습니까? (0) | 2023.06.03 |
| RSpec과 시간 비교 문제 (0) | 2023.06.03 |
| Xcode 4 - "보관"이 회색으로 표시됩니까? (0) | 2023.06.03 |