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?

You should read the OKHttp docs ... there is already async version of Call.execute with callback (remeber that callback is called on background thread, too) github.com/square/okhttp/wiki/Recipes#asynchronous-get — Selvin
– Selvin, Commented May 10, 2016 at 14:05
you should use an AsyncTask, developer.android.com/reference/android/os/AsyncTask.html - and read up a bit on threading in general — anders
– anders, Commented May 10, 2016 at 14:08
The thread runs asynchronously, you cannot demand the result in the next statement, use AsyncTask instead — Pooya
– Pooya, Commented May 10, 2016 at 14:30

Community · Accepted Answer · 2017-05-23 11:52:37Z

1

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

edited May 23, 2017 at 11:52

CommunityBot

11 silver badge

answered May 10, 2016 at 14:21

Pankaj Nimgade

4,5493 gold badges24 silver badges30 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

mwieczorek Over a year ago

Thanks. I've read up on AsyncTask, but I'm getting more questions than answers. How do I pass arguments to it?

Pankaj Nimgade Over a year ago

I have updated the answer, new MyTask().execute("your argument to doInBackground");

Andrey Lebedenko · Accepted Answer · 2016-05-10 18:59:57Z

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

Collectives™ on Stack Overflow

Creating a callback on a class method

2 Answers 2

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related