Creo que muchos tuvieron la necesidad de reutilizar módulos individuales de su aplicación de Android en otro proyecto. Hay formas simples de resolver este problema, por ejemplo, alojar públicamente su biblioteca de Android usando JitPack . La solución es excelente, pero si necesita colocar la biblioteca en privado, tendrá que pagar, y la tarifa dependerá con mayor frecuencia de la cantidad de artefactos colocados. Esta solución no es adecuada para todos.
A continuación, ofreceré una solución simple a este problema utilizando Sonatype Nexus Repository OSS.Introduccion
El artículo no pretende ser exhaustivo y refleja solo una solución básica. Como resultado, habrá instalado software para administrar artefactos en el lado de un host, un script para publicar una biblioteca de Android, la capacidad de implementar dependencias en su aplicación desde el repositorio local de Maven. Tal vez ya hay publicaciones de este tipo en Habré, pero no encontré un tutorial comprensible para el desarrollador de Android, lo que me llevó a compartir información con usted. Me alegrará si resulta ser realmente útil en el trabajo.
Paso 1. Preparación
Primero debes decidir dónde instalar Nexus. Es lógico si este es un servidor, al que siempre tendrá acceso durante el desarrollo. En este artículo, instalaremos Nexus en el mismo host en el que estamos desarrollando. Las diferencias al instalar en el servidor estarán solo en la dirección IP en la que accederemos a los repositorios.
Antes de instalar Nexus, debe
descargar e instalar JRE. Solo Oracle JRE es adecuado y solo la versión 1.8 (intentó 10, pero Nexus juró), esto se
indica claramente en la documentación . Recuerde agregar la ruta a los ejecutables JRE en su RUTA.
A continuación, debe
descargar Nexus desde el sitio oficial . Al momento de escribir, esta es la versión 3.12
Paso 2. Instalar y configurar Nexus
Es suficiente para descomprimir el archivo descargado donde sea conveniente para usted. Luego puede iniciar el programa y comenzar a trabajar. Para un uso conveniente y a largo plazo, debe registrar Nexus como un servicio y ejecutarlo cuando se inicie el sistema operativo. Cómo hacerlo se
describe con bastante claridad
en la documentación . En nuestro caso, simplemente vaya a la
nexus-3.12/bin/ "
nexus-3.12/bin/ " y ejecute el archivo nexus desde la línea de comandos.
En el caso de c Windows:
nexus.exe /run
En el caso de Unix:
./nexus run
Como resultado, debería ver una notificación sobre un lanzamiento exitoso, se ve así:
Ha llegado el momento de probar la funcionalidad del Nexus. Para hacer esto, solo vaya al enlace
http: // localhost: 8081 . Como comprenderá, en el caso de un servidor, en lugar de "
localhost ", debe especificar la dirección IP de su servidor, y Nexus usa el puerto 8081 para trabajar. Verá esta página:
En primer lugar, debe iniciar sesión, hacer clic en "
Sign in "
Sign in admin123 superior derecha e ingresar el inicio de sesión (
admin ) y la contraseña (
admin123 ) del administrador. Después de eso, aparece el ícono de ajustes, al hacer clic en el cual ingresamos a la configuración.
En la pantalla de configuración, verá enlaces a
Blob Stores and
Repositories .
Blob Stores son los repositorios para sus datos de repositorio. En la configuración de cada repositorio, puede especificar un
Blob Store específico para almacenar información. Uno será suficiente para nosotros, creado por defecto.
Repositories son los repositorios de interés para nosotros, en los que se almacenarán las bibliotecas.
Pero antes de pasar a la descripción de los repositorios, vale la pena realizar configuraciones básicas para los usuarios. Vayamos a la sección "
Roles ".
Además de las funciones de administrador y usuario anónimo, propongo asignar funciones del tipo "
Downloader " - para cargar dependencias en proyectos, "
Contributor " - para enviar bibliotecas a Nexus.
Haga clic en "Crear rol", luego seleccione el "rol Nexus", ingrese los datos para el "Descargador" como en la captura de pantalla siguiente:
Qué privilegios son responsables de lo que se describe
en detalle
en la documentación . Necesitamos seleccionar un privilegio con el indicador de "
repository-view " (es responsable de trabajar con los datos de los repositorios), el privilegio también debe dar derecho a leer los datos del repositorio, este es el indicador de "
read ", y dado que en Android trabajamos con repositorios Maven, vale la pena detenerse en el
maven2 "
maven2 " para evitar que el usuario trabaje con otros tipos de repositorios. Haga clic en "
Create role ".
Por analogía, creamos el rol de "
Contributor ". La única diferencia es que heredaremos la lectura directamente del rol "
Downloader " (configuración en la parte inferior de la página), y con nuestras manos daremos privilegios para editar, agregar artefactos al repositorio y también para ver los datos de los repositorios a través de la interfaz web.
A continuación, cree los usuarios a quienes asignaremos los roles configurados. Vamos a la sección "
Users " (en el lado izquierdo de la ventana) y hacemos clic en "
Create local user ". Para la verificación, puede establecer contraseñas similares a la contraseña de administrador estándar, es decir, "
downloader123 " y "
contributor123 ". Muestra de relleno en la pantalla:
Dado que nuestro objetivo es el trabajo privado, vale la pena deshabilitar el acceso a los datos del repositorio para usuarios anónimos. Para hacerlo, vaya al usuario "
anonimous " y cambie su estado de "
Active " a "
Disabled ". En este caso, no será posible obtener dependencias anónimas en el proyecto de Android, sino solo con un usuario y contraseña específicos, pero aún será posible descargar datos a través de la interfaz web.
Para prohibir a los usuarios anónimos ver el contenido de los repositorios a través de la interfaz web, vaya a la sección "
Allow anonymous users to access the server " y desactive la opción "
Allow anonymous users to access the server ". Recuerde guardar los cambios.
El último paso sigue siendo la configuración de repositorios. Vaya a la sección "
Repositories " y vea los repositorios predeterminados creados allí. Entre ellos hay repositorios "
maven2 ", si observa de cerca, puede ver diferentes tipos: "proxy", "grupo", "alojado". Cuando el repositorio proxy simplemente reenvía al usuario a otro repositorio, en el caso de "
maven-central " preconfigurado, este es un enlace a
https://repo1.maven.org/maven2/ , "grupo" puede incluir varios repositorios, y "alojado" ya es un repositorio específico almacenado en Nexus. Nos serán útiles ahora.
Cree repositorios para las versiones "Release" e "Snapshot" de los artefactos. Haga clic en "
Create repository ", seleccione "
maven2 (hosted) ". Llamaremos al primer repositorio "android" y simplemente lo guardaremos sin cambiar la configuración:
Llamamos al segundo repositorio "android_snapshot", cambiamos la "
Version policy " a "Spapshot" y la "
Deployment policy " a "Permitir la
Deployment policy ".
Si no está claro qué afecta esto, puede leerlo
aquí . De hecho, el repositorio "android" no podrá descargar la misma versión de la biblioteca repetidamente, este es el comportamiento habitual cuando se comunica, por ejemplo, con maven-central. Para el repositorio android_snapshot, el nombre de la versión necesariamente debe terminar en SNAPSHOT y la misma versión estará disponible para descargar nuevamente.
También preste atención al hecho de que la lista de repositorios tiene una columna "URL" con botones "Copiar", necesitaremos estos enlaces en el futuro para acceder a los repositorios de los proyectos.
Felicidades La configuración básica de Nexus está lista, es hora de comenzar a crear y publicar la biblioteca.
Paso 3. Crea y publica la biblioteca de Android
Creamos el proyecto de Android, lo llamaremos "TestLibrary". Luego, en la "Vista del proyecto", haga clic en la raíz del proyecto con el botón derecho del mouse, seleccione "Nuevo" y "Módulo". En la ventana que se abre, seleccione "Biblioteca de Android" y nombre la biblioteca "HelloLibrary". Como resultado, verá el módulo de nuestra nueva biblioteca al lado del módulo "aplicación".
Agregue una clase con una función de bienvenida a la biblioteca:
package com.example.nexus.hellolibrary fun helloFromOurLibrary() { println("### Hello World! This is our new Android library!") }
La biblioteca está lista, es hora de publicar. En la "Vista del proyecto" en el módulo "hellolibrary" agregue el archivo y llámelo "publisher.gradle". Almacenará el script para publicar la 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
Luego, vaya al "build.gradle" de nuestra biblioteca, aplique nuestro editor y elimine las dependencias innecesarias:
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() }
Ahora podemos publicar simplemente completando la tarea "
publishAndroidLibraryPublicationToMavenRepository ".
La biblioteca se publica, ¡felicidades! Verifique el resultado en la interfaz web de nuestro Nexus. Vaya al elemento "Examinar" y seleccione el repositorio "android". Deberías ver lo siguiente:
Paso 4. Usando dependencias de Nexus
Para la prueba, propongo crear otro proyecto de Android vacío.
Para comenzar, conecte el repositorio al proyecto simplemente agregando datos al archivo "build.gradle" del nivel del proyecto:
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 }
Y ahora, como con cualquier otra biblioteca, tenemos una dependencia en nuestra "biblioteca infernal" a través de la implementación en el archivo "build.gradle" del nivel de "aplicación".
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" }
La ruta a la dependencia se
groupId:artifactId:version como
groupId:artifactId:version .
Ahora puede llamar a la función
helloFromOurLibrary() en su proyecto de Android y probar el rendimiento de todo el circuito. Felicidades
Resumen
Ahora tiene la oportunidad de reutilizar bibliotecas privadas de Android en proyectos. Esperando comentarios!
Espero que no hayas perdido tu tiempo, ¡gracias!