lbForce
lbForce

MVVM-live

MVVM-live

Google的项目： https://github.com/googlesamples/android-architecture/tree/master 之 todo‑mvvm

官方解释：

Uses ViewModels and LiveData from Architecture Components and the Data Binding library with an MVVM architecture.

This version of the app is called todo-mvvm-live, and it uses some Architecture Components like ViewModel, LiveData, and other lifecycle-aware classes. It's based on the todo-mvvm-databinding sample, which uses the Data Binding Library to display data and bind UI elements to actions.

总结：MVVM就包含了ViewModels及Data Binding，所以mvvm‑live = mvvm + LiveData

需要了解的概念有 Lifecycle-aware组件、MVVM、LiveData、ViewModel、Data binding library。

以下是翻译Google的文档 + 源码解释。

Lifecycle-aware组件

lifecycle-aware组件能够对其他组件（比如activity和fragment）发生生命周期改变时做出反应，这样的组件显然很容易使用，轻量且易维护。

举个例子：在UI上显示定位信息

传统做法是：

定义获取位置的接口：
public class MyLocationListener {
    public MyLocationListener(Context context, LocCallback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }

    public interface LocCallback {
        void loc(long lat, long lag);
    }
}

在activity里显示位置信息，并在生命周期里控制接口：
public class MyActivity extends AppCompatActivity {

    MyLocationListener myLocationListener;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

        myLocationListener = new MyLocationListener(this, new MyLocationListener.LocCallback() {
            @Override
            public void loc(long lat, long lag) {
                // update ui
            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();
        myLocationListener.start();
    }

    @Override
    protected void onStop() {
        super.onStop();
        myLocationListener.stop();
    }
}

这么做的问题：

  1. 需要在生命周期方法里正确去回调接口方法，如果没有正确回调有可能导致内存泄漏。
  2. 并且可能在生命周期方法里有很多类似调用，导致代码很难维护，丑陋。
  3. 甚至有可能myLocationListener.stop()在start()之后调用，导致myLocationListener周期异常，例如：
@Override
protected void onStart() {
    super.onStart();
    Util.checkUserStatus(result -> {
        // what if this callback is invoked AFTER activity is stopped?
        if (result) {
            myLocationListener.start();
        }
    });
}
    
    @Override
    protected void onStop() {
        super.onStop();
        myLocationListener.stop();
    }

android.arch.lifecycle组件包能帮助避免这些问题。

下面详细介绍。

Lifecycle

Lifecycle是一个类维护了组件（像activity或fragment）的生命周期信息，并且允许这些信息被观察者获取。内部使用2个enum类Event和State来跟踪与之关联的组件状态：

Event ：从关联的组件（activities 或 fragments）里发送过来的，表明组件已经到了哪个生命周期了（如ON_CREATE、ON_START等）

State ：Lifecycle对象跟踪的关联组件的状态。

官方event与state关系图

lifecycle_frag_activity图

定义可以观察组件生命周期的observer，用annotation方式：

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void connectListener() {
        //...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void disconnectListener() {
        //...
    }
}

在外部通过myLifecycleOwner.getLifecycle().addObserver(new MyObserver()) 让MyObserver观察组件的生命周期。

那什么是LifecycleOwner？

LifecycleOwner

定义：

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

只是一个接口，表明实现者有Lifecycle。v4包里的fragemnt和activity都实现了这个，也可以实现自己的LifecycleOwner。
前面显示定位信息的例子可以改为：

public class MyLocationListener2 implements LifecycleObserver {
    private boolean enabled = false;
    private Lifecycle lifecycle;
    private WeakReference callbackWeakReference;  // 弱引用

    public MyLocationListener2(Context context, Lifecycle lifecycle, LocCallback callback) {
       // ...
       callbackWeakReference = new WeakReference(callback);
    }

    public void enable() {  // 提供enable方法，更安全
        enabled = true;
        if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
            // connect if not connected
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void start() {
        if (enabled) {
            // connect
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void stop() {
        // disconnect if connected
    }

    public interface LocCallback {
        void onLoc(long lat, long lag);
    }
}

public class MyActivity2 extends AppCompatActivity {

    MyLocationListener2 myLocationListener;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

        myLocationListener = new MyLocationListener2(this, getLifecycle(), new MyLocationListener2.LocCallback() {
            @Override
            public void onLoc(long lat, long lag) {
                // update ui
            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();
        Util.checkUserStatus(result -> {
            if (result) {
                myLocationListener.enable();
            }
        });
    }
}

这个MyLocationListener2就是一个lifecycle-aware的组件。

这么做的好处是：

  1. 让MyLocationListener2自己观察生命周期的变化，不需要外部组件回调，外部组件需需要初始化它就好。
  2. 避免了潜在的泄漏问题
  3. MyLocationListener2非常独立，很好复用。

Google官方的建议：

If a library provides classes that need to work with the Android lifecycle, we recommend that you use lifecycle-aware components. Your library clients can easily integrate those components without manual lifecycle management on the client side.

就是说如果你的library需要跟生命周期有关系，那就实现成lifecycle-aware的组件，这样外部就很容易集成而不用管理它的生命周期。

自定义LifecycleOwner

V4包的Support Library 26.1.0版本及以上的Fragment与Activitie已经实现了LifecycleOwner，也可以自己实现，同样借助LifecycleRegistry。

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

MVVM

维基百科的解释： mvvm

关键点：

  • Model 代表domain model或者数据访问层。
  • View 代表用户在界面上能看到的UI，如layout，fragment，各种组件。（我认为activity也是，在MVVM框架里，activity被弱化了，只作为view的承载着和生命周期的体现者）。
  • View model 是view的抽象，暴露公开的属性和命令。MVVM有binder。在view model里，binder协调着view和data binder，view model可以被看成是model层数据的一种状态。
  • Binder 把view model里的数据绑定到view上的库。

LiveData

参考google官方解释： architecture-livedata
源码里LiveData的解释很棒！

其实LiveData就是lifecycle-aware组件的增强版，其内部实现了LifecycleObserver。（LifecycleBoundObserver实现的）

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer observer) {
        ... ...
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ... ...
        owner.getLifecycle().addObserver(wrapper);
    }

关键点：

  • 是可被观察的data holder
  • 是lifecycle-aware的，就是说它可感知组件（如activities, fragments, services）的生命周期。并且它只更新处于active状态的观察者组件。
  • active状态是指生命周期处于 STARTED 或者 RESUMED 状态，LiveData只通知active的观察者，非active的观察者得不到通知。
  • STARTED的解释，RESUMED的解释

优点：

  • 确保UI跟数据状态匹配

LiveData notifies Observer objects when the lifecycle state changes. You can consolidate your code to update the UI in these Observer objects。LiveData notifies Observer objects when the lifecycle state changes.

  • 没有内存泄漏

Observers are bound to Lifecycle objects and clean up after themselves when their associated lifecycle is destroyed.

  • 不会因为activity stop掉而crash

If the observer's lifecycle is inactive, such as in the case of an activity in the back stack, then it doesn’t receive any LiveData events.

  • 自动处理由于生命周期改变的影响

UI components just observe relevant data and don’t stop or resume observation. LiveData automatically manages all of this since it’s aware of the relevant lifecycle status changes while observing.

  • 在active时，observer总是收到最新的数据

If a lifecycle becomes inactive, it receives the latest data upon becoming active again. For example, an activity that was in the background receives the latest data right after it returns to the foreground.

  • 对configuration change的处理

If an activity or fragment is recreated due to a configuration change, like device rotation, it immediately receives the latest available data.

  • 在app内共享资源

You can extend a LiveData object using the singleton pattern to wrap system services so that they can be shared in your app. The LiveData object connects to the system service once, and then any observer that needs the resource can just watch the LiveData object. For more information, see Extend LiveData 。通过下面的ViewModel也可以做到。

怎么使用LiveData：

  1. 在ViewModel里创建LiveData
public class NameViewModel extends AndroidViewModel {

    // Create a LiveData with a String
    private MutableLiveData curName; // LiveData是data的封装，LiveData通常是放在ViewModel里，通过getter被获取

    public NameViewModel(@NonNull Application application) {
        super(application);
    }

    public MutableLiveData getCurName() {
        if (curName == null) {
            curName = new MutableLiveData();
        }
        return curName;
    }

    public void requestFromServer(String params) {
        // make the request

        // set the response data
        curName.setValue("LiBo");// setValue()需要再主线程调用
//        curName.postValue("liBo");// postValue()可以在子线程调用
    }
}
  1. 在lifecycle owner的组件（比如activity、fragment）里observe live data
public class MvvmTestActivity extends AppCompatActivity {

    private TextView nameTv;

    private NameViewModel nameViewModel;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

        // Get the ViewModel.
        nameViewModel = ViewModelProviders.of(this).get(NameViewModel.class);

        // Create the observer which updates the UI.
        final Observer nameObserver = new Observer() {
            @Override
            public void onChanged(@Nullable String s) {
                // Update the UI
                nameTv.setText(s);
            }
        };

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        nameViewModel.getCurName().observe(this, nameObserver);// 第一个参数是 LifecycleOwner对象
//        nameViewModel.getCurName().observeForever(nameObserver); // observer is considered to be always active and is therefore always notified about modifications
    }

}

需要明白的几点:

  • 在viewmodel里而不是fragment或activity管理livadata对象，因为（避免fragment或activitydiamante臃肿，避免congiguration change销毁livadata）。解释-1
  • 当更新LiveData里的value时，会触发所有活着的observer（其所关联的LifecycleOwner在active状态）。 解释-2
  • 如果observer从inactione变成active状态，也会受到推送的数据。 解释-3
  • 调用observe(this, nameObserver)就意味着nameObserver跟MvvmTestActivity这个lifecycle owner产生关联，其实是跟activity关联的lifecycle对象LifecycleRegistry关联的。当lifecycle对象不是active状态时，nameObserver 不会接收到更新，当lifecycle对象被销毁时，nameObserver自动从livedata里移除。

解释：

  • 1
    见下面 ' ViewModel为什么能够保活？'
  • 2
LiveData.java

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    mVersion++;   // 记录数据版本，很重要
    mData = value;
    dispatchingValue(null);  // 会调用 considerNotify()
}

private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }
        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
        //
        // we still first check observer.active to keep it as the entrance for events. So even if
        // the observer moved to an active state, if we've not received that event, we better not
        // notify for a more predictable notification order.
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false); 
            return;
        }
        // 如果observer接受的数据版本大于等于目前版本，就不用通知observer了。
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData); // 通知obserser
    }
  • 3
在LiveData.observe()里调用了owner.getLifecycle().addObserver(wrapper) 把obserser关联到了owner的lifecycle。
当owner即activity或fragment state状态发生改变时，会调用LifecycleRegistry.markState()或handleLifecycleEvent()，
再调用sync()，最后会遍历所有关联的observer，并调用其 onStateChanged()，

在LiveData.java
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
    if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
        removeObserver(mObserver);   // 如果lifecycle owner已经是DESTROYED状态，就移除该observer
        return;
    }
    activeStateChanged(shouldBeActive()); // 
}

void activeStateChanged(boolean newActive) {
    if (newActive == mActive) {
        return;
    }
    // immediately set active state, so we'd never dispatch anything to inactive owner
    mActive = newActive;
    boolean wasInactive = LiveData.this.mActiveCount == 0;
    LiveData.this.mActiveCount += mActive ? 1 : -1;  // mActiveCount记录活着的observer个数
    if (wasInactive && mActive) {
        onActive();
    }
    if (LiveData.this.mActiveCount == 0 && !mActive) {
        onInactive();
    }
    if (mActive) {
        dispatchingValue(this); // 上面解释过
    }
}

Transform LiveData

一些高级的用法，待更新

Merge multiple LiveData sources

一些高级的用法，待更新

ViewModel

参考官方 ViewModel
源码里ViewModel的解释很棒！

设计ViewModel的目的是存储及管理UI相关的数据同时关注其生命周期，能保证数据在configuration change（比如切屏）时存活，还有作为fragment，activity与其他的逻辑的通信桥梁。

考虑以下情况：

  • 当configuration change时，activity被销毁并重建，虽然可以通过onSaveInstanceState()保存数据，但是只可以保存少量的可序列化的数据；

  • 还有ui controller（activity、fragment等）需要管理一些异步调用并保证在适当时清理掉 以避免内存泄漏，这些管理工作很麻烦；

  • UI controller应该只是显示数据到UI、相应用户操作、处理系统的交互如处理permission请求。

使用ViewModel可以把数据及处理从Ui controller分离。

怎么使用ViewModel

继承ViewModel，ViewModel的对象可以在configuration change时自动保活，其保存的数据可以立即被下一个activity或fragment实例使用。
public class MyViewModel extends ViewModel {
    private MutableLiveData> users;
    public LiveData> getUsers() {
        if (users == null) {
            users = new MutableLiveData>();
            loadUsers();
        }
        return users;
    }

    private void loadUsers() {
        // Do an asynchronous operation to fetch users.
    }
}

class User {

}

注意：ViewModel一定不要引用一个view、lifecycle或任何会引用activity context的类。 ViewModel被设计用来独立与view或LifecycleOwner而保活数据的。ViewModel可以维护LifecycleObserver例如LiveData，但是不能observe lifecycle-aware的被观察者例如LiveData。如果需要application context，可以继承AndroidViewModel。

ViewModel的生命周期

ViewModel对象一直存活直到关联的lifecycle永远失效，例如 activity 被finish掉（注意不是onDestroy()被调用）或者fragment被detatched了。生命周期图
验证一下：

public class MainViewModel extends AndroidViewModel {
    private int count = 0; // 只是用于activity更新以在某时做finish操作

    public MainViewModel(@NonNull Application application) {
        super(application);
    }

    @Override
    protected void onCleared() {
        super.onCleared();
        Log.i("lbtest", "MainViewModel onCleared");
    }

    public void updateCount() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

private MainViewModel obtainViewModel() {
        MainViewModel vm = ViewModelProviders.of(this)
                .get(MainViewModel.class);
        return vm;
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i("lbtest", "onCreate this="+this+", vm="+obtainViewModel());
    }

    @Override
    public void onResume() {
        super.onResume();
        MainViewModel viewModel = obtainViewModel();
        Log.i("lbtest", "onResume this="+this+", vm="+viewModel);
        viewModel.updateCount();
        if (viewModel.getCount() == 2) {
            Log.i("lbtest", "onResume finish this="+this);
            finish();
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.i("lbtest", "onPause this="+this+", vm="+obtainViewModel());
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.i("lbtest", "onStop this="+this+", vm="+obtainViewModel());
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i("lbtest", "onDestroy this="+this/*+", vm="+obtainViewModel()*/);
    }

运行结果：

04-03 14:33:50.828 30546-30546/? I/lbtest: onCreate this=com.lb.legor.MainActivity@50deb83, vm=com.lb.legor.MainViewModel@e6d758a
04-03 14:33:50.832 30546-30546/? I/lbtest: onResume this=com.lb.legor.MainActivity@50deb83, vm=com.lb.legor.MainViewModel@e6d758a
// 切屏操作
04-03 14:33:57.558 30546-30546/com.lb.legor I/lbtest: onPause this=com.lb.legor.MainActivity@50deb83, vm=com.lb.legor.MainViewModel@e6d758a
04-03 14:33:57.560 30546-30546/com.lb.legor I/lbtest: onStop this=com.lb.legor.MainActivity@50deb83, vm=com.lb.legor.MainViewModel@e6d758a
04-03 14:33:57.560 30546-30546/com.lb.legor I/lbtest: onDestroy this=com.lb.legor.MainActivity@50deb83
// 新的activity对象创建了，viewmodel对象不变
04-03 14:33:57.577 30546-30546/com.lb.legor I/lbtest: onCreate this=com.lb.legor.MainActivity@390bb73, vm=com.lb.legor.MainViewModel@e6d758a
04-03 14:33:57.582 30546-30546/com.lb.legor I/lbtest: onResume this=com.lb.legor.MainActivity@390bb73, vm=com.lb.legor.MainViewModel@e6d758a
04-03 14:33:57.582 30546-30546/com.lb.legor I/lbtest: onResume finish this=com.lb.legor.MainActivity@390bb73 // 主动去finish()
04-03 14:33:57.589 30546-30546/com.lb.legor I/lbtest: onPause this=com.lb.legor.MainActivity@390bb73, vm=com.lb.legor.MainViewModel@e6d758a
04-03 14:33:57.658 30546-30546/com.lb.legor I/lbtest: onStop this=com.lb.legor.MainActivity@390bb73, vm=com.lb.legor.MainViewModel@e6d758a
04-03 14:33:57.658 30546-30546/com.lb.legor I/lbtest: MainViewModel onCleared // viewmodel对象被清
04-03 14:33:57.659 30546-30546/com.lb.legor I/lbtest: onDestroy this=com.lb.legor.MainActivity@390bb73
// 重新进入app，肯定都是新的对象
04-03 14:36:28.277 30546-30546/com.lb.legor I/lbtest: onCreate this=com.lb.legor.MainActivity@c0db1d, vm=com.lb.legor.MainViewModel@34e80ea
04-03 14:36:28.280 30546-30546/com.lb.legor I/lbtest: onResume this=com.lb.legor.MainActivity@c0db1d, vm=com.lb.legor.MainViewModel@34e80ea

在fragment间共享ViewModel：

public class SharedViewModel extends ViewModel {
    private final MutableLiveData selected = new MutableLiveData();

    public void select(Item item) {
        selected.setValue(item);
    }

    public LiveData getSelected() {
        return selected;
    }
}

public class MasterFragment extends Fragment {
    private SharedViewModel model;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

public class DetailFragment extends Fragment {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        model.getSelected().observe(this, { item ->
           // Update the UI.
        });
    }
}

注意，2个fragment里用getActivity()获取到相同的ViewModel对象。

这样共享ViewModel的好处是：

activity不需要知道fragment之间通信的细节，fragment之间也不需要知道对方，一个fragemnt的存活与否也不影响另一个fragment使用viewmodle。

原理分析

ViewModel架构图

ViewModel为什么能够保活？

ViewModelProviders.java:
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @NonNull Factory factory) {
        checkApplication(activity);
        return new ViewModelProvider(ViewModelStores.of(activity), factory);
    }
    
ViewModelStores.java:
    @MainThread
    public static ViewModelStore of(@NonNull FragmentActivity activity) {
        return holderFragmentFor(activity).getViewModelStore();
    }
    
HolderFragment.java:
    private ViewModelStore mViewModelStore = new ViewModelStore();
    public HolderFragment() {
        setRetainInstance(true); // Control whether a fragment instance is retained across
        // Activity re-creation (such as from a configuration change).
    }

    .HolderFragmentManager （内部类）:
            private ActivityLifecycleCallbacks mActivityCallbacks =
                new EmptyActivityLifecycleCallbacks() {
                    @Override
                    public void onActivityDestroyed(Activity activity) {
                        // activity被destroyed了才移除对应的fragment，所以其维护的mViewModelStore也没了。
                        HolderFragment fragment = mNotCommittedActivityHolders.remove(activity);
                        if (fragment != null) {
                            Log.e(LOG_TAG, "Failed to save a ViewModel for " + activity);
                        }
                    }
                };

        HolderFragment holderFragmentFor(FragmentActivity activity) {
            FragmentManager fm = activity.getSupportFragmentManager();
            HolderFragment holder = findHolderFragment(fm);
            if (holder != null) {
                return holder;
            }
            holder = mNotCommittedActivityHolders.get(activity);
            if (holder != null) {
                return holder;
            }

            if (!mActivityCallbacksIsAdded) {
                mActivityCallbacksIsAdded = true;
                activity.getApplication().registerActivityLifecycleCallbacks(mActivityCallbacks); // 观察activity的生命周期
            }
            holder = createHolderFragment(fm);
            mNotCommittedActivityHolders.put(activity, holder);
            return holder;
        }
    
        private static HolderFragment createHolderFragment(FragmentManager fragmentManager) {
            HolderFragment holder = new HolderFragment(); // 创建时会setRetainInstance(true)让该fragment保活。
            // 创建一个HolderFragment对象，add进activity或者fragment关联的FragmentManager，但不显示，没有UI。
            fragmentManager.beginTransaction().add(holder, HOLDER_TAG).commitAllowingStateLoss();
            return holder;
        }

ViewModelProvider of(@NonNull Fragment fragment)逻辑类似。

ViewModel为什么可以share?

因为通过ViewModelProvider of(FragmentActivity)获得的ViewModelProvider对象里是相同的ViewModelStore对象
从这个对象里用相同的key获取viewmodel就是一个model对象。

ViewModelProvider.java：
    public  T get(@NonNull String key, @NonNull Class modelClass) {
        ViewModel viewModel = mViewModelStore.get(key); // 

        if (modelClass.isInstance(viewModel)) {
            //noinspection unchecked
            return (T) viewModel;
        } else {
            //noinspection StatementWithEmptyBody
            if (viewModel != null) {
                // TODO: log a warning.
            }
        }

        viewModel = mFactory.create(modelClass);
        mViewModelStore.put(key, viewModel);
        //noinspection unchecked
        return (T) viewModel;
    }

AndroidViewModel 与ViewModel，该用哪个？
ViewModel是不支持任何context的，如果在ViewModel里需要使用context就用AndroidViewModel，因为可以通过getApplication()得到app context，也不会造成内存泄漏。

Data Binding Library

参考 官方解释

Data Binding Library具有高度可扩展性和易用性，是一个支持库，可以在Android 2.1 (API level 7+)以上使用。

优点：

  • 不用再findViewById()了，code也不会出现自动生成的控件标签
  • 可以自动绑定数据
  • 可以优雅的处理事件（如click或自定义方法等）
  • 更多高级用法，如表达式及转换等

使用之前在app module的build.gradle file 里添加

android {
    ....
    dataBinding {
        enabled = true
    }
}

Android Gradle Plugin 3.1.0 Canary 6使用了新的bindding编译器，在gradle.properties里添加
android.databinding.enableV2=true 就可以激活它。

使用data binding，首先从layout文件开始，在java文件里通过DataBinding实例或DataBindingUtil来inflate一个layout，之后就可以通过DataBinding实例来操作layout。

写个简单的demo演示下前2个优点，用mvvm-live模式，显示一个person的简单信息：

  1. 主layout：
  1. 主activity：
public class DataBindingActivity extends FragmentActivity {
    ActivityDatabindingBinding binding;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = DataBindingUtil.setContentView(this, R.layout.activity_databinding);
        observeData();
    }

    @Override
    protected void onResume() {
        super.onResume();
        obtainViewModel().requestAPerson();
    }

    private void observeData() {
        obtainViewModel().getPersonLiveData().observe(this, new Observer() {
            @Override
            public void onChanged(@Nullable Person person) {
                if (person == null) {
                    return;
                }
                binding.simpleTextView.textView.setText("A person's simple info:");
                binding.setPerson(person);
                binding.dataBindingLayout1.updateData(person.name);
                binding.dataBindingLayout2.updateData(person.basic);
                binding.recyclerView.setLayoutManager(new LinearLayoutManager(DataBindingActivity.this));
                binding.recyclerView.setAdapter(new CompanyAdapter(DataBindingActivity.this, person.companyList));
            }
        });
    }

    private DataBindingViewModel obtainViewModel() {
        return ViewModelProviders.of(this).get(DataBindingViewModel.class);
    }
}
  1. DataBindingLayout1类
public class DataBindingLayout1 extends LinearLayout {
    private LayoutDatabinding1Binding binding;

    public DataBindingLayout1(Context context) {
        this(context, null);
    }

    public DataBindingLayout1(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public DataBindingLayout1(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // 有2种写法，用编译生成的LayoutDatabinding1Binding或DataBindingUtil
        binding = LayoutDatabinding1Binding.inflate(LayoutInflater.from(context), this, true);
//        binding = DataBindingUtil.inflate(LayoutInflater.from(context), R.layout.layout_databinding_1, this, true);
    }

    public void updateData(Person.Name name) {
        binding.setName(name);
    }
}
  1. DataBindingLayout1类的layout：

DataBindingLayout2类似

  1. CompanyAdapter类：
public class CompanyAdapter extends RecyclerView.Adapter {

    private Context context;
    private List data;

    public CompanyAdapter(Context context, List data) {
        this.context = context;
        this.data = data;
    }

    @Override
    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        SimpleTextviewBinding binding = DataBindingUtil.inflate(LayoutInflater.from(context), R.layout.simple_textview,
                parent, false);
        return new MyViewHolder(binding.getRoot(), binding);
    }

    @Override
    public void onBindViewHolder(MyViewHolder holder, int position) {
        holder.binding.textView.setText(data.get(position).name);
    }

    @Override
    public int getItemCount() {
        return data.size();
    }

    static class MyViewHolder extends RecyclerView.ViewHolder {
        SimpleTextviewBinding binding;

        public MyViewHolder(View itemView, SimpleTextviewBinding binding) {
            super(itemView);
            this.binding = binding;
        }
    }
}
  1. DataBindingViewModel类：
public class DataBindingViewModel extends AndroidViewModel {
    private MutableLiveData personLiveData = new MutableLiveData<>();

    public DataBindingViewModel(@NonNull Application application) {
        super(application);
    }

    public void requestAPerson() {
        //...
        Person person = new Person();
        person.id = "340811199001011234";
        Person.Name name = new Person.Name();
        name.firstName = "Paul";
        name.lastName = "Li";
        person.name = name;
        Person.Basic basic = new Person.Basic();
        basic.age = 18;
        basic.sex = "Male";
        person.basic = basic;
        List companyList = new ArrayList<>();
        Person.Company company1 = new Person.Company();
        company1.name = "Rong";
        companyList.add(company1);
        Person.Company company2 = new Person.Company();
        company2.name = "Le";
        companyList.add(company2);
        Person.Company company3 = new Person.Company();
        company3.name = "Sony";
        companyList.add(company3);
        person.companyList = companyList;
        personLiveData.setValue(person);
    }

    public MutableLiveData getPersonLiveData() {
        return personLiveData;
    }
}

done，运行截图

借鉴 & 运用

你可能感兴趣的:(MVVM-live)

  • Android应用开发进阶，flutter页面跳转防止页面重复刷新 m0_64604842 程序员面试android移动开发
    第三章通过Google官方的架构示例项目To-Do，详细介绍了Android的应用架构，包括MVP，MVP-Clean，MVP-Dagger，MVP-RxJava，MVVM-DataBinding，MVVM-Live。第四章介绍了实战项目AndroidPlus，AndroidPlus是一个专注于Andriod领域的知识问答与分享平台，遵循MaterialDesign，使用了MVP-Dagger架构
  • MVVM-live lbForce
    MVVM-liveGoogle的项目：https://github.com/googlesamples/android-architecture/tree/master之todo‑mvvm官方解释：UsesViewModelsandLiveDatafromArchitectureComponentsandtheDataBindinglibrarywithanMVVMarchitecture.Thi
  • Java 并发包之线程池和原子计数 lijingyao8206 Java计数ThreadPool并发包java线程池
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。     这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
  • java编程思想 抽象类和接口 百合不是茶 java抽象类接口
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持   1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错)   抽象方法 : 在方法中仅有声明而没有方法体    package com.wj.Interface;
  • [房地产与大数据]房地产数据挖掘系统 comsci 数据挖掘
           随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间...        所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产     &nb
  • 数组队列总结 沐刃青蛟 数组队列
          数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。      以下是数组队列的功能实现代码：   import List.Student; public class
  • Oracle存储过程无法编译的解决方法 IT独行者 oracle存储过程　
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。   1.     查看无效对象 XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
  • 重装系统之后oracle恢复 文强chu oracle
    前几天正在使用电脑，没有暂停oracle的各种服务。 突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 直接把我的c盘给格式化了 并且清理了注册表，再装系统。 然后的结果就是我的oracl
  • python学习二（ 一些基础语法） 小桔子 pthon基础语法
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 1.ptyhon的源文件以UTF-8编码格式 2. /   除 结果浮点型 //  除 结果整形 %   除 取余数 *   乘 **  乘方 eg 5**2 结果是5的2次方25 _&
  • svn 常用命令 aichenglong SVN版本回退
    1 svn回退版本   1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 两者的区别:   revert this version:表示回退到当前版本(该版本后的版本全部作废)   revert chanages from this versio
  • 某小公司面试归来 alafqq 面试
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 老拿这些对付毕业生的东东来吓唬我。。 面试官很刁难，问了几个问题，记录下； 1，包的范围。。。public,private,protect. --悲剧了 2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 4，stru
  • 动态数组的存储速度比较 集合框架 百合不是茶 集合框架
    集合框架： 自定义数据结构(增删改查等) package 数组; /** * 创建动态数组 * @author 百合 * */ public class ArrayDemo{ //定义一个数组来存放数据 String[] src = new String[0]; /** * 增加元素加入容器 * @param s要加入容器
  • 用JS实现一个JS对象，对象里有两个属性一个方法 bijian1013 js对象
    <html> <head> </head> <body> 用js代码实现一个js对象，对象里有两个属性，一个方法 </body> <script> var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){
  • 探索JUnit4扩展：使用Rule bijian1013 java单元测试JUnitRule
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 1. Rule       &n
  • [Gson一]非泛型POJO对象的反序列化 bit1129 POJO
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 1. POJO对象不包含任何泛型的字段 2. POJO对象包含泛型字段，例如泛型集合或者泛型类 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO    
  • 【Kakfa五】Kafka Producer和Consumer基本使用 bit1129 kafka
    0.Kafka服务器的配置 一个Broker， 一个Topic Topic中只有一个Partition（）   1. Producer： package kafka.examples.producers; import kafka.producer.KeyedMessage; import kafka.javaapi.producer.Producer; impor
  • lsyncd实时同步搭建指南——取代rsync+inotify ronin47
    1. 几大实时同步工具比较 1.1 inotify + rsync 最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果 bylijinnan java
    public class IsBinTreePostTraverse{ static boolean isBSTPostOrder(int[] a){ if(a==null){ return false; } /*1.只有一个结点时，肯定是查找树 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是 6 {6,5}对应的BST是
  • MySQL的sum函数返回的类型 bylijinnan javaspringsqlmysqljdbc
    今天项目切换数据库时，出错 访问数据库的代码大概是这样： String sql = "select sum(number) as sumNumberOfOneDay from tableName"; List<Map> rows = getJdbcTemplate().queryForList(sql); for (Map row : rows
  • java设计模式之单例模式 chicony java设计模式
    在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式的结构 　　单例模式的特点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 　　饿汉式单例类   publ
  • javascript取当月最后一天 ctrain JavaScript
    <!--javascript取当月最后一天--> <script language=javascript> var current = new Date(); var year = current.getYear(); var month = current.getMonth(); showMonthLastDay(year, mont
  • linux tune2fs命令详解 daizj linuxtune2fs查看系统文件块信息
    一.简介： tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 二.用法： Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
  • 做有中国特色的程序员 dcj3sjt126com 程序员
      从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
  • Android：TextView属性大全 dcj3sjt126com textview
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
  • tomcat虚拟目录安装及其配置 eksliang tomcat配置说明tomca部署web应用tomcat虚拟目录安装
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 1.-------------------------------------------tomcat  目录结构 config：存放tomcat的配置文件 temp  ：存放tomcat跑起来后存放临时文件用的 work   ： 当第一次访问应用中的jsp
  • 浅谈：APP有哪些常被黑客利用的安全漏洞 gg163 APP
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 1. 应用反编译漏洞：APK 包非常容易被反编译成可读
  • C#根据网址生成静态页面 hvt Web.netC#asp.nethovertree
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法：   bool CreateHtmlFile(string url, string path) { //http://keleyi.com/a/bjae/3d10wfax.htm stri
  • SVG 教程 （一） 天梯梦 svg
    SVG 简介 SVG 是使用 XML 来描述二维图形和绘图程序的语言。 学习之前应具备的基础知识： 继续学习之前，你应该对以下内容有基本的了解： HTML XML 基础 如果希望首先学习这些内容，请在本站的首页选择相应的教程。 什么是SVG？ SVG 指可伸缩矢量图形 (Scalable Vector Graphics) SVG 用来定义用于网络的基于矢量
  • 一个简单的java栈 luyulong java数据结构栈
    public class MyStack { private long[] arr; private int top; public MyStack() { arr = new long[10]; top = -1; } public MyStack(int maxsize) { arr = new long[maxsize]; top
  • 基础数据结构和算法八：Binary search sunwinner AlgorithmBinary search
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 刘星宇 c面试
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 1.gets()函数 问：请找出下面代码里的问题： #include<stdio.h> int main(void) {     char buff[10];     memset(buff,0,sizeof(buff));
  • ITeye 7月技术图书有奖试读获奖名单公布 ITeye管理员 活动ITeye试读
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 7月试读活动回顾： http://webmaster.iteye.com/blog/2092746 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《Java性能优化权威指南》
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他