ViewModel creation in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a ViewModel in Android development?

A ViewModel is a class that holds UI data and survives configuration changes like screen rotations. It helps keep data separate from UI controllers like Activities or Fragments.

beginner

How do you create a simple ViewModel class in Kotlin?

You create a class that extends <code>ViewModel</code>. For example:<br><pre>class MyViewModel : ViewModel() { }</pre>

beginner

Why should UI data be stored in a ViewModel instead of an Activity?

Because ViewModel survives configuration changes, it prevents data loss when the screen rotates. Activities get destroyed and recreated, losing their data.

intermediate

How do you obtain a ViewModel instance inside an Activity?

Use the ViewModelProvider like this:

val model = ViewModelProvider(this).get(MyViewModel::class.java)

intermediate

What is the benefit of using LiveData inside a ViewModel?

LiveData holds data that UI can observe. It updates the UI automatically when data changes, and respects lifecycle to avoid crashes.

What does a ViewModel help with in Android apps?

A Managing network connections

B Drawing UI elements on screen

C Keeping UI data during screen rotations

D Handling user input events

ViewModel keeps UI data safe during configuration changes like screen rotations.

Which class should your ViewModel extend?

A Activity

B ViewModel

C Fragment

D Application

A ViewModel class must extend the Android ViewModel class.

How do you get a ViewModel instance in an Activity?

A new ViewModel()

B findViewById()

C getSystemService()

D ViewModelProvider(this).get()

Use ViewModelProvider with the Activity context to get the ViewModel.

What happens to data stored in an Activity when the screen rotates?

A It is lost unless saved

B It is preserved automatically

C It is sent to the server

D It is cached permanently

Activity is destroyed and recreated on rotation, so data is lost unless saved elsewhere.

Why use LiveData inside a ViewModel?

A To observe data changes safely

B To draw graphics

C To handle user clicks

D To store files

LiveData lets UI observe data changes and updates automatically respecting lifecycle.

Explain how to create and use a ViewModel in an Android app.

Think about separating UI data from Activity lifecycle.

Describe why ViewModel is important for handling screen rotations.

Imagine what happens when you turn your phone sideways.

Practice

1. What is the main purpose of a ViewModel in Android development?

easy

A. To define the layout of the app screen

B. To handle user input events directly

C. To store and manage UI-related data in a lifecycle conscious way

D. To manage network requests

Solution

1. Step 1: Understand ViewModel role

   A ViewModel is designed to hold UI data safely during configuration changes like screen rotations.

2. Step 2: Compare options

   Only To store and manage UI-related data in a lifecycle conscious way describes this purpose correctly; others describe unrelated tasks.

3. Final Answer:

   To store and manage UI-related data in a lifecycle conscious way -> Option C

4. Quick Check:

   ViewModel purpose = store UI data safely [OK]

Hint: ViewModel holds UI data safely during screen changes [OK]

Common Mistakes:

• Confusing ViewModel with UI layout classes
• Thinking ViewModel handles user input directly
• Assuming ViewModel manages network calls

2. Which of the following is the correct way to declare a ViewModel class in Kotlin?

easy

A. class MyViewModel extends ViewModel {}

B. class MyViewModel : ViewModel() {}

C. fun MyViewModel() : ViewModel {}

D. val MyViewModel = ViewModel()

Solution

1. Step 1: Recall Kotlin class syntax

   Kotlin uses a colon (:) to extend a class and parentheses for constructor calls.

2. Step 2: Check each option

   class MyViewModel : ViewModel() {} uses correct Kotlin syntax for extending ViewModel; others use Java syntax or invalid declarations.

3. Final Answer:

   class MyViewModel : ViewModel() {} -> Option B

4. Quick Check:

   Kotlin inheritance uses ':' and parentheses [OK]

Hint: Use ':' to extend class in Kotlin, not 'extends' [OK]

Common Mistakes:

• Using Java syntax 'extends' in Kotlin
• Declaring ViewModel as a function
• Assigning ViewModel to a val without class

3. Given this ViewModel code snippet, what will be the output when counter.value is printed after increment() is called twice?

class CounterViewModel : ViewModel() {
  val counter = MutableLiveData(0)
  fun increment() {
    counter.value = (counter.value ?: 0) + 1
  }
}

medium

A. 2

B. 1

C. null

D. 0

Solution

1. Step 1: Understand initial value and increment

   counter starts at 0; each increment adds 1 to current value.

2. Step 2: Calculate after two increments

   After first call: 0 + 1 = 1; after second call: 1 + 1 = 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Two increments from 0 = 2 [OK]

Hint: Each increment adds 1; two calls add 2 total [OK]

Common Mistakes:

• Forgetting to unwrap nullable value
• Assuming counter resets each time
• Confusing LiveData with normal variable

4. Identify the error in this ViewModel code:

class SampleViewModel : ViewModel() {
  val data = MutableLiveData<String>()

  fun updateData(newData: String) {
    data.value = newData
  }

  fun getData(): String {
    return data.value
  }
}

medium

A. ViewModel class must be abstract

B. MutableLiveData cannot hold String values

C. updateData() should not modify LiveData value

D. getData() returns nullable String but declared as non-nullable

Solution

1. Step 1: Check LiveData type and usage

   MutableLiveData<String> can hold String values; updateData() correctly sets value.

2. Step 2: Analyze getData() return type

   data.value is nullable String?, but getData() returns non-nullable String, causing a type mismatch.

3. Final Answer:

   getData() returns nullable String but declared as non-nullable -> Option D

4. Quick Check:

   LiveData value is nullable; return type must match [OK]

Hint: LiveData.value is nullable; match return types carefully [OK]

Common Mistakes:

• Ignoring nullable type of LiveData.value
• Thinking ViewModel must be abstract
• Believing LiveData can't hold String

5. You want to create a ViewModel that holds a list of user names and updates the UI reactively. Which is the best way to declare and update this list inside your ViewModel?

hard

A. class UserViewModel : ViewModel() {\n val users = MutableLiveData(emptyList())\n fun addUser(name: String) {\n users.value = users.value?.plus(name)\n }\n}

B. class UserViewModel : ViewModel() {\n val users = mutableListOf<String>()\n fun addUser(name: String) {\n users.add(name)\n }\n}

C. class UserViewModel : ViewModel() {\n var users = listOf<String>()\n fun addUser(name: String) {\n users += name\n }\n}

D. class UserViewModel : ViewModel() {\n val users = LiveData()\n fun addUser(name: String) {\n users.value = listOf(name)\n }\n}

Solution

1. Step 1: Identify reactive data holder

   MutableLiveData<List<String>> allows UI to observe changes and update reactively.

2. Step 2: Check update method correctness

   class UserViewModel : ViewModel() {\n val users = MutableLiveData<List<String>>(emptyList())\n fun addUser(name: String) {\n users.value = users.value?.plus(name)\n }\n} uses users.value?.plus(name) to add a user immutably and update LiveData, which is correct.

3. Step 3: Review other options

   class UserViewModel : ViewModel() {\n val users = mutableListOf<String>()\n fun addUser(name: String) {\n users.add(name)\n }\n} uses mutableList but not LiveData, so UI won't update reactively. class UserViewModel : ViewModel() {\n var users = listOf<String>()\n fun addUser(name: String) {\n users += name\n }\n} uses var list but no LiveData. class UserViewModel : ViewModel() {\n val users = LiveData<List<String>>()\n fun addUser(name: String) {\n users.value = listOf(name)\n }\n} tries to instantiate LiveData directly, which is abstract and invalid.

4. Final Answer:

   class UserViewModel : ViewModel() {\n val users = MutableLiveData<List<String>>(emptyList())\n fun addUser(name: String) {\n users.value = users.value?.plus(name)\n }\n} -> Option A

5. Quick Check:

   Use MutableLiveData with immutable updates for reactive UI [OK]

Hint: Use MutableLiveData and update list immutably for UI updates [OK]

Common Mistakes:

• Using mutableList without LiveData for UI data
• Trying to instantiate LiveData directly
• Modifying list without updating LiveData value