精华内容
下载资源
问答
  • 主要为大家详细介绍了android事件总线EventBus3.0使用方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • android基于livedata实现的事件总线框架,可以根据key来识别特定的通知,优雅的解决eventbus的弊端,不依赖第三方库,更加轻量好用。
  • 以新浪微博为例,在新浪微博首页好友动态列表页和好友动态...Android事件总线框架 AndroidEventBus 为此类需求的实现提供了非常方便的方案。 文章地址:http://blog.csdn.net/kpioneer123/article/details/51260660
  • Android 事件总线总结

    2019-05-31 10:33:00
    Android 应用开发过程中,经常会设计Activity、Fragnebt、Service等不同组件或者模块之间的消息传递,使用传统的方法,往往会写出丑陋的代码,而且不同组件和模块之间耦合严重。随着模块的日益增多、代码逻辑的不断...

    Android 应用开发过程中,经常会设计Activity、Fragnebt、Service等不同组件或者模块之间的消息传递,使用传统的方法,往往会写出丑陋的代码,而且不同组件和模块之间耦合严重。随着模块的日益增多、代码逻辑的不断新增和修改,整个代码的架构就会显得越来越混乱。
    举个栗子:多个Activity页面跳转和数据回传的问题,例如Acticity A 跳转到 Activity B,接着跳转到C,在C中执行一系列操作后,需要传递数据或者时间给Activity A,传统的做法是进行接口回调,但这样不仅增加逻辑复杂性,而且增大页面间的耦合性。
    为了解决以上问题,实现组件间和模块间的解耦,我们引入了事件总线的概念

    原理

    事件总线是基于观察者模式的思想实现的,它使用发布订阅的方式支持组件和模块间的通信,摒弃了观察者模式需要显示注册回调的缺点,同时可用于替换Java中传统的时间监听方式。
    事件总线涉及到的关联方如下:

    • 事件Event:一个普通的POJO类,只包含数据,不包含对数据的操作。事件有两种类型:普通事件和粘滞事件,粘滞事件的特点实在事件发布后,订阅者才开始订阅该类型的事件,它依然可以收到这个事件,而普通事件是收不到的
    • 订阅者Subscriber:订阅某种类型事件的对象,通常会有一个回调函数用于对接收到的事件进行处理,,订阅者可以订阅事件,也可以取消订阅的事件,订阅者可以引入优先级的概念,优先级高的订阅者可以优先接收到该事件,并可以决定是否继续传递事件给低优先级的订阅者。
    • 发布者Publisher:事件的源头,发布某种类型事件的对象。
    • 总线EventBus:负责订阅者,事件等信息的存储,同时处理事件的流动和分发,通过总线,订阅者和发布者是解耦的,不想不知道对方的存在。

    开源实现

    Android 事件总线的开源实现有很多,如google出品的Guava库中就包含一个EventBus模块但是由于Guava库很庞大,为了避免引入太多的无用代码,一般不建议使用这个库,使用最广泛的主要有greenrobot的EventBus、Square的otto,

    EventBus

    EventBus是一个专门为Android平台优化定制的事件总线函数库,出于性能考虑,没有使用Java注解,因为在Android 4.0之前的系统上,查询注解很慢。它使用“名称约定优于配置”的思想,导致如下:

    • 接收事件的函数必须以onEvent开头
    • 一般每个事件对应一个Event类,会产生很多样板类,从而增加APP出现64K方法书问题的可能
    • 用于接收EventBus事件的类不能混淆,否则会找不到onEvent函数
      但是在EventBus 3.0版本之后接收事件的函数不在需要以onEvent开头,是要使用@Subsribe注解标注即可,同时性能也得到了提升。
    展开全文
  • Android事件总线

    2021-06-04 00:42:44
    Android中Activity、Service、Fragment之间的相互通信比较麻烦,主要有以下一些方法:(1)使用广播,...但是这些方法都比较繁琐,一种比较简单有效的方法就是使用事件总线事件总线的基本原理是发送者把消息发送到事...

    Android中Activity、Service、Fragment之间的相互通信比较麻烦,主要有以下一些方法:

    (1)使用广播,发送者发出广播,接收者接收广播后进行处理;

    (2)使用Handler和Message,如下载线程完成下载任务后,给UI发送Message,UI收到Message后更新界面。

    但是这些方法都比较繁琐,一种比较简单有效的方法就是使用事件总线。事件总线的基本原理是发送者把消息发送到事件总线,然后事件总线在接收者中查找哪些方法注册了这个事件,如果某个方法注册了这个事件,就触发该方法。这样实现组件之间的通信要比其他方法简单得多,代码也更加简洁。

    1.下载simple_eventbus.jar,并导入Android工程,并且在需要发送或接收消息的组件里面import下面两个类:

    import org.simple.eventbus.EventBus;

    import org.simple.eventbus.Subcriber;

    2.新建两个Activity:MainActivity和Activity2。其中MainActivity作为消息的接收者,Activity2作为消息的发送者。由于这两个Activity都要使用事件总线,在onCreate(Bundle savedInstanceState)中需要注册EventBus:

    EventBus.getDefault().register(this);

    在onDestroy()中需要注销EventBus:

    EventBus.getDefault().unregister(this);

    3.在Activity2中新建一个Button,onClick()方法如下:

    @Override

    public void onClick(View v) {

    switch (v.getId()){

    case R.id.btnRun2:

    num++;

    txtStatus.setText("点击了" + num + "次!");

    EventBus.getDefault().post(new Object(), "my_tag");

    break;

    default:

    break;

    }

    }

    每点击一次Button,就使用EventBus.getDefault().post()方法向EventBus发送一次消息。EventBus.getDefault().post()有两个参数:第一个参数是向事件接收者传递的对象,由于我们这里不需要向发送者传递对象,所以只new了一个Object;第二个参数是tag,相当于广播里面的action,只有接收者里面注册了这个tag的方法才会被触发,没有注册这个tag的方法就不会被触发。

    4.在MainActivity中新建接收消息的方法:

    @Subcriber(tag = "my_tag")

    private void updateUI(Object o){

    num++;

    txtStatus.setText("Activity 2 点击了" + num + "次!");

    Log.e("num=", String.valueOf(num));

    }

    其中@Subcriber(tag = "my_tag")注解表明该方法是一个消息接收方法,tag = "my_tag"表明该方法注册了"my_tag"这个消息,接收到该消息该方法就会被触发。

    5.运行结果。进入Activity 2,6次点击Button:

    ccf6529e7fd58bb5330df7547932f403.png

    再回到MainActivity,可以看到updateUI()被触发,显示出了Activity 2的点击次数:

    1eb309d7b5407a58659391501b843309.png

    0b1331709591d260c1c78e86d0c51c18.png

    展开全文
  • 快速和可靠的事件总线系统多总线支持WebView〜> JavaScript支持的类型:Bool Int Float Double String任何列表(使用此列表中的类型,包括地图)任何地图(使用此列表中的类型,包括列表) JavaScript〜> Android...
  • Android 事件总线EventBus

    2021-06-05 12:44:51
    2.build.gradlecompile 'org.greenrobot:eventbus:3.0.0'3.onCreateEventBus.getDefault().register(this);4.创建public class UserEvent {public String username;}public void sendEvent(View view) {new Thread()...

    2.build.gradle

    compile 'org.greenrobot:eventbus:3.0.0'

    3.onCreate

    EventBus.getDefault().register(this);

    4.创建

    public class UserEvent {

    public String username;

    }

    public void sendEvent(View view) {

    new Thread(){

    @Override

    public void run() {

    UserEvent event = new UserEvent();

    event.username="小熊";

    EventBus.getDefault().post(event);

    }

    }.start();

    EventBus.getDefault().post(new FinishEvent());

    }

    5.onDestory()

    EventBus.getDefault().unregister(this);

    super.onDestroy();

    6.线程

    @Subscribe(threadMode = ThreadMode.MAIN) //不管你发布的是什么线程 我都跑在 主线程

    public void changeText(UserEvent event){

    Log.e("event","thread1:"+Thread.currentThread().getName());

    mText.append(event.username);

    }

    @Subscribe(threadMode = ThreadMode.POSTING) //发布过来是 什么线程 就运行在什么线程

    public void changeText(final UserEvent event){

    Log.e("event","thread2:"+Thread.currentThread().getName());

    runOnUiThread(new Runnable() {

    @Override

    public void run() {

    mText.append(event.username);

    }

    });

    }

    @Subscribe(threadMode = ThreadMode.BACKGROUND) //发布过来是 主线程 创建子线程 发布过来是 子线程直接运行在该子线程

    public void changeText(final UserEvent event){

    Log.e("event","thread3:"+Thread.currentThread().getName());

    runOnUiThread(new Runnable() {

    @Override

    public void run() {

    mText.append(event.username);

    }

    });

    }

    @Subscribe(threadMode = ThreadMode.ASYNC) //不管发布的是什么线程 都创建子线程

    public void changeText(final UserEvent event){

    Log.e("event","thread4:"+Thread.currentThread().getName());

    runOnUiThread(new Runnable() {

    @Override

    public void run() {

    mText.append(event.username);

    }

    });

    }

    展开全文
  • Android事件总线EventBus的用法详解

    千次阅读 2016-07-04 11:24:10
    Android中模块更新的机制有很多种,EventBus又是其中使用起来较为方便简单的一种,本文就... EventBus是针一款对Android的发布/订阅事件总线。它可以让我们很轻松的实现在Android各个组件之间传递消息,并且代码的可

    Android中模块更新的机制有很多种,EventBus又是其中使用起来较为方便简单的一种,本文就针对EventBus在平常工作中的用法,做一个个人总结。主要分为以下几点来展示:

    1. 介绍
    2. 源码分析
    3. 用法示例

    下图也就是本文要讲的主要内容:
    这里写图片描述

    1、介绍:
    EventBus是针一款对Android的发布/订阅事件总线。它可以让我们很轻松的实现在Android各个组件之间传递消息,并且代码的可读性更好,耦合度更低。我们可以在要进行实时界面更新的交互上使用该模块以替代一些消息机制的处理。EventBus的·优点是用法简单,不必写繁琐的代码,而且耦合度也低。缺点其实个人发现无明显的缺点,可能就是得针对每个事件定义也一个事件类,感觉会造成重复造轮子的感觉。此外,关于事件总线还有的一个框架是Otto,这边就不分析这个框架了。

    2、源码分析:
    按照惯例,我们在代码里面查看EventBus.java的源码,这里就不贴出整个类的源码了。我们首先看下,该类的构造方法:

    /**
         * Creates a new EventBus instance; each instance is a separate scope in which events are delivered. To use a
         * central bus, consider {@link #getDefault()}.
         */
        public EventBus() {
            this(DEFAULT_BUILDER);
        }
    
        EventBus(EventBusBuilder builder) {
            subscriptionsByEventType = new HashMap<Class<?>, CopyOnWriteArrayList<Subscription>>();
            typesBySubscriber = new HashMap<Object, List<Class<?>>>();
            stickyEvents = new ConcurrentHashMap<Class<?>, Object>();
            mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
            backgroundPoster = new BackgroundPoster(this);
            asyncPoster = new AsyncPoster(this);
            subscriberMethodFinder = new SubscriberMethodFinder(builder.skipMethodVerificationForClasses);
            logSubscriberExceptions = builder.logSubscriberExceptions;
            logNoSubscriberMessages = builder.logNoSubscriberMessages;
            sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
            sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
            throwSubscriberException = builder.throwSubscriberException;
            eventInheritance = builder.eventInheritance;
            executorService = builder.executorService;
        }

    主要是一些要用到类的对象的初始化,用的是Builder模式。
    注册的方法:

    /**
         * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
         * are no longer interested in receiving events.
         * <p/>
         * Subscribers have event handling methods that must be annotated by {@link Subscribe}.
         * The {@link Subscribe} annotation also allows configuration like {@link
         * ThreadMode} and priority.
         */
        public void register(Object subscriber) {
            Class<?> subscriberClass = subscriber.getClass();
            List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
            synchronized (this) {
                for (SubscriberMethod subscriberMethod : subscriberMethods) {
                    subscribe(subscriber, subscriberMethod);
                }
            }
        }

    通过SubscriberMethodFinder该类的findSubscriberMethods方法,查询到SubscriberMethod列表,SubscriberMethod类的构造方法:

    public SubscriberMethod(Method method, Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
            this.method = method;
            this.threadMode = threadMode;
            this.eventType = eventType;
            this.priority = priority;
            this.sticky = sticky;
        }

    可知,五个参数为方法、事件类型、线程模式、优先级、sticky,SubscriberMethod的其他方法:

    @Override
        public boolean equals(Object other) {
            if (other == this) {
                return true;
            } else if (other instanceof SubscriberMethod) {
                checkMethodString();
                SubscriberMethod otherSubscriberMethod = (SubscriberMethod)other;
                otherSubscriberMethod.checkMethodString();
                // Don't use method.equals because of http://code.google.com/p/android/issues/detail?id=7811#c6
                return methodString.equals(otherSubscriberMethod.methodString);
            } else {
                return false;
            }
        }
    
        private synchronized void checkMethodString() {
            if (methodString == null) {
                // Method.toString has more overhead, just take relevant parts of the method
                StringBuilder builder = new StringBuilder(64);
                builder.append(method.getDeclaringClass().getName());
                builder.append('#').append(method.getName());
                builder.append('(').append(eventType.getName());
                methodString = builder.toString();
            }
        }

    现在清楚了,其实就是查询SubscriberMethodFinder类的作用是在Subscriber中找到所有以methodName(即默认的onEvent)开头的方法,具体我们可以看下findSubscriberMethods方法的代码。
    EventBus中 findSubscriberMethods方法 2.4源码:

    List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
            String key = subscriberClass.getName();
            List<SubscriberMethod> subscriberMethods;
            synchronized (methodCache) {
                subscriberMethods = methodCache.get(key);
            }
            if (subscriberMethods != null) {
                return subscriberMethods;
            }
            subscriberMethods = new ArrayList<SubscriberMethod>();
            Class<?> clazz = subscriberClass;
            HashSet<String> eventTypesFound = new HashSet<String>();
            StringBuilder methodKeyBuilder = new StringBuilder();
            while (clazz != null) {
                String name = clazz.getName();
                if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) {
                    // Skip system classes, this just degrades performance
                    break;
                }
    
                // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again)
                Method[] methods = clazz.getDeclaredMethods();
                for (Method method : methods) {
                    String methodName = method.getName();
                    if (methodName.startsWith(ON_EVENT_METHOD_NAME)) {
                        int modifiers = method.getModifiers();
                        if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                            Class<?>[] parameterTypes = method.getParameterTypes();
                            if (parameterTypes.length == 1) {
                                String modifierString = methodName.substring(ON_EVENT_METHOD_NAME.length());
                                ThreadMode threadMode;
                                if (modifierString.length() == 0) {
                                    threadMode = ThreadMode.PostThread;
                                } else if (modifierString.equals("MainThread")) {
                                    threadMode = ThreadMode.MainThread;
                                } else if (modifierString.equals("BackgroundThread")) {
                                    threadMode = ThreadMode.BackgroundThread;
                                } else if (modifierString.equals("Async")) {
                                    threadMode = ThreadMode.Async;
                                } else {
                                    if (skipMethodVerificationForClasses.containsKey(clazz)) {
                                        continue;
                                    } else {
                                        throw new EventBusException("Illegal onEvent method, check for typos: " + method);
                                    }
                                }
                                Class<?> eventType = parameterTypes[0];
                                methodKeyBuilder.setLength(0);
                                methodKeyBuilder.append(methodName);
                                methodKeyBuilder.append('>').append(eventType.getName());
                                String methodKey = methodKeyBuilder.toString();
                                if (eventTypesFound.add(methodKey)) {
                                    // Only add if not already found in a sub class
                                    subscriberMethods.add(new SubscriberMethod(method, threadMode, eventType));
                                }
                            }
                        } else if (!skipMethodVerificationForClasses.containsKey(clazz)) {
                            Log.d(EventBus.TAG, "Skipping method (not public, static or abstract): " + clazz + "."
                                    + methodName);
                        }
                    }
                }
                clazz = clazz.getSuperclass();
            }
            if (subscriberMethods.isEmpty()) {
                throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called "
                        + ON_EVENT_METHOD_NAME);
            } else {
                synchronized (methodCache) {
                    methodCache.put(key, subscriberMethods);
                }
                return subscriberMethods;
            }
        }

    现在应该豁然开朗,就是2.4版本,必须使用三种方法接收post过来的消息:MainThread、BackgroundThread、Async。而在3.0中的源码则是这样的:

     List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
            List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
            if (subscriberMethods != null) {
                return subscriberMethods;
            }
    
            if (ignoreGeneratedIndex) {
                subscriberMethods = findUsingReflection(subscriberClass);
            } else {
                subscriberMethods = findUsingInfo(subscriberClass);
            }
            if (subscriberMethods.isEmpty()) {
                throw new EventBusException("Subscriber " + subscriberClass
                        + " and its super classes have no public methods with the @Subscribe annotation");
            } else {
                METHOD_CACHE.put(subscriberClass, subscriberMethods);
                return subscriberMethods;
            }
        }

    subscriberMethods = findUsingReflection(subscriberClass);说的是利用反射来查询方法。
    所以我们3.0通过注解,可以使用自定义的方法,不在受限,看完了注册的代码,
    接下来就看下post的源码。

    /** Posts the given event to the event bus. */
        public void post(Object event) {
            PostingThreadState postingState = currentPostingThreadState.get();
            List<Object> eventQueue = postingState.eventQueue;
            eventQueue.add(event);
    
            if (!postingState.isPosting) {
                postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
                postingState.isPosting = true;
                if (postingState.canceled) {
                    throw new EventBusException("Internal error. Abort state was not reset");
                }
                try {
                    while (!eventQueue.isEmpty()) {
                        postSingleEvent(eventQueue.remove(0), postingState);
                    }
                } finally {
                    postingState.isPosting = false;
                    postingState.isMainThread = false;
                }
            }
        }

    发现操作的对象是PostingThreadState,然后就是这段代码:

    postSingleEvent(eventQueue.remove(0), postingState);

    继续查看相关的代码:

     private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
            Class<?> eventClass = event.getClass();
            boolean subscriptionFound = false;
            if (eventInheritance) {
                List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
                int countTypes = eventTypes.size();
                for (int h = 0; h < countTypes; h++) {
                    Class<?> clazz = eventTypes.get(h);
                    subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
                }
            } else {
                subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
            }
            if (!subscriptionFound) {
                if (logNoSubscriberMessages) {
                    Log.d(TAG, "No subscribers registered for event " + eventClass);
                }
                if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                        eventClass != SubscriberExceptionEvent.class) {
                    post(new NoSubscriberEvent(this, event));
                }
            }
        }
    
        private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
            CopyOnWriteArrayList<Subscription> subscriptions;
            synchronized (this) {
                subscriptions = subscriptionsByEventType.get(eventClass);
            }
            if (subscriptions != null && !subscriptions.isEmpty()) {
                for (Subscription subscription : subscriptions) {
                    postingState.event = event;
                    postingState.subscription = subscription;
                    boolean aborted = false;
                    try {
                        postToSubscription(subscription, event, postingState.isMainThread);
                        aborted = postingState.canceled;
                    } finally {
                        postingState.event = null;
                        postingState.subscription = null;
                        postingState.canceled = false;
                    }
                    if (aborted) {
                        break;
                    }
                }
                return true;
            }
            return false;
        }
    
        private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
            switch (subscription.subscriberMethod.threadMode) {
                case POSTING:
                    invokeSubscriber(subscription, event);
                    break;
                case MAIN:
                    if (isMainThread) {
                        invokeSubscriber(subscription, event);
                    } else {
                        mainThreadPoster.enqueue(subscription, event);
                    }
                    break;
                case BACKGROUND:
                    if (isMainThread) {
                        backgroundPoster.enqueue(subscription, event);
                    } else {
                        invokeSubscriber(subscription, event);
                    }
                    break;
                case ASYNC:
                    asyncPoster.enqueue(subscription, event);
                    break;
                default:
                    throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
            }
        }

    这里就用到ThreadMode了:

    如果是PostThread,直接执行
    如果是MainThread,判断当前线程,如果本来就是UI线程就直接执行,否则加入mainThreadPoster队列
    如果是后台线程,如果当前是UI线程,加入backgroundPoster队列,否则直接执行
    如果是Async,加入asyncPoster队列。关于post,就暂时写到这里啊,主要是理清内部的处理机制。

    另外还有优先级和Stick的使用。这里就不阐述了。EventBus关键的部分源码我就写到这里,以下写下我们如何在代码中简单使用该模块。

    3、使用示例:
    一、首先是引入该模块:
    我用的是gradle构建(demo源码和资源在最后会提供):

    //    compile files('libs/eventbus-2.4.0.jar')
        compile 'org.greenrobot:eventbus:3.0.0'//3.0

    二、create方法中注册:

    EventBusManager.getInstance().getGlobaEventBus().register(this);

    EventBusManager.java自己封装的类:

    
    //import de.greenrobot.event.EventBus;//2.4
    
    import org.greenrobot.eventbus.EventBus;//3.0
    
    /**
     * @创建者 :viviant
     * @时间 :2016/06/28  13:47
     * @描述 : 事件总线管理
     */
    public class EventBusManager {
    
        private static EventBusManager busManager;
        private EventBus globalEventBus;
    
        private EventBusManager() {
        }
    
        public EventBus getGlobaEventBus() {
            if (globalEventBus == null) {
                globalEventBus = new EventBus();
            }
            return globalEventBus;
        }
    
        public static EventBusManager getInstance() {
            if (busManager == null) {
                synchronized (EventBusManager.class) {
                    if (busManager == null) {
                        busManager = new EventBusManager();
                    }
                }
            }
            return busManager;
        }
    }

    Event实体类编写:

    /**
     * 作者:viviant on 2016/7/4 10:35
     * 描述:
     */
    public class TestEvent {
        private String eventName;
    
        public void setEventName(String eventName) {
            this.eventName = eventName;
        }
    
        public String getEventName() {
            return eventName;
        }
    }

    接收页面方法编写(demo源码中有说明版本区别):

    /**
         * 不同模块之间数据的同步
         *2.4的用法必须使用以下的几个方法,不需要注解
         * @param event
         */
         @Subscribe
        public void onEventReceive(TestEvent event) {
            Log.d("weiwei", "onEventMainThread收到了消息:" );
    
            if (event.getEventName().equals("tv1")) {
                tv1.setText("change by bt1");
    
            } else if (event.getEventName().equals("tv2")) {
                tv2.setText("tv2");
    
            } else if (event.getEventName().equals("tv3")) {
    
            } else if (event.getEventName().equals("tv4")) {
    
            }
        }

    操作activity中的相关代码:

    import android.os.Bundle;
    import android.support.annotation.Nullable;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    
    import constraintlayout.test.test.viviant.eventbustest.event.TestEvent;
    import constraintlayout.test.test.viviant.eventbustest.manager.EventBusManager;
    
    /**
     * 作者:viviant on 2016/7/4 10:37
     * 描述:
     */
    public class SecActivity extends AppCompatActivity implements View.OnClickListener{
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            setContentView(R.layout.activity_sec);
    
            Button bt1 = (Button) findViewById(R.id.bt1);
            Button bt2 = (Button) findViewById(R.id.bt2);
            Button bt3 = (Button) findViewById(R.id.bt3);
            Button bt4 = (Button) findViewById(R.id.bt4);
    
            bt1.setOnClickListener(this);
            bt2.setOnClickListener(this);
            bt3.setOnClickListener(this);
            bt4.setOnClickListener(this);
    
    
        }
    
        @Override
        public void onClick(View view) {
            TestEvent te = new TestEvent();
            switch (view.getId()) {
    
                case R.id.bt1:
                    te.setEventName("tv1");
                    EventBusManager.getInstance().getGlobaEventBus().post(te);
                    break;
    
                case R.id.bt2:
                    te.setEventName("tv2");
                    EventBusManager.getInstance().getGlobaEventBus().post(te);
                    break;
    
                case R.id.bt3:
                    break;
    
                case R.id.bt4:
                    break;
                default:
                    break;
            }
        }
    }

    云行之后我们先点击跳转activity,再点击相应but,然后返回去,便可以看到发生相应的变化。
    MainActivity界面:
    这里写图片描述

    SecActivity界面:

    这里写图片描述

    点击第一个按钮后回到MainActivity的界面:
    这里写图片描述

    源码地址:
    https://github.com/viviant1224/EventBusTest

    2.4jar包下载地址:
    http://download.csdn.net/detail/u013606974/9566754

    demo中查看gradle中可切换EventBus版本。改完之后也要改相应的引包类。

    展开全文
  • Android事件总线EventBus

    2020-09-07 00:08:05
    EventBus可以用于应用程序内各组件间、...创建相关事件 /*** * 搜索事件 * @time 2020/8/21 10:25 */ public class OnSearchEvent { /** * 搜索关键字 */ private String data; /** * 当前显示界面的索引 */
  • android事件总线eclipse版测试demo
  • Latest version router 1.2.8 —— modified code to avoid concurrent bugs router 1.2.6 -- use apt to process subscribe annotation router 1.2.0 -- use WeakReference to avoid MemoryLeak cause by forgot ...
  • AgeraBus 是基于谷歌开源的 Agera 实现的 Android 事件总线,实现了 EventBus 基本常用的功能
  • build.gradle compile ' com.squareup:otto:1.3.8 '
  • Android事件总线(一)EventBus3.0用法全解析

    万次阅读 多人点赞 2016-08-17 10:21:59
    EventBus是一款针对Android优化的发布/订阅事件总线。简化了应用程序内各组件间、组件与后台线程间的通信。优点是开销小,代码更优雅,以及将发送者和接收者解耦。如果Activity和Activity进行交互还好说,如果...
  • Android事件总线 ( AndroidEventBus ) 框架发布 2015-02-06 13:28 15215人阅读 评论(5) 收藏 举报 分类: android(79) 目录(?)[+] AndroidEventBus 如果你不知道事件总线是什么,那么没有关系,下面...
  • Kotlin编写的事件总线
  • Android事件总线otto学习笔记

    千次阅读 2016-07-06 19:06:53
    otto是Square推出的库,主要用于Android不同组件之间的通信,类如可以通过一个Activity修改另外一个Activity里面的数据。  otto类似于广播,但广播是进程级别的(可能有错,我自己的理解)。otto是线程级别的,也需...
  • 这2个框架主要是用于Android中Activity、Service、Fragment之间的相互通信,其实就是不同线程之间的互相通信,常见的场景有:从一个列表页面进去一个编辑页录数据,录完保存成功后关闭编辑页并且刷新列表页,因为...
  • } 发送方 在对应的点击事件或 页面生命周期中 发送消息 EventBus.getDefault().post(new MessageEvent("更新数据")); 如果一个页面不止一个发送消息 可以通过消息体传入的参数来判断 是哪一个动作发送的消息。
  • EventBus是一个Android端优化的publish/subscribe消息总线,简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络,等网络返回时通过Handler或Broadcast通知UI,两个Fragment之间需要通过Listener通信,...
  • 这一步实现的是,告诉事件生产者,我有这些事件需要处理,通过注解进行标记,方便我们的框架进行收集此类需要处理的事件,例如以下这些操作: @Subscribe(threadMode = ThreadMode.MainThread) public void ...
  • Event Bus是一个发布 / 订阅的事件总线。 Event Bus模式 — 也被称为Message Bus或者发布者/订阅者(publisher/subscriber)模式 — 可以让两个组件相互通信,但是他们之间并不相互知晓。 基于事件总线管理/订阅/...
  • Otto框架是square公司为Android出的一款事件总线框架,设计用于解耦应用程序的不同部分,同时仍然允许它们有效地通信。 https://github.com/square/otto 以下简单介绍一下Otto框架的使用方式: 创建Bus实例: ...
  • EventBus是Android下高效的发布/订阅事件总线机制。作用是可以代替传统的Intent,Handler,Broadcast或接口函数在Fragment,Activity,Service,线程之间传递数据,执行方法。特点是代码简洁,是一种发布订阅设计模式...
  • 广播接收者后续和安卓事件总线粘性广播有序广播EventBus 粘性广播 特点:可以不用先执行注册 方法:sendstickyBroadcast 发送者 // An highlighted block public void sendBroadCastoOther(){ Intent intent = ...
  • Android事件总线设计(一) 我们通常在进行安卓设计的时候,不同的Activity,Fragment,Service等之间通讯一直是个不小的问题,用Intent以及Handler都觉得有一点麻烦,于是,为了简化以及更加高质量的完成通信,同时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,429
精华内容 8,571
关键字:

安卓事件总线