Início / coding / Perguntas / 79595192
Accepted
Cristi
Asked: 2025-04-27 23:27:46 +0800 CST

Como corrigir "Não é possível criar uma instância da classe ViewModel" ao usar o Hilt?

  • 772

Estou fazendo um curso do JetPack Compose e estou tentando executar um projeto de exemplo mostrando o uso do ViewModel junto com o Hilt.

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()

        setContent {
            Surface(color = MaterialTheme.colorScheme.background) {
                val noteViewModel: NoteViewModel = hiltViewModel<NoteViewModel>()
                // NoteApp(noteViewModel)
            }
        }
    }
}

Para inicializar o ViewModel eu também tentei

 noteViewModel by viewModels()

e

 noteViewModel = hiltViewModel()

O código do ViewModel é o seguinte:

@HiltViewModel
class NoteViewModel @Inject constructor(private val repository: NoteRepository) : ViewModel() {
    //private var noteList = mutableStateListOf<Note>()

    private val _noteList = MutableStateFlow<List<Note>>(emptyList())
    val noteList = _noteList.asStateFlow()

    init {
        //noteList.addAll(NotesDataSource.loadDataNotes())
        viewModelScope.launch(Dispatchers.IO) {
            repository.getAllNotes().distinctUntilChanged().collect { listOfNotes ->
                if (listOfNotes.isEmpty()) {
                    Log.d("JetNote", "EmptyList")
                } else {
                    _noteList.value = listOfNotes
                }
            }
        }
    }

    fun addNote(note: Note) = viewModelScope.launch {
        repository.addNote(note)
    }

    fun updateNote(note: Note) = viewModelScope.launch {
        repository.updateNote(note)
    }

    fun removeNote(note: Note) = viewModelScope.launch {
        repository.deleteNote(note)
    }
}

A configuração do AppModule para o Hilt é a seguinte:

@InstallIn(SingletonComponent::class)
@Module
object AppModule {

    @Singleton
    @Provides
    fun provideNotesDao(noteDatabase: NoteDatabase) : NoteDatabaseDao = noteDatabase.noteDao()

    @Singleton
    @Provides
    fun provideAppDatabase(@ApplicationContext context: Context) : NoteDatabase =
        Room.databaseBuilder(
            context,
            NoteDatabase::class.java,
            "notes_db"
        ).fallbackToDestructiveMigration().build()
}

Código do NoteRepository:

class NoteRepository @Inject constructor(private val noteDatabaseDao: NoteDatabaseDao) {
    suspend fun addNote(note: Note) = noteDatabaseDao.insert(note)
    suspend fun updateNote(note: Note) = noteDatabaseDao.update(note)
    suspend fun deleteNote(note: Note) = noteDatabaseDao.deleteNote(note)
    suspend fun deleteAllNotes() = noteDatabaseDao.deleteAll()
    fun getAllNotes(): Flow<List<Note>> = noteDatabaseDao.getNotes().flowOn(Dispatchers.IO).conflate()
}

O erro que recebo ao executar o aplicativo é:

java.lang.RuntimeException: Cannot create an instance of class com.course.jetnote.screens.NoteViewModel
........................
Caused by: java.lang.NoSuchMethodException: com.course.jetnote.screens.NoteViewModel.<init> []

E esta é minha configuração do Gradle:

build.gradle.kts:

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.kotlin.compose)
}

android {
    namespace = "com.course.jetnote"
    compileSdk = 35

    defaultConfig {
        applicationId = "com.course.jetnote"
        minSdk = 26
        targetSdk = 35
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    kotlinOptions {
        jvmTarget = "11"
    }
    buildFeatures {
        compose = true
    }

    packaging {
        resources {
            excludes += "/META-INF/gradle/incremental.annotation.processors"
            excludes += "META-INF/androidx/room/room-compiler-processing/LICENSE.txt"
        }
    }

}

configurations.implementation {
    exclude(group = "org.jetbrains", module = "annotations")
}


dependencies {

    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
    implementation(libs.androidx.activity.compose)
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.ui)
    implementation(libs.androidx.ui.graphics)
    implementation(libs.androidx.ui.tooling.preview)
    implementation(libs.androidx.material3)
    implementation(libs.androidx.lifecycle.viewModelCompose)
    implementation(libs.hilt.android)
    implementation(libs.hilt.compiler)
    implementation(libs.androidx.hilt.navigation.compose)
    implementation(libs.room.ktx)
    implementation(libs.room.runtime)
    implementation(libs.room.compiler)
    implementation(libs.kotlinx.coroutines.android)
    implementation(libs.androidx.room.runtime.android)

    testImplementation(libs.junit)
    androidTestImplementation(libs.androidx.junit)
    androidTestImplementation(libs.androidx.espresso.core)
    androidTestImplementation(platform(libs.androidx.compose.bom))
    androidTestImplementation(libs.androidx.ui.test.junit4)
    debugImplementation(libs.androidx.ui.tooling)
    debugImplementation(libs.androidx.ui.test.manifest)
}

lib.versions.toml:

[versions]
agp = "8.8.2"
kotlin = "2.0.0"
coreKtx = "1.15.0"
junit = "4.13.2"
junitVersion = "1.2.1"
espressoCore = "3.6.1"
lifecycleRuntimeKtx = "2.8.7"
activityCompose = "1.10.1"
composeBom = "2024.04.01"
androidxLifecycle = "2.8.7"

androidxHiltNavigationCompose = "1.0.0"
hilt = "2.56.2"
hiltExt = "1.0.0"

room = "2.6.0"

kotlinxCoroutines = "1.10.0"
kotlinxDatetime = "0.6.0"
kotlinxSerializationJson = "1.8.0"
roomRuntimeAndroid = "2.7.1"

[libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
 junit = { group = "junit", name = "junit", version.ref = "junit" }
 androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
 androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
 androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
 androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
 androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
 androidx-ui = { group = "androidx.compose.ui", name = "ui" }
 androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
 androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
 androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
 androidx-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
 androidx-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
 androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
 androidx-lifecycle-viewModelCompose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "androidxLifecycle" }


hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
hilt-compiler = { group = "com.google.dagger", name = "hilt-android-compiler", version.ref = "hilt" }
hilt-ext-compiler = { group = "androidx.hilt", name = "hilt-compiler", version.ref = "hiltExt" }
androidx-hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navigation-compose", version.ref = "androidxHiltNavigationCompose" }



#Database
room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }

#Kotlin Coroutines, serialization, datetime...
kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "kotlinxCoroutines" }
kotlinx-datetime = { group = "org.jetbrains.kotlinx", name = "kotlinx-datetime", version.ref = "kotlinxDatetime" }
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
androidx-room-runtime-android = { group = "androidx.room", name = "room-runtime-android", version.ref = "roomRuntimeAndroid" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }

1 respostas

  1. Best Answer

    O Hilt (e o Room) não estão configurados corretamente nos seus arquivos Gradle. Para corrigir, siga estes passos:

    1. Primeiro, você precisa do plugin Kotlin Symbol Processing (KSP) para que o Hilt possa gerar o código-fonte durante a compilação. Você precisa disso no seu catálogo de versões:

      [versions]
ksp = "2.0.0-1.0.24"

[plugins]
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

      A versão do KSP consiste em duas partes. A primeira parte deve sempre corresponder à sua versão do Kotlin. Como você está usando o Kotlin 2.0.0, esta é a versão que você deve usar. A segunda parte é a versão do KSP propriamente dita. Sempre que você atualizar sua versão do Kotlin, também precisará atualizar o KSP. Você pode encontrar uma lista de todas as versões do KSP aqui: https://github.com/google/ksp/releases

      Agora use-o em seus arquivos Gradle como você faz com os outros plugins:

      alias(libs.plugins.ksp) apply false

      respectivamente

      alias(libs.plugins.ksp)

    2. Agora que você tem o KSP disponível, você precisa mudar sua dependência

      implementation(libs.hilt.compiler)

      para

      ksp(libs.hilt.compiler)

      Você também precisa adicionar o plugin Hilt Gradle, como você adicionou o KSP acima:

      [plugins]
hilt-android = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }

      e

      alias(libs.plugins.hilt.android) apply false

      respectivamente

      alias(libs.plugins.hilt.android)

    Isso deve resolver, o Hilt deve funcionar agora.

    Você ainda tem problemas com as dependências do seu Room, então seu aplicativo ainda não funcionará.

    Primeiro, misture as diferentes versões de Room room = "2.6.0"e roomRuntimeAndroid = "2.7.1". Isso não vai funcionar, você sempre precisa usar a mesma versão. Então, vamos substituir ambas por isto:

    room = "2.7.1"

    Além disso, você não precisa usar explicitamente a biblioteca androidx-room-runtime-android, então você pode simplesmente removê-la do catálogo de versões e seu uso implementation(libs.androidx.room.runtime.android)no seu arquivo gradle.

    Agora, você tem um problema semelhante ao que teve com o Hilt: você precisa substituir

    implementation(libs.room.compiler)

    com

    ksp(libs.room.compiler)

    Você já tem o KSP instalado, então isso é tudo o que precisa. Seu aplicativo deve estar funcionando agora.

    Em relação aos blocos packaginge configurations.implementationno seu arquivo Gradle que você mencionou nos comentários, não vejo como isso seja necessário. Você provavelmente deveria removê-los por enquanto e deixar esse tipo de otimização para depois, se for o caso.

    Apenas dois pontos de interesse adicionais que você pode querer dar uma olhada:

    1. Há também um plugin para Gradle disponível. Embora não seja obrigatório, ele ajuda na migração de bancos de dados de uma versão para outra.

    2. Como já mencionado nos comentários, o seu tratamento de fluxo está muito errado. A única coisa que você precisa no modelo de visualização é isto:

      val noteList: StateFlow<List<Note>> = repository.getAllNotes().stateIn(
    scope = viewModelScope,
    started = SharingStarted.WhileSubscribed(5.seconds),
    initialValue = emptyList(),
)

      Isso simplesmente converte o fluxo do banco de dados do repositório em um StateFlow. É tudo o que precisa: você pode remover o initbloco e o MutableStateFlow _noteList.
      Como regra geral, nunca colete fluxos no modelo de visualização. Se precisar processar o conteúdo de um fluxo (o que não é feito aqui, mas talvez você queira fazer no futuro), você pode usar as diversas funções de transformação disponíveis para fluxos, como map, flatMapLatest, combinee assim por diante.

      Da mesma forma, .flowOn(Dispatchers.IO).conflate()é redundante no seu repositório. Com corrotinas Kotlin, a parte do código que realmente executa o trabalho crítico é responsável por alternar para o despachante apropriado. Neste caso, isso acontece internamente na biblioteca Room. Portanto, você não precisa especificar o despachante posteriormente. E como os StateFlows são sempre combinados (e você não faz nada caro até que o fluxo do banco de dados seja convertido para um StateFlow), você também não precisa fazer isso explicitamente aqui.

    • 0

relate perguntas