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

@@ -27,11 +27,9 @@ import androidx.core.content.edit
 import com.ichi2.anki.CrashReportService
 import com.ichi2.anki.common.time.TimeManager
 import com.ichi2.anki.common.time.getTimestamp
-import org.acra.ACRA
 import org.json.JSONObject
 import timber.log.Timber
 import java.io.File
-import java.util.UUID
 
 /**
  * Manages the creation, loading, and switching of user profiles.
@@ -229,6 +227,101 @@ class ProfileManager private constructor(
         // TODO: Implement process restart logic (e.g. ProcessPhoenix)
     }
 
+    /**
+     * Permanently deletes a profile, removing its registry entry and associated data
+     * across both internal and external storage.
+     *
+     *
+     * - Internal Storage: Deletes private app data like WebView cookies,
+     *   internal databases, and namespaced SharedPreferences.
+     * - External Storage (/storage/emulated/0/Android/data/.../files): Deletes the
+     *   AnkiDroid collection directory, media, and backups for this profile.
+     */
+    fun deleteProfile(profileId: ProfileId) {
+        /*
+         * The file system data is removed before the registry entry. If deletion fails
+         * or is interrupted, the registry entry remains so the user can retry.
+         */
+        require(profileRegistry.getLastActiveProfileId() != profileId) {
+            "Cannot delete the currently active profile ($profileId). Switch first."
+        }
+
+        val appDataRoot = ContextCompat.getDataDir(appContext)
+
+        if (profileId.isDefault()) {
+            deleteDefaultProfileDataOnly(appDataRoot)
+        } else {
+            val profileDir = resolveProfileDirectory(profileId).file
+            if (profileDir.exists()) {
+                profileDir.deleteRecursively()
+            }
+
+            // Delete namespaced SharedPreferences (e.g., profile_p_alice_preferences.xml)
+            if (appDataRoot != null) {
+                val sharedPrefsDir = File(appDataRoot, "shared_prefs")
+                if (sharedPrefsDir.exists() && sharedPrefsDir.isDirectory) {
+                    val prefix = "profile_${profileId.value}_"
+                    sharedPrefsDir.listFiles()?.forEach { file ->
+                        if (file.name.startsWith(prefix)) {
+                            file.delete()
+                        }
+                    }
+                }
+            }
+        }
+
+        val externalFilesDir = appContext.getExternalFilesDir(null)
+        if (externalFilesDir != null) {
+            val collectionFolderName = if (profileId.isDefault()) "AnkiDroid" else profileId.value
+            val collectionDir = File(externalFilesDir, collectionFolderName)
+
+            if (collectionDir.exists()) {
+                collectionDir.deleteRecursively()
+            }
+        }
+
+        profileRegistry.removeProfile(profileId)
+        Timber.i("Deleted profile: $profileId")
+    }
+
+    /**
+     * Wipes the Default profile's legacy data from the root directories
+     * while protecting the subdirectories belonging to other profiles.
+     */
+    private fun deleteDefaultProfileDataOnly(appDataRoot: File?) {
+        if (appDataRoot == null) 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()
+            }
+        }
+
+        val sharedPrefsDir = File(appDataRoot, "shared_prefs")
+        if (sharedPrefsDir.exists() && sharedPrefsDir.isDirectory) {
+            sharedPrefsDir.listFiles()?.forEach { file ->
+                val fileName = file.name
+                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 +420,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,16 +36,19 @@ 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
 import org.junit.runner.RunWith
 import org.robolectric.annotation.Config
 import java.io.File
+import kotlin.test.assertNotEquals
 
 @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 +203,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 remains
+        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),
+        )
+    }
 }