Add UpdateCalendarWork

app/src/main/java/com/todoroo/astrid/dao/TaskDao.kt

@@ -89,8 +89,10 @@ class TaskDao @Inject constructor(
             val deletionDateModified = task.deletionDate != original?.deletionDate ?: 0
             val justCompleted = completionDateModified && task.isCompleted
             val justDeleted = deletionDateModified && task.isDeleted
-            if (justCompleted && (task.isRecurring || !task.calendarURI.isNullOrBlank())) {
-                workManager.afterComplete(task)
+            if (justCompleted && task.isRecurring) {
+                workManager.scheduleRepeat(task)
+            } else if (!task.calendarURI.isNullOrBlank()) {
+                workManager.updateCalendar(task)
             }
             coroutineScope {
                 launch(Dispatchers.Default) {

app/src/main/java/com/todoroo/astrid/gcal/GCalHelper.kt

@@ -25,7 +25,7 @@ import java.util.*
 import javax.inject.Inject
 
 class GCalHelper @Inject constructor(
-        @ApplicationContext context: Context,
+        @ApplicationContext private val context: Context,
         private val taskDao: TaskDao,
         private val preferences: Preferences,
         private val permissionChecker: PermissionChecker,
@@ -94,11 +94,18 @@ class GCalHelper @Inject constructor(
         return null
     }
 
-    fun updateEvent(uri: String?, task: Task) {
+    fun updateEvent(task: Task) {
+        val uri = task.calendarURI ?: return
+        if (!permissionChecker.canAccessCalendars()) {
+            return
+        }
         try {
             val updateValues = ContentValues()
-            // check if we need to update the item
-            updateValues.put(CalendarContract.Events.TITLE, task.title)
+            updateValues.put(CalendarContract.Events.TITLE, if (task.isCompleted) {
+                context.getString(R.string.gcal_completed_title, task.title)
+            } else {
+                task.title
+            })
             updateValues.put(CalendarContract.Events.DESCRIPTION, task.notes)
             createStartAndEndDate(task, updateValues)
             cr.update(Uri.parse(uri), updateValues, null, null)

app/src/main/java/org/tasks/calendars/CalendarEventProvider.java

@@ -65,6 +65,9 @@ public class CalendarEventProvider {
   }
 
   public void deleteEvent(Task task) {
+    if (!permissionChecker.canAccessCalendars()) {
+      return;
+    }
     String uri = task.getCalendarURI();
     task.setCalendarURI("");
     deleteEvent(uri);

app/src/main/java/org/tasks/dialogs/DateTimePicker.kt

@@ -243,9 +243,10 @@ class DateTimePicker : BottomSheetDialogFragment() {
         if (dueDate != arguments?.getLong(EXTRA_TIMESTAMP)) {
             if (taskId > 0) {
                 lifecycleScope.launch(NonCancellable) {
-                    val task: Task = taskDao.fetch(taskId)!!
-                    task.setDueDateAdjustingHideUntil(dueDate)
-                    taskDao.save(task)
+                    taskDao.fetch(taskId)?.let {
+                        it.setDueDateAdjustingHideUntil(dueDate)
+                        taskDao.save(it)
+                    }
                 }
             } else {
                 val intent = Intent()

app/src/main/java/org/tasks/jobs/AfterSaveWork.kt

@@ -1,21 +1,15 @@
 package org.tasks.jobs
 
-import android.content.ContentValues
 import android.content.Context
-import android.net.Uri
-import android.provider.CalendarContract
 import androidx.hilt.Assisted
 import androidx.hilt.work.WorkerInject
 import androidx.work.WorkerParameters
-import com.todoroo.astrid.data.Task
+import com.todoroo.astrid.gcal.GCalHelper
 import com.todoroo.astrid.repeats.RepeatTaskHelper
-import org.tasks.R
-import org.tasks.Strings.isNullOrEmpty
 import org.tasks.analytics.Firebase
 import org.tasks.data.CaldavDao
 import org.tasks.data.TaskDao
 import org.tasks.injection.BaseWorker
-import timber.log.Timber
 
 class AfterSaveWork @WorkerInject constructor(
         @Assisted context: Context,
@@ -23,42 +17,22 @@ class AfterSaveWork @WorkerInject constructor(
         firebase: Firebase,
         private val repeatTaskHelper: RepeatTaskHelper,
         private val taskDao: TaskDao,
-        private val caldavDao: CaldavDao
+        private val caldavDao: CaldavDao,
+        private val gCalHelper: GCalHelper
 ) : BaseWorker(context, workerParams, firebase) {
 
     override suspend fun run(): Result {
         val taskId = inputData.getLong(EXTRA_ID, -1)
-        val task = taskDao.fetch(taskId)
-        if (task == null) {
-            Timber.e("Missing saved task")
-            return Result.failure()
-        }
+        val task = taskDao.fetch(taskId) ?: return Result.failure()
+
+        gCalHelper.updateEvent(task)
 
-        updateCalendarTitle(task)
-        val account = caldavDao.getAccountForTask(taskId)
-        if (account == null || !account.isSuppressRepeatingTasks) {
+        if (caldavDao.getAccountForTask(taskId)?.isSuppressRepeatingTasks != true) {
             repeatTaskHelper.handleRepeat(task)
         }
         return Result.success()
     }
 
-    private fun updateCalendarTitle(task: Task) {
-        val calendarUri = task.calendarURI
-        if (!isNullOrEmpty(calendarUri)) {
-            try {
-                // change title of calendar event
-                val cr = context.contentResolver
-                val values = ContentValues()
-                values.put(
-                        CalendarContract.Events.TITLE,
-                        context.getString(R.string.gcal_completed_title, task.title))
-                cr.update(Uri.parse(calendarUri), values, null, null)
-            } catch (e: Exception) {
-                Timber.e(e)
-            }
-        }
-    }
-
     companion object {
         const val EXTRA_ID = "extra_id"
     }

app/src/main/java/org/tasks/jobs/UpdateCalendarWork.kt

@@ -0,0 +1,41 @@
+package org.tasks.jobs
+
+import android.content.Context
+import androidx.hilt.Assisted
+import androidx.hilt.work.WorkerInject
+import androidx.work.WorkerParameters
+import com.todoroo.astrid.gcal.GCalHelper
+import org.tasks.analytics.Firebase
+import org.tasks.calendars.CalendarEventProvider
+import org.tasks.data.TaskDao
+import org.tasks.injection.BaseWorker
+import org.tasks.preferences.PermissionChecker
+
+class UpdateCalendarWork @WorkerInject constructor(
+        @Assisted context: Context,
+        @Assisted workerParams: WorkerParameters,
+        firebase: Firebase,
+        private val taskDao: TaskDao,
+        private val gCalHelper: GCalHelper,
+        private val calendarEventProvider: CalendarEventProvider,
+        private val permissionChecker: PermissionChecker
+) : BaseWorker(context, workerParams, firebase) {
+
+    override suspend fun run(): Result {
+        if (!permissionChecker.canAccessCalendars()) {
+            return Result.failure()
+        }
+        val taskId = inputData.getLong(EXTRA_ID, -1)
+        val task = taskDao.fetch(taskId) ?: return Result.failure()
+        if (task.hasDueDate()) {
+            gCalHelper.updateEvent(task)
+        } else {
+            calendarEventProvider.deleteEvent(task)
+        }
+        return Result.success()
+    }
+
+    companion object {
+        const val EXTRA_ID = "extra_id"
+    }
+}

app/src/main/java/org/tasks/jobs/WorkManager.kt

@@ -7,7 +7,9 @@ import org.tasks.data.Place
 
 interface WorkManager {
 
-    fun afterComplete(task: Task)
+    fun scheduleRepeat(task: Task)
+
+    fun updateCalendar(task: Task)
 
     fun cleanup(ids: Iterable<Long>)
 

app/src/main/java/org/tasks/jobs/WorkManagerImpl.kt

@@ -55,7 +55,7 @@ class WorkManagerImpl constructor(
     private val alarmManager: AlarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
     private val workManager = androidx.work.WorkManager.getInstance(context)
 
-    override fun afterComplete(task: Task) {
+    override fun scheduleRepeat(task: Task) {
         enqueue(
                 OneTimeWorkRequest.Builder(AfterSaveWork::class.java)
                         .setInputData(Data.Builder()
@@ -63,6 +63,14 @@ class WorkManagerImpl constructor(
                                 .build()))
     }
 
+    override fun updateCalendar(task: Task) {
+        enqueue(
+                OneTimeWorkRequest.Builder(UpdateCalendarWork::class.java)
+                        .setInputData(Data.Builder()
+                                .putLong(UpdateCalendarWork.EXTRA_ID, task.id)
+                                .build()))
+    }
+
     override fun cleanup(ids: Iterable<Long>) {
         ids.chunked(MAX_CLEANUP_LENGTH) {
             enqueue(

app/src/main/java/org/tasks/ui/TaskEditViewModel.kt

@@ -380,19 +380,12 @@ class TaskEditViewModel @ViewModelInject constructor(
         if (!permissionChecker.canAccessCalendars()) {
             return
         }
-        if (eventUri == null || task?.hasDueDate() != true) {
-            if (!task?.calendarURI.isNullOrBlank()) {
-                calendarEventProvider.deleteEvent(task)
-            }
+        if (eventUri == null) {
+            calendarEventProvider.deleteEvent(task)
         }
         if (task?.hasDueDate() != true) {
             return
         }
-        eventUri?.let {
-            if (!it.isBlank()) {
-                gCalHelper.updateEvent(it, task!!)
-            }
-        }
         selectedCalendar?.let {
             try {
                 task?.calendarURI = gCalHelper.createTaskEvent(task!!, it)?.toString()