MVVM Demo解析

import android.app.Application
import dagger.android.AndroidInjector
import dagger.android.DispatchingAndroidInjector
import dagger.android.HasAndroidInjector
import org.phcbest.mvvm_demo.di.AppInjector
import javax.inject.Inject

/**
 * dagger 2.23 版本后,将Has*Injector替换为了HasAndroidInjector
 */
class MVVMApplication : Application(), HasAndroidInjector {

    private val TAG = "MVVMApplication"

    @Inject
    lateinit var dispatchingAndroidInjector: DispatchingAndroidInjector<Any>

    override fun onCreate() {
        super.onCreate()
        AppInjector.init(this)
    }

    override fun androidInjector(): AndroidInjector<Any> {
        return dispatchingAndroidInjector
    }
}

class MainActivity : AppCompatActivity(), HasAndroidInjector {
    @Inject
    lateinit var dispatchingAndroidInjector: DispatchingAndroidInjector<Any>

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //添加列表Fragment
        if (savedInstanceState == null) {
            val projectListFragment = ProjectListFragment()
            supportFragmentManager.beginTransaction()
                .add(R.id.fragment_container, projectListFragment, ProjectListFragment.TAG).commit()
        }
    }

    /**
     * 切换为显示详情的Fragment
     */
    fun show(project: Project) {
        val projectFragment = ProjectFragment.forProject(project.name)
        supportFragmentManager.beginTransaction().addToBackStack("project")
            .replace(R.id.fragment_container, projectFragment, null).commit()
    }

    override fun androidInjector(): AndroidInjector<Any> = dispatchingAndroidInjector
}

import android.app.Activity
import android.app.Application
import android.os.Bundle
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentActivity
import androidx.fragment.app.FragmentManager
import dagger.android.AndroidInjection
import dagger.android.HasAndroidInjector
import dagger.android.support.AndroidSupportInjection
import org.phcbest.mvvm_demo.MVVMApplication

/**
 * 初始化注入器
 */
class AppInjector {

    companion object {
        fun init(mvvmApplication: MVVMApplication) {
            DaggerAppComponent.builder().application(mvvmApplication).build()
                .inject(mvvmApplication)
            mvvmApplication.registerActivityLifecycleCallbacks(object :
                Application.ActivityLifecycleCallbacks {
                override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
                    handleActivity(activity)
                }
                override fun onActivityStarted(activity: Activity) {                }
                override fun onActivityResumed(activity: Activity) {                }
                override fun onActivityPaused(activity: Activity) {                }
                override fun onActivityStopped(activity: Activity) {                }
                override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {                }
                override fun onActivityDestroyed(activity: Activity) {                }
            })
        }

        private fun handleActivity(activity: Activity) {
            //如果类继承了HasAndroidInjector
            if (activity is HasAndroidInjector) {
                //实现注入
                AndroidInjection.inject(activity)
            }
            //如果是Activity的实现
            if (activity is FragmentActivity) {
                //设置fragment的生命周期监听
                activity.supportFragmentManager.registerFragmentLifecycleCallbacks(object :
                    FragmentManager.FragmentLifecycleCallbacks() {
                    override fun onFragmentCreated(
                        fm: FragmentManager,
                        f: Fragment,
                        savedInstanceState: Bundle?
                    ) {
                        //如果fragment继承Injectable,实现注入
                        if (f is Injectable) {
                            AndroidSupportInjection.inject(f)
                        }
                    }
                }, true)
            }
        }
    }
}

interface Injectable {}

import android.app.Application
import dagger.BindsInstance
import dagger.Component
import dagger.android.AndroidInjectionModule
import org.phcbest.mvvm_demo.MVVMApplication
import javax.inject.Singleton

@Singleton
@Component(modules = [AndroidInjectionModule::class, AppModule::class, MainActivityModel::class])
interface AppComponent {

    /**
     * 者接口是用于创建构造器的
     */
    @Component.Builder
    interface Builder {
        @BindsInstance
        fun application(application: Application): Builder
        fun build(): AppComponent
    }

    fun inject(mvvmApplication: MVVMApplication?)
}

import androidx.lifecycle.ViewModelProvider
import dagger.Module
import dagger.Provides
import org.phcbest.mvvm_demo.service.respository.GitHubService
import org.phcbest.mvvm_demo.viewmodel.ProjectViewModelFactory
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import javax.inject.Singleton

@Module(subcomponents = [ViewModelSubComponent::class])
class AppModule {

    /**
     * 单例并且设置为依赖提供者
     */
    @Singleton
    @Provides
    fun provideGithubService(): GitHubService {
        return Retrofit.Builder().baseUrl(GitHubService.HTTPS_API_GITHUB_URL)
            .addConverterFactory(GsonConverterFactory.create()).build()
            .create(GitHubService::class.java)

    }

    /**
     * 要求返回一个viewmodel提供者的工厂
     */
    @Singleton
    @Provides
    fun provideViewModelFactory(viewModelSubComponent: ViewModelSubComponent.Builder): ViewModelProvider.Factory {
        return ProjectViewModelFactory(viewModelSubComponent.build())
    }

}

import dagger.Module
import dagger.android.ContributesAndroidInjector
import org.phcbest.mvvm_demo.view.ui.MainActivity

@Module
abstract class MainActivityModel {

    @ContributesAndroidInjector(modules = [FragmentBuildersModule::class])
    abstract fun contributeMainActivity(): MainActivity
}

@Module
abstract class FragmentBuildersModule {
    /**
     * 提供Android 项目Fragment
     */
    @ContributesAndroidInjector
    abstract fun contributeProjectFragment(): ProjectFragment?

    @ContributesAndroidInjector
    abstract fun contributeProjectListFragment(): ProjectListFragment?
}

class ProjectListFragment : Fragment(), Injectable {

    private lateinit var binding: FragmentProjectListBinding
    private lateinit var projectAdapter: ProjectAdapter


    @Inject
    lateinit var viewModelProvider: ViewModelProvider.Factory

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = DataBindingUtil.inflate(
            inflater,
            R.layout.fragment_project_list,
            container,
            false
        ) as FragmentProjectListBinding
        projectAdapter = ProjectAdapter(projectClickCallback)
        binding.projectList.adapter = projectAdapter
        binding.isLoading = true
        return binding.root
    }

    /**
     * adapter item 的点击事件
     */
    private var projectClickCallback = object : ProjectClickCallback {
        override fun onClick(project: Project) {
            // 切换为项目Fragment
            if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
                (activity as MainActivity).show(project)
            }
        }
    }

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        //使用ViewModel提供者提供个ViewModel对象
        val viewModel =
            ViewModelProviders.of(
                this,
                viewModelProvider
            )[ProjectListViewModel::class.java]

        observeViewModel(viewModel)
    }

    /**
     * 观测ViewModel
     */
    private fun observeViewModel(viewModel: ProjectListViewModel) {
        //当观测到这个数据发生改变时，执行以下操作
        viewModel.getProjectListObservable()
            .observe(this.viewLifecycleOwner, object : Observer<List<Project>> {
                override fun onChanged(t: List<Project>?) {
                    if (t != null) {
                        binding.isLoading = false
                        projectAdapter.setProjectListParam(t)
                    }
                }
            })
    }


    companion object {
        const val TAG = "ProjectListFragment"

    }
}

class ProjectListViewModel : AndroidViewModel {

    //UI可以直接观测该参数
    private lateinit var projectListObservable: LiveData<List<Project>>

    /**
     * 在构造的时候进行了网络请求,获得list
     */
    @Inject
    constructor(
        projectRepository: ProjectRepository,
        application: Application
    ) : super(application) {
        this.projectListObservable = projectRepository.getProjectList(application.getString(R.string.userid))
    }

    //UI可以直接观测该参数
    fun getProjectListObservable(): LiveData<List<Project>> {
        return projectListObservable
    }

}