I'll answer this anyway. Just in case someone needs it.

ReceiverActivity.java

An activity that watches for notifications for the event named "custom-event-name".

@Override public void onCreate(Bundle savedInstanceState) { ... // Register to receive messages. // We are registering an observer (mMessageReceiver) to receive Intents // with actions named "custom-event-name". LocalBroadcastManager.getInstance(this).registerReceiver(mMessageReceiver, new IntentFilter("custom-event-name")); } // Our handler for received Intents. This will be called whenever an Intent // with an action named "custom-event-name" is broadcasted. private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { // Get extra data included in the Intent String message = intent.getStringExtra("message"); Log.d("receiver", "Got message: " + message); } }; @Override protected void onDestroy() { // Unregister since the activity is about to be closed. LocalBroadcastManager.getInstance(this).unregisterReceiver(mMessageReceiver); super.onDestroy(); } 

SenderActivity.java

The second activity that sends/broadcasts notifications.

@Override public void onCreate(Bundle savedInstanceState) { ... // Every time a button is clicked, we want to broadcast a notification. findViewById(R.id.button_send).setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { sendMessage(); } }); } // Send an Intent with an action named "custom-event-name". The Intent sent should // be received by the ReceiverActivity. private void sendMessage() { Log.d("sender", "Broadcasting message"); Intent intent = new Intent("custom-event-name"); // You can also include some extra data. intent.putExtra("message", "This is my message!"); LocalBroadcastManager.getInstance(this).sendBroadcast(intent); } 

With the code above, every time the button R.id.button_send is clicked, an Intent is broadcasted and is received by mMessageReceiver in ReceiverActivity.

The debug output should look like this:

01-16 10:35:42.413: D/sender(356): Broadcasting message 01-16 10:35:42.421: D/receiver(356): Got message: This is my message! 

I'd rather like to answer comprehensively.

1. LocalbroadcastManager included in android 3.0 and above so you have to use support library v4 for early releases. see instructions here

2. Create a broadcast receiver:

   private BroadcastReceiver onNotice= new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { // intent can contain anydata Log.d("sohail","onReceive called"); tv.setText("Broadcast received !"); } }; 

3. Register your receiver in onResume of activity like:

   protected void onResume() { super.onResume(); IntentFilter iff= new IntentFilter(MyIntentService.ACTION); LocalBroadcastManager.getInstance(this).registerReceiver(onNotice, iff); } //MyIntentService.ACTION is just a public static string defined in MyIntentService. 

4. unRegister receiver in onPause:

   protected void onPause() { super.onPause(); LocalBroadcastManager.getInstance(this).unregisterReceiver(onNotice); } 

5. Now whenever a localbroadcast is sent from applications' activity or service, onReceive of onNotice will be called :).

Edit: You can read complete tutorial here LocalBroadcastManager: Intra application message passing

On Receiving end:

• First register LocalBroadcast Receiver

• Then handle incoming intent data in onReceive.

   @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(this); lbm.registerReceiver(receiver, new IntentFilter("filter_string")); } public BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if (intent != null) { String str = intent.getStringExtra("key"); // get all your data from intent and do what you want } } }; 

On Sending End:

 Intent intent = new Intent("filter_string"); intent.putExtra("key", "My Data"); // put your all data using put extra LocalBroadcastManager.getInstance(this).sendBroadcast(intent); 

In Eclipse, eventually I had to add Compatibility/Support Library by right-clicking on my project and selecting:

Android Tools -> Add Support Library

Once it was added, then I was able to use LocalBroadcastManager class in my code.

localbroadcastmanager is deprecated, use implementations of the observable pattern instead.

androidx.localbroadcastmanager is being deprecated in version 1.1.0

Reason

LocalBroadcastManager is an application-wide event bus and embraces layer violations in your app; any component may listen to events from any other component. It inherits unnecessary use-case limitations of system BroadcastManager; developers have to use Intent even though objects live in only one process and never leave it. For this same reason, it doesn’t follow feature-wise BroadcastManager .

These add up to a confusing developer experience.

Replacement

You can replace usage of LocalBroadcastManager with other implementations of the observable pattern. Depending on your use case, suitable options may be LiveData or reactive streams.

Advantage of LiveData

You can extend a LiveData object using the singleton pattern to wrap system services so that they can be shared in your app. The LiveData object connects to the system service once, and then any observer that needs the resource can just watch the LiveData object.

 public class MyFragment extends Fragment { @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); LiveData<BigDecimal> myPriceListener = ...; myPriceListener.observe(this, price -> { // Update the UI. }); } } 

The observe() method passes the fragment, which is an instance of LifecycleOwner, as the first argument. Doing so denotes that this observer is bound to the Lifecycle object associated with the owner, meaning:

• If the Lifecycle object is not in an active state, then the observer isn't called even if the value changes.

• After the Lifecycle object is destroyed, the observer is automatically removed

The fact that LiveData objects are lifecycle-aware means that you can share them between multiple activities, fragments, and services.

How to change your global broadcast to LocalBroadcast

1) Create Instance

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this); 

2) For registering BroadcastReceiver

Replace

registerReceiver(new YourReceiver(),new IntentFilter("YourAction")); 

With

localBroadcastManager.registerReceiver(new YourReceiver(),new IntentFilter("YourAction")); 

3) For sending broadcast message

Replace

sendBroadcast(intent); 

With

localBroadcastManager.sendBroadcast(intent); 

4) For unregistering broadcast message

Replace

unregisterReceiver(mybroadcast); 

With

localBroadcastManager.unregisterReceiver(mybroadcast); 

When you'll play enough with LocalBroadcastReceiver I'll suggest you to give Green Robot's EventBus a try - you will definitely realize the difference and usefulness of it compared to LBR. Less code, customizable about receiver's thread (UI/Bg), checking receivers availability, sticky events, events could be used as data delivery etc.

Kotlin version of using LocalBroadcastManager:

Please check the below code for registering, sending and receiving the broadcast message.

class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // register broadcast manager val localBroadcastManager = LocalBroadcastManager.getInstance(this) localBroadcastManager.registerReceiver(receiver, IntentFilter("your_action")) } // broadcast receiver var receiver: BroadcastReceiver = object : BroadcastReceiver() { override fun onReceive(context: Context?, intent: Intent?) { if (intent != null) { val str = intent.getStringExtra("key") } } } /** * Send broadcast method */ fun sendBroadcast() { val intent = Intent("your_action") intent.putExtra("key", "Your data") LocalBroadcastManager.getInstance(this).sendBroadcast(intent); } override fun onDestroy() { // Unregister broadcast LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver) super.onDestroy() } } 

An example of an Activity and a Service implementing a LocalBroadcastManager can be found in the developer docs. I personally found it very useful.

EDIT: The link has since then been removed from the site, but the data is the following: https://github.com/carrot-garden/android_maven-android-plugin-samples/blob/master/support4demos/src/com/example/android/supportv4/content/LocalServiceBroadcaster.java

enter code here if (createSuccses){ val userDataChange=Intent(BRODCAST_USER_DATA_CHANGE) LocalBroadcastManager.getInstance(this).sendBroadcast( userDataChange ) enableSpinner(false) finish() 

By declaring one in your AndroidManifest.xml file with the tag (also called static)

<receiver android:name=".YourBrodcastReceiverClass" android:exported="true"> <intent-filter> <!-- The actions you wish to listen to, below is an example --> <action android:name="android.intent.action.BOOT_COMPLETED"/> </intent-filter> 

You will notice that the broadcast receiver declared above has a property of exported=”true”. This attribute tells the receiver that it can receive broadcasts from outside the scope of the application.
2. Or dynamically by registering an instance with registerReceiver (what is known as context registered)

public abstract Intent registerReceiver (BroadcastReceiver receiver, IntentFilter filter); public void onReceive(Context context, Intent intent) { //Implement your logic here } 

There are three ways to send broadcasts:
The sendOrderedBroadcast method, makes sure to send broadcasts to only one receiver at a time. Each broadcast can in turn, pass along data to the one following it, or to stop the propagation of the broadcast to the receivers that follow.
The sendBroadcast is similar to the method mentioned above, with one difference. All broadcast receivers receive the message and do not depend on one another.
The LocalBroadcastManager.sendBroadcast method only sends broadcasts to receivers defined inside your application and does not exceed the scope of your application.

I am an iOS dev, so I made a solution similar to NotificationCenter:

object NotificationCenter { var observers: MutableMap<String, MutableList<NotificationObserver>> = mutableMapOf() fun addObserver(observer: NotificationObserver, notificationName: NotificationName) { var os = observers[notificationName.value] if (os == null) { os = mutableListOf<NotificationObserver>() observers[notificationName.value] = os } os.add(observer) } fun removeObserver(observer: NotificationObserver, notificationName: NotificationName) { val os = observers[notificationName.value] if (os != null) { os.remove(observer) } } fun removeObserver(observer:NotificationObserver) { observers.forEach { name, mutableList -> if (mutableList.contains(observer)) { mutableList.remove(observer) } } } fun postNotification(notificationName: NotificationName, obj: Any?) { val os = observers[notificationName.value] if (os != null) { os.forEach {observer -> observer.onNotification(notificationName,obj) } } } } interface NotificationObserver { fun onNotification(name: NotificationName,obj:Any?) } enum class NotificationName(val value: String) { onPlayerStatReceived("on player stat received"), ... } 

Some class that want to observe notification must conform to observer protocol:

class MainActivity : AppCompatActivity(), NotificationObserver { override fun onCreate(savedInstanceState: Bundle?) { ... NotificationCenter.addObserver(this,NotificationName.onPlayerStatReceived) } override fun onDestroy() { ... super.onDestroy() NotificationCenter.removeObserver(this) } ... override fun onNotification(name: NotificationName, obj: Any?) { when (name) { NotificationName.onPlayerStatReceived -> { Log.d(tag, "onPlayerStatReceived") } else -> Log.e(tag, "Notification not handled") } } 

Finally, post some notification to observers:

NotificationCenter.postNotification(NotificationName.onPlayerStatReceived,null)