Han pasado ya un par de días desde el anuncio de la muerte de MeeGo (o al menos ese es el deseo de Intel y Samsung) y el nacimiento de Tizen, y digo muerte de MeeGo, porque a pesar de que Intel, la Linux Foundation y los socios de LiMo tratan de vender este anuncio como la fusión de dos proyectos en los que se usara lo mejor de ellos, lo cual a mi entender no es mas que un puñado de expresiones dichas pour la galerie para atajarse de la mala acogida que pensaban podía tener y que efectivamente ha tenido la noticia en la comunidad.

Desde el momento del anuncio hasta ahora, hay mas dudas que certezas acerca de este nuevo proyecto, lo único oficial que sabemos es que para el primer trimestre de 2012 estará disponible la primera release del SDK, que las aplicaciones serán desarrolladas usando HTML5, que va ser compatible con WAC y que sera posible crear aplicaciones nativas, aunque no se han dado muchos detalles acerca de esto ultimo.

¿Donde quedo Qt?

Cuando leía por primera vez el anuncio, veía las palabras, HTML5, APIs, transición, comunidad, pero en ningún lugar se hacia mención a Qt, desde el momento en que fue publicado este comunicado hasta ahora, lo único que quiere saber la comunidad, es que carajo va a pasar con Qt, y la respuesta del otro lados ha sido nula, lo que hace pensar que el soporte sera también nulo.

La comunidad MeeGo y Maemo esta muy decepcionada por la decisión de dejar de lado a Qt, haciendo primar el aspecto político antes que el técnico, esto no hace mas que demostrar que tanto Intel, Samsung y resto de los miembros que conforman Limo, no entienden como funciona el Open Source, y que la Linux Foundation no es mas que un sello de goma, que no tiene ni voz ni voto en las decisiones importantes, el hecho de que Qt este moviéndose a un modelo de Open Governance no sirvió para quitarse el olor a Nokia que tiene, y Samsung que quiere liderar el proyecto Tizen, le bajo el pulgar a Qt, aprovechando la situación de desesperación por la que esta pasando Intel en su búsqueda de un socio que use sus eternamente prometidos, pero nunca presentados, chips de bajo consumo en dispositivos móviles.

La decisión de dejar de soportar Qt, no solo genero el pataleo entre los seguidores de MeeGo y los aficionados al Open Source, sino que también esta afectando a muchas empresas que habían apostado por MeeGo, como plataforma y a Qt como entorno de desarrollo, donde mas patente queda esto, es en la versión IVI de MeeGo, donde la gente del consorcio GENIVI apoyo fuertemente su desarrollo y ahora ha quedado en el limbo, o empresas como Asus que hace poco comenzó a vender netbooks con MeeGo preinstalado o como Metasys, que actualmente esta distribuyendo netbooks con MeeGo en escuelas de Brasil.

¿HTML5 versus Qt?

HTML5 versus Qt no es el punto, el punto es porque solo HTML5 como entorno de desarrollo, eso es lo que la comunidad que creció alrededor de MeeGo reclama, y si Tizen no puede proveer una manera amigable de integrar Qt en el stack de desarrollo, alguien mas lo va a hacer, es lo bueno del Open Source.

La continuidad de MeeGo

Según el roadmap, en Octubre de 2011 debería ser liberada las versión 1.3 de MeeGo, todo indica que a pesar del cambio de planes, el lanzamiento sera hará efectivo, la pregunta es, ¿podrá seguir MeeGo su desarrollo independientemente de Intel?, ¿la Linux Foundation permitirá que un tercero o la comunidad sigan usando la marca MeeGo?, y es que aunque parezca una opción remota, es posible que alguien quiera tomar la posta y ayude a continuar con el desarrollo de algunas de las múltiples personalidades de MeeGo, por ahora no hay novedades al respecto, veremos si en los próximos días esto cambia.

Meltemi y la invasión de los Qt Phones

Ayer el WSJ tiro como “primicia” que Nokia estaría trabajando en un nuevo OS, basado en Linux para teléfonos de bajo coste, el OS cuyo nombre código es Meltemi y del cual se viene filtrando información desde principios de año vendría a formar parte de una nueva línea de dispositivos que reemplazaría a los S40 actuales, esto unido a los últimos lanzamientos de móviles S40 con procesadores de 1Gz, hacen que la idea de llevar Qt al Next Billion no suene tan descabellada y permitiría a Nokia competir contra los cada vez mas baratos, móviles básicos equipados con Android provenientes de China.

Si ven las ultimas entrevistas dadas por Marko Ahtisaari y otros ejecutivos de Nokia, en ellas tratan de dejar bien en claro que debemos ver al Nokia N9, no como un móvil con MeeGo, sino como el primero de muchos Qt Phones que están por venir, y que muchas de las innovaciones y conceptos presentados con el N9, serán aplicados en próximos productos,  esto es algo que suena prometedor e interesante, pero que también hace que uno se pregunte ¿se puede seguir confiando en Nokia luego de Febrero 11?, la respuesta es un ni (ni un No, ni un Si), aun hay bronca y algo de frustración por el acuerdo con Microsoft, pero también es justo decir que desde ese día, Nokia a venido cumpliendo con todo lo que dijo iba a hacer, Symbian Anna (con algo de retraso) esta distribuyéndose, Symbian Belle esta a la vuelta de la esquina y los cambios hechos en el han sido profundos y muy bien recibidos, por el lado de Qt, el trabajo sigue a paso firme y moviéndose a un modelo de Open Governance para transparentar aun mas el proceso.

Afortunadamente en unos días mas, entre el 24 y 27 de Octubre se van a estar realizando los Qt Developer Day 2011 y la Nokia World,  eventos en los cuales se hablara sobre el futuro de Qt, Harmattan y si hay suerte quizás veamos algún avance de Meltemi.

La espera continua

En este punto de los acontecimientos, hay mas dudas que certezas, es difícil confiar en la palabra de empresas que piden apoyo por parte de los developers, pero que piensan a muy corto plazo, si no basta ver el ejemplo de HP, que mato a WebOS luego de pocos meses en el mercado y se llevo puesto el trabajo de miles de developers que creyeron en la promesas de HP, empresas que a diferencia de la era PC en donde la compatibilidad y la interoperabilidad era lo mas importante, se centran en crear cárceles para el usuario, cárceles que ellos llaman ecosistemas.

El sueño de muchos, de un OS para móviles, verdaderamente Open Source y que pueda ser instalado en una multitud de dispositivos de diferentes fabricantes se vuelve cada vez mas lejano, mientras tanto vamos a tener que seguir aguardando, usando opciones a medio camino como Android, Harmattan o Meltemi y apoyando, con sus pros y contras a proyectos como Tizen.

Y llego el día, Nokia anuncio por fin el N9, su primer dispositivo MeeGo compatible(*) enfocado al publico en general, quiero aprovechar este post, no para hacer una review del evento de presentación, ni para hablar de las features del mismo, sino para aclarar algunos aspectos sobre la personalidad del OS y sobre los recursos y herramientas que ya tenemos disponibles para comenzar a desarrollar.

Harmattan?, que es eso?

MeeGo 1.2 Harmattan es la implementación MeeGo de Nokia, es altamente compatible a nivel de APIs y arquitectura, lo que permitirá fácilmente tomar los cambios que se hagan en el upstream de MeeGo he incorporarlos cuando se vayan liberando, Harmattan trae integrado, Qt 4.7.?, Qt Quick Components 1.0, Qt Mobility 1.2.0, Qt Webkit 2.1.1, PulseAudio y GStreamer para crear aplicaciones y plugins que hagan uso de audio y video, Telepathy-Qt4 para aplicaciones que usen vídeo llamadas y mensajería instantánea y por ultimo la Qt Games API para el desarrollo de juegos basados en OpenGL ES 2.0.

N9 & N950

Como dije al principio, el N9 es el primer dispositivo MeeGo de Nokia para el publico en general, en cambio para los desarrolladores se encuentra disponible el N950, el mismo no puede ser comprado directamente, sino que Nokia se encargara de entregarlos usando un criterio que aun no se ha hecho publico, pero que seguramente incluirá a los Forum Nokia Champions, los miembros del programa Launchpad y a contribuyentes destacados de las comunidades MeeGo, Maemo y Qt.

Developer and Design Tools

Apenas terminada la presentación del Nokia N9, fueron liberadas las herramienta necesarias para comenzar a diseñar y desarrollar aplicaciones para el mismo.

Qt SDK 1.1.2 Update for Meego 1.2 Harmattan

Este update incorpora una actualización menor de Qt Creator y el toolchain para crear aplicaciones compatibles con Meego 1.2 Harmattan, el toolchain aun esta en fase experimental y no están completas aun muchas de sus herramientas y características..

Pueden instalar el SDK haciendo una instalación limpia del mismo usando algunos de los siguientes instaladores:

O si ya tienen instalado Qt SDK, pueden actualizarlo utilizando la herramienta SDKMaintenanceTool y seleccionado Harmattan en la sección Experimental

Harmattan UX Guidelines

Se ha habilitado toda una nueva sección en Nokia Developer para hacer lugar a la nuevas Nokia N9 UX Guidelines, la documentación es realmente muy completa, visual e interactiva, tratando de guiarnos en el nuevo paradigma que acompaña la UI del N9, ademas de la documentación en linea, es posible bajar, las guidelines y templates para el diseño de iconos, como así también un toolkit con los graficos de los distintos componentes que forman parte de la UI para ser usados en el prototipado de aplicaciones.

Creo que con estos recursos y estas herramientas tenemos como para entretenernos un buen rato, conociendo y explorando las posibilidades que MeeGo nos puede proveer y como aplicarlas a futuros proyectos.

Hace un tiempo escribí sobre lo fácil que es consumir XML con QML, hoy le toca el turno a JSON, consumir JSON con QML requiere un poco mas de trabajo comparado con XML, pero no mucho mas.

Pasemos al código, lo primero que haremos sera crear un archivo data.js que contendrá la lógica que poblara al Model con los datos, para este ejemplo vamos a usar el API de Wikileaks para mostrar un listado con los últimos cables liberados, lo siguiente es agregar el ListModel, el Delegate cuyo código esta al final y no necesita muchos comentarios, el ListView que mostrara los datos y vamos a disparar la función getLatestCables() cuando la view se haya cargado.

main.qml

import QtQuick 1.0
import "data.js" as Data

Rectangle {
    width:360
    height:640

    Component.onCompleted:Data.getLatestCables();

    ListModel {
        id:cablesModel
    }

    CablesDelegate {
        id:cablesDelegate
    }

    Item {
        id:cablesList
        anchors.fill:parent

        ListView {
            model:cablesModel
            delegate:cablesDelegate
            anchors.fill:parent
        }
    }
}

La magia que no es mucha, pasa aquí, esto es simple y puro JavaScript, utilizaremos un XMLHttpRequest para acceder al feed con los datos, luego lo parseamos e iremos agregando uno a uno los datos al Model.

data.js

function getLatestCables(){
    var xhr = new XMLHttpRequest;
    xhr.open("GET", "http://api.leakfeed.com/v1/cables/latest.json");
    xhr.onreadystatechange = function() {
        if (xhr.readyState == XMLHttpRequest.DONE) {
            var a = JSON.parse(xhr.responseText);
            for (var c in a) {
                var i = a[c];
                cablesModel.append({identifier: i.identifier, classification: i.classification, office: i.office, subject: i.subject});
            }
        }
    }
    xhr.send();
}

CablesDelegate.qml

import QtQuick 1.0

Component {

    Rectangle {
        border.color:"#b7b7b7"
        border.width:1
        width:parent.width
        height:cableIdentifier.height + cableOffice.height + cableClass.height + cableSubject.height + 10
        color:"#fff"

        Item {
            width:parent.width
            height:parent.height

            Grid {
                rows:4
                width:parent.width
                anchors.verticalCenter:parent.verticalCenter
                anchors.left:parent.left
                anchors.leftMargin:5
                anchors.right:parent.right
                anchors.rightMargin:5

                Text {
                    id:cableIdentifier
                    text:identifier
                    font.bold:true
                    font.pixelSize:18
                    smooth:true
                    color:"#333"
                }

                Text {
                    id:cableOffice
                    color:"#0076A3"
                    text:office
                    font.pixelSize:18
                    font.bold:true
                    smooth:true
                }

                Text {
                    id:cableClass
                    color:"#aa1317"
                    text:classification
                    font.pixelSize:16
                    font.bold:true
                    smooth:true
                }

                Text {
                    id:cableSubject
                    text:subject
                    font.pixelSize: 14
                    wrapMode:Text.WrapAtWordBoundaryOrAnywhere
                    width:parent.width
                    smooth:true
                    color:"#333"
                }
            }
        }
    }
}

Si todo sale bien, al correr la demo deberíamos obtener como resultado algo parecido a los que se ve en la siguiente imagen.

Qt/3D es un conjunto de herramientas y funciones que permiten crear aplicaciones que hagan uso de gráficos 3D, Qt3D extiende las clases del modulo OpenGL de Qt, estas APIs facilitan escribir código que sea fácil de portar entre aplicaciones de escritorio OpenGL y aplicaciones embebidas o mobile OpenGL/ES, por ultimo pero no menos importante, contamos con un binding para utilizar Qt/3D desde QML.

Para comenzar con Qt/3D lo primero que debemos hacer es instalarlo, los pasos a seguir están muy bien explicados aquí, ya sea en Linux, Windows o Mac OS X, no son complicados, aunque puede tomar algo de tiempo el proceso.

¿Que podemos hacer con Qt/3D y QML?

Con Qt/3D podemos crear viewports, asignar luces y cámaras, crear o importar nuestros propios modelos 3D, ya sea usando las figuras básicas incluidas, creando nuestros propios meshes, o usando algún modelo ya existente en formato 3ds o bzs, también podemos crear animaciones y aplicárselas a los modelos, las cámaras y las luces.

Si han trabajado anteriormente con aplicaciones 3D todos estos términos y conceptos les sonaran familiares, lo que les permitirá reutilizar su conocimiento a la vez de que podrán rápidamente ponerse manos a la obra.

Hello World 3D

El siguiente ejemplo muestra de forma simple, algunos de los conceptos y controles que se usan en la mayoría de la aplicaciones 3D, lo primero es crear los imports correspondientes de Qt/3D, luego sigue el Viewport que define la escena 3D, así como su tamaño, las luces y las cámaras a utilizar y sus posiciones.

Luego tenemos un objeto Sphere que tiene un levelOfDetail de 10 el máximo de su tipo y que mide la cantidad de triángulos necesarios para crear el objeto, en este caso 32768, luego alineamos el objeto al eje Y, para terminar aplicándole una textura usando el elemento Effect.

Para finalizar vamos a animar el objeto 3D, para ello usaremos una Rotation3D, a la cual seteamos el eje que queremos animar y luego en una NumberAnimation establecemos la propiedad a animar, en este caso, angle.

import Qt 4.7
import Qt3D 1.0
import Qt3D.Shapes 1.0

Viewport {
    width: 640
    height: 360
    camera: Camera {
        eye: Qt.vector3d(0,0,8)
    }
    Sphere {
        levelOfDetail: 10
        axis: Qt.YAxis
        effect: Effect {
            texture: "images/land_ocean_ice_2048.jpg"
            decal: true
        }
        transform:[
            Rotation3D {
                axis: Qt.vector3d(0,1,0)
                NumberAnimation on angle {
                    running: true
                    loops: Animation.Infinite
                    from: 360
                    to: 0
                    duration: 6000
                }
            }
        ]
    }
}

Con este simple ejemplo pueden darse una idea del poder que nos brinda la combinación Qt/3D y QML, si están interesados en el tema, pueden profundizar mas en el dando un vistazo a la documentación oficial, o ver un repaso rápido de las principales características en la presentación dada por Sarah Smith en los Qt Developers Days 2010.

Últimamente hay mucho revuelo y movimiento relacionado a lo que es mobile, pero de todo ese ruido muy pocas cosas son realmente originales o proponen un cambio de paradigma, una de esas excepciones es la nueva UI de Windows Phone 7 y aunque posiblemente nunca compre, use o desarrolle para WP7 hay un par de conceptos interesantes que me gustaría tomar prestados, como por ejemplo los controles Panorama (ver imagen abajo) y Pivot para poder usarlos en mis aplicaciones QML.

Vamos a comenzar con el control Panorama, implementarlo no es para nada complicado, como verán hay algunas propiedades para configurar el look and feel, el contenido o el elemento que hará de contenedor de los PanoramaItems, también tenemos un control Flickable que utilizaremos para mover horizontalmente los PanoramaItems hijos y para finalizar tenemos un elemento Text que usaremos para mostrar el titulo del control Panorama y una Grid en donde se irán acomodando los PanoramaItems.

Panorama.qml

import Qt 4.7

Rectangle {
    id: container
    width:parent.width
    height:parent.height
    default property alias content: content.children
    property string title: "panorama"
    property int titleSize:48
    property string titleFont: ""
    property color titleColor:"#fff"
    property color background:"#333"
    property string backgroundImage:""
    property string backgroundFillMode:"Tile"

    color: container.background

    Flickable {
        width:parent.width
        height:parent.height
        contentWidth: content.width;
        contentHeight: container.height
        boundsBehavior: "StopAtBounds"
        Image{
            source: container.backgroundImage
            fillMode: container.backgroundFillMode
            Grid{
                width: content.width
                height: content.height
                rows:2
                Text {
                    id: title
                    text: container.title
                    font.pointSize: container.titleSize
                    font.family: container.titleFont
                    color: container.titleColor
                }
                Grid {
                    id: content
                    spacing:10
                }
            }
        }
    }
}

El control PanoramaItem es aun mas sencillo como se ve en el código a continuación.

PanoramaItem.qml

import Qt 4.7

Item {
    id: container
    default property alias content: content.children
    property string title: "panoramaItem"
    property int titleSize: 21
    property color titleColor: "#fff"

    height: wrapper.height

    Grid{
        id: wrapper
        rows:2
        Text {
            id: title
            width: container.width
            text: container.title
            smooth: true
            wrapMode: "Wrap"
            font.pointSize: container.titleSize
            color: container.titleColor
        }
        Rectangle {
            id: content
            width: container.width
            height: container.height - title.height            
        }
    }
}

Bien, ahora que ya tenemos nuestros controles, es momento de usarlos, para ello solo debemos crear un control Panorama, establecer el titulo, el tipo y tamaño del font, una imagen de fondo si es que vamos a usar una, para luego agregar los PanoramaItems que deseemos con su respectivos contenidos.

PanoramaDemo.qml

import Qt 4.7

Rectangle {
    id: screen
    width: 360
    height: 640

    Panorama{
        id:myPanorama
        title: "my Panorama"
        backgroundImage:"images/bg.jpg"
        PanoramaItem{
            width: screen.width -30
            title:"first item"
            titleSize: 21
            
            // Content here
            
        }
        PanoramaItem{
            width: screen.width
            title:"second Item"
            titleSize: 21
            
            // Content here
            
        }
        PanoramaItem{
            width: screen.width
            title:"third Item"
            titleSize: 21
            
            // Content here
  
        }
    }    
}

En la imagen a continuación pueden ver el resultado de el ejemplo y en el vídeo su funcionamiento.

Como verán duplicar el comportamiento básico de estos controles no fue para nada difícil, aunque esto es solo un simple ejemplo, con muchas cosas aun por pulir y funcionalidades por implementar para lograr una emulación completa de las funcionalidades de los controles originales, aun sirve para demostrar la capacidades de QML y como con poco código se pueden lograr resultados interesantes.