J2ME development in 2025

Hello everyone!

I think everyone here is either old enough, or just a retro‑enthusiast, and knows which phones were used in the 2000s.

At the beginning of 9th grade (late 2022) I wrote a small J2ME application exactly for such a device.

Math Them Right

Later I made a remake in 2024 because I lost the original source code, but despite the setbacks we’ll still go through the steps.

Getting the development tools

To develop for the device, the first thing you need are the development tools, as ironic as that sounds.
I Googled “Symbian SDK”, and almost all the results were for the wrong tools, but that’s the usual story.

Most SDKs on those sites point to SDKs for more advanced models and use C++.
All of that is irrelevant, and yes, I tested and downloaded all of it – no, I’m not crazy.

Finally I realized that I have a Series 40 phone, so I needed the SDK for that series. I stumbled upon this link with an archival Java version, thanks to the now‑closed and removed StackOverflow post…

Required version, hooray!

Studying examples and setting up the build

I started looking at examples. For the test app I needed a 3‑D sound‑playback example, so I also downloaded Apache Ant, because it is used for building. Its version can be any; Java 6 is required only for the utilities.

file manager

The 3‑D sound test app is very simple; after tweaking everything I made a small game.

From my observations, the emulator works for a limited time without registration, after which it asks for registration – which didn’t really work for me under Wine. The preverify utility looks extremely home‑grown; it’s hard to tell what it actually does.

From my own code I updated the Ant build file so that it takes values from environment variables (there’s no point explaining that here; it’s visible in the repository). I just set the variables to the previously‑hardcoded values.

  <project name="MathThemRight" default="build">

  <property environment="env"/>

  <property name="build" value="build" />
  <property name="classes" value="${build}/classes" />
  <property name="src" value="src" />
  <property name="rsrc" value="rsrc" />
  <property name="midp_rsrc" value="${rsrc}/midp" />
  <property name="bundle" value="${build}/bundle" />
  <property name="preverified" value="${build}/preverified" />
  <property name="bin" value="bin" />
  <property name="midp_bin" value="${midp}/bin" />
  <property name="targets" value="targets" />
  <property name="javadoc" value="doc/javadoc" />
  <property name="javadoc_rsrc" value="${rsrc}/javadoc" />

  <property name="midp" value="." />

  <property name="java_cmd" value="${env.JAVA_6_CMD}" />
  <property name="sdk_location" value="${env.NOKIA_SERIES40_SDK}" />

  <property name="preverify" value="${env.NOKIA_SERIES40_SDK_PREVERIFY}" />

  <description>
   Math Them Right MIDlet java build project file
  </description>


  <target name="clean">
    <delete dir="${bin}" />
  </target>

  <target name="cleanSrc" description="deletes all class files from src folder">
    <delete>
      <fileset dir="${src}" includes="**/*.class"/>
    </delete>
  </target>


  <target name="build" description="clean, compile and build">
    <antcall target="clean" />
    <antcall target="compile" />
    <antcall target="preverify" />
    <antcall target="package" />
  </target>

  <target name="compile">

    <mkdir dir="${classes}" />
    <javac destDir="${classes}" srcDir="${src}" source="1.4" target="1.4" classpathref="project.class.path" includeAntRuntime="no" includeJavaRuntime="no" fork="yes" executable="${java_cmd}">
  <bootclasspath>
          <fileset dir="${sdk_location}/lib">
          <include name="**/*.jar"/>
    <include name="**/*.zip"/>
          </fileset>
    </bootclasspath>


   </javac>
   <copy todir="${classes}">
      <fileset dir="${src}" excludes="**/*.java"/>
    </copy>
  </target>


<path id="project.class.path">
  <fileset dir="${sdk_location}/lib">
             <include name="**/*.jar"/>
             <include name="**/*.zip"/>
          </fileset>
  </path>

 <property name="myclasspath" refid="project.class.path"/>

  <target name="preverify">

    <mkdir dir="${preverified}"/>
    <exec executable="${preverify}"  failonerror="true">

      <arg line="-classpath ${myclasspath}"/>
      <arg line="-d ${preverified}"/>
      <arg line="${classes}"/>
    </exec>
    <copy todir="${preverified}"  failonerror="false">
      <fileset dir="${src}" excludes="**/*.java"/>
    </copy>
  </target>

  <target name="package">
    <mkdir dir="${bin}" />
      <jar basedir="${preverified}" jarfile="${bin}/${ant.project.name}.jar"
      manifest="${midp_rsrc}/MANIFEST.MF" compress="true">
      </jar>

    <length file="${bin}/${ant.project.name}.jar" property="length.jarfile" />
    <copy file="${midp_rsrc}/${ant.project.name}.jad" toDir="${bin}" />
    <replace file="${bin}/${ant.project.name}.jad" token="@@@" value="${length.jarfile}"/>

  </target>

</project>

Finishing the game (audio code)

Then I completed the rest of the game, adding music according to Sun’s (yes, not Oracle’s!) MIDP documentation.

1
package com.foxelyss.maththemright;
2

3
import java.io.InputStream;
4
import java.util.Random;
5

6
import javax.microedition.lcdui.*;
7
import javax.microedition.media.Manager;
8
import javax.microedition.media.Player;
9
import javax.microedition.midlet.MIDlet;
10
import javax.microedition.midlet.MIDletStateChangeException;
11

12

13
public class Game extends MIDlet implements CommandListener {
14

15
    private static final String START_FORM_TITLE = "Math Them Right";
16

17
    private static final String START_MESSAGE = "Please press Next";
18

19
    private static final String CONTENT_TYPE = "audio/x-wav";
20

21
    private static final String WIN_SOUND = "/com/foxelyss/maththemright/res/win.wav";
22
    private static final String LOSE_SOUND = "/com/foxelyss/maththemright/res/lose.wav";
23

24
    Display display;
25

26
    ChoiceGroup answers;
27

28
    Command startCommand = new Command("Next", Command.OK, 1);
29
    Command exitCommand = new Command("Exit", Command.EXIT, 2);
30

31
    Player win_player;
32
    Player lose_player;
33

34
    InputStream win_sound_stream;
35
    InputStream lose_sound_stream;
36

37
    Form startForm;
38

39
    int win_strike = 0;
40
    int right_answer_index = -3;
41

42

43
    public Game() {
44
        display = Display.getDisplay(this);
45
    }
46

47
    public void startApp() throws MIDletStateChangeException {
48
        initAudio();
49
        startForm = new Form(START_FORM_TITLE);
50
        startForm.append(START_MESSAGE);
51
        startForm.addCommand(startCommand);
52
        startForm.addCommand(exitCommand);
53
        startForm.setCommandListener(this);
54

55
        answers = new ChoiceGroup("Answers", Choice.EXCLUSIVE);
56
        startForm.append(answers);
57
        display.setCurrent(startForm);
58
    }
59

60
    public void pauseApp() {
61
    }
62

63
    public void destroyApp(boolean unconditional) {
64
        try {
65
            win_player.stop();
66
            lose_player.stop();
67
            win_player = null;
68
            lose_player = null;
69
        } catch (Exception e) {
70
            e.printStackTrace();
71
        }
72
    }
73

74
    void initAudio() {
75
        try {
76
            win_sound_stream = getClass().getResourceAsStream(WIN_SOUND);
77
            lose_sound_stream = getClass().getResourceAsStream(LOSE_SOUND);
78

79
            win_player = Manager.createPlayer(win_sound_stream, CONTENT_TYPE);
80

81
            win_player.realize();
82
            win_player.prefetch();
83

84
            lose_player = Manager.createPlayer(lose_sound_stream, CONTENT_TYPE);
85

86
            lose_player.realize();
87
            lose_player.prefetch();
88

89
        } catch (Exception e) {
90
            e.printStackTrace();
91
        }
92
    }
93

94
    public void commandAction(Command c, Displayable d) {
95
        if (c == startCommand) {
96
            if (checkAnswer()) {
97
                win_strike++;
98
                try {
99
                    win_player.start();
100
                } catch (Exception e) {
101
                }
102
            } else {
103
                win_strike = 0;
104
                try {
105
                    lose_player.start();
106
                } catch (Exception e) {
107
                }
108
            }
109

110
            generateExercise();
111
        } else if (c == exitCommand) {
112
            destroyApp(true);
113
            notifyDestroyed();
114
        }
115
    }
116

117
    public boolean checkAnswer() {
118
        return right_answer_index == answers.getSelectedIndex();
119
    }
120

121
    public void generateExercise() {
122
        Random random = new Random();
123

124
        int a = random.nextInt(200);
125
        int b = random.nextInt(200);
126

127
        int operation = random.nextInt(4);
128

129
        int right_result = a / b;
130

131
        char operand = '/';
132
        switch (operation) {
133
            case 0:
134
                operand = '+';
135
                right_result = a + b;
136
                break;
137
            case 1:
138
                operand = '-';
139
                right_result = a - b;
140
                break;
141
            case 2:
142
                operand = '*';
143
                right_result = a * b;
144
                break;
145
        }
146

147
        String question = a + " " + operand + " " + b + "\t=";
148
        ((StringItem) startForm.get(0)).setText(question + "\n" + "Winning streak:\t" + win_strike);
149

150
        right_answer_index = random.nextInt(4);
151

152
        answers.deleteAll();
153
        for (int i = 0; i < 4; i++) {
154
            int offset = random.nextInt(24);
155
            String answer = "" + right_result;
156
            if (i != right_answer_index) {
157
                answer = (right_result + (offset < 12 ? -1 * (1 + offset) : offset)) + "";
158
            }
159

160
            answers.append(answer, null);
161
        }
162
    }
163

164
}

The final game is available in the releases – see the GitHub repository. That’s it, more or less!