How to return calculations made in Service for activity? [duplicate]

Your activity needs to wait for the result to be ready, and the service needs to notify the activity when the calculation is complete. To do this, he needs to keep a reference of the activity, so he can know who he will warn. The way to do this is to register the activity as a service listener (default Observer ).

First, create the following interface:

public interface ReceptorDeResultado {
    public void receberResultado(double resultado);
}

Then, create an mListener attribute on the service that implements this interface (for information only, the letter m in the name is to differentiate from local variables. mListener is a member of the Service class - in this case, an instance variable):

private ReceptorDeResultado mListener = null;

Then modify the LocalBinder class to support registration and removal of the listener:

public class LocalBinder extends Binder{

    public Valores getService(){
        return Service.this;
    }

    public void registerListener(ReceptorDeResultado listener) {
        Service.this.mListener = listener;
    }

    public void unregisterListener() {
        Service.this.mListener = null;
    }
}

Now, make MainActivity implement the ResultReceiver interface:

public class MainActivity extends ActionBarActivity
        implements ServiceConnection, ReceptorDeResultado {

Because the MainActivity class now implements the ResultReceiver interface, it is required to have a getResult () method:

public void receberResultado() {
    // Neste método você faz uso do resultado, por exemplo exibindo-o
    // na tela. O código para fazer isso eu deixo por sua conta.
}

Now let's put into use the preparations we have made. But before that, in the MainActivity class, you need to make the binder variable an instance variable and not a local variable. So declare it along with the other instance variables:

private LocalBinder mBinder = null;

and correct its use in the onServiceConnected () method:

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    // TODO Auto-generated method stub
    mBinder = (LocalBinder) service;
}

Now let's go. Respecting the activity life cycle and avoiding memory leaks, we will register the activity as service listener and cancel this activity when the activity is destroyed. So in the same onServiceConnected () method we just moved:

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    LocalBinder binder = (LocalBinder) service;
    binder.registerListener(MainActivity.this);
}

Removing the listener in the onPause method (create this method in the MainActivity class):

@Override
public void onPause() {
    super.onPause();
    if (binder != null) {
        binder.unregisterListener();
    }
}

Registering the listener again in the onResume method, in case the activity has been destroyed and recreated for example in case of screen rotation (create the onResume () method in the MainActivity class):

@Override
public void onResume() {
    super.onResume();
    if (binder != null) {
        binder.registerListener(this);
    }
}

Ready, the service now has a listener (or observer) to tell you when the result is ready. Let's do this in the Service class:

resultado = Double.valueOf(valor1) + Double.valueOf(valor2);
if (mListener != null) {
    mListener.receberResultado(resultado);
}

Voilà! If everything went well (I did not test the code), the service will inform the calculated result to the activity (if it is watching the service at that moment).

Now a caveat for the future. For more time-consuming calculations, you will need your Service to perform this calculation on a separate thread (today it runs on the main thread and only allows fast calculations, which do not cause blocking of the main thread). The easiest way to allow this is to make your service extend the IntentService class and not android.app.Service. This is because IntentService executes commands on a separate thread by default. So, when you're implementing your most time-consuming calculations, study IntentService .

The problem you are having is because you are recovering the values before the onStartCommand has ended, so the values were not calculated because the calculation is asynchronous.

My suggestion is to use a BroadcastReceiver local, without exposing private data outside of your application.

Remembering that you need to declare the dependency in the support library v4, if you can not, use BroadcastManager, but then it will be global.

My Service example that uses LocalBroadcastManager to notify the termination of an asynchronous job:

public class TheService extends Service {

    public static final String BROADCAST_FILTER = "the_service_broadcast";
    public static final String PARAMETER_EXTRA_KEY = "the_service_key";

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        int result = super.onStartCommand(intent, flags, startId);

        new Thread() {
            @Override
            public void run() {
                try {
                    // Doing Heavy Work...
                    Thread.sleep(TimeUnit.SECONDS.toMillis(5));
                    broadcast(true);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    broadcast(false);
                }
            }
        }.start();

        return result;
    }

    void broadcast(boolean success) {
        LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(BROADCAST_FILTER).putExtra(PARAMETER_EXTRA_KEY, success));
    }
}

Example of Activity that registers a BroadcastReceiver for the broadcast of Service :

public class MainActivity extends Activity {

    // BroadcastReceiver responsavel por escutar o broadcast do Service
    BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context, "Broadcast from TheService(" + intent.getBooleanExtra(TheService.PARAMETER_EXTRA_KEY, false) + ")", Toast.LENGTH_LONG).show();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Todo seu codigo de inicializacao...
        startTheService();
    }

    @Override
    public void onResume() {
        super.onResume();

        // Registra o BroadcastReceiver para escutar por broadcast's do Service.
        LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver, new IntentFilter(TheService.BROADCAST_FILTER));
    }

    @Override
    public void onPause() {
        super.onPause();

        // Remove o Receiver quando a Activity for pausada.
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver);
    }

    private void startTheService() {
        // Inicia o servico
        startService(new Intent(this, TheService.class));
    }
}

I recommend using onPause to remove (avoid leaks from memory) and onResume to register. If your Activity is placed in background the BroadcastReceiver will be removed and if Activity returns to foreground BroadcastReceiver will be re-registered.

If you need the result even though Activity is not visible, then I recommend removing only the onStop or onDestroy . It would be valid to save the result, but it is not recommended to change the View's in these cases.