Updating Activity UI component from Broadcast Receiver?

Question

I have very basic ques. and it might be very simple but i am not getting it. I have an Activity where I am using some UI component. and I also have a broadcast receiver (registering from manifest) where I need to update some UI component of Activity class. Like -

    Class MyActivity extends Activity
     {

        onCreate(){

         //using some UI component lets say textview
           textView.setText("Some Text");
        }

       updateLayout()
       {
         textView.setText("TextView Upadated...");
       }
 }


Class broadCastReceiver
{

    onReceive()
    {
       //here I want to update My Activity component like 
       UpdateLayout();

    }

}

For that- One solution is that make the updateLayout() method public static, and use that method in receiver class by activity reference . But I think, this is not the right way to do this.. Is there any proper way to do that?

you can either subclass the broadcast receiver inside your activity, or, use the delegation pattern — Blackbelt, Jul 24 '14 at 10:58
When I subclass receiver class then I have to make it static class and again i have to create method as static.. — T_V, Jul 24 '14 at 11:00
could u please tell me something more about delegation pattern — T_V, Jul 24 '14 at 11:02
@blackbelt http://stackoverflow.com/questions/4391974/is-it-possible-to-define-a-broadcast-receiver-as-an-inner-class-in-manifest-file — T_V, Jul 24 '14 at 11:04
@blackbelt Actually broadcast should register as soon as activity app starts. And above activity open up after three activities. — T_V, Jul 24 '14 at 11:14

score 6 · Answer 1 · answered Jul 28 '14 at 05:24

Instead of registering a receiver in manifest, you can register and unregister it at runtime as follows:

Also make sure you register your receiver with correct Action in Intent Filter.

public class MyActivity extends Activity{

// used to listen for intents which are sent after a task was
// successfully processed
private BroadcastReceiver mUpdateReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        new UpdateUiTask().execute();
    }
};

@Override
public void onResume() {        
    registerReceiver(mUpdateReceiver, new IntentFilter(
            YOUR_INTENT_ACTION));
    super.onResume();
}

@Override
public void onPause() {     
    unregisterReceiver(mUpdateReceiver);
    super.onPause();
}


// used to update the UI
private class UpdateUiTask extends AsyncTask<Void, Void, String> {

    @Override
    protected void onPreExecute() {

    }

    @Override
    protected String doInBackground(Void... voids) {
        Context context = getApplicationContext();
        String result = "test";
        // Put the data obtained after background task. 
        return result;
    }

    @Override
    protected void onPostExecute(String result) {
        // TODO: UI update          
    }
}  

}

Hope it helps.

Async task is provided just in case a network call is to be made based on the result intent in onReceive(). In that case one can do that in doInBackground(). Else one can simply update the UI in postExecute(). @blackbelt ,I would definitely like to learn if anything better can be done here. Thnx. — Ritesh Gune, Aug 03 '14 at 18:01

score 4 · Accepted Answer · answered Aug 02 '14 at 08:54

If you really have to keep using BroadcastReceiver registered from AndroidManifest.xml then you could consider using event bus. There is one cool open source library Otto from Square.

It's implementing publisher/subscriber pattern very nicely. You will find many examples on the web how to use it, it's very simple. First of all check out the Otto's website

If you can register/unregister receiver directly from Activity then I would follow @Ritesh Gune answer.

score 4 · Answer 3 · edited Aug 22 '17 at 12:26

I'd certainly recommend EventBus from GreenRobot

EventBus is an Android optimized publish/subscribe event bus. A typical use case for Android apps is gluing Activities, Fragments, and background threads together. Conventional wiring of those elements often introduces complex and error-prone dependencies and life cycle issues. With EventBus propagating listeners through all participants (e.g. background service -> activity -> multiple fragments or helper classes) becomes deprecated. EventBus decouples event senders and receivers and thus simplifies communication between app components. Less code, better quality. And you don't need to implement a single interface!

check out : https://github.com/greenrobot/EventBus

score 3 · Answer 4 · edited Aug 01 '14 at 21:05

you can use ObservableEvent with extends Observable class.

public class ObservableEvent extends Observable {
public void setChanged(){
    super.setChanged();
}
}

Make singleton class notification center

public class NSNotificationCenter {

private HashMap<String, ObservableEvent> observables = new HashMap<String, ObservableEvent>();

/**
 * Lazy load the event bus
 */

public void addObserver(String notification, Observer observer) {
    ObservableEvent observable = observables.get(notification);
    if (observable == null) {
        observable = new ObservableEvent();
        observables.put(notification, observable);
    }
    observable.addObserver(observer);
}

public void removeObserver(String notification, Observer observer) {
    Observable observable = observables.get(notification);
    if (observable != null) {
        observable.deleteObserver(observer);
    }
}


public void postNotification(String notification, Object object) { 
        ObservableEvent observable = observables.get(notification);
        if (observable != null) {
            observable.setChanged();
            if (object == null) { 
                observable.notifyObservers();
            } else {
                observable.notifyObservers(object);
            }
        } 
}

}

just use to add observer for observing notify and for firing method use post notification

score 2 · Answer 5 · answered Jul 28 '14 at 06:42

From the docs:

You can either dynamically register an instance of this class with Context.registerReceiver() or statically publish an implementation through the tag in your AndroidManifest.xml.

Register a receiver in Activity.onResume() implementation and unregister in Activity.onPause().

public class MyActivity extends Activity
{
    private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            MyActivity.this.broadcastReceived(intent);
        }
    };

    public void onResume() {
       super.onResume();
       IntentFilter intentFilter = new IntentFilter();
       // add action, category, data to intentFilter
       this.registerReceiver(this.mBroadcastReceiver, intentFilter);
    }

    public void onPause() {
       super.onPause();
       this.unregisterReceiver(this.mBroadcastReceiver);
    }

    public void broadcastReceived(Intent intent) {
       // Update the UI component here.
    }
}

score 0 · Answer 6 · answered Jul 28 '14 at 22:27

You can use observer pattern-the activity registers itself in onResume() with the broadcast receiver to receive updates and in onPause() unregisters itself.

There are lot of material on net to learn observer pattern-http://en.wikipedia.org/wiki/Observer_pattern

Updating Activity UI component from Broadcast Receiver?

6 Answers6