Observe authenticated user to update profile

Author: jeffdgr8

src/app/src/main/java/com/couchbase/learningpath/services/AuthenticationService.kt

@@ -1,8 +1,10 @@
 package com.couchbase.learningpath.services
 
+import androidx.lifecycle.LiveData
 import com.couchbase.learningpath.models.User
 
 interface AuthenticationService {
+    val currentUser: LiveData<User?>
     fun getCurrentUser() : User
     fun authenticatedUser(username: String, password: String) : Boolean
     fun logout()

src/app/src/main/java/com/couchbase/learningpath/services/MockAuthenticationService.kt

@@ -1,33 +1,37 @@
 package com.couchbase.learningpath.services
 
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
 import com.couchbase.learningpath.models.User
 
 class MockAuthenticationService : AuthenticationService {
 
-    private var _user: User? = null
+    private var _user = MutableLiveData<User?>()
     private var _mockUsers = HashMap<String, User>()
 
+    override val currentUser: LiveData<User?> = _user
+
     override fun getCurrentUser(): User {
-        return _user?: User("", "", "")
+        return _user.value ?: User("", "", "")
     }
 
     override fun authenticatedUser(username: String, password: String): Boolean {
         return if (_mockUsers.containsKey(username)){
             val user = _mockUsers[username]
             if (user?.password == password){
-                _user = user
+                _user.value = user
                 true
             } else {
                 false
             }
         } else {
-            _user = User(username = username, password = password, team = "team2")
+            _user.value = User(username = username, password = password, team = "team2")
             return true
         }
     }
 
     override fun logout() {
-        _user = null
+        _user.value = null
     }
 
     init {

src/app/src/main/java/com/couchbase/learningpath/ui/MainActivity.kt

@@ -6,6 +6,7 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.compose.material.*
 import androidx.compose.runtime.*
+import androidx.compose.runtime.livedata.observeAsState
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalLifecycleOwner
 import androidx.compose.ui.res.stringResource
@@ -24,18 +25,22 @@ import org.koin.androidx.compose.getViewModel
 import com.couchbase.learningpath.InventoryNavGraph
 import com.couchbase.learningpath.MainDestinations
 import com.couchbase.learningpath.R
-import com.couchbase.learningpath.data.KeyValueRepository
 import com.couchbase.learningpath.services.AuthenticationService
 import com.couchbase.learningpath.services.ReplicatorService
 import com.couchbase.learningpath.ui.components.Drawer
 import com.couchbase.learningpath.ui.profile.UserProfileViewModel
 import com.couchbase.learningpath.ui.theme.LearningPathTheme
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import org.koin.androidx.viewmodel.ext.android.viewModel
 
 @kotlinx.serialization.ExperimentalSerializationApi
 @ExperimentalMaterialApi
 @ExperimentalCoroutinesApi
 class MainActivity : ComponentActivity() {
+
+    //used for drawing profile in drawer
+    private val profileViewModel: UserProfileViewModel by viewModel()
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
@@ -45,18 +50,13 @@ class MainActivity : ComponentActivity() {
                 val navController = rememberNavController()
                 val scaffoldState = rememberScaffoldState()
                 val authService: AuthenticationService by inject()
-                val userProfileRepository: KeyValueRepository by inject()
                 val replicatorService : ReplicatorService by inject()
                 val menuResource = stringResource(id = R.string.btnMenu)
                 val mainViewModel = getViewModel<MainViewModel>()
 
-                //used for drawing profile in drawer
-                var profileViewModel: UserProfileViewModel? = null
-
                 fun logout() {
                     replicatorService.stopReplication()
                     replicatorService.updateAuthentication(isReset = true)
-                    profileViewModel = null
                     authService.logout()
                 }
                 //we need a drawer overflow menu on multiple screens
@@ -65,14 +65,6 @@ class MainActivity : ComponentActivity() {
                 val drawerState = rememberDrawerState(DrawerValue.Closed)
                 val openDrawer = {
                     scope.launch {
-                        if (profileViewModel == null) {
-                            profileViewModel = UserProfileViewModel(
-                                repository = userProfileRepository,
-                                authService = authService,
-                                mainViewModel.context)
-                        } else {
-                            profileViewModel?.updateUserProfileInfo()
-                        }
                         drawerState.open()
                     }
                 }
@@ -83,17 +75,24 @@ class MainActivity : ComponentActivity() {
                             scaffoldState.snackbarHostState
                         }) {
                         ModalDrawer(
-                            modifier = Modifier.semantics { contentDescription = menuResource },
+                            modifier = Modifier
+                                .semantics { contentDescription = menuResource },
                             drawerState = drawerState,
                             gesturesEnabled = drawerState.isOpen,
                             drawerContent = {
+                                val givenName by profileViewModel.givenName.observeAsState()
+                                val surname by profileViewModel.surname.observeAsState()
+                                val emailAddress by profileViewModel.emailAddress.observeAsState()
+                                val team by profileViewModel.team.observeAsState()
+                                val profilePic by profileViewModel.profilePic.observeAsState()
+
                                 Drawer(
                                     modifier = Modifier.semantics { contentDescription = "{$menuResource}1" },
-                                    firstName = profileViewModel?.givenName?.value,
-                                    lastName =  profileViewModel?.surname?.value,
-                                    email = profileViewModel?.emailAddress?.value,
-                                    team = profileViewModel?.team?.value,
-                                    profilePicture = profileViewModel?.profilePic?.value,
+                                    firstName = givenName,
+                                    lastName =  surname,
+                                    email = emailAddress,
+                                    team = team,
+                                    profilePicture = profilePic,
                                     onClicked = { route ->
                                         scope.launch {
                                             drawerState.close()

src/app/src/main/java/com/couchbase/learningpath/ui/profile/UserProfileView.kt

@@ -18,6 +18,7 @@ import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Menu
 import androidx.compose.runtime.*
+import androidx.compose.runtime.livedata.observeAsState
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -42,7 +43,15 @@ import com.couchbase.learningpath.ui.theme.Red500
 fun UserProfileView(
     openDrawer: () -> Unit,
     scaffoldState: ScaffoldState = rememberScaffoldState(),
-    viewModel: UserProfileViewModel) {
+    viewModel: UserProfileViewModel
+) {
+    val givenName by viewModel.givenName.observeAsState("")
+    val surname by viewModel.surname.observeAsState("")
+    val jobTitle by viewModel.jobTitle.observeAsState("")
+    val profilePic by viewModel.profilePic.observeAsState()
+    val emailAddress by viewModel.emailAddress.observeAsState("")
+    val team by viewModel.team.observeAsState("")
+    val toastMessage by viewModel.toastMessage.observeAsState()
 
     LearningPathTheme {
         // A surface container using the 'background' color from the theme
@@ -59,17 +68,17 @@ fun UserProfileView(
             )
             {
                 UserProfileFormWidget(
-                    viewModel.givenName.value,
+                    givenName,
                     viewModel.onGivenNameChanged,
-                    viewModel.surname.value,
+                    surname,
                     viewModel.onSurnameChanged,
-                    viewModel.jobTitle.value,
+                    jobTitle,
                     viewModel.onJobTitleChanged,
-                    viewModel.profilePic.value,
+                    profilePic,
                     viewModel.onProfilePicChanged,
-                    viewModel.emailAddress.value,
-                    viewModel.team.value,
-                    viewModel.toastMessage.value,
+                    emailAddress,
+                    team,
+                    toastMessage,
                     viewModel.onSave,
                     viewModel.clearToastMessage
                 )

src/app/src/main/java/com/couchbase/learningpath/ui/profile/UserProfileViewModel.kt

@@ -4,8 +4,10 @@ import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.drawable.Drawable
-import androidx.compose.runtime.mutableStateOf
 import androidx.core.graphics.drawable.toBitmap
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.Observer
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.couchbase.lite.Blob
@@ -22,76 +24,90 @@ import com.couchbase.learningpath.models.User
 
 class UserProfileViewModel(
     private val repository: KeyValueRepository,
-    authService: AuthenticationService,
+    private val authService: AuthenticationService,
     context: WeakReference<Context>
 ) : ViewModel() {
 
-    private var currentUser: User? = null
-
     //track our fields in our composable
-    var givenName = mutableStateOf("")
-    var surname = mutableStateOf("")
-    var jobTitle = mutableStateOf("")
-    var emailAddress = mutableStateOf("")
-    var team = mutableStateOf("")
-    var toastMessage = mutableStateOf("")
-    var profilePic = mutableStateOf<Bitmap?>(null)
+    private val _givenName = MutableLiveData("")
+    val givenName: LiveData<String> = _givenName
 
-    init {
-        currentUser = authService.getCurrentUser()
-        updateUserProfileInfo()
-        profilePic.value = BitmapFactory.decodeResource(context.get()?.resources, R.drawable.profile_placeholder)
-    }
+    private val _surname = MutableLiveData("")
+    val surname: LiveData<String> = _surname
+
+    private val _jobTitle = MutableLiveData("")
+    val jobTitle: LiveData<String> = _jobTitle
+
+    private val _emailAddress = MutableLiveData("")
+    val emailAddress: LiveData<String> = _emailAddress
+
+    private val _team = MutableLiveData("")
+    val team: LiveData<String> = _team
+
+    private val _toastMessage = MutableLiveData("")
+    val toastMessage: LiveData<String> = _toastMessage
 
-    fun updateUserProfileInfo() {
+    private val _profilePic = MutableLiveData<Bitmap?>(null)
+    val profilePic: LiveData<Bitmap?> = _profilePic
+
+    private val userObserver: (User?) -> Unit = { currentUser ->
         currentUser?.let { authenticatedUser ->
-            emailAddress.value = authenticatedUser.username
-            team.value = authenticatedUser.team
+            _emailAddress.value = authenticatedUser.username
+            _team.value = authenticatedUser.team
             //when getting information from the database need to make sure
             //to use Dispatchers.IO so that Disk I/O work isn't done on the main thread
             viewModelScope.launch(Dispatchers.IO) {
                 val userProfile = repository.get(authenticatedUser.username)
                 //make sure when we update the UI we update on the Main Thread
                 withContext(Dispatchers.Main) {
                     userProfile["givenName"]?.let {
-                        givenName.value = userProfile["givenName"] as String
+                        _givenName.value = userProfile["givenName"] as String
                     }
                     userProfile["surname"]?.let {
-                        surname.value = userProfile["surname"] as String
+                        _surname.value = userProfile["surname"] as String
                     }
                     userProfile["jobTitle"]?.let {
-                        jobTitle.value = userProfile["jobTitle"] as String
+                        _jobTitle.value = userProfile["jobTitle"] as String
                     }
                     userProfile["imageData"]?.let {
                         val blob = userProfile["imageData"] as Blob
                         val d = Drawable.createFromStream(blob.contentStream, "res")
-                        profilePic.value = d?.toBitmap()
+                        _profilePic.value = d?.toBitmap()
                     }
                 }
             }
         }
     }
 
+    init {
+        authService.currentUser.observeForever(userObserver)
+        _profilePic.value = BitmapFactory.decodeResource(context.get()?.resources, R.drawable.profile_placeholder)
+    }
+
+    override fun onCleared() {
+        authService.currentUser.removeObserver(userObserver)
+    }
+
     val onGivenNameChanged: (String) -> Unit = { newValue ->
-        givenName.value = newValue
+        _givenName.value = newValue
     }
 
     val onSurnameChanged: (String) -> Unit = { newValue ->
-        surname.value = newValue
+        _surname.value = newValue
     }
 
     val onJobTitleChanged: (String) -> Unit = { newValue ->
-        jobTitle.value = newValue
+        _jobTitle.value = newValue
     }
 
     val onProfilePicChanged: (Bitmap) -> Unit = { newValue ->
         viewModelScope.launch(Dispatchers.Main) {
-            profilePic.value = newValue
+            _profilePic.value = newValue
         }
     }
 
     val clearToastMessage: () -> Unit = {
-        toastMessage.value = ""
+        _toastMessage.value = ""
     }
 
     val onSave: () -> Unit = {
@@ -116,9 +132,9 @@ class UserProfileViewModel(
             //make sure when we update the UI we update on the Main Thread
             withContext(Dispatchers.Main) {
                 if (didSave) {
-                    toastMessage.value = "Successfully updated profile"
+                    _toastMessage.value = "Successfully updated profile"
                 } else {
-                    toastMessage.value = "Error saving, try again later."
+                    _toastMessage.value = "Error saving, try again later."
                 }
             }
         }