《第一行代码：Android篇》学习笔记（五）

《第一行代码：Android篇》学习笔记（五）
本文和接下来的几篇文章为阅读郭霖先生所著《第一行代码：Android（篇第2版）》的学习笔记，按照书中的内容顺序进行记录，书中的Demo本人全部都做过了。
每一章节本人都做了详细的记录，以下是我学习记录（包含大量书中内容的整理和自己在学习中遇到的各种bug及解决方案），方便以后阅读和查阅。最后，感激感激郭霖先生提供这么好的书籍。

第5章全局大喇叭——详解广播机制

如果你了解网络通信原理应该会知道，在一个IP网络范围中，最大的IP地址是被保留作为广播地址来使用的。

比如某个网络的IP范围是192.168.0.XXX，子网掩码是255.255.255.0，那么这个网络的广播地址就是192.168.0.255。广播数据包会被发送到同一网络上的所有端口，这样在该网络中的每台主机都将会收到这条广播。为了便于进行系统级别的消息通知，Android也引入了一套类似的广播消息机制。

5.1 广播机制简介

为什么说Android中的广播机制更加灵活呢？
1. 注册和接收自己感兴趣的广播
Android中的每个应用程序都可以对自己感兴趣的广播进行注册，这样该程序就只会接收到自己所关心的广播内容，这些广播可能是来自于系统的，也可能是来自于其他应用程序的。
1. 完整API
Android提供了一套完整的API，允许应用程序自由地发送和接收广播。
1. 发送/接收广播的方法
发送广播的方法，就是借助之前稍微提到过学过的Intent。而接收广播的方法则需要引入一个新的概念——广播接收器（Broadcast Receiver）。

Android中的广播主要可以分为两种类型：标准广播和有序广播。
- 标准广播（Normal broadcasts）
是一种完全异步执行的广播，在广播发出之后，所有的广播接收器几乎都会在同一时刻接收到这条广播消息，因此它们之间没有任何先后顺序可言。这种广播的效率会比较高，但同时也意味着它是无法被截断的。标准广播的工作流程如图：
- 有序广播
是一种同步执行的广播，在广播发出之后，同一时刻只会有一个广播接收器能够收到这条广播消息，当这个广播接收器中的逻辑执行完毕后，广播才会继续传递。

所以此时的广播接收器是有先后顺序的，优先级高的广播接收器就可以先收到广播消息，并且前面的广播接收器还可以截断正在传递的广播，这样后面的广播接收器就无法收到广播消息了。有序广播的工作流程如图：

5.2 接收系统广播

Android内置了很多系统级别的广播，我们可以在应用程序中通过监听这些广播来得到各种系统的状态信息。比如手机开机完成后会发出一条广播，电池的电量发生变化会发出一条广播，时间或时区发生改变也会发出一条广播，等等。如果想要接收到这些广播，就需要使用广播接收器，下面我们就来看一下它的具体用法。

5.2.1 动态注册监听网络变化

广播接收器可以自由地对自己感兴趣的广播进行注册，这样当有相应的广播发出时，广播接收器就能够收到该广播，并在内部处理相应的逻辑。

注册广播的方式一般有两种，在代码中注册和在AndroidManifest.xml中注册，其中前者也被称为动态注册，后者也被称为静态注册。

那么该如何创建一个广播接收器呢？

其实只需要新建一个类，让它继承自BroadcastReceiver，并重写父类的onReceive()方法就行了。这样当有广播到来时，onReceive()方法就会得到执行，具体的逻辑就可以在这个方法中处理。

那我们就先通过动态注册的方式编写一个能够监听网络变化的程序，借此学习一下广播接收器的基本用法吧。新建一个BroadcastTest项目，然后修改MainActivity中的代码，如下所示：
```
package com.zhouzhou.broadcasttest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    private IntentFilter intentFilter;
    private NetWorkChangeReceiver netWorkChangeReceiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        intentFilter = new IntentFilter();
        intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
        netWorkChangeReceiver = new NetWorkChangeReceiver();
        registerReceiver(netWorkChangeReceiver,intentFilter);
    }

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

    class NetWorkChangeReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context,"network changes",Toast.LENGTH_SHORT).show();
        }
    }
}
```
- 在MainActivity中定义了一个内部类NetworkChangeReceiver。
这个类是继承自BroadcastReceiver的，并重写了父类的onReceive()方法。这样每当网络状态发生变化时，onReceive()方法就会得到执行，这里只是简单地使用Toast提示了一段文本信息。
- onCreate()方法，首先创建了一个IntentFilter的实例，并给它添加了一个值为android.net.conn.CONNECTIVITY_CHANGE的action。
为什么要添加这个值呢？因为当网络状态发生变化时，系统发出的正是一条值为android.net.conn.CONNECTIVITY_CHANGE的广播，也就是说我们的广播接收器想要监听什么广播，就在这里添加相应的action。
- 创建了一个NetworkChangeReceiver的实例，然后调用registerReceiver()方法进行注册，将NetworkChangeReceiver的实例和IntentFilter的实例都传了进去。
这样NetworkChangeReceiver就会收到所有值为android.net.conn.CONNECTIVITY_CHANGE的广播，也就实现了监听网络变化的功能。
- 动态注册的广播接收器一定都要取消注册才行。
这里我们是在onDestroy()方法中通过调用unregisterReceiver()方法来实现的。

整体来说，代码还是非常简单的，现在运行一下程序。首先你会在注册完成的时候收到一条广播，图示如下：

然后按下Home键回到主界面（注意不能按Back键，否则onDestroy()方法会执行），接着打开Settings程序→Data usage进入到数据使用详情界面，然后尝试着开关Cellular data按钮来启动和禁用网络，你就会看到有Toast提醒你网络发生了变化。图示如下：

不过，只是提醒网络发生了变化还不够人性化，最好是能准确地告诉用户当前是有网络还是没有网络，因此我们还需要对上面的代码进行进一步的优化。修改MainActivity中的代码，如下所示：
```
package com.zhouzhou.broadcasttest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    private IntentFilter intentFilter;
    private NetWorkChangeReceiver netWorkChangeReceiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        intentFilter = new IntentFilter();
        intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
        netWorkChangeReceiver = new NetWorkChangeReceiver();
        registerReceiver(netWorkChangeReceiver,intentFilter);
    }

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

    class NetWorkChangeReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
         //下面一行会爆红，点击红色小灯泡第一行就行。意思是在AndroidManifest.xml文件中添加：
        //<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
            if (networkInfo != null && networkInfo.isAvailable()){
                Toast.makeText(context,"network is available",Toast.LENGTH_SHORT).show();
            }else {
                Toast.makeText(context,"network is unavailable",Toast.LENGTH_SHORT).show();
            }
        }
    }
}
```
在onReceive()方法中，首先通过getSystemService()方法得到了ConnectivityManager的实例，这是一个系统服务类，专门用于管理网络连接的。然后调用它的getActiveNetworkInfo()方法可以得到NetworkInfo的实例，接着调用NetworkInfo的isAvailable()方法，就可以判断出当前是否有网络了，最后我们还是通过Toast的方式对用户进行提示。

另外，这里有非常重要的一点需要说明，Android系统为了保护用户设备的安全和隐私，做了严格的规定：如果程序需要进行一些对用户来说比较敏感的操作，就必须在配置文件中声明权限才可以，否则程序将会直接崩溃。比如这里访问系统的网络状态就是需要声明权限的。打开AndroidManifest.xml文件，在里面加入如下权限就可以访问系统网络状态了：(就是上面代码中爆红的位置的说明)
```
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
```
其实Android中有许多操作都是需要声明权限才可以进行的，后面我们还会不断使用新的权限。

不过目前这个访问系统网络状态的权限还是比较简单的，只需要在AndroidManifest.xml文件中声明一下就可以了，而Android 6.0系统中引入了更加严格的运行时权限，从而能够更好地保证用户设备的安全和隐私，关于这部分内容我们将在第7章中学习。

现在重新运行程序，然后按下Home键→Settings→Data usage，进入到数据使用详情界面，关闭Cellular data会弹出无网络可用的提示，如图：

然后重新打开Cellular data又会弹出网络可用的提示。

5.2.2 静态注册实现开机启动

动态注册的广播接收器可以自由地控制注册与注销，在灵活性方面有很大的优势，但是它也存在着一个缺点，即必须要在程序启动之后才能接收到广播，因为注册的逻辑是写在onCreate()方法中的。

那么有没有什么办法可以让程序在未启动的情况下就能接收到广播呢？这就需要使用静态注册的方式了。

这里我们准备让程序接收一条开机广播，当收到这条广播时就可以在onReceive()方法里执行相应的逻辑，从而实现开机启动的功能。可以使用Android Studio提供的快捷方式来创建一个广播接收器，右击com.zhouzhou.broadcasttest包→New→Other→BroadcastReceiver，会弹出如图所示的窗口：

可以看到，这里将广播接收器命名为BootCompleteReceiver, Exported属性表示是否允许这个广播接收器接收本程序以外的广播，Enabled属性表示是否启用这个广播接收器。勾选这两个属性，点击Finish完成创建。

然后修改BootCompleteReceiver中的代码，如下所示：
```
package com.zhouzhou.broadcasttest;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class BootCompleteReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // TODO: This method is called when the BroadcastReceiver is receiving
        // an Intent broadcast.
        //throw new UnsupportedOperationException("Not yet implemented");
        Toast.makeText(context,"Boot Complete",Toast.LENGTH_LONG).show();
    }
}
```
只是在onReceive()方法中使用Toast弹出一段提示信息。另外，静态的广播接收器一定要在AndroidManifest.xml文件中注册才可以使用，不过由于我们是使用Android Studio的快捷方式创建的广播接收器，因此注册这一步已经被自动完成了。打开AndroidManifest.xml文件瞧一瞧，代码如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.zhouzhou.broadcasttest">
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <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.BroadcastTest">
        <receiver
            android:name=".BootCompleteReceiver"
            android:enabled="true"
            android:exported="true"></receiver>
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
```
可以看到，<application>标签内出现了一个新的标签<receiver>，所有静态的广播接收器都是在这里进行注册的。它的用法其实和<activity>标签非常相似，也是通过android:name来指定具体注册哪一个广播接收器，而enabled和exported属性则是根据我们刚才勾选的状态自动生成的。

不过目前BootCompleteReceiver还是不能接收到开机广播的，我们还需要对AndroidManifest. xml文件进行修改才行，如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.zhouzhou.broadcasttest">
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <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.BroadcastTest">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver
            android:name=".BootCompleteReceiver"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED"/>
            </intent-filter>
        </receiver>
    </application>
</manifest>
```
现在重新运行程序后，程序就已经可以接收开机广播了。将模拟器关闭并重新启动，在启动完成之后就会收到开机广播（这里测试太多次啦！呜呜呜~启动程序，再将模拟器关闭，是（手机）长按关机键，唤出关机按钮，关机。然后再重新启动，启动之后，马上按Home键，就是得赶上没有完全开机之前，进入到桌面。然后就是等待完全开机，就会跳出Toast：“Boot Complete”啦！):

到目前为止，在广播接收器的onReceive()方法中都只是简单地使用Toast提示了一段文本信息，当你真正在项目中使用到它的时候，就可以在里面编写自己的逻辑。

需要注意的是，不要在onReceive()方法中添加过多的逻辑或者进行任何的耗时操作，因为在广播接收器中是不允许开启线程的，当onReceive()方法运行了较长时间而没有结束时，程序就会报错。因此广播接收器更多的是扮演一种打开程序其他组件的角色，比如创建一条状态栏通知，或者启动一个服务等，这几个概念我们会在后面的章节中学到。

5.3 发送自定义广播

广播主要分为两种类型：标准广播和有序广播，在本节中我们就将通过实践的方式来看一下这两种广播具体的区别。

5.3.1 发送标准广播

在发送广播之前，还是需要先定义一个广播接收器来准备接收此广播才行，不然发出去也是白发。因此新建一个MyBroadcastReceiver，代码如下所示：
```
package com.zhouzhou.broadcasttest;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class MyBroadcastReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // TODO: This method is called when the BroadcastReceiver is receiving
        // an Intent broadcast.
        //throw new UnsupportedOperationException("Not yet implemented");
        Toast.makeText(context,"received in MyBroadcastReceiver",Toast.LENGTH_SHORT).show();
    }
}
```
这里当MyBroadcastReceiver收到自定义的广播时，就会弹出“received in MyBroadcastReceiver”的提示。然后在AndroidManifest.xml中对这个广播接收器进行修改：
```
<receiver
          android:name=".MyBroadcastReceiver"
          android:enabled="true"
          android:exported="true">
    <intent-filter>
        <action android:name="com.zhouzhou.broadcasttest.MY_BROADCAST"/>
    </intent-filter>
</receiver>
```
这里让MyBroadcastReceiver接收一条值为com.zhouzhou.broadcasttest. MY_BROADCAST的广播，因此待会儿在发送广播的时候，我们就需要发出这样的一条广播。接下来修改activity_main.xml中的代码，如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <Button 
        android:id="@+id/button" 
        android:layout_width="match_parent" 
        android:layout_height="wrap_content" 
        android:text="Send Broadcast"/>
</LinearLayout>
```
这里在布局文件中定义了一个按钮，用于作为发送广播的触发点。然后修改MainActivity中的代码，如下所示：
```
package com.zhouzhou.broadcasttest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    private IntentFilter intentFilter;
    private NetWorkChangeReceiver netWorkChangeReceiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent("com.zhouzhou.broadcasttest.MY_BROADCAST");
                //书中缺少：intent.setComponent("广播接收器得包的路径名","广播接收器的类路径名")
                intent.setComponent(new ComponentName("com.zhouzhou.broadcasttest","com.zhouzhou.broadcasttest.MyBroadcastReceiver"));
                sendBroadcast(intent);
            }
        });
        intentFilter = new IntentFilter();
        intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
        netWorkChangeReceiver = new NetWorkChangeReceiver();
        registerReceiver(netWorkChangeReceiver,intentFilter);
    }

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

    class NetWorkChangeReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
            if (networkInfo != null && networkInfo.isAvailable()){
                Toast.makeText(context,"network is available",Toast.LENGTH_SHORT).show();
            }else {
                Toast.makeText(context,"network is unavailable",Toast.LENGTH_SHORT).show();
            }
        }
    }
}
```
在按钮的点击事件里面加入了发送自定义广播的逻辑。首先构建出了一个Intent对象，并把要发送的广播的值传入，然后调用了Context的sendBroadcast()方法将广播发送出去，这样所有监听com.zhouzhou.broadcasttest.MY_BROADCAST这条广播的广播接收器就会收到消息。此时发出去的广播就是一条标准广播。重新运行程序，并点击一下Send Broadcast按钮，效果如图：

这样就成功完成了发送自定义广播的功能。另外，由于广播是使用Intent进行传递的，因此还可以在Intent中携带一些数据传递给广播接收器。

5.3.2 发送有序广播

广播是一种可以跨进程的通信方式，这一点从前面接收系统广播的时候就可以看出来了。因此在我们应用程序内发出的广播，其他的应用程序应该也是可以收到的。

为了验证这一点，我们需要再新建一个BroadcastTest2项目，点击Android Studio导航栏→File→New→New Project进行创建。将项目创建好之后，还需要在这个项目下定义一个广播接收器，用于接收上一小节中的自定义广播。新建AnotherBroadcastReceiver，代码如下所示：
```
package com.zhouzhou.broadcasttest2;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class AnotherBroadcastReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // TODO: This method is called when the BroadcastReceiver is receiving
        // an Intent broadcast.
        //throw new UnsupportedOperationException("Not yet implemented");
        Toast.makeText(context,"received in AnotherBroadcastReceiver",Toast.LENGTH_SHORT).show();
    }
}
```
这里仍然是在广播接收器的onReceive()方法中弹出了一段文本信息。然后在AndroidManifest.xml中对这个广播接收器进行修改，代码如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.zhouzhou.broadcasttest2">
    <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.BroadcastTest2">
        <receiver
            android:name=".AnotherBroadcastReceiver"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                
                <action android:name="com.zhouzhou.broadcasttest.MY_BROADCAST"/>
            </intent-filter>
        </receiver>
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
```
可以看到，AnotherBroadcastReceiver同样接收的是com.zhouzhou.broadcasttest.MY_BROADCAST这条广播。现在运行BroadcastTest2项目将这个程序安装到模拟器上，然后重新回到BroadcastTest项目的主界面，并点击一下Send Broadcast按钮，就会分别弹出两次提示信息，如图所示：

这样就强有力地证明了，我们的应用程序发出的广播是可以被其他的应用程序接收到的。到目前为止，程序里发出的都还是标准广播，现在尝试一下发送有序广播。

重新回到BroadcastTest项目，然后修改MainActivity中的代码，如下所示：
```
public class MainActivity extends AppCompatActivity {
    private IntentFilter intentFilter;
    private NetWorkChangeReceiver netWorkChangeReceiver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent("com.zhouzhou.broadcasttest.MY_BROADCAST");
                //书中缺少：intent.setComponent("广播接收器得包的路径名","广播接收器的类路径名")
                intent.setComponent(new ComponentName("com.zhouzhou.broadcasttest","com.zhouzhou.broadcasttest.MyBroadcastReceiver"));
                //sendBroadcast(intent);
                sendOrderedBroadcast(intent,null);
            }
        });
        ...
    }
...
}
```
可以看到，发送有序广播只需要改动一行代码，即将sendBroadcast()方法改成send-OrderedBroadcast()方法。sendOrderedBroadcast()方法接收两个参数，第一个参数仍然是Intent，第二个参数是一个与权限相关的字符串，这里传入null就行了。

现在重新运行程序，并点击Send Broadcast按钮，发现两个应用程序仍然都可以接收到这条广播。看上去好像和标准广播没什么区别嘛，不过别忘了，这个时候的广播接收器是有先后顺序的，而且前面的广播接收器还可以将广播截断，以阻止其继续传播。

那么该如何设定广播接收器的先后顺序呢？当然是在注册的时候进行设定的了，修改AndroidManifest.xml中的代码，如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.zhouzhou.broadcasttest">
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    <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.BroadcastTest">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver
            android:name=".BootCompleteReceiver"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
            </intent-filter>
        </receiver>
        <receiver
            android:name=".MyBroadcastReceiver"
            android:enabled="true"
            android:exported="true">
            
            <intent-filter android:priority="100">
                <action android:name="com.zhouzhou.broadcasttest.MY_BROADCAST"/>
            </intent-filter>
        </receiver>
    </application>
</manifest>
```
通过android:priority属性给广播接收器设置了优先级，优先级比较高的广播接收器就可以先收到广播。这里将MyBroadcastReceiver的优先级设成了100，以保证它一定会在AnotherBroadcastReceiver之前收到广播。

既然已经获得了接收广播的优先权，那么MyBroadcastReceiver就可以选择是否允许广播继续传递了。修改MyBroadcastReceiver中的代码，如下所示：
```
package com.zhouzhou.broadcasttest;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class MyBroadcastReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context,"received in MyBroadcastReceiver",Toast.LENGTH_SHORT).show();
        abortBroadcast();
    }
}
```
书中讲述：“如果在onReceive()方法中调用了abortBroadcast()方法，就表示将这条广播截断，后面的广播接收器将无法再接收到这条广播。现在重新运行程序，并点击一下Send Broadcast按钮，你会发现，只有MyBroadcastReceiver中的Toast信息能够弹出，说明这条广播经过MyBroadcastReceiver之后确实是终止传递了。”实际上，在4.4以上，abortBroadcast()方法不能实现拦截功能了。上面的测试，并没有成功拦截。

5.4 使用本地广播

前面我们发送和接收的广播全部属于系统全局广播，即发出的广播可以被其他任何应用程序接收到，并且我们也可以接收来自于其他任何应用程序的广播。

这样就很容易引起安全性的问题，比如说我们发送的一些携带关键性数据的广播有可能被其他的应用程序截获，或者其他的程序不停地向我们的广播接收器里发送各种垃圾广播。

为了能够简单地解决广播的安全性问题，Android引入了一套本地广播机制，使用这个机制发出的广播只能够在应用程序的内部进行传递，并且广播接收器也只能接收来自本应用程序发出的广播，这样所有的安全性问题就都不存在了。

本地广播的用法并不复杂，主要就是使用了一个LocalBroadcastManager来对广播进行管理，并提供了发送广播和注册广播接收器的方法。下面我们就通过具体的实例来尝试一下它的用法，修改MainActivity中的代码，如下所示：
```
package com.zhouzhou.broadcasttest;

import androidx.appcompat.app.AppCompatActivity;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;

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

public class MainActivity extends AppCompatActivity {
    private IntentFilter intentFilter;
    private LocalReceiver localReceiver;
    private LocalBroadcastManager localBroadcastManager;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        localBroadcastManager = LocalBroadcastManager.getInstance(this);//获取实例
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent("com.zhouzhou.broadcasttest.LOCAL_BROADCAST");
                localBroadcastManager.sendBroadcast(intent);//发送本地广播
            }
        });
        intentFilter = new IntentFilter();
        intentFilter.addAction("com.zhouzhou.broadcasttest.LOCAL_BROADCAST");
        localReceiver = new LocalReceiver();
        localBroadcastManager.registerReceiver(localReceiver,intentFilter);//注册本地广播监听器
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        localBroadcastManager.unregisterReceiver(localReceiver);
    }
    class LocalReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context,"received local broadcast",Toast.LENGTH_SHORT).show();
        }
    }
}
```
实这基本上就和前面所学的动态注册广播接收器以及发送广播的代码是一样的。只不过现在首先是通过LocalBroadcastManager的getInstance()方法得到了它的一个实例，然后在注册广播接收器的时候调用的是LocalBroadcastManager的registerReceiver()方法，在发送广播的时候调用的是LocalBroadcastManager的sendBroadcast()方法，仅此而已。这里我们在按钮的点击事件里面发出了一条com.zhouzhou.broadcasttest.LOCAL_BROADCAST广播，然后在LocalReceiver里去接收这条广播。重新运行程序，并点击SendBroadcast按钮，效果如图：

可以看到，LocalReceiver成功接收到了这条本地广播，并通过Toast提示了出来。如果你还有兴趣进行实验，可以尝试在BroadcastTest2中也去接收com.zhouzhou.broadcasttest.LOCAL_BROADCAST这条广播。答案是显而易见的，肯定无法收到，因为这条广播只会在BroadcastTest程序内传播。（经过测试，竟然也能收到！！！）

另外还有一点需要说明，本地广播是无法通过静态注册的方式来接收的。其实这也完全可以理解，因为静态注册主要就是为了让程序在未启动的情况下也能收到广播，而发送本地广播时，我们的程序肯定是已经启动了，因此也完全不需要使用静态注册的功能。

盘点一下使用本地广播的几点优势：

❑ 可以明确地知道正在发送的广播不会离开我们的程序，因此不必担心机密数据泄漏。

❑ 其他的程序无法将广播发送到我们程序的内部，因此不需要担心会有安全漏洞的隐患。

❑ 发送本地广播比发送系统全局广播将会更加高效。

5.5 广播的最佳实践——实现强制下线功能

强制下线功能，很多的应用程序都具备这个功能，比如你的QQ号在别处登录了，就会将你强制挤下线。其实实现强制下线功能的思路也比较简单，只需要在界面上弹出一个对话框，让用户无法进行任何其他操作，必须要点击对话框中的确定按钮，然后回到登录界面即可。

可是这样就存在着一个问题，因为当我们被通知需要强制下线时可能正处于任何一个界面，难道需要在每个界面上都编写一个弹出对话框的逻辑？我们完全可以借助本章中所学的广播知识，来非常轻松地实现这一功能。

新建一个BroadcastBestPractice项目，然后开始动手吧。强制下线功能需要先关闭掉所有的活动，然后回到登录界面。先创建一个ActivityCollector类用于管理所有的活动，代码如下所示：
```
package com.zhouzhou.broadcastbestpractice;

import android.app.Activity;
import java.util.ArrayList;
import java.util.List;

//ActivityCollector类 用于管理所有的活动
public class ActivityCollector {
    public static List<Activity> activities = new ArrayList<>();
    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();
            }
        }
        activities.clear();
    }
}
```
然后创建BaseActivity类作为所有活动的父类，代码如下所示：
```
package com.zhouzhou.broadcastbestpractice;

import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;

//BaseActivity类 作为所有活动的父类
public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityCollector.addActivity(this);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityCollector.removeActivity(this);
    }
}
```
创建一个登录界面的活动，新建LoginActivity，并让Android Studio帮我们自动生成相应的布局文件。然后编辑布局文件activity_login.xml，代码如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="60dp">
        <TextView
            android:layout_width="90dp"
            android:layout_height="wrap_content"
            android:layout_gravity="center_vertical"
            android:textSize="18sp"
            android:text="Account:"/>
        <EditText
            android:id="@+id/account"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:layout_gravity="center_vertical"/>
    </LinearLayout>
    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="60dp">
        <TextView
            android:layout_width="90dp"
            android:layout_height="wrap_content"
            android:layout_gravity="center_vertical"
            android:textSize="18sp"
            android:text="Password"/>
        <EditText
            android:id="@+id/password"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:layout_gravity="center_vertical"
            android:inputType="textPassword"/>
    </LinearLayout>
    <Button
        android:id="@+id/login"
        android:layout_width="match_parent"
        android:layout_height="60dp"
        android:text="Login"/>
</LinearLayout>
```
使用LinearLayout编写出了一个登录布局，最外层是一个纵向的LinearLayout，里面包含了3行直接子元素。第一行是一个横向LinearLayout，用于输入账号信息；第二行也是一个横向的LinearLayout，用于输入密码信息；第三行是一个登录按钮。接下来修改LoginActivity中的代码，如下所示：
```
package com.zhouzhou.broadcastbestpractice;

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

public class LoginActivity extends BaseActivity {
    private EditText accountEdit;
    private EditText passwordEdit;
    private Button login;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        accountEdit = (EditText) findViewById(R.id.account);
        passwordEdit = (EditText) findViewById(R.id.password);
        login = (Button) findViewById(R.id.login);
        login.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                String account = accountEdit.getText().toString();
                String password = passwordEdit.getText().toString();
                //如果账号是admin且密码是123456，就认为登录成功
                if (account.equals("admin") && password.equals("123456")) {
                    Intent intent = new Intent(LoginActivity.this,MainActivity.class);
                    startActivity(intent);
                    finish();
                }else {
                    Toast.makeText(LoginActivity.this,"account or password is invalid",Toast.LENGTH_SHORT).show();
                }
            }
        });
    }
}
```
模拟了一个非常简单的登录功能。首先要将LoginActivity的继承结构改成继承自BaseActivity，然后调用findViewById()方法分别获取到账号输入框、密码输入框以及登录按钮的实例。

接着在登录按钮的点击事件里面对输入的账号和密码进行判断，如果账号是admin并且密码是123456，就认为登录成功并跳转到MainActivity，否则就提示用户账号或密码错误。

因此，你就可以将MainActivity理解成是登录成功后进入的程序主界面了，这里我们并不需要在主界面里提供什么花哨的功能，只需要加入强制下线功能就可以了，修改activity_main.xml中的代码，如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <Button
        android:id="@+id/force_offline"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Send force offline broadcast"/>
</LinearLayout>
```
只有一个按钮而已，用于触发强制下线功能。然后修改MainActivity中的代码，如下所示：
```
package com.zhouzhou.broadcastbestpractice;

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

public class MainActivity extends BaseActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button forceOffline = (Button) findViewById(R.id.force_offline);
        forceOffline.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent("com.zhouzhou.broadcastbestpractice.FORCE_OFFLINE");
                sendBroadcast(intent);
            }
        });
    }
}
```
这里有个重点，在按钮的点击事件里面发送了一条广播，广播的值为com.zhouzhou.broadcastbestpractice.FORCE_OFFLINE，这条广播就是用于通知程序强制用户下线的。

也就是说强制用户下线的逻辑并不是写在MainActivity里的，而是应该写在接收这条广播的广播接收器里面，这样强制下线的功能就不会依附于任何的界面，不管是在程序的任何地方，只需要发出这样一条广播，就可以完成强制下线的操作了。

那么毫无疑问，接下来我们就需要创建一个广播接收器来接收这条强制下线广播，唯一的问题就是，应该在哪里创建呢？由于广播接收器里面需要弹出一个对话框来阻塞用户的正常操作，但如果创建的是一个静态注册的广播接收器，是没有办法在onReceive()方法里弹出对话框这样的UI控件的，而我们显然也不可能在每个活动中都去注册一个动态的广播接收器。那么到底应该怎么办呢？

答案其实很明显，只需要在BaseActivity中动态注册一个广播接收器就可以了，因为所有的活动都是继承自BaseActivity的。修改BaseActivity中的代码，如下所示：
```
package com.zhouzhou.broadcastbestpractice;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;

//BaseActivity类 作为所有活动的父类
public class BaseActivity extends AppCompatActivity {
    private ForceOfflineReceiver receiver;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityCollector.addActivity(this);
    }
    @Override
    protected void onResume() {
        super.onResume();
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction("com.zhouzhou.broadcastbestpractice.FORCE_OFFLINE");
        receiver = new ForceOfflineReceiver();
        registerReceiver(receiver,intentFilter);
    }
    @Override
    protected void onPause() {
        super.onPause();
        if (receiver != null){
            unregisterReceiver(receiver);
            receiver = null;
        }
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityCollector.removeActivity(this);
    }
    class ForceOfflineReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            AlertDialog.Builder builder = new AlertDialog.Builder(context);
            builder.setTitle("Warning");
            builder.setMessage("You are forced to be offline.Please try to login again");
            builder.setCancelable(false);
            builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    ActivityCollector.finishAll();//销毁所有活动
                    Intent intent = new Intent(context,LoginActivity.class);
                    context.startActivity(intent);//重新启动LoginActivity
                }
            });
            builder.show();
        }
    }
}
```
ForceOfflineReceiver中的代码，这次onReceive()方法里不仅仅弹出一个Toast了，首先肯定是使用AlertDialog.Builder来构建一个对话框，注意这里一定要调用setCancelable()方法将对话框设为不可取消，否则用户按一下Back键就可以关闭对话框继续使用程序了。

然后使用setPositiveButton()方法来给对话框注册确定按钮，当用户点击了确定按钮时，就调用ActivityCollector的finishAll()方法来销毁掉所有活动，并重新启动LoginActivity这个活动。

我们是怎么注册ForceOfflineReceiver这个广播接收器的，这里重写了onResume()和onPause()这两个生命周期函数，然后分别在这两个方法里注册和取消注册了ForceOfflineReceiver。

那么为什么要这样写呢？之前不都是在onCreate()和onDestroy()方法里来注册和取消注册广播接收器的么？这是因为我们始终需要保证只有处于栈顶的活动才能接收到这条强制下线广播，非栈顶的活动不应该也没有必要去接收这条广播，所以写在onResume()和onPause()方法里就可以很好地解决这个问题，当一个活动失去栈顶位置时就会自动取消广播接收器的注册。

这样的话，所有强制下线的逻辑就已经完成了，接下来我们还需要对AndroidManifest.xml文件进行修改，代码如下所示：
```
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.zhouzhou.broadcastbestpractice">
    <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.BroadcastBestPractice">
        <activity android:name=".MainActivity"/>
        <activity
            android:name=".LoginActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
```
这里只需要，将主活动设置为LoginActivity而不再是MainActivity，因为你肯定不希望用户在没登录的情况下就能直接进入到程序主界面吧？尝试运行一下程序，首先会进入到登录界面，并可以在这里输入账号和密码，如图：

如果输入的账号是admin，密码是123456，点击登录按钮就会进入到程序的主界面：

这时点击一下发送广播的按钮，就会发出一条强制下线的广播，ForceOfflineReceiver里收到这条广播后会弹出一个对话框提示用户已被强制下线，如图：

这时用户将无法再对界面的任何元素进行操作，只能点击确定按钮，然后会重新回到登录界面。这样，强制下线功能就已经完整地实现了。

5.6 Git时间——初识版本控制工具

Git是一个开源的分布式版本控制工具，它的开发者就是鼎鼎大名的Linux操作系统的作者Linus Torvalds。Git被开发出来的初衷是为了更好地管理Linux内核，而现在却早已被广泛应用于全球各种大中小型的项目中。

5.6.1 安装Git

由于Git和Linux操作系统都是同一个作者，Git在Linux上的安装是最简单方便的。比如使用的是Ubuntu系统，只需要打开shell界面，并输入：
```
sudo apt-get install git-core
```
按下回车后输入密码，即可完成Git的安装。

使用Windows操作系统，如何在Windows上安装Git。不同于Linux, Windows上可无法通过一行命令就完成安装了，需要先把Git的安装包下载下来。访问网址https://git-for-windows.github.io/，可以看到如图页面：

目前最新的git for windows版本是2.35.1.12，如果你下载的时候发现又有新的版本，可以尝试一下最新版本的Git。点击Download按钮可以开始下载，下载完成后双击安装包进行安装，之后一直点击“下一步”就可以完成安装了。

5.6.2 创建代码仓库

虽然在Windows上安装的Git是可以在图形界面上进行操作的，并且AndroidStudio也支持以图形化的形式操作Git，但是这里并不建议你这样做，因为Git的各种命令才是你应该掌握的核心技能，不管你是在哪个操作系统中，使用命令来操作Git肯定都是通用的。

而图形化的操作应该是在你能熟练掌握命令用法的前提下，进一步提升你工作效率的手段。那么我们现在就来尝试一下如何通过命令来使用Git。如果你使用的是Linux系统，就先打开shell界面，如果使用的是Windows系统，就从开始里找到GitBash并打开。

首先应该配置一下你的身份，这样在提交代码的时候Git就可以知道是谁提交的了，命令如下所示：
```
$ git config --global user.name "Zhouzhou"
$ git config --global user.email "1693977889@qq.com"
```
配置完成后,还可以使用同样的命令来查看是否配置成功，只需要将最后的名字和邮箱地址去掉即可，
```
$ git config --global user.name
$ git config --global user.email
```
如图：

然后，就可以开始创建代码仓库了，仓库（Repository）是用于保存版本管理所需信息的地方，所有本地提交的代码都会被提交到代码仓库中，如果有需要还可以再推送到远程仓库中。

这里我们尝试着给BroadcastBestPractice项目建立一个代码仓库。先进入到BroadcastBestPractice项目的目录下面，如图：

然后在这个目录下面输入如下命令：
```
git init
```
只需要一行命令就可以完成创建代码仓库的操作，如图所示：

仓库创建完成后，会在BroadcastBestPractice项目的根目录下生成一个隐藏的.git文件夹，这个文件夹就是用来记录本地所有的Git操作的，可以通过ls-al命令来查看一下，如图所示：

5.6.3 提交本地代码

代码仓库建立完之后就可以提交代码了，只需要使用add和commit命令就可以了。add用于把想要提交的代码先添加进来，而commit则是真正地去执行提交操作。比如我们想添加build.gradle文件，就可以输入如下命令：
```
git add build.gradle
```
这是添加单个文件的方法。想添加某个目录，只需要在add后面加上目录名就可以了。比如将整个app目录下的所有文件都进行添加，就可以输入如下命令：
```
git add app
```
可是这样一个个地添加感觉还是有些复杂，一次性就把所有的文件都添加好：只需要在add的后面加上一个点，就表示添加所有的文件了，命令如下所示：
```
git add .
```
现在BroadcastBestPractice项目下所有的文件都已经添加好了，我们可以来提交一下了，输入如下命令：
```
git commit -m "First commit."
```
注意，在commit命令的后面，一定要通过-m参数来加上提交的描述信息，没有描述信息的提交被认为是不合法的。这样所有的代码就已经成功提交了。关于Git的内容，今天先学到这里。
个人学习笔记，针对本人在自学中遇到的问题。
相关阅读:
“孤立”用户
 MongoDB 维护Replica Set
Design7：数据删除设计
 abap取中值的函数
 REPLACE...IN.....WITH.... 的使用
 ABAP中RETURN与EXIT语句的区别
 在一个程序中调用另一个程序并且传输数据到选择屏幕执行这个程序
 Extract Datasets
事件
 计算字符串长度的实例
原文地址：https://www.cnblogs.com/1693977889zz/p/16256347.html

《第一行代码：Android篇》学习笔记（五）

第5章 全局大喇叭——详解广播机制

5.1 广播机制简介

5.2 接收系统广播

5.2.1 动态注册监听网络变化

5.2.2 静态注册实现开机启动

5.3 发送自定义广播

5.3.1 发送标准广播

5.3.2 发送有序广播

5.4 使用本地广播

5.5 广播的最佳实践——实现强制下线功能

5.6 Git时间——初识版本控制工具

5.6.1 安装Git

5.6.2 创建代码仓库

5.6.3 提交本地代码

第5章全局大喇叭——详解广播机制