Hands-on Labs de desarrollo de aplicaciones Metro

Microsoft ha agregado, como parte del Training Kit de Visual Studio 11 Developer Preview, varios Hands-on Labs para aprender a usar las características de Metro. Estos tutoriales, de aproximadamente una hora de duración, cubren una buena cantidad de novedades de Metro, algunas de las que se han descrito en este blog.

Hay en total casi 20 labs usando C#, Visual Basic, Javascript y C++, entre los que se incluyen los anteriormente comentados, ejemplos de creación de juegos con C++, diseño de interfaz con Blend, pruebas o interacción de Javascript y C#, entre otros.

Sin duda una manera muy práctica de aprender a desarrollar aplicaciones Metro.

Más información:

Proporcionar ficheros en aplicaciones Metro

En el artículo anterior se ha visto cómo se consumían ficheros desde una aplicación Metro, en este se verá cómo convertir una aplicación existente en un origen de datos para otras aplicaciones

Proporcionando ficheros

La otra cara de trabajar con ficheros permite a nuestras aplicaciones proporcionar archivos directamente de los servicios a los que estén conectados.

¿Qué aplicaciones deberían implementarlo?

En general, cualquier aplicación que trabaje con ficheros, entre las que se puede mencionar, como ejemplo:

  • Redes sociales, para obtener fotos o vídeo directamente.
  • Programas que reciban RSS de vídeo, música o imágenes.
  • Gestores de tareas que almacenen, para cada proyecto, ficheros.
  • Blocs de notas, etc…

Implementación

Para que la aplicación desarrollada que nuestra aplicación tenga esta funcionalidad, debe incluir el contrato Picker, que se agrega en la ventana Project > Add New Item… :
Una vez agregado, es necesario configurar, como se ha visto en el artículo dedicado al contrato Share, la opción Supported File Types en el fichero .appxmanifest. Esta opción permitirá limitar a qué tipo de ficheros accederán las otras aplicaciones.


Una vez hecho esto, se habrá creado una plantilla similar a la de compartir. La diferencia es que todo el manejo de ficheros y la interfaz tendrá que ir por nuestra cuenta, mientras respetemos los elementos comunes de la interfaz.

El objeto más importante para poder proporcionar ficheros es el objeto FilePickerBasket, que servirá como enlace común.al resto de las aplicaciones.

Para poder agregar ficheros al Basket se usará un código similar en el caso de que la ruta al fichero sea local:

StorageFile pickedFile = await Package.Current.InstalledLocation.GetFileAsync(@"ruta\al\fichero");
this.AddFileToBasket("Fichero local", pickedFile);

En el caso de que el fichero se encuentre en un servidor remoto, será necesario que el servicio asociado proporcione una URL para poder acceder a él, y el propio sistema se encargará de descargarlo y asociarlo a la aplicación que lo requiera.

StorageFile pickedUriFile = await StorageFile.GetFileFromUriAsync(uri, filename, StreamReference.CreateFromUri("http://ruta/al/fichero"));
this.AddFileToBasket("Fichero remoto", pickedUriFile);

La última línea cargará el siguiente código auxiliar, válido tanto para ficheros locales como remotos.

        void AddFileToBasket(string id, StorageFile file)
        {
            bool inBasket;
            switch (this.basket.AddFile(id, file))
            {
                case AddFileToBasketResult.AddedToBasket:
                case AddFileToBasketResult.AlreadyInBasket:
                    inBasket = true;
                    break;

                default:
                    inBasket = false;
                    break;
            }
            this.UpdateSelectionState(id, inBasket);
        }

Para eliminar un fichero del Basket el código sería este, válido tanto para un fichero local como para un fichero remoto:

id = "Nombre del fichero";
if (this.basket.ContainsFile(id))
{
    this.basket.RemoveFile(id);
}

Conclusiones

Las nuevas maneras de consumir y proporcionar ficheros de las aplicaciones Metro permite, al igual que como se veía en los artículos dedicados a las opciones de compartir, llegar a un nuevo nivel de interacción entre diferentes aplicaciones y con el propio sistema.

Serán los propios usuarios, quienes descubran nuevas maneras de combinar las aplicaciones existentes usando estos nuevos servicios, creando una nueva experiencia en el uso de sus ordenadores personales.

Más información

Consumir ficheros en aplicaciones Metro

En artículos anteriores se ha visto cómo compartir contenido desde nuestras aplicaciones así como consumir contenido de otras. En este artículo y en el siguiente se hablará de cómo consumir ficheros del sistema de archivos, y como proporcionar opciones para que otras aplicaciones puedan hacerlo usando el contrato File Picker.

Consumiendo ficheros

Para poder consumir ficheros solamente es necesario cargar un menú, de la misma manera que lo haríamos con una aplicación Windows Forms.

Lo primero necesario es una referencia a Windows.Storage.Pickers así como a Windows.Storage

Tras agregar la referencia, el siguiente paso es cargar el filePicker, para ello, se puede asignar a un botón, enlazandolo con el evento Click, o también se podría cargar automáticamente (por ejemplo, si estuviese vacía una base de datos, para una importación inicial). Estos métodos, como se ha visto en otros artículos relacionados con Metro, deberán ser asíncronos.

Finalmente se podrán establecer filtros para seleccionar una extensión concreta, la manera de mostrar el menú de selección, o si lo que se carga es una selección simple o una múltiple.

De esta manera para seleccionar un único fichero txt situado en la biblioteca Documents, y que se muestre como una lista de ficheros, el código a usar será este:

async void Button_Click(object sender, RoutedEventArgs e)
{
    FileOpenPicker openPicker = new FileOpenPicker();
    openPicker.ViewMode = PickerViewMode.List;
    openPicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
    openPicker.FileTypeFilter.Add(".txt");
    StorageFile file = await openPicker.PickSingleFileAsync();
}

Como alternativas a este código, si el objetivo es cargar múltiples ficheros, se ha de cambiar la última llamada del código por pickMultipleFilesAsync(). En caso de que el contenido sean imágenes, lo más recomendable sería cambiar la cuarta línea del código para que se mostraran como miniaturas, para lo que se usaría PickerViewMode.Thumbnail.

En el próximo artículo se mostrará cómo se pueden proporcionar ficheros a otras aplicaciones y al sistema como si de otro origen de datos se tratara.

Más información

Evento Aplicaciones Metro para Windows 8: Materiales

Hoy he tenido la oportunidad de compartir con un grupo de estudiantes de 1º de grado de Ingeniería Informática en la Universidad Pontificia de Salamanca en Madrid (UPSAM), algunas ideas sobre el desarrollo de aplicaciones Metro con las nuevas características de Windows 8.

Durante una hora aproximadamente, hemos visto contenidos que van desde la pantalla de Login, las Charms, las notificaciones hasta las interfaces adaptables, también desde el punto de vista de desarrollador hemos visto una solución funcional que usa estos componentes.

La presentación integra está disponible en SlideShare, y dejo además un par de enlaces para descarga de las herramientas y otros artículos relacionados.

Gracias a Rubén Gonzalez (Profesor de la UPSAM) y a Fernando Gomez (Presidente del DotNetClub de la universidad) por la oportunidad.

Enlaces:

Ant y NAnt, gestión inteligente de código fuente

Apache Ant, es originalmente a java lo que la herramienta Makefile a gcc, permite automatizar la compilación, pruebas, documentación, distribución y puesta en funcionamiento de nuestras aplicaciones.

NAnt es una implementación del sistema para la plataforma .net, así que gran parte de lo contado aquí es válido para ambas plataformas.

Introducción

Ant está basado en tareas, y se diferencia de comandos de shell y ficheros make en que la sintaxis está basada en XML en vez de comandos. Esto permite que sea independiente del sistema operativo en el que se implementa.

Respecto a la compatibilidad, los editores actuales de Java (NetBeans y Eclipse) lo soportan soportan nativamente, de hecho concretamente en Netbeans la compilación se hace a través de un fichero Ant que se genera automáticamente.

Ejemplo de uso

El siguiente ejemplo muestra un fichero estándar de Ant, contiene información del proyecto, y las diferentes tareas llamadas target que tienen el atributo correspondiente al nombre, y las diferentes acciones a realizar.

<project name="MyProject" default="dist" basedir=".">
    <description>
        simple example build file
    </description>
  <!-- set global properties for this build -->
  <property name="src" location="src"/>
  <property name="build" location="build"/>
  <property name="dist"  location="dist"/>

  <target name="init">
    <!-- Create the time stamp -->
    <tstamp/>
    <!-- Create the build directory structure used by compile -->
    <mkdir dir="${build}"/>
  </target>

  <target name="compile" depends="init"
        description="compile the source " >
    <!-- Compile the java code from ${src} into ${build} -->
    <javac srcdir="${src}" destdir="${build}"/>
  </target>

  <target name="dist" depends="compile"
        description="generate the distribution" >
    <!-- Create the distribution directory -->
    <mkdir dir="${dist}/lib"/>

    <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
    <jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
  </target>

  <target name="clean"
        description="clean up" >
    <!-- Delete the ${build} and ${dist} directory trees -->
    <delete dir="${build}"/>
    <delete dir="${dist}"/>
  </target>
</project>

Las acciones que se muestran en este ejemplo son:

  • Creación / borrado de directorios.
  • Compilación.
  • Distribución y empaquetado.
Estas acciones serán válidas para cualquier proyecto de principiantes, aunque se pueden hacer muchas más:
  • Copia a un servidor remoto vía FTP.
  • Copia de ficheros
  • Compresión en zip.
  • Pruebas.
  • Generación de documentación (Existe un plugin para ejecutar Doxygen).

Además, debido a que está integrado con los entornos de desarrollo, se pueden ejecutar tareas en momentos clave, como antes de la compilación, justo después, justo antes del empaquetado, etc.

Un escenario posible podría ser el de la entrega de una versión de un producto, donde con un único script podríamos compilar, pasar las pruebas unitarias, de integración y de aceptación, generar la documentación, ofuscar el código, empaquetarlo, generar un ejecutable, enviarlo vía FTP y recibiendo un e-mail con los resultados.

Conclusiones:

Una de las cosas que es deseable tener en un proyecto de desarrollo, es este script mágico que nos da un entregable del producto en un paso. Ant permite llevar a cabo esta tarea, ahorrarnos complicaciones y mejorar nuestra productividad.

Más información:

http://ant.apache.org/manual/index.html

Documentando código fuente con Doxygen

La documentación de las funciones y clases al programar puede ser una tarea tediosa o incluso aburrida, pero es algo realmente útil por varias razones, obliga a revisar qué hace cada función exactamente, sienta bases para que futuros desarrolladores (o uno mismo en años siguientes) pueda averiguar qué hacía el código.

Doxygen es una herramienta de generación de documentación a partir del código fuente, es decir, no crea la documentación por nosotros, pero es un paso. Es compatible con Java, C++, C# entre otros.

Características:

  • Multiplataforma (Windows / Mac / Linux)
  • Compatible con C++, Java, C#, PHP, Objective-C, VHDL… entre otros
  • Genera diagramas de herencia de manera automática
  • Exporta a HTML, CHM, RTF, LaTeX, PDF (Vía LaTeX), XML, o incluso páginas de man

Instalación y Uso

Existen varias maneras de usar la herramienta, siendo la más cómoda el asistente visual que incorpora. Usando un simple sistema de menús se pueden configurar las opciones básicas que son:

  • Project: En este apartado se selecciona el nombre del proyecto, una breve descripción, la versión, el logo, la carpeta donde debe buscar el código y la carpeta donde debe guardar la documentación.
  • Mode: En este apartado  se selecciona el lenguaje de programación en el que está el código, y se selecciona si se quieren mostrar todas las entidades o solo aquellas documentadas, de tal manera que podemos evitar tener valores vacíos solo con el nombre, como pasa en javadoc. Además se puede referenciar directamente al código fuente, para que conecte cada función con la línea de código correspondiente.
  • Output: En este apartado se puede seleccionar el formato de salida, y las diferentes opciones de generación, siendo los dos apartados mayores HTML y LaTeX, y además pudiendo generar el resto de los formatos vistos anteriormente.
  • Diagrams: En este apartado se permite personalizar la manera de generar los gráficos y diagramas.

Una vez configuradas dichas opciones, en la pestaña Run se hace click en “Run doxygen” donde, en función de las opciones configuradas se generarán una o varias salidas.

Sintaxis

La transición a partir código comentado para herramientas como Javadoc es automática ya que reconoce los comandos habituales. Si es la primera vez que usa un sistema de generación de documentación puede usar otras notaciones como la de este ejemplo (Escrito en C pero aplicable a otros lenguajes):

/**
 *  A test class. A more elaborate class description.
 */

class Test
{
  public:

    /**
     * An enum.
     * More detailed enum description.
     */

    enum TEnum {
          TVal1, /**&lt; enum value TVal1. */
          TVal2, /**&lt; enum value TVal2. */
          TVal3  /**&lt; enum value TVal3. */
         }
       *enumPtr, /**&lt; enum pointer. Details. */
       enumVar;  /**&lt; enum variable. Details. */

      /**
       * A constructor.
       * A more elaborate description of the constructor.
       */
      Test();

      /**
       * A destructor.
       * A more elaborate description of the destructor.
       */
     ~Test();

      /**
       * a normal member taking two arguments and returning an integer value.
       * @param a an integer argument.
       * @param s a constant character pointer.
       * @see Test()
       * @see ~Test()
       * @see testMeToo()
       * @see publicVar()
       * @return The test results
       */
       int testMe(int a,const char *s);

      /**
       * A pure virtual member.
       * @see testMe()
       * @param c1 the first argument.
       * @param c2 the second argument.
       */
       virtual void testMeToo(char c1,char c2) = 0;

      /**
       * a public variable.
       * Details.
       */
       int publicVar;

      /**
       * a function variable.
       * Details.
       */
       int (*handler)(int a,int b);
};

La salida correspondiente a este código, una vez procesado por Doxygen en formato html se muestra aquí.

Extras

Además de la documentación que generemos a partir de las cabeceras de nuestras funciones, se puede agregar documentación adicional (casos de uso, ejemplos, o imágenes externas), lo que nos permitirá generar, usando solamente nuestro código fuente y los comentarios, una documentación completa que estará siempre actualizada.

Dentro de esta personalización, se puede modificar la página principal, que será la primera referencia a la API del proyecto, usando la siguiente plantilla (Que deberá ser incluida en cualquier fichero de código fuente):

/*! \mainpage My Personal Index Page
 *
 * \section intro_sec Introduction
 *
 * This is the introduction.
 *
 * \section install_sec Installation
 *
 * \subsection step1 Step 1: Opening the box
 *
 * etc...
 */

Cada página adicional se puede generar usando el atributo \page seguido por el nombre de la página y el título de ésta, y enlazarla usando el atributo \link, lo que permite tener una documentación completa más allá de los comentarios de las funciones

Conclusiones

Desde que leí el libro “The pragmatic Programmer” estaba buscando un sistema que me permitiera automatizar la generación de documentación, y Doxygen es un buen candidato, el formato final tiene una sorprendente calidad, además de ser 100% personalizable, incluso puede integrarse con herramientas como Ant (o el equivalente en .net NAnt) para conseguir una generación automática de una versión siempre actualizada de la documentación.

Más información

DEP Dennis Ritchie

El creador del lenguaje de programación C, y co-creador del sistema operativo UNIX, ha fallecido.

Sus aportaciones al campo de la ingeniería informática, concretamente el desarrollo de UNIX le otorgaron, entre otros galardones, el premio Turing en 1983 y la Medalla Nacional de Tecnología de los EEUU en 1999.

Tanto C como UNIX han constituido la base de otros lenguajes de programación derivados, así como el resto de sistemas operativos del entorno *nix, como Linux.

 

Entre los estudiantes de informática, es muy conocido por el libro “El lenguaje de programación C”, escrito junto con Brian Kernigan, y que representa la referencia básica de este lenguaje de programación.

Ha fallecido el pasado domingo, con la edad de 70 años. Se nos va otra mente brillante. Descanse en paz.