C H A P T E R 4 - Quick Start: Building on Linux for ARM

C H A P T E R 4

Quick Start: Building on Linux for ARM

This chapter is about cross-compiling, where you build the Java Wireless Client software on a Linux desktop computer but run it on a device with an ARM processor.

Linux builds come in two flavors:

Framebuffer (fb) builds use a simple virtual display. You can use the qvfb tool to see and interact with the Java Wireless Client software.

Qt (qt) builds use the Qt toolkit directly. The high-level graphics system of Java Wireless Client software is implemented using Qt widgets. For this type of build, you need the Qt toolkit, available at http://www.trolltech.com/products/qt.

This chapter describes how to perform the linux_fb_gcc build for an ARM processor.

This chapter is based on example scripts that help you run the different parts of the build. The scripts are available in docs/build-scripts/linux-arm. Once you have everything set up, run the scripts to perform the build. Work along as you read through the chapter to understand how it all fits together.

Setting Up Your Environment

Most of the time, Linux already has most of the tools you need. These examples show how to find out if you have these tools available. If you do not, you will need to install the appropriate tools and adjust your PATH to include them.

GNU Make

   $ make --version

   GNU Make 3.80

   Copyright (C) 2002  Free Software Foundation, Inc.

   This is free software; see the source for copying conditions.

   There is NO warranty; not even for MERCHANTABILITY or FITNESS

   FOR A PARTICULAR PURPOSE.

On your computer, GNU Make might be gmake instead of make.

GCC cross compiler

   $ gcc --version

   3.3.1

JDK software

   $ java -version

   java version "1.4.2_08"

   Java(TM) 2 Runtime Environment, Standard Edition

      (build 1.4.2_08-b03)

   Java HotSpot(TM) Client VM (build 1.4.2_08-b03, mixed mode)

   $ javac

   Usage: javac <options> <source files>

   where possible options include:

...

Each of the build scripts in the rest of this chapter operate by setting up, doing some work, and cleaning up.

The setting up script is setup.sh and the cleaning up script is teardown.sh.

setup.sh looks like this:

export Acme=/home/jk134021/jwc

export JDK_DIR=/usr/java/j2sdk1.4.2_08

export GNU_TOOLS_DIR=/opt/Embedix/tools/arm-linux

export Scripts=`pwd`

export Output=$Acme/output

export Log=$Acme/log.txt

rm -f $Log

This script is available as docs/build-scripts/linux-arm/setup.sh.

The Acme variable is the top level of the Java Wireless Client software. Adjust the value to point to the top level of your own installation. Also, make sure JDK_DIR points to the top directory of your JDK. Finally, adjust GNU_TOOLS_DIR to point to the installation directory of your GCC cross compiler.

Don't run setup.sh yet. It will be used by the build scripts in the rest of this chapter.

teardown.sh looks like this:

cat $Log

cd $Scripts

You do not need to modify this script.

Building PCSL

The first step is to build PCSL. You have to do this twice to generate all the output that CLDC will need when you build it. First you need to build PCSL for linux_i386_gcc. Then you build PCSL for linux_arm_gcc.

Tell PCSL the target platform and where to put output files. Set PCSL_PLATFORM to linux_i386_gcc first, then linux_arm_gcc. Tell PCSL where to put its output files with the PCSL_OUTPUT_DIR variable.

In addition, because you are cross-compiling for another platform, tell the PCSL build where to find the cross compiler by setting GNU_TOOLS_DIR.

This script, build-pcsl.sh, that performs the build:

. setup.sh

cd $Acme/pcsl

make \

  PCSL_PLATFORM=linux_i386_gcc \

  PCSL_OUTPUT_DIR=$Output/pcsl \

  NETWORK_MODULE=bsd/generic \

$1

make \

  GNU_TOOLS_DIR=$GNU_TOOLS_DIR \

  PCSL_PLATFORM=linux_arm_gcc \

  PCSL_OUTPUT_DIR=$Output/pcsl \

  NETWORK_MODULE=bsd/generic \

$1

if [ $? -ne 0 ]; then

  echo "build-pcsl=failed" >> $Log

else

  echo "build-pcsl=OK" >> $Log

fi

. $Scripts/teardown.sh

This script uses the setup.sh and teardown.sh script from before.

Run build-pcsl.sh as follows:

build-scripts/linux-arm> sh build-pcsl.sh

building memory port module...

make[4]: Entering directory `/home/jonathan/jwc/pcsl/memory/memory_port'

make[4]: Leaving directory `/home/jonathan/jwc/pcsl/memory/memory_port'

building memory module...

make[4]: Entering directory `/home/jonathan/jwc/pcsl/memory/malloc'

make[4]: Leaving directory `/home/jonathan/jwc/pcsl/memory/malloc'

make[3]: Leaving directory `/home/jonathan/jwc/pcsl/memory'

make[2]: Leaving directory `/home/jonathan/jwc/pcsl/string/utf16'

make[1]: Leaving directory `/home/jonathan/jwc/pcsl/string'

build-pcsl=OK

build-scripts/linux-arm>

A series of build messages will be displayed, with a message at the end about the success of the PCSL build.

The output goes in $Acme/output/pcsl. Take a look:

/home/jonathan> ls jwc/output/pcsl

linux_arm linux_i386

/home/jonathan> ls jwc/output/pcsl/linux_arm

inc  lib  obj

/home/jonathan>

Building CLDC

CLDC is built on top of PCSL. Tell CLDC to use PCSL by setting ENABLE_PCSL to true, and specify where to find PCSL with PCSL_OUTPUT_DIR.

In addition, the CLDC build system expects you to define various environment variables as follows:

JDK_DIR is the location of the Java Development Kit software.

JVMWorkSpace is the cldc directory.

JVMBuildSpace contains the output of the completed CLDC build.

Define GNU_TOOLS_DIR just like for the PCSL build.

The following script, build-cldc.sh, runs the CLDC build.

. setup.sh

cd $Acme/cldc/build/linux_arm

make \

  GNU_TOOLS_DIR=$GNU_TOOLS_DIR \

  JDK_DIR=$JDK_DIR \

  ENABLE_PCSL=true \

  PCSL_OUTPUT_DIR=$Output/pcsl \

  JVMWorkSpace=$Acme/cldc \

  JVMBuildSpace=$Output/cldc \

$1

if [ $? -ne 0 ]; then

  echo "cldc_status=failed" >> $Log

else

  echo "cldc_status=OK" >> $Log

fi

. $Scripts/teardown.sh

Go ahead and give it a try with sh build-cldc.sh. Wait for a success message at the end of the build, and take a look at the generated files in output/cldc.

Building Java Wireless Client Software

The last step in creating a Java Wireless Client software stack is building MIDP and optional APIs. This chapter describes how to build MIDP only. Later chapters describe how to include optional APIs in this part of the build and the many variables you can use to change how Java Wireless Client software is built.

For now, build MIDP using the CLDC and PCSL output you already generated.

You need JDK_DIR defined, just as it was for the CLDC build. In addition, you must tell the MIDP build where to find PCSL and CLDC:

Set PCSL_OUTPUT_DIR.

Set CLDC_DIST_DIR to the dist directory of the CLDC build you wish to use. In this case, it is $Output/cldc/linux_arm/dist.

The first thing that happens with the MIDP build is that tools are created for use later in the build. Use TOOLS_DIR to point to the tools directory.

Set GNU_TOOLS_DIR as before.

Set TARGET_CPU to arm to tell the build system the type of target processor.

Finally, set MIDP_OUTPUT_DIR to the location that will contain the output of the build.

Run the build from the midp/build/linux_fb_gcc directory. Here is a script, build-sjwc.sh, that sets the necessary variables and runs the MIDP build:

. setup.sh

cd $Acme/midp/build/linux_fb_gcc

make \

  GNU_TOOLS_DIR=$GNU_TOOLS_DIR \

  JDK_DIR=$JDK_DIR \

  PCSL_OUTPUT_DIR=$Output/pcsl \

  CLDC_DIST_DIR=$Output/cldc/linux_arm/dist \

  TOOLS_DIR=$Acme/tools \

  TARGET_CPU=arm \

  MIDP_OUTPUT_DIR=$Output/midp \

$1

if [ $? -ne 0 ]; then

  echo "sjwc_status=failed" >> $Log

else

  echo "sjwc_status=OK" >> $Log

fi

. $Scripts/teardown.sh

Run sh build-sjwc.sh without modifying the script. Wait until you see the message sjwc_status=OK at the end of the build. Congratulations! You've just built a complete MIDP stack.

Running Java Wireless Client Software

Now what do you do with it? To run the software, copy the following three directories to your Linux ARM hardware:

$MIDP_OUTPUT_DIR/appdb

$MIDP_OUTPUT_DIR/bin

$MIDP_OUTPUT_DIR/lib

Now run the Java Wireless Client software with bin/arm/usertest.

The Java Wireless Client software runs on the device screen.

FIGURE 4-1 Application Manager