Heartbeat Study survey

app/src/main/kotlin/edu/stanford/bdh/engagehf/health/components/TimePicker.kt

@@ -19,6 +19,7 @@
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import edu.stanford.bdh.engagehf.R
+import edu.stanford.spezi.core.design.component.DatePickerDialog
 import edu.stanford.spezi.core.design.theme.Spacings
 import edu.stanford.spezi.core.design.theme.TextStyles
 import java.time.Instant
@@ -53,7 +54,7 @@
     }
 
     if (showDatePicker) {
-        edu.stanford.spezi.module.account.register.DatePickerDialog(
+        DatePickerDialog(
             onDateSelected = { date ->
                 updateDate(date)
             },

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/register/DatePickerDialog.kt → core/design/src/main/kotlin/edu/stanford/spezi/core/design/component/DatePickerDialog.kt

@@ -1,4 +1,4 @@
-package edu.stanford.spezi.module.account.register
+package edu.stanford.spezi.core.design.component
 
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.material3.Button
@@ -11,18 +11,19 @@
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
-import edu.stanford.spezi.module.account.R
+import edu.stanford.spezi.core.design.R
 import java.time.Instant
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun DatePickerDialog(
     onDateSelected: (Instant) -> Unit,
+    selectableDatesPredicate: (Instant) -> Boolean = { it <= Instant.now() },
     onDismiss: () -> Unit,
 ) {
     val datePickerState = rememberDatePickerState(selectableDates = object : SelectableDates {
         override fun isSelectableDate(utcTimeMillis: Long): Boolean {
-            return utcTimeMillis <= System.currentTimeMillis()
+            return selectableDatesPredicate(Instant.ofEpochMilli(utcTimeMillis))
         }
     })
 

core/design/src/main/kotlin/edu/stanford/spezi/core/design/component/FocusEvent.kt

@@ -0,0 +1,23 @@
+package edu.stanford.spezi.core.design.component
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.relocation.BringIntoViewRequester
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import androidx.compose.ui.focus.onFocusEvent
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalFoundationApi::class)
+fun Modifier.bringIntoViewOnFocusedEvent() = this then Modifier.composed {
+    val bringIntoViewRequester = remember { BringIntoViewRequester() }
+    val coroutineScope = rememberCoroutineScope()
+    onFocusEvent { focusState ->
+        if (focusState.isFocused) {
+            coroutineScope.launch {
+                bringIntoViewRequester.bringIntoView()
+            }
+        }
+    }
+}

core/design/src/main/kotlin/edu/stanford/spezi/core/design/theme/Colors.kt

@@ -71,6 +71,36 @@
         @Composable
         @ReadOnlyComposable
         get() = Color.Transparent
+
+    val white
+        @Composable
+        @ReadOnlyComposable
+        get() = White
+
+    val black
+        @Composable
+        @ReadOnlyComposable
+        get() = Black
+
+    val black20
+        @Composable
+        @ReadOnlyComposable
+        get() = Black20
+
+    val black40
+        @Composable
+        @ReadOnlyComposable
+        get() = Black40
+
+    val black80
+        @Composable
+        @ReadOnlyComposable
+        get() = Black80
+
+    val cardinalRedLight
+        @Composable
+        @ReadOnlyComposable
+        get() = CardinalRedLight
 }
 
 @Suppress("unused")

core/design/src/main/res/values/strings.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="ok">OK</string>
+    <string name="cancel">Cancel</string>
+</resources>

heartbeat-app/src/main/kotlin/edu/stanford/bdh/heartbeat/app/MainApplication.kt

@@ -2,6 +2,14 @@ package edu.stanford.bdh.heartbeat.app
 
 import android.app.Application
 import dagger.hilt.android.HiltAndroidApp
+import edu.stanford.spezi.core.logging.SpeziLogger
 
 @HiltAndroidApp
-class MainApplication : Application()
+class MainApplication : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+
+        SpeziLogger.setLoggingEnabled(enabled = BuildConfig.DEBUG)
+    }
+}

heartbeat-app/src/main/kotlin/edu/stanford/bdh/heartbeat/app/account/AccountManager.kt

@@ -10,20 +10,63 @@ import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.tasks.await
 import javax.inject.Inject
+import javax.inject.Singleton
 
 data class AccountInfo(
     val email: String,
     val name: String?,
     val isEmailVerified: Boolean,
 )
 
-class AccountManager @Inject internal constructor(
+interface AccountManager {
+    fun observeAccountInfo(): Flow<AccountInfo?>
+
+    suspend fun reloadAccountInfo(): Result<AccountInfo?>
+
+    suspend fun getToken(): Result<String>
+
+    suspend fun deleteCurrentUser(): Result<Unit>
+
+    suspend fun signOut(): Result<Unit>
+
+    suspend fun signUpWithEmailAndPassword(
+        email: String,
+        password: String,
+    ): Result<Unit>
+
+    suspend fun sendForgotPasswordEmail(email: String): Result<Unit>
+
+    suspend fun sendVerificationEmail(): Result<Unit>
+
+    suspend fun signIn(email: String, password: String): Result<Unit>
+}
+
+@Singleton
+class AccountManagerImpl @Inject internal constructor(
     private val firebaseAuth: FirebaseAuth,
     @Dispatching.IO private val coroutineScope: CoroutineScope,
-) {
+) : AccountManager {
     private val logger by speziLogger()
+    private var userToken: String? = null
+
+    init {
+        observeUserTokenChanges()
+    }
 
-    fun observeAccountInfo(): Flow<AccountInfo?> = callbackFlow {
+    private fun observeUserTokenChanges() {
+        firebaseAuth.addIdTokenListener { auth: FirebaseAuth ->
+            val currentUser = auth.currentUser
+            if (currentUser == null) {
+                userToken = null
+            } else {
+                auth.currentUser?.getIdToken(false)?.addOnSuccessListener { result ->
+                    userToken = result.token
+                }
+            }
+        }
+    }
+
+    override fun observeAccountInfo(): Flow<AccountInfo?> = callbackFlow {
         val authStateListener = FirebaseAuth.AuthStateListener { _ ->
             coroutineScope.launch { send(getAccountInfo()) }
         }
@@ -35,44 +78,46 @@ class AccountManager @Inject internal constructor(
         }
     }
 
-    fun getAccountInfo(): AccountInfo? {
-        return firebaseAuth.currentUser?.let { user ->
-            AccountInfo(
-                email = user.email ?: "",
-                name = user.displayName?.takeIf { it.isNotBlank() },
-                isEmailVerified = user.isEmailVerified
-            )
-        }
+    override suspend fun reloadAccountInfo(): Result<AccountInfo?> = runCatching {
+        firebaseAuth.currentUser?.reload()?.await()
+        userToken = getToken(forceRefresh = true).getOrNull()
+        getAccountInfo()
     }
 
-    suspend fun getToken(forceRefresh: Boolean = false): Result<String> {
+    override suspend fun getToken(): Result<String> {
+        return getToken(forceRefresh = false)
+    }
+
+    private suspend fun getToken(forceRefresh: Boolean): Result<String> {
+        val currentReceivedToken = userToken.takeIf { forceRefresh.not() }
+        if (currentReceivedToken != null) return Result.success(currentReceivedToken)
         return runCatching {
-            val user = firebaseAuth.currentUser ?: error("Does not have a current user to get a token for")
-            val idToken = user.getIdToken(forceRefresh).await()
-            return@runCatching idToken.token ?: error("Id token refresh didn't include a token")
+            val user =
+                firebaseAuth.currentUser ?: error("Does not have a current user to get a token for")
+            val token = user.getIdToken(forceRefresh).await().token ?: error("Id token refresh didn't include a token")
+            userToken = token
+            token
         }.onFailure {
-            logger.e { "Failed to force refresh token" }
+            logger.e(it) { "Failed to retrieve token" }
         }
     }
 
-    suspend fun deleteCurrentUser(): Result<Unit> {
+    override suspend fun deleteCurrentUser(): Result<Unit> {
         return runCatching {
-            firebaseAuth.currentUser?.delete()?.await()
-            return@runCatching
+            firebaseAuth.currentUser?.delete()?.await() ?: error("User not available")
+            Unit
         }.onFailure {
             logger.e { "Failed to delete user." }
         }
     }
 
-    fun signOut() {
-        runCatching {
-            firebaseAuth.signOut()
-        }.onFailure {
-            logger.e { "Failed to sign out" }
-        }
+    override suspend fun signOut(): Result<Unit> = runCatching {
+        firebaseAuth.signOut()
+    }.onFailure {
+        logger.e { "Failed to sign out" }
     }
 
-    suspend fun signUpWithEmailAndPassword(
+    override suspend fun signUpWithEmailAndPassword(
         email: String,
         password: String,
     ): Result<Unit> {
@@ -84,15 +129,15 @@ class AccountManager @Inject internal constructor(
         }
     }
 
-    suspend fun sendForgotPasswordEmail(email: String): Result<Unit> {
+    override suspend fun sendForgotPasswordEmail(email: String): Result<Unit> {
         return runCatching {
             firebaseAuth.sendPasswordResetEmail(email).await().let { }
         }.onFailure { e ->
             logger.e { "Error sending forgot password email: ${e.message}" }
         }
     }
 
-    suspend fun sendVerificationEmail(): Result<Unit> {
+    override suspend fun sendVerificationEmail(): Result<Unit> {
         return runCatching {
             firebaseAuth.currentUser?.sendEmailVerification()?.await()
             return@runCatching
@@ -101,12 +146,22 @@ class AccountManager @Inject internal constructor(
         }
     }
 
-    suspend fun signIn(email: String, password: String): Result<Unit> {
+    override suspend fun signIn(email: String, password: String): Result<Unit> {
         return runCatching {
             val result = firebaseAuth.signInWithEmailAndPassword(email, password).await()
             if (result.user == null) error("Failed to sign in, returned null user")
         }.onFailure { e ->
             logger.e { "Error signing in with email and password: ${e.message}" }
         }
     }
+
+    private fun getAccountInfo(): AccountInfo? {
+        return firebaseAuth.currentUser?.let { user ->
+            AccountInfo(
+                email = user.email ?: "",
+                name = user.displayName?.takeIf { it.isNotBlank() },
+                isEmailVerified = user.isEmailVerified
+            )
+        }
+    }
 }

heartbeat-app/src/main/kotlin/edu/stanford/bdh/heartbeat/app/account/LoginPage.kt

@@ -1,8 +1,10 @@
 package edu.stanford.bdh.heartbeat.app.account
 
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
 import androidx.compose.material3.Button
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
@@ -13,8 +15,9 @@ import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.input.PasswordVisualTransformation
-import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
+import edu.stanford.spezi.core.design.theme.Spacings
+import edu.stanford.spezi.core.design.theme.TextStyles
 
 @Composable
 fun LoginPage() {
@@ -40,7 +43,22 @@ private fun LoginPage(
         }
     }
 
-    Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
+    Column(modifier = Modifier.fillMaxWidth().padding(Spacings.medium)) {
+        Text(
+            "Your Account",
+            style = TextStyles.headlineLarge,
+            modifier = Modifier.align(Alignment.CenterHorizontally)
+        )
+
+        Spacer(modifier = Modifier.size(Spacings.medium))
+
+        Text(
+            "You may login to your existing account. Or create a new one if you don't have one already.",
+            modifier = Modifier.align(Alignment.CenterHorizontally),
+        )
+
+        Spacer(modifier = Modifier.size(Spacings.medium))
+
         OutlinedTextField(
             modifier = Modifier.fillMaxWidth(),
             value = uiState.username,

heartbeat-app/src/main/kotlin/edu/stanford/bdh/heartbeat/app/account/RegisterViewModel.kt

@@ -47,6 +47,7 @@ class RegisterViewModel @Inject constructor(
                                     isLoading = false,
                                 )
                             }
+                            accountManager.sendVerificationEmail().getOrNull()
                         }
                         .onFailure { error ->
                             _uiState.update {