我还是要回答这个问题。以防有人需要。

ReceiverActivity.java

一个监视名为“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

第二个活动发送/广播通知。

@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);
}

使用上面的代码，每次按钮都是R.id。button_send被点击，Intent被广播并被ReceiverActivity中的mMessageReceiver接收。

调试输出应该是这样的:

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! 

在Eclipse中，最终我不得不通过右键单击我的项目并选择添加兼容性/支持库:

Android工具->添加支持库

一旦添加了它，我就可以在代码中使用LocalBroadcastManager类了。

我更愿意全面地回答。

LocalbroadcastManager included in android 3.0 and above so you have to use support library v4 for early releases. see instructions here 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 !"); } }; 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. unRegister receiver in onPause: protected void onPause() { super.onPause(); LocalBroadcastManager.getInstance(this).unregisterReceiver(onNotice); } Now whenever a localbroadcast is sent from applications' activity or service, onReceive of onNotice will be called :).

编辑:你可以在这里阅读完整的教程LocalBroadcastManager:内部应用程序消息传递

一个实现LocalBroadcastManager的Activity和Service的例子可以在开发者文档中找到。我个人觉得它非常有用。

编辑:该链接已从网站上删除，但数据如下: https://github.com/carrot-garden/android_maven-android-plugin-samples/blob/master/support4demos/src/com/example/android/supportv4/content/LocalServiceBroadcaster.java

我们也可以使用接口相同的broadcastManger在这里我分享broadcastManager的测试代码，但通过接口。

首先，创建如下界面:

public interface MyInterface {
     void GetName(String name);
}

2-这是第一个需要实现的类

public class First implements MyInterface{

    MyInterface interfc;    
    public static void main(String[] args) {
      First f=new First();      
      Second s=new Second();
      f.initIterface(s);
      f.GetName("Paddy");
  }
  private void initIterface(MyInterface interfc){
    this.interfc=interfc;
  }
  public void GetName(String name) {
    System.out.println("first "+name);
    interfc.GetName(name);  
  }
}

3-这里是实现相同接口的第二个类，其方法自动调用

public class Second implements MyInterface{
   public void GetName(String name) {
     System.out.println("Second"+name);
   }
}

因此，通过这种方法，我们可以使用与broadcastManager功能相同的接口。

当你玩够了LocalBroadcastReceiver的时候，我会建议你试试Green Robot的EventBus——你一定会意识到它与LBR的区别和有用性。更少的代码，可定制关于接收者的线程(UI/Bg)，检查接收者的可用性，粘性事件，事件可以用作数据传递等。

接收端:

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 } } };

发送端:

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

   LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

如何将全局广播更改为局部广播

1)创建实例

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(this);

2)用于注册BroadcastReceiver

取代

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

与

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

3)用于发送广播信息

取代

sendBroadcast(intent);

与

localBroadcastManager.sendBroadcast(intent);

4)注销广播信息

取代

unregisterReceiver(mybroadcast);

与

localBroadcastManager.unregisterReceiver(mybroadcast);

Localbroadcastmanager已弃用，请改用可观察模式的实现。

androidx。Localbroadcastmanager在1.1.0版中已弃用

原因

LocalBroadcastManager是一个应用程序范围内的事件总线，在你的应用程序中包含层冲突;任何组件都可以侦听来自任何其他组件的事件。 它继承了系统BroadcastManager不必要的用例限制;开发人员必须使用Intent，即使对象只存在于一个进程中并且从未离开。出于同样的原因，它没有遵循BroadcastManager的特性。

这些都给开发者带来了令人困惑的体验。

更换

您可以将LocalBroadcastManager的使用替换为可观察模式的其他实现。根据您的用例，合适的选项可能是LiveData或响应式流。

LiveData的优势

你可以使用单例模式来扩展一个LiveData对象来包装系统服务，这样它们就可以在你的应用程序中共享。LiveData对象连接到系统服务一次，然后任何需要资源的观察者都可以观察LiveData对象。

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

observe()方法将片段作为第一个参数传递，它是LifecycleOwner的一个实例。这样做表示这个观察者被绑定到与所有者相关的生命周期对象上，这意味着:

如果Lifecycle对象不处于活动状态，那么观察器 即使值更改，也不调用。 在Lifecycle对象被销毁之后，观察者就被销毁了 自动删除

LiveData对象能够感知生命周期这一事实意味着您可以在多个活动、片段和服务之间共享它们。

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

通过在AndroidManifest.xml文件中声明一个标签(也称为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>

你会注意到上面声明的广播接收器有一个属性export = " true "。此属性告诉接收器它可以接收来自应用程序范围之外的广播。 2. 或者通过向registerReceiver动态注册一个实例(即所谓的上下文注册)

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.

使用LocalBroadcastManager的Kotlin版本:

请检查下面的注册代码， 发送和接收广播消息。

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()
    }

}

我是一名iOS开发者，所以我做了一个类似于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"),
    ...
}

一些想要观察通知的类必须符合观察者协议:

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")
        }
    }

最后，向观察者发布一些通知:

NotificationCenter.postNotification(NotificationName.onPlayerStatReceived,null)