Activity to Activity communication without finish

Question

I have two activities: one is the main (A), and the second one which is started from A (B). I start B with startActivityForResult(intent, id).

I know I can send the result back to A via the setResult() method, but as far as I know, the result isn't sent until finish() is called. I need to send data from B to A without closing B (even several times before closing). Is there a way to achieve that?

As far as I've read, there are not many options to achieve this. I could use SharedPreferences but then I'd need also some kind of event to inform A that it has to read a value!

Any ideas appreciated.

------ FINAL SOLUTION ------

Finally I got it thanks to @Nathaniel Waggoner's advice. Here's what I did:

Inside my activity I declared the extension of BroadcastReceiver:

class ActivityBroadcast extends BroadcastReceiver {
  @Override
  public void onReceive(final Context context, final Intent intent) {
    final String txt2send = intent.getStringExtra("txt2send");
    if ((txt2send != null) && (!txt2send.isEmpty())) {
      // Do the needed stuff
      ...
    }
  }
}

So now I declared the ActivityBroadcast instance in my class and initialized it:

private static ActivityBroadcast broadcast_signal;
broadcast_signal = new ActivityBroadcast();

The way I control that it's just my Intent the one who triggers the onReceive method is with an IntentFilter set to the SENDTXT2SOCK customized action, this way:

// CustomActions.SENDJOIN2CHAN is just a constant from a customized public class
// where I define my own constants to not interfere with the "official" ones
registerReceiver(broadcast_signal, new IntentFilter(CustomActions.SENDTXT2SOCK));

This way I'm saying that on broadcast_signal will just be registered the CustomActions.SENDTXT2SOCK action, so any other is ignored. Now we just have to send a signal from the desired activity to that receiver:

final Intent intentResult = new Intent(CustomActions.SENDTXT2SOCK);
intentResult.putExtra("txt2send", "blabla");
sendBroadcast(intentResult);

And that's all, works like a charm!

Answer 1

Use broadcasts and intents.

Broadcast Receivers:

http://developer.android.com/reference/android/content/BroadcastReceiver.html

Answer 2

You can also give a shot to OnsharedPreferenceChangelistner

Answer 3

you can use eventBus simple library.
first register eventbus in receiver activity

   @Override
    public void onStart() {
       super.onStart();
     EventBus.getDefault().register(this);
    } 

then set a subscriber method

@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) {/* Do something */};

then in other activity post your entity like this

EventBus.getDefault().post(new MessageEvent());

Answer 4

You can use broadcasts and observers to call a method of one activity from another activity. You will use an intent to call a broadcast from activity B, and then you will use an observer to call a method in activity A from the broadcast.

For example, if you want to call ActivityA.someMethod from ActivityB, you can do the following (don't forget implements Observer on ActivityA):

public class ActivityA extends AppCompatActivity implements Observer{
    //This is the method you want to call from ActivityB
    public void someMethod(Intent intent){
        //intent will be the Intent object created in ActivityB, you can pass data to this method by setting extras in the intent
    }

    //Define the observer and broadcast receiver classes
    private static class MyObservable extends Observable{
        private static final MyObservable instance = new MyObservable();
        public void updateValue(Object data){
            synchronized(this){
                setChanged();
                notifyObservers(data);    //This method calls ActivityA.update
            }
        }
    }

    public static class MyBroadcastReceiver extends BroadcastReceiver{
        //This class must be public and static and must be added to the manifest
        //To add this class to the manifest in Android Studio put the cursor on the name of the class, press Alt+Enter and choose "Add to manifest"
        @Override
        public void onReceive(Context context, Intent intent){    //This method will be called when the broadcast is sent from ActivityB
            MyObservable.instance.updateValue(intent);
        }
    }

    //Connect the observer to the activity in the onCreate method
    @Override
    protected void onCreate(Bundle savedInstanceState){
        MyObservable.instance.addObserver(this);
        //Do everything else in onCreate as usual
    }

    //This method will be called when the notifyObservers method is called from the oberver
    @Override
    public void update(Observable observable, Object data){
        this.someMethod((Intent) data);    //Call the method that you need
    }
}

public class ActivityB extends AppCompatActivity{
    public void callSomeMethodOnActivityB(){
        Intent intent = new Intent(this, ActivityA.MyBroadcastReceiver.class);
        //Add some extras to the intent to pass data
        sendBroadcast(intent);    //Calls ActivityA.MyBroadcastReceiver.onReceive
    }
}

Most of this answer is based on ilw's answer to "Communication between BroadcastReceiver and Activity", credits to them.