A vueltas con Windows Phone 7.8

Tal y como comentaba en un post anterior, Microsoft pretende proporcionar a los actuales poseedores de Windows Phone una versión que acerque nuestros terminales a la nueva versión Windows Phone 8.

Parece que estoy equivocado.

Al menos, de momento, sólo se confirma la nueva página de inicio (que como os comentaba, parece poco más que un caramelo… )

El hecho de que haya una gran cantidad de nuevas características en WP 8 que estén atadas al hardware hace que muchos (no me atrevería a decir todos) dispositivos actuales no puedan contar con ellas (yo, desde luego, no puedo contar con NFC en mi actual HTC HD 7). Sin embargo, hay un buen número de características del nuevo sistema operativo que no se encuentran vinculadas tan directamente con el hardware (o con el nuevo kernel implantado).

Pues bien, no soy muy amigo de las cartas de petición (quizá sea un tema cultural, pero en demasiadas ocasiones sirven de muy poco), pero por esta vez voy a hacer una excepción.

En UserVoice podéis encontrar una solicitud (muy seguida, dicho sea de paso) a Microsoft para que vuestro futuro Windows Phone 7.8 contenga el mayor número posible de estas nuevas características.

Yo, desde luego, no estoy por la labor de comprarme un Smart Phone cada dos años, pero pensando en aquellos que acaben de agenciarse su flamante nuevo Nokia, imagino que poca gracia les hará y poca ayuda para el negocio de Microsoft. Dicho sea de paso, parece que Microsoft quisiera contar con los incondicionales, ques somos unos cuantos, a la hora de propagar el boca a boca.

Pues, en mi opinión, esta es una magnífica oportunidad que se les presenta para conseguir que los que estábamos contentos con nuestros teléfonos, lo estemos todavía más.

P.D. ¿Alguien ha visto durante la Eurocopa un anuncio de Windows Phone acompañando a los de iPhone y Android que hay en cada descanso de partido? Mientras sea esta la campaña de márketing de Microsoft con su Windows Phone, los incondicionales seguiremos siendo importantes a la hora de que este teléfono termine por ocupar la cuota que se merece.

Anuncios

Windows Phone 7.8

¿De dónde viene?

Como sabréis, se ha celebrado recientemente el Windows Phone Summit y se ha aprovechado el evento para hablar mucho del futuro Windows Phone 8.

Lo cierto es que la web está llena de artículos sobre la futura versión de WP, así que mi intención es contar aquí dos o tres cosas que me llaman la atención y que pueden hacer que WP sea una plataforma llena de posibilidades y con futuro (pese a empezar con una seria desventaja frente a sus competidores).

Para poder explicar qué es la versión 7.8 (lo poco que se sabe) antes hay que ver un poco sobre las diferencias fundamentales entre la versión 7.8 y la 8 (y no estoy hablando de funcionalidad).

Windows Phone 7.X y 8

Windows Phone 8 (Apollo) es un cambio radical en el SO. Para que os hagáis una idea: en realidad se trata de Sistema Operativo diferente y no de una evolución del actual (por mucho que el nombre y la versión hagan pensar lo contrario).

El núcleo de un sistema operativo es el corazón, las tripas, el sistema nervioso central y el sistema nervioso periférico. Lo demás son, más o menos, adornos (bueno, más o menos). La pieza más pegada a la tecnología, al hardware. Ya sea procesador, memoria, dispositivos… es, precisamente, el núcleo. Pues bien el núcleo de Windows Phone 7.X está basado en WinCE, un sistema operativo que Microsoft diseñó en su momento para sistemas embebidos, que ha tenido su evolución desde 1996 y que, desde el comienzo daba soporte a varias arquitecturas de micro-procesadores (a destacar Intel x86 y ARM).

Por el contrario, Windows Phone 8 tiene un núcleo basado en Windows NT (sí, ese sistema operativo de Servidor de la segunda mitad de los 90 y que es, por decirlo de alguna manera, el abuelo directo de la mayoría de los actuales Sistemas Operativos de Microsoft. Este sistema operativo nació con la idea original de proporcionar sabores de estación de trabajo y de servidor (con más o menos éxito) pero que, fijaos cómo son las cosas, va a tener una n-ésima reencarnación dentro de un teléfono.

Vale. ¿Y qué pasa entonces con mi Windows Phone 7.X?

Las arquitecturas de ambos sistemas operativos son bastante diferentes (aunque tenían cierta base común). Así que, por resumir un poco el tema, resulta complicado que los teléfonos móviles que actualmente ejecutan Windows Phone 7.X puedan llegar a ejecutar correctamente Windows Phone 8 (no seré categórico aquí, que no me sorprendería ver poco después de la salida de WP 8 algunas ROM que pongan el nuevo Sistema Operativo en los antiguos teléfonos… ya veremos).

Así que, ya veis. Olvidaos de encontraros alguna actualización en vuestros teléfonos móviles que os instale el nuevo Sistema Operativo. Por otro lado, aunque no me haga muy feliz, lo cierto es que esto no es nada nuevo (tanto Android como iPhone se han encontrado con escenarios idénticos).

La estrategia de Microsoft está clara al respecto. Tanto el nuevo Windows 8 (que será el Sistema Operativo común para Tablets y PCs) como Windows Phone 8 tendrán en común una base muy importante. Esto sienta los principios para una única línea (es de suponer) de sistemas operativos para todos los ecosistemas de Microsoft. Algo que Apple ya hace con su iPhone y su iPad y Android con sus teléfonos y tabletas (sí, Android tiene tabletas, no sólo existe el iPad).

Para todos aquellos, pobres de nosotros, que tenemos un teléfono basado en Windows Phone 7.X, Microsoft ha asegurado que estaremos en condiciones de “acercarnos” todo lo posible al nuevo Windows Phone 8. Eso, es, precisamente la versión Windows Phone 7.8. Una versión pensada para los dispositivos actuales que no soportarán el nuevo sistema operativo Windows Phone 8.

¿Y qué cambios traerá?

Aquí entro en el ámbito de la opinión personal. Y con los datos que hay actualmente, que son muy pocos, no voy a meterme demasiado en el barro.

Una cosa es que Microsoft de un caramelo como la nueva página de inicio de Windows Phone 8 (que estará presente en Windows Phone 7.8)

Pero esto es muy poco representativo y, en mi opinión aporta entre poco y nada, habida cuenta de que Windows Phone 7.8 probablemente seguirá teniendo una única resolución de pantalla (y no como las tres que soportará la versión 8).

En definitiva, tendremos que esperar a ver qué nos proporcionará Windows Phone 7.8, pero no tengo muchas expectativas que digamos:

  • Algunas cosas podemos ir descartándolas con casi toda seguridad (ejecución de código nativo, por ejemplo que será muy útil para portar juegos de otras plataformas y extraer el máximo rendimiento a la máquina).
  • Otras me encantaría verlas en la versión 7.8 (como un Market Place privado para el mundo empresarial).
  • Por último, algunas características de red indispensables para que este sistema operativo pueda ser utilizado en el mundo de la empresa, y que estarán presentes en Windows Phone 8, tengo dudas que puedan llegar a estar en Windows Phone 7.8 pero de ilusión también se vive.

Empezando con Windows 7.1 (y XVIII) – Utilizando Behaviors

Los “comportamientos” (Behaviors) son piezas de funcionalidad relacionadas con la interacción del usuario y que pueden ser reutilizadas con facilidad.

Mucha gente asocia la utilización de un Behavior a Expression, y es más que lógica dicha asociación (échale un vistazo al link de referencia para ver dónde está clasificado dentro de la MSDN).

Sin embargo su utilización no se limita a Expression. Podemos sacarles partido en nuestro Windows Phone de manera sencila.

Montando Un Cuadro de Diálogo

Un escenario muy común en la utilización de cualquier patrón que busque desacoplar la capa de presentación de la lógica de presentación (es decir, la Vista de lo que sea que pongamos detrás) es mostrar un cuadro de diálogo. En su versión más sencilla, este cuadro muestra un mensaje de aviso al usuario y proporciona algún mecanismo para que el usuario escoga de entre un número limitado de acciones.

En este caso me voy a centrar en mostrar un mensaje de diálogo sencillo al usuario haciendo uso de un Behavior y de algunas facilidades que nos ofrece MVVM Light.

Al lío

Imagninemos que necesitamos realizar un intercambio de datos a través de la red y que no disponemos de conexión. Podríamos querer avisar al usuario de esta situación.

MVVM Light nos pone al alcance un tipo de mensaje llamado DialogMessage (desafortunadamente no es fácil encontrar documentación completa en la red sobre cada clase, afortunadamente ahí está el código para revisarlo).

Vamos a descomponer el problema en dos partes. Por un lado, necesitamos poder disponer de algún mecanismo declarativo que nos permita mostrar un cuadro de diálogo con título y texto variables (también sería bueno si pudiéramos mostrar diferentes acciones, pero eso me mete en un jardín en el que, por ahora, no quiero entrar).

Construir un Behavior para los Mensajes

Vamos a comenzar con la construcción de un Behavior que nos permita introducir declarativamente un cuadro de diálogo en la vista.

 1: using System;

 2: using System.Windows;

 3: using System.Windows.Interactivity;

 4: using GalaSoft.MvvmLight.Messaging;

 5:

 6: /// <summary>

 7: /// Clase que nos permitirá implementar un comportamiento para mostrar mensajes de forma ajustada al patrón MVVM

 8: /// </summary>

 9: public class DialogBehavior : Behavior<FrameworkElement>

 10: {

 11:     #region Miembros Públicos

 12:

 13:     public static DependencyProperty TituloProperty = DependencyProperty.Register("Titulo", typeof(string), typeof(DialogBehavior), new PropertyMetadata(String.Empty));

 14:     public static DependencyProperty IdentificadorProperty = DependencyProperty.Register("Identificador", typeof(string), typeof(DialogBehavior), new PropertyMetadata(String.Empty));

 15:     public static DependencyProperty TextoProperty = DependencyProperty.Register("Texto", typeof(string), typeof(DialogBehavior), new PropertyMetadata(String.Empty));

 16:

 17:     /// <summary>

 18:     /// Identificador

 19:     /// </summary>

 20:     public string Identificador

 21:     {

 22:         get

 23:         {

 24:             return (string)GetValue(IdentificadorProperty);

 25:         }

 26:         set

 27:         {

 28:             SetValue(IdentificadorProperty, value);

 29:         }

 30:     }

 31:

 32:     /// <summary>

 33:     /// Título a mostrar

 34:     /// </summary>

 35:     public string Titulo

 36:     {

 37:         get

 38:         {

 39:             return (string)GetValue(TituloProperty);

 40:         }

 41:         set

 42:         {

 43:             SetValue(TituloProperty, value);

 44:         }

 45:     }

 46:

 47:     //public string Titulo { get; set; }

 48:

 49:     /// <summary>

 50:     /// Texto a mostrar

 51:     /// </summary>

 52:     public string Texto

 53:     {

 54:         get

 55:         {

 56:             return (string)GetValue(TextoProperty);

 57:         }

 58:         set

 59:         {

 60:             SetValue(TextoProperty, value);

 61:         }

 62:     }

 63:

 64:     /// <summary>

 65:     /// Botones a mostrar

 66:     /// </summary>

 67:     public MessageBoxButton Botones { get; set; }

 68:

 69:     #endregion Miembros Públicos

 70:

 71:     #region Miembros Privados

 72:

 73:     private static Messenger _messenger = Messenger.Default;

 74:

 75:     /// <summary>

 76:     /// Método invocado para mostrar el mensaje

 77:     /// </summary>

 78:     /// <param name="dm"></param>

 79:     private void ShowDialog(GalaSoft.MvvmLight.Messaging.DialogMessage dm)

 80:     {

 81:         var result = MessageBox.Show(Texto, Titulo, Botones);

 82:

 83:         if (dm.Callback != null)

 84:             dm.Callback(result);

 85:     }

 86:

 87:     #endregion Miembros Privados

 88:

 89:     #region Miembros Protegidos

 90:

 91:     protected override void OnAttached()

 92:     {

 93:         base.OnAttached();

 94:

 95:         _messenger.Register<GalaSoft.MvvmLight.Messaging.DialogMessage>(this, Identificador, ShowDialog);

 96:     }

 97:

 98:     #endregion Miembros Protegidos

 99: }

De este código merede la pena destacar varias cosas.

  • Estamos heredando de la clase Behavior<FrameworkElement> que es el escenario más sencillo que podemos contemplar ahora mismo.
  • Hemos creado propiedades para el Identificador (ayuda a decidir sobre qué Diálogo estamos lanzando el mensaje), Título y Texto.
  • Como queremos que estas propiedades puedan estar enlazadas (ya sabes, DataBinding) con propiedades de la VistaModelo, hemos creado tres DependencyProperty por detrás que nos ayudarán en el soporte al DataBinding (si me limito a exponer las propiedades de Texto no es posible establecer el mencionado DataBinding)
  • Por lo demás, no mucho más. Lanzamos un MessageBox y llamamos a la función de callback (si la hay) con el resultado de la elección del usuario.

Ahora la vista

Con nuestro Behavior creado, nos vamos a la vista a declararlo.

 1: <i:Interaction.Behaviors>

 2:     <jdmv:DialogBehavior

 3:         Titulo="{Binding Path=TituloDialogo}"

 4:         Texto="{Binding Path=TextoDialogo}"

 5:         Botones="OKCancel"

 6:         Identificador="{Binding Path=IdMensajeMensaje}" />

 7: </i:Interaction.Behaviors>

Los espacios de nombres utilizados son los siguientes (he quitado unos cuantos para facilitar la lectura).

 1: <phone:PhoneApplicationPage

 2:     x:Class="Lcdad.SquareMatrix.ViewModel.FourSquareLogin"

 3:     xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

 4:     xmlns:jdmv="clr-namespace:Jdmveira.WindowsPhone.Mvvm.Messaging;assembly=Jdmveira.WindowsPhone">

No hay mucho que comentar. Las propiedades están enlazadas con propiedades de la VistaModelo.

Por último, la VistaModelo

Tan solo nos queda la VistaModelo, en ella he centralizado la utilización de los mensajes y los errores a través de dos métodos. Pongo el detalle de Mensaje por ser el más completo.

 1: /// <summary>

 2: /// Muestra un mensaje con opciones en pantalla

 3: /// </summary>

 4: /// <param name="titulo">Título del diálogo de error</param>

 5: /// <param name="texto">Texto a mostrar</param>

 6: /// <param name="callback">Instancia de <see cref="Action<MessageBoxResult>"/> con el método de callback para manejar la respuesta de usuario</param>

 7: private void Mensaje(string titulo, string texto, Action<MessageBoxResult> callback)

 8: {

 9:     TituloDialogo = titulo;

 10:     TextoDialogo = texto;

 11:

 12:     var msg = new DialogMessage(this, this, texto, callback);

 13:

 14:     DispatcherHelper.CheckBeginInvokeOnUI(() => { MessengerInstance.Send<DialogMessage>(msg, IdMensajeMensaje); });

 15: }

Que recibe los argumentos y se asegura de lanzar el cuadro de diálogo en el contexto del hilo de la UI.

Como podéis ver, su utilización es muy sencilla y permite desacoplar la operativa de mostrar el mensaje en pantalla. Hay todavía espacio para mejorarlo, pero es un buen comienzo.

Desarrollo de Windows Phone 7 con Visual Studio 2012 RC

Estoy decepcionado, no lo puedo evitar. Visual Studio 2012 RC sigue sin dar soporte a Windows Phone 7 SDK.

image

image

La pregunta del millón es: ¿Lo hará? Lo cierto es que sería lógico que sí, pero quizá la empresa de Redmon vaya  a centrarse en el soporte del próximo Windows Phone 8.

Bueno. Toca esperar y, mientras tanto, seguir con Visual Studio 2010.