Felices fiestas!

Felices fiestas!

Queridos amigos, celebréis lo que celebréis, os deseo a todos unas
felices fiestas, que espero que podáis compartir con vuestros familiares
y amigos.

Para el 2015!

Para el próximo año os deseo a todos salud, trabajo y que sea un gran
año que os permita cumplir todos vuestros objetivos y sueños. Este 2014
ha sido un año donde he podido aprender y descubrir grandes
tecnologías, he conocido a gente excelente y he podido
asistir/participar en grandes eventos. Para el próximo año sólo pido
poder continuar aprendiendo lo máximo posible para compartir. Ah, y
seguir “desvirtualizando” a muchos de vosotros!

Felices fiestas!

[Windows Phone 8.1] Usando el sensor de luz

Introducción

Existen grandes aplicaciones en la Windows Phone Store que se adaptan
a ciertas condiciones del medio. Por ejemplo, vamos en el coche con HERE Drive+
y oscurece, el tono de la aplicación cambia de claro a oscuro para no
molestar a los ojos. Lo mismo ocurre al entrar en un túnel o en
condiciones atmosféricas adversas.

Sin duda, una característica sumamente interesante y de agradecer de la Aplicación.

Pero…

¿cómo lo hacen?

El sensor de luz

El sensor de luz es uno de los sensores disponibles en muchos de los dispositivos Windows Phone. Este sensor nos devolverá información relacionada con el nivel de iluminación. Esta medida viene dada en Lux, lumens por metro cuadrado. Los niveles de Lux los podemos catalogar de la siguiente forma:

Condiciones de Luz De(lux) A(lux) Valor Medio (lux) Iluminación
Oscuridad total 0 10 5 1
Muy oscuro 11 50 30 2
Interior oscuro 51 200 125 3
Interior con poca luz 201 400 300 4
Interior normal 401 1000 700 5
Interior con luz 1001 5000 3000 6
Exterior oscuro 5001 10,000 7500 7
Exterior nublado 10,001 30,000 20,000 8
Luz solar directa 30,001 100,000 65,000 9

Manos a la obra

Comenzamos creando un nuevo proyecto desde cero:

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.

En este artículo vamos a crear un ejemplo que adapte el tema de la
aplicación entre claro y oscuro dependiendo de la luminosidad del
ambiente, gracias al sensor de luz.

Comenzamos añadiendo algunas propiedades básicas e nuestra viewmodel:

public string Info
{
     get
     {
          return "En un lugar de la Mancha, de cuyo nombre no quiero acordarme...";
     }
}

Definimos un valor intermedio entre los Lux que nos indican condiciones de interior y los de exterior para determinar si el “estado” debe ser tema claro u oscuro.

public string State
{
     get { return Lux < 3000 ? "Dark" : "Light"; }
}

Por otro lado, mostraremos en pantalla en todo momento la cantidad de Lux recibidas desde el sensor de luz:

private float _lux;
 
public float Lux
{
     get { return _lux; }
     set
     {
          _lux = value;
          RaisePropertyChanged();
          RaisePropertyChanged("State");
     }
}

Pasamos a definir nuestra interfaz de usuario:

<ScrollViewer>
     <StackPanel>
          <StackPanel
               Orientation="Horizontal">
               <TextBlock Text="LUX:"
                          FontSize="24" />
               <TextBlock
                    Text="{Binding Lux}"
                    FontSize="24"
                    FontWeight="Black"
                    Margin="5, 0"/>
          </StackPanel>
          <TextBlock
               Text="{Binding Info}"
               FontSize="24"
               TextWrapping="Wrap" />
     </StackPanel>
</ScrollViewer>

Muy sencilla. Mostramos el valor de Lux recibidos del sensor de luz y el texto de la propiedad Info de la viewmodel.

El resultado:

Al entrar en la vista, en la sobreescritura del método OnNavigatedTo, verficamos si el dispositivo cuenta con sensor de luz. Para ello, utilizamos el método GetDefault() de la clase LightSensor disponible como no podía ser de otra forma en el namespace Windows.Devices.Sensors. Si el sensor esta disponible el método GetDefault() devolverá una instancia del sensor de luz.

Una vez establecida la referencia,estableceremos el valor de ReportInterval.
Esta propiedad indica en milisegundos el valor de la tasa de refresco
en la que el sensor tomará de nuevo información. Por defecto cuenta con
un valor dado por la implementación del driver del sensor. Si deseamos
ajustar el valor a las condiciones de nuestra aplicación bastará con asignar un valor diferente a cero.

NOTA: Al salir de la Aplicación recordad devolver el valor a cero. Esto es importante para no afectar al consumo energético.

Por último, llegamos a la forma en la que obtenemos la información. Tenemos dos opciones:

  • GetCurrentReading: Obtiene una vez el valor de Lux facilitado por el sensor.
  • ReadingChanged: Realizando una suscripción a este
    evento obtenemos información del sensor de manera continuada. La tasa de
    refresco vendrá indicada por la propiedad ReportInternval.
public override Task OnNavigatedTo(NavigationEventArgs args)
{
     _dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
     _lightSensor = LightSensor.GetDefault();
 
     if (_lightSensor != null)
     {
          uint minReportInterval = _lightSensor.MinimumReportInterval;
          _lightSensor.ReportInterval = minReportInterval > 1000 ? minReportInterval : 1000;
          _lightSensor.ReadingChanged += _lightSensor_ReadingChanged;
     }
     else
     {
          Debug.WriteLine("El dispositivo no cuenta con el sensor de luz");
     }
 
      return null;
}

Al salir de la vista, en el método OnNavigatedFrom, cancelamos la suscripción al evento ReadingChanged y establecemos el valor de ReportInterval a cero:

public override Task OnNavigatedFrom(NavigationEventArgs args)
{
     if (_lightSensor != null)
     {
          _lightSensor.ReportInterval = 0;
          _lightSensor.ReadingChanged -= _lightSensor_ReadingChanged;
     }
 
     return null;
}

Llega el mometo cumbre del artículo, a continuación vamos a ver como obtenemos el valor de Lux:

void _lightSensor_ReadingChanged(LightSensor sender, LightSensorReadingChangedEventArgs args)
{
     _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
     {
          Lux = args.Reading.IlluminanceInLux;
          AppFrame.RequestedTheme =
          State.Equals("Dark", StringComparison.CurrentCultureIgnoreCase) ?
               ElementTheme.Dark : ElementTheme.Light;
     });
 
     Debug.WriteLine("Lux: {0}", Lux);
}

El método anterior se lanzará de manera continuada pudiendo acceder a la información del sensor. Obtenemos el valor de Lux
dados por el sensor, actualizará nuestra propiedad State y dependiendo
del valor de la misma, cambiamos el tema utilizado de claro a oscuro o
viceversa.

NOTA: La ejecución del método se realiza en otro
hilo en background. Por lo tanto cualquier acción que conlleve un
actualización de la UI debemos envolverla en una llamada de Dispatcher.


Podéis ver el resultado del ejemplo en video a continuación:

Y la App Universal realizada como ejemplo la podéis descargar del siguiente enlace:

Como hemos podido ver en este artículo, el uso del sensor de luz es
una tarea bastante sencilla que nos permite adaptar la UI a condicones
ambientales mejorando la experiencia de usuario.

NOTA: Exactamente la misma API la tenemos disponible para Apps Windows Store.

Recordar que podéis dejar en los comentarios cualquier tipo de sugerencia o pregunta.

Más información

[Christmas Mobile Apps Sessions] Material de “Publicación de Universal Apps”

El evento

El pasado Miércoles 10 de Diciembre tenía lugar el cuarto webcast de las Christmas Mobile Apps Sessiones. Las Christmas Mobile Apps Sessions son un conjunto 10 webcasts sobre desarrollo de apps móviles con variada  temática.

En esta sesión, vimos formas de monetización en aplicaciones
universales viendo como crear Trials, In-App Purchase o como añadir
publicidad, creamos el paquete de aplicación, publicamos en la tienda
con diferentes opciones y finalmente vimos como añadir analíticas
avanzadas.

El material

La presentación utilizada:

 

Podéis descargar el conjunto de ejemplos realizados en el webcast a continuación:

Por último, podéis ver en cualquier momento el webcast en el siguiente video:

Más información

[Windows Phone 8.1] Reproducir Audio en Background

Introducción

Una tarea habitual a realizar en aplicaciones es la reproducción de
archivos de audio ya sean podcasts, música, sonidos, etc. En muchas de
las situaciones la reproducción debe continuar cuando la aplicación pasa
a background.

En este artículo vamos a crear un reproductor de audio con continuidad al pasar a background.

¿Te apuntas?

Un poco de teoría antes de comenzar…

En Windows Phone 8.0 ya podíamos realizar esta acción, reproducir
audio en background. Con la llegada de las aplicaciones Universales con
Windows Phone 8.1, la forma de crear la tarea en background es
diferente, algo más similar a la forma ya disponible en WinRT aunque
tampoco igual. Esto nos permite crear la tarea en background de audio
compartiendo  código aunque no sería exactamente el mismo, hay
diferencias entre la implementación del agente en background para
Windows Phone y Windows Store. Además tendremos acceso a nuevas
características previamente no disponibles como trabajar con la
velocidad de reproducción por ejemplo.

NOTA: Al actualizar una Aplicación Windows Phone 8.0 a Silverlight 8.1 que implementase una tarea en background de audio hay que tener en cuenta que el AudioPlayerAgent no esta soportado.

Queremos reproducir audio cuando nuestra interfaz de usuario no este
en primer plano. Para ello, utilizaremos una tarea en background capaz
de reproducir audio.En el espacio de nombres Windows.Media.Playback
contamos con un conjunto de APIs destinadas a ofrecernos la posibilidad
de reproducir audio en segundo plano (incluso en primer plano en caso
necesario). Usando esta API utilizaremos un MediaPlayer global encargado de llevar a cabo la reproducción.

La reprodución del audio se realizará desde background mientras que la App accederá a la información del MediaPlayer
vía objeto proxy. Concretamente la comunicación se realizará por un
sencillo sistema de mensajería. Se pueden enviar mensajes desde primer plano a segundo plano y viceversa.

NOTA: Un mensaje puede ser desde una simple cadena a un conjunto de valores.

Veamos el diagrama de como sería el sistema:

Cuando queremos reproducir audio en una tarea de fondo en Windows Phone estamos tratando con dos procesos.
Por un lado contamos con un proceso en primer plano, nuestra App con
nuestra interfaz de usuario y por otro lado una tarea en segundo plano
que contará con la lógica para reproducir el audio. Esto es asi ya que
si el sistema o el usuario suspende o finaliza el primer proceso, el
audio seguiría reproduciendose desde el segundo.

Nuestra UI

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.

En este ejemplo tendremos eventos del //BUILD 2014 de Channel 9. Nuestro objetivo será crear una App capaz de reproducir el audio de los eventos funcionando por supuesto en segundo plano.

Comenzamos creand el modelo:

public class Event
{
     public string Name { get; set; }
 
     public string Image { get; set; }
 
     public string Duration { get; set; }
 
     public string Url { get; set; }
}

Una sencilla clase que nos permita almacenar toda la información relacionada con un evento. Los valores principales será la Url donde tendremos el acceso al audio y la propiedad Name que nos indicará que se esta reproduciendo.

En nuestra viewmodel, cargaremos la información de un evento:

private Event LoadEvent()
{
     return new Event
     {
          Name = "What’s New for Windows and Windows Phone Developers",
          Image = "ms-appx:///Assets/Build.jpg",
          Duration = "27 minutes, 43 seconds",
     };
}

Lo llamaremos cuando la vista pase a ser la activa, es decir, al entrar en la vista, sobreescritura del método OnNavigatedTo:

public override Task OnNavigatedTo(NavigationEventArgs args)
{
     // Cargamos los datos del evento
     Event = LoadEvent();
 
     return null;
}

Una vez cargada la información del evento contaremos en nuestra interfaz con un botón para controlar la reproducción (PlayStop). Definimos una pequeña enumeración para que la gestión del estado sea sencilla:

public enum PlayerState
{
     Play,
     Pause
};
 
private PlayerState _state;
public PlayerState State
{
     get { return _state; }
     set
     {
          _state = value;
          RaisePropertyChanged();
     }
}

También necesitaremos el comando a ejecutar en la viewmodel al pulsar sobre el botón:

private ICommand _playerCommand;
 
public ICommand PlayerCommand
{
     get { return _playerCommand = _playerCommand ?? new DelegateCommand(PlayerCommandExecute); }
}
 
private void PlayerCommandExecute()
{
     if(State == PlayerState.Play)
          // Play
     else
          // Stop
}

De modo que la definición del botón en nuestra interfaz sería:

<Button VerticalAlignment="Stretch"
        BorderBrush="{x:Null}" Width="50"
        Command="{Binding PlayerCommand}">
     <Image Source="{Binding State, Converter={StaticResource StateToIconConverter}}"/>
</Button>

Donde la imagen la gestiona un Converter. El Converter devuelve un icono de Play o Stop segun el estado:

public class StateToIconConverter : IValueConverter
{
     private const string Play = "ms-appx:///Assets/Play.png";
     private const string Stop = "ms-appx:///Assets/Stop.png";
 
     public object Convert(object value, Type targetType, object parameter, string language)
     {
          var state = value as PlayerViewModel.PlayerState?;
 
          if (state == null)
              return string.Empty;
 
          return state == PlayerViewModel.PlayerState.Play ? Play : Stop;
     }
 
     public object ConvertBack(object value, Type targetType, object parameter, string language)
     {
          return null;
     }
}

El resultado de nuestra UI es el siguiente:

NOTA: Para simplificar el ejemplo se han
suprimido ciertas partes de código no necesarias para el objetivo
principal del artículo, el audio en background. Hablamos de código como
el estilo del botón de reproducción o el XAML general de la vista. En la
parte inferior del artículo esta disponible todo el código fuente del
ejemplo.

Creando la tarea en background

Teniendo una aplicación Windows Phone 8.1 nos centramos en añadir la background task. Para añadir la background task debemos añadir un componente WinRT.

Una vez creado el componente WinRT renombraremos la clase a UpdateTask. La clase BackgoundAudioTask implementa la interfaz IBackgroundTask. Esta interfaz cuenta con un único método llamado Run.

public sealed class BackgroundAudioTask : IBackgroundTask
{
    public void Run(IBackgroundTaskInstance taskInstance)
    {
              
    }
}

NOTA:  La clase de la tarea en segundo plano debe ser una clase public y sealed.

Comenzamos a escribir el código necesario en la tarea en background para realizar la reproducción de audio:

private BackgroundTaskDeferral _deferral;
private SystemMediaTransportControls _systemMediaTransportControl;
private MediaPlayer _mediaPlayer;

Creamos las variables globales necesarias. Antes de continuar vamos a
determinar su cometido. Comenzamos hablando de la variable de tipo BackgroundTaskDeferral. La tarea en segundo plano es iniciada por el proceso en primer plano haciendo una llamada aBackgroundMediaPlayer.Current. Tras esa llamada se lanza el método IBackgroundTask.Run donde se inicia la variable _deferral con el objetivo de completar el aplazamiento, la reproducción en los eventos Canceled o Completed.

SystemMediaTransportControls representa los controles multimedia del sistema.

Los utilizaremos para gestionar el audio cuando nuestra Aplicación no
se encuentre en primer plano (Ejemplo: Pantalla de bloqueo).

Por último, la variable de tipo MediaPlayer será la que nos exponga
los métodos necesarios para comenzar y detener la reproducción del
audio.

Continuamos. Vamos a definir el código del método Run:

public void Run(IBackgroundTaskInstance taskInstance)
{
     // La clase SystemMediaTransportControls permite a tu aplicación usar los controles de
     // transporte multimedia del sistema proporcionados por Windows y actualizar la información
     // multimedia que se muestra.
     _systemMediaTransportControl = SystemMediaTransportControls.GetForCurrentView();
     _systemMediaTransportControl.IsEnabled = true;
 
     BackgroundMediaPlayer.MessageReceivedFromForeground += MessageReceivedFromForeground;
     BackgroundMediaPlayer.Current.CurrentStateChanged += BackgroundMediaPlayerCurrentStateChanged;
 
     taskInstance.Canceled += OnCanceled;
     taskInstance.Task.Completed += Taskcompleted;
 
     _deferral = taskInstance.GetDeferral();
}

Aparte de instanciar las variables globales vistas previamente cabe destacar la suscripción a dos eventos fundamentales:

  • MessageReceivedFromForeground: Este evento se lanzará cada vez que un mensaje desde la UI sea enviado.
  • CurrentStateChanged: Este evento se lanzará cada vez que el estado del MediaPlayer cambie entre Playing, Paused o Stopped.

Vemos la definición de los eventos recibidos desde la aplicación:

private void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
{
     ValueSet valueSet = e.Data;
     foreach (string key in valueSet.Keys)
     {
          switch (key)
          {
               case "Play":
                    Play(valueSet[key].ToString(), valueSet["Title"].ToString());
                    break;
               case "Pause":
                    Pause();
                    break;
          }
     }
}

Sencillo. Recordad que la UI se comunica con la tarea en segundo
plano vía mensajes. En este evento capturamos los mensajes y los
interpretamos. Podemos recibir dos tipos de mensajes desde la UI,
comenzar la reproducción detenerla. Asi que en función de la Key recibida lanzamos un método Play o un método Pause.

Veamos por lo tanto la definición de los métodos base, Play y Pause:

private void Play(string url, string title)
{
     _mediaPlayer = BackgroundMediaPlayer.Current;
     _mediaPlayer.AutoPlay = true;
     _mediaPlayer.SetUriSource(new Uri(url));
 
     _systemMediaTransportControl.ButtonPressed += MediaTransportControlButtonPressed;
     _systemMediaTransportControl.IsPauseEnabled = true;
     _systemMediaTransportControl.IsPlayEnabled = true;
     _systemMediaTransportControl.DisplayUpdater.Type = MediaPlaybackType.Music;
     _systemMediaTransportControl.DisplayUpdater.MusicProperties.Title = title;
     _systemMediaTransportControl.DisplayUpdater.Update();
}

El método Play define la fuente del audio en el objeto MediaPlayer y actualiza toda la información del reproductor SystemMediaTransportControl.

El método Pause:

Lanza el método Pause del MediaPlayer.

private void Pause()
{
     if (_mediaPlayer == null)
          _mediaPlayer = BackgroundMediaPlayer.Current;
 
     _mediaPlayer.Pause();
}

Debemos controlar que el PlaybackStatus del control SystemMediaTransportControl se ve reflejado en el estado de nuestro MediaPlayer:

private void BackgroundMediaPlayerCurrentStateChanged(MediaPlayer sender, object args)
{
     switch (sender.CurrentState)
     {
          case MediaPlayerState.Playing:
               _systemMediaTransportControl.PlaybackStatus = MediaPlaybackStatus.Playing;
               break;
          case MediaPlayerState.Paused:
               _systemMediaTransportControl.PlaybackStatus = MediaPlaybackStatus.Paused;
               break;
     }
}

También debemos gestionar la pulsación de botones en el control SystemMediaTransportControl:

private void MediaTransportControlButtonPressed(SystemMediaTransportControls sender,
            SystemMediaTransportControlsButtonPressedEventArgs args)
{
     switch (args.Button)
     {
          case SystemMediaTransportControlsButton.Play:
               BackgroundMediaPlayer.Current.Play();
               break;
          case SystemMediaTransportControlsButton.Pause:
               BackgroundMediaPlayer.Current.Pause();
               break;
     }
}

Y por supuesto, debemos cerrar correctamente la tarea de fondo. En caso de finalización o cancelación detenemos la reproducción:

private void Taskcompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
{
     BackgroundMediaPlayer.Shutdown();
     _deferral.Complete();
}
 
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
     BackgroundMediaPlayer.Shutdown();
     _deferral.Complete();
}

Cerramos aqui el código de nuestra tarea en background. Continuamos
viendo como vincular nuestro proyecto Windows Phone 8.1, la UI, con la
tarea.

En nuestro proyecto Windows Phone 8.1 hacemos clic derecho, opción “Add references”:

Tras añadir la referencia al componente WinRT debemos realizar algunos cambios en el archivo Package.appxmanifiest. Nos dirigimos a la pestaña “Capabilites”. Añadimos una nueva capacidad de tipo Background Task:

En las propiedades debemos definir el tipo a Audio la propiedad Entry Point, es decir, el nombre completo de la clase de nuestra background task incluido namespace:

Y todo listo!

Integrándolo todo

Con la tarea en background definida y referenciada en nuestro proyecto Windows Phone es hora de integrarlo todo. Vamos a utilizar la tarea en segundo plano en el comando que gestiona la reproducción en la viewmodel, lo recordamos:

private void PlayerCommandExecute()
{
     if(State == PlayerState.Play)
          // Play
     else
          // Stop
}

En los comentarios realizaremos llamadas a metodos Play() Y Stop() respectivamente. Definimos el método de reproducción:

private void Play()
{
     State = PlayerState.Pause;
     BackgroundMediaPlayer.SendMessageToBackground(new ValueSet
     {
          {
               "Play",
               _event.Url
          },
          {
               "Title",
               _event.Name
          }
     });
}

Enviamos un mensaje a nuestra tarea en segundo
plano. En la Key le indicamos la acción a ejecutar, la reproducción,
pasando en el valor la Url con el audio a reproducir. Podemos pasar
tantos parámetros como necesitemos. No estamos limitados a una sencilla
cadena. En este ejemplo también se pasa el nombre del audio a reproducir
aunque también podría ser interesante la portada del evento/album, el
autor o artista, etc.

Ahora pasamos al método de detención de la reproducción.

private void Pause()
{
     State = PlayerState.Play;
     BackgroundMediaPlayer.SendMessageToBackground(new ValueSet
     {
          {
               "Pause",
               string.Empty
          }
     });
}

De esta forma, nuestro comando quedara de la siguiente forma:

private void PlayerCommandExecute()
{
     if(State == PlayerState.Play)
          Play();
     else
          Pause();
}

Y hasta aqui ya lo tenemos todo listo!. El resultado final es el siguiente:

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

Y hasta aquí llega el artículo de hoy. Como siempre espero que os
resulte interesante. Recordar que cualquier tipo de duda o sugerencia la
podéis dejar reflejada en los comentarios.

En próximos artículos veremos como realizar la misma operación en una
Aplicaicón Windows Store para Windows 8.1 entre otras novedades.

Más información

[Christmas Mobile Apps Sessions] Material de “Herramientas y toolkits para Universal Apps”

El evento

El pasado Miércoles 10 de Diciembre tenía lugar el cuarto webcast de las Christmas Mobile Apps Sessiones. Las Christmas Mobile Apps Sessions son un conjunto 10 webcasts sobre desarrollo de apps móviles con variada  temática.

En esta sesión, vimos novedades de Visual Studio en XAML y C#
relacionadas con aplicaciones universales, profundizamos en todas las
posibilidades que nos brinda el emulador de Windows Phone, repasamos
algunas características fundamentales de Blend, probamos la herramientas
de análisis de rendimiento además de ver muchas otras herramientas
variadas.

El material

La presentación utilizada:

 

Podéis descargar el conjunto de ejemplos realizados en el webcast a continuación:

Por último, podéis ver en cualquier momento el webcast en el siguiente video:

Más información

[Christmas Mobile Apps Sessions] Material de “Introducción a Universal Apps”

El evento

El pasado Viernes 05 de Diciembre tenía lugar el segundo webcast de las Christmas Mobile Apps Sessiones. Las Christmas Mobile Apps Sessions son un conjunto 10 webcasts sobre desarrollo de apps móviles con variada  temática. En esta sesión, vimos en qué consisten, como crear así como los aportes de las Aplicaciones Universales. Además, profundizamos en la convergencia entre las plataformas Windows analizando distintas técnicas para compartir código.

El material

La presentación utilizada:

 

Podéis descargar el conjunto de ejemplos realizados en el webcast a continuación:

Por último, podéis ver en cualquier momento el webcast en el siguiente video:

Más información

[Evento] Christmas Mobile Apps Sessions

El evento

Las Christmas Mobile Apps Sessions son un conjunto 10 webcasts
sobre desarrollo de apps móviles con variada  temática. Desde
desarrollo de aplicaciones universales, a desarrollo de aplicaciones
nativas multiplataforma con Xamarin pasando por la creación de
backends.  Todo rodeado de ponentes de lujo como Josué Yeray, Santiago Porras, Rafa Serna, y un servidor, MVPs de Windows Platform Development, con Eduard Tomás, MVP de ASP.NET y con Alejandro Campos, Technical Evangelist en Microsoft.

La agenda

  1. ALM con Visual Studio Online, Jueves 4 de diciembre de 6pm a 7pm por Alejandro Campos. En
    esta sesión veremos cómo con Visual Studio Online podemos gestionar el
    ciclo de vida completo de nuestro proyecto con metodologías ágiles, así
    como gestionar nuestro código fuente y automatizar la compilación, las
    pruebas y la publicación de nuestras aplicaciones.

  2. Introducción a Universal Apps, Viernes 5 de diciembre de 6pm a 7pm por un servidor. Con
    la llegada de Windows Phone 8.1 al mercado los desarrolladores tenemos
    grandes cambios en la plataforma de desarrollo entre ellos, las
    aplicaciones universales. En esta sesión aprenderemos en qué consisten,
    como crearlas así como sus aportes. Además,  profundizaremos en la
    convergencia entre la plataforma Windows analizando distintas técnicas
    para compartir código.

  3. Buenas prácticas en Universal Apps, Martes 9 de diciembre de 6pm a 7pm por Josué YerayEn
    el mundo del desarrollo móvil, publicar una aplicación no es una meta,
    es solo un paso más del camino. Después de publicarla viene el
    mantenimiento y actualización, mejor cuanto más constante y rápido sea.
    En esta sesión vamos a ver buenas practicas que nos ayudarán a crear
    apps mantenibles y de fácil actualización como MVVM, Servicios,
    Inyección de dependencias, separación de estilos y plantillas en
    diccionarios…

  4. Herramientas y toolkits para Universal Apps, Miércoles 10 de diciembre de 6pm a 7pm por un servidor. Desde
    Visual Studio contamos con una gran cantidad de herramientas destinadas
    al desarrollo de aplicaciones universales. Podemos analizar paquetes,
    desplegar paquetes, medir el rendimiento de la aplicación y contamos con
    versátiles emuladores entre otras herramientas. En esta sesión
    repasaremos todas las herramientas incluidas con el SDK de desarrollo
    así como herramientas de terceros que nos incluyen librerías auxiliares y
    nuevos controles.

  5. Desarrollo Móvil Multi-plataforma con Xamarin, Jueves 11 de diciembre de 6pm a 7pm, por Alejandro Campos. ¿Podemos
    desarrollar una misma app que funcione en dispositivos Windows, Android
    e iOS? ¿Y que sea nativa? ¿Y podemos crearla con un mismo IDE y un
    mismo lenguaje? Con Visual Studio, C# y Xamarin es posible. En esta
    sesión te contamos cómo.

  6. Introducción al Diseño, trucos y consejos en Universal Apps, Viernes 12 de diciembre de 6pm a 7pm, por Santiago Porras. Conoce
    los conceptos esenciales del diseño de Aplicaciones Universales para
    poder crear aplicaciones que atraigan a los usuarios. Además, aprenderás
    algunos trucos y consejos simples para diferenciarte y crear
    experiencias únicas.

  7. Desarrollo Móvil Multi-plataforma con Apache Cordova, Lunes 15 de diciembre de 6pm a 7pm por Alejandro Campos.
    Podemos desarrollar una misma app que funcione en dispositivos Windows,
    Android e iOS con HTML5 y JavaScript?¿Y podemos crearla con
    herramientas de primer nivel que nos ayuden en la creación del código,
    en su depuración, y pruebas? Con Visual Studio y Apache Cordova es
    posible. En esta sesión te contamos cómo.
  8. Crea tu backend con Azure Mobile Services, Martes 16 de diciembre de 6pm a 7pm por Rafa Serna. Casi
    cualquier aplicación móvil necesita de un backend para darle toda la
    funcionalidad y potencia que necesita. Con Azure Mobile Services
    dispondremos de autenticación, servicios de datos, notificaciones y un
    completo set de usos, los cuales nos proporcionan un extenso backend en
    la nube casi a un click de distancia.
  9. Crea tu backend con ASP.NET Web API, Miércoles 17 de diciembre de 6pm a 7pm por Eduard Tomás. Da
    igual lo que haga tu app: tarde o temprano necesitará hablar con un
    servidor. En esta charla veremos cómo crear fácilmente una API REST
    aprovechando toda la potencia de ASP.NET WebApi y verás que da igual lo
    compleja que sean tus necesidades, ¡que con WebApi podrás cubrirlas
    rápidamente!
  10. Publicación de Universal Apps, Jueves 18 de diciembre de 6pm a 7pm por un servidor. Antes
    de enviar nuestra aplicación a publicar debemos revisar el archivo de
    manifiesto, generar y validar el paquete entre otras acciones. En esta
    sesión repasaremos todos los pasos necesarios a realizar antes de
    publicar la aplicación, repasaremos formas de monetización así como
    incluir analíticas y por supuesto publicaremos una aplicación universal
    paso a paso
    .

NOTA: Todas las sesiones serán grabadas para
poder visualizarlas posteriormente aunque no dudéis en conectar online
para aprovechar y poder realizar preguntas al ponente de turno.

Más información