Membuat ViewModel dengan dependensi   Bagian dari Android Jetpack.

Mengikuti praktik terbaik injeksi dependensi, ViewModel dapat mengambil dependensi sebagai parameter dalam konstruktornya. Sebagian besar jenis ini berasal dari lapisan domain atau data. Karena framework ini menyediakan ViewModel, mekanisme khusus diperlukan untuk membuat instance darinya. Mekanisme tersebut adalah antarmuka ViewModelProvider.Factory. Hanya penerapan antarmuka ini yang dapat membuat instance ViewModel dalam cakupan yang tepat.

Catatan: Jika ViewModel tidak menggunakan dependensi atau hanya jenis SavedStateHandle sebagai dependensi, Anda tidak perlu menyediakan factory untuk framework guna membuat instance jenis ViewModel tersebut.

Catatan: Saat memasukkan ViewModel menggunakan Hilt sebagai solusi injeksi dependensi, Anda tidak perlu menentukan factory ViewModel secara manual. Hilt menghasilkan factory yang mengetahui cara membuat semua ViewModel yang dianotasikan dengan @HiltViewModel untuk Anda pada waktu kompilasi. Class yang dianotasikan dengan @AndroidEntryPoint dapat langsung mengakses factory yang dihasilkan Hilt saat memanggil API ViewModel reguler.

ViewModel dengan CreationExtras

Jika class ViewModel menerima dependensi dalam konstruktornya, sediakan factory yang mengimplementasikan antarmuka ViewModelProvider.Factory. Ganti fungsi create(Class<T>, CreationExtras) untuk memberikan instance baru ViewModel.

CreationExtras memungkinkan Anda mengakses informasi relevan yang membantu membuat instance ViewModel. Berikut adalah daftar kunci yang dapat diakses dari tambahan:

Kunci	Fungsi
ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY	Menyediakan akses ke kunci kustom yang Anda teruskan ke ViewModelProvider.get().
ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY	Menyediakan akses ke instance class Application.
SavedStateHandleSupport.DEFAULT_ARGS_KEY	Memberikan akses ke Paket argumen yang harus Anda gunakan untuk membuat SavedStateHandle.
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY	Memberikan akses ke SavedStateRegistryOwner yang sedang digunakan untuk membuat ViewModel.
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY	Memberikan akses ke ViewModelStoreOwner yang sedang digunakan untuk membuat ViewModel.

Untuk membuat instance SavedStateHandle baru, gunakan CreationExtras.createSavedStateHandle() dan meneruskannya ke ViewModel.

CreationExtras dengan APPLICATION_KEY

Berikut adalah contoh cara menyediakan instance ViewModel yang mengambil repositori yang dicakup ke class Application dan SavedStateHandle sebagai dependensi:

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);
        }
    );
}

Catatan: Sebaiknya tempatkan factory ViewModel dalam file ViewModel untuk konteks yang lebih baik, keterbacaan, dan penemuan yang lebih mudah. ViewModel yang sama factory dapat digunakan untuk beberapa ViewModels saat berbagi dependensi, seperti Hal ini berlaku untuk contoh Blueprint Arsitektur.

Kemudian, Anda dapat menggunakan factory ini saat mengambil instance 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)
) {
    // ...
}

Atau, gunakan DSL factory ViewModel untuk membuat factory menggunakan API Kotlin yang lebih idiomatis:

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
                )
            }
        }
    }
}

Meneruskan parameter kustom sebagai CreationExtras

Anda dapat meneruskan dependensi ke ViewModel melalui CreationExtras dengan membuat kunci kustom. Hal ini dapat berguna jika ViewModel Anda bergantung pada objek yang tidak dapat diakses melalui class Application dan APPLICATION_KEY. Contoh ini adalah saat ViewModel Anda dibuat di dalam Kotlin Modul multiplatform sehingga tidak memiliki akses ke dependensi Android.

Dalam contoh ini, ViewModel menentukan kunci kustom dan menggunakannya di 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,
                )
            }
        }
    }
}

Anda dapat membuat instance ViewModel dengan CreationExtras.Key dari ViewModelStoreOwner seperti ComponentActivity, Fragment, atau NavBackStackEntry, atau dengan 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,
    )
}

Factory untuk ViewModel versi yang lebih lama dari 2.5.0

Jika menggunakan versi ViewModel yang lebih lama dari 2.5.0, Anda harus menyediakan factory dari subset class yang memperluas ViewModelProvider.Factory dan mengimplementasikan fungsi create(Class<T>). Tergantung pada dependensi kebutuhan ViewModel, class yang berbeda harus diperluas dari:

• AndroidViewModelFactory jika class Application diperlukan.
• AbstractSavedStateViewModelFactory jika SavedStateHandle harus diteruskan sebagai dependensi.

Jika Application atau SavedStateHandle tidak diperlukan, cukup perluas dari ViewModelProvider.Factory.

Contoh berikut menggunakan AbstractSavedStateViewModelFactory untuk ViewModel yang menggunakan repositori dan jenis SavedStateHandle sebagai dependensi:

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);
    }
}

Peringatan: jika menggunakan versi ViewModel yang lebih lama dari 2.5.0, Anda mungkin memiliki opsi untuk mengganti fungsi create dengan CreationExtras dalam tanda tangannya. Jangan ganti fungsi tersebut. Sebagai gantinya, ganti fungsi create yang memiliki parameter key, modelClass dan savedStateHandle.

Kemudian, Anda dapat menggunakan factory untuk mengambil 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
        )
    )
) {
    // ...
}