• 0-Broadcast机制原理简要介绍



    导语

    广播机制在Android系统中，也不算是什么创新的东西。如果读者了解J2EE或者COM，就会知道，在J2EE中，提供了消息驱动Bean（Message-Driven Bean），用来实现应用程序各个组件之间的消息传递；而在COM中，提供了连接点（Connection Point）的概念，也是用来在应用程序各个组间间进行消息传递。无论是J2EE中的消息驱动Bean，还是COM中的连接点，或者Android系统的广播机制，它们的实现机理都是消息发布/订阅模式的事件驱动模型，消息的生产者发布事件，而使用者订阅感兴趣的事件。


    在Android系统中，广播（Broadcast）是在组件之间传播数据（Intent）的一种机制；这些组件甚至是可以位于不同的进程中，这样它就像Binder机制一样，起到进程间通信的作用；本文通过一个简单的例子来学习Android系统的广播机制，为后续分析广播机制的源代码作准备。在Android系统中，为什么需要广播机制呢？广播机制，本质上它就是一种组件间的通信方式，如果是两个组件位于不同的进程当中，那么可以用Binder机制来实现，如果两个组件是在同一个进程中，那么它们之间可以用来通信的方式就更多了，这样看来，广播机制似乎是多余的。然而，广播机制却是不可替代的，它和Binder机制不一样的地方在于，广播的发送者和接收者事先是不需要知道对方的存在的，这样带来的好处便是，系统的各个组件可以松耦合地组织在一起，这样系统就具有高度的可扩展性，容易与其它系统进行集成。

            

    在软件工程中，是非常强调模块之间的高内聚低耦合性的，不然的话，随着系统越来越庞大，就会面临着越来越难维护的风险，最后导致整个项目的失败。Android应用程序的组织方式，可以说是把这种高内聚低耦合性的思想贯彻得非常透彻，在任何一个Activity中，都可以使用一个简单的Intent，通过startActivity或者startService，就可以把另外一个Activity或者Service启动起来为它服务，而且它根本上不依赖这个Activity或者Service的实现，只需要知道它的字符串形式的名字即可，而广播机制更绝，它连接收者的名字都不需要知道。

            


    分析案例:

    我们通过具体的例子来介绍Android系统的广播机制。在这个例子中，有一个Service，它在另外一个线程中实现了一个计数器服务，每隔一秒钟就自动加1，然后将结果不断地反馈给应用程序中的界面线程，而界面线程中的Activity在得到这个反馈后，就会把结果显示在界面上。

    为什么要把计数器服务放在另外一个线程中进行呢？

    我们可以把这个计数器服务想象成是一个耗时的计算型逻辑，如果放在界面线程中去实现，那么势必就会导致应用程序不能响应界面事件，最后导致应用程序产生ANR（Application Not Responding）问题。计数器线程为了把加1后的数字源源不断地反馈给界面线程，这时候就可以考虑使用广播机制了。

            

    首先在Android源代码工程中创建一个Android应用程序工程，名字就称为Broadcast吧。这个应用程序工程定义了一个名为shy.luo.broadcast的package，这个例子的源代码主要就是实现在这里了。下面，将会逐一介绍这个package里面的文件。 

            

    1. 计数器的服务接口ICounterServicce ：src/shy/luo/broadcast/ICounterService.Java

    1. package shy.luo.broadcast;  
    2.   
    3. public interface ICounterService {  
    4.         public void startCounter(int initVal);  
    5.         public void stopCounter();  
    6. }   co
    这个接口很简单，它只有两个成员函数，分别用来启动和停止计数器；启动计数时，还可以指定计数器的初始值。

    2. 接着，我们来看一个应用程序的默认Activity的实现 ：src/shy/luo/broadcast/MainActivity.java
    1. package shy.luo.broadcast;  
    2.   
    3. import android.app.Activity;  
    4. import android.content.BroadcastReceiver;  
    5. import android.content.ComponentName;  
    6. import android.content.Context;  
    7. import android.content.Intent;  
    8. import android.content.IntentFilter;  
    9. import android.content.ServiceConnection;  
    10. import android.os.Bundle;  
    11. import android.os.IBinder;  
    12. import android.util.Log;  
    13. import android.view.View;  
    14. import android.view.View.OnClickListener;  
    15. import android.widget.Button;  
    16. import android.widget.TextView;  
    17.   
    18. public class MainActivity extends Activity implements OnClickListener {  
    19.     private final static String LOG_TAG = "shy.luo.broadcast.MainActivity";  
    20.          
    21.     private Button startButton = null;  
    22.     private Button stopButton = null;  
    23.     private TextView counterText = null;  
    24.       
    25.     private ICounterService counterService = null;  
    26.       
    27.         @Override  
    28.         public void onCreate(Bundle savedInstanceState) {  
    29.             super.onCreate(savedInstanceState);  
    30.             setContentView(R.layout.main);  
    31.           
    32.             startButton = (Button)findViewById(R.id.button_start);  
    33.             stopButton = (Button)findViewById(R.id.button_stop);  
    34.             counterText = (TextView)findViewById(R.id.textview_counter);  
    35.           
    36.             startButton.setOnClickListener(this);  
    37.             stopButton.setOnClickListener(this);  
    38.           
    39.             startButton.setEnabled(true);  
    40.             stopButton.setEnabled(false);  
    41.           
    42.             Intent bindIntent = new Intent(MainActivity.this, CounterService.class);  
    43.             bindService(bindIntent, serviceConnection, Context.BIND_AUTO_CREATE);  
    44.           
    45.             Log.i(LOG_TAG, "Main Activity Created.");  
    46.         }  
    47.       
    48.         @Override   
    49.         public void onResume() {  
    50.             super.onResume();  
    51.             IntentFilter counterActionFilter = new IntentFilter(CounterService.BROADCAST_COUNTER_ACTION);  
    52.             registerReceiver(counterActionReceiver, counterActionFilter);  
    53.         }  
    54.       
    55.         @Override  
    56.         public void onPause() {  
    57.             super.onPause();  
    58.             unregisterReceiver(counterActionReceiver);  
    59.         }  
    60.       
    61.         @Override  
    62.         public void onDestroy() {  
    63.             super.onDestroy();  
    64.             unbindService(serviceConnection);  
    65.         }  
    66.       
    67.         @Override  
    68.         public void onClick(View v) {  
    69.             if(v.equals(startButton)) {  
    70.             if(counterService != null) {  
    71.                 counterService.startCounter(0);  
    72.                   
    73.                 startButton.setEnabled(false);  
    74.                 stopButton.setEnabled(true);  
    75.               }  
    76.             } else if(v.equals(stopButton)) {  
    77.             if(counterService != null) {  
    78.                 counterService.stopCounter();  
    79.                   
    80.                 startButton.setEnabled(true);  
    81.                 stopButton.setEnabled(false);  
    82.             }  
    83.             }  
    84.         }  
    85.       
    86.         private BroadcastReceiver counterActionReceiver = new BroadcastReceiver(){  
    87.         public void onReceive(Context context, Intent intent) {  
    88.             int counter = intent.getIntExtra(CounterService.COUNTER_VALUE, 0);  
    89.             String text = String.valueOf(counter);  
    90.             counterText.setText(text);  
    91.               
    92.             Log.i(LOG_TAG, "Receive counter event");  
    93.         }  
    94.     };  
    95.      
    96.     private ServiceConnection serviceConnection = new ServiceConnection() {  
    97.             public void onServiceConnected(ComponentName className, IBinder service) {  
    98.             counterService = ((CounterService.CounterBinder)service).getService();  
    99.               
    100.             Log.i(LOG_TAG, "Counter Service Connected");  
    101.             }  
    102.             public void onServiceDisconnected(ComponentName className) {  
    103.             counterService = null;  
    104.             Log.i(LOG_TAG, "Counter Service Disconnected");  
    105.             }  
    106.         };  
    107. }   cop

    1. MainActivity的实现也很简单，它在创建（onCreate）的时候，会调用bindService函数来把计数器服务（CounterService）启动起来。

    2. 它的第二个参数serviceConnection是一个ServiceConnection实例, 计数器服务启动起来后，系统会调用这个实例的onServiceConnected函数将一个Binder对象传回来.

    3. 通过调用这个Binder对象的getService函数，就可以获得计数器服务接口。这里，把这个计数器服务接口保存在MainActivity的counterService成员变量中。

    4. 当我们调用unbindService停止计数器服务时，系统会调用这个实例的onServiceDisconnected函数告诉MainActivity，它与计数器服务的连接断开了。


    注意，这里通过调用bindService函数来启动Service时，这个Service与启动它的Activity是位于同一个进程中，它不像我们在前面一篇文章Android系统在新进程中启动自定义服务过程（startService）的原理分析中所描述那样在新的进程中启动服务，后面我们再写一篇文章来分析bindService启动服务的过程。



    1. 在MainActivity的onResume函数中，通过调用registerReceiver函数注册了一个广播接收器counterActionReceiver，它是一个BroadcastReceiver实例，并且指定了这个广播接收器只对CounterService.BROADCAST_COUNTER_ACTION类型的广播感兴趣。

    2. 当CounterService发出一个CounterService.BROADCAST_COUNTER_ACTION类型的广播时，系统就会把这个广播发送到counterActionReceiver实例的onReceiver函数中去。在onReceive函数中，从参数intent中取出计数器当前的值，显示在界面上。

    MainActivity界面上有两个按钮，分别是Start Counter和Stop Counter按钮，点击前者开始计数，而点击后者则停止计数。


    计数器服务CounterService实现在src/shy/luo/broadcast/CounterService.java文件中：

    1. package shy.luo.broadcast;  
    2.   
    3. import android.app.Service;  
    4. import android.content.Intent;  
    5. import android.os.AsyncTask;  
    6. import android.os.Binder;  
    7. import android.os.IBinder;  
    8. import android.util.Log;  
    9.   
    10. public class CounterService extends Service implements ICounterService {  
    11.     private final static String LOG_TAG = "shy.luo.broadcast.CounterService";  
    12.       
    13.     public final static String BROADCAST_COUNTER_ACTION = "shy.luo.broadcast.COUNTER_ACTION";  
    14.     public final static String COUNTER_VALUE = "shy.luo.broadcast.counter.value";  
    15.       
    16.     private boolean stop = false;  
    17.       
    18.     private final IBinder binder = new CounterBinder();  
    19.       
    20.     public class CounterBinder extends Binder {  
    21.         public CounterService getService() {  
    22.             return CounterService.this;  
    23.         }  
    24.     }  
    25.       
    26.     @Override  
    27.         public IBinder onBind(Intent intent) {  
    28.                 return binder;  
    29.         }  
    30.       
    31.     @Override  
    32.     public void onCreate() {  
    33.         super.onCreate();  
    34.           
    35.         Log.i(LOG_TAG, "Counter Service Created.");  
    36.     }  
    37.       
    38.     @Override  
    39.         public void onDestroy() {  
    40.                 Log.i(LOG_TAG, "Counter Service Destroyed.");  
    41.         }  
    42.       
    43.     public void startCounter(int initVal) {  
    44.             
    45.        AsyncTask<Integer, Integer, Integer> task = new AsyncTask<Integer, Integer, Integer>() {      
    46.             @Override  
    47.             protected Integer doInBackground(Integer... vals) {  
    48.                 Integer initCounter = vals[0];  
    49.                   
    50.                 stop = false;  
    51.                 while(!stop) {  
    52.                     publishProgress(initCounter);  
    53.                       
    54.                     try {  
    55.                         Thread.sleep(1000);  
    56.                     } catch (InterruptedException e) {  
    57.                         e.printStackTrace();  
    58.                     }  
    59.                       
    60.                     initCounter++;  
    61.                 }  
    62.                   
    63.                 return initCounter;  
    64.             }  
    65.               
    66.             @Override   
    67.             protected void onProgressUpdate(Integer... values) {  
    68.                 super.onProgressUpdate(values);  
    69.                   
    70.                 int counter = values[0];  
    71.                   
    72.                 Intent intent = new Intent(BROADCAST_COUNTER_ACTION);  
    73.                 intent.putExtra(COUNTER_VALUE, counter);  
    74.                   
    75.                 sendBroadcast(intent);  
    76.             }  
    77.               
    78.             @Override  
    79.             protected void onPostExecute(Integer val) {  
    80.                 int counter = val;  
    81.                   
    82.                 Intent intent = new Intent(BROADCAST_COUNTER_ACTION);  
    83.                 intent.putExtra(COUNTER_VALUE, counter);  
    84.                   
    85.                 sendBroadcast(intent);  
    86.             }  
    87.           
    88.                 
    89.        };  
    90.               
    91.        task.execute(0);      
    92.    }  
    93.   
    94.    public void stopCounter() {  
    95.         stop = true;  
    96.     }  
    97. }
    这个计数器服务实现了ICounterService接口。当这个服务被binderService函数启动时，系统会调用它的onBind函数，这个函数返回一个Binder对象给系统。上面我们说到，当MainActivity调用bindService函数来启动计数器服务器时，系统会调用MainActivity的ServiceConnection实例serviceConnection的onServiceConnected函数通知MainActivity，这个服务已经连接上了，并且会通过这个函数传进来一个Binder远程对象，这个Binder远程对象就是来源于这里的onBind的返回值了。

            

    函数onBind返回的Binder对象是一个自定义的CounterBinder实例，它实现了一个getService成员函数。当系统通知MainActivity，计数器服务已经启动起来并且连接成功后，并且将这个Binder对象传给MainActivity时，MainActivity就会把这个Binder对象强制转换为CounterBinder实例，然后调用它的getService函数获得服务接口。这样，MainActivity就通过这个Binder对象和CounterService关联起来了。

            

    当MainActivity调用计数器服务接口的startCounter函数时，计数器服务并不是直接进入计数状态，而是通过使用异步任务（AsyncTask）在后台线程中进行计数。这里为什么要使用异步任务来在后台线程中进行计数呢？前面我们说过，这个计数过程是一个耗时的计算型逻辑，不能把它放在界面线程中进行，因为这里的CounterService启动时，并没有在新的进程中启动，它与MainActivity一样，运行在应用程序的界面线程中，因此，这里需要使用异步任务在在后台线程中进行计数。

            

    异步任务AsyncTask的具体用法可以参考官方文档http://developer.android.com/reference/android/os/AsyncTask.html。它的大概用法是:

    1. 当我们调用异步任务实例的execute（task.execute）方法时，当前调用线程就返回了，系统启动一个后台线程来执行这个异步任务实例的doInBackground函数

    2. 这个函数就是我们用来执行耗时计算的地方了，它会进入到一个循环中，每隔1秒钟就把计数器加1，然后进入休眠（Thread.sleep），醒过来，再重新这个计算过程。

    2. 在计算的过程中，可以通过调用publishProgress函数来通知调用者当前计算的进度，好让调用者来更新界面，调用publishProgress函数的效果最终就是直入到这个异步任务实例的onProgressUpdate函数中，这里就可以把这个进度值以广播的形式（sendBroadcast）发送出去了，这里的进度值就定义为当前计数服务的计数值。

            

    当MainActivity调用计数器服务接口的stopCounter函数时，会告诉函数doInBackground停止执行计数（stop = true），于是，函数doInBackground就退出计数循环，然后将最终计数结果返回了，返回的结果最后进入到onPostExecute函数中，这个函数同样通过广播的形式（sendBroadcast）把这个计数结果广播出去。

    计算器服务就介绍到这里了，下面我们看看应用程序的配置文件AndroidManifest.xml：

    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
    3.       package="shy.luo.broadcast"  
    4.       android:versionCode="1"  
    5.       android:versionName="1.0">  
    6.     <application android:icon="@drawable/icon" android:label="@string/app_name">  
    7.         <activity android:name=".MainActivity"  
    8.                   android:label="@string/app_name">  
    9.             <intent-filter>  
    10.                 <action android:name="android.intent.action.MAIN" />  
    11.                 <category android:name="android.intent.category.LAUNCHER" />  
    12.             </intent-filter>  
    13.         </activity>  
    14.     <service android:name=".CounterService"  
    15.          android:enabled="true">  
    16.     </service>  
    17.     </application>  
    18. </manifest>
    这个配置文件很简单，只是告诉系统，它有一个Activity和一个Service。




    案例:

    这样，使用广播的例子就介绍完了。回顾一下，使用广播的两个步骤：

            

    1. 广播的接收者需要通过调用registerReceiver函数告诉系统，它对什么样的广播有兴趣，即指定IntentFilter，并且向系统注册广播接收器，即指定BroadcastReceiver：

    1. IntentFilter counterActionFilter = new IntentFilter(CounterService.BROADCAST_COUNTER_ACTION);  
    2. registerReceiver(counterActionReceiver, counterActionFilter);
    这里，指定感兴趣的广播就是CounterService.BROADCAST_COUNTER_ACTION了，而指定的广播接收器就是counterActonReceiver，它是一个c类型的实例。

    这里注册就是IntentFilter 和 BroadcastReceiver 注册到AMS 中

        

        

    2. 广播的发送者通过调用sendBroadcast函数来发送一个指定的广播，并且可以指定广播的相关参数：

    1. Intent intent = new Intent(BROADCAST_COUNTER_ACTION);  
    2. intent.putExtra(COUNTER_VALUE, counter);  
    3. sendBroadcast(intent)
    这里，指定的广播为CounterService.BROADCAST_COUNTER_ACTION，并且附带的带参数当前的计数器值counter。调用了sendBroadcast函数之后，所有注册了CounterService.BROADCAST_COUNTER_ACTION广播的接收者便可以收到这个广播了。   






    1. 在第1步中，广播的接收者把广播接收器注册到AMS中；

    2. 在第2步中，广播的发送者同样是把广播发送到AMS中，由AMS去查找注册了这个广播的接收者，然后把广播分发给它们。

    3. 在第2步的分发的过程，其实就是把这个广播转换成一个消息，然后放入到接收器所在的线程消息队列中去，最后就可以在消息循环中调用接收器的onReceive函数了。

    4. 由于ActivityManagerService把这个广播放进接收器所在的线程消息队列后，就返回了，它不关心这个消息什么时候会被处理，因此，对广播的处理是异步的，即调用sendBroadcast时，这个函数不会等待这个广播被处理完后才返回。

            

    下面，我们以一个序列图来总结一下，广播的注册和发送的过程：


    虚线上面Step 1到Step 4步是注册广播接收器的过程，

    其中Step 2通过LoadedApk.getReceiverDispatcher在LoadedApk内部创建了一个IIntentReceiver接口，并且传递给ActivityManagerService；


    虚线下面的Step 5到Step 11是发送广播的过程，

    在Step 8中，ActivityManagerService利用上面得到的IIntentReceiver远程接口，调用LoadedApk.performReceiver接口，LoadedApk.performReceiver接口通过ActivityThread.H接口的post函数将这个广播消息放入到ActivityThread的消息队列中去

    最后这个消息在LoadedApk的Args.run函数中处理，LoadedApk.Args.run函数接着调用MainActivity.BroadcastReceiver的onReceive函数来最终处理这个广播。
  • 相关阅读:
    C# 控件，MenuStrip，statusStrip,contextMenuStrip,ImageList, Listview,MonthCalendar、DataGridView,combobox,textbox，DateTimePicker,treeview,picturebox、toolStrip,radioButton,TableLayoutPanel,numericUpDown
    c# 数据库操作,多数据库操作、数据库操作异常报错等问题
    Jquery 选择器的写法， selector
    C# 一、语法结构、注释、命名空间、Main入口点、变量与常量、运算符、流程控制（循环）
    c# 项目文件，C#viual studio使用方法
    finereport Web工具栏
    C# 学习笔记
    c# public private protected internal protected internal
    js Object.prototype.hasOwnProperty() 与 for in 区别
    js 对象的深克隆
  • 原文地址：https://www.cnblogs.com/jiaoxiake/p/7042975.html
Copyright © 2020-2023  润新知