Creating an UME Image for your Device

TODO

Warning

This procedure was tested and worked as described. All the efforts will be taken to keep it up-to-date but bear in mind that it's based on software in development and test stages so your mileage may vary.

More recent documentation and an up to date image creation procedure can be found here

Summary

This document walks through the process of creating a working image for your mobile device using the Moblin Image Creator utility, described in detail here. Running this image on a device will boot the Linux kernel, load the appropriate drivers, start X, show the UI, and allow you to launch applications.

Supported devices

The Image Creator currently allows you to create an image for a Samsung Q1 Ultra. However, having this device is not necessary for application development. For application or driver development, or to simply test run the UI, you can run everything using Xephyr on your Linux workstation.

Development Environment

As described above, the having the target device is not really necessary. Just a PC workstation running a GNU/Linux will be enough. Theoretically, any recent Linux distribution should work but this procedure was tested on Ubuntu Gutsy Gibbon (future 7.10) and 7.04. As a series of packages from the Gutsy repositories are need to build the project, a connection to the internet is required. To transfer the final image to the device, one will need a RW-CD or USB Pen Drive (>= 512MBytes).

Concepts

The Image Creator uses the concept of Projects that are linked to Platforms and one or more Targets that is comprised of one or more "functional sets" or fsets. The Image Creator uses these elements to create an image. Each element is described below.

Install and Run Image Creator

Installation

Just run

sudo apt-get install moblin-image-creator

Creating an Image

As described above, the image is the final result of the process. It's what's going to be used to install the file system that will run at the target device. There is two ways to create the image: using the GUI or using the command line. Both are described bellow.

Using the GUI

Start the image creator

What matters for now at this moment is the Platform Project session. The three buttons are use to Add a project, Delete a project or to open a terminal chrooted into the project selected in case any manual changes are needed.

Create the Project

Wait for the installation

The Image Builder is now creating the base project. This can take several minutes.

Create the target system

The next step is to create the target and add one or more functional sets. In this session of the interface we see the buttons Add, to add a target to the current project, Add Functional Set, to include a functional set or more to the selected target, Delete, to delete a target from the list, Terminal, to open a chrooted terminal inside the target file system and Kernel cmdline that can be used to add command line parameters to be used when the target kernel is executed.

Choose a functional set

After the process is done, we will have a file system ready to be transfered to the target device or we can use the Terminal button to open a chrooted terminal and run the hildon environment directly in a Xephyr session.

Generate image

The last step, which can be optional, is to create the image for the target. There are five different image styles that can be created, attached to the five first buttons in this session of the interface:

Currently, only the Install USB image type is supported. Once the generation of the image is done, use the Write USB Image button to write it to your USB drive.

Using the command line

As stated before, the same steps above can be done using the command line. This is very handy once the parameters are already defined as we can process the whole projects in batch. The steps taken can be as simple as follows:

  1. Create the Project
    • $ sudo image-creator -c create-project                  \
                            --platform-name mccaslin            \
                            --project-name "myproject"          \
                            --project-path "/usr/src/myproject" \
                            --project-description "My Samsung Q1 Ultra project"
  2. Create the target system
    • $ sudo image-creator -c create-target          \
                            --project-name "myproject" \
                            --target-name "target1"
  3. Install the functional set.
    • $ sudo image-creator -c install-fset         \
                            --project-name myproject \
                            --target-name target1    \
                            --fset-name "full-mobile-stack"
  4. Create the image
    • $ sudo image-creator -c create-install-usb \
                           --project-name myproject \
                           --target-name target1 \
                           --image-name myproject_target1_install-usb.img
    Once finished, a file called myproject_target1_install-usb.img will have the image ready to be burn to a USB drive and be installed in the target. Another option is to chroot to the generated file system with:
    • $ sudo image-creator -c chroot-target        \
                            --project-name myproject \
                            --target-name target1

And from there run the hildon-desktop with pointing to a Xephyr instance (see also Hildon Manual Procedure).

Outstanding Issues

MobileAndEmbedded/CreatingAnImageForUMEDevice (last edited 2008-08-06 16:15:15 by localhost)