Question

I am new to blackberry development and I am creating a native blackberry application. On every screen of my application, I need to send and receive data to the server on the same connection.

What I have done so far is I have made a ConnectToServer class which has a bunch of methods for sending and receiving. I instantiate it on the main screen and I pass it to each screen as a parameter.

That class in not a thread because I only read and write when the user types in information and presses a button. So basically I am using the inputStream and outputStream on the event thread which I hear is BAD. Then I ask ConnectToServer to get me what the server sent. For instance, I get a vector which I use to make a ListField.

How can I make these UI updates?

public class Screen3 extends MainScreen {

  ConnectToServer con;
  Vector v;

  public Screen3(String exerciseName, ConnectToServer connect)
  {
      con = connect;
      con.send(exerciseName);
      v = con.receiveVector();

      mylist = new listField();
      mylist.setSize(v.size());
      add(mylist);
   }

   public void drawListRow(...)
   {
      graphics.drawText((String) v.elementAt(index)
   }
}

Answer 1

So, there’s many ways to approach this. First of all, since it seems like you only want one instance of ConnectToServer, and you are currently having to pass that around, you might try making that class a Singleton object. This is not necessary, and does not have anything to do with your threading problem, but I only offer it as a solution, for situations where you want to enforce that there’s only one instance of something, and want to avoid having to pass it around everywhere. A simple Singleton implementation might be this:

public class ConnectToServer {

    private static ConnectToServer _instance;

    /** use this static method to get the one and only instance */
    public static ConnectToServer getInstance() {
        if (_instance == null) {
            _instance = new ConnectToServer();
        }
        return _instance;
    }

    /** private to enforce Singleton pattern */
    private ConnectToServer() {
    }
}

And use it in your screens like this (no need to pass it into the constructor any more):

ConnectoToServer connection = ConnectToServer.getInstance();
connection.blahBlahBlah();

Now, on to the threading problem. You’re right that you should not be performing network requests on the main (aka “UI”, aka “Event”) thread. If you have a nice separate ConnectToServer class, that makes it easier to encapsulate this behaviour. Instead of UI clients using a synchronous send() and receiveVector() method, make one method that just kicks off the request, and another callback method that the ConnectToServer class will call when the response comes back. The ConnectToServer class will use a Thread to perform this work, and thus avoid freezing the UI during the request.

I’ll define an interface that the UI clients will implement:

public interface RequestListener {

    /** listeners must implement this method to get data.  method will be called on the UI thread */
    void onDataReceived(Vector response);
}

And then the new (partial) ConnectToServer class:

public class ConnectToServer {
    private Thread _worker;
    private RequestListener _listener;

    public void setRequestListener(RequestListener listener) {
        // note: this implementation only allows one listener at once.  
        //  make it a list if you need something more
        _listener = listener;
    }

    /** initiate a network request on a background thread */
    public void sendRequest(final String request) {
        _worker = new Thread(new Runnable() {
            public void run() {    // run on the background/worker thread
                send(request);

                final Vector response = receiveVector();

                if (_listener != null) {
                    // this assumes all our listeners are UI objects, so we pass 
                    //   data back to them  on the UI thread:
                    UiApplication.getUiApplication().invokeLater(new Runnable() {
                        public void run() {    // run on UI thread                
                            _listener.onDataReceived(response);
                        }
                    });
                }
            }
        });

        _worker.start();
    }
}

Note that you should also make your original send() and receiveVector() methods in this class private. They should only be called from inside the class now, not directly from UI clients.

Then, you need to code your Screen classes like this:

public class Screen3 extends MainScreen implements RequestListener {

    public Screen3(String exerciseName) {
        ConnectToServer connection = ConnectToServer.getInstance();
        connection.setRequestListener(this);
        // kick off the request (on a background thread)
        connection.sendRequest(exerciseName);
    }

    public void onDataReceived(Vector response) {
         if (mylist == null) {
             // first time data has been received, so create and add the list field:
             mylist = new listField();            
             add(mylist);
         }
         mylist.setSize(response.size());
         // TODO: presumably, you would copy the contents of 'response' into 'mylist' here  
    }
}

Also, you might also want to code the server class to protect against multiple UI clients making concurrent requests, allow current requests to be cancelled, etc. But the above should get you started on a solution that provides a responsive app, without freezing your UI.