Android jetPack 组件摸索学习->ViewModel+LiveData

首先是依赖

  implementation 'android.arch.lifecycle:livedata:1.1.1'
    implementation 'android.arch.lifecycle:viewmodel:1.1.1'
    implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0'

---

public class MyModel extends ViewModel {

    private MutableLiveData<String> mNameEvent = new MutableLiveData<>();

    public MutableLiveData<String> getmNameEvent() {
        return mNameEvent;
    }

}

---

   private TextView tv;
    private MutableLiveData<String> stringMutableLiveData;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        tv = findViewById(R.id.tv);
        // 实例化
        MyModel myModel = ViewModelProviders.of(this).get(MyModel.class);

        //获取观察滴对象
        stringMutableLiveData = myModel.getmNameEvent();

        //设置监听
        stringMutableLiveData.observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                System.out.println(Thread.currentThread()+"");
                tv.setText(s);
            }
        });


//        我们需要调用 livedata 的 setValue 或者 postvalue 方法。他们之间的区别是，

//        调用 setValue 方法，Observer 的 onChanged 方法会在调用 serValue 方法的线程回调。
//        而postvalue 方法，Observer 的 onChanged 方法将会在主线程回调。

        tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                stringMutableLiveData.setValue("改变,就是好事");

            }
        });


    }

 

打印结果:

然后改一下:

我换了个线程,报错了!

    new Thread(){
                    @Override
                    public void run() {
                        super.run();
                        stringMutableLiveData.setValue("改变,就是好事");
                    }
                }.start();

换个post

   new Thread(){
                    @Override
                    public void run() {
                        super.run();
                        stringMutableLiveData.postValue("改变,就是好事");
                    }
                }.start();

厉害厉害

以后买大买小 都是post 了

---

然后 ,这个的对象初始化 是 of.get

ViewModelProviders.of(this).get(MyModel.class);

一个类里 如果用到俩个嘞??  额,我是这么想的

于是有了

public class MyModel extends ViewModel {

    private String mKey;
    private MutableLiveData<String> mNameEvent = new MutableLiveData<>();

    public MutableLiveData<String> getmNameEvent() {
        return mNameEvent;
    }


    public MyModel(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 MyModel(mKey);
        }
    }

    public String getKey() {
        return mKey;
    }

}

        MyModel myModel = ViewModelProviders.of(this,new MyModel.Factory("key1")).get(MyModel.class);

---

貌似还有实战例子

大致,有这么几个方法

一.obseve  设置监听的

将给定的观察者添加到给定所有者的生命周期内的观察者列表中。事件在主线程上发送。如果LiveData已经有数据集，它将被传递给观察者。

二.onActive 看起来像是   改变中,正在被调用中

当活动观察者的数量从0变为1时调用。
此回调可用于知道正在使用此LiveData，因此应保持最新。

三.onInActive  应该是 使用完了  或者 没有在使用

当活动观察者的数量从1变为0时调用。
这并不意味着没有观察者离开，可能仍然有观察者，但他们的生命周期状态不是STARTED或RESUMED（如后堆栈中的Activity）。
您可以通过hasObservers（）检查是否有观察者。

四.observeForever

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

 

一个监听网络变化的例子  网络变化了 系统返给俺们的NetInfo 也会变化,其实这里呢 主要是每次变化 每次 setValue,然后每次都会调用

---

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();
        mContext.registerReceiver(mNetworkReceiver, mIntentFilter);
    }

    @Override
    protected void onInactive() {
        super.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);
            @SuppressLint("MissingPermission")
            NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
            getInstance(context).setValue(activeNetwork);

        }
    }
}

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