[Tips and Tricks] Añadir Intellisense a Xamarin.Forms

Introducción

Junto a la versión 3 de Xamarin nos llegaba Xamarin.Forms, un toolkit para crear 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). Un framework bastante versátil y con una evolución constante. Sin embargo, aun no contamos con ciertos aspectos importantes en el desarrollo como por ejemplo Intellisense.

Intellisense nos facilita la tarea con autocompletado además de otorgarnos de manera muy sencilla acceso a documentación.

Añadir Intellisense a Xamarin.Forms

Mobile Essentials Gallery Beta nos permite añadir extensiones para
Visual Studio con herramientas para el desarrollo de aplicaciones
móviles con Xamarin. De momento cuentan con una extensión para añadir Intellisense en Xamarin.Forms y en esta entrada vamos a ver como obtenerlo.

¿Te apuntas?

Comenzamos obteniendo la extensión. Desde Visual Studio nos dirigimos a la opción de menu Herramientas | Opciones. Nos aparecerá un modal donde elegiremos la opción Extensiones y actualizaciones dentro del desplegable Entorno.

Añadimos una nueva extensión:

Utilizamos la siguiente URL:

http://gallery.mobileessentials.org/feed.atom

Una vez añadida nos dirigimos al menu Herramientas | Extensiones y actualizaciones:

En el modal nos aparecerá una nueva opción Mobile Essentials dentro de la categoría En línea. Desde aqui podemos instalar la extensión:

Una vez instalada, utilizando un proyecto Xamarin.Forms…

Más información

[Universal App] Roaming Settings, compartiendo datos entre plataformas

Introducción

Algo muy habitual en cualquier tipo de aplicación móvil es trabajar
con distntos tipos de datos, datos locales de la aplicación, archivos de
configuración, etc. Segun el tipo de dato debemos proporcionar un
tratamiento diferente pero siempre buscando facilitar el uso de la
aplicación por parte del usuario.

Ante un mundo lleno de múltiples dispositivos para distintas
situaciones (PCs, Tablets, móviles, Bands, etc.) es cada vez más
habitual que un mismo usuario se instale la misma aplicación en
diferentes dispositivos. Ante este tipo de situación el usuario espera
que los datos básicos y de configuración se mantengan sincronizados y no tener que establecer su configuración básica una y otra vez.

¿Cómo lo conseguimos?

Almacenamiento de datos de aplicación

Tanto en aplicaciones Silverlight 8.1 como en aplicaciones Windows XAML tenemos disponible las siguientes carpetas:

  • LocalFolder:
    Un viejo conocido. Ya lo teníamos disponible en Windows Phone 8 e
    incluso era la carpeta usada como Isolated Storage desde Windows Phone
    7. Guardaremos información que persiste entre actualizaciones de la
    aplicación y entra dentro de los datos guardados al realizar un backup
    del sistema.
  • RoamingFolder:
    Almacenamiento muy útil. Al guardar datos en RoamingData, la
    información estará disponible en todos los dispositivos donde la
    aplicación este instalada (con el mismo id). Ideal para guardar la
    configuración de la aplicación y mantenerla sincronizada entre la
    aplicación Windows Phone y la Windows Store por ejemplo.
  • TemporaryFolder:
    Aqui guardaremos información sin tener la necesidad de borrarla más
    tarde. La información se guardará entre las distintas sesiones pero
    cuando el sistema requiera espacio (Ejemplo: poca memoria disponible),
    eliminará la información.  Es un lugar idóneo donde guardar datos
    obtenidos de peticiones web, servicios o imágenes por ejemplo.

Roaming Data

Si un usuario obtiene la aplicación en múltiples dispositivos,
Windows y Windows Phone, es fantástico para el que la configuración de
la misma se comparta. De modo que, cualquier cambio realizado en la
configuración de la Aplicación uno de los dispositivos se vea reflejado
en el otro. Esto lo podemos conseguir utilizando Roaming Data entre aplicaciones Windows Phone 8.1 y Windows 8.1 que compartan el mismo PFN (Package Family Name).

El Roaming de datos nos proporciona una forma de
compartir y sincronizar datos entre distintos dispositivos físicos de
manera sencilla.

NOTA: Si publicamos dos versiones de la misma
aplicación (una para la Windows Store y otra para la Windows Phone
Store) podemos compartir configuración e información utilizando el mismo
PFN en cada aplicación.

Utilizaremos diccionarios (clave / valor) que automáticamente se almacenarán en el OneDrive del usuario. El tamaño máximo de los datos Roaming viene establecido en la propiedad ApplicationData.RoamingStorageQuota (normalmente 100KB).

NOTA: Los datos de Roaming no afecta al tamaño de almacenamiento del usuario.

Manos a la obra

Comenzamos creando un nuevo proyecto:

Añadimos las carpetas Views, ViewModels y Services además de las clases base necesarias para implementar el patrón MVVM de la misma forma que vimos en este artículo.

Nuestro objetivo en este ejemplo sera simular una opción de
configuración sencilla, como por ejemplo, el color básico utilizado en
la aplicación y utilizar datos Roaming para mantener el color
seleccionado por el usuario sincronizado entre las aplicaciones Windows y
Windows Phone.

Vamos a tener una configuración de colores por lo tanto empezaremos definiendo… el color. En nuestra carpeta Models crearemos la siguiente clase:

public class Accent
{
     public string Name { get; set; }
 
     public string Hex { get; set; }
}

Nos permite definir el nombre y valor hexadecimal de cada color. A continuación, en nuestra viewmodel tendremos una colección de colores:

private Accent _current;
private ObservableCollection<Accent> _accents;
 
public ObservableCollection<Accent> Accents
{
     get { return _accents; }
     set { _accents = value; }
}
 
public Accent Current
{
     get { return _current; }
     set
     {
          _current = value;
          RaisePropertyChanged("Current");
     }
}

Al entrar en la vista, utilizaremos un método para obtener el listado de colores disponibles:

_accents = new ObservableCollection<Accent>
{
     new Accent { Name = "Blue", Hex= "#1BA1E2" },
     new Accent { Name = "Brown", Hex= "#A05000" },
     new Accent { Name = "Green", Hex= "#339933" },
     new Accent { Name = "Pink", Hex= "#E671B8" },
     new Accent { Name = "Purple", Hex= "#A200FF" },
     new Accent { Name = "Red", Hex= "#E51400" },
     new Accent { Name = "Teal", Hex= "#00ABA9" },
     new Accent { Name = "Lime", Hex= "#A2C139 " },
     new Accent { Name = "Magenta", Hex= "#D80073 " }
};

Todo preparado para poder definir la interfaz:

<ListView
     Grid.Row="1"
     ItemsSource="{Binding Accents}"
     SelectedItem="{Binding Current, Mode=TwoWay}">
     <ListView.ItemsPanel>
         <ItemsPanelTemplate>
             <WrapGrid MaximumRowsOrColumns="3" />
         </ItemsPanelTemplate>
     </ListView.ItemsPanel>
     <ListView.ItemTemplate>
         <DataTemplate>
             <Grid Background="{Binding Hex}"
                   Height="100"
                   Width="100"
                   Margin="5">
                 <TextBlock Text="{Binding Name}"
                            VerticalAlignment="Bottom"/>
             </Grid>
         </DataTemplate>
     </ListView.ItemTemplate>
</ListView>

Hasta aqui nuestro ejemplo básico. Un listado de colores que el
usuario seleccionará àra utilizar como color principal en la aplicación.
Utilizamos datos Roaming para guardar el color seleccionado. Para ello,
comenzamos…

Asociando la aplicación con la Store

Para que la infraestructura de datos Roaming funcione (datos en OneDrive), debemos asociar la aplicación con la tienda.

NOTA: No es necesario publicar la aplicación para realizar pruebas.

Para asociar la aplicación con la tienda haremos clic derecho sobre la misma y elegiremos la opción “Associate App with the Store…”:

Nos aparecerá una ventana modal como la siguiente:

Registraremos un nombre de Aplicación:

Al finalizar el proceso, nuestra aplicación quedará asociada a la tienda
y tendremos un resumen de todos los valores correctos a utilizar en el
archivo de manifiesto:

Una vez realizado el proceso en la aplicación Windows Store o Windows
Phone, debemos repetir lo mismo en la otra seleccionando el nombre
reservado previamente. Antes de continuar sería oportuno revisar el
archivo de manifiesto de cada aplicación para asegurar que el PFN (Package Family Name) es el mismo.

Misma cuenta Microsoft en Windows/Phone

Para que la sincronización de datos funcione correctamente, ambos
dispositivos deben utilizar la misma cuenta Microsoft. Esto que es
sencillo, en el punto final es fácil de cumplir pero quizas no tanto en
el desarrollo. En la máquina de desarrollo tendremos una cuenta
Microsoft establecida pero probablemente no en el emulador de Windows
Phone. Recuerda utilizar la misma cuenta en el emulador para garantizar
que todo funcione o utiliza un dispositivo físico.

Usando Roaming Settings

Llegamos a la parte central del artículo, el uso de Roaming. Para
utilizar Roaming en nuestro ejemplo vamos a crear un servicio llamado RoamingSettingsService con la siguiente definición:

/// <summary>
/// Almacenar y recuperar configuraciones y archivos desde el almacén de datos móviles de aplicaciones.
/// </summary>
public interface IRoamingSettingsService
{
     void SaveData(string key, string value);
 
     void SaveData(string container, string key, string value);
 
     void SaveData(string key, ApplicationDataCompositeValue value);
 
     bool ContainsKey(string key);
 
     object GetData(string key);
 
     object GetData(string container, string key);
 
     ApplicationDataCompositeValue GetDataComposite(string key);
 
     void RemoveData(string key);
 
     ApplicationDataContainer CreateContainer(string container);
 
     void RemoveContainer(string container);
}

Ahora nos centramos en la definición del servicio. Comenzamos creando una propiedad RoamingSettings que accederá a la propiedad ApplicationData.RoamingSettings para obtener la configuración.

/// <summary>
///  Almacenar y recuperar configuraciones y archivos desde el almacén de datos móviles de aplicaciones.
///
/// </summary>
public class RoamingSettingsService : IRoamingSettingsService
{
     internal ApplicationDataContainer RoamingSettings
     {
         get { return ApplicationData.Current.RoamingSettings; }
     }
}

Definimos el método que nos permitirá guardar datos Roaming. Ya
comentamos previamente que trabajaremos con diccionarios con clave y
valor. El método para guardar datos recibirá la clave y el valor a
almacenar:

/// <summary>
/// Escribir datos en una configuración.
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SaveData(string key, string value)
{
     RoamingSettings.Values[key] = value;
}

NOTA: Podríamos pasar un tercer parámetro para indicar la prioridad utilizando la propiedad HighPriority pero solo tendría efecto en la aplicación Windows Store.

Antes de almacenar un valor nos puede interesar verficar si ya existe
un valor almacenado con la clave otorgada. Definiremos un sencillo
método que nos haga esta verificación:

/// <summary>
/// Verifica si existe algun dato relacionado con la clave facilitada.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool ContainsKey(string key)
{
     return RoamingSettings.Values.ContainsKey(key);
}

Una vez guardado datos desearemos recuperarlos posteriormente… creamos
el método que nos permite recuperar el valor de una clave otorgada:

/// <summary>
/// Leer datos desde una configuración.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public object GetData(string key)
{
     return RoamingSettings.Values[key];
}

Utilizamos la propiedad ApplicationDataContainer.Values para acceder al valor almacenado con la clave dada.

Para eliminar una configuración, utilizaremos el método ApplicationDataContainerSettings.Remove:

/// <summary>
/// Eliminar configuraciones.
/// </summary>
/// <param name="key"></param>
public void RemoveData(string key)
{
     RoamingSettings.Values.Remove(key);
}

Utilizando el servicio en nuestra viewmodel, al cargar el color
seleccionado verificaremos si esta ya guardado como una configuración
almacenada en Roaming y en caso afirmativo, recuperaremos el valor. En
caso de no existir, seleccionamos el primer color del listado:

if (_roamingSettingsService.ContainsKey(Key))
{
     var hex = _roamingSettingsService.GetData(Key).ToString();
     Current = Accents.First(c => c.Hex.Equals(hex));
}
else
     Current = Accents.First();

Cada vez que el usuario cambie de color, guardaremos el mismo:

public Accent Current
{
     get { return _current; }
     set
     {
          _current = value;
          _roamingSettingsService.SaveData(Key, _current.Hex);
 
          RaisePropertyChanged("Current");
     }
}

Recibiendo la notificación de cambio en los datos

El evento DataChanged se lanzará cada vez que los datos Roaming cambien siempre y cuando la aplicación este activa en el momento del cambio.

Debemos suscribirnos al evento:

ApplicationData.Current.DataChanged -=
                new TypedEventHandler<ApplicationData, object>(DataChangeHandler);

Hemos establecido DataChangeHandler como el controlador para cambios de datos móviles:

void DataChangeHandler(ApplicationData appData, object args)
{
 
}

Podéis descargar el ejemplo realizado a continuación:

Más opciones utilizando Roaming Data

Hasta este punto hemos visto todo lo necesario para utilizar datos en
Roaming de manera simple, tal y como hemos usado en nuestro ejemplo.
Sin embargo, tenemos muchas otras opciones disponibles. Si recordáis la
definición de nuestro servicio veréis muchos otros métodos que no hemos
usado hasta ahora. Vamos a revisarlos uno a uno.

Utilizamos el método ApplicationDataContainer.CreateContainer para crear un contenedor de configuraciones:

/// <summary>
/// Crea o abre el contenedor de configuración especificado.
/// </summary>
/// <param name="container"></param>
/// <returns></returns>
public ApplicationDataContainer CreateContainer(string container)
{
     return RoamingSettings.CreateContainer(container, ApplicationDataCreateDisposition.Always);
}

Utilizamos el método ApplicationDataContainer.DeleteContainer para eliminar el contenedor de configuraciones:

/// <summary>
/// Elimina el contenedor de configuración especificado.
/// </summary>
/// <param name="container"></param>
public void RemoveContainer(string container)
{
     RoamingSettings.DeleteContainer(container);
}

Guardamos el valor value para acceder a la configuración dada por el parámetro key del contenedor container:

/// <summary>
/// Escribir datos en una configuración.
/// </summary>
/// <param name="container"></param>
/// <param name="key"></param>
/// <param name="value"></param>
public void SaveData(string container, string key, string value)
{
     RoamingSettings.Containers[container].Values[key] = value;
}

Usamos la propiedad ApplicationDataContainer.Values para acceder a la configuración dada por el parámetro key del contenedor container:

/// <summary>
/// Leer datos desde una configuración de un contenedor de configuración especificado.
/// </summary>
/// <param name="container"></param>
/// <param name="key"></param>
/// <returns></returns>
public object GetData(string container, string key)
{
     return RoamingSettings.Containers[container].Values[key];
}

Podemos guardar settings utilizando un objeto ApplicationDataCompositeValue que contiene un conjunto de  configuraciones:

/// <summary>
/// Escribir datos en una configuración.
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SaveData(string key, ApplicationDataCompositeValue value)
{
     RoamingSettings.Values[key] = value;
}

Consejos al usar Roaming Data

A la hora de utilizar Roaming Data es aconsejable que tengas en cuenta:

  • La sincronización de los datos se realiza en background.
  • Utilizar datos en Roaming es ideal para poca cantidad de información
    como por ejemplo la configuración de la aplicación, o pequeños
    volúmenes de datos relacionados con actividad reciente. Sin embargo, NO se debe utilizar Roaming para grandes cantidades de información.
  • La propiedad HighPriority para forzar una sincronización rápida solo esta disponible en Windows, no tiene efecto en Windows Phone.
  • A la hora de depurar aplicaciones que hagan uso de Roaming, si hay
    problemas en la sincronización, asegúrate que ambos dispositivos usan la
    misma cuenta Microsoft, que en el archivo de manifiesto tenemos el
    mismo PFN y la misma versión.

Más información

[Windows Phone] Usando el nuevo control Ad Mediator

Monetización de aplicaciones

El desarrollar una aplicación móvil elegir su modelo de negocio es un
punto vital. Los motivos por el cual como desarrollador decidimos
publicar aplicaciones son muy variados:

  • Por amor al arte.
  • Por dinero.
  • Por aprender, etc.
  • Porque deseamos cubrir un hueco existente.
  • ¿Habíamos mencionado ya el dinero?

Hay muchos motivos. Un motivo habitual suele ser el obtener una
ganacia económica por nuestro trabajo. Nuestras aplicaciones puede ser
gratuitas y de pago. Además, nuestras aplicaciones de pago pueden contar
con modo Trial (sumamente recomendado) e incluso tenemos disponible la
opción de añadir In App Purchase.

Si deseamos obtener un beneficio económico parece obvio que debemos
optar por aplicaciones de pago. Sin embargo, tenemos otras opciones
interesantes para obtener beneficio económico como el uso de publicidad.

Actualmente en la Windows Phone Store, la publicidad
representa aproximadamente la tercera parte de todos los ingresos
generados por los desarrolladores.

El “problema” del uso de publicidad

Si nos decidimos a utilizar publicidad contamos con  varios SDKs de
bastante calidad a la hora de generar publicidad y por lo tanto
beneficios. Sin embargo, con todas las opciones nos preocuparemos por el
eCPM (es el coste efectivo por cada mil impresiones,
es decir, nuestros beneficios). Cada sistema cuenta con un valor
diferente dependiendo de muchos factores como:

  • Categoría de anuncios elegidos
  • Mercado
  • El día y mes de la impresión
  • Etc

Bien, es un problema conocido y que los desarrolladores intentamos solucionar o al menos reducir el efecto al máximo.

¿Cómo?

Una de las soluciones habituales es utilizar distintas redes de
publicidad para aumentar la disponibilidad de anuncios y asi los
ingresos. En el momento en el que una red de anuncios no es capaz de
mostrar un anuncio u otra red aporta un beneficio superior,  la
aplicacion pasa a utilizar una segunda red y asi sucesivamente.

Ad Mediation

El proceso descrito anteriormente es un proceso más o menos complejo y
sacado a base de pruebas y experiencia. Recientemente Microsoft ha
anunciado Windows ad mediation,
un sistema de mediación de anuncios que nos permite utilizar múltiples
SDKs. El algoritmo utilizará un sistema de anuncios, si no es capaz de
servir ningun anuncio, se llamará a un segundo sistema, luego a un
tercero y asi sucesivamente. Basicamente, nos permite aumentar nuestro rendimiento a la hora de obtener beneficios mediante publicidad de una forma muy sencilla.

NOTA: El uso de Ad Mediator no nos garantizará
que tendremos publicidad en el 100% de las situaciones. Nos garantiza
que si un proveedor de publicidad no cuenta con anuncios se utilizará
otro diferente.

Entre las características principales contamos con:

  • Podemos realizar una configuración a nivel global e incluso a nivel local en ciertos mercados.
  • Control sobre la tasa de refresco de la publicidad.
  • Podemos pausar y reanudar la publicidad.
  • Podemos elegir la prioridad de cada red de publicidad.
  • Podemos excluir redes de publicidad.

Windows Ad Mediation esta ya disponible para usar en Windows Phone 8.0, Windows Phone 8.1 Silverlight y aplicaciones universales XAML y los sistemas de publicidad soportados en estos momentos son:

NOTA: En Windows XAML los servicios AdMob, MobFox, InMobi y Inneractive no estan soportados.

En este artículo vamos a utilizar Windows Ad Mediator en una aplicación Universal realizando la integración paso a paso.

¿Te apuntas?

Usando el control Ad Mediator

Obtener la extensión Windows Ad Mediator

El primero paso que debemos llevar a cabo para utilizar Ad Mediator es descargar e instalar la extensión.

Nueva aplicación

Comenzamos creando un nuevo proyecto:

Añadir el control AdMediatorControl

En las referencias del proyecto hacemos clic derecho y elegimos la pestaña Extensiones dentro de Windows Phone 8.1:

Una vez añadida la referencia podemos arrastrar directamente el control AdMediatorControl en la vista de diseño en la vista o vistas deseadas.

<adMediator:AdMediatorControl x:Name="AdMediator_01B3E5" HorizontalAlignment="Left" Height="80" Id="AdMediator-Id-9A1E0E47-BE2F-41CC-A28B-0E14AD66165E" VerticalAlignment="Top" Width="480"/>

Tras arrastrar el control se generara en XAML un código similar al anterior. Como podemos ver se añade un nombre y un identificador único. Tanto el nombre como el identificador los utilizaremos a la hora de configurar Ad Mediator.

eL namespace XAML utilizado es el siguiente (App Windows Phone XAML):

xmlns:adMediator="using:Microsoft.AdMediator.WindowsPhone81"

Una vez añadido el control el siguiente paso sera configurarlo añadiendo los servicios de publicidad deseados.

Configuración del control AdMediatorControl

Una vez añadido el control AdMediatorControl es hora de configurarlo conectándolo a servicios conectados.

Hacemos clic derecho sobre el proyecto en el explorador de soluciones y seleccionamos la opción Nuevo  -> Servicio conectado.

Nos aparecerá la ventana de gestión de servicios conectados. Por
defecto, las librerías de Microsoft Advertising se añaden por defecto.

NOTA: Si no deseamos utilizar Microsoft Advertising lo podemos eliminar sin problemas.

Para añadir otros proveedores de anuncios podemos pulsar el botón Seleccionar redes de anuncios:

Nos aparecerá una ventana donde podremos seleccionar cada una de las
redes de anuncios disponibles para el tipo de proyecto en el que estemos
trabajando.

Al añadir una nueva opción:

Todas las librerías necesarias para utilizar la red de anuncios seleccionada se añaden automáticamente al proyecto.

En este punto solo nos falta configurar cada red de anuncio añadida. Pulsamos el botón Configurar de la red de anuncios seleccionada.

Añadir las capacidades necesarias

Segun el sistema de publicidad utilizado se necesitarán unas
capacidades u otras. Podemos ver las capacidades requeridas por cada
servicio de publicidad en la ventana de gestión de servicios. Para
evitar excepciones al utilizar publicidad debemos añadir las capacidades
requeridas en el archivo de manifiesto de la aplicación.

Gestión de excepciones no controladas desde la publicidad

Debemos asegurarnos de controlar las excepciones no controladas que nos puedan llegar desde las diferentes redes de anuncios:

// In App.xaml.cs file, register with the UnhandledException event handler.
UnhandledException += App_UnhandledException;
void App_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
      if (e != null)
      {
         Exception exception = e.Exception;
         if (exception is NullReferenceException && exception.ToString().ToUpper().Contains("SOMA"))
         {
            Debug.WriteLine("Handled Smaato null reference exception {0}", exception);
            e.Handled = true;
            return;
         }
      }
 
      // APP SPECIFIC HANDLING HERE
 
      if (Debugger.IsAttached)
      {
         // An unhandled exception has occurred; break into the debugger
         Debugger.Break();
      }
}

Otras opciones de configuración

Podemos especificar el tiempo en segundos (de 2 a 30 segundos) que Ad
Mediator espera a la respuesta de una red de anuncios antes de pasar a
la siguiente en caso de no tener respuesta válida. La gestión de timeouts
es configurable. Por defecto, el tiempo de espera es de 5 segundos para
todas las redes excepto Microsoft Advertising y Google AdMob que
cuentan con 10 segundos por defecto.

Podemos especificar el tiempo de timeout de una red concreta facilmente:

AdMediatorControl.AdSdkTimeouts[AdSdkNames.MicrosoftAdvertising] = TimeSpan.FromSeconds(15);

Ad Mediator también nos facilita distintos eventos para gestionar cuando se producen eventos, errores, etc.:

AdMediator_Bottom.AdSdkError += AdMediator_Bottom_AdError;
AdMediator_Bottom.AdMediatorFilled += AdMediator_Bottom_AdFilled;
AdMediator_Bottom.AdMediatorError += AdMediator_Bottom_AdMediatorError;
AdMediator_Bottom.AdSdkEvent += AdMediator_Bottom_AdSdkEvent;

Testing

Probando la aplicación en el emulador se utilizarán una serie de
metadatos de prueba que nos permite probar la aplicación aun sin
configurar la red de anuncios. Los anuncios rotarán secuencialmente con
una misma duración en ciclo. Nos permite verificar errores y eventos
para garantizar que todo lo llevamos bien.

Tras asegurarnos, debemos probar en dispositivos físicos antes de
publicar. En este caso debemos tener cada red de anuncio configurada y
cada anuncio se mostrarás durante 60 segundos (podemos ajustar este
parámetro al publicar). De nuevo, debemos asegurarnos que cada red de
anuncio es capaz de mostrar contenido verificando eventos y errores.

Podéis descargar el ejemplo realizado a continuación:

Publicación

Una vez tengamos nuestra aplicación lista y testeada es hora de
publicar la aplicación. Al crear el paquete y subirlo a la Store, si la
App usa Ad Mediator, se detecta automáticamente junto a las redes de
anuncios utilizadas. En este caso tendremos disponibles una nueva
sección de configuración específica para el Ad Mediator.

NOTA: La primera vez que publicamos la aplicación
crearemos una configuración general. En las sucesivas actualizaciones
podemos crear configuraciones específicas para distintos mercados.

Más información

Xamarin.Forms 1.3.0 Technology Preview

Introducción

En la pasada conferencia Xamarin Evolve 2014, se mostraron una gran cantidad de nuevas características en la plataforma:

  • Asociación con IBM para ofrecer a los desarrolladores una librería que permita conectar con IBM Worklight.
  • El apoyo de múltiples compañías reconocidas por sus controles en otras plataformas para Xamarin.Forms.
  • La llegada de Xamarin Android Player, emulador de Android basado en virtualización pro hardware y gráficos tambien acelerados por hardware.
  • Sketches,
    entorno que permite obtener un resultado en tiempo real mientras se va
    escribiendo el código. Diseñada para hacer C# y F# más accesible.
  • Xamarin Profiler,
    herramienta que permite obtener información y analizar el
    comportamiento de aplicaciones móviles con el fin de mejorar consumo de
    memoria, detectar cuellos de botella  y otros aspectos.
  • Múltiples mejoras en Xamarin Test Cloud como ejecución de tests por lotes, capturas de pantalla, etc.
  • Xamarin Insights que permite monitorear en tiempo real que sucede con la App.

Y entre tantísima novedad, que iremos viendo con más detalle en futuras entradas, nos llega también la versión 1.3 de Xamarin.Forms Technology Preview.

Novedades en Xamarin.Forms

Esta nueva versión llega cargada de novedades, algunas muy esperadas como:

  • Soporte a recursos dinámicos tanto en XAML (usando DynamicResource) como desde código C# (usando SetDynamicResource).
  • Cambios interesantes en las aplicaciones
    Xamarin.Forms. Se añade soporte a eventos del ciclo de vida
    Sleep/Resumen/Start; diccionario de recursos a nivel de aplicación, etc.
  • Soporte de estilos  y triggers
    tanto en XAML como en código. Permite estilos basados en recursos
    dinámicos y además tenemos la posibilidad de crear estilos específicos
    por plataforma.
  • Mejoras de rendimiento, consumo de memoria y pequeñas mejoras en controles existentes.
  • Corección de Bugs.
  • Etc.

Ante tal cantidad de “golosas” novedades no podemos más que
lanzarnos a probar, ¿cierto?. En este artículo vamos a ver como instalar
la versón 1.3.0 de Xamarin.Forms y a analizar los principales cambios
obtenidos en una aplicación.

¿Te apuntas?

Obtener Xamarin.Forms 1.3.0

Podemos descargar Xamarin.Forms 1.3.0 desde este enlace.

Es un paquete NuGet, que venía adjunto junto al anuncio y
que debemos descargar e instalar por ahora manualmente. Descomprimimos
el paquete descargado a una ruta específica del sistema:

Desde Visual Studio nos dirigimos a herramientas, Administrador de paquetes NuGet y seleccionamos la opción Configuración del Administrador de paquetes:

Nos aparecerá una vista de configuración de la fuente de los paquetes NuGet:

Pulsamos el botón + para añadir un nuevo orígen de
paquetes seleccionando la ruta de nuestro disco duro local donde tenemos
los ficheros descomprimidos:

Crear un nuevo proyecto utilizando Xamarin.Forms 1.3.0

Creamos un nuevo proyecto Xamarin.Forms tal como hacíamos hasta
ahora. Desde Visual Studio seleccionamos la plantilla vacía desde el
apartado Mobile Apps:

Una vez creado el proyecto necesitamos actualizar el paquete Xamarin.Forms. En herramientas, seleccionamos la opción Nuget Package Manager para la solución. Seleccionamos la fuente de paquetes creado previamente y elegimos la única opción disponible Xamarin.Forms v1.3.0.pre0.

Tras actualizar ya tendremos nuestra aplicación funcionando bajo Xamarin.Forms 1.3.0.

Muy sencillo, ¿no?.

Tendremos cambios relevantes en algunas partes del código de la App como por ejemplo, en el archivo App.cs del proyecto Shared:

protected override void OnResume()
{
     Console.WriteLine("OnResume");
     base.OnResume();
}
 
protected override void OnSleep()
{
     Console.WriteLine("OnSleep");
     base.OnSleep();
}
 
protected override void OnStart()
{
     Console.WriteLine("OnStart");
     base.OnStart();
}

Ahora la clase hereda de Application e implementa varios métodos para gestionar el ciclo de vida de la aplicación entre otros cambios.

En próximas entradas iremos analizando todas las novedades poco a poco, nos os la perdáis!

Más información