|Getting Started with MeeGo|
The MeeGo project is about to celebrate its first birthday, but there may still be Linux and open source developers who aren't quite sure how it relates to other Linux-based distributions for tablets, netbooks, or phones — like Android, Chrome OS, or the netbook remixes of popular desktop distros. MeeGo takes a different approach, aiming to be a vendor-neutral Linux platform for a variety of devices. If you're a developer, that is a key distinction, because it means it is easier to get started writing or porting apps to MeeGo, even digging in to the platform itself.
The Bird's-Eye View
At its essence, MeeGo is a collaboratively-developed Linux OS designed for use on non-PC consumer computing devices. That means MeeGo is not intended to run on typical desktop systems or servers, which are already well-served by existing distros. But it is meant to replace the roll-your-own approach taken by most consumer electronics OEMs that want to build a product around Linux.
Moreover, the project aims to deliver a standardized Linux platform that OEMs can build real products around, but to keep that platform as close as possible to the upstream projects and "standard" Linux distributions. That simplifies the work for the product-maker, prevents fragmentation, and makes life easier for app developers as well.
The actual project was formed by merging two other Linux-for-devices projects that shared much of the same philosophy: Intel's Moblin (which targeted netbooks), and Nokia's Maemo (which targeted handheld devices like phones). Both used an "upstream first" development model, and they shared most of the same libraries and system software, so they joined forces. As a result, most of the lower-level components in a MeeGo system are the same regardless of whether it's a netbook, handset, or a set-top-box: the kernel, X11, PulseAudio, BlueZ, Qt, Tracker, GStreamer, Telepathy, etc. The distinctly different use-cases are referred to as "user experiences" (UXes), and there active sub-projects for a handful of UXes: Netbooks, Handsets, Connected TVs, and In-Vehicle systems for cars.
Officially, the nonprofit Linux Foundation shepherds the project: it sets up working groups for each UX, hosts the infrastructure, sets the broad release schedules, and coordinates the community issues. But the actual coding on the MeeGo Core OS and the various UXes is done by volunteers and by developers who work for companies interested in making MeeGo-based products. Initially, a lot of the full-time MeeGo developers were from Intel's Moblin and Nokia's Maemo teams, but subsequently a large number of other companies (chip-makers, system builders, and software shops) have joined in as well.
The MeeGo project makes releases at approximately six-month intervals. Each release includes core OS components, and may include installable builds for several of the UXes, although which depends on the individual UX projects. For instance, the 1.0 release in May of 2010 included just the Netbook UX, while the 1.1 release that followed in October included stable releases for Netbook and Handset UXes.
Although the UX releases are installable, it is important to separate these releases from what an actual MeeGo-based product's interface might look like. Each UX includes a "base implementation" of the user interface and core applications, usually sporting the familiar MeeGo branding and look-and-feel, but vendors like Nokia will generally customize the interface on their MeeGo-based products, possibly even adding or replacing applications.
The real importance to an official MeeGo release is compliance guarantee that accompanies the base OS. The project has a compliance program to test and verify that both hardware devices and software applications work with any given MeeGo release; that way app developers can be insured, for example, that their code will run equally well on a MeeGo-1.1-powered netbook regardless of whether it has an Intel or an AMD processor inside. The compliance specifications are hosted on the MeeGo wiki, as are further details on the process and the compliance tools used to check applications.
If you want to see MeeGo in action, the best place to start is with one of the installable images. MeeGo 1.1 builds are available for Atom-based netbooks, which is probably the simplest option for most developers, as well as Nokia N900 phone handsets and Atom-based in-vehicle-infotainment (IVI) devices. The downloads page on MeeGo.com holds links to the latest releases for each UX, plus the instructions for installing the releases on different hardware devices.
The process varies slightly from device to device, and as the project has grown more architectures are supported with each release — so be sure you read the instructions specific to your hardware. For example, although the Nokia N900 was the only supported Handset UX device when the 1.0 release was made, 1.1 includes builds for handsets using Intel's Aava platform as well. Most Atom-based netbooks are supported by the Netbook UX release, and users without access to an Atom-based IVI system can also install the IVI UX on an Atom-powered netbook.
Actual MeeGo development is done largely via upstream projects like the kernel, but you can browse through MeeGo-specific projects hosted at Gitorious.org. These include packages for subsystems like Bluetooth, cellular connectivity, and touch input, plus MeeGo-curated versions of key MeeGo Architecture components like security tools, package installation, and messaging that require closer integration work for compliance reasons. The repository also includes the base UX implementations, hardware-specific drivers, and support tools like SDK components and emulators.
If you are interested in getting involved with the MeeGo project itself — that is, contributing to the MeeGo code base, as opposed to making your own app run on MeeGo — you should start by reading the contribution guidelines. They explain how to submit feature requests and propose requirements, plus how to package and submit patches, how to fit your contribution into the release schedule at the best time, and how to escalate a patch request if your submission gets accidentally overlooked.
You do not need to sign a contributor agreement to start working on MeeGo (or assign copyright), but you are required to attach a "signed-off-by" tag to your patches certifying that the patch contains your work, is your property, and adheres to the appropriate open source license.
Next, you will want to find the appropriate project and project maintainers to start directly participating. Remember that MeeGo tries to work with upstream projects whenever possible, so you may actually discover that the subsystem you wish to contribute to is actually hosted elsewhere and maintained by a different project. For the MeeGo-hosted projects, however, most of the ongoing development discussion is done on mailing lists. The MeeGo wiki lists them all — there is a core MeeGo-dev list for general development discussion, plus specific development lists for each UX, and development lists for each core component of the MeeGo Architecture. The project also uses the Freenode IRC network, with channels reserved for open discussion, regular meetings, and other collaborative topics.
There are several important non-code contributions you should consider working with as well, most importantly bug reporting and triage, updating and maintaining the documentation on the wiki, and executing QA tests to locate and document bugs. In addition, the MeeGo project maintains an active forum for developers and end-users which is also always looking for regular contributors.
Developing MeeGo Applications
But don't think that hacking on MeeGo itself is the only interesting way to get involved in the project. The core MeeGo releases include a suite of productivity and networking applications, but enabling third-party developers to write new apps for — or port existing apps to — the OS is one of the most important tasks for MeeGo's long-term success. As mentioned above, device makers may customize the user interface or build their own apps, but at its heart MeeGo is a Linux distribution, and needs open source apps from independent developers to really be interesting.
To get started, take a look at the MeeGo API documentation, starting with the API view of the overall MeeGo architecture. The system provides the familiar Qt application framework for application developers, supplemented by the QtMobility framework that adds common services necessary for portable and mobile devices (such as contacts management,location-based services, and mobile messaging), as well as OpenGL ES for 3-D graphics and hardware-accelerated 2-D graphics.
There are currently four "platform" APIs in the MeeGo stack that are available, but are regarded as "testing" libraries from a stability standpoint: the MeeGo Touch framework, which supports touch capabilities not in Qt or QtMobility, the GStreamer multimedia framework, the PulseAudio audio server, and the MeeGo Web Developer Library, which enables Web developers to write standards-based Web apps for MeeGo. If you need the advanced functionality of these APIs today, you can count on their presence, but in the long term the project is planning on integrating support for them into the Qt and QtMobility APIs recommended for general usage.
Once you know what is available to you, you can start setting up your development environment. The app development cycle begins with the MeeGo SDK. The SDK includes the Qt Creator IDE, plus toolchains for both Intel and ARM architectures, compilation targets for each UX, and MeeGo runtime images for the QEMU emulator. The SDK is officially tested on both Fedora and Ubuntu, though the community regularly tests it on other Linux distributions and maintains a wiki page with its current status. To get started, read the installation and setup document, which explains the hardware and software prerequisites, plus how to download and install targets and runtime images, and how to set up Qt Creator to use the MeeGo SDK toolchain.
Before you distribute your code to others, you will also need to package it for MeeGo. Although MeeGo uses the RPM package format, it is a distinctly different experience from Red Hat, Fedora, or other RPM-based distros. You should read the packaging guidelines to get a feel for how MeeGo packages are built, although a portion of that document pertains only to packages that are part of MeeGo itself. For third-party apps, there is a tutorial from the 1.0 release of the SDK that walks you through the process, which should be updated for 1.1 in the near future.
You can build your own local packages, but that may not be the easiest solution. The newest addition to the development cycle is the availability of the MeeGo Community build system. This is an instance of the openSUSE project's Open Build Service, which allows third-party community developers to build and package their code against stable MeeGo build targets. At the moment, the infrastructure is still being set up, so you can request access, since accounts are not being automatically created. Check the OBS wiki page for instructions as they are updated.
You can also use the community OBS to host a personal or team package repository, which makes it easy to distribute your work to testers and end users. The community OBS will power the MeeGo Garage, a third-party application repository for community-created, open source applications. It has not launched yet, but it is a direct descendant of the successful Maemo Garage project. You certainly are not required to use the community OBS or MeeGo garage, however: you can distribute your applications individually, or through third-party repositories or "app stores."
Much of the wiki documentation is directed at developers of new applications, but many existing Linux apps will run on MeeGo with very little alteration. The porting guide is filled with general information about porting from other distributions to MeeGo, and guidelines for meeting the MeeGo compliance program specifications. It covers packaging supporting libraries, adapting your code to the MeeGo architecture, working with the MeeGo security framework, and specific instructions for trickier components like X, audio, and the input components used by handheld devices.
Finally, although Qt is the officially-supported development framework for third-party applications, GTK+ applications can run on MeeGo as well, often with very little adaptation. There is a special porting page on the wiki outlining what is required to port existing GTK+-based apps to run on MeeGo.
MeeGo is a different creature in the realm of Linux. In some respects, it is much like any other Linux distro — focusing on packaging, integration, building and supporting releases, and helping third-party developers. But in other respects it is very unusual; something like a "metadistribution" — because it ships multiple UXes designed for different types of hardware, but it also expects customers to take its code and modify it heavily before delivering it to consumers. Once you dig into the project, however, you can see that it's just Linux underneath — although the opportunity it offers app developers to write open source programs for netbooks, phones, and other devices is certainly new territory.