Android - Return boolean value from within a Thread

Question

Im trying to return a boolean value from a runnable method within a Thread. I need to know whether a HTTPRequest method succeeded or not. The problem is I know the request is successful but I always get false as the response.

public boolean SmsDelivery;

SmsDelivery=sendSMS(prefix, number);

 if(SmsDelivery){
    //Do stuff
}
//The method itself
    private boolean sendSMSinThread(final String str){
        final AtomicBoolean b = new AtomicBoolean(false);
        Thread thread = new Thread(new Runnable(){

            HttpClient httpclient = new DefaultHttpClient();
            HttpPost httppost = new HttpPost(str);
            @Override
            public void run() {
                try {
                    // Execute HTTP Post Request
                    //HttpResponse response = httpclient.execute(httppost);
                    httpclient.execute(httppost);
                    b.set(true);
                } catch (ClientProtocolException e) {
                    // TODO Auto-generated catch block
                    Log.e("Thread:","Unable to generate call"+e);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    Log.e("Thread:","Unable to generate call"+e);
                }
            }
        });
        thread.start();
        return b.get();
    }

UPDATE

Based on the advices here i managed to get the desired result, however, I dont know which method is more suitable for my needs. Can someone recommend whats the best usage in my case? Using AsyncTask or a Thread + join method.
First method is using AsyncTask in the following manner:

SmsTask smsTask = new SmsTask();
        try{
            smsResult = smsTask.execute(urlString).get();
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (ExecutionException e){
            e.printStackTrace();
        }

//the class itself
     class SmsTask extends AsyncTask<String,Void, Boolean> {
         final AtomicBoolean b = new AtomicBoolean(false);

        @Override
        protected Boolean doInBackground(String... params) {
            HttpClient httpclient = new DefaultHttpClient();
            HttpPost httppost = new HttpPost(params[0]);

            try {
                httpclient.execute(httppost);
                b.set(true);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return b.get();
        }

        @Override
        protected void onPostExecute(Boolean result) {
            // result holds what you return from doInBackground
            Log.i("result from async: ",""+result);
            super.onPostExecute(result);
        }
    }

Second method, almost as I initially posted but with the 'thread.join()' method:

thread.start();
try {
    thread.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}
return b.get();

Answer 1

You should wait until task will be performed. In this case you should run this code in single thread (new Thread is useless) or use Android's AsyncTask-like class and process result in onPostExecute method.

Answer 2

You could use some Observer pattern or something.

Something like this:

// have a custom Runnable

public class HTTPRequestRunnable implements Runnable {

    HttpClient httpclient;
    HttpPost httppost;
    private HTTPRequestListner listner;

    public HTTPRequestRunnable(String str, HTTPRequestListner listner) {
        httpclient = new DefaultHttpClient();
        httppost = new HttpPost(str);
        this.listner = listner;

    }
    @Override
    public void run() {
        try {
            // Execute HTTP Post Request
            //HttpResponse response = httpclient.execute(httppost);
            httpclient.execute(httppost);
            if (listner != null)
                listner.onSuccess();
        } catch (ClientProtocolException e) {
            if (listner != null)
                listner.onFail();
            Log.e("Thread:", "Unable to generate call" + e);
        } catch (IOException e) {
            if (listner != null)
                listner.onFail();
            e.printStackTrace();
            Log.e("Thread:", "Unable to generate call" + e);
        }
    }


    public void setListner(HTTPRequestListner listner) {
        this.listner = listner;
    }
    /**
     * here is your observer class
     */

    public interface HTTPRequestListner {

        void onSuccess();

        void onFail();
    }
}

Then use it like this in your method:

public void sendSMSinThread(final String str){

        HTTPRequestRunnable httpRequestRunnable = new HTTPRequestRunnable(str,new HTTPRequestListner() {
            @Override
            public void onSuccess() {
                //DO your logic here on success
            }

            @Override
            public void onFail() {
               //DO your logic here on fail
            }
        });

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

Here you go and i hope it will help you

Answer 3

There are multiple ways to achieve this.

1. Use a callable, instead of runnable, as callable's call method can return result

2. Stick to your approach, but before returning the result, call thread.join()

   thread.start();
   thread.join();
   return b.get();
   

   Drawbacks

   If there are thousands of SMS to be sent, it will create those many threads. There is no use of thread creation here as you can the incoming thread itself to send SMS.

3. Use Runnable and Future.

   a. For each SMS create a SendSms object,

   b. It will create a maximum of 10 threads.

   c. The send SMS and getSMSdelivery will be synchronous events. So for each SMS sent, you can get the delivery status if that's your requirement.

   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   import java.util.concurrent.Future;
   
   public class SendSms 
   {
       private static ExecutorService pool = Executors.newFixedThreadPool(10);
   
      public boolean submitSms(String message,String phNo)
      {        
         Runnable run = new SendSMSThread(message,phNo);
         Future future = pool.submit(run);
         try {
             if(null ==future.get())
             {
                 return true;
             }
         } catch (InterruptedException | ExecutionException e) {
             // SMS Sending failed.
             e.printStackTrace();
            return false;
         }
       return false;
       }
   
      private class SendSMSThread implements Runnable
      {
          String message;
          String phNo;
          public SendSMSThread(String message,String phNo)
          {
              this.message = message;
              this.phNo = phNo;
          }
          public void run()
          {
              //Send SMS
          }
       }
   }
   

4. All the above three solution are blocking. So it will keep the threads in BLOCKING state, thereby posing significant threat to scalability of system.

   a. Use a BlockingQueue.

   b. For each SMS request, add a SMSObject to BlockingQueue.

   c. Use a threadpool and process the objects in Queue.

   d. Once the SMS is sent successfully, save the result to another data-structure.

   e. Use a threadpool, read the data from above data-structure and notify about successful SMS delivery.

Answer 4

Try this

thread.start();
thread.join();
return b.get();