Leer un XML en Windows Phone 8.0 y 8.1

September 22nd, 2014 No comments

Lee el post original de Amin Espinoza en El blog de Kañaz.

Si eres un desarrollador de aplicaciones y estás comenzando con una nueva plataforma definitivamente vas a hacer un “Hola mundo”. Después de hacerlo, el siguiente paso es comenzar a explorar la posibilidad de recibir datos y acomodarlos de manera ordenada y agradable a la vista de los usuarios. En este artículo vamos a ver como puedes hacer una aplicación básica de lectura de feeds que es un gran ejemplo de como manejar archivos XML. Lo más importante de esto es como hacerlo en las dos versiones de Windows Phone que ahora se encuentran disponibles así que comencemos. Leer más…

Categories: Artículos Tags:

Manejando contenedores de blobs

September 21st, 2014 No comments

Lee el post original de Víctor Moreno en: Azure Sin Límites

  • Crear una cuenta en el Azure Storage.
  • Identificar que es un contenedor de Blobs.
  • Como crear contenedores de Blobs.
  • Como listar contenedores de Blobs.
  • Como eliminar contenedores de Blobs.
Categories: Uncategorized Tags:

Noches de innovación a la mexicana.

September 16th, 2014 No comments

Lee el post original de Saturnino Pimentel en El blog de Satur.

Como ya he comentado en un post anterior he tenido el gusto de participar en noches de innovación a la mexicana con el tema nuevas características de C# 6.0 donde he mostrado lo que probablemente sean las nuevas características de este lenguaje. Leer mas…

Categories: Uncategorized Tags:

Creando una cuenta para acceder al Azure Storage

September 15th, 2014 No comments

Lee el post original de Víctor Moreno en: Azure Sin Límites

  • Crear una cuenta en el Azure Storage.
  • Escribir código para acceder al Azure Storage.
  • Ajustar las propiedades de un proyecto tipo rol para configurar una cuenta de almacenamiento del Azure Storage.

Leer más…

Categories: Uncategorized Tags:

Almacenamiento con Blobs

September 7th, 2014 No comments

Lee el post original de Víctor Moreno en: Azure Sin Límites

En una anterior publicación, hablé del Azure Storage y los tipos de almacenamiento en la nube (véase Azure Storage), en esta ocasión hablaré un poco más acerca de los Blobs.

Un blob es cualquier archivo que podamos imaginar: una imagen, un video, un archivo comprimido, un documento, etc. Existen básicamente dos tipos de Blobs: Leer más…

Categories: Uncategorized Tags:

C# 6.0 y un poco de historia

August 27th, 2014 No comments

Lee el post original de Saturnino Pimentel en El blog de Satur.

El día de ayer participamos en un hangout junto a Marta Jimenez (@ml2j_), Juan Carlos Ruiz (@JuanKRuiz) , Nicolás Herrera(@nicolocodev) y Sergio Vargas @Serandvaraco donde hablamos de lo nuevo dentro de la siguiente versión de C# 6.0 Leer mas…

Categories: Artículos, Videos Tags:

El programa de mejora de experiencia de Visual Studio 2013

August 15th, 2014 No comments

Lee el post original de Amin Espinoza en El blog de Kañaz.

Cada vez que nosotros instalamos una nueva aplicación o conjunto de estas solemos encontrarnos con una opción que nos invita a participar en el programa de mejora de experiencia. Al menos en el caso que me interesa en este post. El de Visual Studio (actualmente Visual Studio 2013). Cuando comienzas a instalar te aparecerá una ventana como la siguiente. Leer más…

Categories: Artículos Tags:

31 días de Windows 8 | Día 16: Menú contextual

April 21st, 2013 1 comment

Este artículo es una traducción de “Día 16: Menú contextual” de Jeff Blakenburg. Puedes encontrar aquí la versión en inglés.

Hoy nuestro foco es en menús contextuales. Estos son aquellos pequeños comandos que se muestran ocasionalmente en tu aplicación cuando das un clic derecho o algo similar. Microsoft ofrece una guía muy especial en cuanto al uso de menús contextuales y cuando usar un control de AppBar en su lugar y seguiremos estas reglas en este artículo.

¿Qué es un menú contextual?

Si has usado Windows 8, probablemente los hayas encontrado. Comúnmente ellos se muestran al momento de dar clic derecho en algo que no puedas seleccionar o texto con el que quieras interactuar. Aquí hay un ejemplo de menú contextual:

An image of the context menu for text shown over editable text while there is no text in the clipboard to paste.

(imagen de: http://msdn.microsoft.com/library/windows/apps/Hh465308)

Podrías también lanzar un menú contextual desde un elemento en tu página que no sea seleccionable como esta imagen en mi aplicación de ejemplo:

16-XAML-ContextMenuExample

Dar clic derecho en la imagen lanza el menú contextual a la derecha. (Te mostraré como hacer que esto suceda a continuación). Cada uno de los comandos tendrán una función asignada a ella, el cual es ejecutado cuando el elemento sea presionado.

Determinando la ubicación de un elemento.

Quizá hayas notado que los menús contextuales aparecen adyacentes directamente al elemento que ha sido seleccionado. Esto no sucede por magia. De hecho deberemos determinar la posición del elemento seleccionado por nosotros mismos (así como su tamaño) y pasarlo a nuestro control menú cuando lo creamos en forma de un objeto de Rectángulo. Aquí esta el método que he creado para determinar su ubicación.

private Rect ObtenerRect(object sender)
{
FrameworkElement elemento = sender as FrameworkElement;
GeneralTransform transformacionElemento = elemento.TransformToVisual(null);
Point point = transformacionElemento.TransformPoint(new Point());
return new Rect(point, new Size(elemento.ActualWidth, elemento.ActualHeight));
}

Como puedes ver, seré capaz de para mi “sender” en este método y regresar un objeto Rectángulo con un punto (la ubicación de la esquina superior derecha de nuestro elemento) y tamaño (las dimensiones de nuestro objeto llamado).

Creando un menú contextual

Una vez que ya tengo el método ObtenerRect() en su lugar creando un menú contextual cerca de nuestros controles es simple. En este ejemplo, he agregado un evento Right Tapped a mi imagen el cual llama a este método.

private async void Element_RightTapped(object sender, RightTappedRoutedEventArgs e)
{
PopupMenu menuContextual = new PopupMenu();
menuContextual.Commands.Add(new UICommand("La liga silverlight", (command) => { ((Grid)Logo.Parent).Background = new SolidColorBrush(Colors.Red); }));
await menuContextual.ShowForSelectionAsync(ObtenerRect(sender), Placement.Right);
}

Como puedes ver arriba, esto simplemente crea un nuevo control de tipo PopupMenu, agrega un comando a el (con el código de ejecución especificado en la expresión lambda) y llama al método ShowForSelectionAsync() para mostrarlo. Este método toma dos parámetros.

* El primero es el valor de Rectángulo que estamos obteniendo de nuestro método ObtenerRect(). Pasa el sender y obtiene el rectángulo apropiado de regreso.

* El segundo es la ubicación del menú contextual. En mi ejemplo, coloqué Placement.Right como mi valor. Tienes cuatro opciones pero no pierdas tiempo en esto. La guía de Microsoft en menús contextuales es que “aparezcan sobre el objeto sobre el que están actuando a menos que se interponga sobre otros elementos de la interfaz en cuyo caso se debe colocar a un lado o por debajo del objeto”. Mantén la experiencia en Windows 8 consistente para tus usuarios a menos de que tengas una buena razón para hacerlo de otra manera.

Ejecutar este código, como se muestra arriba, resultará en un menú que lucirá como esto:

image

Y cuando yo ejecute esta opción, el fondo de la página se volverá rojo. Como esto.

image

Así que así es como mostramos un menú contextual. Pero ¿cuántos comandos podemos tener a la vez? La respuesta es SEIS. Agregar más de 6 elementos a tu menú PopupMenu resultará en un error cuando trates de crearlo. Lo mostré antes pero aquí está un ejemplo de un menú de cinco elementos.

image

Finalmente, también tienes la opción de crear un UICommandSeparator() el cual es simplemente una línea horizontal en lugar de un comando. Los separadores tomarán lugar en uno de tus seis espacios disponibles sin embargo; así que ten esto en cuenta cuando lo uses, esto lucirá así.

image

Para hacer esto, tu sentencia de creación del comando debería lucir como esto:

menuContextual.Commands.Add(new UICommand("31 Días de Windows 8", (command) => { ((Grid)Logo.Parent).Background = new SolidColorBrush(Colors.Orange); }));
menuContextual.Commands.Add(new UICommandSeparator());

¡Esto es todo! Ahora deberías ser capaz de agregar menús contextuales a tus aplicaciones cuando las AppBars y otros elementos no tienen sentido. Pero ¿qué hay acerca interactuar con algo de texto en una caja de texto?

Lanzar un menú contextual desde una caja de texto

Actualmente, cerca de todo en este proceso es el mismo, excepto por las matemáticas de donde surge la la caja contextual. Inicialmente al comenzar a resolver este problema, estaba esperando agregarla en un menú contextual que ya apareciera cuando des clic derecho en el texto.

image

Mientras aparece no puede. Así que para nuestro ejemplo, vamos a decir que queremos mantener todas esas opciones, pero también agregar algunas nuevas. Para hacerlo, primero necesitamos sobre escribir el menú contextual creando un manejador de eventos para cancelar el pre establecido y recrear toda su funcionalidad.

Para hacer esto, creamos un manejador de eventos como el siguiente.

protected override void OnNavigatedTo(NavigationEventArgs e)
{
txtLipsum.ContextMenuOpening += txtLipsum_ContextMenuOpening;
}

protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
{
txtLipsum.ContextMenuOpening -= txtLipsum_ContextMenuOpening;
}

También cree una sentencia para retirar el manejador de eventos cuando deje la página.

En el método que este manejador de eventos llama, cancelaremos la llamada inicial con Handled = true, y después crear nuestro propio menú contextual que aún haga algunas de las llamadas apropiadas al portapapeles. Solo vamos a cubrir esta parte brevemente en este artículo pero consumiremos el artículo entero de mañana para las diferentes formas de usar esta gran herramienta.

En suma, encontrar el lugar adecuado para mostrar un menú contextual dentro de un TextBox es diferente a solo determinar la posición de un control en la página. Aquí está mi método ObtenerRectanguloTexto().

private Rect ObtenerRectanguloTexto(TextBox cajaTexto)
{
Rect contenedorDatos = cajaTexto.GetRectFromCharacterIndex(cajaTexto.SelectionStart, false);

GeneralTransform transform = cajaTexto.TransformToVisual(null);
Point punto = transform.TransformPoint(new Point());
punto.X = punto.X + contenedorDatos.X;
punto.Y = punto.Y + contenedorDatos.Y;

return new Rect(punto, new Size(contenedorDatos.Width, contenedorDatos.Height));
}

Y aquí esta el método para crear nuestro menú Popup (notarás que he usado un método secundario para determinar que comando es presionado que no use expresiones lambdas en esta ocasión. Es más fácil para lectura pero deberías también notar que el método es mucho más largo).

async void txtLipsum_ContextMenuOpening(object sender, ContextMenuEventArgs e)
{
e.Handled = true;
TextBox textoResaltado = (TextBox)sender;

PopupMenu menuContextual = new PopupMenu();
menuContextual.Commands.Add(new UICommand("Cortar", null, 0));
menuContextual.Commands.Add(new UICommand("Copiar", null, 1));
menuContextual.Commands.Add(new UICommand("Pegar", null, 2));
menuContextual.Commands.Add(new UICommand("Seleccionar todo", null, 3));
menuContextual.Commands.Add(new UICommandSeparator());
menuContextual.Commands.Add(new UICommand("Borrar", null, 4));

var comandoElegido = await menuContextual.ShowForSelectionAsync(ObtenerRectanguloTexto(textoResaltado));

if (comandoElegido != null)
{
String texto;
DataPackage paqueteDatos;

switch ((int)comandoElegido.Id)
{
case 0: //Cortar
texto = textoResaltado.SelectedText;
textoResaltado.SelectedText = "";
paqueteDatos = new DataPackage();
paqueteDatos.SetText(texto);
Clipboard.SetContent(paqueteDatos);
break;
case 1: //Copiar
texto = textoResaltado.SelectedText;
paqueteDatos = new DataPackage();
paqueteDatos.SetText(texto);
Clipboard.SetContent(paqueteDatos);
break;
case 2: //Pegar
texto = await Clipboard.GetContent().GetTextAsync();
textoResaltado.SelectedText = texto;
break;
case 3: //Seleccionar todo
textoResaltado.SelectAll();
break;
case 4: //Borrar
textoResaltado.SelectedText = "";
break;
}
}
}

Si estás siguiendo tu propio proyecto, deberías ahora ser capaz de resaltar algo de texto en tu caja de texto y obtener un menú similar al de la imagen de arriba.

En resumen

Hoy vimos el arte de crear menús contextuales para nuestros usuarios. Hay una manera excelente de proveer interacciones con elementos que no sean seleccionables o para comandos que tengan más sentido estando directamente adyacentes al elemento con el que se está interactuando.

Si quisieras ver el código de ejemplo completo para este artículo, presiona sobre el ícono de abajo.

 

 

Mañana, como prometí, nos aventuraremos en la funcionalidad del portapepeles disponible para nosotros en el desarrollo de Windows 8. ¡Nos vemos entonces!

Categories: Tutoriales, Windows 8 Tags:

31 días de Windows 8 | Día 15: El teclado en pantalla

March 29th, 2013 2 comments

Este artículo es una traducción del día #15 en la serie 31 días de Windows 8 de Jeff Blakenburg.

Hoy vamos a dar un vistazo al teclado en pantalla de Windows 8. Microsoft no parece hacer una distinción de nombres entre el teclado que aparece cuando haces tap con tu dedo en un control TextBox y el que encuentras en el Centro de Accesibilidad. Vamos a enfocarnos hoy en el teclado que se ve como esto:

15-XAML-NormalKeyboard

Por otro lado, el teclado de Accesibilidad, es una herramienta diseñada para hacer más fácil el uso de la computadora a quienes no pudieran usar el teclado de ninguna forma. Lo puedes encontrar abriendo el centro de Accesibilidad en tu maquina…

15-XAML-EaseOfAccessCenter

Y haciendo click en la opción de “Iniciar Teclado en Pantalla” vas a descubrir un teclado que se ve como este:

15-XAML-EaseOfAccessKeyboard

El enfoque principal de este teclado es permitir al usuario usar Windows completamente sin tener un teclado conectado a su computadora. No es personalizable, y no responde a ningún código que escribamos en este artículo. El teclado es también una de las pocas ventana que pueden ser puestas sobre la pantalla de Inicio. Míralo aquí:

15-XAML-OnScreenKeyboardStartScreen

OK, así hemos usado los primeros párrafos de este artículo hablando acerca de un teclado que NO es el objetivo de este artículo. ¿Porque? Hay dos razones:

  1. Si estas usando dispositivos no touch mientras trabajas con este artículo (o en tu propia app y quieres usar las características del teclado regular touch), te encontraras con que los clicks del mouse no lanzan el teclado touch en tu máquina. Así que buscaras en la web una solución para hacer que se muestren.
  2. Mientras buscas por la web más información sobre manipular el teclado en pantalla en Windows 8, vas a encontrar varios artículos sobre el de la versión de Accesibilidad, que es el que no necesitas. Si encuentras un artículo apropiado sobre como lanzar el teclado touch, probablemente sea este, porque no pude hallar una forma de hacerlo funcionar.

La primera razón de esto es porque este es uno de las pocas veces que Windows 8 hace distinción entre un click de mouse y un tap de dedo. Si das click en un TExtBox, Windows 8 asume que estas usando un teclado real, incluso si estas usando una máquina habilitada para touch. Un tap de dedo, sin embargo, mostrara el teclado que vamos a usar hoy.

Para ahorrarte algo de frustración, al desarrollar tu aplicación que tomara ventaja de el teclado en pantalla, usa el simulador si no estas trabajando en una maquina touch. Te permite simular “taps” con tu mouse. Aquí es donde lo puedes ver:

15-XAML-SimulatorTapButton

OK, ahora que hemos hecho a un lado todo eso, iniciemos de una vez este artículo.

 

Usando el teclado en pantalla

Primero, demos un vistazo a los estados por defecto del teclado en pantalla que el usuario puede navegar en cualquier momento cuando la pantalla está abierta. Hemos visto ya la vista QWERTY standard:

15-XAML-NormalKeyboard

Pero hay muchas más. Cuando construimos una aplicación, nuestro primer enfoque, mas que cualquier otro, debe ser el hacer que las tareas que el usuario necesita hacer sean lo más fácil de cumplir que se pueda. (Eso ESTÁ en tus prioridades, correcto?) En ese sentido, el teclado en pantalla puede ser manipulado para que eso sea posible. Hay una propiedad que puede establecerse en los controles TextBox llamada InputScrope que nos permite mostrar el teclado apropiado para la tarea a realizar. Si un InputScope no se especifica, el teclado normal se mostrará. Aquí está como luce el código:

<TextBox InputScope="EmailSmtpAddress" />

 

Vas a encontrar, mienstra empiezas a jugar con el InputScope, que hay de hecho 18 diferentes valores de InputScope que pueden ser usados (pero para usuarios Anglo-parlantes, hay de hecho solo tres teclados diferentes por ahora). Estos son (en orden alfabético):

  • AlphanumericFullWidth
  • AlphaNumericHalfWidth
  • ChineseFullWidth
  • ChineseHalfWidth
  • Default
  • EmailSmtpAddress
  • HangulFullWidth
  • HangulHalfWidth
  • Hanja
  • Hiragana
  • KatakanaFullWidth
  • KatakanaHalfWidth
  • NativeScript
  • Number
  • NumberFullWidth
  • Search
  • TelephoneNumber
  • Url

Los únicos valores de ámbito de entrada que responden a computadoras con el lenguaje Inglés de pantalla son: Default, EmailSmtpAddress, Number, Search, TelephoneNumber, y Url. Aquí está como se ven:

EmailSmtpAddress (agrega el botón “@” y “.com”)

15-XAML-EmailKeyboard

Url (agrega botones “/” y “.com”, barra de espacio más pequeña, tecla Go)

15-XAML-URL

Number y TelephoneNumber (muestra el teclado numérico)

15-XAML-Number

Búsqueda (lo mismo que el teclado por defecto, pero la tecla Enter remplazada por Search o Búsqueda)

15-XAML-Search

El resto de los valores InputScope están generalmente enfocados a los lenguajes Asiatico Orientales, y aunque no les quiero faltar al respeto, no se lo suficiente acerca de esos conjuntos de caracteres para tener una discusión inteligente acerca de las pequeñas diferencias entre caracteres FullWidth y HalfWidth.

Sumado a nuestros valores InputScope, es importante entender las otras opciones que nuestros usuarios pueden navegar en cualquier momento cuando el teclado esta en la pantalla del usuario. Aquí las tienes:

Letras Mayúsculas

15-XAML-CAPS

Emoji (hay de hecho 30 PAGINAS de emoji, haz click aquí para verlos todos)

15-XAML-Emoji

Simbolos (un segundo set de simbolos después del que se muestra con el teclado Number)

15-XAML-Symbols2

Teclado dividido (una opción del usuario, este teclado esta optimizado para escritura con pulgar)

15-XAML-SplitKeyboard

Teclado de tinta (Este teclado hace reconocimiento de escritura a mano)

15-XAML-InkingKeyboard

Obviamente, este es un gran conjunto de puntos de entrada para nosotros como desarrolladores, y proporcionando el teclado adecuado para el trabajo hará tu app más útil para tus usuarios. Hay también una distribución de teclado más, y es el del control PasswordBox. Un control PasswordBox muestra símbolos en vez de los caracteres que se escribieron, y el teclado se ve como esto:

15-XAML-PasswordBox

Notaras que también tiene un botón “Ocultar presión de teclas”. Hay veces cuando la gente puede ver tu máquina (especialmente si la estás proyectando a una audiencia) y no quieres que sean capaces de ver los teclazos de tu password. Este botón no resalta los botones cuando son tocados. (Vas a notar también que el botón de Emoji esta deshabilitado, porque esos caracteres no deben ser usados para un password.)

En el pasado, he escrito artículo acerca de TextBoxes y teclados virtuales, y revise cada uno de los casos de uso donde quieras mostrar el teclado sin mostrar lo que escribe el usuario. Un gran ejemplo de esto podría ser el juego de Ahorcado. Quieres que el usuario sea capaz de elegir una letra, pero también ocultar el teclado así el usuario puede ver su progreso.

En Windows 8, esto no es posible ya. No puedes lanzar el teclado en pantalla vía código. De hecho, establecer el foco a un control TextBox no hara nada más que hacer el cursor intermitente. Específicamente requiere que un evento tap (no un click de mouse) ocurra en el TextBox antes que aparezca el teclado en pantalla. (Esa es la misma razón de porque debes usar el Simulador al depurar este tipo de funcionalidad en tus apps.)

Resúmen

Hot, hemos cubierto una variedad de teclado que están disponibles a nuestros usuarios. Podemos aprovechar los valores InputScop para mostrar el teclado correcto en el momento correcto. Adicionalmente, aprendí que hay 30 paginas completa de caracteres Emoji para usar también. (Si no es obvio, me beneficio mucho de escribir estos artículos también!)

Si quieres ver una aplicación funcional que usa cada uno de los valores InputSCop, haz click en el icono para descargarlo:

downloadXAML

Mañana, vamos a echarnos un clavado a usar los Menus Contextuales para ofrecer a nuestro usuario comandos contextuales directamente en la pantalla de la app. ¡Hasta entonces!

downloadTheTools

Aquí esta la lista enorme de Emoji, en caso de que hayas olvidado hacerle click:

Emoji

Categories: Tutoriales, Windows 8 Tags:

31 días de Windows 8 | Día 14: Geo localización

March 29th, 2013 No comments

Este artículo es una traducción de “Día 14: Geo localización” de Jeff Blakenburg. Puedes encontrar aquí la versión original en inglés.

Hoy vamos a hablar acerca de uno de mis elementos favoritos e cualquier plataforma de desarrollo. Tener el conocimiento de la ubicación del usuario (o más específicamente, del dispositivo) hace mejor a cualqueir aplicación. Aquí están algunos ejemplos de como:

Aplicaciones de línea de negocios

Conoce que planta estará visitando tu gerente hoy de modo que el tenga toda la documentación apropiada para la maquinaria en esa instalación. Además tu aplicación podrá navegar e fotos y nombres de los empleados en ese lugar así ellos estarán más preparados cuando el llegue.

Juegos

Identifica otros jugadores cercanos y ten la oportunidad de retarlos a un juego. No solo mejorará potencialmente la latencia de red para ellos sino que también podrás formar un gremio de nada. Crea un juego global de parejas, basado únicamente en la proximidad, no en contacto.

Mapas

Duh. Haremos esto como una parte del código de ejemplo de hoy.

Viajes

Reconoce la distancia del usuario y tiempo de viaje potencial desde el aeropuerto y alértalos  de caer en la urgencia de perder su vuelo. Además, una vez que has establecido que no llegarán a tiempo podrás ayudarlos a encontrar el siguiente vuelo disponible sin que el usuario lo tenga que hacer por sí solo.

Ejercicio

Hay toneladas de aplicaciones disponibles para seguir tu ruta de ejercicio. Piensa en correr, ciclismo, etcétera. La aplicación de geolocalización obvia de estas aplicaciones es la habilidad de mapear la ruta que tomaste durante tus viajes. Una más importante, sin embargo, creo que es la responsabilidad que probablemente cae en los fabricantes de SO mismos, es la habilidad de reconocer un accidente. En promedio, 4500 ciclistas al año son víctimas de situaciones de accidentes, donde ellos son abandonados lastimados (o peor) en un lado del camino. En el mundo de hoy, casi todo el mundo tiene un teléfono con ellos, incluso al correr o andar en bicicleta. Imagina que tu teléfono es capaz de reconocer un impacto grande (usando información del acelerómetro o giroscopio), seguido de ningún movimiento. Después de 30 segundos de movimiento nulo, tu teléfono te incita a llamar a un número de emergencia y enviar mensajes de texto a una lista pre seleccionada de contactos con un mensaje de ayuda y tu ubicación. Después de otros 30 segundos inmediatamente llama a emergencias y envía la información. Esta funcionalidad podría salvar vidas, tantas como esos ciclistas que fallecen sin ayuda solo porque nadie sabe donde están. Siento ser tan crudo, pero es una razón importante en la cual pensar.

Como puedes ver, hay siempre una razón por la cual tomar información de ubicación y hacer tu aplicación incluso mejor. Además, si amas las ideas que te doy arriba eres completamente libre de robarlas en tu favor. Probablemente yo nunca cree ninguna de estas aplicaciones. Necesitaría haber 48 horas en un día para hacer que eso sucediera.

Actualizando nuestro manifiesto

Afortunadamente, obtener la información de nuestra ubicación geográfica es muy sencillo y como de costumbre, tenemos que declarar que la Ubicación es una de nuestras capacidades a usar. Para hacer esto, abre la sección de Capacidades de tu archivo package.appxmanifest y selecciona la caja de Ubicación.

image

Si omites este paso y solo tratas de implementar el código del resto del artículo no tendrás ningún error pero tampoco obtendrás ninguna información.

Obteniendo nuestra ubicación geográfica

En este ejemplo, he construido una aplicación que monitoree constantemente la ubicación del dispositivo del usuario. Lo primero que me confundió en este proceso fue como preguntar al usuario por permiso para iniciar la localización en la aplicación. Si revisas el Día #11 Pantalla de bloqueo, necesitamos pedir un permiso explícito del usuario para acceder a su pantalla de bloqueo. Con la ubicación, sin embargo no. El simple acto de tratar de acceder a la información le preguntará a tu usuario por ti. Para hacer esto increíblemente más fácil, aquí está TODO el código que necesitarás para acceder a la ubicación de un dispositivo desde tu aplicación (Ten en cuenta que estoy enviando todos mis valores a cajas de texto en mi MainPage.xaml que muestran la información. Todas están nombradas como [DataType]Value para hacerlo obvio).

Geolocator ubicacion;

protected override void OnNavigatedTo(NavigationEventArgs e)
{
ubicacion = new Geolocator();
ubicacion.PositionChanged += location_PositionChanged;
ubicacion.StatusChanged += location_StatusChanged;
}

protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
{
ubicacion.PositionChanged -= location_PositionChanged;
ubicacion.StatusChanged -= location_StatusChanged;
}

async void location_PositionChanged(Geolocator sender, PositionChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Geoposition posicion = args.Position;

LatitudeValue.Text = posicion.Coordinate.Latitude.ToString();
LongitudeValue.Text = posicion.Coordinate.Longitude.ToString();
AccuracyValue.Text = posicion.Coordinate.Accuracy.ToString();

TimestampValue.Text = posicion.Coordinate.Timestamp.ToString();

if (posicion.Coordinate.Altitude != null)
AltitudeValue.Text = posicion.Coordinate.Altitude.ToString()
+ "(+- " + posicion.Coordinate.AltitudeAccuracy.ToString() + ")";
if (posicion.Coordinate.Heading != null)
HeadingValue.Text = posicion.Coordinate.Heading.ToString();
if (posicion.Coordinate.Speed != null)
SpeedValue.Text = posicion.Coordinate.Speed.ToString();
});
}

async void location_StatusChanged(Geolocator sender, StatusChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
StatusValue.Text = args.Status.ToString();
});
}

Como podrás haber adivinado, esta es una operación manejada por eventos. Cuando mi página se carga, creo un nuevo objeto de tipo Geolocator y agrego dos eventos: PositionChanged y StatusChanged.

PositionChanged es el importante. Aquí es donde obtenemos toda la información útil como Latitud, Longitud y Precisión. Todos estos valores vienen de la clase Geocoordinate y como puedes ver en el código de arriba, hay muchas más.

* Accuracy es la medida, en metros, del radio de un círculo que tenga nuestros valores de latitud y longitud como punto central. Como esto.

14-XAML-Accuracy

* Timestamp es el tiempo actual en el que el valor de la ubicación fue leído. Esto incluye información de la zona horaria así que tendrás que convertir los tiempos para almacenar todo en UTC.

* Altitude es la elevación del dispositivo, en metros. Este es probablemente encontrado en dispositivos con un barómetro (cubriremos los sensores más tarde en esta serie) pero es una pieza valiosa de información si la puedes tener.

*AltitudeAccuracy es como nuestro otro valor de precisión, excepto que es el simple margen de error para el valor de altitud. Es decir, que estás en + o – estos metros.

* Heading también será mostrado con el sensor adecuado, la brújula. Esto mide en grados relativos a nuestro norte verdadero.

* Speed puede ser técnicamente calculado al monitorear los valores de latitud/longitud cada determinado tiempo, pero ellos nos lo han hecho increíblemente fácil para nosotros. Es medido en metros/segundo pero es un valor opcional que el dispositivo GPS puede dar. Esto significa que no todos los dispositivos pueden regresar un valor.

El otro código, del ejemplo de arriba del que me gustaría hablar es acerca de la cosa async/await. Quizá hayas notado que ambos manejadores de eventos tienen async en el inicio, y que después tenemos algo como esto:

await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { });

Dado que la adquisición de nuestra ubicación sucede en un hilo en segundo plano, necestiamos usar un Dispatcher para regresar a nuestro hilo primario para poder escribir nuestros valores en la pantalla. Sin este código tendremos un error en el momento que tratamos de manipular la capa de la UI dado que los hilos en segundo plano no tienen acceso a esto directamente. Aquí está como luce mi UI básica (no, no es ahí donde vivo pero podrías saberlo si checas esa ubicación):

image

Así que hemos obtenido nuesta información de ubicación pero aún está el manejador de eventos de StatusChanged que creamos antes. Esto no es algo a lo que generalmente le damos acceso a nuestro usuario es más como información administrativa para nosotros pero es un conjunto importante de información de cualquier manera. Puede tener seis diferentes valores.

* notInitialized es regresado cuando tu aplicación no ha solicitado permiso para acceder a la información de ubicación.

* disabled es el valor que obtendrás cuando el usuario rechace tu solicitud de acceder a su información de ubicación.

* notAvailable es regresado si el dispositivo del usuario no soporta la ubicación espacial.

* noData es regresado si el dispositivo del usuario soporta la ubicación pero no puede obtener ninguna. Esto podría pasar en un escenario donde el dispositivo no está conectado a Wi-Fi y está dentro de un edificio por ejemplo.

* initializing es el valor del estado que recibirás entre el momento en que el usuario autorice el acceso a su ubicación y el momento en que comiences a recibir esa información. En usos futuros de tu aplicación, este también se mandará cuando tu aplicación esté esperando a acceder a los datos de ubicación por primera vez.

* ready es la respuesta de oro y te permite saber que la información esta disponible para tu uso.

Así que el ejemplo que te he dado en este artículo te permite reconocer cada vez que la ubicación de tu usuario cambie y todas las veces que eso suceda. Si solo necesitas obtener esta información UNA SOLA VEZ, digamos, para etiquetar una imagen que el usuario acaba de tomar, solo haces una solicitud al objeto de tipo Geolocator sin tener que crear todos los eventos que he marcado arriba. En el método de abajo, podemos hacer una llamada simple al método ObtenerPosicionUnaVez en su lugar.

async private void ObtenerUbicacionUnaVez()
{
Geoposition posicion = await ubicacion.GetGeopositionAsync().AsTask();

LatitudeValue.Text = posicion.Coordinate.Latitude.ToString();
LongitudeValue.Text = posicion.Coordinate.Longitude.ToString();
AccuracyValue.Text = posicion.Coordinate.Accuracy.ToString();
}

En este caso, solo necesitamos un valor simple, una ocasión. No crees un ciclo que haga esta llamada una y otra vez, es mucho más lento y ahorrarás toneladas de recursos de la máquina siguiendo el ejemplo anterior que registró nuestros manejadores de eventos.

Usar el simulador para para fingir ubicación

Si estás usando una PC de escritorio tradicional, quizá ya has notado que tu máquina no hace un gran trabajo determinando tu posición. La ubicación por red puede ser decente pero es poco probable que tus coordenadas latitud y longitud sean muy acertadas. Entra al simulador. Puedes ajustar una ubicación específica en el simulador sin tener que estar en un avión. Para hacer esto solo abre los ajustes de ubicación del simulador.

14-XAML-SimulatorOption

En este punto, puedes darle los valores de latitud, longitud, altitud y valores de precisión:

14-XAML-SimulatorSettings

¡Ahí tienes! Puedes ahora escribir una aplicación que pueda determinar donde se encuentra el dispositivo del usuario y mientras la estás construyendo, puedes pretender que estás en cualquier parte de la tierra. No es una forma mala de viajar ¡al menos los costos son menores!

En resumen

Hoy hablamos acerca de los datos de geo localización y que tan importante puede ser para cualquier aplicación en el mercado. Vimos como seguir la ruta de un usuario, también obtener su ubicación una sola vez para aplicaciones que solo necesitan la ubicación específica “justo ahora” pero no todo el tiempo.

Si quisieras descargar una aplicación de ejemplo que incluya todo el código de este artículo, da clic en el ícono de abajo.

 

 

Mañana, vamos a ver el teclado en pantalla, InputScopes y cajas de texto. ¡Nos vemos entonces!

Categories: Tutoriales, Windows 8 Tags:

31 días de Windows 8 | Día 13: Navegación

March 28th, 2013 No comments

Este artículo es una traducción de “Día 13: Navegación” de Jeff Blakenburg. Puedes encontrar aquí la versión original en inglés.

Hemos pasado los últimos días enfocándonos mucho en actualizar el sistema con información para permitirle saber al usuario que es lo que sucede. De hecho, en los primeros 12 días esta serie hemos pasado muy poco tiempo hablando de una de las actividades más comunes que vamos a encontrar en el desarrollo de Windows 8: La navegación entre páginas con XAML.

Hoy corregiremos lo que estaba incorrecto metiéndonos en este tema. Hay tres escenarios específicos que quiero asegurarme de cubrir en este artículo:

* El simple acto de navegación de la página A a la página B. ¿Qué sucede entonces y qué información está disponible para nosotros?

* Pasar información de una página a otra. Esto no solo incluye cadenas y enteros, podemos pasar también objetos enteros entre páginas.

* Guardar el caché de las páginas. Cuando un usuario presiona el botón de retroceso, ellos no quieren descubrir que toda la información que ingresaron ha desaparecido. Discutiremos esto más adelante.

Navegar entre páginas en Windows 8 XAML

Parece que cada vez que encontramos una nueva plataforma hay también una nueva manera de navegar entre páginas en una aplicación XAML. Windows 8 no es diferente en ese aspecto. Este proceso es fácilmente explicado guiándote al momento de crear algunas páginas, así que iniciemos ahí.

Crea una nueva aplicación en blanco y después agrega dos nuevas páginas básicas en ella. Para este ejemplo puedes llamarlas PaginaA.xaml y PaginaB.xaml

image

En cada una de esas páginas, hay una línea de XAML que ajusta el el AppName.

<page .Resources>
<x:string x:Key="AppName">My Application</x:string>
</page>

Normalmente, moveríamos esto a nuesto archivo App.xaml y lo haríamos aplicar a todas las páginas de nuestra aplicación. Por hoy, vamos a usar este mecanismo simple para darle a cara una de nuestras páginas un nombre distinto que podamos ver cuando esté cargada. Ajusta el valor de PaginaA a “Página A” y el de PaginaB a “´Página B” de modo que tus páginas luzcan así:

image image

Para hacer el ejemplo sencillo de usar, también vamos a hacer un cambio rápido a nuestro archivo App.xaml.cs. Cerca del fondo del método OnLaunched() está algo de código que luce como lo siguiente.

if (rootFrame.Content == null)
{
if (!rootFrame.Navigate(typeof(MainPage), args.Arguments))
{
throw new Exception("Failed to create initial page");
}
}

Vamos a querer cambiar la referencia de typeof(MainPage) a typeof(PaginaA). Como se muestra a continuación:

if (rootFrame.Content == null)
{
if (!rootFrame.Navigate(typeof(PaginaA), args.Arguments))
{
throw new Exception("Failed to create initial page");
}
}

Esto causará que tu aplicacion arranque con PaginaA como página inicial. Hasta este punto, ejecuta tu proyecto. Verás que comienza la pantalla de inicio y después PaginaA aparecerá. Deberías notar que incluso aún cuando en Visual Studio apareceuna flecha cerca del título de nuestra página esta enlazada a si es posible o no la página de “ir hacia atrás” con la propiedad Frame.GoBack. Hablaremos de ello más adelante.

Por ahora, vamos a la navegación. Has visto técnicamente como hacerlo desde App.xaml.cs pero luce un poco diferente cuando vayas de página en página. He agregado un control de tipo botón a mi archivo PaginaA.xaml.cs justo antes de la sección VisualStateManager. El XAML luce así:

<button x:Name="btnPagina"
Grid.Row ="1"
Content="A página B"
Width="150"
Height="150"
Click="btnPagina_Click"></button>

 

En el manejador de eventos para el botón, escribimos nuestra primera sentencia de navegación (¡finalmente!).

private void btnPagina_Click(object sender, RoutedEventArgs e)
{
Frame.Navigate(typeof(PaginaB));
}

Como puedes ver es un proceso muy sencillo. Lo vamos a hacer más complicado ahora al agregar a un nuevo botón a la página B. Esto podría parecer una tarea repetitiva pero notarás que podemos meternos en problemas rápidamente (deberías ejecutar tu proyecto en este momento para asegurar que de hecho navegas a tu página B). Agrega el mismo botón y su manejador de eventos en Pagina B pero obviamente apuntando a página A en esta ocasión. Ahora tienes un botón en cada página que apunta a la otra. Si tu solo usas estos botones para hacer tu navegación vas a terminar creando una GRAN fila de navegación de retroceso y esto hará al concepto del botón de regreso completamente irrelevante. Lo que necesitamos hacer en este caso es implementar un manejador de eventos para GoHome que es parte del objeto LayoutAwarePage que estamos usando. Para ilustrar efectivamente este ejemplo, agrega un segundo botón en tu PaginaB.xaml con un nuevo manejador de eventos. En este manejador de eventos, sin embargo no vamos a navegar a una página. En su lugar vamos a crear un evento GoHome y llamarlo. Lucirá así:

private void btnPagina_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
if (this.Frame != null)
{
while (this.Frame.CanGoBack) Frame.GoBack();
}
}

private void btnHome_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
base.GoHome(sender, e);
}

Como puedes ver, nuestro método GoHome ejecuta un ciclo rápido intentando “Volver” hasta que ya no pueda más. En este punto, terminamos en la cima de la fila de navegación en nuestra página inicial. Es un buen truco, pero creo que se ilustrará mejor con un video breve.

Pasar información entra páginas en Windows 8

Después, vamos a querer pasar información entre páginas. Quizá un objeto, quizá una cadena, información en todo caso. Mientras se retira, nuestro método Frame.Navigate() es sobrecargado para poder aceptar un parámetro de información. Para este ejemplo he agregado un TextBox y un Button a mi página A pero ahora voy a asumir que sabes como hacer esto. La parte importante de esto es donde tengo un manejador de eventos que envíe el valor del texto del TextBox y lo envíe como parte del método Navigate(). Como lo siguiente:

private void btnPagina_Click(object sender, RoutedEventArgs e)
{
Frame.Navigate(typeof(PaginaB), txtMensaje.Text);
}

Por otro lado, en la páginaB necesitamos atrapar esta información y desplegarla. De nuevo, he agregado un TextBlock en mi código de ejemplo (el cual podrás descartar al final del artículo) pero la pieza importante es mi nuevo manejador para el evento OnNavigatedTo() y atrapar la información cuando llegue.

protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);

string mensaje = e.Parameter as string;

if (!string.IsNullOrWhiteSpace(mensaje))
{
txtRecibido.Text = mensaje;
}
else
{
txtRecibido.Text = "Necesitas recibir una cadena. Regresa e ingresa un valor";
}
}

En la página B podremos recoger el valor obtenido de NavigationEventArgs.Parameter, donde lo estoy convirtiendo a valor de cadena. Necesitarás convertir tu valor a un tipo apropiado antes de que puedas utilizarlo, pero una vez que lo hayas hecho, podrás ¡pasar datos de una página a otra!

Además, mencionéantes que puedes pasar objetos completos, usando este mecanismo también. ¿Recuerdas nuestra clase Elemento del Día 4? Voy a pasar un Elemento personalizado de la página A a la página B en el siguiente ejemplo. Aquí está el código de la página A:

private void btnGalio_Click(object sender, RoutedEventArgs e)
{
Frame.Navigate(typeof(PaginaB), new Elemento
{
NumeroAtomico = 31,
PesoAtomico = 69.72,
Categoria = "Otros metales",
Nombre = "Galio",
Simbolo = "Ga",
Estado = "Sólido"
});
}

Puedes ver claramente que estamos pasando un elemento completamente nuevo a la página B. Aquí está la manera de atrapar esta información en la página B.

protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);

Elemento elementoRecibido = e.Parameter as Elemento;
txtRecibido.Text = elementoRecibido.Categoria;
}

Creando caché de páginas para un mejor rendimiento del botón de regreso

La última cosa que queremos manejar relacionado a la navegación es el caché de las páginas. Para este ejemplo final estoy usando nuestra aplicación de ejemplo en el estado donde estaba pasando valores de cadenas hacia atrás y adelante. Quizá hayas notado, si construiste tu propia aplicación de ejemplo que si escribes algo en el texto de la página A y envías la información a la página B, cuando presiones el botón de volver y regreses a la página A, esta no recordará lo que has escrito en la caja. Este es un patrón de experiencia de usuario increíblemente frustrante que puedes ver en la web todo el tiempo.

Podemos evitar esto con una simple línea en el constructor de las páginas a las que queremos crearles caché.

public PaginaA()
{
this.InitializeComponent();
NavigationCacheMode = NavigationCacheMode.Enabled;
}

Después de que ajustes el NavigationCacheMode, encontrarás que los valores del TextBox (y todo lo demás en tu página) permanecerán al momento de regresar. Dale una prueba, es una mucho mejor experiencia y no requiere que nosotros llenemos y rellenemos la forma cada vez que el usuario regrese a la página.

En resumen

Esta es una vista extensa de la nevegación en aplicaciones XAML para Windows 8. Cubrimos la manera de movernos entre páginas, pasar datos entre páginas y atrapar estas páginas para cuando el usuario de clic en los botones de volver.

Si quisieras descargar el código completo de este artículo, puedes dar clic sobre el ícono de abajo. (Nota por favor que el botón del Galio está deshabilitado, necesitarás eliminar los comentarios para el manejador de eventos para este botón, también como el código en la página B para hacerlo funcionar. La página B solo puede aceptar un tipo de parámetro a la vez y está actualmente listo para la cadena).

 

 

Mañana, vamos a iniciar nuestra conversación determinando la ubicación actual de un usuario usando GeoLocalización, incluyendo las reglas que van al usar esta tecnología. ¡Nos vemos entonces!

Categories: Tutoriales, Windows 8 Tags:

31 días de Windows 8 | Día 12: Tareas en segundo plano

March 21st, 2013 No comments

Este artículo es una traducción de “Día 12: Tareas en segundo plano” de Jeff Blakenburg. Puedes encontrar aquí la versión original en inglés.

Hoy, vamos a hablar acerca de las tareas en segundo plano. La vía pequeña para describir una tarea en segundo plano es esta:

Una tarea en segundo plano es el código que corre cuando tu aplicación no.

Piensa en estos escenarios.

* Audio vía streaming continuo, incluso cuando el usuario esta ejecutando otra aplicación.

* Actualizar el mosaico de la aplicación para reflejar nuevos datos.

* Mostrar una notificación toast para hacerle saber al usuario que nueva información ha sucedido.

* Actualizar la pantalla de bloqueo, incluso cuando el dispositivo esta bloqueado.

Obtener una tarea en segundo plano establecida y registrada con el sistema es un proceso de dos pasos. Primero, tienes que registrar la tarea en segundo plano en tu archivo package.appxmanifest. Una vez que ha sido hecho, aún necesitas registrar los eventos de la tarea con el sistema del código de tu aplicación y después están los eventos adicionales para controlar lo que sucede cuando la tarea en segundo plano finaliza. Cubriremos estos escenarios en este artículo.

Crear una clase de tarea en segundo plano

Mi primer paso es siempre crear un proyecto secundario que contendrá mis tareas en segundo plano. No es requerido pero es una buena separación visual de tu código.

12-XAML-AddProject

Cuando creas un proyecto, elige “Windows Runtime Component” como el tipo de proyecto.

12-XAML-WindowsRuntimeComponent

Por defecto, tendrás una clase llamada Class1.cs. Puedes renombrarla si gustas o solo eliminarla y agregar una nueva clase al proyecto. En cualquier caso, vas a crear una nueva clase llamada ActualizarMosaico.cs

Ahora, las tareas en segundo plano deben implementar una interfaz muy específica: IBackgroundTask. Esta solo implementa un método, Run(), este método es el que llamaremos cuando nuestra aplicación inicie la tarea en segundo plano. Solo para que inicies, aquí está como luce mi código C# después de implementar la interfaz.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.ApplicationModel.Background;

namespace AgenteSegundoPlano
{
class ActualizarMosaico : IBackgroundTask
{
public void Run(IBackgroundTaskInstance taskInstance)
{
//Agregaremos código aquí después
}
}
}

He agregado un comentario donde nuestro código residirá, pero por ahora es un buen inicio.

Configurando tu archivo Package.appxmanifest

El siguiente paso en este proceso es declara que usaremos las tareas en segundo plano en esta aplicación. Hacemos esto en el archivo package.appxmanifest en la sección de Declaraciones como se muestra en la imagen de abajo.

image

Como puedes ver , he agregado una declaración para la tarea en segundo plano (necesitarás una nueva de estas por cada tarea en segundo plano que quieras agregar en tu proyecto), y ajustar el punto de entrada a AgenteSegundoPlano.ActualizarMosaico, nuestra nueva clase. Después, necesitamos registrar esta tarea in nuestra aplicación actual de modo que Windows 8 lo sepa ejecutar en los momentos adecuados.

Registrando tu tarea en segundo plano

Vamos a tomar un par de pasos en este código de nuestro MainPage.xaml.cs, iniciando con checar si nuestra tarea en segundo plano ha sido ya registrada en el sistema. Yo generalmente hago esto tan pronto como la página se cargue en mi método OnNavigatedTo(). He creado un nuevo método llamado VerificarRegistroTarea() que verifique este estado por mí y ajuste un valor booleano global en la página. Tu puedes de hecho hacer esto en tu archivo App.xaml.cs también pero para nuestros propósitos simples, esta ubicación bastará.

bool estaTareaRegistrada = false;

protected override void OnNavigatedTo(NavigationEventArgs e)
{
VerificarRegistroTarea();
}

private void VerificarRegistroTarea()
{
foreach (var tarea in BackgroundTaskRegistration.AllTasks)
{
if (tarea.Value.Name == "ActualizarMosaico")
{
estaTareaRegistrada = true;
break;
}
}
if (!estaTareaRegistrada)
{
RegistrarTarea("ActualizarMosaico", "AgenteSegundoPlano.ActualizarMosaico");
}
}

Como puedes ver, estamos recorriendo a través de la colección BackgroundTaskRegistration.AllTasks porque podríamos tener muchas tareas en segundo plano ejecutándose bajo de nuestra aplicación y en este caso yo solo estoy interesado en uno: ActualizarMosaico. Puedes también ver que he hecho una llamada a RegistrarTarea() si la tarea no está aún registrada.

Depende de ti como manejar este caso pero en mi aplicación yo quiero asegurarme de que mi tarea en segundo plano esté siempre registrada y si ha sido eliminada del registro por alguna razón, quiero agregarla de nuevo. Así es como luce mi método RegistrarTarea().

private void RegistrarTarea(string nombre, string puntoEntrada)
{
BackgroundTaskBuilder tareaSegundoPlano = new BackgroundTaskBuilder();
tareaSegundoPlano.Name = nombre;
tareaSegundoPlano.TaskEntryPoint = puntoEntrada;
tareaSegundoPlano.SetTrigger(new SystemTrigger(SystemTriggerType.InternetAvailable, false));
BackgroundTaskRegistration tarea = tareaSegundoPlano.Register();
}

Puedes ver que estoy pasando el valor del nombre y punto de entrada pero puedes de hecho establecer estos valores dependiendo de tu situación. Dado que esta aplicación podría tener múltiples tareas en segundo plano, he decidido hacer esta construcción un poco más simple y pasarlos en algunos parámetros.

En nuestro método de registro, creamos un objeto de tipo BackgroundTaskBuilder(), ajusta el nombre y punto de entrada y después determina un SystemTrigger que ejecutará nuestra tarea en segundo plano. En este caso, he elegido el lanzador fácilmente probable InternetAvailable. Para probarlo, estaremos cortando el acceso a internet en nuestra máquina.

Si en algún momento necesitas eliminar el registro de la tarea en segundo plano es muy sencillo. Aquí está el método de ejemplo EliminarRegistroTarea() que puedes usar para eliminar la tarea.

private void EliminarRegistroTarea(string nombre)
{
foreach (var tarea in BackgroundTaskRegistration.AllTasks)
{
if (tarea.Value.Name == nombre)
{
tarea.Value.Unregister(true);
}
}
}

En ese ejemplo revisamos a través de las tareas que están registradas de nuevo y si encontramos alguna de ellas con el nombre que estamos buscando llamamos al método Unregister() confirmándolo con el parámetro en verdadero.

Así que hemos trabajado con la forma de registrar o eliminar el registro de nuestra tarea en segundo plano y ahora hemos especificado que nuestra aplicación debería lanzar nuestra tarea en segundo plano cuando la zona horaria de nuestra máquina cambie. Vamos a escribir algo de código en nuestra clase AgenteSegundoPlano y después darle una prueba a esto.

Haciendo que tu tarea en segundo plano HAGA algo

Antes, hemos creado un archivo llamado ActualizarMosaico.cs en nuestro nuevo proyecto de tipo Windows Runtime Component y dejamos un espacio en blanco para agregar código en el método Run() que debe ser implementado como parte de la interfaz IBackgroundTask. Aquí está como debería lucir el archivo con el código para actualizar nuestro mosaico.

public void Run(IBackgroundTaskInstance taskInstance)
{
XmlDocument datosTile = TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquareText04);
XmlNodeList datosTexto = datosTile.GetElementsByTagName("text");
datosTexto[0].InnerText = "Actualizar mosaicos es absolutamente genial. #31daysofwin8";
TileNotification notificacion = new TileNotification(datosTile);
notificacion.ExpirationTime = DateTimeOffset.UtcNow.AddSeconds(30);
TileUpdateManager.CreateTileUpdaterForApplication().Update(notificacion);
}

Obviamente, podríamos escribir una tarea en segundo plano similar para implementar el envío de una notificación toast, actualizar la pantalla de bloqueo u otras llamadas a servicios web por ejemplo.

En resumen

Hay una cosa más a notar acerca de las tareas en segundo plano: son mucho más complejas de depurar que el código en tu aplicación. De hecho Microsoft ha escrito un artículo entero acerca de como depurar exactamente las tareas en segundo plano. Yo recomiendo ampliamente leerlo. Ellos han creado también un tutorial de inicio rápido llamado Crear y Registrar una tarea en segundo plano.

Si quisieras descargar el código de ejemplo funcional de este artículo, da clic sobre la imagen de abajo.

 

 

Mañana, vamos a doblar por completo de nuevo y comenzaremos a hablar acerca de navegación. Específicamente como navegar entre páginas en una aplicación XAML y pasar parámetros como información entre páginas como parte del proceso. ¡Nos vemos entonces!

Categories: Tutoriales, Windows 8 Tags: