Android中的广播Broadcast详解

拼搏现实的明天。 2022-08-01 02:52 262阅读 0赞

今天来看一下Android中的广播机制，我们知道广播Broadcast是Android中的四大组件之一，可见他的重要性了，当然它的用途也很大的，比如一些系统的广播：电量低、开机、锁屏等一些操作都会发送一个广播，具体的Android系统中的广播可以参见我的另外一篇博客: [http://blog.csdn.net/jiangwei0910410003/article/details/17218985][http_blog.csdn.net_jiangwei0910410003_article_details_17218985] .

下面就来详细讲解一下广播机制：

广播被分为两种不同的类型：“普通广播（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，然后传给下一个接收者。

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **class** IncomingSMSReceiver extendsBroadcastReceiver \{  
2.    @Override **public** **void** onReceive(Contextcontext, Intentintent) \{  
3.    \}  
4.  \}

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  IntentFilter filter = newIntentFilter("android.provider.Telephony.SMS\_RECEIVED");  
2.  IncomingSMSReceiver receiver = newIncomingSMSReceiver();  
3.  registerReceiver(receiver, filter);

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

**\[html\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

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

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

**下面看一下例子：**

看一下项目结构：

![Center][]

看一下静态订阅广播:

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

在AndroidMainfest.xml中订阅:

**\[html\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **<?****xml** version="1.0" encoding="utf-8"**?>**  
2.  **<****manifest** xmlns:android="http://schemas.android.com/apk/res/android"  
3.      package="com.example.androidbroadcastdemo"  
4.      android:versionCode="1"  
5.      android:versionName="1.0" **>**  
6.    
7.      **<****uses-sdk**  
8.          android:minSdkVersion="8"  
9.          android:targetSdkVersion="18" **/>**  
10.       
11.       
12.     **<****uses-permission** android:name="android.permission.RECEIVE\_SMS"**/>**  
13.     **<****uses-permission** android:name="android.permission.INTERNET"**/>**  
14.     **<****uses-permission** android:name="android.permission.SEND\_SMS"**/>**  
15.     **<****uses-permission** android:name="android.permission.READ\_PHONE\_STATE" **/>**  
16.   
17.     **<****application**  
18.         android:allowBackup="true"  
19.         android:icon="@drawable/ic\_launcher"  
20.         android:label="@string/app\_name"  
21.         android:theme="@style/AppTheme" **>**  
22.         **<****activity**  
23.             android:name="com.broadcast.demo.StaticRegisterBroadcastActivity"  
24.             android:label="@string/app\_name" **>**  
25.             **<****intent-filter****>**  
26.                 **<****action** android:name="android.intent.action.MAIN" **/>**  
27.                 **<****category** android:name="android.intent.category.LAUNCHER" **/>**  
28.             **</****intent-filter****>**  
29.         **</****activity****>**  
30.           
31.           
32.         **<****receiver** android:name="com.broadcast.receiver.UnSortBroadcastReceiver"**>**  
33.             **<****intent-filter** **>**  
34.                 **<****action** android:name="com.broadcast.demo.mybroadcast"**/>**  
35.             **</****intent-filter****>**  
36.         **</****receiver****>**  
37.           
38.           
39.           
40.         **<****receiver** android:name="com.broadcast.receiver.SortBroadcastReceiverA"**>**  
41.             **<****intent-filter** android:priority="999"**>**  
42.                 **<****action** android:name="com.broadcast.set.broadcast"**/>**  
43.             **</****intent-filter****>**  
44.         **</****receiver****>**  
45.           
46.           
47.         **<****receiver** android:name="com.broadcast.receiver.SortBroadcastReceiverB"**>**  
48.             **<****intent-filter** android:priority="1000"**>**  
49.                 **<****action** android:name="android.provider.Telephony.SMS\_RECEIVED"**/>**  
50.             **</****intent-filter****>**  
51.         **</****receiver****>**  
52.           
53.           
54.           
55.         **<****service** android:name="com.broadcast.service.UploadSMSService"**>**  
56.             **<****intent-filter** **>**  
57.                 **<****action** android:name="com.broadcast.service.uploadsmsservice"**/>**  
58.             **</****intent-filter****>**  
59.         **</****service****>**  
60.           
61.     **</****application****>**  
62.   
63. **</****manifest****>**

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

**\[html\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.    
2.         **<****receiver** android:name="com.broadcast.receiver.UnSortBroadcastReceiver"**>**  
3.              **<****intent-filter** **>**  
4.                  **<****action** android:name="com.broadcast.demo.mybroadcast"**/>**  
5.              **</****intent-filter****>**  
6.          **</****receiver****>**  
7.

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

下面来看一下动态订阅：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

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

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

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

第一个广播接收者:

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

第二个广播接收者:

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

在AndroidMainfest.xml中订阅广播

**\[html\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.   **<****receiver** android:name="com.broadcast.receiver.SortBroadcastReceiverA"**>**  
2.              **<****intent-filter** android:priority="999"**>**  
3.                  **<****action** android:name="com.broadcast.set.broadcast"**/>**  
4.              **</****intent-filter****>**  
5.  **</****receiver****>**  
6.            
7.  **<****receiver** android:name="com.broadcast.receiver.SortBroadcastReceiverB"**>**  
8.              **<****intent-filter** android:priority="1000"**>**  
9.                  **<****action** android:name="com.broadcast.set.broadcast"**/>**  
10.             **</****intent-filter****>**  
11. **</****receiver****>**

运行结果:

![Center 1][]

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

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

运行结果：

![Center 2][]

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

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

abortBroadcast();

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

![Center 3][]

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

下面在修改一下代码：

接收者B：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

接收者A的代码：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

运行结果如下：

![Center 4][]

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

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

下面来做一个案例就是网上很多人弄过的：短信拦截

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

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  <uses-permission android:name="android.permission.RECEIVE\_SMS"/>  
2.  <uses-permission android:name="android.permission.INTERNET"/>

订阅短信广播:

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

![Center 5][]

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

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

**方案一:在我们定义的短信广播接收者中，我们能够从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结束了，它的宿主进程还在运行，那么子线程还会继续执行。但宿主进程此时很容易在系统需要内存时被优先杀死，因为它属于空进程（没有任何活动组件的进程）。

**\[html\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

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

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

[http_blog.csdn.net_jiangwei0910410003_article_details_17218985]: http://blog.csdn.net/jiangwei0910410003/article/details/17218985
[view plain]: http://blog.csdn.net/jiangwei0910410003/article/details/19150705#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/186218
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/186218/fork
[Center]: /images/20220731/7f9bc157a31b40a7b50868bb78c4b66f.png
[Center 1]: /images/20220731/8e93f653422a43fa8c4699b23702a406.png
[Center 2]: /images/20220731/ecd3f62d4dcd4ef58778bdf70ddbe3e3.png
[Center 3]: /images/20220731/f17efed485144aef860b053d4a1f5bd6.png
[Center 4]: /images/20220731/13898b8961174d74a54459fa6b5e4d19.png
[Center 5]: /images/20220731/80a48a4e546947d085a8d3affc7883c9.png