Estratégia de versão do gradle

Versão seu aplicativo.

Seu aplicativo deve ter versão de versão Definir a versão nos arquivos de criação Gradle do aplicativo Como sua versão afeta seus aplicativos como os usuários são atualizados Determine sua estratégia de versão no início do processo de desenvolvimento, incluindo considerações para versões futuras.

Neste documento.

O controle de versão é um componente essencial da atualização do seu aplicativo e da estratégia de manutenção. O controle de versão é importante porque:

Os usuários precisam ter informações específicas sobre a versão do aplicativo instalada em seus dispositivos e as versões de atualização disponíveis para instalação. Outras aplicações & mdash; incluindo outros aplicativos que você publica como um conjunto & mdash; precisa consultar o sistema para a versão do seu aplicativo, para determinar a compatibilidade e identificar dependências. Os serviços através dos quais você publicará seu (s) aplicativo (s) também podem precisar consultar seu aplicativo para sua versão, para que eles possam exibir a versão para os usuários. Um serviço de publicação também pode precisar verificar a versão do aplicativo para determinar a compatibilidade e estabelecer relacionamentos de atualização / downgrade.

O sistema Android usa as informações da versão do seu aplicativo para proteger contra downgrades. O sistema não usa informações de versão do aplicativo para impor restrições sobre atualizações ou compatibilidade de aplicativos de terceiros. Seu aplicativo deve impor restrições de versão e deve informar os usuários sobre elas.

O sistema Android não impõe a compatibilidade de versão do sistema conforme expresso pela configuração minSdkVersion nos arquivos de construção. Essa configuração permite que um aplicativo especifique a API mínima do sistema com a qual é compatível. Para obter mais informações, consulte Especificando a versão mínima da API do sistema.

Definir informações da versão do aplicativo.

Para definir as informações da versão do seu aplicativo, defina valores para as configurações de versão nos arquivos de criação do Gradle. Esses valores são então mesclados no arquivo de manifesto do aplicativo durante o processo de criação.

Observação: se o seu aplicativo definir a versão do aplicativo diretamente no & lt; manifest & gt; elemento, os valores de versão no arquivo de compilação Gradle substituirão as configurações no manifesto. Além disso, definir essas configurações nos arquivos de criação do Gradle permite que você especifique valores diferentes para diferentes versões do seu aplicativo. Para maior flexibilidade e para evitar possíveis substituições quando o manifesto é mesclado, você deve remover esses atributos da tag & lt; manifest & gt; elemento e defina suas configurações de versão nos arquivos de compilação do Gradle.

Duas configurações estão disponíveis e você deve sempre definir valores para ambas:

versionCode - Um inteiro usado como um número de versão interno. Esse número é usado apenas para determinar se uma versão é mais recente que outra, com números mais altos indicando versões mais recentes. Este não é o número da versão mostrado aos usuários; esse número é definido pela configuração versionName, abaixo. O sistema Android usa o valor de versionCode para proteger contra downgrades, impedindo que os usuários instalem um APK com um versionCode inferior à versão atualmente instalada em seu dispositivo.

O valor é um número inteiro para que outros aplicativos possam avaliar programaticamente, por exemplo, para verificar um relacionamento de upgrade ou downgrade. Você pode definir o valor para qualquer número inteiro desejado, mas deve garantir que cada versão sucessiva do seu aplicativo use um valor maior. Você não pode fazer upload de um APK para a Play Store com um versionCode que você já usou para uma versão anterior.

Observação: em algumas situações específicas, talvez você queira fazer o upload de uma versão do seu aplicativo com um versionCode inferior à versão mais recente. Por exemplo, se você estiver publicando vários APKs, poderá ter intervalos de versionCode predefinidos para APKs específicos. Para mais informações sobre atribuição de valores de versionCode para vários APKs, consulte Suporte para vários APKs.

Normalmente, você lançaria a primeira versão do seu aplicativo com o versionCode definido como 1 e, em seguida, monotonicamente aumentaria o valor a cada lançamento, independentemente de o lançamento constituir um lançamento principal ou secundário. Isso significa que o valor de versionCode não tem necessariamente uma forte semelhança com a versão de lançamento do aplicativo que é visível para o usuário (consulte versionName, abaixo). Aplicativos e serviços de publicação não devem exibir esse valor de versão para os usuários.

Aviso: o maior valor que o Google Play permite para o versionCode é 2100000000.

O valor é uma string para que você possa descrever a versão do aplicativo como um & lt; major & gt;. & Lt; minor & lt; point & gt; string, ou como qualquer outro tipo de identificador de versão absoluta ou relativa. O versionName não tem outro propósito senão ser exibido aos usuários.

Você pode definir valores padrão para essas configurações incluindo-os no bloco defaultConfig <>, aninhado dentro do bloco android <> do arquivo build. gradle do seu módulo. Você pode substituir esses valores padrão para diferentes versões de seu aplicativo, definindo valores separados para tipos de versão individuais ou tipos de produtos. O arquivo build. gradle a seguir mostra as configurações de versionCode e versionName no bloco defaultConfig <>, bem como o bloco productFlavors <>.

No bloco defaultConfig <> deste exemplo, o valor de versionCode indica que o APK atual contém a segunda versão do aplicativo, e a string versionName especifica que ele será exibido para os usuários como versão 1.1. Este arquivo build. gradle também define dois tipos de produtos, "demo" e "full". Como o sabor do produto "demo" define versionName como "1.1-demo", a compilação "demo" usa este versionName em vez do valor padrão. O bloco de sabor de produto "completo" não define versionName, portanto, ele usa o valor padrão de "1.1".

A estrutura do Android fornece uma API para permitir que você consulte o sistema em busca de informações sobre a versão do seu aplicativo. Para obter informações de versão, use o método getPackageInfo (java. lang. String, int) do PackageManager.

Nota: Quando você usa Instant Run, o Android Studio define automaticamente o versionCode como MAXINT e o versionName como "INSTANTRUN".

Especifique os requisitos de nível da API.

Se seu aplicativo exigir uma versão mínima específica da plataforma Android, você poderá especificar esse requisito de versão como configurações de nível de API no arquivo build. gradle do aplicativo. Durante o processo de criação, essas configurações são mescladas no arquivo de manifesto do seu aplicativo. Especificar requisitos de nível de API garante que seu aplicativo só possa ser instalado em dispositivos que estejam executando uma versão compatível da plataforma Android.

Nota: Se você especificar requisitos de nível de API diretamente no arquivo de manifesto do seu aplicativo, as configurações correspondentes nos arquivos de compilação substituirão as configurações no arquivo de manifesto. Além disso, definir essas configurações nos arquivos de criação do Gradle permite que você especifique valores diferentes para diferentes versões do seu aplicativo. Para maior flexibilidade e para evitar possíveis substituições quando o manifesto é mesclado, você deve remover esses atributos da tag & lt; uses-sdk & gt; elemento e defina suas configurações de nível de API nos arquivos de construção do Gradle.

Existem duas configurações de nível de API disponíveis:

minSdkVersion & mdash; A versão mínima da plataforma Android na qual o aplicativo será executado, especificada pelo identificador de nível da API da plataforma. targetSdkVersion & mdash; Especifica o nível da API em que o aplicativo foi projetado para ser executado. Em alguns casos, isso permite que o aplicativo use elementos ou comportamentos de manifesto definidos no nível da API de destino, em vez de restringir-se a usar somente aqueles definidos para o nível mínimo da API.

Para especificar requisitos de nível de API padrão em um arquivo build. gradle, inclua uma ou mais das configurações acima no bloco defaultConfig <>, aninhado dentro do bloco android <>. Você também pode substituir esses valores padrão para diferentes versões de seu aplicativo, adicionando as configurações para criar tipos ou tipos de produtos. O seguinte arquivo build. gradle especifica as configurações padrão minSdkVersion e targetSdkVersion no bloco defaultConfig <> e substitui o minSdkVersion por um sabor do produto.

Ao se preparar para instalar seu aplicativo, o sistema verifica o valor dessas configurações e compara-as com a versão do sistema. Se o valor de minSdkVersion for maior que a versão do sistema, o sistema impedirá a instalação do aplicativo.

Se você não especificar essas configurações, o sistema presumirá que seu aplicativo é compatível com todas as versões da plataforma.

Para mais informações, consulte o & lt; uses-sdk & gt; documentação do elemento manifesto e o documento Níveis da API. Para configurações de compilação do Gradle, consulte Configurar variantes de compilação.

Introdução ao gerenciamento de dependências.

Índice.

O que é gerenciamento de dependência?

Projetos de software raramente funcionam isoladamente. Na maioria dos casos, um projeto depende de funcionalidade reutilizável na forma de bibliotecas ou é dividido em componentes individuais para compor um sistema modularizado. O gerenciamento de dependência é uma técnica para declarar, resolver e usar as dependências exigidas pelo projeto de maneira automatizada.

Para obter uma visão geral dos termos usados ​​em todo o guia do usuário, consulte a Terminologia de gerenciamento de dependência.

Gerenciamento de dependências no Gradle.

Gradle tem suporte embutido para gerenciamento de dependências e cumpre a tarefa de cumprir cenários típicos encontrados em projetos de software modernos. Vamos explorar os principais conceitos com a ajuda de um projeto de exemplo. A ilustração abaixo deve fornecer uma visão geral aproximada de todas as partes móveis.

Figura: Gerenciamento de dependência grande figura.

O projeto de exemplo cria o código-fonte Java. Alguns dos arquivos de origem Java importam classes do Google Guava, uma biblioteca de código aberto que fornece uma grande variedade de funcionalidades de utilitário. Além de Guava, o projeto precisa das bibliotecas JUnit para compilar e executar o código de teste.

Goiaba e JUnit representam as dependências deste projeto. Um desenvolvedor de script de construção pode declarar dependências para diferentes escopos, por exemplo apenas para compilação de código-fonte ou para executar testes. No Gradle, o escopo de uma dependência é chamado de configuração. Para uma visão geral completa, consulte o material de referência nos tipos de dependência.

Muitas vezes as dependências vêm na forma de módulos. Você precisará informar ao Gradle onde encontrar esses módulos para que eles possam ser consumidos pelo build. O local para armazenar módulos é chamado de repositório. Ao declarar repositórios para uma construção, o Gradle saberá como encontrar e recuperar módulos. Os repositórios podem ter diferentes formas: como diretório local ou repositório remoto. A referência nos tipos de repositório fornece uma ampla cobertura sobre esse tópico.

Em tempo de execução, Gradle localizará as dependências declaradas, se necessário, para operar uma tarefa específica. As dependências podem precisar ser baixadas de um repositório remoto, recuperadas de um diretório local ou requerem que outro projeto seja construído em uma configuração de vários projetos. Esse processo é chamado de resolução de dependência. Você pode encontrar uma discussão detalhada na seção chamada "Como funciona a resolução de dependências".

Uma vez resolvido, o mecanismo de resolução armazena os arquivos subjacentes de uma dependência em um cache local, também chamado de cache de dependência. Futuro constrói reutilizar os arquivos armazenados no cache para evitar chamadas de rede desnecessárias.

Módulos podem fornecer metadados adicionais. Metadados são os dados que descrevem o módulo mais detalhadamente, e. as coordenadas para encontrá-lo em um repositório, informações sobre o projeto ou seus autores. Como parte dos metadados, um módulo pode definir que outros módulos são necessários para que funcione corretamente. Por exemplo, o módulo da plataforma JUnit 5 também requer o módulo commons da plataforma. O Gradle resolve automaticamente esses módulos adicionais, chamados de dependências transitivas. Se necessário, você pode personalizar o comportamento do tratamento de dependências transitivas para os requisitos do seu projeto.

Projetos com dezenas ou centenas de dependências declaradas podem facilmente sofrer de dependência infernal. O Gradle fornece ferramentas suficientes para visualizar, navegar e analisar o gráfico de dependência de um projeto, seja com a ajuda de uma varredura de compilação ou tarefas internas. Saiba mais em Inspeção de Dependências.

Figura: Construir relatório de dependências de varredura.

Como funciona a resolução de dependências

Gradle pega suas declarações de dependência e definições de repositório e tenta baixar todas as suas dependências por um processo chamado resolução de dependência. Abaixo está um breve resumo de como esse processo funciona.

Dada uma dependência exigida, o Gradle tenta resolver a dependência procurando pelo módulo em que os pontos de dependência estão. Cada repositório é inspecionado em ordem. Dependendo do tipo de repositório, o Gradle procura por arquivos de metadados que descrevam o módulo (arquivo. module,.pom ou ivy. xml) ou diretamente para arquivos de artefatos.

Se a dependência for declarada como uma versão dinâmica (como 1. +), o Gradle resolverá isso para a versão concreta mais alta disponível (como 1.2) no repositório. Para os repositórios Maven, isso é feito usando o arquivo maven-metadata. xml, enquanto que para os repositórios Ivy isso é feito por listagem de diretórios.

Se o metadado do módulo for um arquivo POM que tenha um POM pai declarado, o Gradle tentará recursivamente resolver cada um dos módulos pai do POM.

Uma vez que cada repositório tenha sido inspecionado para o módulo, Gradle escolherá o 'melhor' para usar. Isso é feito usando os seguintes critérios:

Para uma versão dinâmica, uma versão concreta 'superior' é preferível a uma versão 'inferior'.

Os módulos declarados por um arquivo de metadados do módulo (arquivo. module,.pom ou ivy. xml) são preferidos em relação aos módulos que possuem apenas um arquivo de artefato.

Módulos de repositórios anteriores são preferidos em relação a módulos em repositórios posteriores.

Quando a dependência é declarada por uma versão concreta e um arquivo de metadados do módulo é encontrado em um repositório, não há necessidade de continuar pesquisando repositórios posteriores e o restante do processo é curto-circuitado.

Todos os artefatos para o módulo são então solicitados do mesmo repositório que foi escolhido no processo acima.

O processo de resolução de dependência é altamente personalizável para atender aos requisitos corporativos. Para obter mais informações, consulte o capítulo Personalização do comportamento de resolução de dependência.

Comparação de Gradle vs Maven.

A seguir, um resumo das principais diferenças entre o Gradle e o Apache Maven: flexibilidade, desempenho, experiência do usuário e gerenciamento de dependências. Não é para ser exaustivo, mas você pode verificar a lista de recursos do Gradle e comparação de desempenho do Gradle vs Maven para saber mais.

Este GIF mostra uma construção limpa lado a lado da biblioteca Apache Commons Lang usando Maven e Gradle (sem cache de compilação). Você pode visualizar a varredura de compilação para esta compilação aqui.

Flexibilidade.

O Google escolheu o Gradle como a ferramenta oficial de criação do Android; não porque os scripts de construção sejam códigos, mas porque o Gradle é modelado de uma maneira que é extensível das formas mais fundamentais. O modelo de Gradle também permite que ele seja usado para desenvolvimento nativo com C / C ++ e pode ser expandido para cobrir qualquer ecossistema. Por exemplo, o Gradle é projetado com a incorporação em mente usando sua API de ferramentas.

Tanto o Gradle quanto o Maven fornecem convenção sobre configuração. No entanto, o Maven fornece um modelo muito rígido que torna a personalização tediosa e, às vezes, impossível. Embora isso possa facilitar a compreensão de qualquer configuração do Maven, desde que você não tenha nenhum requisito especial, isso também o torna inadequado para muitos problemas de automação. Gradle, por outro lado, é construído com um usuário capacitado e responsável em mente.

Atuação.

Melhorar o tempo de compilação é uma das formas mais diretas de envio mais rápido. Tanto a Gradle quanto a Maven empregam alguma forma de construção paralela de projetos e resolução paralela de dependências. As maiores diferenças são os mecanismos de Gradle para evitar o trabalho e a incrementalidade. Os 3 principais recursos que tornam o Gradle muito mais rápido que o Maven são:

Incrementalidade - Gradle evita trabalhar rastreando entrada e saída de tarefas e executando apenas o que é necessário, e somente processando arquivos que foram alterados quando possível. Cache de Construção - Reutiliza as saídas de construção de qualquer outra construção Gradle com as mesmas entradas, inclusive entre máquinas. Gradle Daemon - Um processo de longa duração que mantém as informações de construção "quentes" na memória.

Esses e mais recursos de desempenho tornam o Gradle no mínimo duas vezes mais rápido para quase todos os cenários (100 vezes mais rápido para grandes construções usando o cache de compilação) nessa comparação de desempenho do Gradle contra o Maven.

Experiência de usuário.

O mandato mais longo da Maven significa que seu suporte por IDEs é melhor para muitos usuários. O suporte IDE da Gradle continua a melhorar rapidamente, no entanto. Por exemplo, Gradle agora tem uma DSL baseada em Kotlin que oferece uma experiência IDE muito melhor. A equipe da Gradle está trabalhando com os criadores de IDE para tornar o suporte à edição muito melhor - fique atento às atualizações.

Embora os IDEs sejam importantes, um grande número de usuários prefere executar operações de criação por meio de uma interface de linha de comando. O Gradle fornece uma CLI moderna que possui recursos de descoberta como `tarefas gradle`, bem como registro aprimorado e conclusão de linha de comando.

Por fim, o Gradle fornece uma interface de usuário interativa baseada na web para depurar e otimizar compilações: construir varreduras. Eles também podem ser hospedados no local para permitir que uma organização colete histórico de construções e faça análises de tendências, compare construções para depuração ou otimize os tempos de construção.

Gerenciamento de Dependência.

Ambos os sistemas de compilação fornecem recursos internos para resolver dependências de repositórios configuráveis. Ambos são capazes de armazenar em cache as dependências localmente e baixá-las em paralelo.

Como um consumidor de biblioteca, o Maven permite substituir uma dependência, mas apenas por versão. O Gradle fornece regras personalizáveis ​​de seleção e substituição de dependência que podem ser declaradas uma vez e lidar com dependências indesejadas em todo o projeto. Esse mecanismo de substituição permite que a Gradle construa vários projetos de origem juntos para criar construções compostas.

O Maven tem poucos escopos de dependência incorporados, o que força arquiteturas de módulos inábeis em cenários comuns, como o uso de equipamentos de teste ou geração de código. Não há separação entre testes unitários e de integração, por exemplo. O Gradle permite escopos de dependência personalizados, que fornecem construções mais bem modeladas e mais rápidas.

Como produtor de bibliotecas, Gradle permite que os produtores declarem dependências `api` e` implementation` para evitar que bibliotecas indesejadas vazem para os caminhos de classe dos consumidores. O Maven permite que os editores forneçam metadados por meio de dependências opcionais.

Próximos passos.

Recomendamos que você analise com mais profundidade os recursos do Gradle ou comece com esses recursos.

Use números de compilação diferentes para cada compilação - usando automaticamente um script graduado.

Outro ticket do JIRA com um relatório de falha de um cliente: "O aplicativo sempre falha ao filtrar os produtos". Nenhuma mais informação dada. É um novo acidente? Como podemos reproduzi-lo? Qual versão do aplicativo ele estava usando? Depois de chamar o cliente, descobri que o acidente acontece apenas em seu tablet Samsung com o aplicativo versão 1.1.2. Ao testá-lo em nossos dispositivos, não consegui reproduzi-lo. O rastreamento de acidentes capturou o acidente, mas não fazia o menor sentido. Um NullPointerException dentro de um comentário?

Longa história curta; o cliente estava usando uma compilação de depuração que criei e implantei na última reunião que tinha alterações locais. A versão 1.1.2 neste dispositivo de teste era diferente da versão 1.1.2 marcada em nosso repositório git. Normalmente, a compilação para o cliente tem um número de compilação 1.1.2–65. O número de compilação ausente identificou a versão do aplicativo como uma versão de depuração construída localmente.

Aumentar o número de compilação com Jenkins.

Aumentar o número de compilação para cada compilação nos trabalhos do Jenkins é uma prática comum. A única coisa que me incomoda é que um maior número de versão do Jenkins não significa um estado de aplicativo mais recente. O número aumenta se eu construir a versão 2.3.6 ou 1.0.1.

É difícil entender por que o recurso X faz parte do build 202, mas não está incluído no build 203. Recebi vários emails devido a um "recurso ausente", simplesmente porque fizemos a gentileza de criar uma compilação a partir de uma ramificação de recurso em andamento. o progresso (a versão anterior).

Resolvemos esse problema com trabalhos Jenkins separados para construções de visualização. Nunca enviamos links para a versão "mais recente", um link sempre aponta para uma versão específica quando enviamos visualizações que ainda não foram mescladas.

Outro trabalho cria a filial "desenvolver" para fornecer a versão "mais recente". Embora essa estratégia funcione, ela não resolve o problema com construções locais. Não seria legal ter a mesma versão de compilação, esteja você construindo em sua máquina local ou através de Jenkins? Uma solução que também funciona para o seu projeto divertido sem o Jenkins?

Bons números de construção.

Na minha opinião, um bom número de compilação mostra o estado atual da versão do software. Não é um timestamp ou um número crescente aleatório, por isso não deve mudar quando eu construir uma versão duas vezes! Um número maior indica uma versão mais avançada do software, porque todos nós sabemos; Um número maior é sempre melhor, todo mundo entende isso.

A Microsoft faz um bom trabalho com seus números de compilação para o Windows. É claro que 11082 é muito mais antigo que a versão 14342 e não há grande diferença para a versão mais recente 14352.

O SVN também usa um bom controle de versão, aumentando a revisão de cada confirmação. É a mesma revisão para construções locais e remotas. No entanto, não é possível no git porque a ramificação é tão comum (e isso é bom). Contar os commits da filial atual não é exato. “342. commit "não aponta para um commit específico e vários commits em diferentes branches podem ter 341 antepassados.

Números de compilação estática para o git.

Pensei muito sobre esse problema e encontrei a seguinte solução:

Para cada compilação eu conto os commits no branch principal (“master” ou “develop” para a maioria das pessoas). Esse número de confirmação é um bom começo, mas não é suficiente, pois acredito que ele forneça muitos insights sobre o projeto. Quando um cliente sabe que a contagem de commits é igual ao número de compilação, ele começa a perguntar por que a contagem de commits é tão alta / baixa para a última versão. É por isso que adiciono a idade do projeto (confirmação inicial à confirmação mais recente) como parte dos segundos da revisão e os adiciono juntos.

Eu decidi dar um ano o valor 1000 - isso significa que a contagem de revisões aumenta a cada 8,67 horas. Quando você iniciou seu projeto há meio ano e você tem 325 commits, a revisão é provavelmente 825. Esse número é fácil de entender, estável para cada commit (localmente e no Jenkins) e sempre aumentando.

Vários ramos.

O número sozinho não resolve o problema de vários ramos. Para resolver isso, eu adiciono uma segunda parte ao número da compilação, a contagem de commits na ramificação do recurso desde a última mesclagem da ramificação padrão e um identificador de dois caracteres (hash) do nome da ramificação (exemplo: 825-ud4). Quando você vê outra compilação com o mesmo número de compilação (825-za2), é fácil reconhecer que ambas as construções são criadas com base na mesma confirmação (número de compilação 825). Aparentemente, essas compilações são de ramificações diferentes devido a diferentes identificadores de ramificação.

Quando você disse a um cliente que o recurso X está disponível no build 450, ele nunca perguntará por que o recurso não está no build 436-as16. E enquanto desenvolvemos o recurso Y, você pode fornecer “wt” - test-builds e seu cliente sabe que o recurso Y está disponível na compilação 421-wt6, bem como 532-wt6 (onde você mesclou a última compilação 532 da ramificação padrão em seu recurso ramo de recurso Y).

Mudanças Locais.

Enviar compilações de depuração para o cliente não é uma prática comum. Mas acontece que uma versão de aplicativo de depuração permanece em um dispositivo do cliente porque um bug nesse dispositivo específico exigia depuração nele. Eu também compartilho os mesmos dispositivos de teste com o controle de qualidade. Identificar compilações de depuração com alterações locais é muito importante.

Eu adiciono o número de alterações locais e um grande - SNAPSHOT para tal compilação.

Esta compilação tem 6 alterações locais em um ramo de recurso (dm) com 4 commits.

Adicione ao seu projeto.

É tão fácil. Eu escrevi essa lógica como um scriptcript gradle que você pode aplicar com uma única linha e acessar o nome da versão com a variável ext. gitVersionName. A configuração é opcional.

A variável gitVersion fornece todas as informações separadamente. Isso permite gerar seu próprio padrão.

Veja o projeto GitHub para mais informações e o código github / passsy / gradle-GitVersioner.

Alguns de vocês podem usar a estratégia preguiçosa de Jake Whartons para gerar um número de compilação. Isso é uma grande ajuda, mas aumentar manualmente uma versão de compilação é algo que eu sempre esqueço.

O mesmo funciona com o meu script. A versão aumenta para cada confirmação no ramo padrão. #automatetudo

Fácil, não é?

Por favor, deixe-me saber o que você pensa sobre o meu git versioner - testá-lo em seu projeto atual levará apenas alguns segundos. Estou animado para receber seu feedback!

Estratégia de versionamento Gradle.

Estratégia de versionamento Gradle.

Re: estratégia de versionamento Gradle.

Treinador e Consultor, Gradle Inc.

Fundador, Spock Framework.

Re: estratégia de versionamento Gradle.

& gt; Dê uma olhada nas páginas de alteração de alterações:

& gt; As APIs Gradle foram razoavelmente estáveis ​​por um tempo, mas haverá.

& gt; certamente serão mudanças em nosso caminho para o 1.0. Ainda não há garantias fortes.

& gt; Treinador & amp; Consultor, Gradle Inc.

& gt; Fundador, Spock Framework.

& gt; Enviado do arquivo da lista de discussão gradle-user no Nabble.

& gt; Para cancelar a inscrição nesta lista, visite:

Re: estratégia de versionamento Gradle.

o que você espera de uma tarefa única?

& gt; O plugin do aplicativo é interessante. Pessoalmente acho uma tarefa onejar.

& gt; tipo está faltando. Isso teria um lugar como parte da versão 1.0? Está.

& gt; código que eu estaria disposto a contribuir.

& gt; & gt; Dê uma olhada nas páginas de alterações de quebra:

& gt; & gt; As APIs do Gradle foram razoavelmente estáveis ​​por um tempo, mas haverá.

& gt; & gt; certamente serão mudanças em nosso caminho para o 1.0. Ainda não há garantias fortes.

& gt; & gt; Treinador & amp; Consultor, Gradle Inc.

& gt; & gt; Fundador, Spock Framework.

& gt; & gt; Veja esta mensagem no contexto:

& gt; & gt; Enviado do arquivo da lista de discussão gradle-user no Nabble.

& gt; & gt; Para cancelar a inscrição nesta lista, visite:

Para cancelar a inscrição nesta lista, visite:

Re: estratégia de versionamento Gradle.

& gt; o que você espera de uma tarefa única?

& gt; Am, 28.01.2011, 15:28, schrieb Merlyn Albery:

& gt; & gt; O plugin do aplicativo é interessante. Pessoalmente acho uma tarefa onejar.

& gt; & gt; tipo está faltando. Isso teria um lugar como parte da versão 1.0? Está.

& gt; & gt; código que eu estaria disposto a contribuir.

& gt; & gt; & gt; Dê uma olhada nas páginas de alterações de quebra:

& gt; & gt; & gt; As APIs do Gradle foram razoavelmente estáveis ​​por um tempo, mas haverá.

& gt; & gt; & gt; certamente serão mudanças em nosso caminho para o 1.0. Ainda não há garantias fortes.

& gt; & gt; & gt; Treinador & amp; Consultor, Gradle Inc.

& gt; & gt; & gt; Fundador, Spock Framework.

& gt; & gt; & gt; Veja esta mensagem no contexto:

& gt; & gt; & gt; Enviado do arquivo da lista de discussão gradle-user no Nabble.

& gt; & gt; & gt; Para cancelar a inscrição nesta lista, visite:

Versionando seus aplicativos.

Seu aplicativo deve ser versionado Você configura a versão no arquivo de manifesto do aplicativo Como sua versão afeta seus aplicativos Como os usuários são atualizados Determine sua estratégia de versão no início do processo de desenvolvimento, incluindo considerações para versões futuras.

Neste documento.

O controle de versão é um componente crítico da estratégia de atualização e manutenção de seu aplicativo. O controle de versão é importante porque:

Os usuários precisam ter informações específicas sobre a versão do aplicativo que está instalada em seus dispositivos e as versões de atualização disponíveis para instalação. Outras aplicações & mdash; incluindo outros aplicativos que você publica como um conjunto & mdash; precisa consultar o sistema para a versão do seu aplicativo, para determinar a compatibilidade e identificar dependências. Os serviços através dos quais você publicará seus aplicativos também podem precisar consultar seu aplicativo para sua versão, para que eles possam exibir a versão para os usuários. Um serviço de publicação também pode precisar verificar a versão do aplicativo para determinar a compatibilidade e estabelecer relacionamentos de atualização / downgrade.

O sistema Android não usa informações sobre a versão do aplicativo para impor restrições sobre atualizações, downgrades ou compatibilidade de aplicativos de terceiros. Em vez disso, você (o desenvolvedor) é responsável por impor restrições de versão em seu aplicativo ou por informar os usuários sobre as restrições e limitações de versão. O sistema Android, no entanto, reforça a compatibilidade de versão do sistema conforme expresso pelo atributo minSdkVersion no manifesto. Esse atributo permite que um aplicativo especifique a API do sistema mínima com a qual ele é compatível. Para obter mais informações, consulte Especificando a versão mínima da API do sistema.

Configurando a versão do aplicativo.

Para definir as informações de versão para seu aplicativo, você define atributos no arquivo de manifesto do aplicativo. Dois atributos estão disponíveis e você deve sempre definir valores para ambos:

android: versionCode & mdash; Um valor inteiro que representa a versão do código do aplicativo, relativo a outras versões.

O valor é um número inteiro para que outros aplicativos possam avaliar programaticamente, por exemplo, para verificar um relacionamento de upgrade ou downgrade. Você pode definir o valor para qualquer número inteiro que desejar, no entanto, certifique-se de que cada release sucessivo de seu aplicativo use um valor maior. O sistema não impõe esse comportamento, mas aumentar o valor com releases sucessivos é normativo.

Normalmente, você liberaria a primeira versão do seu aplicativo com o versionCode definido como 1 e, em seguida, monotonicamente aumentaria o valor com cada release, independentemente de o release constituir um lançamento principal ou secundário. Isso significa que o valor android: versionCode não tem necessariamente uma forte semelhança com a versão de lançamento do aplicativo que é visível para o usuário (consulte android: versionName, abaixo). Os aplicativos e serviços de publicação não devem exibir esse valor de versão para os usuários.

O valor é uma string para que você possa descrever a versão do aplicativo como um & lt; major & gt ;. & lt; minor & lt; point & gt; string, ou como qualquer outro tipo de identificador de versão absoluta ou relativa.

Como no android: versionCode, o sistema não usa esse valor para nenhum propósito interno, além de permitir que os aplicativos o exibam para os usuários. Os serviços de publicação também podem extrair o valor android: versionName para exibição aos usuários.

Você define esses dois atributos de versão na tag & lt; manifest & gt; elemento do arquivo de manifesto ou o arquivo de compilação Gradle. Consulte Configurando as construções do Gradle.

Aqui está um exemplo de manifesto que mostra os atributos android: versionCode e android: versionName na tag & lt; manifest & gt; elemento.

Neste exemplo, observe que o valor android: versionCode indica que o atual. apk contém a segunda versão do código do aplicativo, que corresponde a uma versão secundária secundária, conforme mostrado pela string android: versionName.

A estrutura do Android fornece uma API para permitir que os aplicativos consultem o sistema em busca de informações sobre a versão do seu aplicativo. Para obter informações de versão, os aplicativos usam o método getPackageInfo (java. lang. String, int) do PackageManager.

Especificando os requisitos da API do sistema do seu aplicativo.

Se o seu aplicativo exigir uma versão mínima específica da plataforma Android ou for projetado apenas para suportar um determinado intervalo de versões da plataforma Android, você poderá especificar esses requisitos de versão como identificadores de nível de API no arquivo de manifesto do aplicativo. Isso garante que seu aplicativo só possa ser instalado em dispositivos que estejam executando uma versão compatível do sistema Android.

Para especificar os requisitos do Nível da API, adicione um & lt; uses-sdk & gt; elemento no manifesto do aplicativo, com um ou mais desses atributos:

android: minSdkVersion & mdash; A versão mínima da plataforma Android na qual o aplicativo será executado, especificada pelo identificador de nível de API da plataforma. android:targetSdkVersion — Specifies the API Level on which the application is designed to run. In some cases, this allows the application to use manifest elements or behaviors defined in the target API Level, rather than being restricted to using only those defined for the minimum API Level. android:maxSdkVersion — The maximum version of the Android platform on which the application is designed to run, specified by the platform's API Level identifier. Important: Please read the <uses-sdk> documentation before using this attribute.

When preparing to install your application, the system checks the value of this attribute and compares it to the system version. If the android:minSdkVersion value is greater than the system version, the system aborts the installation of the application. Similarly, the system installs your application only if its android:maxSdkVersion is compatible with the platform version.

If you do not specify these attributes in your manifest, the system assumes that your application is compatible with all platform versions, with no maximum API Level.

To specify a minimum platform version for your application, add a <uses-sdk> element as a child of <manifest> , then define the android:minSdkVersion as an attribute.

For more information, see the <uses-sdk> manifest element documentation and the API Levels document. For Gradle build settings, see Configuring Gradle Builds.