Gostaria que meu Gradle fosse criado para criar um arquivo apk assinado de liberação usando o Gradle.
Não tenho certeza se o código está correto ou se estou perdendo um parâmetro ao fazer isso gradle build
?
Este é um pouco do código no meu arquivo gradle:
android {
...
signingConfigs {
release {
storeFile file("release.keystore")
storePassword "******"
keyAlias "******"
keyPassword "******"
}
}
}
A compilação gradle termina com SUCESSO e, na minha build/apk
pasta, só vejo os arquivos ...-release-unsigned.apk
e ...-debug-unaligned.apk
.
Alguma sugestão sobre como resolver isso?
Respostas:
Maneira mais fácil do que as respostas anteriores:
Coloque isso em
~/.gradle/gradle.properties
Modifique o seu
app/build.gradle
e adicione-o dentro doandroid {
bloco de código:Então você pode correr
gradle assembleRelease
Veja também a referência para o
signingConfigs
Gradle DSLfonte
file()
sempre assume caminhos relativos. Usenew File(path)
se você quiser que seja tratado como absoluto.Consegui resolvê-lo adicionando este código e construindo com
gradle build
:Isso gera um arquivo apk de versão assinada.
fonte
gradle build
orgradlew build
in Terminal / Prompt commandObserve que o script do @ sdqali solicitará (pelo menos ao usar o Gradle 1.6) a senha sempre que você invocar qualquer tarefa do gradle. Como você só precisa disso
gradle assembleRelease
(ou semelhante), pode usar o seguinte truque:Observe que eu também precisei adicionar o seguinte (no Android) para fazê-lo funcionar:
fonte
installRelease
desapareceu da lista de tarefas ... Por quê?KEYSTORE
precisa ser definida mesmo para compilações de depuração e para "gradle sync" no Android Studio; caso contrário, ocorrerá um erro sobre o caminho ser nulo.Se você quiser evitar codificar seu keystore e senha em build.gradle , poderá usar um arquivo de propriedades conforme explicado aqui: MANUSEANDO A ASSINATURA DE CONFIGURAÇÕES COM GRADLE
Basicamente:
1) crie um arquivo myproject.properties em / home /[ usernameername//assinando com esse conteúdo:
2) crie um arquivo gradle.properties (talvez na raiz do diretório do seu projeto) com o conteúdo:
3) consulte-o em seu build.gradle assim:
fonte
Assinatura automática de aplicativo com Gradle ao usar git
É incrível quantas maneiras complicadas existem para fazer isso. Aqui está o meu próprio caminho, em que tento seguir a própria recomendação do Google . No entanto, a explicação deles não é totalmente clara, portanto descreverei o procedimento para o Linux em detalhes.
Descrição:
As instruções padrão do Google para assinar automaticamente um aplicativo durante a compilação, sem manter as senhas e os arquivos de assinatura no caminho de desenvolvimento de aplicativos (GIT), são bastante obscuras. Aqui estão as instruções passo a passo esclarecidas sobre como fazer isso.
Premissas iniciais:
Você tem um aplicativo chamado "MyApp" em um diretório dado pelo seguinte caminho:
$HOME/projects/mydev/MyApp
. No entanto, o diretório MyApp é usado e controlado com o GIT.Problema
Obviamente, não queremos ter nossos arquivos de assinatura ou senha em nenhum lugar do diretório controlado pelo GIT, mesmo que sejamos capazes de usar
.gitignore
etc, ainda é muito arriscado e fácil cometer um erro. Portanto, queremos nossos arquivos de keystore e assinatura fora.Solução
Precisamos fazer três (3) coisas:
build.gradle
arquivo do módulo para usar (1) e (2).Neste exemplo, nomeamos os dois arquivos:
keystore.properties
MyApp-release-key.jks
Podemos colocar esses dois arquivos aqui:
(1) Crie o arquivo de senha do keystore
O primeiro arquivo contém as senhas de texto não criptografado usadas no; e caminhos para o arquivo da chave de liberação em (2). Comece preenchendo isso, pois facilitará a operação de copiar e colar para a próxima etapa.
Edite
keystore.properties
para que seu conteúdo seja:A única parte complicada aqui, é o
myStoreFileLocation
. Este é o caminho, conforme visto nobuild.gradle
arquivo do módulo durante a construção. Isto significa geralmente um caminho semelhante e em relação a:$HOME/projects/mydev/MyApp/app/build.gradle
. Portanto, para apontar para oMyApp-release-key.jks
arquivo, o que precisamos colocar aqui é:../../../MyApp-release-key.jks
Aqui, também escolhemos o alias "myapp" para a chave. Em seguida, o arquivo final deve parecer:
(2) Crie o arquivo de assinatura
O segundo arquivo é gerado automaticamente quando você cria a chave de assinatura. Se você não tiver outros aplicativos e este for seu único keystore, crie o arquivo com:
Isso solicitará duas senhas e várias informações. (O mesmo material do Android Studio.) Agora copie / cole as senhas escolhidas anteriormente.
(3) Edite seu
gradle.build
arquivo de módulo para usar o acimaAs seguintes partes precisam estar presentes no arquivo de construção Gradle do seu aplicativo / módulo. Primeiro, adicione as seguintes linhas fora e antes do seu
android {}
bloqueio.Em seguida, dentro do
android {}
bloco, adicione:Agora, a partir do shell, você pode recriar seu aplicativo com:
Isso deve gerar um aplicativo assinado corretamente que possa ser usado no Google Play.
ATUALIZAÇÃO: 2019-04-02
Versões mais recentes
keytool
e algo está lhe dizendo que você deve usar um arquivo de chaves baseado no PKCS12 em vez do original / padrão, como eu uso acima. Eles continuam dizendo que você deve converter para o novo formato aberto PKCS12. No entanto, parece que as ferramentas de desenvolvimento do Android ainda não estão prontas para isso, porque se você o fizer, receberá os seguintes erros estranhos:Portanto, não use uma chave convertida!
fonte
keystore.properties
arquivo fictício no controle de origem, para criar trabalhos em máquinas de desenvolvimento. Eu descrevi uma configuração do servidor de compilação aqui .keytool
geração de um keystore PKCS12: você pode transmitir-storetype JKS
okeytool
comando para definir o tipo de keystore como JKS, o que é necessário pelas ferramentas do Android.Como o @Destil disse, mas permita que outras pessoas que não têm a chave para criar: Maneira mais fácil do que as respostas anteriores:
Coloque isso em
~/.gradle/gradle.properties
Modifique o seu
build.gradle
como este:Então você pode executar
gradle assembleRelease
OUgradle build
fonte
(Em resposta ao usuário672009 acima.)
Uma solução ainda mais fácil, se você quiser manter suas senhas fora de um repositório git; No entanto, desejar incluir o build.gradle nele, que funciona muito bem com os sabores do produto, é criar um arquivo gradle separado. Vamos chamá-lo de 'signature.gradle' (inclua-o no seu .gitignore). Como se fosse o seu arquivo build.gradle menos tudo relacionado à sua entrada.
Em seguida, no seu arquivo build.gradle, inclua esta linha logo abaixo de "apply plugin: 'android'"
Se você não tiver ou usar vários sabores, renomeie "flavor1" para "release" acima e você deverá concluir. Se você estiver usando sabores, continue.
Por fim, vincule seus sabores a sua assinatura corretaConfig no arquivo build.gradle e você deverá concluir.
fonte
Se você já possui o arquivo keystore, pode ser tão simples quanto adicionar alguns parâmetros ao seu comando build:
Não são necessárias alterações permanentes no seu projeto Android.
Fonte: http://www.tinmith.net/wayne/blog/2014/08/gradle-sign-command-line.htm
fonte
Esta é uma resposta ao user672009 e uma adição à postagem do sdqali (seu código falhará na criação da versão de depuração pelo botão "Executar" do IDE):
Você pode usar o seguinte código:
fonte
keyPassword new String(console.readPassword("Enter key password: "))
se certificar que sua senha não é exibida durante a entradaNo Android Studio mais recente, existe uma maneira de GUI muito fácil e que também preenche os arquivos Gradle.
File -> Project Structure
Module ->
Escolha o módulo principal ('app' ou outro nome personalizado)Signing
guia -> imagem Plus para adicionar nova configuraçãoPreencher dados no lado direito
O arquivo OK e Gradle é criado automaticamente
Você precisará adicionar manualmente uma linha
signingConfig signingConfigs.NameOfYourConfig
dentrobuiltTypes{release{}}
Imagens:
Duas notas importantes (!):
(EDIT 12/15)
Para criar APK assinado, é necessário abrir a guia Terminal do Android Studio (parte inferior da interface principal) e emitir um comando
./gradlew assembleRelease
Se você esqueceu
keyAlias
(o que acontece frequentemente comigo), terá que iniciarBuild -> Generate Signed APK
para iniciar o processo e ver o nome da chave Alias.fonte
build.gradle
arquivo, não é?Se você criar o apk via linha de comando como eu, poderá fornecer a configuração de assinatura como argumentos.
Adicione isto ao seu
build.gradle
Faça o seu
signingConfigs
assimEntão você executa
gradlew
assimfonte
build.gradle
? Nível superior? Por favor, adicione mais códigoapp/build.gradle
arquivo que estou falando.fonte
Você também pode usar a opção de linha de comando -P da gradle para ajudar na assinatura. Em seu build.gradle, adicione o cantoConfigs como este:
Em seguida, chame gradle build assim:
Você pode usar -P para definir storeFile e keyAlias, se preferir.
Esta é basicamente a solução da Destil, mas com as opções de linha de comando.
Para obter mais detalhes sobre as propriedades da gradle, consulte o guia do usuário da gradle .
fonte
A resposta do @ Destil é boa se você puder reutilizar a mesma configuração em todos os projetos. Como alternativa, o Android Studio vem com um
local.properties
arquivo que talvez possa ser usado, mas é supostamente gerado por IDE e não consigo encontrar uma maneira de estendê-lo no Android Studio.Esta é uma variação da resposta de @ jonbo . Essa resposta permite configurações específicas do projeto, mas vem com um pouco de sobrecarga do desenvolvedor. Especificamente, um clichê significativo é necessário para mover a
signingConfigs
definição para um arquivo separado - especialmente se você precisar fazer isso para vários projetos, o que é um dos principais motivos para escolher essa solução em detrimento da Destil. Isso pode ser um pouco aliviado, incluindo também a linhano arquivo de credenciais, pois isso permitirá a conclusão do IDE.
Finalmente, a maioria das soluções aqui não permite a construção do projeto no modo de depuração - que lida com a assinatura de depuração automaticamente - sem fornecer uma
signingConfigs
definição válida sintaticamente, se não semanticamente válida . Se você não precisar produzir uma versão compilada a partir de uma determinada máquina, essa etapa extra poderá ser vista como um obstáculo desnecessário. Por outro lado, pode ser uma ajuda contra colegas ignorantes ou preguiçosos que executam compilações de depuração na produção.Essa solução permitirá compilações de depuração sem se preocupar com credenciais, mas exigirá credenciais válidas para produzir compilações de versão e requer muito pouco clichê. No entanto, como desvantagem, isso pode incentivar outras pessoas a substituir valores ilegais por credenciais reais e não há como se proteger contra isso.
Isso cria uma propriedade fictícia que serve apenas para produzir um arquivo de compilação sintaticamente válido. Os valores atribuídos às
ext.signing
propriedades de são irrelevantes na medida em que as compilações de depuração vão. Para ativar compilações, cópiaext.signing
emsigning.gradle
e substituir os valores fictícios com credenciais válidas.Obviamente,
signing.gradle
deve ser ignorado pelo VCS.fonte
Agora, quase todas as plataformas oferecem algum tipo de chaveiro; portanto, não há motivo para deixar senhas de texto não criptografado.
Proponho uma solução simples que use o módulo Python Keyring (principalmente o script do console complementar
keyring
) e um wrapper mínimo em torno do['do', 'something'].execute()
recurso Groovy :Usando esta função, a
signingConfigs
seção se torna:Antes de executar,
gradle assembleRelease
você deve definir as senhas no seu chaveiro, apenas uma vez:Happy releases!
fonte
Estendendo a resposta de David Vavra, crie um arquivo ~ / .gradle / gradle.properties e inclua
Em seguida, no build.gradle
fonte
Eu me diverti bastante tentando entender isso. Aqui está o meu passo a passo.
Instruções passo a passo de A a Z sobre como criar um arquivo de construção da classificação no IntelliJ (v.13.1.4) Esta explicação pressupõe que você sabe como criar um arquivo keystore. Para que este tutorial funcione, você precisará que o arquivo keystore esteja localizado na pasta do aplicativo e que o arquivo zipalign.exe esteja localizado em 'SDK-ROOT \ tools'. Esse arquivo geralmente é encontrado em 'SDK-ROOT \ build-tools' e, nesta pasta, ele estará na pasta api mais alta (alfa ou beta, recomendo a versão alfa).
Para aqueles de vocês que desejam pular direto aqui, está o arquivo de construção do gradle.
Você pode criar parte desse arquivo de compilação (acima) na opção de menu: Estrutura de arquivo / projeto A partir daqui, selecione Facetas e clique em 'Android-Gradle (App). A partir daqui, você verá as guias: 'Propriedades', 'Assinatura', 'Sabores', 'Tipos de compilação' e 'Dependências' para este passo a passo. Apenas usaremos 'Assinatura' e 'Tipos de compilação'. Em 'Tipos de compilação' (na seção nome), insira qualquer nome que você deseja identificar sua configuração de tipo de compilação e nos outros 4 campos insira suas informações de armazenamento de chaves (definindo o caminho do armazenamento de chaves como aquele na pasta de aplicativos).
Sob os 'Tipos de compilação', digite o valor 'assembleRelease' no campo de nome, 'Debuggable' deve ser definido como falso, 'Jni Debug Build' deve ser falso, defina 'Run Proguard' como true e 'Zip Align' como true. Isso irá gerar o arquivo de construção, mas não como descrito acima, você precisará adicionar algumas coisas ao arquivo de construção posteriormente. O local do arquivo ProGuard aqui será definido manualmente no arquivo de compilação gradle. (como mostrado acima)
Os contêineres DSL que você precisará adicionar posteriormente são os seguintes:
Você também terá que adicionar:
observe que esse contêiner DSL acima ('dependências') deve estar na parte inferior do arquivo de configuração, mas não dentro do contêiner DSL do Android. Para criar o contêiner de dependências no menu IntelliJ, selecione: Estrutura de Arquivo / Projeto. A partir daí, selecione Facetas novamente e, em seguida, Android-Gradle (aplicativo). Você verá as mesmas 5 guias mencionadas acima. Selecione a guia 'Dependências' e adicione as dependências necessárias.
Depois de tudo isso, você verá um arquivo de compilação Gradle semelhante ao arquivo na parte superior deste guia. Para criar sua versão com alinhamento zip assinado, você precisará abrir as tarefas Gradle. Você pode acessar essa janela selecionando Exibir / Janelas de ferramentas / Gradle. A partir daqui, você pode clicar duas vezes em 'assembleAssembleRelease. Isso deve gerar seu APK implantável.
Os possíveis problemas que podem ocorrer ao compilar sua versão são (mas não limitados a): O arquivo de construção do Gradle está no lugar errado. Existem dois arquivos de construção Gradle; um na pasta raiz do aplicativo e outro na pasta do aplicativo, na raiz do aplicativo. Você deve usar o último.
Você também pode ter problemas com fiapos. (Nota: o Android Developer Studio é muito melhor para detectar problemas de cotão do que o IntelliJ; você perceberá isso ao tentar gerar um APK assinado nas opções do menu)
Para contornar problemas com fiapos, você precisará colocar o seguinte contêiner DSL dentro do contêiner Android (na parte superior):
colocar isso dentro do contêiner DSL do Android fará com que um arquivo de erro seja gerado na pasta de construção (diretamente abaixo da pasta do aplicativo), o nome do arquivo deve ser algo como 'lint-results-release-fatal.html'. a classe em que o erro ocorreu. Outro arquivo que será gerado é um arquivo XML que contém o 'ID do problema' associado ao erro de cotão. O nome do arquivo deve ser algo como 'lint-results-release-fatal.xml'. Em algum lugar próximo à parte superior do arquivo, você verá um nó 'issue' dentro do qual verá algo semelhante a 'id = "IDOfYourLintProblem"'
Para corrigir esse problema, abra o arquivo em seu projeto listado no arquivo 'lint-results-assembleRelease-fatal.html' e digite a seguinte linha de código no arquivo Java Class logo acima do nome da classe: @SuppressLint ("IDOfYourLintProblem "). Pode ser necessário importar 'android.annotation.SuppressLint;'
Portanto, seu arquivo de classe java deve aparecer como:
Observe que suprimir erros de cotão nem sempre é a melhor IDEA; é melhor alterar seu código que causou os erros de cotão.
Outro problema que pode ocorrer é se você não tiver definido a variável de ambiente para a variável de ambiente Gradle HOME. Essa variável é denominada 'GRADLE_HOME' e deve ser definida como o caminho do diretório inicial da gradle, algo como 'C: \ gradle-1.12' Às vezes, você também pode querer definir a variável de ambiente para 'ANDROID_HOME' e definir como 'SUA- Raiz do SDK \ sdk '
Depois disso, retorne à janela de tarefas Gradle e clique duas vezes no assembleAssembleRelease.
Se tudo der certo, você poderá acessar a pasta app \ build \ apk e encontrar o arquivo APK implementável.
fonte
Mais uma abordagem para o mesmo problema. Como não é recomendável armazenar qualquer tipo de credencial no código-fonte, decidimos definir as senhas para o armazenamento de chaves e o alias de chave em um arquivo de propriedades separado da seguinte maneira:
Se você usar git, poderá criar um arquivo de texto chamado, por exemplo, secure.properties. Você deve excluí-lo do seu repositório (se estiver usando git, adicione-o ao arquivo .gitignore). Em seguida, você precisaria criar uma configuração de assinatura, como indicam algumas das outras respostas. A única diferença está em como você carregaria as credenciais:
Nunca se esqueça de atribuir o signatureConfig ao tipo de compilação do release manualmente (por algum motivo, às vezes, assumo que ele será usado automaticamente). Além disso, não é obrigatório ativar o proguard, mas é recomendável.
Gostamos dessa abordagem melhor do que usar variáveis de ambiente ou solicitar entrada do usuário, porque isso pode ser feito a partir do IDE, alternando para o tipo de construção realease e executando o aplicativo, em vez de precisar usar a linha de comando.
fonte
Android Studio Vá para Arquivo -> Estrutura do projeto ou pressione Ctrl + Alt + Shift + S
Veja a imagem
Clique OK
Em seguida, o signatureConfigs será gerado no seu arquivo build.gradle.
fonte
Eu tive vários problemas que coloquei a seguinte linha em um lugar errado:
Certifique-se de colocar as peças de assinaturaConfigs na seção android:
ao invés de
É fácil cometer esse erro.
fonte
É 2019 e preciso assinar o APK com V1 (assinatura jar) ou V2 (assinatura APK completa). Eu pesquisei no Google "gerar um apk assinado" e isso me trouxe aqui. Então, eu estou adicionando minha solução original aqui.
Minha pergunta original: Como usar V1 (assinatura Jar) ou V2 (assinatura APK completa) do arquivo build.gradle
fonte
Para complementar as outras respostas, você também pode colocar seu arquivo gradle.properties em sua própria pasta de módulo, junto com build.gradle, caso seu keystore seja específico para um projeto.
fonte
Estou trabalhando no Ubuntu14.04. vim ~ / .bashrc e inclua export ANDROID_KEYSTORE = export ANDROID_KEYALIAS =
e depois no conjunto build.gradle.
fonte
System.console()
retornanull
.Uma alternativa é definir uma tarefa que é executada apenas nas versões do release.
fonte
Você pode solicitar senhas na linha de comando:
O
if-then-else
bloqueio evita solicitações de senhas quando você está criando um release. Embora aelse
ramificação esteja inacessível, ele faz com que Gradle crie umainstall...Release
tarefa.História de fundo . Conforme observado em https://stackoverflow.com/a/19130098/3664487 , "Os scripts Gradle podem solicitar a entrada do usuário usando o método System.console (). ReadLine ." Infelizmente, o Gradle sempre solicita uma senha, mesmo quando você está criando uma versão de depuração (consulte Como criar um arquivo apk assinado de versão usando o Gradle? ). Felizmente, isso pode ser superado, como mostrei acima.
fonte
Adicionando minha maneira de fazer isso no React-Native usando o pacote react-native-config .
Crie um arquivo .env:
note que isso não deve fazer parte do controle de versão.
no seu
build.gradle
:fonte
No meu caso, eu estava carregando o apk errado, para o lançamento de outro aplicativo.
fonte
Para Groovy (build.gradle)
Você não deve colocar suas credenciais de assinatura diretamente no arquivo build.gradle . Em vez disso, as credenciais devem vir de um arquivo que não está sob controle de versão.
Coloque um arquivo signature.properties em que o build.gradle específico do módulo é encontrado. Não se esqueça de adicioná-lo ao seu arquivo .gitignore !
signature.properties
build.gradle
fonte
Para script Kotlin (build.gradle.kts)
Você não deve colocar suas credenciais de assinatura diretamente no arquivo build.gradle.kts . Em vez disso, as credenciais devem vir de um arquivo que não está sob controle de versão.
Coloque um arquivo signature.properties onde o build.gradle.kts específico do módulo é encontrado. Não se esqueça de adicioná-lo ao seu arquivo .gitignore !
signature.properties
build.gradle.kts
fonte
se você não quiser ver Não é possível chamar o método readLine () no objeto nulo. você precisa escrever primeiro em gradle.properties .
fonte