Android项目实战搭建 MVVM架构

View层

详细代码：

 activity:

1. /**
2. * @description:
3. * 普通Activity基类，不带ViewModel,显示基本加载状态
4. * 需要获取到子类的布局id用于databinding的绑定
5. * @author YL Chen
6. * @date 2024/9/4 21:34
7. * @version 1.0
8. */
9. abstract class BaseActivity<VB : ViewDataBinding>(@LayoutRes layoutID: Int) :
10.     AppCompatActivity() { //此处不能将layoutId传递进去，否则会导致fragment加载但不显示
12.     open lateinit var mRefreshLayout: SmartRefreshLayout
13.     //仅供直接继承本类的子类调用,继承于BaseVMActivity的调用此对象的方法无效,
14.     // 因为setSuccessView方法先于getLoadView方法执行,导致加载状态无法被移除,继承于BaseVMActivity的想改变状态需使用mViewModel调用changeStateView方法
15.     open lateinit var mMultiplyStateView: MultiplyStateView
16.     //子view的布局id
17.     private var mLayoutId: Int = layoutID
19.     //子View的dataBinding
20.     lateinit var mBinding: VB
22.     override fun onCreate(savedInstanceState: Bundle?) {
23.         super.onCreate(savedInstanceState)
24.         //设置基础布局
25.         setContentView(R.layout.base_load_more_layout)
26.         //初始化界面
27.         initView()
28.         //初始化数据
29.         initData()
30.     }
32.     //初始化界面
33.     open fun initView() {
34.         //获取加载成功DataViewBinding
35.         mBinding = DataBindingUtil.inflate(
36.             layoutInflater,
37.             mLayoutId,
38.             null,
39.             false
40.         )
41.         //刷新框架
42.         mRefreshLayout = findViewById(R.id.refreshLayout)
43.         //找到基础布局中的自定义多状态View控件
44.         mMultiplyStateView = findViewById(R.id.multiply_state_view)
45.         // 将加载成功View布局添加到自定义多状态View中
46.         mMultiplyStateView.setSuccessView(mBinding.root)
47.     }
49.     //初始化数据
50.     abstract fun initData()
51. }
55. /**
56. * @description: 携带ViewModel的Activity基类，继承自BaseActivity
57. * @author YL Chen
58. * @date 2024/9/6 14:16
59. * @version 1.0
60. */
61. abstract class BaseVMActivity<VB : ViewDataBinding, VM : BaseViewModel>(@LayoutRes layoutId: Int) :
62.     BaseActivity<VB>(layoutId) {
63.     //子类ViewModel实例
64.     lateinit var mViewModel: VM
66.     /**
67.      * 获取对应的ViewModel，并初始化数据
68.      */
69.     override fun initData() {
70.         //dataLoading()
71.         mViewModel = getViewModel()!!
72.         //将子类的ViewModel和dataBinding联系起来，实现界面数据的自动更新
73.         //将xml布局对应的viewModel对象赋值到xml布局中声明的viewModel变量 即实现如:mBinding.viewModel = ViewModel() 的效果
74.         val variableId = getVariableId()
75.         if (variableId != -1) {
76.             mBinding.setVariable(variableId, mViewModel)
77.             //立即执行 Data Binding 中的挂起绑定
78.             //即Data Binding 会立即将 ViewModel 的属性和方法更新到布局文件中
79.             mBinding.executePendingBindings()
80.         }
81.         //初始化视图状态
82.         initViewState()
83.         //初始化ViewModel数据
84.         initVMData()
85.         //监听liveData
86.         observeLiveData()
87.         //设置状态页点击重新加载监听
88.         mMultiplyStateView.setOnReLodListener(mViewModel)
89.     }
91.     /**
92.      * 监听ViewModel中的LiveData
93.      */
94.     open fun observeLiveData() {
95.     }
97.     /**
98.      * 初始化状态
99.      */
100.     private fun initViewState() {
101.         mViewModel.mStateViewLiveData.observe(this) {
102.             when (it) {
103.                 ViewStateEnum.VIEW_LOADING -> {
104.                     LogUtils.d(this, "StateLayoutEnum.DATA_LOADING")
105.                     dataLoading()
106.                 }
108.                 ViewStateEnum.VIEW_EMPTY -> {
109.                     LogUtils.d(this, "StateLayoutEnum.DATA_ERROR")
110.                     dataEmpty()
111.                 }
113.                 ViewStateEnum.VIEW_NET_ERROR -> {
114.                     LogUtils.d(this, "StateLayoutEnum.NET_ERROR")
115.                     netError()
116.                 }
118.                 ViewStateEnum.VIEW_LOAD_SUCCESS -> {
119.                     LogUtils.d(this, "StateLayoutEnum.LOAD_SUCCESS")
120.                     loadSuccess()
121.                 }
123.                 ViewStateEnum.VIEW_NONE -> {
124.                     LogUtils.d(this, "StateLayoutEnum.NONE")
125.                 }
126.             }
127.         }
128.     }
130.     /**
131.      * 数据加载成功
132.      */
133.     open fun loadSuccess() {
134.         mMultiplyStateView.showSuccess()
135.     }
137.     /**
138.      * 网络加载失败
139.      */
140.     open fun netError() {
141.         mMultiplyStateView.showNetError()
142.     }
145.     /**
146.      * 数据加载为空
147.      */
148.     open fun dataEmpty() {
149.         mMultiplyStateView.showEmpty()
150.     }
152.     /**
153.      * 数据加载中
154.      */
155.     open fun dataLoading() {
156.         mMultiplyStateView.showLoading()
157.         val loadingView = mMultiplyStateView.getLoadingView()
158.         val myLoadingView = loadingView.findViewById<MyLoadingView>(R.id.my_loading_view)
159.         myLoadingView.startRotate()
160.     }
162.     /**
163.      * 初始化ViewModel数据
164.      */
165.     abstract fun initVMData()
167.     /**
168.      * 获取xml绑定的variable
169.      * @return Int
170.      */
171.     //子类通过重写此方法返回子类对应xml文件中绑定的viewModel变量的id
172.     open fun getVariableId(): Int {
173.         return -1
174.     }
176.     /**
177.      * 通过反射获取子类的ViewModel
178.      * @return VM?
179.      */
180.     private fun getViewModel(): VM? {
181.         //这里获得到的是类的泛型的类型
182.         val type = javaClass.genericSuperclass
183.         if (type != null && type is ParameterizedType) {
184.             val actualTypeArguments = type.actualTypeArguments
185.             val tClass = actualTypeArguments[1]
186.             return ViewModelProvider(
187.                 this,
188.                 ViewModelProvider.AndroidViewModelFactory.getInstance(application)
189.             )
190.                 .get(tClass as Class<VM>)
191.         }
192.         return null
193.     }
194. }

复制代码

fragment：

1. /**
2. * @description: 普通Fragment基类，不带ViewModel
3. * @author YL Chen
4. * @date 2024/9/6 16:19
5. * @version 1.0
6. */
7. abstract class BaseFragment<VB : ViewDataBinding>(@LayoutRes layoutId: Int = 0) : Fragment() {
9.     open lateinit var mRefreshLayout: SmartRefreshLayout
10.     open lateinit var mMultiplyStateView: MultiplyStateView
12.     //子类的布局id
13.     private val mLayoutId: Int = layoutId
15.     //子View的dataBinding
16.     lateinit var mBinding: VB
18.     lateinit var mRootView: View
20.     override fun onCreateView(
21.         inflater: LayoutInflater,
22.         container: ViewGroup?,
23.         savedInstanceState: Bundle?
24.     ): View? {
25.         //设置根布局
26.         mRootView = layoutInflater.inflate(R.layout.base_load_more_layout, container, false)
27.         return mRootView
28.     }
31.     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
32.         super.onViewCreated(view, savedInstanceState)
33.         //初始化视图
34.         initView()
35.         //初始化数据
36.         initData()
37.     }
39.     //初始化视图
40.     open fun initView() {
41.         //获取加载成功View的DataViewBinding
42.         mBinding = DataBindingUtil.inflate(layoutInflater, mLayoutId, null, false)
43.         //找到根布局的baseFrameLayout
44.         mMultiplyStateView = mRootView.findViewById(R.id.multiply_state_view)
45.         //将子类加载成功View布局添加进去
46.         mMultiplyStateView.setSuccessView(mBinding.root)
47.         //获取到刷新框架
48.         mRefreshLayout = mRootView.findViewById(R.id.refreshLayout)
49.     }
51.     //初始化数据
52.     abstract fun initData()
53. }
59. /**
60. * @description: 携带ViewModel的fragment
61. * @author YL Chen
62. * @date 2024/9/6 21:52
63. * @version 1.0
64. */
65. abstract class BaseVMFragment<VB : ViewDataBinding, VM : BaseViewModel>(@LayoutRes layoutId: Int) :
66.     BaseFragment<VB>(layoutId) {
69.     lateinit var mViewModel: VM
71.     override fun initData() {
72.         mViewModel = getViewModel()!!
73.         val variableId = getVariableId()
74.         if (variableId != -1) {
75.             mBinding.setVariable(getVariableId(), mViewModel)
76.             mBinding.executePendingBindings()
77.         }
78.         initState()
79.         initVMData()
80.         observeLiveData()
81.         //设置状态页点击重新加载监听
82.         mMultiplyStateView.setOnReLodListener(mViewModel)
83.     }
85.     /**
86.      * 获取子类xml 的Variable
87.      * @return Int
88.      */
89.     open fun getVariableId(): Int {
90.         return -1
91.     }
93.     /**
94.      * 初始化状态
95.      */
96.     private fun initState() {
97.         mViewModel.mStateViewLiveData.observe(this) {
98.             when (it) {
99.                 ViewStateEnum.VIEW_LOADING -> {
100.                     LogUtils.d(this, "StateLayoutEnum.DATA_LOADING")
101.                     dataLoading()
102.                 }
104.                 ViewStateEnum.VIEW_EMPTY -> {
105.                     LogUtils.d(this, "StateLayoutEnum.DATA_ERROR")
106.                     dataEmpty()
107.                 }
110.                 ViewStateEnum.VIEW_NET_ERROR -> {
111.                     LogUtils.d(this, "StateLayoutEnum.NET_ERROR")
112.                     netError()
113.                 }
115.                 ViewStateEnum.VIEW_LOAD_SUCCESS -> {
116.                     LogUtils.d(this, "StateLayoutEnum.LOAD_SUCCESS")
117.                     loadSuccess()
118.                 }
120.                 ViewStateEnum.VIEW_NONE -> {
121.                     LogUtils.d(this, "StateLayoutEnum.NONE")
122.                 }
123.             }
124.         }
125.     }
127.     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
128.         super.onViewCreated(view, savedInstanceState)
129.         LogUtils.d(this, "onViewCreated")
130.     }
132.     /**
133.      * 数据加载成功
134.      */
135.     open fun loadSuccess() {
136.         mMultiplyStateView.showSuccess()
137.     }
139.     /**
140.      * 网络加载失败
141.      */
142.     open fun netError() {
143.         mMultiplyStateView.showNetError()
144.     }
147.     /**
148.      * 数据加载错误
149.      */
150.     open fun dataEmpty() {
151.         mMultiplyStateView.showEmpty()
152.     }
154.     /**
155.      * 数据加载中
156.      */
157.     open fun dataLoading() {
158.         mMultiplyStateView.showLoading()
159.         val loadingView = mMultiplyStateView.getLoadingView()
160.         val myLoadingView = loadingView.findViewById<MyLoadingView>(R.id.my_loading_view)
161.         myLoadingView.startRotate()
162.     }
164.     /**
165.      * 通过反射获取子类的ViewModel
166.      * @return VM?
167.      */
168.     private fun getViewModel(): VM? {//这里获得到的是类的泛型的类型
169.         val type = javaClass.genericSuperclass
170.         if (type != null && type is ParameterizedType) {
171.             val actualTypeArguments = type.actualTypeArguments
172.             val tClass = actualTypeArguments[1]
173.             return ViewModelProvider(
174.                 this,
175.                 ViewModelProvider.AndroidViewModelFactory.getInstance(requireActivity().application)
176.             )
177.                 .get(tClass as Class<VM>)
178.         }
179.         return null
180.     }
182.     /**
183.      * 初始化ViewModel数据
184.      */
185.     abstract fun initVMData()
187.     /**
188.      * 监听ViewModel中的LiveData
189.      */
190.     open fun observeLiveData() {
191.     }
193. }

复制代码

思路：

BaseXXX:

通过泛型吸收子类视图的ViewDataBInding类型，并通过构造方法获取子类的视图ID。
在onCreate()方法中，设置底子视图base_load_more_layout.xml，base_load_more_layout.xml中携带SmartRefreshLayout刷新框架和自定义的MultiplyStateView状态视图切换View，以实现刷新、加载更多视图和底子的状态视图切换功能；调用initView()，initData()方法
initView(): 初始化ViewDataBinding，使用构造方法中转达过来的子类视图ID举行初始化，并将其声明为公开的成员变量（mBinding），子类可直接调用，此ViewDataBinding为成功视图，并初始化SmartRefreshLayout和MultiplyStateView，声明为成员变量(mRefreshLayout和mMultiplyStateView)，设置初始化的ViewDataBinding.root为MultiplyStateView的成功视图。
initData抽象方法欺压子类重写，用于初始化数据。
BaseVMXXX:

通过泛型担当子类的ViewDataBinding和ViewModel，并通过构造方法获取子类视图ID，继续自BaseXXX，将泛型ViewDataBinding和视图ID转达给BaseXXX。
重写BaseXXX的initData()方法：

• 通过反射获取通过泛型转达进来的子类ViewModel的对象，并将其声明为公开的成员变量，子类可直接调用（mViewModel）
  
• 调用getVariableId()方法获取子类转达过来的在XML结构中绑定的ViewModel变量，并通过mBinding调用setsetVariable()方法将其与mViewModel绑定到一起，使得可以在子类的视图的一些事件可以绑定对应的ViewModel中。
  
• 调用initViewState()初始化当前View的视图状态，默认是Loding（加载中）状态。
  
• 调用initVMData()初始化ViewModel数据
  
• 调用observeLiveData()监听ViewMode中的LiveData
  
• lifecycle.addObserver(mViewModel)，使ViewModel监听对应View类的生命周期，相当于将ViewModel与View类举行绑定，使其只在View生命周期内相应，制止内存泄漏大概资源的错误开释。
  
• mMultiplyStateView.setOnReLodListener(mViewModel)：为状态视图设置重新加载监听，监听者为View类对应的ViewModel。
  

getVariableId()：公开的方法，默认返回-1，供子类重写返回XML视图中绑定的ViewModel变量
initViewState()：观察对应ViewModel中的切换视图LiveData变量(mStateViewLiveData)，实现状态视图的初始化和切换。
observeLiveData()：公开的方法，供子类重写监听观察对应ViewMode中的LiveData变量。
补充：

自定义多状态视图View代码：

1. package com.yl.wanandroid.ui.custom
3. import android.content.Context
4. import android.util.AttributeSet
5. import android.view.LayoutInflater
6. import android.view.View
7. import android.widget.FrameLayout
8. import androidx.annotation.LayoutRes
9. import com.yl.wanandroid.R
10. import com.yl.wanandroid.model.ViewStateEnum
11. import com.yl.wanandroid.utils.LogUtils
14. /**
15. * @description: 自定义多状态View
16. * @author YL Chen
17. * @date 2024/9/29 10:47
18. * @version 1.0
19. */
21. open class MultiplyStateView : FrameLayout {
23.     private var mOnReLodListener: OnReLodListener? = null
24.     private lateinit var params: LayoutParams
25.     private lateinit var mInflater: LayoutInflater
26.     private var mSuccessViewId: Int = 0
27.     private var mEmptyViewId: Int = 0
28.     private var mNetErrorViewId: Int = 0
29.     private var mLoadingViewId: Int = 0
31.     //四种展示的view
32.     private var mLoadingView: View? = null
33.     private var mSuccessView: View? = null
34.     private var mNetErrorView: View? = null
35.     private var mEmptyView: View? = null
37.     //当前视图状态
38.     private var currentState: ViewStateEnum = ViewStateEnum.VIEW_NONE
40.     constructor(context: Context) : this(context, null)
42.     constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)
44.     constructor(context: Context, attrs: AttributeSet?, defy: Int) : super(context, attrs, defy) {
45.         initView(context, attrs)
46.     }
48.     private fun initView(context: Context, attrs: AttributeSet?) {
49.         //获取自定义属性
50.         val a =
51.             context.obtainStyledAttributes(attrs, R.styleable.MultiplyStateView)
52.         mLoadingViewId =
53.             a.getResourceId(R.styleable.MultiplyStateView_msv_loadingView, R.layout.view_loading)
54.         mNetErrorViewId =
55.             a.getResourceId(R.styleable.MultiplyStateView_msv_netErrorView, R.layout.view_net_error)
56.         mEmptyViewId =
57.             a.getResourceId(R.styleable.MultiplyStateView_msv_emptyView, R.layout.view_empty)
58.         mSuccessViewId = a.getResourceId(R.styleable.MultiplyStateView_msv_successView, 0)
60.         a.recycle()
61.         mInflater = LayoutInflater.from(context)
62.         params = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
63.         setLoadingView(mLoadingViewId)
64.         setEmptyView(mEmptyViewId)
65.         setNetErrorView(mNetErrorViewId)
66.     }
68.     //在 XML 布局文件中的视图被加载并且所有的子视图都被添加到父视图中之后执行
69. /*    override fun onFinishInflate() {
70.         super.onFinishInflate()
71.         //展示加载页面
72.         LogUtils.d(this,"onFinishInflate-->showLoading")
73.         showLoading()
74.         val loadingView = getLoadingView()
75.         val myLoadingView = loadingView.findViewById<MyLoadingView>(R.id.my_loading_view)
76.         myLoadingView.startRotate()
77.     }*/
79.     //++++++++++++++++++++++++++++++++加载页面++++++++++++++++++++
81.     //动态加载并展示加载页面
82.     fun showLoading() {
83.         if (mLoadingView == null) {
84.             mLoadingView = mInflater.inflate(mLoadingViewId, null)
85.         }
86.         if (mLoadingView != null ) {
87.             removeAllViews()
88.             addView(mLoadingView, 0, params)
89.         } else {
90.             throw NullPointerException("you have to set loading view before that")
91.         }
92.     }
94.     /**
95.      * 提供方法给外界设置自定义加载页面
96.      * @param layoutId Int 布局Id
97.      */
98.     open fun setLoadingView(@LayoutRes layoutId: Int) {
99.         setLoadingView(mInflater.inflate(layoutId, null))
100.     }
102.     open fun setLoadingView(view: View) {
103.         mLoadingView = view
104.     }
106.     /**
107.      * 获取加载页面
108.      */
109.     fun getLoadingView(): View {
110.         if (null == mLoadingView) {
111.             mLoadingView = mInflater.inflate(mLoadingViewId, null)
112.         }
113.         return mLoadingView!!
114.     }
116.     //++++++++++++++++++++++++++++++++成功页面++++++++++++++++++++
117.     /**
118.      * 显示成功状态
119.      */
120.     fun showSuccess() {
121.         if (null == mSuccessView) {
122.             mSuccessView = mInflater.inflate(mSuccessViewId, null)
123.         }
124.         if (mSuccessView != null) {
125.             LogUtils.d(this,"childCount-->${childCount}")
126.             val loadingView = getLoadingView()
127.             val myLoadingView = loadingView.findViewById<MyLoadingView>(R.id.my_loading_view)
128.             myLoadingView.stopRotate()
129.             removeAllViews()
130.             LogUtils.d(this,"childCount-->${childCount}")
131.             addView(mSuccessView, 0, params)
132.             LogUtils.d(this,"childCount-->${childCount}")
133.             currentState = ViewStateEnum.VIEW_LOAD_SUCCESS
134.         } else {
135.             throw NullPointerException("you have to set success view before that")
136.         }
137.     }
139.     /**
140.      * 设置自定义的成功页面
141.      *
142.      * @param layoutResID
143.      */
144.     fun setSuccessView(@LayoutRes layoutResID: Int) {
145.         setSuccessView(mInflater.inflate(layoutResID, null))
146.     }
148.     /**
149.      * 设置自定义的成功页面
150.      *
151.      * @param view
152.      */
153.     fun setSuccessView(view: View) {
154.         mSuccessView = view
155.         LogUtils.d(this,"setSuccessView-->${view}")
156.     }
159.     /**
160.      * 获取成功页面
161.      */
162.     fun getSuccessView(): View {
163.         if (null == mSuccessView) {
164.             mSuccessView = mInflater.inflate(mSuccessViewId, null)
165.         }
166.         return mSuccessView!!
167.     }
170.     //++++++++++++++++++++++++++++++++网络错误页面++++++++++++++++++++
171.     /**
172.      * 显示加载失败(网络错误)状态 带监听器的
173.      */
174.     fun showNetError() {
175.         if (null == mNetErrorView) {
176.             mNetErrorView = mInflater.inflate(mNetErrorViewId, null)
177.         }
179.         if (mNetErrorView != null) {
180.             removeAllViews()
181.             addView(mNetErrorView, 0, params)
182.             currentState = ViewStateEnum.VIEW_NET_ERROR
183.             mNetErrorView!!.setOnClickListener { showReLoading() }
184.         } else {
185.             throw java.lang.NullPointerException("you have to set unknown view before that")
186.         }
187.     }
190.     /**
191.      * 设置自定义的网络异常
192.      *
193.      * @param layoutResID
194.      */
195.     fun setNetErrorView(@LayoutRes layoutResID: Int) {
196.         setNetErrorView(mInflater.inflate(layoutResID, null))
197.     }
199.     /**
200.      * 设置自定义的网络异常
201.      *
202.      * @param view
203.      */
204.     fun setNetErrorView(view: View) {
205.         mNetErrorView = view
206.     }
209.     /**
210.      * 设置获取网络错误页面
211.      */
212.     fun getNetErrorView(): View {
213.         if (null == mNetErrorView) {
214.             mNetErrorView = mInflater.inflate(mNetErrorViewId, null)
215.         }
216.         return mNetErrorView!!
217.     }
220.     //++++++++++++++++++++++++++++++++空页面页面++++++++++++++++++++
221.     /**
222.      * 显示无数据状态
223.      */
224.     fun showEmpty() {
225.         if (null == mEmptyView) {
226.             mEmptyView = mInflater.inflate(mEmptyViewId, null)
227.         }
229.         if (mEmptyView != null) {
230.             removeAllViews()
231.             addView(mEmptyView, 0, params)
232.             currentState = ViewStateEnum.VIEW_EMPTY
233.         } else {
234.             throw java.lang.NullPointerException("you have to set empty view before that")
235.         }
236.     }
239.     /**
240.      * 设置自定义的空页面
241.      *
242.      * @param layoutResID
243.      */
244.     fun setEmptyView(@LayoutRes layoutResID: Int) {
245.         setEmptyView(mInflater.inflate(layoutResID, null))
246.     }
248.     /**
249.      * 设置自定义的空页面
250.      *
251.      * @param view
252.      */
253.     fun setEmptyView(view: View) {
254.         mEmptyView = view
255.     }
258.     /**
259.      * 设置获取空页面
260.      */
261.     fun getEmptyView(): View {
262.         if (null == mEmptyView) {
263.             mEmptyView = mInflater.inflate(mEmptyViewId, null)
264.         }
265.         return mEmptyView!!
266.     }
269.     /**
270.      * 再次加载数据
271.      */
272.     private fun showReLoading() {
273.         //第一步重新loading
274.         if (mOnReLodListener != null) {
275.             showLoading()
276.             mOnReLodListener!!.onReLoad()
277.         } else {
278.             //未设置重新加载回调
279.             LogUtils.e(this, "请设置重新加载监听")
280.         }
281.     }
283.     /**
284.      * 外部回调
285.      *
286.      * @param onReLodListener
287.      */
288.     fun setOnReLodListener(onReLodListener: OnReLodListener) {
289.         this.mOnReLodListener = onReLodListener
290.     }
292.     /**
293.      * 重新加载页面的回调接口
294.      */
295.     interface OnReLodListener {
296.         fun onReLoad()
297.     }
299.     override fun onAttachedToWindow() {
300.         super.onAttachedToWindow()
301.         updateVisibility()
302.     }
304.     private fun updateVisibility() {
305.         // 获取父布局的可见性
306.         val parentVisibility = (parent as? View)?.visibility ?: View.VISIBLE
307.         visibility = parentVisibility
308.     }
311.     // 如果需要监听父布局的可见性变化，可以重写这个方法
312.     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
313.         super.onLayout(changed, left, top, right, bottom)
314.         updateVisibility()
315.     }
317.     override fun onDetachedFromWindow() {
318.         super.onDetachedFromWindow()
319.         mOnReLodListener = null // 清除监听器引用
320.     }
322. }

复制代码

ViewModel层

BaseViewModel详细代码：

1. /**
2. * @description: ViewModel基类
3. * @author YL Chen
4. * @date 2024/9/6 14:17
5. * @version 1.0
6. */
7. abstract class BaseViewModel : ViewModel(),MultiplyStateView.OnReLodListener {
9.     /**
10.      * 控制状态视图的LiveData
11.      */
12.     val mStateViewLiveData = MutableLiveData(ViewStateEnum.VIEW_LOADING)
14.     /**
15.      * 切换到UI线程
16.      * @param errorCallback SuspendFunction0<Unit> 错误回调
17.      * @param requestCall SuspendFunction0<Unit> 网络请求函数
18.      */
19.     fun launchUI(
20.         errorCallback: suspend (Int?, String?) -> Unit,
21.         requestCall: suspend () -> Unit
22.     ) {
23.         viewModelScope.launch(Dispatchers.Main) {
24.             //统一进行异常捕获
25.             safeApiCall(errorCallback, requestCall)
26.         }
27.     }
29.     /**
30.      * 对网络请求进行统一异常捕获
31.      * @param errorCallback SuspendFunction2<Int?, String?, Unit> 错误回调
32.      * @param requestCall SuspendFunction0<Unit> 网络请求函数
33.      * @return T? 网络请求成功数据
34.      */
35.     private suspend fun<T> safeApiCall(
36.         errorCallback: suspend (Int?, String?) -> Unit,
37.         requestCall: suspend () -> T?
38.     ): T? {
39.         try {
40.             //返回网络请求结果
41.             return requestCall()
42.         }catch (e: Exception){
43.             LogUtils.e(this@BaseViewModel,e.message.toString())
44.             e.printStackTrace()
45.             //统一异常处理
46.             //将异常转为ApiException
47.             val apiException = ExceptionHandler.handleException(e)
48.             if (apiException.errCode == ERROR.UNKNOW_HOST.code || apiException.errCode == ERROR.NETWORD_ERROR.code){
49.                 changeStateView(ViewStateEnum.VIEW_NET_ERROR)
50.             }
51.             errorCallback(apiException.errCode,apiException.errMsg)
52.         }
53.         return null
54.     }
56.     /**
57.      * 更改状态视图的状态
58.      */
59.     fun changeStateView(
60.         state: ViewStateEnum
61.     ) {
62.         // 对参数进行校验
63.         when (state) {
64.             ViewStateEnum.VIEW_LOADING -> {
65.                 mStateViewLiveData.postValue(ViewStateEnum.VIEW_LOADING)
66.             }
68.             ViewStateEnum.VIEW_EMPTY -> {
69.                 mStateViewLiveData.postValue(ViewStateEnum.VIEW_EMPTY)
70.             }
72.             ViewStateEnum.VIEW_NET_ERROR -> {
73.                 mStateViewLiveData.postValue(ViewStateEnum.VIEW_NET_ERROR)
74.             }
76.             ViewStateEnum.VIEW_LOAD_SUCCESS -> {
77.                 mStateViewLiveData.postValue(ViewStateEnum.VIEW_LOAD_SUCCESS)
78.             }
79.             ViewStateEnum.VIEW_NONE -> {
80.                 mStateViewLiveData.postValue(ViewStateEnum.VIEW_NONE)
81.             }
82.         }
83.     }
85.     //错误视图点击回调函数
86.     override fun onReLoad() {
87.         //调用方法由子类实现
88.         onReload()
89.     }
91.     //子类可实现此方法实现界面重新加载
92.     open fun onReload(){}
93. }

复制代码

思路：

继续自ViewModel，实现MultiplyStateView.OnReLodListener接口，重写onReload()方法，当用户点击重新加载状态视图时，回调此方法
声明mStateViewLiveData成员变量，给View层观察监听
封装changeStateView()方法，用于在网络哀求数据相干操纵后举行手动调用，改变mStateViewLiveData变量的值，View下层对此变量举行观察监听，实现状态视图的实时切换。
onReload()方法：公开的方法，用户自己选择是否重新，不是MultiplyStateView.OnReLodListener欺压重写的，而是自定义的，在欺压重写的onReload中调用。
封装safeApiCall()方法，传入网络哀求函数和错误回调函数，用于调用Modle层中的网络哀求方法，并对返回结果举行统一的异常处理，如当网络异常时，调用ViewModel.changStateView(ViewStateEnum.VIEW_NET_ERROR)改变状态视图。
封装launchUI()方法，用于切换到UI线程，在其中调用safeApiCall()方法。
Model层

BaseBean详细代码：网络哀求返回的底子数据Bean类（与接口返回的数据结构有关）

1. data class BaseBean<T>(val data: T,val errorCode: Int, val errorMsg: String)/**
2. * 网络返回数据类
3. * @param T
4. * @property errorCode String 0:正常，非0异常
5. * @property errorMsg String
6. * @property data T
7. * @constructor
8. */
10. data class BaseResult<T>(val data: T,val errorCode: Int, val errorMsg: String, ) {
11.     fun isFailed(): Boolean {
12.         return errorCode != 0
13.     }
14. }

复制代码

BaseRepository详细代码：网络哀求底子仓库

1. /**
2. * @description: 网络请求基础仓库
3. * @author YL Chen
4. * @date 2024/9/10 17:06
5. * @version 1.0
6. */
7. open class BaseRepository {
8.     /**
9.      * IO中处理请求,请求错误抛出自定义异常
10.      * @param requestCall SuspendFunction0<BaseResult<T>?>
11.      * @return T?
12.      */
13.     suspend fun <T> requestResponse(requestCall: suspend () -> BaseResult<T>?): T? {
14.         val result = withContext(Dispatchers.IO) {
15.             withTimeout(Constant.CONNECT_TIME_OUT * 1000) {
16.                 requestCall()
17.             }
18.         } ?: return null
19.         LogUtils.e(this@BaseRepository,"result-->$result")
21.         if (result.isFailed()) {
22.             throw ApiException(result.errorCode, result.errorMsg)
23.         }
24.         return result.data
25.     }
26. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。