LiveData basics in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a LiveData variable named data of type String.

Android Kotlin

val data: LiveData<[1]> = MutableLiveData()

Drag options to blanks, or click blank then click option'

AInt

BString

CBoolean

DFloat

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong data type like Int when you want to hold text.

Forgetting to specify the type inside the angle brackets.

LiveData holds data of a specific type. Here, we want it to hold strings, so we use LiveData.

2fill in blank

medium

Complete the code to observe the LiveData data inside an Activity and update a TextView when data changes.

Android Kotlin

data.observe(this, [1] { newValue -> textView.text = newValue })

Drag options to blanks, or click blank then click option'

Aobserve

BobserveForever

CobserveData

DObserver

Attempts:

3 left

💡 Hint

Common Mistakes

Using observeForever inside an Activity which can cause memory leaks.

Passing a wrong method name like observeData.

To observe LiveData changes, you pass an Observer object that reacts to updates.

3fill in blank

hard

Fix the error in this code that tries to update LiveData value inside a ViewModel.

Android Kotlin

private val _data = MutableLiveData<String>()
val data: LiveData<String> = _data

fun updateData(newValue: String) {
  _data.[1] = newValue
}

Drag options to blanks, or click blank then click option'

Avalue

BsetValue

CupdateValue

DpostValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using postValue on the main thread when setValue or value assignment is preferred.

Trying to call a method named updateValue which does not exist.

To update LiveData value on the main thread, assign the new value to the 'value' property.

4fill in blank

hard

Fill both blanks to create a LiveData that transforms another LiveData's data by converting it to uppercase.

Android Kotlin

val originalData: LiveData<String> = MutableLiveData()
val upperData: LiveData<String> = Transformations.[1](originalData) { it.[2]() }

Drag options to blanks, or click blank then click option'

Amap

BswitchMap

CtoUpperCase

Duppercase

Attempts:

3 left

💡 Hint

Common Mistakes

Using switchMap instead of map when only transforming data.

Using the deprecated 'toUpperCase()' method.

Use Transformations.map to create a LiveData that applies a function to the original data. The modern Kotlin method to convert to uppercase is 'uppercase()'.

5fill in blank

hard

Fill all three blanks to create a ViewModel with MutableLiveData, expose it as LiveData, and update its value safely.

Android Kotlin

class MyViewModel : ViewModel() {
  private val _count = MutableLiveData<Int>().apply { value = [1] }
  val count: LiveData<Int> = [2]

  fun increment() {
    val current = _count.value ?: 0
    _count.[3] = current + 1
  }
}

Drag options to blanks, or click blank then click option'

A0

B_count

Cvalue

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Exposing the MutableLiveData directly instead of as LiveData.

Using the wrong property or method to update the LiveData value.

Initialize MutableLiveData with 0, expose it as LiveData by returning _count, and update the value property to increment.

Practice

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

easy

A. To manage database queries directly

B. To perform background tasks without blocking the UI

C. To store user preferences permanently

D. To hold data that UI components can observe and update automatically

Solution

1. Step 1: Understand LiveData's role

   LiveData is designed to hold data that UI components can observe, so they update automatically when data changes.

2. Step 2: Compare with other options

   Background tasks, storing preferences, and database management are handled by other components, not LiveData.

3. Final Answer:

   To hold data that UI components can observe and update automatically -> Option D

4. Quick Check:

   LiveData = Observable data holder [OK]

Hint: LiveData = data holder that UI watches [OK]

Common Mistakes:

• Confusing LiveData with background task handlers
• Thinking LiveData stores data permanently
• Mixing LiveData with database management

2. Which of the following is the correct way to declare a mutable LiveData variable in Kotlin?

easy

A. val data = MutableLiveData<String>()

B. val data = LiveData<String>()

C. var data = LiveData<String>()

D. var data = MutableLiveData

Solution

1. Step 1: Identify MutableLiveData syntax

   MutableLiveData requires specifying the type with angle brackets and calling its constructor with parentheses.

2. Step 2: Check each option

   val data = MutableLiveData<String>() correctly uses val data = MutableLiveData<String>(). val data = LiveData<String>() uses LiveData which is immutable. var data = LiveData<String>() uses LiveData with var but still immutable. var data = MutableLiveData misses type and parentheses.

3. Final Answer:

   val data = MutableLiveData<String>() -> Option A

4. Quick Check:

   MutableLiveData syntax = val data = MutableLiveData<String>() [OK]

Hint: MutableLiveData needs type and parentheses [OK]

Common Mistakes:

• Using LiveData instead of MutableLiveData to change data
• Omitting parentheses when creating MutableLiveData
• Not specifying the generic type

3. Given the code below, what will be printed when liveData.value = "Hello" is called?

val liveData = MutableLiveData<String>()
liveData.observe(this) { value ->
    println(value)
}

medium

A. Nothing is printed

B. Compilation error

C. Hello

D. null

Solution

1. Step 1: Understand observe behavior

   The observer is set to print the new value whenever liveData changes.

2. Step 2: Assigning value triggers observer

   Setting liveData.value = "Hello" triggers the observer lambda, printing "Hello".

3. Final Answer:

   Hello -> Option C

4. Quick Check:

   Observer prints new value = Hello [OK]

Hint: Setting value triggers observer print [OK]

Common Mistakes:

• Thinking observer triggers only on lifecycle start
• Expecting null because initial value is empty
• Confusing observe with observeForever

4. What is wrong with this code snippet?

val liveData = MutableLiveData<Int?>()
liveData.observe(this) { value ->
    println(value)
}
liveData.value = 10
liveData.value = null

medium

A. LiveData cannot hold null values

B. Nothing is wrong; null is allowed in MutableLiveData

C. Setting liveData.value to null causes a crash

D. Observe must be called after setting value

Solution

1. Step 1: Check if MutableLiveData accepts null

   MutableLiveData can hold null values if the generic type allows it (Int? or nullable type).

2. Step 2: Analyze code behavior

   The code declares MutableLiveData<Int?>(), which allows null since Int? is nullable. Setting to 10 and then null works fine without crash; observer prints both.

3. Final Answer:

   Nothing is wrong; null is allowed in MutableLiveData -> Option B

4. Quick Check:

   MutableLiveData accepts null if type nullable [OK]

Hint: MutableLiveData can hold null if type nullable [OK]

Common Mistakes:

• Assuming LiveData never accepts null
• Thinking observe order matters for value setting
• Confusing runtime crash with compile error

5. You want to update UI only when LiveData has a non-null and non-empty string. Which code snippet correctly observes liveData to achieve this?

val liveData = MutableLiveData<String>()
liveData.observe(this) { value ->
    // What to put here?
}

hard

A. if (value != null && value.isNotEmpty()) { updateUI(value) }

B. if (value == null || value.isEmpty()) { updateUI(value) }

C. updateUI(value ?: "")

D. updateUI(value!!)

Solution

1. Step 1: Define condition for UI update

   We want to update UI only if value is not null and not empty.

2. Step 2: Check each option logic

   if (value != null && value.isNotEmpty()) { updateUI(value) } checks both conditions correctly. if (value == null || value.isEmpty()) { updateUI(value) } updates UI on null or empty, opposite of requirement. updateUI(value ?: "") updates UI always with fallback empty string. updateUI(value!!) forces non-null with !! which can crash.

3. Final Answer:

   if (value != null && value.isNotEmpty()) { updateUI(value) } -> Option A

4. Quick Check:

   Check non-null and non-empty before update [OK]

Hint: Check both null and empty before UI update [OK]

Common Mistakes:

• Updating UI on null or empty values
• Using !! operator risking crash
• Ignoring empty string check