Android 系统广播机制

最新推荐文章于 2024-08-26 11:38:09 发布
最新推荐文章于 2024-08-26 11:38:09 发布
阅读量2.5k 收藏
点赞数
分类专栏： Android源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jltxgcy/article/details/37032517
版权

一、Android应用程序注册广播接收器（registerReceiver）的过程分析

       参考Android应用程序注册广播接收器（registerReceiver）的过程分析http://blog.csdn.net/luoshengyang/article/details/6737352和《Android系统源代码情景分析》，作者罗升阳。

        0、总图：



        1、MainActivity和CounterService所在应用程序主线程向ActivityManagerService进程发送REGISTER_RECEIVER_TRANSACTION


 

       如图：第一步

       ~/Android/frameworks/base/core/java/android/app

       ----ActivityManagerNative.java

class ActivityManagerProxy implements IActivityManager
{
	......

	public Intent registerReceiver(IApplicationThread caller,
			IIntentReceiver receiver,
			IntentFilter filter, String perm) throws RemoteException
	{
		Parcel data = Parcel.obtain();
		Parcel reply = Parcel.obtain();
		data.writeInterfaceToken(IActivityManager.descriptor);
		data.writeStrongBinder(caller != null ? caller.asBinder() : null);
		data.writeStrongBinder(receiver != null ? receiver.asBinder() : null);
		filter.writeToParcel(data, 0);
		data.writeString(perm);
		mRemote.transact(REGISTER_RECEIVER_TRANSACTION, data, reply, 0);
		reply.readException();
		Intent intent = null;
		int haveIntent = reply.readInt();
		if (haveIntent != 0) {
			intent = Intent.CREATOR.createFromParcel(reply);
		}
		reply.recycle();
		data.recycle();
		return intent;
	}

	......

}
          其中receiver为InnerReceiver对象，如下图。还要filter，主要关注这两个参数。


       如图：第二步，省略binder_transaction传输过程，因为上面已经分析过了。


       如图：第三步

       ~/Android/frameworks/base/core/java/android/app

       ----ActivityManagerNative.java

public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
    ......
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
        case REGISTER_RECEIVER_TRANSACTION:
        {
            data.enforceInterface(IActivityManager.descriptor);
            IBinder b = data.readStrongBinder();
            IApplicationThread app =
                b != null ? ApplicationThreadNative.asInterface(b) : null;
            b = data.readStrongBinder();
            IIntentReceiver rec
                = b != null ? IIntentReceiver.Stub.asInterface(b) : null;
            IntentFilter filter = IntentFilter.CREATOR.createFromParcel(data);
            String perm = data.readString();
            Intent intent = registerReceiver(app, rec, filter, perm);
            reply.writeNoException();
            if (intent != null) {
                reply.writeInt(1);
                intent.writeToParcel(reply, 0);
            } else {
                reply.writeInt(0);
            }
            return true;
        }
    .......
}
        rec为 IIntentReceiver.Stub.Proxy对象，如上图所示。还要filter，主要关注这两个参数。

       如图：第四步 

       ~/Android/frameworks/base/services/java/com/android/server/am

       ----ActivityManagerService.java

public final class ActivityManagerService extends ActivityManagerNative
		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
	......

	public Intent registerReceiver(IApplicationThread caller,
			IIntentReceiver receiver, IntentFilter filter, String permission) {
		synchronized(this) {
			ProcessRecord callerApp = null;
			if (caller != null) {
				callerApp = getRecordForAppLocked(caller);
				if (callerApp == null) {
					......
				}
			}

			.......
			ReceiverList rl
				= (ReceiverList)mRegisteredReceivers.get(receiver.asBinder());
			if (rl == null) {
				rl = new ReceiverList(this, callerApp,
					Binder.getCallingPid(),
					Binder.getCallingUid(), receiver);

				if (rl.app != null) {
					rl.app.receivers.add(rl);
				} else {
					......
				}
				mRegisteredReceivers.put(receiver.asBinder(), rl);
			}

			BroadcastFilter bf = new BroadcastFilter(filter, rl, permission);
			rl.add(bf);
			......
			mReceiverResolver.addFilter(bf);

			// Enqueue broadcasts for all existing stickies that match
			// this filter.
			if (allSticky != null) {
				......
			}

			return sticky;
		}
	}

	......

}
  
        主要做了以下几件事：

      （1）根据receiver创建ReceiverList。

      （2）根据filter和rl创建BroadcastFilter。

      （3）mReceiver.addFilter(bf)。


二、Android应用程序发送广播（sendBroadcast）的过程分析

      0、总图



      1、MainActivity和CounterService所在应用程序主线程向ActivityManagerService进程发送BROADCAST_INTENT_TRANSACTION


      

       如图：第一步

       ~/Android/frameworks/base/core/java/android/app

       ----ActivityManagerNative.java

class ActivityManagerProxy implements IActivityManager
{
	......

	public int broadcastIntent(IApplicationThread caller,
		Intent intent, String resolvedType,  IIntentReceiver resultTo,
		int resultCode, String resultData, Bundle map,
		String requiredPermission, boolean serialized,
		boolean sticky) throws RemoteException
	{
		Parcel data = Parcel.obtain();
		Parcel reply = Parcel.obtain();
		data.writeInterfaceToken(IActivityManager.descriptor);
		data.writeStrongBinder(caller != null ? caller.asBinder() : null);
		intent.writeToParcel(data, 0);
		data.writeString(resolvedType);
		data.writeStrongBinder(resultTo != null ? resultTo.asBinder() : null);
		data.writeInt(resultCode);
		data.writeString(resultData);
		data.writeBundle(map);
		data.writeString(requiredPermission);
		data.writeInt(serialized ? 1 : 0);
		data.writeInt(sticky ? 1 : 0);
		mRemote.transact(BROADCAST_INTENT_TRANSACTION, data, reply, 0);
		reply.readException();
		int res = reply.readInt();
		reply.recycle();
		data.recycle();
		return res;
	}

	......

}
        其中主要关注intent参数。

       如图：第二步，省略binder_transaction传输过程，因为上面已经分析过了。


       如图：第三步

       ~/Android/frameworks/base/core/java/android/app

       ----ActivityManagerNative.java

public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
    ......
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
        case BROADCAST_INTENT_TRANSACTION:
        {
            data.enforceInterface(IActivityManager.descriptor);
            IBinder b = data.readStrongBinder();
            IApplicationThread app =
                b != null ? ApplicationThreadNative.asInterface(b) : null;
            Intent intent = Intent.CREATOR.createFromParcel(data);
            String resolvedType = data.readString();
            b = data.readStrongBinder();
            IIntentReceiver resultTo =
                b != null ? IIntentReceiver.Stub.asInterface(b) : null;
            int resultCode = data.readInt();
            String resultData = data.readString();
            Bundle resultExtras = data.readBundle();
            String perm = data.readString();
            boolean serialized = data.readInt() != 0;
            boolean sticky = data.readInt() != 0;
            int res = broadcastIntent(app, intent, resolvedType, resultTo,
                    resultCode, resultData, resultExtras, perm,
                    serialized, sticky);
            reply.writeNoException();
            reply.writeInt(res);
            return true;
        }
    .......
}

       如图：第四步 

       ~/Android/frameworks/base/services/java/com/android/server/am

       ----ActivityManagerService.java

public final class ActivityManagerService extends ActivityManagerNative
		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
	......

	public final int broadcastIntent(IApplicationThread caller,
			Intent intent, String resolvedType, IIntentReceiver resultTo,
			int resultCode, String resultData, Bundle map,
			String requiredPermission, boolean serialized, boolean sticky) {
		synchronized(this) {
			intent = verifyBroadcastLocked(intent);

			final ProcessRecord callerApp = getRecordForAppLocked(caller);
			final int callingPid = Binder.getCallingPid();
			final int callingUid = Binder.getCallingUid();
			final long origId = Binder.clearCallingIdentity();
			int res = broadcastIntentLocked(callerApp,
				callerApp != null ? callerApp.info.packageName : null,
				intent, resolvedType, resultTo,
				resultCode, resultData, map, requiredPermission, serialized,
				sticky, callingPid, callingUid);
			Binder.restoreCallingIdentity(origId);
			return res;
		}
	}

	......
}
          
        主要做了以下几件事：

      （1）根据intent找出相应的广播接收器：

List<BroadcastFilter> registeredReceivers = null; 
registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false);
      （2）根据intent(里面还包含数据)，registeredReceivers创建BroadcastRecord对象，并加入mParallelBroadcasts中： 

BroadcastRecord r = new BroadcastRecord(intent, callerApp,
		callerPackage, callingPid, callingUid, requiredPermission,
		registeredReceivers, resultTo, resultCode, resultData, map,
		ordered, sticky, false);
mParallelBroadcasts.add(r);
      （3）根据r和从r中得到的BroadcastFilter(即上面注册时的 BroadcastFilter)，调用deliverToRegisteredReceiverLocked： 
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false);
      （4）调用filter.receiverList.receiver和new Intent(r.intent)调用performReceiveLocked： 

performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
					new Intent(r.intent), r.resultCode,
					r.resultData, r.resultExtras, r.ordered, r.initialSticky);

     （5）ActivityManagerService进程向 MainActivity和CounterService所在应用程序子线程发送SCHEDULE_REGISTERED_RECEIVER_TRANSACTION 

app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
					data, extras, ordered, sticky);

       其中receiver为IIntentReceiver.Stub.Proxy对象。intent为要传递的数据。    

 

        2、ActivityManagerService进程向MainActivity和CounterService所在应用程序子线程发送SCHEDULE_REGISTERED_RECEIVER_TRANSACTION



         如图：第一步

         ~/Android/frameworks/base/core/java/android/app

         ----ApplicationThreadNative.java，ApplicationThreadProxy类

class ApplicationThreadProxy implements IApplicationThread {
	......

	public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
			int resultCode, String dataStr, Bundle extras, boolean ordered, boolean sticky)
			throws RemoteException {
		Parcel data = Parcel.obtain();
		data.writeInterfaceToken(IApplicationThread.descriptor);
		data.writeStrongBinder(receiver.asBinder());
		intent.writeToParcel(data, 0);
		data.writeInt(resultCode);
		data.writeString(dataStr);
		data.writeBundle(extras);
		data.writeInt(ordered ? 1 : 0);
		data.writeInt(sticky ? 1 : 0);
		mRemote.transact(SCHEDULE_REGISTERED_RECEIVER_TRANSACTION, data, null,
			IBinder.FLAG_ONEWAY);
		data.recycle();
	}

	......
}
       其中receiver为 IIntentReceiver.Stub.Proxy对象，intent为要传递的数据。

        如图：第二步，省略binder_transaction传输过程，因为上面已经分析过了。


       如图：第三步

       ~/Android/frameworks/base/core/java/android/app

       ----ApplicationThreadNative.java

public abstract class ApplicationThreadNative extends Binder
        implements IApplicationThread {
    ........
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        switch (code) {
         case SCHEDULE_REGISTERED_RECEIVER_TRANSACTION: {
            data.enforceInterface(IApplicationThread.descriptor);
            IIntentReceiver receiver = IIntentReceiver.Stub.asInterface(
                    data.readStrongBinder());
            Intent intent = Intent.CREATOR.createFromParcel(data);
            int resultCode = data.readInt();
            String dataStr = data.readString();
            Bundle extras = data.readBundle();
            boolean ordered = data.readInt() != 0;
            boolean sticky = data.readInt() != 0;
            scheduleRegisteredReceiver(receiver, intent,
                    resultCode, dataStr, extras, ordered, sticky);
            return true;
        }
   .......
}

        其中receiver为InnerReceiver。intent为要传递的数据。

        大家已经对，IIntentReceiver.Stub.asInterface( data.readStrongBinder())很费解，data.readStrongBinder得到是InnerReceiver对象，那为什么要生成IIntentReceiver.Stub.Proxy的代理对象呢？其实不然，绕了一圈，最后还是生成了InnerReceiver对象。

public static android.content.IIntentReceiver asInterface(
				android.os.IBinder obj) {
			if ((obj == null)) {
				return null;
			}
			android.os.IInterface iin = (android.os.IInterface) obj
					.queryLocalInterface(DESCRIPTOR);//如果是BinderProxy对象调用这个方法，返回的NULL，但是现在是InnerReceiver，具体调用如下，返回的是IInterface
			if (((iin != null) && (iin instanceof android.content.IIntentReceiver))) {
				return ((android.content.IIntentReceiver) iin);
			}
			return new android.content.IIntentReceiver.Stub.Proxy(obj);
		}

 public IInterface queryLocalInterface(String descriptor) {
        if (mDescriptor.equals(descriptor)) {
            return mOwner;
        }
        return null;
    }
        现在是InnerReceiver，具体调用如下，返回的是IInterface，这个是在IIntentReceiver.Stub初始化时设置的。 

public interface IIntentReceiver extends android.os.IInterface {
	/** Local-side IPC implementation stub class. */
	public static abstract class Stub extends android.os.Binder implements
			android.content.IIntentReceiver {
		private static final java.lang.String DESCRIPTOR = "android.content.IIntentReceiver";

		/** Construct the stub at attach it to the interface. */
		public Stub() {
			this.attachInterface(this, DESCRIPTOR);
		}

        如图：第四步

        ~/Android/frameworks/base/core/java/android/app

        ----ActivityThread.java

public final class ActivityThread {
	......

	private final class ApplicationThread extends ApplicationThreadNative {
		......

		// 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);
		}

		......
	}

	......

}
       经过一系列折腾，最后在MainActivity和CounterService所在应用程序主线程执行： 

 receiver.onReceive(mContext, intent);
       执行onRecevice函数：   
public class MainActivity extends Activity implements OnClickListener {    
	......  

	private BroadcastReceiver counterActionReceiver = new BroadcastReceiver(){  
		public void onReceive(Context context, Intent intent) {  
			int counter = intent.getIntExtra(CounterService.COUNTER_VALUE, 0);  
			String text = String.valueOf(counter);  
			counterText.setText(text);  

			Log.i(LOG_TAG, "Receive counter event");  
		}    
	}

	......  

}

jltxgcy
关注
专栏目录
Android之旅---广播（BroadCast）
weixin_34355715的博客
03-06 139
什么是广播          在Android中，Broadcast是一种广泛运用的在应用程序之间传输信息的机制。我们拿广播电台来做个比方。我们平常使用收音机收音是这样的：许许多多不同的广播电台通过特定的频率来发送他们的内容，而我们用户只需要将频率调成和广播电台的一样就可以收听他们的内容了。Android中的广播机制就和这个差不多的道理。 电台发送的内容是语音，而在Android中...
Android native层发送广播
读书未遍、未敢妄下雌黄
11-06 2621
github代码地址
Android接收系统广播
最新发布
m0_63526467的博客
08-26 1303
Android接收系统广播
Android的Native方式广播intent
u011494885的博客
12-24 1137
原文：https://blog.csdn.net/alien75/article/details/50789168  版权声明：本文为博主原创文章，转载请附上博文链接！   本文是在“在Android中使用native程序（非Java）来广播intent”这篇博文的基础上的完整实现，实现了在Native下广播一个即将关机的通知。 #define LOG_TAG "IntentTest"  ...
(八)React Native实现调用android原生java方法并实现广播的发送和接受
qq1377399077的专栏
04-15 4248
接触到混合应用开发提议后，首先想到了之前学的ionic，其次便是这两年火遍全球的RN，由于ionic框架用的angular.js，而且angular1和angular2写法区别很大，angular2对于初学者还是比较好接受的，但是angular1写的很乱，代码很难维护，便放弃了。决定用RN后觉得还是蛮顺手的，跟angular2很相似，又是ES6，很快便能入手
Android Native发布广播Intent步骤和原理解析
moumde的博客
05-08 1123
最近出于工作需要，要在Native层发送广播，参考了网上的一些博客如下其中内容基本大同小异，但是由于Android版本的迭代，目前其中的代码具体来说已经不太适用，笔者这边调试了很久终于通了，本文主要用来记录一下整个调试过程，并且会尽可能说明原理以便读者自己实现。
基于Android系统广播机制下的网络状态变化提醒APP的实现.pdf
09-21
本文研究了如何利用Android系统广播机制开发一款能够监测并及时提醒用户网络状态变化的APP。 一、Android系统广播机制概述 Android系统作为全球应用最广泛的手机操作系统，其开放性特点允许用户对手机进行私人定制...
Android BroadcastReceiver广播机制概述
09-01
Android的BroadcastReceiver广播机制是Android系统中的一种重要组件，它允许应用程序在系统内接收和响应全局性的事件。BroadcastReceiver作为广播接收者，主要用于监听并处理系统或者应用发送的广播消息。这种机制...
Android开发之广播机制浅析
01-05
Android中的广播机制基本如下图所示： 那广播在Android程序中到底是如何运行的呢？下面将以代码的形式给大家好好分析一下： 一、发送广播 Intent是Activity中发送广播的桥梁，通过他我们可以轻松的将广播发送到系统...
Android广播机制安全性研究
01-19
近年来，Android组件的安全性是研究热点，但...在研究Android广播机制的基础上，对其安全结构与特点进行了深入分析。基于Android广播机制的安全挑战，针对性地给出相应的安全对策。最后，总结并展望今后的研究方向。
Android 广播机制
03-28
广播机制是Android系统事件分发的核心，能够处理系统级别的通知（如设备开机、网络状态变化）以及应用程序自定义的事件。本文将深入探讨Android广播的工作原理、类型、注册方式以及如何创建和接收广播。 首先，...
【安卓framework实战】实现一个安卓native服务
qq_23542165的博客
06-21 1128
本文介绍了如何实现一个安卓native服务。 需求： 在native framework层实现一个服务接受云控配置，并执行云控命令。 已有条件：系统接受到云控配置会发送特定action的广播并将信息包含在intent中，我们只需要接受此广播并完成我们的逻辑即可。 一、预先分析 在开始写代码之前，做一些功能点大致的分析如下： 1：在java framework需要一个广播接收器，接受传来的广播，此广播接收器需要在开机时就注册。根据安卓开机流程，我选择在system_server启动AMS后，注册此Rece.
在Android中使用native程序（非Java）来广播intent
缘来如此 ...
02-07 5281
首先在看之前必须确定你已经部分了解广播intent的原理（从Java层到native层）。如果一窍不通的话，请先百度看完。 进入正题，广播intent从Java层最终会调用binder机制来触发native层的发送，即发送消息BROADCAST_INTENT_TRANSACTION，而这个消息是通过IActivityManager接口处理的，所以我们在程序中必须先获得这个接口，即如下：
第二行代码学习笔记——第五章:全局大喇叭——详解广播机制
JiangWeiHu的博客
05-03 1478
本章要点为了便于系统级别的消息通知，Android也引入了一套类似的广播消息机制。5.1 广播机制简介Android中的广播机制更加灵活，因为Android中的每个应用程序都可以对自己感兴趣的广播进行注册，广播来自于系统或应用程序。Android提供了一套完整的API，允许程序自由的接收和发送广播，接收广播的方法——广播接收器（Broadcast Receiver）。Android广播的两种类型：
Android 四大组件之广播
bobolan
07-09 5876
在Android中， 什么是广播？、系统广播、自定义广播、本地广播、广播的注册
Android广播分类
qq_41878758的博客
05-18 2010
2. 有序广播（Ordered Broadcast）：这种广播是一种同步的广播，保证所有接收者都会按照一定的顺序接收到广播。这种广播适合需要保证所有接收者均接收到广播的情况。3. 粘性广播（Sticky Broadcast）：这种广播是一种可以被持久化的广播，即发送者可以将广播发送给尚未注册的接收者，当这些接收者注册时，它们可以立即接收到最近一次的广播。5. 系统广播（System Broadcast）：这种广播是由系统发送的广播，用于通知应用程序系统事件的发生，如屏幕开关、电量变化、网络状态变化等。
android IntentReceiver$Stub$Proxy的说明
l309681481的博客
06-22 316
是Android系统用于实现跨进程BroadcastReceiver调用的代理类，它基于Binder机制工作，确保了广播可以在不同应用进程之间安全、高效地传递和处理。
Android广播机制详解
热门推荐
houliang120的专栏
06-07 1万+
1 广播类型 从广播的注册方式来分，分为以下2种： （1）静态广播：通过的形式在AndroidManifest.xml中注册的广播； （2）动态广播：通过context. registerReceiver在程序中显示注册的广播； 上面静态广播和动态广播比较明显的2个区别:    1）静态广播在进程没有运行的时候，也可以收到，这时候会先启动进程，然后处理广播onReceive函数（静态广播
Android 广播(Broadcast)
m0_61130325的博客
08-04 6365
Broadcast是android中的四大组件之一(其他的组件分别是:)，是在组件之间传播数据（Intent）的一种机制。广播的发送者和接收者事先是不需要知道对方的存在的。这样带来的好处便是，系统的各个组件可以松耦合地组织在一起，这样系统就具有高度的可扩展性，容易与其它系统进行集成。1.广播接收者的生命周期是非常短暂的，在接收到广播的时候创建，onReceive()方法结束之后销毁2.广播接收者中不要做一些耗时的工作，否则会弹出Application No Response错误对话框。...........
Android系统广播事件详解
"这是关于Android系统广播的全面梳理，包含了各种重要的广播事件和相关动作，旨在帮助开发者更好地理解和利用Android系统的广播机制。" 在Android开发中，广播（Broadcast）是一种非常关键的组件，它允许应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值