#1655 fix: do not crash when restoring key map groups

Author: sds100

CHANGELOG.md

@@ -15,6 +15,7 @@
 
 - Inputting key events with Shizuku does not crash the app if a Key Mapper keyboard is being used at the same time. And latency when inputting key events has been improved in some apps.
 - #1646 disabling Bluetooth clears the list of connected devices
+- #1655 do not crash when restoring key map groups
 
 ## [3.0.0](https://github.com/sds100/KeyMapper/releases/tag/v3.0.0)
 

app/src/main/java/io/github/sds100/keymapper/backup/BackupManager.kt

@@ -70,6 +70,7 @@ import kotlinx.coroutines.withContext
 import timber.log.Timber
 import java.io.IOException
 import java.io.InputStream
+import java.util.LinkedList
 import java.util.UUID
 
 /**
@@ -410,7 +411,12 @@ class BackupManagerImpl(
             val soundFiles = soundDir.listFiles() ?: emptyList() // null if dir doesn't exist
 
             return@then parseBackupContent(inputStream).then { backupContent ->
-                restore(restoreType, backupContent, soundFiles)
+                restore(
+                    restoreType,
+                    backupContent,
+                    soundFiles,
+                    currentTime = System.currentTimeMillis(),
+                )
             }
         }
     }
@@ -441,25 +447,45 @@ class BackupManagerImpl(
         }
     }
 
-    private suspend fun restore(
+    suspend fun restore(
         restoreType: RestoreType,
         backupContent: BackupContent,
         soundFiles: List<IFile>,
+        currentTime: Long,
     ): Result<*> {
         try {
             // MUST come before restoring key maps so it is possible to
             // validate that each key map's group exists in the repository.
             if (backupContent.groups != null) {
-                val groupUids = backupContent.groups.map { it.uid }.toMutableSet()
-
                 val existingGroupUids = groupRepository.getAllGroups().first()
                     .map { it.uid }
                     .toSet()
-                    .also { groupUids.addAll(it) }
 
-                val currentTime = System.currentTimeMillis()
+                val groupUids = backupContent.groups.map { it.uid }.toMutableSet()
+
+                groupUids.addAll(existingGroupUids)
+
+                // Group parents must be restored first so an SqliteConstraintException
+                // is not thrown when restoring a child group.
+                val groupsToRestoreMap = backupContent.groups.associateBy { it.uid }.toMutableMap()
+                val groupRestoreQueue = LinkedList<GroupEntity>()
 
+                // Order the groups into a queue such that a parent is always before a child.
                 for (group in backupContent.groups) {
+                    if (groupsToRestoreMap.containsKey(group.uid)) {
+                        groupRestoreQueue.addFirst(group)
+                    }
+
+                    var parent = groupsToRestoreMap[group.parentUid]
+
+                    while (parent != null) {
+                        groupRestoreQueue.addFirst(parent)
+                        groupsToRestoreMap.remove(parent.uid)
+                        parent = groupsToRestoreMap[parent.parentUid]
+                    }
+                }
+
+                for (group in groupRestoreQueue) {
                     // Set the last opened date to now so that the imported group
                     // shows as the most recent.
                     var modifiedGroup = group.copy(lastOpenedDate = currentTime)

app/src/test/java/io/github/sds100/keymapper/BackupManagerTest.kt

@@ -5,6 +5,7 @@ import com.google.gson.Gson
 import com.google.gson.JsonParser
 import io.github.sds100.keymapper.actions.sound.SoundFileInfo
 import io.github.sds100.keymapper.actions.sound.SoundsManager
+import io.github.sds100.keymapper.backup.BackupContent
 import io.github.sds100.keymapper.backup.BackupManagerImpl
 import io.github.sds100.keymapper.backup.RestoreType
 import io.github.sds100.keymapper.data.db.AppDatabase
@@ -46,10 +47,12 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TemporaryFolder
 import org.junit.runner.RunWith
+import org.mockito.ArgumentMatchers
 import org.mockito.junit.MockitoJUnitRunner
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyVararg
 import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.inOrder
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.times
@@ -79,6 +82,7 @@ class BackupManagerTest {
     private lateinit var fakeFileAdapter: FakeFileAdapter
     private lateinit var fakePreferenceRepository: PreferenceRepository
     private lateinit var mockKeyMapRepository: KeyMapRepository
+    private lateinit var mockGroupRepository: GroupRepository
     private lateinit var mockSoundsManager: SoundsManager
     private lateinit var mockUuidGenerator: UuidGenerator
 
@@ -94,6 +98,10 @@ class BackupManagerTest {
         fakePreferenceRepository = FakePreferenceRepository()
 
         mockKeyMapRepository = mock()
+        mockGroupRepository = mock<GroupRepository> {
+            on { getAllGroups() } doReturn MutableStateFlow(emptyList())
+            on { getGroupsByParent(ArgumentMatchers.any()) }.thenReturn(MutableStateFlow(emptyList()))
+        }
 
         fakeFileAdapter = FakeFileAdapter(temporaryFolder)
 
@@ -116,9 +124,7 @@ class BackupManagerTest {
             floatingLayoutRepository = mock<FloatingLayoutRepository> {
                 on { layouts } doReturn MutableStateFlow(State.Data(emptyList()))
             },
-            groupRepository = mock<GroupRepository> {
-                on { getAllGroups() } doReturn MutableStateFlow(emptyList())
-            },
+            groupRepository = mockGroupRepository,
         )
 
         parser = JsonParser()
@@ -130,6 +136,62 @@ class BackupManagerTest {
         Dispatchers.resetMain()
     }
 
+    /**
+     * Issue #1655. If the list of groups in the backup has a child before the parent then the
+     * parent must be restored first. Otherwise the SqliteConstraintException will be thrown.
+     */
+    @Test
+    fun `restore groups breadth first so parents exist before children are restored`() = runTest(testDispatcher) {
+        val parentGroup1 = GroupEntity(
+            uid = "parent_group_1_uid",
+            name = "parent_group_1_name",
+            parentUid = null,
+            lastOpenedDate = 0L,
+        )
+
+        val parentGroup2 = GroupEntity(
+            uid = "parent_group_2_uid",
+            name = "parent_group_2_name",
+            parentUid = null,
+            lastOpenedDate = 0L,
+        )
+
+        val childGroup = GroupEntity(
+            uid = "child_group_uid",
+            name = "child_group_name",
+            parentUid = parentGroup1.uid,
+            lastOpenedDate = 0L,
+        )
+
+        val grandChildGroup = GroupEntity(
+            uid = "grand_child_group_uid",
+            name = "grand_child_group_name",
+            parentUid = childGroup.uid,
+            lastOpenedDate = 0L,
+        )
+
+        val backupContent = BackupContent(
+            appVersion = Constants.VERSION_CODE,
+            dbVersion = AppDatabase.DATABASE_VERSION,
+            groups = listOf(parentGroup2, grandChildGroup, childGroup, parentGroup1),
+        )
+
+        inOrder(mockGroupRepository) {
+            backupManager.restore(
+                RestoreType.REPLACE,
+                backupContent,
+                emptyList(),
+                currentTime = 0L,
+            )
+
+            verify(mockGroupRepository).insert(parentGroup1)
+            verify(mockGroupRepository).insert(childGroup)
+            verify(mockGroupRepository).insert(grandChildGroup)
+            verify(mockGroupRepository).insert(parentGroup2)
+            verify(mockGroupRepository, never()).update(any())
+        }
+    }
+
     @Test
     fun `when backing up everything include layouts that are not in the list of key maps`() = runTest(testDispatcher) {
         val layoutWithButtons = FloatingLayoutEntityWithButtons(