De manera gratuita hasta el 31 de agosto, podrás descargar para tu Windows Phone 8 la app Splashtop2.

Desde hace tiempo estaba esperando una app de manejo remoto (Remote Desktop Connection) de Windows como esta! Me permite acceder a mis PCc directamente desde el phone. Puedo ver y editar archivos, hacer streaming de películas HD, jugar y más! La transmisión de video se hace con velocidades de hasta 30 cuadros por Segundo!!!

Screenshot de mi Visual Studio 2012 operándose desde mi Windows Phone 8.

Basta con que instales la app en tu phone y la aplicación Splashtop Streamer en tu PC:

PC:

Splashtop.com

Phone:

Splastop2 App

Una nueva visión para el futuro se hace hoy realidad con la presentación de Xbox One de Microsoft Corp., el sistema de juego y entretenimiento todo en uno diseñado y pensado para hoy y la nueva generación. En una exhibición en las oficinas centrales de Microsoft en Redmond, Washington, la compañía demostró cómo Xbox One te coloca en el centro de todos tus juegos, programas de TV, películas, música, programas deportivos y Skype.

“Xbox One está diseñado para ofrecer una nueva generación de exitosos videojuegos, televisión y entretenimiento en un poderoso dispositivo todo en uno”, comentó Don Mattrick, Presidente de Interactive Entertainment Business de Microsoft. “Nuestra exclusiva y moderna arquitectura brinda simplicidad a la sala y por primera vez en la historia la capacidad de cambiar de manera instantánea entre tus juegos y tu entretenimiento”.

Xbox One

Con Xbox One, los juegos superan los límites de lo real y la televisión obedece tus comandos. Di "Encender Xbox" para iniciar tu pantalla de inicio personalizada de Xbox One, descubre cuáles son los programas populares en la TV o ve los últimos logros de juegos de tus amigos, todo esto utilizando la interfaz más natural: tu voz. Mientras más interactúes con Xbox One, te conocerá mejor y aprenderá cuáles son tus gustos. Algunas de las revolucionarias características de Xbox One que te colocan en el centro del entretenimiento en la sala de tu casa incluyen:

TV en Xbox One. Navega y ve programas de televisión en vivo desde la conexión de tu decodificador de cable, o set satelital a través de tu Xbox One. Microsoft está comprometido con hacer llegar la señal de TV en vivo a través de diversas soluciones a todos los mercados donde estará disponible Xbox One.

Home Screen. Enciende tu sistema de entretenimiento pronunciando dos poderosas palabras, "Encender Xbox" y un tablero de inicio con diseño personalizado te dará la bienvenida presentándote tus juegos, programas de TV y entretenimiento favoritos.

Snap View Podrás hacer dos cosas al mismo tiempo en la pantalla de tu casa. Utiliza Snap para participar en una batalla con varios jugadores, mientras ves tu película favorita; conversa con amigos por Skype al mismo tiempo que ves programas de TV en vivo, o sigue al equipo de tus sueños en TV mientras ves un gran juego y mucho más.

Skype para Xbox One: Especialmente diseñado para Xbox One, conversa con amigos en tu televisor en impresionante alta definición, o por primera vez en la historia, mantén una llamada grupal de Skype en tu televisión.

Trends Mantente al tanto de lo más visto en TV descubriendo el entretenimiento que es más popular entre tus amigos, y ve aquello que marca tendencias dentro de la comunidad Xbox.

ONE Guide: Encuentra fácilmente tu entretenimiento favorito, buscando por red, nombre u horario todo a través del sonido de tu voz y presentado en una guía de programas personalizada.

Para crear el sistema Xbox más avanzado que jamás se haya diseñado para juegos, TV y entretenimiento, Microsoft creó un sistema operativo de vanguardia y lo fusionó con una plataforma de entretenimiento igualmente sorprendente, de modo que no tengas que cambiar las conexiones para ver la TV o jugar un videojuego. Un procesador x86 de ocho núcleos y más de cinco billones de transistores ayudan a que el retraso y los tiempos de carga sean algo del pasado para que puedas, de manera instantánea, pasar del juego al entretenimiento a la velocidad de la luz o ejecutar un grupo de aplicaciones al mismo tiempo sin que haya ninguna pérdida en el desempeño.

Títulos y Material exclusivo de Xbox One

Jugar con Xbox One sumerge a los jugadores en mundos cinemáticos que parecen reales, con personajes que se ven más humanos que nunca. Exitosos títulos presentados para Xbox One incluyen los siguientes:

Forza Motorsport 5 de Turn 10 Studios es la última edición de la franquicia de juegos de carreras mejor calificada de los últimos 10 años.³ Diseñado desde cero para sacar provecho de  Xbox One y del infinito poder de la nube, ningún otro juego entrega mejor la sensación de estar al volante. “Forza Motorsport 5” establece un nuevo estándar para los juegos de carreras y estará disponible de manera exclusiva para el lanzamiento de Xbox One.

Call of Duty: Ghosts es la siguiente generación de “Call of Duty” y un avance extraordinario para la franquicia. El juego brinda un nuevo mundo, personajes e historias totalmente nuevos, diseñados a partir de un nuevo motor de última generación. Las avanzadas técnicas construidas para soportar las increíbles mejoras en la mecánica del juego hacen de esta la experiencia “Call of Duty” más envolvente y jamás vista. Activision y Microsoft anunciaron también la renovación de su estrecha colaboración que verá el regreso de “Call of Duty^® Championship”, presentado por Xbox, como contenido descargable totalmente nuevo que hará su debut exclusivo en la plataforma Xbox.

“FIFA 14”, “Madden NFL 25”, “NBA Live 14” y “EA SPORTS UFC” de EA SPORTS cambiarán la manera en que los consumidores experimentan y juegan los videojuegos de deportes. Impulsados por el nuevo motor de EA SPORTS, estos nuevos juegos ofrecerán enormes innovaciones en cuanto a inteligencia humana, movimientos reales del jugador y mundos vivos. Además de su compromiso con Xbox One, EA SPORTS anunció su promesa de contenido exclusivo que se anunciará en los próximos meses.

“Quantum Break” de Remedy Entertainment es una revolucionaria experiencia de entretenimiento de los creadores de “Max Payne” y “Alan Wake” que difumina la línea entre los juegos y la TV al integrar elementos dramáticos y mecánica de juego a una experiencia uniforme y excepcionalmente envolvente. La manera en que se juegue el afecta al programa, y dicho programa informará cómo se debe jugar el juego.

Además de la increíble gama de juegos que estarán disponibles para Xbox One, Microsoft presentó asociaciones para desarrollo de contenidos exclusivos con algunos de los principales nombres en TV, deportes y entretenimiento.

La serie para televisión “Halo”. El galardonado productor y director Steven Spielberg será el productor ejecutivo de una serie para televisión de “Halo”, que tendrá contenido interactivo exclusivo para Xbox One, creado en conjunto con 343 Industries y Xbox Entertainment Studios.

National Football League (NFL) Una asociación histórica de varios años ofrecerá lo último en  experiencia interactiva televisiva de la NFL para Xbox One y aprovechará los dispositivos y servicios de Microsoft para evolucionar tanto dentro como fuera de la cancha. La NFL en Xbox redefinirá la experiencia de transmisión a través de las innovaciones en torno a Skype, Xbox SmartGlass y los accesorios tecnológicos que el jugador puede usar; agregará una solución de fútbol virtual totalmente nueva para la pantalla más grande de la casa; y creará un destino NFL personalizado disponible únicamente en Xbox One.

Xbox Live (Nueva Generación)

Xbox One está diseñado para potenciar una nueva generación de Xbox Live que sea más poderosa, personal e inteligente. Desencadenar el poder virtual de Xbox Live hace que todo sea más conveniente y accesible, desde permitir la instalación de juegos por segmentos para que la mecánica de juego pueda empezar más rápido, hasta descargar actualizaciones en segundo plano. Guarda y almacena tu perfil personalizado, tus juegos y entretenimiento para poder acceder a ellos en cualquier momento, desde cualquier consola Xbox One.⁴ Además, las membresias Xbox Live Gold de  Xbox 360 se transferirá sin problemas a Xbox One.⁵ Xbox Live te permite sumergirte en tus juegos favoritos con características totalmente nuevas.

Smart Match. El nuevo sistema de coincidencias Smart Match prácticamente elimina el periodo de espera al calcular los tiempos y encontrar personas con quienes te gustaría jugar mientras disfrutas de otras actividades; la reputación es fundamental y ayuda a encontrar las mejores coincidencias.

Living Games Mundos dinámicos y vivos que evolucionan y mejoran mientras más juegues, e inteligencia artificial avanzada que puede aprender a jugar como tú, de modo que tus amigos puedan jugar contra tu sombra.

Logros expandidos. Un nuevo y expandido sistema de logros captura tus momentos épicos en video, continúa aumentando los logros de un juego al paso del tiempo y te recompensa en forma novedosa, transfiriendo tu puntaje de jugador desde tu Xbox 360.

Xbox SmartGlass Xbox SmartGlass es una parte nativa de Xbox One, plataforma desarrollada desde el inicio con la capacidad de proporcionar contenido directamente en tu dispositivo; y ahora es posible conectarse a más dispositivos al mismo tiempo para las opciones de entretenimiento multijugador.

look and feel

El nuevo hardware de Xbox One es elegante y moderno y complementa cualquier tipo de decoración. La forma de la consola tiene una relación de aspecto 16:9 y emplea una orientación horizontal optimizada para su unidad de disco Blu-ray^™ de alta velocidad. Está moldeada en un color negro líquido e incluye un característico borde biselado.

El completamente rediseñado sensor Kinect de 1080p es más preciso, más receptivo e intuitivo. Su incomparable tecnología de visión, movimiento y voz le permite sumergirse en los juegos y el entretenimiento como nunca antes al expandir extraordinariamente su campo de visión y fidelidad. Funciona en casi cualquier condición de iluminación, reconoce el control de movimiento preciso desde una ligera rotación de la muñeca, y distingue tu voz incluso en una habitación ruidosa mediante un avanzado aislamiento del ruido.

El control Xbox, líder en su clase, se actualizó con más de 40 innovaciones técnicas y de diseño. El mando direccional actualizado, la palanca de pulgar y el ajuste ergonómico generan una experiencia envolvente para todos los jugadores exclusiva de Xbox y se ha aumentado de manera radical la precisión y el control con nuevos gatillos de pulso con vibración.⁶ El control inalámbrico de Xbox One está diseñado para funcionar junto con el nuevo Kinect, permitiendo que ambos elementos se vinculen automáticamente para crear una perfecta sincronización del jugador.

Xbox One se lanzará en los distintos mercados del mundo más adelante este año a nivel mundial. Visita el nuevo blog de Xbox Wire en http://news.xbox.com para conocer con mayor profundidad las características del nuevo sistema e incluso acceder a fotografías y videos del evento de presentación y el contenido de Xbox nuevo y con actualización continua. Más detalles de Xbox One y juegos estarán disponibles en la feria Electronic Entertainment Expo del mes de junio.

LightSwitch es un RAD para hacer aplicaciones basadas en datos bien sea usando Silverlight, o HTML5. En cuestión de minutos podemos tener una aplicación de ese estilo desplegada y funcionando.

Cuando ya estamos desarrollando una app de cierta complejidad sin embargo, tarde o temprano llegamos a la necesidad de consultar data que se encuentra distribuida en varias tablas en un ambiente relacional.

Aunque LightSwitch provee un wizard de consultas básicas, éstas últimas requieren la escritura de código.

El código usado para escribir consultas complejas el LightSwitch no es más que LINQ.

En mi primer intento de hacer una consulta cruzada con LINQ dentro de LightSwitch sin embargo, a pesar de escribir instrucciones completamente válidas de acuerdo a la definición de LINQ, siempre obtenía un error emitido por LightSwitch, que además dado el mensaje presentado, no da muchas luces de qué es lo que está sucediendo:

Unable to create a constant value of type ‘LightSwitchApplication.MiTabla’. Only primitive types or enumeration types are supported in this context.

Pasé mucho tiempo experimentando qué podría ser hasta que descubrí que el error sucede cuando en el where de la instrucción LINQ ponemos dos tablas de la DB directamente. Entonces una solución que se me ocurrió y que mi buen amigo @jramirezdev me ayudó a implementar fue descargar primero unos datos, enumerarlos en una lista y luego con joins lograr el resultado. Sin embargo, dado que esto requiere dos llamados distintos a la DB y además resulta en una consulta LINQ difícil de leer, seguí “escarbando” y encontré una gran ayuda en el operador any  de LINQ, que me permite seleccionar los datos que quiero sin tener que citar varias tablas dentro de LINQ, sino más bien explorando las propiedades de navegación del modelo de objetos.

En este artículo, he invitado precisamente a @jramirezdev, a quien agradezco el haber escrito el proceso de problema y solución en detalle; algo muy valioso para desarrolladores que estén teniendo este mismo problema:

...

Es muy común que en nuestras aplicaciones tengamos un origen de datos relacional y sobre este debamos realizar consultas en varias tablas para obtener la información que necesitamos. En LightSwitch las consultas simples se puede realizar con el diseñador integrado, pero si este no es el caso debemos recurrir a crear una consulta desde ceros, esto es, usar EntityFramework + LINQ.

Cuando utilizamos Entity Framework en LightSwitch nos encontraremos con algunas limitaciones, es por esto que debemos ser cuidadosos pues aunque la consulta LINQ compile no significa que al ejecutarla vayamos a obtener los resultados esperados.

Para entender esto veremos un caso específico donde realizaremos una consulta de tablas cruzadas con LINQ.

Aplicación: Crearemos una aplicación que permitirá registrar Usuarios, Tiendas y Facturas. Para esto debemos tener en cuenta que una factura será específica de un Usuario y una Tienda, esto significa que debe existir una relación entre Usuario y Tienda para finalmente registrar las facturas de ese usuario en esa tienda.

Modelo Relacional:

Problema: Se necesita generar un listado de todas las facturas que existan en las tiendas donde está registrado el usuario "Jorge Ramirez".

Para resolver este problema comenzaremos por crear una solución de LS, que se vera de la siguiente manera:

Aquí podemos observar que debajo de la tabla "Facturas" encontramos una consulta llamada "GetFacturasPorTiendasAsociadasAlCliente", es en ese archivo que escribiremos nuestra consulta LINQ.

Escribiré mi primer consulta de la siguiente manera.

        partial void 
        GetFacturasPorTiendasAsociadasAlCliente_PreprocessQuery
          (ref IQueryable<Factura> query)
        {
            //Consulta 1
 
            var tiendas = from UsuarioTienda ut in UsuarioTiendas
                          where ut.Usuario.Nombre == "Jorge Ramirez"
                          select ut;
 
            var facturas = from Factura factura in query
                           from UsuarioTienda ut in tiendas
                           where factura.UsuarioTiendas.Tienda.Id ==
                               ut.Tienda.Id
                           select factura;
 
            query = facturas;
       }

Resultado Consulta 1: Error.

Este error aunque pareciera claro, no lo es, pues fácilmente nos confunde el pensar ¿Dónde creamos un Obj del tipo "UsuarioTienda"? Pues bueno, aquí es importante conocer el concepto de que son Propiedades de Navegación de EntityFramework.

Leyendo este error vemos que existe una limitación para acceder a las tablas relacionadas/cruzadas a través de las propiedades de navegación, lo cual nos indica que debemos considera una solución más del lado semántico de TSQL donde hacemos los JOINS de forma explícita.

       partial void 
          GetFacturasPorTiendasAsociadasAlCliente_PreprocessQuery
          (ref IQueryable<Factura> query)
       {
            //Consulta 2
            var facturas = (from UsuarioTienda utienda in UsuarioTiendas
                            join Usuario usuario in Usuarios on 
                               utienda.Usuario.Id equals usuario.Id
                            join Tienda tienda in Tiendas on 
                               utienda.Tienda.Id equals tienda.Id
                            join Factura factura in query on tienda.Id 
                                 equals factura.UsuarioTiendas.Tienda.Id
                            where usuario.Nombre == "Jorge Ramirez"
                            select factura).AsQueryable();
 
            query = facturas;
      }

Resultado Consulta 2: Exito.

De esta forma EntityFramework ha logrado resolver las relaciones y entregarnos la data que necesitamos.

También podemos considerar otra posibilidad jugando con las propiedades de navegación y una expresión Lambda para que nuestra consulta sea más corta.

        partial void 
          GetFacturasPorTiendasAsociadasAlCliente_PreprocessQuery
          (ref IQueryable<Factura> query)
        {
            //Consulta 3
 
            var facturas = from Factura factura in query
                         where factura.UsuarioTiendas
                        .Tienda.UsuarioTiendas.
                        Any(c => c.Usuario.Nombre == "Jorge Ramirez")
                        select factura;
 
            query = facturas;
        }

Resultado Consulta 3: Exito.

PROFILING

Finalmente como un proceso educativo, realizaremos uso de un perfilador (profiler) para ver como se comportan nuestras dos consultas exitosas.

Consulta 2: Reporte

Consula 2: Entity SQL Generado

SELECT TOP (45) [Project1].[Id]     
                   AS [Id],
                [Project1].[RowVersion]         
                   AS [RowVersion],
                [Project1].[Producto]              
                   AS [Producto],
                [Project1].[Valor] 
                   AS [Valor],
                [Project1].[UsuarioTienda_Factura]
                   AS [UsuarioTienda_Factura],
                [Project1].[C1]
                    AS [C1],
                [Project1].[C2]
                    AS [C2],
                [Project1].[Id1]
                   AS [Id1],
                [Project1].[RowVersion1]
                   AS [RowVersion1],
                [Project1].[Tienda_UsuarioTienda]
                   AS [Tienda_UsuarioTienda],
                [Project1].[UsuarioTienda_Usuario]
                   AS [UsuarioTienda_Usuario]
FROM   (SELECT [Project1].[Id]
                                  AS [Id],
               [Project1].[RowVersion]
                          AS [RowVersion],
               [Project1].[Producto]
                          AS [Producto],
               [Project1].[Valor]
                          AS [Valor],
               [Project1].[UsuarioTienda_Factura]
                          AS [UsuarioTienda_Factura],
               [Project1].[Id1]
                          AS [Id1],
               [Project1].[RowVersion1]
                          AS [RowVersion1],
               [Project1].[Tienda_UsuarioTienda]
                          AS [Tienda_UsuarioTienda],
               [Project1].[UsuarioTienda_Usuario]
                          AS [UsuarioTienda_Usuario],
               [Project1].[C1]
                          AS [C1],
               [Project1].[C2]
                          AS [C2],
             row_number() OVER (ORDER BY [Project1].[Id] ASC)
                AS [row_number]
        FROM   (SELECT [Extent1].[Id]
                    AS [Id],
                       [Extent1].[RowVersion]
                    AS [RowVersion],
                       [Extent1].[Producto]
                    AS [Producto],
                       [Extent1].[Valor]
                    AS [Valor],
                       [Extent1].[UsuarioTienda_Factura]
                    AS [UsuarioTienda_Factura],
                       [Extent2].[Id]
                    AS [Id1],
                       [Extent2].[RowVersion]
                    AS [RowVersion1],
                       [Extent2].[Tienda_UsuarioTienda]
                    AS [Tienda_UsuarioTienda],
                       [Extent2].[UsuarioTienda_Usuario]
                    AS [UsuarioTienda_Usuario],
                       N'UsuarioTiendas'
                    AS [C1],
                       N'UsuarioTiendas'
                    AS [C2]
                FROM   [dbo].[Facturas] AS [Extent1]
                       INNER JOIN [dbo].[UsuarioTiendas]
                    AS [Extent2]
                         ON [Extent1].[UsuarioTienda_Factura] = 
[Extent2].[Id]) AS [Project1]) AS [Project1]
WHERE  [Project1].[row_number] > 0
ORDER  BY [Project1].[Id] ASC

Consulta 3: Reporte

Consulta 3: Entity SQL Generado

SELECT TOP (45) [Project2].[Id]
                    AS [Id],
                [Project2].[RowVersion]
            AS [RowVersion],
                [Project2].[Producto]
              AS [Producto],
                [Project2].[Valor]
                 AS [Valor],
                [Project2].[UsuarioTienda_Factura]
 AS [UsuarioTienda_Factura],
                [Project2].[C1]
                    AS [C1],
                [Project2].[C2]
                    AS [C2],
                [Project2].[Id1]
                   AS [Id1],
                [Project2].[RowVersion1]
           AS [RowVersion1],
                [Project2].[Tienda_UsuarioTienda]
  AS [Tienda_UsuarioTienda],
                [Project2].[UsuarioTienda_Usuario]
 AS [UsuarioTienda_Usuario]
FROM   (SELECT [Project2].[Id]
                                  AS [Id],
               [Project2].[RowVersion]
                          AS [RowVersion],
               [Project2].[Producto]
                            AS [Producto],
               [Project2].[Valor]
                               AS [Valor],
               [Project2].[UsuarioTienda_Factura]
               AS [UsuarioTienda_Factura],
               [Project2].[Id1]
                                 AS [Id1],
               [Project2].[RowVersion1]
                         AS [RowVersion1],
               [Project2].[Tienda_UsuarioTienda]
                AS [Tienda_UsuarioTienda],
               [Project2].[UsuarioTienda_Usuario]
               AS [UsuarioTienda_Usuario],
               [Project2].[C1]
                                  AS [C1],
               [Project2].[C2]
                                  AS [C2],
               row_number() OVER 
(ORDER BY [Project2].[Id] ASC) AS [row_number]
        FROM   (SELECT [Extent1].[Id]
                    AS [Id],
                       [Extent1].[RowVersion]
            AS [RowVersion],
                       [Extent1].[Producto]
              AS [Producto],
                       [Extent1].[Valor]
                 AS [Valor],
                       [Extent1].[UsuarioTienda_Factura]
 AS [UsuarioTienda_Factura],
                       [Extent2].[Id]
                    AS [Id1],
                       [Extent2].[RowVersion]
            AS [RowVersion1],
                       [Extent2].[Tienda_UsuarioTienda]
  AS [Tienda_UsuarioTienda],
                       [Extent2].[UsuarioTienda_Usuario]
 AS [UsuarioTienda_Usuario],
                       N'UsuarioTiendas'
|                 AS [C1],
                       N'UsuarioTiendas'
                 AS [C2]
                FROM   [dbo].[Facturas] AS [Extent1]
                       INNER JOIN [dbo].[UsuarioTiendas]
 AS [Extent2]
     ON [Extent1].[UsuarioTienda_Factura] = [Extent2].[Id]
                WHERE  EXISTS (SELECT 1 AS [C1]
        FROM   [dbo].[UsuarioTiendas] AS [Extent3]
       INNER JOIN [dbo].[UsuarioTiendas] AS [Extent4]
       ON [Extent3].[Tienda_UsuarioTienda] = 
[Extent4].[Tienda_UsuarioTienda]
      INNER JOIN [dbo].[Usuarios] AS [Extent5]
      ON [Extent4].[UsuarioTienda_Usuario] = 
[Extent5].[Id]
      WHERE  ([Extent1].[UsuarioTienda_Factura] = 
[Extent3].[Id])
      AND (N'Jorge Ramirez' = [Extent5].[Nombre]))) 
AS [Project2]) AS [Project2]
WHERE  [Project2].[row_number] > 0
ORDER  BY [Project2].[Id] ASC

Nota: El perfilador usado fue Entity Framework Profiler, podemos aprender como usarlo Aquí.

Con esto hemos finalizado el proceso de creación y análisis de consultas LINQ to Entities en LightSwitch.

Muchas Gracias.

Jorge Ramírez (@JramirezDev): Es Tecnólogo de Sistemas y estudiante de Ingeniería de Sistemas, con 4 años de experiencia en desarrollo de BackEnd y FrontEnd usando .NET Framework; especialista en LINQ y WCF.  Encuentren la versión original de este post y mucho contenido adicional muy interesante en su blog.

A partir de hoy, Flash es soportado en Windows 8 nuevamente.

Qué?

Alguna vez dejó de ser soportado?

Antes de responder esta pregunta, déjenme contarles acerca de los sabores de Internet Explorer 10 en Windows 8.

Básicamente son 4 sabores:

2 sabores para Windows 8 sobre arquitecturas x86 y x64 (llamémoslas tradicionales) y otros 2 sabores para WindowsRT. Entonces, en las arquitecturas tradicionales los sabores de IE que tenemos son IE de escritorio y el IE de interfaz moderna o inmersiva.

Lo mismo pasa en WindowsRT. Recuerden que en WindowsRT también hay un desktop, solo que ese desktop no soporta la instalación de nuevas aplicaciones. Las apps a instalarse solo pueden ser aquellas de la interfaz moderna o Windows Store. Entonces en este caso también tenemos 2 versiones de Internet Explorer. Una de desktop y otra de interfaz moderna.

Cuando se lanzó Windows 8 el soporte a Flash se limitó de la siguiente manera:

1. WindowsRT sólo permitía visualizar ciertos sitios web incluidos en una lista blanca, con Flash en ambos sabores del browser.
2. Windows 8 sólo permitía visualizar ciertos sitios web incluidos en una lista blanca, con Flash en la interfaz inmersiva o moderna.
3. Windows 8 tenía soporte full para visualizar todos los sitios web con Flash.

Por qué la limitante?

Pensemos por un momento en la filosofía de Apps: Proveer un mercado de aplicaciones confiables del que solo se pueden bajar apps seguras que no vayan a hacerle ningún daño al usuario. Incluyendo ausencia de virus, spyware, troyanos y demás. Para poder lograr esto, las apps deben correr en un entorno seguro o sandbox que llaman. Del que no pueden salirse para ir a atacar o controlar otras apps. Además de esto, la filosofía de apps también incluye desarrollo amigable con la batería.

Entonces lo que sucede con Flash es que algunos sitios no respetaban ese sandbox y representaban huecos de seguridad para el sistema. Así que uno piensa: para que un entorno tan protegido como el sandbox si los atacantes pueden entrar a través de flash?

Además otros sitios con sus apps de flash exigían un esfuerzo enorme a los procesadores central y gráfico, lo que obviamente gastaba la batería en muy corto tiempo. Esto también derivaría en una pobre experiencia de usuario.

En conclusión la limitante se impuso para proteger la experiencia de usuario. No con el ánimo de excluir a un jugador importante de la industria sin el cual por ejemplo, mucho del contenido con DRM que está en la web no podría ser presentado (recordemos que HTML5 aún no define un estándar para manejar esta tecnología. Es algo que por el momento debe definir cada códec, de manera que la tarea se hace complicada a la hora de manejarlo.)

Lista blanca?

Sí, no todos los sitios que usan flash tenían esos problemas de seguridad y performance. Así que en el pasado uno podía pedirle a Microsoft que evaluara su sitio y permitiese a Flash ejecutar el contenido.

Cuál es entonces el soporte que se brinda hoy en día

Básicamente se cambió de tener una lista blanca a una lista negra. Ahora por defecto todos los sitios con flash pueden visualizarse en cualquiera de los 4 sabores de browser descritos anteriormente, a menos de que el sitio esté plenamente identificado como inseguro o de pobre performance y por ende se haya agregado a una lista negra.

TODOS los sitios con Flash que se pueden ver hoy en día en el IE desktop sobre Windows 8 (x86 y x64), se podrán seguir viendo sin ningún problema.

Cómo se logró esto?

Gracias a un trabajo conjunto entre Microsoft y Adobe, se logró adicionar a Windows 8 y Windows RT una nueva versión de Adobe Flash totalmente optimizada para el uso Inmersivo o de interfaz moderna. Esta versión es mucho más generosa con la batería, con el performance y con la seguridad del sistema y demuestra totalmente el compromiso que Microsoft tiene con los usuarios de ofrecerles la mejor experiencia, independientemente de que esto implique incluir productos de otros fabricantes.

A partir de cuándo lo puedo tener?

Como es tradicional ya con Windows 8, todos los martes podemos tenemos actualizaciones. En la de hoy, martes 12 de marzo, estaremos incluyendo esta actualización entre otras muy importantes. Por ejemplo estaremos actualizando el firmware de la Surface para corregir algunos problemas menores.

Esta presentación la he usado en varios eventos últimamente, como el TechDay de Cali, Medellín y algunas charlas online. Nos muestra unos temas que ya he tratado en varios de mis posts anteriormente, relacionados con Windows Azure Mobile Services, Windows Azure Storage, Web Api y Apps.

Aquí quise integrar todos esos posts en un ejemplo de la vida real, al que le damos solución de una manera bastante sencilla:

Cómo compartir archivos desde un dispositivo móvil a otros, a través de una Plataforma propia.

Toda la teoría relativa a esta demostración la puedes encontrar aquí.

Veamos pues la presentación en video:

Luego de la gran acogida del episodio de lanzamiento del curso de NodeJS que publiqué hace unos días, me permito presentarles en esta ocasión el segundo capítulo de la serie. Saliendo un poco más tarde de lo planeado debido a que lo que inicialmente concebí como un pequeño tutorial de  JavaScript, terminó siendo un curso completo de 1 hora.

Esto me exigió repasar nuevamente toda la teoría (Una semana de lectura) y luego condensar todo esto en la menor cantidad de tiempo en video que pude durante un proceso de edición de 8 horas.

Finalmente, aquí está el resultado:

Un recorrido súper rápido por JavaScript. Como ustedes sabrán del primer capítulo, es el lenguaje protagonista en NodeJS. Así que en este episodio encontrarán los aspectos fundamentales del lenguaje ha tener en cuenta.

El episodio está enfocado a desarrolladores orientados a objetos en lenguajes tradicionales (De allí el título del mismo). De manera que si eres experto en C#, C++ o VB pero no has estado en contacto muy profundo con JavaScript, este curso será excelente no solo para que comiences luego con Node.JS sino también con Apps para Windows 8 en JavaScript + HTML5, HTML5 en el browser, JQuery, LIGHTSWITCH basado en HTML5 y hasta Napa: el conjunto de tools para hacer apps basadas en Office. Así pues, es un episodio que te abrirá las puertas a muchas otras tecnologías.

Este es el segundo episodio de Noding w/ @WarNov. El curso rápido de Node.js que te permitirá de manera rápida y fácil aprender de qué se trata Node.js y cómo utilizarlo.

Este episodio es un recorrido rápido por JavaScript para developers Orientados a Objetos (aquellos con experiencia en lenguajes como C++, C# o VB), que aunque han tenido contacto con JavaScript no tienen los conocimientos avanzados de ese lenguaje para poder incursionar en Node.js. Ya vimos en el episodio anterior que JavaScript es central en Node.js. Por esto es necesario tener conocimientos sólidos del lenguaje antes de arrancar con Node.js.

Adicionalmente, en este video muestro como integrar Visual Studio con Node.js a través de la consola de comandos de NuGet Package Manager.

Si ya eres experto en JavaScript y deseas pasar de inmediato a NodeJS, puedes hacer skip de este episodio y continuar con el siguiente.

Sin más preámbulos, aquí los dejo con Noding w/ @WarNov. Episodio 2: JavaScript para Orientados a Objetos.

Así es para subscriptores Ultimate y Premium de MSDN
Por un año!

Todas las herramientas y recursos requeridos para comenzar a construir y probar apps de Office 365:

• Un sitio en SharePoint Online personalizado para crear y personalizar apps
• Acceso a las herramientas de Desarrollo Napa para crear y probar apps
• Un Microsoft Seller Dashboard para exponer apps gratis y pagas para vender en el Office Store.

Por ahora no hay disponibilidad para suscripciones adquiridas a través de programas especiales como Bizspark.

La suscripción igual se puede comprar aquí.

Más información acerca de cómo construir Office y SharePoint apps, próximamente en este blog.

Como saben, ya está al alcance de todos la posibilidad de subir la versión de Windows Phone 8 de nuestras apps. Sin embargo, comencé a notar con la gente que trabajo, que cuando en el store de Windows Phone residen las dos versiones tanto para WP7 como para WP8, cuando un usuario con WP8 trata de bajar la app, le sigue bajando la misma de WP7, a pesar de que la de WP8 está también presente.

Uno diría que se debería detectar el modelo del aparato y bajarse la adecuada.

Desafortunadamente esto no está sucediendo, así que mientras se corrige, aquí les dejo mi solución recomendada:

Solo basta con aumentar la versión de la app, en la versión de WP8.

Por ejemplo, si su versión de app de WP7 es la 1.7.x, asegúrense de que en WP8 será 1.8.x

De esta manera, sus usuarios de WP8 bajarán la versión adecuada.

Para hacer este cambio, solo basta entrar al manifiesto de la app y hacer la respectiva modificación:

Primero abrimos el AppManifest.xml que está dentro de la carpera properties del proyecto:

y luego  cambiamos la versión dentro del archivo:

Espero que con esto puedan solucionar el inconveniente, o mejor aún, puedan evitar que suceda.

@lvbernal, quien hace parte de nuestro grupo de MCS, me preguntó acerca de un problema que estaba teniendo en su desarrollo con Windows Azure, al tratar de usar caracteres especiales en los metadatos de los blobs que requería subir a Windows Azure. Le di la guía que lo llevó a la solución y él muy amablemente nos estructuró la solución en este post que he puesto como invitado para su deleite.

Nos dice Leonardo:

Estoy desarrollando una aplicación que guarda documentos en Windows Azure y quiero compartir dos decisiones de diseño:

• No utilizo tablas que relacionen usuarios y documentos, sino que creo un contenedor para cada usuario. Eso me da mayor flexibilidad al momento de hacer transacciones o al eliminar los usuarios (tarea muy frecuente en fase de desarrollo).
• Los datos asociados al documento como fechas, descripción, etc. los almaceno en los metadatos del blob.

Leonardo Vargas Bernal: Es Ingeniero Telemático de la Universidad Icesi, hace parte del Grupo de Investigación en Informática y Telecomunicaciones i2T, en las áreas de Aplicaciones y servicios móviles, Comunicaciones inalámbricas y Computación ubicua. Microsoft Community Specialist y MSP de 2007 a 2009, ha trabajado con tecnologías como Windows 8, Windows Azure y ASP.NET MVC. Emprendedor y amante de los retos de ingeniería. Encuentren su blog aquí.

Por primera vez en la historia, gracias al brillante trabajo de Xamarin, hoy podemos escribir aplicaciones nativas de iOS en Visual Studio y Windows usando C#! Todo lo bueno que se nos ofrece en el IDE más poderoso del mundo (Resharper, TFS, addons, y demás) ahora incluye además soporte para iOS!

Xamarin iOS for Visual Studio nos permite escribir, depurar y probar aplicaciones iOS desde máquinas Windows, siempre y cuando se cuente con al menos una Mac conectada en red que provea los servicios de build y despliegue.

Las ventajas que ofrece este acercamiento es que podemos crear una sola solución para desarrollar cross platform apps, mientras se usan herramientas poderosas solo disponibles en VS, como TFS o Resharper, usando la experiencia familiar que nosotros developers Windows ya tenemos dentro de nuestra casa VS.

De hecho, si lo único que tienen son MACs, pero igual quieren las ventajas de tener el IDE más poderoso del mundo para hacer desarrollos sobre iOS, la solución de Xamarin permite correrlo sobre un Windows en Parallels.

Por qué se requiere un MAC?
Las apps iOS no pueden ser creadas sin el compilador de Apple, y no puedes ser desplegadas sin los certificados de Apple y sus herramientas de firmado de código, que obviamente no están disponibles a terceros.

Lo bueno, es que una vez se configura, Xamarin hace toda la conexión sin que uno se de cuenta como developer.

Así que los requerimientos serían:
Windows 7 u 8.
VS2010 o VS2012.
Plugin de Xamarin para VS

Y en la MAC:
OS X Lion o Mountain Lion
Xamarin iOS SDK
El Xcode IDE y el iOS SDK

De acuerdo a la gente de Xamarin, la arquitectura de esta solución es:

Un detalle importante sin embargo, es que el emulador de iOS no corre en Windows, así que en este paso hay que ir a la MAC para ver la ejecución. Sin embargo el resto de ventajas, valen la pena.

Este producto se puede adquirir desde USD$1000= 

Queremos sitios web realmente veloces. Sitios web que puedan atender a miles de usuarios concurrentes sin presentar fallas de escalabilidad en sus servicios.

Necesitamos un nuevo acercamiento que nos permita a nosotros como developers poder desarrollar este tipo de sitios Web y, efectivamente, NodeJS cumple esta tarea a cabalidad.

Este es el primer episodio del curso Noding With WarNov, en el que aprenderás a manejar Node.js para crear sitios web de última generación que funcionan a grandes velocidades y soportando grandes cargas. Node.js básicamente es una compilación de paquetes. Por un lado incluye el engine V8 JavaScript de Google. Por el otro la capa de abstracción provista por libUV y finalmente una librería core de Node.js escrita principalmente en JavaScript.

Creado en 2009 por Ryan Dahl, hoy es altamente usado en aplicaciones web que requieren alta velocidad y manejo de tráfico optimizado. Es mantenido por Joyent, aunque sigue siendo open source. La principal característica que lo distingue de otros acercamientos similares, es que no necesita de un browser para correr, pues se ejecuta del lado del server. Además implementa un API de I/O creada específicamente para no generar bloqueos, lo que es bastión en la velocidad de respuesta del server.

Adicionalmente Node.js incluye también un ambiente REPL (Read, Evaluate, Print, Loop) que permite el testing interactivo de instrucciones Node.js.

En este video, veremos cómo todos los elementos mostrados anteriormente se integran para producir sitios web, de una manera básica.

En siguientes capítulos iremos avanzando sobre el estudio de esta tecnología.

Bien. A manera de documentación, aquí les dejo el código que usé para hacer nuestro primer servidor Web basado en Node.js:

var http = require('http');
var serv = http.createServer(
    function (req, res) {
        res.writeHead(200, { 'Content-Type': 'text/html' });
        res.end('<marquee>Noding with @WarNov</marquee>');

        var d = new Date();
        var hours = d.getHours();
        var minutes = d.getMinutes();
        var seconds = d.getSeconds();

        var time = hours + ":" + minutes + ":" + seconds;
        console.log('Somedoby just node with @WarNov at ' +
            time);
    });
serv.listen(3000);

Este video fue grabado en Noviembre de 2012 y contiene mi charla acerca del negocio de las apps en el marco del evento realizado por el Ministerio de las Tecnologías de Información y Comunicación en Colombia, llamado Colombia 3.0.

Observamos aquí un recorrido por la historia de la industria de las aplicaciones y cómo han llegado a convertirse hoy en apps. Así como en los principios fundamentales para establecer un negocio alrededor de este tema:

Presentación

Hoy, en mi post invitado del mes, les presento a Andrés Ortiz. Lo he invitado porque desarrolló una interesante manera de generar clientes WindowsRT para aplicaciones de SharePoint. En este interesante artículo, nos cuenta su experiencia su experiencia:

Contenido

Desde hace ya unos meses que Windows 8 viene cobrando mucha fuerza en diferentes campos: usuarios finales (portátiles, tablets, teléfonos), desarrolladores, diseñadores y más. Esto ha sido definitivamente un cambio de paradigma total de Microsoft de cara a su ya famoso sistema operativo, que básicamente no había tenido una evolución trascendental hasta que apareció Windows 7. Pero con Windows 8, se cambió definitivamente de página.

Por esta razón, hemos decido explorar lo que ofrece Windows 8 en el campo de los desarrolladores, específicamente para los que desarrollamos sobre la plataforma SharePoint, y definitivamente ha sido una experiencia muy gratificante. Nuestro resultado actual y el motivo de esta entrada, es una aplicación que corre en Windows 8, despliega Tiles en vivo con ítems de una lista de noticias (Thumbnail + Título de la noticia), y cuando se ingresa a la aplicación, se conecta a MySite de una granja de SharePoint y despliega la información de las personas que tengan su sitio personal creado. A continuación vamos a comentar los aspectos más importantes del desarrollo de esta aplicación.

Capa de Servicios: Cuando comenzamos a implementar la solución, lo primero que se nos vino a la mente es cómo íbamos a conectar la aplicación Windows 8 con la información almacenada en el servidor SharePoint. Como ya sabemos, SharePoint ofrece servicios Web, a través de los cuales se puede consumir la información almacenada en sus listas, y también la información de los perfiles, lo cual es necesario para obtener información de MySite. Por tal razón lo primero que debíamos implementar era la capa de servicios, a través de un proyecto .NET de tipo Windows Communication Foundation. En este sentido, tendríamos toda nuestra lógica de negocio, y temas de consumo de datos bien separados y aislados en un proyecto WCF totalmente dedicado a esa parte.
La Interfaz del servicio WCF es similar a la siguiente y resume los métodos utilizados que se deberán implementar para consumir la información:

[ServiceContract]
public interface IService1
{
    [OperationContract]
    List<TGNews> GetNewsTile();
    [OperationContract]
    List<TGUsers> GetUserInfo();
    [OperationContract]
    TGUsers GetUserInfoDetails(string loginName);
    [OperationContract]
    CompositeType GetDataUsingDataContract(CompositeType composite);
}  

• Servicio REST para consultar información de la lista de Noticias: http://server/_vti_bin/listdata.svc
• Servicio Web para consultar información de los perfiles: http://server/_vti_bin/userprofileservice.asmx y http://server/_vti_bin/usergroup.asmx

public List<TGNews> GetNewsTile()  
{        
   TGNews item = null;  
   List<TGNews> items = new List<TGNews>();  
   try  
   {  
        HomeDataContext dataContext = new HomeDataContext(new Uri("http:
        //server/_vti_bin/listdata.svc"));  
        dataContext.Credentials = new System.Net.NetworkCredential("user"
        , "password", "dominio");  
        var news = from temp in dataContext.Noticias  
                      select temp;  
        foreach (NoticiasItem temp in news)  
        {  
             item = new TGNews();  
             item.Title = temp.Título;  
             item.Thumbnail = temp.Thumbnail;  
             if (!string.IsNullOrEmpty(item.Thumbnail))  
             {  
                  GetImageNews("http://server" + item.Thumbnail, 
                  item.Title);  
                  item.Thumbnail = "ms-appx:///Assets/" + item.Title +
                  ".png";  
             }  
             items.Add(item);  
        }       
   }  
   catch (Exception ex)  
   {  
        //Log de la excepción  
        throw;  
   }  
   return items;  
}

public List<TGUsers> GetUserInfo()  
{  
   UserGroup userGroup = new UserGroup();  
   userGroup.Credentials = new System.Net.NetworkCredential("user",
   "password", "dominio");  
   XmlNode allUsers = userGroup.GetAllUserCollectionFromWeb();  
   XNode xNode = XDocument.Parse(allUsers.OuterXml);  
   return (from root in xNode.Document.Elements()  
    from users in root.Elements()  
    from user in users.Elements()  
    let loginName = (string)user.Attribute("LoginName")  
    let userInfo = GetUserInfoDetails(loginName)  
    //Filter out admin accounts.  
    //Strangely enough I couldn’t find a consistent  
    //correlating property.  
    where loginName != "SHAREPOINT\\system" &&  
      loginName != "NT AUTHORITY\\LOCAL SERVICE" &&  
      loginName != "NT AUTHORITY\\SERVICIO LOCAL" &&  
      loginName != "NT AUTHORITY\\usuarios autentificados"  
    select new TGUsers()  
    {  
      Title = userInfo.Title,  
      Image = userInfo.Image,  
      Id = loginName,  
      Phonenumber = userInfo.Phonenumber,  
      Manager = userInfo.Manager,  
      Cellphone = userInfo.Cellphone,  
      Birthay = userInfo.Birthay,  
      Department = userInfo.Department,  
      HireDate = userInfo.HireDate,  
      JobTitle = userInfo.JobTitle,  
      Localitationoffice = userInfo.Localitationoffice,  
      Titulo = userInfo.Titulo,  
      Workemail = userInfo.Workemail  
    }).ToList();  
 }  

 public TGUsers GetUserInfoDetails(string loginName)  
 {  
    TGUsers userInfo = new TGUsers();  
    if (loginName != "SHAREPOINT\\system" && loginName != 
     "NT AUTHORITY\\LOCAL SERVICE")  
    {  
      //Set the default picture URL. Silverlight can't use the
      //default GIF  
      //provided by SharePoint.  
      userInfo.Image = "ms-appx:///Assets/usuario.jpg";  
      try  
      {  
        UserProfileService userProfileService = 
         new UserProfileService();  
        userProfileService.Credentials =
         new System.Net.NetworkCredential("user", "password", "dominio");  
        PropertyData[] data = userProfileService.
         GetUserProfileByName(loginName);  
        string pictureUrl = GetPropertyData(data, "PictureURL");  
        if (!string.IsNullOrEmpty(pictureUrl))  
        {   
          GetImage(pictureUrl, loginName.Split('\\')[1]);  
          userInfo.Image = "ms-appx:///Assets/"+ 
         loginName.Split('\\')[1] + ".png";  
        }  
        userInfo.Title = GetPropertyData(data, "FirstName") + 
         " " + GetPropertyData(data, "LastName");  
        if (string.IsNullOrWhiteSpace(userInfo.Title))  
        {  
          userInfo.Title = GetPropertyData(data, "AccountName");  
        }  
          userInfo.Phonenumber = GetPropertyData(data, "WorkPhone");  
          userInfo.Cellphone = GetPropertyData(data, "CellPhone");  
          userInfo.Manager = GetPropertyData(data, "Manager");  
          userInfo.Department = GetPropertyData(data, "Department");  
          userInfo.Birthay = GetPropertyData(data, "SPS-Birthday");  
          userInfo.HireDate = GetPropertyData(data, "SPS-HireDate");  
          userInfo.JobTitle = GetPropertyData(data, "SPS-JobTitle");  
          userInfo.Localitationoffice = 
         GetPropertyData(data, "SPS-Location");  
          userInfo.Titulo = GetPropertyData(data, "Title");  
          userInfo.Workemail = GetPropertyData(data, "WorkEmail");  
      }  
      catch (System.Web.Services.Protocols.SoapException ex)  
      {  
        if (!ex.Message.Contains("A user with the account name"))  
        {  
          //throw;  
        }  
      }  
      catch (Exception ex)  
      {  
           throw;  
      }  
    }  
    return userInfo;  
  }      

Los métodos anteriores se encargan principalmente de obtener diferentes propiedades del perfil de un usuario específico, a través de su Login,  y retornar esa información como una lista genérica de tipo TGUser. De ese modo la primera pantalla de la aplicación Windows 8 se encarga de listar a todas las personas, y luego podremos navegar al detalle de la información de cada uno de esos contactos. Vale la pena destacar del método anterior y también del método que trae la información de la noticia, la manera de manipular las imágenes. Aunque para el caso del Tile se pueden consumir imágenes a través de una URL, en este caso específico, dichas imágenes se encuentran en una biblioteca de SharePoint. Al momento de querer consumirlas a través de su URL obteníamos un error de permisos y no fue posible. Por tal razón la solución fue, descargarlas primero a la carpeta Assets de la aplicación Windows 8, y desde ahí, si darle la ruta a la aplicación para que las cargue. Esa fue la solución que le dimos a esa parte para poder que las imágenes se desplegaran, tanto las fotos de las noticias, como las fotos del perfil de cada usuario.
Hasta este punto ya teníamos listas genéricas, con información de la lista de Noticias y de los Perfiles. Era el momento de sentarnos a escribir la capa Cliente, donde básicamente lo que se hace, es en Visual Studio 2012 crear un proyecto de tipo Windows 8.
Con el proyecto de Windows 8 creado, lo primero era referenciar el proyecto WCF a través de una referencia de servicio. Con esto tendríamos acceso a los métodos expuestos por el servicio.

Tile en Vivo: Los tiles son una de las características interesantes de Windows 8, y quizá lo que le da vida a la interfaz del usuario final. Es muy llamativo ingresar al escritorio del Sistema Operativo en la interfaz estilo “Metro” y ver toda esa información en vivo, por cada una de las aplicaciones instaladas: lectores RSS, correo, mensajería, juegos, entre otros. En nuestro caso la idea era desplegar el thumbnail y título de las Noticias almacenadas en una lista de SharePoint, y dicha información ya estaba lista en el método respectivo ofrecido por el servicio WCF. El tile luce similar a la siguiente imagen enmarcada en rojo, cuando la aplicación es desplegada en Windows 8:

El código encargado de obtener la información de las noticias y la creación del tile es el siguiente:

public void Actualizartile()  
 {  
   var tileUpdateManager = TileUpdateManager.
    CreateTileUpdaterForApplication();  
   tileUpdateManager.EnableNotificationQueue(true);  
   ServiceReference.Service1Client client = 
    new ServiceReference.Service1Client();  
   Task<List<TGNews>> news = client.GetNewsTileAsync();  
   List<TGNews> items = news.Result;  
   foreach (TGNews temp in items)  
   {  
     if (!string.IsNullOrEmpty(temp.Thumbnail))  
     {  
       tileUpdateManager.Update(new TileNotification(  
        CrearIconoCuadradoYLargo(temp.Title, 
        "ms-appx:///Assets/" + temp.Title + ".png"))  
       {  
         ExpirationTime = DateTime.UtcNow.AddMinutes(60) 
       });  
     }  
     else  
     {  
       tileUpdateManager.Update(new TileNotification(  
        CrearIconoCuadradoYLargo(temp.Title, 
        "ms-appx:///Assets/default.png"))  
       {  
         ExpirationTime = DateTime.UtcNow.AddMinutes(60) 
       });  
     }  
   }  
 }  

private XmlDocument CrearIconoCuadradoYLargo(string texto,
        string rutaimagen)  
     {  
       //obtenemos el xml del del icono largo  
       var larga = CrearIconoLargoTextoImagen(texto, 
        rutaimagen);  
       //obtenemos el xml del icono cuadrado y extraemos su
        etiqueta binding  
       var cuadrada = larga.ImportNode(CrearIconoCuadradoTexto(texto).
        GetElementsByTagName("binding")[0], true);  
       // insertamos en el xml del icono largo el binding del icono 
        //cuadrado y hacemos que sean hermanos ambos tienen a visual como padre  
       larga.GetElementsByTagName("visual")[0].AppendChild(cuadrada);  
       return larga;  
     }  

     private XmlDocument CrearIconoCuadradoTexto(string texto)  
     {  
       var tilexml = TileUpdateManager.GetTemplateContent(
        TileTemplateType.TileSquareText04);  
       tilexml.GetElementsByTagName("text")[0].AppendChild(
        tilexml.CreateTextNode(texto));  
       return tilexml;  
     }  

     private XmlDocument CrearIconoLargoTextoImagen(string texto,
         string rutaimagen)  
     {  
       var tilexml = TileUpdateManager.GetTemplateContent(
        TileTemplateType.TileWideImageAndText02);  
       //añadimos nuestro texto  
       tilexml.GetElementsByTagName("text")[0].InnerText = texto;  
       //obtenemos la etiqueta image  
       dynamic imagen = tilexml.GetElementsByTagName("image");  
       //añadimos la ruta de la imagen dentro del atributo "src"  
       imagen[0].SetAttribute("src", rutaimagen);  
       return tilexml;  
    }  

El método CrearIconoCuadradoTexto() se encarga de retornar la plantilla de tipo TileTemplateType.TileSquareText04, la cual básicamente nos permite desplegar un mensaje de texto cuando se despliega el Tile en formato cuadrado o pequeño. El método CrearIconoLargoTextoImagen() se encargará a través de la plantilla TileTemplateType.TileWideImageAndText02 de desplegar la imagen y el título de la noticia cuando el Tile se despliega más grande.

Página de Items Agrupados: En el instante que el usuario hace clic en la aplicación lo primero que verá será el grupo de perfiles que se consultan a través del servicio Web de SharePoint 2010 ya  explicado. Básicamente el grupo de perfiles mostrará por cada persona su foto y su nombre, luciendo similar a lo siguiente:

La imagen anterior es el consumo de los perfiles de un sitio Demo de SharePoint 2010, por lo cual se ven algunas fotos repetidas, pero esto no sucederá consumiendo los servicios de un sitio SharePoint donde ya se tengan datos de perfiles de usuarios reales. Lo importante es que observemos entonces lo interesante de la solución, y es que desde una interfaz de Windows 8 muy amigable, podamos consultar la información de nuestros compañeros en la organización, sin tener que navegar a la interfaz Web del sitio en SharePoint. Esto significa un acceso rápido a información de compañeros de trabajo que podamos requerir consultar rápidamente.

Luego que se han cargado todos los perfiles, se puede hacer clic en alguno de ellos, y posteriormente se desplegará una ventana donde se muestra el detalle de las propiedades de dicho perfil, similar a la siguiente imagen:

Bien, hasta este punto hemos mostrado lo interesante que es implementar soluciones en Windows 8, porque definitivamente las plantillas que ofrece para carga de información y su consecuente navegación, el modelo de objetos, y todas las facilidades para implementar interfaces WOW para el usuario final, ya están listas, es solo comenzar a utilizarlo. Y por otro lado toda la riqueza que SharePoint 2010 ofrece para consumir su información, esta vez desde una aplicación cliente como Windows 8, son definitivamente una reunión de tecnologías muy interesantes para crear soluciones mucho más avanzadas y con mayor funcionalidad. Todo esto ha sido construido en una máquina con Windows 8 instalado y Visual Studio .NET 2012 Ultimate. La granja SharePoint 2010 está totalmente aislada de todo esto y gracias a los servicios Web y REST se puede consumir su información sin requerir mucho más de eso.

 Andres Ortiz Es Ingeniero de Sistemas de la Universidad del Cauca, con más de 10 años de experiencia en el desarrollo de soluciones de Software y actualmente apasionado y especializado en la plataforma Microsoft SharePoint. Con más de 4 años de experiencia en SharePoint, trabajo en la compañía TopGroup, como Líder de Proyectos del área SharePoint, diseñando la arquitectura e implementando soluciones sobre esta plataforma para una gran variedad de clientes. Puede contactarlo en aortiz@topgroup.com.ar si está interesado en crear soluciones SharePoint de alto impacto en su compañía.

Luego de implementar el citado evento en mi propio blog, he recibido muchas preguntas de cómo lo logré.

He aquí la respuesta:

Este trabajo es basado en un algoritmo de Javascript para HTML5 creado por David Flanagan que se basa en generar un elemento canvas por cada copito de nieve bajando en el blog. Entonces cada copo de nieve se agrega al DOM y es animado usando posicionamiento a través de CSS. Sin embargo se puede mejor usar un solo canvas y animar los copos dentro de este tal como lo sugiere Giorgo Sardo, con el fin de ahorrar memoria. Esto sin embargo puede producir que se bloquee la interacción normal con la página… es así que lo mejor es poner el canvas en un background de menor prioridad (atrás del contenido) tal como lo pueden ver en mi blog.    

Este es el JavaScript requerido:

(function () {

    // Start Animation only if browser support <canvas>
    if (document.createElement('canvas').getContext) {
        if (document.readyState === 'complete')
            Snow();
        else
            window.addEventListener('DOMContentLoaded', Snow,
         false);
    }

    var deg = Math.PI / 180;         //Degrees to radians
    var sqrt3_2 = Math.sqrt(3) / 2; //Height of an eq triangle
    var flakes = [];               // Things that are dropping
    var scrollspeed = 64;   // How often we animate things
    var snowspeed = 500;   // How often we add a new snowflake
    var maxflakes = 20;//Max number of flakes to be added
    var rand = function (n) { return Math.floor(n * 
        Math.random()); }

    var canvas, sky;
    var snowingTimer;
    var invalidateMeasure = false;

    function Snow() {
        canvas = document.createElement('canvas');
        canvas.style.position = 'fixed';
        canvas.style.top = '0px';
        canvas.style.left = '0px';
        canvas.style.zIndex = '0';
        document.body.insertBefore(canvas, 
            document.body.firstChild);
        sky = canvas.getContext('2d');

        ResetCanvas();

        snowingTimer = setInterval(createSnowflake,snowspeed);
        setInterval(moveSnowflakes, scrollspeed);

        window.addEventListener('resize', ResetCanvas, false);
    }

    function ResetCanvas() {
        invalidateMeasure = true;
        canvas.width = document.body.offsetWidth;
        canvas.height = window.innerHeight;
        sky.strokeStyle = '#0066CC';
        sky.fillStyle = 'white';
    }

    function drawFlake(x, y, size, order) {
        sky.save();
        sky.translate(x, y);
        snowflake(order, 0, Math.floor(sqrt3_2 * y), size);
        sky.fill();
        sky.stroke();
        sky.restore();
    }

    function snowflake(n, x, y, len) {
        sky.save();           // Save current transformation
        sky.beginPath();
        sky.translate(x, y);   
        // Translate to starting point
        sky.moveTo(0, 0);      // Begin a new subpath there
        leg(n);       // Draw the first leg of the fractal
        sky.rotate(-120 * deg); 
         // Rotate 120 degrees anticlockwise
        leg(n);             // Draw the second leg
        sky.rotate(-120 * deg); // Rotate again.
        leg(n);             // Draw the final leg
        sky.closePath();      // Close the subpath
        sky.restore();        
        // Restore original transformation

        // Draw a single leg of a level-n Koch snowflake.
        // Leaves the current point at the end of
        // the leg it has drawn and translates the coordinate
        // system so the current point is (0,0). 
        // This means you
        // can easily call rotate() after drawing a leg.
        function leg(n) {
            sky.save();           // Save current transform
            if (n == 0) {           // Non-recursive case:
                sky.lineTo(len, 0);//   Just a horizontal line
            }
            else { // Recursive case:           _  _
                //     draw 4 sub-legs like:  \/
                sky.scale(1 / 3, 1 / 3);  
                 // Sub-legs are 1/3rd size
                leg(n - 1);           
              // Draw the first sub-leg
                sky.rotate(60 * deg);  
              // Turn 60 degrees clockwise
                leg(n - 1);          
               // Draw the second sub-leg
                sky.rotate(-120 * deg); 
              // Rotate 120 degrees back
                leg(n - 1);           // Third sub-leg
                sky.rotate(60 * deg);  
                  // Back to original heading
                leg(n - 1);           // Final sub-leg
            }
            sky.restore();            // Restore the transform
            sky.translate(len, 0);// Translate to end of leg
        }
    }

    function createSnowflake() {
        var order = 2;
        var size = 10 + rand(90);
        var t = (document.body.offsetWidth - 964) / 2;
        var x = (rand(2) == 0) ? rand(t) : t + 964 + rand(t);
        // Make it fit with my blog
        var y = window.pageYOffset;

        flakes.push({ x: x, y: y, vx: 
         0, vy: 3 + rand(3), size: size, order: order });

        if (flakes.length > maxflakes) 
           clearInterval(snowingTimer);
    }

    function moveSnowflakes() {
        sky.clearRect(0, 0, canvas.width, canvas.height);

        var maxy = canvas.height;

        for (var i = 0; i < flakes.length; i++) {
            var flake = flakes[i];

            flake.y += flake.vy;
            flake.x += flake.vx;

            if (flake.y > maxy) flake.y = 0;
            if (invalidateMeasure) {
                var t = (canvas.width - 964) / 2;
                flake.x = (rand(2) == 0) ? 
                   rand(t) : t + 964 + rand(t);
            }

            drawFlake(flake.x,flake.y,flake.size,flake.order);

            // Sometimes change the sideways velocity
            if (rand(4) == 1) flake.vx += (rand(11) - 5) / 10;
            if (flake.vx > 2) flake.vx = 2;
            if (flake.vx < -2) flake.vx = -2;
        }
        if (invalidateMeasure) invalidateMeasure = false;
    }


}());

Felices fiestas!

private async void ProcedimientoAsincrono()
{
   for (int i = 0; i < 5; i++)
   {
       //Ejecutar subproceso i
   }
}

await ProcedimientoAsincrono();
SiguienteProcedimiento();

Task.Run(()=>ProcedimientoNoAsincrono());
SiguienteProcedimiento();

Como se observa, Task.Run recibe una Action, que no es más que una Lambda apuntando al procedimiento no asíncrono que existe en algún otro sitio. El procedimiento llamado por Task, también puede ser asíncrono, pero en este caso es más fácil llamarlo directamente, como vimos arriba.

El llamado a Task también es susceptible a ser esperado usando await, así que obtenemos las mismas ventajas:
No se bloque la interfaz y decidimos si trabajar en paralelo o de manera síncrona.

En conclusión vimos qué nos ofrece el Framework .NET 4.5 para generar interfaces de usuario rápidas y fluidas. En el proceso, comprendimos sin muchas complicaciones para qué son y cómo se usan estos tres sujetos: async, await y task.

Para ver async y await en acción, les dejo este post, donde capturamos imágenes desde la cámara de un dispositivo con Windows 8.

Las apps del Windows Store, a diferencia de las de cualquier otro Store de apps, ofrecen una gran versatilidad de presentación, pues pueden ejecutarse en diversos dispositivos que por ende presentarán diversos tamaños de pantalla.

Por ejemplo, podemos ir desde netbooks de 1024x768, pasando a tablets como la Surface de 1366x768 y laptops o desktops de 1280x1024 y muchos intermedios hasta llegar a dispositivos HD como televisores a 1920x1200 y más.

Entonces es lógico concluir que las imágenes que incluyamos en nuestras apps, no van a servir para todas las resoluciones. Deberíamos entonces generar todo programáticamente con vectores, cosa que no es sencilla aunque es posible y soportada en Windows 8.

Cuál es entonces la solución?

Igual recomiendo que comiencen a pensar en vectores. Cuando creen una imagen, háganlo en formato vectorial… olviden el dibujito jpg…. literalmente no escala y cuando escala se pixela. Recuerdan la premisa de que la app debe ser linda y así se debe ver en cualquier tipo de resolución? Pues bien; una de las grandes características de los gráficos vectoriales es que escalan muy bien y es fácil generarlos para varias resoluciones. Los gráficos vectoriales vienen en versiones como *.SVG que ya es un estándar. Y pueden exportarse fácilmente a los formatos convencionales. Además al igual que los *.PNG, soportan muy bien las transparencias. Desafortunadamente las apps como tal no soportan gráficos *.SVG. Siempre tenemos que pasarles las versiones *.PNG preferiblemente.

Pero en ese caso, cómo se logra el escalado para cada tipo de resolución?

Muy sencillo. Windows 8 soporta que pongamos tres versiones de un mismo archivo, para que este pueda escalar adecuadamente. La idea es que cada archivo tenga una escala específica para cada tipo de monitor. En Windows 8 se han definido tres escalas. Normal (basada en una pantalla de 1366x768) o 100%, luego viene una mediana que es de 140% y finalmente la grande de 180% que soporta resoluciones HD sin distorsionar las imágenes. Y dependiendo de la resolución detectada, Windows 8 carga automáticamente el archivo adecuado. Nosotros solo lo referenciamos con la raíz del nombre y Windows 8 escoge el adecuado; otra opción es usar la convención de un folder por cada tipo de escala. Entonces al final implementaríamos de alguna de estas dos maneras:

En este caso, una imagen de 100x100 pixeles, tendría otras dos acompañantes: una de 140x140 y otra de 180x180.

Como se aprecia, es un mecanismo bastante sencillo, ya que teniendo una imagen vectorial, podemos exportarla con las distintas resoluciones, incluirlas en nuestros assets y luego dejar que Windows 8 se encargue del trabajo sucio.

Tal como fue prometido, VS 2012 estará liberando updates frecuentes para mejorar rápidamente la experiencia que con esta herramienta tenemos como desarrolladores. Es el caso del update 1, que aparece solo pocas semanas tras el lanzamiento oficial. Es así como ya no tenemos que esperar a que aparezcan los pesados Service Pack que venían a ejecutar una serie de mejoras, pero con un alto costo de instalación.

El Update de Visual Studio 2012 es detectado automáticamente por la herramienta y se instala desde ella misma. No hay que bajar nada manualmente. Es un proceso bastante sencillo.

Hace solo un día, liberé la segunda versión de mi app PhotoRanker. Y una de las correcciones que le hice, fue incluir el ícono del logo para el store, pues anteriormente había olvidado hacerlo.

Por qué lo olvidé? Fácil: Porque estando trabajando solo con Visual Studio en el editor del Package.appxmanifest que es donde encontramos el “wizard”para ajustar las imágenes requeridas para el store, en ningún lado nos pide esta imagen. Así que uno debe cambiarla manualmente, reemplazando el archivo StoreLogo.png que se encuentra dentro del folder de Assets. Esto es algo muy fácil de olvidar, claramente:

Qué tiene que ver esto con el update de Visual Studio 2012?

Pues que entre muchas otras mejoras, el editor del Package.appxmanifest ha cambiado, incluyendo un manejador de imágenes mucho más avanzado y adecuado:

Como se aprecia, aquí sí aparece el espacio para incluir el Store Logo de nuestra app. Así que ya no vamos a requerir un update solo para esto (cosa de la que yo fui victima). Pero por si fuera poco, además del nuevo orden que se le ha dado, podemos especificar también las tres escalas que manejamos en Windows 8 para poder presentar siempre imágenes de alta resolución sin importar el tamaño del dispositivo de presentación, tal como lo explico en este post.

Es una gran mejora que facilita la vida a nosotros developers al momento de preparar nuestros paquetes de apps para certificar en el store.

Otras mejoras incluidas en el update:

• Code Analysis para apps de Windows Phone 8
• Mejoramiento en el ALM para aplicaciones de SharePoint sobretodo en el campo de testing.
• Mejoras para el trabajo en equipos ágiles en la administración de proyectos. Esto incluye soporte a Kanban; una herramienta para hacer tracking de proyectos.
• La Calidad Continuada ha sido protagonista de mojoras también; por ejemplo con el update ya se puede ejecutar el code coverage en pruebas manuales de ASP.NET, sin mencionar que ya se puede ejecutar también grabado de pruebas en Internet Explorer, que después pueden reproducirse en los browsers modernos, para poder ejecutar pruebas cross-browsing.

Si aún no te ha llegado el update y quieres aplicarlo ahora, puedes ejecutarlo desde aquí.

No son tan graves como el título; pero tener conocimiento de ellas, nos ayudará a evitar tener que perder tiempo en envíos/rechazos de nuestras apps al store.

Este artículo contiene información extraida de este post de uno de nuestros MVPs. Se trata de Roberto Alvarado, quien ha estado trabajando mucho con el desarrollo móvil, aún desde Windows Mobile. Así que me he permitido invitarle a mi blog con su post acerca de esta experiencia y él muy amablemente quiso acompañarnos. También tiene información extraida de este post de Juan Carlos Ruiz, colega mío dentro de Microsoft Colombia, y finalmente de mis propias experiencias desde que ha estado al aire el store de Windows. Es así como primero listaré las observaciones de Roberto y luego las de Juan, adicionando algunos comentarios donde sea requerido: 

De Roberto Alvarado:

1. Seleccionar el idioma de la App y de la tienda.

Independiente que el idioma de Visual Studio sea ingles, el idioma de la aplicación y sobre el cual se certificará en la tienda debe ser claro y especifico.

En mi caso, el idioma es español y en Colombia.

Nota de WarNov: Este cambio de idioma tan importante se ejecuta dentro de Visual Studio. No en el store. Se hace en el archivo  Package.AppManifest que tiene un editor visual para hacer el cambio. Los detalles de este procedimiento los pueden encontrar en este post que he creado.

2. La descripción de la aplicación que se va a colocar en la tienda debe ser una frase que tenga mínimo 7 palabras, no debe ser una palabra. Debe describir de manera rápida y sencilla lo que hace la aplicación.

3. Se deben enviar mínimo 2 imágenes de 1366 x 768, a pesar de que solo se exige 1, si se envía 1 imagen nos rechazan la App.

4. Es muy importante tener una pagina web o Url en donde se publique una Política de privacidad para nuestra App.

Si no tiene una, puede utilizar esta, que fue provista por WarNov para su difusión: tiene el texto tanto en ingles como en español. http://bdotnet.wix.com/privacypolicy

Además tu App debe tener un charm en donde indique la política de privacidad que utilizas, en este link te indico como puedes crear este charm: Crear página de Política de Privacidad de un App Windos 8

Nota de WarNov: Solo es requerido que tu app incluya una política de privacidad, si en las capacidades de la app dentro del manifiesto de la misma, se especifica que la app se conecta a internet:

En el ejemplo ven el manifiesto de mi app PhotoRanker y como ven, dado que mi app no usa internet, no requiere una política de privacidad.

5. Llenar o dar las instrucciones necesarias al equipo de testing en el store, sobre el manejo de la aplicación para que no sea rechazada porque no la saben manejar.

En la imagen un ejemplo sobre este punto.

6. Es muy importante el rango de edad en el cual coloca su App, si su rango de edad es de 3 años o superior, o de siete años o superior, su App no debe tener conexión a Internet ni hacer utilización de la cámara del dispositivo.

Tengamos muy en cuenta las opciones y recomendaciones que nos da la misma tienda de Windows para ubicar nuestra App en uno de los rangos de fechas disponibles.

En este momento no hay posibilidad si no de estas 4 opciones para nuestro App.

Nota de WarNov: Para la mayoría de Apps, es recomendable escoger el límite de edad 12+.

7. La imágenes del App, si verificamos la carpeta Assets del explorador de soluciones de Visual Studio, debemos dejar los mismos nombres de las imágenes, el mismo formato y principalmente las mismas dimensiones de lo contrario nuestra App será rechazada el momento de ejecutar el kit de Certificación de App para Windows 8.

Un ejemplo de esto:

Si cambia el nombre de la imagen del logo por ejemplo debe indicarlo en el manifiesto también del App de manera correcta.

8. Si utiliza una base de datos local, como SQLite, debe asegurarse que en las propiedades del proyecto en la pestaña de Compilación (Build) esté seleccionado el procesador correcto de su PC, y asegurarse que en las referencias del proyecto, la referencia de SQLIte no tenga una advertencia, si la tiene, elimine la referencia y vuelva a crear la referencia a SQLite.

9. Al publicar su App debe asegurarse que tener en “Release” su App al momento de las compilaciones y verificaciones que se realizan con el KIT de Certificación.

De Juan Carlos Ruiz:

1. Website

• La aplicación debe estar publicada en un sitio web del publicador o uno específico para la App con vínculos claros que permitan descubrir la aplicación a los usuarios a través de la pagina web
• No tienes sitio web? no sabes como crearlo? hay muchas formas de crear sitios web sencillos rápidamente sin una línea de código, solo búscalos en internet

Nota de WarNov: No es necesario crear un sitio web para la app como tal. Por ejemplo poner tu url de twitter como desarrollador, será suficiente. Aunque sin lugar a dudas, es mucho mejor tener un website dedicado a la app donde tengas info de la misma como instrucciones y changelog, tal como lo hice para mi app PhotoRanker, usando los WebSites de Windows Azure, que son totalmente gratuitos.

2. Estabilidad

• Cero fallos después de abrir y cerrar varias veces
• Desconexión de red, la app no debe hacer crash si no hay dispositivos de red o la red esta caída
• Desconexión internet la app no debe hacer crash si no hay conexión a internet
• La aplicación no debe presentar ningún fallo o app crash durante su uso

3. Contenidos

• Aptos para todos: no sexo explícito , no agredir religiones, no terrorismo, no discriminación de ninguna índole
• Si la aplicación se clasifica en el rating para niños menores de 7 años NO SE PUEDE HACER USOS DE DISPOSITIVOS NI DE INTERNET, en este caso la aplicación debe considerarse para mayores de 7años de forma obligatoria.
• Si la aplicación puede mostrar contenidos sensibles como desnudos artísticos parciales o violencia real moderada etc. se recomienda establecerla para mayores de 16 años

4. Funcionalidad

• La aplicación DEBE soportar Snapped View, con esto no digo que tengan que desarrollar esta vista adicional, pero por lo menos sino lo hacen deben evitar que en ese espacio se muestre la información de manera desordenada o desagradable , en dado caso sino se va a soportar la funcionalidad entonces colocar una banner que cubra todo el espacio, tal como lo hace la propia App del Windows Store
• Si implementan funcionalidades de búsqueda, esta debe estar creada usando el Charm de búsqueda (Search), cualquier implementación diferente causa el rechazo de la App.

Nota de WarNov: De la anterior regla de búsqueda, quedan excluidas las apps que tengan funcionalidades de búsqueda avanzada que requieran de más de un campo de búsqueda. Por ejemplo una app para buscar vehículos para comprar puede requerir buscar por modelo, color o placa. En este caso, sí se justifica una búsqueda adicional a la incluida en el charm.

• No deben haber botones para cerrar la App
• Si en el manifest se marca que la App soporta determinadas posiciones de la tableta, así debe ser, si falta alguna de las seleccionadas la aplicación es devuelta.
• La app no debe ser solo para mostrar publicidad, la publicidad debe ser utilizada en justa medida, pero no puede ser el objeto principal de la App.
• La aplicación debe ser 100% funcional utilizando solo dispositivos Mouse y Teclado
• La aplicación debe ser 100% funcional utilizando solo dispositivos Touch
• La aplicación debe tener descripción adecuada, todos los logos necesarios y screenshots en Windows Store y en el Package.appmanifest
• La aplicación no debe incluir en su nombre palabras como “trial”, “test”, “beta”, “demo” , si es requerido informar que la aplicación esta en etapa preliminar, utilizar la palabra "preview"
• La aplicación no debe tener en la pantalla principal ninguna característica, marco, tableta, botón o label que indique que es una funcionalidad futura, es decir evitar palabras como "coming soon”, “more to come”, “not available yet” . "próximamente", "en construcción" etc.
• Las funcionalidades principales de la aplicación no deben re direccionar el usuario al browser. Solo características no principales en el 2do o 3er nivel de navegación son permitidas para direccionar al browser. Las funcionalidades principales deben estar dentro de la App.
• Se recomienda incluir información para soporte técnico en el Charm de configuración (settings ) y en la página web de la aplicación, con alguno de los siguientes mecanismos de contacto:
  • email de contacto
  • url
  • teléfonos etc.

5. Información para Windows Store

• Si la aplicación requiere de usuario y contraseña u otros mecanismos para garantizar el acceso a todas sus características se debe enviar junto con la aplicación la información de acceso necesaria para realizar las pruebas. Hay una sección llamada ‘Notas para testers’ donde se debe depositar dicha información.
• Si la aplicación requiere información o trámites de pago para activar funcionalidades, en las notas para los testers se debe incluir información de pago que puedan utilizar para acceder a estas características de la aplicación y realizar pruebas.
• Validar que toda la información del Windows Store este correctamente diligenciada, poniendo especial atención a los ratings y publico objetivo, así como a la descripción de la aplicación, el vínculo a la política de privacidad etc.

6. Localización y Lenguaje

• La localización y lenguaje de la aplicación debe ser establecido en el package.appmanifest. Ejemplo: si la app esta en español pero en el manifest dice EN-US será rechazada, puesto que esta cadena de localización indica que la App esta en inglés  y esto no es cierto.
• Localización: La aplicación debe estar completamente localizada para los lenguajes que se hayan establecido en el package.appmanifest, esto incluye: textos y logos, screenshots etc. Si la aplicación va a nivel mundial se recomienda soportar 100% ingles.
• Todo lenguaje soportado debe tener personalizados el 100% de los textos, imágenes etc. Localizaciones parciales son rechazadas automáticamente

7. Política de Privacidad

• Si la aplicación recopila información del usuario de alguna índole esta DEBE TENER una política de privacidad asociada

Nota de WarNov: En realidad la condición no es recopilar info del usuario o no, sino el mero hecho de que en las capacidades de la app dentro del manifiesto de la misma, se especifica que la app se conecta a internet, como lo muestro en mi segunda anotación arriba.

• Aunque la app no haga uso de ninguna información del usuario, se recomienda indicar eso en una política de privacidad sencilla.
• La política de privacidad que se declara dentro del sitio web creado para la App, debe estar conforme a la estructura del sitio y no ser un archivo de texto nada más. La política debe ser descubrible por vínculos dentro del sitio.
• Se recomienda que la política de privacidad sea accesible desde el Charm de configuración
• Si se comparte información con terceros,  en el Charm de configuración junto con la política de privacidad se debe agregar una opción visible para autorizar o denegar ese uso de los datos.
• Si el usuario no autoriza dicho uso la aplicación no debe perder toda funcionalidad, esto no es aceptado, la restricción de funcionalidad debe ser limitada.

Las apps para el Windows Store y Windows Phone Store, manejan un lenguaje por defecto que se encuentra en el manifiesto de cada una de ellas.

Este lenguaje se ajusta de acuerdo al lenguaje de la máquina del desarrollador. Por ejemplo si el desarrollador tiene su máquina ajustada a Inglés de Estados Unidos, este será el lenguaje por defecto de la app.

Sin embargo, este lenguaje es configurable; pero al encontrarse en una ubicación no muy visible, puede pasar que no lo observemos y luego pasemos al proceso de publicación dejando un lenguaje por defecto incorrecto, porque puede que haya quedado en Inglés y nuestra app vaya solo en español.

Cuando pasamos al proceso de publicación en ambos store nos piden los idiomas en los que está disponible nuestra app. También nos piden los países en los que queremos visible nuestra app.

Ojo que son cosas distintas que no deben confundirse: Uno como developer puede poner su app visible en diversos países, independientemente del o de los idiomas que esté exponiendo. Hay developers que piensan que dado que nuestra app solo expone español, entonces no puede ponerse en mercados que no hablan español, pero esto no es así. Lamentablemente este hecho nos puede quitar oportunidades de darle visibilidad a nuestra app al ponerla en varios países, tal como lo describo en este post.

Por ejemplo yo como developer colombiano puedo poner mi app visible en Colombia, Estados Unidos e Inglaterra, habiéndola publicado solo en español. Y esto es válido y la app puede ser publicada sin ningún problema.

Sin embargo observen este hecho curioso: Supongan que escogemos Español. Y que agregamos todos los recursos e imágenes en español necesarias para este fin. Además que pusimos nuestra app disponible en todo el mundo.

Pero luego de un tiempo nos llega el rechazo de la app porque dizque no subimos los recursos necesarios para los lenguajes especificados. Será porque escogimos países que no hablan español?

Como lo expliqué anteriormente, este no es el motivo.

Por qué pasa esto?

Como les comenté al principio, dado que las apps además quedaron con lenguaje por defecto Inglés Estados Unidos, pues el store espera que subamos esos recursos también.

Así que la forma de solucionar este problema es modificar estos lenguajes y culturas por defecto, antes de subir la app al respectivo  store.

En el caso de Windows Phone, esta información se encuentra en las propiedades de la app. Así que abriendo el cuadro de diálogo propiedades desde el explorador de soluciones dando click derecho obtenemos el editor de propiedades. Allí escogemos la información del assembly y allí modificamos el valor. En este ejemplo vemos como estamos cambiando desde Inglés Estados Unidos a Español Colombia:

En Windows 8, esta información se configura desde el editor del Package.appxmanifest (doble click al archivo con este nombre para abrir el editor):

Aquí solo basta corregir “en-US” por es o por ejemplo “es-CO”.

Y listo!

De esta manera ya le estamos diciendo al store que no espere recursos de Inglés Estados Unidos, porque ahora la cultura por defecto es el Español.

Conclusión: No se confundan si su app es rechazada por motivos de idioma. Esto no tiene nada que ver con los países de publicación elegidos, sino con la cultura por defecto que viene configurada cuando ustedes arrancan a desarrollar una app.