I’ve started to learn J2ME yesterday and I was looking for a easy way to scroll canvas in J2ME but without success (some people were even arguing that it’s impossible) and then I figured something out so here’s a little recipe…

Instead of putting graphics directly on the screen like in this part of an example code:

class CanvasList extends Canvas implements CommandListener{
    private Image image;

    public void paint(Graphics g){
       g.setColor(53,53,53); g.fillRect(0,0,width,height_that_is_too_big_to_fit);

We have to put it into the memory first:

class CanvasList extends Canvas implements CommandListener{
    // private Image image;

    public void paint(Graphics g){
       Image image = Image.createImage(width, put_here_max_height_of_your_picture);
       Graphics ig = image.getGraphics();
       ig.setColor(53,53,53); ig.fillRect(0,0,width,height_that_is_too_big_to_fit);

As you maybe figured out, you should use something else than a rectangle to see the difference – this is only an example. Now we need to display our canvas on the screen:

g.drawImage(image, 0, 0, Graphics.TOP | Graphics.LEFT);

And the most important part – how to make this thing move? It’s very simple. If you want to look at the bottom of canvas that is outside the screen just do something like this:

g.translate(0,-50); // moving graphic 0 px horizontal and -50 vertical
g.drawImage(image, 0, 0, Graphics.TOP | Graphics.LEFT);
repaint();

You can move your canvas using phone keypad by placing a variable in g.translate and changing it’s value after pressing a key. Here is little example:

protected void keyPressed(int keyCode){
    if (keyCode==56)
        { if (y_pos>(((canvas_vert_size-screen_height)*-1)-5)) { y_position = y_position-10; }}
    if (keyCode==50) { if (y_pos<0) { y_pos = y_pos+10; }}
    display.setCurrent(canvas);
    repaint();
    }

We are using y_pos for y coordinates passed to g.translate. Hope that’ll help somebody because I think it’s one of most common problems with graphic applications on mobile devices.

J2ME to środowisko tworzenia aplikacji na telefony komórkowe w Javie. W tym krótkim wpisie przedstawię prosty sposób na jego instalację w systemie Arch Linux.

Pierwszym krokiem jest instalacja Java Development Kit (JDK):

# pacman -S jdk

Teraz należy pobrać i zainstalować Sun Java Wireless Toolkit (WTK) z adresu http://java.sun.com/products/sjwtoolkit/download.html:

# chmod +x ./sun_java_wireless_toolkit-2.5.2_01-linuxi486.bin.sh
# ./sun_java_wireless_toolkit-2.5.2_01-linuxi486.bin.sh

Akceptujemy licencję i jako ścieżkę interpretera (wciskając 1) podajemy /opt/java/bin/. Ścieżkę instalacji WTK podajemy jako /opt/java/wtk2.5.2 (adekwatnie do numeru wersji).

Dodajemy ścieżki do zmiennej PATH:

PATH+=:/opt/java/bin/:/opt/java/wtk2.5.2/bin/

Możemy je także dodać do pliku ~/.bash_profile aby nie trzeba było wpisywać ich po każdym zalogowaniu.

Rozpoczynamy testowanie środowiska. Przechodzimy do katalogu z przykładami i uruchamiamy emulator z poziomu konsoli:

$ cd /opt/java/wtk2.5.2/apps/Games/bin/ $ emulator -Xdescriptor:./Games.jad

Oczom naszym powinien ukazać się wirtualny telefon z uruchomioną aplikacją. Teraz skorzystamy z nakładki graficznej:

$ ktoolbar

Przed oczami ukaże się nam graficzny interfejs. Możemy dzięki niemu otworzyć przykładowe pliki za pomocą Open Project, zaznaczając Show available demos i spróbować je skompilować (build) oraz uruchomić (Run).

Teraz zajmiemy się utworzeniem przykładowej aplikacji HelloWorld. W ktoolbar wybieramy New Project i w obydwa pola wpisujemy HelloWorld. Zmieniamy ustawienia z MSA (MIDP 2.1) na Custom i wybieramy profil MIDP 2.0 (niewielka ilość telefonów obsługuje MIDP 2.1 i stąd ta zmiana – wcześniej dobrze jest sprawdzić jak to jest w przypadku naszego urządzenia). Resztę pozostawiamy bez zmian.
W katalogu ~/j2mewtk/2.5.2/apps/HelloWorld/ zostanie utworzony szkielet naszego projektu. Teraz uruchamiamy ulubiony edytor tekstu i tworzymy plik ~/j2mewtk/2.5.2/apps/HelloWorld/src/HelloWorld.java z zawartością:

// Sample adapted from http://developers.sun.com/mobility/midp/articles/wtoolkit/
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
public class HelloWorld
extends MIDlet
implements CommandListener
{
private Form mMainForm;
public HelloWorld()
{
mMainForm = new Form(“HelloWorld”);
mMainForm.append(new StringItem(null, “Hello, World!”));
mMainForm.addCommand(new Command(“Exit”, Command.EXIT, 0));
mMainForm.setCommandListener(this);
}
public void startApp()
{ Display.getDisplay(this).setCurrent(mMainForm); }
public void pauseApp() {}
public void destroyApp(boolean unconditional) {}
public void commandAction(Command c, Displayable s)
{ notifyDestroyed(); }
}

Powracamy do WTK, wciskamy Build i Run. W emulatorze telefonu uruchamiamy naszą aplikację i powinniśmy ujrzeć znajomy napis. Aby aplikacja była gotowa do uruchomienia w telefonie wybieramy Project -> Package -> Create Package. Dzięki temu utworzone zostaną pliki jad oraz jar.

Polecane artykuły:
Writing J2ME applications in Linux
Linux J2ME HOWTO
Przewodnik po technologii J2ME

W AUR znajdują się źródła potrzebne do przygotowania paczki Moto4lin ale niestety się nie kompilują, a rozwiązania na forach brak (poza dziwnym pomysłem usunięcia QT4). Jeśli posiadasz problem tego typu:

$ make
cd moto_ui/ && /usr/bin/qmake moto_ui.pro -unix -o Makefile
WARNING: Failure to find: images/video.png
uic: File generated with too old version of Qt Designer (3.3)
uic: File generated with too old version of Qt Designer (3.3)
uic: File generated with too old version of Qt Designer (3.3)
uic: File generated with too old version of Qt Designer (3.3)
cd moto_ui/ && make -f Makefile
make[1]: Wejście do katalogu `/src/moto4lin/moto4lin-0.3/moto_ui’
/usr/bin/uic form1_base.ui -o ui/ui_form1_base.h
uic: File generated with too old version of Qt Designer (3.3)
File ‘form1_base.ui’ is not valid
make[1]: *** [ui/ui_form1_base.h] Błąd 1
make[1]: Opuszczenie katalogu `/src/moto4lin-0.3/moto_ui’
make: *** [sub-moto_ui-make_default] Błąd 2

Rozwiązaniem jest uruchomienie qmake z QT3:

$ /opt/qt/bin/qmake

Po tym poleceniu uruchamiamy make i make install ale naszym oczom ukazują się kolejne błędy:

$ sudo make install
( [ -d moto_ui ] && cd moto_ui ; grep “^qmake_all:” Makefile && make -f Makefile qmake_all; ) || true
( [ -d moto_ui ] && cd moto_ui ; make -f Makefile install; ) || true
make[1]: Wejście do katalogu `/src/moto4lin-0.3/moto_ui’ ( cd moc && make ) make[2]: Wejście do katalogu `/src/moto4lin-0.3/moto_ui/moc’
make[2]: *** Nie podano obiektów i nie znaleziono makefile. Stop.
make[2]: Opuszczenie katalogu `/src/moto4lin-0.3/moto_ui/moc’
make[1]: *** [/bin/moc] Błąd 2
make[1]: Opuszczenie katalogu `/src/moto4lin-0.3/moto_ui’

Można je jednak zignorować gdyż w katalogu znajduje się plik wykonywalny moto4lin, który należy uruchomić z poziomu roota.