From 7c6745a053ebc1bab398844c205d1e140f9a9b99 Mon Sep 17 00:00:00 2001
From: Eldi Cano <eldi.cano@hotmail.com>
Date: Sun, 8 Dec 2024 23:21:42 +0100
Subject: [PATCH 1/3] request notification permissions in home

---
 .../bluetooth/screen/HomeScreenTest.kt        |  75 +++
 .../engagehf/simulator/HomeScreenSimulator.kt |  36 ++
 .../edu/stanford/bdh/engagehf/MainActivity.kt |   6 +-
 .../bdh/engagehf/bluetooth/HomeViewModel.kt   | 367 +++++++++++
 .../data/mapper/BluetoothUiStateMapper.kt     |   1 -
 .../engagehf/bluetooth/data/models/Action.kt  |   2 +-
 .../bluetooth/data/models/BluetoothUiState.kt |   1 -
 .../engagehf/bluetooth/data/models/UiState.kt |   1 +
 .../engagehf/bluetooth/screen/HomeScreen.kt   | 357 +++++++++++
 .../engagehf/navigation/screens/AppScreen.kt  |   4 +-
 .../engagehf/bluetooth/HomeViewModelTest.kt   | 586 ++++++++++++++++++
 .../data/mapper/BluetoothUiStateMapperTest.kt |  19 -
 .../onboarding/EngageConsentManagerTest.kt    |   2 +-
 .../design/component/PermissionRequester.kt   |   8 +-
 .../notification/NotificationPermissions.kt   |  28 +
 .../notification/di/NotificationModule.kt     |  15 +-
 .../setting/NotificationSettingScreen.kt      |  64 +-
 .../setting/NotificationSettingViewModel.kt   |  36 +-
 .../NotificationPermissionsTest.kt            |  59 ++
 .../NotificationSettingViewModelTest.kt       |  70 ++-
 .../stanford/spezi/core/utils/BuildInfo.kt    |  12 +
 .../spezi/core/utils/di/UtilsModule.kt        |   5 +
 .../spezi/core/utils/BuildInfoTest.kt         |  14 +
 23 files changed, 1645 insertions(+), 123 deletions(-)
 create mode 100644 app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt
 create mode 100644 app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/HomeScreenSimulator.kt
 create mode 100644 app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModel.kt
 create mode 100644 app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreen.kt
 create mode 100644 app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModelTest.kt
 create mode 100644 core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/NotificationPermissions.kt
 create mode 100644 core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/NotificationPermissionsTest.kt
 create mode 100644 core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/BuildInfo.kt
 create mode 100644 core/utils/src/test/kotlin/edu/stanford/spezi/core/utils/BuildInfoTest.kt

diff --git a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt
new file mode 100644
index 000000000..678df08c3
--- /dev/null
+++ b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt
@@ -0,0 +1,75 @@
+package edu.stanford.bdh.engagehf.bluetooth.screen
+
+import android.Manifest
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.test.rule.GrantPermissionRule
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import edu.stanford.bdh.engagehf.R
+import edu.stanford.bdh.engagehf.bluetooth.data.models.UiState
+import edu.stanford.bdh.engagehf.simulator.HomeScreenSimulator
+import edu.stanford.spezi.core.design.component.ComposeContentActivity
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+@HiltAndroidTest
+class HomeScreenTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule
+    val composeTestRule = createAndroidComposeRule<ComposeContentActivity>()
+
+    @get:Rule
+    val runtimePermissionRule: GrantPermissionRule = GrantPermissionRule.grant(
+        Manifest.permission.POST_NOTIFICATIONS,
+        Manifest.permission.BLUETOOTH_CONNECT,
+        Manifest.permission.BLUETOOTH_SCAN,
+        Manifest.permission.ACCESS_COARSE_LOCATION,
+        Manifest.permission.ACCESS_FINE_LOCATION,
+    )
+
+    @Before
+    fun init() {
+        composeTestRule.activity.setScreen {
+            HomeScreen()
+        }
+    }
+
+    @Test
+    fun `test home screen root is displayed`() {
+        homeScreen {
+            assertIsDisplayed()
+        }
+    }
+
+    @Test
+    fun `test home screen message title is displayed`() {
+        homeScreen {
+            assertMessageTitle(composeTestRule.activity.getString(R.string.messages))
+        }
+    }
+
+    @Test
+    fun `test home screen vital title is displayed`() {
+        homeScreen {
+            assertVitalTitle(composeTestRule.activity.getString(R.string.vitals))
+        }
+    }
+
+    @Test
+    fun `test home screen vital is displayed`() {
+        homeScreen {
+            val uiState = UiState()
+            assertVital(uiState.weight.title)
+            assertVital(uiState.heartRate.title)
+            assertVital(uiState.bloodPressure.title)
+        }
+    }
+
+    private fun homeScreen(block: HomeScreenSimulator.() -> Unit) {
+        HomeScreenSimulator(composeTestRule).apply(block)
+    }
+}
diff --git a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/HomeScreenSimulator.kt b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/HomeScreenSimulator.kt
new file mode 100644
index 000000000..3412c8ddb
--- /dev/null
+++ b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/HomeScreenSimulator.kt
@@ -0,0 +1,36 @@
+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.bluetooth.screen.HomeScreenTestIdentifier
+import edu.stanford.spezi.core.testing.onNodeWithIdentifier
+
+class HomeScreenSimulator(
+    private val composeTestRule: ComposeTestRule,
+) {
+    private val root = composeTestRule.onNodeWithIdentifier(HomeScreenTestIdentifier.ROOT)
+
+    private val messageTitle =
+        composeTestRule.onNodeWithIdentifier(HomeScreenTestIdentifier.MESSAGE_TITLE)
+
+    private val vitalTitle =
+        composeTestRule.onNodeWithIdentifier(HomeScreenTestIdentifier.VITAL_TITLE)
+
+    fun assertVital(vitalTitle: String) {
+        composeTestRule.onNodeWithIdentifier(HomeScreenTestIdentifier.VITALS, vitalTitle)
+            .assertIsDisplayed()
+    }
+
+    fun assertIsDisplayed() {
+        root.assertIsDisplayed()
+    }
+
+    fun assertMessageTitle(text: String) {
+        messageTitle.assertIsDisplayed().assertTextEquals(text)
+    }
+
+    fun assertVitalTitle(text: String) {
+        vitalTitle.assertIsDisplayed().assertTextEquals(text)
+    }
+}
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/MainActivity.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/MainActivity.kt
index 15ba15ad1..304c37108 100644
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/MainActivity.kt
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/MainActivity.kt
@@ -22,7 +22,7 @@ import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.toRoute
 import dagger.hilt.android.AndroidEntryPoint
-import edu.stanford.bdh.engagehf.bluetooth.BluetoothViewModel
+import edu.stanford.bdh.engagehf.bluetooth.HomeViewModel
 import edu.stanford.bdh.engagehf.bluetooth.data.models.Action
 import edu.stanford.bdh.engagehf.contact.ui.ContactScreen
 import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
@@ -59,7 +59,7 @@ class MainActivity : FragmentActivity() {
 
     private val viewModel by viewModels<MainActivityViewModel>()
 
-    private val bluetoothViewModel by viewModels<BluetoothViewModel>()
+    private val homeViewModel by viewModels<HomeViewModel>()
 
     @Inject
     @Dispatching.Main
@@ -67,7 +67,7 @@ class MainActivity : FragmentActivity() {
 
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
-        bluetoothViewModel.onAction(Action.NewIntent(intent))
+        homeViewModel.onAction(Action.NewIntent(intent))
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModel.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModel.kt
new file mode 100644
index 000000000..15719d2ff
--- /dev/null
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModel.kt
@@ -0,0 +1,367 @@
+package edu.stanford.bdh.engagehf.bluetooth
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.Settings
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import edu.stanford.bdh.engagehf.R
+import edu.stanford.bdh.engagehf.bluetooth.component.AppScreenEvents
+import edu.stanford.bdh.engagehf.bluetooth.data.mapper.BluetoothUiStateMapper
+import edu.stanford.bdh.engagehf.bluetooth.data.models.Action
+import edu.stanford.bdh.engagehf.bluetooth.data.models.UiState
+import edu.stanford.bdh.engagehf.bluetooth.measurements.MeasurementsRepository
+import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEService
+import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEServiceEvent
+import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEServiceState
+import edu.stanford.bdh.engagehf.education.EngageEducationRepository
+import edu.stanford.bdh.engagehf.messages.HealthSummaryService
+import edu.stanford.bdh.engagehf.messages.Message
+import edu.stanford.bdh.engagehf.messages.MessageRepository
+import edu.stanford.bdh.engagehf.messages.MessageType
+import edu.stanford.bdh.engagehf.messages.MessagesAction
+import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
+import edu.stanford.bdh.engagehf.navigation.screens.BottomBarItem
+import edu.stanford.spezi.core.logging.speziLogger
+import edu.stanford.spezi.core.navigation.Navigator
+import edu.stanford.spezi.core.notification.NotificationPermissions
+import edu.stanford.spezi.core.notification.notifier.FirebaseMessage
+import edu.stanford.spezi.core.notification.notifier.FirebaseMessage.Companion.FIREBASE_MESSAGE_KEY
+import edu.stanford.spezi.core.utils.MessageNotifier
+import edu.stanford.spezi.modules.education.EducationNavigationEvent
+import edu.stanford.spezi.modules.education.videos.Video
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@HiltViewModel
+@Suppress("LongParameterList")
+class HomeViewModel @Inject internal constructor(
+    private val bleService: EngageBLEService,
+    private val uiStateMapper: BluetoothUiStateMapper,
+    private val measurementsRepository: MeasurementsRepository,
+    private val messageRepository: MessageRepository,
+    private val appScreenEvents: AppScreenEvents,
+    private val navigator: Navigator,
+    private val engageEducationRepository: EngageEducationRepository,
+    private val healthSummaryService: HealthSummaryService,
+    private val messageNotifier: MessageNotifier,
+    @ApplicationContext private val context: Context,
+    notificationPermissions: NotificationPermissions,
+) : ViewModel() {
+    private val logger by speziLogger()
+
+    private val _uiState = MutableStateFlow(
+        UiState(
+            missingPermissions = notificationPermissions.getRequiredPermissions()
+        )
+    )
+
+    val uiState = _uiState.asStateFlow()
+
+    init {
+        bleService.start()
+        observeBleService()
+        observeRecords()
+        observeMessages()
+    }
+
+    private fun observeBleService() {
+        viewModelScope.launch {
+            bleService.state.collect { state ->
+                logger.i { "Received EngageBLEService state $state" }
+                _uiState.update { currentState ->
+                    val missingPermissions = currentState.missingPermissions.toMutableSet()
+                    if (state is EngageBLEServiceState.MissingPermissions) {
+                        missingPermissions.addAll(state.permissions)
+                    }
+                    currentState.copy(
+                        bluetooth = uiStateMapper.mapBleServiceState(state),
+                        missingPermissions = missingPermissions,
+                    )
+                }
+            }
+        }
+
+        viewModelScope.launch {
+            bleService.events.collect { event ->
+                logger.i { "Received BLEService event $event" }
+                when (event) {
+                    is EngageBLEServiceEvent.MeasurementReceived -> {
+                        appScreenEvents.emit(AppScreenEvents.Event.CloseBottomSheet)
+                        _uiState.update {
+                            val dialog = uiStateMapper.mapMeasurementDialog(event.measurement)
+                            it.copy(measurementDialog = dialog)
+                        }
+                    }
+
+                    is EngageBLEServiceEvent.DeviceDiscovered,
+                    is EngageBLEServiceEvent.DeviceConnected,
+                    is EngageBLEServiceEvent.DevicePaired,
+                    -> {
+                        logger.i { "Ignoring event $event" }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun observeRecords() {
+        viewModelScope.launch {
+            measurementsRepository.observeBloodPressureRecord().collect { result ->
+                _uiState.update { it.copy(bloodPressure = uiStateMapper.mapBloodPressure(result)) }
+            }
+        }
+
+        viewModelScope.launch {
+            measurementsRepository.observeHeartRateRecord().collect { result ->
+                _uiState.update { it.copy(heartRate = uiStateMapper.mapHeartRate(result)) }
+            }
+        }
+
+        viewModelScope.launch {
+            measurementsRepository.observeWeightRecord().collect { result ->
+                _uiState.update { it.copy(weight = uiStateMapper.mapWeight(result)) }
+            }
+        }
+    }
+
+    private fun observeMessages() {
+        viewModelScope.launch {
+            messageRepository.observeUserMessages().collect { messages ->
+                _uiState.update {
+                    it.copy(
+                        messages = messages
+                    )
+                }
+            }
+        }
+    }
+
+    fun onAction(action: Action) {
+        when (action) {
+            is Action.ConfirmMeasurement -> {
+                handleConfirmMeasurementAction(action)
+            }
+
+            is Action.BLEDevicePairing -> {
+                appScreenEvents.emit(AppScreenEvents.Event.BLEDevicePairingBottomSheet)
+            }
+
+            is Action.DismissDialog -> {
+                _uiState.update {
+                    it.copy(measurementDialog = it.measurementDialog.copy(isVisible = false))
+                }
+            }
+
+            is Action.MessageItemClicked -> {
+                onMessageClicked(message = action.message)
+            }
+
+            is Action.ToggleExpand -> {
+                handleToggleExpandAction(action)
+            }
+
+            is Action.Resumed -> {
+                bleService.start()
+            }
+
+            is Action.PermissionResult -> {
+                _uiState.update { state ->
+                    val missingPermission = state.missingPermissions.filterNot { it == action.permission }
+                    state.copy(missingPermissions = missingPermission.toSet())
+                }
+                bleService.start()
+            }
+
+            is Action.Settings.AppSettings -> {
+                val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                    data = Uri.fromParts("package", context.packageName, null)
+                }
+                launch(intent = intent)
+            }
+
+            is Action.Settings.BluetoothSettings -> {
+                launch(intent = Intent(Settings.ACTION_BLUETOOTH_SETTINGS))
+            }
+
+            is Action.NewIntent -> handleNewIntent(action.intent)
+            is Action.VitalsCardClicked -> appScreenEvents.emit(
+                AppScreenEvents.Event.NavigateToTab(
+                    BottomBarItem.HEART_HEALTH
+                )
+            )
+        }
+    }
+
+    private fun onMessageClicked(message: Message) {
+        viewModelScope.launch {
+            uiStateMapper.mapMessagesAction(message.action)
+                .onFailure { error ->
+                    logger.e(error) { "Error while mapping action: ${message.action}" }
+                }
+                .onSuccess { messagesAction ->
+                    messagesAction?.let {
+                        onMessage(
+                            messagesAction = it,
+                            messageId = message.id,
+                            isDismissible = message.isDismissible,
+                        )
+                    }
+                }
+        }
+    }
+
+    private fun handleNewIntent(intent: Intent) {
+        val firebaseMessage =
+            intent.getParcelableExtra<FirebaseMessage>(FIREBASE_MESSAGE_KEY)
+        firebaseMessage?.messageId?.let { messageId ->
+            viewModelScope.launch {
+                onAction(
+                    Action.MessageItemClicked(
+                        message = Message(
+                            id = messageId, // Is needed to dismiss the message
+                            type = MessageType.Unknown, // We don't need the type, since we directly use the action
+                            title = "", // We don't need the title, since we directly use the action
+                            action = firebaseMessage.action, // We directly use the action
+                            isDismissible = firebaseMessage.isDismissible
+                                ?: false
+                        )
+                    )
+                )
+            }
+        }
+    }
+
+    private fun launch(intent: Intent) {
+        runCatching {
+            context.startActivity(intent.apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) })
+        }.onFailure {
+            logger.e(it) { "Failed to launch intent ${intent.action}" }
+        }
+    }
+
+    private suspend fun onMessage(
+        messagesAction: MessagesAction,
+        messageId: String,
+        isDismissible: Boolean,
+    ) {
+        var shouldDismissMessage = isDismissible
+        when (messagesAction) {
+            is MessagesAction.HealthSummaryAction -> {
+                handleHealthSummaryAction(messageId).onFailure {
+                    shouldDismissMessage = false
+                }
+            }
+
+            is MessagesAction.VideoSectionAction -> {
+                handleVideoSectionAction(messagesAction).onFailure {
+                    shouldDismissMessage = false
+                }
+            }
+
+            is MessagesAction.MeasurementsAction -> {
+                appScreenEvents.emit(AppScreenEvents.Event.DoNewMeasurement)
+            }
+
+            is MessagesAction.MedicationsAction -> {
+                appScreenEvents.emit(
+                    AppScreenEvents.Event.NavigateToTab(
+                        BottomBarItem.MEDICATION
+                    )
+                )
+            }
+
+            is MessagesAction.QuestionnaireAction -> {
+                navigator.navigateTo(
+                    AppNavigationEvent.QuestionnaireScreen(
+                        messagesAction.questionnaireId
+                    )
+                )
+            }
+        }
+        if (shouldDismissMessage) {
+            messageRepository.completeMessage(messageId = messageId)
+        }
+    }
+
+    private suspend fun handleVideoSectionAction(messageAction: MessagesAction.VideoSectionAction): Result<Video> {
+        return engageEducationRepository.getVideoBySectionAndVideoId(
+            messageAction.videoSectionVideo.videoSectionId,
+            messageAction.videoSectionVideo.videoId
+        ).onSuccess { video ->
+            navigator.navigateTo(EducationNavigationEvent.VideoSectionClicked(video))
+        }.onFailure {
+            messageNotifier.notify(
+                messageId = R.string.error_while_handling_message_action
+            )
+            logger.e(it) { "Error while getting video by section and video id" }
+        }
+    }
+
+    private suspend fun handleHealthSummaryAction(messageId: String): Result<Unit> {
+        val setLoading = { loading: Boolean ->
+            _uiState.update {
+                it.copy(
+                    messages = it.messages.map { message ->
+                        if (message.id == messageId) {
+                            message.copy(isLoading = loading)
+                        } else {
+                            message
+                        }
+                    }
+                )
+            }
+        }
+        setLoading(true)
+        val result = healthSummaryService.generateHealthSummaryPdf()
+        setLoading(false)
+        return result
+    }
+
+    public override fun onCleared() {
+        super.onCleared()
+        bleService.stop()
+    }
+
+    private fun handleToggleExpandAction(action: Action.ToggleExpand) {
+        _uiState.update {
+            it.copy(
+                messages = it.messages.map { message ->
+                    if (message.id == action.message.id) {
+                        message.copy(isExpanded = !message.isExpanded)
+                    } else {
+                        message
+                    }
+                }
+            )
+        }
+    }
+
+    private fun handleConfirmMeasurementAction(action: Action.ConfirmMeasurement) {
+        _uiState.update {
+            it.copy(
+                measurementDialog = it.measurementDialog.copy(
+                    isProcessing = true,
+                )
+            )
+        }
+        viewModelScope.launch {
+            measurementsRepository.save(measurement = action.measurement)
+            _uiState.update {
+                it.copy(
+                    measurementDialog = it.measurementDialog.copy(
+                        isVisible = false,
+                        measurement = null,
+                        isProcessing = false,
+                    )
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapper.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapper.kt
index e4ba233c1..b6f358804 100644
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapper.kt
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapper.kt
@@ -53,7 +53,6 @@ class BluetoothUiStateMapper @Inject constructor(
             is EngageBLEServiceState.MissingPermissions -> {
                 BluetoothUiState.Idle(
                     description = R.string.bluetooth_permissions_not_granted_description,
-                    missingPermissions = state.permissions,
                     settingsAction = Action.Settings.AppSettings,
                 )
             }
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/Action.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/Action.kt
index 22228093b..5bd5fe2ba 100644
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/Action.kt
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/Action.kt
@@ -9,7 +9,7 @@ sealed interface Action {
     data object DismissDialog : Action
     data class MessageItemClicked(val message: Message) : Action
     data class ToggleExpand(val message: Message) : Action
-    data class PermissionGranted(val permission: String) : Action
+    data class PermissionResult(val permission: String) : Action
     data object Resumed : Action
     data object BLEDevicePairing : Action
     data class NewIntent(val intent: Intent) : Action
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/BluetoothUiState.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/BluetoothUiState.kt
index 50516f16a..263a95ed1 100644
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/BluetoothUiState.kt
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/BluetoothUiState.kt
@@ -5,7 +5,6 @@ import edu.stanford.bdh.engagehf.R
 sealed interface BluetoothUiState {
     data class Idle(
         val description: Int = R.string.bluetooth_not_enabled_description,
-        val missingPermissions: List<String>? = null,
         val settingsAction: Action.Settings? = null,
     ) : BluetoothUiState
 
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/UiState.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/UiState.kt
index 765c2de01..c3fda25b3 100644
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/UiState.kt
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/models/UiState.kt
@@ -12,6 +12,7 @@ data class UiState(
     val weight: VitalDisplayData = VitalDisplayData(
         title = "Weight",
     ),
+    val missingPermissions: Set<String> = emptySet(),
     val messages: List<Message> = emptyList(),
     val bluetooth: BluetoothUiState = BluetoothUiState.Idle(),
     val measurementDialog: MeasurementDialogUiState = MeasurementDialogUiState(),
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreen.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreen.kt
new file mode 100644
index 000000000..ca444fb0b
--- /dev/null
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreen.kt
@@ -0,0 +1,357 @@
+package edu.stanford.bdh.engagehf.bluetooth.screen
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.Lifecycle
+import edu.stanford.bdh.engagehf.R
+import edu.stanford.bdh.engagehf.bluetooth.HomeViewModel
+import edu.stanford.bdh.engagehf.bluetooth.component.OperationStatus
+import edu.stanford.bdh.engagehf.bluetooth.component.VitalDisplay
+import edu.stanford.bdh.engagehf.bluetooth.data.models.Action
+import edu.stanford.bdh.engagehf.bluetooth.data.models.BluetoothUiState
+import edu.stanford.bdh.engagehf.bluetooth.data.models.DeviceUiModel
+import edu.stanford.bdh.engagehf.bluetooth.data.models.MeasurementDialogUiState
+import edu.stanford.bdh.engagehf.bluetooth.data.models.UiState
+import edu.stanford.bdh.engagehf.bluetooth.data.models.VitalDisplayData
+import edu.stanford.bdh.engagehf.messages.Message
+import edu.stanford.bdh.engagehf.messages.MessageItem
+import edu.stanford.bdh.engagehf.messages.MessageType
+import edu.stanford.spezi.core.design.component.AsyncTextButton
+import edu.stanford.spezi.core.design.component.DefaultElevatedCard
+import edu.stanford.spezi.core.design.component.LifecycleEvent
+import edu.stanford.spezi.core.design.component.PermissionRequester
+import edu.stanford.spezi.core.design.component.SecondaryText
+import edu.stanford.spezi.core.design.component.StringResource
+import edu.stanford.spezi.core.design.component.VerticalSpacer
+import edu.stanford.spezi.core.design.theme.Colors
+import edu.stanford.spezi.core.design.theme.Spacings
+import edu.stanford.spezi.core.design.theme.SpeziTheme
+import edu.stanford.spezi.core.design.theme.TextStyles
+import edu.stanford.spezi.core.design.theme.ThemePreviews
+import edu.stanford.spezi.core.utils.extensions.testIdentifier
+import java.time.ZonedDateTime
+
+private const val IDLE_DESCRIPTION_WEIGHT = 0.5f
+
+@Composable
+fun HomeScreen() {
+    val viewModel = hiltViewModel<HomeViewModel>()
+    val uiState by viewModel.uiState.collectAsState()
+    HomeScreen(
+        uiState = uiState,
+        onAction = viewModel::onAction
+    )
+}
+
+@Composable
+private fun HomeScreen(
+    uiState: UiState,
+    onAction: (Action) -> Unit,
+) {
+    PermissionRequester(
+        missingPermissions = uiState.missingPermissions,
+        onResult = { _, permission -> onAction(Action.PermissionResult(permission = permission)) }
+    )
+
+    LifecycleEvent { event ->
+        if (event == Lifecycle.Event.ON_RESUME) {
+            onAction(Action.Resumed)
+        }
+    }
+
+    LazyColumn(
+        modifier = Modifier
+            .testIdentifier(HomeScreenTestIdentifier.ROOT)
+            .fillMaxSize()
+            .padding(Spacings.medium)
+    ) {
+        item {
+            BluetoothHeaderSection(bluetoothUiState = uiState.bluetooth, onAction = onAction)
+            MeasurementDialog(
+                uiState = uiState.measurementDialog,
+                onAction = onAction,
+            )
+            VerticalSpacer()
+            Text(
+                text = stringResource(R.string.messages),
+                style = TextStyles.titleMedium,
+                modifier = Modifier.testIdentifier(HomeScreenTestIdentifier.MESSAGE_TITLE)
+            )
+        }
+        if (uiState.messages.isNotEmpty()) {
+            items(uiState.messages) { message ->
+                MessageItem(
+                    message = message,
+                    onAction = onAction,
+                )
+            }
+        } else {
+            item {
+                Text(
+                    text = "No messages",
+                    style = TextStyles.bodyMedium,
+                    modifier = Modifier.padding(vertical = Spacings.small)
+                )
+            }
+        }
+
+        item {
+            VerticalSpacer()
+            Text(
+                text = stringResource(R.string.vitals),
+                style = TextStyles.titleMedium,
+                modifier = Modifier.testIdentifier(HomeScreenTestIdentifier.VITAL_TITLE)
+            )
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(Spacings.medium),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(top = Spacings.medium)
+            ) {
+                VitalDisplay(
+                    modifier = Modifier
+                        .weight(1f)
+                        .clickable { onAction(Action.VitalsCardClicked) }
+                        .testIdentifier(
+                            identifier = HomeScreenTestIdentifier.VITALS,
+                            suffix = uiState.weight.title
+                        ),
+                    vitalDisplayUiState = uiState.weight
+                )
+                VitalDisplay(
+                    modifier = Modifier
+                        .weight(1f)
+                        .clickable { onAction(Action.VitalsCardClicked) }
+                        .testIdentifier(
+                            identifier = HomeScreenTestIdentifier.VITALS,
+                            suffix = uiState.heartRate.title
+                        ),
+                    vitalDisplayUiState = uiState.heartRate
+                )
+            }
+            VitalDisplay(
+                modifier = Modifier
+                    .padding(vertical = Spacings.medium)
+                    .clickable { onAction(Action.VitalsCardClicked) }
+                    .testIdentifier(
+                        identifier = HomeScreenTestIdentifier.VITALS,
+                        suffix = uiState.bloodPressure.title
+                    ),
+                vitalDisplayUiState = uiState.bloodPressure
+            )
+        }
+    }
+}
+
+@Composable
+private fun BluetoothHeaderSection(
+    bluetoothUiState: BluetoothUiState,
+    onAction: (Action) -> Unit,
+) {
+    Row(
+        modifier = Modifier.padding(bottom = Spacings.small),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = stringResource(R.string.your_devices_header_title),
+            style = TextStyles.titleMedium,
+            color = Colors.onSurface,
+        )
+        Spacer(modifier = Modifier.weight(1f))
+        if (bluetoothUiState is BluetoothUiState.Ready) {
+            IconButton(onClick = { onAction(Action.BLEDevicePairing) }) {
+                Icon(Icons.Filled.Add, contentDescription = "Pair device")
+            }
+        }
+    }
+
+    when (bluetoothUiState) {
+        is BluetoothUiState.Idle -> {
+            DefaultElevatedCard(modifier = Modifier.fillMaxWidth()) {
+                Row(
+                    modifier = Modifier
+                        .padding(Spacings.small)
+                        .fillMaxWidth(),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    SecondaryText(
+                        modifier = Modifier
+                            .padding(Spacings.small)
+                            .weight(IDLE_DESCRIPTION_WEIGHT),
+                        text = stringResource(id = bluetoothUiState.description),
+                    )
+                    bluetoothUiState.settingsAction?.let {
+                        AsyncTextButton(
+                            text = stringResource(id = R.string.home_settings_action),
+                            onClick = { onAction(it) },
+                        )
+                    }
+                }
+            }
+        }
+
+        is BluetoothUiState.Ready -> {
+            Devices(readyState = bluetoothUiState)
+        }
+    }
+}
+
+@Composable
+private fun Devices(readyState: BluetoothUiState.Ready) {
+    readyState.header?.let {
+        SecondaryText(text = stringResource(id = it))
+    }
+
+    Column(verticalArrangement = Arrangement.spacedBy(Spacings.small)) {
+        readyState.devices.forEach { device ->
+            DeviceComposable(device = device)
+        }
+    }
+}
+
+@Composable
+fun DeviceComposable(device: DeviceUiModel) {
+    DefaultElevatedCard(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(bottom = Spacings.small),
+    ) {
+        Column(
+            modifier = Modifier
+                .padding(Spacings.medium),
+            verticalArrangement = Arrangement.spacedBy(Spacings.small)
+        ) {
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(4.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Box(
+                    modifier = Modifier
+                        .size(10.dp)
+                        .background(
+                            if (device.connected) Color.Green else Color.Red,
+                            shape = CircleShape,
+                        )
+
+                )
+                Text(text = device.name, style = TextStyles.bodyMedium)
+            }
+            SecondaryText(text = device.summary)
+            SecondaryText(text = device.lastSeen.text())
+        }
+    }
+}
+
+enum class HomeScreenTestIdentifier {
+    ROOT,
+    MESSAGE_TITLE,
+    VITAL_TITLE,
+    VITALS,
+}
+
+@ThemePreviews
+@Composable
+@Suppress("UnusedPrivateMember")
+private fun HomeScreenPreview(@PreviewParameter(HomeScreenPreviewProvider::class) uiState: UiState) {
+    val mockOnAction: (Action) -> Unit = {}
+    SpeziTheme {
+        HomeScreen(
+            uiState = uiState,
+            onAction = mockOnAction
+        )
+    }
+}
+
+private class HomeScreenPreviewProvider : PreviewParameterProvider<UiState> {
+    private val defaultUiState = createUiState()
+    override val values: Sequence<UiState>
+        get() = sequenceOf(
+            defaultUiState,
+            defaultUiState.copy(
+                bluetooth = BluetoothUiState.Ready(
+                    header = R.string.paired_devices_hint_description,
+                    devices = emptyList(),
+                )
+            ),
+            defaultUiState.copy(
+                bluetooth = BluetoothUiState.Idle(
+                    description = R.string.bluetooth_not_enabled_description,
+                    settingsAction = Action.Settings.BluetoothSettings,
+                )
+            ),
+            defaultUiState.copy(
+                bluetooth = BluetoothUiState.Idle(
+                    description = R.string.bluetooth_permissions_not_granted_description,
+                    settingsAction = Action.Settings.BluetoothSettings,
+                )
+            )
+        )
+
+    private fun createUiState() = UiState(
+        bluetooth = BluetoothUiState.Ready(
+            header = null,
+            devices = listOf(
+                DeviceUiModel(
+                    name = "My device",
+                    summary = "Device 1 Summary",
+                    connected = true,
+                    lastSeen = StringResource("Last seen on 12.04.05 12:43"),
+                ),
+            )
+        ),
+        measurementDialog = MeasurementDialogUiState(
+            isVisible = false,
+            formattedWeight = "0.0"
+        ),
+        messages = listOf(
+            Message(
+                id = "1",
+                dueDate = ZonedDateTime.now(),
+                type = MessageType.WeightGain,
+                title = "Weight Gained",
+                description = "You gained weight. Please take action.",
+                action = "New Weight Entry"
+            )
+        ),
+        weight = VitalDisplayData(
+            title = "Weight",
+            value = "0.0",
+            unit = "kg",
+            status = OperationStatus.SUCCESS,
+            date = "01 Jan 2022"
+        ),
+        heartRate = VitalDisplayData(
+            title = "Heart Rate",
+            status = OperationStatus.FAILURE,
+            error = "Cannot retrieve data"
+        ),
+    )
+}
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/navigation/screens/AppScreen.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/navigation/screens/AppScreen.kt
index f83ad84cb..d259dd556 100644
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/navigation/screens/AppScreen.kt
+++ b/app/src/main/kotlin/edu/stanford/bdh/engagehf/navigation/screens/AppScreen.kt
@@ -33,7 +33,7 @@ import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import edu.stanford.bdh.engagehf.bluetooth.component.DoNewMeasurementBottomSheet
 import edu.stanford.bdh.engagehf.bluetooth.pairing.BLEDevicePairingBottomSheet
-import edu.stanford.bdh.engagehf.bluetooth.screen.BluetoothScreen
+import edu.stanford.bdh.engagehf.bluetooth.screen.HomeScreen
 import edu.stanford.bdh.engagehf.health.HealthScreen
 import edu.stanford.bdh.engagehf.health.bloodpressure.bottomsheet.AddBloodPressureBottomSheet
 import edu.stanford.bdh.engagehf.health.bloodpressure.bottomsheet.BloodPressureDescriptionBottomSheet
@@ -172,7 +172,7 @@ fun BottomSheetScaffoldContent(
                 modifier = Modifier.padding(innerPadding)
             ) {
                 when (uiState.selectedItem) {
-                    BottomBarItem.HOME -> BluetoothScreen()
+                    BottomBarItem.HOME -> HomeScreen()
                     BottomBarItem.HEART_HEALTH -> HealthScreen()
                     BottomBarItem.MEDICATION -> MedicationScreen()
                     BottomBarItem.EDUCATION -> EducationScreen()
diff --git a/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModelTest.kt b/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModelTest.kt
new file mode 100644
index 000000000..54593827e
--- /dev/null
+++ b/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/HomeViewModelTest.kt
@@ -0,0 +1,586 @@
+package edu.stanford.bdh.engagehf.bluetooth
+
+import android.content.Context
+import androidx.health.connect.client.records.BloodPressureRecord
+import androidx.health.connect.client.records.HeartRateRecord
+import androidx.health.connect.client.records.WeightRecord
+import com.google.common.truth.Truth.assertThat
+import edu.stanford.bdh.engagehf.R
+import edu.stanford.bdh.engagehf.bluetooth.component.AppScreenEvents
+import edu.stanford.bdh.engagehf.bluetooth.data.mapper.BluetoothUiStateMapper
+import edu.stanford.bdh.engagehf.bluetooth.data.models.Action
+import edu.stanford.bdh.engagehf.bluetooth.data.models.BluetoothUiState
+import edu.stanford.bdh.engagehf.bluetooth.data.models.MeasurementDialogUiState
+import edu.stanford.bdh.engagehf.bluetooth.data.models.VitalDisplayData
+import edu.stanford.bdh.engagehf.bluetooth.measurements.MeasurementsRepository
+import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEService
+import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEServiceEvent
+import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEServiceState
+import edu.stanford.bdh.engagehf.bluetooth.service.Measurement
+import edu.stanford.bdh.engagehf.education.EngageEducationRepository
+import edu.stanford.bdh.engagehf.messages.HealthSummaryService
+import edu.stanford.bdh.engagehf.messages.Message
+import edu.stanford.bdh.engagehf.messages.MessageRepository
+import edu.stanford.bdh.engagehf.messages.MessageType
+import edu.stanford.bdh.engagehf.messages.MessagesAction
+import edu.stanford.bdh.engagehf.messages.VideoSectionVideo
+import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
+import edu.stanford.bdh.engagehf.navigation.screens.BottomBarItem
+import edu.stanford.spezi.core.navigation.Navigator
+import edu.stanford.spezi.core.notification.NotificationPermissions
+import edu.stanford.spezi.core.testing.CoroutineTestRule
+import edu.stanford.spezi.core.testing.runTestUnconfined
+import edu.stanford.spezi.core.utils.MessageNotifier
+import edu.stanford.spezi.modules.education.EducationNavigationEvent
+import edu.stanford.spezi.modules.education.videos.Video
+import io.mockk.Runs
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.verify
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.flowOf
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import java.time.ZonedDateTime
+
+class HomeViewModelTest {
+    private val bleService: EngageBLEService = mockk()
+    private val uiStateMapper: BluetoothUiStateMapper = mockk()
+    private val measurementsRepository = mockk<MeasurementsRepository>(relaxed = true)
+    private val messageRepository = mockk<MessageRepository>(relaxed = true)
+    private val engageEducationRepository = mockk<EngageEducationRepository>(relaxed = true)
+    private val healthSummaryService = mockk<HealthSummaryService>(relaxed = true)
+    private val context: Context = mockk(relaxed = true)
+    private val messageNotifier = mockk<MessageNotifier>(relaxed = true)
+    private val notificationPermissions = mockk<NotificationPermissions>(relaxed = true)
+
+    private val bleServiceState =
+        MutableStateFlow<EngageBLEServiceState>(EngageBLEServiceState.Idle)
+    private val bleServiceEvents = MutableSharedFlow<EngageBLEServiceEvent>()
+    private val readyUiState: BluetoothUiState.Ready = mockk()
+    private val appScreenEvents = mockk<AppScreenEvents>(relaxed = true)
+    private val navigator = mockk<Navigator>(relaxed = true)
+    private val messageAction = "some-action"
+    private val messageId = "some-id"
+    private val message: Message = mockk {
+        every { action } returns messageAction
+        every { id } returns messageId
+        every { isExpanded } returns false
+        every { isDismissible } returns true
+    }
+
+    @get:Rule
+    val coroutineTestRule = CoroutineTestRule()
+
+    private lateinit var viewModel: HomeViewModel
+
+    @Before
+    fun setup() {
+        with(bleService) {
+            every { state } returns bleServiceState
+            every { events } returns bleServiceEvents
+            every { start() } just Runs
+            every { stop() } just Runs
+        }
+        with(uiStateMapper) {
+            every { mapBleServiceState(any()) } returns readyUiState
+            every { mapWeight(any()) } returns mockk()
+            every { mapHeartRate(any()) } returns mockk()
+            every { mapBloodPressure(any()) } returns mockk()
+            every { mapMeasurementDialog(any()) } returns mockk()
+            every { mapMessagesAction(any()) } returns Result.failure(Throwable())
+        }
+        every { context.packageName } returns "some-package"
+    }
+
+    @Test
+    fun `it should indicate notification permissions in initial ui state`() {
+        // given
+        val permissions = setOf("permission1", "permission2")
+        every { notificationPermissions.getRequiredPermissions() } returns permissions
+        createViewModel()
+
+        // when
+        val uiState = viewModel.uiState.value
+
+        // then
+        assertThat(uiState.missingPermissions).isEqualTo(permissions)
+    }
+
+    @Test
+    fun `it should start ble service and start collection on init`() {
+        // when
+        createViewModel()
+
+        // then
+        verify { bleService.start() }
+        verify { bleService.state }
+        verify { bleService.events }
+    }
+
+    @Test
+    fun `it should start record observation on init`() {
+        // when
+        createViewModel()
+
+        // then
+        coVerify { measurementsRepository.observeWeightRecord() }
+        coVerify { measurementsRepository.observeHeartRateRecord() }
+        coVerify { measurementsRepository.observeBloodPressureRecord() }
+    }
+
+    @Test
+    fun `it should start messages observation on init`() {
+        // when
+        createViewModel()
+
+        // then
+        coVerify { messageRepository.observeUserMessages() }
+    }
+
+    @Test
+    fun `it should handle ble service state updates correctly`() = runTestUnconfined {
+        // given
+        val updates = listOf(
+            EngageBLEServiceState.Idle,
+            EngageBLEServiceState.Scanning(emptyList()),
+            EngageBLEServiceState.MissingPermissions(emptyList()),
+            EngageBLEServiceState.BluetoothNotEnabled,
+        )
+
+        createViewModel()
+        updates.forEach { update ->
+            every { uiStateMapper.mapBleServiceState(update) } returns readyUiState
+
+            // when
+            bleServiceState.emit(update)
+
+            // then
+            verify { uiStateMapper.mapBleServiceState(update) }
+            assertBluetoothUiState(state = readyUiState)
+        }
+    }
+
+    @Test
+    fun `it should handle MeasurementReceived events correctly`() =
+        runTestUnconfined {
+            // given
+            val measurement: Measurement = mockk()
+            val event =
+                EngageBLEServiceEvent.MeasurementReceived(
+                    device = mockk(),
+                    measurement = measurement
+                )
+            val measurementDialog: MeasurementDialogUiState = mockk()
+            every { uiStateMapper.mapMeasurementDialog(measurement) } returns measurementDialog
+
+            createViewModel()
+
+            // when
+            bleServiceEvents.emit(event)
+
+            // then
+            verify { appScreenEvents.emit(AppScreenEvents.Event.CloseBottomSheet) }
+            assertBluetoothUiState(state = readyUiState)
+            assertThat(viewModel.uiState.value.measurementDialog).isEqualTo(
+                measurementDialog
+            )
+        }
+
+    @Test
+    fun `it should handle weight updates correctly`() = runTestUnconfined {
+        // Given
+        val result: Result<WeightRecord?> = mockk()
+        val uiState: VitalDisplayData = mockk()
+        every { uiStateMapper.mapWeight(result) } returns uiState
+        coEvery {
+            measurementsRepository.observeWeightRecord()
+        } returns flowOf(result)
+
+        // When
+        createViewModel()
+
+        // Then
+        assertThat(viewModel.uiState.value.weight).isEqualTo(uiState)
+    }
+
+    @Test
+    fun `it should handle blood pressure updates correctly`() = runTestUnconfined {
+        // Given
+        val result: Result<BloodPressureRecord?> = mockk()
+        val uiState: VitalDisplayData = mockk()
+        every { uiStateMapper.mapBloodPressure(result) } returns uiState
+        coEvery {
+            measurementsRepository.observeBloodPressureRecord()
+        } returns flowOf(result)
+
+        // When
+        createViewModel()
+
+        // Then
+        assertThat(viewModel.uiState.value.bloodPressure).isEqualTo(uiState)
+    }
+
+    @Test
+    fun `it should handle heart rate updates correctly`() = runTestUnconfined {
+        // Given
+        val result: Result<HeartRateRecord?> = mockk()
+        val uiState: VitalDisplayData = mockk()
+        every { uiStateMapper.mapHeartRate(result) } returns uiState
+        coEvery {
+            measurementsRepository.observeHeartRateRecord()
+        } returns flowOf(result)
+
+        // When
+        createViewModel()
+
+        // Then
+        assertThat(viewModel.uiState.value.heartRate).isEqualTo(uiState)
+    }
+
+    @Test
+    fun `it should handle message updates correctly`() {
+        // given
+        val messages = List(10) { mockk<Message>() }
+        coEvery { messageRepository.observeUserMessages() } returns flowOf(messages)
+
+        // when
+        createViewModel()
+
+        // then
+        assertThat(viewModel.uiState.value.messages).isEqualTo(messages)
+    }
+
+    @Test
+    fun `it should stop service on cleared`() {
+        // given
+        createViewModel()
+
+        // when
+        viewModel.onCleared()
+
+        // then
+        verify { bleService.stop() }
+    }
+
+    @Test
+    fun `it should handle confirm measurement action correctly`() {
+        val measurement: Measurement.Weight = mockk()
+        val action = Action.ConfirmMeasurement(measurement = measurement)
+        coEvery { measurementsRepository.save(measurement = measurement) } just Runs
+        createViewModel()
+
+        // when
+        viewModel.onAction(action)
+
+        coVerify { measurementsRepository.save(measurement = measurement) }
+        val measurementDialog = viewModel.uiState.value.measurementDialog
+        with(measurementDialog) {
+            assertThat(isVisible).isFalse()
+            assertThat(this.measurement).isNull()
+            assertThat(this.isProcessing).isFalse()
+        }
+    }
+
+    @Test
+    fun `it should handle dismiss dialog correctly`() {
+        // given
+        val action = Action.DismissDialog
+        createViewModel()
+
+        // when
+        viewModel.onAction(action)
+
+        // then
+        assertThat(viewModel.uiState.value.measurementDialog.isVisible).isFalse()
+    }
+
+    @Test
+    fun `it should do nothing on MessageItemClicked with error result`() {
+        // given
+        val action = Action.MessageItemClicked(message = message)
+        every { uiStateMapper.mapMessagesAction(messageAction) } returns Result.failure(Throwable())
+        createViewModel()
+        val initialState = viewModel.uiState.value
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        assertThat(viewModel.uiState.value).isEqualTo(initialState)
+    }
+
+    @Test
+    fun `it should complete message on non error result`() {
+        // given
+        val action = Action.MessageItemClicked(message = message)
+        every {
+            uiStateMapper.mapMessagesAction(messageAction)
+        } returns Result.success(MessagesAction.HealthSummaryAction)
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        coVerify { messageRepository.completeMessage(messageId = messageId) }
+    }
+
+    @Test
+    fun `it should not dismiss health summary message on error result`() {
+        // given
+        val action = Action.MessageItemClicked(message = message)
+        every {
+            uiStateMapper.mapMessagesAction(messageAction)
+        } returns Result.success(MessagesAction.HealthSummaryAction)
+        coEvery {
+            healthSummaryService.generateHealthSummaryPdf()
+        } returns Result.failure(Throwable())
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        coVerify(
+            exactly = 0
+        ) { messageRepository.completeMessage(messageId = messageId) }
+    }
+
+    @Test
+    fun `it should not dismiss video section message on error result`() {
+        // given
+        val action = Action.MessageItemClicked(message = message)
+        every {
+            uiStateMapper.mapMessagesAction(messageAction)
+        } returns Result.success(MessagesAction.VideoSectionAction(VideoSectionVideo("1", "2")))
+        coEvery {
+            engageEducationRepository.getVideoBySectionAndVideoId(any(), any())
+        } returns Result.failure(Throwable())
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        coVerify(
+            exactly = 0
+        ) { messageRepository.completeMessage(messageId = messageId) }
+        coVerify {
+            messageNotifier.notify(
+                messageId = R.string.error_while_handling_message_action
+            )
+        }
+    }
+
+    @Test
+    fun `it should handle MeasurementsAction correctly`() {
+        // given
+        val action = Action.MessageItemClicked(message = message)
+        every {
+            uiStateMapper.mapMessagesAction(messageAction)
+        } returns Result.success(MessagesAction.MeasurementsAction)
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        verify { appScreenEvents.emit(AppScreenEvents.Event.DoNewMeasurement) }
+    }
+
+    @Test
+    fun `it should handle BLEDevicePairing correctly`() {
+        // given
+        val action = Action.BLEDevicePairing
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        verify { appScreenEvents.emit(AppScreenEvents.Event.BLEDevicePairingBottomSheet) }
+    }
+
+    @Test
+    fun `it should navigate to questionnaire screen on QuestionnaireAction`() {
+        // given
+        val questionnaireId = "1"
+        val action = Action.MessageItemClicked(message = message)
+        every {
+            uiStateMapper.mapMessagesAction(messageAction)
+        } returns Result.success(MessagesAction.QuestionnaireAction(questionnaireId))
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        verify { navigator.navigateTo(AppNavigationEvent.QuestionnaireScreen(questionnaireId)) }
+    }
+
+    @Test
+    fun `it should handle video section action correctly`() = runTestUnconfined {
+        val videoSectionId = "some-video-section-id"
+        val videoId = "some-video-id"
+        val videoSection: VideoSectionVideo = mockk {
+            every { this@mockk.videoSectionId } returns videoSectionId
+            every { this@mockk.videoId } returns videoId
+        }
+        val video: Video = mockk()
+        val videoSectionAction = MessagesAction.VideoSectionAction(videoSectionVideo = videoSection)
+        every { uiStateMapper.mapMessagesAction(messageAction) } returns Result.success(
+            videoSectionAction
+        )
+        coEvery {
+            engageEducationRepository.getVideoBySectionAndVideoId(videoSectionId, videoId)
+        } returns Result.success(video)
+        createViewModel()
+
+        // when
+        viewModel.onAction(Action.MessageItemClicked(message = message))
+
+        // then
+        coVerify { engageEducationRepository.getVideoBySectionAndVideoId(videoSectionId, videoId) }
+        verify { navigator.navigateTo(EducationNavigationEvent.VideoSectionClicked(video)) }
+    }
+
+    @Test
+    fun `it should handle health summary action correctly`() = runTestUnconfined {
+        // given
+        val action = Action.MessageItemClicked(message = message)
+        every {
+            uiStateMapper.mapMessagesAction(messageAction)
+        } returns Result.success(MessagesAction.HealthSummaryAction)
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        coVerify { healthSummaryService.generateHealthSummaryPdf() }
+    }
+
+    @Test
+    fun `it should handle medication change action correctly`() {
+        // given
+        val action = Action.MessageItemClicked(message = message)
+        every {
+            uiStateMapper.mapMessagesAction(messageAction)
+        } returns Result.success(MessagesAction.MedicationsAction)
+        createViewModel()
+
+        // when
+        viewModel.onAction(action = action)
+
+        // then
+        verify { appScreenEvents.emit(AppScreenEvents.Event.NavigateToTab(BottomBarItem.MEDICATION)) }
+    }
+
+    @Test
+    fun `it should handle toggle expand action correctly`() {
+        // given
+        val isExpanded = false
+        val message = Message(
+            id = messageId,
+            dueDate = ZonedDateTime.now(),
+            description = "",
+            title = "",
+            action = "",
+            type = MessageType.MedicationChange,
+            isExpanded = isExpanded,
+        )
+        every { this@HomeViewModelTest.message.id } returns "new-id"
+
+        coEvery { messageRepository.observeUserMessages() } returns flowOf(
+            listOf(
+                message,
+                this.message
+            )
+        )
+        createViewModel()
+
+        // when
+        viewModel.onAction(Action.ToggleExpand(message))
+
+        // then
+        assertThat(
+            viewModel.uiState.value.messages.first().isExpanded
+        ).isEqualTo(isExpanded.not())
+    }
+
+    @Test
+    fun `it should handle permission result action correctly`() = runTestUnconfined {
+        // given
+        val permissions = listOf("permission1")
+        val state = EngageBLEServiceState.MissingPermissions(permissions)
+        createViewModel()
+        bleServiceState.emit(state)
+        val initialState = viewModel.uiState.value
+
+        // when
+        viewModel.onAction(Action.PermissionResult(permission = permissions.first()))
+        val newState = viewModel.uiState.value
+
+        // then
+        assertThat(initialState.missingPermissions).isEqualTo(permissions.toSet())
+        assertThat(newState.missingPermissions).isEmpty()
+        verify(exactly = 2) { bleService.start() }
+    }
+
+    @Test
+    fun `it should handle resumed action correctly`() = runTestUnconfined {
+        // given
+        createViewModel()
+
+        // when
+        viewModel.onAction(Action.Resumed)
+
+        // then
+        verify(exactly = 2) { bleService.start() }
+    }
+
+    @Test
+    fun `it should handle VitalsCardClicked action correctly`() {
+        // given
+        val action = Action.VitalsCardClicked
+        createViewModel()
+
+        // when
+        viewModel.onAction(action)
+
+        // then
+        verify {
+            appScreenEvents.emit(
+                AppScreenEvents.Event.NavigateToTab(
+                    BottomBarItem.HEART_HEALTH
+                )
+            )
+        }
+    }
+
+    private fun assertBluetoothUiState(state: BluetoothUiState) {
+        assertThat(viewModel.uiState.value.bluetooth).isEqualTo(state)
+    }
+
+    private fun createViewModel() {
+        viewModel = HomeViewModel(
+            bleService = bleService,
+            uiStateMapper = uiStateMapper,
+            measurementsRepository = measurementsRepository,
+            messageRepository = messageRepository,
+            appScreenEvents = appScreenEvents,
+            navigator = navigator,
+            engageEducationRepository = engageEducationRepository,
+            healthSummaryService = healthSummaryService,
+            context = context,
+            messageNotifier = messageNotifier,
+            notificationPermissions = notificationPermissions,
+        )
+    }
+}
diff --git a/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapperTest.kt b/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapperTest.kt
index 3afa898d5..421c1dd38 100644
--- a/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapperTest.kt
+++ b/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/data/mapper/BluetoothUiStateMapperTest.kt
@@ -80,25 +80,6 @@ class BluetoothUiStateMapperTest {
         )
     }
 
-    @Test
-    fun `it should map MissingPermissions state correctly`() {
-        // given
-        val permissions = listOf("permission1", "permission2")
-        val state = EngageBLEServiceState.MissingPermissions(permissions)
-
-        // when
-        val result = mapper.mapBleServiceState(state) as BluetoothUiState.Idle
-
-        // then
-        assertThat(result).isEqualTo(
-            BluetoothUiState.Idle(
-                description = R.string.bluetooth_permissions_not_granted_description,
-                missingPermissions = permissions,
-                settingsAction = Action.Settings.AppSettings,
-            )
-        )
-    }
-
     @Test
     fun `it should map empty sessions correctly`() {
         // given
diff --git a/app/src/test/kotlin/edu/stanford/bdh/engagehf/onboarding/EngageConsentManagerTest.kt b/app/src/test/kotlin/edu/stanford/bdh/engagehf/onboarding/EngageConsentManagerTest.kt
index bd2e8474a..6484060f0 100644
--- a/app/src/test/kotlin/edu/stanford/bdh/engagehf/onboarding/EngageConsentManagerTest.kt
+++ b/app/src/test/kotlin/edu/stanford/bdh/engagehf/onboarding/EngageConsentManagerTest.kt
@@ -45,7 +45,7 @@ class EngageConsentManagerTest {
     }
 
     @Test
-    fun `it should navigate to bluetooth screen on consented`() = runTestUnconfined {
+    fun `it should navigate to home screen on consented`() = runTestUnconfined {
         // given
         val navigationEvent = AppNavigationEvent.AppScreen(clearBackStack = true)
 
diff --git a/core/design/src/main/kotlin/edu/stanford/spezi/core/design/component/PermissionRequester.kt b/core/design/src/main/kotlin/edu/stanford/spezi/core/design/component/PermissionRequester.kt
index f9ae03a6d..f08c05a54 100644
--- a/core/design/src/main/kotlin/edu/stanford/spezi/core/design/component/PermissionRequester.kt
+++ b/core/design/src/main/kotlin/edu/stanford/spezi/core/design/component/PermissionRequester.kt
@@ -7,13 +7,13 @@ import androidx.compose.runtime.LaunchedEffect
 
 @Composable
 fun PermissionRequester(
-    missingPermissions: List<String>?,
-    onGranted: (String) -> Unit,
+    missingPermissions: Set<String>,
+    onResult: (Boolean, String) -> Unit,
 ) {
-    val permission = missingPermissions?.firstOrNull() ?: return
+    val permission = missingPermissions.firstOrNull() ?: return
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission()
-    ) { granted -> if (granted) onGranted(permission) }
+    ) { granted -> onResult(granted, permission) }
 
     LaunchedEffect(key1 = permission) {
         launcher.launch(permission)
diff --git a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/NotificationPermissions.kt b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/NotificationPermissions.kt
new file mode 100644
index 000000000..87bfd68d5
--- /dev/null
+++ b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/NotificationPermissions.kt
@@ -0,0 +1,28 @@
+package edu.stanford.spezi.core.notification
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.os.Build
+import edu.stanford.spezi.core.utils.BuildInfo
+import edu.stanford.spezi.core.utils.PermissionChecker
+import javax.inject.Inject
+
+interface NotificationPermissions {
+    fun getRequiredPermissions(): Set<String>
+}
+
+internal class NotificationPermissionsImpl @Inject constructor(
+    private val permissionChecker: PermissionChecker,
+    private val buildInfo: BuildInfo,
+) : NotificationPermissions {
+
+    override fun getRequiredPermissions(): Set<String> {
+        return if (buildInfo.getSdkVersion() >= Build.VERSION_CODES.TIRAMISU) {
+            @SuppressLint("InlinedApi")
+            val permission = Manifest.permission.POST_NOTIFICATIONS
+            if (permissionChecker.isPermissionGranted(permission)) emptySet() else setOf(permission)
+        } else {
+            emptySet()
+        }
+    }
+}
diff --git a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt
index a915bf897..8969848db 100644
--- a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt
+++ b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt
@@ -3,16 +3,29 @@ package edu.stanford.spezi.core.notification.di
 import android.content.Context
 import androidx.core.app.NotificationManagerCompat
 import com.google.firebase.messaging.FirebaseMessaging
+import dagger.Binds
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import edu.stanford.spezi.core.notification.NotificationPermissions
+import edu.stanford.spezi.core.notification.NotificationPermissionsImpl
 import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
-internal class NotificationModule {
+class NotificationModule {
+
+    @Module
+    @InstallIn(SingletonComponent::class)
+    internal abstract class Bindings {
+        @Binds
+        internal abstract fun bindNotificationPermissions(
+            impl: NotificationPermissionsImpl,
+        ): NotificationPermissions
+    }
+
     @Provides
     @Singleton
     internal fun provideFirebaseMessaging(): FirebaseMessaging =
diff --git a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingScreen.kt b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingScreen.kt
index 6b2f7b27b..6192aa3ba 100644
--- a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingScreen.kt
+++ b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingScreen.kt
@@ -3,7 +3,6 @@ package edu.stanford.spezi.core.notification.setting
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
@@ -77,7 +76,7 @@ internal fun NotificationSettingScreen(
         Column(
             modifier = Modifier
                 .padding(paddingValues)
-                .padding(horizontal = Spacings.medium)
+                .padding(Spacings.medium)
         ) {
             when (uiState) {
                 is NotificationSettingViewModel.UiState.Error -> {
@@ -118,42 +117,31 @@ private fun MissingPermissions(
     uiState: NotificationSettingViewModel.UiState.MissingPermissions,
     onAction: (NotificationSettingViewModel.Action) -> Unit,
 ) {
-    LazyColumn(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(Spacings.medium)
-    ) {
-        item {
-            PermissionRequester(missingPermissions = uiState.missingPermissions,
-                onGranted = { permission ->
-                    onAction(
-                        NotificationSettingViewModel.Action.PermissionGranted(
-                            permission
-                        )
-                    )
-                })
+    PermissionRequester(
+        missingPermissions = uiState.missingPermissions,
+        onResult = { granted, permission ->
+            onAction(NotificationSettingViewModel.Action.PermissionResult(permission, granted))
         }
-        item {
-            DefaultElevatedCard(modifier = Modifier.fillMaxWidth()) {
-                Row(
-                    modifier = Modifier
-                        .padding(Spacings.small)
-                        .fillMaxWidth(),
-                    verticalAlignment = Alignment.CenterVertically,
-                ) {
-                    SecondaryText(
-                        modifier = Modifier
-                            .padding(Spacings.small)
-                            .weight(IDLE_DESCRIPTION_WEIGHT),
-                        text = stringResource(R.string.feature_requires_notifications),
-                    )
-                    AsyncTextButton(
-                        modifier = Modifier.padding(Spacings.small),
-                        text = stringResource(R.string.settings),
-                        onClick = { onAction(NotificationSettingViewModel.Action.AppSettings) },
-                    )
-                }
-            }
+    )
+
+    DefaultElevatedCard(modifier = Modifier.fillMaxWidth()) {
+        Row(
+            modifier = Modifier
+                .padding(Spacings.small)
+                .fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            SecondaryText(
+                modifier = Modifier
+                    .padding(Spacings.small)
+                    .weight(IDLE_DESCRIPTION_WEIGHT),
+                text = stringResource(R.string.feature_requires_notifications),
+            )
+            AsyncTextButton(
+                modifier = Modifier.padding(Spacings.small),
+                text = stringResource(R.string.settings),
+                onClick = { onAction(NotificationSettingViewModel.Action.AppSettings) },
+            )
         }
     }
 }
@@ -240,7 +228,7 @@ private class NotificationUiStateProvider :
     override val values = sequenceOf(
         NotificationSettingViewModel.UiState.Loading,
         NotificationSettingViewModel.UiState.Error("An error occurred"),
-        NotificationSettingViewModel.UiState.MissingPermissions(listOf("permission")),
+        NotificationSettingViewModel.UiState.MissingPermissions(setOf("permission")),
         NotificationSettingViewModel.UiState.NotificationSettingsLoaded(
             notificationSettings = NotificationSettings(
                 settings = mapOf(
diff --git a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModel.kt b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModel.kt
index ea2c2614e..f4637d875 100644
--- a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModel.kt
+++ b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModel.kt
@@ -1,10 +1,8 @@
 package edu.stanford.spezi.core.notification.setting
 
-import android.Manifest
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
-import android.os.Build
 import android.provider.Settings
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
@@ -14,6 +12,7 @@ import edu.stanford.spezi.core.design.action.PendingActions
 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.core.notification.NotificationPermissions
 import edu.stanford.spezi.core.utils.MessageNotifier
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -30,7 +29,7 @@ internal class NotificationSettingViewModel @Inject constructor(
     private val navigator: Navigator,
     private val notificationSettingsMapper: NotificationSettingsStateMapper,
     private val messageNotifier: MessageNotifier,
-    private val permissionChecker: edu.stanford.spezi.core.utils.PermissionChecker,
+    private val notificationPermissions: NotificationPermissions,
     @ApplicationContext private val context: Context,
 ) : ViewModel() {
     private val logger by speziLogger()
@@ -44,8 +43,7 @@ internal class NotificationSettingViewModel @Inject constructor(
 
     private fun loadNotificationSettings() {
         viewModelScope.launch {
-            val missingPermissions =
-                REQUIRED_PERMISSIONS.filterNot { permissionChecker.isPermissionGranted(it) }
+            val missingPermissions = notificationPermissions.getRequiredPermissions()
             if (missingPermissions.isNotEmpty()) {
                 _uiState.update { UiState.MissingPermissions(missingPermissions) }
             } else {
@@ -96,8 +94,8 @@ internal class NotificationSettingViewModel @Inject constructor(
                 }
             }
 
-            is Action.PermissionGranted -> {
-                handlePermissionResult(action.permission)
+            is Action.PermissionResult -> {
+                handlePermissionResult(permission = action.permission, granted = action.granted)
             }
 
             Action.AppSettings -> {
@@ -117,17 +115,15 @@ internal class NotificationSettingViewModel @Inject constructor(
         }
     }
 
-    private fun handlePermissionResult(permission: String) {
-        _uiState.update {
-            val currentState = _uiState.value
+    private fun handlePermissionResult(permission: String, granted: Boolean) {
+        _uiState.update { currentState ->
             if (currentState is UiState.MissingPermissions) {
-                val missingPermissions =
-                    currentState.missingPermissions.orEmpty().filterNot { it == permission }
+                val missingPermissions = currentState.missingPermissions.filterNot { granted && it == permission }
                 if (missingPermissions.isEmpty()) {
                     loadNotificationSettings()
                     currentState
                 } else {
-                    UiState.MissingPermissions(missingPermissions)
+                    UiState.MissingPermissions(missingPermissions.toSet())
                 }
             } else {
                 currentState
@@ -144,27 +140,17 @@ internal class NotificationSettingViewModel @Inject constructor(
         ) : Action
 
         data object AppSettings : Action
-        data class PermissionGranted(val permission: String) : Action
+        data class PermissionResult(val permission: String, val granted: Boolean) : Action
     }
 
     sealed interface UiState {
         data object Loading : UiState
         data class Error(val message: String) : UiState
-        data class MissingPermissions(val missingPermissions: List<String>?) : UiState
+        data class MissingPermissions(val missingPermissions: Set<String>) : UiState
 
         data class NotificationSettingsLoaded(
             val notificationSettings: NotificationSettings,
             val pendingActions: PendingActions<Action.SwitchChanged> = PendingActions(),
         ) : UiState
     }
-
-    private companion object {
-        val REQUIRED_PERMISSIONS = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            listOf(
-                Manifest.permission.POST_NOTIFICATIONS,
-            )
-        } else {
-            emptyList()
-        }
-    }
 }
diff --git a/core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/NotificationPermissionsTest.kt b/core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/NotificationPermissionsTest.kt
new file mode 100644
index 000000000..7dc390d24
--- /dev/null
+++ b/core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/NotificationPermissionsTest.kt
@@ -0,0 +1,59 @@
+package edu.stanford.spezi.core.notification
+
+import android.Manifest
+import android.os.Build
+import com.google.common.truth.Truth.assertThat
+import edu.stanford.spezi.core.utils.BuildInfo
+import edu.stanford.spezi.core.utils.PermissionChecker
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.Test
+
+class NotificationPermissionsTest {
+    private val permissionChecker: PermissionChecker = mockk()
+    private val buildInfo: BuildInfo = mockk()
+    private val tiramisu = Build.VERSION_CODES.TIRAMISU
+
+    private val notificationPermissions = NotificationPermissionsImpl(
+        permissionChecker = permissionChecker,
+        buildInfo = buildInfo,
+    )
+
+    @Test
+    fun `getRequiredPermissions returns empty set below TIRAMISU`() {
+        // given
+        every { buildInfo.getSdkVersion() } returns tiramisu - 1
+
+        // when
+        val requiredPermissions = notificationPermissions.getRequiredPermissions()
+
+        // then
+        assertThat(requiredPermissions).isEmpty()
+    }
+
+    @Test
+    fun `getRequiredPermissions returns POST_NOTIFICATIONS when permission is not granted on TIRAMISU or higher`() {
+        // given
+        every { buildInfo.getSdkVersion() } returns tiramisu
+        every { permissionChecker.isPermissionGranted(Manifest.permission.POST_NOTIFICATIONS) } returns false
+
+        // when
+        val requiredPermissions = notificationPermissions.getRequiredPermissions()
+
+        // then
+        assertThat(requiredPermissions).isEqualTo(setOf(Manifest.permission.POST_NOTIFICATIONS))
+    }
+
+    @Test
+    fun `getRequiredPermissions returns empty set when permission is granted on TIRAMISU or higher`() {
+        // given
+        every { buildInfo.getSdkVersion() } returns tiramisu
+        every { permissionChecker.isPermissionGranted(Manifest.permission.POST_NOTIFICATIONS) } returns true
+
+        // when
+        val requiredPermissions = notificationPermissions.getRequiredPermissions()
+
+        // then
+        assertThat(requiredPermissions).isEmpty()
+    }
+}
diff --git a/core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModelTest.kt b/core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModelTest.kt
index 1f4554838..314defabb 100644
--- a/core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModelTest.kt
+++ b/core/notification/src/test/kotlin/edu/stanford/spezi/core/notification/setting/NotificationSettingViewModelTest.kt
@@ -4,15 +4,15 @@ import android.content.Context
 import com.google.common.truth.Truth.assertThat
 import edu.stanford.spezi.core.navigation.NavigationEvent
 import edu.stanford.spezi.core.navigation.Navigator
+import edu.stanford.spezi.core.notification.NotificationPermissions
 import edu.stanford.spezi.core.testing.CoroutineTestRule
 import edu.stanford.spezi.core.utils.MessageNotifier
-import edu.stanford.spezi.core.utils.PermissionChecker
 import io.mockk.coEvery
+import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.test.runTest
-import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 
@@ -25,19 +25,16 @@ class NotificationSettingViewModelTest {
     private val navigator: Navigator = mockk(relaxed = true)
     private val uiStateMapper: NotificationSettingsStateMapper = mockk(relaxed = true)
     private val messageNotifier: MessageNotifier = mockk(relaxed = true)
-    private val permissionChecker: PermissionChecker = mockk(relaxed = true)
+    private val notificationPermissions: NotificationPermissions = mockk(relaxed = true)
     private val context: Context = mockk(relaxed = true)
 
-    private lateinit var viewModel: NotificationSettingViewModel
-
-    @Before
-    fun setup() {
-        viewModel = NotificationSettingViewModel(
+    private val viewModel: NotificationSettingViewModel by lazy {
+        NotificationSettingViewModel(
             repository = repository,
             navigator = navigator,
             notificationSettingsMapper = uiStateMapper,
             messageNotifier = messageNotifier,
-            permissionChecker = permissionChecker,
+            notificationPermissions = notificationPermissions,
             context = context,
         )
     }
@@ -54,6 +51,41 @@ class NotificationSettingViewModelTest {
         assertThat(uiState).isEqualTo(initialState)
     }
 
+    @Test
+    fun `it should have missing permissions state if required permissions are not empty`() = runTest {
+        // Given
+        val permissions = setOf("permission1", "permission2")
+        every { notificationPermissions.getRequiredPermissions() } returns permissions
+        val expectedState = NotificationSettingViewModel.UiState.MissingPermissions(permissions)
+
+        // When
+        val uiState = viewModel.uiState.value
+
+        // Then
+        assertThat(uiState).isEqualTo(expectedState)
+    }
+
+    @Test
+    fun `it should clear granted permission`() = runTest {
+        // Given
+        val granted = "to-be-granted-permission"
+        val nonGranted = "non-granted-permission"
+        val permissions = setOf(granted, nonGranted)
+        every { notificationPermissions.getRequiredPermissions() } returns permissions
+        val initialState = viewModel.uiState.value
+
+        // When
+        viewModel.onAction(NotificationSettingViewModel.Action.PermissionResult(permission = granted, granted = true))
+        viewModel.onAction(NotificationSettingViewModel.Action.PermissionResult(permission = nonGranted, granted = false))
+        val newState = viewModel.uiState.value
+
+        // Then
+        assertThat(initialState).isEqualTo(NotificationSettingViewModel.UiState.MissingPermissions(permissions))
+        assertThat(newState).isEqualTo(
+            NotificationSettingViewModel.UiState.MissingPermissions(setOf(nonGranted))
+        )
+    }
+
     @Test
     fun `loadNotificationSettings should update state on success`() = runTest {
         // Given
@@ -67,17 +99,9 @@ class NotificationSettingViewModelTest {
         )
 
         // When
-        viewModel = NotificationSettingViewModel(
-            repository = repository,
-            navigator = navigator,
-            notificationSettingsMapper = uiStateMapper,
-            messageNotifier = messageNotifier,
-            permissionChecker = permissionChecker,
-            context = context,
-        )
+        val uiState = viewModel.uiState.value
 
         // Then
-        val uiState = viewModel.uiState.value
         assertThat(uiState).isInstanceOf(NotificationSettingViewModel.UiState.NotificationSettingsLoaded::class.java)
         val loadedState = uiState as NotificationSettingViewModel.UiState.NotificationSettingsLoaded
         assertThat(loadedState.notificationSettings).isEqualTo(notificationSettings)
@@ -95,17 +119,9 @@ class NotificationSettingViewModelTest {
         )
 
         // When
-        viewModel = NotificationSettingViewModel(
-            repository = repository,
-            navigator = navigator,
-            notificationSettingsMapper = uiStateMapper,
-            messageNotifier = messageNotifier,
-            permissionChecker = permissionChecker,
-            context = context,
-        )
+        val uiState = viewModel.uiState.value
 
         // Then
-        val uiState = viewModel.uiState.value
         assertThat(uiState).isInstanceOf(NotificationSettingViewModel.UiState.Error::class.java)
         val errorState = uiState as NotificationSettingViewModel.UiState.Error
         assertThat(errorState.message).isEqualTo("Failed to observe notification settings")
diff --git a/core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/BuildInfo.kt b/core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/BuildInfo.kt
new file mode 100644
index 000000000..7c683b836
--- /dev/null
+++ b/core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/BuildInfo.kt
@@ -0,0 +1,12 @@
+package edu.stanford.spezi.core.utils
+
+import android.os.Build
+import javax.inject.Inject
+
+interface BuildInfo {
+    fun getSdkVersion(): Int
+}
+
+internal class BuildInfoImpl @Inject constructor() : BuildInfo {
+    override fun getSdkVersion(): Int = Build.VERSION.SDK_INT
+}
diff --git a/core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/di/UtilsModule.kt b/core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/di/UtilsModule.kt
index f9ef26418..aedf213b8 100644
--- a/core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/di/UtilsModule.kt
+++ b/core/utils/src/main/kotlin/edu/stanford/spezi/core/utils/di/UtilsModule.kt
@@ -4,6 +4,8 @@ import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
+import edu.stanford.spezi.core.utils.BuildInfo
+import edu.stanford.spezi.core.utils.BuildInfoImpl
 import edu.stanford.spezi.core.utils.LocaleProvider
 import edu.stanford.spezi.core.utils.LocaleProviderImpl
 
@@ -13,4 +15,7 @@ abstract class UtilsModule {
 
     @Binds
     internal abstract fun bindLocaleProvider(impl: LocaleProviderImpl): LocaleProvider
+
+    @Binds
+    internal abstract fun bindBuildInfo(impl: BuildInfoImpl): BuildInfo
 }
diff --git a/core/utils/src/test/kotlin/edu/stanford/spezi/core/utils/BuildInfoTest.kt b/core/utils/src/test/kotlin/edu/stanford/spezi/core/utils/BuildInfoTest.kt
new file mode 100644
index 000000000..98e5edb95
--- /dev/null
+++ b/core/utils/src/test/kotlin/edu/stanford/spezi/core/utils/BuildInfoTest.kt
@@ -0,0 +1,14 @@
+package edu.stanford.spezi.core.utils
+
+import android.os.Build
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class BuildInfoTest {
+    private val buildInfo = BuildInfoImpl()
+
+    @Test
+    fun `it should indicate sdk version`() {
+        assertThat(buildInfo.getSdkVersion()).isEqualTo(Build.VERSION.SDK_INT)
+    }
+}

From 2306f19a470cb682cefb5b6c84230e9b84ef60af Mon Sep 17 00:00:00 2001
From: Eldi Cano <eldi.cano@hotmail.com>
Date: Sun, 8 Dec 2024 23:21:42 +0100
Subject: [PATCH 2/3] request notification permissions in home

---
 .../bluetooth/screen/BluetoothScreenTest.kt   |  74 ---
 .../simulator/BluetoothScreenSimulator.kt     |  36 --
 .../engagehf/bluetooth/BluetoothViewModel.kt  | 339 -----------
 .../bluetooth/screen/BluetoothScreen.kt       | 360 -----------
 .../bluetooth/BluetoothViewModelTest.kt       | 565 ------------------
 5 files changed, 1374 deletions(-)
 delete mode 100644 app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreenTest.kt
 delete mode 100644 app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/BluetoothScreenSimulator.kt
 delete mode 100644 app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModel.kt
 delete mode 100644 app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreen.kt
 delete mode 100644 app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModelTest.kt

diff --git a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreenTest.kt b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreenTest.kt
deleted file mode 100644
index 2e113b998..000000000
--- a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreenTest.kt
+++ /dev/null
@@ -1,74 +0,0 @@
-package edu.stanford.bdh.engagehf.bluetooth.screen
-
-import android.Manifest
-import androidx.compose.ui.test.junit4.createAndroidComposeRule
-import androidx.test.rule.GrantPermissionRule
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import edu.stanford.bdh.engagehf.R
-import edu.stanford.bdh.engagehf.bluetooth.data.models.UiState
-import edu.stanford.bdh.engagehf.simulator.BluetoothScreenSimulator
-import edu.stanford.spezi.core.design.component.ComposeContentActivity
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-
-@HiltAndroidTest
-class BluetoothScreenTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @get:Rule
-    val composeTestRule = createAndroidComposeRule<ComposeContentActivity>()
-
-    @get:Rule
-    val runtimePermissionRule: GrantPermissionRule = GrantPermissionRule.grant(
-        Manifest.permission.BLUETOOTH_CONNECT,
-        Manifest.permission.BLUETOOTH_SCAN,
-        Manifest.permission.ACCESS_COARSE_LOCATION,
-        Manifest.permission.ACCESS_FINE_LOCATION,
-    )
-
-    @Before
-    fun init() {
-        composeTestRule.activity.setScreen {
-            BluetoothScreen()
-        }
-    }
-
-    @Test
-    fun `test bluetooth screen root is displayed`() {
-        bluetoothScreen {
-            assertIsDisplayed()
-        }
-    }
-
-    @Test
-    fun `test bluetooth screen message title is displayed`() {
-        bluetoothScreen {
-            assertMessageTitle(composeTestRule.activity.getString(R.string.messages))
-        }
-    }
-
-    @Test
-    fun `test bluetooth screen vital title is displayed`() {
-        bluetoothScreen {
-            assertVitalTitle(composeTestRule.activity.getString(R.string.vitals))
-        }
-    }
-
-    @Test
-    fun `test bluetooth screen vital is displayed`() {
-        bluetoothScreen {
-            val uiState = UiState()
-            assertVital(uiState.weight.title)
-            assertVital(uiState.heartRate.title)
-            assertVital(uiState.bloodPressure.title)
-        }
-    }
-
-    private fun bluetoothScreen(block: BluetoothScreenSimulator.() -> Unit) {
-        BluetoothScreenSimulator(composeTestRule).apply(block)
-    }
-}
diff --git a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/BluetoothScreenSimulator.kt b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/BluetoothScreenSimulator.kt
deleted file mode 100644
index 9b2fdbe04..000000000
--- a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/simulator/BluetoothScreenSimulator.kt
+++ /dev/null
@@ -1,36 +0,0 @@
-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.bluetooth.screen.BluetoothScreenTestIdentifier
-import edu.stanford.spezi.core.testing.onNodeWithIdentifier
-
-class BluetoothScreenSimulator(
-    private val composeTestRule: ComposeTestRule,
-) {
-    private val root = composeTestRule.onNodeWithIdentifier(BluetoothScreenTestIdentifier.ROOT)
-
-    private val messageTitle =
-        composeTestRule.onNodeWithIdentifier(BluetoothScreenTestIdentifier.MESSAGE_TITLE)
-
-    private val vitalTitle =
-        composeTestRule.onNodeWithIdentifier(BluetoothScreenTestIdentifier.VITAL_TITLE)
-
-    fun assertVital(vitalTitle: String) {
-        composeTestRule.onNodeWithIdentifier(BluetoothScreenTestIdentifier.VITALS, vitalTitle)
-            .assertIsDisplayed()
-    }
-
-    fun assertIsDisplayed() {
-        root.assertIsDisplayed()
-    }
-
-    fun assertMessageTitle(text: String) {
-        messageTitle.assertIsDisplayed().assertTextEquals(text)
-    }
-
-    fun assertVitalTitle(text: String) {
-        vitalTitle.assertIsDisplayed().assertTextEquals(text)
-    }
-}
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModel.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModel.kt
deleted file mode 100644
index b7dc67848..000000000
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModel.kt
+++ /dev/null
@@ -1,339 +0,0 @@
-package edu.stanford.bdh.engagehf.bluetooth
-
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
-import android.provider.Settings
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import dagger.hilt.android.qualifiers.ApplicationContext
-import edu.stanford.bdh.engagehf.R
-import edu.stanford.bdh.engagehf.bluetooth.component.AppScreenEvents
-import edu.stanford.bdh.engagehf.bluetooth.data.mapper.BluetoothUiStateMapper
-import edu.stanford.bdh.engagehf.bluetooth.data.models.Action
-import edu.stanford.bdh.engagehf.bluetooth.data.models.UiState
-import edu.stanford.bdh.engagehf.bluetooth.measurements.MeasurementsRepository
-import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEService
-import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEServiceEvent
-import edu.stanford.bdh.engagehf.education.EngageEducationRepository
-import edu.stanford.bdh.engagehf.messages.HealthSummaryService
-import edu.stanford.bdh.engagehf.messages.Message
-import edu.stanford.bdh.engagehf.messages.MessageRepository
-import edu.stanford.bdh.engagehf.messages.MessageType
-import edu.stanford.bdh.engagehf.messages.MessagesAction
-import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
-import edu.stanford.bdh.engagehf.navigation.screens.BottomBarItem
-import edu.stanford.spezi.core.logging.speziLogger
-import edu.stanford.spezi.core.navigation.Navigator
-import edu.stanford.spezi.core.notification.notifier.FirebaseMessage
-import edu.stanford.spezi.core.notification.notifier.FirebaseMessage.Companion.FIREBASE_MESSAGE_KEY
-import edu.stanford.spezi.core.utils.MessageNotifier
-import edu.stanford.spezi.modules.education.EducationNavigationEvent
-import edu.stanford.spezi.modules.education.videos.Video
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-@HiltViewModel
-@Suppress("LongParameterList")
-class BluetoothViewModel @Inject internal constructor(
-    private val bleService: EngageBLEService,
-    private val uiStateMapper: BluetoothUiStateMapper,
-    private val measurementsRepository: MeasurementsRepository,
-    private val messageRepository: MessageRepository,
-    private val appScreenEvents: AppScreenEvents,
-    private val navigator: Navigator,
-    private val engageEducationRepository: EngageEducationRepository,
-    private val healthSummaryService: HealthSummaryService,
-    private val messageNotifier: MessageNotifier,
-    @ApplicationContext private val context: Context,
-) : ViewModel() {
-    private val logger by speziLogger()
-
-    private val _uiState = MutableStateFlow(UiState())
-
-    val uiState = _uiState.asStateFlow()
-
-    init {
-        bleService.start()
-        observeBleService()
-        observeRecords()
-        observeMessages()
-    }
-
-    private fun observeBleService() {
-        viewModelScope.launch {
-            bleService.state.collect { state ->
-                logger.i { "Received EngageBLEService state $state" }
-                _uiState.update { it.copy(bluetooth = uiStateMapper.mapBleServiceState(state)) }
-            }
-        }
-
-        viewModelScope.launch {
-            bleService.events.collect { event ->
-                logger.i { "Received BLEService event $event" }
-                when (event) {
-                    is EngageBLEServiceEvent.MeasurementReceived -> {
-                        appScreenEvents.emit(AppScreenEvents.Event.CloseBottomSheet)
-                        _uiState.update {
-                            val dialog = uiStateMapper.mapMeasurementDialog(event.measurement)
-                            it.copy(measurementDialog = dialog)
-                        }
-                    }
-
-                    is EngageBLEServiceEvent.DeviceDiscovered,
-                    is EngageBLEServiceEvent.DeviceConnected,
-                    is EngageBLEServiceEvent.DevicePaired,
-                    -> {
-                        logger.i { "Ignoring event $event" }
-                    }
-                }
-            }
-        }
-    }
-
-    private fun observeRecords() {
-        viewModelScope.launch {
-            measurementsRepository.observeBloodPressureRecord().collect { result ->
-                _uiState.update { it.copy(bloodPressure = uiStateMapper.mapBloodPressure(result)) }
-            }
-        }
-
-        viewModelScope.launch {
-            measurementsRepository.observeHeartRateRecord().collect { result ->
-                _uiState.update { it.copy(heartRate = uiStateMapper.mapHeartRate(result)) }
-            }
-        }
-
-        viewModelScope.launch {
-            measurementsRepository.observeWeightRecord().collect { result ->
-                _uiState.update { it.copy(weight = uiStateMapper.mapWeight(result)) }
-            }
-        }
-    }
-
-    private fun observeMessages() {
-        viewModelScope.launch {
-            messageRepository.observeUserMessages().collect { messages ->
-                _uiState.update {
-                    it.copy(
-                        messages = messages
-                    )
-                }
-            }
-        }
-    }
-
-    fun onAction(action: Action) {
-        when (action) {
-            is Action.ConfirmMeasurement -> {
-                handleConfirmMeasurementAction(action)
-            }
-
-            is Action.BLEDevicePairing -> {
-                appScreenEvents.emit(AppScreenEvents.Event.BLEDevicePairingBottomSheet)
-            }
-
-            is Action.DismissDialog -> {
-                _uiState.update {
-                    it.copy(measurementDialog = it.measurementDialog.copy(isVisible = false))
-                }
-            }
-
-            is Action.MessageItemClicked -> {
-                viewModelScope.launch {
-                    uiStateMapper.mapMessagesAction(action.message.action)
-                        .onFailure { error ->
-                            logger.e(error) { "Error while mapping action: ${action.message.action}" }
-                        }
-                        .onSuccess { messagesAction ->
-                            messagesAction?.let {
-                                onMessage(
-                                    messagesAction = it,
-                                    messageId = action.message.id,
-                                    isDismissible = action.message.isDismissible,
-                                )
-                            }
-                        }
-                }
-            }
-
-            is Action.ToggleExpand -> {
-                handleToggleExpandAction(action)
-            }
-
-            is Action.PermissionGranted, is Action.Resumed -> {
-                bleService.start()
-            }
-
-            is Action.Settings.AppSettings -> {
-                val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
-                    data = Uri.fromParts("package", context.packageName, null)
-                }
-                launch(intent = intent)
-            }
-
-            is Action.Settings.BluetoothSettings -> {
-                launch(intent = Intent(Settings.ACTION_BLUETOOTH_SETTINGS))
-            }
-
-            is Action.NewIntent -> handleNewIntent(action.intent)
-            is Action.VitalsCardClicked -> appScreenEvents.emit(
-                AppScreenEvents.Event.NavigateToTab(
-                    BottomBarItem.HEART_HEALTH
-                )
-            )
-        }
-    }
-
-    private fun handleNewIntent(intent: Intent) {
-        val firebaseMessage =
-            intent.getParcelableExtra<FirebaseMessage>(FIREBASE_MESSAGE_KEY)
-        firebaseMessage?.messageId?.let { messageId ->
-            viewModelScope.launch {
-                onAction(
-                    Action.MessageItemClicked(
-                        message = Message(
-                            id = messageId, // Is needed to dismiss the message
-                            type = MessageType.Unknown, // We don't need the type, since we directly use the action
-                            title = "", // We don't need the title, since we directly use the action
-                            action = firebaseMessage.action, // We directly use the action
-                            isDismissible = firebaseMessage.isDismissible
-                                ?: false
-                        )
-                    )
-                )
-            }
-        }
-    }
-
-    private fun launch(intent: Intent) {
-        runCatching {
-            context.startActivity(intent.apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) })
-        }.onFailure {
-            logger.e(it) { "Failed to launch intent ${intent.action}" }
-        }
-    }
-
-    private suspend fun onMessage(
-        messagesAction: MessagesAction,
-        messageId: String,
-        isDismissible: Boolean,
-    ) {
-        var shouldDismissMessage = isDismissible
-        when (messagesAction) {
-            is MessagesAction.HealthSummaryAction -> {
-                handleHealthSummaryAction(messageId).onFailure {
-                    shouldDismissMessage = false
-                }
-            }
-
-            is MessagesAction.VideoSectionAction -> {
-                handleVideoSectionAction(messagesAction).onFailure {
-                    shouldDismissMessage = false
-                }
-            }
-
-            is MessagesAction.MeasurementsAction -> {
-                appScreenEvents.emit(AppScreenEvents.Event.DoNewMeasurement)
-            }
-
-            is MessagesAction.MedicationsAction -> {
-                appScreenEvents.emit(
-                    AppScreenEvents.Event.NavigateToTab(
-                        BottomBarItem.MEDICATION
-                    )
-                )
-            }
-
-            is MessagesAction.QuestionnaireAction -> {
-                navigator.navigateTo(
-                    AppNavigationEvent.QuestionnaireScreen(
-                        messagesAction.questionnaireId
-                    )
-                )
-            }
-        }
-        if (shouldDismissMessage) {
-            messageRepository.completeMessage(messageId = messageId)
-        }
-    }
-
-    private suspend fun handleVideoSectionAction(messageAction: MessagesAction.VideoSectionAction): Result<Video> {
-        return engageEducationRepository.getVideoBySectionAndVideoId(
-            messageAction.videoSectionVideo.videoSectionId,
-            messageAction.videoSectionVideo.videoId
-        ).onSuccess { video ->
-            navigator.navigateTo(EducationNavigationEvent.VideoSectionClicked(video))
-        }.onFailure {
-            messageNotifier.notify(
-                messageId = R.string.error_while_handling_message_action
-            )
-            logger.e(it) { "Error while getting video by section and video id" }
-        }
-    }
-
-    private suspend fun handleHealthSummaryAction(messageId: String): Result<Unit> {
-        val setLoading = { loading: Boolean ->
-            _uiState.update {
-                it.copy(
-                    messages = it.messages.map { message ->
-                        if (message.id == messageId) {
-                            message.copy(isLoading = loading)
-                        } else {
-                            message
-                        }
-                    }
-                )
-            }
-        }
-        setLoading(true)
-        val result = healthSummaryService.generateHealthSummaryPdf()
-        setLoading(false)
-        return result
-    }
-
-    public override fun onCleared() {
-        super.onCleared()
-        bleService.stop()
-    }
-
-    private fun handleToggleExpandAction(action: Action.ToggleExpand) {
-        _uiState.update {
-            it.copy(
-                messages = it.messages.map { message ->
-                    if (message.id == action.message.id) {
-                        message.copy(isExpanded = !message.isExpanded)
-                    } else {
-                        message
-                    }
-                }
-            )
-        }
-    }
-
-    private fun handleConfirmMeasurementAction(action: Action.ConfirmMeasurement) {
-        _uiState.update {
-            it.copy(
-                measurementDialog = it.measurementDialog.copy(
-                    isProcessing = true,
-                )
-            )
-        }
-        viewModelScope.launch {
-            measurementsRepository.save(measurement = action.measurement)
-            _uiState.update {
-                it.copy(
-                    measurementDialog = it.measurementDialog.copy(
-                        isVisible = false,
-                        measurement = null,
-                        isProcessing = false,
-                    )
-                )
-            }
-        }
-    }
-}
diff --git a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreen.kt b/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreen.kt
deleted file mode 100644
index e1d2bfae4..000000000
--- a/app/src/main/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/BluetoothScreen.kt
+++ /dev/null
@@ -1,360 +0,0 @@
-package edu.stanford.bdh.engagehf.bluetooth.screen
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Add
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.Lifecycle
-import edu.stanford.bdh.engagehf.R
-import edu.stanford.bdh.engagehf.bluetooth.BluetoothViewModel
-import edu.stanford.bdh.engagehf.bluetooth.component.OperationStatus
-import edu.stanford.bdh.engagehf.bluetooth.component.VitalDisplay
-import edu.stanford.bdh.engagehf.bluetooth.data.models.Action
-import edu.stanford.bdh.engagehf.bluetooth.data.models.BluetoothUiState
-import edu.stanford.bdh.engagehf.bluetooth.data.models.DeviceUiModel
-import edu.stanford.bdh.engagehf.bluetooth.data.models.MeasurementDialogUiState
-import edu.stanford.bdh.engagehf.bluetooth.data.models.UiState
-import edu.stanford.bdh.engagehf.bluetooth.data.models.VitalDisplayData
-import edu.stanford.bdh.engagehf.messages.Message
-import edu.stanford.bdh.engagehf.messages.MessageItem
-import edu.stanford.bdh.engagehf.messages.MessageType
-import edu.stanford.spezi.core.design.component.AsyncTextButton
-import edu.stanford.spezi.core.design.component.DefaultElevatedCard
-import edu.stanford.spezi.core.design.component.LifecycleEvent
-import edu.stanford.spezi.core.design.component.PermissionRequester
-import edu.stanford.spezi.core.design.component.SecondaryText
-import edu.stanford.spezi.core.design.component.StringResource
-import edu.stanford.spezi.core.design.component.VerticalSpacer
-import edu.stanford.spezi.core.design.theme.Colors
-import edu.stanford.spezi.core.design.theme.Spacings
-import edu.stanford.spezi.core.design.theme.SpeziTheme
-import edu.stanford.spezi.core.design.theme.TextStyles
-import edu.stanford.spezi.core.design.theme.ThemePreviews
-import edu.stanford.spezi.core.utils.extensions.testIdentifier
-import java.time.ZonedDateTime
-
-private const val IDLE_DESCRIPTION_WEIGHT = 0.5f
-
-@Composable
-fun BluetoothScreen() {
-    val viewModel = hiltViewModel<BluetoothViewModel>()
-    val uiState by viewModel.uiState.collectAsState()
-    BluetoothScreen(
-        uiState = uiState,
-        onAction = viewModel::onAction
-    )
-}
-
-@Composable
-private fun BluetoothScreen(
-    uiState: UiState,
-    onAction: (Action) -> Unit,
-) {
-    val state = uiState.bluetooth as? BluetoothUiState.Idle
-    state?.let {
-        PermissionRequester(
-            missingPermissions = it.missingPermissions,
-            onGranted = { onAction(Action.PermissionGranted(permission = it)) }
-        )
-    }
-
-    LifecycleEvent { event ->
-        if (event == Lifecycle.Event.ON_RESUME) {
-            onAction(Action.Resumed)
-        }
-    }
-
-    LazyColumn(
-        modifier = Modifier
-            .testIdentifier(BluetoothScreenTestIdentifier.ROOT)
-            .fillMaxSize()
-            .padding(Spacings.medium)
-    ) {
-        item {
-            BluetoothHeaderSection(bluetoothUiState = uiState.bluetooth, onAction = onAction)
-            MeasurementDialog(
-                uiState = uiState.measurementDialog,
-                onAction = onAction,
-            )
-            VerticalSpacer()
-            Text(
-                text = stringResource(R.string.messages),
-                style = TextStyles.titleMedium,
-                modifier = Modifier.testIdentifier(BluetoothScreenTestIdentifier.MESSAGE_TITLE)
-            )
-        }
-        if (uiState.messages.isNotEmpty()) {
-            items(uiState.messages) { message ->
-                MessageItem(
-                    message = message,
-                    onAction = onAction,
-                )
-            }
-        } else {
-            item {
-                Text(
-                    text = "No messages",
-                    style = TextStyles.bodyMedium,
-                    modifier = Modifier.padding(vertical = Spacings.small)
-                )
-            }
-        }
-
-        item {
-            VerticalSpacer()
-            Text(
-                text = stringResource(R.string.vitals),
-                style = TextStyles.titleMedium,
-                modifier = Modifier.testIdentifier(BluetoothScreenTestIdentifier.VITAL_TITLE)
-            )
-            Row(
-                horizontalArrangement = Arrangement.spacedBy(Spacings.medium),
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(top = Spacings.medium)
-            ) {
-                VitalDisplay(
-                    modifier = Modifier
-                        .weight(1f)
-                        .clickable { onAction(Action.VitalsCardClicked) }
-                        .testIdentifier(
-                            identifier = BluetoothScreenTestIdentifier.VITALS,
-                            suffix = uiState.weight.title
-                        ),
-                    vitalDisplayUiState = uiState.weight
-                )
-                VitalDisplay(
-                    modifier = Modifier
-                        .weight(1f)
-                        .clickable { onAction(Action.VitalsCardClicked) }
-                        .testIdentifier(
-                            identifier = BluetoothScreenTestIdentifier.VITALS,
-                            suffix = uiState.heartRate.title
-                        ),
-                    vitalDisplayUiState = uiState.heartRate
-                )
-            }
-            VitalDisplay(
-                modifier = Modifier
-                    .padding(vertical = Spacings.medium)
-                    .clickable { onAction(Action.VitalsCardClicked) }
-                    .testIdentifier(
-                        identifier = BluetoothScreenTestIdentifier.VITALS,
-                        suffix = uiState.bloodPressure.title
-                    ),
-                vitalDisplayUiState = uiState.bloodPressure
-            )
-        }
-    }
-}
-
-@Composable
-private fun BluetoothHeaderSection(
-    bluetoothUiState: BluetoothUiState,
-    onAction: (Action) -> Unit,
-) {
-    Row(
-        modifier = Modifier.padding(bottom = Spacings.small),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Text(
-            text = stringResource(R.string.your_devices_header_title),
-            style = TextStyles.titleMedium,
-            color = Colors.onSurface,
-        )
-        Spacer(modifier = Modifier.weight(1f))
-        if (bluetoothUiState is BluetoothUiState.Ready) {
-            IconButton(onClick = { onAction(Action.BLEDevicePairing) }) {
-                Icon(Icons.Filled.Add, contentDescription = "Pair device")
-            }
-        }
-    }
-
-    when (bluetoothUiState) {
-        is BluetoothUiState.Idle -> {
-            DefaultElevatedCard(modifier = Modifier.fillMaxWidth()) {
-                Row(
-                    modifier = Modifier
-                        .padding(Spacings.small)
-                        .fillMaxWidth(),
-                    verticalAlignment = Alignment.CenterVertically,
-                ) {
-                    SecondaryText(
-                        modifier = Modifier
-                            .padding(Spacings.small)
-                            .weight(IDLE_DESCRIPTION_WEIGHT),
-                        text = stringResource(id = bluetoothUiState.description),
-                    )
-                    bluetoothUiState.settingsAction?.let {
-                        AsyncTextButton(
-                            text = stringResource(id = R.string.home_settings_action),
-                            onClick = { onAction(it) },
-                        )
-                    }
-                }
-            }
-        }
-
-        is BluetoothUiState.Ready -> {
-            Devices(readyState = bluetoothUiState)
-        }
-    }
-}
-
-@Composable
-private fun Devices(readyState: BluetoothUiState.Ready) {
-    readyState.header?.let {
-        SecondaryText(text = stringResource(id = it))
-    }
-
-    Column(verticalArrangement = Arrangement.spacedBy(Spacings.small)) {
-        readyState.devices.forEach { device ->
-            DeviceComposable(device = device)
-        }
-    }
-}
-
-@Composable
-fun DeviceComposable(device: DeviceUiModel) {
-    DefaultElevatedCard(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(bottom = Spacings.small),
-    ) {
-        Column(
-            modifier = Modifier
-                .padding(Spacings.medium),
-            verticalArrangement = Arrangement.spacedBy(Spacings.small)
-        ) {
-            Row(
-                horizontalArrangement = Arrangement.spacedBy(4.dp),
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Box(
-                    modifier = Modifier
-                        .size(10.dp)
-                        .background(
-                            if (device.connected) Color.Green else Color.Red,
-                            shape = CircleShape,
-                        )
-
-                )
-                Text(text = device.name, style = TextStyles.bodyMedium)
-            }
-            SecondaryText(text = device.summary)
-            SecondaryText(text = device.lastSeen.text())
-        }
-    }
-}
-
-enum class BluetoothScreenTestIdentifier {
-    ROOT,
-    MESSAGE_TITLE,
-    VITAL_TITLE,
-    VITALS,
-}
-
-@ThemePreviews
-@Composable
-@Suppress("UnusedPrivateMember")
-private fun BluetoothScreenPreview(@PreviewParameter(BluetoothScreenPreviewProvider::class) uiState: UiState) {
-    val mockOnAction: (Action) -> Unit = {}
-    SpeziTheme {
-        BluetoothScreen(
-            uiState = uiState,
-            onAction = mockOnAction
-        )
-    }
-}
-
-private class BluetoothScreenPreviewProvider : PreviewParameterProvider<UiState> {
-    private val defaultUiState = createUiState()
-    override val values: Sequence<UiState>
-        get() = sequenceOf(
-            defaultUiState,
-            defaultUiState.copy(
-                bluetooth = BluetoothUiState.Ready(
-                    header = R.string.paired_devices_hint_description,
-                    devices = emptyList(),
-                )
-            ),
-            defaultUiState.copy(
-                bluetooth = BluetoothUiState.Idle(
-                    description = R.string.bluetooth_not_enabled_description,
-                    settingsAction = Action.Settings.BluetoothSettings,
-                )
-            ),
-            defaultUiState.copy(
-                bluetooth = BluetoothUiState.Idle(
-                    description = R.string.bluetooth_permissions_not_granted_description,
-                    settingsAction = Action.Settings.BluetoothSettings,
-                )
-            )
-        )
-
-    private fun createUiState() = UiState(
-        bluetooth = BluetoothUiState.Ready(
-            header = null,
-            devices = listOf(
-                DeviceUiModel(
-                    name = "My device",
-                    summary = "Device 1 Summary",
-                    connected = true,
-                    lastSeen = StringResource("Last seen on 12.04.05 12:43"),
-                ),
-            )
-        ),
-        measurementDialog = MeasurementDialogUiState(
-            isVisible = false,
-            formattedWeight = "0.0"
-        ),
-        messages = listOf(
-            Message(
-                id = "1",
-                dueDate = ZonedDateTime.now(),
-                type = MessageType.WeightGain,
-                title = "Weight Gained",
-                description = "You gained weight. Please take action.",
-                action = "New Weight Entry"
-            )
-        ),
-        weight = VitalDisplayData(
-            title = "Weight",
-            value = "0.0",
-            unit = "kg",
-            status = OperationStatus.SUCCESS,
-            date = "01 Jan 2022"
-        ),
-        heartRate = VitalDisplayData(
-            title = "Heart Rate",
-            status = OperationStatus.FAILURE,
-            error = "Cannot retrieve data"
-        ),
-    )
-}
diff --git a/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModelTest.kt b/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModelTest.kt
deleted file mode 100644
index 62aca1012..000000000
--- a/app/src/test/kotlin/edu/stanford/bdh/engagehf/bluetooth/BluetoothViewModelTest.kt
+++ /dev/null
@@ -1,565 +0,0 @@
-package edu.stanford.bdh.engagehf.bluetooth
-
-import android.content.Context
-import androidx.health.connect.client.records.BloodPressureRecord
-import androidx.health.connect.client.records.HeartRateRecord
-import androidx.health.connect.client.records.WeightRecord
-import com.google.common.truth.Truth.assertThat
-import edu.stanford.bdh.engagehf.R
-import edu.stanford.bdh.engagehf.bluetooth.component.AppScreenEvents
-import edu.stanford.bdh.engagehf.bluetooth.data.mapper.BluetoothUiStateMapper
-import edu.stanford.bdh.engagehf.bluetooth.data.models.Action
-import edu.stanford.bdh.engagehf.bluetooth.data.models.BluetoothUiState
-import edu.stanford.bdh.engagehf.bluetooth.data.models.MeasurementDialogUiState
-import edu.stanford.bdh.engagehf.bluetooth.data.models.VitalDisplayData
-import edu.stanford.bdh.engagehf.bluetooth.measurements.MeasurementsRepository
-import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEService
-import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEServiceEvent
-import edu.stanford.bdh.engagehf.bluetooth.service.EngageBLEServiceState
-import edu.stanford.bdh.engagehf.bluetooth.service.Measurement
-import edu.stanford.bdh.engagehf.education.EngageEducationRepository
-import edu.stanford.bdh.engagehf.messages.HealthSummaryService
-import edu.stanford.bdh.engagehf.messages.Message
-import edu.stanford.bdh.engagehf.messages.MessageRepository
-import edu.stanford.bdh.engagehf.messages.MessageType
-import edu.stanford.bdh.engagehf.messages.MessagesAction
-import edu.stanford.bdh.engagehf.messages.VideoSectionVideo
-import edu.stanford.bdh.engagehf.navigation.AppNavigationEvent
-import edu.stanford.bdh.engagehf.navigation.screens.BottomBarItem
-import edu.stanford.spezi.core.navigation.Navigator
-import edu.stanford.spezi.core.testing.CoroutineTestRule
-import edu.stanford.spezi.core.testing.runTestUnconfined
-import edu.stanford.spezi.core.utils.MessageNotifier
-import edu.stanford.spezi.modules.education.EducationNavigationEvent
-import edu.stanford.spezi.modules.education.videos.Video
-import io.mockk.Runs
-import io.mockk.coEvery
-import io.mockk.coVerify
-import io.mockk.every
-import io.mockk.just
-import io.mockk.mockk
-import io.mockk.verify
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.flowOf
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import java.time.ZonedDateTime
-
-class BluetoothViewModelTest {
-    private val bleService: EngageBLEService = mockk()
-    private val uiStateMapper: BluetoothUiStateMapper = mockk()
-    private val measurementsRepository = mockk<MeasurementsRepository>(relaxed = true)
-    private val messageRepository = mockk<MessageRepository>(relaxed = true)
-    private val engageEducationRepository = mockk<EngageEducationRepository>(relaxed = true)
-    private val healthSummaryService = mockk<HealthSummaryService>(relaxed = true)
-    private val context: Context = mockk(relaxed = true)
-    private val messageNotifier = mockk<MessageNotifier>(relaxed = true)
-
-    private val bleServiceState =
-        MutableStateFlow<EngageBLEServiceState>(EngageBLEServiceState.Idle)
-    private val bleServiceEvents = MutableSharedFlow<EngageBLEServiceEvent>()
-    private val readyUiState: BluetoothUiState.Ready = mockk()
-    private val appScreenEvents = mockk<AppScreenEvents>(relaxed = true)
-    private val navigator = mockk<Navigator>(relaxed = true)
-    private val messageAction = "some-action"
-    private val messageId = "some-id"
-    private val message: Message = mockk {
-        every { action } returns messageAction
-        every { id } returns messageId
-        every { isExpanded } returns false
-        every { isDismissible } returns true
-    }
-
-    @get:Rule
-    val coroutineTestRule = CoroutineTestRule()
-
-    private lateinit var bluetoothViewModel: BluetoothViewModel
-
-    @Before
-    fun setup() {
-        with(bleService) {
-            every { state } returns bleServiceState
-            every { events } returns bleServiceEvents
-            every { start() } just Runs
-            every { stop() } just Runs
-        }
-        with(uiStateMapper) {
-            every { mapBleServiceState(any()) } returns readyUiState
-            every { mapWeight(any()) } returns mockk()
-            every { mapHeartRate(any()) } returns mockk()
-            every { mapBloodPressure(any()) } returns mockk()
-            every { mapMeasurementDialog(any()) } returns mockk()
-            every { mapMessagesAction(any()) } returns Result.failure(Throwable())
-        }
-        every { context.packageName } returns "some-package"
-    }
-
-    @Test
-    fun `it should start ble service and start collection on init`() {
-        // when
-        createViewModel()
-
-        // then
-        verify { bleService.start() }
-        verify { bleService.state }
-        verify { bleService.events }
-    }
-
-    @Test
-    fun `it should start record observation on init`() {
-        // when
-        createViewModel()
-
-        // then
-        coVerify { measurementsRepository.observeWeightRecord() }
-        coVerify { measurementsRepository.observeHeartRateRecord() }
-        coVerify { measurementsRepository.observeBloodPressureRecord() }
-    }
-
-    @Test
-    fun `it should start messages observation on init`() {
-        // when
-        createViewModel()
-
-        // then
-        coVerify { messageRepository.observeUserMessages() }
-    }
-
-    @Test
-    fun `it should handle ble service state updates correctly`() = runTestUnconfined {
-        // given
-        val updates = listOf(
-            EngageBLEServiceState.Idle,
-            EngageBLEServiceState.Scanning(emptyList()),
-            EngageBLEServiceState.MissingPermissions(emptyList()),
-            EngageBLEServiceState.BluetoothNotEnabled,
-        )
-
-        createViewModel()
-        updates.forEach { update ->
-            every { uiStateMapper.mapBleServiceState(update) } returns readyUiState
-
-            // when
-            bleServiceState.emit(update)
-
-            // then
-            verify { uiStateMapper.mapBleServiceState(update) }
-            assertBluetoothUiState(state = readyUiState)
-        }
-    }
-
-    @Test
-    fun `it should handle MeasurementReceived events correctly`() =
-        runTestUnconfined {
-            // given
-            val measurement: Measurement = mockk()
-            val event =
-                EngageBLEServiceEvent.MeasurementReceived(
-                    device = mockk(),
-                    measurement = measurement
-                )
-            val measurementDialog: MeasurementDialogUiState = mockk()
-            every { uiStateMapper.mapMeasurementDialog(measurement) } returns measurementDialog
-
-            createViewModel()
-
-            // when
-            bleServiceEvents.emit(event)
-
-            // then
-            verify { appScreenEvents.emit(AppScreenEvents.Event.CloseBottomSheet) }
-            assertBluetoothUiState(state = readyUiState)
-            assertThat(bluetoothViewModel.uiState.value.measurementDialog).isEqualTo(
-                measurementDialog
-            )
-        }
-
-    @Test
-    fun `it should handle weight updates correctly`() = runTestUnconfined {
-        // Given
-        val result: Result<WeightRecord?> = mockk()
-        val uiState: VitalDisplayData = mockk()
-        every { uiStateMapper.mapWeight(result) } returns uiState
-        coEvery {
-            measurementsRepository.observeWeightRecord()
-        } returns flowOf(result)
-
-        // When
-        createViewModel()
-
-        // Then
-        assertThat(bluetoothViewModel.uiState.value.weight).isEqualTo(uiState)
-    }
-
-    @Test
-    fun `it should handle blood pressure updates correctly`() = runTestUnconfined {
-        // Given
-        val result: Result<BloodPressureRecord?> = mockk()
-        val uiState: VitalDisplayData = mockk()
-        every { uiStateMapper.mapBloodPressure(result) } returns uiState
-        coEvery {
-            measurementsRepository.observeBloodPressureRecord()
-        } returns flowOf(result)
-
-        // When
-        createViewModel()
-
-        // Then
-        assertThat(bluetoothViewModel.uiState.value.bloodPressure).isEqualTo(uiState)
-    }
-
-    @Test
-    fun `it should handle heart rate updates correctly`() = runTestUnconfined {
-        // Given
-        val result: Result<HeartRateRecord?> = mockk()
-        val uiState: VitalDisplayData = mockk()
-        every { uiStateMapper.mapHeartRate(result) } returns uiState
-        coEvery {
-            measurementsRepository.observeHeartRateRecord()
-        } returns flowOf(result)
-
-        // When
-        createViewModel()
-
-        // Then
-        assertThat(bluetoothViewModel.uiState.value.heartRate).isEqualTo(uiState)
-    }
-
-    @Test
-    fun `it should handle message updates correctly`() {
-        // given
-        val messages = List(10) { mockk<Message>() }
-        coEvery { messageRepository.observeUserMessages() } returns flowOf(messages)
-
-        // when
-        createViewModel()
-
-        // then
-        assertThat(bluetoothViewModel.uiState.value.messages).isEqualTo(messages)
-    }
-
-    @Test
-    fun `it should stop service on cleared`() {
-        // given
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onCleared()
-
-        // then
-        verify { bleService.stop() }
-    }
-
-    @Test
-    fun `it should handle confirm measurement action correctly`() {
-        val measurement: Measurement.Weight = mockk()
-        val action = Action.ConfirmMeasurement(measurement = measurement)
-        coEvery { measurementsRepository.save(measurement = measurement) } just Runs
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action)
-
-        coVerify { measurementsRepository.save(measurement = measurement) }
-        val measurementDialog = bluetoothViewModel.uiState.value.measurementDialog
-        with(measurementDialog) {
-            assertThat(isVisible).isFalse()
-            assertThat(this.measurement).isNull()
-            assertThat(this.isProcessing).isFalse()
-        }
-    }
-
-    @Test
-    fun `it should handle dismiss dialog correctly`() {
-        // given
-        val action = Action.DismissDialog
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action)
-
-        // then
-        assertThat(bluetoothViewModel.uiState.value.measurementDialog.isVisible).isFalse()
-    }
-
-    @Test
-    fun `it should do nothing on MessageItemClicked with error result`() {
-        // given
-        val action = Action.MessageItemClicked(message = message)
-        every { uiStateMapper.mapMessagesAction(messageAction) } returns Result.failure(Throwable())
-        createViewModel()
-        val initialState = bluetoothViewModel.uiState.value
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        assertThat(bluetoothViewModel.uiState.value).isEqualTo(initialState)
-    }
-
-    @Test
-    fun `it should complete message on non error result`() {
-        // given
-        val action = Action.MessageItemClicked(message = message)
-        every {
-            uiStateMapper.mapMessagesAction(messageAction)
-        } returns Result.success(MessagesAction.HealthSummaryAction)
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        coVerify { messageRepository.completeMessage(messageId = messageId) }
-    }
-
-    @Test
-    fun `it should not dismiss health summary message on error result`() {
-        // given
-        val action = Action.MessageItemClicked(message = message)
-        every {
-            uiStateMapper.mapMessagesAction(messageAction)
-        } returns Result.success(MessagesAction.HealthSummaryAction)
-        coEvery {
-            healthSummaryService.generateHealthSummaryPdf()
-        } returns Result.failure(Throwable())
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        coVerify(
-            exactly = 0
-        ) { messageRepository.completeMessage(messageId = messageId) }
-    }
-
-    @Test
-    fun `it should not dismiss video section message on error result`() {
-        // given
-        val action = Action.MessageItemClicked(message = message)
-        every {
-            uiStateMapper.mapMessagesAction(messageAction)
-        } returns Result.success(MessagesAction.VideoSectionAction(VideoSectionVideo("1", "2")))
-        coEvery {
-            engageEducationRepository.getVideoBySectionAndVideoId(any(), any())
-        } returns Result.failure(Throwable())
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        coVerify(
-            exactly = 0
-        ) { messageRepository.completeMessage(messageId = messageId) }
-        coVerify {
-            messageNotifier.notify(
-                messageId = R.string.error_while_handling_message_action
-            )
-        }
-    }
-
-    @Test
-    fun `it should handle MeasurementsAction correctly`() {
-        // given
-        val action = Action.MessageItemClicked(message = message)
-        every {
-            uiStateMapper.mapMessagesAction(messageAction)
-        } returns Result.success(MessagesAction.MeasurementsAction)
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        verify { appScreenEvents.emit(AppScreenEvents.Event.DoNewMeasurement) }
-    }
-
-    @Test
-    fun `it should handle BLEDevicePairing correctly`() {
-        // given
-        val action = Action.BLEDevicePairing
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        verify { appScreenEvents.emit(AppScreenEvents.Event.BLEDevicePairingBottomSheet) }
-    }
-
-    @Test
-    fun `it should navigate to questionnaire screen on QuestionnaireAction`() {
-        // given
-        val questionnaireId = "1"
-        val action = Action.MessageItemClicked(message = message)
-        every {
-            uiStateMapper.mapMessagesAction(messageAction)
-        } returns Result.success(MessagesAction.QuestionnaireAction(questionnaireId))
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        verify { navigator.navigateTo(AppNavigationEvent.QuestionnaireScreen(questionnaireId)) }
-    }
-
-    @Test
-    fun `it should handle video section action correctly`() = runTestUnconfined {
-        val videoSectionId = "some-video-section-id"
-        val videoId = "some-video-id"
-        val videoSection: VideoSectionVideo = mockk {
-            every { this@mockk.videoSectionId } returns videoSectionId
-            every { this@mockk.videoId } returns videoId
-        }
-        val video: Video = mockk()
-        val videoSectionAction = MessagesAction.VideoSectionAction(videoSectionVideo = videoSection)
-        every { uiStateMapper.mapMessagesAction(messageAction) } returns Result.success(
-            videoSectionAction
-        )
-        coEvery {
-            engageEducationRepository.getVideoBySectionAndVideoId(videoSectionId, videoId)
-        } returns Result.success(video)
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(Action.MessageItemClicked(message = message))
-
-        // then
-        coVerify { engageEducationRepository.getVideoBySectionAndVideoId(videoSectionId, videoId) }
-        verify { navigator.navigateTo(EducationNavigationEvent.VideoSectionClicked(video)) }
-    }
-
-    @Test
-    fun `it should handle health summary action correctly`() = runTestUnconfined {
-        // given
-        val action = Action.MessageItemClicked(message = message)
-        every {
-            uiStateMapper.mapMessagesAction(messageAction)
-        } returns Result.success(MessagesAction.HealthSummaryAction)
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        coVerify { healthSummaryService.generateHealthSummaryPdf() }
-    }
-
-    @Test
-    fun `it should handle medication change action correctly`() {
-        // given
-        val action = Action.MessageItemClicked(message = message)
-        every {
-            uiStateMapper.mapMessagesAction(messageAction)
-        } returns Result.success(MessagesAction.MedicationsAction)
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action = action)
-
-        // then
-        verify { appScreenEvents.emit(AppScreenEvents.Event.NavigateToTab(BottomBarItem.MEDICATION)) }
-    }
-
-    @Test
-    fun `it should handle toggle expand action correctly`() {
-        // given
-        val isExpanded = false
-        val message = Message(
-            id = messageId,
-            dueDate = ZonedDateTime.now(),
-            description = "",
-            title = "",
-            action = "",
-            type = MessageType.MedicationChange,
-            isExpanded = isExpanded,
-        )
-        every { this@BluetoothViewModelTest.message.id } returns "new-id"
-
-        coEvery { messageRepository.observeUserMessages() } returns flowOf(
-            listOf(
-                message,
-                this.message
-            )
-        )
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(Action.ToggleExpand(message))
-
-        // then
-        assertThat(
-            bluetoothViewModel.uiState.value.messages.first().isExpanded
-        ).isEqualTo(isExpanded.not())
-    }
-
-    @Test
-    fun `it should handle permission granted action correctly`() = runTestUnconfined {
-        // given
-        val permissions = listOf("permission1")
-        val state = EngageBLEServiceState.MissingPermissions(permissions)
-        createViewModel()
-        bleServiceState.emit(state)
-
-        // when
-        bluetoothViewModel.onAction(Action.PermissionGranted(permission = permissions.first()))
-
-        // then
-        verify(exactly = 2) { bleService.start() }
-    }
-
-    @Test
-    fun `it should handle resumed action correctly`() = runTestUnconfined {
-        // given
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(Action.Resumed)
-
-        // then
-        verify(exactly = 2) { bleService.start() }
-    }
-
-    @Test
-    fun `it should handle VitalsCardClicked action correctly`() {
-        // given
-        val action = Action.VitalsCardClicked
-        createViewModel()
-
-        // when
-        bluetoothViewModel.onAction(action)
-
-        // then
-        verify {
-            appScreenEvents.emit(
-                AppScreenEvents.Event.NavigateToTab(
-                    BottomBarItem.HEART_HEALTH
-                )
-            )
-        }
-    }
-
-    private fun assertBluetoothUiState(state: BluetoothUiState) {
-        assertThat(bluetoothViewModel.uiState.value.bluetooth).isEqualTo(state)
-    }
-
-    private fun createViewModel() {
-        bluetoothViewModel = BluetoothViewModel(
-            bleService = bleService,
-            uiStateMapper = uiStateMapper,
-            measurementsRepository = measurementsRepository,
-            messageRepository = messageRepository,
-            appScreenEvents = appScreenEvents,
-            navigator = navigator,
-            engageEducationRepository = engageEducationRepository,
-            healthSummaryService = healthSummaryService,
-            context = context,
-            messageNotifier = messageNotifier
-        )
-    }
-}

From 8d70e0196d79baaee8a663de7edbe753dadb0db7 Mon Sep 17 00:00:00 2001
From: Eldi Cano <eldi.cano@hotmail.com>
Date: Mon, 9 Dec 2024 00:01:32 +0100
Subject: [PATCH 3/3] replace notification permissions for app integration
 tests to satisfy running in version 31

---
 .../bluetooth/screen/HomeScreenTest.kt        |  1 -
 .../stanford/bdh/engagehf/di/AppTestModule.kt | 28 +++++++++++++++++++
 .../notification/di/NotificationModule.kt     |  2 +-
 3 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/di/AppTestModule.kt

diff --git a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt
index 678df08c3..8a5f47348 100644
--- a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt
+++ b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/bluetooth/screen/HomeScreenTest.kt
@@ -24,7 +24,6 @@ class HomeScreenTest {
 
     @get:Rule
     val runtimePermissionRule: GrantPermissionRule = GrantPermissionRule.grant(
-        Manifest.permission.POST_NOTIFICATIONS,
         Manifest.permission.BLUETOOTH_CONNECT,
         Manifest.permission.BLUETOOTH_SCAN,
         Manifest.permission.ACCESS_COARSE_LOCATION,
diff --git a/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/di/AppTestModule.kt b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/di/AppTestModule.kt
new file mode 100644
index 000000000..47726e7e4
--- /dev/null
+++ b/app/src/androidTest/kotlin/edu/stanford/bdh/engagehf/di/AppTestModule.kt
@@ -0,0 +1,28 @@
+package edu.stanford.bdh.engagehf.di
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.components.SingletonComponent
+import dagger.hilt.testing.TestInstallIn
+import edu.stanford.spezi.core.notification.NotificationPermissions
+import edu.stanford.spezi.core.notification.di.NotificationModule
+
+@Module
+@TestInstallIn(
+    components = [SingletonComponent::class],
+    replaces = [NotificationModule.Bindings::class]
+)
+class AppTestModule {
+
+    /**
+     * Since our instrumented tests run for android versions 31 and 34, we can't use grant rule
+     * to grant notification permission by default as it would fail for version 31. Hence, we simply
+     * replace the dependency to return empty permissions
+     */
+    @Provides
+    fun provideNotificationPermissions(): NotificationPermissions {
+        return object : NotificationPermissions {
+            override fun getRequiredPermissions(): Set<String> = emptySet()
+        }
+    }
+}
diff --git a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt
index 8969848db..77838a789 100644
--- a/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt
+++ b/core/notification/src/main/kotlin/edu/stanford/spezi/core/notification/di/NotificationModule.kt
@@ -19,7 +19,7 @@ class NotificationModule {
 
     @Module
     @InstallIn(SingletonComponent::class)
-    internal abstract class Bindings {
+    abstract class Bindings {
         @Binds
         internal abstract fun bindNotificationPermissions(
             impl: NotificationPermissionsImpl,