广播基础

发表于 更新于 分类于 Changyan：

一.广播

  • 广播的生命周期很短，经过调用对象–>实现onReceive–>结束，整个过程就结束了。从实现的复杂度和代码量来看，广播无疑是最迷你的Android 组件，实现往往只需几行代码。广播对象被构造出来后通常只执行BroadcastReceiver.onReceive方法，便结束了其生命周期。所以有的时候我们可以把它当做函数看也未必不可。

  • 和所有组件一样，广播对象也是在应用进程的主线程中被构造，所以广播对象的执行必须是要同步且快速的。也不推荐在里面开子线程，因为往往线程还未结束，广播对象就已经执行完毕被系统销毁。如果需要完成一项比较耗时的工作 , 应该通过发送 Intent 给 Service, 由 Service 来完成。

  • 每次广播到来时 , 会重新创建 BroadcastReceiver 对象 , 并且调用 onReceive() 方法 , 执行完以后 , 该对象即被销毁 . 当 onReceive() 方法在 10 秒内没有执行完毕， Android 会认为该程序无响应。

二.接收系统广播：

广播接收器可以自由地对自己感兴趣的广播进行注册，这样当有相应的广播发出时，广播接收器就能收到该广播，并在内部处理相应的逻辑。注册广播的方式有两种，在代码中注册和在清单文件中注册，前者称为动态注册，后者称为静态注册。

  1. 动态注册监听网络变化：
    新建工程文件，首先在MainActivity中定义一个内部类netWorkChangeReceiver，并重写父类的onReceive()方法，这样每当网络状态发生变化时，onReceive()方法就会得到执行，这里使用Toast提示一段文本信息，代码如下：

    1
    2
    3
    4
    5
    6
    class netWorkChangeReceiver extends BroadcastReceiver {
            @Override
            public void onReceive(Context context, Intent intent) {
                Toast.makeText(context, "network changes", Toast.LENGTH_SHORT).show();
            }        
        }

    紧接着在onCreate方法中进行动态注册，然后在onDestroy方法中进行取消注册：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
     private IntentFilter intentFilter;
     private netWorkChangeReceiver netWorkChangeReceiver;
     
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
         
         //动态注册：创建一个IntentFilter的实例，添加网络变化的广播(功能是对组件进行过滤，只获取需要的消息)
        intentFilter = new IntentFilter();
        intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
       //创建NetWorkChangeReceiver的实例，并调用registerReceiver()方法进行注册
       netWorkChangeReceiver = new netWorkChangeReceiver();
        registerReceiver(netWorkChangeReceiver, intentFilter);
        
    }
     
    //取消注册，一定要记得，不然系统会报错
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(netWorkChangeReceiver);
    }

    上方代码解释如下：
    11行：给意图过滤器intentFilter添加一个值为android.net.conn.CONNECTIVITY_CHANGE的action。因为每当网络状态发生变化时，系统就会发出一条值为android.net.conn.CONNECTIVITY_CHANG的广播。
    注：最后要记得，动态注册的广播接收器一定要取消注册才行。
    运行程序，就可以了。
    不过只是提醒网络发生变化还不够人性化，为了能够准确的告诉用户当前是有网络还是没有网络，我们还需要对上述代码进一步优化，修改netWorkChangeReceiver中的代码如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class netWorkChangeReceiver extends BroadcastReceiver {
        
        @Override
        public void onReceive(Context context, Intent intent) {
            //通过getSystemService()方法得到connectionManager这个系统服务类，专门用于管理网络连接
            ConnectivityManager connectionManager = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = connectionManager.getActiveNetworkInfo();
            if(networkInfo != null && networkInfo.isAvailable()){
                Toast.makeText(context, "network is available",Toast.LENGTH_SHORT).show();
            }else{
                Toast.makeText(context, "network is unavailable",Toast.LENGTH_SHORT).show();
            }
                
        }
    }

    上方代码解释：
    06行：在onReceive()方法中，首先通过通过getSystemService()方法得到connectionManager这个系统服务类，专门用于管理网络连接。
    07行：然后调用它的getActiveNetworkInfo()方法可以得到NetworkInfo的实例，接着调用NetworkInfo的isAvailable()方法，就可以判断当前是否有网络了，最后通过Toast提示用户。
    另外，查询系统的网络状态是需要申明权限的，打开清单文件，添加如下权限：

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

    注：访问http://developer.android.com/reference/android/Manifest.permission.html可以查看Android系统所有的可声明的权限。
    现在运行程序，就可以了。
    上方程序完整版代码如下：

    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
    package com.example.m05_broadcastreceiver01;
    import android.app.Activity;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.net.ConnectivityManager;
    import android.net.NetworkInfo;
    import android.os.Bundle;
    import android.widget.Toast;
    public class MainActivity extends Activity {
        private IntentFilter intentFilter;
        private netWorkChangeReceiver netWorkChangeReceiver;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            // 动态注册：创建一个IntentFilter的实例，添加网络变化的广播
            intentFilter = new IntentFilter();
            intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
            // 创建NetWorkChangeReceiver的实例，并调用registerReceiver()方法进行注册
            netWorkChangeReceiver = new netWorkChangeReceiver();
            registerReceiver(netWorkChangeReceiver, intentFilter);
        }
        // 取消注册，一定要记得，不然系统会报错
        @Override
        protected void onDestroy() {
            super.onDestroy();
            unregisterReceiver(netWorkChangeReceiver);
        }
        class netWorkChangeReceiver extends BroadcastReceiver {
            @Override
            public void onReceive(Context context, Intent intent) {
                //通过getSystemService()方法得到connectionManager这个系统服务类，专门用于管理网络连接
                ConnectivityManager connectionManager = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkInfo networkInfo = connectionManager.getActiveNetworkInfo();
                if(networkInfo != null && networkInfo.isAvailable()){
                    Toast.makeText(context, "network is available",Toast.LENGTH_SHORT).show();
                }else{
                    Toast.makeText(context, "network is unavailable",Toast.LENGTH_SHORT).show();
                }

            }
        }
    }

  2. 静态注册实现开机启动：
    动态注册的方式比较灵活，但缺点是：必须在程序启动之后才能接收到广播，因为注册的逻辑是写在onCreate()方法中的。为了让程序在未启动的情况下就能接收到广播，这里就需要使用到静态注册。
    这里我们准备让程序接收一条开机广播，当收到这条广播时，就可以在onReceive()方法中执行相应的逻辑，从而实现开机启动的功能。
    新建一个类：BootCompleteReceiver，让他继承BroadcastReceiver，在onReceive()方法中简单地Toast一下，代码如下：

    1
    2
    3
    4
    5
    6
    public class BootCompleteReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context, "Boot Complete", Toast.LENGTH_SHORT).show();
        }
    }

    可以看到，这里不再使用内部类的方式来定义广播接收器，因为稍后我们需要在清单文件AndroidManifest.xml中将这个广播接收器的类名注册进去。
    然后修改清单文件AndroidManifest.xml，代码如下：

    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
    <uses-sdk
            android:minSdkVersion="8"
            android:targetSdkVersion="16" />
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
        <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

        <application
            android:allowBackup="true"
            android:icon="@drawable/ic_launcher"
            android:label="@string/app_name"
            android:theme="@style/AppTheme" >
            <activity
                android:name="com.example.m05_broadcastreceiver01.MainActivity"
                android:label="@string/app_name" >
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />

                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
            
            <receiver android:name=".BootCompleteReceiver">
                <intent-filter >
                    <action android:name="android.intent.action.BOOT_COMPLETED"/>
                </intent-filter>
            </receiver>
        </application>

    代码解释如下：
    终于，标签内多了个子标签，所有的静态注册的广播接收器都是在这里进行注册的。
    22行：name中为广播接收器的名字
    24行：想要接收的广播。Android系统启动完成后，会发出这条名为android.intent.action.BOOT_COMPLETED的广播。
    05行：监听系统开机广播需要声明权限。
    运行程序后，将手机关机重启，就能收到这条广播了。

三.发送自定义广播

  1. 发送标准广播　　
    新建工程文件。在发广播之前，我们先定义一个广播接收器来接收此广播才行。因此，新建一个类：MyBroadcastReceiver，让他继承BroadcastReceiver，代码如下：

    1
    2
    3
    4
    5
    6
    public class MyBroadcastReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context, "received in MyBroadcastReceiver", Toast.LENGTH_SHORT).show();
        }
    }

    这里，当MyBroadcastReceiver 收到自定义的广播时，就会执行onReceive()方法中的逻辑，弹出一个Toast。
    紧接着，要在清单文件AndroidManifest.xml中对这个广播接收器进行注册：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.m05_broadcastreceiver02.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
     
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
       <receiver android:name=".MyBroadcastReceiver">
            <intent-filter >
                <action android:name="com.example.m05_broadcastreceiver02.MY_BROADCAST"/>
            </intent-filter>
        </receiver>
    </application>

    代码解释：
    18行：让MyBroadcastReceiver接收一条值为om.example.m05_broadcastreceiver02.MY_BROADCAST的广播，因此待会儿在发送广播的时候，我们就需要发出这样的一条广播。
    紧接着，修改activity.xml中的代码，添加一个按钮Button。
    然后，修改MainActivity.java中的代码，添加Button的监听事件：点击按钮时，发送广播

    1
    2
    3
    4
    5
    6
    7
    8
    Button button1=(Button)findViewById(R.id.button1);
    button1.setOnClickListener(new OnClickListener() {            
        @Override
        public void onClick(View v) {
            Intent intent =new Intent("com.example.m05_broadcastreceiver02.MY_BROADCAST");
            sendBroadcast(intent);
        }
    });

    总结：可以看到，点击按钮时，发送com.example.m05_broadcastreceiver02.MY_BROADCAST这条广播，这样，所有能够监听com.example.m05_broadcastreceiver02.MY_BROADCAST这条广播的广播接收器就都会同时收到消息，此时发出去的就是一条标准广播，即无序广播。所以接下来就需要讲到有序广播。

  2. 发送有序广播：
    广播是一种可以跨进程的通信方式，其他应用程序是可以收到的。现在我们来发一条有序广播。
    有序广播不仅有先后顺序，而且前面的广播还可以将后面的广播截断。
    在3.1的代码基础之上，将按钮的监听事件修改如下：

    1
    2
    3
    4
    5
    6
    7
    8
    Button button1=(Button)findViewById(R.id.button1);
    button1.setOnClickListener(new OnClickListener() {            
        @Override
        public void onClick(View v) {
            Intent intent =new Intent("com.example.m05_broadcastreceiver02.MY_BROADCAST");
            sendOrderedBroadcast(intent, null);
        }
    });

    即将06行代码修改一下，将sendBroadcast()方法改为sendOrderedBroadcast()方法，sendOrderedBroadcast()方法接收两个参数，第二个参数是一个与权限相关的字符串，这里传入null即可。
    紧接着，修改清单文件AndroidManifest.xml中对广播接收器的注册，设置优先级：

    1
    2
    3
    4
    5
    <receiver android:name=".MyBroadcastReceiver">
        <intent-filter android:priority="100">
           <action android:name="com.example.m05_broadcastreceiver02.MY_BROADCAST"/>
        </intent-filter>
    </receiver>

    即添加第02行代码。可以看到，通过android:priority属性给广播接收器设置了优先级。这个属性的范围在-1000到1000，数值越大，优先级越高。
    接下来，如果想要拦截这个广播，防止让后面的广播接收器也接收到了这个广播。可以修改MyBroadcastReceiver中的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    public class MyBroadcastReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context, "received in MyBroadcastReceiver", Toast.LENGTH_SHORT).show();
            abortBroadcast();//拦截广播，防止后面的接收到
        }
    }

    即添加第06行代码。如果在onReceive()方法中调用了abortBroadcast()方法，就表示是将这条广播拦截，后面的广播接收器将无法再接收到。
    特别关注：
    广播接收器的生命周期：关键在于BroadcastReceiver中的onReceive()方法，从onReceive()里的第一行代码开始，onReceive()里的最后一行代码结束。
    一个广播到来的时候，用什么方式提醒用户是最友好的呢？第一种方式是吐司，第二种方式是通知。注：不要使用对话框，以免中断了用户正在进行的操作。

四.使用本地广播：

之前我们发送和接收的广播全部都是属于全局广播，即发出去的广播可以被其他任何应用程序接收到，并且我们也可以接收来自于其他任何应用程序的广播。这样一来，必然会造成安全问题。于是便有了本地广播：即只能在本应用程序中发送和接收广播。这就要使用到了LocalBroadcastManager这个类来对广播进行管理。
我们修改2.1中动态注册广播接收器的代码，即修改MainActivity.java中的代码如下：

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
package com.example.broadcasttest;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.support.v4.content.LocalBroadcastManager;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity {
    private IntentFilter intentFilter;

    private LocalReceiver localReceiver;

    private LocalBroadcastManager localBroadcastManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //通过LocalBroadcastManager的getInstance()方法得到它的一个实例
        localBroadcastManager = LocalBroadcastManager.getInstance(this);
        Button button = (Button) findViewById(R.id.button);
        button.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(
                        "com.example.broadcasttest.LOCAL_BROADCAST");
                localBroadcastManager.sendBroadcast(intent);//调用sendBroadcast()方法发送广播
            }
        });
        //动态注册本地的广播接收器
        intentFilter = new IntentFilter();
        intentFilter.addAction("com.example.broadcasttest.LOCAL_BROADCAST");
        localReceiver = new LocalReceiver();
        localBroadcastManager.registerReceiver(localReceiver, intentFilter);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        localBroadcastManager.unregisterReceiver(localReceiver);
    }

    class LocalReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context, "received local broadcast",
                    Toast.LENGTH_SHORT).show();
        }
    }
}

注：本地广播是无法通过静态注册的方式来接收的。其实也完全可以理解，因为静态注册主要就是为了让程序在未启动的情况下也能收到广播。而发送本地广播时，我们的程序肯定是已经启动了，没有必要使用到静态注册的功能。

五.各种各样的广播：

在android中有很多系统自带的intent.action，通过监听这些事件我们可以完成很多功能。

  1. 开机：
    String BOOT_COMPLETED_ACTION 广播：在系统启动后。这个动作被广播一次（只有一次）。监听： android.intent.action.BOOT_COMPLETED
  2. 电话拨入：
    String ANSWER_ACTION 动作：处理拨入的电话。监听： android.intent.action.ANSWER
  3. 电量变化：
    String BATTERY_CHANGED_ACTION 广播：充电状态，或者电池的电量发生变化。监听： android.intent.action.BATTERY_CHANGED
  4. 日期改变：
    String DATE_CHANGED_ACTION 广播：日期被改变。 监听：android.intent.action.DATE_CHANGED
  5. 取消更新下载：
    String FOTA_CANCEL_ACTION 广播：取消所有被挂起的 (pending) 更新下载。 监听：android.server.checkin.FOTA_CANCEL
  6. 更新开始安装：
    String FOTA_READY_ACTION 广播：更新已经被下载 可以开始安装。监听 android.server.checkin.FOTA_READY
  7. 主屏幕：
    String HOME_CATEGORY 类别：主屏幕 (activity)。设备启动后显示的第一个 activity。 监听：”android.intent.category.HOME`
  8. 新应用：
    String PACKAGE_ADDED_ACTION 广播：设备上新安装了一个应用程序包。监听： android.intent.action.PACKAGE_ADDED
  9. 删除应用：
    String PACKAGE_REMOVED_ACTION 广播：设备上删除了一个应用程序包。监听： android.intent.action.PACKAGE_REMOVED
  10. 屏幕关闭：
    String SCREEN_OFF_ACTION 广播：屏幕被关闭。监听： android.intent.action.SCREEN_OFF
  11. 屏幕开启：
    String SCREEN_ON_ACTION 广播：屏幕已经被打开。 监听：android.intent.action.SCREEN_ON
  12. 时区改变：
    String TIMEZONE_CHANGED_ACTION 广播：时区已经改变。监听： android.intent.action.TIMEZONE_CHANGED
  13. 时间改变：
    String TIME_CHANGED_ACTION 广播：时间已经改变（重新设置）。 android.intent.action.TIME_SET
  14. 时间流逝：
    String TIME_TICK_ACTION 广播：当前时间已经变化（正常的时间流逝）。 android.intent.action.TIME_TICK
  15. 进入大容量存储模式：
    String UMS_CONNECTED_ACTION 广播：设备进入 USB 大容量存储模式。 android.intent.action.UMS_CONNECTED
  16. 退出大容量存储模式：
    String UMS_DISCONNECTED_ACTION 广播：设备从 USB 大容量存储模式退出。 android.intent.action.UMS_DISCONNECTED
  17. 壁纸改变：
    String WALLPAPER_CHANGED_ACTION 广播：系统的墙纸已经改变。 android.intent.action.WALLPAPER_CHANGED
  18. web搜索：
    String WEB_SEARCH_ACTION 动作：执行 web 搜索。 android.intent.action.WEB_SEARCH
  19. 网络变化：
    String CONNECTIVITY_CHANGE_ACTION 动作：网络变化。android.intent.action.CONNECTIVITY_CHANGE_ACTION

六.实例：使用动态注册，监听手机的电量变化。

完整版代码如下：

  • activity_main.xml代码如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
       android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".MainActivity" >

        <TextView
            android:id="@+id/textView1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:textSize="30dp"
            android:gravity="center"/>

    </LinearLayout>

  • MainActivity.java的代码如下：

    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
    package com.example.m05_broadcastreceiver02;

    import android.app.Activity;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.os.Bundle;
    import android.widget.TextView;

    public class MainActivity extends Activity {

        
        private BatteryBroadcastReceiver batteryBroadcastReceiver;
        private TextView textView;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            textView=(TextView)findViewById(R.id.textView1);
            
            //动态注册监听电量的广播接收器
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction("android.intent.action.BATTERY_CHANGED");
            batteryBroadcastReceiver = new BatteryBroadcastReceiver();
            registerReceiver(batteryBroadcastReceiver, intentFilter);       
        }
        
        //取消注册监听电量的广播接收器
        @Override
        protected void onDestroy() {
            super.onDestroy();
            unregisterReceiver(batteryBroadcastReceiver);
        }

        //新建一个广播接收器，监听电量的变化
        public class BatteryBroadcastReceiver extends BroadcastReceiver {
            @Override
            public void onReceive(Context context, Intent intent) {
                if(intent.getAction().equals(Intent.ACTION_BATTERY_CHANGED)) {
                    //获取当前电量
                    int level = intent.getIntExtra("level", 0);
                    //电量的总刻度
                    int scale = intent.getIntExtra("scale", 100);
                    textView.setText("电池电量为"+((level*100) / scale)+"%");
                    
                    //当电量低时，可以进行一些操作，例如弹出通知等
    /*                if(level<15){
                        do something
                    }*/
                }
            }         
       }    
    }

    紧接着，在清单文件中进行权限声明：

    MainActivity.java的代码解释如下： 40至45行：固定代码，用于获取当前电量 48至50行：当电量低时，可以进行一些操作，例如弹出通知等

  • 运行后，界面如下：