Feature: educational videos

app/build.gradle.kts

@@ -42,6 +42,7 @@ dependencies {
     implementation(project(":core:coroutines"))
     implementation(project(":core:navigation"))
     implementation(project(":modules:account"))
+    implementation(project(":modules:education"))
     implementation(project(":modules:onboarding"))
 
     implementation(libs.androidx.core.ktx)

app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/AppNavigationTest.kt

@@ -51,10 +51,10 @@ class AppNavigationTest {
     }
 
     @Test
-    fun `test navigation to bluetooth screen`() {
+    fun `test navigation to app screen`() {
         mainActivity {
-            navigateToBluetoothScreen()
-            assertBluetoothScreenIsDisplayed()
+            navigateToAppScreen()
+            assertAppScreenIsDisplayed()
         }
     }
 

app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/AppTest.kt

@@ -0,0 +1,62 @@
+package edu.stanford.bdh.engagehf
+
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import edu.stanford.bdh.engagehf.navigation.screens.AppScreen
+import edu.stanford.bdh.engagehf.simulator.AppSimulator
+import edu.stanford.spezi.core.design.component.ComposeContentActivity
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+@HiltAndroidTest
+class AppTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule
+    val composeTestRule = createAndroidComposeRule<ComposeContentActivity>()
+
+    @Before
+    fun init() {
+        composeTestRule.activity.setScreen {
+            AppScreen()
+        }
+    }
+
+    @Test
+    fun `test app screen root is displayed`() {
+        appScreen {
+            assertIsDisplayed()
+        }
+    }
+
+    @Test
+    fun `test app screen navigation bar items are displayed`() {
+        BottomBarItem.entries.forEach { item ->
+            appScreen {
+                assertNavigationBarItemIsDisplayed(composeTestRule.activity.getString(item.label))
+            }
+        }
+    }
+
+    @Test
+    fun `test app screen top app bar is displayed`() {
+        appScreen {
+            assertTopAppBarIsDisplayed()
+        }
+    }
+
+    @Test
+    fun `test app screen top app bar title is displayed`() {
+        appScreen {
+            assertTopAppBarTitleIsDisplayed(composeTestRule.activity.getString(BottomBarItem.entries.first().label))
+        }
+    }
+
+    private fun appScreen(block: AppSimulator.() -> Unit) {
+        AppSimulator(composeTestRule).apply(block)
+    }
+}

app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/AppSimulator.kt

@@ -0,0 +1,38 @@
+package edu.stanford.bdh.engagehf.simulator
+
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertTextEquals
+import androidx.compose.ui.test.junit4.ComposeTestRule
+import edu.stanford.bdh.engagehf.navigation.screens.AppScreenTestIdentifier
+import edu.stanford.spezi.core.testing.onNodeWithIdentifier
+
+class AppSimulator(
+    private val composeTestRule: ComposeTestRule,
+) {
+    private val root = composeTestRule.onNodeWithIdentifier(AppScreenTestIdentifier.ROOT)
+
+    private val topAppBar =
+        composeTestRule.onNodeWithIdentifier(AppScreenTestIdentifier.TOP_APP_BAR)
+
+    private val topAppBarTitle =
+        composeTestRule.onNodeWithIdentifier(AppScreenTestIdentifier.TOP_APP_BAR_TITLE)
+
+    fun assertIsDisplayed() {
+        root.assertIsDisplayed()
+    }
+
+    fun assertTopAppBarIsDisplayed() {
+        topAppBar.assertIsDisplayed()
+    }
+
+    fun assertTopAppBarTitleIsDisplayed(text: String) {
+        topAppBarTitle.assertIsDisplayed()
+            .assertTextEquals(text)
+    }
+
+    fun assertNavigationBarItemIsDisplayed(text: String) {
+        composeTestRule
+            .onNodeWithIdentifier(AppScreenTestIdentifier.NAVIGATION_BAR_ITEM, text)
+            .assertIsDisplayed()
+    }
+}

app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/NavigatorSimulator.kt

@@ -2,8 +2,8 @@ package edu.stanford.bdh.engagehf.simulator
 
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.ComposeTestRule
-import edu.stanford.bdh.engagehf.bluetooth.screen.BluetoothScreenTestIdentifier
 import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
+import edu.stanford.bdh.engagehf.navigation.screens.AppScreenTestIdentifier
 import edu.stanford.spezi.core.navigation.Navigator
 import edu.stanford.spezi.core.testing.onAllNodes
 import edu.stanford.spezi.core.testing.onNodeWithIdentifier
@@ -29,17 +29,17 @@ class NavigatorSimulator(
         composeTestRule.onNodeWithIdentifier(InvitationCodeScreenTestIdentifier.ROOT)
     private val sequential =
         composeTestRule.onNodeWithIdentifier(SequentialOnboardingScreenTestIdentifier.ROOT)
-    private val bluetooth = composeTestRule.onNodeWithIdentifier(BluetoothScreenTestIdentifier.ROOT)
+    private val appScreen = composeTestRule.onNodeWithIdentifier(AppScreenTestIdentifier.ROOT)
     private val consent = composeTestRule.onNodeWithIdentifier(ConsentScreenTestIdentifier.ROOT)
 
     fun assertOnboardingIsDisplayed() {
         waitNode(OnboardingScreenTestIdentifier.ROOT)
         onboarding.assertIsDisplayed()
     }
 
-    fun assertBluetoothScreenIsDisplayed() {
-        waitNode(BluetoothScreenTestIdentifier.ROOT)
-        bluetooth.assertIsDisplayed()
+    fun assertAppScreenIsDisplayed() {
+        waitNode(AppScreenTestIdentifier.ROOT)
+        appScreen.assertIsDisplayed()
     }
 
     fun assertLoginScreenIsDisplayed() {
@@ -67,8 +67,8 @@ class NavigatorSimulator(
         consent.assertIsDisplayed()
     }
 
-    fun navigateToBluetoothScreen() {
-        navigator.navigateTo(AppNavigationEvent.BluetoothScreen)
+    fun navigateToAppScreen() {
+        navigator.navigateTo(AppNavigationEvent.AppScreen)
     }
 
     fun navigateToOnboardingScreen() {

app/src/main/kotlin/edu/stanford/bdh/engagehf/MainActivity.kt

@@ -13,13 +13,14 @@
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.toRoute
 import dagger.hilt.android.AndroidEntryPoint
-import edu.stanford.bdh.engagehf.bluetooth.screen.BluetoothScreen
 import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
 import edu.stanford.bdh.engagehf.navigation.RegisterParams
 import edu.stanford.bdh.engagehf.navigation.Routes
+import edu.stanford.bdh.engagehf.navigation.screens.AppScreen
 import edu.stanford.bdh.engagehf.navigation.serializableType
 import edu.stanford.spezi.core.coroutines.di.Dispatching
 import edu.stanford.spezi.core.design.theme.SpeziTheme
+import edu.stanford.spezi.core.navigation.NavigationEvent
 import edu.stanford.spezi.module.account.AccountNavigationEvent
 import edu.stanford.spezi.module.account.login.LoginScreen
 import edu.stanford.spezi.module.account.register.RegisterScreen
@@ -28,6 +29,10 @@
 import edu.stanford.spezi.module.onboarding.invitation.InvitationCodeScreen
 import edu.stanford.spezi.module.onboarding.onboarding.OnboardingScreen
 import edu.stanford.spezi.module.onboarding.sequential.SequentialOnboardingScreen
+import edu.stanford.spezi.modules.education.EducationNavigationEvent
+import edu.stanford.spezi.modules.education.EducationRoutes
+import edu.stanford.spezi.modules.education.video.VideoScreen
+import edu.stanford.spezi.modules.education.videos.Video
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -82,8 +87,16 @@
             LoginScreen(isAlreadyRegistered = args.isAlreadyRegistered)
         }
 
-        composable<Routes.BluetoothScreen> {
-            BluetoothScreen()
+        composable<EducationRoutes.VideoDetail>(
+            typeMap = mapOf(
+                typeOf<Video>() to serializableType<Video>()
+            )
+        ) {
+            VideoScreen()
+        }
+
+        composable<Routes.AppScreen> {
+            AppScreen()
         }
 
         composable<Routes.InvitationCodeScreen> {
@@ -125,7 +138,6 @@
                             )
                         )
 
-                        is AppNavigationEvent.BluetoothScreen -> navHostController.navigate(Routes.BluetoothScreen)
                         is OnboardingNavigationEvent.InvitationCodeScreen -> navHostController.navigate(
                             Routes.InvitationCodeScreen
                         )
@@ -141,6 +153,16 @@
                         is OnboardingNavigationEvent.ConsentScreen -> navHostController.navigate(
                             Routes.ConsentScreen
                         )
+
+                        is AppNavigationEvent.AppScreen -> navHostController.navigate(Routes.AppScreen)
+                        is NavigationEvent.PopBackStack -> navHostController.popBackStack()
+                        is NavigationEvent.NavigateUp -> navHostController.navigateUp()
+
+                        is EducationNavigationEvent.VideoSectionClicked -> navHostController.navigate(
+                            EducationRoutes.VideoDetail(
+                                video = event.video
+                            )
+                        )
                     }
                 }
             }

app/src/main/kotlin/edu/stanford/bdh/engagehf/MainActivityViewModel.kt

@@ -1,16 +1,23 @@
 package edu.stanford.bdh.engagehf
 
+import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
+import edu.stanford.bdh.engagehf.navigation.data.models.AppUiState
 import edu.stanford.spezi.core.logging.speziLogger
 import edu.stanford.spezi.core.navigation.NavigationEvent
 import edu.stanford.spezi.core.navigation.Navigator
 import edu.stanford.spezi.module.account.AccountEvents
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import javax.inject.Inject
+import edu.stanford.spezi.core.design.R as DesignR
 
 @HiltViewModel
 class MainActivityViewModel @Inject constructor(
@@ -19,13 +26,23 @@
 ) : ViewModel() {
     private val logger by speziLogger()
 
+    private val _uiState = MutableStateFlow(
+        AppUiState(
+            items = BottomBarItem.entries,
+            selectedItem = BottomBarItem.HOME
+        )
+    )
+
+    val uiState = _uiState.asStateFlow()
+
     init {
         viewModelScope.launch {
             accountEvents.events.collect { event ->
                 when (event) {
                     is AccountEvents.Event.SignUpSuccess, AccountEvents.Event.SignInSuccess -> {
-                        navigator.navigateTo(AppNavigationEvent.BluetoothScreen)
+                        navigator.navigateTo(AppNavigationEvent.AppScreen)
                     }
+
                     else -> {
                         logger.i { "Ignoring registration event: $event" }
                     }
@@ -34,5 +51,46 @@
         }
     }
 
+    fun onAction(action: Action) {
+        when (action) {
+            is Action.UpdateSelectedBottomBarItem -> {
+                _uiState.update {
+                    it.copy(selectedItem = action.selectedBottomBarItem)
+                }
+            }
+        }
+    }
+
     fun getNavigationEvents(): Flow<NavigationEvent> = navigator.events
 }
+
+sealed interface Action {
+    data class UpdateSelectedBottomBarItem(val selectedBottomBarItem: BottomBarItem) : Action
+}
+
+enum class BottomBarItem(
+    @StringRes val label: Int,
+    @DrawableRes val icon: Int,
+    @DrawableRes val selectedIcon: Int,
+) {
+    HOME(
+        label = R.string.home,
+        icon = DesignR.drawable.ic_home,
+        selectedIcon = DesignR.drawable.ic_home
+    ),
+    HEART_HEALTH(
+        label = R.string.heart_health,
+        icon = DesignR.drawable.ic_vital_signs,
+        selectedIcon = DesignR.drawable.ic_vital_signs
+    ),
+    MEDICATION(
+        label = R.string.medication,
+        icon = DesignR.drawable.ic_medication,
+        selectedIcon = DesignR.drawable.ic_medication
+    ),
+    EDUCATION(
+        label = R.string.education,
+        icon = DesignR.drawable.ic_school,
+        selectedIcon = DesignR.drawable.ic_school
+    ),
+}

app/src/main/kotlin/edu/stanford/bdh/engagehf/education/EducationModule.kt

@@ -0,0 +1,16 @@
+package edu.stanford.bdh.engagehf.education
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import edu.stanford.spezi.modules.education.videos.data.repository.EducationRepository
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class EducationModule {
+    @Binds
+    abstract fun bindEducationRepository(
+        engageEducationRepository: EngageEducationRepository,
+    ): EducationRepository
+}

app/src/main/kotlin/edu/stanford/bdh/engagehf/education/EngageEducationRepository.kt

@@ -0,0 +1,20 @@
+package edu.stanford.bdh.engagehf.education
+
+import com.google.firebase.firestore.FirebaseFirestore
+import edu.stanford.spezi.module.onboarding.invitation.await
+import edu.stanford.spezi.modules.education.videos.VideoSection
+import edu.stanford.spezi.modules.education.videos.data.repository.EducationRepository
+import javax.inject.Inject
+
+class EngageEducationRepository @Inject constructor(
+    private val firebaseFirestore: FirebaseFirestore,
+    private val mapper: VideoSectionDocumentToVideoSectionMapper,
+) : EducationRepository {
+    override suspend fun getVideoSections(): Result<List<VideoSection>> {
+        return runCatching {
+            firebaseFirestore.collection("videoSections").get().await().mapNotNull { document ->
+                mapper.map(document)
+            }.sortedBy { it.orderIndex }
+        }
+    }
+}