Focus Countdown Timer

import androidx.lifecycle.viewmodel.compose.viewModel

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

@Composable
private fun FocusTimer(timer: TimerViewModel = viewModel()) {
    val state by timer.state.collectAsStateWithLifecycle()
    val owner = LocalLifecycleOwner.current
    DisposableEffect(owner, timer) {
        val observer = LifecycleEventObserver { _, event ->
            // Product decision: leaving the screen pauses a session, including a rotation.
            if (event == Lifecycle.Event.ON_STOP) timer.pause()
        }
        owner.lifecycle.addObserver(observer)
        onDispose { owner.lifecycle.removeObserver(observer) }
    }
    MiniScreen(stringResource(R.string.timer_title)) {
        Text(stringResource(R.string.timer_instruction))
        val choices = listOf(
            10 to R.string.duration_demo,
            60 to R.string.duration_one,

import kotlinx.coroutines.launch

enum class TimerPhase { Ready, Running, Paused, Complete }

data class TimerState(
    val durationSeconds: Int = 25 * 60,
    val remainingMillis: Long = 25 * 60 * 1_000L,
    val phase: TimerPhase = TimerPhase.Ready,
)

class TimerViewModel(private val savedState: SavedStateHandle) : ViewModel() {
    private val allowedDurations = setOf(10, 60, 300, 1500)
    private val restoredDuration = savedState.get<Int>("duration")
        ?.takeIf { it in allowedDurations } ?: 1500
    private val restoredRemaining = (savedState.get<Long>("remaining") ?: restoredDuration * 1_000L)
        .coerceIn(0L, restoredDuration * 1_000L)
    private val _state = MutableStateFlow(
        TimerState(
            durationSeconds = restoredDuration,
            remainingMillis = restoredRemaining,
            phase = when {
                restoredRemaining == 0L -> TimerPhase.Complete
                savedState.get<Boolean>("started") == true -> TimerPhase.Paused
                else -> TimerPhase.Ready
            },
        ),

package com.mastercoding.miniprojects.timer

fun remainingUntil(deadlineMillis: Long, nowMillis: Long): Long =
    (deadlineMillis - nowMillis).coerceAtLeast(0L)

// Round up: a freshly started 10-second timer should still display 00:10.
fun formatRemaining(millis: Long): String {
    val seconds = (millis.coerceAtLeast(0L) + 999L) / 1_000L
    return "%02d:%02d".format(java.util.Locale.ROOT, seconds / 60, seconds % 60)
}

    }

    fun startOrResume() {
        if (ticker?.isActive == true || state.value.remainingMillis <= 0L) return
        deadlineMillis = SystemClock.elapsedRealtime() + state.value.remainingMillis
        publish(state.value.copy(phase = TimerPhase.Running))
        // This is the only place that launches a countdown. Repeated Start events are ignored.
        ticker = viewModelScope.launch {
            while (true) {
                val remaining = remainingUntil(deadlineMillis, SystemClock.elapsedRealtime())
                publish(state.value.copy(
                    remainingMillis = remaining,
                    phase = if (remaining == 0L) TimerPhase.Complete else TimerPhase.Running,
                ))
                if (remaining == 0L) break
                delay(100L)
            }
        }
    }

    fun pause() {
        if (state.value.phase != TimerPhase.Running) return
        val remaining = remainingUntil(deadlineMillis, SystemClock.elapsedRealtime())
        ticker?.cancel()
        ticker = null
        publish(state.value.copy(

    }

    fun pause() {
        if (state.value.phase != TimerPhase.Running) return
        val remaining = remainingUntil(deadlineMillis, SystemClock.elapsedRealtime())
        ticker?.cancel()
        ticker = null
        publish(state.value.copy(
            remainingMillis = remaining,
            phase = if (remaining == 0L) TimerPhase.Complete else TimerPhase.Paused,
        ))
    }

    fun reset() {
        ticker?.cancel()
        ticker = null
        val seconds = state.value.durationSeconds
        publish(TimerState(seconds, seconds * 1_000L))
    }

    private fun publish(next: TimerState) {
        _state.value = next
        savedState["duration"] = next.durationSeconds
        savedState["remaining"] = next.remainingMillis
        savedState["started"] = next.phase != TimerPhase.Ready
    }

@Composable
private fun FocusTimer(timer: TimerViewModel = viewModel()) {
    val state by timer.state.collectAsStateWithLifecycle()
    val owner = LocalLifecycleOwner.current
    DisposableEffect(owner, timer) {
        val observer = LifecycleEventObserver { _, event ->
            // Product decision: leaving the screen pauses a session, including a rotation.
            if (event == Lifecycle.Event.ON_STOP) timer.pause()
        }
        owner.lifecycle.addObserver(observer)
        onDispose { owner.lifecycle.removeObserver(observer) }
    }
    MiniScreen(stringResource(R.string.timer_title)) {
        Text(stringResource(R.string.timer_instruction))
        val choices = listOf(
            10 to R.string.duration_demo,
            60 to R.string.duration_one,
            300 to R.string.duration_five,
            1500 to R.string.duration_twenty_five,
        )
        choices.chunked(2).forEach { row ->
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                row.forEach { (seconds, label) ->
                    FilterChip(
                        selected = state.durationSeconds == seconds,

    val state by timer.state.collectAsStateWithLifecycle()
    val owner = LocalLifecycleOwner.current
    DisposableEffect(owner, timer) {
        val observer = LifecycleEventObserver { _, event ->
            // Product decision: leaving the screen pauses a session, including a rotation.
            if (event == Lifecycle.Event.ON_STOP) timer.pause()
        }
        owner.lifecycle.addObserver(observer)
        onDispose { owner.lifecycle.removeObserver(observer) }
    }
    MiniScreen(stringResource(R.string.timer_title)) {
        Text(stringResource(R.string.timer_instruction))
        val choices = listOf(
            10 to R.string.duration_demo,
            60 to R.string.duration_one,
            300 to R.string.duration_five,
            1500 to R.string.duration_twenty_five,
        )
        choices.chunked(2).forEach { row ->
            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                row.forEach { (seconds, label) ->
                    FilterChip(
                        selected = state.durationSeconds == seconds,
                        enabled = state.phase != TimerPhase.Running,
                        onClick = { timer.chooseDuration(seconds) },
                        label = { Text(stringResource(label)) },

    }

    private fun publish(next: TimerState) {
        _state.value = next
        savedState["duration"] = next.durationSeconds
        savedState["remaining"] = next.remainingMillis
        savedState["started"] = next.phase != TimerPhase.Ready
    }
}