[Microsoft Tech Summit] Taller Xamarin

Introducción

Si para el próximo 06 de Octubre en el Microsoft Tech Summit tenías dudas de como organizarte con los 9 tracks de charlas, las posibilidades de networking o  entre los stands de patrocinadores, ¿y si lo complicamos todo un poco más?.

Tendremos un “décimo” track con talleres de desarrollo donde se puede encontrar un taller de desarrollo de aplicaciones móviles nativas multiplataforma con Xamarin.

Taller Xamarin
Taller Xamarin

Taller Xamarin

En el taller, veremos como crear una aplicación móvil multiplataforma para iOS, Android y Windows con Xamarin.Forms. En este taller organizado en diferentes bloques, vamos a crear una aplicación desde cero, conoceremos todos los conceptos básicos, aplicaremos MVVM y terminaremos conectando la misma con la nube.

Recuerda, es necesario que cumplas con un par de sencillos requisitos:

  • Portátil con Visual Studio y Xamarin instalado (la versión Community es suficiente).
  • Tener preparados emuladores, o algún dispositivo para hacer pruebas.

Además de desarrollar y mostrar la aplicación paso a paso en directo, la ayuda está garantizada, Josué Yeray, Rafael Serna, Marcos Cobeña y un servidor estaremos preparados para resolver cualquier duda que pueda surgir. Prepara tu equipo con Visual Studio y acércate al taller.

No te lo pierdas!

Más información

Xbox One

[Tips and Tricks] Habilitar PlayReady en aplicación UWP para Xbox One

Introducción

Windows 10 ha llegado como la culminación en el viaje hacia la convergencia en el desarrollo entre plataformas Windows. Ahora hablamos de Apps Universales escritas una única vez con un código común tanto para la lógica de negocio como para la interfaz de usuario. Además, generamos un único paquete que mantendrá una interfaz consistente y familiar para el usuario pero adaptada a cada plataforma.

Podemos crear apps que funcionen en todo tipo de dispositivos como teléfonos, tabletas, portátiles, dispositivos IoT, Surface Hub e incluso Xbox One. Para ello tenemos las vías utilizadas hasta este momento, es decir, utilizando C# y XAML (o VB, C++, etc).

Ahora con la posibilidad no solo de desarrollar aplicaciones UWP para Xbox One sino además con la posibilidad de publicar la misma en la tienda, se convierte en una nueva vía llena de posibilidades.

Entre el conjunto de aplicaciones de interés para la plataforma, existen algunas categorías con especial peso como por ejemplo, las aplicaciones multimedia. Contenido en directo, bajo demanda o compartir contenido multimedia a nivel social son opciones habituales hoy día y con gran interés en una Xbox One conectada a una gran pantalla.

Te lanzas manos a la obra, con contenido adaptativo PlayReady utilizando un MediaElement y Microsoft Universal Smooth Streaming Client SDK, todo funciona correctamente pero a la hora de reproducir en la Xbox One…

MEDIA_ERR_SRC_NOT_SUPPORTED – 0x80070005

¿Qué ocurre?.

La clave, entrada en el archivo de manifiesto

Tranquilo, no estas haciendo nada incorrecto, para reproducir contenido PlayReady DRM en una aplicación UWP en Xbox One se requiere una DeviceCapability específica en el manifiesto.

Haz clic derecho sobre el archivo Package.appxmanifiest. Selecciona la opción abrir con editor XML. Dentro del conjunto de Capabilities debes añadir:

<Capabilities>
    <DeviceCapability Name="6a7e5907-885c-4bcb-b40a-073c067bd3d5" />
</Capabilities>

Y todo listo!.

Más información

Monkeys

[Curso CampusMVP] Desarrollo de aplicaciones móviles nativas multiplataforma con C# y Xamarin

Introducción

No hay duda, los smartphones y tabletas han llegado, y ya forman parte de la vida de todos nosotros. En muchos aspectos de nuestra vida accedemos a información, realizamos algna tarea o sencillamente nos entretenemos con uno de ellos.

Esto también nos afecta como desarrolladores. El desarrollo móvil se ha convertido en una prioridad en una gran mayoria de ámbitos.

Actualmente contamos con varias plataformas dominantes:

  • iOS
  • Android
  • Windows

El mercado móvil actual

Esto a nivel de desarrollo nos supone barreras. Contamos con múltiples plataformas de desarrollo diferentes, lenguajes diferentes, etc. suponiendo un nivel de aprendizaje y esfuerzo cada vez mayor de cara a desarrolladores. Además, la experiencia nos ha demostrado que los usuarios no aceptan aplicaciones no nativas. Buscan aplicaciones rápidas, fluidas y con consumos moderados perfectamente adaptadas a la plataforma, ofreciendo una experiencia completa.

¿Qué podemos hacer para mejorar este panorama?

Xamarin

Aquí es donde entran en juego las tecnologías multiplataforma. En estos últimos años han aparecido diversas tecnologías que permiten aprovechar una base de código en multiples plataformas. Entre diversas opciones brilla con especial fuerza, por diferentes motivos (evolución, comunidad, apoyo de Microsoft) Xamarin.

Xamarin es una plataforma de desarrollo gratuita de Microsoft que permite crear nuestras aplicaciones móviles una sola vez y que funcionen en Android, iOS y Windows entre otros sistemas (Windows 10, Mac, wearables…).

Las apps que creamos con Xamarin son aplicaciones nativas, es decir, no tienen diferencias con las que podríamos crear usando las herramientas propias de cada plataforma.

xamarinmonkeysCurso completo Xamarin en CampusMVP

Tras diferentes proyectos o eventos relacionados con Xamarin donde he podido aprender y compartir con toda la comunidad, ¿algo mejor que abordar todo lo posible en un curso completo?. Así nace el curso de desarrollo de aplicaciones móviles nativas multiplataforma con C# y Xamarin en CampusMVP.

El curso, organizado en diferentes módulos comienza realizando una introducción al desarrollo Xamarin, desde la instalación y requisitos iniciales a la primera aplicación. Continua con todos los conceptos básicos de interfaces de usuario tanto nativas como con Xamarin.Forms. Se realiza una parada obligatorio en el repaso de conceptos como los principios SOLID para acabar implementando el patrón MVVM desde cero y conocer MVVMCross. Tras todo este bloque de conceptos básicos profundizamos más con controles más pesados y complejos (listados o Custom Renders en Xamarin.Forms), navegación o el acceso a la plataforma (creación de servicios, controles personalizados, sensores, uso de bases de datos, etc.). Cerramos con la publicación de aplicaciones en las diferentes tiendas no sin antes conocer como crear pruebas unitarias, Xamarin.UITest y el uso de Test Cloud por ejemplo.

Estamos ante un curso que cubre tanto Xamarin.Classic como Xamarin.Forms (iOS, Android y Windows), con más de 200 lecciones, 60 videos, decenas de ejemplos, pruebas y tests, etc. Por si fuese poco, en el último de los módulos se desarrolla desde cero una aplicación real completa para iOS y Android, que repasa la mayor parte de las técnicas y conceptos vistos en el resto del curso: patrones de navegación, animaciones en Xamarin.Forms, uso de servicios REST, RSS, SQLite, MVVM, IoC…

Si te resulta interesante, puedes acceder a más información en el siguiente enlace. Espero sin duda que ayude a crecer la comunidad de desarrolladores Xamarin. Estoy deseando ver vuestras aplicaciones!

Como de costumbre, si tienes dudas o sugerencias relacionadas con la entrada, no dudes en usar los comentarios.

Más información

[Mesa redonda CartujaDotNet] ¿Cómo ser mas productivo?, GTD vs Uberman

Introducción

La productividad es un área de estudio por diversos tipos de expertos desde hace muchos años y está muy ligada a la gestión del tiempo de un profesional en su puesto de trabajo.

Ya no se trata de trabajar más rápido y hacer más en menos, sino de aumentar nuestra productividad.

Gettings Things Done o más conocido como GTD, es un método de productividad creado por David Allen basado en concentrar la mente en realizar tareas pendientes guardadas previamente, evitando la necesidad de recordar lo que hay que hacer. Es una forma potente de almacenar tareas, hacer seguimiento y revisión.

GTD
GTD

Por otro lado, el método Uberman de sueño polifásico propone manipular los distintos estados de sueño para conseguir que el cuerpo utilice directamente los estados MOR (Movimientos Oculares Rápidos) o REM (Rapid Eye Movements). Pasamos por varias estapas de sueño siendo la REM aquella en la que la mente descansa y soñamos. El objetivo final es dormir 20 minutos cada 4 horas entrando directamente en fase REM consiguiendo el descanso necesario con muchas menos horas de sueño.

Uberman
Uberman

Dos propuestas conocidas y extendidas con puntos de vista muy diferentes. Por un lado se busca la priorización y orden para ganar concentración, por otro lado, se busca menor cantidad de horas de sueño o lo que es lo mismo, una cantidad de horas productivas más elevada.

Mesa redonda

Desde CartujaDotNet y ante interesantes conversaciones en nuestras quedadas (te recomendamos asistir!) hemos decidido organizar una interesante mesa redonda. Entre todos y con la ayuda de Juan María Lao, quien aplica diariamente GTD y David R. Noguera, que lleva a cabo Uberman, tratemos ambas propuestas y hablemos de métodos de productividad para sacar sin duda interesantes conclusiones entre todos.

¿Te esperamos?

Más información

DevDays-1024x339

[Material] Xamarin Dev Days Sevilla

El evento

El pasado sábado 10 de Septiembre, tenía lugar en Sevilla el Xamarin Dev Days. Una jornada con varias sesiones técnicas, taller, regalos y mucho networking.

highres_454015178

El resultado fue un fantástico día de desarrollo Xamarin con la asistencia de todos los asistentes registrados, con muchas preguntas, ayuda y tiempo para charlar entre todos rodeados de un café o unas pizzas.

El material

Pude participar en el evento con una de las sesiones. Nos centramos en el desarrollo de aplicaciones móviles multiplataforma utilizando Xamarin.Forms:

Comenzamos por una introducción de conceptos básicos, primera demo aplicando MVVM y terminamos repasando todas las últimas novedades como DataPages, Native Embedding o la creación de de efectos.

En cuanto a las demos técnicas realizadas, las tenéis disponible en GitHub:

Ver GitHub

Quisiera terminar añadiendo algunos agradecimientos. Comienzo por los chicos de WorkINCompany por las instalaciones y toda la ayuda; a Plain Concepts y DevsDNA por su patrocinio y permitir contar con la sala y comida para los asistentes (muchas gracias); a SyncFusion y Xamarin también por patrocinar el evento, los asistentes quedaron encantados con los goodies y licencias; a mis compañeros Josué Yeray y Marcos Cobeña por sus demos y ayudar con todo y por supuesto a los asistentes. Gracias a todos, no es muy habitual que todos y cada uno de los registrados asistan. Si además están todo el día y con preguntas constantes, hace que todo sea tan apasionante y divertido que…¿cuándo la próxima?.

Más información

[Material] React Native vs Xamarin

El evento

El pasado 08 de Septiembre, desde Lemoncode, se organizaba un evento centrado en desarrollo móvil multiplataforma, realizando una comparativa de dos de las opciones más uitlizadas actualmente, Xamarin y React.

Xamarin VS React
Xamarin VS React

Un servidor junto a mi compañero en Plain Concepts, Carlos Fernández, realizamos una comparativa de ambas opciones donde vimos:

  • Introducción. Análisis de aporte, funcionamiento y demos básicas.
  • Código!. Comparamos el desarrollo de una aplicación haciendo uso de servicio REST, mapas, la cámara, etc.
  • Otras opciones. Herramientas extras, estado y madurez, etc.

El material

En mi parte me centré en el desarrollo Xamarin, viendo desde una introducción inicial hasta el desarrolo de una aplicación completa. La presentación la tenéis disponible a continuación:

Toda la sesión fue grabada y podéis acceder a la misma en cualquier momento:

En cuanto a las demos técnicas realizadas, las tenéis disponible en GitHub:

Ver GitHub

Quisiera terminar añadiendo algunos agradecimientos. Gracias a todos los asistentes por asistir además de la constante participación con preguntas, gracias a Braulio Diez y los chicos de Lemoncode por toda su ayuda y organización y a Carlos Fernández por sus demos en la parte de React. Espero que os haya gustado. Nos vemos en la próxima!

Más información

Macbook Xamarin

[Xamarin.Forms] Introducción al uso de efectos

Introducción

Xamarin.Forms añade una capa de abstracción sobre la capa de la interfaz de usuario permitiendo definir la misma una única vez siendo válida para todas las plataformas.

Xamarin.Forms
Xamarin.Forms

Cuenta con páginas, layouts y controles que son renderizados de forma diferente en cada plataforma. Se utiliza una clase Renderer distinta en cada plataforma y encargada de crear un control nativo y añadirlo en pantalla.

¿Qué es un efecto?

Un efecto permite el acceso al control nativo de cada plataforma con el objetivo de personalizarlo, principalmente aplicando pequeños cambios estéticos o de comportamiento. Permiten simplificar la personalización del control y sobretodo se convierten en “piezas” reutilizables de código incluso aceptando parametrización.

¿Por qué usar efectos y no un Custom Renderer?

Tener acceso a un control nativo, poder personalizarlo y además tenerlo todo en una pieza reutilizable está al alcance de nuestra mano gracias al uso de efectos.

¿Cuándo utilizamos entonces un Custom Renderer, y cuándo un efecto?

  • Si necesitamos crear un nuevo control o  reemplazar el control específico implementado por Xamarin.Forms de una plataforma, necesitamos un Custom Renderer.
  • Si sólo necesitamos modificar o añadir alguna propiedad que modifica la apariencia o comportamiento del control nativo implementado por Xamarin.Forms, efecto.

Crear un efecto

El proceso de creación de un efecto, se puede resumir en una serie de sencillos pasos:

  1. Crear en la PCL una clase que herede de RoutingEffect. Código independiente de la plataforma encargado de hacer el wrapping del efecto. Podemos definir distintas propiedades que permitan modificar la acción realizada por el efecto. Por ejemplo, en un efecto encargado de aplicar Blur a una imagen, se puede definir una propiedad encarga de aplicar mayor o menor distorsión.
  2. Crear clases en cada plataforma soportada que hereden de PlatformEffect.
  3. Sobrecargar el método OnAttached y añadir la lógica de personalización del control.
  4. Sobrecargar el método OnDetached y añadir lógica de liberación de recursos.
  5. Añadir el atributo ResolutionGroupName. Este atributo permite establecer el nombre del creador o compañia tras el efecto. Recuerda que uno de los objetivos fundamentales de los efectos es lograr permitir compartir y reutilizar con suma facilidad. Con este atributo se previenen colisiones con otros efectos que compartan nombre.
  6. Añadir el atributo ExportEffect. Este atributo registra el efecto con un identificador único usado por Xamarin.Forms, junto al nombre del grupo, permite localizar y aplicar el efecto.

Para comprender el proceso de creación de un efecto vamos a crear uno paso a paso. Nuestro efecto será simple, permitirá aplicar el efecto blur a una imagen.

Comenzamos en la PCL. Dentro de la carpeta Effects, creamos una clase que herede de RoutingEffect:

public class BlurredEffect : RoutingEffect
{
     public string Url { get; set; }
     public int Radius { get; set; }

     public BlurredEffect() : base("Xamarin.BlurredImageEffect")
     {

     } 
}

Además de la implementación del constructor, donde indicamos el nombre del grupo y del efecto que utilizaremos en la implementación de cada plataforma, añadimos dos propiedades:

  • Url: La Url de la imagen a la que aplicaremos el efecto.
  • Radius: Un entero que permite establecer el nivel de distorsión aplicado. A valores más altos, mayor nivel de distorsión.

Tras la creación de la “definición” de lo que será nuestro servicio, pasamos al código específico por plataforma. Se deben de crear clases que hereden de PlatformEffect:

public class BlurredImageEffect : PlatformEffect  
{

}

PlatformEffect provocará la necesidad de implementar los métodos OnAttached y OnDetached:

protected override void OnAttached() 
{

}

protected override void OnDetached()    
{
        
}

Vamos a comprender el objetivo de cada método:

  • OnAttached: Lanzado cuando un efecto se adjunta un control Xamarin.Forms. La sobrecarga de este método en cada plataforma es el lugar idóneo para añadir código específico de plataforma que afecte al control ya sea en su apariencia o en su comportamiento.
  • OnDetached: Este método se lanza cuando el efecto se quita del control Xamarin.Forms. La sobrecarga permite añadir código específico de liberación de recursos y limpieza.

Aunque no lo usamos en nuestro efecto de blur, PlatformEffect expone el método OnElementPropertyChanged. Este método se lanza cuando una propiedad del efecto cambia. Lugar idóneo para responder a cambios de la propiedades.

Implementamos el código del método OnAttached en Android:

protected override void OnAttached()
{
     try
     {
          var imageView = Control as ImageView;
          var effect = (BlurredEffect)Element.Effects.FirstOrDefault(e => e is BlurredEffect);
          if (effect != null)
          {
               var d = imageView.Drawable;
               if (d != null)
               {
                    var bitmap = GetImageBitmapFromUrl(effect.Url);

                    if (bitmap != null)
                    {
                        imageView.SetImageBitmap(CreateBlurredImage(effect.Radius, bitmap));
                        imageView.Invalidate();
                    }
                }
          }
     }   
     catch (Exception ex)
     {
          Console.WriteLine("Cannot set property on attached control. Error: ", ex.Message);
     }
}

Cada clase específica de plataforma que hereda de PlatformEffect cuenta con:

  • Control: Control nativo usado por Xamarin.Forms como implementación del control Xamarin.Forms. Por ejemplo, en Android en el caso de una Image, hablaríamos de un ImageView.
  • Element: Control Xamarin.Forms renderizado.

Analicemos el código anterior. Comienza accediendo al efecto, disponible en la colección Effects del control representado por Element.

Tras acceder al efecto, se crea un Bitmap partiendo de la Url recibida como parámetro en la propiedad Url, y se aplica el efecto Blur utilizando la imagen anterior y aplicando el grado de distorsión utilizando la propiedad Radius.

El método encargado de crear el Bitmap en base a la Url:

prprivate Bitmap GetImageBitmapFromUrl(string url)   
{            
     Bitmap imageBitmap = null;
          
     using (var webClient = new WebClient())
     {
          var imageBytes = webClient.DownloadData(url);
          if (imageBytes != null && imageBytes.Length > 0)
          {
               imageBitmap = BitmapFactory.DecodeByteArray(imageBytes, 0, imageBytes.Length);
          }
     }

     return imageBitmap;
}

Utiliza un WebClient para descargar la información de la imagen y BitmapFactory para crear el Bitmap usando los datos descargados.

El método encargado de aplicar el efecto Blur:

private Bitmap CreateBlurredImage(int radius, Bitmap originalBitmap)
{
     Bitmap blurredBitmap;
     blurredBitmap = Bitmap.CreateBitmap(originalBitmap);

     var rs = RenderScript.Create(Forms.Context);
     var input = Allocation.CreateFromBitmap(rs, originalBitmap, Allocation.MipmapControl.MipmapFull, AllocationUsage.Script);
     var output = Allocation.CreateTyped(rs, input.Type);

     var script = ScriptIntrinsicBlur.Create(rs, Android.Renderscripts.Element.U8_4(rs));
     script.SetInput(input);
     script.SetRadius(radius);
     script.ForEach(output);

     output.CopyTo(blurredBitmap);

     return blurredBitmap;
}

Basado en RenderScript para aplicar el efecto.

Nos faltaría aplicar las etiquetas que permitan establecer el nombre del grupo y la exportación del efecto:

[assembly: ResolutionGroupName("Xamarin")]
[assembly: ExportEffect(typeof(BlurredImageEffect), "BlurredImageEffect")]

De igual forma, en otras plataformas (iOS y Windows) se debe de crear la clase e implementar PlatformEffect.

Utilizar un efecto

Desde la PCL, en la vista compartida definida en XAML, para utilizar el efecto se debe utilizar el espacio de nombre donde se ha definido:

xmlns:effects="clr-namespace:BlurImageEffect.Effects"

Y utilizarlo:

<Label 
     Text="Image"/>
<Image
     Source="https://www.xamarin.com/content/images/pages/branding/assets/xamarin-logo.png"/>
<Label 
      Text="Blurred Image"/>
<Image>
     <Image.Effects>
        <effects:BlurredEffect
             Url="https://www.xamarin.com/content/images/pages/branding/assets/xamarin-logo.png"
             Radius="20"/>
     </Image.Effects>
</Image>

El efecto BlurredEfect se adjunta a la segunda imagen añadiéndolo a la colección Effects. Xamarin.Forms utilizará Effect.Resolve para devolver el efecto especificado utilizando una concatenación del nombre de grupo (ResolutionGroupName) junto a su identificador (especificado con el atributo ExportEffect).

El resultado:

BlurredImageEffect
BlurredImageEffect

Tenéis el código fuente del ejemplo utilizado disponible en GitHub:

Ver GitHub

Recuerda, cualquier tipo de duda o sugerencia es bienvenida en los comentario del artículo.

Más información

Windows 10 Anniversary Update

[Windows 10 Anniversary Update] Novedades en x:Bind, bindings compilados

Link - 05Introducción

Data binding es un mecanismo mediante el cual podemos enlazar los elementos de la interfaz de usuario con los objetos que contienen la información a mostrar. Cuando realizamos data binding, creamos una dependencia entre el valor de una propiedad llamada target con el valor de otra propiedad llamada source. Donde normalmente, la propiedad target recibirá el valor de la propiedad source.

Es el mecanismo base que nos permite utilizar el patrón MVVM en nuestras Apps móviles logrando:

  • Nos permite dividir el trabajo de manera muy sencilla (diseñadores – desarrolladores)
  • El mantenimiento es más sencillo.
  • Permite realizar Test a nuestro código.
  • Permite una más fácil reutilización de código.

Sin embargo, además de toda la potencia mencionada teníamos ciertas limitaciones. Los errores de Binding no se producían en tiempo de compilación de la App además de tener diferentes mejoras relacionadas con el rendimiento. Limitaciones existentes hasta ahora…

Con la llegada de Windows 10 nos llegaba la posibilidad de crear bindings compilados en lugar de los bindings clásicos. Ya vimos previamente su uso, pros y contras en este artículo. Ahora, con la llegada del Anniversary Update nos llegan una gran cantidad de novedades relacionadas con el desarrollo que iremos desgranando poco a poco, entre las que se incluyen novedades en x:Bind.

¿En qué consisten?, ¿qué aportan?

En este artículo vamos a centrarnos en el conjunto de novedades incluidas en el sistema de enlace a datos compilados en la actualización Anniversary Update.

Enlace a métodos

Previamente, desde la versión 1607 de Windows, {x:Bind} soportaba un evento como parte del enlace a datos.

Veamos un ejemplo. Vamos a crear una interfaz mostrando un listado de casas. La colección de casas:

private ObservableCollection<House> _houses;
 
public ObservableCollection<House> Houses
{
     get
     {
          if (_houses == null)
               LoadHouses();
 
          return _houses;
     }
}

Que cargaremos con sencillos datos locales:

private void LoadHouses()
{
     _houses = new ObservableCollection<House>();
 
     _houses.Add(new House
     {
          Name = "Home 1"
     });
     _houses.Add(new House
     {
          Name = "Home 2"
     });
}

La interfaz de usuario, un control ListView enlazado con un enlace compilado a la colección:

<ListView
     ItemsSource="{x:Bind Houses}"
     ItemTemplate="{StaticResource HouseDataTemplate}" />

En cuanto a la plantilla que define cada elemento del listado:

<DataTemplate
     x:Key="HouseDataTemplate"
     x:DataType="model:House">
     <Grid>
          <Grid.ColumnDefinitions>
               <ColumnDefinition Width="Auto" />
               <ColumnDefinition Width="*" />
          </Grid.ColumnDefinitions>
          <TextBlock 
               Text="{x:Bind Name}"
               x:Phase="1"
               VerticalAlignment="Center" />
          <Button 
               Grid.Column="1"
               Content="Click me!"
               Click="{x:Bind Click}" />
     </Grid>
</DataTemplate

Se utiliza x:Bind para enlazar las propiedades, estableciendo el tipo de los datos a enlazar mediante la propiedad x:DataType.

NOTA: Recuerda que x:Bind está fuertemente tipado.

¿Ves algo “raro”?. El botón incluido dentro de la plantilla enlaza el evento Click a “algo” llamado Click.

Hasta ahora no habíamos visto la definición de la entidad House:

public class House
{ 
     public string Name { get; set; }
 
     public void Click(object sender, RoutedEventArgs e)
     {
          Debug.WriteLine(string.Format("Clicked {0}!", Name));
     }
}

Ahora probablemente has deducido que ocurre. Se pueden realizar enlace a datos directamente a eventos. Se necesita en el evento:

  • No tener parámetros. Ejemplo void Click().
  • Coincidir los parámetros con los parámetros del evento. Ejemplo: void Click(object sender, RoutedEventArgs e).
  • O coincidir con los tipos base de los parámetros del evento. Ejemplo: void Click(object sender, object e).

Al pulsar el botón de cada plantilla, se desencadena el evento Click que tenemos disponible en la entidad.

El resultado:

Event Bindings
Event Bindings

Ahora, tras la actualización Anniversary Update, se da un paso más permitiendo enlazar con cualquier método sin necesidad de un converter. Las únicas condiciones que debe complir el método es que sea público y en caso de tener parámetros, facilitarlos. Una forma de:

  • Obtener conversión de valores avanzada.
  • Tener un enlace a datos que dependa de más de un parámetro.

Veamos un ejemplo. En algunos formularios donde hay contraseñas involucradas se ofrece feedback visual de la seguridad de la contraseña introducida. Vamos a mostrar una barra de color rojo, naranja o rojo dependiendo de la seguridad.

Tendremos una propiedad donde se enlazará la contraseña:

public string UserPassword { get; set; }

En la UI:

<ProgressBar 
     Background="Transparent"
     Foreground="{x:Bind PasswordStrengthBrush(Password.Password), Mode=OneWay}"
     Value="{x:Bind PasswordStrengthValue(Password.Password), Mode=OneWay}"
     Height="3"/>
<PasswordBox 
     x:Name="Password"
     PlaceholderText="Insert Password"      
     Password="{x:Bind UserPassword, Mode=TwoWay}" />

Un control PasswordBox encargado de capturar la contraseña (utilizando x:Bind), y en la parte superior un ProgressBar que mostrará más o menos recorrido y distintos colores dependiendo de la seguridad de la contraseña introducida.

Fíjate en el enlace a datos de Foreground y Value del PasswordBox. ¿Qué está pasando?.

Para modificar el color se enlaza a un método público llamado PasswordStrengthBrush que recibe como parámetro la contraseña (directamente accediendo a la propiedad Password del PasswordBox!).

En cuanto al valor, de nuevo, se hace un enlace a un método público llamado PasswordStrengthValue recibiendo como parámetro de nuevo la contraseña.

El primero de los métodos:

public SolidColorBrush PasswordStrengthBrush(string password)
{
     if (string.IsNullOrEmpty(password))
          return new SolidColorBrush(Colors.Transparent);
 
     int length = password.Length;
 
     if (length >= 3 && length < 6)
          return new SolidColorBrush(Colors.Orange);
     if (length >= 6)
          return new SolidColorBrush(Colors.Green);
 
     return new SolidColorBrush(Colors.Red);
}

Si la longitud de la contraseña es inferior a tres carácteres, se devuelve color rojo, si es ingerior a seis carácteres, color naranja, devolviendo color verde en caso de que la longitud de la contraseña sea superior a seis carácteres.

El segundo de los métodos:

public double PasswordStrengthValue(string password)
{
     if (string.IsNullOrEmpty(password))
          return 0;
 
     int length = password.Length;
 
     if (length >= 3 && length < 6)
          return 66;
     if (length >= 6)
          return 100;
 
     return 33;
}

Aumentará el progreso de la barra de progreso en base a la longitud de la contraseña.

El resultado:

Function Bindings
Function Bindings

En un escenario donde se necesite un enlace a datos en modo two-way, se debe tener un segundo método encargado de hacer la operación inversa. Esto se consigue utilizando la propiedad BindBack.

Conversiones implícitas

x:Bind añade soporte a conversiones implícitas de algunos tipos.

¿Cuántas veces has creado un BoolToVisibilityConverter o similar (inverso, con opacidad, etc.)?.

Ya no sería necesario!. Podemos tener propiedades de tipo bool:

public bool IsVisible { get; set; }
public bool IsNotVisible { get; set; }

Donde una es cierta y otra falsa:

IsVisible = true;
IsNotVisible = false;

Al enlazar desde la UI:

<TextBlock 
     Text="Visible"
     Visibility="{x:Bind IsVisible}"/>
<TextBlock 
     Text="No Visible"
     Visibility="{x:Bind IsNotVisible}"/>

Podemos enlazar la propiedad Visibility directamente con bindings compilados a las propiedades de tipo bool.

¿El resultado?

Conversiones implícitas
Conversiones implícitas

El esperado, se muestra el elemento visual enlazada la propiedad verdadera. Se realiza la conversión implícita de un tipo a otro.

Castings de valor explícito soportados

Al contrario que el sistema de enlace a datos clásico que hace uso de duck typing, validación semántica, para validar el enlace, los bindings compilados verifican en tiempo de compilación que los tipos de los datos proporcionados coinciden. O lo que es lo mismo, si el valor que se estan tratando de enlazar no tiene un casting implícito al tipo de la propiedad, no se puede realizar el enlace sin un converter.

Eso era hasta ahora. Al más puro estilo C#, podemos declarar casting explícitos en un binding compilado.

Si tenemos una propiedad de tipo object:

public object Element { get; set; }

Si al crear la instancia, se crea utilizando un tipo específico (en nuestro ejemplo se utilizan tipos básicos para simplificar el ejemplo, object y TextBlock):

Element = new TextBlock
{
     Text = "Cool"
};

En la UI:

<TextBlock 
     Text="{x:Bind ((TextBlock)Element).Text}"/>

El resultado:

Casting explícito
Casting explícito

Se hace el casting al tipo TextBlock y podemos acceder a sus propiedades, enlazamos al texto.

Tenéis el código fuente del ejemplo utilizado disponible en GitHub:

Ver GitHub

Interesantes novedades, algunas de ellas muy solicitadas. También se han añadido otro tipo de actualizaciones menores como el soporte a más tipos de datos, por ejemplo, acceder a un índice específico de un diccionario clave-valor. Sin embargo, nos hemos concentrado en las que mayor impacto directo pueden tener en el desarrollo del día a día.

Y a ti, ¿qué te parecen?, ¿cúal es tu novedad favorita?, ¿qué te gustaría que se añadiese?.

Más información

[Evento SVQXDG] Xamarin Dev Days en Sevilla!

XamarinEl evento

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.

Xamarin Dev Days
Xamarin Dev Days

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. Por Josué Yeray.

• 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, DataPages, Themes o Native Embedding. Por Javier Suárez.

• 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. Por Marcos Cobeña.

• 12:00 – 2:00PM Hands on Lab. ¿Crear una aplicación Xamarin paso a paso con MVVM, uso de servicios web 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.

• 3:00 – 4:00PM Hands on Lab.

El lugar

El evento se celebrará en el WorkINCompany. Dirección detallada:

Calle Rioja 13, 1º C, Sevilla

WorkINCompany
WorkINCompany

La fecha

El evento tendrá lugar el próximo Sábado, 10 de Septiembre de 9:00h a 16:00h. Tendremos tres sesiones técnicas de  40 minutos de duración cada una junto a un taller de 3 horas de duración. Además contaremos con regalos y sorpresas.

¿Te apuntas?

Más información

[Material XDev Madrid] WinObjc: De iOS a Windows y extendiendo Xamarin.Forms

El evento

El pasado 09 de Agosto, desde el grupo XDev en Madrid, se organizaba un evento veraniego centrado en desarrollo móvil multiplataforma, con temas como convertir aplicaciones de iOS a UWP o extender Xamarin.Forms, además de tener momentos para el networking y algun que otro detalle con los asistentes.

El material

Pude participar en el evento con dos sesiones.

En la primera de ellos, nos centramos en el Windows Bridge para iOS, WinObjC. Convertimos algunas aplicaciones iOS a UWP e incluso vimos como añadir características específicas de la plataforma Windows como el uso de Live Tiles.

En la segunda sesión, nos centramos en como extender Xamarin.Forms para poder acceder a características específicas de cada plataforma, crear nuevos controles o efectos con el objetivo de ofrecer la mejor experiencia posible en cada plataforma, aun compartiendo gran parte de la interfaz de usuario.

En cuanto a las demos técnicas realizadas, las tenéis disponible en GitHub:

Ver GitHub

Quisiera terminar añadiendo algunos agradecimientos. Gracias a todos los asistentes por asistir además de la constante participación con preguntas, en estas fechas y con tan poca antelación en el anuncio del evento es destacable; gracias a Dachi Gogotchuri por toda la ayuda en la organización y gracias a Liferay por sus increíbles instalaciones cediéndonos una sala. Nos vemos en la próxima!

Más información