Blackberry controls and midlets

Question

Midlet meets blackberry let the battle for who can use the escape key begin!
If you're having trouble mapping keys from the blackberry to your midlet..this will definitely help you!
in this post I go over: Adding menu items to the blackberry menu, and gaining access to undetected keys such as the Escape Key.
First of all, that **** menu how do I add stuff to it?
Well...that in itself is a hastle but lemme just say, that menu
is in a nutshell a CommandListener. Same freakin menu. Later on in this post I show how to map the escape key..and i'm guessing pretty much every other key...of course
the only key I ever had a problem with was the EscapeKey/HangUpKey
Anyways if you want that BlackBerry Menu Code here
* MIDletDemo.java
* Copyright © 1998-2008 Research In Motion Ltd.
* Note: For the sake of simplicity, this sample application may not leverage
* resource bundles and resource strings.  However, it is STRONGLY recommended
* that application developers make use of the localization features available
* within the BlackBerry development platform to ensure a seamless application
* experience across a variety of languages and geographies.  For more information
* on localizing your application, please refer to the BlackBerry Java Development
* Environment Development Guide associated with this release.
import java.util.*;
import java.io.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.lang.*;
* An Example MIDlet.
* The application must extend the MIDlet class to allow the application management
* software to control the MIDlet.
public class MIDletDemo extends MIDlet implements CommandListener
    private Alert _alert;
    private int _time;
    private Form _form;
    private myCanvas customCanvas;
    private Display _display;
    private UpdateThread _updateThread;
     * The thread that updates the explosion dialog box.
    private class UpdateThread extends Thread
        private boolean _disarmed;
        public void run()
            _disarmed = false;
            int i = _time;
            while (i > 0 && !_disarmed)
                try
                    _alert.setString(Integer.toString(i));
                    synchronized(this)
                            this.wait(1000);
                    System.out.println("timeout in:" +i);
                catch(InterruptedException e)
                    System.out.println("MyMidlet: Exception: " + e);
                i--;
            if(!_disarmed)
                _alert.setString("BOOM");
        void disarm()
            _disarmed = true;
     * Thread that pops up the program's main dialog box.
    private class GoCommand extends Command implements Runnable
        private GoCommand(String label, int type, int priority)
            super(label, type, priority);
        public void run()
            _alert.setString(Integer.toString(_time));
            _alert.setTimeout(_time * 1000 + 5000);
            _updateThread = new UpdateThread();
            _updateThread.start();
            _display.setCurrent(_alert, _form);
     * <p>The default constructor. Creates a simple screen and a command with an alert
     * dialog box which pops up when the command is selected.
    public MIDletDemo()
        _alert = new Alert("The Thermonuclear Device has been activated!\nTo disarm the device, dismiss this Alert.\nDevice will detonate in:");
        _alert.setCommandListener(this);
        _time = 10;
        // Create a simple screen.
        _form = new Form("Thermo-Nuclear Event");
      _form.append("Choose 'Go' from the menu.");
     customCanvas = new myCanvas();
        _display = Display.getDisplay(this);
        // Add our command.
        //_form.addCommand(new GoCommand("Go", Command.SCREEN, 1));
customCanvas.addCommand(new GoCommand("Go", Command.SCREEN, 1));
customCanvas.setCommandListener(this);
        //_form.setCommandListener(this);
        _display.setCurrent(customCanvas);
    //_display.setCurrent(_form);
    public void commandAction(Command c, Displayable s)
        if ( c instanceof Runnable )
            ((Runnable)c).run();
        if( c == Alert.DISMISS_COMMAND )
            _updateThread.disarm();
        _display.setCurrent(playerGUI);
     * <p>Signals the MIDlet that it has entered the Active state.
    public void startApp()
        // Not implemented.
     * <p>Signals the MIDlet to stop and enter the Pause state.
    public void pauseApp()
        // Not implemented.
     * <p>Signals the MIDlet to terminate and enter the Destroyed state.
     * @param unconditional When set to true, the MIDlet must cleanup and release all
     * resources. Otherwise, the MIDlet may throw a MIDletStateChangeException to
     * indicate it does not want to be destroyed at this time.
    public void destroyApp(boolean unconditional)
        // Not implemented.
}now keep in mind, I took this from a nice little example MIDlet called DemoMidlet inside the BlackBerry JDE
so it's not like they didn't make an effort. I mean I pretty much took it out of their examples located in
C:\Program Files\Research In Motion\BlackBerry JDE 4.6.0\samples\com\rim\samples\device\midletdemo
but lets face it...some of us like to use the Canvas Class...so showing us how to use it with a Form not exactly helpful.
All I did was the same thing it's just I made a canvas, and implemented the CommandListener, then swapped their form for my canvas.
It freaking worked like a charm. I mean I didn't really use that alert stuff...as it wasn't necessary, but it's a nice demo to learn from.
Part 2: The Escape Key!
The first and only problem I noticed when porting over to the blackberry was the lack of certain keys
that I truly enjoy and need. I guess blackberry decided to just not implement them
into the MIDlet canvas class?
I mean they did a great job at figuring out how to map the entire qwerty keyboard, but when it comes to the Escape Key
good luck!
So after tearing my hair out I found a solution...which i'm guessing everyone else also found but i'm posting this
cuz well..what if you're tearing your hair out right now...calm down take a deep breaths this is currently working on the BB 9000
jde emulator.
First of all I know this sucks but if you want to use that lovely escape key you're going to have to implement the BB KeyListener.
I know WTF MAN!? "first i code the whole thing using keylistener/commandlistener now I gotta use some stupid BB KEYLISTENER!?...just who does blackberry think they are?"
well heres the thing, I tore my hair out for like 12 hours straight trying to get around this...but after giving it a rest it's not such a big deal.
Steps
1) you have to grab the blackberry net_rim_api, and add it to your wireless toolkit.
the path is:
C:\Program Files\Research In Motion\BlackBerry JDE 4.6.0\lib\net_rim_api.jar
what I did was copied the file and pasted it into
C:\WTK2.5.1\lib\ext
once you have that inside your ext folder in your project settings you can enable the external package, this way you can build
using the RIM API.
in case you wanta take a glance at that headache it's : http://www.blackberry.com/developers/docs/4.5.0api/index.html
to enable it simply open up wtk, go to project/settings/External API's and check it off...take note that the wtk 2.5 generally comes with
Nokia SNAP Mobile API so i'm guessing it's a normal thing to do with MIDlets. Also if you check off Bundle..that's not too good it includes the API
with your package...which is really only helpful if you're trying to include some of that junk which really isn't necessary as the reason we're doing this in the first
place is cuz blackberry wanted to be cool and have their own proprietary keys....
Anyways check that off and continue to step 2.
Implementing Key Listener with the Canvas Class! :-)
2) This part is so easy...
import java.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
import net.rim.device.api.system.*;
public class myCanvas extends Canvas implements CommandListener,KeyListener{
String thekey = "no key pressed yet";
  public myCanvas() {
Application.getApplication().addKeyListener(this);
public void paint(Graphics g){
g.setColor(255,255,255);
g.fillRect(0,0,500,500);
g.setColor(0,0,0);
g.drawString(thekey,0,0,Graphics.TOP|Graphics.LEFT);
public boolean keyDown(int keycode, int time)
                thekey = String.valueOf(keycode);
                repaint();
            return false;
        public boolean keyRepeat(int keycode, int time)
             return false;
        public boolean keyStatus(int keycode, int time)
              return false;
        public boolean keyUp(int keycode, int time)
               return false;
  public boolean keyChar(char key, int status, int time) {
      if (key == Characters.ESCAPE)
         return false;
public void commandAction(Command c, Displayable s)
  ///YOU DON'T NEED THIS! I just left it here, in case you wanted to also use the blackberry menu to do stuff...in this case
//well the command is shown...and it calls the run method of the class you add the command to. My previous example
// used the command GO, and i made a private class...so this would cause the run method to execute when the user hits enter on go.     
     // if ( c instanceof Runnable )
          //  ((Runnable)c).run();
}i'm gonne be honest with you, the function public boolean keyChar()
I don't know if that actually works...I just don't want to recompile without it cuz I just got over this headache..so I left it there.
According to most people you use that to check if the key == Characters.ESCAPE and if it does then you do some stuff.
Also you don't need the command listener, I just left it in there because well..if you're like me and you use the blackberry menu, you're pretty much
going to use the CommandListener on your canvas to check to see if the user hit enter on a menu item.
The function that matters here, is the same function Midlet coders are used to.
instead of keyPressed it's simply keyDown
so basically you're importing the package
import net.rim.device.api.system.*;
which allows you to implement blackberry's keyListener which gives you access to all the keys vs. a limited amount of them.
now blackberry went all out as you can see. You have to have keyDown, keyUp, keyRepeated...it's kinda rediculous.
but no worries, as long as you make sure that Display.setCurrent(yourcanvas);
or you use one of those to give the canvas control...you'll be fine.
It works because in the method for creating myCanvas()
or whatever canvas you'll be using, it calls Application.getApplication.addKeyListener(this);
and that little command gives your canvas the ability to listen for blackberry keys such as escape.
the current code will start displaying the keycodes for each key...and apparently keys such as ESCAPE
can be labeled properly. I love this because I can map the hang up call key to destroy my midlet, or even the escape key.
Unfortunately every keycode displayed is in like unicode or some stupid format, so that's my guess as to why the Escape key is not detected by the normal
canvas keyPressed method.
Anyways you're done this should work...now if you're having trouble using canvas and you're like "but I don't use canvas" idk man...
I use canvas...cuz I think programs should look cool. I'm sure this works without the canvas...on a form or something.
But don't be fooled, you're not limited to KeyListener, you can also use TrackWheelEvent and all kinds of stuff. So just like the choices for CommandListener vs. keyPressed
Blackberry has other choices as well.
And they said merging the API's was a bad idea...shucks, how else are we supposed to use the freaking escape key.
--JavaLover53
P.S. I marked this as a question cuz I want people to really take a look at this. Make some comments, I love this forum
and I really feel that this topic is not covered on the internet. A lot of naysayers, and when I found the solution I was like "that's it"
"that's all I had to do?" "well then wheres the freaking tutorial!
seriously people had me thinking I had to extend the blackberry UI when this is all I had to do..such an easy task
that other people claim is ridiculously hard.
Go ahead make your comments, lemme know if you know something I don't, i'm here to learn! :-)

Answer 1

good writeup, however i found this only working when you're not running fullscreen