广播组件Broadcast

1.BroadcastReceiver的定义

Broadcast直译广播，我们举个形象的例子来帮我理解下BroadcastReceiver，记得以前读书 的时候，每个班级都会有一个挂在墙上的大喇叭，用来广播一些通知，比如，开学要去搬书，广播： “每个班级找几个同学教务处拿书”，发出这个广播后，所有同学都会在同一时刻收到这条广播通知， 收到，但不是每个同学都会去搬书，一般去搬书的都是班里的"大力士"，这群"大力士"接到这条 广播后就会动身去把书搬回可是！
——好吧，上面这个就是一个广播传递的一个很形象的例子：
大喇叭–> 发送广播 --> 所有学生都能收到广播 --> 大力士处理广播

回到我们的概念，其实BroadcastReceiver就是应用程序间的全局大喇叭，即通信的一个手段， 系统自己在很多时候都会发送广播，比如电量低或者充足，刚启动完，插入耳机，输入法改变等， 发生这些时间，系统都会发送广播，这个叫系统广播，每个APP都会收到，如果你想让你的应用在接收到 这个广播的时候做一些操作，比如：系统开机后，偷偷后台跑服务，哈哈，这个时候你只需要为你的应用 注册一个用于监视开机的BroadcastReceiver，当接收到开机广播就做写偷偷摸摸的勾当~ 当然我们也可以自己发广播，比如：接到服务端推送信息，用户在别处登录，然后应该强制用户下线回到 登陆界面，并提示在别处登录 ，当然，这些等下都会写一个简单的示例帮大家了解广播给我们带来的好处~

2.两种广播类型：

3.接收系统广播

1）两种注册广播的方式

系统在某些时候会发送相应的系统广播，下面我们就来让我们的APP接收系统广播， 接收之前，还需要为我们的APP注册广播接收器哦！而注册的方法又分为以下两种：动态与静态！

2）动态注册实例(监听网络状态变化)

代码示例：
效果图：

好的，一开始是没有联网的，即没有打开wifi，点击打开wifi过了一会儿就出现Toast提示了~ 实现起来也很简单！

代码实现：
自定义一个BroadcastReceiver，在onReceive()方法中完成广播要处理的事务，比如这里的提示Toast信息： MyBRReceiver.java

public class MyBRReceiver extends BroadcastReceiver{
    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context,"网络状态发生改变~",Toast.LENGTH_SHORT).show();
    }
}

MainActivity.java中动态注册广播：

public class MainActivity extends AppCompatActivity {

    MyBRReceiver myReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //核心部分代码：
        myReceiver = new MyBRReceiver();
        IntentFilter itFilter = new IntentFilter();
        itFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
        registerReceiver(myReceiver, itFilter);
    }

    //别忘了将广播取消掉哦~
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(myReceiver);
    }
}

动态注册简单吧~但是动态注册有个缺点就是需要程序启动才可以接收广播，假如我们需要程序 没有启动，但是还是能接收广播的话，那么就需要注册静态广播了！

3）静态注册实例(接收开机广播)

代码示例：
这里就没有示意图了，直接看代码实现吧~
代码实现：
1.自定义一个BroadcastReceiver，重写onReceive完成事务处理

public class BootCompleteReceiver extends BroadcastReceiver {
    private final String ACTION_BOOT = "android.intent.action.BOOT_COMPLETED";
    @Override
    public void onReceive(Context context, Intent intent) {
    if (ACTION_BOOT.equals(intent.getAction()))
        Toast.makeText(context, "开机完毕~", Toast.LENGTH_LONG).show();
    }
}

2.在AndroidManifest.xml中对该BroadcastReceiver进行注册，添加开机广播的intent-filter!
对了，别忘了加上android.permission.RECEIVE_BOOT_COMPLETED的权限哦！

<receiver android:name=".BootCompleteReceiver">
    <intent-filter>
        <action android:name = "android.intent.cation.BOOT_COMPLETED">
    </intent-filter>
</receiver>

<!-- 权限 -->
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

好的，然后你重启下手机会发现过了一会儿，就会弹出开机完毕这个Toast的了~ 另外，Android 4.3以上的版本，是允许将程序安装到SD卡上的，假如你的程序是安装在SD上 的，就会收不到开机广播，具体原因以及解决方法下一节再详细讲解！

4)使用广播的注意事项：

使用广播要注意：
不要在广播里添加过多逻辑或者进行任何耗时操作,因为在广播中是不允许开辟线程的, 当onReceiver( )方法运行较长时间(超过10秒)还没有结束的话,那么程序会报错(ANR), 广播更多的时候扮演的是一个打开其他组件的角色,比如启动Service,Notification提示, Activity等！

4.发送广播

嗯，上面我们都是接收系统的广播，系统发我们收，我们不能老这么被动，总得主动点是吧！ 另外，明天七夕，程序猿们好好把握，争取脱单，哈哈！好的，说回广播，我们自己主动发广播！ 下面我们就来看下怎么实现！

如何发送： 发送广播前，要先定义一个接收器，先确定目标，然后再告白！_{(●’◡’●)}

代码示例：(标准广播)
MyBroadcastReceiver.java

public class MyBroadcastReceiver extends BroadcastReceiver {
    private final String ACTION_BOOT = "com.example.broadcasttest.MY_BROADCAST";
    @Override
    public void onReceive(Context context, Intent intent) {
        if(ACTION_BOOT.equals(intent.getAction()))
        Toast.makeText(context, "收到告白啦~",Toast.LENGTH_SHORT).show();
    }
}

然后AndroidManifest.xml中注册下，写上Intent-filter：

<receiver android:name=".MyBroadcastReceiver">
    <intent-filter>
        <action android:name="com.example.broadcasttest.MY_BROADCAST"/>
    </intent-filter>
</receiver>

好的，接下来我们把上面这个程序项目运行下，然后关掉，接下来我们新建一个项目， 在这个项目里完成广播发送~新建Demo2，布局就一个简单按钮，然后在MainActivity中完成广播发送：
MainActivity.java:

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button btn_send = (Button) findViewById(R.id.btn_send);
        btn_send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                sendBroadcast(new Intent("com.example.broadcasttest.MY_BROADCAST"));
            }
        });
    }
}

5.本地广播

1）核心用法：

PS：本地广播无法通过静态注册方式来接受,相比起系统全局广播更加高效

2）注意事项：

3）代码示例(别处登陆踢用户下线)：

像微信一样，正在运行的微信，如果我们用别的手机再次登陆自己的账号，前面这个是会提醒账户 在别的终端登录这样，然后把我们打开的所有Activity都关掉，然后回到登陆页面这样~
下面我们就来写个简单的例子：

代码实现：
Step 1：准备一个关闭所有Activity的ActivityCollector ，这里之前用前面Activity提供的那个!
ActivityCollector.java

public class ActivityCollector {
    private static List<Activity> activities = new ArrayList<Activity>();
    public static void addActivity(Activity activity) {
        activities.add(activity);
    }
    public static void removeActivity(Activity activity) {
        activities.remove(activity);
    }
    public static void finishAll() {
        for (Activity activity : activities) {
            if (!activity.isFinishing()) {
                activity.finish();
            }
        }
    }
}

Step 2：先写要给简单的BaseActivity，用来继承，接着写下登陆界面！

public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityCollector.addActivity(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityCollector.removeActivity(this);
    }
}

LoginActivity.java:

public class LoginActivity extends BaseActivity implements View.OnClickListener{


    private SharedPreferences pref;
    private SharedPreferences.Editor editor;

    private EditText edit_user;
    private EditText edit_pawd;
    private Button btn_login;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        pref = PreferenceManager.getDefaultSharedPreferences(this);

        bindViews();
    }

    private void bindViews() {
        edit_user = (EditText) findViewById(R.id.edit_user);
        edit_pawd = (EditText) findViewById(R.id.edit_pawd);
        btn_login = (Button) findViewById(R.id.btn_login);
        btn_login.setOnClickListener(this);
    }

    @Override
    protected void onStart() {
        super.onStart();
        if(!pref.getString("user","").equals("")){
            edit_user.setText(pref.getString("user",""));
            edit_pawd.setText(pref.getString("pawd",""));
        }
    }

    @Override
    public void onClick(View v) {
        String user = edit_user.getText().toString();
        String pawd = edit_pawd.getText().toString();
        if(user.equals("123")&&pawd.equals("123")){
            editor = pref.edit();
            editor.putString("user", user);
            editor.putString("pawd", pawd);
            editor.commit();
            Intent intent = new Intent(LoginActivity.this, MainActivity.class);
            startActivity(intent);
            Toast.makeText(LoginActivity.this,"哟，竟然蒙对了~",Toast.LENGTH_SHORT).show();
            finish();
        }else{
            Toast.makeText(LoginActivity.this,"这么简单都输出，脑子呢？",Toast.LENGTH_SHORT).show();
        }

    }
}

Step 3：自定义一个BroadcastReceiver，在onReceive里完成弹出对话框操作，以及启动登陆页面： MyBcReceiver.java

public class MyBcReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(final Context context, Intent intent) {
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(context);
        dialogBuilder.setTitle("警告：");
        dialogBuilder.setMessage("您的账号在别处登录，请重新登陆~");
        dialogBuilder.setCancelable(false);
        dialogBuilder.setPositiveButton("确定",
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        ActivityCollector.finishAll();
                        Intent intent = new Intent(context, LoginActivity.class);
                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        context.startActivity(intent);
                    }
                });
        AlertDialog alertDialog = dialogBuilder.create();
        alertDialog.getWindow().setType(
                WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
        alertDialog.show();
    }
}

别忘了AndroidManifest.xml中加上系统对话框权限： < uses-permission android:name=“android.permission.SYSTEM_ALERT_WINDOW” />

Step 4：在MainActivity中，实例化localBroadcastManager，拿他完成相关操作，另外销毁时 注意unregisterReceiver！
MainActivity.java

public class MainActivity extends BaseActivity {

    private MyBcReceiver localReceiver;
    private LocalBroadcastManager localBroadcastManager;
    private IntentFilter intentFilter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        localBroadcastManager = LocalBroadcastManager.getInstance(this);

        //初始化广播接收者，设置过滤器
        localReceiver = new MyBcReceiver();
        intentFilter = new IntentFilter();
        intentFilter.addAction("com.jay.mybcreceiver.LOGIN_OTHER");
        localBroadcastManager.registerReceiver(localReceiver, intentFilter);

        Button btn_send = (Button) findViewById(R.id.btn_send);
        btn_send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent("com.jay.mybcreceiver.LOGIN_OTHER");
                localBroadcastManager.sendBroadcast(intent);
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        localBroadcastManager.unregisterReceiver(localReceiver);
    }
}

6.Android 4.3以上版本监听开机启动广播的问题解决

在Android 4.3以上的版本，允许我们将应用安装在SD上，我们都知道是系统开机 间隔一小段时间后，才装载SD卡的，这样我们的应用就可能监听不到这个广播了！ 所以我们需要既监听开机广播又监听SD卡挂载广播！

另外，有些手机可能并没有SD卡，所以这两个广播监听我们不能写到同一个Intetn-filter里 而是应该写成两个，配置代码如下：

<receiver android:name=".MyBroadcastReceiver">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED"/>
    </intent-filter>
    <intent-filter>
        <action android:name="ANDROID.INTENT.ACTION.MEDIA_MOUNTED"/>
        <action android:name="ANDROID.INTENT.ACTION.MEDIA_UNMOUNTED"/>
        <data android:scheme="file"/>
    </intent-filter>
</receiver>

7.常用的系统广播总结：

最后给大家提供下我们平常可能会用到的一些系统广播吧：

intent.action.AIRPLANE_MODE;
//关闭或打开飞行模式时的广播

Intent.ACTION_BATTERY_CHANGED;
//充电状态，或者电池的电量发生变化
//电池的充电状态、电荷级别改变，不能通过组建声明接收这个广播，只有通过Context.registerReceiver()注册

Intent.ACTION_BATTERY_LOW;
//表示电池电量低

Intent.ACTION_BATTERY_OKAY;
//表示电池电量充足，即从电池电量低变化到饱满时会发出广播

Intent.ACTION_BOOT_COMPLETED;
//在系统启动完成后，这个动作被广播一次（只有一次）。

Intent.ACTION_CAMERA_BUTTON;
//按下照相时的拍照按键(硬件按键)时发出的广播

Intent.ACTION_CLOSE_SYSTEM_DIALOGS;
//当屏幕超时进行锁屏时,当用户按下电源按钮,长按或短按(不管有没跳出话框)，进行锁屏时,android系统都会广播此Action消息

Intent.ACTION_CONFIGURATION_CHANGED;
//设备当前设置被改变时发出的广播(包括的改变:界面语言，设备方向，等，请参考Configuration.java)

Intent.ACTION_DATE_CHANGED;
//设备日期发生改变时会发出此广播

Intent.ACTION_DEVICE_STORAGE_LOW;
//设备内存不足时发出的广播,此广播只能由系统使用，其它APP不可用？

Intent.ACTION_DEVICE_STORAGE_OK;
//设备内存从不足到充足时发出的广播,此广播只能由系统使用，其它APP不可用？

Intent.ACTION_DOCK_EVENT;
//
//发出此广播的地方frameworks\base\services\java\com\android\server\DockObserver.java

Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE;
移动APP完成之后，发出的广播(移动是指:APP2SD)

Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE;
//正在移动APP时，发出的广播(移动是指:APP2SD)

Intent.ACTION_GTALK_SERVICE_CONNECTED;
//Gtalk已建立连接时发出的广播

Intent.ACTION_GTALK_SERVICE_DISCONNECTED;
//Gtalk已断开连接时发出的广播

Intent.ACTION_HEADSET_PLUG;
//在耳机口上插入耳机时发出的广播

Intent.ACTION_INPUT_METHOD_CHANGED;
//改变输入法时发出的广播

Intent.ACTION_LOCALE_CHANGED;
//设备当前区域设置已更改时发出的广播

Intent.ACTION_MANAGE_PACKAGE_STORAGE;
//

Intent.ACTION_MEDIA_BAD_REMOVAL;
//未正确移除SD卡(正确移除SD卡的方法:设置--SD卡和设备内存--卸载SD卡)，但已把SD卡取出来时发出的广播
//广播：扩展介质（扩展卡）已经从 SD 卡插槽拔出，但是挂载点 (mount point) 还没解除 (unmount)

Intent.ACTION_MEDIA_BUTTON;
//按下"Media Button" 按键时发出的广播,假如有"Media Button" 按键的话(硬件按键)

Intent.ACTION_MEDIA_CHECKING;
//插入外部储存装置，比如SD卡时，系统会检验SD卡，此时发出的广播?
Intent.ACTION_MEDIA_EJECT;
//已拔掉外部大容量储存设备发出的广播（比如SD卡，或移动硬盘）,不管有没有正确卸载都会发出此广播?
//广播：用户想要移除扩展介质（拔掉扩展卡）。
Intent.ACTION_MEDIA_MOUNTED;
//插入SD卡并且已正确安装（识别）时发出的广播
//广播：扩展介质被插入，而且已经被挂载。
Intent.ACTION_MEDIA_NOFS;
//
Intent.ACTION_MEDIA_REMOVED;
//外部储存设备已被移除，不管有没正确卸载,都会发出此广播？
// 广播：扩展介质被移除。
Intent.ACTION_MEDIA_SCANNER_FINISHED;
//广播：已经扫描完介质的一个目录
Intent.ACTION_MEDIA_SCANNER_SCAN_FILE;
//
Intent.ACTION_MEDIA_SCANNER_STARTED;
//广播：开始扫描介质的一个目录

Intent.ACTION_MEDIA_SHARED;
// 广播：扩展介质的挂载被解除 (unmount)，因为它已经作为 USB 大容量存储被共享。
 Intent.ACTION_MEDIA_UNMOUNTABLE;
//
Intent.ACTION_MEDIA_UNMOUNTED
// 广播：扩展介质存在，但是还没有被挂载 (mount)。
Intent.ACTION_NEW_OUTGOING_CALL;

Intent.ACTION_PACKAGE_ADDED;
//成功的安装APK之后
//广播：设备上新安装了一个应用程序包。
//一个新应用包已经安装在设备上，数据包括包名（最新安装的包程序不能接收到这个广播）
 Intent.ACTION_PACKAGE_CHANGED;
//一个已存在的应用程序包已经改变，包括包名
Intent.ACTION_PACKAGE_DATA_CLEARED;
//清除一个应用程序的数据时发出的广播(在设置－－应用管理－－选中某个应用，之后点清除数据时?)
//用户已经清除一个包的数据，包括包名（清除包程序不能接收到这个广播）

Intent.ACTION_PACKAGE_INSTALL;
//触发一个下载并且完成安装时发出的广播，比如在电子市场里下载应用？
//
Intent.ACTION_PACKAGE_REMOVED;
//成功的删除某个APK之后发出的广播
//一个已存在的应用程序包已经从设备上移除，包括包名（正在被安装的包程序不能接收到这个广播）

Intent.ACTION_PACKAGE_REPLACED;
//替换一个现有的安装包时发出的广播（不管现在安装的APP比之前的新还是旧，都会发出此广播？）
Intent.ACTION_PACKAGE_RESTARTED;
//用户重新开始一个包，包的所有进程将被杀死，所有与其联系的运行时间状态应该被移除，包括包名（重新开始包程序不能接收到这个广播）
Intent.ACTION_POWER_CONNECTED;
//插上外部电源时发出的广播
Intent.ACTION_POWER_DISCONNECTED;
//已断开外部电源连接时发出的广播
Intent.ACTION_PROVIDER_CHANGED;
//

Intent.ACTION_REBOOT;
//重启设备时的广播

Intent.ACTION_SCREEN_OFF;
//屏幕被关闭之后的广播

Intent.ACTION_SCREEN_ON;
//屏幕被打开之后的广播

Intent.ACTION_SHUTDOWN;
//关闭系统时发出的广播

Intent.ACTION_TIMEZONE_CHANGED;
//时区发生改变时发出的广播

Intent.ACTION_TIME_CHANGED;
//时间被设置时发出的广播

Intent.ACTION_TIME_TICK;
//广播：当前时间已经变化（正常的时间流逝）。
//当前时间改变，每分钟都发送，不能通过组件声明来接收，只有通过Context.registerReceiver()方法来注册

Intent.ACTION_UID_REMOVED;
//一个用户ID已经从系统中移除发出的广播
//

Intent.ACTION_UMS_CONNECTED;
//设备已进入USB大容量储存状态时发出的广播？

Intent.ACTION_UMS_DISCONNECTED;
//设备已从USB大容量储存状态转为正常状态时发出的广播？

Intent.ACTION_USER_PRESENT;
//

Intent.ACTION_WALLPAPER_CHANGED;
//设备墙纸已改变时发出的广播

8.收发应用广播

8.1 收发标准广播

1．发送标准广播

广播的发送操作很简单，一共只有两步：先创建意图对象，再调用sendBroadcast方法发送广播即可。不过要注意，意图对象需要指定广播的动作名称，如同每个路由器都得给自己的WiFi起个名称一般，这样接收方才能根据动作名称判断来的是李逵而不是李鬼。下面是通过点击按钮发送广播的活动页面代码：

public class BroadStandardActivity extends AppCompatActivity implements
View.OnClickListener {
private final static String TAG = "BroadStandardActivity";
// 这是广播的动作名称，发送广播和接收广播都以它作为接头暗号
private final static String STANDARD_ACTION =
"com.example.chapter09.standard";
private TextView tv_standard; // 声明一个文本视图对象
private String mDesc = "这里查看标准广播的收听信息";
@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(mDesc);
findViewById(R.id.btn_send_standard).setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.btn_send_standard) {
Intent intent = new Intent(STANDARD_ACTION); // 创建指定动作的意图
sendBroadcast(intent); // 发送标准广播
}
}
}

2．定义广播接收器

广播发出来之后，还得有设备去接收广播，也就是需要广播接收器。接收器主要规定两个事情，一个是接收什么样的广播，另一个是收到广播以后要做什么。由于接收器的处理逻辑大同小异，因此Android提供了抽象之后的接收器基类BroadcastReceiver，开发者自定义的接收器都从BroadcastReceiver派生而来。新定义的接收器需要重写onReceive方法，方法内部先判断当前广播是否符合待接收的广播名称，校验通过再开展后续的业务逻辑。下面是广播接收器的一个定义代码例子：

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

3．开关广播接收器

为了避免资源浪费，还要求合理使用接收器。就像WiFi上网，需要上网时才打开WiFi，不需要上网时就关闭WiFi。广播接收器也是如此，活动页面启动之后才注册接收器，活动页面停止之际就注销接收器。在注册接收器的时候，允许事先指定只接收某种类型的广播，即通过意图过滤器挑选动作名称一致的广播。接收器的注册与注销代码示例如下：

private StandardReceiver standardReceiver; // 声明一个标准广播的接收器实例
@Override
protected void onStart() {
super.onStart();
standardReceiver = new StandardReceiver(); // 创建一个标准广播的接收器
// 创建一个意图过滤器，只处理STANDARD_ACTION的广播
IntentFilter filter = new IntentFilter(STANDARD_ACTION);
registerReceiver(standardReceiver, filter); // 注册接收器，注册之后才能正常接收广播
}
@Override
protected void onStop() {
super.onStop();
unregisterReceiver(standardReceiver); // 注销接收器，注销之后就不再接收广播
}

完成上述3个步骤后，便构建了广播从发送到接收的完整流程。运行测试App，初始的广播界面如图9-1所示，点击发送按钮触发广播，界面下方立刻刷新广播日志，如图9-2所示，可见接收器正确收到广播并成功打印日志。

8.2 收发有序广播

由于广播没指定唯一的接收者，因此可能存在多个接收器，每个接收器都拥有自己的处理逻辑。这种机制固然灵活，却不够严谨，因为不同接收器之间也许有矛盾。

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

至于如何实现有序广播的收发，则需完成以下的3个编码步骤：

1．发送广播时要注明这是个有序广播

之前发送标准广播用到了sendBroadcast方法，可是该方法发出来的广播是无序的。只有调用sendOrderedBroadcast方法才能发送有序广播，具体的发送代码示例如下：

Intent intent = new Intent(ORDER_ACTION); // 创建一个指定动作的意图
sendOrderedBroadcast(intent, null); // 发送有序广播

2．定义有序广播的接收器

接收器的定义代码基本不变，也要从BroadcastReceiver继承而来，唯一的区别是有序广播的接收器允许中断广播。倘若在接收器的内部代码调用abortBroadcast方法，就会中断有序广播，使得后面的接收器不能再接收该广播。下面是有序广播的两个接收器代码例子：

private OrderAReceiver orderAReceiver; // 声明有序广播接收器A的实例
// 定义一个有序广播的接收器A
private class OrderAReceiver extends BroadcastReceiver {
// 一旦接收到有序广播，马上触发接收器的onReceive方法
@Override
public void onReceive(Context context, Intent intent) {
if (intent != null && intent.getAction().equals(ORDER_ACTION)) {
String desc = String.format("%s%s 接收器A收到一个有序广播\n",tv_order.getText().toString(),
DateUtil.getNowTime());
tv_order.setText(desc);
if (ck_abort.isChecked()) {
abortBroadcast(); // 中断广播，此时后面的接收器无法收到该广播
}
}
}
}
private OrderBReceiver orderBReceiver; // 声明有序广播接收器B的实例
// 定义一个有序广播的接收器B
private class OrderBReceiver extends BroadcastReceiver {
// 一旦接收到有序广播B，马上触发接收器的onReceive方法
@Override
public void onReceive(Context context, Intent intent) {
if (intent != null && intent.getAction().equals(ORDER_ACTION)) {
String desc = String.format("%s%s 接收器B收到一个有序广播\n",
tv_order.getText().toString(),
DateUtil.getNowTime());
tv_order.setText(desc);
if (ck_abort.isChecked()) {
abortBroadcast(); // 中断广播，此时后面的接收器无法收到该广播
}
}
}
}

3．注册有序广播的多个接收器

接收器的注册操作同样调用registerReceiver方法，为了给接收器排队，还需调用意图过滤器的setPriority方法设置优先级，优先级越大的接收器，越先收到有序广播。如果不设置优先级，或者两个接收器的优先级相等，那么越早注册的接收器，会越先收到有序广播。譬如以下的广播注册代码，尽管接收器A更早注册，但接收器B的优先级更高，结果先收到广播的应当是接收器B。

orderAReceiver = new OrderAReceiver(); // 创建一个有序广播的接收器A
// 创建一个意图过滤器A，只处理ORDER_ACTION的广播
IntentFilter filterA = new IntentFilter(ORDER_ACTION);
filterA.setPriority(8); // 设置过滤器A的优先级，数值越大优先级越高
registerReceiver(orderAReceiver, filterA); // 注册接收器A，注册之后才能正常接收广播
orderBReceiver = new OrderBReceiver(); // 创建一个有序广播的接收器B
// 创建一个意图过滤器A，只处理ORDER_ACTION的广播
IntentFilter filterB = new IntentFilter(ORDER_ACTION);
filterB.setPriority(10); // 设置过滤器B的优先级，数值越大优先级越高
registerReceiver(orderBReceiver, filterB); // 注册接收器B，注册之后才能正常接收广播

接下来通过测试页面演示有序广播的收发，如果没要求中断广播，则有序广播的接收界面如图9-3所示，此时接收器B和接收器A依次收到了广播；如果要求中断广播，则有序广播的接收界面如图9-4所示，此时只有接收器B收到了广播。

8.3 收发静态广播

前面几节使用广播之时，无一例外在代码中注册接收器。可是同为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，弹出如图9-5所示的组件创建对话框。

在组件创建对话框的Class Name一栏填写接收器的类名，比如ShockReceiver，再单击对话框右下角的Finish按钮。之后Android Studio自动在receiver包内创建代码文件ShockReceiver.java，且接收器的默认代码如下所示：

public class ShockReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
}
}

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

<receiver
android:name=".receiver.ShockReceiver"
android:enabled="true"
android:exported="true"></receiver>

然而自动生成的接收器不仅啥都没干，还丢出一个异常UnsupportedOperationException。明显这个接收器没法用，为了感知到接收器正在工作，可以考虑在onReceive方法中记录日志，也可在该方法中震动手机。因为ShockReceiver未依附于任何活动，自然无法直接操作界面控件，所以只能观察程序日
志，或者干脆让手机摇晃起来。实现手机震动之时，要调用getSystemService方法，先从系统服务VIBRATOR_SERVICE获取震动管理器Vibrator，再调用震动管理器的vibrate方法震动手机。包含手机震动功能的接收器代码示例如下：

public class ShockReceiver extends BroadcastReceiver {
private static final String TAG = "ShockReceiver";
// 静态注册时候的action、发送广播时的action、接收广播时的action，三者需要保持一致
public static final String SHOCK_ACTION = "com.example.chapter09.shock";
@Override
public void onReceive(Context context, Intent intent) {
Log.d(TAG, "onReceive");
if (intent.getAction().equals(ShockReceiver.SHOCK_ACTION)){
// 从系统服务中获取震动管理器
Vibrator vb = (Vibrator)
context.getSystemService(Context.VIBRATOR_SERVICE);
vb.vibrate(500); // 命令震动器吱吱个若干秒，这里的500表示500毫秒
}
}
}

由于震动手机需要申请对应的权限，因此打开AndroidManifest.xml添加以下的权限申请配置：

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

此外，接收器代码定义了一个动作名称，其值为“com.example.chapter09.shock”，表示onReceive方法只处理过滤该动作之后的广播，从而提高接收效率。除了在代码中过滤之外，还能修改AndroidManifest.xml，在receiver节点内部增加intent-filter标签加以过滤，添加过滤配置后的receiver节点信息如下所示：

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

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

String receiverPath = "com.example.chapter09.receiver.ShockReceiver";
Intent intent = new Intent(ShockReceiver.SHOCK_ACTION); // 创建一个指定动作的意图
// 发送静态广播之时，需要通过setComponent方法指定接收器的完整路径
ComponentName componentName = new ComponentName(this, receiverPath);
intent.setComponent(componentName); // 设置意图的组件信息
sendBroadcast(intent); // 发送静态广播

经过上述的编码以及配置工作，总算完成了静态广播的发送与接收流程。特别注意，经过整改的静态注册只适用于接收App自身的广播，不能接收系统广播，也不能接收其他应用的广播。

运行测试App，初始的广播发送界面如图9-6所示，点击发送按钮触发静态广播，接着接收器收到广播信息，手机随之震动了若干时间，说明静态注册的接收器奏效了。

9.监听系统广播

9.1接收分钟到达广播

除了应用自身的广播，系统也会发出各式各样的广播，通过监听这些系统广播，App能够得知周围环境发生了什么变化，从而按照最新环境调整运行逻辑。分钟到达广播便是系统广播之一，每当时钟到达某分零秒，也就是跳到新的分钟时刻，系统就通过全局大喇叭播报分钟广播。App只要在运行时侦听分钟广播Intent.ACTION_TIME_TICK，即可在分钟切换之际收到广播信息。

由于分钟广播属于系统广播，发送操作已经交给系统了，因此若要侦听分钟广播，App只需实现该广播的接收操作。具体到编码上，接收分钟广播可分解为下面3个步骤：
步骤一，定义一个分钟广播的接收器，并重写接收器的onReceive方法，补充收到广播之后的处理逻辑。
步骤二，重写活动页面的onStart方法，添加广播接收器的注册代码，注意要让接收器过滤分钟到达广播Intent.ACTION_TIME_TICK。
步骤三，重写活动页面的onStop方法，添加广播接收器的注销代码。

根据上述逻辑编写活动代码，使之监听系统发来的分钟广播，下面是演示页面的活动代码例子：

public class SystemMinuteActivity extends AppCompatActivity {
private TextView tv_minute; // 声明一个文本视图对象
private String desc = "开始侦听分钟广播，请稍等。注意要保持屏幕亮着，才能正常收到广播";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_system_minute);
tv_minute = findViewById(R.id.tv_minute);
tv_minute.setText(desc);
}
@Override
protected void onStart() {
super.onStart();
timeReceiver = new TimeReceiver(); // 创建一个分钟变更的广播接收器
// 创建一个意图过滤器，只处理系统分钟变化的广播
IntentFilter filter = new IntentFilter(Intent.ACTION_TIME_TICK);
registerReceiver(timeReceiver, filter); // 注册接收器，注册之后才能正常接收广播
}
@Override
protected void onStop() {
super.onStop();
unregisterReceiver(timeReceiver); // 注销接收器，注销之后就不再接收广播
}
private TimeReceiver timeReceiver; // 声明一个分钟广播的接收器实例
// 定义一个分钟广播的接收器
private class TimeReceiver extends BroadcastReceiver {
// 一旦接收到分钟变更的广播，马上触发接收器的onReceive方法
@Override
public void onReceive(Context context, Intent intent) {
if (intent != null) {
desc = String.format("%s\n%s 收到一个分钟到达广播%s", desc,
DateUtil.getNowTime(), intent.getAction());
tv_minute.setText(desc);
}
}
}
}

运行测试App，初始界面如图9-7所示，稍等片刻直到下一分钟到来，界面马上多了广播日志，如图9-8所示，可见此时准点收到了系统发出的分钟到达广播。

9.2 接收网络变更广播

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

接收网络变更广播可分解为下面3个步骤：
步骤一，定义一个网络广播的接收器，并重写接收器的onReceive方法，补充收到广播之后的处理逻辑。
步骤二，重写活动页面的onStart方法，添加广播接收器的注册代码，注意要让接收器过滤网络变更广播android.net.conn.CONNECTIVITY_CHANGE。
步骤三，重写活动页面的onStop方法，添加广播接收器的注销代码。

上述3个步骤中，尤为注意第一步骤，因为onReceive方法只表示收到了网络广播，至于变成哪种网络，还得把广播消息解包才知道是怎么回事。网络广播携带的包裹中有个名为networkInfo的对象，其数据类型为NetworkInfo，于是调用NetworkInfo对象的相关方法，即可获取详细的网络信息。下面是NetworkInfo的常用方法说明：
getType：获取网络类型。网络类型的取值说明见表9-1。

getTypeName：获取网络类型的名称。
getSubtype：获取网络子类型。当网络类型为数据连接时，子类型为2G/3G/4G的细分类型，如CDMA、EVDO、HSDPA、LTE等。网络子类型的取值说明见表9-2。

表9-2　网络子类型的取值说明

getSubtypeName：获取网络子类型的名称。
getState：获取网络状态。网络状态的取值说明见表9-3。

根据梳理后的解包逻辑编写活动代码，使之监听系统发来的网络变更广播，下面是演示页面的代码片段：

@Override
protected void onStart() {
super.onStart();
networkReceiver = new NetworkReceiver(); // 创建一个网络变更的广播接收器
// 创建一个意图过滤器，只处理网络状态变化的广播
IntentFilter filter = new
IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
registerReceiver(networkReceiver, filter); // 注册接收器，注册之后才能正常接收广播
}
@Override
protected void onStop() {
super.onStop();
unregisterReceiver(networkReceiver); // 注销接收器，注销之后就不再接收广播
}
private NetworkReceiver networkReceiver; // 声明一个网络变更的广播接收器实例
// 定义一个网络变更的广播接收器
private class NetworkReceiver extends BroadcastReceiver {
// 一旦接收到网络变更的广播，马上触发接收器的onReceive方法
@Override
public void onReceive(Context context, Intent intent) {
if (intent != null) {
NetworkInfo networkInfo = intent.getParcelableExtra("networkInfo");
String networkClass =
NetworkUtil.getNetworkClass(networkInfo.getSubtype());
desc = String.format("%s\n%s 收到一个网络变更广播，网络大类为%s，" +
"网络小类为%s，网络制式为%s，网络状态为%s",
desc, DateUtil.getNowTime(),
networkInfo.getTypeName(),
networkInfo.getSubtypeName(), networkClass,
networkInfo.getState().toString());
tv_network.setText(desc);
}
}
}

运行测试App，初始界面如图9-9所示，说明手机正在使用数据连接。然后关闭数据连接，再开启WLAN，此时界面日志如图9-10所示，可见App果然收到了网络广播，并且正确从广播信息中得知已经切换到了WiFi网络。

9.3定时管理器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个编码步骤：定义定时器的广播接收器、开关定时器的广播接收器、设置定时器的播报规则，分别叙述如下。

1．定义定时器的广播接收器

闹钟广播的接收器采用动态注册方式，它的实现途径与标准广播类似，都要从BroadcastReceiver派生新的接收器，并重写onReceive方法。闹钟广播接收器的定义代码示例如下：

// 声明一个闹钟广播事件的标识串
private String ALARM_ACTION = "com.example.chapter09.alarm";
private String mDesc = ""; // 闹钟时间到达的描述
// 定义一个闹钟广播的接收器
public class AlarmReceiver extends BroadcastReceiver {
// 一旦接收到闹钟时间到达的广播，马上触发接收器的onReceive方法
@Override
public void onReceive(Context context, Intent intent) {
if (intent != null) {
mDesc = String.format("%s\n%s 闹钟时间到达", mDesc,
DateUtil.getNowTime());
tv_alarm.setText(mDesc);
// 从系统服务中获取震动管理器
Vibrator vb = (Vibrator)
context.getSystemService(Context.VIBRATOR_SERVICE);
vb.vibrate(500); // 命令震动器吱吱个若干秒
}
}
}

2．开关定时器的广播接收器

定时接收器的开关流程参照标准广播，可以在活动页面的onStart方法中注册接收器，在活动页面的onStop方法中注销接收器。相应的接收器开关代码如下所示：

private AlarmReceiver alarmReceiver; // 声明一个闹钟的广播接收器
@Override
public void onStart() {
super.onStart();
alarmReceiver = new AlarmReceiver(); // 创建一个闹钟的广播接收器
// 创建一个意图过滤器，只处理指定事件来源的广播
IntentFilter filter = new IntentFilter(ALARM_ACTION);
registerReceiver(alarmReceiver, filter); // 注册接收器，注册之后才能正常接收广播
}
@Override
public void onStop() {
super.onStop();
unregisterReceiver(alarmReceiver); // 注销接收器，注销之后就不再接收广播
}

3．设置定时器的播报规则

首先从系统服务中获取闹钟管理器，然后调用管理器的set***方法，把事先创建的延迟意图填到播报规则当中。下面是发送闹钟广播的代码例子：

// 发送闹钟广播
private void sendAlarm() {
Intent intent = new Intent(ALARM_ACTION); // 创建一个广播事件的意图
// 创建一个用于广播的延迟意图
PendingIntent pIntent = PendingIntent.getBroadcast(this, 0,
intent,
PendingIntent.FLAG_UPDATE_CURRENT);
// 从系统服务中获取闹钟管理器
AlarmManager alarmMgr = (AlarmManager) getSystemService(ALARM_SERVICE);
long delayTime = System.currentTimeMillis() + mDelay*1000; // 给当前时间加上若干
秒
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
// 允许在空闲时发送广播，Android6.0之后新增的方法
alarmMgr.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, delayTime,
pIntent);
} else {
// 设置一次性闹钟，延迟若干秒后，携带延迟意图发送闹钟广播（但Android6.0之后，set方法
在暗屏时不保证发送广播，必须调用setAndAllowWhileIdle方法）
alarmMgr.set(AlarmManager.RTC_WAKEUP, delayTime, pIntent);
}
}

完成上述的3个步骤之后，运行测试App，点击“设置闹钟”按钮，界面下方回显闹钟的设置信息，如图9-11所示。稍等片刻，发现回显文本多了一行日志，如图9-12所示，同时手机也嗡嗡震动了一会，对比日志时间可知，闹钟广播果然在设定的时刻触发且收听了。


至于闹钟的重复播报问题，因为setRepeating方法不再可靠，所以要修改闹钟的收听逻辑，在onReceive末尾补充调用sendAlarm方法，确保每次收到广播之后立即准备下一个广播。调整以后的onReceive方法代码示例如下：

public void onReceive(Context context, Intent intent) {
if (intent != null) {
if (ck_repeate.isChecked()) { // 需要重复闹钟广播
sendAlarm(); // 发送闹钟广播
}
}
}

10.捕获屏幕的变更事件

10.1　竖屏与横屏切换

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

接下来做个实验观察屏幕方向切换给生命周期带来的影响，现有一个测试页面ActTestActivity.java，参考第4章的“4.1.2 Activity的生命周期”，它的活动代码重写了主要的生命周期方法，在每个周期方法中都打印状态日志，完整代码见
chapter09\src\main\java\com\example\chapter09\ActTestActivity.java。运行测试App，初始的竖屏界面如图9-13所示；接着旋转手机使之处于横屏，测试App也跟着转过来，此时横屏界面如图9-14所示。

对比图9-13的竖屏界面和图9-14的横屏界面，发现二者打印的生命周期时间居然是不一样的，而且横屏界面的日志时间全部在竖屏界面的日志时间后面，说明App从竖屏变为横屏的时候，整个活动页面又重头创建了一遍。可是这个逻辑明显不对劲啊，从竖屏变为横屏，App界面就得重新加载；再从横屏变回竖屏，App界面又得重新加载，如此反复重启页面，无疑非常浪费系统资源。

为了避免横竖屏切换时重新加载界面的情况，Android设计了一种配置变更机制，在指定的环境配置发生变更之时，无须重启活动页面，只需执行特定的变更行为。该机制的编码过程分为两步：修改AndroidManifest.xml、修改活动页面的Java代码，详细说明如下。

1．修改AndroidManifest.xml

首先创建新的活动页面ChangeDirectionActivity，再打开AndroidManifest.xml，看到该活动对应的节点配置是下面这样的：

<activity android:name=".ChangeDirectionActivity" />

给这个activity节点增加android:configChanges属性，并将属性值设为
“orientation|screenLayout|screenSize”，修改后的节点配置如下所示：

<activity
android:name=".ChangeDirectionActivity"
android:configChanges="orientation|screenLayout|screenSize" />

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

2．修改活动页面的Java代码

打开ChangeDirectionActivity的Java代码，重写活动的onConfigurationChanged方法，该方法的输入参数为Configuration类型的配置对象，根据配置对象的orientation属性，即可判断屏幕的当前方向是竖屏还是横屏，再补充对应的代码处理逻辑。下面是重写了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，一开始手机处于竖屏界面，旋转手机使之切为横屏状态，此时App界面如图9-15所示，可见App成功获知了变更后的屏幕方向。反向旋转手机使之切回竖屏状态，此时App界面如图9-16所示，可见App同样监听到了最新的屏幕方向。

经过上述两个步骤的改造，每次横竖屏的切换操作都不再重启界面，只会执行
onConfigurationChanged方法的代码逻辑，从而节省了系统的资源开销。

如果希望App始终保持竖屏界面，即使手机旋转为横屏也不改变App的界面方向，可以修改AndroidManifest.xml，给activity节点添加android:screenOrientation属性，并将该属性设置为portrait表示垂直方向，也就是保持竖屏界面；若该属性为landscape则表示水平方向，也就是保持横屏界面。修改后的activity节点示例如下：

<activity android:name=".ActTestActivity"
android:screenOrientation="portrait"/>

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

App不但能监测手机屏幕的方向变更，还能获知回到桌面的事件，连打开任务列表的事件也能实时得知。回到桌面与打开任务列表都由按键触发，例如按下主页键会回到桌面，按下任务键会打开任务列表。虽然这两个操作看起来属于按键事件，但系统并未提供相应的按键处理方法，而是通过广播发出事件信息。

因此，若想知晓是否回到桌面，以及是否打开任务列表，均需收听系统广播
Intent.ACTION_CLOSE_SYSTEM_DIALOGS。至于如何区分当前广播究竟是回到桌面还是打开任务列表，则要从广播意图中获取原因reason字段，该字段值为homekey时表示回到桌面，值为recentapps时表示打开任务列表。接下来演示一下此类广播的接收过程。

首先定义一个广播接收器，只处理动作为Intent.ACTION_CLOSE_SYSTEM_DIALOGS的系统广播，并判断它是主页键来源还是任务键来源。该接收器的代码定义示例如下：

// 定义一个返回到桌面的广播接收器
private class DesktopRecevier extends BroadcastReceiver {
// 在收到返回桌面广播时触发
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)) {
String reason = intent.getStringExtra("reason"); // 获取变更原因
// 按下了主页键或者任务键
if (!TextUtils.isEmpty(reason) && (reason.equals("homekey")
|| reason.equals("recentapps")))
{
showChangeStatus(reason); // 显示变更的状态
}
}
}
}

接着在活动页面的onCreate方法中注册接收器，在onDestroy方法中注销接收器，其中接收器的注册代码如下所示：

private DesktopRecevier desktopRecevier; // 声明一个返回桌面的广播接收器对象
// 初始化桌面广播
private void initDesktopRecevier() {
desktopRecevier = new DesktopRecevier(); // 创建一个返回桌面的广播接收器
// 创建一个意图过滤器，只接收关闭系统对话框（即返回桌面）的广播
IntentFilter intentFilter = new
IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
registerReceiver(desktopRecevier, intentFilter); // 注册接收器，注册之后才能正常接
收广播
}

可是监听回到桌面的广播能用来干什么呢？一种用处是开启App的画中画模式，比如原先应用正在播放视频，回到桌面时势必要暂停播放，有了画中画模式之后，可将播放界面缩小为屏幕上的一个小方块，这样即使回到桌面也能继续观看视频。注意从Android 8.0开始才提供画中画模式，故而代码需要判断系统版本，下面是进入画中画模式的代码例子：

// 显示变更的状态
private void showChangeStatus(String reason) {
mDesc = String.format("%s%s 按下了%s键\n", mDesc, DateUtil.getNowTime(),
reason);
tv_monitor.setText(mDesc);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
&& !isInPictureInPictureMode()) { // 当前未开启画中画，则开启画中画模式
// 创建画中画模式的参数构建器
PictureInPictureParams.Builder builder = new
PictureInPictureParams.Builder();
// 设置宽高比例值，第一个参数表示分子，第二个参数表示分母
// 下面的10/5=2，表示画中画窗口的宽度是高度的两倍
Rational aspectRatio = new Rational(10,5);
builder.setAspectRatio(aspectRatio); // 设置画中画窗口的宽高比例
// 进入画中画模式，注意enterPictureInPictureMode是Android8.0之后新增的方法
enterPictureInPictureMode(builder.build());
}
}

以上代码用于开启画中画模式，但有时希望在进入画中画之际调整界面，则需重写活动的
onPictureInPictureModeChanged方法，该方法在应用进入画中画模式或退出画中画模式时触发，在此可补充相应的处理逻辑。重写后的方法代码示例如下：

// 在进入画中画模式或退出画中画模式时触发
@Override
public void onPictureInPictureModeChanged(boolean isInPicInPicMode,
Configuration newConfig) {
Log.d(TAG, "onPictureInPictureModeChanged
isInPicInPicMode="+isInPicInPicMode);
super.onPictureInPictureModeChanged(isInPicInPicMode, newConfig);
if (isInPicInPicMode) { // 进入画中画模式
} else { // 退出画中画模式
}
}

另外，画中画模式要求在AndroidManifest.xml中开启画中画支持，也就是给activity节点添加supportsPictureInPicture属性并设为true，添加新属性之后的activity配置示例如下：

<activity
android:name=".ReturnDesktopActivity"
android:configChanges="orientation|screenLayout|screenSize"
android:supportsPictureInPicture="true"
android:theme="@style/AppCompatTheme" />

运行测试App，正常的竖屏界面如图9-17所示。