Eu acho que muitos tiveram a necessidade de reutilizar módulos individuais de seus aplicativos Android em outro projeto. Existem maneiras simples de resolver esse problema, por exemplo, hospedar publicamente sua biblioteca Android usando o JitPack . A solução é excelente, mas se você precisar colocar a biblioteca em particular, terá que pagar, e a tarifa geralmente dependerá do número de artefatos colocados. Esta solução não é adequada para todos.
Abaixo, vou oferecer uma solução simples para esse problema usando o OSS do Repositório Sonatype Nexus.1. Introdução
O artigo não pretende ser abrangente e reflete apenas uma solução básica. Como resultado, você terá um software instalado para gerenciar artefatos no lado de um host, um script para publicar uma biblioteca Android, a capacidade de implementar dependências em seu aplicativo a partir do repositório maven local. Talvez já existam publicações desse tipo no Habré, mas não encontrei um tutorial compreensível para o desenvolvedor do Android, o que me levou a compartilhar informações com você. Ficarei feliz se isso for realmente útil no trabalho.
Etapa 1. Preparação
Primeiro, você precisa decidir onde instalar o Nexus. É lógico se for um servidor ao qual você sempre terá acesso durante o desenvolvimento. Neste artigo, instalaremos o Nexus no mesmo host em que estamos desenvolvendo. As diferenças ao instalar no servidor estarão apenas no endereço IP no qual acessaremos os repositórios.
Antes de instalar o Nexus, você precisa
baixar e instalar o JRE. Somente o Oracle JRE é adequado e apenas a versão 1.8 (tente 10, mas o Nexus jurou), isso está
claramente indicado na documentação . Lembre-se de adicionar o caminho aos executáveis do JRE em seu PATH.
Em seguida, você precisa
baixar o Nexus do site oficial . No momento da redação deste documento, esta é a versão 3.12
Etapa 2. Instale e configure o Nexus
Basta descompactar o arquivo baixado onde for conveniente para você. Então você pode iniciar o programa e começar a trabalhar. Para uso conveniente e a longo prazo, você precisa registrar o Nexus como um serviço e executá-lo quando o sistema operacional for iniciado. Como fazer isso é claramente
descrito na documentação . No nosso caso, basta ir para a
nexus-3.12/bin/ "
nexus-3.12/bin/ " e executar o arquivo nexus na linha de comando.
No caso de c Windows:
nexus.exe /run
No caso do Unix:
./nexus run
Como resultado, você deve receber uma notificação sobre um lançamento bem-sucedido, algo parecido com isto:
Chegou a hora de testar a funcionalidade do Nexus. Para fazer isso, basta acessar o link
http: // localhost: 8081 . Como você sabe, no caso do servidor em vez de "
localhost " é preciso especificar o endereço IP do seu servidor, e Nexus para usando a porta 8081. Você verá uma página:
Antes de tudo, é necessário fazer login, clique em "
Sign in "
Sign in canto superior direito e digite o login (
admin ) e a senha (
admin123 ) do administrador. Depois disso, o ícone de roda dentada aparece, clicando no qual entramos nas configurações.
Na tela de configurações, você verá links para
Blob Stores and
Repositories .
Blob Stores são os repositórios para seus dados de repositório. Nas configurações de cada repositório, você pode especificar um
Blob Store específico para armazenar informações. Um será suficiente para nós, criado por padrão.
Repositories são os repositórios de nosso interesse, nos quais as bibliotecas serão armazenadas.
Mas antes de passar para a descrição dos repositórios, vale a pena fazer configurações básicas para os usuários. Vamos para a seção "
Roles ".
Além das funções de administrador e usuário anônimo, proponho alocar funções do tipo "
Downloader " - para carregar dependências em projetos, "
Contributor " - para enviar bibliotecas ao Nexus.
Clique em "Criar função", selecione a "Função Nexus", insira os dados para o "Downloader" como na imagem abaixo:
Quais privilégios são responsáveis pelo que é descrito
em detalhes
na documentação . Precisamos selecionar um privilégio com o sinalizador "
repository-view " (é responsável por trabalhar com os dados dos repositórios), o privilégio também deve dar o direito de ler os dados do repositório, esse é o sinalizador "
read " e, como no Android trabalhamos com repositórios maven, vale a pena parar na bandeira "
maven2 ", de modo a não permitir que o usuário para trabalhar com outros tipos de repositórios. Clique em "
Create role ".
Por analogia, criamos a função "
Contributor ". A única diferença é que herdaremos a leitura diretamente da função "
Downloader " (configuração na parte inferior da página) e, com as nossas mãos, daremos privilégios para editar, adicionar artefatos ao repositório e também para visualizar os dados dos repositórios pela interface da web.
Em seguida, crie os usuários aos quais atribuiremos as funções configuradas. Vamos para a seção "
Users " (no lado esquerdo da janela) e clique em "
Create local user ". Para verificação, você pode definir senhas semelhantes à senha de administrador padrão, ou seja, "
downloader123 " e "
contributor123 ". Amostra de preenchimento na tela:
Como nosso objetivo é o trabalho privado, vale a pena desativar o acesso aos dados do repositório para usuários anônimos. Para isso, vamos ao usuário "
anonimous " e
anonimous seu status de "
Active " para "
Disabled ". Nesse caso, não será possível obter anonimamente dependências no projeto Android, mas apenas com um usuário e senha específicos, mas ainda será possível fazer o download de dados pela interface da web.
Para proibir usuários anônimos de visualizar o conteúdo dos repositórios via interface da web, vá para a seção "
Anonimous " e desmarque a opção "
Allow anonymous users to access the server ". Lembre-se de salvar as alterações.
O último passo permanece - configurando repositórios. Vá para a seção "
Repositories " e veja os repositórios padrão criados lá. Entre eles, existem repositórios "
maven2 "; se você observar de perto, poderá ver diferentes tipos: "proxy", "grupo", "hospedado". «Proxy» repositório simplesmente está encaminhando ao se referir a si mesmo para outro repositório de usuários, no caso de pré-construído "
maven-central " é uma referência a
https://repo1.maven.org/maven2/ , «grupo» podem incluir vários repositórios, e "hospedado" já é um repositório específico armazenado no Nexus. Eles serão úteis para nós agora.
Crie repositórios para as versões “Release” e “Snapshot” dos artefatos. Clique em "
Create repository ", selecione "
maven2 (hosted) ". Vamos chamar o primeiro repositório de "android" e simplesmente salvá-lo sem alterar as configurações:
Chamamos o segundo repositório de "android_snapshot", alteramos a "
Version policy " para "Spapshot" e a "
Deployment policy " para "Permitir reimplantação".
Se não estiver claro o que isso afeta, você pode lê-lo
aqui . De fato, o repositório “android” não poderá baixar a mesma versão da biblioteca repetidamente; esse é o comportamento usual ao se comunicar, por exemplo, com o maven-central. Para o repositório android_snapshot, o nome da versão deve necessariamente terminar em SNAPSHOT e a mesma versão estará disponível para download novamente.
Também preste atenção ao fato de que a lista de repositórios possui uma coluna "URL" com os botões "Copiar", precisaremos desses links no futuro para acessar repositórios de projetos.
Parabéns! A configuração básica do Nexus está concluída, é hora de começar a criar e publicar a biblioteca.
Etapa 3. Crie e publique a biblioteca Android
Criamos o projeto Android, denominaremos "TestLibrary". Em seguida, na "Visualização do projeto", clique na raiz do projeto com o botão direito do mouse, selecione "Novo" e "Módulo". Na janela que se abre, selecione "Biblioteca Android" e nomeie a biblioteca "HelloLibrary". Como resultado, você verá o módulo da nossa nova biblioteca ao lado do módulo "app".
Adicione uma classe com uma função de boas-vindas à biblioteca:
package com.example.nexus.hellolibrary fun helloFromOurLibrary() { println("### Hello World! This is our new Android library!") }
A biblioteca está pronta, é hora de publicar. Na "visualização do projeto" no módulo "hellolibrary", adicione o arquivo e chame-o de "publisher.gradle". Ele irá armazenar o script para publicar a biblioteca.
// apply plugin: 'maven-publish' ext { // URL Release repositoryReleaseUrl = "http://localhost:8081/repository/android/" // URL Snapshot repositorySnapshotUrl = "http://localhost:8081/repository/android_snapshot/" // , contributorUserName = "contributor" // , contributorPassword = "contributor123" // libraryGroupId = "com.example.nexus" // libraryArtifact = "hellolibrary" // libraryVersion = "0.0.1" } // publishing { // repositories { // maven { // credentials { username contributorUserName password contributorPassword } // Snapshot url libraryVersion.endsWith("SNAPSHOT") ? repositorySnapshotUrl : repositoryReleaseUrl } } // maven-publish publications { // AndroidLibrary - , // , AndroidLibrary(MavenPublication) { // groupId libraryGroupId artifactId libraryArtifact version libraryVersion // artifact "$buildDir/outputs/aar/${project.getName()}-release.aar" pom { // , // ClassNotFoundException // . withXml { def dependencies = asNode().appendNode("dependencies") configurations.getByName("releaseCompileClasspath") .getResolvedConfiguration() .getFirstLevelModuleDependencies() .each { def dependency = dependencies.appendNode("dependency") dependency.appendNode("groupId", it.moduleGroup) dependency.appendNode("artifactId", it.moduleName) dependency.appendNode("version", it.moduleVersion) } } // withXml } // pom } // AndroidLibrary } // publications // assembleRelease model { tasks.publishAndroidLibraryPublicationToMavenRepository { dependsOn project.tasks.assembleRelease } } } //publishing
Em seguida, vá para o "build.gradle" da nossa biblioteca, aplique nosso editor e limpe as dependências desnecessárias:
apply plugin: 'com.android.library' apply plugin: 'kotlin-android' // publisher apply from: "publisher.gradle" android { compileSdkVersion 28 defaultConfig { minSdkVersion 18 targetSdkVersion 28 versionCode 1 versionName "1.0" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version" } repositories { mavenCentral() }
Agora podemos publicar apenas concluindo a tarefa "
publishAndroidLibraryPublicationToMavenRepository ".
A biblioteca é publicada, parabéns! Verifique o resultado na interface da web do nosso Nexus. Vá para o item "Browse" e selecione o repositório "android". Você deve ver o seguinte:
Etapa 4. Usando dependências do Nexus
Para o teste, proponho criar outro projeto Android vazio.
Para começar, conecte o repositório ao projeto simplesmente adicionando dados ao arquivo “build.gradle” do nível do projeto:
buildscript { ext.kotlin_version = '1.2.50' repositories { google() jcenter() } dependencies { classpath 'com.android.tools.build:gradle:3.1.3' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" } } allprojects { repositories { google() jcenter() // maven { credentials { username "downloader" password "downloader123" } url "http://localhost:8081/repository/android" } } } task clean(type: Delete) { delete rootProject.buildDir }
E agora, como em qualquer outra biblioteca, temos uma dependência de nossa "biblioteca do inferno" por meio da implementação no arquivo "build.gradle" do nível "aplicativo".
apply plugin: 'com.android.application' apply plugin: 'kotlin-android' apply plugin: 'kotlin-android-extensions' android { compileSdkVersion 28 defaultConfig { applicationId "com.example.nexus.fff" minSdkVersion 18 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version" implementation 'com.android.support:appcompat-v7:28.0.0-alpha3' implementation 'com.android.support.constraint:constraint-layout:1.1.2' testImplementation 'junit:junit:4.12' androidTestImplementation 'com.android.support.test:runner:1.0.2' androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2' // implementation "com.example.nexus:hellolibrary:0.0.1" }
O caminho para a dependência é
groupId:artifactId:version como
groupId:artifactId:version .
Agora você pode chamar a função
helloFromOurLibrary() no seu projeto Android e testar o desempenho de todo o circuito. Parabéns!
Sumário
Agora você tem a oportunidade de reutilizar bibliotecas privadas do Android em projetos. À espera de comentários!
Espero que você não tenha perdido seu tempo, obrigado!