Working with threads in blackberry

Question

I am using threads in blackberry to perform web service calls. I want to get notified as soon as the call gets a response back. I was using

Handlers

in android. I didnt find anything similar in blackberry.

Here is the code I am using to run the thread

class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

How can I get a notification after the thread finished running? How can I do this in blackberry? Thanks

Added more Information : Thanks for your reply. Its really informative. Let me explain a bit more on my issue. I have a webservice call which is running on a thread. As soon as I get the reply back from server I want to execute the next function(next call to server) which is based on the response from the previous call.So I need to wait until I get a response back. Also at them same time I need to show a activity indicator on screen. I was using handler for this in android. I am looking for something similar on blackberry.

Answer 1

Android has a much rich multi threading primitives. But you can achieve the same even in Blackberry with equal elegance. The solution I provide below is essentially the same as previous, but with a minor change. Waiter thread can be replaced with built-in utility to perform painting on UI thread using UiApplicaiton's invokeLater method. You don't actually need to "notify" anyone but just update the UI once a particular task is completed. Check the docs for more info.

Anyway, you can model your code along the lines:

class ProgressScreen extends FullScreen
{
    LabelField _label;
    public void start()
    {
    }
    public void setMessage( final String message )
    {
    UiApplication.getApplication( 
            UiApplication.invokeLater( 
                new Runnable() {
                 _label.setText( message );
            }
        )
    );
    }

    public void dismiss()
    {
        this.close();
    }
}

interface WebserviceTask
{
    int STATUS_CONDITIONS_NOT_SATISFIED = -3;
    int STATUS_NET_ERR = -2;
    int STATUS_FAILURE = -1;
    int STATUS_SUCCESS =  0;

    public int invoke();

}

public class Updater extends Thread
{
    final int NUM_TASKS = 10;
    WebServiceTask tasks[] = new WebServiceTask[ NUM_TASKS ];
    WebServiceTask tasks[0] = new WebServiceTask(){
        public int invoke()
        {
            int retCode = 0;
            // invoke a particular web service
            return STATUS_SUCCESS;
        }
    }

    public void run()
    {
        ProgressScreen progress = new ProgressScreen();
        progress.start();
        for( int i=0; i < NUM_TASKS; i++ )
        {
            int retcode;
            WebServiceTask t = tasks[i];
            retcode = t.invoke();
            String mesg;
            switch( retcode )
            {
            case STATUS_SUCCESS: { mesg ="Task successfully completed!";} break;
            case STATUS_NET_ERR: { mesg ="Could not connect to network";} break;
            }
            progress.setMessage(message);
        }
        progress.dismiss();
    }
}

Note that I have provided only the stubs to give you an idea how you may accomplish. Let us know how it goes.

Answer 2

As I got the Zach's question - he asks how to execute some code that involves UI changes (something like showing an info popup or closing the progress popup) upon a background thread completion. On Android a Handler created on the UI thread is often used for that purpose.

In BB you can use another way which is similar to Swing on desktop Java. When you need some code to be executed on the UI thread you wrap it in a Runnable and pass to one of the following methods:

// Puts runnable object into this application's event queue, 
// and waits until it is processed.
Application.invokeAndWait(Runnable runnable)

// Puts runnable object into this application's event queue.    
Application.invokeLater(Runnable runnable)

// Puts runnable object into this application's event queue 
// for repeated execution.
Application.invokeLater(Runnable runnable, long time, boolean repeat)

So the behaviour of the above calls is similar to what Handler.post(Runnable r) (and the like) does.

Note, you can always get a handle to your Application instance by a static call Application.getApplication().

So in the end of a background thread it is safe to do something like this:

Application.getApplication().invokeLater(new Runnable() {
    public void run() {
        progressScreen.close();
        Dialog.alert("I am finished!");
    }
});

It is similar to Android's:

handler.post(new Runnable() {
    public void run() {
        progressScreen.dismiss();
        showDialog(DIALOG_TASK_FINISHED_ID);
    }
});

Answer 3

So your question essentially is this

1. One thread does the job while the other thread waits for completion
2. The first thread completes the job and "notifies" the second thread.

This is a simple producer consumer problem. Here is the code how you can solve this.

 class JobResult
{
  boolean done = false;
}

JobResult result = new JobResult();

 class Worker extends Thread
{
    JobResult _result;
    public Worker( JobResult result )
    {
        _result = result
    }
    public void run()
    {
        // Do some very long job
        synchronized( _result )
        {
            // modify result
            _result.done = true;
            _result.notify();
        }
    }
}

public class Waiter extends Thread
{
    JobResult _result;
    public Waiter( JobResult result )
    {
        _result = result;
    }
    public void run()
    {
        synchroinzed( _result ){

            while(! _result.done)
            {

                this.wait();
            }
        }
        // Wait is over. You can do something now.
    }
}