VM:TI2Rv=119
VM:TI2Rv=112
VM:TR2Iv=37
VM:TR2Iv=36
VM:TR2Iv=43
VM:TR2Iv=49
VM:TR2Iv=91
VM:TR2Iv=79
VM:TR2Iv=42
VM:TR2Iv=44
VM:TR2Iv=54
VM:TR2Iv=45
VM:TR2Iv=48
VM:TR2Iv=50
VM:TR2Iv=51
VM:TR2Iv=47
VM:TR2Iv=57
VM:-CR=0
PhoneFolders.getInstance(): _instance is null
PhoneFolders.getInstance(): have _instance
Something I’m interested in <<<
VM:ICSFv=1,w=131044
JVM: bklt[1] @35661: JBSC on=1
JVM: bklt[1] @35661: SC 1
JVM: bklt @35661: setTimer 22
Starting com_naviina_boelexdebug_app
Started com_naviina_boelexdebug_app(161)
Foreground com_naviina_boelexdebug_app(161)

I resorted to putting an ugly prefix at the start of every line so my output would stand out:

System.out.println(“——————————————-” + someParam);

Below is the source for a class that has helped me a lot when having to work without being able to step through code. It outputs html markup to a file in the simulator SD card directory, used in conjunction with the ReloadEvery Firefox plugin it allows you to see only the information you need without the distraction of the VM output. Plus it has the added benefit of being able to colour-code the output from different classes in your project.

import java.io.IOException;
import java.io.OutputStream;
import javax.microedition.io.Connector;
import javax.microedition.io.file.FileConnection;
 
public class Web {
 
    public static final int MODE_OUTPUT = 0;
    public static final int MODE_SDCARD = 1;
    private static int outputmode = MODE_SDCARD;
    private static String debugFile = "file:///SDCard/debug.htm";
    private static OutputStream os = null;
    private static FileConnection fc = null;
 
    public static void setOutputMode(int _outputmode) {
        outputmode = _outputmode;
    }
 
    public static void out(String message) {
        switch (outputmode) {
            case MODE_OUTPUT:
                System.out.println(message);
                break;
            case MODE_SDCARD:
                writeLine(message + "<br>");
                break;
        }
 
    }
 
    public static void out(String message, int textColor) {
        switch (outputmode) {
            case MODE_OUTPUT:
                System.out.println("<span style=\"color: " + color2web(textColor) + "\">" + message + "</span><br>");
                break;
            case MODE_SDCARD:
                writeLine("<span style=\"color: " + color2web(textColor) + "\">" + message + "</span><br>");
                break;
        }
    }
 
    public static void out(String message, int textColor, int backgroundColor) {
        switch (outputmode) {
            case MODE_OUTPUT:
                System.out.println("<span style=\"color: " + color2web(textColor) + "; background-color:" + color2web(backgroundColor) + "\">" + message + "</span><br>");
                break;
            case MODE_SDCARD:
                writeLine("<span style=\"color: " + color2web(textColor) + "; background-color:" + color2web(backgroundColor) + "\">" + message + "</span><br>");
                break;
        }
    }
 
    public static String color2web(int color) {
        String webcolor = "#" + Integer.toHexString(color);
        return webcolor;
    }
 
    private static void writeLine(String line) {
        try {
            if (fc == null) {
                try {
                    fc = (FileConnection) Connector.open(debugFile, Connector.READ_WRITE);
                    if (!fc.exists()) {
                        fc.create();
                    }
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
            os = fc.openOutputStream(fc.fileSize());
            line = line + "\n";
            byte[] lineArray = line.getBytes();
            os.write(lineArray, 0, lineArray.length);
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                os.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
 
    public static void clearOutput() {
        if (fc == null) {
            try {
                fc = (FileConnection) Connector.open(debugFile, Connector.READ_WRITE);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
 
        }
        if (fc.exists()) {
            try {
                fc.delete();
                fc.create();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

Instructions for use:

1 – make sure your simulator has an SD card directory setup on you computer. To do this on later RIM JDE versions go to Edit > Preferences > Simulator Tab > Memory Tab. Check ‘Simulate SD Card Inserted’ and ‘Use PC Filesystem for SD Card Files’ and select a directory to use by clicking Browse under ‘PC filesystem path for SD Card files’.

2 – Create the class (Web.java) and add to your project. Syntax for output is:

Web.out("Test Standard Out");
Web.out("Test Black Out", Color.BLACK);
Web.out("Test Red Out", Color.RED);
Web.out("Test Yellow Text, Red background", Color.YELLOW, Color.RED);

3 – To delete the file contents add the following at the start of your application:

Web.clearOutput();

4 – Run your app once to create the debug.html file on the SDCard, open it in Firefox and (assuming you installed the ReloadEvery plugin already) right-click on the page and select ‘Reload Every…’, choose ‘Reload Every 5s’ or choose custom and create a delay of a second or two.

5 – enjoy clear, clean and colour-coded debugging.

Note – There’s also the option to send these html tagged messages to the standard debug output, you can copy the output to a file and see your coloured information stand out clearly amongst the other irrelevant messages, just set the outputmode:

Web.setOutputMode(Web.MODE_OUTPUT);

The application also displays how an MP voted in the Digital Economy Bill reading in the House of Commons.

In addition, Find Your MP has a link to the related VoterPower mobile site so you can see just how little/much your vote is worth.

The MP and consituency lists are both quite large, after the first time they’re loaded a copy persists on the device to cut down bandwidth for you and the TheyWorkForYou servers, at any time you can refresh this information from the menu item on both the ‘View and Search Mps’ and ‘View and Search constituencies’ screens.

Thanks to Matthew at TheyWorkForYou.com for putting up with my inane API questions over the last 24 hours and Wonky for the logo.

Find Your MP is available in BlackBerry AppWorld or download it from m.naviina.eu using your BlackBerry browser. (Requires OS4.5 or later)

Here’s a quick hack adapted (pretty much line for line) for BlackBerry from Daniel Shiffman’s example at Processing.org:

package com.naviina.littlemandlebrot;
 
import net.rim.device.api.system.Display;
import net.rim.device.api.ui.Graphics;
import net.rim.device.api.ui.UiApplication;
import net.rim.device.api.ui.container.MainScreen;
 
public class LittleMandlebrot extends UiApplication {
 
    public static void main(String[] args) {
        new LittleMandlebrot().enterEventDispatcher();
    }
 
    public LittleMandlebrot() {
        pushScreen(new LittleMandlebrotScreen());
    }
}
 
class LittleMandlebrotScreen extends MainScreen {
 
    int screenWidth = Display.getWidth();
    int screenHeight = Display.getHeight();
    float xmin = (float) -2.5;
    float ymin = -2;
    float wh = 4;
    float xmax = xmin + wh;
    float ymax = ymin + wh;
    int maxiterations = 200;
    float dx = (xmax - xmin) / (screenWidth);
    float dy = (ymax - ymin) / (screenHeight);
    float y = ymin;
 
    protected void paint(Graphics graphics) {
        drawMandlebrot(graphics);
    }
 
    void drawMandlebrot(Graphics graphics) {
        System.out.println("Starting Mandlebrot calculations");
        for (int j = 0; j < screenHeight; j++) {
            float x = xmin;
            for (int i = 0; i < screenWidth; i++) {
                float a = x;
                float b = y;
                int n = 0;
                while (n < maxiterations) {
                    float aa = a * a;
                    float bb = b * b;
                    float twoab = (float) 2.0 * a * b;
                    a = aa - bb + x;
                    b = twoab + y;
                    if (aa + bb > 16.0) {
                        break;
                    }
                    n++;
                }
 
                if (n == maxiterations) {
                    graphics.setColor(0x000000);
                    graphics.drawPoint(i, j);
                } else {
                    graphics.setColor(n * 16 % 255);
                    graphics.drawPoint(i, j);
                }
                x += dx;
            }
            y += dy;
        }
        System.out.println("Finished Mandlebrot drawing");
    }
}

• - As per the instructions put your SIM into the USB 3G modem then plug it into your Mac.
• - Wait for the CD image to mount then ctrl-click the MobileConnect appliction and select ‘Show Package Contents’.
• - Drill down into the directory structure and double-click Mobile_Connect_Drv_App.pkg – this will install the drivers for the USB modem.
• - OSX should pick up the new connection, click to open Network Preferences or navigate to System Preferences > Network
• - Select ‘HUAWEI Mobile’ from the pane on the left and enter the following details:
  

  • - Telephone Number: *99#
  • - Account Name: o2bb
  • - Password: password

• - Click advanced, set the following details in the modem pane then click OK:
  

  • - Vendor: Generic
  • - Model: GPRS (GSM/3G)
  • - APN: m-bb.o2.co.uk

• - Select ‘Show modem status in menu bar’ so you get some feedback then click Connect
• - Assuming everything’s gone as planned you can now launch your web browser, navigate to https://mobilebroadbandaccess.o2.co.uk and follow the on-screen instructions to buy data access (you’ll need your SIM number which is printed on the creditcard you just popped it out of)
• - Disconnect the connection by clicking the phone icon in the menu-bar and select ‘Disconnect HUAWEI Mobile’ then restart it by doing the same and choosing ‘Connect HUAWEI Mobile’.
• - Browse the web!

This worked for me – your mileage may vary.

A few years ago a rumour went round that there was a special suffix you could add to your connection string on a BlackBerry app that magically removed all the headaches associated with using DirectTCP and tunelling through the carriers WAP gateway, it did away with the need for users to enter their carrier APN settings – or maintain an unreliable internal look-up list.

Actually I remember someone noticing that Googletalk connected fine without the APN being entered, they hacked into the app and found a lookup list of APNs, they did some more digging and found that this was a red-herring to disguise the actual connection method, this was back when it was unclear who’d developed Googletalk.

Fast-forward a couple of years and this connection method has become semi-official, if you want to connect using this suffix you’re supposed to apply to Rim.

There’s an extremely useful sticky thread on the official BlackBerry forums by Peter Strange that goes into detail about the different connection methods on BlackBerry so I won’t repeat that content here – but it’s an essential read for any BlackBerry developer.

Why does Rim want this connection string kept secret? When you apply to Rim for permission to use this connection method you have to fill in a form that states various parameters including:

- Size of each transaction.
- Frequency of connections.

How large is the data your app will be sending and how often will it send it? This data allows Rim to properly scale the service and ensure it runs smoothly. If lots of third party developers use this method without thinking about the impact they’re having it could lead to an unreliable service. Imagine a developer that has a video upload application, it uses a lot of bandwidth and they use this connection string unofficially, now imagine their app becomes ‘the next big thing’ and they suddenly have millions of users – it’d potentially knock out BIS-B – and BIS-B is the channel BIS (consumer) BlackBerry’s use to browse the web from the native browser.

Should you use the magic string? I have in the past and the app is still up and running fine. Someone in Rim told me around a year ago that they’re looking into possibly having a whitelist of approved apps in the future and blocking any apps using the channel without permission. I don’t know if this has changed. If you do use it your users might one day find their app can’t connect anymore, then again; this might never happen. Plus, as David McCormack said on Twitter:

Doing so would break countless popular apps – a bad move if they’re trying to boost the platform’s popularity among developers.

We’re in a bit of a crazy situation. If we don’t use this extremely robust and reliable method of connecting to the network our apps are inferior to competitors who do use it, if we do use it (without permission) we don’t make any friends at Rim. We’re not all huge enterprise alliance partners so the situation essentially creates two tiers of apps. The wealthy get a more reliable connection method.

Another question is why on earth does a company that’s a leader in security expose such a big feature with nothing more than a special secret string? Security through obscurity is no security at all.

This post is largely conjecture and opinion, if there are any errors let me know and I’ll put in a correction.

feedback, errata, insults:

Latest Version: 1.1
Browse the Javadoc

NordScreen is a screen class that behaves the same way as MainScreen but has some added functionality, it includes the transition behavior described in the BlackBerryTransitionScreen class post (for the OS5.0 version of the library) and also the Loading popup described in the Loading class for BlackBerry post.

NordFieldManager is similar to the EyelidFieldManager new to OS5.0 but allows greater control over the behavior of the top and bottom managers. It also adds the ability to add fields into a standard VerticalFieldManager as well as using absolute coordinates. In addition it enables developers to have the same behavior as the EyelidFieldManager on pre-OS5.0 devices (although the transparancy on the animated VerticalFieldManagers is lost).

SpacerField is similar to the native SeparatorField but is a little more versatile and allows you set the color, height and width with various constructors. Is useful for padding and laying out screens.

CuteLabel is a fantastic little field for creating header sections and clickable labels. You can have an icon aligned to the left or right and control all aspects of the look n’ feel.

We’ll add more to this post as new features are added.

Use of the library is subject to a CreativeCommons Licence, you are free to use the library in commercial works but must include a notification giving attribution to naviina – this can be as simple as a LabelField on your ‘about screen’ saying something similar to:

This product uses the NordvästLibrary from naviina.eu

1.1 Download here – added SpacerField and CuteLabel classes.

1.0 Download the early first release here.

Please mail roygbiv at the address below with any issues.

feedback, errata, insults:

Usage – extend TransitionScreen and pass one of the 5 transition type constants to the super class:

import net.rim.device.api.ui.TransitionContext;
 
public class MyScreen extends TransitionScreen{
 
    public MyScreen(){
        super(TransitionContext.TRANSITION_FADE);
        setTitle("My Screen");
    }
}

and the class source:

import net.rim.device.api.ui.TransitionContext;
import net.rim.device.api.ui.Ui;
import net.rim.device.api.ui.UiEngineInstance;
import net.rim.device.api.ui.container.MainScreen;
 
public class TransitionScreen extends MainScreen {
 
    public TransitionScreen(int transitionType) {
        attachTransition(transitionType);
    }
 
    //second constructor for passing styles to MainScreen superclass 
    public TransitionScreen(int transitionType, long mainscreenStyle) {
        super(mainscreenStyle);
        attachTransition(transitionType);
    }
 
    private void attachTransition(int transitionType) {
        UiEngineInstance engine = Ui.getUiEngineInstance();
        TransitionContext pushAction = null;
        TransitionContext popAction = null;
 
        switch (transitionType) {
            case TransitionContext.TRANSITION_FADE:
                pushAction = new TransitionContext(TransitionContext.TRANSITION_FADE);
                popAction = new TransitionContext(TransitionContext.TRANSITION_FADE);
 
                pushAction.setIntAttribute(TransitionContext.ATTR_DURATION, 750);
                popAction.setIntAttribute(TransitionContext.ATTR_DURATION, 750);
                break;
            case TransitionContext.TRANSITION_NONE:
                pushAction = new TransitionContext(TransitionContext.TRANSITION_NONE);
                popAction = new TransitionContext(TransitionContext.TRANSITION_NONE);
                break;
            case TransitionContext.TRANSITION_SLIDE:
                pushAction = new TransitionContext(TransitionContext.TRANSITION_SLIDE);
                popAction = new TransitionContext(TransitionContext.TRANSITION_SLIDE);
 
                pushAction.setIntAttribute(TransitionContext.ATTR_DURATION, 750);
                pushAction.setIntAttribute(TransitionContext.ATTR_DIRECTION, TransitionContext.DIRECTION_LEFT);
 
                popAction.setIntAttribute(TransitionContext.ATTR_DURATION, 750);
                popAction.setIntAttribute(TransitionContext.ATTR_DIRECTION, TransitionContext.DIRECTION_RIGHT);
                break;
            case TransitionContext.TRANSITION_WIPE:
                pushAction = new TransitionContext(TransitionContext.TRANSITION_WIPE);
                popAction = new TransitionContext(TransitionContext.TRANSITION_WIPE);
                break;
            case TransitionContext.TRANSITION_ZOOM:
                pushAction = new TransitionContext(TransitionContext.TRANSITION_ZOOM);
                popAction = new TransitionContext(TransitionContext.TRANSITION_ZOOM);
                break;
            default:
                pushAction = new TransitionContext(TransitionContext.TRANSITION_NONE);
                popAction = new TransitionContext(TransitionContext.TRANSITION_NONE);
        }
        engine.setTransition(null, this, UiEngineInstance.TRIGGER_PUSH, pushAction);
        engine.setTransition(this, null, UiEngineInstance.TRIGGER_POP, popAction);
    }
}

In the above code I’ve customized the values for the SLIDE and FADE transition, I’m not a fan of WIPE and ZOOM so I’ve left the default behavior intact as they won’t get used. In all other respects this class behaves the same as MainScreen so just use it in the same way as normal.

feedback, errata, insults:

You can now add seperators between groups of tests and different test classes. I’ve also added a couple of convenience tests for ‘greater than’ and ‘less than’ (integer only).

Illustrating adding a display separator as seen in above screenshot:

public class DemoAppTests {
 
    public DemoAppTests() {
    }
 
    public void runTests() throws AssertionFailedException {
        Assertion.addSeparator("Config Tests");
        testSetUsername();
        testPasswordsMatch();
        testIncorrectPassword();
        testNewPassword();
        Assertion.addSeparator("Network Tests");
        testCanPing();
        testCanDownload();
        testConfigSax();
        testIconDownload();
        testGetRequest();
        testPostRequest();
    }
    ...

The name-spacing has also been tidied up:

com.naviina.bunit – Contains display screen and test runner class
com.naviina.bunit.jmunit – All the ported JMUnit source plus some BlackBerry specific logic/fields
com.naviina.bunit.resources – couple of images (thanks to famfamfam)
com.naviina.bunit.tests – Where you keep your tests

If you have a large number of tests you may want to thread the logic and/or bypass the ui and write directly to System.out instead – the source is easily hackable. If you’re using it as-is you just need to add your test class to the tests package then add a call to it in the RunTests() method of TestRunner.java (you can also add multiple test classes to keep things manageable). Download a beta version here, it includes the demo tests shown above, I’ll review the codebase and make sure the correct GNU notifications are in place before I figure out the SourceForge repository again (it’s been a while). If you use this please let me know, I’ve been finding out lately that lots of people have been using the old version and I had no idea.

feedback, errata, insults:

First create your app and push a homescreen to start on:

import net.rim.device.api.ui.UiApplication;
 
public class ScreenTransitions extends UiApplication{
    ScreenTransitions app = this;
 
    public static void main(String[] args){
        new ScreenTransitions().enterEventDispatcher();
    }
 
    public ScreenTransitions(){
        pushScreen(new HomeScreen(app));
    }
}

The homescreen class including the procedure to attach the transition to the target screen:

import net.rim.device.api.ui.Field;
import net.rim.device.api.ui.FieldChangeListener;
import net.rim.device.api.ui.component.ButtonField;
import net.rim.device.api.ui.container.MainScreen;
import net.rim.device.api.ui.*;
import net.rim.device.api.ui.container.*;
import net.rim.device.api.ui.component.*;
 
class HomeScreen extends MainScreen implements FieldChangeListener {
    ScreenTransitions app;
    ButtonField nextButton = new ButtonField("Next Screen", ButtonField.CONSUME_CLICK);
 
    public HomeScreen(ScreenTransitions app){
        setTitle("Home Screen");
        this.app = app;
        nextButton.setChangeListener(this);
        add(nextButton);
    }
 
    public void fieldChanged(Field field, int context) {
        if (field == nextButton) {
            ContentScreen contentScreen = new ContentScreen();
            UiEngineInstance engine = Ui.getUiEngineInstance();
 
            TransitionContext transitionContextPush = new TransitionContext(TransitionContext.TRANSITION_SLIDE);
            transitionContextPush.setIntAttribute(TransitionContext.ATTR_DURATION, 750);
            transitionContextPush.setIntAttribute(TransitionContext.ATTR_DIRECTION, TransitionContext.DIRECTION_LEFT);
 
            TransitionContext transitionContextPop = new TransitionContext(TransitionContext.TRANSITION_SLIDE);
            transitionContextPop.setIntAttribute(TransitionContext.ATTR_DURATION, 750);
            transitionContextPop.setIntAttribute(TransitionContext.ATTR_DIRECTION, TransitionContext.DIRECTION_RIGHT);
            transitionContextPop.setIntAttribute(TransitionContext.ATTR_KIND, TransitionContext.KIND_OUT);
 
            engine.setTransition(null, contentScreen, UiEngineInstance.TRIGGER_PUSH, transitionContextPush);
            engine.setTransition(contentScreen, null, UiEngineInstance.TRIGGER_POP, transitionContextPop);
 
            app.pushScreen(contentScreen);
        }
    }
 
    public boolean onClose(){
        System.exit(0);
        return true;
    }
}

Finally, your target screen:

import net.rim.device.api.ui.container.MainScreen;
 
class ContentScreen extends MainScreen {
 
    public ContentScreen() {
        setTitle("Content Screen");
    }
}

This creates an application with a screen that scrolls in from right to left when it’s pushed and the opposite when it’s popped, you could create a custom screen that extends MainScreen with it’s own pushScreen method to hide all the UiEngine logic and keep things clean. Remember it’ll be months, maybe a year, before the majority of your users have gone through the 12-18 month upgrade cycle and will have access to the new features introduced in OS 5.0.

A really nice cross-fade effect is possible by swapping out the TransitionContext code in the example above with:

TransitionContext transitionContextIn = new TransitionContext(TransitionContext.TRANSITION_FADE);
transitionContextIn.setIntAttribute(TransitionContext.ATTR_DURATION, 750);
 
TransitionContext transitionContextOut = new TransitionContext(TransitionContext.TRANSITION_FADE);
transitionContextOut.setIntAttribute(TransitionContext.ATTR_DURATION, 750);

Setting the ATTR_KIND value is supposed to indicate which way an effect works, a fade effect with ATTR_KIND of KIND_IN would change the opacity from 0% to 100% while KIND_OUT would reverse the effect from 100% to 0%.

feedback, errata, insults: