Why state drives UI updates in Android Kotlin - Build It to Prove It

Build: Counter Screen

A simple screen that shows a number and a button. Each time the button is pressed, the number increases by one. The number on the screen updates automatically because it depends on the state.

Target UI

-------------------
|   Counter App   |
-------------------
|                 |
|       0         |
|                 |
|   [Increase]    |
-------------------

Display a number starting at 0

Show a button labeled 'Increase'

When the button is pressed, increase the number by 1

The displayed number updates automatically to show the new value

Starter Code

Android Kotlin

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.tooling.preview.Preview

class MainActivity : ComponentActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContent {
      // TODO: Add your code here
    }
  }
}

@Composable
fun CounterScreen() {
  // TODO: Add your code here
}

@Preview(showBackground = true)
@Composable
fun CounterScreenPreview() {
  CounterScreen()
}

Task 1

Task 2

Task 3

Task 4

Task 5

Solution

Android Kotlin

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContent {
      CounterScreen()
    }
  }
}

@Composable
fun CounterScreen() {
  var count by remember { mutableStateOf(0) }

  Column(
    modifier = Modifier.fillMaxSize().padding(16.dp),
    verticalArrangement = Arrangement.Center,
    horizontalAlignment = Alignment.CenterHorizontally
  ) {
    Text(text = "$count", style = MaterialTheme.typography.displayLarge)
    Spacer(modifier = Modifier.height(24.dp))
    Button(onClick = { count++ }) {
      Text("Increase")
    }
  }
}

@Preview(showBackground = true)
@Composable
fun CounterScreenPreview() {
  CounterScreen()
}

This app uses a count variable to hold the current number. It is a mutableStateOf, which means Compose watches it for changes. When the button is clicked, count++ increases the number. Because count is state, Compose automatically redraws the Text showing the number. This shows how state drives UI updates: changing the state triggers the UI to update without extra code.

Final Result

Completed Screen

-------------------
|   Counter App   |
-------------------
|                 |
|       0         |
|                 |
|   [Increase]    |
-------------------

User taps the 'Increase' button

The number in the center increases by 1 each tap

The displayed number updates immediately after each tap

Stretch Goal

Add a 'Reset' button that sets the count back to 0

💡 Hint

Add another Button below 'Increase' with onClick setting count = 0

Practice

1. Why is state important in Android UI development?

easy

A. Because state stores the app's installation files

B. Because state is used only for background services

C. Because state controls the device's hardware directly

D. Because state holds the current data that the UI shows

Solution

1. Step 1: Understand what state represents

   State holds the current data or information that the UI displays to the user.

2. Step 2: Connect state to UI updates

   When state changes, the UI updates to reflect the new data, making the app interactive.

3. Final Answer:

   Because state holds the current data that the UI shows -> Option D

4. Quick Check:

   State = current UI data [OK]

Hint: State means current UI data shown to user [OK]

Common Mistakes:

• Confusing state with app installation files
• Thinking state controls hardware directly
• Believing state is only for background tasks

2. Which Kotlin syntax correctly declares a mutable state variable for UI updates?

easy

A. var count = mutableStateOf(0)

B. var count = 0

C. val count = 0

D. val count = mutableStateOf(0)

Solution

1. Step 1: Identify mutable state declaration

   In Kotlin Compose, mutableStateOf() creates a state holder that triggers UI updates when changed.

2. Step 2: Check variable mutability

   Using var with mutableStateOf allows changing the state value, which updates the UI.

3. Final Answer:

   var count = mutableStateOf(0) -> Option A

4. Quick Check:

   Mutable state uses var + mutableStateOf() [OK]

Hint: Use var with mutableStateOf() for mutable UI state [OK]

Common Mistakes:

• Using val with mutableStateOf prevents reassignment
• Using plain var without mutableStateOf won't trigger UI updates
• Using val count = 0 is immutable and not state

3. What will be displayed on screen after this code runs?

var count = mutableStateOf(0)
count.value = 5
Text(text = "Count: ${count.value}")

medium

A. Count: 0

B. Error: Cannot assign value

C. Count: 5

D. Count: ${count.value}

Solution

1. Step 1: Understand mutableStateOf usage

   count is a state holding integer 0 initially, updated to 5 by count.value = 5.

2. Step 2: Evaluate Text display

   The Text composable shows the string with count.value, which is now 5.

3. Final Answer:

   Count: 5 -> Option C

4. Quick Check:

   State updated to 5, UI shows 5 [OK]

Hint: Text shows current state value, not variable name [OK]

Common Mistakes:

• Thinking Text shows literal string with ${count.value}
• Assuming count.value stays 0 after assignment
• Believing assignment causes error

4. Identify the error in this Kotlin Compose code snippet:

var count = 0
count = 1
Text(text = "Count: $count")

medium

A. count should be declared with mutableStateOf to update UI

B. Text composable cannot use variables inside strings

C. count must be val, not var

D. No error, code works fine

Solution

1. Step 1: Check state usage for UI updates

   Declaring count as plain var means UI won't update when count changes.

2. Step 2: Explain correct state usage

   Using mutableStateOf wraps count so Compose tracks changes and updates UI automatically.

3. Final Answer:

   count should be declared with mutableStateOf to update UI -> Option A

4. Quick Check:

   State needed for UI updates [OK]

Hint: Use mutableStateOf for variables that change UI [OK]

Common Mistakes:

• Thinking var alone triggers UI updates
• Believing Text cannot use variables in strings
• Confusing val and var roles

5. You want a button to increase a counter and update the UI each time it is clicked. Which approach correctly uses state to achieve this?

var count = 0
Button(onClick = { count++ }) {
  Text(text = "Count: $count")
}

hard

A. Keep count as var and increment count directly

B. Use mutableStateOf for count and update count.value inside onClick

C. Declare count as val and increment inside onClick

D. Use a local variable inside onClick without state

Solution

1. Step 1: Identify why UI won't update with plain var

   Incrementing a plain var count won't notify Compose to recompose UI.

2. Step 2: Use mutableStateOf to hold count

   Declaring count as mutableStateOf allows Compose to track changes and update UI automatically when count.value changes.

3. Final Answer:

   Use mutableStateOf for count and update count.value inside onClick -> Option B

4. Quick Check:

   State drives UI updates on change [OK]

Hint: Wrap changing variables with mutableStateOf for UI updates [OK]

Common Mistakes:

• Incrementing plain var without state causes no UI update
• Using val prevents changing count
• Using local variable inside onClick loses state