Add save as to EditTextPlainActivity

Crustack · Crustack · commit d1df077d9952 · 2026-02-25T19:05:58.000+01:00
diff --git a/app/src/main/java/com/philkes/notallyx/data/model/Converters.kt b/app/src/main/java/com/philkes/notallyx/data/model/Converters.kt
@@ -174,6 +174,8 @@ object Converters {
         val jsonObject = JSONObject()
         jsonObject.put("value", repetition.value)
         jsonObject.put("unit", repetition.unit.name) // Store the TimeUnit as a string
+        repetition.occurrence?.let { jsonObject.put("occurrence", it) }
+        repetition.dayOfWeek?.let { jsonObject.put("dayOfWeek", it) }
         return jsonObject
     }
 
@@ -185,7 +187,9 @@ object Converters {
             RepetitionTimeUnit.valueOf(
                 jsonObject.getString("unit")
             ) // Convert string back to TimeUnit
-        return Repetition(value, unit)
+        val occurrence = if (jsonObject.has("occurrence")) jsonObject.getInt("occurrence") else null
+        val dayOfWeek = if (jsonObject.has("dayOfWeek")) jsonObject.getInt("dayOfWeek") else null
+        return Repetition(value, unit, occurrence, dayOfWeek)
     }
 
     private fun getSafeLocalName(jsonObject: JSONObject): String {
diff --git a/app/src/main/java/com/philkes/notallyx/data/model/ModelExtensions.kt b/app/src/main/java/com/philkes/notallyx/data/model/ModelExtensions.kt
@@ -12,8 +12,10 @@ import com.philkes.notallyx.presentation.applySpans
 import com.philkes.notallyx.utils.decodeToBitmap
 import java.io.File
 import java.text.DateFormat
+import java.text.SimpleDateFormat
 import java.util.Calendar
 import java.util.Date
+import java.util.Locale
 import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
@@ -321,14 +323,55 @@ fun BaseNote.attachmentsDifferFrom(other: BaseNote): Boolean {
         other.audios.any { audio -> audios.none { it.name == audio.name } }
 }
 
-fun Repetition.toText(context: Context): String =
-    when {
+fun Reminder.toRepetitionText(context: Context): String {
+    val rep = repetition ?: return context.getString(R.string.reminder_no_repetition)
+    if (rep.unit == RepetitionTimeUnit.MONTHS && rep.occurrence == null && rep.value == 1) {
+        val calendar = dateTime.toCalendar()
+        val dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH)
+        val isLastDayOfMonth = dayOfMonth == calendar.getActualMaximum(Calendar.DAY_OF_MONTH)
+
+        val prefix =
+            if (rep.value == 1) ""
+            else
+                "${context.getString(R.string.every)} ${rep.value} ${context.getString(R.string.months)}"
+        val postfix =
+            if (isLastDayOfMonth)
+                context.getString(R.string.of_the_month_last, context.getString(R.string.day))
+            else context.getString(R.string.of_the_month, "$dayOfMonth.")
+        return "$prefix $postfix"
+    }
+    return rep.toText(context)
+}
+
+fun Repetition.toText(context: Context): String {
+    if (unit == RepetitionTimeUnit.MONTHS && occurrence != null && dayOfWeek != null) {
+        val dayOfWeekStr =
+            SimpleDateFormat("EEEE", Locale.getDefault())
+                .apply {
+                    val cal = Calendar.getInstance()
+                    cal.set(Calendar.DAY_OF_WEEK, dayOfWeek!!)
+                }
+                .format(
+                    Calendar.getInstance().apply { set(Calendar.DAY_OF_WEEK, dayOfWeek!!) }.time
+                )
+        val monthlyOptionText =
+            when (occurrence) {
+                -1 -> context.getString(R.string.of_the_month_last, dayOfWeekStr)
+                else -> "$occurrence. ${context.getString(R.string.of_the_month, dayOfWeekStr)}"
+            }
+        val prefix =
+            if (value == 1) ""
+            else "${context.getString(R.string.every)} $value ${context.getString(R.string.months)}"
+        return "$prefix $monthlyOptionText"
+    }
+    return when {
         value == 1 && unit == RepetitionTimeUnit.DAYS -> context.getString(R.string.daily)
         value == 1 && unit == RepetitionTimeUnit.WEEKS -> context.getString(R.string.weekly)
         value == 1 && unit == RepetitionTimeUnit.MONTHS -> context.getString(R.string.monthly)
         value == 1 && unit == RepetitionTimeUnit.YEARS -> context.getString(R.string.yearly)
         else -> "${context.getString(R.string.every)} $value ${unit.toText(context)}"
     }
+}
 
 private fun RepetitionTimeUnit.toText(context: Context): String {
     val resId =
@@ -388,19 +431,85 @@ fun Reminder.nextNotification(from: Date = Date()): Date? {
     if (repetition == null) {
         return null
     }
-    val calendar = dateTime.toCalendar()
-    val field = repetition!!.unit.toCalendarField()
-    val value = repetition!!.value
 
-    // If from is exactly at dateTime, we want the next one
-    while (true) {
-        calendar.add(field, value)
-        if (calendar.time.after(from)) {
-            break
+    val rep = repetition!!
+    if (rep.unit == RepetitionTimeUnit.MONTHS && rep.occurrence != null && rep.dayOfWeek != null) {
+        val next = dateTime.toCalendar()
+        // Ensure we start from the current date's month or later
+        val fromCal = from.toCalendar()
+        if (next.before(fromCal)) {
+            next.set(Calendar.YEAR, fromCal.get(Calendar.YEAR))
+            next.set(Calendar.MONTH, fromCal.get(Calendar.MONTH))
+        }
+
+        while (true) {
+            val targetDate =
+                findOccurrenceInMonth(
+                    next.get(Calendar.YEAR),
+                    next.get(Calendar.MONTH),
+                    rep.occurrence!!,
+                    rep.dayOfWeek!!,
+                    dateTime.toCalendar(),
+                )
+            if (targetDate.after(fromCal)) {
+                return targetDate.time
+            }
+            next.add(Calendar.MONTH, rep.value)
         }
     }
 
-    return calendar.time
+    val timeDifferenceMillis: Long = from.time - dateTime.time
+    val intervalsPassed = timeDifferenceMillis / rep.toMillis()
+    val unitsUntilNext = ((rep.value) * (intervalsPassed + 1)).toInt()
+    val reminderStart = dateTime.toCalendar()
+    reminderStart.add(rep.unit.toCalendarField(), unitsUntilNext)
+    return reminderStart.time
+}
+
+private fun findOccurrenceInMonth(
+    year: Int,
+    month: Int,
+    occurrence: Int,
+    dayOfWeek: Int,
+    originalTime: Calendar,
+): Calendar {
+    val cal =
+        Calendar.getInstance().apply {
+            set(Calendar.YEAR, year)
+            set(Calendar.MONTH, month)
+            set(Calendar.DAY_OF_MONTH, 1)
+            set(Calendar.HOUR_OF_DAY, originalTime.get(Calendar.HOUR_OF_DAY))
+            set(Calendar.MINUTE, originalTime.get(Calendar.MINUTE))
+            set(Calendar.SECOND, originalTime.get(Calendar.SECOND))
+            set(Calendar.MILLISECOND, originalTime.get(Calendar.MILLISECOND))
+        }
+
+    if (occurrence > 0) {
+        // Find first dayOfWeek
+        while (cal.get(Calendar.DAY_OF_WEEK) != dayOfWeek) {
+            cal.add(Calendar.DAY_OF_MONTH, 1)
+        }
+        // Advance to the Nth occurrence
+        cal.add(Calendar.DAY_OF_MONTH, 7 * (occurrence - 1))
+
+        // If we advanced into the next month, it means there are fewer than 'occurrence' of that
+        // day in this month.
+        // The requirement says "if not, it'll behave like the previous option, so 4th day" for the
+        // last day,
+        // but for 1st-4th it should probably stay in the month if it exists.
+        // Actually, for 1st-4th, they ALWAYS exist in every month. Only 5th might not exist.
+        if (cal.get(Calendar.MONTH) != month) {
+            // Fallback to 4th if 5th doesn't exist (though only 1-4 and -1 are currently planned)
+            return findOccurrenceInMonth(year, month, occurrence - 1, dayOfWeek, originalTime)
+        }
+    } else if (occurrence == -1) {
+        // Last occurrence
+        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH))
+        while (cal.get(Calendar.DAY_OF_WEEK) != dayOfWeek) {
+            cal.add(Calendar.DAY_OF_MONTH, -1)
+        }
+    }
+    return cal
 }
 
 fun Reminder.nextRepetition(from: Date = Date()): Date? {
diff --git a/app/src/main/java/com/philkes/notallyx/data/model/Reminder.kt b/app/src/main/java/com/philkes/notallyx/data/model/Reminder.kt
@@ -12,7 +12,13 @@ data class Reminder(
     var isNotificationVisible: Boolean = false,
 ) : Parcelable
 
-@Parcelize data class Repetition(var value: Int, var unit: RepetitionTimeUnit) : Parcelable
+@Parcelize
+data class Repetition(
+    var value: Int,
+    var unit: RepetitionTimeUnit,
+    var occurrence: Int? = null,
+    var dayOfWeek: Int? = null,
+) : Parcelable
 
 enum class RepetitionTimeUnit {
     MINUTES,
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/note/reminders/RemindersActivity.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/note/reminders/RemindersActivity.kt
@@ -41,7 +41,9 @@ import com.philkes.notallyx.presentation.view.main.reminder.ReminderListener
 import com.philkes.notallyx.presentation.viewmodel.NotallyModel
 import com.philkes.notallyx.utils.canScheduleAlarms
 import com.philkes.notallyx.utils.now
+import java.text.SimpleDateFormat
 import java.util.Calendar
+import java.util.Locale
 import kotlinx.coroutines.launch
 
 class RemindersActivity : LockedActivity<ActivityRemindersBinding>(), ReminderListener {
@@ -238,9 +240,19 @@ class RemindersActivity : LockedActivity<ActivityRemindersBinding>(), ReminderLi
                             value == 1 && unit == RepetitionTimeUnit.WEEKS ->
                                 Weekly.isChecked = true
 
-                            value == 1 && unit == RepetitionTimeUnit.MONTHS ->
+                            value == 1 && unit == RepetitionTimeUnit.MONTHS && occurrence == null ->
                                 Monthly.isChecked = true
 
+                            value == 1 &&
+                                unit == RepetitionTimeUnit.MONTHS &&
+                                occurrence != null -> {
+                                MonthlyAdvanced.apply {
+                                    visibility = View.VISIBLE
+                                    text = toText(this@RemindersActivity)
+                                    isChecked = true
+                                }
+                            }
+
                             value == 1 && unit == RepetitionTimeUnit.YEARS ->
                                 Yearly.isChecked = true
 
@@ -266,6 +278,7 @@ class RemindersActivity : LockedActivity<ActivityRemindersBinding>(), ReminderLi
                             R.id.Weekly -> Repetition(1, RepetitionTimeUnit.WEEKS)
                             R.id.Monthly -> Repetition(1, RepetitionTimeUnit.MONTHS)
                             R.id.Yearly -> Repetition(1, RepetitionTimeUnit.YEARS)
+                            R.id.MonthlyAdvanced -> reminder?.repetition?.copy()
                             R.id.Custom -> reminder?.repetition?.copy()
                             else -> null
                         }
@@ -284,11 +297,88 @@ class RemindersActivity : LockedActivity<ActivityRemindersBinding>(), ReminderLi
             None.setOnCheckedEnableButton(positiveButton)
             Daily.setOnCheckedEnableButton(positiveButton)
             Weekly.setOnCheckedEnableButton(positiveButton)
-            Monthly.setOnCheckedEnableButton(positiveButton)
+            Monthly.setOnClickListener {
+                dialog.dismiss()
+                showMonthlyAdvancedRepetitionDialog(reminder, calendar, onRepetitionSelected)
+            }
+            MonthlyAdvanced.setOnClickListener {
+                dialog.dismiss()
+                showMonthlyAdvancedRepetitionDialog(reminder, calendar, onRepetitionSelected)
+            }
             Yearly.setOnCheckedEnableButton(positiveButton)
         }
     }
 
+    private fun showMonthlyAdvancedRepetitionDialog(
+        reminder: Reminder? = null,
+        calendar: Calendar,
+        onRepetitionSelected: (Repetition?) -> Unit,
+    ) {
+        val dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK)
+        val dayOfWeekStr = SimpleDateFormat("EEEE", Locale.getDefault()).format(calendar.time)
+        val dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH)
+        val isLastDayOfMonth = dayOfMonth == calendar.getActualMaximum(Calendar.DAY_OF_MONTH)
+
+        val monthlyOptionText =
+            if (isLastDayOfMonth) {
+                getString(R.string.of_the_month_last, getString(R.string.day))
+            } else {
+                "$dayOfMonth. ${getString(R.string.of_the_month, getString(R.string.day))}"
+            }
+
+        val options =
+            arrayOf(
+                monthlyOptionText,
+                "1. ${getString(R.string.of_the_month, dayOfWeekStr)}",
+                "2. ${getString(R.string.of_the_month, dayOfWeekStr)}",
+                "3. ${getString(R.string.of_the_month, dayOfWeekStr)}",
+                "4. ${getString(R.string.of_the_month, dayOfWeekStr)}",
+                getString(R.string.of_the_month_last, dayOfWeekStr),
+            )
+
+        var selectedIndex = 0
+        reminder?.repetition?.let {
+            if (it.unit == RepetitionTimeUnit.MONTHS && it.value == 1) {
+                selectedIndex =
+                    when (it.occurrence) {
+                        null -> 0
+                        1 -> 1
+                        2 -> 2
+                        3 -> 3
+                        4 -> 4
+                        -1 -> 5
+                        else -> 0
+                    }
+            }
+        }
+
+        MaterialAlertDialogBuilder(this)
+            .setTitle(R.string.monthly)
+            .setSingleChoiceItems(options, selectedIndex) { dialog, which ->
+                val repetition =
+                    when (which) {
+                        0 -> Repetition(1, RepetitionTimeUnit.MONTHS)
+                        1 -> Repetition(1, RepetitionTimeUnit.MONTHS, 1, dayOfWeek)
+                        2 -> Repetition(1, RepetitionTimeUnit.MONTHS, 2, dayOfWeek)
+                        3 -> Repetition(1, RepetitionTimeUnit.MONTHS, 3, dayOfWeek)
+                        4 -> Repetition(1, RepetitionTimeUnit.MONTHS, 4, dayOfWeek)
+                        5 -> Repetition(1, RepetitionTimeUnit.MONTHS, -1, dayOfWeek)
+                        else -> Repetition(1, RepetitionTimeUnit.MONTHS)
+                    }
+                onRepetitionSelected(repetition)
+                dialog.dismiss()
+            }
+            .setNegativeButton(R.string.back) { dialog, _ ->
+                dialog.dismiss()
+                showRepetitionDialog(
+                    reminder,
+                    calendar,
+                    onRepetitionSelected = onRepetitionSelected,
+                )
+            }
+            .show()
+    }
+
     private fun showCustomRepetitionDialog(
         reminder: Reminder? = null,
         calendar: Calendar,
@@ -325,7 +415,19 @@ class RemindersActivity : LockedActivity<ActivityRemindersBinding>(), ReminderLi
                             R.id.Years -> RepetitionTimeUnit.YEARS
                             else -> null
                         }
-                    onRepetitionSelected(selectedTimeUnit?.let { Repetition(value, it) })
+                    onRepetitionSelected(
+                        selectedTimeUnit?.let {
+                            if (it == RepetitionTimeUnit.MONTHS && value == 1) {
+                                showMonthlyAdvancedRepetitionDialog(
+                                    reminder,
+                                    calendar,
+                                    onRepetitionSelected,
+                                )
+                                return@setPositiveButton
+                            }
+                            Repetition(value, it)
+                        }
+                    )
                 }
                 .setBackgroundInsetBottom(0)
                 .setBackgroundInsetTop(0)
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/view/main/reminder/ReminderVH.kt b/app/src/main/java/com/philkes/notallyx/presentation/view/main/reminder/ReminderVH.kt
@@ -1,9 +1,8 @@
 package com.philkes.notallyx.presentation.view.main.reminder
 
 import androidx.recyclerview.widget.RecyclerView
-import com.philkes.notallyx.R
 import com.philkes.notallyx.data.model.Reminder
-import com.philkes.notallyx.data.model.toText
+import com.philkes.notallyx.data.model.toRepetitionText
 import com.philkes.notallyx.databinding.RecyclerReminderBinding
 import com.philkes.notallyx.presentation.format
 
@@ -15,9 +14,7 @@ class ReminderVH(
     fun bind(value: Reminder) {
         binding.apply {
             DateTime.text = value.dateTime.format()
-            Repetition.text =
-                value.repetition?.toText(itemView.context)
-                    ?: itemView.context.getText(R.string.reminder_no_repetition)
+            Repetition.text = value.toRepetitionText(itemView.context)
             EditButton.setOnClickListener { listener.edit(value) }
             DeleteButton.setOnClickListener { listener.delete(value) }
         }
diff --git a/app/src/main/res/layout/dialog_reminder_repetition.xml b/app/src/main/res/layout/dialog_reminder_repetition.xml
@@ -44,6 +44,13 @@
         android:layout_height="wrap_content"
         android:text="@string/yearly" />
 
+    <RadioButton
+        android:id="@+id/MonthlyAdvanced"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:visibility="gone"
+        android:text="@string/monthly" />
+
     <RadioButton
         android:id="@+id/Custom"
         android:layout_width="wrap_content"
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
diff --git a/app/src/test/kotlin/com/philkes/notallyx/data/model/ReminderRepetitionTest.kt b/app/src/test/kotlin/com/philkes/notallyx/data/model/ReminderRepetitionTest.kt
diff --git a/app/translations.xlsx b/app/translations.xlsx
