Creating a callback on a class method

Question

I'm struggling with a network connection class I've created. The result of the Runnable I create returns a JSON object that contains all the information needed from the server. The thread runs, and receives the data perfectly, but of course, the program keeps running in the meantime, which results in a JSONException as being NULL.

I created a class called NetworkManager, which has the following method (jsonResponse is initialized at the beginning of the class)

JSONObject jsonResponse;

public void createNetworkThread(Context context, final String requestURI, final RequestBody formParameters) {

    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder().url(requestURI).post(formParameters).build();

            Response response = null;

            try {
                response = client.newCall(request).execute();
                String stringResponse = response.body().string();
                NetworkManager.this.jsonResponse =  new JSONObject(stringResponse);

                // This works perfectly, "message" is received and printed to the log //
                Log.d("Net", NetworkManager.this.jsonResponse.getString("message"));

            } catch (IOException e) {
                Log.d("Net", "Failed");
                e.printStackTrace();
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    };

    Thread thread = new Thread(runnable);
    thread.start();
}

The above is called from the Activity, as:

Net.createNetworkThread(SignupActivity.this, requestURI, formVars);
JSONObject jsonResponse = Net.jsonResponse;

The JSON object jsonResponse is returning as NULL because the Thread is still accessing the server for the response.

I need to figure out how to stop the jsonResponse Object from being populated by Net.jsonResponse until the thread completes in order to stop it from returning NULL.

Any help?

Answer 1

If you want to offload the main thread, you should consider that the parallel task could finish it's execution after, generally speaking, any amount of time. Sure, you can wait in the main thread for the child thread to finish (using 'join()'), though this is kind of questionable in terms of speed gain.

Anyway, answering your question:

I need to figure out how to stop the jsonResponse Object from being populated by Net.jsonResponse until the thread completes in order to stop it from returning NULL.

I suggest you change

public void createNetworkThread(...

to

public Thread createNetworkThread(...
{
...
    Thread thread = new Thread(runnable);
    thread.start();
    return thread;
}

And consequently

Thread t = Net.createNetworkThread(SignupActivity.this, requestURI, formVars);
t.join(); // Wait until 't' finishes -- try-catch is omitted for the sake of demo.
JSONObject jsonResponse = Net.jsonResponse;

This, apparently, opens question of performance, since main thread will be effectively completely blocked by 't.join()' until the child thread will finish.

Answering the question in the topic: in Java 8 you can use lambda functional interface like this:

package multithreaded;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Multithreaded {

    public static void main(String[] args) throws Exception {
        Logger logger = LoggerFactory.getLogger("Main");

        Worker<String, String> worker = new Worker<String, String>(
             (String s) ->
             { // This is actual call-back code. 
               // It will be called by method 'apply' of interface 'Function' in the 'Worker'. 
               // It will accept String parameter and pass it in this block as variable 's'
                 logger.info("Embrace the beauty and power of Java 8! "+s); // yes, we can use local variables of the parent thread.
                 return "Call-Back "+s;
             }
        );

        logger.info("Application starts new Worker.");
        worker.start();
        logger.info("Worker is running in background.");

        Thread.currentThread().sleep(500); // Simulate some activity here...
        logger.info("Result is unpredictable (could be null): "+worker.getResult());

        // Wait here until worker is fully finished
        worker.join();
        logger.info("Result is predictable: "+worker.getResult());
    } 
}

Worker.java:

package multithreaded;

import java.util.function.Function;

public class Worker<T extends String, R extends String> extends Thread {

    private final Function<T, R> callBack;
    private volatile R result;

    public Worker(Function<T, R> callBack)
    { this.callBack = callBack; }

    @Override
    public void run()
    {
        try{
            int i = (int)(Math.random()*1000);
            // simulate some activity unpredictable in terms of duration
            Thread.currentThread().sleep(i);

            // After "activity" is finished -- call the call-back function and get result in local variable.
            // (Synchronization ommited for the sake of simplicity)
            result = this.callBack.apply((T)("Result "+i)); // now let's call the call-back function and save the result in local variable.
        }
        catch(InterruptedException e)
        {e.printStackTrace();}
    }

    // Getter for the local variable, populated by call-back function.
    // (Synchronization ommited for the sake of simplicity)
    public R getResult()
    { return this.result; }
}

Running above code multiple times, you will notice that from the parent thread's perspective the result is still unpredictable until the child thread is completely finished.

P.s. I suggest you re-think entire logic of data processing in your app and consider re-factoring towards entirely independent multi-threaded processing (perhaps using producer-consumer logic).

Answer 2

I would only agree to the comments on your question and let you know, what you can do here.

If you are creating a thread just to get of the main UI thread to do the Network call you probably want to use OkHttp feature which allows you to get the Network call off the thread and provides you with callbacks to get the result something like this. you can check some example here

Request request = new Request.Builder()
            .url(url)
            .build();

    client.newCall(request).enqueue(new Callback() {
        @Override
        public void onFailure(Request request, IOException e) {

        }

        @Override
        public void onResponse(Response response) throws IOException {
        // this is the callback which tells you the network call was successful, If like to make some changes to UI, you should call `runOnUiThread`.

        "YourClassName".this.runOnUiThread(new Runnable() {
                @Override
                public void run() {

                }
            });
        }
    });

or you can use AsyncTask which also gets your job done off the main UI thread and gives you the result in the callbacks.

private class MyTask extends AsyncTask<Void, Void, Void> {

//you can change the Type Void, Void, Void here to something which you want 
//First Void belongs to doInBackground(Void... avoid)
//Second Void belongs to onProgressUpdate(Void... progress) 
//Third Void belongs to onPostExecute(Void result)
// you may change these as you fit, 
//when you want to start this class with your argument you can do something like this. 
//new MyTask().execute("your argument to doInBackground");


    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    @Override
    protected Void doInBackground(Void... params) {
    // this is the method where you provide your implementation for doing a task off the main UI thread.
        return null;
    }

    @Override
    protected void onPostExecute(Void aVoid) {
        super.onPostExecute(aVoid);
    // in this callback you are back in the main UI thread to make changes to UI depending on your response 
    }
}

here is an example of AsyncTask