Gracias a poder participar en múltiples talleres relacionados con el desarrollo Xamarin y principalmente, a los cursos Xamarin que tengo disponible en CampusMVP tengo la posibilidad de interactuar con una gran cantidad de desarrolladores que utilizan Xamarin. Esto me ha permitido conocer las principales dudas y los principales problemas a los que se enfrentan.
En el artículo de hoy, vamos a centrarnos en un error relacionado con la compilación Android dado en mayor medida tras actualizar el paquete de Xamarin.Forms o uno de los implicados con Xamarin.Android.
El problema
Tras actualizar el paquete de Xamarin.Forms o alguno de los implicados con Xamarin.Android obtenemos el siguiente error:
Please install package: 'Xamarin.Android.Support.v4' available in SDK installer. Java library file ...\AppData\Local\Xamarin\Xamarin.Android.Support.v4\23.3.0.0\content\libs/internal_impl-23.3.0.jar doesn't exist.
También puede ser:
error APT0000: Error retrieving parent for item: No resource found that matches the given name 'Theme.AppCompat.Light.DarkActionBar'.
Xamarin descarga paquetes relacionados con el SDK de Android en la ruta %UserProfile%\AppData\Local\Xamarin\zips tras la restauración de paquetes. Dependiendo de varios factores como la conexión a internet, el tiempo de respuesta puede verse afectado. La implicación es el «congelado» del proceso de compilación en Visual Studio. Puedes creer que no esta sucediendo nada o bien, que algún error ha ocurrido. Ante esta situación, si se cancela la compilación o se cierra Visual Studio, todo puede quedar un estado indeterminado.
La solución
Lo primero que se suele intentar es limpiar y recompilar el proyecto. No funciona. Nos ponemos «más serios» y limpiamos la carpeta packages, bin y obj. Tampoco es suficiente.
Debemos de volver a permitir realizar la descarga de los paquetes relacionados con el SDK Android desde cero. Para ello:
Cerrar Visual Studio.
Acceder a la carpeta del proyecto, limpiar la carpeta packages.
Limpiar todos los paquetes de Xamarin.Android disponibles en la cache de NuGet disponible en la ruta %UserProfile%\.nuget\packages\Xamarin.Android.*.
Limpiar todos los paquetes de Xamarin.Android disponibles en la cache de Xamarin disponible en la ruta %UserProfile%\.nuget\packages\Xamarin.Android.*.
¿Recuerdas la ruta donde se descargaban los paquetes relacionados con el SDK de Android?. Limpiar las descargas no completadas de la ruta %UserProfile%\AppData\Local\Xamarin\zips.
Tras el proceso anterior, recompilar y esperar (es importante, paciencia!). Todo correcto de nuevo.
En ocasiones en nuestras aplicaciones tendremos la necesidad de mostrar al usuario cierta información de la manera más directa y sencilla posible de modo que de un solo vistazo el usuario sea capaz de obtener la mayor información posible. A nivel de interfaz tenemos muchísimas opciones muy interesantes sin embargo, un excelente recurso muy utilizado para este tipo de situaciones es el uso de gráficas. Por ejemplo, estamos realizando una aplicación de compra de viviendas. Sería fantástico mostrarle al usuario la información de como ha oscilado el precio de la viviendo en el último trimestre por ejemplo. ¿Como lo hacemos?, ¿Que piensas que sería lo más acertado?. Posiblemente una gráfica de barras u otra similar te haya pasado por la mente.
En esta entrada vamos a aprender como utilizar gráficas en nuestras aplicaciones Xamarin utilizando OxyPlot.
Añadiendo las dependencias necesarias
Tras crear la solución Xamarin.Forms, comenzamos añadiendo las dependencias necesarias. Hacemos clic secundario sobre la solución, Administrar paquetes NuGet para la solución…
Buscamos por Oxyplot.Xamarin.Forms:
Inciando renderers Oxyplot
Es necesario añadir código específico en cada plataforma para inicializar renderers de Oxyplot.
iOS
Utilizamos el método FinishedLaunching del delegado de la aplicación:
Tras inicializar OxyPlot, estamos preparados para comenzar a trabajar con la librería. OxyPlot cuenta con un control llamado PlotView. Este control se encuentra disponible en el namespace XAML:
PlotModel define el origen de la fuente de información de la gráfica así como, información relacionada con el tipo de gráfica.
Enlazar datos
A nivel de ViewModel, necesitamos definir una propiedad de tipo PlotModel:
private PlotModel _plotModel;
Propiedad pública:
public PlotModel PlotModel
{
get { return _plotModel; }
set
{
_plotModel = value;
RaisePropertyChanged();
}
}
PlotModel cuenta con diferentes propiedades que permiten definir el renderizado de la gráfica. Tenemos desde propiedades sencillas y comunes como Title que permite definir el título de la gráfica a otras más complejas como Series.
La propiedad Series espera un valor de tipo OxyPlot.Series. Esta propiedad permite definir el tipo de gráfica a utilizar.
Veamos un sencillo ejemplo para crear una gráfica de columnas utilizando ColumnSeries:
PlotModel = new PlotModel
{
Title = "Column"
};
var columnSerie = new ColumnSeries
{
StrokeThickness = 2.0
};
columnSerie.Items.Add(new ColumnItem(1));
columnSerie.Items.Add(new ColumnItem(2));
columnSerie.Items.Add(new ColumnItem(3));
columnSerie.Items.Add(new ColumnItem(4));
columnSerie.Items.Add(new ColumnItem(5));
PlotModel.Series.Add(columnSerie);
El resultado:
Tipos de gráficas
Tenemos una enome variedad de tipos de gráficas diferentes:
Área
Líneas
Barras
Columnas
Puntos
Circular
Mapa de calor
Etc
Además se pueden realizar composiciones haciendo combinaciones de varias de ellas, por ejemplo, barras con líneas.
Tenéis el código fuente del ejemplo utilizado disponible en GitHub:
Recuerda, cualquier tipo de duda o sugerencia es bienvenida en los comentario del artículo.
En el desarrollo de aplicaciones móviles contamos con una serie de controles de peso, altamente utilizados y que definen las características básicas de muchas aplicaciones. Hablamos de controles como listados, carruseles o mapas.
En Xamarin.Forms se pueden utilizar mapas utilizando las APIs nativas de cada plataforma. El uso básico se ve altamente simplifcado utilizando un paquete NuGet, Xamarin.Forms.Maps, que requiere cierta configuración inicial.
Trabajando con mapas, el inicio
Para trabajar con mapas en Xamarin.Forms debemos de comenzar añadiendo un paquete NuGet en cada proyecto de la solución, es decir, tanto en la librería portable como en cada proyecto nativo.
Tras añadir el paquete NuGet se deben de realizar tareas de inicialización.
En el caso de iOS se debe añadir:
Xamarin.FormsMaps.Init();
En el delegado principal de la aplicación tras inicializar Xamarin.Forms en el método FinishedLaunching.
En el caso de Android:
Xamarin.FormsMaps.Init(this, bundle);
Se realiza la inicialización de los mapas en la actividad principal utilizando el método OnCreate.
Por último, en el caso de Windows, la inicialización se realiza en el constructor de la página principal, MainPage:
Además de realizar el proceso de inicialización, los mapas requieren de ciertas capacidades además de requerir un Api Key correspondiente a los mapas nativos utilizados en cada plataforma.
En iOS, si se utiliza iOS 8 o superior, es necesario añadir dos claves al Info.plist.
<key>NSLocationAlwaysUsageDescription</key>
<string>Can we use your location</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>We are using your location</string>
En Android se utiliza la API de Google Maps que requiere un Api Key. A nivel de aplicación en el arhivo de manifiesto Android es necesario añadir:
Además, es necesario añadir los siguientes permisos:
AccessCoarseLocation
AccessFineLocation
AccessLocationExtraCommands
AccessMockLocation
AccessNetworkState
AccessWifiState
Internet
Se pueden añadir desde Opciones > Build > Android Application.
Para trabajar con Windows, como ya vimos en el proceso de inicialización, se necesita generar un token de autorización para poder autenticar con Bing Maps.
Uso básico de mapas
A la hora de trabajar con mapas en Xamarin.Forms haremos uso del control Map. El control se puede inicializar y utilizar desde C#:
var map = new Map(
MapSpan.FromCenterAndRadius(
new Position(37,-122), Distance.FromMiles(0.3))) {
IsShowingUser = true,
HeightRequest = 100,
WidthRequest = 960,
VerticalOptions = LayoutOptions.FillAndExpand
};
MapType: Permite establecer el tipo de mapa entre vista satélite, calle e híbrida.
Pins: Conjunto de pushpins del mapa.
Para añadir pushpins al mapa basta con rellenar la colección Pins con objetos de tipo Pin.
En cuanto a los métodos fundamentales tenemos:
MoveToRegion: Permite establecer y modificar la posición y nivel de zoom aplicado al mapa.
MyMap.MoveToRegion(
MapSpan.FromCenterAndRadius(
new Position(37,-122), Distance.FromMiles(1)));
Utilizando MVVM
Hasta este punto tenemos el mapa funcionando y contamos con todos los conceptos básicos necesarios para trabajar con mapas. Sin embargo, rellenar la colección de pushpins utilizando la propiedad Pins o posiciona el mapa utilizando el método MoveToRegion en el código asociado, no es lo que habitualmente realizamos.
¿Cómo utilizamos todo utilizando MVVM?
Pongámonos en situación. Habitualmente tendremos cierto contexto. Imagina que tenemos una aplicación de Taxis donde por supuesto, tendremos clientes. Cada cliente lo representaremos utilizando una entidad, dentro de la carpeta Models:
public class Customer
{
public int Id { get; set; }
public string Name { get; set; }
public string Title { get; set; }
public string Phone { get; set; }
public string Address { get; set; }
public string Description { get; set; }
public double Longitude { get; set; }
public double Latitude { get; set; }
public DateTime? FullyAttendedTime { get; set; }
}
La lógica necesaria para añadir pushpins al mapa es sencilla utilizando la propiedad Pins del mapa. También podemos gestionar la posición central del mapa y el nivel de zoom utilizando el método MoveToRegion:
private void AddPins()
{
foreach (var customer in DataRepository.LoadCustomerData())
{
var pin = new Pin
{
Type = PinType.Place,
Position = new Position(customer.Latitude, customer.Longitude),
Label = customer.Name,
Address = customer.Address
};
MyMap.Pins.Add(pin);
}
}
private void PositionMap()
{
MyMap.MoveToRegion(
MapSpan.FromCenterAndRadius(
new Position(GlobalSetting.UserLatitude, GlobalSetting.UserLongitude),
Distance.FromMiles(1)));
}
Vamos a aprovechar toda la versatilidad y potencia que nos brindan los Behaviors en Xamarin.Forms.
El concepto de Behavior es algo muy sencillo. Un Behavior espera por “algo” para hacer “algo”. Concretamos más. Un Behavior espera por “algo”. Puede ser un evento que se lanza, el cambio de una propiedad o cualquier otra acción personalizada que deseamos monitorear. Una vez que ese “algo” se desencadena, el Behavior puede hacer acciones muy variadas, desde cambiar el valor de una propiedad, lanzar un evento, hacer verificaciones o validaciones, etc.
Los Behaviors nos permiten encapsular lógica que se puede adjuntar a un componente específico. Generalmente ayudan a personalizar o completar ciertos componentes e incluso en muchas ocasiones son un a ayuda fundamental para mantener una estructura idónea al implementar patrones como MVVM.
Comenzamos creando la clase MapBehavior que debe de heredar de BindableBehavior<Map>:
public class MapBehavior : BindableBehavior<Map>
{
}
Para permitir tener acceso a la colección de pushpins vamos a crear una BindableProperty de tipo IEnumerable<Customer>:
public static readonly BindableProperty ItemsSourceProperty =
BindableProperty.CreateAttached("ItemsSource", typeof(IEnumerable<Customer>), typeof(MapBehavior),
default(IEnumerable<Customer>), BindingMode.Default, null, OnItemsSourceChanged);
public IEnumerable<Customer> ItemsSource
{
get { return (IEnumerable<Customer>)GetValue(ItemsSourceProperty); }
set { SetValue(ItemsSourceProperty, value); }
}
Al recibir la información, añadiremos los pushpins al mapa y centraremos la posición deseada:
private static void OnItemsSourceChanged(BindableObject view, object oldValue, object newValue)
{
var mapBehavior = view as MapBehavior;
if (mapBehavior != null)
{
mapBehavior.AddPins();
mapBehavior.PositionMap();
}
}
Sencillo, ¿cierto?. Pues ahora llega el momento de utilizar el Behavior. Añadimos en la página el namespace XAML necesario:
Tenéis el código fuente del ejemplo utilizado disponible en GitHub:
Hasta este punto hemos aprendido como utilizar mapas en Xamarin.Forms de forma básica. Sin embargo, en las aplicaciones que hacen un uso intensivo de mapas vemos características como:
Pushpins totalmente personalizados.
Pushpins dinámicos (se añaden, se quitan e incluso se desplazan).
Mostrar un diálogo al pulsar un puhspin.
Traza de rutas.
Dibujo de figuras poligonales.
¿Cómo hacemos estas opciones en Xamarin.Forms?. En próximos artículos iremos profundizando en el uso de mapas viendo como realizar cada uno de los puntos anteriores.
Recuerda, cualquier tipo de duda o sugerencia es bienvenida en los comentario del artículo.
Xamarin.Forms es un toolkit que crea una abstracción sobre la interfaz de usuario de Android, iOS y Windows Phone permitiendo desarrollarla una única vez con código C# o Extensible Application Markup Language (XAML). Actualmente tenemos disponibl Xamarin.Forms Previewer o lo que es lo mismo, una herramienta que nos permite visualizar en tiempo real cualquier cambio relacionado con el código XAML que define la UI. Sin embargo, existen grandes opciones que vienen de parte de la comunidad y que vienen a extender y ayudar a la experiencia disponible directamente en Visual Studio. De esta forma tenemos propuestas como Gorilla Player o como la herramienta que va a cubrir toda la atención de este artículo, UI Seuth.
UI Sleuth
UI Sleuth es una herramienta creada por Michael Davis actualmente disponible en fase Beta para Windows (próximamente disponible también para MacOS) que nos permite depurar nuestras aplicaciones Xamarin.Forms. Entre las principales características permite:
Conectar y manejar un dispositivo.
Ver el árbol de elementos que componen la UI.
Hacer prototipos de UI de forma rápida y sencilla.
Detectar errores de UI.
Podemos resumir las características en un inspector visual (UI) en tiempo real de aplicaciones Xamarin.Forms.
¿Y en comparación con otras herramientas?
Xamarin Previewer permite ver directamente la renderización de una página XAML en Visual Studio. La aplicación no corre en un emulador o dispositivo, es una aproximación visible directamente en el IDE.
Por otro lado, tenemos a Gorilla Player. Esta gran herramienta permite ver los cambios en el codigo XAML de una página en tiempo real en N emuladores o dispositivos. La aplicación no se encuentra en ejecución.
La instalación
Empezamos por el principio, realizar la instalación de la herramienta. Debemos accerder a la página de UI Sleuth, rellenar el formulario básico con nombre y correo (recuerda, se encuentra en fase beta, la clave actualmente es probar y reportar feedback!).
Tras rellenar el formulario, accedemos a la página de descarga.
Para instalar basta con hacer doble clic sobre el archivo descargado. La instalación es un proceso rápido y sencillo.
Los requisitos de la herramienta son:
Microsoft Windows 7+ 64bit
Visual Studio 2012+
Xamarin.Forms 2.0+
Emulador Android 4.03+ o dispositivo Android SDK (opcional)
Preparar la solución para utilizar UI Sleuth
Tras instalar la herramienta debemos de preparar nuestra aplicación para poder ver cambios al vuelo. En el proyecto Android, debemos hacer clic secundario en Administrar paquetes NuGet…
Buscamos por «UISleuth.Android»:
Instalamos el paquete. A continuación, en la actividad principal, MainActivity.cs añadimos el siguiente código tras la llamada a LoadApplication:
#if DEBUG
UISleuth.Inspector.Init();
#endif
Todo listo!. Lanzamos la aplicación en un emulador o dispositivo real.
Conectando
Continuamos arrancando la herramienta UISleuth. Nos aparecerá un listado de emuladores o dispositivos conectados. Podemos conectar directamente pulsando el botón Connect.
También podemos realizar un proceso de conexión manual utilizando la dirección IP del dispositivo.
Tras conectar, veremos la pantalla principal de la herramienta:
Tenemos:
Visual Outline: Este panel situado a la izquierda nos permite explorar el árbol visual que compone la interfaz de usuario.
History: Sencillo panel que guarda cada paso de cada movimiento realizado en la herramienta. También situado a la izquierda.
Properties (Attached Properties y Events): Panel muy importante y completo. Tenemos la posibilidad de gestionar de forma visual las propiedades y eventos de cada control que compone la UI.
Utilizando UI Sleuth
Vamos a utilizar la herramienta para crear una sencilla vista de Login. Desde la propia herramienta podemos añadir los elementos visuales que necesitamos. Vamos a utilizar:
StackLayout
Label
Entry
Button
Tras añadir los elementos, tenemos la posibilidad de editar todas sus propiedades:
A la hora de añadir diferentes elementos de la UI, tenemos la posibilidad de modificar, arrastrar y soltar dentro del árbol visual para modificar el Layout de la aplicación:
E incluso, podemos probar la aplicación y ver una previsualización en la misma herramienta:
En resumen
Seguimos esperando un editor visual que permite la construcción de interfaces de usuario de forma sencilla, arrastrando y soltando, etc. Sin embargo, cada vez tenemos más opciones disponibles para la edición y gestión de la UI de nuestras aplicaciones Xamarin.Forms. UI Sleuth permite ver cambios de una aplicación en ejecución, además de poder acceder a listado de controles para añadir, poder ver el árbol visual pudiendo hacer drag & drop en el mismo, etc. En breve llegarán más características (versión MacOS, soporte a listados, etc.). Sin duda, una opción más que interesante la de Michael Davis que seguro a muchos os gustará y que seguirá mejorando en próximos meses.
Xamarin Dev Days son una serie de eventos celebrados a lo largo de todo el mundo que ofrecen la posibilidad de conocer las últimas novedades relacionadas con el desarrollo Xamarin, poder disfrutar de talleres y por supuesto, compartir momentos de networking.
Agenda
La agenda:
9:00AM Registro y bienvenida.
9:30 – 10:10AM Introducción a Xamarin. Introducción a los conceptos básicos tanto de Xamarin Classic como de Xamarin.Forms así como a la integración con Visual Studio, Xamarin Test Cloud, etc.
10:20 – 11:00AM Xamarin Forms. Tras una introducción a conceptos básicos se verá como estructurar el proyecto y una serie de buenas prácticas para compartir la mayor cantidad de código posible. Finalmente se terminará con las últimas novedades como Xamarin.Forms Previewer, etc.
11:10 – 11:50AM Xamarin + Azure. Gracias al Azure podemos crear servicios de backend, notificaciones push y otras características esenciales de forma compartida. En esta sesión aprenderemos como sacarle partido a Azure desde nuestras aplicaciones Xamarin.
12:00 – 2:00PM Hands on Lab. ¿Crear una aplicación Xamarin paso a paso con MVVM, uso de servicios REST y accediendo a características de cada plataforma?. En este taller realizaremos una aplicación con esas características entre todos. Anímate y ven con tu portátil preparado!.
2:00 – 3:00PM Comida.
La fecha
El evento tendrá lugar el próximo Sábado, 08 de Abril de 9:00h a 15:00h. Tendremos tres sesiones técnicas de 40 minutos de duración cada una junto a un taller de 2 horas de duración. Además contaremos con regalos (ya los hemos visto, son geniales!) y sorpresas.
El pasado Microsoft Connect 2016, en San Francisco, se presentaba Visual Studio Mobile Center con el firme objetivo de convertirse en el centro de control de nuestras aplicaciones móviles. Mobile Center soporta tanto aplicaciones Xamarin como aplicaciones nativas con Java, Objective-C o Swift además de aplicaciones React Native.
Incluye los siguientes servicios:
Build: Integración y entrega continua.
Test: Pruebas automáticas en dispositivos reales.
Reporte de errores: Analíticas de errores en tiempo real.
Distribución: Despliegue a usuarios o grupos.
Analíticas: Métricas de uso.
Autenticación: Integración sencilla con métodos comunes.
EasyTables: Crear almacenamiento de forma muy rápida.
Un vistazo a Visual Studio Mobile Center
Ante una nueva herramienta con tantas posibilidades, ¿algo mejor que probarla y verla en video?
Tenéis el código fuente del ejemplo utilizado disponible en GitHub:
Recordad que podéis dejar cualquier comentario, sugerencia o duda en los comentarios.
Si hace escasamente un par de meses, tenía la gran oportunidad de participar en un cursogratuito de Xamarin con CampusMVP y Microsoft con la creación del contenido, ¿algo mejor aún para fomentar el uso y crecimiento de la comunidad?.
Concurso de Apps Xamarin
Todo puede ser, prepárate para el concurso de Apps Xamarin!. La mecánica es muy sencilla. Desarrolla tu App Xamarin utilizando Azure, tienes hasta el próximo 30 de Junio para enviar la App. Tras evaluar las aplicaciones, la ganadora recibirá un premio de 5000€ más acceso al curso de pago de Xamarin en CampusMVP. Del segundo clasificado al quinto, obtendrán 1000€ cada uno.
NOTA: En este concurso solo podrán participar personas físicas residentes en España.
Si ya has realizado el curso de Xamarin o si tu aplicación hace uso de ciertas tecnologías o viene a resolver problemas sociales como Bulling / cyberbulling, desempleo, corrupción, violencia de género, racismo, etc. obtendrás puntos extras que se tendrán en cuenta a la hora de evaluar.
La calidad en el software es algo innegociable. Debemos entregar Apps móviles perfectamente adaptadas a cada plataforma, ofreciendo la mejor experiencia de usuario posible pero sobretodo, funcional. Una App funcional debe cubrir y cumplir unos mínimos exigentes de calidad.
Como desarrolladores, somo humanos y el código no estara libre de errores. Sin embargo, el proceso que apliquemos para la detección y corrección a los mismos, es vital.
Podemos crear dos tipos de pruebas diferenciadas:
Pruebas unitarias: Pruebas de pequeñas unidades funcionales de nuestra App. Utilizaremos NUnit para realizar estas pruebas unitarias generalmente de ViewModels, Helpers y Servicios.
Pruebas de interfaz de usuario: Pruebas sobre la interfaz de usuario, escritura en cajas de texto, pulsaciones de botones, etc. Utilizaremos Xamarin UITest para estas pruebas.
Creando Tests de Apps Xamarin
A continuación, utilizando como base una aplicación de una calculadora realizada en Xamarin.Forms, se muestra en video:
Introducción al concepto de pruebas unitarias.
Como crear pruebas unitarias a un proyecto Xamarin.
Conceptos básicos necesarios de Xamarin.UITest.
Crear proyecto de tipo Xamarin.UITest.
Introducción a Xamarin Test Cloud.
Lanzar pruebas de tipo UITest en Test Cloud.
Tenéis el código fuente del ejemplo utilizado disponible en GitHub:
Recordad que podéis dejar cualquier comentario, sugerencia o duda en los comentarios.
Las plantillas de proyectos así como de diferentes tipos de archivos son una necesidad básica y muy requeridos a la hora de arrancar un proyecto. En la última actualización de Xamarin, la versión RC del Cycle 9, nos encontramos con novedades en las plantillas de proyectos Xamarin.Forms:
Ahora al seleccionar la plantilla Cross Platform App disponible en la categoría Cross Platform, tenemos disponible un asistente que nos permite configurar el proyecto:
Entre utilizar Xamarin.Forms o Xamarin.Classic.
PCL o Shared.
Plantilla vacía o maestro detalle.
Añadir proyecto Azure Mobile App directamente.
Tras crear un proyecto Xamarin.Forms, podemos añadir nuevas páginas y tenemos novedades:
Ahora contamos con plantillas para crear nuevas páginas utilizando:
Mapas
Pestañas
Listado
Si añadimos una página de tipo listado:
No solo añade la vista, también una ViewModel asociada con datos FAKE.
Un vistazo en video
Suena interesante, ¿cierto?. Si te lo parece, no te pierdas el siguiente recorrido por las novedades en video.
La calidad en el software es algo innegociable. Un buen proceso en el desarrollo y gestión del proceso es fundamental para conseguir ese objetivo. Debemos entregar Apps móviles perfectamente adaptadas a cada plataforma, ofreciendo la mejor experiencia de usuario posible pero sobretodo, funcional. Una App funcional debe cubrir y cumplir unos mínimos exigentes de calidad.
Como desarrolladores, somo humanos y el código no estara libre de errores. Sin embargo, el proceso que apliquemos para la detección y corrección a los mismos, es vital.
Realizar un proceso automático en cada nuevo checkin o de manera programada donde:
Compilar proyectos.
Pasar pruebas unitarias.
Pasar pruebas de interfaz de usuario.
Incluso publicar automáticamente paquetes y resultados.
Nos permitirá detectar problemas en el código de la forma más prematura posible, pudiendo ofrecer mayor calidad. Hablamos de procesos de integración continua y de entrega continua.
En artículos anteriores ya vimos como utilizar Team City o Visual Studio Team Services para realizar integración continua. En esta ocasión vamos a centrarnos en el uso de Bitrise.
Bitrise
Desde sus inicios (centrados en iOS), Bitrise se ha enfocado como una herramienta destinada a realizar integración y entrega continua de aplicaciones móviles teniendo en cuenta una enorme cantidad de integraciones con otras herramientas y servicios de terceros. Todo ello, con la sencillez y simpleza en mente.
Tras añadir soporte a aplicaciones Xamarin, se puede realizar la compilación, testing y distribución de aplicaciones Xamarin.iOS y Xamarin.Android con Bitrise.
NOTA: Como muchos otros servicios, Bitrise se basa en un modelo de suscripción mensual o anual con diferentes opciones y precios. Cuenta con una opción gratuita. La versión gratuita permite hasta 200 builds mensuales con soporte a Xamarin y más de 100 integraciones con servicios de terceros. La mayor limitación es que sólo permite la compilación de una única aplicación (concurrencia) de manera simultánea.
Integración Continua
La integración continua consiste en hacer integraciones automáticas de un proyecto lo más a menudo posible para así detector fallos cuantos antes.
Entendemos por integración la compilación y ejecución de pruebas.
El flujo del proceso sería:
El desarrollador trabaja en su equipo de desarrollo subiendo cambios al repositorio de código donde estaría el código además de las pruebas unitarias.
De una forma automática, el repositorio de código envia el mismo al servidor de BUILD.
El servidor de BUILD realizará la compilación de la solución o proyectos, ejecutará pruebas y recopilará la información de los resultados.
Los resultados los obtiene el desarrollador para poder analizarlos y actuar en consecuencia.
“La integración continua no evitará que se produzcan bugs, pero si nos permite encontrarlos y solucionarlos de una forma dramáticamente más fácil”
Martin Flowler
Los beneficios de utilizar integración continua son:
Detectar errores con mayor rapidez y antelación. Esto provocará que sea más sencillo de corregir y por lo tanto más barato.
Consistencia. O lo que es lo mismo, tener Builds reproducibles. La App funcionará en cualquier entorno con las mismas condiciones. Evitamos la “contaminación de la Build” o lo que es lo mismo, tener la Build con parámetros “a fuego” y condiciones específicas de la máquina de Build.
Poder automatizar también la entrega consiguiendo una entrega continua.
Comenzamos añadiendo una nueva aplicación
Tras realizar el registro de forma gratuita y hacer Login:
Accedemos al Dashboard principal. Desde este apartado tendremos un vistazo rápido a todas las aplicaciones creadas y su estado, últimas noticias o acceder a la configuración.
Para añadir una nueva aplicación bastará con pulsar el botón Add:
Comenzamos con el proceso de creación de la aplicación. El primer paso consiste en indicar la dónde se encuentra el código fuente, es decir, el repositorio de la aplicación. Es posible configurar:
GitHub
Bitbucket
Gitlab
Cualquier otra opción con configuración manual estableciendo la URL de acceso y credenciales.
NOTA: Si la autenticación se realiza utilizando un proveedor de identificación de terceros como por ejemplo GitHub, el repositorio aparecerá configurado y listo para utilizar.
Para este artículo vamos a utilizar un repositorio correspondiente a una aplicación Xamarin.Forms meteorológica clonada de un repositorio original de James Montemagno.
Tras seleccionar el proyecto a utilizar se pide como paso el añadir una clave SSH al repositorio para facilitar la validación y acceso con los privileegios necesarios para completar todo el proceso de compilación.
Tras añadir la clave y completar el proceso de validación, podemos elegir la rama a utilizar la realizar la compilación.
Tras un pequeño proceso de validación (acceso al repo, clonado, elección de tipo de proyecto, etc.):
Automáticamente se detecta el tipo de proyecto aplicando la configuración idónea en cada caso, la elección de herramientas, tipo de compilación y plataforma:
NOTA: Es posible realizar una configuración detallada a mano de cada uno de los parámetros necesarios.
El siguiente paso que requiere configuración consiste en la creación de un webhook. El concepto es sencillo, se configuran una serie de triggers (disparadores) que desencaden una acción, generalmente compilar en base a unas condiciones. Las condiciones establecidas suelen ser:
Una fecha y hora establecida (Build programada).
Un commit.
Una Pull Request.
Etc.
Tras crear un Webhook (por defecto creado para lanzar la Build cada vez que se crea un nuevo commit a la rama), podemos lanzar nuestra primera Build. Bastará con pulsar el botón:
Comienza el proceso de integración continua configurado. En todo momento accedemos a feedback inmediato de cada acción realizada, logs, estados e incluso ver el flujo de acciones a ejecutar.
Al completar el proceso, por defecto, seremos notificados del resultado y la información relacionada con los paquetes vía correo. Además de poder descargar el paquete generado, podemos distribuirlo de forma sencilla enviando notificaciones a otros miembros pudiendo crear grupos, etc.
Llegados a este punto podemos comprobar como la sencillez buscada por la herramienta se traduce en conseguir de forma bastante rápida y «a tiro» de pocos clics un proceso de integración continua.
El editor de flujos de trabajos
El editor del flujo de trabajo (Workflow) permite mediante el uso de casillas, seleccionar diferentes procesos a realizar y ordenarnos secuancialmente en base al orden de ejecución deseado. Con todo el proceso anterior, conseguimos:
Acceder al repositorio
Descargar el código fuente
Restaurar paquetes NuGets
Compilar
Crear los paquetes
Desplegar los paquetes a Bitrise
Sin embargo, en ocasiones necesitaremos realizar más procesos de validación, testing o despliegue.
Nuevos pasos, integración con servicios
Al añadir un nuevo paso, tendremos acceso al listado de integraciones con herramientas y servicios de terceros disponibles.
De esta forma podemos añadir nuevos pasos, subir el paquete a HockeyApp y publicar un mensaje en Slack al terminar. Se puede ver un listado de todas las integraciones disponibles en este enlace.
Hasta aquí esta pequeña introducción a Bitrise. Suficiente para conocer sus posibilidades aunque nos faltan por ver la posibilidad de lanzar pruebas unitarias o Xamarin.UITest además de las opciones de distribución o publicación. Algo que veremos en próximos artículos. La herramienta se muestra como una opción sólida, integrada con las necesidades de Xamarin así como los servicios y herramientass habitualmente necesarios. Sin duda, me ha gustado bastante todo lo que he probado. Y a ti, ¿qué te parece?.