Introducción
Cuando tratamos el desarrollo de aplicaciones Xamarin hay algunas preguntas importantes a resolver. Entre ellas, destaca con fuerza, ¿Xamarin Classic o Xamarin.Forms?. Es una pregunta habitual en diferentes charlas de diferentes temáticas, en formación y a la hora de afrontar un nuevo proyecto. La respuesta suele requerir algo de tiempo para analizar muchos aspectos como la interfaz de la aplicación, conocimiento del equipo, etc. Pero…¿y si nos quedamos con las dos opciones?.
¿Qué es Forms Embedding?
Con Xamarin.Forms podemos acceder a cualquier API nativa, podemos crear nuevos controles y acceder a la plataforma con Custom Renders o efectos e incluso podemos incrustar controles nativos con Native Views. Forms Embedding es el nombre asignado a la posibilidad de incrustar cualquier ContentPage de Xamarin.Forms en una aplicación nativa de Android, iOS o Windows.
Forms Embedding
Estará disponible entre el conjunto de novedades de la próxima versión 3.0 de Xamarin.Forms:
- Mejoras en rendimiento (Fast Renderers y Layout Compression).
- Nuevas plataformas (GTK#, WPF o MacOS).
- Native Embedding.
- XAML Standard.
- Etc.
Suena interesante, ¿verdad?. Aquellos desarrollos utilizando Xamarin Classic (también llamado Native) se pueden beneficiar de Xamarin.Forms para compartir vistas comunes. Podemos combinar lo mejor de las dos opciones!
Haciendo Forms Embedding ahora
A pesar de llegar como opción en Xamarin.Forms 3.0, podemos hacer Forms Embedding ahora mismo. Sólo necesitamos un poco más de código. Veamos como hacerlo!
Creamos una aplicación Xamarin Classic utilizando una PCL y la plantilla Maestro y detalle:
Nueva App
Gracias a la plantilla tenemos rápidamente una aplicación Xamarin Classic completa:
Plantilla Maestro y detalle
Añadimos un nuevo proyecto, una librería portable (PCL) donde vamos a añadir las vistas Xamarin.Forms totalmente compartidas entre todas las plataformas.
PCL
Un ejemplo muy común de vista que suele tener mucho sentido tener totalmente compartida, es una vista de configuración. Añadimos una nueva ContentPage llamada SettingsView:
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="FormsEmbedding.Forms.Views.SettingsView">
<ContentPage.Content>
<StackLayout>
<Label Text="Welcome to Xamarin Forms Settings!" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition />
<ColumnDefinition />
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<Label Grid.Column="0" Grid.Row="0" Text="Settings 1" />
<Switch Grid.Column="1" Grid.Row="0" HorizontalOptions="End" />
<Label Grid.Column="0" Grid.Row="1" Text="Settings 2" />
<Switch Grid.Column="1" Grid.Row="1" HorizontalOptions="End" />
<Label Grid.Column="0" Grid.Row="2" Text="Settings 3" />
<Switch Grid.Column="1" Grid.Row="2" HorizontalOptions="End" />
<Label Grid.Column="0" Grid.Row="3" Text="Settings 4" />
<Switch Grid.Column="1" Grid.Row="3" HorizontalOptions="End" />
<Label Grid.Column="0" Grid.Row="4" Text="Settings 5" />
<Switch Grid.Column="1" Grid.Row="4" HorizontalOptions="End" />
</Grid>
</StackLayout>
</ContentPage.Content>
</ContentPage>
El resultado:
SettingsView
¿Cómo utilizamos esta página desde Android, iOS y Windows?. Lo primero es crear una aplicación Application de tipo Xamarin.Forms.
public class FormsApp : Application
{
public FormsApp(Type page = null)
{
SetMainPage(page);
}
public void SetPage(Type page)
{
if (page == null)
{
MainPage = new ContentPage();
return;
}
MainPage = (Page)Activator.CreateInstance(page);
}
public static Page GetPage<T>() where T : Page
{
return Activator.CreateInstance<T>();
}
}
Establecemos como MainPage la página pasada como parámetro.
Android
Xamarin.Forms utiliza una actividad de tipo FormsAppCompatActivity donde se realiza la inicialización de Xamarin.Forms y se realiza la carga de la App. Vamos a crear una actividad nueva donde realizar la inicialización requerida de Forms así como, recibir la vista Xamarin.Forms a mostrar y cargarla en la App.
public class FormsActivity : FormsAppCompatActivity
{
public static bool IsFormsInitialized;
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
var view = Intent.Extras.GetString("View");
var viewPath = typeof(FormsApp).Namespace + ".Views." + view;
var viewType = typeof(FormsApp).Assembly.GetType(viewPath);
if (!IsFormsInitialized)
{
global::Xamarin.Forms.Forms.Init(this, bundle);
IsFormsInitialized = true;
}
LoadApplication(new FormsApp(viewType));
}
}
Fíjate que esperamos un parámetro View donde tenemos el nombre de la página Xamarin.Forms a mostrar. Partiendo del nombre, obtenemos el tipo de la página y realizamos la inicialización.
Con todo esto, posiblemente tengas ya en mente como vamos a realizar la navegación a la página de Xamarin.Forms:
var intent = new Intent(this, typeof(FormsActivity));
intent.PutExtra("View", "SettingsView");
StartActivity(intent);
Navegamos a una nueva actividad, nuestra actividad FormsActivity, pasandole como parámetro la página Xamarin.Forms a mostrar.
El resultado:
Android
iOS
En el caso de iOS nuestro objetivo será tener un UIViewController al que poder navegar partiendo de la ContentPage de Xamarin.Forms:
var settingsViewControler = FormsApp.GetPage<SettingsView>().CreateViewController();
await PresentViewControllerAsync(settingsViewControler, true);
En Xamarin.Forms contamos con una extensión de páginas que cuenta con el método CreateViewController que nos hace la mayor parte del trabajo. Obtenemos la página de Forms, convertimos a UIViewController y navegamos!
iOS
Windows
Llegamos a UWP. En este caso, Xamarin.Forms, utiliza una vista nativa de tipo FormsWindowsPage donde se realiza la carga de la App. Creamos en el proyecto UWP una nueva página nativa:
<forms:WindowsPage
x:Class="FormsEmbedding.UWP.Pages.FormsWindowsPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:FormsEmbedding.UWP.Pages"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:forms="using:Xamarin.Forms.Platform.UWP"
mc:Ignorable="d">
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
</Grid>
</forms:WindowsPage>
Reemplazamos el tipo de Page a FormsWindowsPage utilizando el namespaces correspondiente. En el código asociado de la página realizaremos dos acciones necesarias (como ya hicimos en otras plataformas). Por un lado, inicializaremos la aplicación Xamarin.Forms:
var formsApp = new FormsApp()
LoadApplication(formsApp);
Y por otro lado, estableceremos la página principal:
_formsApp.SetPage(e.Parameter as Type);
Con todo preparado, para navegar a una página de Xamarin.Forms bastaría con:
Frame.Navigate(typeof(FormsWindowsPage), typeof(SettingsView));
Navegar a la nueva página creada pasando como parámetro el tipo de la página de Forms. También podríamos pasar el nombre de la página como cadena y tras recuperarlo obtener el tipo como hicimos en Android.
El resultado:
UWP
NOTA: En todos los proyectos nativos hemos añadido la última versión del paquete estable de Xamarin.Forms.
El ejemplo de esta versión se encuentra disponible en GitHub:
Xamarin.Forms 3.0
Hoy día ya podemos probar una versión Preview de Xamarin.Forms 3.0. Para ello, debemos añadir https://www.myget.org/F/xamarinforms-dev/api/v3/index.json como nuevo origen de paquetes.
Nuevo origen de paquetes
De esta forma tendrás acceso a los paquetes previos de Xamarin.Forms 3.0:
Paquetes NuGet Xamarin.Forms 3.0
Con el paquete previo de la versión 3.0 nos llega el soporte oficial a Forms Embedding o lo que es lo mismo, todo lo necesario para incrustar páginas Xamarin.Forms en aplicaciones nativas de forma rápida y muy sencilla.
Volvemos a crear un nuevo proyecto en una PCL donde vamos a añadir las páginas Xamarin.Forms a compartir, de igual forma a como hicimos previamente.
Veamos como utilizar la página en cada plataforma.
Android
En Android se ha añadido una extensión de página de modo que podemos hacer:
var settings = new SettingsView().CreateFragment(this);
Creamos una instancia de la página Xamarin.Forms y utilizamos el método CreateFragment para crear un Fragment Android que podemos añadir como contenido de nuestra aplicación Xamarin.Android.
iOS
En el caso de iOS nuestro objetivo será tener un UIViewController al que poder navegar partiendo de la ContentPage de Xamarin.Forms:
var settingsViewControler = FormsApp.GetPage<SettingsView>().CreateViewController();
await PresentViewControllerAsync(settingsViewControler, true);
En Xamarin.Forms contamos con una extensión de páginas que cuenta con el método CreateViewController que nos hace la mayor parte del trabajo. Si, es sumamente parecido a lo que ya vimos previamente.
Windows
Y llegamos a UWP donde al igual que en el resto de plataformas, se utiliza una extensión de página para obtener un FrameworkElement a partir de la página Xamarin.Forms.
var settingsView = new SettingsView().CreateFrameworkElement();
Muy muy sencillo, ¿cierto?.
El ejemplo de esta versión se encuentra disponible en GitHub:
Más información
El evento
Introducción
Introducción
Introducción
Introducción
El evento
Introducción
Introducción
