Maemo App Development - One Year Ago

I just realized that one year ago, I was giving a talk about Maemo Development at the Metalab here in Vienna. Back in January 2010, things were still very much different from today:

• Scratchbox was the SDK - Linux only, VMs for everything else
• No proper IDEs for Hildon development (there was Eclipse integration, but I never used it)
• Qt still was "the new stuff that's coming up" for Maemo development
• Mer was still something to look forward to
• MeeGo didn't exist - Maemo 6 was the future ;)
• MADDE was in Technology Preview state - not widely used
• Direct UI (now MeeGo Touch) was thought to be the future toolkit
• Qt 4.6 was just released in December - no QML in Qt yet

It turns out that we are in a much better position now, we've got a nice cross-platform IDE (Qt Creator), a proper SDK (Qt SDK) that works on Windows and OS X the same as on Linux and the "low-level" issues (optification, packaging, ...) are handled by Qt Creator mostly.

Today, the issues are different - I'm complaining about Qt Creator (from the Qt SDK 1.1 Preview) crashing a lot in QML design mode, I can deploy my apps to Symbian devices without much effort (didn't think I would ever do that) - even though there's no proper toolchain for Linux or OS X (Remote Compiler doesn't count). The Qt Quick Components are still not released, even though I'd love to create some great apps with them. And most people forget in the N9 rumor jungle that we have still got the best Linux-based mobile OS (with Linux userland) that exists in an actual product that you can buy right now (that's Maemo 5 on the N900 if you didn't get that hint..). Just like Duke Nukem Forever, a MeeGo handset will be announced and released eventually - give it some time.

Back to the "Qt Creator shouldn't crash when editing QML" developer story: We're not there yet, but comparing the current state with the state one year ago, that's some progress right there! Looking forward to those bits falling into place in the upcoming months.

New tutorial: PySide/QML on MeeGo

In addition to my old PySide tutorials, there is now a proper PDF guide for PySide development on MeeGo available. Except for packaging, all steps apply to Maemo as well, and this is the document that includes the first gPodder QML UI code example (the final gPodder QML UI will be totally different and "much cooler", though).

As part of the new year's cleanup, I also dug out the old MTF UI demo of gPodder and put its source online here - for third party applications, QML is now the preferred UI over MeeGo Touch, so this might not be of much use for you now, but maybe somebody can put it to good use.

The Qt promise and what Maemo 5 needs

(tl;dr: Nokia should provide updated Qt packages as official SSU for Maemo 5.) Before I start, here are some facts (correct me if I'm wrong):

• The N900 runs the Maemo 5 operating system
• Maemo 5 received some updates (the latest one being PR1.3)
• We don't really expect PR1.4 to come out any time soon, if at all
• The MeeGo Handset images from meego.com are inferior to Maemo 5 and not a replacement (and never will be)
• The MeeGo operating system on the first Nokia MeeGo handset will have a proprietary UX and proprietary apps, and won't be available for the N900

In summary, it means: We are stuck with Maemo 5 on the N900. And that is a good thing! Lots of useful apps, a helpful community (if you subtract the trolls) and a polished OS. Sure, there's room for improvement, and lots of open bugs that should be fixed, but that's another issue (which will ideally be solved by open sourcing closed components with bugs that Nokia isn't interested in fixing anymore and by the Community SSU). This one is about Qt.

Two days ago, an e-mail was sent to maemo-community, proposing a "community service pack", which basically is a big pile of workarounds. Read my response for some initial thoughts.

When Qt arrived on Maemo 5, the promise was two-fold:

• Write your apps in Qt and you're ready for MeeGo (apps written now will run on the platform released in the future)
• Maemo 5 gets Qt support, so MeeGo apps will run on the N900 (apps written in the future will run on the platform released now)

It turns out that the first one will probably hold true (surely with QML, maybe even with QWidget), while the second one is doubtful, as Maemo 5 has only got Qt 4.7.0 through the official channels (PR1.3), with no real official update in sight. If you use QML, use QtQuickCompat as workaround ("Qt Qml plugin that reregisters all “Qt 4.7” types in the “QtQuick 1.0” namespace … useful if you’re forced to stay with 4.7.0 (e.g. on N900), but still want to use the new namespace.").

There is also a real bug (yes, a bug!) in Qt 4.7.0 on the N900, and the fix isn't released as update - it's a new package: libqt4-bearer-hotfix ("This is a hotfix for the broken ICD package in Qt 4.7.0. It can be removed once Qt mobility 1.1 is released."). Now, the proposed "Community service pack" would combine all these fixes into a single dependendable metapackage (yes, a new one). It becomes the "Unbreak my Qt" feature that every app developer has to depend on and specify in the packaging.

This is wrong! No developer targetting MeeGo who has not heard about Maemo 5 will go through all those ugly workarounds and spend a week fixing things up for Maemo 5 just so that the app works. Now imagine what would happen if the first MeeGo device also introduces such kludges once it falls out of its support life cycle. Or what if the problems on Symbian are similar, and developers have to special-case things there. Not only for Symbian^3, but also for S60v5? Fragmentation.

How to avoid fragmentation? Simple: Provide Qt as a "feature" with a quicker release cycle that can be updated every month if need be. Provide Qt updates also for operating systems that don't get updates for the OS anymore. Here's my proposal:

• Provide SSU updates for Maemo 5 for Qt (and Qt Mobility) through official channels (that's the important part here!)
• A new Qt (and Qt Mobility) release should be available on all platforms (Maemo 5, S60v5, Symbian^3, MeeGo) at the same time through official (end-user approved) channels
• Apps targetting stores and repositories (Maemo Extras, Ovi Store, MeeGo Apps/Downloads) should be able to depend on the latest Qt (and Qt Mobility) version

Without that, you'll get fragmentation similar to Android: The 1.5, 1.6, 2.1 versions are similar to Qt 4.6, Qt 4.7.0 and Qt 4.7.1 (for example). Again, you don't need to update the OS, just update the framework - through official channels!

PySide/QML tutorials online, workshop next Sunday

To get myself accustomed to PySide UI development using Qt Quick (aka QML) and to check out what works already and what does not, I've experimented with creating some common elements that I'd use in an application (i.e. a QML version of gPodder - a blingy demo already exists) and decided to share my experiences and results as tutorials.

Here are all the tutorials in their current state:

• Selectable list of Python objects in QML
• Multi-selection lists in Python with QML
• Defining and using constants from PySide in QML
• Using QtWebKit and QML with PySide
• Updating QML content from Python threads
• Utilizing Qt Quick Colibri in PySide
• Filling and reading QML UI forms from Python
• Auto-generating QObject from template in PySide
• Using QtMobility sensors and QML from PySide

Screenshots are available on Flickr:

I'd like to get some feedback on whether or not the tutorials worked for you and were helpful and what else you would like to see. You can try out all the examples on your N900 today! Just install python-pyside and python-qtmobility (for the last example) from Extras-Devel and copy the examples from the Wiki. The usual disclaimers for software in Extras-Devel apply.

In related news, there will be a PySide/QML workshop at the December meeting of the Python User Group Austria, so if you happen to be in or around Vienna on Sunday, 2010-12-12, stop by at the Metalab and meet fellow Pythonistas.

Hildon UI elements in QML

I've been playing with PySide and QML this week (more on that soon), but here's something that might be interesting to the Maemo community: Using the native Hildon look and feel of Maemo 5 in QML.

This QML demo uses the current theme graphics of Hildon and provides QML components that can be used just like their Hildon counterparts, but inside QML UIs. This is not a complete library, just a test of what could be possible in case anyone wants to step up and create and maintain a Hildon library of QML components. Here's a video:

The code for this demo is on Gitorious - you can try it out on your N900 using qmlviewer.

Maemo 5 app UIs: {The,A} big picture

Sooner or later it will be necessary to create a QML UI for gPodder if it is to integrate nicely with devices on which Qt is the "native" toolkit for third party apps. At the moment, the reusable UI elements that can be used with QML (Qt Components) have not yet been officially released (the Git repository is available on Gitorious, though), and there are no UI style guidelines for Harmattan out (yet?). I'm also not able to locate UI style guidelines for QML apps on Symbian^3, and there are only a few small sample QML apps out right now.

Let's look at what we have on Maemo 5 right now. Here's a simplified overview of the current Maemo 5 UI of gPodder:

You can also check out the full-size image (~ 3.5 MB).

The UI follows the Maemo 5 Style Guide where it makes sense and tries to come up with better solutions where the Style Guide does not have a definitive answer. I'd like to hear your opinion about the current UX of gPodder and how these concepts can be translated into a QML app that integrates nicely with "future" UIs (Harmattan, S^3). The new-style episode list that can be seen in this picture will be made available with the next release that will be out Really Soon Now™.

MeeGoConf 2010: Fun, QML, gPodder, Python

I've attended the MeeGo Conference 2010 in Dublin this week. Meeting people, playing werewolf or table tennis and discussing MeeGo Python are just some of the great things about this conference.

One of my burning questions for third-party app development ("QWidget? MeeGo Touch? QML? Which one of those?") was answered with "QML". I've played with QML before, and it's great, but right now, one has to work on a very low level (as in "design your own buttons") and without any UI style guidelines. Let's hope the Qt Components provide reusable UI parts there and that the style guidelines are published as soon as possible.

I've also got some gPodder feedback: Niels suggested subscription pausing and auto-deletion of episodes (both are already implemented and just need exposure as UI elements). Murray suggested a custom TreeModel implementation for the episode list, which I've started working on now. Mike suggested the often-requested multi-episode deletion feature, which is also something I plan for the next release.

On Wednesday, we had a Python BoF to discuss the state and future of MeeGo Python. I'm looking forward to using PySide for the QML UI of gPodder. A PySide/QML workshop is planned for the next PyUGAT meeting, so join in if you are in Vienna in early December.

Oh, and the IdeaPad that we got from Intel is great. Thanks a lot for that. Will come in handy for prototyping and testing Touch UI interfaces!

Hope to see you again in a future MeeGo event :)