• - 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.0
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).

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

Download the early first release here and 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:

You can inject your applications directly onto a device using the Javaloader.exe utility that comes with the Rim JDE, create a .bat file called LoadMyApp.bat and use the following syntax:

@ECHO ON
"C:\Program Files\Research In Motion\BlackBerry JDE 4.7.0\bin\javaloader" -usb load "C:\pathtoprojectdirectory\MyApp.cod"
PAUSE
EXIT


Connect your BlackBerry via USB, build and code-sign the application, run the batch file and you should be testing on-device within 15 seconds.

feedback, errata, insults:

// ==UserScript==
// @name           Naviina flickrCleanr
// @namespace   com.naviina.greasemonkey.flickr.uicleaner
// @description   Get rid of the new Yahoo! logo addition.
// @include         http://*.flickr.com
// ==/UserScript==
 
var logo = document.getElementById("FlickrLogo");
logo.src = "http://farm4.static.flickr.com/3107/2910970627_96ffdd6094_t.jpg";
logo.width = 100;
logo.height = 25;

feedback, errata, insults:

To use the class, extend SplashScreen and pass the image and the seconds to display into the super class:

package com.naviina.splashscreen;
 
import net.rim.device.api.system.Bitmap;
import net.rim.device.api.ui.component.LabelField;
 
public class WelcomeScreen extends SplashScreen {
 
    public WelcomeScreen() {
        super(Bitmap.getBitmapResource("thepopup.png"), 5);
        //normal mainscreen items:
        setTitle("SplashScreen Test");
        add(new LabelField("HelloWorld!"));
    }
}

and the class itself:

package com.naviina.splashscreen;
 
import java.util.Timer;
import java.util.TimerTask;
import net.rim.device.api.system.Bitmap;
import net.rim.device.api.system.Display;
import net.rim.device.api.ui.Graphics;
import net.rim.device.api.ui.container.MainScreen;
 
public class SplashScreen extends MainScreen {
 
    Bitmap popup;
    SplashScreen screen = this;
    private Timer splashTimer = new Timer();
    private TimerTask splashTask;
    int count = 0;
    int screenWidth = Display.getWidth();
    int screenHeight = Display.getHeight();
    int yCoord;
    int xCoord;
    boolean showSplash = true;
    boolean splashDisplayed = false;
 
    public SplashScreen(Bitmap popup, final int seconds) {
        this.popup = popup;
        xCoord = (screenWidth - popup.getWidth()) / 2;
        yCoord = (screenHeight - popup.getHeight()) / 2;
 
        splashTask = new TimerTask() {
 
            public void run() {
                if (showSplash && !splashDisplayed) {
                    count++;
                    if (count == seconds * 10) {
                        showSplash = false;
                        splashDisplayed = true;
                        splashTimer.cancel();
                        invalidate();
                    }
                }
            }
        };
 
        splashTimer.scheduleAtFixedRate(splashTask, 100, 100);
 
    }
 
    protected void paint(Graphics graphics) {
        super.paint(graphics);
        if (showSplash && !splashDisplayed) {
            graphics.drawBitmap(xCoord, yCoord, popup.getWidth(), popup.getHeight(), popup, 0, 0);
            //draw border, delete if not needed:
            //graphics.setColor(0xcccccc);
            //graphics.drawRect(xCoord, yCoord, popup.getWidth(), popup.getHeight());
        }
    }
 
    protected void onUiEngineAttached(boolean attached) {
        showSplash = true;
        invalidate();
        super.onUiEngineAttached(attached);
    }
 
    //allow user to dismiss splash screen:
    protected boolean navigationMovement(int dx, int dy, int status, int time) {
        return DismissSplash();
    }
 
    protected boolean navigationClick(int status, int time) {
        return DismissSplash();
    }
 
    protected boolean keyChar(char c, int status, int time) {
        return DismissSplash();
    }
 
    private boolean DismissSplash() {
        if (showSplash) {
            showSplash = false;
            splashDisplayed = true;
            invalidate();
            return true;
        }else{
            return false;
        }
    }
}

The use of two booleans might seem unnecessary at first but they’re in place to make sure the introduction popup only displays the first time the screen is pushed onto the display stack and not when subsequent screens are popped. The splashTimer.cancel(); would take care of that but the logic is left in place to ease a super-screen class combining elements of the Tooltip and Loader classes mentioned above.

feedback, errata, insults:

It seems like there are thousands of Twitter apps for BlackBerry but they’re all too fussy and complex (and usually slow), if you set LittleChirp to launch via one of the side convenience keys on your BlackBerry it’s by far the quickest way to post a tweet.

For this and future products we’ve created the Mobikraft brand to separate the consumer side of things from the solutions/enterprise parent Naviina, we’re building the Mobikraft site at the moment and should have it ready within a week, check back for some more official release information.

Unfortunately LittleChirp won’t run on touchscreen BlackBerry’s due to a buggy native API which doesn’t reliably show the on-screen keyboard when there’s an EditField displayed in a modal Popup, AppWorld does have a nice mechanism for packaging many builds for different devices and OS versions though so we’ll try and create a custom version of the app sometime soon. Some older devices may not show the widget correctly; LittleChirp functions fine but has a white background rather than floating over the homescreen as above, we’ve only seen this happen on an older Pearl flip and if we can fix the issue it’ll appear as a free upgrade.

feedback, errata, insults: