优化

MrShi

5 天以前 3a154bdb0a5aaa2c0ac3eac95a6ba747068bd454

 keyCabinet-android/lib_coremodel/src/main/java/com/doumee/lib_coremodel/base/BaseViewModel.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,508 @@
package com.doumee.lib_coremodel.base;

import android.app.Application;
import android.os.Bundle;
import android.os.Message;
import android.view.View;

import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.StringRes;
import androidx.databinding.ObservableField;
import androidx.databinding.ObservableInt;
import androidx.hilt.lifecycle.ViewModelInject;
import androidx.lifecycle.AndroidViewModel;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;

import com.doumee.lib_coremodel.base.livedata.ActionEvent;
import com.doumee.lib_coremodel.base.livedata.MessageEvent;
import com.doumee.lib_coremodel.base.livedata.SingleLiveEvent;
import com.doumee.lib_coremodel.base.livedata.StatusEvent;
import com.doumee.lib_coremodel.bean.event.ActionEventData;
import com.doumee.lib_coremodel.binding.command.BindingAction;
import com.doumee.lib_coremodel.binding.command.BindingCommand;
import com.doumee.lib_coremodel.binding.command.BindingConsumer;
import com.doumee.lib_coremodel.http.rxJava.RxJavaGcManager;

import java.util.HashMap;


/**
 * MVVMFrame æ¡†æž¶åŸºäºŽGoogle官方的 JetPack æž„建，在使用MVVMFrame时，需遵循一些规范：
 *
 * å¦‚果您继承使用了BaseViewModel或其子类，你需要参照如下方式在构造函数上添加@ViewModelInject注解
 *
 * @example BaseViewModel
 * //-------------------------
 *    public class YourViewModel extends BaseViewModel<YourModel> {
 *        @ViewModelInject
 *        public DataViewModel(@NonNull Application application, YourModel model) {
 *            super(application, model);
 *        }
 *    }
 * //-------------------------
 *
 * å¦‚果您继承使用了BaseModel或其子类，你需要参照如下方式在构造函数上添加@Inject注解
 *
 * @example BaseModel
 * //-------------------------
 *    public class YourModel extends BaseModel {
 *        @Inject
 *        public BaseModel(IDataRepository dataRepository){
 *            super(dataRepository);
 *        }
 *    }
 * //-------------------------
 *
 *
 * æ ‡å‡†MVVM模式中的VM (ViewModel)层基类
 * @author <a href="mailto:jenly1314@gmail.com">Jenly</a>
 */
public class BaseViewModel<M extends BaseModel> extends AndroidViewModel implements IViewModel {

    public ObservableField<String> title=new ObservableField<>("121");
    public ObservableField<String> saveStr=new ObservableField<>("保存");
    /**
     * æ˜¾ç¤ºä¿å­˜
     * */
    public ObservableInt saveStrvisibility = new ObservableInt(View.GONE);
    /**
     * åˆ°åº•
     */
    public ObservableInt loadMoreVisibility = new ObservableInt(View.GONE); /**
     * æ— æ•°æ®
     */
    public ObservableInt emptyVisibility = new ObservableInt(View.VISIBLE);
    public RxJavaGcManager rxJavaGcManager;//网络请求生命控制
    protected String tag;

    /**
     * è¿”回事件
     * */
    public BindingCommand backOnClickCommand=new BindingCommand(new BindingAction() {
        @Override
        public void call() {
            backOnClickCommand();
        }
    });
    /**
     * ä¿å­˜äº‹ä»¶
     * */
    public BindingCommand saveOnClickCommand=new BindingCommand(new BindingAction() {
        @Override
        public void call() {
            saveOnClickCommand();
        }
    });
    public void backOnClickCommand(){
        finish();
    }
    public void saveOnClickCommand(){

    }

    public BindingCommand myTypeCommand = new BindingCommand(new BindingConsumer<Integer>() {
        @Override
        public void call(Integer type) {
            clickByTypeCommand(type);
        }
    });

    protected void clickByTypeCommand(int type){

    }

    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    private LifecycleOwner lifecycleOwner;

    /**
     * è¯·é€šè¿‡ {@link #getModel()} èŽ·å–，后续版本 {@link #mModel}可能会私有化
     */
    private M mModel;

    /**
     * åŠ¨ä½œäº‹ä»¶
     */
    private ActionEvent actionEvent = new ActionEvent();

    /**
     * æ¶ˆæ¯äº‹ä»¶
     */
    private MessageEvent mMessageEvent = new MessageEvent();

    /**
     * çŠ¶æ€äº‹ä»¶
     */
    private StatusEvent mStatusEvent = new StatusEvent();

    /**
     * åŠ è½½çŠ¶æ€
     */
    private SingleLiveEvent<Boolean> mLoadingEvent = new SingleLiveEvent<>();

    /**
     * æä¾›è‡ªå®šä¹‰å•ä¸€æ¶ˆæ¯äº‹ä»¶
     */
    private SingleLiveEvent<Message> mSingleLiveEvent  = new SingleLiveEvent<>();

    /**
     * ç»§æ‰¿è€…都将使用此构造
     * @param application
     * @param model
     */
    public BaseViewModel(@NonNull Application application, M model) {
        super(application);
        this.mModel = model;
        rxJavaGcManager=new RxJavaGcManager();
    }

    /**
     * ç‰¹æ®Šæž„造，仅供内部使用
     * ä¸ºäº†æ»¡è¶³@ViewModelInject注解
     * @param application
     */
    @ViewModelInject
    BaseViewModel(@NonNull Application application) {
        super(application);

    }

    @Override
    public void onCreate() {

    }

    @Override
    public void onStart() {

    }

    @Override
    public void onResume() {

    }

    @Override
    public void onPause() {

    }

    @Override
    public void onStop() {

    }

    @Override
    public void onDestroy() {
        if(mModel != null){
            mModel.onDestroy();
            mModel = null;
        }
        rxJavaGcManager.disposableActives();
    }

    @Override
    public void onAny(LifecycleOwner owner, Lifecycle.Event event) {

    }

    public void finish(){
        actionEvent.setValue(new ActionEventData(ActionEvent.Action.FINISH,new HashMap<>()));
    }

    public void toast(String msg){
        actionEvent.setValue(new ActionEventData(ActionEvent.Action.TOAST,"toast",msg));
    }

    public void doAction(int type){
        actionEvent.setValue(new ActionEventData(type));
    }

    public void doAction(int type,String obj){
        actionEvent.setValue(new ActionEventData(type,obj));
    }

    public LifecycleOwner getLifecycleOwner() {
        return lifecycleOwner;
    }

    public void setLifecycleOwner(LifecycleOwner lifecycleOwner) {
        this.lifecycleOwner = lifecycleOwner;
    }

    /**
     * {@link M}
     * @return {@link #mModel}
     */
    public M getModel(){
        return this.mModel;
    }

    public ActionEvent getActionEvent() {
        return actionEvent;
    }

    public void updateAction(ActionEventData data, boolean post){
        if(post){
            actionEvent.postValue(data);
        }else{
            actionEvent.setValue(data);
        }
    }

    public void startActivity(Class<?> cla, Bundle bundle){
        HashMap<String,Object> hashMap=new HashMap<>();
        hashMap.put(ActionEvent.ParameterField.CLASS,cla);
        if(bundle!=null){
            hashMap.put(ActionEvent.ParameterField.BUNDLE,bundle);
        }
        updateAction(new ActionEventData(ActionEvent.Action.START_ACTIVITY,hashMap),false);
    }

    public void startActivity(Class<?> cla){
        HashMap<String,Object> hashMap=new HashMap<>();
        hashMap.put(ActionEvent.ParameterField.CLASS,cla);
        updateAction(new ActionEventData(ActionEvent.Action.START_ACTIVITY,hashMap),false);
    }

    /**
     *  æš´éœ²ç»™è§‚察者提供加载事件，{@link BaseActivity} æˆ– {@link BaseFragment} å·²é»˜è®¤æ³¨å†ŒåŠ è½½äº‹ä»¶ï¼Œ
     *  åªéœ€è°ƒç”¨{@link #showLoading()} æˆ– {@link #hideLoading()}即可在{@link BaseActivity}
     *  æˆ– {@link BaseFragment} ä¸­æ”¶åˆ°è®¢é˜…事件
     * @return {@link #mLoadingEvent}
     */
    public SingleLiveEvent<Boolean> getLoadingEvent(){
        return mLoadingEvent;
    }

    /**
     * æš´éœ²ç»™è§‚察者提供消息事件，通过注册{@link BaseActivity#registerMessageEvent(MessageEvent.MessageObserver)}或
     * {@link BaseFragment#registerMessageEvent(MessageEvent.MessageObserver)} æˆ–
     * {@link BaseDialogFragment#registerMessageEvent(MessageEvent.MessageObserver)}接收消息事件
     * @return {@link #mMessageEvent}
     */
    public MessageEvent getMessageEvent(){
        return mMessageEvent;
    }

    /**
     * æš´éœ²ç»™è§‚察者提供状态变化事件，通过注册{@link BaseActivity#registerStatusEvent(StatusEvent.StatusObserver)}或
     * {@link BaseFragment#registerStatusEvent(StatusEvent.StatusObserver)} æˆ–
     * {@link BaseDialogFragment#registerStatusEvent(StatusEvent.StatusObserver)}接收消息事件
     * @return {@link #mStatusEvent}
     */
    public StatusEvent getStatusEvent(){
        return mStatusEvent;
    }

    /**
     * æš´éœ²ç»™è§‚察者提供接收单个消息事件，通过注册{@link BaseActivity#registerSingleLiveEvent(Observer)}或
     * {@link BaseFragment#registerSingleLiveEvent(Observer)} æˆ–
     * {@link BaseDialogFragment#registerSingleLiveEvent(Observer)}接收消息事件
     * @return {@link #mSingleLiveEvent}
     */
    public SingleLiveEvent<Message> getSingleLiveEvent(){
        return mSingleLiveEvent;
    }

    /**
     * å‘送消息，通过注册{@link BaseActivity#registerMessageEvent(MessageEvent.MessageObserver)}或
     * {@link BaseFragment#registerMessageEvent(MessageEvent.MessageObserver)} æˆ–
     * {@link BaseDialogFragment#registerMessageEvent(MessageEvent.MessageObserver)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getMessageEvent()}接收消息事件
     * @param msgId èµ„源文件id
     */
    @MainThread
    public void sendMessage(@StringRes int msgId) {
        sendMessage(msgId,false);
    }

    /**
     * å‘送消息，通过注册{@link BaseActivity#registerMessageEvent(MessageEvent.MessageObserver)}或
     * {@link BaseFragment#registerMessageEvent(MessageEvent.MessageObserver)} æˆ–
     * {@link BaseDialogFragment#registerMessageEvent(MessageEvent.MessageObserver)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getMessageEvent()}接收消息事件
     * @param msgId èµ„源文件id
     * @param post å¦‚果为{@code true}则可以在子线程调用，相当于调用{@link MutableLiveData#postValue(Object)}，
     *             å¦‚果为{@code false} ç›¸å½“于调用{@link MutableLiveData#setValue(Object)}
     */
    public void sendMessage(@StringRes int msgId, boolean post) {
        sendMessage(getApplication().getString(msgId),post);
    }

    /**
     * å‘送消息，通过注册{@link BaseActivity#registerMessageEvent(MessageEvent.MessageObserver)}或
     * {@link BaseFragment#registerMessageEvent(MessageEvent.MessageObserver)} æˆ–
     * {@link BaseDialogFragment#registerMessageEvent(MessageEvent.MessageObserver)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getMessageEvent()}接收消息事件
     * @param message æ¶ˆæ¯å†…容
     */
    @MainThread
    public void sendMessage(String message){
        mMessageEvent.setValue(message);
    }

    /**
     * å‘送消息，通过注册{@link BaseActivity#registerMessageEvent(MessageEvent.MessageObserver)}或
     * {@link BaseFragment#registerMessageEvent(MessageEvent.MessageObserver)} æˆ–
     * {@link BaseDialogFragment#registerMessageEvent(MessageEvent.MessageObserver)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getMessageEvent()}接收消息事件
     * @param message æ¶ˆæ¯å†…容
     * @param post å¦‚果为{@code true}则可以在子线程调用，相当于调用{@link MutableLiveData#postValue(Object)}，
     *             å¦‚果为{@code false} ç›¸å½“于调用{@link MutableLiveData#setValue(Object)}
     */
    public void sendMessage(String message, boolean post){
        if(post){
            mMessageEvent.postValue(message);
        }else{
            mMessageEvent.setValue(message);
        }
    }


    /**
     * æ›´æ–°çŠ¶æ€ï¼Œé€šè¿‡æ³¨å†Œ{@link BaseActivity#registerStatusEvent(StatusEvent.StatusObserver)}或
     * {@link BaseFragment#registerStatusEvent(StatusEvent.StatusObserver)} æˆ–
     * {@link BaseDialogFragment#registerStatusEvent(StatusEvent.StatusObserver)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getStatusEvent()}接收消息事件
     * @param status
     */
    @MainThread
    public void updateStatus(@StatusEvent.Status int status){
        updateStatus(status,false);
    }

    /**
     * æ›´æ–°çŠ¶æ€ï¼Œé€šè¿‡æ³¨å†Œ{@link BaseActivity#registerStatusEvent(StatusEvent.StatusObserver)}或
     * {@link BaseFragment#registerStatusEvent(StatusEvent.StatusObserver)} æˆ–
     * {@link BaseDialogFragment#registerStatusEvent(StatusEvent.StatusObserver)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getStatusEvent()}接收消息事件
     * @param status
     * @param post å¦‚果为{@code true}则可以在子线程调用，相当于调用{@link MutableLiveData#postValue(Object)}，
     *             å¦‚果为{@code false} ç›¸å½“于调用{@link MutableLiveData#setValue(Object)}
     */
    public void updateStatus(@StatusEvent.Status int status, boolean post){
        if(post){
            mStatusEvent.postValue(status);
        }else{
            mStatusEvent.setValue(status);
        }
    }

    /**
     * å‘送单个消息事件，消息为{@link Message}对象，可通过{@link Message#what}区分消息类型，用法与{@link Message}一致，
     * é€šè¿‡æ³¨å†Œ{@link BaseActivity#registerSingleLiveEvent(Observer)}或
     * {@link BaseFragment#registerSingleLiveEvent(Observer)} æˆ–
     * {@link BaseDialogFragment#registerSingleLiveEvent(Observer)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getSingleLiveEvent()}接收消息事件
     * @param what
     */
    @MainThread
    public void sendSingleLiveEvent(int what){
        sendSingleLiveEvent(what,false);
    }

    /**
     * å‘送单个消息事件，消息为{@link Message}对象，可通过{@link Message#what}区分消息类型，用法与{@link Message}一致，
     * é€šè¿‡æ³¨å†Œ{@link BaseActivity#registerSingleLiveEvent(Observer)}或
     * {@link BaseFragment#registerSingleLiveEvent(Observer)} æˆ–
     * {@link BaseDialogFragment#registerSingleLiveEvent(Observer)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getSingleLiveEvent()}接收消息事件
     * @param what
     * @param post å¦‚果为{@code true}则可以在子线程调用，相当于调用{@link MutableLiveData#postValue(Object)}，
     *             å¦‚果为{@code false} ç›¸å½“于调用{@link MutableLiveData#setValue(Object)}
     */
    public void sendSingleLiveEvent(int what, boolean post){
        Message message = Message.obtain();
        message.what = what;
        sendSingleLiveEvent(message,post);
    }

    /**
     * å‘送单个消息事件，消息为{@link Message}对象，可通过{@link Message#what}区分消息类型，用法与{@link Message}一致，
     * é€šè¿‡æ³¨å†Œ{@link BaseActivity#registerSingleLiveEvent(Observer)}或
     * {@link BaseFragment#registerSingleLiveEvent(Observer)} æˆ–
     * {@link BaseDialogFragment#registerSingleLiveEvent(Observer)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getSingleLiveEvent()}接收消息事件
     * @param message
     */
    @MainThread
    public void sendSingleLiveEvent(Message message){
        sendSingleLiveEvent(message,false);
    }

    /**
     * å‘送单个消息事件，消息为{@link Message}对象，可通过{@link Message#what}区分消息类型，用法与{@link Message}一致，
     * é€šè¿‡æ³¨å†Œ{@link BaseActivity#registerSingleLiveEvent(Observer)}或
     * {@link BaseFragment#registerSingleLiveEvent(Observer)} æˆ–
     * {@link BaseDialogFragment#registerSingleLiveEvent(Observer)}接收消息事件，
     * ä¹Ÿå¯é€šè¿‡è§‚察{@link #getSingleLiveEvent()}接收消息事件
     * @param message
     * @param post å¦‚果为{@code true}则可以在子线程调用，相当于调用{@link MutableLiveData#postValue(Object)}，
     *             å¦‚果为{@code false} ç›¸å½“于调用{@link MutableLiveData#setValue(Object)}
     */
    public void sendSingleLiveEvent(Message message, boolean post){
        if(post){
            mSingleLiveEvent.postValue(message);
        }else{
            mSingleLiveEvent.setValue(message);
        }
    }

    /**
     * è°ƒç”¨æ­¤ç±»ä¼šåŒæ­¥é€šçŸ¥æ‰§è¡Œ{@link BaseActivity#showLoading()}或{@link BaseFragment#showLoading()}或
     * {@link BaseDialogFragment#showLoading()}
     */
    @MainThread
    public void showLoading() {
        showLoading(true);
    }

    /**
     * è°ƒç”¨æ­¤ç±»ä¼šåŒæ­¥é€šçŸ¥æ‰§è¡Œ{@link BaseActivity#showLoading()}或{@link BaseFragment#showLoading()}或
     * {@link BaseDialogFragment#showLoading()}
     */
    public void showLoading(boolean post) {
        if(post){
            mLoadingEvent.postValue(true);
        }else{
            mLoadingEvent.setValue(true);
        }
    }

    /**
     * è°ƒç”¨æ­¤ç±»ä¼šåŒæ­¥é€šçŸ¥æ‰§è¡Œ{@link BaseActivity#hideLoading()}或{@link BaseFragment#hideLoading()}或
     * {@link BaseDialogFragment#hideLoading()}
     */
    @MainThread
    public void hideLoading() {
        hideLoading(false);
    }


    /**
     * è°ƒç”¨æ­¤ç±»ä¼šåŒæ­¥é€šçŸ¥æ‰§è¡Œ{@link BaseActivity#hideLoading()}或{@link BaseFragment#hideLoading()}或
     * {@link BaseDialogFragment#hideLoading()}
     * @param post å¦‚果为{@code true}则可以在子线程调用，相当于调用{@link MutableLiveData#postValue(Object)}，
     *             å¦‚果为{@code false} ç›¸å½“于调用{@link MutableLiveData#setValue(Object)}
     */
    public void hideLoading(boolean post) {
        if(post){
            mLoadingEvent.postValue(false);
        }else{
            mLoadingEvent.setValue(false);
        }
    }


}