Manual de melhores práticas de desenvolvimento Android é o único em toda a rede, grandes empresas conhecidas estão usando, recomenda-se coletar

Diretório

• Prefácio
• Sumário
• Androids SDK
• Sistema de compilação
• Resumo do projeto
• Configuração Gradle
• Ambiente de desenvolvimento integrado IDE e editor de texto
• Biblioteca de classes
• Atividades e Fragmentos
• Estrutura de pacotes Java
• Estrutura de teste
• Emulador
• Configuração ofuscada

Prefácio

Este artigo é um resumo das práticas recomendadas pelos desenvolvedores do Android na Futurice. Seguir estas diretrizes pode evitar a fabricação repetitiva de rodas. Se você estiver interessado no desenvolvimento do iOS ou Windows Phone, verifique também as práticas recomendadas para iOS e as práticas recomendadas para o desenvolvimento do cliente Windows.

Sumário

• Use Gradle e sua estrutura de engenharia recomendada
• Coloque senhas e dados confidenciais em gradle.properties
• Não escreva seu próprio cliente HTTP, use a biblioteca Volley ou OkHttp
• Analisando Dados JSON Utilizando a Biblioteca Jackson
• Evite usar o Guava e use algumas bibliotecas para evitar o limite do método de 65k (no máximo, 65536 métodos podem ser executados em um programa Android)
• Use Fragments para apresentar uma visualização da interface do usuário
• Use Atividades apenas para gerenciar fragmentos
• Layout é código XMLs, organize-os
• Ao usar XMLs de layout, use arquivos de estilos para evitar atributos duplicados
• Use vários arquivos de estilo para evitar um único arquivo de estilo grande
• Mantenha seu colors.xml curto SECO (não se repita), basta definir a paleta de cores
• Sempre use dimens.xml DRY (não se repita), defina constantes universais
• Não crie um ViewGroup profundo
• Evite processar no cliente ao usar o WebViews, cuidado com vazamentos de memória
• Use o teste de unidade Robolectric, o teste Robotium do UI
• Use Genymotion como seu emulador
• Sempre use a confusão ProGuard e DexGuard para projetar

Androids SDK

Coloque o SDK do Android em um local não relacionado ao diretório inicial ou a outros aplicativos. Ao instalar alguns IDEs que incluem SDK, o SDK pode ser colocado no mesmo diretório do IDE.Quando você precisar atualizar (ou reinstalar) o IDE ou substituí-lo, será muito problemático. Além disso, se o seu IDE estiver sendo executado como um usuário comum, não na raiz, você também deve evitar colocar o SDK em um diretório no nível do sistema que exija permissões de sudo.

Sistema de compilação

Seu ambiente de compilação padrão deve ser o Gradle.O Ant tem muitas limitações e também é redundante. Usando Gradle, é conveniente concluir as seguintes tarefas:

• Crie variantes de diferentes versões do aplicativo
• Faça tarefas simples como scripts
• Dependências de gerenciamento e download
• Chave personalizada
• Mais

Ao mesmo tempo, o plug-in Android Gradle está sendo desenvolvido ativamente pelo Google como um novo sistema de compilação padrão.

Resumo do projeto

Existem duas estruturas populares: a antiga estrutura do projeto Ant & Eclipse ADT e a nova estrutura do Gradle & Android Studio. Você deve escolher a nova estrutura do projeto. Se o seu projeto ainda estiver usando a estrutura antiga, considere desistir. O projeto é transplantado para a nova estrutura.

Estrutura antiga

Nova estrutura

[Falha na transferência de imagem da cadeia externa, o site de origem pode ter um mecanismo de cadeia anti-roubo, é recomendável salvar a imagem e enviá-la diretamente (img-Eb2YhruK-1585838741642) (https://upload-images.jianshu.io/upload_images/22459598-5d2d08de3e07fceb?imageMogr2 / orientação automática / faixa% 7CimageView2 / 2 / w / 1240)]

As principais diferenças são:

• A nova estrutura separa claramente 'conjuntos de fontes' (main, androidTest), um conceito de Gradle. Você pode, por exemplo, adicionar o grupo de origem 'pago' e 'grátis' no src, que se tornará o código-fonte dos modos gratuitos e pagos do seu aplicativo.
• Quando o seu projeto faz referência a uma biblioteca de projetos de terceiros (por exemplo, library-foobar), é muito útil ter um aplicativo de nome de pacote de nível superior para distinguir seu aplicativo do projeto de biblioteca de terceiros. Em seguida, o settings.gradle faz referência constante a esses projetos de bibliotecas, dos quais app / build.gradle pode ser referenciado.

Configuração Gradle

 Referência de estrutura comum

Guia do Google sobre Gradle para Android

Pequenas tarefas  , além de (shell, Python, Perl, etc ) estes linguagem de script, você também pode fazer uso tarefa Gradle. Para mais informações, consulte a documentação de Gradle.

 A senha do seu aplicativo quando a versão for lançada

build.gradle você precisa definir signingConfigs Neste ponto, você deve evitar o seguinte:

Não faça isso, pois isso aparecerá no controle de versão.

signingConfigs {   
 release {        
storeFile file(
"myapp.keystore")       
 storePassword "password123"      
  keyAlias "thekey"        keyPassword "password789"    
       }
}

Em vez disso, crie um arquivo gradle.properties sem adicionar um sistema de controle de versão.

KEYSTORE_PASSWORD=password123
KEY_PASSWORD=password789

Esse arquivo é introduzido automaticamente por gradle, você pode usá-lo no arquivo buld.gradle, por exemplo:

signingConfigs { 
   release {    
    try {          
  storeFile file(
"myapp.keystore")           
 storePassword KEYSTORE_PASSWORD           
 keyAlias "thekey"           
 keyPassword KEY_PASSWORD    
    }      
  catch (ex) {            
throw new
 InvalidUserDataException(
"You should define KEYSTORE_PASSWORD 
and KEY_PASSWORD in 
gradle.properties."
)      
           }  
       }
}

Use o esquema de dependência do Maven em vez de usar o esquema do pacote jar importado.Se você usar explicitamente os arquivos jar no seu projeto, eles poderão se tornar versões permanentes, como a 2.1.1.O download do pacote jar para atualizá-los é muito complicado. Boa solução, este também é o método recomendado na compilação do Android Gradle. Você pode especificar um intervalo de versões, como 2.1. +, E o Maven atualizará automaticamente para a versão mais recente especificada, por exemplo:

dependencies {
    compile
 'com.netflix.rxjava:rxjava-
core:0.19.+'   
 compile
 'com.netflix.rxjava:rxjava-
android:0.19.+'   
 compile
 'com.fasterxml.jackson.core:jackson-
databind:2.4.+'    
compile
 'com.fasterxml.jackson.core:jackson-core:2.4.+'   
 compile 
'com.fasterxml.jackson.core:jackson-
annotations:2.4.+' 
   compile
 'com.squareup.okhttp:okhttp:2.0.+' 
   compile
 'com.squareup.okhttp:okhttp-
urlconnection:2.0.+'}

Ambiente de desenvolvimento integrado IDE e editor de texto

• Não importa qual editor você use, não deixe de criar um bom editor de estrutura de engenharia.Todo mundo tem sua própria escolha.É de sua responsabilidade deixar seu editor operar de acordo com a estrutura de engenharia e o sistema de construção.
• O Android Studio é o primeiro a ser promovido porque é desenvolvido pelo Google e é o mais próximo de Gradle. Ele usa a mais recente estrutura de engenharia por padrão. Chegou ao estágio beta (atualmente já existe a versão 1.0) e é personalizado para o desenvolvimento do Android.
• Você também pode usar o Eclipse ADT, mas é necessário configurá-lo porque ele usa a estrutura de engenharia antiga e o Ant como o sistema de construção. Você pode até usar editores de texto simples como Vim, Sublime Text ou Emacs. Nesse caso, você precisa usar as linhas de comando Gardle e adb.
• Se você não usar o Eclipse para integrar o Gradle, basta usar a linha de comando para criar o projeto ou migrar para o Android Studio.
• Independentemente da ferramenta de desenvolvimento usada, verifique se o Gradle e a nova estrutura do projeto mantêm a maneira oficial de criar o aplicativo e evite adicionar o arquivo de configuração do editor ao controle de versão.
• Por exemplo, evite adicionar arquivos Ant build.xml. Especialmente se você alterar a configuração do Ant, não esqueça de manter o build.gradle atualizado e funcionando. Ao mesmo tempo, trate bem os outros desenvolvedores e não force a mudança de suas ferramentas e preferências de desenvolvimento.

Biblioteca de classes

Jackson é uma biblioteca de classes que converte objetos java em JSON e JSON em classes java. O Gson é uma solução popular para esse problema.No entanto, descobrimos que Jackson é mais eficiente porque suporta métodos alternativos para lidar com JSON: fluxos, modelos de árvore de memória e ligação de dados JSON-POJO tradicional. No entanto, lembre-se de que a biblioteca Jsonkson é maior que o GSON; portanto, dependendo da sua situação, você pode escolher o GSON para evitar as limitações do método APP 65k. Outras opções: Json-smart e Boon JSON

Existem várias soluções interativas para solicitações de rede, armazenamento em cache e servidores de back-end de execução de imagem.Você deve considerar a possibilidade de implementar seu próprio cliente de rede. Use Voleibol ou Retrofit. O Volley também fornece classes de cache de imagens. Se você optar por usar o Retrofit, considere usar o Picasso para carregar imagens e cache e use o OkHttp como uma solicitação de rede eficiente. Retrofit, Picasso e OkHttp são todos desenvolvidos pela mesma empresa (Nota: desenvolvida pela Square), para que possam funcionar bem juntos. O OkHttp também pode usar o Volley com o Volley.

RxJava é uma biblioteca reativa funcional, ou seja, pode lidar com eventos assíncronos. Este é um modelo poderoso e promissor e também pode causar confusão, porque é muito diferente. Recomendamos uma consideração cuidadosa antes de usar esta biblioteca para estruturar o aplicativo inteiro. Alguns projetos são concluídos usando o RxJava, se você precisar de ajuda, entre em contato com estas pessoas: Timo Tuominen, Olli Salonen, Andre Medeiros, Mark Voit, Antti Lammi, Vera Izrailit, Juha Ristolainen e também escrevemos alguns blogs: [1 ], [2], [3], [4].

Se você já usou o Rx antes, comece a usá-lo a partir da resposta da API. Além disso, comece com uma manipulação simples de eventos da interface do usuário, como clicar em eventos ou inserir eventos na barra de pesquisa. Se você confia na sua tecnologia Rx e deseja aplicá-la à sua arquitetura geral, escreva Javadocs na parte complicada. Lembre-se de que outros desenvolvedores que não estão familiarizados com o RxJava podem achar difícil entender o projeto inteiro. Faça o seu melhor para ajudá-los a entender seu código e Rx.

Retrolambda é uma biblioteca Java que usa a sintaxe de expressão Lambda nas plataformas Android e pré-JDK8. Isso ajuda a manter seu código compacto e legível, especialmente quando você usa programação de estilo funcional, como o RxJava. Ao usá-lo, primeiro instale o JDK8, configure-o como o caminho do SDK na caixa de diálogo Estrutura do projeto do Android Studio, configure as variáveis ​​de ambiente JAVA8_HOME e JAVA7_HOME ao mesmo tempo e, em seguida, configure build.gradle no diretório raiz do projeto :

dependencies {    classpath 'me.tatarka:gradle-retrolambda:2.4.+'}

Ao mesmo tempo, adicione o build.gradle de cada módulo

apply plugin: 'retrolambda'
android {   
 compileOptions {   
 sourceCompatibility
 JavaVersion.VERSION_1_8   
 targetCompatibility 
JavaVersion.VERSION_1_8
}
retrolambda {  
  jdk System.getenv("JAVA8_HOME")  
  oldJdk System.getenv("JAVA7_HOME")   
 javaVersion
 JavaVersion.VERSION_1_7
}

O Android Studio fornece a cinta Java8 lambdas como suporte à dica de código. Se você não estiver familiarizado com os lambdas, comece a aprender consultando o seguinte:

• Qualquer método que contenha apenas uma interface é "compatível com lambda" e o código pode ser dobrado em uma sintaxe mais compacta
• Se você tiver dúvidas sobre parâmetros ou similares, escreva uma classe interna anônima normal e deixe o Status do Android gerar uma lambda para você.
• Cuidado com a limitação do número de métodos dex, evitando o uso de muitas bibliotecas Android.Quando compactados em um arquivo dex, há um limite rígido de 65535 métodos de aplicação [1] [2] [3]. Ao quebrar o limite de 65k, você verá um erro fatal. Portanto, use um intervalo normal de arquivos de biblioteca e use a ferramenta dex-method-counts para determinar quais bibliotecas podem ser usadas sob o limite de 65k. Em particular, evite usar a biblioteca Guava porque ela contém mais de 13k métodos.

Atividades e Fragmentos

Fragmentos devem ser sua escolha padrão para implementar a interface da interface do usuário. Você pode reutilizar a interface do usuário do Fragments para compor seu aplicativo. É altamente recomendável o uso de fragmentos em vez de atividades para apresentar interfaces da interface do usuário pelos seguintes motivos:

• Fornecer soluções de layout de vários painéis

A introdução de fragmentos estende principalmente o aplicativo móvel ao tablet; portanto, no tablet você pode ter dois painéis A e B, mas no aplicativo móvel A e B pode preencher a tela inteira, respectivamente. Se seu aplicativo usar fragmentos desde o início, será muito simples adaptar seu aplicativo a outras telas de tamanhos diferentes no futuro.

• Comunicação de dados entre telas

Enviar dados complexos (como objetos Java) de uma Atividade para outra Atividade, a API do Android não fornece um método adequado. Mas com o Fragment, você pode usar uma instância de atividade como um canal de comunicação para os subfragmentos dessa atividade. Mesmo que isso seja melhor que a comunicação entre Activity e Activity, você também deve considerar o uso da arquitetura do barramento de eventos, como Otto ou greenrobot EventBus como uma implementação mais concisa. Se você deseja evitar adicionar outra biblioteca, o RxJava também pode implementar um barramento de eventos.

• Fragmentos geralmente não são apenas UI

Você pode ter um fragmento sem uma interface como uma atividade para fornecer trabalho em segundo plano. Além disso, você pode usar esse recurso para criar um fragmento que contém a lógica para alterar outros fragmentos, em vez de colocar essa lógica na atividade.

• Até o ActionBar pode ser gerenciado usando fragmentos internos

Você pode optar por usar um fragmento sem uma interface de interface do usuário para gerenciar especificamente o ActionBar ou pode adicionar sua própria ação em cada fragmento como o ActionBar da atividade pai.

Infelizmente, não recomendamos o uso extensivo de fragmentos aninhados, pois às vezes causam erros de matryoshka. Somente usamos fragmentos extensivamente quando faz sentido (por exemplo, um ViewPager que desliza horizontalmente em um fragmento como uma tela) ou se ele é realmente uma escolha sábia.

No nível da arquitetura, seu aplicativo deve ter uma atividade de nível superior para conter a maioria dos fragmentos relacionados aos negócios. Você também pode ter algumas atividades auxiliares, essas atividades auxiliares se comunicam com a atividade principal e simplesmente limitam-se a esses dois métodos  Intent.setData () ou Intent.setAction () ou métodos semelhantes.

Estrutura de pacotes Java

• O aplicativo Android é aproximadamente uma estrutura Model-View-Controller em Java. No Android, Fragment e Activity geralmente são classes de controladores (http://www.informit.com/articles/article.aspx?p=2126865) Em outras palavras, eles fazem parte da interface do usuário, que também é a visualização Views Seção
• Por esse motivo, é difícil dividir estritamente fragmentos (ou atividades) estritamente em controladores ou exibir visualizações. É melhor colocá-los em seu próprio pacote de fragmentos. Desde que você siga as recomendações mencionadas anteriormente, as Atividades podem ser colocadas no diretório de nível superior. Se você planeja ter mais de 2 ou 3 atividades, crie um pacote de atividades.
• No entanto, essa arquitetura pode ser vista como outra forma de MVC que contém dados JSON a serem analisados ​​pela resposta da API para preencher o pacote de modelos POJO. E um pacote de visualizações para conter visualizações personalizadas, notificações, visualizações de navegação, widgets etc. Adaptador Adaptador está entre os dados e a exibição. No entanto, eles geralmente precisam exportar algumas visualizações pelo método getView (), para que você possa colocar o pacote de adaptadores no pacote de visualizações.
• Algumas classes de função de controlador estão no nível do aplicativo e próximas ao sistema. Essas classes são colocadas no pacote de gerenciadores. Algumas classes complicadas de processamento de dados, como "DateUtils", são colocadas no pacote utils. A interação com o back-end é responsável pela classe de processamento de rede, que é colocada no pacote de rede.
• Em resumo, organize-os mais perto do usuário do que no back-end.

com.futurice.project
├─ network
├─ models
├─ managers
├─ utils
├─ fragments
└─ views   
├─ adapters   
├─ actionbar  
 ├─ widgets   
└─ notifications

Recursos

• A nomeação segue a convenção de prefixos indicando tipos, como type_foo_bar.xml. Por exemplo: fragment_contact_details.xml, view_primary_button.xml, activity_main.xml.
• Organizando arquivos de layout Se você não tiver certeza de como digitar um arquivo de layout, seguir as regras pode ajudar.
• Uma linha por atributo, recuada por 4 espaços
• android: id é sempre usado como o primeiro atributo
• atributo android: layout _ **** está no topo
• atributo de estilo na parte inferior
• Fechar tag /> Iniciar uma nova linha, ajudar a ajustar e adicionar novos atributos
• Considere usar

Atributos de tempo de design Atributos de tempo de design, o Android Studio forneceu suporte, em vez de android codificado: texto (Nota do tradutor: você também pode consultar este link do blog em stormzhang).

<? xml version = "1.0" encoding = "utf-8"?>

Como regra geral, o atributo android: layout_ deve ser definido no XML do layout, enquanto outros atributos android: devem ser colocados no XML do modelador. Há exceções a essa regra, mas geralmente funciona bem. A idéia geral dessa idéia é manter os atributos de layout (posicionamento, margem, dimensionamento) e conteúdo no arquivo de layout e colocar todos os atributos de detalhes da aparência (cores, preenchimento, fonte) no arquivo de estilo.

As exceções são as seguintes:

• android: id obviamente deve estar no arquivo de layout
• android: a orientação nos arquivos de layout geralmente é mais significativa para um layout LinearLayout
• android: text Como é um conteúdo definido, ele deve ser colocado no arquivo de layout
• Às vezes, faz mais sentido colocar os atributos android: layout_width e android: layout_height em um estilo como um estilo geral, mas, por padrão, eles devem ser colocados no arquivo de layout.

Usando estilos  Quase todos os projetos requerem o uso adequado de arquivos de estilos, porque é muito comum uma exibição ter uma aparência repetida. Para a maioria dos conteúdos de texto no aplicativo, pelo menos você deve ter um arquivo de estilo comum, por exemplo:

Aplicar ao TextView:

Pode ser necessário fazer o mesmo para os controles de botão, não pare por aí. Coloque um conjunto de atributos android: **** relacionados e repetidos em um estilo comum.

** Divida um arquivo de estilo grande em vários arquivos ** Você pode ter vários arquivos styles.xml. O SDK do Android oferece suporte a outros arquivos.O nome do arquivo de estilos não tem efeito.O que funciona é que os arquivos no 标签。因此你可以有多个style文件styles.xml,style_home.xml,style_item_details.xml,styles_forms.xml。 不用于资源文件路径需要为系统构建起的有意义，在res/valuesdiretório xml no arquivo podem ser nomeados arbitrariamente.

colors.xml é uma paleta de  cores.No seu arquivo colors.xml, ele deve apenas mapear o nome da cor para um valor RGBA e nada mais. Não o utilize para definir valores RGBA para botões diferentes.

Não faça isso

#FFFFFF # 2A91BD # 5F5F5F # 939393 #FFFFFF # FF9D2F… # 323232

Usando esse formato, você pode facilmente começar a definir valores RGBA repetidamente, o que torna muito complicado alterar as alterações básicas de cor, se necessário. Ao mesmo tempo, essas definições estão associadas a alguns ambientes, como botão ou comentário, que devem ser colocadas no estilo de botão, e não no arquivo color.xml.

Em vez disso, faça o seguinte:

#FFFFFF #DBDBDB # 939393 # 5F5F5F # 323232 # 27D34D # 2A91BD # FF9D2F # FF432F

Peça ao designer do aplicativo esta paleta.O nome não precisa ser o mesmo que "verde", "azul" etc. Nomes como "brand_primary", "brand_secondary", "brand_negative" também são completamente aceitáveis. Cores padrão como essa podem ser facilmente modificadas ou refatoradas, deixando claro quantas cores diferentes são usadas no aplicativo. Normalmente, para uma interface do usuário com valor estético, é muito importante reduzir os tipos de cores usadas.

Tratar o arquivo dimens.xml como você faz com colors.xml é o mesmo que definir uma paleta de cores.Você também deve definir uma "paleta" de espaços e tamanhos de fonte. Um bom exemplo é o seguinte:

22sp 18sp 15sp 12sp 40dp 24dp 14dp 10dp 4dp 60dp 40dp 32dp

Ao escrever margens e preenchimentos durante o layout, você deve usar o formato de espaçamento _ **** para o layout, em vez de escrever valores diretamente, como strings de String. Escrever dessa maneira será muito sensacional e facilitará a organização e a alteração do estilo ou layout.

** Evite a estrutura profunda da vista ** Às vezes, para colocar uma vista, você pode tentar adicionar outro LinearLayout. Você pode usar este método para resolver:

<RelativeLayout…> <LinearLayout…> <LinearLayout…> <LinearLayout…>

Mesmo que você não o use com muita clareza em um arquivo de layout, se você passar de um inflamento de exibição (esse inflamento não pode ser traduzido, todo mundo entende) para outros modos de exibição em um arquivo Java, isso pode acontecer.

Pode causar uma série de problemas. Você pode encontrar problemas de desempenho devido à necessidade de lidar com uma estrutura de árvore da interface do usuário complexa. Também pode causar o seguinte problema mais sério StackOverflowError.

Portanto, tente manter sua árvore de visualizações: aprenda como usar o RelativeLayout, como otimizar seu layout e como usar as tags ``.

Tenha cuidado com as exibições na Web . Se você precisar exibir uma exibição na Web, por exemplo, para um artigo de notícias, evite trabalhar com HTML no lado do cliente, é melhor pedir ao engenheiro de back-end que o ajude a retornar um HTML "puro". Os WebViews também podem causar vazamento de memória ao manter suas atividades citadas, em vez de serem vinculadas ao ApplicationContext. Ao usar texto ou botões simples, evite usar o WebView, então TextView ou Buttons é melhor.

Estrutura de teste

A estrutura de teste do Android SDK ainda está engatinhando, principalmente em relação aos testes de interface do usuário. Atualmente, o Android Gradle implementa um teste chamado connectedAndroidTest, que usa uma extensão JUnit do JUnit com ajudantes para Android. Você pode executar o teste JUnit gerado,

** O Robolectric é usado apenas para testes de unidade, e as visualizações não são necessárias. ** É o teste "fora do dispositivo" mais exigido para acelerar o desenvolvimento. Em muitas ocasiões, são realizados testes de unidade de modelos e modelos de visualização. No entanto, ao usar o teste Robolectric, ele é impreciso e não testa completamente a interface do usuário. Ao testar elementos da interface do usuário, caixas de diálogo etc. relacionadas à animação, haverá problemas, principalmente porque você está "trabalhando no escuro" (teste sem uma interface controlável)

_Robotium facilita a escrita de testes de interface do usuário. _ Para testes de interface do usuário, você não precisa do Robotium para executar um teste para se conectar ao dispositivo. Mas isso pode ser benéfico para você, pois tem muitos para ajudar a turma a obter e analisar a visualização, controlar a tela. O caso de teste parece tão simples como este:

solo.sendKey(Solo.MENU);
solo.clickOnText("More"); // searches
 for the first occurence of "More" and
 clicks on it
solo.clickOnText("Preferences");
solo.clickOnText(
"Edit File Extensions");
Assert.assertTrue(solo.searchText(
"rtf"));

Emulador

Se você desenvolve aplicativos para Android em período integral, compre um emulador de Genymotion. O emulador Genymotion é executado em uma segunda taxa de quadros mais rápida do que um emulador AVD típico. Ele possui ferramentas para demonstrar seu APP, conexão de rede simulada de alta qualidade, localização GPS e assim por diante. Também possui um teste de conexão ideal. Se você estiver envolvido na adaptação a muitos dispositivos diferentes, comprar um copyright da Genymotion é muito mais barato do que comprar muitos dispositivos reais.

Nota: O simulador Genymotion não carrega todos os serviços do Google, como Google Play Store e Maps. Você também pode precisar testar a API especificada pela Samsung. Nesse caso, ainda precisa comprar um dispositivo Samsung real.

Configuração ofuscada

O ProGuard é uma ferramenta amplamente usada em projetos Android para compactar e ofuscar o código-fonte empacotado.

A utilização do ProGuard depende da configuração do seu projeto.Quando você cria uma versão do apk, geralmente deve configurar o arquivo gradle.

buildTypes {
	debug {
		minifyEnabled false
	}
	release {
		signingConfig
		signingConfigs.release
		minifyEnabled true
			      proguardFiles 'proguard-rules.pro'
	}
}

Para decidir qual código deve ser retido e qual código deve ser ofuscado, você deve especificar uma ou mais classes de entidade em seu código. Essas entidades devem ser classes especificadas, contendo métodos principais, applets, midlets, atividades etc. A estrutura do Android usa um arquivo de configuração padrão, que pode ser encontrado no diretório SDK_HOME / tools / proguard / proguard-android.txt. As regras de ofuscação específicas do projeto especificadas pelo projeto customizado, conforme definidas em my-project / app / proguard-rules.pro, serão adicionadas à configuração padrão.

Uma pergunta comum sobre o ProGuard é verificar se o aplicativo falha e relata ClassNotFoundException ou NoSuchFieldException ou exceções semelhantes, mesmo se a compilação for bem-sucedida sem aviso. Isso significa as duas seguintes possibilidades:

O ProGuard removeu classes, enumerações, métodos, variáveis ​​de membros ou anotações, considerando se é necessário.

O ProGuard confunde os nomes de classes, enumerações e variáveis ​​de membros, mas esses nomes são usados ​​como nomes originais, como por meio da reflexão em Java.

Verifique o arquivo app / build / outputs / proguard / release / use.txt para ver se o objeto em questão foi removido. Verifique o arquivo app / build / outputs / proguard / release / mapping.txt para ver se o objeto em questão está confuso.

Para impedir que o ProGuard retire as classes ou membros da classe necessários, adicione uma opção de manutenção à sua configuração proguard: Para impedir que o ProGuard retire as classes e os membros da classe necessários, adicione uma opção keep no seu arquivo de configuração do proguard:

-keep class com.futurice.project.MyClass { *; }

Para evitar que o ProGuard confunda algumas classes e membros, adicione keepnames:

-keepnames class com.futurice.project.MyClass { *; }

Confira alguns exemplos na configuração do ProGuard deste modelo. Para mais exemplos, consulte Proguard.

No início do projeto de construção, uma versão foi lançada para verificar se as regras do ProGuard estavam corretas e mantinham partes importantes. Ao mesmo tempo, sempre que você adicionar uma nova biblioteca de classes, faça uma versão de lançamento e, ao mesmo tempo, o apk será executado no dispositivo para testar. Não espere seu aplicativo lançar a versão "1.0" antes de fazer uma versão. Nesse momento, você pode encontrar muitas exceções inesperadas e precisar de algum tempo para corrigi-las.

Dicas Cada vez que você lança uma nova versão, você deve escrever o mapping.txt. Toda vez que uma versão é lançada, se o usuário encontrar um bug, ele também envia um rastreamento de pilha ofuscado. Mantendo o arquivo mapping.txt, determine os problemas que você pode depurar.

 Se você precisar de ferramentas essenciais para otimizar o DexGuard e confundir especificamente o código de lançamento, considere usar o DexGuard, um software comercial, o ProGuard também é desenvolvido por sua equipe. Ele dividirá facilmente o arquivo Dex para resolver o problema de limitação do método 65K.

O artigo não é fácil, se você gosta deste artigo ou é útil para você, espero que todos gostem e o encaminhem. O artigo será atualizado continuamente. Absolutamente produtos secos! ! !