Criar ViewModels com dependências   Parte do Android Jetpack.

Seguindo as práticas recomendadas de injeção de dependência, os ViewModels podem usar dependências como parâmetros no construtor. Elas são principalmente de tipos das camadas de domínio ou de dados. Como o framework fornece os ViewModels, é necessário um mecanismo especial para criar as instâncias deles. Esse mecanismo é a interface ViewModelProvider.Factory. Somente implementações dessa interface podem instanciar ViewModels no escopo correto.

Observação: se o ViewModel não tiver dependências ou apenas o tipo SavedStateHandle como dependência, não será necessário fornecer uma fábrica para o framework instanciar instâncias desse tipo ViewModel.

Observação: ao injetar ViewModels usando o Hilt como uma solução de injeção de dependência, não é necessário definir uma fábrica ViewModel manualmente. O Hilt gera uma fábrica que sabe como criar todos os ViewModels anotados com @HiltViewModel para você durante a compilação. As classes anotadas com @AndroidEntryPoint podem acessar diretamente a fábrica gerada pelo Hilt ao chamar as APIs ViewModel comuns.

ViewModels com CreationExtras

Se uma classe ViewModel receber dependências no construtor, forneça uma fábrica que implemente a interface ViewModelProvider.Factory. Substitua a função create(Class<T>, CreationExtras) para fornecer uma nova instância do ViewModel.

O elemento CreationExtras permite que você acesse informações relevantes que ajudam a instanciar um ViewModel. Confira uma lista de chaves que podem ser acessadas nos extras:

Chave	Funcionalidade
ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY	Fornece acesso à chave personalizada transmitida para ViewModelProvider.get().
ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY	Fornece acesso à instância da classe Application.
SavedStateHandleSupport.DEFAULT_ARGS_KEY	Fornece acesso ao pacote de argumentos que você precisa usar para construir um SavedStateHandle.
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY	Fornece acesso ao SavedStateRegistryOwner usado para construir o ViewModel.
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY	Fornece acesso ao ViewModelStoreOwner usado para construir o ViewModel.

Para criar uma nova instância de SavedStateHandle, use a função CreationExtras.createSavedStateHandle() e transmita-a para o ViewModel.

CreationExtras com APPLICATION_KEY

Confira abaixo um exemplo de como fornecer uma instância de um ViewModel que usa um repositório com escopo para a classe Application e SavedStateHandle como dependências:

Kotlin

    import androidx.lifecycle.SavedStateHandle
    import androidx.lifecycle.ViewModel
    import androidx.lifecycle.ViewModelProvider
    import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
    import androidx.lifecycle.createSavedStateHandle
    import androidx.lifecycle.viewmodel.CreationExtras

    class MyViewModel(
        private val myRepository: MyRepository,
        private val savedStateHandle: SavedStateHandle
    ) : ViewModel() {

        // ViewModel logic
        // ...

        // Define ViewModel factory in a companion object
        companion object {

            val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
                @Suppress("UNCHECKED_CAST")
                override fun <T : ViewModel> create(
                    modelClass: Class<T>,
                    extras: CreationExtras
                ): T {
                    // Get the Application object from extras
                    val application = checkNotNull(extras[APPLICATION_KEY])
                    // Create a SavedStateHandle for this ViewModel from extras
                    val savedStateHandle = extras.createSavedStateHandle()

                    return MyViewModel(
                        (application as MyApplication).myRepository,
                        savedStateHandle
                    ) as T
                }
            }
        }
    }

Java

import static androidx.lifecycle.SavedStateHandleSupport.createSavedStateHandle;
import static androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY;

import androidx.lifecycle.SavedStateHandle;
import androidx.lifecycle.ViewModel;
import androidx.lifecycle.viewmodel.ViewModelInitializer;

public class MyViewModel extends ViewModel {

    public MyViewModel(
        MyRepository myRepository,
        SavedStateHandle savedStateHandle
    ) { /* Init ViewModel here */ }

    static final ViewModelInitializer<MyViewModel> initializer = new ViewModelInitializer<>(
        MyViewModel.class,
        creationExtras -> {
            MyApplication app = (MyApplication) creationExtras.get(APPLICATION_KEY);
            assert app != null;
            SavedStateHandle savedStateHandle = createSavedStateHandle(creationExtras);

            return new MyViewModel(app.getMyRepository(), savedStateHandle);
        }
    );
}

Observação: é recomendável colocar fábricas ViewModel no arquivo ViewModel para melhor contexto, legibilidade e descoberta mais fácil. A mesma fábrica do ViewModel pode ser usada para vários ViewModels quando elas compartilham dependências, como é o caso do exemplo Architecture Blueprints (link em inglês).

Em seguida, use essa fábrica ao extrair uma instância do ViewModel:

Kotlin

import androidx.activity.viewModels

class MyActivity : AppCompatActivity() {

    private val viewModel: MyViewModel by viewModels { MyViewModel.Factory }

    // Rest of Activity code
}

Java

import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.ViewModelProvider;

public class MyActivity extends AppCompatActivity {

MyViewModel myViewModel = new ViewModelProvider(
    this,
    ViewModelProvider.Factory.from(MyViewModel.initializer)
).get(MyViewModel.class);

// Rest of Activity code
}

Jetpack Compose

import androidx.lifecycle.viewmodel.compose.viewModel

@Composable
fun MyScreen(
    modifier: Modifier = Modifier,
    viewModel: MyViewModel = viewModel(factory = MyViewModel.Factory)
) {
    // ...
}

Como alternativa, use a DSL de fábrica ViewModel para criar fábricas usando uma API Kotlin mais idiomática:

import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
import androidx.lifecycle.createSavedStateHandle
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory

class MyViewModel(
    private val myRepository: MyRepository,
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    // ViewModel logic

    // Define ViewModel factory in a companion object
    companion object {
        val Factory: ViewModelProvider.Factory = viewModelFactory {
            initializer {
                val savedStateHandle = createSavedStateHandle()
                val myRepository = (this[APPLICATION_KEY] as MyApplication).myRepository
                MyViewModel(
                    myRepository = myRepository,
                    savedStateHandle = savedStateHandle
                )
            }
        }
    }
}

Transmitir parâmetros personalizados como CreationExtras

É possível transmitir dependências para o ViewModel por CreationExtras criando uma chave personalizada. Isso pode ser útil se o ViewModel depender de objetos que não são acessíveis pela classe Application e APPLICATION_KEY. Um exemplo é quando o ViewModel é criado em um módulo multiplataforma do Kotlin e, portanto, não tem acesso às dependências do Android.

Neste exemplo, o ViewModel define uma chave personalizada e a usa no ViewModelProvider.Factory.

import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory

class MyViewModel(
    private val myRepository: MyRepository,
) : ViewModel() {
    // ViewModel logic

    // Define ViewModel factory in a companion object
    companion object {

        // Define a custom key for your dependency
        val MY_REPOSITORY_KEY = object : CreationExtras.Key<MyRepository> {}

        val Factory: ViewModelProvider.Factory = viewModelFactory {
            initializer {
                // Get the dependency in your factory
                val myRepository = this[MY_REPOSITORY_KEY] as MyRepository
                MyViewModel(
                    myRepository = myRepository,
                )
            }
        }
    }
}

Você pode instanciar um ViewModel com um CreationExtras.Key usando um ViewModelStoreOwner, como ComponentActivity, Fragment ou NavBackStackEntry, ou com o Jetpack Compose.

Kotlin

import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelStoreOwner
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.MutableCreationExtras
// ...
    // Use from ComponentActivity, Fragment, NavBackStackEntry,
    // or another ViewModelStoreOwner.
    val viewModelStoreOwner: ViewModelStoreOwner = this
    val myViewModel: MyViewModel = ViewModelProvider.create(
        viewModelStoreOwner,
        factory = MyViewModel.Factory,
        extras = MutableCreationExtras().apply {
            set(MyViewModel.MY_REPOSITORY_KEY, myRepository)
        },
    )[MyViewModel::class]

Jetpack Compose

import androidx.lifecycle.viewmodel.MutableCreationExtras
import androidx.lifecycle.viewmodel.compose.viewModel
// ...
@Composable
fun MyApp(myRepository: MyRepository) {
    val extras = MutableCreationExtras().apply {
        set(MyViewModel.MY_REPOSITORY_KEY, myRepository)
    }
    val viewModel: MyViewModel = viewModel(
        factory = MyViewModel.Factory,
        extras = extras,
    )
}

Fábricas para versões do ViewModel anteriores à 2.5.0

Se você estiver usando uma versão do ViewModel anterior à 2.5.0, será necessário fornecer fábricas de um subconjunto de classes que estendem ViewModelProvider.Factory e implementar a função create(Class<T>). Dependendo das dependências necessárias para o ViewModel, uma classe diferente precisa ser estendida de:

• AndroidViewModelFactory se a classe Application for necessária.
• AbstractSavedStateViewModelFactory se for necessário transmitir SavedStateHandle como uma dependência.

Se os elementos Application e SavedStateHandle não forem necessários, basta estender a ViewModelProvider.Factory.

O exemplo abaixo usa uma AbstractSavedStateViewModelFactory para um ViewModel que usa um repositório e um tipo SavedStateHandle como dependência:

Kotlin

class MyViewModel(
private val myRepository: MyRepository,
private val savedStateHandle: SavedStateHandle
) : ViewModel() {

// ViewModel logic ...

// Define ViewModel factory in a companion object
companion object {
    fun provideFactory(
        myRepository: MyRepository,
        owner: SavedStateRegistryOwner,
        defaultArgs: Bundle? = null,
    ): AbstractSavedStateViewModelFactory =
        object : AbstractSavedStateViewModelFactory(owner, defaultArgs) {
            @Suppress("UNCHECKED_CAST")
            override fun <T : ViewModel> create(
                key: String,
                modelClass: Class<T>,
                handle: SavedStateHandle
            ): T {
                return MyViewModel(myRepository, handle) as T
            }
        }
    }
}

Java

import androidx.annotation.NonNull;
import androidx.lifecycle.AbstractSavedStateViewModelFactory;
import androidx.lifecycle.SavedStateHandle;
import androidx.lifecycle.ViewModel;

public class MyViewModel extends ViewModel {
    public MyViewModel(
        MyRepository myRepository,
        SavedStateHandle savedStateHandle
    ) { /* Init ViewModel here */ }
}

public class MyViewModelFactory extends AbstractSavedStateViewModelFactory {

    private final MyRepository myRepository;

    public MyViewModelFactory(
        MyRepository myRepository
    ) {
        this.myRepository = myRepository;
    }

    @SuppressWarnings("unchecked")
    @NonNull
    @Override
    protected <T extends ViewModel> T create(
        @NonNull String key, @NonNull Class<T> modelClass, @NonNull SavedStateHandle handle
    ) {
        return (T) new MyViewModel(myRepository, handle);
    }
}

Aviso: se você estiver usando uma versão do ViewModel anterior à 2.5.0, talvez encontre a opção de substituir uma função de criação por CreationExtras nessa assinatura. Não faça essa substituição. Em vez disso, substitua a função create que tem os parâmetros key, modelClass e savedStateHandle.

Em seguida, use a fábrica para extrair o ViewModel:

Kotlin

import androidx.activity.viewModels

class MyActivity : AppCompatActivity() {

    private val viewModel: MyViewModel by viewModels {
        MyViewModel.provideFactory((application as MyApplication).myRepository, this)
    }

    // Rest of Activity code
}

Java

import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.ViewModelProvider;

public class MyActivity extends AppCompatActivity {

    MyViewModel myViewModel = new ViewModelProvider(
        this,
        ViewModelProvider.Factory.from(MyViewModel.initializer)
    ).get(MyViewModel.class);

    // Rest of Activity code
}

Jetpack Compose

import androidx.lifecycle.viewmodel.compose.viewModel

@Composable
fun MyScreen(
    modifier: Modifier = Modifier,
    viewModel: MyViewModel = viewModel(
        factory = MyViewModel.provideFactory(
            (LocalContext.current.applicationContext as MyApplication).myRepository,
            owner = LocalSavedStateRegistryOwner.current
        )
    )
) {
    // ...
}