Michael Narinsky

There is a couple of things I’ve learned about BlackBerry Java development that I think might be worth sharing.

1. SQLite: Don’t use Cursor.close() – use Statement.close() instead.

It turned out that Cursor.close() method is also closing the Statement that was used to create that Cursor, even if the Statement was later reinitialized. I believe that removing Cursor.close() calls from the code helped me to avoid a couple of ‘File System Error (12)’ errors while doing some IO operations over the SQLite db file. I tend to think that ‘File System Error (12)’ error actually means ‘File is locked’ (thank you BlackBerry, btw, for such nice, self-explanatory error messages and providing no documentation about them), so now it all makes sense to me.

More info: http://supportforums.blackberry.com/t5/Java-Development/Cursor-close-closes-the-Statement-used-to-Create-It/ta-p/614699

2. Memory optimization

There is a nice blog post that provides an overview of RIM’s memory monitoring tools (Memory Statistics, Object Statistics and Objects) and gives a set of steps that should be taken in order to detect a memory leak and identify the root cause. I’ve seen this article before, but this time I’ve actually read it thoroughly (all three parts) and I think it’s very good place to start if you do a memory optimization:

http://devblog.blackberry.com/2009/10/how-to-find-that-memory-leak-part-one/

http://devblog.blackberry.com/2010/01/how-to-find-that-memory-leak-part-two-detecting-the-leak/ (you might need to tweak images’ source URLs in order to get them for this part)

http://devblog.blackberry.com/2010/03/how-to-find-that-memory-leak-part-three/

Sending an HTTP request in a separate thread is a very common operation for almost every client-server web application. The idea is to spin-off a background thread that will send a request and process the response data, but won’t block the main (GUI) thread on the same time.  At the end of its execution the background thread should use some kind of a callback mechanism to pass response results back to the main thread. Since this operation is very common I was expecting that pretty much every modern framework should have a lot of tutorials available online describing how to implement this functionality in a quick and easy way. However this was not the case for the BlackBerry Java API -  after a couple of hours researching I still didn’t find anything that was ‘quick and easy’…

Finally, looking through RIM’s API docs I found a method Application.invokeLater() which can take a runnable object defined in a background thread and start it in the main thread. This method allowed me to pass execution control back to the main thread.

Here is a sample code:

First let’s create a ConnectionThread class that can take a URL (to send a request to) and call a method of some screen once the response is received (for the sake of simplicity we’ll be calling a method of the screen that is currently on top of the screen’s stack).

public class ConnectionThread extends Thread {
	String URL;

	public ConnectionThread(String URL) {
		this.URL = URL; //URL to send a request to
	}

	public void run() {
		//optional: show some popup "Please wait screen"
		final Screen dialogScreen = new WaitPopupScreen(); //wait popup screen extends RIM's PopupScreen class
		UiApplication.getUiApplication().invokeLater(new Runnable() {
			public void run() {
				UiApplication.getUiApplication().pushModalScreen(dialogScreen);
			}
		});

		//send HTTP request and save the response
		HttpConnection connection = null;
		//use API 5.0 Connection factory class to get first available connection
		byte responseData[] = null;
		try { 
			connection = (HttpConnection) new ConnectionFactory().getConnection(URL).getConnection();
			int len = (int) connection.getLength();
			responseData = new byte[len];
			DataInputStream dis;
			dis = new DataInputStream(connection.openInputStream());
			dis.readFully(responseData);
		} catch (Exception e) {
			 // TODO Handle exception 
		} 

		final byte[] responseDataToProcess = responseData;
		//use invokeLater method to pass results back to the main thread
		UiApplication.getUiApplication().invokeLater(new Runnable() {
			public void run() {
				UiApplication.getUiApplication().popScreen(dialogScreen); //hide wait popup screen
				//pass results to the callback mathod of the current screen
				((MyScreen)UiApplication.getUiApplication().getActiveScreen()).callBackMethod(responseDataToProcess);
			}
		});
	}
}

This is the actual screen where we spin the connection thread off:

public class MyScreen extends MainScreen {
	public MyScreen() {
		super();
		// add a button that will initiate an HTTP request
		ButtonField requestButton = new ButtonField("Send HTTP Request");
		requestButton.setChangeListener(new FieldChangeListener() {
			public void fieldChanged(Field field, int context) {
				//start connectionThread on a button click
				new ConnectionThread("http://mnarinsky.com").start();
			}
		});
		add(requestButton);
	}
	
	//this method will be called from the connection thread
	public void callBackMethod(byte[] responseData){
		//process response
	}
}

Finally this is a code for an optional 'Please wait' popup screen – displays a simple “Please wait..” text. If you want you can make it little more fancy by using some animated GIF image.   

public class WaitPopupScreen extends PopupScreen {
	public WaitPopupScreen() {
		super(new VerticalFieldManager());
		LabelField labelField = new LabelField("Please wait...",
				Field.FIELD_HCENTER);
		add(labelField);
	}
}

Last month I have passed Microsoft Exam 70-515 (Web Applications Development with .NET Framework 4.0) and thus finally completed my long term project of getting a Microsoft .NET Developer Certification.

It all started in October 2009 – back then I’ve decided to pass MS Exam# 70-536 (.NET Application Development Foundation), which was a pre-requirement for all Microsoft development certifications. I’ve got a preparation book, studied it thoroughly and was ready for an exam around March 2010 - just a month before .NET 4.0 came out and Microsoft has announced a complete new set of exams targeting the updated framework. New exams became available on July 2010, but no preparation materials were released until December 2010. Around Christmas 2010 I finally got a new preparation book, spent another 2 months preparing and, voila, passed it in February 2011 – just 14 month after the start :)

Anyway, glad that this project is finally over – time to move on to the next one…