Dagger/Hilt 2.32-alpha Hilt Jetpack 1.0.0-alpha03 + 动态特征 + ViewModel + SavedStateHandle 和 dagger.assistant.AssistedInject

问题描述

我创建了一个示例项目，将 Dagger/Hilt 与动态功能和 viewmodel 结合使用，一切都很好，Dagger/Hilt 2.29.1-alpha 和 Hilt Jetpack 1.0.0-alpha02 您可以查看源代码 here。现在新版本的 Dagger/Hilt 是 Dagger/Hilt 2.32-alpha Hilt Jetpack 1.0.0-alpha03，您可以查看源代码 here。在 app 模块中，我创建了以下类作为通用视图模型工厂

package com.ibrahim.currencyconverter.di

import android.annotation.SuppressLint
import android.os.Bundle
import androidx.hilt.lifecycle.viewmodelAssistedFactory
import androidx.lifecycle.AbstractSavedStateviewmodelFactory
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.SavedStateviewmodelFactory
import androidx.lifecycle.viewmodel
import androidx.savedstate.SavedStateRegistryOwner
import javax.inject.Provider

class DFMSavedStateviewmodelFactory(
    owner: SavedStateRegistryOwner,defaultArgs: Bundle?,private val delegateFactory: SavedStateviewmodelFactory,private val viewmodelFactories: @JvmSuppressWildcards Map<String,Provider<viewmodelAssistedFactory<out viewmodel>>>
) : AbstractSavedStateviewmodelFactory(owner,defaultArgs) {

    @SuppressLint("RestrictedApi")
    override fun <T : viewmodel?> create(
        key: String,modelClass: Class<T>,handle: SavedStateHandle
    ): T {
        val factoryProvider = viewmodelFactories[modelClass.name]
            ?: return delegateFactory.create("$KEY_PREFIX:$key",modelClass)
        @Suppress("UNCHECKED_CAST")
        return factoryProvider.get().create(handle) as T
    }

    companion object {
        private const val KEY_PREFIX = "androidx.hilt.lifecycle.HiltviewmodelFactory"
    }
}

FragmentviewmodelModule 模块中的

app 类提供视图模型工厂

package com.ibrahim.currencyconverter.di

import android.app.Application
import androidx.fragment.app.Fragment
import androidx.hilt.lifecycle.viewmodelAssistedFactory
import androidx.lifecycle.SavedStateviewmodelFactory
import androidx.lifecycle.viewmodel
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.FragmentComponent
import javax.inject.Provider

@Module
@InstallIn(FragmentComponent::class)
object FragmentviewmodelModule {

    @Provides
    fun provideSavedStateviewmodelFactory(
        application: Application,fragment: Fragment,viewmodelFactories: @JvmSuppressWildcards Map<String,Provider<viewmodelAssistedFactory<out viewmodel>>>,): DFMSavedStateviewmodelFactory {
        val defaultArgs = fragment.arguments
        val delegate = SavedStateviewmodelFactory(application,fragment,defaultArgs)
        return DFMSavedStateviewmodelFactory(fragment,defaultArgs,delegate,viewmodelFactories)
    }
}

AppDependencies 模型中的

app 类用于公开动态功能模块所需的依赖项，动态功能模块是 home 动态功能模块

package com.ibrahim.currencyconverter.di

import android.app.Application
import dagger.hilt.EntryPoint
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import retrofit2.Retrofit

@EntryPoint
@InstallIn(SingletonComponent::class)
interface AppDependencies {
    fun exposeApplication(): Application
    fun exposeRetrofit(retrofit: Retrofit): Retrofit
}

然后在 home 动态特征模块中，我创建了 HomeComponent 类来注入 HomeFragment

package com.ibrahim.home

import androidx.fragment.app.Fragment
import com.ibrahim.currencyconverter.di.AppDependencies
import dagger.BindsInstance
import dagger.Component
import kotlinx.coroutines.ExperimentalCoroutinesApi
import javax.inject.Singleton

@Singleton
@Component(dependencies = [AppDependencies::class],modules = [HomeModule::class])
interface HomeComponent {

    @ExperimentalCoroutinesApi
    fun inject(fragment: HomeFragment)

    fun fragment(): Fragment

    @Component.Builder
    interface Builder {
        fun fragment(@BindsInstance fragment: Fragment): Builder
        fun appDependencies(appDependencies: AppDependencies): Builder
        fun build(): HomeComponent
    }

}

HomeModule 类提供 home 模块依赖

package com.ibrahim.home

import com.ibrahim.currencyconverter.di.AppModule
import com.ibrahim.currencyconverter.di.FragmentviewmodelModule
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.FragmentComponent
import kotlinx.coroutines.ExperimentalCoroutinesApi
import retrofit2.Retrofit

@Module(
    includes = [
        FragmentviewmodelModule::class,AppModule::class
    ]
)
@InstallIn(FragmentComponent::class)
object HomeModule {

    @Provides
    fun provideHomeRemoteDataSource(retrofit: Retrofit): IHomeRemoteDataSource {
        return retrofit.create(IHomeRemoteDataSource::class.java)
    }

    @ExperimentalCoroutinesApi
    @Provides
    fun provideHomeRepository(repository: HomeRepository): IHomeRepository {
        return repository
    }

}

Homeviewmodel 类

package com.ibrahim.home

import androidx.lifecycle.SavedStateHandle
import com.ibrahim.core.Coreviewmodel
import com.ibrahim.core.None
import com.ibrahim.core.exhaustive
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.collect
import timber.log.Timber

@ExperimentalCoroutinesApi
class Homeviewmodel @AssistedInject constructor(
    private val latestExchangeRateUseCase: LatestExchangeRateUseCase,@Assisted private val savedStateHandle: SavedStateHandle
) :
    Coreviewmodel<HomeIntent,HomeResult,HomeState>(HomeState.Idle) {

    override suspend fun handleIntent(intent: HomeIntent) {
        when (intent) {
            is HomeIntent.GetLatestExchangeRate -> {
                latestExchangeRateUseCase.execute(None()).collect {
                    updateState(it)
                }
            }
        }.exhaustive
    }

    override fun reduce(result: HomeResult): HomeState {
        return when (result) {
            is HomeResult.Loading -> {
                HomeState.Loading
            }
            is HomeResult.ExchangeRateSuccess -> {
                HomeState.ExchangeRateSuccess(result.exchangeRates)
            }
            is HomeResult.ExchangeRateFailure -> {
                HomeState.ExchangeRateFailure(result.failure)
            }
        }.exhaustive
    }

    override fun onCleared() {
        Timber.i("Homeviewmodel: onCleared()")
        super.onCleared()
    }

}

最后是 HomeFragment 类

package com.ibrahim.home

import android.content.Context
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewmodels
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.DividerItemdecoration
import com.ibrahim.core.Failure
import com.ibrahim.core.exhaustive
import com.ibrahim.currencyconverter.di.AppDependencies
import com.ibrahim.currencyconverter.di.DFMSavedStateviewmodelFactory
import com.ibrahim.currencyconverter.exchangerate.ExchangeRateData
import com.ibrahim.home.databinding.FragmentHomeBinding
import dagger.hilt.android.EntryPointAccessors
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch
import timber.log.Timber
import java.net.socketTimeoutException
import javax.inject.Inject

@ExperimentalCoroutinesApi
class HomeFragment : Fragment() {

    private var _binding: FragmentHomeBinding? = null

    // This property is only valid between onCreateView and
    // onDestroyView.
    private val binding get() = _binding!!

    @Inject
    lateinit var savedStateviewmodelFactory: DFMSavedStateviewmodelFactory

    private val viewmodel by viewmodels<Homeviewmodel> { savedStateviewmodelFactory }

    private val adapter: ExchangeRatesAdapter by lazy {
        ExchangeRatesAdapter {
            val base =
                if (viewmodel.state.value is HomeState.ExchangeRateSuccess) {
                    (viewmodel.state.value as HomeState.ExchangeRateSuccess).exchangeRates.base
                } else {
                    ""
                }
            findNavController().navigate(
                HomeFragmentDirections.actionHomeFragmentToExchangeRateFragment(
                    ExchangeRateData(
                        base = base,target = it.name,rate = it.rate
                    )
                )
            )
        }
    }

    override fun onAttach(context: Context) {
        super.onAttach(context)
        DaggerHomeComponent.builder()
            .fragment(this)
            .appDependencies(
                EntryPointAccessors.fromApplication(
                    requireContext().applicationContext,AppDependencies::class.java
                )
            )
            .build()
            .inject(this)
    }

    override fun onCreateView(
        inflater: LayoutInflater,container: ViewGroup?,savedInstanceState: Bundle?
    ): View {
        // Inflate the layout for this fragment
        _binding = FragmentHomeBinding.inflate(inflater,container,false)
        return binding.root
    }

    override fun onViewCreated(view: View,savedInstanceState: Bundle?) {
        super.onViewCreated(view,savedInstanceState)

        binding.rvRates.addItemdecoration(
            DividerItemdecoration(
                requireContext(),DividerItemdecoration.VERTICAL
            )
        )
        binding.rvRates.setHasFixedSize(true)
        binding.rvRates.adapter = adapter

        lifecycleScope.launchWhenStarted {
            viewmodel.state.collect { state ->
                render(state)
            }
        }

    }

    private fun render(state: HomeState) {
        when (state) {
            is HomeState.Idle -> {
                binding.progressBar.visibility = View.VISIBLE
            }

            is HomeState.Loading -> {
                binding.progressBar.visibility = View.VISIBLE
            }

            is HomeState.ExchangeRateSuccess -> {
                onLatestExchangeRateSuccess(state.exchangeRates)
                binding.progressBar.visibility = View.GONE
            }

            is HomeState.ExchangeRateFailure -> {
                onLatestExchangeRateFailure(state.failure)
                binding.progressBar.visibility = View.GONE
            }
        }.exhaustive
    }

    private fun onLatestExchangeRateSuccess(exchangeRates: ExchangeRates) {
        Timber.i("latestExchangeRate: ${exchangeRates.exchangeRates.size}")
        requireActivity().title = exchangeRates.base
        if (adapter.items.isNullOrEmpty()) {
            adapter.items.addAll(exchangeRates.exchangeRates)
            adapter.notifyDataSetChanged()
        }
    }

    private fun onLatestExchangeRateFailure(failure: Failure) {
        Timber.i("latestExchangeRateFailure: $failure")
        var errorMessage: String = getString(R.string.something_went_wrong_please_try_again_later)
        when (failure) {
            is Failure.NetworkConnection -> {
                errorMessage =
                    if (failure.throwable is SocketTimeoutException)
                        getString(R.string.looks_like_the_server_is_taking_too_long_to_respond_please_try_again_later)
                    else
                        getString(R.string.no_internet_connection)
            }
            is Failure.ServerError -> {
                errorMessage = getString(R.string.no_internet_connection)
            }
            is Failure.FeatureFailure -> {
            }
        }
        Toast.makeText(
            requireContext(),errorMessage,Toast.LENGTH_SHORT
        ).show()
    }

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        if (viewmodel.state.value !is HomeState.ExchangeRateSuccess) {
            lifecycleScope.launch {
                viewmodel dispatch HomeIntent.GetLatestExchangeRate
            }
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        Timber.i("onDestroyView")
    }

    override fun onDetach() {
        super.onDetach()
        Timber.i("onDetach")
    }

    override fun onDestroy() {
        super.onDestroy()
        Timber.i("onDestroy")
    }

}

由于以下错误，我无法构建项目，我不知道出了什么问题以及如何修复它。另外，我检查了 hilt-multi-module documentation

/home/ibrahim/Android/Projects/CurrencyConverter/home/build/tmp/kapt3/stubs/debug/com/ibrahim/home/HomeComponent.java:8: error: [Dagger/MissingBinding] java.util.Map<java.lang.String,javax.inject.Provider<androidx.hilt.lifecycle.viewmodelAssistedFactory<? extends androidx.lifecycle.viewmodel>>> cannot be provided without an @Provides-annotated method.
public abstract interface HomeComponent {
                ^
      java.util.Map<java.lang.String,javax.inject.Provider<androidx.hilt.lifecycle.viewmodelAssistedFactory<? extends androidx.lifecycle.viewmodel>>> is injected at
          com.ibrahim.currencyconverter.di.FragmentviewmodelModule.provideSavedStateviewmodelFactory(…,viewmodelFactories)
      com.ibrahim.currencyconverter.di.DFMSavedStateviewmodelFactory is injected at
          com.ibrahim.home.HomeFragment.savedStateviewmodelFactory
      com.ibrahim.home.HomeFragment is injected at
          com.ibrahim.home.HomeComponent.inject(com.ibrahim.home.HomeFragment)warning: The following options were not recognized by any processor: '[dagger.hilt.android.internal.disableAndroidSuperclassValidation,kapt.kotlin.generated]'

解决方法

确定你想要在 viewmodel 中的依赖

@AssistedFactory
interface HomeViewModelFactory {
    fun create(handle: SavedStateHandle): HomeViewModel
}

class HomeViewModel @AssistedInject constructor(
    private val latestExchangeRateUseCase: LatestExchangeRateUseCase,@Assisted private val savedStateHandle: SavedStateHandle
) : CoreViewModel<HomeIntent,HomeResult,HomeState>(HomeState.Idle) {

    companion object {
        fun provideFactory(
            assistedFactory: HomeViewModelFactory,owner: SavedStateRegistryOwner,defaultArgs: Bundle? = null,): AbstractSavedStateViewModelFactory =
            object : AbstractSavedStateViewModelFactory(owner,defaultArgs) {
                override fun <T : ViewModel?> create(
                    key: String,modelClass: Class<T>,handle: SavedStateHandle
                ): T {
                    return assistedFactory.create(handle) as T
                }

            }
    }
}

并提供依赖

class HomeFragment : Fragment() {
    @Inject
    lateinit var homeViewModelFactory: HomeViewModelFactory

    private val viewModel: HomeViewModel by viewModels {
        HomeViewModel.provideFactory(homeViewModelFactory,this)
    }
}