Introducción
Según evoluciona de Xamarin.Forms, llegan más y más opciones que simplifican la creación de diferentes elementos de la interfaz de usuario.
En el estado actual de Xamarin.Forms se pueden conseguir aplicaciones nativas de gran escala, con interfaces cuidadas y con alta integración con la plataforma. Hay que tener en cuenta el conjunto de Custom Renderers (código específico en cada plataforma) necesario para lograrlo.
NOTA:La elección entre Xamarin Classic o Xamarin.Forms es importante. Es necesario evaluar la aplicación a desarrollar, el conjunto de características específicas de cada plataforma (que pueden requerir un Custom Renderer), etc.
En este artículo, vamos a tomar como referencia un diseño de Dribbble (por Anton Aheichanka), que intentaremos replicar con Xamarin.Formspaso a paso.
My Tasks
Vamos a intentar replicar la UI del diseño paso a paso en Xamarin.Forms.
Los retos del ejemplo
Vamos a comenzar haciendo un análisis de la interfaz de usuario desglosando los elementos que la componen:
- Cabecera: La cabecera cuenta con información del perfil de usuario. La imagen del perfil es circular algo que es sencillo de conseguir de diversas formas (FFImageLoadingcon transformaciones, ImageCirclePlugino incluso con SkiaSharp). La otra característica destacada de la cabecera es la imagen de fondo ya que tiene un corte horizontal sencillo pero que hace destacar aun más la cabecera. Entre las opciones que tenemos, una de las más sencillas es utilizar SkiaSharp.
- El listado: El listado cuenta con una cabecera sencilla pero elegante, fácil de conseguir con la propiedad Header del ListView; elementos que se pueden conseguir definiendo una celda personalizada. En la celda, en caso de reuniones se muestran los participantes. Ahora gracias a BindableLayout es algo sencillo.
- El menu de filtro: La característica principal de la vista. Una de mis APIs favoritas en Xamarin.Forms es la de animaciones. Sencilla pero ofrece una libertas muy alta. En este caso, podemos replicarlo usando una ContentView con imágenes en el interior y el efecto de apertura y cierre del menu lo conseguimos a base de animaciones (de escala, opacidad, etc.).
Imagen con corte horizontal
¿Cómo conseguimos la imagen con corte horizontal?
SkiaSharpsuele ser una opción ideal para opciones de dibujado. En este caso, nos vendría genial directamente dibujar la imagen pero recortando una pequeña parte (triangulo) de la parte inferior. SkiaSharp permite cargar imágenes además de tener una enorme variedad de posibilidades al tratar la misma. aplicar diferentes transformaciones, efectos, etc. Podemos hacer un recorte con trazado (un path) de una imagen.
Tras añadir los paquetes de SkiaSharp.Views.Formsa la solución, creamos un nuevo control que herede de SKCanvasView.
Comenzamos definiendo el trazado que usaremos para recortar la imagen:
SKPath Path = SKPath.ParseSvgPathData("m 0 0 l 400 0 l 0 300 l -400 -50");
Usamos el método ClipPathpara hacer el recorte:
canvas.ClipPath(Path);
Para dibujar la imagen usamos SKBitmap que pintaremos con el método DrawBitmap:
canvas.DrawBitmap(_bitmap, info.Rect);
Sencillo, ¿verdad?
Listado
Llegamos al listado. No tiene nada especialmente complejo, pero vamos a ir desglosando cada bloque. Comenzamos por la cabecera. Nos apoyamos en la propiedad Header del ListView para definir la misma:
<ListView.Header>
<templates:TaskHeaderTemplate />
</ListView.Header>
Donde TaskHeaderTemplatees un ContentViewcon la definición de la cabecera.
Cada elemento del listado es definido en el ItemTemplatedel listado:
<ListView.ItemTemplate>
<DataTemplate>
<ViewCell>
<templates:TaskItemTemplate />
</ViewCell>
</DataTemplate>
</ListView.ItemTemplate>
En la definición de cada elemento del listado tenemos una peculiaridad. En caso de reunión, mostramos las personas que asisten. Para ello, hacemos uso de BindableLayoutintroducido en Xamarin.Forms 3.5:
<StackLayout
Orientation="Horizontal"
BindableLayout.ItemsSource="{Binding People}">
<BindableLayout.ItemTemplate>
<DataTemplate>
<Grid>
<imageCircle:CircleImage
Source="{Binding Photo}"
Aspect="AspectFit"
Style="{StaticResource PhotoStyle}"/>
</Grid>
</DataTemplate>
</BindableLayout.ItemTemplate>
</StackLayout>
Pero nos sigue quedando una peculiaridad del ejemplo en el listado…
Animando cada elemento del listado
Cada vez que se añaden o quitan elementos al listado, se introducen con una breve pero efectiva animación de Fade In y translación hacia arriba.
¿Cómo lo conseguimos?
Vamos a crear una ViewCellpersonalizada. Para ellos creamos una clase que here de ViewCell y al añadir un elemento hijo:
protected override void OnChildAdded(Element child)
{
base.OnChildAdded(child);
uint duration = 750;
var animation = new Animation();
animation.WithConcurrent((f) => TaskItemTemplate.Opacity = f, 0, 1, Easing.CubicOut);
animation.WithConcurrent(
(f) => TaskItemTemplate.TranslationY = f,
TaskItemTemplate.TranslationY + 50, 0,
Easing.CubicOut, 0, 1);
TaskItemTemplate.Animate("FadeIn", animation, 16, Convert.ToUInt32(duration));
}
La definición del ItemTemplate del ListView debe cambiar a algo como:
<ListView.ItemTemplate>
<DataTemplate>
<cells:TaskItemViewCell />
</DataTemplate>
</ListView.ItemTemplate>
Voila!
Filtro circular
Y llegamos a la parte más atractiva del ejemplo.
¿Cómo conseguirla de forma sencilla?
Vamos a crear un ContentViewque contendrá primero la imagen del menu cerrado. Por otro lado, la imagen para cerrar el menu y el fondo expandido además de claro, una imagen por cada elemento del menu.
Haremos uso de GestureRecognizerspara capturar las pulsaciones en el menu o cada elemento del menú. Al pulsar haremos dos acciones.
Por un lado, lanzaremos un comando definido en el control:
public static readonly BindableProperty SelectedCommandProperty =
BindableProperty.Create("SelectedCommand", typeof(ICommand), typeof(FilterMenu), null);
public ICommand SelectedCommand
{
get { return (ICommand)GetValue(SelectedCommandProperty); }
set { SetValue(SelectedCommandProperty, value); }
}
Y por otro lado, haremos uso de animaciones!. Veamos por ejemplo, que hacemos para abrir el menu:
await InnerButtonMenu.RotateTo(360, _animationDelay); await InnerButtonMenu.FadeTo(0, _animationDelay); await InnerButtonClose.RotateTo(360, _animationDelay); await InnerButtonClose.FadeTo(1, _animationDelay); await OuterCircle.ScaleTo(3.5, 100, Easing.Linear); await N.FadeTo(1, speed); await NW.FadeTo(1, speed); await SW.FadeTo(1, speed); await S.FadeTo(1, speed);
Ocultamos con una rotación el botón (imagen) para abrir el menu. a continuación mostramos el botón de cerrar y escalamos (importante!) el area del menu. Por último, cambiamos la opacidad de cada elemento del menu.
Sencillo, pero realmente espectacular y efectivo.
Esta idea de menu esta basada en un gran ejemplo de Alan Beechque Ricardo Vasquezha elaborado más para tener un control.
El resultado conseguido:
Puedes encontrar el ejemplo en GitHub:
Hasta aquí el desglose del ejemplo. Lo terminamos sin Custom Renderers o efectos, haciendo uso de Xamarin.Forms y sus APIs para tareas complejas como el menú de filtro o el listado y apoyándonos en SkiaSharp para algunas tareas.
Cualquier duda o comentario es bienvenido en los comentarios!
Más información
- GitHub: My Task
Introducción
El evento
Introducción
