Android單項(xiàng)綁定MVVM項(xiàng)目模板的方法

class LiveDataCallAdapterFactory : CallAdapter.Factory() {

 override fun get(
 returnType: Type,
 annotations: Array<Annotation>,
 retrofit: Retrofit
 ): CallAdapter<*, *>? {
 if (CallAdapter.Factory.getRawType(returnType) != LiveData::class.java) {
 return null
 }
 val observableType = CallAdapter.Factory.getParameterUpperBound(0, returnType as ParameterizedType)
 val rawObservableType = CallAdapter.Factory.getRawType(observableType)
 if (rawObservableType != ApiResponse::class.java) {
 throw IllegalArgumentException("type must be a resource")
 }
 if (observableType !is ParameterizedType) {
 throw IllegalArgumentException("resource must be parameterized")
 }
 val bodyType = CallAdapter.Factory.getParameterUpperBound(0, observableType)
 return LiveDataCallAdapter<Any>(bodyType)
 }
}

class LiveDataCallAdapter<R>(private val responseType: Type) : CallAdapter<R, LiveData<ApiResponse<R>>> {


 override fun responseType() = responseType

 override fun adapt(call: Call<R>): LiveData<ApiResponse<R>> {
 return object : LiveData<ApiResponse<R>>() {
 private var started = AtomicBoolean(false)
 override fun onActive() {
 super.onActive()
 if (started.compareAndSet(false, true)) {
  call.enqueue(object : Callback<R> {
  override fun onResponse(call: Call<R>, response: Response<R>) {
  postValue(ApiResponse.create(response))
  }

  override fun onFailure(call: Call<R>, throwable: Throwable) {
  postValue(ApiResponse.create(throwable))
  }
  })
 }
 }
 }
 }
}

.object GitHubApi {

 var gitHubService: GitHubService = Retrofit.Builder()
 .baseUrl("https://api.github.com/")
 .addCallAdapterFactory(LiveDataCallAdapterFactory())
 .addConverterFactory(GsonConverterFactory.create())
 .build().create(GitHubService::class.java)


}

interface GitHubService {

 @GET("users/{login}")
 fun getUser(@Path("login") login: String): LiveData<ApiResponse<User>>

}

abstract class NetWorkResource<ResultType, RequestType>(val executor: AppExecutors) {

 private val result = MediatorLiveData<Resource<ResultType>>()

 init {
 result.value = Resource.loading(null)
 val dbData=loadFromDb()
 if (shouldFetch(dbData)) {
 fetchFromNetWork()
 }
 else{
 setValue(Resource.success(dbData))
 }
 }

 private fun setValue(resource: Resource<ResultType>) {

 if (result.value != resource) {
 result.value = resource
 }

 }

 private fun fetchFromNetWork() {
 val networkLiveData = createCall()

 result.addSource(networkLiveData, Observer {

 when (it) {

 is ApiSuccessResponse -> {
  executor.diskIO().execute {
  val data = processResponse(it)
  executor.mainThread().execute {
  result.value = Resource.success(data)
  }
  }
 }

 is ApiEmptyResponse -> {
  executor.diskIO().execute {
  executor.mainThread().execute {
  result.value = Resource.success(null)
  }
  }
 }

 is ApiErrorResponse -> {
  onFetchFailed()
  result.value = Resource.error(it.errorMessage, null)
 }

 }

 })

 }

 fun asLiveData() = result as LiveData<Resource<ResultType>>

 abstract fun onFetchFailed()

 abstract fun createCall(): LiveData<ApiResponse<RequestType>>

 abstract fun processResponse(response: ApiSuccessResponse<RequestType>): ResultType

 abstract fun shouldFetch(type: ResultType?): Boolean

 abstract fun loadFromDb(): ResultType?
}

class UserRepository {

 private val executor = AppExecutors()

 fun getUser(userId: String): LiveData<Resource<User>> {

 return object : NetWorkResource<User, User>(executor) {
 override fun shouldFetch(type: User?): Boolean {

 return true
 }

 override fun loadFromDb(): User? {
 return null
 }

 override fun onFetchFailed() {

 }

 override fun createCall(): LiveData<ApiResponse<User>> = GitHubApi.gitHubService.getUser(userId)

 override fun processResponse(response: ApiSuccessResponse<User>): User {
 return response.body
 }

 }.asLiveData()
 }
}

abstract class VMActivity<T : BaseViewModel> : BaseActivity() {

 protected lateinit var mViewModel: T

 abstract fun loadViewModel(): T

 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 mViewModel = loadViewModel()
 lifecycle.addObserver(mViewModel)
 }
}

class MainActivity : VMActivity<MainViewModel>() {
 override fun loadViewModel(): MainViewModel {
 return MainViewModel()
 }

 override fun getLayoutId(): Int = R.layout.activity_main

 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 mViewModel.loginResponseLiveData.observe(this, Observer {

 when (it?.status) {

 Status.SUCCESS -> {
  contentTV.text = it.data?.reposUrl
 }

 Status.ERROR -> {
  contentTV.text = "error"
 }

 Status.LOADING -> {
  contentTV.text = "loading"
 }

 }


 })
 loginBtn.setOnClickListener {
 mViewModel.login("skateboard1991")
 }
 }
}