Android 开发 - 广播组件（标准广播、有序广播、静态注册广播、分钟到达广播、网络变更广播...）

一、广播概述

1. 广播的本质是一种数据传输方式

2. Android 中的广播是发送一条广播，可以被不同的广播接收者所接收，广播接收者收到广播之后，再进行逻辑处理

---

二、标准广播

1、基本介绍

• 标准广播的实现步骤

1. 定义广播接收器

2. 发送标准广播

3. 开关广播接收器

• 注：默认情况下广播接收者的 onReceive 方法会在主线程中执行

2、具体实现

（1）Activity Layout

• activity_broadcast_standard.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_send_broadcast"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="发送标准广播" />
</LinearLayout>

（2）BroadcastReceiver

• BroadcastStandardReceiver.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

// 定义一个标准广播接收器
public class BroadcastStandardReceiver extends BroadcastReceiver {

    public static final String STANDARD_ACTION = "com.my.broadcast";

    // 一旦接收到广播，马上触发 onReceive 方法
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction() == STANDARD_ACTION) {
            Log.d("BroadcastStandard", "接收到一个标准广播");
        }
    }
}

（3）Activity Code

• BroadcastStandardActivity.java

package com.my.broadcast;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.my.broadcast.receiver.BroadcastStandardReceiver;

public class BroadcastStandardActivity extends AppCompatActivity implements View.OnClickListener {

    private BroadcastStandardReceiver broadcastStandardReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broadcast_standard);

        Button btn_send_broadcast = findViewById(R.id.btn_send_broadcast);
        btn_send_broadcast.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        Intent intent = new Intent(BroadcastStandardReceiver.STANDARD_ACTION);
        sendBroadcast(intent);
    }

    @Override
    protected void onStart() {
        super.onStart();

        broadcastStandardReceiver = new BroadcastStandardReceiver();

        // 创建一个意图过滤器，只处理 STANDARD_ACTION 的广播
        IntentFilter filter = new IntentFilter(BroadcastStandardReceiver.STANDARD_ACTION);

        // 广播接收器，注册之后才能使用广播
        registerReceiver(broadcastStandardReceiver, filter);
    }

    @Override
    protected void onStop() {
        super.onStop();

        // 注销接收器
        unregisterReceiver(broadcastStandardReceiver);
    }
}

（4）Test

• 输出结果

  D/BroadcastStandard: 接收到一个标准广播

---

三、有序广播

1、基本介绍

1. 一个广播存在多个接收器，这些接收器需要有序接收广播，这意味着这是一个有序广播

2. 先收到的广播接收器，既可以让其他接收器接收广播，也可以中断广播让不让其他接收器接收

2、具体实现

（1）Activity Layout

• activity_broadcast_order.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_send_broadcast"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="发送有序广播" />
</LinearLayout>

（2）BroadcastReceiver

1. BroadcastOrderReceiverA.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

import com.my.broadcast.BroadcastOrderActivity;

public class BroadcastOrderReceiverA extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction() == BroadcastOrderActivity.ORDER_ACTION) {
            Log.d("BroadcastOrderA", "接收到一个广播");
        }
    }
}

2. BroadcastOrderReceiverB.java

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

import com.my.broadcast.BroadcastOrderActivity;

public class BroadcastOrderReceiverB extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction() == BroadcastOrderActivity.ORDER_ACTION) {
            Log.d("BroadcastOrderB", "接收到一个广播");
        }
    }
}

（3）Activity Code

• BroadcastOrderActivity.java

package com.my.broadcast;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.my.broadcast.receiver.BroadcastOrderReceiverA;
import com.my.broadcast.receiver.BroadcastOrderReceiverB;

public class BroadcastOrderActivity extends AppCompatActivity implements View.OnClickListener {

    public static final String ORDER_ACTION = "com.my.broadcast.order";
    private BroadcastOrderReceiverA broadcastOrderReceiverA;
    private BroadcastOrderReceiverB broadcastOrderReceiverB;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broadcast_order);

        Button btn_send_broadcast = findViewById(R.id.btn_send_broadcast);
        btn_send_broadcast.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        Intent intent = new Intent(ORDER_ACTION);

        // 发送有序广播
        // 第二个参数是权限
        sendOrderedBroadcast(intent, null);
    }

    @Override
    protected void onStart() {
        super.onStart();

        broadcastOrderReceiverA = new BroadcastOrderReceiverA();
        IntentFilter filterA = new IntentFilter(ORDER_ACTION);

        // 设置优先级
        filterA.setPriority(5);
        registerReceiver(broadcastOrderReceiverA, filterA);

        broadcastOrderReceiverB = new BroadcastOrderReceiverB();
        IntentFilter filterB = new IntentFilter(ORDER_ACTION);

        // 设置优先级
        filterB.setPriority(10);
        registerReceiver(broadcastOrderReceiverB, filterB);
    }

    @Override
    protected void onStop() {
        super.onStop();

        unregisterReceiver(broadcastOrderReceiverA);
        unregisterReceiver(broadcastOrderReceiverB);
    }
}

（4）Test

• 输出结果

  D/BroadcastOrderB: 接收到一个广播
  D/BroadcastOrderA: 接收到一个广播

3、广播中断

（1）BroadcastReceiver

• BroadcastOrderReceiverB.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

import com.my.broadcast.BroadcastOrderActivity;

public class BroadcastOrderReceiverB extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction() == BroadcastOrderActivity.ORDER_ACTION) {
            Log.d("BroadcastOrderB", "接收到一个广播");

            // 广播中断
            abortBroadcast();
        }
    }
}

（2）Test

• 输出结果

  D/BroadcastOrderB: 接收到一个广播

---

四、静态注册广播

1、基本介绍

1. 在 Java 代码中注册广播，该方式被称为动态注册

2. 在 AndroidManifest.xml 文件中注册广播，被称为静态注册，Android 8.0 之后不推荐使用广播的静态注册

2、具体实现

（1）Activity Layout

• activity_broadcast_static.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_send_broadcast"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="发送静态注册广播" />
</LinearLayout>

（2）BroadcastReceiver

• BroadcastStaticReceiver.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Vibrator;
import android.util.Log;

public class BroadcastStaticReceiver extends BroadcastReceiver {

    public static final String STATIC_ACTION = "com.my.broadcast.static";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction() == STATIC_ACTION) {
            Log.d("BroadcastStatic", "收到一个静态注册广播，手机震动一下");

            // 获取震动管理器
            Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);

            // 命令震动器震动 500 毫秒
            vibrator.vibrate(500);
        }
    }
}

（3）AndroidManifest

• AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.my.broadcast">

    <!-- 开启震动权限 -->
    <uses-permission android:name="android.permission.VIBRATE" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.AndroidDevelop">

        <!-- 静态注册广播 -->
        <receiver
            android:name=".receiver.BroadcastStaticReceiver"
            android:exported="true">
            <intent-filter>
                <action android:name="com.my.broadcast.static" />
            </intent-filter>
        </receiver>

        <activity
            android:name=".BroadcastStaticActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

（4）Activity Code

• BroadcastStaticActivity.java

package com.my.broadcast;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.my.broadcast.receiver.BroadcastStaticReceiver;

public class BroadcastStaticActivity extends AppCompatActivity implements View.OnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broadcast_static);

        Button btn_send_broadcast = findViewById(R.id.btn_send_broadcast);
        btn_send_broadcast.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {

        // Android 8.0 之后删除了大部分静态注册，防止 APP 退出后仍在接收广播
        // 为了让应用能够继续接收静态广播，需要给静态注册的广播指定包名
        Intent intent = new Intent(BroadcastStaticReceiver.STATIC_ACTION);
        String fullName = "com.my.broadcast.receiver.BroadcastStaticReceiver";
        ComponentName component = new ComponentName(this, fullName);
        intent.setComponent(component);
        sendBroadcast(intent);
    }
}

（5）Test

• 输出结果

  D/BroadcastStatic: 收到一个静态注册广播，手机震动一下

---

五、分钟到达广播

1、基本介绍

• 系统广播，系统每分钟都会发送一次广播，因为是由系统发送，所有不需要使用按钮等触发

2、具体实现

（1）BroadcastReceiver

• BroadcastMinuteReceiver.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class BroadcastMinuteReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null) {
            Log.d("BoradcastMinute", "接收到了一个广播");
        }
    }
}

（2）Activity Code

• BoradcastMinuteActivity.java

package com.my.broadcast;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;

import com.my.broadcast.receiver.BroadcastMinuteReceiver;

public class BoradcastMinuteActivity extends AppCompatActivity {

    private BroadcastMinuteReceiver broadcastMinuteReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_boradcast_minute);
    }

    @Override
    protected void onStart() {
        super.onStart();

        broadcastMinuteReceiver = new BroadcastMinuteReceiver();
        IntentFilter filter = new IntentFilter(Intent.ACTION_TIME_TICK);
        registerReceiver(broadcastMinuteReceiver, filter);
    }

    @Override
    protected void onStop() {
        super.onStop();

        unregisterReceiver(broadcastMinuteReceiver);
    }
}

（3）Test

• 输出结果

  D/BoradcastMinute: 接收到了一个广播

---

六、网络变更广播

1、基本介绍

• 监听网络变更，判断当前使用的网络是 WIFI 还是数据流量

2、具体实现

---

七、定时管理器 AlarmManager

1、基本介绍

• Android 提供了专门的定时管理器 AlarmManager，它利用系统闹钟定时发送广播，它有如下常见方法

方法	说明
set	设置一次性定时器
setAndAllowWhileIdle	设置一次性定时器，即使设备处于空闲状态，也会保证执行定时器
setRepeating	设置重复定时器，但系统不保证按时发送广播
setExactAndAllowWhileIdle	设置重复定时器，即使设备处于空闲状态，也会保证执行定时器（适用于定时任务）
cancel	取消指定延时意图的定时器

2、延迟意图 PendingIntent

• 定时管理器使用演示意图 PendingIntent，它与 Intent 之间的差异主要有以下三点

1. PendingIntent 代表延迟的意图，它指向的组件不会马上激活，而 Intent 代表实时的意图，它指向的组件会马上激活

2. PendingIntent 是一类消息的组合，不但包含目标的 Intent 对象，还包含请求代码、请求方式等信息

3. PendingIntent 对象在创建之时便已知晓将要用于活动还是广播

3、具体实现

（1）Activity Layout

• activity_broadcast_alarm.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_alarm"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="设置闹钟" />
</LinearLayout>

（2）BroadcastReceiver

• BroadcastAlarmReceiver 类

package com.my.broadcast.receiver;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.util.Log;

public class BroadcastAlarmReceiver extends BroadcastReceiver {

    private static final String ALARM_ACTION = "com.my.broadcast.alarm";
    private final Context mContext;

    public BroadcastAlarmReceiver(Context mContext) {
        super();
        this.mContext = mContext;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction() == ALARM_ACTION) {
            Log.d("BroadcastAlarm", "收到一条闹钟广播");
        }
    }

    // 发送闹钟广播
    public void sendAlarm() {
        Intent intent = new Intent(ALARM_ACTION);

        // 针对 S+（Android 12 及更高版本）要求在创建 PendingIntent 时指定 FLAG_IMMUTABLE 或 FLAG_MUTABLE
        // 强烈考虑使用 FLAG_IMMUTABLE，仅当某些功能依赖于 PendingIntent 是可变的时才使用 FLAG_MUTABLE
        PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, intent, PendingIntent.FLAG_IMMUTABLE);

        // 从系统服务中获取闹钟管理器
        AlarmManager alarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);

        // 设置一次性闹钟，延迟若干秒后，携带延迟意图发送闹钟广播
        // Android 6.0 之后，set 方法在暗屏时不保证发送广播，需要使用 setAndAllowWhileIdle 方法
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, 1000, pendingIntent);
        } else {
            alarmManager.set(AlarmManager.RTC_WAKEUP, 1000, pendingIntent);
        }
    }
}

（3）Activity Code

• BroadcastAlarmActivity 类

package com.my.broadcast;

import androidx.appcompat.app.AppCompatActivity;

import android.content.IntentFilter;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.my.broadcast.receiver.BroadcastAlarmReceiver;

public class BroadcastAlarmActivity extends AppCompatActivity implements View.OnClickListener {

    private static BroadcastAlarmReceiver broadcastAlarmReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broadcast_alarm);

        Button btn_alarm = findViewById(R.id.btn_alarm);
        btn_alarm.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        broadcastAlarmReceiver.sendAlarm();
    }

    @Override
    protected void onStart() {
        super.onStart();

        broadcastAlarmReceiver = new BroadcastAlarmReceiver(getApplicationContext());
        IntentFilter filter = new IntentFilter(BroadcastAlarmReceiver.ALARM_ACTION);
        registerReceiver(broadcastAlarmReceiver, filter);
    }

    @Override
    protected void onStop() {
        super.onStop();

        unregisterReceiver(broadcastAlarmReceiver);
    }
}

（4）Test

• 输出结果

  D/BroadcastAlarm: 收到一条闹钟广播

5、循环发送广播

（1）BroadcastReceiver

• BroadcastAlarmReceiver.java

package com.my.broadcast.receiver;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.util.Log;

public class BroadcastAlarmReceiver extends BroadcastReceiver {

    public static final String ALARM_ACTION = "com.my.broadcast.alarm";
    private final Context mContext;

    public BroadcastAlarmReceiver(Context mContext) {
        super();
        this.mContext = mContext;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction() == ALARM_ACTION) {
            Log.d("BroadcastAlarm", "收到一条闹钟广播");

            // 循环发送闹钟广播
            sendAlarm();
        }
    }

    // 发送闹钟广播
    public void sendAlarm() {
        Intent intent = new Intent(ALARM_ACTION);

        // 针对 S+（Android 12 及更高版本）要求在创建 PendingIntent 时指定 FLAG_IMMUTABLE 或 FLAG_MUTABLE
        // 强烈考虑使用 FLAG_IMMUTABLE，仅当某些功能依赖于 PendingIntent 是可变的时才使用 FLAG_MUTABLE
        PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, intent, PendingIntent.FLAG_IMMUTABLE);

        // 从系统服务中获取闹钟管理器
        AlarmManager alarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);

        // 设置重复闹钟
        // Android 4.4 之后，setRepeating 方法不保证发送广播
		alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), 1000, pendingIntent);
    }
}

（2）Test

• 输出结果

  D/BroadcastAlarm: 收到一条闹钟广播
  D/BroadcastAlarm: 收到一条闹钟广播
  D/BroadcastAlarm: 收到一条闹钟广播

---

八、广播扩展

1、广播携带数据

（1）Activity Layout

• activity_broadcast_has_data.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_send_broadcast"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="发送广播" />
</LinearLayout>

（2）BroadcastReceiver

• BroadcastHasDataReceiver.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class BroadcastHasDataReceiver extends BroadcastReceiver {

    public static final String TAG = BroadcastHasDataReceiver.class.getSimpleName();

    public static final String ACTION = "com.my.broadcast.hasdata";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent == null) return;
        if (intent.getAction() == null || !intent.getAction().equals(ACTION)) return;
        String name = intent.getStringExtra("name");
        int age = intent.getIntExtra("age", -1);
        Log.i(TAG, "------------------------------ name: " + name);
        Log.i(TAG, "------------------------------ age: " + age);
    }
}

（3）Activity Code

• BroadcastHasDataActivity.java

package com.my.broadcast;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.widget.Button;

import com.my.broadcast.receiver.BroadcastHasDataReceiver;
import com.my.broadcast.receiver.BroadcastStandardReceiver;

public class BroadcastHasDataActivity extends AppCompatActivity {

    private BroadcastHasDataReceiver broadcastHasDataReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broadcast_has_data);

        Button btnSendBroadcast = findViewById(R.id.btn_send_broadcast);
        btnSendBroadcast.setOnClickListener(v -> {
            Intent intent = new Intent(BroadcastHasDataReceiver.ACTION);
            intent.putExtra("name", "tom");
            intent.putExtra("age", 30);
            sendBroadcast(intent);
        });
    }

    @Override
    protected void onStart() {
        super.onStart();

        broadcastHasDataReceiver = new BroadcastHasDataReceiver();
        IntentFilter filter = new IntentFilter(BroadcastHasDataReceiver.ACTION);
        registerReceiver(broadcastHasDataReceiver, filter);
    }

    @Override
    protected void onStop() {
        super.onStop();
        unregisterReceiver(broadcastHasDataReceiver);
    }
}

（4）Test

• 输出结果

  ------------------------------ name: tom
  ------------------------------ age: 30

2、广播中发送广播

（1）Activity Layout

• activity_broadcast_transfer.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_send_broadcast"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="发送广播" />
</LinearLayout>

（2）BroadcastReceiver

1. BroadcastTransferAReceiver.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class BroadcastTransferAReceiver extends BroadcastReceiver {
    public static final String TAG = BroadcastTransferAReceiver.class.getSimpleName();

    public static final String ACTION = "com.my.broadcast.transfera";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent == null) return;
        if (intent.getAction() == null || !intent.getAction().equals(ACTION)) return;

        Log.i(TAG, "------------------------------ TransferA 接收到广播，开始向 TransferB 发送广播");

        Intent newIntent = new Intent(BroadcastTransferBReceiver.ACTION);
        context.sendBroadcast(newIntent);
    }
}

2. BroadcastTransferBReceiver.java

package com.my.broadcast.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class BroadcastTransferBReceiver extends BroadcastReceiver {
    public static final String TAG = BroadcastTransferBReceiver.class.getSimpleName();

    public static final String ACTION = "com.my.broadcast.transferb";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent == null) return;
        if (intent.getAction() == null || !intent.getAction().equals(ACTION)) return;

        Log.i(TAG, "------------------------------ TransferB 接收到广播");
    }
}

（3）Activity Code

• BroadcastTransferActivity.java

package com.my.broadcast;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.widget.Button;

import com.my.broadcast.receiver.BroadcastTransferAReceiver;
import com.my.broadcast.receiver.BroadcastTransferBReceiver;

public class BroadcastTransferActivity extends AppCompatActivity {

    private BroadcastTransferAReceiver broadcastTransferAReceiver;
    private BroadcastTransferBReceiver broadcastTransferBReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broadcast_transfer);

        Button btnSendBroadcast = findViewById(R.id.btn_send_broadcast);
        btnSendBroadcast.setOnClickListener(v -> {
            Intent intent = new Intent(BroadcastTransferAReceiver.ACTION);
            sendBroadcast(intent);
        });
    }

    @Override
    protected void onStart() {
        super.onStart();

        broadcastTransferAReceiver = new BroadcastTransferAReceiver();
        IntentFilter filter1 = new IntentFilter(BroadcastTransferAReceiver.ACTION);
        registerReceiver(broadcastTransferAReceiver, filter1);

        broadcastTransferBReceiver = new BroadcastTransferBReceiver();
        IntentFilter filter2 = new IntentFilter(BroadcastTransferBReceiver.ACTION);
        registerReceiver(broadcastTransferBReceiver, filter2);
    }

    @Override
    protected void onStop() {
        super.onStop();

        unregisterReceiver(broadcastTransferAReceiver);
        unregisterReceiver(broadcastTransferBReceiver);
    }
}

（4）Test

• 输出结果

  ------------------------------ TransferA 接收到广播，开始向 TransferB 发送广播
  ------------------------------ TransferB 接收到广播