refactor: Bump version code and name

Signed-off-by: Pranav Purwar <purwarpranav80@gmail.com>

Author: PranavPurwar

Reef/build.gradle.kts

@@ -13,8 +13,8 @@ android {
         applicationId = "dev.pranav.reef"
         minSdk = 26
         targetSdk = 36
-        versionCode = 202
-        versionName = "2.0.2"
+        versionCode = 203
+        versionName = "2.0.3"
     }
 
     viewBinding.enable = true
@@ -26,8 +26,9 @@ android {
 
     buildTypes {
         release {
-            isMinifyEnabled = true
-            isShrinkResources = true
+            // Causing issues smh
+            isMinifyEnabled = false
+            isShrinkResources = false
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
             )

Reef/src/main/java/dev/pranav/reef/CreateRoutineActivity.kt

@@ -414,7 +414,7 @@ fun CreateRoutineScreen(
                     if (result) onSaveComplete()
                 },
                 modifier = Modifier.fillMaxWidth(),
-                shape = RoundedCornerShape(16.dp),
+                shapes = ButtonDefaults.shapes(),
                 contentPadding = PaddingValues(vertical = 16.dp)
             ) {
                 Text(
@@ -427,7 +427,7 @@ fun CreateRoutineScreen(
                 OutlinedButton(
                     onClick = { showDeleteDialog = true },
                     modifier = Modifier.fillMaxWidth(),
-                    shape = RoundedCornerShape(16.dp),
+                    shapes = ButtonDefaults.shapes(),
                     contentPadding = PaddingValues(vertical = 16.dp),
                     colors = ButtonDefaults.outlinedButtonColors(
                         contentColor = MaterialTheme.colorScheme.error

Reef/src/main/java/dev/pranav/reef/RoutinesActivity.kt

@@ -98,26 +98,6 @@ class RoutinesActivity : ComponentActivity() {
             }
         }
     }
-
-    override fun onResume() {
-        super.onResume()
-        setContent {
-            ReefTheme {
-                RoutinesScreen(
-                    onBackPressed = { onBackPressedDispatcher.onBackPressed() },
-                    onCreateRoutine = {
-                        startActivity(Intent(this, CreateRoutineActivity::class.java))
-                    },
-                    onEditRoutine = { routine ->
-                        val intent = Intent(this, CreateRoutineActivity::class.java).apply {
-                            putExtra("routine_id", routine.id)
-                        }
-                        startActivity(intent)
-                    }
-                )
-            }
-        }
-    }
 }
 
 @OptIn(ExperimentalMaterial3Api::class)
@@ -198,7 +178,7 @@ fun RoutinesScreen(
                                 onEditRoutine(routine)
                             }
                         },
-                        onToggle = { enabled ->
+                        onToggle = { _ ->
                             RoutineManager.toggleRoutine(routine.id, context)
                             routines = RoutineManager.getRoutines()
                         }
@@ -219,6 +199,7 @@ fun RoutinesScreen(
                         activateRoutineNow(routine, context)
                         showActivateDialog = null
 
+                        @Suppress("ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE")
                         val limitsText = when (routine.limits.size) {
                             0 -> "No app limits were applied"
                             1 -> "1 app limit has been applied"
@@ -408,7 +389,9 @@ fun RoutineItem(
     }
 }
 
-private fun formatSchedule(schedule: RoutineSchedule): String {
+private fun formatSchedule(schedule: RoutineSchedule?): String {
+    if (schedule == null) return "Unknown schedule"
+
     return when (schedule.type) {
         RoutineSchedule.ScheduleType.DAILY -> {
             val timeRange = if (schedule.time != null && schedule.endTime != null) {

Reef/src/main/java/dev/pranav/reef/util/RoutineManager.kt

@@ -2,60 +2,130 @@ package dev.pranav.reef.util
 
 import android.content.Context
 import androidx.core.content.edit
-import com.google.gson.GsonBuilder
-import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonDeserializer
-import com.google.gson.JsonElement
-import com.google.gson.JsonPrimitive
-import com.google.gson.JsonSerializationContext
-import com.google.gson.JsonSerializer
-import com.google.gson.reflect.TypeToken
 import dev.pranav.reef.data.Routine
 import dev.pranav.reef.data.RoutineSchedule
-import java.lang.reflect.Type
+import org.json.JSONArray
+import org.json.JSONObject
 import java.time.DayOfWeek
 import java.util.UUID
 
 object RoutineManager {
     private const val ROUTINES_KEY = "routines"
 
-    private val gson = GsonBuilder()
-        .registerTypeAdapter(DayOfWeek::class.java, object : JsonSerializer<DayOfWeek> {
-            override fun serialize(
-                src: DayOfWeek?,
-                typeOfSrc: Type?,
-                context: JsonSerializationContext?
-            ): JsonElement {
-                return JsonPrimitive(src?.name)
+    fun getRoutines(): List<Routine> {
+        val json = prefs.getString(ROUTINES_KEY, "[]") ?: "[]"
+        return try {
+            val jsonArray = JSONArray(json)
+            val routines = mutableListOf<Routine>()
+
+            for (i in 0 until jsonArray.length()) {
+                val routineJson = jsonArray.getJSONObject(i)
+                val routine = parseRoutine(routineJson)
+                if (routine != null) {
+                    routines.add(routine)
+                }
             }
-        })
-        .registerTypeAdapter(DayOfWeek::class.java, object : JsonDeserializer<DayOfWeek> {
-            override fun deserialize(
-                json: JsonElement?,
-                typeOfT: Type?,
-                context: JsonDeserializationContext?
-            ): DayOfWeek? {
-                return json?.asString?.let { DayOfWeek.valueOf(it) }
+            routines
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    private fun parseRoutine(json: JSONObject): Routine? {
+        return try {
+            val scheduleJson = json.getJSONObject("schedule")
+            val schedule = RoutineSchedule(
+                type = RoutineSchedule.ScheduleType.valueOf(scheduleJson.getString("type")),
+                timeHour = if (scheduleJson.has("timeHour")) scheduleJson.getInt("timeHour") else null,
+                timeMinute = if (scheduleJson.has("timeMinute")) scheduleJson.getInt("timeMinute") else null,
+                endTimeHour = if (scheduleJson.has("endTimeHour")) scheduleJson.getInt("endTimeHour") else null,
+                endTimeMinute = if (scheduleJson.has("endTimeMinute")) scheduleJson.getInt("endTimeMinute") else null,
+                daysOfWeek = parseDaysOfWeek(scheduleJson.optJSONArray("daysOfWeek")),
+                isRecurring = scheduleJson.optBoolean("isRecurring", true)
+            )
+
+            val limitsArray = json.getJSONArray("limits")
+            val limits = mutableListOf<Routine.AppLimit>()
+            for (i in 0 until limitsArray.length()) {
+                val limitJson = limitsArray.getJSONObject(i)
+                limits.add(
+                    Routine.AppLimit(
+                        packageName = limitJson.getString("packageName"),
+                        limitMinutes = limitJson.getInt("limitMinutes")
+                    )
+                )
             }
-        })
-        .create()
 
-    fun getRoutines(): List<Routine> {
-        val json = prefs.getString(ROUTINES_KEY, "[]") ?: "[]"
-        val type = object : TypeToken<List<Routine>>() {}.type
-        return gson.fromJson(json, type)
+            Routine(
+                id = json.getString("id"),
+                name = json.getString("name"),
+                isEnabled = json.getBoolean("isEnabled"),
+                schedule = schedule,
+                limits = limits
+            )
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private fun parseDaysOfWeek(jsonArray: JSONArray?): Set<DayOfWeek> {
+        if (jsonArray == null) return emptySet()
+        val days = mutableSetOf<DayOfWeek>()
+        for (i in 0 until jsonArray.length()) {
+            try {
+                days.add(DayOfWeek.valueOf(jsonArray.getString(i)))
+            } catch (_: Exception) {
+                // Skip invalid days
+            }
+        }
+        return days
     }
 
     fun saveRoutines(routines: List<Routine>, context: Context? = null) {
-        val json = gson.toJson(routines)
-        prefs.edit { putString(ROUTINES_KEY, json) }
+        val jsonArray = JSONArray()
+        routines.forEach { routine ->
+            jsonArray.put(routineToJson(routine))
+        }
+        prefs.edit { putString(ROUTINES_KEY, jsonArray.toString()) }
 
-        // Reschedule all routines when saved
         context?.let { ctx ->
             RoutineScheduler.scheduleAllRoutines(ctx)
         }
     }
 
+    private fun routineToJson(routine: Routine): JSONObject {
+        return JSONObject().apply {
+            put("id", routine.id)
+            put("name", routine.name)
+            put("isEnabled", routine.isEnabled)
+
+            val schedule = routine.schedule
+            val scheduleJson = JSONObject().apply {
+                put("type", schedule?.type?.name ?: "MANUAL")
+                schedule?.timeHour?.let { put("timeHour", it) }
+                schedule?.timeMinute?.let { put("timeMinute", it) }
+                schedule?.endTimeHour?.let { put("endTimeHour", it) }
+                schedule?.endTimeMinute?.let { put("endTimeMinute", it) }
+
+                val daysArray = JSONArray()
+                schedule?.daysOfWeek?.forEach { daysArray.put(it.name) }
+                put("daysOfWeek", daysArray)
+
+                put("isRecurring", schedule?.isRecurring ?: true)
+            }
+            put("schedule", scheduleJson)
+
+            val limitsArray = JSONArray()
+            routine.limits.forEach { limit ->
+                limitsArray.put(JSONObject().apply {
+                    put("packageName", limit.packageName)
+                    put("limitMinutes", limit.limitMinutes)
+                })
+            }
+            put("limits", limitsArray)
+        }
+    }
+
     fun addRoutine(routine: Routine, context: Context? = null) {
         val routines = getRoutines().toMutableList()
         routines.add(routine)
@@ -89,16 +159,13 @@ object RoutineManager {
 
             context?.let { ctx ->
                 if (oldRoutine.isEnabled) {
-                    // Was enabled, now disabled - cancel scheduling and clear limits if active
                     RoutineScheduler.cancelRoutine(ctx, routineId)
 
-                    // Check if this routine is currently active and clear its limits
                     val activeRoutineId = RoutineLimits.getActiveRoutineId()
                     if (activeRoutineId == routineId) {
                         RoutineLimits.clearRoutineLimits()
                     }
                 } else {
-                    // Was disabled, now enabled - schedule it
                     RoutineScheduler.scheduleRoutine(ctx, routines[index])
                 }
             }

Reef/src/main/java/dev/pranav/reef/util/RoutineScheduler.kt

@@ -23,7 +23,8 @@ object RoutineScheduler {
     }
 
     fun scheduleRoutine(context: Context, routine: Routine) {
-        if (!routine.isEnabled || routine.schedule.type == RoutineSchedule.ScheduleType.MANUAL) {
+        val schedule = routine.schedule
+        if (!routine.isEnabled || schedule.type == RoutineSchedule.ScheduleType.MANUAL) {
             return
         }
 
@@ -33,15 +34,15 @@ object RoutineScheduler {
             activateRoutineNow(context, routine)
 
             // Only schedule deactivation
-            if (routine.schedule.endTime != null) {
+            if (schedule.endTime != null) {
                 scheduleRoutineAction(context, routine, isActivation = false)
             }
         } else {
             // Schedule activation
             scheduleRoutineAction(context, routine, isActivation = true)
 
             // Schedule deactivation if end time exists
-            if (routine.schedule.endTime != null) {
+            if (schedule.endTime != null) {
                 scheduleRoutineAction(context, routine, isActivation = false)
             }
         }
@@ -82,6 +83,8 @@ object RoutineScheduler {
     }
 
     fun scheduleRoutineAction(context: Context, routine: Routine, isActivation: Boolean) {
+        val schedule = routine.schedule
+
         val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
         val intent = Intent(context, RoutineActivationReceiver::class.java).apply {
             putExtra("routine_id", routine.id)
@@ -96,9 +99,9 @@ object RoutineScheduler {
         )
 
         val triggerTime = if (isActivation) {
-            calculateNextTriggerTime(routine.schedule, useStartTime = true)
+            calculateNextTriggerTime(schedule, useStartTime = true)
         } else {
-            calculateNextTriggerTime(routine.schedule, useStartTime = false)
+            calculateNextTriggerTime(schedule, useStartTime = false)
         }
 
         if (triggerTime != null) {
@@ -125,7 +128,7 @@ object RoutineScheduler {
                         "Scheduled routine ${routine.name} $action (inexact) for ${Date(triggerTime)}"
                     )
                 }
-            } catch (e: SecurityException) {
+            } catch (_: SecurityException) {
                 alarmManager.set(
                     AlarmManager.RTC_WAKEUP,
                     triggerTime,
@@ -233,15 +236,13 @@ class RoutineActivationReceiver : BroadcastReceiver() {
     private fun deactivateRoutine(context: Context, routine: Routine) {
         Log.d("RoutineActivationReceiver", "Deactivating routine: ${routine.name}")
 
-        // Clear routine limits
         RoutineLimits.clearRoutineLimits()
 
         // Schedule next occurrence if recurring
         if (routine.schedule.isRecurring) {
             RoutineScheduler.scheduleRoutine(context, routine)
         }
 
-        // Show notification about routine deactivation
         NotificationHelper.showRoutineDeactivatedNotification(context, routine)
     }
 }