第9章广播组件Broadcast

Mr.Tong...

Android

Android

大约 26 分钟

第 9 章广播组件Broadcast

📖9.1 收发应用广播

App在运行的时候有各种各样的数据流转，有的数据从上一个页面流向下一个页面，此时可通过意图在活动之间传递包裹；有的数据从应用内存流向存储卡，此时可进行文件读写操作。还有的数据流向千奇百怪，比如活动页面向碎片传递数据，按照“8.4.2　碎片的动态注册”小节的描述，尚可调用setArguments和getArguments方法存取参数；然而若是由碎片向活动页面传递数据，就没有类似setResult这样回馈结果的方法了。

随着App工程的代码量日益增长，承载数据流通的管道会越发不够用，好比装修房子的时候，给每个房间都预留了网线插口，只有插上网线才能上网。可是现在联网设备越来越多，除了电脑之外，电视也要联网，平板也要联网，乃至空调都要联网，如此一来网口早就不够用了。那怎样解决众多设备的联网问题呢？原来家家户户都配了无线路由器，路由器向四周发射WiFi信号，各设备只要安装了无线网卡，就能接收WiFi信号从而连接上网。于是“发射器+接收器”的模式另辟蹊径，比起网线这种固定管道要灵活得多，无须拉线即可随时随地传输数据。

Android的广播机制正是借鉴了WiFi的通信原理，不必搭建专门的通路，就能在发送方与接收方之间建立连接。同时广播（Broadcast）也是Android的四大组件之一，它用于Android各组件之间的灵活通信，与活动的区别在于：

活动只能一对一通信；而广播可以一对多，一人发送广播，多人接收处理。
对于发送方来说，广播不需要考虑接收方有没有在工作，接收方在工作就接收广播，不在工作就丢弃广播。
对于接收方来说，因为可能会收到各式各样的广播，所以接收方要自行过滤符合条件的广播，之后再解包处理。

与广播有关的方法主要有以下 3 个。

sendBroadcast：发送广播。
BroadcastReceiver:创建广播接收器，在onReceive中处理接受的广播信息。
registerReceiver：注册广播的接收器，可在onStart或onResume方法中注册接收器。
unregisterReceiver：注销广播的接收器，可在onStop或onPause方法中注销接收器。

具体到编码实现上，广播的收发过程可分为 3 个步骤：

发送广播：Intent intent = new Intent(STANDARD_ACTION)->sendBroadcast(intent)
定义广播接收器：new BroadcastReceiver() ->onReceive中处理
过滤action并注册广播接收器：IntentFilter filter = new IntentFilter(STANDARD_ACTION)、registerReceiver(standardReceiver,filter)
注销广播接收器：unregisterReceiver(standardReceiver)

意图对象需要指定广播的action动作名称，如同每个路由器都得给自己的WiFi起个名称一般，这样接收方才能根据动作名称判断来的是李逵而不是李鬼。

✅收发标准广播

标准广播 （Normal broadcasts）是一种完全异步执行的广播，在广播发出后，所有的广播接收器几乎都会在同一时刻接收到这条广播消息，因此它们之间没有任何先后顺序可言。这种广播的效率会比较高，但同时也意味着它是无法被截断的。

下面是通过点击按钮发送广播的活动页面代码：

第一步：定义点击按钮发送广播的活动页面 ：sendBroadcast

第二步：定义广播接收器：需继承 BroadcastReceiver ，并在onReceive接受广播消息并处理

第三步：过滤并注册接收器

第四步：销毁接收器

public class BroadStandardActivity extends AppCompatActivity implements View.OnClickListener {
    private final static String TAG = "BroadStandardActivity";
    //定义广播的动作名称
    private final static String STANDARD_ACTION = "com.example.myapplication";
    private TextView tv_standard;
    private String msg = "这里查看标准广播的收听信息";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_broad_standard);
        tv_standard = findViewById(R.id.tv_standard);
        tv_standard.setText(msg);
        findViewById(R.id.bnt_send_standard).setOnClickListener(this);
    }

    /**
     * 点击事件发送广播
     * @param v The view that was clicked.
     */
    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.bnt_send_standard){
            //1. 创建指定动作的意图
            Intent intent = new Intent(STANDARD_ACTION);
            //2. 发送标准广播
            sendBroadcast(intent);

        }
    }

    /**
     * 定义一个标准广播的接收器
     */
    private class StandardReceiver extends BroadcastReceiver{
        // 一旦接收到标准广播，马上触发接收器的onReceive方法
        @Override
        public void onReceive(Context context, Intent intent) {
            // 广播意图非空，且接头暗号正确
            if (intent != null && intent.getAction().equals(STANDARD_ACTION)){
                msg = String.format("%s\n%s收到一个标准广播",msg, DateUtil.getNowTime());
                tv_standard.setText(msg);
            }
        }
    }

    /**
     * 过滤器动作名称一致的广播,并注册接收器：动作名称类型WiFi名称
     */
   private StandardReceiver standardReceiver;
    @Override
    protected void onStart() {
        super.onStart();
        // 1. 声明一个标准广播的接收器实例
        standardReceiver = new StandardReceiver();
        // 2. 创建一个意图过滤器，只处理STANDARD_ACTION的广播
        IntentFilter intentFilter = new IntentFilter(STANDARD_ACTION);
        // 3. 注册接收器，注册之后才能正常接收广播
        registerReceiver(standardReceiver,intentFilter);
    }

    /**
     * 注销接收器
     */
    @Override
    protected void onStop() {
        super.onStop();
        // 注销接收器，注销之后就不再接收广播
        unregisterReceiver(standardReceiver);
    }
}

✅收发有序广播

前言：
由于广播没指定唯一的接收者，因此可能存在多个接收器，每个接收器都拥有自己的处理逻辑。这种机制固然灵活，却不够严谨，因为不同接收器之间也许有矛盾。比如只要办了借书证，大家都能借阅图书馆的藏书，不过一本书被读者甲借出去之后，读者乙就不能再借这本书了，必须等到读者甲归还了该书之后，读者乙方可继续借阅此书。这个借书场景体现了一种有序性，即图书是轮流借阅着的，且同时刻仅能借给一位读者，只有前面的读者借完归还，才轮到后面的读者借阅。另外，读者甲一定会归还此书吗？可能读者甲对该书爱不释手，从图书馆高价买断了这本书；也可能读者甲粗心大意，不小心弄丢了这本书。不管是哪种情况，读者甲都无法还书，导致正在排队的读者乙无书可借。这种借不到书的场景体现了一种依赖关系，即使读者乙迫不及待地想借到书，也得看读者甲的心情，要是读者甲因为各种理由没能还书，那么读者乙就白白排队了
上述的借书业务对应到广播的接收功能，则要求实现下列的处理逻辑：
一个广播存在多个接收器，这些接收器需要排队收听广播，这意味着该广播是条有序广播。
先收到广播的接收器A，既可以让其他接收器继续收听广播，也可以中断广播不让其他接收器收听。

有序广播是一种同步执行的广播。它按照优先级顺序传递，先被优先级高的接收器接收到，然后再传递给优先级低的接收器。有序广播可以被任何接收器终止，这意味着优先级高的接收器可以决定是否将广播传递给优先级低的接收器。

有序广播通过调用sendOrderedBroadcast()方法发送。

下面是通过点击按钮发送广播的活动页面代码：

第一步：定义点击按钮发送广播的活动页面：sendOrderedBroadcast

第二步：定义AB广播接收器：需继承 BroadcastReceiver ，并在onReceive接受广播消息并处理

第三步：过滤并注册接收器，并设置优先级

第四步：销毁接收器

public class OrderBroadcastActivity extends AppCompatActivity implements View.OnClickListener {
    private static final String ORDER_ACTION = "com.example.myapplication.activity.order";
    private TextView tv_orderBroadcast_receiver;
    private CheckBox cbox_break;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_order_broadcast);
        tv_orderBroadcast_receiver = findViewById(R.id.tv_orderBroadcast_receiver);
        cbox_break = findViewById(R.id.cbox_break);
        findViewById(R.id.bnt_order_broadcast).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.bnt_order_broadcast){
            Intent intent = new Intent(ORDER_ACTION);
            sendOrderedBroadcast(intent,null);//发送有序广播
        }
    }
    /**
     * 创建orderAReceiver广播接收器
     */
    private BroadcastReceiver orderAReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent != null && intent.getAction().equals(ORDER_ACTION)){
                String msg = String.format("%s接收器A收到一个有序广播\n", DateUtil.getNowTime());
                tv_orderBroadcast_receiver.append(msg);
            }
        }
    };
    /**
     * 创建orderBReceiver广播接收器
     */
    private BroadcastReceiver orderBReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent != null && intent.getAction().equals(ORDER_ACTION)){
                String msg = String.format("%s接收器B收到一个有序广播\n", DateUtil.getNowTime());
                tv_orderBroadcast_receiver.append(msg);
                if (cbox_break.isChecked()){
                    abortBroadcast();
                }
            }
        }
    };

    /**
     * 过滤action，注册广播接收器
     */
    @Override
    protected void onStart() {
        super.onStart();
        IntentFilter filterA = new IntentFilter(ORDER_ACTION);
        filterA.setPriority(8);
        registerReceiver(orderAReceiver,filterA);

        IntentFilter filterB = new IntentFilter(ORDER_ACTION);
        filterB.setPriority(10);
        registerReceiver(orderBReceiver,filterB);
    }

    /**
     * 销毁广播接收器
     */
    @Override
    protected void onStop() {
        super.onStop();
        unregisterReceiver(orderAReceiver);
        unregisterReceiver(orderBReceiver);
    }
}

✅收发静态广播

前面几节使用广播之时，无一例外在代码中注册接收器。可是同为 4 大组件，活动（activity）、服务（service）、内容提供器（provider）都能在AndroidManifest.xml注册，为啥广播只能在代码中注册呢？其实广播接收器也能在AndroidManifest.xml注册，并且注册时候的节点名为receiver，一旦接收器在AndroidManifest.xml注册，就无须在代码中注册了。

在AndroidManifest.xml中注册接收器，该方式被称作静态注册；
而在代码中注册接收器，该方式被称作动态注册。

之所以罕见静态注册，是因为静态注册容易导致安全问题，故而Android 8.0之后废弃了大多数静态注册。话虽如此，Android倒也没有彻底禁止静态注册，只要满足特定的编码条件，那么依然能够通过静态方式注册接收器。具体注册步骤说明如下。

创建广播接收器快捷方式：

首先右击当前模块的默认包，依次选择右键菜单的New→Package，创建名为receiver的新包，用于存放静态注册的接收器代码。
其次右击刚创建的receiver包，依次选择右键菜单的New→Other→Broadcast Receiver，如下图所示所示的组件创建对话框，可以快速创建接收器类。

案例：注册静态广播发送震动

第一步： 定义发送广播

由于Android 8.0之后删除了大部分静态注册，防止App退出后仍在收听广播，因此为了让应用能够继续接收静态广播，需要给静态广播指定包名，也就是调用意图对象的setComponent方法设置组件路径。

    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.bnt_shock_send){
            Intent intent = new Intent(ShockReceiver.SHOCK_ACTION);// 指定动作的意图
            // 发送静态广播之时，需要通过setComponent方法指定接收器的完整路径
            ComponentName componentName = new ComponentName(this, ShockReceiver.receiverPath);
            intent.setComponent(componentName);// 设置意图的组件信息
            sendBroadcast(intent);// 发送静态广播
        }
    }

第二步： 静态注册广播接收器，在AndroidManifest.xml里面，通过创建广播接收器创建时会自动生成

实现手机震动之时，要调用getSystemService方法，先从系统服务VIBRATOR_SERVICE获取震动管理器Vibrator，再调用震动管理器的vibrate方法震动手机。

public class ShockReceiver extends BroadcastReceiver {
    private static final String TAG = "ShockReceiver";
    // 指定动作的意图
    public  static final String SHOCK_ACTION = "com.example.myapplication.receiver.shock";
    //接收器的完整路径
    public  static final String receiverPath = "com.example.myapplication.receiver.ShockReceiver";
    @Override
    public void onReceive(Context context, Intent intent) {
        Log.d(TAG, "onReceive");
        if (intent.getAction().equals(SHOCK_ACTION) && intent != null) {
            Log.d(TAG, "震动 ");
            // 从系统服务中获取震动管理器
            Vibrator vb = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
            vb.vibrate(1000); // 命令震动器吱吱个若干秒，这里的500表示500毫秒
        }
    }
}

同时AndroidManifest.xml自动添加接收器的节点配置，默认的receiver配置如下所示：

        <receiver
            android:name=".receiver.ShockReceiver"
            android:exported="true"
            >
            <intent-filter>
                <action android:name="com.example.myapplication.receiver.shock"/>
            </intent-filter>
        </receiver>

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

✅总结

标准广播（Standard Broadcast）：
- 标准广播是一种异步广播方式，广播发出后，不会等待接收者处理完毕，而是立即继续执行广播发出者的代码。
- 所有对该广播感兴趣的接收者都会同时接收到广播，无法控制接收者的顺序。
- 由于广播是异步的，广播发出者无法知道是否有接收者对广播做出了响应。
- 这种广播类型适用于不需要精确控制接收者的情况，例如系统级别的广播事件（例如屏幕开关）。
有序广播（Ordered Broadcast）：
- 有序广播是一种同步广播方式，广播发出后，会按照优先级顺序一个接一个地传递给接收者，每个接收者都有机会处理广播并终止广播。
- 接收者的优先级通过代码或清单文件中的声明进行指定。
- 广播发出者可以根据接收者的处理结果来确定广播是否继续传递。
- 这种广播类型适用于需要按顺序处理的情况，例如短信接收。
静态广播（Static Broadcast）：
- 静态广播是一种特殊类型的广播，由清单文件中的 <receiver> 元素声明，并且不会在运行时创建广播接收者对象。
- 静态广播通常用于在应用程序未运行时接收系统级别的广播事件，而不需要启动应用程序。
- 如果想要在程序未启动时，比如刚开机的情况下接受到系统的开机广播，那就需要使用静态注册。但静态注册长期监听，消耗更多资源，因此大部分情况建议优先使用动态注册解决问题。

📖9.2 监听系统广播

本节介绍了几种系统广播的监听办法，包括如何接收分钟到达广播、如何接收网络变更广播、如何监听定时管理器发出的系统闹钟广播等。

✅接收分钟到达广播

接收分钟广播可分解为下面 3 个步骤：

第一步： 定义分钟广播的接收器timeReceiver，onReceive中处理接收信息

第二步： 过滤action = Intent.ACTION_TIME_TICK，注册registerReceiver广播接收器，在onstart或者onResume中

第三步： 销毁unregisterReceiver广播接收器

public class SystemMinuteActivity extends AppCompatActivity {

    private
    TextView tv_system_receiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_system_minute);
        tv_system_receiver = findViewById(R.id.tv_system_receiver);//显示文本框

    }

    /**
     * 1. 定义分钟广播的接收器
     */
    private BroadcastReceiver timeReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent != null && intent.getAction().equals(Intent.ACTION_TIME_TICK)){
                String msg = String.format("\n%s 收到一个分钟到达广播\n", DateUtil.getNowTime());
                tv_system_receiver.append(msg);
            }
        }
    };

    /**
     * 2. 注册广播接收器
     */
    @Override
    protected void onStart() {
        super.onStart();
        IntentFilter filter = new IntentFilter(Intent.ACTION_TIME_TICK);
        registerReceiver(timeReceiver,filter);
    }

    /**
     * 3. 销毁广播接收器
     */
    @Override
    protected void onStop() {
        super.onStop();
        unregisterReceiver(timeReceiver);
    }
}

✅接收网络变更广播

除了分钟广播，网络变更广播也很常见，因为手机可能使用WiFi上网，也可能使用数据连接上网，而后者会产生流量费用，所以手机浏览器都提供了“智能无图”的功能，连上WiFi网络时才显示网页上的图片，没连上WiFi就不显示图片。这类业务场景就要求侦听网络变更广播，对于当前网络变成WiFi连接、变成数据连接的两种情况，需要分别判断并加以处理。

接收网络变更广播可分解为下面 3 个步骤：

第一步： 定义分钟广播的接收器networkReceiver，onReceive中处理接收信息

第二步： 过滤action = "android.net.conn.CONNECTIVITY_CHANGE"，注册registerReceiver广播接收器，在onstart或者onResume中

第三步： 销毁unregisterReceiver广播接收器

获取网络各种参数如下：

getType：获取网络类型
getTypeName：获取网络类型的名称

getSubtype：获取网络子类型
getSubtypeName：获取网络子类型的名称。获取网络子类型。当网络类型为数据连接时，子类型为2G/3G/4G的细分类型，如CDMA、EVDO、HSDPA、LTE等。

getState：获取网络状态

实例代码如下：

public class SystemNetworkActivity extends AppCompatActivity {

    private TextView tv_systemNetwork_receiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_system_network);
        tv_systemNetwork_receiver = findViewById(R.id.tv_systemNetwork_receiver);
    }
    /**
     * 1. 创建网络变更的广播接收器
     */
    private BroadcastReceiver networkReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent != null && intent.getAction().equals("android.net.conn.CONNECTIVITY_CHANGE")){
                NetworkInfo networkInfo = intent.getParcelableExtra("networkInfo");

                String typeName = networkInfo.getTypeName();//网络类型名称
                String subtypeName = networkInfo.getSubtypeName();//网络子类型的名称
                String state = networkInfo.getState().toString();//网络连接状态
                int subtype = networkInfo.getSubtype();//网络子类型
                String networkClass = NetworkUtil.getNetworkClass(subtype);//网络制式
                String msg = String.format("\n%s 收到网络变更\n网络类型名称：%s\n网络子类型的名称：%s ,对应网络制式：%s\n网络状态:%s\n",
                        DateUtil.getNowTime(),typeName,subtypeName,networkClass,state);
                tv_systemNetwork_receiver.append(msg);
            }
        }
    };
    /**
     * 2. 注册广播接收器
     */
    @Override
    protected void onStart() {
        super.onStart();
        IntentFilter filter = new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
        registerReceiver(networkReceiver,filter);
    }
    /**
     * 3. 销毁广播接收器
     */
    @Override
    protected void onStop() {
        super.onStop();
        unregisterReceiver(networkReceiver);
    }
}

NetworkUtil-获取数据连接的制式类型

public class NetworkUtil {

    /**
     * 获取数据连接的制式类型
     *
     * @param subType
     * @return
     */
    public static String getNetworkClass(int subType) {
        switch (subType) {
            case TelephonyManager.NETWORK_TYPE_GPRS:
            case TelephonyManager.NETWORK_TYPE_EDGE:
            case TelephonyManager.NETWORK_TYPE_1xRTT:
            case TelephonyManager.NETWORK_TYPE_CDMA:
            case TelephonyManager.NETWORK_TYPE_IDEN:
            case TelephonyManager.NETWORK_TYPE_GSM:
                return "2G";
            case TelephonyManager.NETWORK_TYPE_EVDO_0:
            case TelephonyManager.NETWORK_TYPE_EVDO_A:
            case TelephonyManager.NETWORK_TYPE_UMTS:
            case TelephonyManager.NETWORK_TYPE_HSDPA:
            case TelephonyManager.NETWORK_TYPE_HSUPA:
            case TelephonyManager.NETWORK_TYPE_HSPA:
            case TelephonyManager.NETWORK_TYPE_EVDO_B:
            case TelephonyManager.NETWORK_TYPE_EHRPD:
            case TelephonyManager.NETWORK_TYPE_HSPAP:
            case TelephonyManager.NETWORK_TYPE_TD_SCDMA:
                return "3G";
            case TelephonyManager.NETWORK_TYPE_LTE:
            case TelephonyManager.NETWORK_TYPE_IWLAN:
                return "4G";
            case TelephonyManager.NETWORK_TYPE_NR:
                return "5G";
            default:
                return "未知";
        }
    }
}

✅定时管理器AlarmManager

尽管系统的分钟广播能够实现定时功能（每分钟一次），但是这种定时功能太低级了，既不能定制可长可短的时间间隔，也不能限制定时广播的次数。为此Android提供了专门的定时管理器AlarmManager，它利用系统闹钟定时发送广播，比分钟广播拥有更强大的功能。由于闹钟与震动器同属系统服务，且闹钟的服务名称为ALARM_SERVICE，因此依然调用getSystemService方法获取闹钟管理器的实例，下面是从系统服务中获取闹钟管理器的代码：

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

得到闹钟实例后，即可调用它的各种方法设置闹钟规则了，AlarmManager的常见方法说明如下：

set：设置一次性定时器。第一个参数为定时器类型，通常填AlarmManager.RTC_WAKEUP；第二个参数为期望的执行时刻（单位为毫秒）；第三个参数为待执行的延迟意图（PendingIntent类型）。
setAndAllowWhileIdle：设置一次性定时器，参数说明同set方法，不同之处在于：即使设备处于空闲状态，也会保证执行定时器。因为从Android 6.0开始，set方法在暗屏时不保证发送广播，必须调用setAndAllowWhileIdle方法才能保证发送广播。
setRepeating：设置重复定时器。第一个参数为定时器类型；第二个参数为首次执行时间（单位为毫秒）；第三个参数为下次执行的间隔时间（单位为毫秒）；第四个参数为待执行的延迟意图（PendingIntent类型）。然而从Android 4.4开始，setRepeating方法不保证按时发送广播，只能通过setAndAllowWhileIdle方法间接实现重复定时功能。
cancel：取消指定延迟意图的定时器。

扩展：
以上的方法说明出现了新名词—延迟意图，它是PendingIntent类型，顾名思义，延迟意图不是马上执行的意图，而是延迟若干时间才执行的意图。像之前的活动页面跳转，调用startActivity方法跳到下个页面，此时跳转动作是立刻发生的，所以要传入Intent对象。由于定时器的广播不是立刻发送的，而是时刻到达了才发送广播，因此不能传Intent对象只能传PendingIntent对象。当然意图与延迟意图不止一处区别，它们的差异主要有下列 3 点：
（ 1 ）PendingIntent代表延迟的意图，它指向的组件不会马上激活；而Intent代表实时的意图，一旦被启动，它指向的组件就会马上激活。
（ 2 ）PendingIntent是一类消息的组合，不但包含目标的Intent对象，还包含请求代码、请求方式等信息。
（ 3 ）PendingIntent对象在创建之时便已知晓将要用于活动还是广播，例如调用getActivity方法得到的是活动跳转的延迟意图，调用getBroadcast方法得到的是广播发送的延迟意图。
就闹钟广播的收发过程而言，需要实现 3 个编码步骤：定义定时器的广播接收器、开关定时器的广播接收器、设置定时器的播报规则，分别叙述如下。

第一步：定义广播接收器，同时设置发送方法

public class AlarmReceiver extends BroadcastReceiver {

    private final Context mContext;//上下文
    public static final String ALARM_ACTION = "com.example.myapplication.receiver.alarm";
    /**
     * 构造函数，传入上下文
     * @param context
     */
    public AlarmReceiver(Context context) {
        super();
        this.mContext = context;
    }

    /**
     * 接收广播并 处理
     * @param context
     * @param intent
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent != null && intent.getAction().equals(ALARM_ACTION)){
            Log.d("ning", "收到闹钟广播");
            sendAlarm();//循环重复
        }
    }

    /**
     * 发送闹钟广播
     */
    public void sendAlarm(){
        // 1. 创建一个广播事件的意图
        Intent intent = new Intent(ALARM_ACTION);
        // 2. 创建一个用于广播的延迟意图
        //强烈考虑使用 FLAG IMMUTABLE，仅当某些功能依赖于PendingIntent是可变的时才使用FLAG MUTABLE
        PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext,0,intent, PendingIntent.FLAG_IMMUTABLE);
        // 3. 从系统服务中获取闹钟管理器
        AlarmManager alarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);

        //一次性定时
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){
            //从`Android 6.0`开始，set方法在暗屏时不保证发送广播，必须调用`setAndAllowWhileIdle`方法才能保证发送广播
            alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, 1000, pendingIntent);
        }else {
            alarmManager.set(AlarmManager.RTC_WAKEUP, 1000, pendingIntent) ;
        }
    }
}

为啥发送闹钟的方法在接收类中定义？
因为从Android 6.0开始，set方法在暗屏时不保证发送广播，必须调用setAndAllowWhileIdle方法才能保证发送广播，所以通过在onReceive调用sendAlarm方法来间接实现重复定时功能

第一步：过滤，注册，销毁广播

public class AlarmActivity extends AppCompatActivity implements View.OnClickListener {
    private AlarmReceiver alarmReceiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_alarm);
        findViewById(R.id.bnt_alarm).setOnClickListener(this);
    }
    
    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.bnt_alarm){
            alarmReceiver.sendAlarm();
        }
    }

    /**
     * 过滤,注册广播接收器
     */
    @Override
    protected void onStart() {
        super.onStart();
        //1. 创建发送闹钟接收器的实例，传入getApplicationContext()上下文
        alarmReceiver = new AlarmReceiver(getApplicationContext());
        //2. 过滤
        IntentFilter filter = new IntentFilter(AlarmReceiver.ALARM_ACTION);
        //3. 注册
        registerReceiver(alarmReceiver,filter);
    }

    /**
     * 销毁广播接收器
     */
    @Override
    protected void onStop() {
        super.onStop();
        unregisterReceiver(alarmReceiver);
    }
}

📖9.3 捕获屏幕的变更事件

本节介绍几种屏幕变更事件的捕获办法，包括如何监听竖屏与横屏之间的切换事件、如何监听从App界面回到桌面的事件、如何监听从App界面切换到任务列表的事件等。

✅竖屏与横屏切换

除了系统广播之外，App所处的环境也会影响运行，比如手机有竖屏与横屏两种模式，竖屏时水平方向较短而垂直方向较长，横屏时水平方向较长而垂直方向较短。两种屏幕方向不但造成App界面的展示差异，而且竖屏和横屏切换之际，甚至会打乱App的生命周期。

接下来做个实验观察屏幕方向切换给生命周期带来的影响，现有一个测试页面ActTestActivity.java，重写了主要的生命周期方法，在每个周期方法中都打印状态日志，接着旋转手机使之处于横屏，测试App也跟着转过来，结果如下：整个活动页面又重头创建了一遍无疑非常浪费系统资源。

为了避免横竖屏切换时重新加载界面的情况，Android设计了一种配置变更机制，在指定的环境配置发生变更之时，无须重启活动页面，只需执行特定的变更行为。

只需要在AndroidManifest.xml文件中给指定的activity加入新属性configChanges，如下：

       <activity
            android:name=".activity.AlarmActivity"
            android:exported="true"
            android:configChanges="orientation|screenLayout|screenSize">

新属性configChanges的意思是，在某些情况之下，配置项变更不用重启活动页面，只需调用onConfigurationChanged方法重新设定显示方式。故而只要给该属性指定若干豁免情况，就能避免无谓的页面重启操作了。

✅监听竖屏与横屏之间的切换事件

监听监听竖屏与横屏之间的切换事件只需要在activity中重写onConfigurationChanged方法即可，如下案例：

public class ChangeDirectionActivity extends AppCompatActivity {
   private TextView tv_monitor; // 声明一个文本视图对象
   private String mDesc = ""; // 屏幕变更的述说明
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_change_direction);
       tv_monitor = findViewById(R.id.tv_monitor);
 }
   // 在配置项变更时触发。比如屏幕方向发生变更等等
   // 有的手机需要在系统的“设置→显示”菜单开启“自动旋转屏幕”，或者从顶部下拉，找到“自动旋转”图标并开启
   @Override
   public void onConfigurationChanged(Configuration newConfig) {
       super.onConfigurationChanged(newConfig);
       switch (newConfig.orientation) { // 判断当前的屏幕方向
           case Configuration.ORIENTATION_PORTRAIT: // 切换到竖屏
               mDesc = String.format("%s%s %s\n", mDesc,
                       DateUtil.getNowTime(), "当前屏幕为竖屏方向");
               tv_monitor.setText(mDesc);
               break;
           case Configuration.ORIENTATION_LANDSCAPE: // 切换到横屏
               mDesc = String.format("%s%s %s\n", mDesc,
                       DateUtil.getNowTime(), "当前屏幕为横屏方向");
               tv_monitor.setText(mDesc);
               break;
           default:
               break;
    }
 } 
}

竖屏与横屏之间的切换被监听到，如下图：

如果希望App始终保持竖屏或者横屏界面，可以修改 AndroidManifest.xml，给activity节点添加android:screenOrientation属性，并将该属性设置为portrait表示垂直方向；若该属性为landscape则表示水平方向。

//垂直
<activity android:name=".ActTestActivity"
           android:screenOrientation="portrait"/>
//水平
<activity android:name=".ActTestActivity"
           android:screenOrientation="landscape"/>

✅回到桌面与切换到任务列表

App不但能监测手机屏幕的方向变更，还能获知回到桌面的事件，连打开任务列表的事件也能实时得知。回到桌面与打开任务列表都由按键触发，例如按下主页键会回到桌面，按下任务键会打开任务列表。虽然这两个操作看起来属于按键事件，但系统并未提供相应的按键处理方法，而是通过广播发出事件信息。因此，若想知晓是否回到桌面，以及是否打开任务列表，均需收听系统广播Intent.ACTION_CLOSE_SYSTEM_DIALOGS。至于如何区分当前广播究竟是回到桌面还是打开任务列表，则要从广播意图中获取原因reason字段，该字段值为homekey时表示回到桌面，值为recentapps时表示打开任务列表。接下来演示一下此类广播的接收过程。首先定义一个广播接收器，只处理动作为Intent.ACTION_CLOSE_SYSTEM_DIALOGS的系统广播，并判断它是主页键来源还是任务键来源。该接收器的代码定义示例如下：

第一步： 定义一个返回到桌面的广播接收器desktopRevceiver

第二步： 在进入画中画模式或退出画中画模式时触发处理，重写onPictureInPictureModeChanged

第三步： 在oncreate中过滤，注册返回到桌面的广播接收器

第四步： 销毁广播接收器

public class ReturnDesktopActivity extends AppCompatActivity {
    /**
     * 定义一个返回到桌面的广播接收器
     */
    BroadcastReceiver desktopRevceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent != null && intent.getAction().equals(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)) {
                String reason = intent.getStringExtra("reason");
                // 按下了主页键或者任务键
                if (!TextUtils.isEmpty(reason) && (reason.equals("homekey") || reason.equals("recentapps"))) {
                    //Android 8.0 开始才提供画中画模式
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                        //创建画中画模式的参数构建器
                        PictureInPictureParams.Builder builder = new PictureInPictureParams.Builder();
                        //设置宽高比例值，第一个参数表示分子，第二个参数表示分母
                        //如下10/5=2，表示画中画窗口的宽高时高度的两倍
                        Rational rational = new Rational(10, 5);
                        builder.setAspectRatio(rational);
                        //进入画中画模式
                        enterPictureInPictureMode(builder.build());
                    }
                }
            }
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_return_desktop);

        IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
        registerReceiver(desktopRevceiver,filter);
    }

    /**
     * 在进入画中画模式或退出画中画模式时触发
     */
    @Override
    public void onPictureInPictureModeChanged(boolean isInPictureInPictureMode, @NonNull Configuration newConfig) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig);
        }
        if (isInPictureInPictureMode) {
            Log.d("ning", "进入画中画模式 ");
        } else {
            Log.d("ning", "退出画中画模式 ");
        }
    }


    /**
     * 销毁广播接收器
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(desktopRevceiver);
    }
}

✅小结

本章主要介绍广播组件—Broadcast的常见用法，包括：正确收发应用广播（收发标准广播、收发有序广播、收发静态广播）、正确监听系统广播（接收分钟到达广播、接收网络变更广播、定时管理器AlarmManager）、正确捕获屏幕的变更事件（竖屏与横屏切换、回到桌面与切到任务列表）。

通过本章的学习，我们应该能掌握以下 3 种开发技能：

（ 1 ）了解广播的应用场景，并学会正确收发应用广播。

（ 2 ）了解常见的系统广播，并学会正确监听系统广播。

（ 3 ）了解屏幕变更的产生条件，并学会捕捉屏幕变更事件。

✅课后练习题

一、填空题

1 ．活动只能一对一通信，而广播可以（一对多）通信。

2 ．通过静态方式注册广播，就要在AndroidManifest.xml中添加名为（receiver）的接收器标签。

3 ．（PendingIntent）代表延迟的意图，它指向的组件不会马上激活。

4 ．手机的屏幕方向默认是（竖屏）。

5 ．开启（画中画）模式之后，可将App界面缩小为屏幕上的一个方块。

二、判断题（正确打√，错误打×）

1 ．标准广播是无序的，有可能后面注册的接收器反而比前面注册的接收器先收到广播。（ √ ）

2 ．通过setPriority方法设置优先级，优先级越小的接收器，越先收到有序广播。（ × ）

3 ．普通应用能够通过静态注册方式来监听系统广播。（　×　）

4 ．闹钟管理器AlarmManager的setRepeating方法保证能够按时发送广播。（　×　）

5 ．旋转手机使得屏幕由竖屏变为横屏，App默认会重新加载整个页面（先销毁原页面再创建新页面）。（√）

三、选择题

1 ．在接收器内部调用（　A ）方法，就会中断有序广播。

A．abortBroadcast

B．cancelBroadcast

C．interrupt

D．sendBroadcast

2 ．android.permission.VIBRATE表达的是（　D　）权限。

A．呼吸灯

B．麦克风

C．闹钟

D．震动器

3 ．网络类型（　B　）表示手机的数据连接（含2G/3G/4G/5G）。

A．TYPE_WIFI

B．TYPE_MOBILE

C．TYPE_WIMAX

D．TYPE_ETHERNET

4 ．网络状态（　B　）表示已经连接。

A．CONNECTING

B．CONNECTED

C．SUSPENDED

D．DISCONNECTED

5 ．（　ABCD　）属于configChanges属性配置的显示变更豁免情况。

A．orientation

B．screenLayout

C．screenSize

D．keyboard

四、简答题

请简要描述收发标准广播的主要步骤。

定义广播接收器
过滤action，注册广播接收
处理广播消息
销毁广播

五、动手练习

请上机实验下列 3 项练习：

1 ．通过设置不同的优先级，实现有序广播的正确收发。

2 ．通过监听网络变更广播，判断当前位于哪种网络。

3 ．通过监听回到桌面广播，实现App的画中画模式。

你认为这篇文章怎么样？

昵称

邮箱

网址

按正序
按倒序
按热度

第9章 广播组件Broadcast

# 第 9 章 广播组件Broadcast

# 📖9.1 收发应用广播

# ✅收发标准广播

# ✅收发有序广播

# ✅收发静态广播

# ✅总结

# 📖9.2 监听系统广播

# ✅接收分钟到达广播

# ✅接收网络变更广播

# ✅定时管理器AlarmManager

# 📖9.3 捕获屏幕的变更事件

# ✅竖屏与横屏切换

# ✅监听竖屏与横屏之间的切换事件

# ✅回到桌面与切换到任务列表

# ✅小结

# ✅课后练习题