SDK/Docs/1.2/Installing and configuring MeeGo SDK for Linux

Revision as of 10:13, 4 May 2011

This page describes how to install and configure the MeeGo 1.2 SDK on your Linux development system.

This page is in progress and is likely to contain incorrect instructions at present

Prerequisites

• Hardware: Any reasonably modern hardware, such as 32-bit Intel Atom or Intel Core 2 CPU. To use QEMU to run MeeGo in a virtual machine your system should have support for Virtualization Technology (VT). Without this, performance is likely to be very poor. See the Graphics Acceleration page for details. ???
• Software: The MeeGo 1.2 SDK has been validated on 32-bit versions of Fedora 12, Fedora 13, Fedora 14, Ubuntu 9.10, and Ubuntu 10.04 LTS. ???see http://qa-reports.meego.com/1.2 for tested distros
• Root privileges: To install the SDK you will need root privileges. Commands that require root privileges are prefaced with sudo. For convenience, you may wish to setup sudo capabilities to easily switch between root and normal user privileges (use man sudo in a terminal for more details).
• Commands: Terminal commands are prefaced with $. Do not enter $ when entering the commands in your terminal.

Install the MeeGo SDK

The MeeGo SDK installer configures a package repository for your specific Linux distribution and installs SDK packages from it. The main packages installed are Qt Creator (IDE), QEMU (emulator) and MADDE (compilation and runtime environment). For convenience, the package installation process is wrapped inside a graphical installer which will run on any of the supported Linux distributions.

Download the graphical installer from: http://download3.meego.com/MeeGoSDK/Linux/installer/meego-sdk-installer-online-20110429 this link is not working yet???

Run the installer from a terminal:

 # ???filename may change
 $ chmod +x meego-sdk-installer-online-20110429
 $ ./meego-sdk-installer-online-20110429 --verbose

(--verbose is optional but can be reassuring and helpful if things seem to have gone wrong or failed)

Follow the graphical installer prompts to install the SDK:

1. Wait for the installer to retrieve remote data. Then click on Next.
2. Browse to the directory where you want to install the SDK. You can type a new directory name in the box and the installer will create it for you. Click Next again.
3. Select the components you want to install. Qt Creator is the IDE for MeeGo development; MADDE is a tool for developing against different MeeGo targets, allowing you to cross-compile and run your applications in different environments.

   The SDK targets tree enables you to select different SDK targets to download immediately. Be warned that these are large files, so selecting more than one will leave you waiting a long time for the installer to finish. Note that you can add new targets later, so you don't have to select any now.

   Once you've selected components to install, click on Next.

4. Accept the licence and click Next again; then click on Install to start the installer downloading the required components.

   During this process, you will be prompted for a sudo password: enter it and press return.

Note that it may appear that nothing is happening for a long period of time. Be patient and it should eventually complete.

Install a MeeGo Target

A Target is used to build programs using the MeeGo toolchain and libraries (sysroot). It is downloaded as a large (~250MB) .bz2 file using MADDE (MeeGo Application Development and Debugging Environment). mad-admin is the MADDE command-line tool. You can use it to install one or more Targets; once installed, you can switch between them in Qt Creator to compile your application for different environments (described later???link).

Note that if you selected a target as part of SDK installation, you may not need to do this step. However, if at a later date you want to add, remove or otherwise manage MADDE targets for the SDK, follow the instructions below.

Determine the target you want to use

Run the command below (some sample output is shown):

$ sudo mad-admin list

Targets:
meego-core-ia32-1.1                    (installable)
meego-core-ia32-1.1.2                  (installable)
meego-core-ia32-trunk                  (installable)
meego-handset-ia32-1.1.2               (installable)
meego-handset-ia32-1.1.2-4.7.1         (installable)
meego-handset-ia32-1.1                 (installable)
# ... more targets not shown here ...

Runtimes:
meego-handset-ia32-qemu-1.1.20110110.1026-runtime          (installable)
meego-handset-ia32-qemu-1.1.20110118.1010-runtime          (installable)
meego-handset-ia32-qemu-1.1.20101031.2201-sda-runtime      (installed)
# ... more runtimes not shown here ...

The available targets will be listed under the Targets: heading.

A hint about the build environment is provided by the target prefix; for example:

• meego-core-armv7l: For ARM handheld devices (such as N900)
• meego-handset-ia32: For x86 handheld devices (such as Aava)
• meego-netbook-ia32: For x86 netbooks (such as EeePC)
• meego-tablet-ia32: For x86 tablet devices (such as WeTab)

Create the target

Run the command below. Replace <target> with the target you determined in the previous step. Note that the -f flag instructs MADDE to download the Target tarball (bz2) first.

$ sudo mad-admin create -f <target>

If you encounter problems, check the troubleshooting page.

Verify the target is installed correctly

To check that the target has been installed correctly, run the following. Replace <target> with the same value used in the previous step.

# create a skeleton project called qthello, based on the qt-simple template
$ mad -t <target> pscreate -t qt-simple qthello

$ cd qthello

# compile the project
$ mad -t <target> qmake
$ mad -t <target> make

Note: Running qmake will print -unix is deprecated. This is not an error with the compilation and can safely be ignored.

Set a default target (optional)

Once you've installed a target, you can make mad use it as the default. This means you can omit the -t <target> from a command, if you want to use the default target.

Use the following command to set the default:

$ mad set <target>

Verify the target can build software correctly

To check that the qthello binary is created for the correct target, run the following command, and verify the output.

$ file build/qthello

For example, the output for an x86 binary (on Fedora 13) looks like this:

build/qthello: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), \
dynamically linked (uses shared libs), for GNU/Linux 2.6.25, not stripped

And for an ARM binary (on Fedora 13), it looks like this:

build/qthello: ELF 32-bit LSB executable, ARM, version 1 (SYSV), \
dynamically linked (uses shared libs), for GNU/Linux 2.6.25, not stripped

Install a MeeGo Runtime (optional)

A Runtime is the MeeGo OS image which runs under QEMU, for debugging applications on your host system. A runtime is a large (~650MB) .bz2 file which you download with MADDE.

A Runtime is not required if you develop against real hardware running MeeGo. Even if you do require a Runtime, you won't need it until you have finished configuring Qt Creator. However, as this step may take some time, it is recommended that you start it now so it can run in the background while you finish installing the SDK.

See Downloading a Runtime and Using QEMU

Configure Qt Creator to use the MeeGo toolchain(s)

Start Qt Creator by selecting Applications > Programming > Qt Creator.

Next, configure Qt Creator to use the MeeGo toolchain(s):

1. Go to Tools > Options > Qt4 > Qt Versions.
2. On the right side of the Qt Versions view, click on the plus sign button to add a new version.

   A blank, new version appears in the Qt Versions view.

3. On the Version Name line, specify a name for the new version.
4. On the qmake location line, specify a qmake location for the new version. The toolchain installs by default to usr/lib/madde/linux-i686/targets/<target>/bin/qmake.
5. Click Rebuild, Apply and OK.

Adding the MeeGo toolchain(s) in Qt Creator

Using the MeeGo SDK Qt version

It is also possible to use Qt Creator without a MeeGo toolchain. This option can be useful if you don't need to cross-compile your software: for example, if you are doing QML development with no use of C++.

The steps are the same as above, but the qmake location is set to the qmake installed with the meego-sdk-qt libraries. The usual location for this on Linux is:

$ /opt/meego/meego-sdk-qt/bin/qmake

Note: On Ubuntu 10.10, you may need to install g++ in order for this step to work. If necessary, do this:

$ sudo apt-get install g++

Developing with the SDK

To start developing with the MeeGo SDK, the hello world tutorial is a good first step. This tutorial covers how to start a project, package it, and deploy it to a device (either a real device, or a QEMU runtime set up through MADDE).