יצירת מודלים של ViewModel עם יחסי תלות   חלק מ-Android Jetpack.

בהתאם לשיטות המומלצות להזרקת יחסי תלות, ניתן להשתמש במודלים של ViewModel כפרמטרים ב-constructor שלהם. אלה בעיקר סוגים משכבות הדומיין או הנתונים. מכיוון שהמסגרת מספקת את ה-ViewModels, נדרש מנגנון מיוחד כדי ליצור מהם מופעים. הממשק הזה הוא ViewModelProvider.Factory. רק הטמעות של הממשק הזה יכולות ליצור מופע של ViewModels בהיקף הנכון.

הערה: אם ל-ViewModel אין יחסי תלות או רק הסוג SavedStateHandle בתור יחסי תלות, לא צריך לספק מפעל כדי שהמסגרת תיצור מכונות של הסוג ViewModel.

הערה: כשמזריקים ViewModels באמצעות Hilt כפתרון להזרקת יחסי תלות, לא צריך להגדיר מפעל ViewModel באופן ידני. ‏Hilt יוצר עבורכם במהלך הידור מפעל שידע ליצור את כל ה-ViewModels עם ההערה @HiltViewModel. לכיתות שיש להן הערות עם @AndroidEntryPoint יש גישה ישירה ל-Hilt Generate Manufacturer ('מפעל שנוצר על ידי Hilt)' כשמפעילים את ממשקי ה-API הרגילים של ViewModel.

ViewModels עם CreationExtras

אם מחלקה מסוג ViewModel מקבלת יחסי תלות ב-constructor שלה, צריך לספק מפעל שמטמיע את הממשק ViewModelProvider.Factory. משנים את הפונקציה create(Class<T>, CreationExtras) כדי לספק מופע חדש של ViewModel.

CreationExtras מאפשר לגשת למידע רלוונטי שעוזר ליצור מופע של ViewModel. זו רשימה של מפתחות שאפשר לגשת אליהם מהתכונות הנוספות:

מפתח	הפונקציונליות
ViewModelProvider.NewInstanceFactory.VIEW_MODEL_KEY	מספק גישה למפתח בהתאמה אישית שהעברתם אל ViewModelProvider.get().
ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY	מספק גישה למכונה של הכיתה Application.
SavedStateHandleSupport.DEFAULT_ARGS_KEY	מספקת גישה לחבילת הארגומנטים שבהם צריך להשתמש כדי ליצור את SavedStateHandle.
SavedStateHandleSupport.SAVED_STATE_REGISTRY_OWNER_KEY	מספק גישה ל-SavedStateRegistryOwner שמשמש ליצירת ה-ViewModel.
SavedStateHandleSupport.VIEW_MODEL_STORE_OWNER_KEY	מספק גישה ל-ViewModelStoreOwner שמשמש ליצירת ה-ViewModel.

כדי ליצור מופע חדש של SavedStateHandle, משתמשים בפונקציה CreationExtras.createSavedStateHandle() ומעבירים אותה ל-ViewModel.

CreationExtras עם APPLICATION_KEY

הדוגמה הבאה היא איך לציין מכונה של ViewModel עם מאגר בהיקף למחלקה Application, ו-SavedStateHandle כיחסי תלות:

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

הערה: מומלץ להציב מפעלים ViewModel בקובץ ViewModel שלהם כדי לשפר את ההקשר, הקריאוּת והגילוי בקלות. אפשר להשתמש באותו מפעל של ViewModel לכמה ViewModels כשיש להם יחסי תלות משותפים, כמו בדוגמה של Architecture Blueprints.

לאחר מכן תוכלו להשתמש במפעל הזה כשאתם מאחזרים מופע של 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 פיתוח נייטיב

import androidx.lifecycle.viewmodel.compose.viewModel

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

לחלופין, אפשר להשתמש ב-DSL של המפעל ViewModel כדי ליצור מפעלים באמצעות ממשק API של 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.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
                )
            }
        }
    }
}

העברת פרמטרים מותאמים אישית כ-CreationExtras

אפשר להעביר יחסי תלות ל-ViewModel דרך CreationExtras על ידי יצירת מפתח מותאם אישית. האפשרות הזו שימושית אם ViewModel תלוי באובייקטים שלא ניתן לגשת אליהם דרך הכיתה Application ו-APPLICATION_KEY. דוגמה לכך היא כאשר ViewModel נוצר בתוך מודול Kotlin ל-Multiplatform, ולכן אין לו גישה ליחסי התלות ב-Android.

בדוגמה הזו, ה-ViewModel מגדיר מפתח מותאם אישית ומשתמש בו ב-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,
                )
            }
        }
    }
}

אפשר ליצור מופע של ViewModel עם CreationExtras.Key מ-ViewModelStoreOwner כמו ComponentActivity,‏ Fragment או NavBackStackEntry, או באמצעות 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 פיתוח נייטיב

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

מפעלים לגרסת ViewModel מלפני יותר מ-2.5.0

אם אתם משתמשים בגרסה ישנה יותר של ViewModel, בגרסה 2.5.0 ומטה, תצטרכו לספק מפעלים מקבוצת משנה של כיתות שמרחיבות את ViewModelProvider.Factory ומטמיעות את הפונקציה create(Class<T>). בהתאם ליחסי התלות של ViewModel, צריך להרחיב את הכיתה אחרת מ:

• AndroidViewModelFactory אם צריך את הכיתה Application.
• AbstractSavedStateViewModelFactory אם צריך להעביר את SavedStateHandle כיחס תלות.

אם אין צורך ב-Application או ב-SavedStateHandle, פשוט מרחיבים מ-ViewModelProvider.Factory.

בדוגמה הבאה נעשה שימוש ב-AbstractSavedStateViewModelFactory ל-ViewModel שמקבל מאגר וסוג SavedStateHandle כיחסי תלות:

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

אזהרה: אם משתמשים בגרסה של ViewModel ישנה יותר מ-2.5.0, יכול להיות שתהיה אפשרות לשנות את פונקציית Create בחתימה שלה, תוך שימוש ב-CreationExtras. אין לבטל את הפונקציה הזו. במקום זאת, צריך לשנות את ברירת המחדל של הפונקציה create עם הפרמטרים key, modelClass ו-savedStateHandle.

לאחר מכן, אפשר להשתמש בהגדרות היצרן כדי לאחזר את ה-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 פיתוח נייטיב

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
        )
    )
) {
    // ...
}