Crear y Publicar una Librería Android

Spanish (Español) translation by Javier Salesi (you can also view the original English article)

Introducción

Nuestras vidas como desarrolladores Android serían mucho más difíciles si no fuera por las librerías de terceros que nos fascina incluir en nuestros proyectos. En éste tutorial, aprenderás como retribuir a la comunidad de desarrolladores al crear y publicar tus propias librerías Android, que la gente puede agregar sin ningún esfuerzo en sus proyectos.

1. Crear una Librería Android

Si tu librería se va a componer únicamente de clases Java, empacándola como un JAR y distribuyéndola usando un archivo host es quizá la forma más fácil y rápida de compartirla. Si fueras a crearla desde la consola, el siguiente comando sería suficiente:

1	jar cvf mylibrary.jar Class1.class Class2.class ... ClassN.class

Sin embargo, éste tutorial, te muestra como trabajar con librerías más complejas que contienen no solo clases Java, sino también varios tipos de recursos y archivos XML. Tales librerías son creadas por módulos de librerías Android y son generalmente empacadas como archivos AAR.

Creemos una simple librería Android que ofrece un View personalizado a desarrolladores que la utilicen.

Paso 1: Agregar un Nuevo Módulo

Para comenzar, agrega un nuevo módulo Android a tu proyecto seleccionando New > New Module del menú File. Se mostrará la siguiente pantalla, que ofrece muchas opciones:

Selecciona Android Library y presiona Next. En el formulario que sigue, ingresa un nombre para tu librería y pulsa Next. Llamaré a ésta librería mylittlelibrary.

En la última pantalla, selecciona Add no Activity y presiona Finish.

Ahora tu proyecto tendrá dos módulos, uno para la aplicación y uno para la librería. Aquí está como se ve su estructura:

Paso 2: Crea un Layout (Maquetado)

Crea un nuevo layout XML al dar click derecho en el folder res de tu módulo de librería y selecciona New > XML > Layout XML File. Nómbralo my_view.xml.

Para mantener éste tutorial sencillo, crearemos un View personalzado que tiene dos widgets TextView dentro de un LinearLayout. Después de agregar algo de texto en los widgets TextView, el archivo layout XML debería verse así:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="https://schemas.android.com/apk/res/android"
    android:layout_width="match_parent" android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:text="Hello!"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceMedium"
        android:text="This is my custom view from my little library."/>
</LinearLayout>

Paso 3: Crea una Clase Java

Crea una clase Java y nómbrala MyView.java. Asegúrate de poner éste archivo en el directorio src del módulo de la biblioteca-no en el módulo de la aplicación.

Para hacer que ésta clase se comporte como un View, hagamosla una subclase de la clase LinearLayout. Android Studio te pedirá añadir constructores a la clase. Después de agregarlos, la nueva clase debería verse así:

public class MyView extends LinearLayout {

    public MyView(Context context) {
        super(context);
    }

    public MyView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

}

Como puedes ver, ahora tenemos dos constructores. Para evitar agregar código de inicialización a cada constructor, llamamos a un método llamado initialize desde cada constructor. Agrega el siguiente código a cada constructor:

1	initialize(context);

En el método initialize, llamamos a inflate para asociar el maquetado que creamos en el paso anterior con la clase.

1	private void initialize(Context context){
2	inflate(context, R.layout.my_view, this);
3	}

2. Usa la Librería Localmente

Ahora que la librería está lista, hagamos uso de ella en el módulo app del mismo proyecto para asegurarnos de que no hay problemas. Para hacer eso, agreguémosla como una dependencia compile en el archivo build.gradle del módulo de la aplicación:

1	compile project(":mylittlelibrary")

Crea una nueva clase Java, MainActivity, dentro del módulo de la aplicación. Hazla una subclase de la clase Activity y sobreescribe su método onCreate.

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
}

Dentro del método onCreate, crea una instancia de la view personalizada usando su constructor. Pásala al método setContentView para que ocupe todo el espacio de la pantalla de la Activity:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    View v = new MyView(this);
    setContentView(v);

}

Tu Activity está ahora lista. Después de agregarla al manifiesto de la aplicación, crea tu proyecto y despliega tu aplicación en un dispositivo Android. Deberías poder ver el view personalizado cuando inicia la aplicación.

3. Publica Tu Librería en Bintray

Bintray es una plataforma popular que puedes usar para publicar tus librerías Android. Es gratuita y fácil de usar.

Comienza por crear una cuenta en Bintray. Después de ingresar a tu cuenta, verás que ya tienes seis repositorios. Puedes usar uno de ellos o crear un nuevo repositorio. Para éste tutorial, estaré usando el repositorio llamado maven, que es un repositorio Maven.

Visita la página de tu perfil y da click en el botón Edit. En la próxima página, da click en el enlace API Key para ver tu clave API.

Anota la clave, porque la necesitarás para autenticarte cuando usas el plugin de Bintray.

Paso 1: Agrega los Plugins Necesarios

Para interactuar con Bintray en Android Studio, deberías incluir el plugin de Bintray en las dependencies (dependencias) del archivo build.gradle de tu proyecto.

1	classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.2'

Debido a que subirás la librería al repositorio Maven, también deberis agregar el plugin de Maven como se muestra abajo.

1	classpath "com.github.dcendents:android-maven-gradle-plugin:1.3"

Paso 2: Aplica los Plugins

Abre el archivo build.gradle del módulo de tu librería y agrega el siguiente código para aplicar los plugins que agregamos en el paso anterior.

1	apply plugin: 'com.jfrog.bintray'
2	apply plugin: 'com.github.dcendents.android-maven'

Paso 3: Especifica los Detalles de POM

El plugin de Bintray buscará un archivo POM cuando suba la librería. Aunque el plugin de Marven lo genera por tí, deberías especificar el valor de la etiqueta groupId y el valor de la etiqueta version tu mismo. Para hacer eso, utiliza las variables group y version en tu archivo gradle.

1	group = 'com.github.hathibelagal.librarytutorial' // Change this to match your package name
2	version = '1.0.1' // Change this to match your version number

Si estás familiarizado con Maven y te preguntas por qué no especificamos el valor de la etiqueta artifactId, es porque el plugin de Maven, por defecto, utiliza el nombre de tu librería como el artifactId.

Paso 4: Genera un Sources JAR

Para cumplir con los estándares de Maven, tu biblioteca también debería tener un archivo JAR conteniendo los archivos de origen de la librería. Para generar el archivo JAR, crea una nueva tarea Jar, generateSourcesJar, y especifica la ubicación de los archivos de origen usando la función from.

1	task generateSourcesJar(type: Jar) {
2	from android.sourceSets.main.java.srcDirs
3	classifier 'sources'
4	}

Paso 5: Genera un Javadoc JAR

También se recomeinda que tu biblioteca tenga un archivo JAR conteniendo su Javadocs (documentación de proyectos Java). Debido a que no tienes actualmente ningún Javadocs, crea una tarea Javadoc, generatJavadocs, para generarlos. Utiliza la variable source para especificar la ubicación de los archivos de origen. También deberías actualizar la variable classpath para que la tarea puede encontrar clases que pertenecen al Android SDK. Puedes hacer ésto al agregar el valor de retorno del método android.getBootClasspath a él.

task generateJavadocs(type: Javadoc) {
    source = android.sourceSets.main.java.srcDirs
    classpath += project.files(android.getBootClasspath()
            .join(File.pathSeparator))
}

Luego, para generar un JAR de los Javadocs, crea una tarea Jar, generateJavadocsJar, y pasa la propiedad destinationDir de generateJavadocs a su función from. Tu nueva tarea debería verse así:

1	task generateJavadocsJar(type: Jar) {
2	from generateJavadocs.destinationDir
3	classifier 'javadoc'
4	}

Para asegurarte de que la tarea generateJavadocsJar solo inicia cuando la tarea generateJavadocs se ha completado, agrega el siguiente fragmento de código, que usa el método dependsOn para ordenar las tareas:

1	generateJavadocsJar.dependsOn generateJavadocs

Paso 6: Incluye los archivos JAR Generados

Para incluir los archivos de origen y JAR Javadoc en la lista de artifacts (artefactos), que serán subidos al repositorio de Maven, deberías agregar los nombres de sus tareas a un parámetroconfiguration llamado archives. Para hacer eso, usa el siguiente fragmento de código:

1	artifacts {
2	archives generateJavaDocsJar
3	archives generateSourcesJar
4	}

Paso 7: Ejecuta las Tareas

Ahora es tiempo de ejecutar las tareas que creamos en los pasos anteriores. Abre la ventana Gradle Projects y busca una tarea llamada install.

Haz doble click en ella para ejecutar las tareas asociadas con el módulo de la librería. Una vez que se termine de ejecutar, tendrás todo lo que necesitas para publicar tu librería, un archivo POM válido, un archivo AAR, un JAR origen, y un JAR de Javadocs.

Paso 8: Configura el Plugin de Bintray

Para configurar el plugin, deberías usar la clausura o cierre bintray en tu archivo Gradle. Primero, autentícate usando las variables user y key, correspondientes a tu nombre de usuario y la clave de API de Bintray respectivamente.

En Bintray, tu biblioteca residirá dentro de un Bintray package (paquete Bintray). Deberías proporcionar detalles sobre como utilizar los parámetros intuitivamente llamados repo, name, licenses y vcsUrl de la clausura o cierre pkg. Si el paquete no existe, será creado automáticamente por tí.

Cuando subas tus archivos a Bintray, serán asociados con una versión del paquete Bintray. Por lo tanto, pkg debe contener una clausura o cierre version cuya propiedad name es establecida a un nombre único. Opcionalmente, también puedes proporcionar una descripción, fecha de lanzamiento, y etiqueta Git que utiliza los parámetros desc, released y vcsTag.

Finalmente, para especificar los archivos que deberían ser subidos, establece el valor del parámetro configuration en archives.

Ésta es una configuración de ejemplo:

bintray {
    user = 'test-user'
    key = '01234567890abcdef01234567890abcdef'
    pkg {
        repo = 'maven'
        name = 'com.github.hathibelagal.mylittlelibrary'

        version {
            name = '1.0.1-tuts'
            desc = 'My test upload'
            released  = new Date()
            vcsTag = '1.0.1'
        }

        licenses = ['Apache-2.0']
        vcsUrl = 'https://github.com/hathibelagal/LibraryTutorial.git'
        websiteUrl = 'https://github.com/hathibelagal/LibraryTutorial'
    }
    configurations = ['archives']
}

Paso 9: Sube Archivos que Utilizan el Plugin de Bintray

Abre la ventana Gradle Projects de nuevo y busca la tarea bintrayUpload. Haz doble click en él para comenzar a subir los archivos.

Una vez que se completa la tarea, abre un navegador para visitar la página de detalles de tu paquete Bintray. Verás una notificación que señala que tienes cuatro archivos no publicados. Para publicar éstos archivos, da click en el enlace Publish.

4. Usar la Librería de Bintray

Tu librería está ahora disponible como un paquete Bintray. Una vez que compartes la URL de tu repositorio Maven, junto con el ID de grupo, ID del artefacto, y el número de versión, cualquier desarrollador puede accesar a tu librería. Por ejemplo, para usar la librería que creamos, los desarrolladores tendrían que incluir el siguiente fragmento de código:

repositories {
    maven {
        url 'https://dl.bintray.com/eruzza/maven'
    }
}

dependencies {
    compile 'com.github.hathibelagal.librarytutorial:mylittlelibrary:1.0.1@aar'
}

Nota que el desarrollador tiene que incluir explícitamente tu repositorio en la lista de repositories antes de agregar la librería como una dependencia compile.

5. Agregar la Librería a JCenter

Por defecto, Android Studio busca librerías en un repositorio llamado JCenter. Si incluyes tu librería en el repositorio JCenter, los desarrolladores no tendrán que agregar nada a su lista repositories.

Para agregar tu librería a JCenter, abre un navegador y visita la página de detalles de tu paquete Bintray. Da click en el botón etiquetado Add to JCenter.

Posteriormente serás llevado a una página que te permite redactar un mensaje. Puedes usar el campo Comments para mencionar opcionalmente cualquier detalle sobre la librería.

Da click en el botón Send para comenzar el proceso de revisión de Bintray. En uno o dos días, la gente de Bintray enlazarán tu librería al repositorio de JCenter y podrás ver el enlace a JCenter en la página de detalles de tu paquete.

Cualquier desarrollador ahora puede usar tu librería sin cambiar la lista de repositories.

Conclusión

En éste tutorial, aprendiste como crear un sencillo módulo de librería Android y publicarlo tanto en tu propio repositorio Maven como en el repositorio JCenter. En el camino, también aprendiste como crear y ejecutar diferentes tipos de tareas gradle.

Para aprender más de Bintray, visita el manual del usuario de Bintray.

¡Sé el primero en conocer las nuevas traducciones–sigue @tutsplus_es en Twitter!