feat: allow profile deletion

Introduce deleteProfile() for removing a single user profile.
Deletion removes both the registry entry (SharedPreferences) and
the on-disk data directory. The only guard is: the currently active
profile cannot be deleted, all other profiles including default
are deletable.

Author: criticalAY

AnkiDroid/src/main/java/com/ichi2/anki/multiprofile/ProfileManager.kt

@@ -229,6 +229,83 @@ class ProfileManager private constructor(
         // TODO: Implement process restart logic (e.g. ProcessPhoenix)
     }
 
+    /**
+     * Permanently deletes a profile, removing its on-disk data and registry entry.
+     *
+     * @param profileId The [ProfileId] of the profile to delete.
+     * @throws IllegalArgumentException if [profileId] is the currently active profile.
+     */
+    fun deleteProfile(profileId: ProfileId) {
+        require(profileRegistry.getLastActiveProfileId() != profileId) {
+            "Cannot delete the currently active profile ($profileId). Switch first."
+        }
+        /*
+         * SCOPE OF DELETION:
+         * - Secondary Profiles: Deletes the profile-specific directory (e.g., .../files/[profileId]).
+         * This includes the collection database, media, and profile-specific SharedPreferences.
+         * - Default Profile: Deletes the standard app directories (files, databases, shared_prefs)
+         * while explicitly preserving directories belonging to other profiles.
+         *
+         * BACKUPS & PRIVACY:
+         * On Google Play builds, backups are stored within the app's internal scoped storage
+         * (.../files/AnkiDroid/backups). Deletion WILL remove any backups nested within
+         * the profile's file tree. This is irreversible.
+         *
+         * SAFETY & ORDERING:
+         * The on-disk directory is removed BEFORE the registry entry. If the process is
+         * interrupted, the registry entry remains so the user can retry. The active profile
+         * cannot be deleted.
+         */
+
+        if (profileId.isDefault()) {
+            deleteDefaultProfileDataOnly()
+        } else {
+            val profileDir = resolveProfileDirectory(profileId).file
+            if (profileDir.exists()) {
+                profileDir.deleteRecursively()
+            }
+        }
+
+        profileRegistry.removeProfile(profileId)
+    }
+
+    private fun deleteDefaultProfileDataOnly() {
+        val appDataRoot = ContextCompat.getDataDir(appContext) ?: return
+
+        val defaultFolders =
+            listOf(
+                "app_webview",
+                "databases",
+                "files",
+                "cache",
+                "code_cache",
+                "no_backup",
+            )
+
+        defaultFolders.forEach { folderName ->
+            val folder = File(appDataRoot, folderName)
+            if (folder.exists()) {
+                folder.deleteRecursively()
+            }
+        }
+
+        // We can't delete the 'shared_prefs' folder because it contains the Registry.
+        // We must only delete the XML files belonging to the Default profile.
+        val sharedPrefsDir = File(appDataRoot, "shared_prefs")
+        if (sharedPrefsDir.exists() && sharedPrefsDir.isDirectory) {
+            sharedPrefsDir.listFiles()?.forEach { file ->
+                val fileName = file.name
+                // Skip the Registry and skip any file prefixed with "profile_"
+                val isRegistry = fileName == "$PROFILE_REGISTRY_FILENAME.xml"
+                val isOtherProfile = fileName.startsWith("profile_")
+
+                if (!isRegistry && !isOtherProfile) {
+                    file.delete()
+                }
+            }
+        }
+    }
+
     /**
      * Holds the meta-data for a profile.
      * Converted to JSON for storage to allow future extensibility (e.g. avatars, themes).
@@ -327,6 +404,18 @@ class ProfileManager private constructor(
             return result
         }
 
+        /**
+         * Removes a profile entry from the registry.
+         *
+         * Does **not** delete the profile's data directory on disk.
+         * Callers are responsible for cleaning up file-system resources.
+         *
+         * @param id The [ProfileId] of the profile to remove.
+         */
+        fun removeProfile(id: ProfileId) {
+            globalPrefs.edit { remove(id.value) }
+        }
+
         fun contains(id: ProfileId): Boolean = globalPrefs.contains(id.value)
     }
 

AnkiDroid/src/test/java/com/ichi2/anki/multiprofile/ProfileManagerTest.kt

@@ -36,6 +36,7 @@ import io.mockk.unmockkAll
 import io.mockk.verify
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
@@ -46,6 +47,7 @@ import java.io.File
 @RunWith(AndroidJUnit4::class)
 class ProfileManagerTest {
     private lateinit var context: Context
+    private val appDataRoot: File by lazy { context.filesDir.parentFile!! }
 
     private val prefs: SharedPreferences
         get() = context.getSharedPreferences(PROFILE_REGISTRY_FILENAME, Context.MODE_PRIVATE)
@@ -200,4 +202,104 @@ class ProfileManagerTest {
         assertEquals(1, allProfiles.size)
         assertTrue(allProfiles.containsKey(ProfileId.DEFAULT))
     }
+
+    @Test
+    fun `deleteProfile removes profile from registry`() {
+        val manager = ProfileManager.create(context)
+        val profileId = manager.createNewProfile("Temporary")
+
+        manager.deleteProfile(profileId)
+
+        val allProfiles = manager.getAllProfiles()
+        assertFalse(allProfiles.containsKey(profileId))
+    }
+
+    @Test
+    fun `deleteProfile does not remove other profiles`() {
+        val manager = ProfileManager.create(context)
+        val keep = manager.createNewProfile("Keep")
+        val remove = manager.createNewProfile("Remove")
+
+        manager.deleteProfile(remove)
+
+        val allProfiles = manager.getAllProfiles()
+        assertEquals(2, allProfiles.size)
+        assertTrue(allProfiles.containsKey(ProfileId.DEFAULT))
+        assertTrue(allProfiles.containsKey(keep))
+    }
+
+    @Test
+    fun `deleteProfile allows deleting default when not active`() {
+        val manager = ProfileManager.create(context)
+        val other = manager.createNewProfile("Other")
+
+        prefs.edit(commit = true) {
+            putString(KEY_LAST_ACTIVE_PROFILE_ID, other.value)
+        }
+
+        val freshManager = ProfileManager.create(context)
+        freshManager.deleteProfile(ProfileId.DEFAULT)
+
+        assertFalse(freshManager.getAllProfiles().containsKey(ProfileId.DEFAULT))
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `deleteProfile throws when deleting active profile`() {
+        val manager = ProfileManager.create(context)
+        val profileId = manager.createNewProfile("Active")
+
+        prefs.edit(commit = true) {
+            putString(KEY_LAST_ACTIVE_PROFILE_ID, profileId.value)
+        }
+
+        val freshManager = ProfileManager.create(context)
+        freshManager.deleteProfile(profileId)
+    }
+
+    @Test
+    fun `deleteProfile for Default profile wipes legacy root folders but preserves Alice and Bob`() {
+        val manager = ProfileManager.create(context)
+
+        val aliceId = manager.createNewProfile("Alice")
+        val aliceDir = File(appDataRoot, aliceId.value).apply { mkdirs() }
+        val alicePref =
+            File(appDataRoot, "shared_prefs/profile_${aliceId.value}.xml").apply {
+                parentFile?.mkdirs()
+                createNewFile()
+            }
+
+        val defaultFile =
+            File(context.filesDir, "legacy_default.txt").apply {
+                parentFile?.mkdirs()
+                writeText("Old data")
+            }
+        val defaultWebview = File(appDataRoot, "app_webview").apply { mkdirs() }
+        val defaultPref =
+            File(appDataRoot, "shared_prefs/com.ichi2.anki_preferences.xml").apply {
+                createNewFile()
+            }
+
+        manager.switchActiveProfile(aliceId)
+        val managerWithAlice = ProfileManager.create(context)
+
+        managerWithAlice.deleteProfile(ProfileId.DEFAULT)
+
+        //  Default data should be gone
+        assertFalse("Default's filesDir content should be gone", defaultFile.exists())
+        assertFalse("Default's webview folder should be gone", defaultWebview.exists())
+        assertFalse("Default's specific SharedPreferences should be gone", defaultPref.exists())
+
+        // Alice and Global Registry MUST remain
+        assertTrue("Alice's directory must not be touched", aliceDir.exists())
+        assertTrue("Alice's SharedPreferences must not be touched", alicePref.exists())
+        assertTrue(
+            "The Profile Registry file itself must not be deleted",
+            File(appDataRoot, "shared_prefs/$PROFILE_REGISTRY_FILENAME.xml").exists(),
+        )
+
+        assertFalse(
+            "Registry should no longer contain Default",
+            managerWithAlice.getAllProfiles().containsKey(ProfileId.DEFAULT),
+        )
+    }
 }