Notificaciones de empuje para el desarrollo de Windows Phone

Notificaciones de empuje para el desarrollo de Windows Phone

Este artículo es una traducción del artículo original encontrado en: http://create.msdn.com/en-US/education/quickstarts/Push_Notifications.

Las aplicaciones de Windows Phone7 pueden recibir mensajes de Internet iniciados por un servidor, a través del uso de notificaciones Push (empuje). Estas notificaciones pueden ser recibidas por el usuario, incluso si la aplicación no se está ejecutando, y también pueden evitar que las aplicaciones estén jalando actualizaciones. Las notificaciones Push se transmiten a dispositivos de Windows Phone 7 por el Microsoft Push Notification Service (MPN).  

Este artículo contiene las siguientes secciones:

  • Video Tutorial
  • Información general de notificaciones Push
  • Creando un servicio Web que envía notificaciones Push
  • Publicando tu servicio Web en Windows Azure
  • Creando una aplicación de teléfono que recibe notificaciones Push
  • Probando

Descarga el código fuente completo para esta QuickApp en la Galería de Código de Silverlight para Windows Phone.

Video Tutorial

Para ver un ejemplo del funcionamiento del QuickApp en ejecución, y para construir este QuickApp siguiendo un vídeo en lugar de seguir leyendo este artículo, puedes ver el vídeo que se presenta a continuación.  La página de este vídeo en Channel 9 tiene varias opciones de descarga, versiones que se pueden reproducir en dispositivos que no sean una computadora, o si la transmisión de vídeo no es óptima para ti.

Información general de Notificaciones Push

El Microsoft Push Notification Service en Windows Phone ofrece a los desarrolladores un canal dedicado y persistente para enviar información y actualizaciones para una aplicación móvil desde un servicio web.  En el pasado, una aplicación móvil necesitaba sondear con frecuencia su servicio web para saber si existían notificaciones pendientes.  Aun siendo efectiva, el sondeo constante hace uso frecuente de la antena del dispositivo, reduciendo el tiempo de duración de la batería.  Usar notificaciones Push en vez de sondeo, un servicio web puede notificar una aplicación de importantes actualizaciones de una manera bajo demanda.

Cuando un Servicio Web tiene información para mandar a una aplicación, manda una notificación de tipo push (empuje) al Servicio de Notificaciones Push, el cual a su vez enruta la notificación a la aplicación. Dependiendo del formato de las Notificaciones Push y la carga adjunta, la información se entrega como datos en bruto a la aplicación y la aplicación es actualizada visualmente, o una notificación de tipo toast es desplegada.  La aplicación puede entonces contactar al servicio web usando su propio protocolo, si es necesario.

clip_image002

Éstos son los tipos de notificaciones Push compatibles con Windows Phone 7, junto con algunas consideraciones a tener en cuenta para cada uno.

Notificaciones en Mosaicos

  • Actualiza el Live Tile para la aplicación en la pantalla de inicio del teléfono, cambiando el gráfico, el título del mosaico, y el contador numérico pre-construido en el mosaico.
  • Son recibidas incluso si la aplicación está ejecutando.
  • Debe tener 80k o menos, y su descarga debe durar 15 segundos o menos.

Notificaciones en bruto (Raw):

  • Pueden ser utilizadas para cualquier cosa, pero tienen un límite de 1K, por lo que debes suministrar el URI para cualquier dato grande / binarios y manejar la descarga por separado.
  • Sólo se pueden recibir cuando la aplicación se está ejecutando.
  • No desencadenan ninguna reacción visible desde el teléfono, a menos que codifiques tu aplicación para que lo haga.  

Notificaciones Toast:

  • Contienen un mensaje corto, de sólo texto, con asunto y cuerpo.
  • Si la aplicación no está ejecutando, las notificaciones Toast se desplegarán en la parte superior de la pantalla del teléfono, superponiéndose a cualquier otra cosa.
  • Si la aplicación está ejecutando, las notificaciones Toast no desencadenan  ninguna reacción visible desde el teléfono, a menos que el código de la aplicación pueda hacerlo.

Hay un límite diario de 500 notificaciones Push por ChannelURI, a menos que carguen un certificado TLS de una autoridad certificadora  a tu cuenta de desarrollador del teléfono en AppHub.com y utilizarlo para autenticar tu servicio web con el MPNS. Para obtener más información, vea Cómo crear un servicio Web autenticado para Windows Phone.

Creando un servicio Web que envía notificaciones Push

Si deseas publicar su servicio web en Windows Azure, sigue los siguientes pasos:

1.       Instala la última versión de Windows Azure SDK  y regístrate para crear una cuenta gratuita de prueba o completa de Azure.

2.       Después de instalar el SDK de Azure, inicia un nuevo proyecto en Visual Studio usando la plantilla "Cloud" y selecciona "Windows Azure Project", asignando un nombre al proyecto. 

3.       Agrega un WCF Service Web Role a la solución de Windows Azure, a continuación modifica su nombre, escribe uno diferente al que colocaste anteriormente para el proyecto Azure. En este ejemplo, el rol se llama "PushService", que crea un servicio web con este nombre y se utiliza para su espacio de nombres predeterminado.

clip_image004

Introducir un nombre "PushService" va a generar un espacio de nombres con el mismo nombre, tal y como se ve en el código de abajo.

Si no estás planeando usar Azure, sigue estos pasos:

  1. Inicia Visual Studio y seleccione un proyecto de tipo "WCF" para el lenguaje deseado (se utilizará C# para el ejemplo).
  2. Selecciona "WCF Service Application" como tipo de proyecto, e introduce un nombre. En este ejemplo, el proyecto se llama "PushService", que crea un servicio web con el nombre utilizado para el espacio de nombres predeterminado.  

Una vez que el proyecto se carga en Visual Studio, abre IService1.cs y borra el contenido predeterminado de la clase Service1.

En IService1.cs, escribe las signaturas de los cuatro métodos, precedidos por el atributo OperationContract: 

1.       SubscribeMyPhone, que recibirá un GUID que representa el ID del teléfono que se está inscribiendo para recibir las notificaciones Push de este servicio, y un objeto URI representando el URL del Microsoft Push Notification Service en el cual las notificaciones Push que se retransmitirán al teléfono pueden ser recibidas.

2.       PushRawData, que recibe un mensaje que será enviado como una notificación en bruto a todos los teléfonos que se han registrado al servicio con una llamada previa a SubscribeMyPhone.

3.       PushToast, que recibe un mensaje que se envía como una notificación Toast a todos los teléfonos que se han registrado en el servicio con una llamada previa a SubscribeMyPhone.

4.       PushTileUpdate,  que recibe los parámetros que definen una Actualización de Mosaico que se enviará a todos los teléfonos que se han registrado en el servicio con una llamada previa a SubscribeMyPhone.

El contenido final de IService1.cs después de escribir estos métodos es el siguiente:

C # (IService1.cs)

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.Serialization;

using System.ServiceModel;

using System.ServiceModel.Web;

using System.Text;

namespace PushService

{

[ServiceContract]

public interface IService1

{

[OperationContract]

void SubscribeMyPhone(Guid phoneID, string channelURI);

[OperationContract]

void PushRawData(string rawMessage);

[OperationContract]

void PushToast(string toastTitle, string toastMessage);

[OperationContract]

void PushTileUpdate(string tileTitle, int tileCount, string tileImageURI);

}

}

 

En Service1.svc.cs, escribimos el código que implementa estos métodos como parte de la clase por defecto llamada Service1, la cual está en el espacio de nombres predeterminado, PushService.  Service1 contiene las implementaciones de los siguientes miembros:  

 

1.  SubscriptionURIs es un diccionario de tipo <Guid, Uri> que rastrea el GUID de los  teléfonos que han llamado a SubscribeMyPhone y han provisto un Channel URI en dondepueden recibir las notificaciones Push.   

2.  BatchingIntervalValues ​​es una enumeración que define los diferentes tiempos de espera que se pueden utilizar para retrasar cuando una notificación Push será enviada al teléfono desde el Servicio de Notificaciones Push. 

3.  sendPushToSubscribedURIs es un método que recibe la salida de los cuatro métodos que se definen en IService1.cs, los empaqueta en el cuerpo de un paquete HTTP Post que tiene encabezados personalizados que habilitan la funcionalidad de las Notificaciones Push, y envía el paquete final a todos los Canales URI definidos en el diccionario SubscriptionURIs. Estos URIs son proporcionados por el Microsoft Push Notification Service, el cual transmitirá los mensajes a los teléfonos destinados.

4.  SubscribeMyPhone se implementará para actualizar SubscriptionURIs con los Canales URI entrantes.

5.  PushRawData se implementará para codificar el mensaje entrante como arreglo de tipo byte[] y enviar el resultado a sendPushToSubscribedURIs.

6.       PushToast se implementará para codificar el mensaje entrante en una stream XML con una estructura específica que espera Microsoft Push Notification Service, y envía el resultado a sendPushToSubscribedURIs.

7.       PushTileUpdate se implementará para codificar la Actualización de Mosaico entrante en un stream XML con una estructura específica que espera Microsoft Push Notification Service, y envía el resultado a sendPushToSubscribedURIs.

Cuando se haya completado, el archivo final de Service1.svc.sc se verá de la siguiente manera:

C # (Service1.svc.cs)

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.Serialization;

using System.ServiceModel;

using System.ServiceModel.Web;

using System.Text;

using System.Xml;

using System.IO;

using System.Net;

namespace PushService

{

public class Service1 : IService1

{

// Constructor de encargo

public Service1()

{

/ / TODO: Carga de la base de datos en SubscriptionURIs.

}

/ / Datos de los miembros.

/ / Permanece en la lista de dispositivos a channelURI, que se actualiza

/ / mediante llamadas a SubscribeMyPhone ();

private static Dictionary<Guid, Uri> SubscriptionURIs = new Dictionary<Guid, Uri>();

/ / Esto sobrescribe / crea las entradas para cada teléfono que desea recibir / /notificaciones Push.

/ / Nota: Esta lista se pone a cero cada vez que reinicia la aplicación

/ / Almacenar estos datos en la lista SubscriptionURIs en una base de datos

/ / Hay secciones TODO en el código.

public void SubscribeMyPhone(Guid phoneID, string channelURI)

{

Uri thisURI = new Uri(channelURI);

if (SubscriptionURIs.ContainsKey(phoneID))

{

/ / Actualizar la entrada URI para el teléfono, si es necesario

 SubscriptionURIs[phoneID] = thisURI;

}

else

{

/ / Si no, agregar una suscripción para el teléfono

SubscriptionURIs.Add(phoneID, thisURI);

}

/ / TODO: guardar estos datos en una base de datos, de lo contrario se perderán en el reinicio de aplicaciones.

}

/ / Envía el valor de texto recibidos en la notificación

/ / Mientras que la aplicación de teléfono suscrito se está ejecutando.

/ /Notificar que poseen un límite de tamaño de 1K.

public void PushRawData(string rawMessage)

{

Codifica el mensaje como un byte matriz en el Servicio de Notificación de Espera.

System.Text.UTF8Encoding encoding = new UTF8Encoding();

//Send this message to all subscribed devices.

sendPushToSubscribedURIs(encoding.GetBytes(rawMessage), "raw");

}

/ /envía una notificación toast, utilizando los argumentos para definir el

/ /título y la notificación del mensaje.

public void PushToast(string ToastTitle, string ToastMessage)

{

/ / Use el  XMLWriter para construir la estructura de notificación

/ /contenidos.

MemoryStream myStream = new MemoryStream();

XmlWriter myWriter = XmlWriter.Create(myStream);

myWriter.WriteStartDocument();

myWriter.WriteStartElement("wp", "Notification", "WPNotification");

myWriter.WriteStartElement("wp", "Toast", "WPNotification");

myWriter.WriteStartElement("wp", "Text1", "WPNotification");

myWriter.WriteValue(ToastTitle);

myWriter.WriteEndElement();

myWriter.WriteStartElement("wp", "Text2", "WPNotification");

myWriter.WriteValue(ToastMessage);

myWriter.WriteEndElement();

myWriter.WriteEndElement();

myWriter.WriteEndDocument();

//Transfer Xml Outpute from myWriter’s buffer to myStream.

myWriter.Flush();

// Envía este mensaje a todos los dispositivos suscrito.

sendPushToSubscribedURIs(myStream.ToArray(), "toast");

}

/ /Envía el título Tile, la cuenta Tile y la URL de la imagen Tile como una

/ /notificación Tile, que sólo se pueden recibir al mismo tiempo la

/ /aplicación de teléfono cuando no está en ejecución.
/ / El tamaño máximo permitido de la imagen Tile es 80kb, con un
/ / tiempo máximo de descarga de 15 segundos. Sólo las imágenes Tile URL de

/ /los dominios mencionados en ListOfAllowedDomains podrán ser aceptadas.
/ / El Título Azure sobrescribirá el texto de las etiquetas en el menú del

/ /teléfono, y las cuentas Tile muestra un valor numérico aparece en la parte

/ /superior de la imagen, visualmente.

public void PushTileUpdate(string TileTitle, int TileCount, string TileImageURL)

{

/ / Uso de XmlWriter para la construcción de la estructura de notificación

/ /contenidos.

MemoryStream myStream = new MemoryStream();

XmlWriter myWriter = XmlWriter.Create(myStream);

myWriter.WriteStartDocument();

myWriter.WriteStartElement("wp", "Notification", "WPNotification");

myWriter.WriteStartElement("wp", "Tile", "WPNotification");

myWriter.WriteStartElement("wp", "BackgroundImage", "WPNotification");

myWriter.WriteValue(TileImageURL);

myWriter.WriteEndElement();

myWriter.WriteStartElement("wp", "Count", "WPNotification");

myWriter.WriteValue(TileCount);

myWriter.WriteEndElement();

myWriter.WriteStartElement("wp", "Title", "WPNotification");

myWriter.WriteValue(TileTitle);

myWriter.WriteEndElement();

myWriter.WriteEndElement();

myWriter.WriteEndDocument();

// Transferencia de salida XML a partir del búfer myWriter a MyStream.

myWriter.Flush();

// Envía este mensaje a todos los dispositivos suscrito.sendPushToSubscribedURIs(myStream.ToArray(), "tile");

}

/ /Esta enumeración da nombres simbólicos a los valores numéricos utilizados  / /para "lotes juntos" de las Notificaciones push de acuerdo con los

/ /intervalos de tiempo especificados. Puedes enviar notificaciones

/ /inmediatamente, a menos de 450 segundos, o dentro de 900 segundos.

/ /Permitir las notificaciones de servicios para tratar las notificaciones

/ /por lotes que dejaran mensajes en grupo junto con las notificaciones de

/ /otros app para ahorrar la duración de la pila del teléfono.

enum BatchingIntervalValues

{

ImmediateTile = 1,

ImmediateToast = 2,

ImmediateRaw = 3,

Wait450SecondsTile = 11,

Wait450SecondsToast = 12,

Wait450SecondsRaw = 13,

Wait900SecondsTile = 21,

Wait900SecondsToast = 22,

Wait900SecondsRaw = 23

}

/ / Itera a través de SubscriptionURIs, el envío de la construcción a las

/ /notificaciones Push Notification que define a todos los dispositivos

/ /suscritos a través de Microsoft él en servicio ‘Push Notificación. La

/ /carga se empaqueta en un HTTP POST. Mensaje que define cabeceras que

/ /contienen el tipo de notificación y procesamiento por lotes de intervalo.

private static void sendPushToSubscribedURIs(byte[] pushPayload, string notificationType)

{

// Iterar a través de SubscriptionURIs

foreach (var thisURI in SubscriptionURIs.Values)

{

/ /Agregar encabezados de HTTP en mensajes en línea.

var myRequest = (HttpWebRequest)WebRequest.Create(thisURI); // Push Client’s channelURI

myRequest.Method = WebRequestMethods.Http.Post;

myRequest.ContentType = "text/xml";

myRequest.ContentLength = pushPayload.Length;

/ /Da este mensaje de un identificador único

myRequest.Headers.Add("X-MessageID", Guid.NewGuid().ToString());

/ / Personaliza o excluye el encabezado X-WindowsPhone-objetivo basado en el tipo de notificación.

switch (notificationType)

{

case "toast":

myRequest.Headers["X-WindowsPhone-Target"] = "toast";

myRequest.Headers.Add("X-NotificationClass",

((int)BatchingIntervalValues.ImmediateToast).ToString());

break;

case "tile":

myRequest.Headers["X-WindowsPhone-Target"] = "token";

myRequest.Headers.Add("X-NotificationClass",

((int)BatchingIntervalValues.ImmediateTile).ToString());

break;

case "raw":

myRequest.Headers.Add("X-NotificationClass",

((int)BatchingIntervalValues.ImmediateRaw).ToString());

/ / Las notificaciones primas no especifican un valor para la cabecera X-WindowsPhone-Blanco.

break;

}

// Combinar encabezados con la carga útil.

using (var requestStream = myRequest.GetRequestStream())

{

requestStream.Write(pushPayload, 0, pushPayload.Length);

}

// Enviar notificación a este teléfono!

var response = (HttpWebResponse)myRequest.GetResponse();

}

}

}

}

Como paso final, incluye algunos archivos .png que se utilizarán como gráficos de mosaico alternativos para la aplicación del teléfono.  Puedes utilizar los archivos .png incluidos en el código de ejemplo para descargar o crear uno propio.  Los mosaicos deben ser de 80K o más pequeño en tamaño y tener una resolución de 173 x 173 píxeles.  Añade los archivos .png en el proyecto del servicio web, haciendo clic derecho en el rol de servicio web y seleccionando la opción "Add Existing Item".  Una vez visible en el Explorador de soluciones, haz clic en los archivos .png, y en el panel Propiedades establece la propiedad “Copy to Output Directory" a "Always".

El servicio web ahora está completo y listo para ser publicado.  Si no estás interesado en la publicación en Azure, puedes ejecutar este servicio en cualquier servidor IIS que tenga conectividad a Internet (para entrar en contacto con el MPNS) y pueda ser alcanzado por tu dispositivo Windows Phone 7 o el emulador de Windows Phone.

Publicando tu servicio Web en Windows Azure

1.       Regístrate para una cuenta Azure.  Una vez completado el registro, inicia sesión en http://windows.azure.com  con el LiveID asociado con tu cuenta de Azure y asegúrate de que tengas acceso a las herramientas de gestión de Azure.  

2.       Suponiendo que has seguido las instrucciones anteriores de la creación del proyecto, haz clic derecho sobre el proyecto Azure en el Explorador de Soluciones (que cuenta con un icono de globo) y selecciona "Publish" en el menú, como se muestra aquí:

clip_image006

3.       La ventana de despliegue aparecerá. En la lista desplegable "Credentials", selecciona "Add", como se muestra aquí: 

clip_image008

 

4.       En la ventana Windows Azure Project Management Authentication, desplázate hacia abajo a la parte inferior de la lista de credenciales, y selecciona "Create".  Coloca un nombre significativo a estas credenciales, ya que pueden ser reutilizados para cualquier actividad futura en cualquier servicio alojado en tu cuenta.  A continuación haz clic en el vínculo "copy the full path" del archivo de credenciales que has creado, después haz clic en el vínculo para visitar el Portal de Windows Azure en la web, con la ruta del archivo de certificado en el portapapeles.

 

clip_image010

 

5.       En el Portal de Windows Azure, entra en el menú "Management Certificates" en la sección "Hosted Services, Storage Accounts & CDN".  A continuación haz clic en el botón "Add Certificate" alojado en la barra de navegación de la parte superior.  Luego haz clic en "Browse" cuando te pide que selecciones un certificado para añadir, seguidamente pega la ruta completa del certificado que creaste en el paso 4 y haz clic en "OK".  Esto carga el nuevo certificado, genera un ID de subscripción que está asociado con el certificado.  Copia el ID de subscripción a tu portapapeles, y vuelve a Visual Studio.    

clip_image012

6.       En Visual Studio, pega el ID de subscripción en la tercer caja de texto de la ventana Windows Azure Project Management Authentication, y a continuación haz clic en "OK" para guardar la credencial autenticada.

7.       De vuelta en el Portal de Windows Azure, haz clic en " Storage Accounts " en el menú de la izquierda, y luego en la parte superior "New Storage Account".  Dale a tu cuenta de almacenamiento un nombre significativo.  Esta cuenta se puede reutilizar para otros servicios que hospedes en Windows Azure.  Elije un centro de datos que se encuentre en una zona conveniente, a continuación haz clic en "Create" para crear la nueva cuenta de almacenamiento. 

clip_image014

 

8.       En el Portal de Windows Azure, haz clic en "Hosted Services" en el menú de la izquierda, luego en "New Hosted Service" en la parte superior.  Escribe un nombre significatico y un prefijo URL para este servicio.  Ambos serán únicos para este servicio web en particular. Elije el mismo centro de datos donde se creó la cuenta de almacenamiento (para evitar las  tarifas de tráfico entrante a través de los centros de datos) y selecciona la opción de radio "Do Not Deploy".  Haz clic en "OK" para crear un Servicio Hospedado en blanco.

clip_image016

 

9.       De nuevo en Visual Studio, cierra la ventana Deploy Windows Azure Project y vuelve a abrirla haciendo clic derecho sobre el proyecto Azure y seleccionando de nuevo la opción "Publish".  Esta vez, selecciona tus nuevas credenciales en la lista desplegable "Credentials".  Visual Studio cargará las cuentas de servicios de almacenamiento y hospedados que están asociadas con el identificador de la suscripción para este certificado.  Luego cambia el entorno de despliegue a "Production".  A continuación, haz clic en "OK" para publicar tu servicio web en Windows Azure.  Este paso puede tardar varios minutos.  El registro de actividad de Windows Azure muestra el estado actual mientras que el servicio es publicado e inicializado.    

clip_image018

 

10.    Cuando esto se haya completado, el servicio web será accesible en la URL del sitio web enlistado en el Windows Azure Activity Log.  Esta dirección URL coincidirá con el prefijo de URL que introdujiste para el servicio hospedado.  Agrega el nombre del archivo .svc al final de la URL para ver una declaración de WSDL para tu servicio web (por ejemplo, http://my_url_prefix.cloudapp.net/Service1.svc).  Tu servicio ahora se está ejecutando en vivo sobre Windows Azure y está listo para ser consumido.

clip_image020

Creando una aplicación de teléfono que recibe notificaciones Push

Asegúrate de que el servicio web Push, que hemos creado antes, se ha desplegado y tiene conectividad a Internet para que puedas retransmitir mensajes a Microsoft Push Notification Service. En la sección anterior, hemos conseguido esto mediante su publicación en Windows Azure.

Ahora inicia Visual Studio y abre un proyecto de tipo "Silverlight para Windows Phone".  A continuación, crea una interfaz de usuario (UI) que tenga los siguientes elementos:

·         Un TextBlock llamado subscriptionStatus cuyo texto tenga "Checking subscription status…"

·         Un TextBlock llamado rawmessage, con un tamaño de dos líneas, con su propiedad TextWrapping en "Wrap". Dar a la propiedad Text el valor " Waiting to Receive Raw Notification" 

·         Un TextBlock llamado channelURITextBlock, con un tamaño cuatro líneas de alto, con su propiedad TextWrapping en "Wrap". Dar a la propiedad Text el valor  "This App’s ChannelURI: ". 

Un arreglo sugerido de estos elementos se proporciona a continuación. Aquí, un cuarto TextBlock aparece con las instrucciones de despliegue y prueba en color azul claro.  Esto es para ayudarte a ejecutar el código de ejemplo, que se basa en la conectividad a Internet, un servicio web en directo y las Notificaciones Push que serán enviadas sólo después de una ejecución inicial de esta aplicación de teléfono.  Además, debido a estas dependencias, el ejemplo del proyecto necesita un par de modificaciones antes de que pueda ejecutar en tu teléfono. Este TextBlock no es mencionado en otras partes de este artículo o en el propio código.

clip_image022

El código final XAML que contiene estos elementos se muestra a continuación:

XAML (MainPage.xaml)

<-! LayoutRoot es la red de la raíz donde se encuentra todo el contenido de la página ->

<Grid X:Name="LayoutRoot" Background="Transparent">

<Grid.RowDefinitions>

<RowDefinition Height="Auto"/>

<RowDefinition Height="*"/>

</ Grid.RowDefinitions>

<-! TitlePanel contiene el nombre de la aplicación y el título de la página ->

<StackPanel X:Name="TitlePanel" Grid.Row="0" Margin="12,17,0,28">

<TextBlock X:Name="PushDemo" Text="JoMul Presione Demo" Style="{StaticResource PhoneTextNormalStyle}"/>

</ StackPanel>

<-! ContentPanel – colocar el contenido adicional aquí ->

<Grid X:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">

<TextBlock Height = "30" HorizontalAlignment = "top" Margin = "12,460,0,0" Nombre = "subscriptionStatus"

Text = "Verificar el estado de suscripción…" VerticalAlignment = "Top" width = "438" />

<TextBlock Height = "380" HorizontalAlignment = "top" Margin = "12,77,0,0" Name="instructions" Text="To use:

1) Implementar el servicio ‘Push a un host de Internet de acceso (como Azure).

2) En este proyecto (Push cliente) haga clic derecho en el ServiceReference1 del Explorador de soluciones, luego haga clic en "Configuración de servicio de referencia", en la actualización de la dirección URL con Push nuevo servicio de WSDL.

3) Editar ListOfAllowedDomains en MainPage.xaml.cs para incluir el dominio que ahora alberga el servicio ‘Push.

4) Poner en marcha esta aplicación (Push de clientes) en el teléfono por lo que se registra para recibir notificaciones.

5) En el PC, abrir en símbolo del sistema el WCFTestClient de Visual Studio. En el cliente, Presione URL del servicio de WSDL, a continuación, invocar los métodos que envían notificaciones a tu teléfono!

"VerticalAlignment =" Top "width =" 426 "TextWrapping =" Wrap"

TextAlignment = "Left" Foreground="Cyan" Visibility="Visible" />

<TextBlock Height = "134" HorizontalAlignment = "Left" Margin = "12,556,0,0" Name = "channelURITextBlock"

Text="This App’s ChannelURI: " VerticalAlignment="Top" Width="426" TextWrapping="Wrap />  

<TextBlock X:Name="PageTitle" Text="Push Client" Margin="12,-7,-3,613" Style="{StaticResource PhoneTextTitle1Style}"/>

< TextBlock Height="70" HorizontalAlignment="Left" Margin="12,493,0,0" Name="rawmessage" Text="Waiting to receive Raw notification." VerticalAlignment="Top" Width="414" TextWrapping="Wrap"/>

</ Grid>

</ Grid>

 

En el Explorador de Soluciones, haz clic derecho en "References" y selecciona "Add Service Reference’’.  Introduce la dirección del URL del archivo .svc (por ejemplo, http://your_url_prefix.cloudapp.net/Service1.svc), y haz clic en "Go". Una vez que confirmes que Visual Studio ha logrado descubrir el servicio Push, ten en cuenta el espacio de nombres que se asigna a esta referencia de servicio web que es "ServiceReference1" por defecto, a continuación, haz clic en "OK".  El servicio Push ahora  puede accedido a través del espacio de nombres ServiceReference1 en el código de la aplicación.

Abre MainPage.xaml.cs y añade una referencia a los siguientes espacios de nombres: System.IO.IsolatedStorage, System.IO, Microsoft.Phone.Notification, y System.Collections.ObjectModel.

En la parte superior de la clase MainPage, agrega los miembros siguientes datos:

  1. Un GUID llamado deviceID, que vamos a utilizar para almacenar un identificador único para este teléfono.
  2. Un "ServiceReference1.Service1Client" llamado myclient, que utilizaremos para acceder a el servicio Push. Si cambiaste el nombre por defecto del namespace de referencia del servicio o el namespace del servicio Push, este tipo tendrá un nombre diferente.  En este artículo se asumen los valores por defecto.
  3. Un HttpNotificationChannel llamado myPushChannel. Este es el canal que va a "escuchar" las notificaciones Push que se transmiten desde el Microsoft Push Notification Service.  

Ahora implementaremos algunos métodos que permitirán a la aplicación estar lista para la recepción de notificaciones Push:

1.                   En el método MainPage(), comprobamos el almacenamiento aislado en el teléfono (memoria interna accesible sólo por esta aplicación) por un valor con clave "DeviceID".  Si un valor es encontrado, se carga desde el almacenamiento aislado y es asignado a deviceID. De lo contrario, un nuevo valor GUID es generado, asignado y almacenado.

2.                   También en MainPage(), comprobamos si existe un HttpNotificationChannel con la clave "myChannel". Si no, se crea y se almacena allí, y después las funciones para manejar los eventos son adjuntadas.  A continuación el canal es abierto, el cual solicitará un nuevo canal de asignación de URI del MPNS, en la cual las Notificaciones Push pueden ser recibidas por este canal.  Si este canal ya existía previamente, simplemente adjuntamos las funciones de manejo de eventos y pasamos por el canal existente URI para el servicio Push.

3.                   Un método llamado attachHandlerFunctions() se implementa para los delegados que recibirá el callback cuando ciertos eventos sean disparados. El evento ErrorOccurred es manejado, el cual se dispara cuando si se origina una excepción en myPushChannel.  El evento HttpNotificationReceived es manejado,  el cual se dispara cuando una notificación en bruto (raw) es recibida.  El evento ChannelUriUpdated es manejado, el cual se dispara cuando MPNS asigna o actualiza un nuevo URI para myPushChannel.  Por último, un evento en myclient llamado SubscribeMyPhoneCompleted es manejado.  Este evento se dispara cuando una llamada a SubscribeMyPhone() se completa correctamente.  Ten en cuenta que no tuviste que generar este evento, se genera automáticamente cuando agregas una referencia al servicio Push.

A continuación, debemos implementar los delegados que hemos asignado para manejar los eventos especificados en attachHandlerFunctions(): 

  1. myPushChannel_ErrorOccurred simplemente desplegará el mensaje de error en la pantalla utilizando el TextBlock subscriptionStatus. 
  2. myPushChannel_HttpNotificationReceived decodificará las Notificaciones Push de tipo raw usando un StreamReader y lo desplegará en pantalla con el TextBlock rawmessage.  Sin embargo, debido a que los eventos Push son disparados en el hilo de la Notificación, la actualización de rawmessage se maneja con el método BeginInvoke() de la clase Dispatcher.
  3. myClient_SubscribeMyPhoneCompleted despliega un mensaje indicando que el teléfono ha cargado correctamente los valores de deviceID y ChannelURI de la aplicación al servicio Push, mostrando la cadena "Subscribed!"  en el TextBlock subscriptionStatus.
  4. myPushChannel_ChannelUriUpdated es el delegado más complejo.  Aquí, la aplicación verifica que myPushChannel puede recibir notificaciones Push incluso cuando la aplicación no se esté ejecutando mediante la comprobación de los valores de IsShellToastBound y IsShellTileBound. Si estos valores son "falsos", la aplicación enlaza el canal al shell para que estas notificaciones puedan ser recibidas cuando la aplicación no esté ejecutando, pasando una lista de dominios que están autorizados a enviar dichas actualizaciones.  Aquí, el dominio en el que publicamos el servicio Push se especifica (por ejemplo http://your_url_prefix.cloudapp.net).  La recuperación exitosa del URI de un canal en vivo se muestra en pantalla, nuevamente utilizando el método BeginInvoke() de la clase Dispatcher, y una llamada a SubscribeMyPhone() garantiza que este URI sea conocido por el servicio Push.  

Ahora el MainPage.xaml.cs debe parecerse a esto:

C # (MainPage.xaml.cs)

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using Microsoft.Phone.Controls;

//added

using System.IO.IsolatedStorage;

using System.IO;

using Microsoft.Phone.Notification;

using System.Collections.ObjectModel;

namespace Push_Client_Example

{

public partial class MainPage : PhoneApplicationPage

{

/ /Datos de los miembros de esta clase
/ /Un identificador único para el teléfono, guardar en la memoria Guid

/ /deviceID;

/ / Añadir una referencia a su desplegado y presione el  URL del servicio y

/ /el nombre de ServiceReference1 y esta línea se compilará. En el Explorador / /de soluciones, Haga clic en "Add Service Reference", entonces se

/ /incorporara la URL para el archivo SVC, para entrar en el servicio haga

/ /clic en "Go". Compruebe que los cuatro métodos del Servicio son expuestos / /a continuación, haga clic en "OK".

ServiceReference1.Service1Client myClient = new ServiceReference1.Service1Client();

/ / URI para el canal de notificación de app.

HttpNotificationChannel myPushChannel;

// Constructor

public MainPage()

{

InitializeComponent();

/ / En primer lugar, generar un GUID en este teléfono y guardarlo; para

/ /mantener la coherencia con los datos de servicio.

if (IsolatedStorageSettings.ApplicationSettings.Contains("DeviceId"))

{

/ / carga existentedeviceID = (Guid)IsolatedStorageSettings.ApplicationSettings["DeviceId"];

}

else

{

/ /generar nuevo ID

deviceID = Guid.NewGuid();

IsolatedStorageSettings.ApplicationSettings["DeviceId"] = deviceID;

}

/ / A continuación, cree un canal de comunicación que tendrá su propio URI que el servicio web se necesita saber. Estamos nombrando el canal para el
/ / app "myChannel". Los canales sólo necesitan ser creados una vez por

/ /aplicación;
/ / si el URI nunca cambia, el evento ChannelUriUpdated se disparará. Este
/ / evento también se activa cuando el canal se crea por primera vez
.

myPushChannel = HttpNotificationChannel.Find("myChannel");

/ / verificaca si el canal ya se ha creado, si es así, se reutiliza

if (myPushChannel == null)

{

rawmessage.Text += "Channel was null.";

/ / Este canal tiene que ser creado. ChannelUriUpdated se disparará al

/ /finalizar.

myPushChannel = new HttpNotificationChannel("myChannel"); //create, then attach delegates, then Open()

attachHandlerFunctions();

myPushChannel.Open();

/ /No se disparará el ChannelUriUpdated si ningún controlador está conectado primero!}

else

{

rawmessage.Text += "Channel was found!";

/ / ChannelUriUpdated no va a disparar. Llame al método de suscripción de servicios web. Fije los delegados.

myClient.SubscribeMyPhoneAsync(deviceID, myPushChannel.ChannelUri.ToString());

}

}

void attachHandlerFunctions()

{

/ / Asigne a los delegados a impulsar eventos de canal

/  /si existe error, impresión en pantalla

myPushChannel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(myPushChannel_ErrorOccurred);

/ / Después de llamar a SubscribeMyPhone completa, notifique el suceso

myClient.SubscribeMyPhoneCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(myClient_SubscribeMyPhoneCompleted);

/ / ChannelUriUpdated se dispara cuando el canal se crea por primera vez o

/ /existen cambios en el canal URI

myPushChannel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(myPushChannel_ChannelUriUpdated);

/ / Procesar las notificaciones push, mientras que la aplicación se está

/ /ejecutando.

myPushChannel.HttpNotificationReceived += new EventHandler<HttpNotificationEventArgs>(myPushChannel_HttpNotificationReceived);

}

void myPushChannel_HttpNotificationReceived(object sender, HttpNotificationEventArgs e)

{

myReader = new StreamReader(e.Notification.Body);

rawmessage.Text = "Received Raw Notification: " + myReader.ReadToEnd();

});

}

void myPushChannel_ChannelUriUpdated(object sender, NotificationChannelUriEventArgs e)

{

/ /Los disparadores a partir de los hilos del Shell, son actualizados en la

/ /interfaz de usuario que utiliza un despachador.

/ / Hay un par de cosas que queremos hacer, una vez que sabemos que tenemos un canal válido del MPN. Entonces:
/ / 1) Hacer la carcasa del teléfono que está autorizado para recibir Azulejo y  realizar //actualizaciones cuando la aplicación no se está ejecutando.

if (myPushChannel.IsShellTileBound == false)

{

var ListOfAllowedDomains = new Collection<Uri> {

/ / Listas de dominios que puede enviar actualizaciones y así sucesivamente como //notificaciones push.
/ / Sólo estos dominios autorizado serán permitido por el shell

//nuevo Uri (@ "http://TU WEB DE SERVICIO, AQUÍ VA DE DOMINIO")
/ / por ejemplo, Si ha publicado un servicio web en http://foo.com/service1.svc – poner //"http://foo.com" aquí.

};

/ / Registro de este canal con el shell,
/ / dominio en el método de Espera

myPushChannel.BindToShellTile(ListOfAllowedDomains);

}
/ /2)  Se envía un  mensaje, cuando la aplicación no se está ejecutando

if (myPushChannel.IsShellToastBound == false)

{

myPushChannel.BindToShellToast();

}

/ / 3) Demostrar que este evento disparado en la pantalla.

Deployment.Current.Dispatcher.BeginInvoke(() =>

{

rawmessage.Text = "uri updated";

});

/ / 4) Pase al nuevo ChannelUri en el servicio de suscripción.

myClient.SubscribeMyPhoneAsync(deviceID, e.ChannelUri.ToString());

}

void myClient_SubscribeMyPhoneCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)

{

/ / Maneja la terminación de llamada a SubscribeMyPhone () en el servicio web

if (e.Error == null)

{

/ / No hay error del lado del servidor

subscriptionStatus.Text = "Subscribed!";

}

else

{

/ / mostrar el error en pantalla

subscriptionStatus.Text = e.Error.Message;

}

/ / Como último paso, yimprimir su valor en pantalla. No hacer esto en tiempo real
/ /En este caso, es sólo mostrar cómo funciona MPN

channelURITextBlock.Text = myPushChannel.ChannelUri.ToString();

}

void myPushChannel_ErrorOccurred(object sender, NotificationChannelErrorEventArgs e)

{

/ / Maneja error de canal indirecto causado por excepción

subscriptionStatus.Text = e.Message;

}

}

}

 

Probando

 

Si vas a probar en el emulador de Windows Phone sigue estas instrucciones para asegurarte de que un proxy SOCKS se ha introducido en las opciones de Internet en el Panel de Control de tu equipo.

 

Ejecuta la aplicación del teléfono.  Debes ver la cadena " Subscribed! " en la pantalla, así como el URI del canal del Microsoft Push Notification Service.  Esto significa que el teléfono está listo para recibir notificaciones Push.  Para enviar estas notificaciones, vamos a utilizar una herramienta que invoque el servicio Push.

 

Abre el símbolo del sistema de Visual Studio del y escribe "WCFTestClient".  Esta herramienta también puede ser accedida mediante la introducción de las siguientes rutas %ProgramFiles(x86)%\Microsoft Visual Studio 10.0\Common7\IDE (en sistemas de 64 bits) y %ProgramFiles%\Microsoft Visual Studio 10.0\Common7\IDE (en sistemas de 32 bits).


En el cliente de pruebas WCF, ve a "File" > "Add Service", e introduce la URL del archivo. svc para el servicio Push (
http://your_url_prefix.cloudapp.net/Service1.svc).

 

Utilizando el cliente de pruebas WCF, invoca el método PushRawData() mientras la aplicación se esté ejecutando, mandando una cadena a la aplicación.  Deberá aparecer en la pantalla muy rápidamente.


Salte de la aplicación pulsando el botón "Atrás", y ancla tu aplicación en el menú de inicio del teléfono haciendo un largo toque en el icono de tu aplicación y seleccionando "Pin to Start" en el menú emergente.  Ahora desliza el menú del teléfono para que se muestre la pantalla de inicio.

 

Utilizando el cliente de pruebas WCF invoca el método PushTileUpdate(), introduciendo la URL de uno de los archivos. png que incluiste cuando desplegaste el servicio Push (http://your_url_prefix.cloudapp.net/tile1.png) como el valor del parámetro TileImageURL. Escribe lo que quieras para los demás parámetros.  El Live Tile de la aplicación en el menú de inicio se actualizará momentáneamente mostrando todas las modificaciones.

 

Por último, invoca el método PushToast(), entrando un título y un cuerpo para tu mensaje.  La notificación aparecerá en la pantalla del teléfono, y podrás pulsarla para volver a entrar en la aplicación.

clip_image024

One thought on “Notificaciones de empuje para el desarrollo de Windows Phone

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">