家大事记完善

Linjiajia

2023-03-28 bf4e40cdf60c2a2fd8a486051a1ddac2daefef62

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package com.android.app_base.base.viewmodel;
 
import android.app.Application;
 
import androidx.annotation.NonNull;
import androidx.lifecycle.AndroidViewModel;
import androidx.lifecycle.DefaultLifecycleObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
 
import com.android.app_base.base.StateViewEnum;
import com.android.app_base.base.model.BaseModel;
 
 
import org.reactivestreams.Subscriber;
 
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
 
/**
 * ViewModel基类
 */
public abstract class BaseViewModel<M extends BaseModel> extends AndroidViewModel implements DefaultLifecycleObserver {
 
    protected Application application;
    /**
     * 数据仓库model
     */
    protected M model;
    /**
     * 控制状态视图的LiveData
     */
    protected MutableLiveData<StateViewEnum> stateViewLiveData;
    protected MutableLiveData<String> messageLiveData;
    //管理RxJava，主要针对RxJava异步操作造成的内存泄漏
    private CompositeDisposable mCompositeDisposable;
 
    public BaseViewModel(@NonNull Application application) {
        super(application);
        this.application = application;
        model = initModel();
        mCompositeDisposable = new CompositeDisposable();
    }
 
    /**
     * 数据仓库初始化，由子类实现返回
     */
    protected abstract M initModel();
 
    /**
     * Rxjava的异步操作都要调用此方法添加到 mCompositeDisposable里，
     */
    protected void addSubscribe(Disposable disposable) {
        if (mCompositeDisposable == null) {
            mCompositeDisposable = new CompositeDisposable();
        }
        mCompositeDisposable.add(disposable);
    }
 
    /**
     * 获取状态视图LiveData
     */
    public LiveData<StateViewEnum> getStateViewLiveData() {
        if(stateViewLiveData == null){
            stateViewLiveData = new MutableLiveData<>();
        }
        return stateViewLiveData;
    }
    public LiveData<String> getMessageLivaData(){
        if(messageLiveData == null){
            messageLiveData = new MutableLiveData<>();
        }
        return messageLiveData;
    }
    /**
     * 更改状态视图的状态
     */
    public void changeStateView(StateViewEnum state) {
        stateViewLiveData.postValue(state);
    }
 
    @Override
    protected void onCleared() {
        super.onCleared();
        if (model != null) {
            model.onCleared();
        }
        //ViewModel销毁时会执行，同时取消所有异步任务
        if (mCompositeDisposable != null) {
            mCompositeDisposable.clear();
        }
    }
 
 
    /**
     * 子类可以重写生命周期方法，便于生命周期的考虑
     */
    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onCreate(owner);
    }
 
    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onStart(owner);
    }
 
    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onResume(owner);
    }
 
 
    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onPause(owner);
    }
 
    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onStop(owner);
    }
 
    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        DefaultLifecycleObserver.super.onDestroy(owner);
    }
}