精华内容
参与话题
问答
  • 感受LiveData 与 ViewModel结合之美

    万次阅读 2018-06-19 13:48:19
    LiveData与ViewModel都是Android官方架构组件(Android Architecture Components)之一。 1.前言 虽说这篇是说LiveData与ViewModel,但是或多或少都有涉及另外一个组件:Lifecycles 。它们连同Room都是在17年...

    LiveDataViewModel都是Android官方架构组件(Android Architecture Components)之一。

    1.前言

    虽说这篇是说LiveDataViewModel,但是或多或少都有涉及另外一个组件:Lifecycles 。它们连同Room都是在17年谷歌IO大会推出的,当时还是预览版,大致17年底时推出了正式版。到今年的IO大会过后,又增加了许多新成员。

    可以看到27.0.0的v7库有依赖Lifecycles

    当时Lifecycles有集成进SupportActivity

    其实一开始我没有太当回事。。。直到27.1.0以后:

    好吧,今天的主角出现了,LiveDataViewModel。看到这里我觉得是该了解一波了。

    顺便看一下截止目前最新的v7:

    发现好多常用的组件分离出了v4包,比如ViewPagerSwipeRefreshLayout,这里就不多说了。

    2.优势

    LiveData 是一个可以感知 Activity 、Fragment生命周期的数据容器。当 LiveData 所持有的数据改变时,它会通知相应的界面代码进行更新。同时,LiveData 持有界面代码 Lifecycle 的引用,这意味着它会在界面代码(LifecycleOwner)的生命周期处于 started 或 resumed 时作出相应更新,而在 LifecycleOwner 被销毁时停止更新。

    上面的描述介绍了LiveData的优点:不用手动控制生命周期,不用担心内存泄露,数据变化时会收到通知。

    ViewModel 将视图的数据和逻辑从具有生命周期特性的实体(如 Activity 和 Fragment)中剥离开来。直到关联的 Activity 或 Fragment 完全销毁时,ViewModel 才会随之消失,也就是说,即使在旋转屏幕导致 Fragment 被重新创建等事件中,视图数据依旧会被保留。ViewModels 不仅消除了常见的生命周期问题,而且可以帮助构建更为模块化、更方便测试的用户界面。

    ViewModel的优点也很明显,为Activity 、Fragment存储数据,直到完全销毁。尤其是屏幕旋转的场景,常用的方法都是通过onSaveInstanceState()保存数据,再在onCreate()中恢复,真的是很麻烦。

    其次因为ViewModel存储了数据,所以ViewModel可以在当前ActivityFragment中实现数据共享。

    那么LiveDataViewModel的组合使用可以说是双剑合璧,而Lifecycles贯穿其中。

    3.基本使用

    这里我们按照官方Demo来简单说明,

    1. 数据储存

    /**
     * A ViewModel used for the {@link ChronoActivity3}.
     */
    public class LiveDataTimerViewModel extends ViewModel {
    
        private static final int ONE_SECOND = 1000;
    
        private MutableLiveData<Long> mElapsedTime = new MutableLiveData<>();
    
        private long mInitialTime;
    
        public LiveDataTimerViewModel() {
            mInitialTime = SystemClock.elapsedRealtime();
            Timer timer = new Timer();
    
            // Update the elapsed time every second.
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    final long newValue = (SystemClock.elapsedRealtime() - mInitialTime) / 1000;
                    // setValue() cannot be called from a background thread so post to main thread.
                    mElapsedTime.postValue(newValue);
                }
            }, ONE_SECOND, ONE_SECOND);
    
        }
    
        public LiveData<Long> getElapsedTime() {
            return mElapsedTime;
        }
    }

    LiveDataTimerViewModel很简单,在初始化时启动一个定时任务,每隔一秒通过postValue方法刷新一下数据。

    public class ChronoActivity3 extends AppCompatActivity {
    
        private LiveDataTimerViewModel mLiveDataTimerViewModel;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            setContentView(R.layout.chrono_activity_3);
    
            mLiveDataTimerViewModel = ViewModelProviders.of(this).get(LiveDataTimerViewModel.class);
    
            subscribe();
        }
    
        private void subscribe() {
            final Observer<Long> elapsedTimeObserver = new Observer<Long>() {
                @Override
                public void onChanged(@Nullable final Long aLong) {
                    String newText = ChronoActivity3.this.getResources().getString(
                            R.string.seconds, aLong);
                    ((TextView) findViewById(R.id.timer_textview)).setText(newText);
                    Log.d("ChronoActivity3", "Updating timer");
                }
            };
            //
            mLiveDataTimerViewModel.getElapsedTime().observe(this, elapsedTimeObserver);
        }
    }

    Activity也很简单,创建一个观察者elapsedTimeObserver。当LiveDataTimerViewModel中数据有变化时,它就会接收到最新的数据。当然你的页面要处于STARTED 或者 RESUMED。除非你使用observeForever来观察数据,有兴趣的可以去查看源码来了解实现原理。

    mLiveDataTimerViewModel.getElapsedTime().observeForever(elapsedTimeObserver);

    2. Fragmnet 之间数据共享

    public class SeekBarViewModel extends ViewModel {
    
        public MutableLiveData<Integer> seekbarValue = new MutableLiveData<>();
    }

    SeekBarViewModel中存储一个Integer类型的数据。

    public class Fragment_step5 extends Fragment {
    
        private SeekBar mSeekBar;
    
        private SeekBarViewModel mSeekBarViewModel;
    
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            // Inflate the layout for this fragment
            View root = inflater.inflate(R.layout.fragment_step5, container, false);
            mSeekBar = root.findViewById(R.id.seekBar);
            //注意这里是getActivity()
            mSeekBarViewModel = ViewModelProviders.of(getActivity()).get(SeekBarViewModel.class);
    
            subscribeSeekBar();
            return root;
        }
    
        private void subscribeSeekBar() {
    
            // 当SeekBar变化时,更新ViewModel中的数据.
            mSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                @Override
                public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    if (fromUser) {
                        Log.d("Step5", "Progress changed!");
                        mSeekBarViewModel.seekbarValue.setValue(progress);
                    }
                }
                ......
            });
    
            // 当ViewModel数据变化时,更新SeekBar。
            mSeekBarViewModel.seekbarValue.observe(this, new Observer<Integer>() {
                @Override
                public void onChanged(@Nullable Integer value) {
                    if (value != null) {
                        mSeekBar.setProgress(value);
                    }
                }
            });
        }
    }

    实现效果:

    这个页面是上下各有一个Fragment_step5的Fragment,Fragment中各有一个SeekBar。效果是拖动其中的SeekBar,另一边的SeekBar也会随之一样变化。

    4.简化使用

    这里我写了一个小小的工具库Saber来处理(好吧,猝不及防的广告。。。),使用注解处理器(Annotation Processor)将繁琐的代码自动生成。

    首先创建一个类,使用@LiveData注解标记你要保存的数据。注意这里的参数名称,下面会用到。

    public class SeekBar {
    
        @LiveData
        Integer value;
    }

    Build – > Make Project 生成代码如下:

    public class SeekBarViewModel extends ViewModel {
      private MutableLiveData<Integer> mValue;
    
      public MutableLiveData<Integer> getValue() {
        if (mValue == null) {
          mValue = new MutableLiveData<>();
        }
        return mValue;
      }
    
      public Integer getValueValue() {
        return getValue().getValue();
      }
    
      public void setValue(Integer mValue) {
        if (this.mValue == null) {
          return;
        }
        this.mValue.setValue(mValue);
      }
    
      public void postValue(Integer mValue) {
        if (this.mValue == null) {
          return;
        }
        this.mValue.postValue(mValue);
      }
    }
    

    提供了ViewModel的常用操作。setXXX()要在主线程中调用,而postXXX()既可在主线程也可在子线程中调用。一般情况下可以直接使用。比如上面的Fragment例子。简化为:

    public class TestFragment extends Fragment {
    
        private SeekBar mSeekBar;
    
        @BindViewModel(isShare = true) //<--标记需要绑定的ViewModel
        SeekBarViewModel mSeekBarViewModel;
    
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            // Inflate the layout for this fragment
            View root = inflater.inflate(R.layout.fragment_test, container, false);
            mSeekBar = root.findViewById(R.id.seekBar);
            Saber.bind(this); // <--这里绑定ViewModel
            subscribeSeekBar();
            return root;
        }
    
        private void subscribeSeekBar() {
    
            mSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                @Override
                public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    if (fromUser) {
                        mSeekBarViewModel.setValue(progress);
                    }
                }
                ......
            });
        }
    
        @OnChange(model = "mSeekBarViewModel") //<--接收变化
        void setData(Integer value){ //注意这里使用 @LiveData 标记的参数名
            if (value != null) {
                mSeekBar.setProgress(value);
            }
        }
    }

    默认使用@BindViewModel用于数据储存,如果需要Fragment之间数据共享,需要@BindViewModel(isShare = true),当然也要保证传入相同的key值。默认key值是类的规范名称,也就是包名加类名。

    这里写图片描述

    所以一旦需要互通的Fragment类名或包名不一致,就无法数据共享。这时可以指定key值:@BindViewModel(key = "value")

    对于第一个例子我们可以这样使用:

    public class LiveDataTimerViewModel extends TimerViewModel {// <-- 继承生成的ViewModel
    
        private static final int ONE_SECOND = 1000;
    
        private long mInitialTime;
    
        public LiveDataTimerViewModel() {
    
            mInitialTime = SystemClock.elapsedRealtime();
            Timer timer = new Timer();
    
            // Update the elapsed time every second.
            timer.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    final long newValue = (SystemClock.elapsedRealtime() - mInitialTime) / 1000;
                    // setValue() cannot be called from a background thread so post to main thread.
                    postTime(newValue); //<--直接使用post方法。
                }
            }, ONE_SECOND, ONE_SECOND);
    
        }
    
    }

    Activity如下:

    public class ChronoActivity3 extends AppCompatActivity {
    
        private TextView textView;
    
        @BindViewModel
        LiveDataTimerViewModel mTimerViewModel;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);       
            textView = this.findViewById(R.id.tv);
            Saber.bind(this); // <-- 绑定
        }
    
        @OnChange(model = "mTimerViewModel")
        void setData(Long time){
            String newText = MainActivity.this.getResources().getString(R.string.seconds, time);
            textView.setText(newText);
            Log.d("ChronoActivity3 ", "Updating timer");
        }
    }
    

    是不是使用起来更加的简洁了,如果一个页面有多个ViewModel可能效果更加的明显。

    5.原理

    因为实现大量借鉴了butterknife,所以使用方法与butterknife几乎一模一样。是不是想起了 butterknife@BindView@OnClick

    其实原理也不复杂,就是生成一个类来帮我们来获取ViewModel并实现数据的变化监听。如下:

    public class MainActivity_Providers implements UnBinder {
      private MainActivity target;
    
      @UiThread
      public MainActivity_Providers(MainActivity target) {
        this.target = target;
        init();
      }
    
      private void init() {
        target.mTimerViewModel = ViewModelProviders.of(target).get(LiveDataTimerViewModel.class);
        target.mTimerViewModel.getTime().observe(target, new Observer<Long>() {
          @Override
          public void onChanged(Long value) {
            target.setData(value);
          }
        });
      }
    
      @CallSuper
      @UiThread
      public void unbind() {
        MainActivity target = this.target;
        if (target == null) {
          throw new IllegalStateException("Bindings already cleared.");
        }
        this.target = null;
      }
    }
    

    所有代码已上传至Github。希望大家多多点赞支持!有什么问题及建议也可以提Issues,让我们将他慢慢的完善起来。

    6.参考

    展开全文
  • Jetpack LiveData+ViewModel 使用示例

    千次阅读 2020-01-30 20:21:55
    前言 Jetpack 是一套库、工具和指南,可帮助开发者更轻松地编写优质应用。 Jetpack 包含与平台 API 解除捆绑的 androidx.* 软件包库。这意味着,它可以提供向后兼容性,且比 Android 平台的更新频率更高,以此确保...

    前言

    Jetpack 是一套库、工具和指南,可帮助开发者更轻松地编写优质应用。

    Jetpack 包含与平台 API 解除捆绑的 androidx.* 软件包库。这意味着,它可以提供向后兼容性,且比 Android 平台的更新频率更高,以此确保始终可以获取最新且最好的 Jetpack 组件版本。

    ViewModel介绍

    ViewModel 类旨在以注重生命周期的方式存储和管理界面相关的数据。ViewModel 类让数据可在发生屏幕旋转等配置更改后继续存在。

    下图是ViewModel的生命周期,可以看到当Activity 销毁之后,才会将数据清空。
    在这里插入图片描述
    获取Viewmodel的方法

    viewModelWithLiveData = new ViewModelProvider(this).get(ViewModelWithLiveData.class);
    

    LiveData介绍

    LiveData的核心是观察者模式,当观察者观察到LiveData的变化时,会调用Onchange方法,具体内容由我们指定。

    LiveData 是一种可用于任何数据的封装容器,其中包括可实现 Collections 的对象, LiveData 对象通常存储在 ViewModel 对象中,并可通过 getter 方法进行访问。

    实例

    因为Jetpack需要androidx相关依赖,我们在新建android project时,需要勾选使用androidx
    在这里插入图片描述

    其中LiveData+ViewModel 这两个组件都属于这个库,我们以开发一个点赞,和点灭的demo来说明。demo很简单,大概效果是这样的,当点赞时+1,反之-1
    在这里插入图片描述

    以往的做法

    我们先获取两个图标,分别用来表示点赞和灭赞,我们再drawablenew一个向量图标,这一步就是在使用谷歌给我们自带的图标库。
    在这里插入图片描述
    在这里插入图片描述
    使用ConstraintLayout 创建一个界面
    在这里插入图片描述
    接下来,让我们编写逻辑java文件。

    public class MainActivity extends AppCompatActivity {
    
        ImageView imageView1,imageView2;
        TextView textView;
        int count =0;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            imageView1 = findViewById(R.id.imageView);
            imageView2 = findViewById(R.id.imageView2);
            textView=findViewById(R.id.textView);
            textView.setText(String.valueOf(0));
            
            imageView1.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    count++;
                    textView.setText(String.valueOf(count));
                }
            });
           imageView2.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    count--;
                    textView.setText(String.valueOf(count));
                }
            });
        }
    }
    

    使用LiveData和ViewMode时的做法

    在build.gradle中导入相关依赖

    def lifecycle_version = "2.2.0"
    def room_version = "2.2.2"
     // ViewModel
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
    // LiveData
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
    

    当使用LiveData和ViewModel时,我们将数据交给ViewModel类中的LiveData数据结构来管理。

    新建ViewModel的子类

    public class ViewModelWithLiveData extends ViewModel {
    
        /**
         * 保存赞的数量,类型设置为整型
         */
        private MutableLiveData<Integer> LikedNumber;
    
    
    	
        public MutableLiveData<Integer> getLikedNumber() {
            if(LikedNumber ==null)
            {
                LikedNumber = new MutableLiveData<>();
                LikedNumber.setValue(0);
            }
            return LikedNumber;
        }
        public void addLikedNumber(int n)
        {
            LikedNumber.setValue(LikedNumber.getValue()+n);
        }
        
    }
    
    

    而通过观察LiveData,让其能够自动刷新界面。

    public class MainActivity extends AppCompatActivity {
    
        ImageView imageView1,imageView2;
        TextView textView;
        ViewModelWithLiveData viewModelWithLiveData;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            imageView1 = findViewById(R.id.imageView);
            imageView2 = findViewById(R.id.imageView2);
            textView=findViewById(R.id.textView);
    
            viewModelWithLiveData = new ViewModelProvider(this).get(ViewModelWithLiveData.class);
    
            /**
             * 观察LiveData 是否有改变,如果有改变,将textview的值改为相应的值
             */
            viewModelWithLiveData.getLikedNumber().observe(this, new Observer<Integer>() {
                @Override
                public void onChanged(Integer integer) {
                    textView.setText(String.valueOf(integer));
                }
            });
    
    
            imageView1.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                   viewModelWithLiveData.addLikedNumber(1);
                }
            });
           imageView2.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    viewModelWithLiveData.addLikedNumber(-1);
                }
            });
        }
    }
    

    运行效果同前面完全一样,就不再展示。

    好处

    • 让数据和界面更加的分离,特别是当数据量够大时。
    • 使用ViewModel的好处在于,由于ViewModel的生命周期是从第一次获取到Activity销毁,所以ViewModel的数据具有暂存性,比如我们知道当旋转屏幕时,会重新加载界面,从而导致用户对界面的修改丢失,而ViewModel可以帮我们暂存这些修改。
    展开全文
  • Android LiveData 使用详解

    万次阅读 多人点赞 2019-01-26 20:33:41
    这篇博客让我们一起来了解一下 LiveData 是怎样使用的? 为什么要引进 LiveData LiveData 是一个可以被观察的数据持有类,它可以感知 Activity、Fragment或Service 等组件的生命周期。 它可以做到在组件处于...

    说在前面

    本次推出 Android Architecture Components 系列文章,目前写好了四篇,主要是关于 lifecycle,livedata 的使用和源码分析,其余的 Navigation, Paging library,Room,WorkMannager 等春节结束之后会更新,欢迎关注我的公众号,有更新的话会第一时间会在公众号上面通知。

    Android lifecycle 使用详解

    Android LiveData 使用详解

    Android lifecyle 源码解剖

    Android livedata 源码解剖

    github sample 地址: ArchiteComponentsSample

    徐公码字,一位不羁的码农。


    前言

    在上一篇博客中,我们讲解了 lifecycle 的使用及优点。这篇博客让我们一起来了解一下 LiveData 是怎样使用的?


    为什么要引进 LiveData

    LiveData 是一个可以被观察的数据持有类,它可以感知 Activity、Fragment或Service 等组件的生命周期。简单来说,他主要有一下优点。

    1. 它可以做到在组件处于激活状态的时候才会回调相应的方法,从而刷新相应的 UI。
    2. 不用担心发生内存泄漏
    3. 当 config 导致 activity 重新创建的时候,不需要手动取处理数据的储存和恢复。它已经帮我们封装好了。
    4. 当 Actiivty 不是处于激活状态的时候,如果你想 livedata setValue 之后立即回调 obsever 的 onChange 方法,而不是等到 Activity 处于激活状态的时候才回调 obsever 的 onChange 方法,你可以使用 observeForever 方法,但是你必须在 onDestroy 的时候 removeObserver。

    回想一下,在你的项目中,是不是经常会碰到这样的问题,当网络请求结果回来的时候,你经常需要判断 Activity 或者 Fragment 是否已经 Destroy, 如果不是 destroy,才更新 UI。而当你如果使用 Livedata 的话,因为它是在 Activity 处于 onStart 或者 onResume 的状态时,他才会进行相应的回调,因而可以很好得处理这个问题,不必谢一大堆的 activity.isDestroyed()。接下来,让我们一起来看一下 LiveData 的使用


    LiveData 使用

    基本使用

    1. 引入相关的依赖包
    // ViewModel and LiveData
    implementation "android.arch.lifecycle:extensions:1.1.0"
    // alternatively, just ViewModel
    implementation "android.arch.lifecycle:viewmodel:1.1.0"
    // alternatively, just LiveData
    implementation "android.arch.lifecycle:livedata:1.1.0"
    
    1. 在代码中使用

    LiveData 是一个抽象类,它的实现子类有 MutableLiveData ,MediatorLiveData。在实际使用中,用得比较多的是 MutableLiveData。他常常结合 ViewModel 一起使用。下面,让我们一起来看一下怎样使用它?

    首先,我们先写一个类继承我们的 ViewModel,里面持有 mNameEvent。

    public class TestViewModel extends ViewModel {
    
        private MutableLiveData<String> mNameEvent = new MutableLiveData<>();
    
        public MutableLiveData<String> getNameEvent() {
            return mNameEvent;
        }
    
    }
    

    接着,我们在 Activity 中创建 ViewModel,并监听 ViewModel 里面 mNameEvent 数据的变化,当数据改变的时候,我们打印相应的 log,并设置给 textView,显示在界面上。这样我们就完成了对 mNameEvent 数据源的观察。

    mTestViewModel = ViewModelProviders.of(this).get(TestViewModel.class);
    MutableLiveData<String> nameEvent = mTestViewModel.getNameEvent();
    nameEvent.observe(this, new Observer<String>() {
        @Override
        public void onChanged(@Nullable String s) {
            Log.i(TAG, "onChanged: s = " + s);
            mTvName.setText(s);
        }
    });
    

    最后当我们数据源改变的时候,我们需要调用 livedata 的 setValue 或者 postvalue 方法。他们之间的区别是, 调用 setValue 方法,Observer 的 onChanged 方法会在调用 serValue 方法的线程回调。而
    postvalue 方法,Observer 的 onChanged 方法将会在主线程回调。

    mTestViewModel.getNameEvent().setValue(name);
    

    可能部分同学有这样的疑问了,我们的 ViewModel 是通过 ViewModelProviders.of(this).get(TestViewModel.class); 方法创建出来的,如果我们要携带参数,怎么办?

    其实,官方也替我们考虑好了,同样是调用 ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) 方法,只不过,需要多传递一个 factory 参数。

    Factory 是一个接口,它只有一个 create 方法。

    public interface Factory {
        /**
         * Creates a new instance of the given {@code Class}.
         * <p>
         *
         * @param modelClass a {@code Class} whose instance is requested
         * @param <T>        The type parameter for the ViewModel.
         * @return a newly created ViewModel
         */
        @NonNull
        <T extends ViewModel> T create(@NonNull Class<T> modelClass);
    }
    

    在实际当中,我们的做法是:实现 Factory 接口,重写 create 方法,在create 方法里面调用相应的构造函数,返回相应的实例。

    public class TestViewModel extends ViewModel {
    
        private final String mKey;
        private MutableLiveData<String> mNameEvent = new MutableLiveData<>();
    
        public MutableLiveData<String> getNameEvent() {
            return mNameEvent;
        }
    
        public TestViewModel(String key) {
            mKey = key;
        }
    
        public static class Factory implements ViewModelProvider.Factory {
            private String mKey;
    
            public Factory(String key) {
                mKey = key;
            }
    
            @Override
            public <T extends ViewModel> T create(Class<T> modelClass) {
                return (T) new TestViewModel(mKey);
            }
        }
    
        public String getKey() {
            return mKey;
        }
    }
    

    ViewModelProviders.of(this, new TestViewModel.Factory(mkey)).get(TestViewModel.class)


    自定义 Livedata

    Livedata 主要有几个方法

    1. observe
    2. onActive
    3. onInactive
    4. observeForever

    void observe (LifecycleOwner owner, Observer observer)

    Adds the given observer to the observers list within the lifespan of the given owner. The events are dispatched on the main thread. If LiveData already has data set, it will be delivered to the observer.

    void onActive ()

    Called when the number of active observers change to 1 from 0.
    This callback can be used to know that this LiveData is being used thus should be kept up to date.

    当回调该方法的时候,表示该 liveData 正在背使用,因此应该保持最新

    void onInactive ()

    Called when the number of active observers change from 1 to 0.
    This does not mean that there are no observers left, there may still be observers but their lifecycle states aren’t STARTED or RESUMED (like an Activity in the back stack).
    You can check if there are observers via hasObservers().

    当该方法回调时,表示他所有的 obervers 没有一个状态处理 STARTED 或者 RESUMED,注意,这不代表没有 observers。

    Void observeForever

    跟 observe 方法不太一样的是,它在 Activity 处于 onPause ,onStop, onDestroy 的时候,都可以回调 obsever 的 onChange 方法,但是有一点需要注意的是,我们必须手动 remove obsever,否则会发生内存泄漏。

    这里我们以观察网络状态变化为例子讲解

    1. 首先我们自定义一个 Class NetworkLiveData,继承 LiveData,重写它的 onActive 方法和 onInactive 方法
    2. 在 onActive 方法中,我们注册监听网络变化的广播,即ConnectivityManager.CONNECTIVITY_ACTION。在 onInactive 方法的时候,我们注销广播。
    public class NetworkLiveData extends LiveData<NetworkInfo> {
    
        private final Context mContext;
        static NetworkLiveData mNetworkLiveData;
        private NetworkReceiver mNetworkReceiver;
        private final IntentFilter mIntentFilter;
    
        private static final String TAG = "NetworkLiveData";
    
        public NetworkLiveData(Context context) {
            mContext = context.getApplicationContext();
            mNetworkReceiver = new NetworkReceiver();
            mIntentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
        }
    
        public static NetworkLiveData getInstance(Context context) {
            if (mNetworkLiveData == null) {
                mNetworkLiveData = new NetworkLiveData(context);
            }
            return mNetworkLiveData;
        }
    
        @Override
        protected void onActive() {
            super.onActive();
            Log.d(TAG, "onActive:");
            mContext.registerReceiver(mNetworkReceiver, mIntentFilter);
        }
    
        @Override
        protected void onInactive() {
            super.onInactive();
            Log.d(TAG, "onInactive: ");
            mContext.unregisterReceiver(mNetworkReceiver);
        }
    
        private static class NetworkReceiver extends BroadcastReceiver {
    
            @Override
            public void onReceive(Context context, Intent intent) {
                ConnectivityManager manager = (ConnectivityManager) context
                        .getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
                getInstance(context).setValue(activeNetwork);
    
            }
        }
    }
    

    这样,当我们想监听网络变化的时候,我们只需要调用相应的 observe 方法即可,方便又快捷。

    NetworkLiveData.getInstance(this).observe(this, new Observer<NetworkInfo>() {
        @Override
        public void onChanged(@Nullable NetworkInfo networkInfo) {
            Log.d(TAG, "onChanged: networkInfo=" +networkInfo);
        }
    });
    
    

    https://www.jianshu.com/p/4b7945475a6f

    共享数据

    Fragment Activity 之间共享数据

    我们回过头来再来看一下 ViewModelProvider 的 of 方法,他主要有四个方法,分别是

    1. ViewModelProvider of(@NonNull Fragment fragment)
    2. ViewModelProvider of(@NonNull FragmentActivity activity)
    3. ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory)
    4. ViewModelProvider of(@NonNull FragmentActivity activity, @Nullable Factory factory)

    1,2 方法之间的主要区别是传入 Fragment 或者 FragmentActivity。而我们知道,通过 ViewModel of 方法创建的 ViewModel 实例, 对于同一个 fragment 或者 fragmentActivity 实例,ViewModel 实例是相同的,因而我们可以利用该特点,在 Fragment 中创建 ViewModel 的时候,传入的是 Fragment 所依附的 Activity。因而他们的 ViewModel 实例是相同的,从而可以做到共享数据。

    
    // LiveDataSampleActivity(TestFragment 依赖的 Activity)
    mTestViewModel = ViewModelProviders.of(this, new TestViewModel.Factory(mkey)).get(TestViewModel.class);
    MutableLiveData<String> nameEvent = mTestViewModel.getNameEvent();
    nameEvent.observe(this, new Observer<String>() {
        @Override
        public void onChanged(@Nullable String s) {
            Log.i(TAG, "onChanged: s = " + s);
            mTvName.setText(s);
        }
    });
    
    
    // TestFragment 中
    mViewModel = ViewModelProviders.of(mActivity).get(TestViewModel.class);
    mViewModel.getNameEvent().observe(this, new Observer<String>() {
        @Override
        public void onChanged(@Nullable String s) {
            Log.d(TAG, "onChanged: s =" + s + " mViewModel.getKey() =" + mViewModel.getKey());
            mTvName.setText(s);
            boolean result = mViewModel == ((LiveDataSampleActivity) mListener).mTestViewModel;
            Log.d(TAG, "onChanged: s result =" + result);
        }
    });
    

    这样,LiveDataSampleActivity 和 TestFragment 中的 ViewModel 是同一个实例。即 Activity 和 Fragment 共享数据。

    全局共享数据

    说到全局共享数据,我们想一下我们的应用全景,比如说我的账户数据,这个对于整个 App 来说,肯定是全局共享的。有时候,当我们的数据变化的时候,我们需要通知我们相应的界面,刷新 UI。如果用传统的方式来实现,那么我们一般才采取观察者的方式来实现,这样,当我们需要观察数据的时候,我们需要添加 observer,在界面销毁的时候,我们需要移除 observer。

    但是,如果我们用 LiveData 来实现的话,它内部逻辑都帮我们封装好了,我们只需要保证 AccountLiveData 是单例的就ok,在需要观察的地方调用 observer 方法即可。也不需要手动移除 observer,不会发生内存泄漏,方便快捷。

    这里 AccountLiveData 的实现就不贴出来了,可以参考上面的 NetworkLiveData 实现


    小结

    这里说一点关于 LiveData 与 ViewModel 的应用场景吧,我尽量说得通俗一点,不要说得那么官方,这样对新手很难理解。觉得不错的,请点个赞,让我们看到你们的欢呼声。你们的支持就是我写作的最大动力。

    1. LiveData 内部已经实现了观察者模式,如果你的数据要同时通知几个界面,可以采取这种方式
    2. 我们知道 LiveData 数据变化的时候,会回调 Observer 的 onChange 方法,但是回调的前提是 lifecycleOwner(即所依附的 Activity 或者 Fragment) 处于 started 或者 resumed 状态,它才会回调,否则,必须等到 lifecycleOwner 切换到前台的时候,才回调。因此,这对性能方面确实是一个不小的提升。但是,对于你想做一些类似与在后台工作的(黑科技), liveData 就不太适合了,你可以使用 observeForever 方法,或者自己实现观察者模式去吧。

    Lifecycle,LiveData, ViewModel 的基本使用到此已经讲解完毕,想了解他们的实现原理的话可以阅读这两篇文章。

    Android lifecyle 源码解剖

    Android livedata 源码解剖

    github sample 地址: ArchiteComponentsSample

    展开全文
  • LiveData实现新的事件总线

    万次阅读 2019-05-22 10:59:16
    背景:在Android系统中,我们开发的时候不可避免的会用到消息传递,页面和组件之间都在进行消息传递,消息传递既可以用于Android四大组件之间的通信,也可用于主线程和子线程之间的通信。从一开始Android书本中学习...

    背景:在Android系统中,我们开发的时候不可避免的会用到消息传递,页面和组件之间都在进行消息传递,消息传递既可以用于Android四大组件之间的通信,也可用于主线程和子线程之间的通信。从一开始Android书本中学习的Handler、BroadcastReceiver、接口回调等方式,到我们现在广为使用到的greenrobot家的EventBus,Square家的Otto,还有依托响应式编程代表RxJava实现的RxBus,最近在浏览美团技术博客时发现@liaohailiang基于Android Architecture Components实现了一个名为LiveEventBus的新的事件总线,依靠LiveData这个类可以实现一个无须手动解除注册,无内存泄漏问题的事件总线,下面一起来了解一下。

    一、从其他的事件总线说起

    1.EventBus

    EventBus是Android和Java的发布/订阅事件总线。在它出现之前,我们往往使用Handler、Intent、BroadcastReceiver等方式进行数据传递,但这些都不能满足我们高效的开发。自从EventBus出现后,简化了组件之间都通信,将事件发送者和接收者隔离,在Activity和Fragment还有后台线程中表现良好,避免了复杂而且容易出错的依赖关系和生命周期问题,立马受到开发者的欢迎,它的思想就是消息的发布和订阅,这种思想在很多其他框架中都有体现。
    在这里插入图片描述
    从图中可以看出订阅发布模式是一种一对多的关系,同一个事件可以被多个订阅者接收,当发布者的状态发生变化时,订阅者都能收到通知进行数据更新。

    2.RxBus

    RxBus 名字看起来像一个库,但它并不是一个库,而是一种模式,它的思想是使用RxJava来实现了EventBus,而让你不再需要使用Otto或者GreenRobot的EventBus。RxBus就是基于RxJava封装实现的类。随着RxJava在更多Android项目中的使用, 我们完全可以使用RxBus代替EventBus,减少库的引入,增加系统的稳定性。

    EventBus虽然使用方便,但是在事件的生命周期的处理上需要我们利用订阅者的生命周期去注册和取消注册,这个部分还是略有麻烦之处,如果忘记了在生命周期结束回调中取消订阅,就会导致内存泄漏的问题,而我们可以结合使用RxLifecycle来配置,简化这一步骤。

    RxBus的实现

    在RxJava中有个Subject类,它继承Observable类,同时实现了Observer接口,因此Subject既可以作为被观察者发送事件,也可以作为观察者接收事件,而RxJava内部的响应式的支持实现了事件总线的功能。可以使用PublishSubject.create().toSerialized();生成一个Subject对象。

    剩下的动作和EventBus一样了,在需要发消息的地方发送事件,那么订阅了该Subject对象的订阅者就会收到事件进行处理。

    最后当页面finish的时候,如果没有取消订阅,就会和EventBus一样,导致Activity或Fragment无法回收引发内存泄漏,EventBus要求我们在页面结束时取消注册,所以RxBus也需要如此。在RxJava中,订阅操作会返回一个Subscription对象,以便在合适的时机取消订阅,防止内存泄漏,如果一个类产生多个Subscription对象,我们可以用一个CompositeSubscription存储起来,以进行批量的取消订阅。

    网上RxBus有很多实现,例如AndroidKnife/RxBus,大家可以点击查看。

    3.otto

    otto是square推出的一款应用在android上的轻量级事件总线框架,目的是为了解决消息通信的问题,通过反射帮助你在不持有对方引用的情况下通知到对方,缓解了移动开发中会遇到的耦合问题。

    那么它有什么不足呢?
    1.在注册的时候,因为otto要用反射遍历Object的所有方法,所以时间会拉长,对性能会有一定的影响,如果你的项目对性能要求并不那么高,那完全可以使用otto来减少代码量。
    2.从源码里看,在基类中注册事件是一件比较麻烦的事情。
    3.订阅事件的参数问题,otto只允许接收一个参数,不然会抛出RuntimeException。
    4.项目通信场景较多而且复杂的时候,otto框架的拓展性就显得不够友好了。

    目前,Square推荐使用RxJava实现RxBus方式来代替Otto,也就是说otto被square公司抛弃了。

    4.小结

    名称 订阅函数是否可执行在其他线程 特点
    greenrobot的EventBus 拓展能力和使用场景丰富,但订阅函数必须以onEvent开头,效率高
    square的otto 使用注解,使用方便,但是效率比不上EventBus和RxBus
    RxBus 一个类文件,体积小,很容易处理线程切换,效率高

    二、LiveData基础

    1.什么是LiveData?

    LiveData是Android Architecture Components提出的框架,LiveData是一个可以在给定生命周期内被观察的数据持有者类,它可以感知并遵循Activity、Fragment或Service等组件的生命周期。正是由于LiveData对组件生命周期可感知特点,因此可以做到仅在组件处于生命周期的激活状态时才更新UI数据。如果观察者对应的生命周期变成了destroyed状态时,它会被自动的移除,这对Activity和Fragment来说是非常有用的,它们可以很安全的观察LiveData而不用担心泄漏问题,它们被销毁后将立即取消订阅。

    2.两种注册监听方式

    • 1.observe模式
      拥有生命周期,在started和resumed时触发回调,更新数据,无需手动解除注册,无内存泄漏问题。

    • 2.observeForever模式
      一直监听,没有生命周期,跟EventBus和RxBus一样,需要手动解除注册,否则有内存泄漏问题。

    3.LiveData的优点

    • 1.保证数据和UI的统一
      因为LiveData采用了观察者模式,LiveData是被观察者,当数据改变时通知观察者(UI)及时更新。当组件从后台到前台来时,LiveData也能将最新数据通知组件进行更新。

    • 2.避免内存泄漏
      因为LiveData能够监听生命周期的变化,当生命周期变化为DESTROYED时,就会清除观察者对象,不仅可以编写更少的代码,而且可以避免其他事件总线忘记调用反注册带来的内存泄漏风险。

    • 3.页面不可见时不会崩溃
      因为只有当生命周期是STARTED或RESUMED时,LiveData才会通知数据变化,所以不用担心页面不可见时收到通知刷新数据导致的崩溃。

    • 4.不需要额外处理响应生命周期变化
      这一点还是因为LiveData能感知组件的生命周期,所以不需要我们告诉它生命周期状态。

    • 5.解决configuration changed问题
      当组件被recreate时,数据还是存在LiveData中,所以在屏幕发生旋转或者被回收再次启动,立刻就能收到最新的数据。

    4.为什么用LiveData实现的事件总线能替代EventBus、RxBus和otto

    • 1.减少apk包大小
      因为只依赖Android官方的Android Architecture Components组件的LiveData,没有其他依赖,实现只有一个类。而EventBus jar包大小为57kb,RxBus依赖RxJava和RxAndroid,其中RxJava2包大小2.2MB,RxJava1包大小1.1MB,RxAndroid包大小9kb,otto就不说了,因为Square推荐使用RxJava实现RxBus方式来代替Otto[捂脸]。

    • 2.依赖方支持更好
      LiveEventBus只依赖Android官方Android Architecture Components组件的LiveData,相比RxBus依赖的RxJava和RxAndroid,依赖方支持更好。

    三、LiveData代码实现

    1.MutableLiveData

    MutableLiveData是LiveData的子类,其中只重写了两个方法,代码如下:
    在这里插入图片描述一个是postValue(T value),一个是setValue(T value),具体区别就是后台线程/主线程的调用,后面看代码继续了解。

    2.LiveData

    先看看LiveData的声明:
    在这里插入图片描述它是一个抽象类,所以才有了MutableLiveData这个实现类。
    接下来我们先从setValue入手看看LiveData的源码。

    2.1 setValue(T value)
    在这里插入图片描述从注释中知道,如果有处于活跃状态的观察者,value将会通知到它们,setValue方法必须在UI线程中调用,并且指出,如果需要从后台线程使用的话,可以使用postValue方法。

    其中assertMainThread方法实际上是判断是否是主线程,不是则会抛出异常:
    在这里插入图片描述
    mVersion初始值为-1,这里就会变成0;
    主要看看dispatchingValue(null);方法:
    在这里插入图片描述
    参数initiator为null,会走到红框中,接着看:
    在这里插入图片描述
    mLastVersion是在ObserverWrapper这个类中定义的,初始值为-1,在setValue的时候mVersion已经变成了0,所以红框中的逻辑不会进入,接着往下走,observer就会通过onChanged回调方法将我们设置的值通知给订阅者。

    2.2 postValue(T value)
    在这里插入图片描述
    从注释知道该方法是供后台线程使用的,并且多次赋值的话以最后一次赋值为准,来看看红框里的代码:
    在这里插入图片描述
    代码里最终还是调用了setValue方法,回到了setValue的逻辑,只是帮我们处理了后台线程到主线程的切换工作。

    赋值部分看完了,现在该看看注册订阅的代码了。

    2.3 observe(@NonNull LifecycleOwner owner, @NonNull Observer observer)
    在这里插入图片描述
    从注释中得知,订阅事件在主线程上调度,如果LiveData已经有了数据集,它将被传递给观察者。只有所有者处于Link Lifecycle.State Started或Resumed状态时,观察者才会接收事件,如果所有者移动到Link Lifecycle.State Destroyed状态,则观察者将被自动删除。当数据在owner不处于活动状态,它将不会接收任何更新,如果它再次处于活动状态,它将自动接收最后一个可用数据。只要给定的生命周期所有者没有destroy,LiveData将保持对观察者和所有者的强引用,当它被销毁时,LiveData将删除对观察者和所有者的引用。
    在这里插入图片描述
    LifecycleBoundObserver实现了GenericLifecycleObserver,在生命周期发生改变时会回调onStateChanged方法,如果Activity/Fragment对生命周期时destroyed的时候,就会触发removeObserver(mObserver)操作,否则就会执行activeStateChanged(shouldBeActive())方法。

    activeStageChanged(shouldBeActive())是父类ObserverWrapper中定义的方法:
    在这里插入图片描述
    当生命周期处于STARTED或RESUMED时,就会执行红框中的逻辑,其实咱们上面已经看过了dispatchingValue方法,再来看一次:
    在这里插入图片描述在这里插入图片描述
    到这里就出现了一个问题
    如果之前有调用过setValue方法的话,这里mVersion++每次会自增,所以肯定是>-1的,而observer中定义的mLastVersion初始值是-1,所以红框中的逻辑不会执行,代码往下执行走到observer.mObserver.onChanged((T) mData);这样就会导致LiveData每注册一个新的订阅者,这个订阅者立刻会收到一个回调得到之前发布的消息,即使这个设置的动作发生在订阅之前

    如何解决这个问题?
    由于是因为ObserverWrapper的mLastVersion和LiveData的mVersion不同步的问题导致的,所以可以通过继承MutableLiveData然后重写observe方法,LiveData提供getVersion()方法返回mVersion,我们只需把ObserverWrapper的mLastVersion设成mVersion就好了。
    @liaohailiang在github上开源的LiveEventBus就是这么干的:
    在这里插入图片描述
    这样就能保证新注册的订阅者在初始
    if (observer.mLastVersion >= mVersion) { return; }
    执行这个方法时就return了,只有当它setValue或postValue赋值后,才会执行通知逻辑。

    2.4 public void observeForever(@NonNull Observer observer)
    接着看看注册永久观察者方法里做了什么操作:
    在这里插入图片描述
    首先用了一个AlwaysActiveObserver类:
    在这里插入图片描述
    这个类的shouldBeActive方法return true;这个状态表明不受生命周期的影响了。
    另外wrapper.activeStateChanged(true);也是传入了一个true,所以在
    在这里插入图片描述
    considerNotify(ObserverWrapper observer)中,订阅者永远会接收到最新的发布消息。

    2.5 removeObserver(@NonNull final Observer observer)
    在LifecycleBoundObserver中,由于实现了GenericLifecycleObserver,所以当订阅者通过observe方式订阅的时候,当生命周期发生变化时会回调该方法:
    在这里插入图片描述
    当监听到页面当生命周期为DESTROYED会通知移除对应的观察者:
    在这里插入图片描述
    从mObservers列表中移除生命周期所有者对应的观察者,解除绑定观察者,通知状态变化。
    在这里插入图片描述
    Activity或Fragment则会移除观察者对象。
    需要注意的是这对observeForever方式注册的观察者并不生效。

    四、总结

    Android官方提供了Android Architecture Components组件的LiveData,具有很多其他事件总线不具备的优点,能方便的感知到页面的生命周期变化从而进行数据通知,我们也能基于这个类自己实现出一套性能优异的事件总线,这里推荐一个@liaohailiang在GitHub开源的项目代码:LiveEventBus,工程包含了其他的示例代码的使用本文没有做演示,只是对LiveData的核心原理做一个剖析,感兴趣的同学可以自行查阅代码。

    展开全文
  • 分享一个我开发的MVVM架构的开源小项目

    万次阅读 多人点赞 2019-03-01 07:56:31
    大家好,今天跟大家分享一个我编写的MVVM架构的开源小项目。话说这个小项目已经提前跟大家预热很久了,也是被不少朋友催了很多次。我之前在公众号里透漏过这个项目能够帮助大家更好地理解MVVM架构,当然我也希望确实...
  • LiveData 机制详解

    2020-08-06 11:28:45
    一.粘性消息机制 首先展示一个最简单能体现粘性消息的例子
  • LiveData使用详解

    2019-09-05 14:22:47
    LiveData使用之前我们需要导入一个第三方库 此处存在一个坑我们需要在项目的builder.gradle中添加 allprojects { repositories { google() jcenter() maven { url "https://jitpack.io" }//此处为添加 } } 不...
  • LiveData详细分析

    2020-03-05 20:17:16
    01.LiveData是什么东西 02.使用LiveData的优势 03.使用LiveData的步骤 04.简单使用LiveData 05.observe()和observerForever() 06.LiveData原理介绍 07.observe订阅源码分析 08.setValue发送源码分析 09....
  • LiveData的简单使用

    2019-12-11 14:55:50
    简介:LiveData是一个能够被观察的并持有数据的类,与其他的常规的可观察者不同,它关心组件的生命周期,意味着它尊重Activity、Fragment和Service的生命周期,这能够确保仅仅更新处于Start和Resume(生命活动周期)...
  • 一、LiveData简介 LiveData是google官方架构JetPack系列的一个响应式开发框架,LiveData是一个可以被观察的数据持有者类。说到响应式开发或者说观察者就不免想到RxJava,RxJava将观察者模式运用的炉火纯青。但...
  • Android LiveData我的理解

    千次阅读 2019-07-28 03:30:06
    LiveData用大众语言来来讲,是一个观察者,也是一个数据持有类或者可以称为一个数据的包裹类。它有别于其他的观察者的重点是,他具有生命周期感知能力,这里生命周期指的是activities, fragments, or services 的...
  • LiveData使用

    2020-04-18 15:57:00
    一、什么是LiveDataLiveData 是可观察的数据持有者类。与常规的可观察对象不同,LiveData具有生命周期感知功能,这意味着它尊重其他应用程序组件(例如活动,片段或服务)的生命周期。这种意识确保LiveData仅更新...
  • LiveData

    2019-06-06 14:44:46
    LiveData 是一个数据持有者类,它持有一个值并允许观察该值。不同于普通的可观察者,LiveData 遵守应用程序组件的生命周期,以便 Observer 可以指定一个其应该遵守的 Lifecycle。 如果 Observer 的 Lifecycle 处于 ...
  • LiveData

    2020-10-05 15:40:24
  • LiveData

    2017-08-01 16:13:36
    LiveData变换 MediatorLiveData LiveData是用来持有数据方便观测的,类似一个Observable。与一般的Observable不一样的地方在于,LiveData考虑到了app组件的生命周期。 基本使用 自定义类继承LiveData,指定...
  • Lifecycle LiveData LiveData LiveData

    千次阅读 2018-05-13 12:40:28
    Android 架构组件(一)——Lifecycle-Aware Components有一天“谷歌开发者”官微推送了《正式发布 Android 架构组件 1.0 稳定版 | 附带中文介绍视频》,发现这种架构足够秒杀MVP、MVVM,虽然之前的Google I/O大会中...
  • LiveData

    2019-10-27 18:01:35
    Livedata的几种形式及使用,Livedata缓存导致的一些问题和解决
  • LiveData

    2020-05-22 16:15:47
    1. 什么是LiveData ? 数据本身可以被观察者订阅 能够感知组件(Fragment,Activity,Service)的生命周期(基于Lifecycle) 只有在组件处于激活状态(STARTED,RESUMED)才会通知观察者更新数据 当数据变化的时候...
  • LiveData

    2020-01-14 15:07:53
    LiveData是什么? 具有生命周期感知的、可观察的数据持有者 基本使用 MutableLiveData<String> mutableLiveData = new MutableLiveData<>(); mutableLiveData.observe(this, new Observer<...
  • Android livedata 源码解剖

    千次阅读 2019-01-26 20:35:26
    在前面三篇博客中,我们已经介绍了 lifecycle 的使用及原理,livedata ,ViewModel 的常用用法,今天,让我们一起来学习 livedata 的原理。 我们先来回顾一下: LiveData 是一个可以被观察的数据持有类,它可以感知...

空空如也

1 2 3 4 5 ... 20
收藏数 6,054
精华内容 2,421
关键字:

livedata