feat: add option for filtering alarms

app/src/main/java/com/bnyro/clock/obj/AlarmFilters.kt

@@ -0,0 +1,8 @@
+package com.bnyro.clock.obj
+
+data class AlarmFilters(
+    val label: String = "",
+    val weekDays: List<Int> = listOf(0, 1, 2, 3, 4, 5, 6),
+    val startTime: Long = 0, //00:00
+    val endTime: Long = 86340000 //23:59
+)

app/src/main/java/com/bnyro/clock/ui/components/AlarmFilterSection.kt

@@ -0,0 +1,202 @@
+package com.bnyro.clock.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+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.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.AccessTimeFilled
+import androidx.compose.material.icons.filled.ArrowRightAlt
+import androidx.compose.material.icons.filled.CalendarToday
+import androidx.compose.material.icons.outlined.Search
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+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.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.bnyro.clock.R
+import com.bnyro.clock.obj.AlarmFilters
+import com.bnyro.clock.ui.dialog.TimePickerDialog
+import com.bnyro.clock.util.AlarmHelper
+import com.bnyro.clock.util.TimeHelper
+
+@Composable
+fun AlarmFilterSection(
+    filters: AlarmFilters,
+    onChangeLabel: (String) -> Unit,
+    onClickWeekDay: (List<Int>) -> Unit,
+    onClickStartTime: (Long) -> Unit,
+    onClickEndTime: (Long) -> Unit
+) {
+
+    var timeFromFilter by remember { mutableStateOf(false) }
+    var timeToFilter by remember { mutableStateOf(false) }
+
+    Column(
+        modifier = Modifier.fillMaxWidth(),
+        verticalArrangement = Arrangement.Center,
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+
+        OutlinedTextField(
+            value = filters.label,
+            label = { Text(text = stringResource(id = R.string.alarm_name)) },
+            leadingIcon = {
+                Icon(imageVector = Icons.Outlined.Search, contentDescription = null)
+            },
+            singleLine = true,
+            shape = CircleShape,
+            onValueChange = { onChangeLabel(it) },
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(start = 8.dp, end = 8.dp)
+        )
+
+        WeekDayRow(weekDays = filters.weekDays, onClickWeekDay = onClickWeekDay)
+
+        TimeRangeRow(
+            startTime = filters.startTime,
+            endTime = filters.endTime,
+            onClickStartTime = { timeFromFilter = !timeFromFilter },
+            onClickEndTime = { timeToFilter = !timeToFilter }
+        )
+
+        if (timeFromFilter) {
+            TimePickerDialog(
+                label = stringResource(R.string.from),
+                onDismissRequest = { timeFromFilter = false }
+            ) {
+                onClickStartTime(it.toLong())
+                timeFromFilter = false
+            }
+        }
+
+        if (timeToFilter) {
+            TimePickerDialog(
+                label = stringResource(R.string.to),
+                onDismissRequest = { timeToFilter = false }
+            ) {
+                onClickEndTime(it.toLong())
+                timeToFilter = false
+            }
+        }
+    }
+
+
+}
+
+@Composable
+fun WeekDayRow(weekDays: List<Int>, onClickWeekDay: (List<Int>) -> Unit) {
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(20.dp),
+        horizontalArrangement = Arrangement.Start
+    ) {
+        val daysOfWeek = remember { AlarmHelper.getDaysOfWeekByLocale() }
+        val chosenDays = remember { weekDays.toMutableList() }
+
+        Icon(
+            imageVector = Icons.Default.CalendarToday,
+            contentDescription = null
+        )
+
+        Spacer(modifier = Modifier.width(16.dp))
+
+        daysOfWeek.forEach { (day, index) ->
+            val enabled = chosenDays.contains(index)
+            Box(
+                modifier = Modifier
+                    .padding(end = 8.dp)
+                    .size(30.dp)
+                    .background(
+                        if (enabled) MaterialTheme.colorScheme.primary else Color.Transparent,
+                        CircleShape
+                    )
+                    .clip(CircleShape)
+                    .border(
+                        if (enabled) 0.dp else 1.dp,
+                        MaterialTheme.colorScheme.primary,
+                        CircleShape
+                    )
+                    .clickable {
+                        if (enabled) {
+                            if (chosenDays.size > 1) chosenDays.remove(index)
+                        } else {
+                            chosenDays.add(
+                                index
+                            )
+                        }
+                        onClickWeekDay(chosenDays.toList())
+                    },
+                contentAlignment = Alignment.Center
+            ) {
+                Text(
+                    text = day,
+                    color = if (enabled) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onPrimaryContainer
+                )
+            }
+
+        }
+    }
+}
+
+@Composable
+fun TimeRangeRow(
+    startTime: Long,
+    endTime: Long,
+    onClickStartTime: () -> Unit,
+    onClickEndTime: () -> Unit
+) {
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(start = 20.dp, end = 20.dp, bottom = 10.dp),
+        horizontalArrangement = Arrangement.Start,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Icon(
+            imageVector = Icons.Default.AccessTimeFilled,
+            contentDescription = null
+        )
+
+        Spacer(modifier = Modifier.width(16.dp))
+
+        Button(onClick = onClickStartTime, modifier = Modifier.weight(1f)) {
+            Text(text = TimeHelper.millisToFormatted(startTime))
+        }
+
+        Icon(
+            imageVector = Icons.Default.ArrowRightAlt,
+            contentDescription = null,
+            modifier = Modifier.padding(start = 8.dp, end = 8.dp)
+        )
+
+        Button(onClick = onClickEndTime, modifier = Modifier.weight(1f)) {
+            Text(text = TimeHelper.millisToFormatted(endTime))
+        }
+
+    }
+}

app/src/main/java/com/bnyro/clock/ui/model/AlarmModel.kt

@@ -8,38 +8,85 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.bnyro.clock.db.DatabaseHolder
 import com.bnyro.clock.obj.Alarm
+import com.bnyro.clock.obj.AlarmFilters
 import com.bnyro.clock.util.AlarmHelper
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import java.util.Collections
 
 class AlarmModel : ViewModel() {
     var selectedAlarm: Alarm? by mutableStateOf(null)
-    val alarms: StateFlow<List<Alarm>> = DatabaseHolder.instance.alarmsDao().getAllStream().stateIn(
-        scope = viewModelScope,
-        started = SharingStarted.WhileSubscribed(5000L),
-        initialValue = listOf()
-    )
+    var showFilter by mutableStateOf(false)
+    var filters = MutableStateFlow(AlarmFilters())
+        private set
+    var alarms: MutableStateFlow<List<Alarm>> = MutableStateFlow(emptyList())
+        private set
+
+    init {
+        getAlarms()
+    }
+
+    private fun getAlarms() {
+        viewModelScope.launch {
+            alarms.value = DatabaseHolder.instance.alarmsDao().getAll().filter { alarm ->
+                (filters.value.startTime <= alarm.time && alarm.time <= filters.value.endTime)
+                        && !Collections.disjoint(filters.value.weekDays, alarm.days)
+                        && (alarm.label?.lowercase()?.contains(filters.value.label.lowercase()) ?: true)
+
+            }
+        }
+    }
 
     fun createAlarm(alarm: Alarm) {
         viewModelScope.launch(Dispatchers.IO) {
             DatabaseHolder.instance.alarmsDao().insert(alarm)
+            getAlarms()
         }
     }
 
     fun updateAlarm(context: Context, alarm: Alarm) {
         AlarmHelper.enqueue(context, alarm)
         viewModelScope.launch(Dispatchers.IO) {
             DatabaseHolder.instance.alarmsDao().update(alarm)
+            getAlarms()
         }
     }
 
     fun deleteAlarm(context: Context, alarm: Alarm) {
         AlarmHelper.cancel(context, alarm)
         viewModelScope.launch(Dispatchers.IO) {
             DatabaseHolder.instance.alarmsDao().delete(alarm)
+            getAlarms()
         }
     }
+
+    fun updateLabelFilter(label: String) {
+        filters.update { it.copy(label = label) }
+        getAlarms()
+    }
+
+    fun updateWeekDayFilter(weekDays: List<Int>) {
+        filters.update { it.copy(weekDays = weekDays) }
+        getAlarms()
+    }
+
+    fun updateStartTimeFilter(startTime: Long) {
+        filters.update { it.copy(startTime = startTime) }
+        getAlarms()
+    }
+
+    fun updateEndTimeFilter(endTime: Long) {
+        filters.update { it.copy(endTime = endTime) }
+        getAlarms()
+    }
+
+    fun resetFilters() {
+        filters.update { AlarmFilters() }
+        getAlarms()
+    }
 }