test(profiles): store inventory and scope guard

.github/nightly-notes/2026-10-27-feat-profiles-slices.md

@@ -0,0 +1,2 @@
+## Fixed
+- Backups now keep hidden music shelves and library sections, per-channel speeds, playlist sort orders and channels left out of Shorts

.github/nightly-notes/2026-10-27-fix-profiles-notifications.md

@@ -0,0 +1,2 @@
+## Fixed
+- Tapping a premiere reminder notification opens the video

.github/nightly-notes/2026-10-27-fix-profiles-work.md

@@ -0,0 +1,2 @@
+## Fixed
+- The break reminder stops once you turn it off

.github/nightly-notes/2026-10-28-feat-profiles-auto-backup.md

@@ -0,0 +1,3 @@
+## Fixed
+- Automatic master backups now include your recap and favourite artists
+- Automatic backups start again after the app is restored onto a phone

.github/nightly-notes/2026-10-28-feat-profiles-show.md

@@ -0,0 +1,2 @@
+## New
+- Profiles: up to five people can each have their own feed, history, subscriptions, settings and recommendations in one app, switched from the avatar on Home or, on TV, from the rail and a Who's watching? screen (#372, #602, #883, #1039)

app/src/androidTest/java/io/github/aedev/flow/data/local/ProfileDatabaseTest.kt

@@ -0,0 +1,77 @@
+package io.github.aedev.flow.data.local
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import io.github.aedev.flow.data.local.entity.DownloadEntity
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+/**
+ * Every profile opens its own file of the same AppDatabase class, so no profile ever needs a schema change or a
+ * migration of its own. The test runner's Application skips FlowApplication, so the active profile is read lazily
+ * from the registry, as in a restore.
+ */
+@RunWith(AndroidJUnit4::class)
+class ProfileDatabaseTest {
+    private val context = InstrumentationRegistry.getInstrumentation().targetContext
+    private val root = File(context.filesDir, "profile_library/profile-database-test")
+    private val path = File(root, "databases/${AppDatabase.DEFAULT_NAME}").apply { parentFile?.mkdirs() }.absolutePath
+
+    @After
+    fun tearDown() {
+        root.deleteRecursively()
+        root.parentFile?.delete()
+    }
+
+    @Test
+    fun withDefaultRunningBothHandlesAreOneDatabase() {
+        assertSame(AppDatabase.device(context), AppDatabase.profile(context))
+    }
+
+    @Test
+    fun anotherProfilesFileOpensAtTheCurrentVersionWithEmptyTables() {
+        val database = AppDatabase.open(context, path)
+        try {
+            val sqlite = database.openHelper.readableDatabase
+            assertEquals(33, sqlite.version)
+            listOf("watch_history", "playlists", "videos", "notes", "downloads", "sync_log").forEach { table ->
+                sqlite.query("SELECT COUNT(*) FROM $table").use { cursor ->
+                    cursor.moveToFirst()
+                    assertEquals(table, 0, cursor.getInt(0))
+                }
+            }
+            assertTrue(File(path).exists())
+        } finally {
+            database.close()
+        }
+    }
+
+    @Test
+    fun anotherProfilesFileKeepsItsRowsWhenOpenedAgain() =
+        runTest {
+            AppDatabase.open(context, path).run {
+                downloadDao().insertDownload(DownloadEntity(videoId = "v1", title = "Kept", uploader = "Uploader"))
+                close()
+            }
+
+            val reopened = AppDatabase.open(context, path)
+            try {
+                assertEquals(
+                    "Kept",
+                    reopened
+                        .downloadDao()
+                        .getDownloadWithItems("v1")
+                        ?.download
+                        ?.title,
+                )
+            } finally {
+                reopened.close()
+            }
+        }
+}

app/src/debug/AndroidManifest.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application>
+        <!-- DUMP is held by adb's shell and the system only, so nothing installed on the device can send to it. -->
+        <receiver
+            android:name="io.github.aedev.flow.data.profile.ProfileProbeReceiver"
+            android:exported="true"
+            android:permission="android.permission.DUMP" />
+    </application>
+</manifest>

app/src/debug/java/io/github/aedev/flow/data/profile/ProfileProbeReceiver.kt

@@ -0,0 +1,137 @@
+package io.github.aedev.flow.data.profile
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
+import io.github.aedev.flow.data.local.ChannelSubscription
+import io.github.aedev.flow.data.local.LikedVideoInfo
+import io.github.aedev.flow.data.local.LikedVideosRepository
+import io.github.aedev.flow.data.local.PlayerPreferences
+import io.github.aedev.flow.data.local.PlaylistRepository
+import io.github.aedev.flow.data.local.SearchHistoryRepository
+import io.github.aedev.flow.data.local.SubscriptionRepository
+import io.github.aedev.flow.data.local.ViewHistory
+import io.github.aedev.flow.data.model.Video
+import io.github.aedev.flow.data.notes.NoteKind
+import io.github.aedev.flow.data.notes.NotesRepository
+import io.github.aedev.flow.data.recommendation.FlowNeuroEngine
+import io.github.aedev.flow.data.recommendation.InteractionType
+import io.github.aedev.flow.notification.UpcomingReminder
+import io.github.aedev.flow.notification.UpcomingVideoReminderWorker
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+
+/**
+ * Debug builds only: the hook `scripts/profiles/leak_matrix.sh` drives over adb. It writes a marker into every
+ * profile-bound store of the running profile, creates profiles and switches between them; the script then looks for
+ * each marker in files that belong to any other profile.
+ *
+ * `--es op mark --es tag zzleakA` · `--es op create --es name A [--ez copySettings true]` · `--es op switch --es id <id>`
+ */
+@EntryPoint
+@InstallIn(SingletonComponent::class)
+internal interface ProfileProbeEntryPoint {
+    fun profiles(): ProfileRepository
+
+    fun switcher(): ProfileSwitcher
+
+    fun searches(): SearchHistoryRepository
+
+    fun subscriptions(): SubscriptionRepository
+
+    fun playlists(): PlaylistRepository
+
+    fun history(): ViewHistory
+
+    fun likes(): LikedVideosRepository
+
+    fun notes(): NotesRepository
+
+    fun preferences(): PlayerPreferences
+
+    fun engine(): FlowNeuroEngine
+}
+
+class ProfileProbeReceiver : BroadcastReceiver() {
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
+        val app = EntryPointAccessors.fromApplication(context, ProfileProbeEntryPoint::class.java)
+        val pending = goAsync()
+        scope.launch {
+            val result = runCatching { app.handle(context, intent) }.getOrElse { "error ${it.javaClass.simpleName}: ${it.message}" }
+            Log.i(TAG, "${intent.getStringExtra("op")} in ${app.profiles().running().id}: $result")
+            pending.finish()
+        }
+    }
+
+    private suspend fun ProfileProbeEntryPoint.handle(
+        context: Context,
+        intent: Intent,
+    ): String =
+        when (intent.getStringExtra("op")) {
+            "mark" -> {
+                mark(context, requireNotNull(intent.getStringExtra("tag")))
+            }
+
+            "create" -> {
+                val copy = if (intent.getBooleanExtra("copySettings", false)) setOf(SlicePart.SETTINGS) else emptySet()
+                when (val created = profiles().create(requireNotNull(intent.getStringExtra("name")), copy = copy)) {
+                    is CreateResult.Created -> "created ${created.profile.id}"
+                    else -> created.toString()
+                }
+            }
+
+            "switch" -> {
+                val id = requireNotNull(intent.getStringExtra("id"))
+                withContext(Dispatchers.Main) { switcher().switchTo(id) }.toString()
+            }
+
+            else -> {
+                "unknown op"
+            }
+        }
+
+    /** [tag] in every profile-bound store; the subtitle language gets `zzset…` so a settings-only copy can be told apart. */
+    private suspend fun ProfileProbeEntryPoint.mark(
+        context: Context,
+        tag: String,
+    ): String {
+        val videoId = "${tag}vid"
+        val title = "$tag video"
+        val channel = "$tag channel"
+        searches().saveSearchQuery(tag)
+        subscriptions().subscribe(ChannelSubscription(channelId = "UC$tag", channelName = channel, channelThumbnail = ""))
+        playlists().createPlaylist(UUID.randomUUID().toString(), "$tag playlist", "", isPrivate = true)
+        history().savePlaybackPosition(videoId, position = 30_000, duration = 60_000, title = title, channelName = channel)
+        likes().likeVideo(LikedVideoInfo(videoId = videoId, title = title, thumbnail = "", channelName = channel))
+        notes().save(NoteKind.Video, videoId, "$tag note")
+        engine().onVideoInteraction(
+            Video(videoId, title, channel, "UC$tag", "", duration = 600, viewCount = 1_000, uploadDate = ""),
+            InteractionType.WATCHED,
+            percentWatched = 0.9f,
+        )
+        preferences().setPreferredSubtitleLanguage(tag.replace("zzleak", "zzset"))
+        val releaseMs = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(7)
+        preferences().setUpcomingVideoReminder(videoId, true)
+        preferences().saveUpcomingReminder(UpcomingReminder(videoId, releaseMs, title, channel, null))
+        UpcomingVideoReminderWorker.scheduleReminder(context, videoId, releaseMs, title, channel, null)
+        return "marked $tag"
+    }
+
+    private companion object {
+        const val TAG = "ProfileProbe"
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    }
+}

app/src/foss/java/io/github/aedev/flow/discord/DiscordPresenceRuntime.kt

@@ -7,25 +7,39 @@ import kotlinx.coroutines.flow.StateFlow
 import okhttp3.OkHttpClient
 
 object DiscordPresenceRuntime {
-    private val unavailableState = DiscordSettingsState(
-        isAvailable = false,
-        isEnabled = false,
-        canEnable = false,
-        connectionState = DiscordConnectionState.UNAVAILABLE,
-        summary = DiscordSettingsSummary.UNAVAILABLE,
-        accountName = null,
-        errorMessage = null,
-    )
+    private val unavailableState =
+        DiscordSettingsState(
+            isAvailable = false,
+            isEnabled = false,
+            canEnable = false,
+            connectionState = DiscordConnectionState.UNAVAILABLE,
+            summary = DiscordSettingsSummary.UNAVAILABLE,
+            accountName = null,
+            errorMessage = null,
+        )
     private val mutableSettingsState = MutableStateFlow(unavailableState)
     val settingsState: StateFlow<DiscordSettingsState> = mutableSettingsState
 
-    fun initialize(context: Context, okHttpClient: OkHttpClient) = Unit
+    fun initialize(
+        context: Context,
+        okHttpClient: OkHttpClient,
+    ) = Unit
+
     fun attachActivity(activity: Activity?) = Unit
+
     fun detachActivity(activity: Activity) = Unit
+
     fun setAppForeground(foreground: Boolean) = Unit
+
     suspend fun setEnabled(enabled: Boolean) = Unit
+
     suspend fun connectAccount(): DiscordLinkResult = DiscordLinkResult.Failure("")
+
     suspend fun retry(): DiscordLinkResult = DiscordLinkResult.Failure("")
+
     suspend fun unlink(): Boolean = false
+
+    suspend fun endForSwitch() = Unit
+
     fun shutdown() = Unit
 }

app/src/github/java/io/github/aedev/flow/discord/DiscordPreferences.kt

@@ -7,25 +7,29 @@ import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
 import io.github.aedev.flow.data.local.safePreferencesDataStore
+import io.github.aedev.flow.data.profile.StoreScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
 private val Context.discordDataStore: DataStore<Preferences> by safePreferencesDataStore(
     name = "discord_presence",
+    scope = StoreScope.PROFILE_PRIVATE,
 )
 
 class DiscordPreferences(
     private val dataStore: DataStore<Preferences>,
 ) {
     constructor(context: Context) : this(context.applicationContext.discordDataStore)
 
-    val enabled: Flow<Boolean> = dataStore.data.map { preferences ->
-        preferences[ENABLED] ?: false
-    }
+    val enabled: Flow<Boolean> =
+        dataStore.data.map { preferences ->
+            preferences[ENABLED] ?: false
+        }
 
-    val linkedAccountLabel: Flow<String?> = dataStore.data.map { preferences ->
-        preferences[LINKED_ACCOUNT_LABEL]?.takeIf(String::isNotBlank)
-    }
+    val linkedAccountLabel: Flow<String?> =
+        dataStore.data.map { preferences ->
+            preferences[LINKED_ACCOUNT_LABEL]?.takeIf(String::isNotBlank)
+        }
 
     suspend fun setEnabled(enabled: Boolean) {
         dataStore.edit { preferences -> preferences[ENABLED] = enabled }