Un año más, vuelve el Hackathon multiciudad simultáneo. El Megathon, durante el fin de semana del 12 al 14 de abril.

Este año se va a cambiar la dinámica del concurso. Por un lado se podrá desarrollar aplicaciones tanto para Windows 8 como para Windows Phone 8, los premios se incrementan, pero seguro que el buen ambiente y el buen rollo durante todo el fin de semana se va a mantener respecto al pasado año.

Yo, en esta ocasión, tengo el gran honor de estar como mentor en la sede de Salamanca. Los chicos del club .NET de la universidad de Salamanca, USAL, han querido que este con ello intentando ayudar en todo lo que pueda. Eso sí, estoy convencido que los ganadores globales del Megathon este año saldrán de Salamanca. No os quepa duda!!!!!

Otra de las cosas que este año han cambiado ha sido la formación. Muchos opinaron que el pasado año, combinar la formación con el tiempo para desarrollar fue algo estresante. En muchas ocasiones los mentores se encontraron dando charlas al limbo ya que todo el personal estaba dale que te dale a programar, lo digo por experiencia. En esta ocasión los chicos de DPE España, han tenido la gran idea de realizar unas formaciones online, los días previos al megathon.

Por lo tanto entre el próximo día 20 de Marzo y el 11 de Abril podéis “disfrutar” de sesiones de formación tanto de programación en Windows 8, Windows Phone, Azure y Team Foundation Services.

Si queréis mas información, no dudéis en acudir a la web habilitada para tal efecto en la web de Microsoft España.

www.microsoft.es/megathon

Allí encontrareis las bases, las ciudades, recursos de formación, etc., etc.….

Nos vemos en el MEGATHON!!!!

Lo primero que debemos de hacer es controlar de alguna forma si nuestra aplicación esta en modo trial o no. Para ello usaremos la clase LicenseInformation contenida en el espacio de nombres Microsoft.Phone.MarketPlace.

Algún habido lector, habrá pensado, …..MarketPlace?, pero si eso suena a viejuno. Pues si, aunque con la aparición de Windows Phone 8 y el uso de WinRT existe un nuevo espacio de nombres para cualquier tipo de consulta relacionada con estos menesteres, concretamente Windows.ApplicationModel.Store, la clase LicenseInformation que deriva de dicho namespace no se puede usar en Windows Phone 7.x por lo que la mejor forma para hacer este trozo de código totalmente compatible tanto con Windows Phone 7.x como con Windows Phone 8, es usar la clase LicenseInformation de Microsoft.Phone.Marketplace.

Bueno, entonces está claro. Ahora, ¿cual debería de ser la mejor implementación?. Obviamente no quiero sentar cátedra pero siendo un poquito costosa, hablando de rendimiento, la labor de comprobar si nuestra aplicación es o no una versión de prueba. Lo suyo seria realizar esta consulta una sola vez y “archivar” esta información en algún lugar accesible.

Para ello, una de las mejores formas es disponer en nuestro fichero App.xaml.cs de una variable publica y estatica la cual implemente guarde dicha información.

private static bool isTrial;

public static bool IsTrial

{

   get

   {

      return isTrial;

   }

}

Así mismo dispondremos de un procedimiento el cual comprobará mediante la clase LicenseInformation comentada anteriormente, si es o no, nuestra aplicación una versión de prueba. Le llamaremos por ejemplo CheckLicense.

private void CheckLicense()

{

   LicenseInformation license = new Microsoft.Phone.Marketplace.LicenseInformation();

   isTrial = license.IsTral();

}

Ok, perfecto. Simplemente implementamos la clase LicenseInformation y comprobamos su método isTrial, el cual nos devuelve un booleano indicándonos el estado.

Ahora debemos de lanzar en el lugar y momento correcto, el código anterior. Dos son los lugares en donde deberemos de lanzarlo. Por un lado el evento Launching de nuestra aplicación. De esta forma cada vez que lanzamos la aplicación comprobamos el valor.

private void Application_Launching(object sender, LaunchingEventArgs e)

{

    CheckLicense();

}

El otro punto sería el evento Activated. ¿Para que?, si nuestra aplicación no va a cambiar su estado constantemente. Pues básicamente para poder controlar de forma correcta que se haya podido adquirir la aplicación de forma completa mediante un enlace colocado en nuestra aplicación o cuando nuestra aplicación esta suspendida. De esta manera al volver a activarla desde el estado de tombstoning recogemos el valor de forma correcta y actuamos en consecuencia.

private void Application_Activated(object sender, ActivatedEventArgs e)

{

    CheckLicense();

}

Perfecto ya tenemos controlado el acceso a la comprobación solamente en dos puntos, accediendo a la información en cualquier momento sin consumo de recurso alguno.

Vamos a plantear una pantalla muy sencilla la cual, recoja este valor y realice una serie de acciones.

<Grid>

    <Grid Margin="0,0,0,0">

        <Grid.RowDefinitions>

            <RowDefinition Height="Auto"></RowDefinition>

            <RowDefinition></RowDefinition>

        </Grid.RowDefinitions>


        <TextBlock Grid.Row="0" Text="Trial version example"

                    VerticalAlignment="Top"

                    Margin="12,12,0,12"

                    FontSize="42">

        </TextBlock>


        <StackPanel Grid.Row="1">

            <Button Content="action A"

                    Margin="0,130,0,0"

                    HorizontalAlignment="Center"

                    Width="350"

                    Command="{Binding ActionACommand}">

            </Button>

            <Button Content="action B"

                    HorizontalAlignment="Center"

                    Width="350"

                    Command="{Binding ActionBCommand}">

            </Button>

            <Button Content="purchase complete version"

                    Margin="0,130,0,0"

                    HorizontalAlignment="Center"

                    Visibility="{Binding TrialVersion,

                                Converter={StaticResource BoolToVisibility}}"

                    Width="350"

                    Command="{Binding PurchaseCommand}">

            </Button>

        </StackPanel>

    </Grid>

</Grid>

Obviamente (faltaría más) todo nuestro XAML usa una ViewModel de MVVM para realizar toda la lógica de nuestra pagina. Como podéis ver disponemos de 3 sencillos botones. El ultimo de los botones usa un converter para convertir la propiedad TrialVersion de nuestra ViewModel en el correspondiente valor de la enumeración System.Windows.Visibility.

Veamos ahora nuestra ViewModel por partes.

public class VMMainPage : VMBase

{

    bool trialVersion = true;

    Lazy<DelegateCommand> actionACommand;

    Lazy<DelegateCommand> actionBCommand;

    Lazy<DelegateCommand> purchaseCommand;


    public VMMainPage()

    {

        this.trialVersion = App.IsTrial;

        ........

    }


    public bool TrialVersion

    {

        get

        {

            return this.trialVersion;

        }

    }


    ...........

    ...........

}

Hemos creado una variable privada la cual en el momento de instanciar nuestra ViewModel toma el valor de la variable estática contenida en nuestro App.xaml.cs. Por otro lado hemos creado las variables privadas de los DelegateCommands que usaremos a continuación.

Podemos ver también la propiedad publica TrialVersion, que hemos usado en nuestra vista para visualizar o no, a través del converter, el botón de purchase o compra de la aplicación.

    private void ActionACommandExecute()

    {

        MessageBox.Show("Action A");

    }


    private void ActionBCommandExecute()

    {

        MessageBox.Show("Action B");

    }


    private bool ActionBCommandCanExecute()

    {

        return !this.trialVersion;

    }

Ahora vemos la implementación de los comandos asignados a los dos primeros botones. Estos simplemente muestran un mensaje en pantalla (esto lo deberíamos de hacer con un servicio, pero bueno para no complicar mas las cosas…) En la inicialización del primero de ellos, no hemos asignado nada a la función de retorno del CanExecute, pero si en el caso del segundo botón.

En el ejemplo dejamos el primer botón accesible a cualquiera de los dos tipos de estado de la aplicación, mientras que el segundo botón, estará deshabilitado si la aplicación está en versión Trial. Para ello retornamos el valor contrario a la variable privada isTrial como respuesta en el CanExecute de este segundo botón.

El resultado hasta el momento de nuestro pequeño ejemplo es el siguiente:

La mejor forma de dirigir al usuario a comprar la versión completa de nuestra aplicación es utilizar el lanzador MarketPlaceDetailTask, como podemos ver en la implementación del comando que ejecuta nuestro tercer botón.

    private void PurchaseCommandExecute()

    {

        MarketplaceDetailTask market = new MarketplaceDetailTask();


        market.Show();

    }

Así de sencillo. Simplemente instanciamos el lanzador y lo ejecutamos con su método Show. La clase MarketplaceDetailTask dispone de una propiedad denominada ContentIdentifier, la cual acepta un valor string que representa el ID del producto del cual queremos mostrar sus características para proceder a la compra. Si este valor no es asignado o es asignado un valor nulo, el lanzador muestra los datos de la aplicación la cual le ha llamado.

Lamentablemente si la aplicación no esta publicada, ya estemos ejecutando en el emulador o en un dispositivo físico, la llamada al método show de la clase nos lanzara un error como el que vemos a continuación. Es algo que debemos de tener en cuenta.

Bueno, pues llegados a este punto ya sabemos como controlar si nuestra aplicación esta en versión trial o versión completa. Como de forma muy sencilla poder gestionarlo con MVVM y como poder realizar la compra mostrando la correspondiente pagina de la Windows Phone Store de nuestra aplicación. Pero, ¿como podemos probar para dar valores según nos convenga a la variable IsTrial de nuestro App.xaml.cs?

Ya que si ejecutamos la aplicación tal y como la tenemos hasta el momento al leer el valor del método isTrial, de la clase LicenseInformation, este siempre nos devuelve false.

Para ello existen principalmente dos formas, que cada uno usa según le parezcan. Por un lado podríamos detectar si estamos en modo debug y preguntar si queremos ejecutar en modo trial o en modo full.

private void CheckLicenseWithQuestion()

{

#if DEBUG

    string message = "Pulsa 'OK' para simular el modo trial. Pulsa 'Cancel' para ejecutar la aplicación en modo normal.";

    if (MessageBox.Show(message, "Debug Trial",MessageBoxButton.OKCancel) == MessageBoxResult.OK)

    {

        isTrial = true;

    }

    else

    {

        isTrial = false;

    }

#else

    LicenseInformation license = new Microsoft.Phone.Marketplace.LicenseInformation();


    isTrial = license.IsTrial();

#endif

}

En el código anterior hemos modificado nuestro procedimiento CheckLicense para que, mediante el uso de directivas de compilación condicional, en el caso de que estemos compilando en modo debug, nos lance una pregunta para elegir el modo de prueba de la aplicación. Activado o desactivado. En el caso de que estemos compilando en versión release, directamente se comprobara el modo de ejecución a través de la clase LicenseInformation. El resultado seria el siguiente:

Pero este método solo funcionara en aplicaciones para Windows Phone 7.x, ya que la llamada al método Show, de nuestro MessageBox, en Windows Phone 8 no se puede hacer hasta que no se ha inicializado el elemento RootVisual de nuestra aplicación. Es decir para poder usar este método en WP8, no es posible indicar la llamada en el evento Launching, sino que lo deberemos de invocar en el evento CompleteInitializePhoneApplication, tras la asignación del RootVisual.

Esto trae mas problemas, ya que si llamamos en ese lugar al procedimiento CheckLicense, nuestra ViewModel principal ya a sido creada por lo que ya hemos recogido los valores de la propiedad IsTrial, sin haberla dado el valor que queremos. La implementación en este caso debe de ser diferente y deberíamos de comprobar los valores de dicha propiedad sobrescribiendo el evento OnNavigatedTo de nuestra pagina principal.

Otra forma seria seguir implementando el procedimiento CheckLicense como hasta el momento, y simplemente en el modo debug activar siempre el modo trial.

private void CheckLicense()

{

#if DEBUG

    isTrial = true;

#else

    LicenseInformation license = new Microsoft.Phone.Marketplace.LicenseInformation();


    isTrial = license.IsTrial();

#endif

}

Esto tiene un gran inconveniente y es que para poder probar la versión completa, deberemos de compilar en modo release, perdiendo todo lo que el modo debug nos aporta. Para solventar este problema podríamos crear en Visual Studio una nueva configuración de compilación. Para ello debemos de dirigirnos al menú “Build > Configuration Manager”. Dentro de él, seleccionamos del combo “Active solution configuration”, el valor “<New…>”.

En la nueva pantalla que se abre, indicaremos un nombre para la nueva configuración, por ejemplo “Debug Trial” e indicaremos que queremos copiar todos los valores de la configuración ya existente “Debug”.

Una vez creada esta nueva configuración vamos a otorgarla una valor necesario para nuestro cometido. Para ello, entraremos en las propiedades de nuestro proyecto y en la pestaña de “Build” seleccionaremos la nueva configuración que acabamos de crear, en este caso “Debug Trial”.

Una vez seleccionada, solamente deberemos de añadir en la casilla de “Conditional compilation symbols:” la palabra “TRIAL” precedida de un punto y como para separarla de las que ya existen. Ojo en el ejemplo indico la palabra Trial, pero obviamente podríamos usar la que quisiéramos.

Con nuestra nueva configuración ya creada y parame trizada a nuestro gusto, tan solo nos resta modificar definitivamente nuestro procedimiento para adecuarle a los nuevos cambios.

private void CheckLicense()

{

#if TRIAL

    isTrial = true;

#else

    LicenseInformation license = new Microsoft.Phone.Marketplace.LicenseInformation();


    isTrial = license.IsTrial();

#endif

}

Como vemos la directiva de compilación condicional, ahora busca la palabra “TRIAL” en vez de genéricamente “DEBUG” como anteriormente. Ahora cuando queramos ejecutar en modo debug versión trial, seleccionaremos una opción de compilación, en el caso de compilar en modo debug en versión completo, seleccionaremos otra. Según nos convenga en cada caso.

Ya tenemos todo nuestro código implementado. Como comento al principio esta es una de las muchas formas de realizar la gestión de las versiones trial de nuestras aplicaciones.

Pero una cosa es segura, cualquier aplicación de pago que se precie de disponer si o si de una versión Trial. Los datos aportados por la Windows Phone Store lo indican. Las aplicaciones con versiones trial son descargadas 70 veces mas que las que no las tienen. Con una media de un 10% de conversiones a versión completa. Lo que representa un 10 veces más ingresos que una aplicación que no disponga de versión trial.

Aquí os dejo el enlace a un ejemplo de código que muestra todo lo que he comentado hasta el momento.

Para cualquier cosa, ya sabéis donde estoy…. 

A pasarlo bien.

Pero este año disponemos de otra categoría. Y es que también cualquier persona que desarrolle y suba una aplicación para Windows 8, también tendrá su propio sorteo de otra XBOX 360 por semana.

La adjudicación de premios es por riguroso sorteo entre todos los participantes en la promoción, 1 premio para Windows Phone y otro para Windows 8. En esta ocasión no existirá ni jurado ni calificación de la aplicación, quien mas suerte tenga será quien se lleve el gato al agua.

A parte de esto si durante el transcurso de esta promoción es activada una subscripción a Windows Azure, podrás ganar una subscripción a MSDN.

Un aliciente mas para desarrollar……

Suerte a todos.

Recuerdo ahora mismo las muchas conversaciones que Yeray y yo hemos mantenido sobre la escritura de este libro. Sobre disponer en español de una buena fuente de información sobre la programación en estas plataformas siguiendo un patrón de diseño especifico, en este caso MVVM y trabajando siempre con buenas practicas.

Lo que en su momento iba a ser algo sencillo, de distracción para el verano, se fue convirtiendo poco a poco en un mastodonte que no hacia mas que crecer en contenido. Seguramente a ambos nos hubiera gustado contar mas cosas en el libro. Por ejemplo por falta de tiempo nos hemos dejado en el tintero cosas como la gestión de procesos en Background, la gestión de trials, el In-app purchase, y muchos mas etcéteras que seguro poco a poco irán viendo la luz en nuestros respectivos blogs…

Pues nada, lo dicho, aquí podéis adquirir nuestro nuevo libraco y a empezar a degustarlo poquito a poquito, que tiene su miga.

Por cierto, gracias a la colaboración de Nokia España, todos los que compréis el libro el primer mes, entrareis en el sorteo de un flamante Nokia Lumia 820, una subscripción al WP Dev Center, componentes de Telerik y alguna cosilla más.

Con lo que no podéis dejar pasar esta oportunidad. ALE A COMPRAR…..

Antes de terminar, quiero dejar aquí constancia de los agradecimientos expresados por mi parte en el libro. Nunca podre expresar todo lo que mi familia me ha ayudado para poder llegar hasta aquí, por lo que esto es otra pequeña gota de gratitud.

“Cuando hace ya unos cuantos meses, Yeray y yo decidimos escribir este libro, jamás me hubiera imaginado que fuera a ser una de las tareas más costosas de todo cuanto he realizado hasta el momento. Todo el tiempo que he dedicado en su escritura, se lo he tenido que robar al sueño y por supuesto a mi familia. Por esa razón, solo puedo agradecer a mi mujer Susana y a mi hija Celia, su inmensa paciencia al verme un día sí  y otro también pegado al portátil, sin dedicarlas en los últimos meses el tiempo que ambas se merecen. Gracias por vuestro apoyo constante y por creer tanto en mí"

Si alguno de vosotros a intentado usarla, podrá ver que tanto el método InvokeScript como el evento ScriptNotify no funcionan. Es mas si en el código HTML que cargamos en nuestro WebBrowser tenemos cualquier tipo de código de script, este tampoco funcionará.

En mi anterior post os había comentado que nuestro WebBrowser tenia por defecto deshabilitada la opción de cargar y ejecutar cualquier tipo de script, pero que simplemente indicando a true la propiedad IsScriptEnabled de dicho control, todo funcionaria.

Bueno, pues como todos habréis visto en la plantilla que Visual Studio nos crea, una de las primeras líneas de código, concretamente en el evento Loaded del WebBrowser, viene pre escrito concretamente esto

private void Browser_Loaded(object sender, RoutedEventArgs e)
{
    // Add your URL here
    Browser.Navigate(new Uri(MainUri, UriKind.Relative));
    Browser.IsScriptEnabled = true;
}

Con lo que ya nos podemos imaginar que la comentada propiedad IsScriptEnabled, esta perfectamente indicada.

Pues bien, este código no funciona ya que dicha propiedad debemos de indicarla o cambiar su valor antes de realizar la navegación para que surta efecto. Para solventar este problema simplemente deberemos de establecer la propiedad a true directamente en las propiedades del control dentro del código XAML.

<phone:WebBrowser x:Name="Browser"
            HorizontalAlignment="Stretch"
            VerticalAlignment="Stretch"
            Loaded="Browser_Loaded"
            IsScriptEnabled="True"
            NavigationFailed="Browser_NavigationFailed" />

Es una opción, existen otras, pero quizás sea la mas sencilla.

Comencé diciendo que era un error gravísimo y así me lo parece, ya que cualquier neófito puede pasarse mucho tiempo hasta que descubra que todo su código no funciona simplemente por un error de bulto de quien a diseñado esta plantilla.

Bueno esperemos que dentro de no mucho la corrijan. Pero de momento basta con saberlo y poder solucionar el problema..

Bueno seguiré hablando en sucesivas entradas de la programación HTML dentro de Windows Phone, aunque pueda perder amigos por el camino…… ;-( 

Bueno la cuestión es, que el nuevo SDK de Windows Phone 8, incorpora una nueva plantilla de proyecto la cual se denomina “Windows Phone HTML5 App”.

Esta plantilla no es mas que una pagina de Windows Phone, con un componente WebBrowser incorporado, una serie de eventos de la misma ya creados y una carpeta denominada HTML en donde nos encontramos con una estructura de web básica.

Disponemos de la posibilidad de interactuar desde la web que se visualiza en el WebBrowser, con nuestro sistema a través del evento ScriptNotify, y desde nuestra aplicación con la pagina web usando el método InvokeScript.

Vamos a poner un ejemplo muy sencillo. Realizaremos algunos cambios en el código creado por la plantilla para mostrar el control WebBrowser, un textbox y un simple boton. La idea es mostrar en la web incrustada en el WebBrowser lo que le indiquemos en el textbox y mostrar un MessageBox de Windows Phone cuando interactuemos con la web.

Y nuestro código HTML que mostraremos en el WebBrowser tendrá una pinta como esta:

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <link rel="stylesheet" type="text/css" href="/html/css/phone.css" />
        <title>Windows Phone</title>

      <script type="text/javascript">
        function IncorporarTexto(data) {
          container.innerText = data;
        }
      </script>
    </head>
    <body>
      <div id="container">
        El texto Aquí.
      </div>
    </body>
</html>

Ahora simplemente deberemos de llamar al método InvokeScript desde el evento Click de nuestro botón, pasando como parámetro al script de la pagina web el texto contenido en el TextBox, de la siguiente forma.

private void Boton1_Click(object sender, System.Windows.RoutedEventArgs e)
{
    if (loadCompleted == true)
    {
        Browser.InvokeScript("IncorporarTexto",TextBox1.Text);
    }
}

Vemos en el anterior trozo de código que disponemos de una variable para controlar si la pagina esta totalmente cargada o no, ya que el método InvokeScript solo funcionará de forma correcta cuando el HTML a cargar en el WebBrowser haya terminado totalmente de cargarse. Para ello podremos controlar esto subscribiéndonos al evento LoadCompleted de nuestro WebBrowser.

private void Browser_LoadCompleted(object sender, 

                               System.Windows.Navigation.NavigationEventArgs e)
{
    loadCompleted = true;
}

Ok, perfecto ya sabemos como podemos interactuar desde nuestra aplicación y desde nuestro código C# en los scripts de nuestra pagina web que acabamos de cargar.

Solamente una cosa mas, nuestro componente WebBrowser por defecto tiene deshabilitada la capacidad de ejecutar scripts en el código HTML que se carga. Para poder habilitar dicha capacidad debemos de indicar a true la propiedad IsScriptEnabled de dicho componente WebBrowser.

La siguiente opción que hemos comentado es la capacidad del código HTML cargado por el componente WebBrowser para interactuar con nuestro sistema, mediante el control del evento ScriptNotify del propio WebBrowser.

Vamos a modificar nuestro código HTML, para crear una nueva función en JavaScript e incorporar un botón que dispare dicha función.

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <link rel="stylesheet" type="text/css" href="/html/css/phone.css" />
        <title>Windows Phone</title>

      <script type="text/javascript">
        function IncorporarTexto(data) {
          container.innerText = data;
        }

        function SaludarAlTelefono() {
          var texto = "Hola WP8 desde JS";
          window.external.notify(texto);
        }

      </script>
    </head>
    <body>
      <div id="container">
        El texto Aquí.
      </div>
      <hr/>
      <button onClick="SaludarAlTelefono()">Saludar</button>
    </body>
</html>

Como podemos ver para realizar esta acción usamos el objeto de JavaScript, window.external, concretamente el método notify, el cual es el encargado de disparar el evento ScriptNotify del WebBrowser.

private void Browser_ScriptNotify(object sender,
                   Microsoft.Phone.Controls.NotifyEventArgs e)
{
    MessageBox.Show(e.Value);
}

Dentro de los argumentos que nos entrega el evento, disponemos de la propiedad Value, que nos trae el valor del parámetro que hayamos indicado en la instrucción de JavaScript.

Los ejemplos que he puesto son muy simples, pero las posibilidades son enormes. Ahora viene lo bueno. Todo el mundo debería de saber que esto ya lo podíamos hacer con Windows Phone 7.5, hasta aquí no existe absolutamente nada nuevo que incorpore Windows Phone 8. Si es verdad que quizás esta característica del control WebBrowser no era muy conocida, pero como os comento no hay nada nuevo.

¿Cual es entonces la función real de esta plantilla? Pues sinceramente lo desconozco. Tal vez el equipo de producto quiso hacer creer que igual que en Windows 8 disponemos de un tipo de programación en JavaScript, en Windows Phone 8, también lo tendríamos. Pero no, nada de WinJS a la vista.

Bueno realmente tengo que decir que lo novedoso de todo esto es la incorporación de IE10 al sistema. Es de suponer que con esta versión del navegador vamos a poder explotar en un grado muy alto todas las capacidades que HTML5 incorpora. Podéis desde el propio emulador acceder a http://ie.microsoft.com/testdrive y ver todos los test que IE10 en su versión móvil pasa con muy buena nota.

Así mismo en la documentación del SDK de Windows Phone 8, en la sección en la que se habla de este tipo de plantilla, se nos indica que consultemos la guía para desarrolladores de Internet Explorer 10, para poder sacar todo el potencial que los desarrolladores HTML disponen en Windows Phone 8.

¿Cual es el motivo?, bueno pues seguramente que serán muchos, pero uno de ellos es que el nuevo emulador para testear nuestras aplicaciones, no es un emulador al uso tal y como lo teníamos en Windows Phone 7.5, sino que es una imagen del S.O. virtualizada a través de la tecnología Hyper-V de Microsoft y esta tecnología solo es compatible con sistemas de 64 bits como podéis ver en sus requerimientos.

Esto para mi significa una gran ventaja con respecto al emulador de anteriores versiones. Por un lado le dota de mayor estabilidad y un mayor rendimiento, por otro lado el lanzar varios emuladores al mismo tiempo se hace una tarea bastante mas sencilla que antes, la gestión de las imágenes de nuestros Windows Phone emulados ahora son gestionables y no como antes que eran un simple fichero y a veces teníamos que pegarnos con los ficheros de sesión que se quedaban colgados y demás…

Bueno, pues manos a la obra y vamos a disponernos a lanzar nuestro flamante emulador y ver in situ todo su potencial.

Vaya la primera en la frente, Visual Studio me advierte gentilmente que quizás no tenga habilitado en la BIOS el soporte para la virtualización por hardware, necesario para lanzar Hyper-V y por consiguiente el emulador.

Pero lo primero seria comprobar si nuestro sistema es capaz de ejecutar Hyper-V y si tenemos el Hardware necesario para ello. Os recuerdo que necesitamos que nuestra maquina ejecute la virtualización asistida de Hardware, SLAT (Second Level Address Translation) y DEP (Hardware-based Data Execution Prevention).

Si esto te suena a chino y no tienes ni remota idea de que estoy hablando lo mejor es descargarnos esta pequeña utilidad de Microsoft, llamada Coreinfo para comprobar todos estos requerimientos.

Simplemente tras descargarnos Coreinfo, lo ejecutamos en la línea de comandos con permisos de administrador, con el parámetro –v

C:\> Coreinfo.exe -v

Esto nos mostrara una serie de datos de capacidades de nuestro procesador.

Debemos de asegurarnos de tener un asterisco, en las 2 ultimas características, capacidad de virtualización por hardware y SLAT presente.y que nos indique que el Hypervisor está presente.

Por ultimo debemos de hacer otra comprobación, en este caso ejecutando Coreinfo sin ningún tipo de parámetro de entrada.

C:\> Coreinfo.exe

Entre todas las características que nos presenta debemos de buscar la opción NX, la cual nos dirá si disponemos de la capacidad de DEP (Hardware-base Data Executivo Prevención) o no, con un asterisco.

Una vez comprobado todo, debemos de saber que tenemos que tener un asterisco en las 3 características comentadas y ver que Hypervisor esta presente, si esto no es así ya podemos ir pensando en comprar otro ordenador o simplemente olvidarnos de probar nuestras aplicaciones en el emulador de Windows Phone 8.

Si tenemos la suerte de contar con todos estos requisitos, simplemente deberemos de ir a la BIOS de nuestro sistema y activar la virtualización por hardware que normalmente viene deshabilitada. En mi caso simplemente tengo que ir a la sección de características de la CPU dentro de mi BIOS y activarlo:

Solo una cosita mas, una vez comprobado nuestro sistema y activado en la BIOS la opción de virtualización, deberemos de añadir nuestro usuario de Windows al grupo de administradores de Hyper-V, para evitarnos posibles problemas de permisos y demás a la hora de asignar hardware al emulador.  Para ello simplemente iremos al administrador de equipos y en la sección de usuarios asignaremos el nuestro al grupo administradores de Hyper-V.

Bueno, pues listos, una vez realizados estos pasos, la próxima vez que ejecutemos la depuración en el emulador, nos mostrara el aviso de ejecución con permisos elevados, si es que no ejecutamos ya Visual Studio con permisos de administrador.

Aquí nuestro flamante emulador listo para comenzar a probar nuestras aplicaciones para Windows Phone 8.

Se lo que estas pensando, pues que los mentores me ayuden a subirlo y punto pelota. Pues no amigo no, lo tienes claro, aquí cada uno se guisa las alubias el solito, que los que os vais a ir a Redmond sois vosotros colegas….. Y además si los equipos deben de estar formados por un máximo de 4 personas, ¿como pensáis intercambiaros el código que vayáis generando?, ¿copiando y pegando carpetas?, venga hombre… Como os oiga algún MVP de estos de ALM que andan por aquí os corren a gorrazos.

Pero lo primero es lo primero, ¿que demonios es eso de Team Fundation?, Bueno pues exactamente Team Foundation Server o Team Foundation Service que es a fin de cuentas lo mismo pero en su versión en la nube y es lo que nos piden que usemos, comúnmente conocido como TFS, es un producto que ofrece herramientas colaborativas, administración y planificación de proyectos, automatización de ejecución de test, integración continua y un magnifico repositorio de código fuente.

Nosotros de momento y para ese fin de semana solamente necesitaremos controlar de una forma muy básica el gestor de código fuente. En nuestro caso, la sede de Santander hemos creado una cuenta común para todos los asistentes al Megathon de nuestra sede, con lo que una vez creados los equipos iremos dando acceso a los usuarios a los diferentes proyectos creados.

Pero bueno si queréis vosotros mismos ir creando vuestros proyectos y demás, Team Foundation Services están aun en versión Preview con lo que de momento todos sus servicios son totalmente gratuitos, simplemente abriendo su web, TFSPreview.com y creando una cuenta dispondréis al momento de todo.

De momento lo primero que debemos de hacer es agregar nuestra cuenta de Team Foundation Services recién creada a nuestro Visual Studio. Funciona tanto para las versiones Express que ya comentamos como descargarlas e instalarlas como obviamente las versiones full de pago, lo único que como es de suponer en las versiones Express las opciones de integración son mas limitadas.

Para ello, abriremos nuestro Visual Studio 2012 Express para Windows 8 y nos conectaremos con el servicio de Team Foundation Services, en el menú superior en “Equipo > Conectar a Team Foundation Server” o sacando el add-in de Team Explorer en “Ver > Team Explorer”. Usaremos esta segunda opción, ya que de esta manera tendremos a mano la pestaña de Team Explorer para realizar los siguientes procesos.

Nota: Tiene narices, que en el anterior post, os comente que mejor instalarse la versión en Ingles, pues me acabo de dar cuenta que yo me la he instalado en español, jeje, donde dije digo digo Diego…..

Una vez que tengamos la pestaña de Team Explorer deberemos de conectarnos propiamente al servidor de TFS, para ello pulsaremos sobre conectar con Team Foundation Server.

Tras esto deberemos de añadir nuestro servidor, si es que no lo tenemos ya, para ello pulsaremos sobre el botón “Servidores”

Dentro de la sección de agregar o quitar servidores, procederemos a agregar uno nuevo, pulsando Agregar.

Ahora debemos de introducir la dirección de nuestro servidor. En nuestro caso, la sede de Santander hemos creado un servidor de Team Foundation Services bajo el nombre de Nuberos (Nuberos.Net es el nombre del grupo de usuarios de .Net en Cantabria, organizador del Hackaton en Santander), por lo que nuestro servidor es “nuberos.tfspreview.com” Como podéis ver una vez introducido el dominio *.tfspreview.com el sistema detecta que es una instancia de TFS en la nube y no nos solicita mas datos de configuración.

Tras pulsar el botón de Aceptar, Visual Studio nos solicita que hagamos login con una cuenta con la cual tengamos permisos sobre algún elemento que se encuentre en ese servidor. En nuestro caso cada participante nos dirá su dirección de email, la cual debe de ser un Windows Live ID.

Bueno pues una vez creado el servidor, simplemente cerramos la pantalla de gestión de servidores.

Seleccionamos el servidor que acabamos de crear y nos aparecerán aquellos proyectos creados en dicho servidor para los cuales tengamos algún tipo de permiso de acceso. En el caso de los participantes, deberían de tener cada uno de ellos el proyecto por el cual van a trabajar, pelear y sudar…

Seleccionamos el proyecto y ya tenemos conectado nuestro Visual Studio Express a Team Foundation Services. Podemos ver que la pestaña de “Team Explorer”, ya ha cambiado y nos propone nuevas opciones.

Nota: Conectar la versión full de Visual Studio, es básicamente igual.

Bueno pues una vez conectado a TFS, lo que procederemos a hacer es a “Proteger” nuestro código fuente, vamos a lo que se llama hacer un check-in. Con ello dejaremos nuestro código en el servidor, para que este a disposición de cualquier miembro del equipo, y de esta forma también comenzar a gestionar el ciclo de vida de nuestro código fuente.

Lo primero que debemos de hacer para esto es asignar nuestra solución a ese proyecto de Team Foundation Server al que nos acabamos de conectar. Para ello con el proyecto que hayamos creado, deberemos de pulsar sobre el con el botón derecho, en el “Explorador de soluciones”, y seleccionaremos la opción “Agregar solución al control de código fuente”

Si aun no hemos creado nuestro proyecto, otra opción es a la hora de crearle, indicarle que le vamos a añadir al control de código de Team Foundation Server.

En nuestro caso, al ser el primero que vamos a añadir código al repositorio, le debemos de indicar en que carpeta lo vamos a colocar, si por ejemplo ya disponemos de una carpeta en donde nos indican que dejemos el código deberíamos de seleccionarla. Como digo en este caso crearemos dentro del repositorio una carpeta, la llamaremos “RamaPrincipal” y dentro de esa carpeta colocaremos el proyecto.

Y ya como ultimo paso, es hacer el Check-in (Proteger) de nuestro proyecto. Para ello, simplemente pulsando de nuevo sobre el proyecto en el “Explorador de soluciones”, pulsamos sobre la opción “Proteger” o “CheckIn”.

Nos aparece una pantalla en la que nos indica que ficheros son los que se van a proteger y nos muestra una serie de opciones mas, de momento simplemente le damos una descripción o comentario al proceso y pulsamos sobre el botón “Proteger”.

Con esto ya tenemos nuestro código en el repositorio central, a partir de ahora cada cambio que vayamos haciendo en el proyecto, lo que deberemos de hacer es ir realizando diferentes chekins o protecciones, según avancemos.

Una opción que teníamos disponible en nuestra pestaña de “Team Explorer” es la de “Explorador de código fuente”. Al pulsar esta opción se abre dicho explorador pudiendo ver las carpetas creadas, en nuestro caso solo una “RamaPrincipal” y lo que tenemos en cada carpeta.

Si por ejemplo otro compañero del equipo ya ha creado su proyecto y queremos descargárnoslo, lo único que debemos de hacer es pulsar sobre la carpeta “RafaPrincipal” y seleccionar el proyecto que nos queremos descargar y añadir en nuestra solución, botón derecho y seleccionar la opción “Obtener la ultima versión”.

Una vez hecho esto, ya disponemos de los últimos cambios que los demás integrantes del equipo van haciendo a sus proyectos o a los ficheros que van modificando de nuestro mismo proyecto.

Con estas nociones muy básicas como os digo podemos gestionar de una manera muy sencilla la integración de Visual Studio Express con el repositorio en la nube de TFS, Team Foundation Services.

Nota: Este mini tutorial, no pretendo que sea ni con mucho algo avanzado, mi única intención es la de que gente que jamás se a topado con TFS y el control de código pueda desenvolverse medianamente los días que dure el Hackaton. Se que algunas de las cosas que digo no son muy ortodoxas, tampoco soy ningún experto en ALM, bueno básicamente no soy experto en nada, con lo que si queréis de verdad aprender a usar TFS y saber mas de la gestión del ciclo de vida de las aplicaciones os recomiendo encarecidamente que acudáis a los blogs de monstruos como El Bruno, Luis Fraile, o compañía.

Todo en la vida es una cuestión de decisiones y este paso no iba a ser diferente al resto. Tenemos dos opciones, o instalarnos la versión completa de Visual Studio o instalarnos las versiones express mas reducidas en capacidades, pero gratis.

En este caso, voy a describir los pasos para instalarnos las herramientas de desarrollo express, ya que para los asistentes al Megathon quizás sean mas que suficientes para lo que van ha hacer, y no solo eso ya que para muchos desarrolladores que lo que quieren es trastear un poco en sus casas y de vez en cuando desarrollar una pequeña aplicación o web es mas que suficiente. Y ojo no nos olvidemos son GRATIS.

Bueno, pues manos a la obra. De momento y hasta que no llegue el 12 de Septiembre día en el que oficialmente será liberada la versión final de Visual Studio 2012, deberemos de instalarnos las versiones Release Candidate. Pero bueno funcionan razonablemente bien.

Nota: Si eres un agraciado poseedor de una subscripción MSDN, tendrás las versiones finales de Visual Studio el día 15 de Agosto.

Las versiones express como ya he comentado se caracterizan por ser versiones de Visual Studio limitadas en su funcionalidad, por lo que en este caso la versión que nos vamos a descargar solo nos permite crear aplicaciones para Windows 8 estilo Metro (ups… ) UI Style, tanto en C# como en JavaScript.

Nos dirigimos al sitio web de los productos express de Visual Studio.

A parte de poder buscar y leer mucha información sobre esta familia de productos, nos debemos de dirigir al sitio de descargar de Visual Studio 2012, que encontraremos en la parte inferior en la sección “Visual Studio Express 2012 para Windows 8” o en este enlace.

Seleccionaremos el idioma en el que queremos obtener nuestro producto e iniciamos la descarga e instalación con un instalador web o la descarga para su posterior instalación de una imagen de disco en formato ISO.

Nota: Cada uno obviamente podrá hacer lo que le venga en gana, pero mi recomendación es que os instaléis Visual Studio en la lengua de Shakespeare, usease en ingles. Por una razón muy sencilla, por suerte o por desgracia, la mayoría de información, tutoriales, libros, etc.. sobre programación y sobre .NET, salvo muy agradables y honrosas excepciones, están escritos en ingles con lo que si el IDE le tenemos en español muchas veces es complicado saber que o donde nos indican que debemos de realizar tal o cual cosa. Además que leches, así aprendéis (aprendemos) un poco de ingles…..

Una vez descargado, la instalación no tienen ninguna ciencia, siguiente, siguiente y poco mas. En algunos casos puede llegar a ser un poco tedioso y largo, todo depende del ordenador de destino, pero bueno todo se arregla con un poco de paciencia.

Tras realizar la instalación ya disponemos de nuestro flamante Visual Studio 2012 Express, presto y dispuesto para que le meamos el diente y nos pongamos a programar como locos….

Uno de los nuevos requisitos para crear una aplicación para Windows 8, es la adquisición de una licencia de desarrollo para el sistema, esta licencia es gratuita y se pueden obtener tantas como se precisen, simplemente registrándonos con nuestro correo de Windows Live ID. Se adjudican licencias por equipo, por lo que si instalamos Visual Studio en otro ordenador deberemos de obtener la licencia otra vez.

Junto con Visual Studio Express, se instalan como no podía ser de otra forma el SDK de desarrollo para Windows 8, que viene con unos cuantos ejemplos para poder ir practicando, de todas formas en la web de MSDN disponemos de una sección con un montón de aplicaciones de ejemplo y también podemos descargarnos los Virtual Labs de Windows 8 para poder ir adquiriendo conocimientos.

Otra cosa mas que se instala junto a Visual Studio Express, es la aplicación para diseñar nuestros proyectos, Microsoft Blend para Visual Studio, herramienta que quizás un día de estos daré un rápido repaso para explicar por encima su uso. Pero bueno básicamente nos ayudara a crear de una manera mucho mas sencilla el UI de nuestras aplicaciones.