网站发布的步骤,济南网站制作经验,做网站中的镜像是什么,jsp网站开发环境搭建Android 中的 本地广播LocalBroadcastManager 文章目录 Android 中的 本地广播LocalBroadcastManager一、LocalBroadcastManager 的基本作用二 、LocalBroadcastManager 的基本使用1、包的导入#xff08;1#xff09;Android 源码中bp文件的导入#xff1a;#xff08;21Android 源码中bp文件的导入2Android Studio导入 2、代码调用使用1发送2接收 三、LocalBroadcastManager 源码四、LocalBroadcastManager 总结1、LocalBroadcastManager注册广播只能通过代码注册的方式。传统的广播可以通过代码和xml两种方式注册。2、LocalBroadcastManager注册广播后一定要记得取消监听。这一步可以有效的解决内存泄漏的问题。3、LocalBroadcastManager采用的是Handler的消息机制来处理的广播所以可以高效在应用内部通讯。 一、LocalBroadcastManager 的基本作用
对于LocalBroadcastManager在google官方文档中也说得很清楚比较简短也很好看懂可以去看看。
Helper to register for and send broadcasts of Intents to local objects within your process. This has a number of advantages over sending global broadcasts with sendBroadcast(Intent):You know that the data you are broadcasting won’t leave your app, so don’t need to worry about leaking private data.
It is not possible for other applications to send these broadcasts to your app, so you don’t need to worry about having security holes they can exploit.
It is more efficient than sending a global broadcast through the system.大体介绍就是这些顾名思义本地广播(注册)数据安全其他app也不能给你发广播(接收)。
也比系统广播高效。
一般使用在应用内部不同fragment和Activity的交互或者界面和service 的交互。
BroadcastReceiver设计的初衷是从全局考虑可以方便应用程序和系统、应用程序之间、应用程序内的通信所以对单个应用程序而言BroadcastReceiver是存在安全性问题的(恶意程序脚本不断的去发送你所接收的广播)。为了解决这个问题LocalBroadcastManager就应运而生了。
二 、LocalBroadcastManager 的基本使用
1、包的导入
1Android 源码中bp文件的导入 static_libs: [androidx.core_core,androidx.legacy_legacy-support-v4, // 包含LocalBroadcastManager。。。],2Android Studio导入
只要有 androidx 的包就可以第一次使用有可能有右键根据提示导入一下或者依赖里面加入
implementation androidx.legacy:legacy-support-v4:1.0.0如果是非常就的android.support 项目,自行查一下或者那直接使用本地保存的Java类吧。
其实 LocalBroadcastManager 就是一个普通的工具类后面有源码提供直接保存成java文件就可以只用如果实在无法导包可以这样操作
2、代码调用使用
1发送
LocalBroadcastManager lcmLocalBroadcastManager.getInstance(mContext);
lcm.sendBroadcast(new Intent(ACTION_LOCATION));//发送2接收
LocalBroadcastManager mLocalBroadcastManagerLocalBroadcastManager.getInstance(this);
mBoradCast new MyBroadCast(); //定义广播广播里面接收处理具体事务
IntentFilter intentFilter new IntentFilter(); //添加监听的广播ActionintentFilter.addAction(XXX);
//重点在这里本地注册本地接收。
mLocalBroadcastManager.registerReceiver(mBoradCast, intentFilter);private BroadcastReceiver mReceiver new BroadcastReceiver() {Overridepublic void onReceive(Context context, Intent intent) { //处理具体事务String action intent.getAction();Log.d(TAG, onReceive: action action);if (action.equals(XXX)) {}}};Settings 等很多源码应用就使用到了 LocalBroadcastManager 进行消息通讯。
三、LocalBroadcastManager 源码
源码 package androidx.localbroadcastmanager.content;//复制到本地使用修改成自己的包名即可。import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.Uri;
import android.os.Handler;
import android.os.Message;
import android.util.Log;import androidx.annotation.NonNull;import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;/*** Helper to register for and send broadcasts of Intents to local objects* within your process. This has a number of advantages over sending* global broadcasts with {link android.content.Context#sendBroadcast}:* ul* li You know that the data you are broadcasting wont leave your app, so* dont need to worry about leaking private data.* li It is not possible for other applications to send these broadcasts to* your app, so you dont need to worry about having security holes they can* exploit.* li It is more efficient than sending a global broadcast through the* system.* /ul*/
public final class LocalBroadcastManager {private static final class ReceiverRecord {final IntentFilter filter;final BroadcastReceiver receiver;boolean broadcasting;boolean dead;ReceiverRecord(IntentFilter _filter, BroadcastReceiver _receiver) {filter _filter;receiver _receiver;}Overridepublic String toString() {StringBuilder builder new StringBuilder(128);builder.append(Receiver{);builder.append(receiver);builder.append( filter);builder.append(filter);if (dead) {builder.append( DEAD);}builder.append(});return builder.toString();}}private static final class BroadcastRecord {final Intent intent;final ArrayListReceiverRecord receivers;BroadcastRecord(Intent _intent, ArrayListReceiverRecord _receivers) {intent _intent;receivers _receivers;}}private static final String TAG LocalBroadcastManager;private static final boolean DEBUG false;private final Context mAppContext;private final HashMapBroadcastReceiver, ArrayListReceiverRecord mReceivers new HashMap();private final HashMapString, ArrayListReceiverRecord mActions new HashMap();private final ArrayListBroadcastRecord mPendingBroadcasts new ArrayList();static final int MSG_EXEC_PENDING_BROADCASTS 1;private final Handler mHandler;private static final Object mLock new Object();private static LocalBroadcastManager mInstance;NonNullpublic static LocalBroadcastManager getInstance(NonNull Context context) {synchronized (mLock) {if (mInstance null) {mInstance new LocalBroadcastManager(context.getApplicationContext());}return mInstance;}}private LocalBroadcastManager(Context context) {mAppContext context;mHandler new Handler(context.getMainLooper()) {Overridepublic void handleMessage(Message msg) {switch (msg.what) {case MSG_EXEC_PENDING_BROADCASTS:executePendingBroadcasts();break;default:super.handleMessage(msg);}}};}/*** Register a receive for any local broadcasts that match the given IntentFilter.** param receiver The BroadcastReceiver to handle the broadcast.* param filter Selects the Intent broadcasts to be received.** see #unregisterReceiver*/public void registerReceiver(NonNull BroadcastReceiver receiver,NonNull IntentFilter filter) {synchronized (mReceivers) {ReceiverRecord entry new ReceiverRecord(filter, receiver);ArrayListReceiverRecord filters mReceivers.get(receiver);if (filters null) {filters new ArrayList(1);mReceivers.put(receiver, filters);}filters.add(entry);for (int i0; ifilter.countActions(); i) {String action filter.getAction(i);ArrayListReceiverRecord entries mActions.get(action);if (entries null) {entries new ArrayListReceiverRecord(1);mActions.put(action, entries);}entries.add(entry);}}}/*** Unregister a previously registered BroadcastReceiver. emAll/em* filters that have been registered for this BroadcastReceiver will be* removed.** param receiver The BroadcastReceiver to unregister.** see #registerReceiver*/public void unregisterReceiver(NonNull BroadcastReceiver receiver) {synchronized (mReceivers) {final ArrayListReceiverRecord filters mReceivers.remove(receiver);if (filters null) {return;}for (int ifilters.size()-1; i0; i--) {final ReceiverRecord filter filters.get(i);filter.dead true;for (int j0; jfilter.filter.countActions(); j) {final String action filter.filter.getAction(j);final ArrayListReceiverRecord receivers mActions.get(action);if (receivers ! null) {for (int kreceivers.size()-1; k0; k--) {final ReceiverRecord rec receivers.get(k);if (rec.receiver receiver) {rec.dead true;receivers.remove(k);}}if (receivers.size() 0) {mActions.remove(action);}}}}}}/*** Broadcast the given intent to all interested BroadcastReceivers. This* call is asynchronous; it returns immediately, and you will continue* executing while the receivers are run.** param intent The Intent to broadcast; all receivers matching this* Intent will receive the broadcast.** see #registerReceiver** return Returns true if the intent has been scheduled for delivery to one or more* broadcast receivers. (Note tha delivery may not ultimately take place if one of those* receivers is unregistered before it is dispatched.)*/public boolean sendBroadcast(NonNull Intent intent) {synchronized (mReceivers) {final String action intent.getAction();final String type intent.resolveTypeIfNeeded(mAppContext.getContentResolver());final Uri data intent.getData();final String scheme intent.getScheme();final SetString categories intent.getCategories();final boolean debug DEBUG ||((intent.getFlags() Intent.FLAG_DEBUG_LOG_RESOLUTION) ! 0);if (debug) Log.v(TAG, Resolving type type scheme scheme of intent intent);ArrayListReceiverRecord entries mActions.get(intent.getAction());if (entries ! null) {if (debug) Log.v(TAG, Action list: entries);ArrayListReceiverRecord receivers null;for (int i0; ientries.size(); i) {ReceiverRecord receiver entries.get(i);if (debug) Log.v(TAG, Matching against filter receiver.filter);if (receiver.broadcasting) {if (debug) {Log.v(TAG, Filters target already added);}continue;}int match receiver.filter.match(action, type, scheme, data,categories, LocalBroadcastManager);if (match 0) {if (debug) Log.v(TAG, Filter matched! match0x Integer.toHexString(match));if (receivers null) {receivers new ArrayListReceiverRecord();}receivers.add(receiver);receiver.broadcasting true;} else {if (debug) {String reason;switch (match) {case IntentFilter.NO_MATCH_ACTION: reason action; break;case IntentFilter.NO_MATCH_CATEGORY: reason category; break;case IntentFilter.NO_MATCH_DATA: reason data; break;case IntentFilter.NO_MATCH_TYPE: reason type; break;default: reason unknown reason; break;}Log.v(TAG, Filter did not match: reason);}}}if (receivers ! null) {for (int i0; ireceivers.size(); i) {receivers.get(i).broadcasting false;}mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);}return true;}}}return false;}/*** Like {link #sendBroadcast(Intent)}, but if there are any receivers for* the Intent this function will block and immediately dispatch them before* returning.*/public void sendBroadcastSync(NonNull Intent intent) {if (sendBroadcast(intent)) {executePendingBroadcasts();}}SuppressWarnings(WeakerAccess) /* synthetic access */void executePendingBroadcasts() {while (true) {final BroadcastRecord[] brs;synchronized (mReceivers) {final int N mPendingBroadcasts.size();if (N 0) {return;}brs new BroadcastRecord[N];mPendingBroadcasts.toArray(brs);mPendingBroadcasts.clear();}for (int i0; ibrs.length; i) {final BroadcastRecord br brs[i];final int nbr br.receivers.size();for (int j0; jnbr; j) {final ReceiverRecord rec br.receivers.get(j);if (!rec.dead) {rec.receiver.onReceive(mAppContext, br.intent);}}}}}
}
有兴趣可以自行研究一下。
这个工具类主要特点
1.在获取LocalBroadcastManager对象实例的时候这里用了单例模式。并且把外部传进来的Context 转化成了ApplicationContext有效的避免了当前Context的内存泄漏的问题。这一点我们在设计单例模式框架的时候是值得学习的看源码可以学习到很多东西。2.在LocalBroadcastManager构造函数中创建了一个Handler.可见 LocalBroadcastManager 的本质上是通过Handler机制发送和接收消息的。3.在创建Handler的时候用了 context.getMainLooper() , 说明这个Handler是在Android 主线程中创建的广播接收器的接收消息的时候会在Android 主线程所以我们决不能在广播接收器里面做耗时操作以免阻塞UI。4、LocalBroadcastManager采用的是Handler的消息机制来处理的广播而注册到系统中的是通过Binder机制实现的速度是应用内广播要快很多。不过由于Handler的消息机制是为了同一个进程的多线程间进行通信的因而跨进程时无法使用应用内广播。四、LocalBroadcastManager 总结
1、LocalBroadcastManager注册广播只能通过代码注册的方式。传统的广播可以通过代码和xml两种方式注册。
2、LocalBroadcastManager注册广播后一定要记得取消监听。这一步可以有效的解决内存泄漏的问题。
3、LocalBroadcastManager采用的是Handler的消息机制来处理的广播所以可以高效在应用内部通讯。
