Convert AlarmService to Kotlin

app/src/main/java/com/todoroo/astrid/alarms/AlarmService.java

@@ -1,127 +0,0 @@
-/*
- * Copyright (c) 2012 Todoroo Inc
- *
- * See the file "LICENSE" for the full license governing this code.
- */
-
-package com.todoroo.astrid.alarms;
-
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import org.tasks.data.Alarm;
-import org.tasks.data.AlarmDao;
-import org.tasks.jobs.AlarmEntry;
-import org.tasks.jobs.NotificationQueue;
-
-/**
- * Provides operations for working with alerts
- *
- * @author Tim Su <tim@todoroo.com>
- */
-@Singleton
-public class AlarmService {
-
-  private static final long NO_ALARM = Long.MAX_VALUE;
-
-  private final NotificationQueue jobs;
-  private final AlarmDao alarmDao;
-
-  @Inject
-  public AlarmService(AlarmDao alarmDao, NotificationQueue notificationQueue) {
-    this.alarmDao = alarmDao;
-    jobs = notificationQueue;
-  }
-
-  public void rescheduleAlarms(long taskId, long oldDueDate, long newDueDate) {
-    if (newDueDate <= 0 || newDueDate <= oldDueDate) {
-      return;
-    }
-
-    final Set<Long> alarms = new LinkedHashSet<>();
-    for (Alarm alarm : getAlarms(taskId)) {
-      alarms.add(alarm.getTime() + (newDueDate - oldDueDate));
-    }
-    if (!alarms.isEmpty()) {
-      synchronizeAlarms(taskId, alarms);
-    }
-  }
-
-  public List<Alarm> getAlarms(long taskId) {
-    return alarmDao.getAlarms(taskId);
-  }
-
-  /**
-   * Save the given array of alarms into the database
-   *
-   * @return true if data was changed
-   */
-  public boolean synchronizeAlarms(final long taskId, Set<Long> timestamps) {
-    boolean changed = false;
-
-    for (Alarm item : alarmDao.getAlarms(taskId)) {
-      if (!timestamps.remove(item.getTime())) {
-        jobs.cancelAlarm(item.getId());
-        alarmDao.delete(item);
-        changed = true;
-      }
-    }
-
-    for (Long timestamp : timestamps) {
-      alarmDao.insert(new Alarm(taskId, timestamp));
-      changed = true;
-    }
-
-    if (changed) {
-      scheduleAlarms(taskId);
-    }
-    return changed;
-  }
-
-  // --- alarm scheduling
-
-  private List<Alarm> getActiveAlarms() {
-    return alarmDao.getActiveAlarms();
-  }
-
-  private List<Alarm> getActiveAlarmsForTask(long taskId) {
-    return alarmDao.getActiveAlarms(taskId);
-  }
-
-  /** Schedules all alarms */
-  public void scheduleAllAlarms() {
-    for (Alarm alarm : getActiveAlarms()) {
-      scheduleAlarm(alarm);
-    }
-  }
-
-  public void cancelAlarms(long taskId) {
-    for (Alarm alarm : getActiveAlarmsForTask(taskId)) {
-      jobs.cancelAlarm(alarm.getId());
-    }
-  }
-
-  /** Schedules alarms for a single task */
-  private void scheduleAlarms(long taskId) {
-    for (Alarm alarm : getActiveAlarmsForTask(taskId)) {
-      scheduleAlarm(alarm);
-    }
-  }
-
-  /** Schedules alarms for a single task */
-  private void scheduleAlarm(Alarm alarm) {
-    if (alarm == null) {
-      return;
-    }
-
-    AlarmEntry alarmEntry = new AlarmEntry(alarm);
-    long time = alarmEntry.getTime();
-    if (time == 0 || time == NO_ALARM) {
-      jobs.cancelAlarm(alarmEntry.getId());
-    } else {
-      jobs.add(alarmEntry);
-    }
-  }
-}

app/src/main/java/com/todoroo/astrid/alarms/AlarmService.kt

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2012 Todoroo Inc
+ *
+ * See the file "LICENSE" for the full license governing this code.
+ */
+package com.todoroo.astrid.alarms
+
+import org.tasks.data.Alarm
+import org.tasks.data.AlarmDao
+import org.tasks.jobs.AlarmEntry
+import org.tasks.jobs.NotificationQueue
+import java.util.*
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Provides operations for working with alerts
+ *
+ * @author Tim Su <tim></tim>@todoroo.com>
+ */
+@Singleton
+class AlarmService @Inject constructor(
+        private val alarmDao: AlarmDao,
+        private val jobs: NotificationQueue) {
+
+    fun rescheduleAlarms(taskId: Long, oldDueDate: Long, newDueDate: Long) {
+        if (newDueDate <= 0 || newDueDate <= oldDueDate) {
+            return
+        }
+        val alarms: MutableSet<Long> = LinkedHashSet()
+        for (alarm in getAlarms(taskId)) {
+            alarms.add(alarm.time + (newDueDate - oldDueDate))
+        }
+        if (alarms.isNotEmpty()) {
+            synchronizeAlarms(taskId, alarms)
+        }
+    }
+
+    fun getAlarms(taskId: Long): List<Alarm> {
+        return alarmDao.getAlarms(taskId)
+    }
+
+    /**
+     * Save the given array of alarms into the database
+     *
+     * @return true if data was changed
+     */
+    fun synchronizeAlarms(taskId: Long, timestamps: MutableSet<Long>): Boolean {
+        var changed = false
+        for (item in alarmDao.getAlarms(taskId)) {
+            if (!timestamps.remove(item.time)) {
+                jobs.cancelAlarm(item.id)
+                alarmDao.delete(item)
+                changed = true
+            }
+        }
+        for (timestamp in timestamps) {
+            alarmDao.insert(Alarm(taskId, timestamp))
+            changed = true
+        }
+        if (changed) {
+            scheduleAlarms(taskId)
+        }
+        return changed
+    }
+
+    private fun getActiveAlarmsForTask(taskId: Long): List<Alarm> {
+        return alarmDao.getActiveAlarms(taskId)
+    }
+
+    /** Schedules all alarms  */
+    fun scheduleAllAlarms() {
+        for (alarm in alarmDao.getActiveAlarms()) {
+            scheduleAlarm(alarm)
+        }
+    }
+
+    fun cancelAlarms(taskId: Long) {
+        for (alarm in getActiveAlarmsForTask(taskId)) {
+            jobs.cancelAlarm(alarm.id)
+        }
+    }
+
+    /** Schedules alarms for a single task  */
+    private fun scheduleAlarms(taskId: Long) {
+        for (alarm in getActiveAlarmsForTask(taskId)) {
+            scheduleAlarm(alarm)
+        }
+    }
+
+    /** Schedules alarms for a single task  */
+    private fun scheduleAlarm(alarm: Alarm?) {
+        if (alarm == null) {
+            return
+        }
+        val alarmEntry = AlarmEntry(alarm)
+        val time = alarmEntry.time
+        if (time == 0L || time == NO_ALARM) {
+            jobs.cancelAlarm(alarmEntry.id)
+        } else {
+            jobs.add(alarmEntry)
+        }
+    }
+
+    companion object {
+        private const val NO_ALARM = Long.MAX_VALUE
+    }
+}