Composables
Docs Login
Tally

New habit

package com.composables.tally

import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.selection.selectable
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.unit.dp
import com.composables.compose.ripple.rememberRippleIndication
import com.composables.tally.components.AlertDialog
import com.composables.tally.components.Button
import com.composables.tally.components.ButtonVariant
import com.composables.tally.components.Icon
import com.composables.tally.components.IconButton
import com.composables.tally.components.IconButtonVariant
import com.composables.tally.components.ModalBottomSheet
import com.composables.tally.components.OptionGroup
import com.composables.tally.components.OptionRow
import com.composables.tally.components.Page
import com.composables.tally.components.Section
import com.composables.tally.components.SegmentedControl
import com.composables.tally.components.TemplateCard
import com.composables.tally.components.Text
import com.composables.tally.components.TextField
import com.composables.tally.theme.Archive
import com.composables.tally.theme.Bell
import com.composables.tally.theme.Check
import com.composables.tally.theme.Icons
import com.composables.tally.theme.Minus
import com.composables.tally.theme.Plus
import com.composables.tally.theme.Repeat
import com.composables.tally.theme.Space
import com.composables.tally.theme.SunHorizon
import com.composables.tally.theme.Target
import com.composables.tally.theme.Theme
import com.composables.tally.theme.Trash
import com.composables.tally.theme.X
import kotlinx.datetime.DayOfWeek
import kotlinx.datetime.LocalTime

@Composable
fun NewHabitScreen(
    navigateBack: () -> Unit,
    navigateToHabitForm: (template: String?) -> Unit,
    modifier: Modifier = Modifier,
) {
    Page(
        title = "New habit",
        onBack = navigateBack,
        backIcon = Icons.X,
        backLabel = "Close",
        modifier = modifier,
        bottomBar = {
            Button(onClick = { navigateToHabitForm(null) }, modifier = Modifier.fillMaxWidth()) {
                Text("Create your own")
            }
        },
    ) {
        TemplateGrid("Popular habits", popularTemplates) { navigateToHabitForm(it.name) }
        TemplateGrid("Stay active", activeTemplates) { navigateToHabitForm(it.name) }
    }
}

@Composable
private fun TemplateGrid(
    title: String,
    templates: List<HabitTemplate>,
    onSelect: (HabitTemplate) -> Unit,
) {
    Column(verticalArrangement = Arrangement.spacedBy(Space * 3)) {
        Text(title, style = Theme.typography.title)
        templates.chunked(2).forEach { row ->
            Row(horizontalArrangement = Arrangement.spacedBy(Space * 3)) {
                row.forEach { template ->
                    TemplateCard(
                        name = template.name,
                        goal = "${template.goal} ${template.unit} per day",
                        icon = template.icon,
                        color = template.color.lightColor,
                        onClick = { onSelect(template) },
                        modifier = Modifier.weight(1f),
                    )
                }
                if (row.size == 1) Spacer(Modifier.weight(1f))
            }
        }
    }
}

private val units = listOf("time", "glasses", "minutes", "pages", "steps", "servings")
private val reminderTimes =
    listOf(
        LocalTime(7, 0),
        LocalTime(9, 0),
        LocalTime(12, 30),
        LocalTime(18, 30),
        LocalTime(21, 30),
    )

private enum class FormSheet {
    Repeat,
    Goal,
    TimeOfDay,
    Reminder,
}

@Composable
fun HabitFormScreen(
    navigateBack: () -> Unit,
    navigateAfterRemoving: () -> Unit,
    modifier: Modifier = Modifier,
    template: String? = null,
    habitId: Int? = null,
) {
    val editing = remember(habitId) { habitId?.let(::habitById) }
    val start =
        remember(template) { (popularTemplates + activeTemplates).find { it.name == template } }
    var name by remember { mutableStateOf(editing?.name ?: start?.name.orEmpty()) }
    var color by remember { mutableStateOf(editing?.color ?: start?.color ?: HabitColor.Amber) }
    var repeat by remember { mutableStateOf(editing?.repeat ?: Repeat.EveryDay) }
    var goal by remember { mutableStateOf(editing?.goal ?: start?.goal ?: 1) }
    var unit by remember { mutableStateOf(editing?.unit ?: start?.unit ?: units.first()) }
    var timeOfDay by remember {
        mutableStateOf(editing?.timeOfDay ?: start?.timeOfDay ?: TimeOfDay.AnyTime)
    }
    var reminder by remember { mutableStateOf(editing?.reminder) }
    var sheet by remember { mutableStateOf<FormSheet?>(null) }
    var confirmDelete by remember { mutableStateOf(false) }

    fun save() {
        // save the habit here
        navigateBack()
    }

    fun archive() {
        // archive the habit here
        navigateAfterRemoving()
    }

    fun delete() {
        // delete the habit here
        navigateAfterRemoving()
    }

    Page(
        title = if (editing != null) "Edit habit" else "New habit",
        onBack = navigateBack,
        backIcon = Icons.X,
        backLabel = "Cancel",
        modifier = modifier,
        bottomBar = {
            Button(
                onClick = ::save,
                enabled = name.isNotBlank(),
                modifier = Modifier.fillMaxWidth(),
            ) {
                Text("Save")
            }
        },
        overlay = {
            RepeatSheet(sheet == FormSheet.Repeat, repeat, { repeat = it }) { sheet = null }
            GoalSheet(sheet == FormSheet.Goal, goal, unit, { goal = it }, { unit = it }) {
                sheet = null
            }
            ModalBottomSheet(
                visible = sheet == FormSheet.TimeOfDay,
                onDismiss = { sheet = null },
                title = "Time of day",
            ) {
                OptionGroup {
                    TimeOfDay.entries.forEach { time ->
                        OptionRow(
                            time.label,
                            onClick = {
                                timeOfDay = time
                                sheet = null
                            },
                            selected = time == timeOfDay,
                        )
                    }
                }
            }
            ModalBottomSheet(
                visible = sheet == FormSheet.Reminder,
                onDismiss = { sheet = null },
                title = "Reminder",
            ) {
                OptionGroup {
                    OptionRow(
                        "No reminder",
                        onClick = {
                            reminder = null
                            sheet = null
                        },
                        selected = reminder == null,
                    )
                    reminderTimes.forEach { time ->
                        OptionRow(
                            time.label,
                            onClick = {
                                reminder = time
                                sheet = null
                            },
                            selected = time == reminder,
                        )
                    }
                }
            }
            AlertDialog(
                visible = confirmDelete,
                title = "Delete this habit?",
                message = "Its streaks, progress and notes will be deleted too.",
                onDismissRequest = { confirmDelete = false },
            ) {
                Button(
                    onClick = {
                        confirmDelete = false
                        delete()
                    },
                    variant = ButtonVariant.Destructive,
                    modifier = Modifier.fillMaxWidth(),
                ) {
                    Text("Delete habit")
                }
                Button(
                    onClick = { confirmDelete = false },
                    variant = ButtonVariant.Secondary,
                    modifier = Modifier.fillMaxWidth(),
                ) {
                    Text("Cancel")
                }
            }
        },
    ) {
        Column(verticalArrangement = Arrangement.spacedBy(Space * 3)) {
            TextField(value = name, onValueChange = { name = it }, label = "Habit name")
            ColorPicker(color, onSelect = { color = it })
        }
        Section(null) {
            OptionRow(
                "Repeat",
                onClick = { sheet = FormSheet.Repeat },
                icon = Icons.Repeat,
                value = repeat.label,
                navigates = true,
            )
            OptionRow(
                "Goal",
                onClick = { sheet = FormSheet.Goal },
                icon = Icons.Target,
                value = "$goal $unit per day",
                navigates = true,
            )
            OptionRow(
                "Time of day",
                onClick = { sheet = FormSheet.TimeOfDay },
                icon = Icons.SunHorizon,
                value = timeOfDay.label,
                navigates = true,
            )
        }
        Section(null, footer = "Tally reminds you on the days this habit repeats.") {
            OptionRow(
                "Reminder",
                onClick = { sheet = FormSheet.Reminder },
                icon = Icons.Bell,
                value = reminder?.label ?: "Off",
                navigates = true,
            )
        }
        if (editing != null)
            Section(null) {
                OptionRow("Archive habit", onClick = ::archive, icon = Icons.Archive)
                OptionRow(
                    "Delete habit",
                    onClick = { confirmDelete = true },
                    icon = Icons.Trash,
                    destructive = true,
                )
            }
    }
}

@Composable
private fun ColorPicker(selected: HabitColor, onSelect: (HabitColor) -> Unit) {
    Row(horizontalArrangement = Arrangement.spacedBy(Space * 2)) {
        HabitColor.entries.forEach { color ->
            val isSelected = color == selected
            Box(
                Modifier.size(44.dp)
                    .clip(Theme.shapes.fullyRounded)
                    .then(
                        if (isSelected)
                            Modifier.border(2.dp, Theme.colors.primary, Theme.shapes.fullyRounded)
                        else Modifier
                    )
                    .selectable(
                        selected = isSelected,
                        onClick = { onSelect(color) },
                        role = Role.RadioButton,
                        interactionSource = remember { MutableInteractionSource() },
                        indication = rememberRippleIndication(color = Theme.colors.onBackground),
                    )
                    .padding(5.dp)
                    .clip(Theme.shapes.fullyRounded)
                    .background(color.color)
                    .semantics { contentDescription = color.name },
                contentAlignment = Alignment.Center,
            ) {
                if (isSelected)
                    Icon(
                        Icons.Check,
                        contentDescription = null,
                        modifier = Modifier.size(16.dp),
                        tint = Theme.colors.onBackground,
                    )
            }
        }
    }
}

@Composable
private fun RepeatSheet(
    visible: Boolean,
    repeat: Repeat,
    onChange: (Repeat) -> Unit,
    onDismiss: () -> Unit,
) {
    ModalBottomSheet(visible = visible, onDismiss = onDismiss, title = "Repeat") {
        SegmentedControl(
            options = listOf("Days of the week", "Interval"),
            selected = if (repeat is Repeat.Interval) 1 else 0,
            onSelect = { onChange(if (it == 0) Repeat.EveryDay else Repeat.Interval(2)) },
        )
        OptionGroup {
            when (repeat) {
                is Repeat.Weekly ->
                    DayOfWeek.entries.forEach { day ->
                        val on = day in repeat.days
                        OptionRow(
                            day.name.lowercase().replaceFirstChar { it.uppercase() },
                            onClick = {
                                val days = if (on) repeat.days - day else repeat.days + day
                                if (days.isNotEmpty()) onChange(Repeat.Weekly(days))
                            },
                            selected = on,
                        )
                    }
                is Repeat.Interval ->
                    (2..7).forEach { days ->
                        OptionRow(
                            "Every $days days",
                            onClick = { onChange(Repeat.Interval(days)) },
                            selected = repeat.days == days,
                        )
                    }
            }
        }
    }
}

@Composable
private fun GoalSheet(
    visible: Boolean,
    goal: Int,
    unit: String,
    onGoalChange: (Int) -> Unit,
    onUnitChange: (String) -> Unit,
    onDismiss: () -> Unit,
) {
    ModalBottomSheet(visible = visible, onDismiss = onDismiss, title = "Goal") {
        Row(
            Modifier.fillMaxWidth().padding(vertical = Space * 2),
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.Center,
        ) {
            IconButton(
                onClick = { onGoalChange(goal - 1) },
                contentDescription = "Fewer",
                enabled = goal > 1,
                variant = IconButtonVariant.Tonal,
            ) {
                Icon(Icons.Minus, contentDescription = null, modifier = Modifier.size(20.dp))
            }
            Column(
                Modifier.padding(horizontal = Space * 8),
                horizontalAlignment = Alignment.CenterHorizontally,
            ) {
                Text(goal.toString(), style = Theme.typography.display)
                Text(
                    "$unit per day",
                    style = Theme.typography.caption,
                    color = Theme.colors.onBackgroundMuted,
                )
            }
            IconButton(
                onClick = { onGoalChange(goal + 1) },
                contentDescription = "More",
                variant = IconButtonVariant.Tonal,
            ) {
                Icon(Icons.Plus, contentDescription = null, modifier = Modifier.size(20.dp))
            }
        }
        OptionGroup {
            units.forEach { option ->
                OptionRow(option, onClick = { onUnitChange(option) }, selected = option == unit)
            }
        }
    }
}

More screens from Tally

by Alex Styl

Search screens and components

Screen flows

Screens

UI Elements

One Android lesson, every Wednesday

Building Android apps?

What Alex learned building Android apps for 14 years, so you don't have to. Reads in under a minute.

Join 3,500+ Android developers. Unsubscribe any time.

You're subscribed

The next lesson lands in on Wednesday.