品茗论道说广播(Broadcast内部机制讲解)(下)

Android四大组件系列8 Broadcast广播机制(下) 一 概述 广播 (Broadcast) 机制用于进程/线程间通信,广播分为广播发送和广播接收两个过程,其中广播接收者 BroadcastReceiver 上篇文章已经介绍过了,本篇文章介绍广播的发送,从广播发送方式可分为三类: 普通广播:通过 Context.sendBroadcast() 发送,并行处理 有序广播:通过 Context.sendOrderedBroadcast() 发送,串行处理 Sticky 广播:通过 Context.sendStickyBroadcast() 发送 广播在系统中以 B 阅读详情

品茗论道说广播(Broadcast内部机制讲解)(下)

 

侯 亮



       下面我们来看,递送广播动作中最重要的processNextBroadcast()。

 

3.2 最重要的processNextBroadcast()

        从processNextBroadcast()的代码,我们就可以看清楚前面说的“平行广播”、“有序广播”和“动态receiver”、“静态receiver”之间的关系了。

        我们在前文已经说过,所有的静态receiver都是串行处理的,而动态receiver则会按照发广播时指定的方式,进行“并行”或“串行”处理。能够并行处理的广播,其对应的若干receiver一定都已经存在了,不会牵扯到启动新进程的操作,所以可以在一个while循环中,一次性全部deliver。而有序广播,则需要一个一个地处理,其滚动处理的手段是发送事件,也就是说,在一个receiver处理完毕后,会利用广播队列(BroadcastQueue)的mHandler,发送一个BROADCAST_INTENT_MSG事件,从而执行下一次的processNextBroadcast()。

        processNextBroadcast()的代码逻辑大体是这样的:先尝试处理BroadcastQueue中的“平行广播”部分。这需要遍历并行列表(mParallelBroadcasts)的每一个BroadcastRecord以及其中的receivers列表。对于平行广播而言,receivers列表中的每个子节点是个BroadcastFilter。我们直接将广播递送出去即可:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
while  (mParallelBroadcasts.size() >  0 ) 
{
     r = mParallelBroadcasts.remove( 0 );
     r.dispatchTime = SystemClock.uptimeMillis();
     r.dispatchClockTime = System.currentTimeMillis();
     final  int  N = r.receivers.size();
     . . . . . . 
     for  ( int  i= 0 ; i<N; i++) 
     {
         Object target = r.receivers.get(i);
         . . . . . .
         deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target,  false );
     }
     . . . . . .
}

 

3.2.1 用deliverToRegisteredReceiverLocked()递送到平行动态receiver

        deliverToRegisteredReceiverLocked()的代码截选如下:

【frameworks/base/services/java/com/android/server/am/BroadcastQueue.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
private  final  void  deliverToRegisteredReceiverLocked(BroadcastRecord r,
                                                      BroadcastFilter filter, 
                                                      boolean  ordered) 
{
     . . . . . .
     . . . . . .
     if  (!skip) 
     {
         if  (ordered) 
         {
             r.receiver = filter.receiverList.receiver.asBinder();
             r.curFilter = filter;
             filter.receiverList.curBroadcast = r;
             r.state = BroadcastRecord.CALL_IN_RECEIVE;
             if  (filter.receiverList.app !=  null ) 
             {
                 r.curApp = filter.receiverList.app;
                 filter.receiverList.app.curReceiver = r;
                 mService.updateOomAdjLocked();
             }
         }
         
             . . . . . .
             performReceiveLocked(filter.receiverList.app, 
                                  filter.receiverList.receiver,
                                  new  Intent(r.intent), r.resultCode,
                                  r.resultData, r.resultExtras, 
                                  r.ordered, r.initialSticky);
             if  (ordered) 
             {
                 r.state = BroadcastRecord.CALL_DONE_RECEIVE;
             }
         
         . . . . . .
}

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private  static  void  performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
         Intent intent,  int  resultCode, String data, Bundle extras,
         boolean  ordered,  boolean  sticky)  throws  RemoteException 
{
     // Send the intent to the receiver asynchronously using one-way binder calls.
     if  (app !=  null  && app.thread !=  null ) 
     {
         // If we have an app thread, do the call through that so it is
         // correctly ordered with other one-way calls.
         app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
                 data, extras, ordered, sticky);
     } 
     else 
     {
         receiver.performReceive(intent, resultCode, data, extras, ordered, sticky);
     }
}

终于通过app.thread向用户进程传递语义了。注意scheduleRegisteredReceiver()的receiver参数,它对应的就是前文所说的ReceiverDispatcher的Binder实体——InnerReceiver了。

        总之,当语义传递到用户进程的ApplicationThread以后,走到:

?
1
2
3
4
5
6
7
8
9
// This function exists to make sure all receiver dispatching is
// correctly ordered, since these are one-way calls and the binder driver
// applies transaction ordering per object for such calls.
public  void  scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
         int  resultCode, String dataStr, Bundle extras,  boolean  ordered,
         boolean  sticky)  throws  RemoteException 
{
     receiver.performReceive(intent, resultCode, dataStr, extras, ordered, sticky);
}

终于走到ReceiverDispatcher的InnerReceiver了:

?
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
static  final  class  ReceiverDispatcher 
{
     final  static  class  InnerReceiver  extends  IIntentReceiver.Stub 
     {
         . . . . . .
         . . . . . .
         public  void  performReceive(Intent intent,  int  resultCode,
                                    String data, Bundle extras, 
                                    boolean  ordered,  boolean  sticky) 
         {
             LoadedApk.ReceiverDispatcher rd = mDispatcher.get();
             . . . . . .
             if  (rd !=  null ) {
                 rd.performReceive(intent, resultCode, data, extras,
                                   ordered, sticky);
             } 
             . . . . . .
         }
     }
     . . . . . .
     public  void  performReceive(Intent intent,  int  resultCode,
                                String data, Bundle extras, 
                                boolean  ordered,  boolean  sticky) 
     {
         . . . . . .
         Args args =  new  Args(intent, resultCode, data, extras, ordered, sticky);
         if  (!mActivityThread.post(args))  // 请注意这一句!
         {
             if  (mRegistered && ordered) 
             {
                 IActivityManager mgr = ActivityManagerNative.getDefault();
                 if  (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
                         "Finishing sync broadcast to "  + mReceiver);
                 args.sendFinished(mgr);
             }
         }
     }
}

请注意mActivityThread.post(args)一句,这样,事件泵最终会回调Args参数的run()成员函数:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
final  class  Args  extends  BroadcastReceiver.PendingResult  implements  Runnable 
{
     . . . . . .
     . . . . . .
     public  void  run() 
     {
         final  BroadcastReceiver receiver = mReceiver;
         . . . . . .
         try  {
             ClassLoader cl =  mReceiver.getClass().getClassLoader();
             intent.setExtrasClassLoader(cl);
             setExtrasClassLoader(cl);
             receiver.setPendingResult( this );
             receiver.onReceive(mContext, intent);   // 回调具体receiver的onReceive()
         }  catch  (Exception e) {
             . . . . . .
         }
         
         if  (receiver.getPendingResult() !=  null ) {
             finish();
         }
         . . . . . .
     }
}

其中的那句receiver.onReceive(this),正是回调我们具体receiver的onReceive()成员函数的地方。噢,终于看到应用程序员熟悉的onReceive()了。这部分的示意图如下:


3.2.2 静态receiver的递送

        说完动态递送,我们再来看静态递送。对于静态receiver,情况会复杂很多,因为静态receiver所从属的进程有可能还没有运行起来呢。此时BroadcastRecord节点中记录的子列表的节点是ResolveInfo对象。

?
1
2
3
4
ResolveInfo info = (ResolveInfo)nextReceiver;
. . . . . .
r.state = BroadcastRecord.APP_RECEIVE;
String targetProcess = info.activityInfo.processName;

那么我们要先找到receiver所从属的进程的进程名。

         processNextBroadcast()中启动进程的代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
ProcessRecord app = mService.getProcessRecordLocked(targetProcess, 
info.activityInfo.applicationInfo.uid);
. . . . . .
if  (app !=  null  && app.thread !=  null ) 
{
     . . . . . .
     app.addPackage(info.activityInfo.packageName);
     processCurBroadcastLocked(r, app);
     return ;
     . . . . . .
}
r.curApp = mService.startProcessLocked(targetProcess,
                                info.activityInfo.applicationInfo,  true ,
                                r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND,
                                "broadcast" , r.curComponent,              
                                (r.intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) !=  0 , 
                                false )
. . . . . .
mPendingBroadcast = r;
mPendingBroadcastRecvIndex = recIdx;

        如果目标进程已经存在了,那么app.thread肯定不为null,直接调用processCurBroadcastLocked()即可,否则就需要启动新进程了。启动的过程是异步的,可能很耗时,所以要把BroadcastRecord节点记入mPendingBroadcast。

3.2.2.1 processCurBroadcastLocked()

        我们先说processCurBroadcastLocked()。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private  final  void  processCurBroadcastLocked(BroadcastRecord r,
                         ProcessRecord app)  throws  RemoteException 
{
     . . . . . .
     r.receiver = app.thread.asBinder();
     r.curApp = app;
     app.curReceiver = r;
     . . . . . .
     . . . . . .
         app.thread.scheduleReceiver( new  Intent(r.intent), r.curReceiver,
               mService.compatibilityInfoForPackageLocked(r.curReceiver.applicationInfo),
               r.resultCode, r.resultData, r.resultExtras, r.ordered);
         . . . . . .
         started =  true ;
     . . . . . .
}

其中最重要的是调用app.thread.scheduleReceiver()的那句。在IApplicationThread接口中,是这样定义scheduleReceiver()函数原型的:

?
1
2
3
4
5
void  scheduleReceiver(Intent intent, ActivityInfo info, 
                       CompatibilityInfo compatInfo,                      
                       int  resultCode, String data, 
                       Bundle extras,  boolean  sync) 
                       throws  RemoteException;

其中ActivityInfo info参数,记录着目标receiver的信息。可以看到,递送静态receiver时,是不会用到RecevierDispatcher的。

        用户进程里handleMessage()

?
1
2
3
4
5
6
case  RECEIVER:
     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,  "broadcastReceiveComp" );
     handleReceiver((ReceiverData)msg.obj);
     maybeSnapshot();
     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);    
     break ;

        ActivityThread中,会运用反射机制,创建出BroadcastReceiver对象,而后回调该对象的onReceive()成员函数。

?
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
private  void  handleReceiver(ReceiverData data) 
{
     . . . . . .
     IActivityManager mgr = ActivityManagerNative.getDefault();
     BroadcastReceiver receiver;
     try  {
         java.lang.ClassLoader cl = packageInfo.getClassLoader();
         data.intent.setExtrasClassLoader(cl);
         data.setExtrasClassLoader(cl);
         receiver = (BroadcastReceiver)cl.loadClass(component).newInstance();
     }  catch  (Exception e) {
         . . . . . .
     }
     try  {
         . . . . . .
         receiver.setPendingResult(data);
         receiver.onReceive(context.getReceiverRestrictedContext(), data.intent);
     }  catch  (Exception e) {
         . . . . . .
     }  finally  {
         sCurrentBroadcastIntent.set( null );
     }
     if  (receiver.getPendingResult() !=  null ) {
         data.finish();
     }
}
3.2.2.2 必要时启动新进程

        现在我们回过头来看,在目标进程尚未启动的情况下,是如何完成递送的。刚刚我们已经看到调用startProcessLocked()的句子了,只要不出问题,目标进程成功启动后就会调用AMS的attachApplication()。

        有关attachApplication()的详情,请参考其他关于AMS的文档,此处我们只需知道它里面又会调用attachApplicationLocked()函数。

?
1
private  final  boolean  attachApplicationLocked(IApplicationThread thread,  int  pid)

attachApplicationLocked()内有这么几句:

?
1
2
3
4
5
6
7
8
9
// Check if a next-broadcast receiver is in this process...
if  (!badApp && isPendingBroadcastProcessLocked(pid)) {
     try  {
         didSomething = sendPendingBroadcastsLocked(app);
     }  catch  (Exception e) {
         // If the app died trying to launch the receiver we declare it 'bad'
         badApp =  true ;
     }
}

它们的意思是,如果新启动的进程就是刚刚mPendingBroadcast所记录的进程的话,此时AMS就会执行sendPendingBroadcastsLocked(app)一句。

 

?
1
2
3
4
5
6
7
8
// The app just attached; send any pending broadcasts that it should receive
boolean  sendPendingBroadcastsLocked(ProcessRecord app) {
     boolean  didSomething =  false ;
     for  (BroadcastQueue queue : mBroadcastQueues) {
         didSomething |= queue.sendPendingBroadcastsLocked(app);
     }
     return  didSomething;
}

BroadcastQueue的sendPendingBroadcastsLocked()函数如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public  boolean  sendPendingBroadcastsLocked(ProcessRecord app) {
     boolean  didSomething =  false ;
     final  BroadcastRecord br = mPendingBroadcast;
     if  (br !=  null  && br.curApp.pid == app.pid) {
         try  {
             mPendingBroadcast =  null ;
             processCurBroadcastLocked(br, app);
             didSomething =  true ;
         }  catch  (Exception e) {
             . . . . . .
         }
     }
     return  didSomething;
}

可以看到,既然目标进程已经成功启动了,那么mPendingBroadcast就可以赋值为null了。接着,sendPendingBroadcastsLocked()会调用前文刚刚阐述的processCurBroadcastLocked(),其内再通过app.thread.scheduleReceiver(),将语义发送到用户进程,完成真正的广播递送。这部分在上一小节已有阐述,这里就不多说了。

 

3.2.3 说说有序广播是如何循环起来的?

        我们知道,平行广播的循环很简单,只是在一个while循环里对每个动态receiver执行deliverToRegisteredReceiverLocked()即可。而对有序广播来说,原则上每次processNextBroadcast()只会处理一个BroadcastRecord的一个receiver而已。当然,此时摘下的receiver既有可能是动态注册的,也有可能是静态的。

        对于动态注册的receiver,目标进程处理完广播之后,会间接调用am.finishReceiver()向AMS发出反馈,关于这一步,其实在前面罗列ReceiverDispatcher的performReceive()时已经出现过了,我们再列一下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public  void  performReceive(Intent intent,  int  resultCode,
                            String data, Bundle extras, 
                            boolean  ordered,  boolean  sticky) 
{
     . . . . . .
     Args args =  new  Args(intent, resultCode, data, extras, ordered, sticky);
     if  (!mActivityThread.post(args)) 
     {
         if  (mRegistered && ordered) 
         {
             IActivityManager mgr = ActivityManagerNative.getDefault();
             . . . . . .
             args.sendFinished(mgr);   // 请注意这一句!
         }
     }
}

Args继承于BroadcastReceiver.PendingResult,它调用的sendFinished()就是PendingResult的sendFinished():

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public  void  sendFinished(IActivityManager am) 
{
     synchronized  ( this ) {
         if  (mFinished) {
             throw  new  IllegalStateException( "Broadcast already finished" );
         }
         mFinished =  true ;
     
         try  {
             if  (mResultExtras !=  null ) {
                 mResultExtras.setAllowFds( false );
             }
             if  (mOrderedHint) {
                 am.finishReceiver(mToken, mResultCode, mResultData, mResultExtras,
                         mAbortBroadcast);
             }  else  {
                 // This broadcast was sent to a component; it is not ordered,
                 // but we still need to tell the activity manager we are done.
                 am.finishReceiver(mToken,  0 ,  null ,  null ,  false );
             }
         }  catch  (RemoteException ex) {
         }
     }
}

代码中的am.finishReceiver()会通知AMS,表示用户侧receiver已经处理好了,或者至少告一段落了,请AMS进行下一步动作。

        而对于动态注册的receiver,情况是类似的,最终也是调用am.finishReceiver()向AMS发出回馈的,只不过发起的动作是在ActivityThread的handleReceiver()动作中。前文已经列过这个函数了,大家注意下面的句子即可:

?
1
2
3
4
5
6
7
8
9
10
11
private  void  handleReceiver(ReceiverData data) 
{
         . . . . . .
         receiver.setPendingResult(data);
         receiver.onReceive(context.getReceiverRestrictedContext(),
                 data.intent);
         . . . . . .
     if  (receiver.getPendingResult() !=  null ) {
         data.finish();
     }
}

ReceiverData也是继承于BroadcastReceiver.PendingResult的,它调用的finish()是PendingResult的finish():

?
1
2
3
4
5
6
7
8
9
10
11
public  final  void  finish() 
{
     if  (mType == TYPE_COMPONENT) {
         . . . . . .
     }  else  if  (mOrderedHint && mType != TYPE_UNREGISTERED) {
         if  (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
                 "Finishing broadcast to "  + mToken);
         final  IActivityManager mgr = ActivityManagerNative.getDefault();
         sendFinished(mgr);
     }
}

此处的sendFinished()内部最终也会调用到am.finishReceiver(),向AMS通告receiver已经处理好了。

         AMS侧在收到finishReceiver语义后,执行:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public  void  finishReceiver(IBinder who,  int  resultCode, String resultData,
         Bundle resultExtras,  boolean  resultAbort) 
{
     . . . . . .
     try  {
         boolean  doNext =  false ;
         BroadcastRecord r =  null ;
         synchronized ( this ) {
             r = broadcastRecordForReceiverLocked(who);
             if  (r !=  null ) {
                 doNext = r.queue.finishReceiverLocked(r, resultCode,
                     resultData, resultExtras, resultAbort,  true );
             }
         }
         if  (doNext) {
             r.queue.processNextBroadcast( false );
         }
         trimApplications();
     }  finally  {
         Binder.restoreCallingIdentity(origId);
     }
}

可以看到,如有必要,会继续调用processNextBroadcast(),从而完成有序广播的循环处理。

 

3.2.4 说说有序广播的timeout处理

        因为AMS很难知道一次广播究竟能不能完全成功递送出去,所以它必须实现一种“时限机制”。前文在阐述broadcastIntentLocked()时,提到过new一个BroadcastRecord节点,并插入一个BroadcastQueue里的“平行列表”或者“有序列表”。不过当时我们没有太细说那个BroadcastQueue,现在我们多加一点儿说明。

        实际上系统中有两个BroadcastQueue,一个叫做“前台广播队列”,另一个叫“后台广播队列”,在AMS里是这样定义的:

?
1
2
BroadcastQueue mFgBroadcastQueue;
BroadcastQueue mBgBroadcastQueue;

为什么要搞出两个队列呢?我认为这是因为系统对“广播时限”的要求不同导致的。对于前台广播队列而言,它里面的每个广播必须在10秒之内把广播递送给receiver,而后台广播队列的时限比较宽,只需60秒之内递送到就可以了。具体时限值请看BroadcastQueue的mTimeoutPeriod域。注意,这个10秒或60秒限制是针对一个receiver而言的。比方说“前台广播队列”的某个BroadcastRecord节点对应了3个receiver,那么在处理这个广播节点时,只要能在30秒(3 x 10)之内搞定就可以了。事实上,AMS系统考虑了更多东西,所以它给一个BroadcastRecord的总时限是其所有receiver时限之和的2倍,在此例中就是60秒(2 x 3 x 10)。

        对于平行receiver而言,时限的作用小一点儿,因为动态receiver是直接递送到目标进程的,它不考虑目标端是什么时候处理完这个广播的。

        然而对于有序receiver来说,时限就比较重要了。因为receiver之间必须是串行处理的,也就是说上一个receiver在没处理完时,系统是不会让下一个receiver进行处理的。从processNextBroadcast()的代码来看,在处理有序receiver时,BroadcastRecord里的nextReceiver域会记录“下一个应该处理的receiver”的标号。只有在BroadcastRecord的所有receiver都处理完后,或者BroadcastRecord的处理时间超过了总时限的情况下,系统才会把这个BroadcastRecord节点从队列里删除。因此我们在processNextBroadcast()里看到的获取当前BroadcastRecord的句子是写死为r = mOrderedBroadcasts.get(0)的。


        在拿到当前BroadcastRecord之后,利用nextReceiver值拿到当前该处理的receiver信息:

?
1
2
3
int  recIdx = r.nextReceiver++;
. . . . . .
Object nextReceiver = r.receivers.get(recIdx);

当然,一开始,nextReceiver的值只会是0,表示第一个receiver有待处理,此时会给BroadcastRecord的dispatchTime域赋值。

?
1
2
3
4
5
6
int  recIdx = r.nextReceiver++;
r.receiverTime = SystemClock.uptimeMillis(); if  (recIdx ==  0 ) {
     r.dispatchTime = r.receiverTime;
     r.dispatchClockTime = System.currentTimeMillis();
     . . . . . .
}

也就是说,dispatchTime的意义是标记实际处理BroadcastRecord的起始时间,那么这个BroadcastRecord所能允许的最大时限值就是:

dispatchTime + 2 * mTimeoutPeriod * 其receiver总数

一旦超过这个时限,而BroadcastRecord又没有处理完,那么就强制结束这个BroadcastRecord节点:

?
1
2
3
4
5
6
7
8
if  ((numReceivers >  0 ) &&
         (now > r.dispatchTime + ( 2 *mTimeoutPeriod*numReceivers))) 
{
     . . . . . .
     broadcastTimeoutLocked( false );  // forcibly finish this broadcast
     forceReceive =  true ;
     r.state = BroadcastRecord.IDLE;
}

此处调用的broadcastTimeoutLocked()的参数是boolean fromMsg,表示这个函数是否是在处理“时限消息”的地方调用的,因为当前是在processNextBroadcast()函数里调用broadcastTimeoutLocked()的,所以这个参数为false。从这个参数也可以看出,另一处判断“处理已经超时”的地方是在消息处理机制里,在那个地方,fromMsg参数应该设为true。

        大体上说,每当processNextBroadcast()准备递送receiver时,会调用setBroadcastTimeoutLocked()设置一个延迟消息:

?
1
2
3
long  timeoutTime = r.receiverTime + mTimeoutPeriod;
. . . . . .
setBroadcastTimeoutLocked(timeoutTime);

setBroadcastTimeoutLocked()的代码如下:

?
1
2
3
4
5
6
7
8
final  void  setBroadcastTimeoutLocked( long  timeoutTime) 
{     if  (! mPendingBroadcastTimeoutMessage) 
     {
         Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG,  this );
         mHandler.sendMessageAtTime(msg, timeoutTime);
         mPendingBroadcastTimeoutMessage =  true ;
     }
}

只要我们的receiver能及时处理广播,系统就会cancel上面的延迟消息。这也就是说,但凡事件泵的handleMessage()开始处理这个消息,就说明receiver处理超时了。此时,系统会放弃处理这个receiver,并接着尝试处理下一个receiver。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
final  Handler mHandler =  new  Handler() 
{
     public  void  handleMessage(Message msg) {
         switch  (msg.what) 
         {
             . . . . . .
             case  BROADCAST_TIMEOUT_MSG: 
             {
                 synchronized  (mService) 
                 {
                     broadcastTimeoutLocked( true );
                 }
             }  break ;
         }
     }
};

broadcastTimeoutLocked()的代码截选如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
final  void  broadcastTimeoutLocked( boolean  fromMsg) 
{
     if  (fromMsg) {
         mPendingBroadcastTimeoutMessage =  false ;
     }
     if  (mOrderedBroadcasts.size() ==  0 ) {
         return ;
     }
     long  now = SystemClock.uptimeMillis();
     BroadcastRecord r = mOrderedBroadcasts.get( 0 );
     . . . . . .
     . . . . . .
     finishReceiverLocked(r, r.resultCode, r.resultData,
             r.resultExtras, r.resultAbort,  true );
     scheduleBroadcastsLocked();
     . . . . . .
}

可以看到,当一个receiver超时后,系统会放弃继续处理它,并再次调用scheduleBroadcastsLocked(),尝试处理下一个receiver。

 

4 尾声

        有关Android的广播机制,我们就先说这么多吧。品一杯红茶,说一段代码,管他云山雾罩,任那琐碎冗长,我自冷眼看安卓,瞧他修短随化。

BroadcastReceiver详细分析之串行广播的调度和超时机制 上一篇文章我们主要梳理了广播的动态注册,发送,接收,主要的数据结构以及需要大家严重注意的几点内容,相信大家已经熟悉了。没看过的朋友传送门:BroadcastReceiver详细分析之主要流程 相信聪明的朋友已经发现,上篇基本没怎么介绍串行广播和静态注册器,基本介绍的是普通广播的动态注册器的流程。因此,本篇单独讲解串行广播以及静态注册器的相关调度以及超时机制,毕竟这块知识点还是很多的,值得单开一篇... 阅读详情

相关推荐

STM32N6570-DK ISP调试

将下载线接入STLINK V3EC接口,将BOOT1拨码拨至右边,即将其置为H,上电或已经上电的按复位,打开STM32CubeProgrammer,设置start address:0x70000000。板子消耗电流较大,即使缩短数据线接了USB供电依然不能正常点亮显示屏,最终通过板上CN2端子加了外部5V供电,仍然需要560mA的外部电流。3.烧录bin文件:STM32N6_ISP_IQTune_App_revC01-v1.1.0-trusted.bin。

liu的博客 1067

Android 深入理解 ANR 触发原理:Broadcast

三、BroadcastReceiver Timeout 3.1 processNextBroadcastLocked 在学习Broadcast timeout 之前最好对广播的发生流程有一定了解,可以参考gityuan大神《Android Broadcast广播机制分析》。在广播流程有基础后,我们之间看最关键的代码块processNextBroadcastLocked,在看后面的代码之前我们同样提两个问题:1.broadcast 什么情况下会ANR ? 2.ANR会有哪些log。 final vo

肖岩 4115

别再为数据发愁了!盘点5个公开可用的医学图像数据集(含MRI/CT/PET合成任务)

本文详细介绍了5个高质量的公开医学图像数据集,涵盖MRI、CT和PET三大模态,适用于深度学习模型训练和医学图像合成任务。每个数据集均提供下载指南、预处理技巧和PyTorch加载示例,帮助研究人员快速获取和处理数据,解决医学AI开发中的数据瓶颈问题。

weixin_30689307的博客 528

Android广播的注册和发送原理(基于Android S)

Android广播机制采用类似于“发布-订阅”者的设计模式,基于Binder机制,实现了一对多的通信。 从整体的角度看,广播的使用主要设计两个“动作” ,“注册广播”和“发送广播”,以及三个“角色”,发送方,接收方和中间人。为什么需要中间人,因为有了中间人的存在,就可以减少发送方和接收方的工作而不用去关心具体的实现细节。三者关系可参考下图: AMS就是上面提到的中介,也是最重要的角色。Receiver向AMS注册自己感兴趣的广播,AMS则必须将所有必要的信息记录下来,比如Receiver的.

Tank_Mao的博客 2875

在 Ansys CFX Pre 中配置 RGP 表的分步指南

掌握在 Ansys CFX Pre 中设置 RGP 表的技巧,以优化仿真精度和效率。

jkh920184196的博客 1676

智能车图像处理0-图像处理整体框架思路

1.总体框架如上所示,具体代码请查看后续文章。2.因为参与竞赛时间是大二,所以在编程中有许多不规范的地方(如变量的命名),大家见谅。3.原创文章,请勿侵权=-=

taiyuezyh的博客 1万+

ActivityManagerService 分发广播(6)

上一节我们看了发送广播流程,主要是将广播信息封装至BroadcastRecord,然后通过BroadcastQueueImpl/BroadcastQueueModernImpl的enqueueBroadcastLocked来发送广播。这一节我们来看一下AMS是怎么分发广播的流程,BroadcastQueueImpl/BroadcastQueueModernImpl是两套策略,只是分发的模式不同,我们主要关心流程,策略细节就不去关注了,我们这里就挑BroadcastQueueImpl来看一下分发的流程。

起司锅仔的博客 1637

基于Simulink的双向DC-DC变换器在储能系统中的应用仿真

摘要:本文详细介绍了基于Simulink的双向DC-DC变换器在光伏储能系统中的仿真实现。主要内容包括:1)采用非隔离型双向Buck-Boost拓扑作为储能系统枢纽;2)针对750V直流微网中的20kWh锂电池接口场景进行建模;3)详细阐述双闭环控制器设计(电压外环+电流内环)、工作模式判断逻辑等关键步骤;4)通过仿真验证了系统在功率阶跃和模式切换下的性能。文章提供了完整的建模流程和控制方法,为储能系统接口设计提供了实用参考。

amy_mhd的博客 180

进程的生命周期与优先级

1, 进程生命周期 Android系统将尽量长时间地保持应用进程,但为了新建进程或运行更重要的进程,最终需要清除旧进程来回收内存。 为了确定保留或终止哪些进程,系统会根据进程中正在运行的组件以及这些组件的状态,将每个进程放入“重要性层次结构”中。 必要时,系统会首先消除重要性最低的进程,然后是清除重要性稍低一级的进程,依此类推,以回收系统资源。 Android在回收资源的时候,进程被终止的顺序

Jack的博客 1195

基于 C# 实现 RTSP 摄像头监控分屏系统:从流媒体获取到多画面显示

通过本文的讲解,我们介绍了如何在 C# 中实现 RTSP 摄像头监控分屏系统。我们使用了FFmpeg和VLC两种不同的方法来获取和解码 RTSP 流,并通过PictureBox控件和控件实现了分屏布局。两种解码方案都非常强大,可以根据实际需求选择最适合的方案。通过这种方式,您可以轻松地在 C# 中集成 RTSP 流,并将多个摄像头的视频流实时显示在同一屏幕上,进行监控和分析。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 2309

Python 爬虫实战:在房天下抓取房产信息,分析房价走势

通过本次 Python 爬虫实战,我们成功地从房天下爬取了房产信息,并进行了存储、处理、分析和可视化展示。在这个过程中,我们不仅掌握了爬虫技术的基本应用,还学会了如何对动态加载的数据进行处理和分析。然而,本次爬虫任务也存在一些局限性,例如仅爬取了部分区域的房产数据,且未对房产的图片和视频内容进行分析。在未来的工作中,我们可以进一步优化爬虫程序,爬取更多区域的房产数据,并深入分析房产的多媒体内容、用户行为模式等,为购房者和房地产从业者提供更有价值的数据支持。

u014481728的博客 1374

品茗论道说广播(Broadcast内部机制讲解)(上)

我们在编写Android程序时,常常会用到广播(Broadcast)机制。从易用性的角度来说,使用广播是非常简单的。不过,这个不是本文关心的重点,我们希望探索得再深入一点儿。我想,许多人也不想仅仅停留在使用广播的阶段,而是希望了解一些广播机制的内部机理。如果是这样的话,请容我斟一杯红茶,慢慢道来。

夜静水寒鱼不食 满船空载月明归 3414

【OpenCV】第二十三章: 图像特征检测之SURF、FAST、BRIEF、OBR算法

4、由于在检测特征点时是需要对图像中所有的像素点进行检测,然而图像中的绝大多数点都不是特征点,如果对每个像素点都进行上述的检测过程,那显然是种浪费,所以FAST采用一种进行非特征点判别的方法:首先对候选点的周围90度的点(1,9,5,13)四个点进行测试,而且是先测试1和9,如果它们两个符合阈值要求再测试5和13。继SIFT和SURF后,大家在特征点检测的速度上又进行了很多的改进尝试,但速度的提升效果都不是非常明显,直到FAST算法诞生,特征点检测的速度才有了一个质的飞跃。无法计算描述符的特征点将被删除。

因为热爱所以坚持 2160

品茗论道说广播(Broadcast内部机制讲解)

1 概述         我们在编写Android程序时,常常会用到广播(Broadcast)机制。从易用性的角度来说,使用广播是非常简单的。不过,这个不是本文关心的重点,我们希望探索得再深入一点儿。我想,许多人也不想仅仅停留在使用广播的阶段,而是希望了解一些广播机制的内部机理。如果是这样的话,请容我斟一杯红茶,慢慢道来。         简单地说,Android广播机制的主要工作是为了实现一

omnispace的博客 1070

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

(链接)品茗论道说广播(Broadcast内部机制讲解)

我们在编写Android程序时,常常会用到广播(Broadcast)机制。从易用性的角度来说,使用广播是非常简单的。不过,这个不是本文关心的重点,我们希望探索得再深入一点儿。我想,许多人也不想仅仅停留在使用广播的阶段,而是希望了解一些广播机制的内部机理。如果是这样的话,请容我斟一杯红茶,慢慢道来。 Broadcast  Receiver http://my.oschina.net/your

shineforZnine 348

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

广播(Broadcast内部机制讲解)

http://my.oschina.net/youranhongcha/blog/226274 摘要 我们在编写Android程序时,常常会用到广播(Broadcast)机制。从易用性的角度来说,使用广播是非常简单的。不过,这个不是本文关心的重点,我们希望探索得再深入一点儿。我想,许多人也不想仅仅停留在使用广播的阶段,而是希望了解一些广播机制的内部机理。如果是这样的话,请容我斟一杯红

u014255998的专栏 534

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

值得一看的Android广播分析好文

广播会发送到广播队列中不同集合。其中广播队列有三种类型,分别对应优先级从高到底:前台、后台、长广播队列类型。而广播又分三种:黏性广播、无序广播、有序广播。无序广播和有序广播的处理主要要发送广播的时候,而黏性广播则在广播接收者注册时候被处理。一个应用程序允许注册最大的广播接收者是1000个。广播之间的传递也要经历各种权限检查,所以广播不适合在应用间用于频繁的交互。如果你看到了这里,觉得文章写得不错就给个赞呗?更多Android进阶指南 可以扫码 解锁更多Android进阶资料敲代码不易,关注一下吧。

Eqiqi的博客 1125

ANR(BroadCast)

再广播到来后会执行processNextBroadcastLocked。他在没超时的时候就在循环执行这个,等待被取消或者超时往下执行。我们看下对这个message的处理。

weixin_65101089的博客 354

android framework开发之广播broadcast源码分析-千里马

hi,粉丝朋友大家好! 今天是2-8号,也是我春节第一天正式开工的日子,在这里首先祝大家新的一年技术进步,与千里马共同学习共同进步,共同升职加薪。今天要给大家分享的一个课题是大家都很熟悉的广播。 这里将要分为2个部分来对广播进行分析: 1、广播发送部分 一般我们正常使用发送广播都会有调用一个context的sendBroadcas,方法原型如下: public void sendBroadcast(Intent intent); 这里我们一般就是只想要传递一个intent参数既可以,这里调用conte

learnframework的博客 2437

ANR系列之三:broadcast类型ANR产生原理讲解

本文会讲内容如下: 1.讲解有序广播的传递流程。 2.普通有序广播的ANR机制。 3.静态广播的ANR机制。 4.一些扩展性的问题。

分享+记录 5890

Android LocalBroadcastReceiver本地广播

由于之前的广播都是全局的,所有应用程序都可以接收到,这样就很容易会引起安全性的问题,比如说我们发送一些携带关键性数据的广播有可能被其他的应用程序截获,或者其他的程序不停地向我们的广播接收器里发送各种垃圾广播。   为了能够简单地解决广播的安全性问题,Android引入了一套本地广播机制,使用这个机制发出的广播只能够在应用程序的内部进行传递,并且广播接收器也只能接收来自应用程序发出的广播,这样所有

Arman的博客 3048

Android sendBroadcast的过程分析

发送广播的过程分两步完成 第一步 AMS收到广播之后找到对应的广播接收者并把他们添加到一个广播调度队列中,这个步骤包含两个过程: 1、广播发送者把特定的广播发送给ActivityManagerService 2、AMS收到广播之后找到对应的广播接受者并把他们添加到一个广播调度队列中,在将这个队列传递给BroadcastQueue,最后向消息队列发送一个BROADCAST_INTENT_MSG

riley_zhang的博客 3184

android启动过程发送开机广播,Android app启动流程

final void processNextBroadcast(boolean fromMsg) {synchronized(mService) {BroadcastRecord r;mService.updateCpuStats();if (fromMsg) {mBroadcastsScheduled = false;}while (mParallelBroadcasts.size() >...

weixin_42545636的博客 404
上一篇: 品茗论道说广播(Broadcast内部机制讲解)(上)
下一篇: 说说Android应用的persistent属性
悠然红茶
博客等级 码龄26年 270粉丝 27原创
评论 5
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悠然红茶

原来还有打赏功能,试一下呦。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值