在网络通信中,会规定一个IP
网络范围,最大的IP
地址是被保留作为广播地址来使用的。比如某个网络的IP
范围是192.168.0.XXX
,子网掩码是255.255.255.0
,那么这个网络的广播地址就是192.168.0.255
。广播数据包会被发送到同一网络上的所有端口,这样该网络中的每台主机都会收到这条广播。
为了便于进行系统级别的消息通知,Android
也引入了一套类似的广播消息机制。
1 广播机制简介
Android
中的广播机制更加灵活,这是因为Android
中的每个应用程序都可以对自己感兴趣的广播进行注册,这样该程序就只会收到自己所关心的广播内容,这些广播可能是来自于系统的,也可能是来自于其他应用程序的。
Android
提供了一套完整的API
,允许应用程序自由地发送和接收广播,即:广播发送者、广播接收者(BroadcastReceiver
)。
broadcast [ˈbrɔːdkæst] 广播,播送;广播,播送 receiver [rɪˈsiːvər] 收受者,收件人
BroadcastReceiver
,广播接收者,它是一个监听器,可以监听或接收应用或系统发出的广播消息,所以它可以很方便的进行系统组件之间的通信。只要存在与之匹配的Broadcast
被以Intent
的形式发送出来,BroadcastReceiver
就会被激活,并自动触发它的onReceive()
方法,当onReceive()
方法被执行完成之后,BroadcastReceiver
的实例就会被销毁。
广播的应用场景:
- 同一
APP
内部的同一组件内的消息通信(单个或多个线程之间); - 同一
APP
内部的不同组件之间的消息通信(单个进程); - 同一
APP
具有多个进程的不同组件之间的消息通信; - 不同
APP
之间的组件之间消息通信; Android
系统在特定情况下与APP
之间的消息通信,如:网络变化、电池电量、屏幕开关等。
2 广播类型
Android
中的广播主要可以分为两种类型:标准广播和有序广播。
2.1 标准广播(normal broadcasts
)
标准广播是一种完全异步执行的广播,在广播发出之后,所有的BroadcastReceiver
几乎会在同一时刻收到这条广播消息,因此它们之间没有任何先后顺序可言。这种广播的效率会比较高,但同时也意味着它是无法被截断的。 标准广播的工作流程如图所示:
2.2 有序广播(ordered broadcasts
)
有序广播则是一种同步执行的广播,在广播发出之后,同一时刻只会有一个BroadcastReceiver
能够收到这条广播消息,当这个BroadcastReceiver
中的逻辑执行完毕后,广播才会继续传递。所以此时的BroadcastReceiver
是有先后顺序的, 优先级高的BroadcastReceiver
就可以先收到广播消息,并且前面的BroadcastReceiver
还可以截断正在传递的广播,这样后面的BroadcastReceiver
就无法收到广播消息了。 有序广播的工作流程如图所示:
广播接受者接收广播的顺序规则(同时面向静态和动态注册的广播接受者):按照Priority
属性值从大—>小排序,Priority
属性相同者,动态注册的广播优先。
2.3 其他广播类型
2.3.1 系统广播(System Broadcast
)
Android
系统中内置了多个系统广播,只要涉及到手机的基本操作,基本上都会发出相应的系统广播。如:开机启动,网络状态改变,拍照,屏幕关闭与开启,电量不足等等。
每个系统广播都具有特定的intent-filter
,其中主要包括具体的action
,系统广播发出后,将被相应的BroadcastReceiver
接收。当使用系统广播时,只需在注册广播接收者时定义相关的action
即可,不需要手动发送广播,当系统有相关操作时会自动进行系统广播的发送。
2.3.2 APP
应用内广播(Local Broadcast
)
由于Android
中的广播可以跨APP
直接通信(exported
对于有intent-filter
情况下默认值为true
),可能会出现相应安全隐患:
exported [ɪkˈspɔːtɪd] [贸易]出口;输出
- 其他
APP
针对性发出与当前APP intent-filter
相匹配的广播,由此导致当前APP
不断接收广播并处理; - 其他
APP
注册与当前APP
一致的intent-filter
用于接收广播,获取广播具体信息;即会出现安全性 & 效率性的问题
解决方案
方案1
:将全局广播设置成局部广播
- 对于同一
APP
内部发送和接收广播,将exported
属性设置成false
,使得非本APP
内部发出的此广播不被接收; - 在广播发送和接收时,都增加上相应的
permission
,用于权限验证; - 发送广播时,指定特定广播接收器所在的包名,具体是通过
intent.setPackage(packageName)
指定,这样此广播将只会发送到此包中的APP
内与之相匹配的有效广播接收器中;
方案2
:使用APP
应用内广播(LocalBroadcastManager
类)
APP
应用内广播可理解为一种局部广播,广播的发送者和接收者都同属于一个APP
。相比于全局广播(普通广播),APP
应用内广播优势体现在:安全性高 & 效率高。
使用封装好的LocalBroadcastManager
类使用方式上与全局广播几乎相同,只是注册/取消注册广播接收器和发送广播时将参数的context
变成了LocalBroadcastManager
的单一实例。
对于LocalBroadcastManager
方式发送的应用内广播,只能通过LocalBroadcastManager
动态注册,不能静态注册。
class MainActivity : BaseActivity() {
private lateinit var button: Button
lateinit var localBroadcastReceiver: LocalBroadcastReceiver
lateinit var localBroadcastManager: LocalBroadcastManager
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
button = findViewById(R.id.button)
localBroadcastReceiver = LocalBroadcastReceiver()
val intentFilter = IntentFilter()
intentFilter.addAction("com.example.broadcasttest.LOCAL")
localBroadcastManager = LocalBroadcastManager.getInstance(this)
localBroadcastManager.registerReceiver(localBroadcastReceiver, intentFilter)
button.setOnClickListener {
val intent = Intent("com.example.broadcasttest.LOCAL")
localBroadcastManager.sendBroadcast(intent);
}
}
override fun onDestroy() {
super.onDestroy()
localBroadcastManager.unregisterReceiver(localBroadcastReceiver)
}
inner class LocalBroadcastReceiver : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
Toast.makeText(context, "receive local broadcast", Toast.LENGTH_LONG).show()
}
}
}
本地广播和全局广播的区别
BroadcastReceiver
是针对应用间、应用与系统间、应用内部进行通信的一种方式。LocalBroadcastReceiver
仅在自己的应用内发送接收广播,也就是只有自己的应用能收到,数据更加安全广播只在这个程序里,而且效率更高。
BroadcastReceiver
采用的binder
方式实现跨进程间的通信;LocalBroadcastManager
使用Handler
通信机制LocalBroadcastReceiver
使用LocalBroadcastReceiver
不能静态注册,只能采用动态注册的方式onReceive(context: Context?, intent: Intent?)
中的context
返回值是不一样:- 对于全局广播的动态注册,
context
返回值是:Activity Context
; - 对于应用内广播的动态注册(
LocalBroadcastManager
方式),context
返回值是:Application Context
;
- 对于全局广播的动态注册,
在发送和注册的时候采用,LocalBroadcastManager
的sendBroadcast
方法和registerReceiver
方法注册过程,主要是向mReceivers
和mActions
添加相应数据:
mReceivers
:数据类型为HashMap<BroadcastReceiver, ArrayList>
, 记录广播接收者与IntentFilter
列表的对应关系;mActions
:数据类型为HashMap<String, ArrayList>
, 记录action
与广播接收者的对应关系根据Intent
的action
来查询相应的广播接收者列表; 发送MSG_EXEC_PENDING_BROADCASTS
消息,回调相应广播接收者的onReceiver
方法
2.3.3 粘性广播(Sticky Broadcast
)
sticky [ˈstɪki] 粘的;粘性的
由于在 Android 5.0 & API 21
中已经失效,所以不建议使用,在这里不作阐述。
3 注册广播/接收广播
Android
内置了很多系统级别的广播,我们可以在应用程序中通过监听这些广播来得到各种系统的状态信息。比如手机开机完成后会发出一条广播,电池的电量发生变化会发出一条广播,系统时间发生改变也会发出一条广播,等等。如果想要接收这些广播,就需要使用 BroadcastReceiver
。
我们可以根据自己感兴趣的广播,自由地注册BroadcastReceiver
,这样当有相应的广播发出时,相应的BroadcastReceiver
就能够收到该广播,并可以在内部进行逻辑处理。注册BroadcastReceiver
的方式一般有两种:在代码中注册和在AndroidManifest.xml
中注册。其 中前者也被称为动态注册,后者也被称为静态注册。
- 动态注册:跟随组件的生命变化,组件结束,广播结束。在组件结束前,需要先移除广播,否则容易造成内存泄漏
- 静态注册:常驻系统,不受组件生命周期影响,即便应用退出,广播还是可以被接收,耗电、占内存
3.1 动态注册
那么如何创建一个BroadcastReceiver
呢?其实只需新建一个类,让它继承自BroadcastReceiver
,并重写父类的onReceive()
方法就行了。这样当有广播到来时, onReceive()
方法就会得到执行,具体的逻辑就可以在这个方法中处理。
下面先通过动态注册的方式编写一个能够监听时间变化的程序:
class MainActivity : AppCompatActivity() {
lateinit var timeChangeReceiver: TimeChangeReceiver
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val intentFilter = IntentFilter()
intentFilter.addAction("android.intent.action.TIME_TICK")
timeChangeReceiver = TimeChangeReceiver()
registerReceiver(timeChangeReceiver, intentFilter)
}
override fun onDestroy() {
super.onDestroy()
unregisterReceiver(timeChangeReceiver)
}
inner class TimeChangeReceiver : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
Toast.makeText(context, "Time has changed", Toast.LENGTH_LONG).show()
}
}
}
filter [ˈfɪltər] 过滤;(用程序)筛选 tick [tɪk] 记号,钩号
可以看到,我们在MainActivity
中定义了一个内部类TimeChangeReceiver
,这个类是继承自BroadcastReceiver
的,并重写了父类的onReceive()
方法。这样每当系统时间发生变化时,onReceive()
方法就会得到执行,这里只是简单地使用Toast
提示了一段文本信息。
然后观察onCreate()
方法,首先我们创建了一个IntentFilter
的实例,并给它添加了一个值为android.intent.action.TIME_TICK
的action
,为什么要添加这个值呢?因为当系统时间发生变化时,系统发出的正是一条值为android.intent.action.TIME_TICK
的广播, 也就是说我们的BroadcastReceiver
想要监听什么广播,就在这里添加相应的action
。接下来创建了一个TimeChangeReceiver
的实例,然后调用registerReceiver()
方法进行注 册,将TimeChangeReceiver
的实例和IntentFilter
的实例都传了进去,这样 TimeChangeReceiver
就会收到所有值为android.intent.action.TIME_TICK
的广播, 也就实现了监听系统时间变化的功能。
最后要记得,动态注册的BroadcastReceiver
一定要取消注册才行,这里我们是在onDestroy()
方法中通过调用unregisterReceiver()
方法来实现的。
在运行一下程序,系统每隔 一分钟就会发出一条android.intent.action.TIME_TICK
的广播,因此我们最多只需要等待一分钟就可以收到这条广播了。
这就是动态注册BroadcastReceiver
的基本用法,虽然这里我们只使用了一种系统广播来举例,但是接收其他系统广播的用法是一模一样的。Android
系统还会在亮屏熄屏、电量变化、网 络变化等场景下发出广播。 如果想查看完整的系统广播列表,可以到如下的路径中去查看:
<Android SDK>/platforms/<任意android api版本>/data/broadcast_actions.txt
3.2 静态注册
动态注册的BroadcastReceiver
可以自由地控制注册与注销,在灵活性方面有很大的优势。但是它存在着一个缺点,即必须在程序启动之后才能接收广播,因为注册的逻辑是写在onCreate()
方法中的。那么有没有什么办法可以让程序在未启动的情况下也能接收广播呢? 这就需要使用静态注册的方式了。
其实从理论上来说,动态注册能监听到的系统广播,静态注册也应该能监听到,在过去的Android
系统中确实是这样的。但是由于大量恶意的应用程序利用这个机制在程序未启动的情况下监听系统广播,从而使任何应用都可以频繁地从后台被唤醒,严重影响了用户手机的电量和性能,因此Android
系统几乎每个版本都在削减静态注册BroadcastReceiver
的功能。
在Android 8.0
系统之后,所有隐式广播都不允许使用静态注册的方式来接收了。隐式广播指的是那些没有具体指定发送给哪个应用程序的广播,大多数系统广播属于隐式广播,但是少数特殊的系统广播目前仍然允许使用静态注册的方式来接收。 这些特殊的系统广播列表详见https://developer.android.google.cn/guide/components/broadcast-exceptions.html
在这些特殊的系统广播当中,有一条值为android.intent.action.BOOT_COMPLETED
的广播,这是一条开机广播。这里准备实现一个开机启动的功能。在开机的时候,我们的应用程序肯定是没有启动的, 因此这个功能显然不能使用动态注册的方式来实现,而应该使用静态注册的方式来接收开机广播,然后在onReceive()
方法里执行相应的逻辑,这样就可以实现开机启动的功能了:
可以看到,这里我们将创建的类命名为BootCompleteReceiver
,Exported
属性表示是否允许这个BroadcastReceiver
接收本程序以外的广播,Enabled
属性表示是否启用这个BroadcastReceiver
。勾选这两个属性,点击Finish
完成创建。
然后修改BootCompleteReceiver
中的代码,如下所示:
class BootCompleteReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
Toast.makeText(context, "Boot Complete", Toast.LENGTH_LONG).show()
}
}
另外,静态的BroadcastReceiver
一定要在AndroidManifest.xml
文件中注册才可以使用。不过,使用Android Studio
的快捷方式创建的BroadcastReceiver
,因此注册这一步已经自动完成了。 打开AndroidManifest.xml
文件瞧一瞧,代码如下所示:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.kotlintest">
<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.KotlinTest">
<receiver
android:name=".BootCompleteReceiver"
android:enabled="true"
android:exported="true" />
<activity
android:name=".MainActivity"
android:configChanges="orientation|keyboardHidden|screenSize"
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>
,所有静态的BroadcastReceiver
都是在这里进行注册的。它的用法其实和<activity>
标签非常相似,也是通过android:name
指定具体注册哪一个BroadcastReceiver
,而enabled
和exported
属性则是根据我们刚才勾选的状态自动生成的。
不过目前的BootCompleteReceiver
是无法收到开机广播的,因为我们还需要对AndroidManifest.xml
文件进行修改才行,如下所示:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.kotlintest">
<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.KotlinTest">
<receiver
android:name=".BootCompleteReceiver"
android:enabled="true"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
<activity
android:name=".MainActivity"
android:configChanges="orientation|keyboardHidden|screenSize"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
由于Android
系统启动完成后会发出一条值为android.intent.action.BOOT_COMPLETED
的广播,因此我们在<receiver>
标签中又添加了一个<intent-filter>
标签,并在里面声明了相应的action
。
另外,这里有非常重要的一点需要说明。Android
系统为了保护用户设备的安全和隐私,做了严格的规定:如果程序需要进行一些对用户来说比较敏感的操作,必须在AndroidManifest.xml
文件中进行权限声明,否则程序将会直接崩溃。比如这里接收系统的开机广播就是需要进行权限声明的,所以我们在上述代码中使用<uses-permission>
标签声明了android.permission.RECEIVE_BOOT_COMPLETED
权限。
重新运行程序,现在程序已经可以接收开机广播了。
到目前为止,在BroadcastReceiver
的onReceive()
方法中只是简单地使用Toast
提示了一段文本信息,在真正在项目中使用它的时候,可以在里面编写自己的逻辑。需要注意的是,不要在onReceive()
方法中添加过多的逻辑或者进行任何的耗时操作,因为 BroadcastReceiver
中是不允许开启线程的,当onReceive()
方法运行了较长时间而没有结束时,程序就会出现错误。
4 发送自定义广播
4.1 发送标准广播
在发送广播之前,还是需要先定义一个BroadcastReceiver
来准备接收此广播,不然发出去也是白发。因此新建一个MyBroadcastReceiver
,并在onReceive()
方法中加入如下代码:
class MyBroadcastReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
Toast.makeText(context, "received in MyBroadcastReceiver", Toast.LENGTH_SHORT).show()
}
}
当MyBroadcastReceiver
收到自定义的广播时,就会弹出"received in MyBroadcastReceiver"
的提示。
然后在AndroidManifest.xml
中对这个BroadcastReceiver
进行修改:
<receiver
android:name=".MyBroadcastReceiver"
android:enabled="true"
android:exported="true">
<intent-filter>
<action android:name="com.example.broadcasttest.MY_BROADCAST" />
</intent-filter>
</receiver>
可以看到,这里让MyBroadcastReceive
r接收一条值为com.example.broadcasttest.MY_BROADCAST
的广播,因此待会儿在发送广播的时候,需要发出这样的一条广播。
接下来修改activity_main.xml
中的代码,如下所示:
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="send broadcast"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
这里在布局文件中定义了一个按钮,用于作为发送广播的触发点。然后修改MainActivity
中的代码,如下所示:
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<Button>(R.id.button).setOnClickListener {
val intent = Intent("com.example.broadcasttest.MY_BROADCAST")
intent.setPackage(packageName)
sendBroadcast(intent)
}
}
}
首先构建了一个Intent
对象,并把要发送的广播的值传入。然后调用Intent
的setPackage()
方法,并传入当前应用程序的包名。packageName
是getPackageName()
的语法糖写法,用于获取当前应用程序的包名。最后调用sendBroadcast()
方法将广播发送出去,这样所有监听com.example.broadcasttest.MY_BROADCAST
这条广播的BroadcastReceiver
就会收到消息了。此时发出去的广播就是一条标准广播。
在Android 8.0
系统之后,静态注册的BroadcastReceiver
是无法接收隐式广播的,而默认情况下我们发出的自定义广播恰恰都是隐式广播。因此这里一定要调用setPackage()
方法,指定这条广播是发送给哪个应用程序的,从而让它变成一条显式广播,否则静态注册的BroadcastReceiver
将无法接收到这条广播。
这样就成功完成了发送自定义广播的功能。另外,由于广播是使用Intent
来发送的,因此你还可以在Intent
中携带一些数据传递给相应的BroadcastReceiver
,这一点和Activity
的用法是比较相似的。
4.2 发送有序广播
和标准广播不同,有序广播是一种同步执行的广播,并且是可以被截断的。 为了验证这一点, 我们需要再创建一个新的BroadcastReceiver
。新建AnotherBroadcastReceiver
,代码如下 所示:
class AnotherBroadcastReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
Toast.makeText(context, "received in AnotherBroadcastReceiver", Toast.LENGTH_LONG).show()
}
}
然后在AndroidManifest.xml
中对这个BroadcastReceiver
的配置进行修改,代码如下所示:
<receiver
android:name=".AnotherBroadcastReceiver"
android:enabled="true"
android:exported="true">
<intent-filter>
<action android:name="com.example.broadcasttest.MY_BROADCAST"/>
</intent-filter>
</receiver>
可以看到,AnotherBroadcastReceiver
同样接收的是com.example.broadcasttest.MY_BROADCAST
这条广播。现在重新运行程序,并点 击按钮,就会分别弹出两次提示信息。
到目前为止,程序发出的都是标准广播,下面尝试一下发送有序广播。修改MainActivity
中的代码,如下所示:
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
findViewById<Button>(R.id.button).setOnClickListener {
val intent = Intent("com.example.broadcasttest.MY_BROADCAST")
intent.setPackage(packageName)
sendOrderedBroadcast(intent, null)
}
}
}
可以看到,发送有序广播只需要改动一行代码,即将sendBroadcast()
方法改成sendOrderedBroadcast()
方法。sendOrderedBroadcast()
方法接收两个参数:第一个 参数仍然是Intent
;第二个参数是一个与权限相关的字符串,这里传入null
就行了。 现在重新运行程序,并点击按钮,会发现,两个BroadcastReceiver
仍然都可以收到这条广播。
看上去好像和标准广播并没有什么区别。不过这个时候的BroadcastReceiver
是有先后顺序的,而且前面的BroadcastReceiver
还可以将广播截断,以阻止其继续传播。
那么该如何设定BroadcastReceiver
的先后顺序呢?在注册的时候进行设定,修改AndroidManifest.xml
中的代码,如下所示:
<receiver
android:name=".MyBroadcastReceiver"
android:enabled="true"
android:exported="true">
<intent-filter android:priority="100">
<action android:name="com.example.broadcasttest.MY_BROADCAST" />
</intent-filter>
</receiver>
可以看到,通过android:priority
属性给BroadcastReceiver
设置了优先级,优先级比较高的BroadcastReceiver
就可以先收到广播。 这里将MyBroadcastReceiver
的优先级设成了100
,以保证它一定会在AnotherBroadcastReceiver
之前收到广播。
既然已经获得了接收广播的优先权,那么MyBroadcastReceiver
就可以选择是否允许广播继续传递了。修改MyBroadcastReceiver
中的代码,如下所示:
class MyBroadcastReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
Toast.makeText(context, "received in MyBroadcastReceiver", Toast.LENGTH_SHORT).show()
abortBroadcast()
}
}
bort [əˈbɔːrt] 中止
如果在onReceive()
方法中调用了abortBroadcast()
方法,就表示将这条广播截断,后面的BroadcastReceiver
将无法再接收到这条广播。
现在重新运行程序,并点击按钮,你会发现只有MyBroadcastReceiver
中的Toast
信息能够弹出,说明这条广播经过MyBroadcastReceiver
之后确实终止传递了。
5 广播发送和接收的原理
Android
中的广播使用了观察者模式:基于消息的发布/订阅事件模型,将广播的发送者和接收者解耦,使得系统方便集成,更易扩展。
消息的事件模型中有三个角色:
- 消息订阅者(广播接收者)
- 消息发布者(广播发送者)
- 消息中心(
AMS
,即ActivityManagerService
)
具体实现流程如下:
- 广播接收者
BroadcastReceiver
通过Binder
机制向AMS
中进行注册; - 广播发送者通过
binder
机制向AMS
发送广播; AMS
查找符合相应条件(IntentFilter/Permission
等)的BroadcastReceiver
,将广播发送到BroadcastReceiver
(一般情况下是Activity
)相应的消息循环队列中;- 消息循环(
Handler
)执行拿到此广播,回调BroadcastReceiver
中的onReceive()
方法;
注意:广播发送者和广播接受者的执行顺序是异步的,发送者不会关心有无接收者及接收者是否接收。
6 广播实践:实现强制下线功能
比如如果我们的QQ
号在别处登录了,就会将你强制挤下线。其实实现强制下线功能的思路比较简单,只需要在界面上弹出一个对话框,让用户无法进行任何其他操作,必须点击对话框中的“确定”按钮,然后回到登录界面即可。可是这样就会存在一个问题:当用户被通知需要强制下线时,可能正处于任何一个界面,要在每个界面上都编写一个弹出对话框的逻辑。但是,我们完全可以借助广播,非常轻松地实现这一功能。
强制下线功能需要先关闭所有的Activity
,然后回到登录界面。先创建一个ActivityCollector
类用于管理所有的Activity
,代码如下所示:
object ActivityController {
private val activities = ArrayList<Activity>()
fun addActivity(activity: Activity) {
activities.add(activity)
}
fun removeActivity(activity: Activity) {
activities.remove(activity)
}
fun finishAll() {
for (activity in activities) {
if (!activity.isFinishing) {
activity.finish()
}
}
activities.clear()
}
}
然后创建BaseActivity
类作为所有Activity
的父类,代码如下所示:
open class BaseActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
ActivityController.addActivity(this)
}
override fun onDestroy() {
super.onDestroy()
ActivityController.removeActivity(this)
}
}
接着需要创建一个LoginActivity
来作为登录界面,然后编辑布局文件activity_login.xml
,代码如下所示:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="60dp"
android:orientation="horizontal">
<TextView
android:layout_width="90dp"
android:layout_height="wrap_content"
android:layout_gravity="center_vertical"
android:text="Account:"
android:textSize="18sp" />
<EditText
android:id="@+id/account_edit"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_gravity="center_vertical"
android:layout_weight="1" />
</LinearLayout>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="60dp"
android:orientation="horizontal">
<TextView
android:layout_width="90dp"
android:layout_height="wrap_content"
android:layout_gravity="center_vertical"
android:text="Password:"
android:textSize="18sp" />
<EditText
android:id="@+id/password_edit"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_gravity="center_vertical"
android:layout_weight="1"
android:inputType="textPassword" />
</LinearLayout>
<Button
android:layout_width="200dp"
android:layout_height="60dp"
android:layout_gravity="center_horizontal"
android:text="Login" />
</LinearLayout>
接下来修改LoginActivity
中的代码,如下所示:
class LoginActivity : BaseActivity() {
private val login: Button = findViewById(R.id.login)
private val accountEdit: EditText = findViewById(R.id.account_edit)
private val passwordEdit: EditText = findViewById(R.id.password_edit)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
login.setOnClickListener {
val account = accountEdit.text.toString()
val password = passwordEdit.text.toString()
if (account == "admin" && password == "123456") {
val intent = Intent(this, MainActivity::class.java)
startActivity(intent)
finish()
} else {
Toast.makeText(this, "account or password is invalid", Toast.LENGTH_LONG).show()
}
}
}
}
首先将LoginActivity
的继承结构改成继承自BaseActivity
,然后在登录按钮的点击事件里对输入的账号和密码进行判断:如果账号是 admin
并且密码是123456
,就认为登录成功并跳转到MainActivity
,否则就提示用户账号或密码错误。
因此,可以将MainActivity
理解成是登录成功后进入的程序主界面,这里我们并不需要在界面提供什么功能,只需要加入强制下线功能就可以了。修改activity_main.xm
l中的代 码,如下所示:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity">
<Button
android:id="@+id/forceOffline"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="send force offline broadcast" />
</LinearLayout>
然后修改MainActivity
中的代码,如下所示:
class MainActivity : BaseActivity() {
private val forceOffline: Button = findViewById(R.id.forceOffline)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
forceOffline.setOnClickListener {
val intent = Intent("com.example.broadcasttest.FORCE_OFFLINE")
sendBroadcast(intent)
}
}
}
在按钮的点击事件里发送了一条广播,广播的值为 com.example.broadcasttest.FORCE_OFFLINE
,这条广播就是用于通知程序强制用户下线的。也就是说,强制用户下线的逻辑并不是写在MainActivity
里的,而是应该写在接收这条广播的BroadcastReceiver
里。这样强制下线的功能就不会依附于任何界面了,不管是在程序的任何地方,只要发出这样一条广播,就可以完成强制下线的操作了。
接下来我们就需要创建一个BroadcastReceiver
来接收这条强制下线广播。唯一的问题就是,应该在哪里创建呢?由于BroadcastReceiver
中需要弹出一个对话框来阻塞用户的正常操作,但如果创建的是一个静态注册的BroadcastReceiver
,是没有办法在 onReceive()
方法里弹出对话框这样的UI
控件的,而我们显然也不可能在每个Activity
中都注册一个动态的BroadcastReceiver
。
那么到底应该怎么办呢?答案其实很明显,只需要在BaseActivity
中动态注册一个BroadcastReceiver
就可以了,因为所有的Activity
都继承自BaseActivity
:
open class BaseActivity : AppCompatActivity() {
lateinit var receiver: ForceOfflineReceiver
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
ActivityController.addActivity(this)
}
override fun onResume() {
super.onResume()
val intentFilter = IntentFilter()
intentFilter.addAction("com.example.broadcasttest.FORCE_OFFLINE")
receiver = ForceOfflineReceiver()
registerReceiver(receiver, intentFilter)
}
override fun onPause() {
super.onPause()
unregisterReceiver(receiver)
}
override fun onDestroy() {
super.onDestroy()
ActivityController.removeActivity(this)
}
inner class ForceOfflineReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
AlertDialog.Builder(context).apply {
setTitle("Warning")
setMessage("You are forced to be offline. Please try to login again.")
setCancelable(false)
setPositiveButton("OK") { _, _ ->
ActivityController.finishAll() // 销毁所有的Activity
val i = Intent(context, LoginActivity::class.java)
context.startActivity(i) // 重新启动LoginActivity
}
show()
}
}
}
}
在ForceOfflineReceiver
的onReceive()
方法使用AlertDialog.Builder
构建一个对话框。注意,这里一定要调用setCancelable()
方法将对话框设为不可取消,否 则用户按一下Back
键就可以关闭对话框继续使用程序了。然后使用setPositiveButton()
方法给对话框注册确定按钮,当用户点击了“OK”按钮时,就调用ActivityCollector
的finishAll()
方法销毁所有Activity
,并重新启动LoginActivity
。
接下来是注册ForceOfflineReceiver
这个BroadcastReceiver
。这里重写了onResume()
和onPause()
这两个生命周期方法,然后分别在这两个方法里注册和取消注册了ForceOfflineReceiver
。
为什么不是在onCreate()
和onDestroy()
方法里注册和取消注册BroadcastReceiver
的吗?这是因为始终需要保证只有处于栈顶的Activity
才能接收到这条强制下线广播,非栈顶的Activity
不应该也没必要接收这条广播,所以写在onResume()
和onPause()
方法里就可以很好地解决这个问题,当一个Activity
失去栈顶位置时就会自动取消BroadcastReceiver
的注册。
参考
https://zhuanlan.zhihu.com/p/78271629
http://gityuan.com/2017/04/23/local_broadcast_manager/