Drag and drop in tags and filters

app/src/androidTest/java/com/todoroo/astrid/adapter/CaldavManualSortTaskAdapterTest.kt

@@ -14,6 +14,7 @@ import org.junit.runner.RunWith
 import org.tasks.R
 import org.tasks.data.CaldavCalendar
 import org.tasks.data.CaldavDao
+import org.tasks.data.GoogleTaskDao
 import org.tasks.data.TaskContainer
 import org.tasks.data.TaskListQuery.getQuery
 import org.tasks.injection.InjectingTestCase
@@ -31,6 +32,7 @@ import javax.inject.Inject
 
 @RunWith(AndroidJUnit4::class)
 class CaldavManualSortTaskAdapterTest : InjectingTestCase() {
+    @Inject lateinit var googleTaskDao: GoogleTaskDao
     @Inject lateinit var taskDao: TaskDao
     @Inject lateinit var caldavDao: CaldavDao
     @Inject lateinit var preferences: Preferences
@@ -50,7 +52,7 @@ class CaldavManualSortTaskAdapterTest : InjectingTestCase() {
         preferences.clear()
         preferences.setBoolean(R.string.p_manual_sort, true)
         tasks.clear()
-        adapter = CaldavManualSortTaskAdapter(taskDao, caldavDao)
+        adapter = CaldavManualSortTaskAdapter(googleTaskDao, caldavDao, taskDao)
         adapter.setDataSource(dataSource)
     }
 

app/src/androidTest/java/com/todoroo/astrid/adapter/CaldavTaskAdapterTest.kt

@@ -8,10 +8,7 @@ import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.tasks.data.CaldavDao
+import org.tasks.data.*
-import org.tasks.data.CaldavTask
-import org.tasks.data.SubsetCaldav
-import org.tasks.data.TaskContainer
 import org.tasks.injection.InjectingTestCase
 import org.tasks.injection.TestComponent
 import org.tasks.makers.TaskContainerMaker.PARENT
@@ -23,8 +20,9 @@ class CaldavTaskAdapterTest : InjectingTestCase() {
 
     @Inject lateinit var taskDao: TaskDao
     @Inject lateinit var caldavDao: CaldavDao
+    @Inject lateinit var googleTaskDao: GoogleTaskDao
 
-    private lateinit var adapter: CaldavTaskAdapter
+    private lateinit var adapter: TaskAdapter
     private val tasks = ArrayList<TaskContainer>()
 
     @Before
@@ -32,7 +30,7 @@ class CaldavTaskAdapterTest : InjectingTestCase() {
         super.setUp()
 
         tasks.clear()
-        adapter = CaldavTaskAdapter(taskDao, caldavDao)
+        adapter = TaskAdapter(false, googleTaskDao, caldavDao, taskDao)
         adapter.setDataSource(object : TaskAdapterDataSource {
             override fun getItem(position: Int) = tasks[position]
 

app/src/androidTest/java/com/todoroo/astrid/adapter/GoogleTaskManualSortAdapterTest.kt

@@ -11,6 +11,7 @@ import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.tasks.R
+import org.tasks.data.CaldavDao
 import org.tasks.data.GoogleTaskDao
 import org.tasks.data.TaskContainer
 import org.tasks.data.TaskListQuery.getQuery
@@ -31,6 +32,7 @@ import javax.inject.Inject
 class GoogleTaskManualSortAdapterTest : InjectingTestCase() {
 
     @Inject lateinit var taskDao: TaskDao
+    @Inject lateinit var caldavDao: CaldavDao
     @Inject lateinit var googleTaskDao: GoogleTaskDao
     @Inject lateinit var preferences: Preferences
 
@@ -411,7 +413,7 @@ class GoogleTaskManualSortAdapterTest : InjectingTestCase() {
         preferences.clear()
         preferences.setBoolean(R.string.p_manual_sort, true)
         tasks.clear()
-        adapter = GoogleTaskManualSortAdapter(taskDao, googleTaskDao)
+        adapter = GoogleTaskManualSortAdapter(googleTaskDao, caldavDao, taskDao)
         adapter.setDataSource(dataSource)
     }
 

app/src/androidTest/java/com/todoroo/astrid/adapter/NonRecursiveQueryTest.kt

@@ -13,6 +13,8 @@ import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.tasks.R
+import org.tasks.data.CaldavDao
+import org.tasks.data.GoogleTaskDao
 import org.tasks.data.TaskContainer
 import org.tasks.data.TaskListQuery.getQuery
 import org.tasks.injection.InjectingTestCase
@@ -25,6 +27,8 @@ import javax.inject.Inject
 @RunWith(AndroidJUnit4::class)
 class NonRecursiveQueryTest : InjectingTestCase() {
 
+    @Inject lateinit var googleTaskDao: GoogleTaskDao
+    @Inject lateinit var caldavDao: CaldavDao
     @Inject lateinit var taskDao: TaskDao
     @Inject lateinit var preferences: Preferences
 
@@ -43,7 +47,7 @@ class NonRecursiveQueryTest : InjectingTestCase() {
         preferences.clear()
         preferences.setBoolean(R.string.p_disable_subtasks, true)
         tasks.clear()
-        adapter = TaskAdapter()
+        adapter = TaskAdapter(false, googleTaskDao, caldavDao, taskDao)
         adapter.setDataSource(dataSource)
     }
 

app/src/androidTest/java/com/todoroo/astrid/adapter/OfflineSubtaskTest.kt

@@ -12,6 +12,8 @@ import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.tasks.data.CaldavDao
+import org.tasks.data.GoogleTaskDao
 import org.tasks.data.TaskContainer
 import org.tasks.data.TaskListQuery.getQuery
 import org.tasks.injection.InjectingTestCase
@@ -24,6 +26,8 @@ import javax.inject.Inject
 @RunWith(AndroidJUnit4::class)
 class OfflineSubtaskTest : InjectingTestCase() {
 
+    @Inject lateinit var googleTaskDao: GoogleTaskDao
+    @Inject lateinit var caldavDao: CaldavDao
     @Inject lateinit var taskDao: TaskDao
     @Inject lateinit var preferences: Preferences
 
@@ -41,7 +45,7 @@ class OfflineSubtaskTest : InjectingTestCase() {
         super.setUp()
         preferences.clear()
         tasks.clear()
-        adapter = TaskAdapter()
+        adapter = TaskAdapter(false, googleTaskDao, caldavDao, taskDao)
         adapter.setDataSource(dataSource)
     }
 

app/src/main/java/com/todoroo/astrid/activity/TaskListFragment.kt

@@ -710,9 +710,7 @@ class TaskListFragment : InjectingFragment(), OnRefreshListener, Toolbar.OnMenuI
         if (mode == null) {
             mode = (activity as AppCompatActivity).startSupportActionMode(this)
             updateModeTitle()
-            if (taskAdapter.supportsParentingOrManualSort()) {
+            Flags.set(Flags.TLFP_NO_INTERCEPT_TOUCH)
-                Flags.set(Flags.TLFP_NO_INTERCEPT_TOUCH)
-            }
         }
     }
 

app/src/main/java/com/todoroo/astrid/adapter/AstridTaskAdapter.kt

@@ -6,6 +6,8 @@ import com.todoroo.astrid.dao.TaskDao
 import com.todoroo.astrid.data.Task
 import com.todoroo.astrid.subtasks.SubtasksFilterUpdater
 import org.tasks.Strings.isNullOrEmpty
+import org.tasks.data.CaldavDao
+import org.tasks.data.GoogleTaskDao
 import org.tasks.data.TaskContainer
 import org.tasks.data.TaskListMetadata
 import timber.log.Timber
@@ -16,7 +18,9 @@ class AstridTaskAdapter internal constructor(
         private val list: TaskListMetadata,
         private val filter: Filter,
         private val updater: SubtasksFilterUpdater,
-        private val taskDao: TaskDao) : TaskAdapter() {
+        googleTaskDao: GoogleTaskDao,
+        caldavDao: CaldavDao,
+        private val taskDao: TaskDao) : TaskAdapter(false, googleTaskDao, caldavDao, taskDao) {
 
     private val chainedCompletions = Collections.synchronizedMap(HashMap<String, ArrayList<String>>())
 
@@ -29,8 +33,6 @@ class AstridTaskAdapter internal constructor(
         return updater.getIndentForTask(previous.uuid) + 1
     }
 
-    override fun supportsParentingOrManualSort() = true
-
     override fun supportsManualSorting() = true
 
     override fun moved(from: Int, to: Int, indent: Int) {

app/src/main/java/com/todoroo/astrid/adapter/CaldavManualSortTaskAdapter.kt

@@ -2,8 +2,10 @@ package com.todoroo.astrid.adapter
 
 import com.todoroo.astrid.dao.TaskDao
 import org.tasks.data.CaldavDao
+import org.tasks.data.GoogleTaskDao
+import org.tasks.data.TaskContainer
 
-class CaldavManualSortTaskAdapter internal constructor(private val taskDao: TaskDao, private val caldavDao: CaldavDao) : CaldavTaskAdapter(taskDao, caldavDao) {
+class CaldavManualSortTaskAdapter internal constructor(googleTaskDao: GoogleTaskDao, private val caldavDao: CaldavDao, private val taskDao: TaskDao) : TaskAdapter(false, googleTaskDao, caldavDao, taskDao) {
     override fun supportsManualSorting() = true
 
     override fun moved(from: Int, to: Int, indent: Int) {
@@ -29,4 +31,26 @@ class CaldavManualSortTaskAdapter internal constructor(private val taskDao: Task
 
         taskDao.touch(task.id)
     }
+
+    private fun changeParent(task: TaskContainer, indent: Int, to: Int): Long {
+        val newParent = findParent(indent, to)?.id ?: 0
+        if (task.parent != newParent) {
+            changeParent(task, newParent)
+        }
+        return newParent
+    }
+
+    private fun changeParent(task: TaskContainer, newParent: Long) {
+        val caldavTask = task.getCaldavTask()
+        if (newParent == 0L) {
+            caldavTask.cd_remote_parent = ""
+            task.parent = 0
+        } else {
+            val parentTask = caldavDao.getTask(newParent) ?: return
+            caldavTask.cd_remote_parent = parentTask.remoteId
+            task.parent = newParent
+        }
+        caldavDao.update(caldavTask.cd_id, caldavTask.cd_remote_parent)
+        taskDao.save(task.getTask(), null)
+    }
 }

app/src/main/java/com/todoroo/astrid/adapter/CaldavTaskAdapter.kt

@@ -1,49 +0,0 @@
-package com.todoroo.astrid.adapter
-
-import com.todoroo.astrid.dao.TaskDao
-import org.tasks.data.CaldavDao
-import org.tasks.data.TaskContainer
-import org.tasks.date.DateTimeUtils.toAppleEpoch
-
-open class CaldavTaskAdapter internal constructor(private val taskDao: TaskDao, private val caldavDao: CaldavDao, private val newTasksOnTop: Boolean = false) : TaskAdapter() {
-    override fun supportsParentingOrManualSort() = true
-
-    override fun moved(from: Int, to: Int, indent: Int) {
-        val task = getTask(from)
-        val newParent = changeParent(task, indent, to)
-        if (newParent != task.parent) {
-            val newPosition = if (newTasksOnTop) {
-                caldavDao.findFirstTask(task.caldav!!, newParent)
-                        ?.takeIf { task.creationDate.toAppleEpoch() >= it}
-                        ?.minus(1)
-            } else {
-                caldavDao.findLastTask(task.caldav!!, newParent)
-                        ?.takeIf { task.creationDate.toAppleEpoch() <= it }
-                        ?.plus(1)
-            }
-            caldavDao.update(task.caldavTask.cd_id, newPosition)
-        }
-    }
-
-    internal fun changeParent(task: TaskContainer, indent: Int, to: Int): Long {
-        val newParent = findParent(indent, to)?.id ?: 0
-        if (task.parent != newParent) {
-            changeParent(task, newParent)
-        }
-        return newParent
-    }
-
-    private fun changeParent(task: TaskContainer, newParent: Long) {
-        val caldavTask = task.getCaldavTask()
-        if (newParent == 0L) {
-            caldavTask.cd_remote_parent = ""
-            task.parent = 0
-        } else {
-            val parentTask = caldavDao.getTask(newParent) ?: return
-            caldavTask.cd_remote_parent = parentTask.remoteId
-            task.parent = newParent
-        }
-        caldavDao.update(caldavTask.cd_id, caldavTask.cd_remote_parent)
-        taskDao.save(task.getTask(), null)
-    }
-}

app/src/main/java/com/todoroo/astrid/adapter/GoogleTaskAdapter.kt

@@ -1,27 +0,0 @@
-package com.todoroo.astrid.adapter
-
-import com.todoroo.astrid.dao.TaskDao
-import org.tasks.BuildConfig
-import org.tasks.data.GoogleTaskDao
-
-open class GoogleTaskAdapter internal constructor(private val taskDao: TaskDao, private val googleTaskDao: GoogleTaskDao, private val newTasksOnTop: Boolean) : TaskAdapter() {
-
-    override fun supportsParentingOrManualSort() = true
-
-    override fun moved(from: Int, to: Int, indent: Int) {
-        val task = getTask(from)
-        val googleTask = task.googleTask
-        val newParent = findParent(indent, to)?.id ?: 0
-        if (googleTask.parent == newParent) {
-            return
-        }
-        googleTaskDao.move(
-                googleTask,
-                newParent,
-                if (newTasksOnTop) 0 else googleTaskDao.getBottom(googleTask.listId, newParent))
-        taskDao.touch(task.id)
-        if (BuildConfig.DEBUG) {
-            googleTaskDao.validateSorting(task.googleTaskList!!)
-        }
-    }
-}

app/src/main/java/com/todoroo/astrid/adapter/GoogleTaskManualSortAdapter.kt

@@ -2,11 +2,10 @@ package com.todoroo.astrid.adapter
 
 import com.todoroo.astrid.dao.TaskDao
 import org.tasks.BuildConfig
+import org.tasks.data.CaldavDao
 import org.tasks.data.GoogleTaskDao
 
-class GoogleTaskManualSortAdapter internal constructor(val taskDao: TaskDao, val googleTaskDao: GoogleTaskDao) : TaskAdapter() {
+class GoogleTaskManualSortAdapter internal constructor(private val googleTaskDao: GoogleTaskDao, caldavDao: CaldavDao, private val taskDao: TaskDao) : TaskAdapter(false, googleTaskDao, caldavDao, taskDao) {
-
-    override fun supportsParentingOrManualSort() = true
 
     override fun supportsManualSorting() = true
 

app/src/main/java/com/todoroo/astrid/adapter/TaskAdapter.kt

@@ -5,12 +5,20 @@
  */
 package com.todoroo.astrid.adapter
 
+import com.todoroo.astrid.dao.TaskDao
 import com.todoroo.astrid.data.Task
-import org.tasks.data.TaskContainer
+import org.tasks.BuildConfig
+import org.tasks.data.*
+import org.tasks.date.DateTimeUtils.toAppleEpoch
 import java.util.*
 import kotlin.collections.HashSet
 
-open class TaskAdapter {
+open class TaskAdapter(
+        private val newTasksOnTop: Boolean,
+        private val googleTaskDao: GoogleTaskDao,
+        private val caldavDao: CaldavDao,
+        private val taskDao: TaskDao) {
+
     private val selected = HashSet<Long>()
     private val collapsed = HashSet<Long>()
     private lateinit var dataSource: TaskAdapterDataSource
@@ -111,11 +119,32 @@ open class TaskAdapter {
         }
     }
 
-    open fun supportsParentingOrManualSort(): Boolean = false
-
     open fun supportsManualSorting(): Boolean = false
 
-    open fun moved(from: Int, to: Int, indent: Int) {}
+    open fun moved(from: Int, to: Int, indent: Int) {
+        val task = getTask(from)
+        val newParent = findParent(indent, to)
+        if (newParent?.id ?: 0 == task.parent) {
+            return
+        } else if (newParent != null) {
+            when {
+                task.isGoogleTask -> if (task.googleTaskList != newParent.googleTaskList) {
+                    googleTaskDao.markDeleted(task.id)
+                    task.googletask = null
+                }
+                task.isCaldavTask -> if (task.caldav != newParent.caldav) {
+                    caldavDao.markDeleted(listOf(task.id))
+                    task.caldavTask = null
+                }
+            }
+        }
+        when {
+            newParent == null -> moveToTopLevel(task)
+            newParent.isGoogleTask -> changeGoogleTaskParent(task, newParent)
+            newParent.isCaldavTask -> changeCaldavParent(task, newParent)
+            else -> changeLocalParent(task, newParent)
+        }
+    }
 
     fun isHeader(position: Int): Boolean = dataSource.isHeader(position)
 
@@ -157,4 +186,74 @@ open class TaskAdapter {
         }
         return null
     }
+
+    private fun moveToTopLevel(task: TaskContainer) = when {
+        task.isGoogleTask -> changeGoogleTaskParent(task, null)
+        task.isCaldavTask -> changeCaldavParent(task, null)
+        else -> changeLocalParent(task, null)
+    }
+
+    private fun changeLocalParent(task: TaskContainer, newParent: TaskContainer?) {
+        val t = task.getTask()
+        t.parent = newParent?.id ?: 0
+        t.parentUuid = newParent?.uuid
+        taskDao.save(t, null)
+    }
+
+    private fun changeGoogleTaskParent(task: TaskContainer, newParent: TaskContainer?) {
+        val list = newParent?.googleTaskList ?: task.googleTaskList!!
+        if (newParent == null || task.googleTaskList == newParent.googleTaskList) {
+            googleTaskDao.move(
+                    task.googleTask,
+                    newParent?.id ?: 0,
+                    if (newTasksOnTop) 0 else googleTaskDao.getBottom(list, newParent?.id ?: 0))
+        } else {
+            val googleTask = GoogleTask(task.id, list)
+            googleTask.parent = newParent.id
+            googleTaskDao.insertAndShift(googleTask, newTasksOnTop)
+            task.googletask = SubsetGoogleTask().apply {
+                gt_id = googleTask.id
+                gt_list_id = googleTask.listId
+                gt_order = googleTask.order
+                gt_parent = googleTask.parent
+            }
+        }
+        taskDao.touch(task.id)
+        if (BuildConfig.DEBUG) {
+            googleTaskDao.validateSorting(list)
+        }
+    }
+
+    private fun changeCaldavParent(task: TaskContainer, newParent: TaskContainer?) {
+        val list = newParent?.caldav ?: task.caldav!!
+        val caldavTask = task.getCaldavTask() ?: SubsetCaldav()
+        val newParentId = newParent?.id ?: 0
+        if (newParentId == 0L) {
+            caldavTask.cd_remote_parent = ""
+        } else {
+            val parentTask = caldavDao.getTask(newParentId) ?: return
+            caldavTask.cd_calendar = list
+            caldavTask.cd_remote_parent = parentTask.remoteId
+        }
+        caldavTask.cd_order = if (newTasksOnTop) {
+            caldavDao.findFirstTask(list, newParentId)
+                    ?.takeIf { task.creationDate.toAppleEpoch() >= it}
+                    ?.minus(1)
+        } else {
+            caldavDao.findLastTask(list, newParentId)
+                    ?.takeIf { task.creationDate.toAppleEpoch() <= it }
+                    ?.plus(1)
+        }
+        if (caldavTask.cd_id == 0L) {
+            val newTask = CaldavTask(task.id, list)
+            newTask.order = caldavTask.cd_order
+            newTask.remoteParent = caldavTask.cd_remote_parent
+            caldavTask.cd_id = caldavDao.insert(newTask)
+            task.caldavTask = caldavTask
+        } else {
+            caldavDao.update(caldavTask)
+        }
+        taskDao.setParent(newParentId, null, listOf(task.id))
+        taskDao.touch(task.id)
+    }
 }

app/src/main/java/com/todoroo/astrid/adapter/TaskAdapterProvider.java

@@ -10,16 +10,12 @@ import com.todoroo.astrid.api.TagFilter;
 import com.todoroo.astrid.core.BuiltInFilterExposer;
 import com.todoroo.astrid.dao.TaskDao;
 import com.todoroo.astrid.data.Task;
-import com.todoroo.astrid.gtasks.GtasksListService;
 import com.todoroo.astrid.subtasks.SubtasksFilterUpdater;
 import com.todoroo.astrid.subtasks.SubtasksHelper;
 import javax.inject.Inject;
-import org.tasks.data.CaldavCalendar;
 import org.tasks.data.CaldavDao;
 import org.tasks.data.GoogleTaskDao;
-import org.tasks.data.GoogleTaskList;
 import org.tasks.data.TagData;
-import org.tasks.data.TagDataDao;
 import org.tasks.data.TaskListMetadata;
 import org.tasks.data.TaskListMetadataDao;
 import org.tasks.injection.ForApplication;
@@ -29,10 +25,8 @@ public class TaskAdapterProvider {
 
   private final Context context;
   private final Preferences preferences;
-  private final TagDataDao tagDataDao;
   private final TaskListMetadataDao taskListMetadataDao;
   private final TaskDao taskDao;
-  private final GtasksListService gtasksListService;
   private final GoogleTaskDao googleTaskDao;
   private final CaldavDao caldavDao;
   private final SubtasksHelper subtasksHelper;
@@ -41,51 +35,33 @@ public class TaskAdapterProvider {
   public TaskAdapterProvider(
       @ForApplication Context context,
       Preferences preferences,
-      TagDataDao tagDataDao,
       TaskListMetadataDao taskListMetadataDao,
       TaskDao taskDao,
-      GtasksListService gtasksListService,
       GoogleTaskDao googleTaskDao,
       CaldavDao caldavDao,
       SubtasksHelper subtasksHelper) {
     this.context = context;
     this.preferences = preferences;
-    this.tagDataDao = tagDataDao;
     this.taskListMetadataDao = taskListMetadataDao;
     this.taskDao = taskDao;
-    this.gtasksListService = gtasksListService;
     this.googleTaskDao = googleTaskDao;
     this.caldavDao = caldavDao;
     this.subtasksHelper = subtasksHelper;
   }
 
   public TaskAdapter createTaskAdapter(Filter filter) {
-    if (filter instanceof TagFilter) {
+    if (preferences.isManualSort()) {
-      TagFilter tagFilter = (TagFilter) filter;
+      if (filter instanceof TagFilter) {
-      TagData tagData = tagDataDao.getByUuid(tagFilter.getUuid());
+        return createManualTagTaskAdapter((TagFilter) filter);
-      if (tagData != null && preferences.isManualSort()) {
+      } else if (filter instanceof GtasksFilter) {
-        return createManualTagTaskAdapter(tagFilter);
+        return new GoogleTaskManualSortAdapter(googleTaskDao, caldavDao, taskDao);
+      } else if (filter instanceof CaldavFilter) {
+        return new CaldavManualSortTaskAdapter(googleTaskDao, caldavDao, taskDao);
+      } else if (subtasksHelper.shouldUseSubtasksFragmentForFilter(filter)) {
+        return createManualFilterTaskAdapter(filter);
       }
-    } else if (filter instanceof GtasksFilter) {
-      GtasksFilter gtasksFilter = (GtasksFilter) filter;
-      GoogleTaskList list = gtasksListService.getList(gtasksFilter.getStoreId());
-      if (list != null) {
-        return preferences.isManualSort()
-            ? new GoogleTaskManualSortAdapter(taskDao, googleTaskDao)
-            : new GoogleTaskAdapter(taskDao, googleTaskDao, preferences.addTasksToTop());
-      }
-    } else if (filter instanceof CaldavFilter) {
-      CaldavFilter caldavFilter = (CaldavFilter) filter;
-      CaldavCalendar calendar = caldavDao.getCalendarByUuid(caldavFilter.getUuid());
-      if (calendar != null) {
-        return preferences.isManualSort()
-            ? new CaldavManualSortTaskAdapter(taskDao, caldavDao)
-            : new CaldavTaskAdapter(taskDao, caldavDao, preferences.addTasksToTop());
-      }
-    } else if (subtasksHelper.shouldUseSubtasksFragmentForFilter(filter)) {
-      return createManualFilterTaskAdapter(filter);
     }
-    return new TaskAdapter();
+    return new TaskAdapter(preferences.addTasksToTop(), googleTaskDao, caldavDao, taskDao);
   }
 
   private TaskAdapter createManualTagTaskAdapter(TagFilter filter) {
@@ -99,7 +75,7 @@ public class TaskAdapterProvider {
     }
     SubtasksFilterUpdater updater = new SubtasksFilterUpdater(taskListMetadataDao, taskDao);
     updater.initialize(list, filter);
-    return new AstridTaskAdapter(list, filter, updater, taskDao);
+    return new AstridTaskAdapter(list, filter, updater, googleTaskDao, caldavDao, taskDao);
   }
 
   private TaskAdapter createManualFilterTaskAdapter(Filter filter) {
@@ -129,6 +105,6 @@ public class TaskAdapterProvider {
     }
     SubtasksFilterUpdater updater = new SubtasksFilterUpdater(taskListMetadataDao, taskDao);
     updater.initialize(list, filter);
-    return new AstridTaskAdapter(list, filter, updater, taskDao);
+    return new AstridTaskAdapter(list, filter, updater, googleTaskDao, caldavDao, taskDao);
   }
 }

app/src/main/java/org/tasks/data/CaldavDao.kt

@@ -79,6 +79,13 @@ abstract class CaldavDao {
     @Update
     abstract fun update(caldavTask: CaldavTask)
 
+    fun update(caldavTask: SubsetCaldav) {
+        update(caldavTask.cd_id, caldavTask.cd_order, caldavTask.cd_remote_parent)
+    }
+
+    @Query("UPDATE caldav_tasks SET cd_order = :position, cd_remote_parent = :parent WHERE cd_id = :id")
+    internal abstract fun update(id: Long, position: Long?, parent: String?)
+
     @Query("UPDATE caldav_tasks SET cd_order = :position WHERE cd_id = :id")
     internal abstract fun update(id: Long, position: Long?)
 

app/src/main/java/org/tasks/data/GoogleTaskDao.kt

@@ -7,7 +7,7 @@ import org.tasks.time.DateTimeUtils.currentTimeMillis
 @Dao
 abstract class GoogleTaskDao {
     @Insert
-    abstract fun insert(task: GoogleTask)
+    abstract fun insert(task: GoogleTask): Long
 
     @Insert
     abstract fun insert(tasks: Iterable<GoogleTask>)
@@ -20,7 +20,7 @@ abstract class GoogleTaskDao {
         } else {
             task.order = getBottom(task.listId!!, task.parent)
         }
-        insert(task)
+        task.id = insert(task)
     }
 
     @Query("UPDATE google_tasks SET gt_order = gt_order + 1 WHERE gt_list_id = :listId AND gt_parent = :parent AND gt_order >= :position")

app/src/main/java/org/tasks/tasklist/DragAndDropRecyclerAdapter.kt

@@ -39,6 +39,7 @@ class DragAndDropRecyclerAdapter(
     private val updates: Queue<Pair<SectionedDataSource, DiffUtil.DiffResult>> = LinkedList()
     private var dragging = false
     private val disableHeaders: Boolean
+    private val itemTouchHelper: ItemTouchHelper
 
     override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
         val viewType = getItemViewType(position)
@@ -63,7 +64,7 @@ class DragAndDropRecyclerAdapter(
         taskList.loadTaskListContent()
     }
 
-    override fun dragAndDropEnabled() = adapter.supportsParentingOrManualSort()
+    override fun dragAndDropEnabled() = taskList.getFilter().supportsSubtasks()
 
     override fun isHeader(position: Int): Boolean = list.isHeader(position)
 
@@ -104,7 +105,10 @@ class DragAndDropRecyclerAdapter(
         recyclerView.layoutManager!!.onRestoreInstanceState(recyclerViewState)
     }
 
-    override fun onDetachedFromRecyclerView(recyclerView: RecyclerView) = disposables.dispose()
+    override fun onDetachedFromRecyclerView(recyclerView: RecyclerView) {
+        itemTouchHelper.attachToRecyclerView(null)
+        disposables.dispose()
+    }
 
     override fun getTaskCount() = list.taskCount
 
@@ -263,7 +267,8 @@ class DragAndDropRecyclerAdapter(
     init {
         val filter = taskList.getFilter()
         disableHeaders = !filter.supportsSorting() || preferences.isManualSort && filter.supportsManualSort()
-        ItemTouchHelper(ItemTouchHelperCallback()).attachToRecyclerView(recyclerView)
+        itemTouchHelper = ItemTouchHelper(ItemTouchHelperCallback())
+        itemTouchHelper.attachToRecyclerView(recyclerView)
         list = SectionedDataSource(tasks, disableHeaders, preferences.sortMode, adapter.getCollapsed().toMutableSet())
         val initial = Pair.create<SectionedDataSource, DiffUtil.DiffResult>(list, null)
         disposables.add(publishSubject