第005天：Android开发的广播机制

最新推荐文章于 2023-10-29 14:32:05 发布

侯默辛普森

最新推荐文章于 2023-10-29 14:32:05 发布

阅读量1.1k

点赞数 12

分类专栏：手机app开发实战文章标签： android 网络

本文链接：https://blog.csdn.net/m0_67474913/article/details/128904543

版权

手机app开发实战专栏收录该内容

15 篇文章 40 订阅

订阅专栏

记得在我上学的时候，每个班级的教室里都会装有一个喇叭，这些喇叭都是接入到学校的广播室的，一旦有什么重要的通知，就会播放一条广播来告知全校的师生。类似的工作机制其实在计算机领域也有很广泛的应用，如果你了解网络通信原理应该会知道，在一个IP网络范围中，最大的IP地址是被保留作为广播地址来使用的。比如某个网络的IP范围是192.168.0.XXX,子网掩码是255.255.255.0,那么这个网络的广播地址就是192.168.0.255。广播数据包会被发送到同一网络上的所有端口，这样在该网络中的每台主机都将会收到这条广播。

为了便于进行系统级别的消息通知，Android也引入了一套类似的广播消息机制。相比于我前面举出的两个例子，Android中的广播机制会显得更加灵活，本章就将对这一机制的方方面面进行详细的讲解。

5.1广播机制简介

为什么说Android中的广播机制更加灵活呢？这是因为Android中的每个应用程序都可以对自己感兴趣的广播进行注册，这样该程序就只会接收到自己所关心的广播内容，这些广播可能是来自于系统的，也可能是来自于其他应用程序的。Android提供了一套完整的API,允许应用程序自由地发送和接收广播。发送广播的方法其实之前稍微提到过，如果你记性好的话可能还会有印象，就是借助我们第2章学过的Intent。而接收广播的方法则需要引入一个新的概念——广播接收器(Broadcast Receiver )。

广播接收器的具体用法将会在下一节中做介绍，这里我们先来了解一下广播的类型。Android 中的广播主要可以分为两种类型：标准广播和有序广播。

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

口有序广播(Ordered broadcasts )则是一种同步执行的广播，在广播发出之后，同一时刻只会有一个广播接收器能够收到这条广播消息，当这个广播接收器中的逻辑执行完毕后，广播才会继续传递。所以此时的广播接收器是有先后顺序的，优先级高的广播接收器就可以先收到广播消息，并且前面的广播接收器还可以截断正在传递的广播，这样后面的广播接收器就无法收到广播消息了。有序广播的工作流程如图5.2所示。

掌握了这些基本概念后，我们就可以来尝试一下广播的用法了,首先就从接收系统广播开始吧。

5.2接收系统广播

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

5.2.1动态注册监听网络变化

广播接收器可以自由地对自己感兴趣的广播进行注册，这样当有相应的广播发岀时，广播接收器就能够收到该广播，并在内部处理相应的逻辑。注册广播的方式一般有两种，在代码中注册和在AndroidManifest.xml中注册，其中前者也被称为动态注册，后者也被称为静态注册。

那么该如何创建一个广播接收器呢？其实只需要新建一个类，让它继承自Broadcast- Receiver, 并重写父类的onReceiveO方法就行了。这样当有广播到来时，onReceive( ＞方法就会得到执行，具体的逻辑就可以在这个方法中处理。

那我们就先通过动态注册的方式编写一个能够监听网络变化的程序，借此学习一下广播接收器的基本用法吧。新建一个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);
        intentFilter = new IntentFilter();
        intentFilter.addAction("android.net.connCONNECTIVITY 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的实例，并给它添加了一个值为and「oid.net.conn・CONNECTIVrTY_CHANGE的action,为什么要添加这个值呢？因为当网络状态发生变化时，系统发出的正是一条值为android. net. conn.CONNECTIVITY_CHANGE的广播，也就是说我们的广播接收器想要监听什么广播，就在这里添加相应的action0接下来创建了一个NetworkChangeReceiver的实例，然后调用registerReceiver()方法进行注册，将 NetworkChangeReceiver 的实例和 IntentFilter 的实例都传了进去，这样 NetworkChangeReceiver 就会收到所有值为and「oid.net. conn .CONNECTIVITY CHANGE的广播，也就实现了监听网络变化的功能。

最后要记得，动态注册的广播接收器一定都要取消注册才行，这里我们是在onDestroyO 方法中通过调用unregisterReceiver()方法来实现的。

整体来说，代码还是非常简单的，现在运行一下程序。首先你会在注册完成的时候收到一条广播，然后按下Home键回到主界面(注意不能按Back键，否则。nDestroyO方法会执行),接着打开Settings程序—Data usage进入到数据使用详情界面，然后尝试着开关Cellular data按钮来启动和禁用网络，你就会看到有Toast提醒你网络发生了变化。

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

public class MainActivity extends AppCompatActivity [
    class NetworkChangeReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context，Intent intent)[ConnectivityManager     
        connectionManager =(ConnectivityManager)getSystemService(ContextCONNECTIVITY SERVICE);
        NetworkInfo networkInfo = connectionManager,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 的实例，这是一个系统服务类，专门用于管理网络连接的。然后调用它的getActiveNetwork- Info()方法可以得到Networkinfo的实例，接着调用Networkinfo的isAvailable()方法，就可以判断出当前是否有网络了，最后我们还是通过Toast的方式对用户进行提示。

另外，这里有非常重要的一点需要说明，Android系统为了保护用户设备的安全和隐私，做了严格的规定：如果程序需要进行一些对用户来说比较敏感的操作，就必须在配置文件中声明权限才可以，否则程序将会直接崩溃。比如这里访问系统的网络状态就是需要声明权限的。打开 AndroidManifest.xml文件，在里面加入如下权限就可以访问系统网络状态了：


<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.example.broadcasttest">

<uses-permission android:name=ilandroid.permission.ACCESS_NETWORK_STATE" />

</manifest>

这是你第一次遇到权限的问题，其实Android中有许多操作都是需要声明权限才可以进行的, 后面我们还会不断使用新的权限。不过目前这个访问系统网络状态的权限还是比较简单的，只需要在AndroidManifest.xml文件中声明一下就可以了，而Android 6.0系统中引入了更加严格的运行时权限，从而能够更好地保证用户设备的安全和隐私,关于这部分内容我们将在第7章中学习。

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

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

5.2.2静态注册实现开机启动

动态注册的广播接收器可以自由地控制注册与注销，在灵活性方面有很大的优势，但是它也存在着一个缺点，即必须要在程序启动之后才能接收到广播，因为注册的逻辑是写在onCreateO 方法中的。那么有没有什么办法可以让程序在未启动的情况下就能接收到广播呢？这就需要使用静态注册的方式了。

这里我们准备让程序接收一条开机广播，当收到这条广播时就可以在onReceiveO方法里执行相应的逻辑，从而实现开机启动的功能。可以使用Android Studio »的快捷方式来创建一个广播接收器，右击 com.example.broadcasttest >New—>Othei^Broadcast Receiver,会弾出如图5.5所示的窗口。

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

然后修改BootCompleteReceiver中的代码，如下所示：

public class BootCompleteReceiver extends BroadcastReceiver {

^Override

public void onReceive(Context context, Intent intent) (

Toast.makeText(context, "Boot Complete", Toast.LENGTH_LONG).show();

} "

}

代码非常简单，我们只是在onReceiveO方法中使用Toast弹出一段提示信息。

另夕卜，静态的广播接收器一定要在AndroidManifest.xml文件中注册才可以使用，不过由于我们是使用Android Studi。的快捷方式创建的广播接收器，因此注册这一步已经被自动完成了。打开AndroidManifest.xml文件瞧一瞧，代码如下所示:

<uses-permission android:name="android.permission.ACCESS NETWORK STATE" />

<application

android:allowBackup="true"

android: icon=n(aniipmap/ic_launcher"

android:label="@st ring/appname"

android:supportsRtl="trueH

android:theme="@style/AppTheme">

<receiver

android:name=".BootCompleteReceiver"

android:enabled="true"

android:exported="true">

</receiver>

</application>

</manifest>

可以看到，<application>标签内出现了一个新的标签<receiver>,所有静态的广播接收器都是在这里进行注册的。它的用法其实和<activity>标签非常相似，也是通过android:name 来指定具体注册哪一个广播接收器，而enabled和exported属性则是根据我们刚才勾选的状态自动生成的。

不过目前BootCompleteReceiver还是不能接收到开机广播的,我们还需要对AndroidManifest. xml文件进行修改才行，如下所示：

<uses-permission android:name="android.permission.ACCESSNETWORKSTATE" /> <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

<application

android:allowBackup="true"

android:icon="(amipmap/ic launcher"

and roid: label="(ast ring/appname" android:supportsRtl="true" and roid: theme="(astyle/AppTheme,,>

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

由于Android系统启动完成后会发出一条值为android. intent. action. BOOT COMPLETED 的广播，因此我们在<intent-filter>标签里添加了相应的action0另外，监听系统开机广播也是需要声明权限的，可以看到，我们使用<uses-permission>标签又加入了一条android, permission.RECEIVE_BOOT_COMPLETED 权限。

现在重新运行程序后，我们的程序就已经可以接收开机广播了。将模拟器关闭并重新启动，在启动完成之后就会收到开机广播，如图5.6所示。

到目前为止，我们在广播接收器的onReceive()方法中都只是简单地使用Toast提示了一段文本信息，当你真正在项目中使用到它的时候，就可以在里面编写自己的逻辑。需要注意的是，不要在onReceiveO方法中添加过多的逻辑或者进行任何的耗时操作，因为在广播接收器中是不允许开启线程的，当onReceive()方法运行了较长时间而没有结束时，程序就会报错。因此广播接收器更多的是扮演一种打开程序其他组件的角色，比如创建一条状态栏通知，或者启动一个服务等，这几个概念我们会在后面的章节中学到。

5.3发送自定义广播

现在你已经学会了通过广播接收器来接收系统广播，接下来我们就要学习一下如何在应用程序中发送自定义的广播。前面已经介绍过了，广播主要分为两种类型：标准广播和有序广播，在本节中我们就将通过实践的方式来看一下这两种广播具体的区别。

5.3.1发送标准广播

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

public class MyBroadcastReceiver extends BroadcastReceiver {

^Override

public void onReceive(Context context, Intent intent) {

Toast.makeText(context, "received in MyBroadcastReceiver", Toast.LENGTH_ SHORT).show(); -

这里当MyBroadcastReceiver收到自定义的广播时，就会弹出“received in MyBroadcast- Receiver”的提示。然后在AndroidManifest.xml中对这个广播接收器进行修改：

<application

android:allowBackup="true"

android:icon="@mipmap/ic_launcher"

android:label="@string/app name"

android: supportsRfl=,,true"

android:theme="@style/AppThemeH>

<receiver

android:name=".MyBroadcastReceiver" android:enabled="true" android:exported="true">

<intent-filter>

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

</receiver>

</application>

</manifest>

可以看到，这里让 MyBroadcastReceiver 接收一条值为 com.example.broadcasttest.

MY_BROADCAST的广播，因此待会儿在发送广播的时候，我们就需要发出这样的一条广播。

接下来修改activity main.xml中的代码，如下所示：

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

and roid: layout_width=,,match_pa rent"

android:layout_height="wrap_content" android:text=uSend Broadcast"

</LinearLayout>

这里在布局文件中定义了一个按钮，用于作为发送广播的触发点。然后修改MainActivity中的代码，如下所示：

public class MainActivity extends AppCompatActivity {

©Override

protected void onCreate(Bundle savedlnstanceState) {

super.onCreate(savedlnstanceState);

setContentView(R.layout.activitymain);

Button button = (Button) findViewById(R.id.button); button.setOnClickListener(new View.OnClickListener() { ^Override public void onClick(View v) {

Intent intent = new

Intent("com.example.broadcasttest.MY_BROADCAST"); sendBroadcast(intent);

}

})；

}

可以看到，我们在按钮的点击事件里面加入了发送自定义广播的逻辑。首先构建岀了一个 Intent对象，并把要发送的广播的值传入，然后调用了 Context的sendBroadcast()方法将广播发送出去,这样所有监听com.example.broadcasttest.MY_BROADCAST这条广播的广播接收器就会收到消息。此时发岀去的广播就是一条标准广播。

重新运行程序，并点击一下Send Broadcast按钮，效果如图5.7所示。

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

5.3.2发送有序广播

广播是一种可以跨进程的通信方式，这一点从前面接收系统广播的时候就可以看岀来了。因此在我们应用程序内发出的广播，其他的应用程序应该也是可以收到的。为了验证这一点，我们需要再新建一个 BroadcastTest2 项目，点击 Android Studio 导航栏一>File—>New—>New Project 进行创建。

将项目创建好之后，还需要在这个项目下定义一个广播接收器，用于接收上一小节中的自定义广播。新建AnotherBroadcastReceiver,代码如下所示：

public class AnotherBroadcastReceiver extends BroadcastReceiver {

^Override

public void onReceive(Context context, Intent intent) {

Toast.makeText(context, "received in AnotherBroadcastReceiver11 f

Toast・ LENGTH_SHORT).show();

}

这里仍然是在广播接收器的onReceive()方法中弹出了一段文本信息。然后在

AndroidManifest.xml中对这个广播接收器进行修改，代码如下所示：

<application

and「oid:allowBackup="true"

android:icon="@mipmap/ic_launcher"

android:label="(astring/app name"

android:supportsRtl="true"

android :theme="(astyle/AppTheme">

<receiver

android:name=".AnotherBroadcastReceiver"

android:enabled="true"

android:exported="true">

<intent-filter>

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

</receiver>

</application>

</manifest>

可以看到，AnotherBroadcastReceiver 同样接收的是 com.example. broadcasttest.MY_

BROADCAST这条广播。现在运行BroadcastTest2项目将这个程序安装到模拟器上，然后重新回到

BroadcastTest项目的主界面，并点击一下Send Broadcast按钮，就会分别弹出两次提示信息，如图5.8所示。

图5.8两个程序中都接收到自定义广播

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

回到BroadcastTest项目，然后修改MainActivity中的代码，如下所示：

public class MainActivity extends AppCompatActivity {

^Override

protected void onCreate(Bundle savedlnstanceState) {

super.onCreate(savedlnstanceState); setContentView(R.layout.activitymain);

Button button = (Button) findViewByld(R.id.button); button.setOnClickListener(new View.OnClickListener() { @0verride public void onClick(View v) {

Intent intent = new

Intent("com.example.broadcasttest.MYBROADCAST"); sendOrderedBroadcast(intent, null);

}

})；

}

可以看到，发送有序广播只需要改动一行代码，即将sendBroadcastO方法改成send

OrderedBroadcast () 方法。sendOrderedBroadcast()方法接收两个参数，第一个参数仍然是 Intent,第二个参数是一个与权限相关的字符串，这里传入null就行了。现在重新运行程序，并点击Send Broadcast按钮，你会发现，两个应用程序仍然都可以接收到这条广播。

看上去好像和标准广播没什么区别嘛，不过别忘了，这个时候的广播接收器是有先后顺序的, 而且前面的广播接收器还可以将广播截断，以阻止其继续传播。

那么该如何设定广播接收器的先后顺序呢？当然是在注册的时售进行设定的了，修改

AndroidManifest.xml中的代码，如下所示：

<application

android:allowBackup="true"

android:icon="@mipmap/ic_launcher"

android:label="@string/app_name"

android:supportsRtl="true" android: theme="(astyle/AppTheme">

<receiver

android:name=".AnotherBroadcastReceiver"

android:enabled="true"

android:exported="true">

<intent-filter android:priority="100n>

</receiver>

</application>

</manifest>

可以看到，我们通过android:priority属性给广播接收器设置了优先级，优先级比较高的广播接收器就可以先收到广播。这里将MyBroadcastReceiver的优先级设成了 100,以保证它一定会在AnotherBroadcastReceiver之前收到广播。

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

public class MyBroadcastReceiver extends BroadcastReceiver {

(QOverride

public void onReceive(Context context, Intent intent) {

Toast.makeText(context, "received in MyBroadcastReceiver",

Toast.LENGTH_SHORT).show();

abortBroadcast();

}

如果在onReceive()方法中调用了 abortBroadcast ()方法，就表示将这条广播截断，后面

的广播接收器将无法再接收到这条广播。现在重新运行程序，并点击一下Send Broadcast按钮，你会发现，只有MyBroadcastReceiver中的Toast信息能够弹出，说明这条广播经过MyBroadcast- Receiver之后确实是终止传递了。

5.4使用本地广播

前面我们发送和接收的广播全部属于系统全局广播，即发出的广播可以被其他任何应用程序接收到，并且我们也可以接收来自于其他任何应用程序的广播。这样就很容易引起安全性的问题, 比如说我们发送的一些携带关键性数据的广播有可能被其他的应用程序截获，或者其他的程序不停地向我们的广播接收器里发送各种垃圾广播。

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

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

public class MainActivity extends AppCompatActivity {

private IntentFilter intentFilter;

private LocaLReceiver LocalReceiver;

private LocalBroadcastManager LocalBroadcastManager;

^Override protected void onCreate(Bundle savedlnstanceState) { super.onCreate(savedlnstanceState); setContentView(R.layout.activitymain);

LocalBroadcastManager = LocalBroadcastManager.getlnstance(this); // 获取实例 Button button = (Button) findViewById(R.id.button);

button.setOnClickListener(new View.OnClickListener() {

^Override

public void onClick(View v) {

Intent intent = new Intent("com.example.broadcasttest.LOCAL__ BROADCAST"); "

LocalBroadcastManager. sendBroadcast (intent); // 发送本地广播

}

})； IntentFilter = new IntentFilter();

intentFilter.addAction("com.example.broadcasttest.LOCAL_BROADCAST")； localReceiver = new LocalReceiver();

LocalBroadcastManager.registerReceiver(localReceiverf intentFilter)； // 注册本地广播监听器

(QOverride

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的getlnstance()方法得到了它的一个实例，然后在注册广播接收器的时候调用的是LocalBroadcastManager的 registerReceiver ()方法,在发送广播的时候调用的是 LocalBroadcastManager 的 sendBroadcast () 方法，仅此而已。这里我们在按钮的点击事件里面发出了一条com. example .broadcasttest. LOCAL_BROADCAST广播，然后在LocalReceiver里去接收这条广播。重新运行程序，并点击Send Broadcast按钮，效果如图5.9所示。

BroadcastTest

图5.9接收到本地广播

可以看到，LocalReceiver成功接收到了这条本地广播，并通过Toast提示了出来。如果你还有兴趣进行实验，可以尝试在BroadcastTest2中也去接收com.example.broadcasttest.

LOCAL_BROADCAST这条广播。答案是显而易见的，肯定无法收到，因为这条广播只会在 BroadcastTest程序内传播。

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

最后我们再来盘点一下使用本地广播的几点优势吧。

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

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

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

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

本章的内容不是非常多，因此相信你也一定学得很轻松吧。现在我们就准备通过一个完整例子的实践，来综合运用一下本章中所学到的知识。

强制下线功能应该算是比较常见的了，很多的应用程序都具备这个功能，比如你的QQ号在别处登录了，就会将你强制挤下线。其实实现强制下线功能的思路也比较简单，只需要在界面上弹出一个对话框，让用户无法进行任何其他操作，必须要点击对话框中的确定按钮，然后回到登录界面即可。可是这样就存在着一个问题，因为当我们被通知需要强制下线时可能正处于任何一个界面，难道需要在每个界面上都编写一个弹出对话框的逻辑？如果你真的这么想，那思维就偏远了，我们完全可以借助本章中所学的广播知识，来非常轻松地实现这一功能。新建一个 BroadcastBestPractice项目，然后开始动手吧。

强制下线功能需要先关闭掉所有的活动，然后回到登录界面。如果你的反应足够快的话，应该会想到我们在第2章的最佳实践部分早就已经实现过关闭所有活动的功能了，因此这里只需要使用同样的方案即可。先创建一个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.finishO;

}

)

然后创建BaseActivity类作为所有活动的父类，代码如下所示：

public class BaseActivity extends AppCompatActivity {

@Override

protected void onCreate(Bundle savedlnstanceState) { super・ onCreate(savedlnstanceState); ActivityCollector.addActivity(this);

}

@0verride

protected void onDestroy() { super.onDestroyO; Activitycollector.removeActivity(this);

)

}

以上代码都是直接拿之前写好的内容，非常开心。不过从这里开始，就要靠我们自己去动手实现了。首先需要创建一个登录界面的活动，新建LoginActivity,并让Android Studio帮我们自动生成相应的布局文件。然后编辑布局文件activityjogin.xml,代码如下所示：

<LinearLayout

android:orientation="horizontal" android: layout_width=,,match_pa rent" 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="@dp"

and roid: layout_height=,,wrap_content"

android:layout_weight=H1"

android:layout gravity="center_vertical" />

v/Linea「Layout〉

<LinearLayout

android :orientation=,,horizontal"

android: layout_width=,,match_parent"

android:layout_height="60dp"> <TextView

android :layout_width=,,90dp"

android:layout_height="wrap_content"

android:layoutg ravity="cente r_ve rtical"

android:textSize="18sp" android:text="Password:" />

<EditText

android:id="@+id/password"

android:layout_width="0dp"

android:layout_height="wrap_content" android: layout_weight="l,' android:layoutgravity="center_vertical" android:inputType="textPassword" />

</LinearLayout>

<Button

android:id="@+id/logirT

android:layout_width="match_parent”

android:layout_height="60dp" android:text="Login" />

</LinearLayout>

这里我们使用LinearLayout编写出了一个登录布局，最外层是一个纵向的LinearLayout,里面包含了 3行直接子元素。第一行是一个横向LinearLayout,用于输入账号信息；第二行也是一个横向的LinearLayout,用于输入密码信息；第三行是一个登录按钮。这个布局文件里面用到的全部都是我们之前学过的内容，相信你理解起来应该不会费劲。

接下来修改LoginActivity中的代码，如下所示：

public class LoginActivity extends BaseActivity {

private EditText accountEdit;

private EditText passwordEdit;

private Button login;

^Override protected void onCreate(Bundle savedlnstanceState) ( super.onCreate(savedlnstanceState); setContentView(R.layout.activitylogin);

accountEdit = (EditText) findViewByld(R.id.account); passwordEdit = (EditText) findViewById(R.id.password); login = (Button) findViewByld(R.id.login);

login.setOnClickListener(new View.OnClickListener() {

^Override

public void onClick(View v) {

String account = accountEdit.getText().toString();

String password = passwordEdit.getText().toString();

11如果账号是admin且密码是123456,就认为登录成功

if (account.equals("admin") && password.equals(l>123456")) { Intent intent = new Intent(LoginActivity.this f MainActivity. class);

startActivity(intent); finishO;

} else {

Toast.makeText(LoginActivity.this f "account or password is invalid", Toast.LENGTH_SHORT).show();

})；

}

这里我们模拟了一个非常简单的登录功能。首先要将LoginActivity的继承结构改成继承自 BaseActivity,然后调用findViewById()方法分别获取到账号输入框、密码输入框以及登录按钮的实例。接着在登录按钮的点击事件里面对输入的账号和密码进行判断，如果账号是admin并且密码是123456,就认为登录成功并跳转到MainActivity,否则就提示用户账号或密码错误。

因此，你就可以将MainActivity理解成是登录成功后进入的程序主界面了，这里我们并不需要在主界面里提供什么花哨的功能，只需要加入强制下线功能就可以了，修改aCtivity_main.xml 中的代码，如下所示：

<Button

android:id="@+id/force_offline” android: ■layout_width="match_parent" android:layout_height="wrap_content" android:text="Send force offline broadcast" />

</LinearLayout>

非常简单，只有一个按钮而已，用于触发强制下线功能。然后修改MainActivity中的代码，如下所示：

public class MainActivity extends BaseActivity {

(QOverride

protected void onCreate(Bundle savedlnstanceState) ( super.onCreate(savedlnstanceState); setContentView(R.layout.activitymain);

Button forceOffline = (Button) findViewByld(R.id.force_offline); forceOffline.setOnClickListener(new View.OnCtickListener() { ©Override

public void onClick(View v) { Intent intent = new Intent("com.example.broadcastbestpractice.

FORCE_OFFLINEH); sendBroadcast(intent);

} })；

}

同样非常简单，不过这里有个重点，我们在按钮的点击事件里面发送了一条广播，广播的值为 com.example.broadcastbestpractice.FORCE OFFLINE,这条广播就是用于通知程序强制用户下线的。也就是说强制用户下线的逻辑并不是写在MainActivity里的，而是应该写在接收这条广播的广播接收器里面，这样强制下线的功能就不会依附于任何的界面，不管是在程序的任何地方，只需要发出这样一条广播，就可以完成强制下线的操作了。

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

那么到底应该怎么办呢？答案其实很明显，只需要在BaseActivity中动态注册一个广播接收器就可以了，因为所有的活动都是继承自BaseActivity的。

修改BaseActivity中的代码，如下所示:

public class BaseActivity extends AppCompatActivity (

private ForceOfflineReceiver receiver;

(aOverride

protected void onCreate(Bundle savedlnstanceState) {

super.onCreate(savedlnstanceState); Activitycollector.addActivity(this);

}

(^Override protected void onResumeO { super.onResume(); IntentFilter intentFilter = new IntentFilter(); intentFilter.addAction("com. example.broadcastbestpractice . FORCE_OFFLINE"); receiver = new ForceOfflineReceiver();

registerReceiver(receiver, intentFilter);

}

if (receiver != null) {

unregisterReceiver(receiver);

receiver = null;

}

(QOverride

protected void onDestroy() (

super.onDestroy();

ActivityCollector.removeActivity(this);

}

class ForceOfflineReceiver extends BroadcastReceiver {

^Override

public void onReceive(final 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 Dialoglnterface.OnClickListener() { ^Override public void onClick(Dialoginterface dialog, int which) {

ActivityCollector. f inishAll(); // 销毁所有活动

Intent intent = new Intent(context, LoginActivity.class); context.startActivity(intent); // 重新启动 LoginActivity

}

})；

builder.show();

}

先来看一下ForceOfflineReceiver中的代码，这次onReceive()方法里可不再是仅仅弹出一个Toast 了，而是加入了较多的代码，那我们就来仔细地看看吧。首先肯定是使用 AlertDialog.Builder来构建一个对话框，注意这里一定要调用setCancelable()方法将对话框设为不可取消，否则用户按一下Back键就可以关闭对话框继续使用程序了。然后使用 setPositiveButton()方法来给对话框注册确定按钮，当用户点击了确定按钮时，就调用 ActivityCollector的finishAH()方法来销毁掉所有活动，并重新启动LoginActivity这个活动。

再来看一下我们是怎么注册ForceOfflineReceiver这个广播接收器的，可以看到，这里重写了 onResumeO和onPause()这两个生命周期函数，然后分别在这两个方法里注册和取消注册了 ForceOfflineReceiver o

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

这样的话,

文件进行修改,

所有强制下线的逻辑就已经完成了，接下来我们还需要对AndroidManifest.xml 代码如下所示：

〈manifest

xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.broadcastbestpractice">

<application

android:allowBackup="true"

android: icon=,,@mipmap/ic_launcher"

android:label="@string/appname"

android:supportsRtl="true"

android :theme="(astyle/AppTheme,,>

</activity>

<intent-filter>

<action android: name=,(android. intent. action. MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter>

</activity>

</application>

</manifest>

这里只需要对一处代码进行修改,就是将主活动设置为LoginActivity而不再是MainActivity, 因为你肯定不希望用户在没登录的情况下就能直接进入到程序主界面吧？

好了，现在来尝试运行一下程序吧，首先会进入到登录界面，并可以在这里输入账号和密码, 如图5.10所示。

BroadcastBestPractKe

Account sdmin

图5.10登录界面

如果输入的账号是admin,密码是123456,点击登录按钮就会进入到程序的主界面，如图 5.11所示。这时点击一下发送广播的按钮，就会发出一条强制下线的广播，ForceOfflineReceiver 里收到这条广播后会弹岀一个对话框提示用户已被强制下线，如图5.12所示。

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

结束了本章的最佳实践部分，接下来我们要进入一个特殊的环节。相信你一定也知道，几乎所有出色的项目都不会是由一个人单枪匹马完成的，而是由一个团队共同合作开发完成的。这个时候多人之间代码同步的问题就显得异常重要，因此版本控制工具也就应运而生了。常见的版本控制工具主要有svn和Git,本书中将会对Git的使用方法进行全面的讲解，并且讲解的内容是穿插于一些章节当中的。那么今天，我们就先来看一看关于Git最基本的用法。

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

Git是一个开源的分布式版本控制工具，它的开发者就是鼎鼎大名的Linux操作系统的作者 Linus Torvaldso Git被开发出来的初衷是为了更好地管理Linux内核，而现在却早已被广泛应用于全球各种大中小型的项目中。今天是我们关于Git的第一堂课，主要是讲解一下它最基本的用法，那么就从安装Git开始吧。

安装 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/,可以看到如图5.13所示的页面。

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

5.6.2创建代码仓库

虽然在Windows上安装的Git是可以在图形界面上进行操作的,并且Android Studio也支持以图形化的形式操作Git,但是这里我并不建议你这样做，因为Git的各种命令才是你应该掌握的核心技能，不管你是在哪个操作系统中，使用命令来操作Git肯定都是通用的。而图形化的操作应该是在你能熟练掌握命令用法的前提下，进一步提升你工作效率的手段。

那么我们现在就来尝试一下如何通过命令来使用Git。如果你使用的是Linux系统，就先打开shell界面，如果使用的是Windows系统，就从开始里找到Git Bash并打开。

首先应该配置一下你的身份，这样在提交代码的时候Git就可以知道是谁提交的了，命令如下所示：

git config --global user.name "Tony"

git config --global user.email "tony@gmail.com"

配置完成后你还可以使用同样的命令来查看是否配置成功，只需要将最后的名字和邮箱地址去掉即可，如图5.14所示。

图5.14查看git用户名和邮箱

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

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

图5.15切换到BroadcastBestPractice项目目录下

然后在这个目录下面输入如下命令:

git init

很简单吧！只需要一行命令就可以完成创建代码仓库的操作，如图5.16所示。

图5.16创建代码仓库

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

图5.17查看.git文件

如果你想要删除本地仓库，只需要删除这个文件夹就行了。

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命令的后面，我们一定要通过参数来加上提交的描述信息，没有描述信息的提交被认为是不合法的。这样所有的代码就已经成功提交了！

好了，关于Git的内容，今天我们就学到这里，虽然内容并不多，但是你已经将Git最基本的用法都掌握了，不是吗？在本书后面的章节，还会穿插一些Git的讲解，到时候你将学会更多关于Git的使用技巧，现在就让我们来总结一下吧。

5.7小结与点评

本章中我们主要是对Android的广播机制进行了深入的研究，不仅了解了广播的理论知识，还掌握了接收广播、发送自定义广播以及本地广播的使用方法。广播接收器属于Android四大组件之一，在不知不觉中你已经掌握了四大组件中的两个了。

在最佳实践环节中你一定也收获了不少，不仅运用到了本章所学的广播知识，还将前面章节所学到的技巧综合运用到了一起。经过这个例子之后，相信你对所涉及的每个知识点都有了更深一层的认识。另外，本章还添加了一个最最特殊的环节，即Git时间。在这个环节中，我们对 Git这个版本控制工具进行了初步的学习，后面还会学习关于它的更多内容。

下一章我们本应该继续学习Android四大组件中的内容提供器，不过由于学习内容提供器之前需要先掌握Android中的持久化技术，因此下一章我们就先对这一主题展开讨论。

侯默辛普森

关注

12
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
第005天：Android开发的广播机制

所以此时的广播接收器是有先后顺序的，优先级高的广播接收器就可以先收到广播消息，并且前面的广播接收器还可以截断正在传递的广播，这样后面的广播接收器就无法收到广播消息了。里的，而是应该写在接收这条广播的广播接收器里面，这样强制下线的功能就不会依附于任何的界面，不管是在程序的任何地方，只需要发出这样一条广播，就可以完成强制下线的操作了。中的每个应用程序都可以对自己感兴趣的广播进行注册，这样该程序就只会接收到自己所关心的广播内容，这些广播可能是来自于系统的，也可能是来自于其他应用程序的。
复制链接

扫一扫