Implement message and user data caching using Room persistence library

[siddheshkothadi]

BRO USE IN MainViewModel.kt / package me.siddheshkothadi.chat.ui.viewmodel

import android.util.Log
import android.widget.Toast
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.android.gms.auth.api.signin.GoogleSignInOptions
import com.google.firebase.auth.AuthCredential
import com.google.firebase.auth.ktx.auth
import com.google.firebase.ktx.Firebase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import me.siddheshkothadi.chat.ChatApplication
import me.siddheshkothadi.chat.R
import me.siddheshkothadi.chat.domain.model.User
import me.siddheshkothadi.chat.domain.model.UserData
import me.siddheshkothadi.chat.domain.repository.UserRepository
import javax.inject.Inject

@hiltviewmodel
class MainViewModel @Inject constructor(
private val context: ChatApplication,
private val userRepository: UserRepository
) : ViewModel() {

private val userData = userRepository.userData
private val firebaseAuth = userRepository.firebaseAuth

val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
    .requestIdToken(context.getString(R.string.default_web_client_id))
    .requestEmail()
    .build()

val textState = mutableStateOf("")
val users = userRepository.users
val chats = userRepository.chats
val isUserListLoading = userRepository.isUserListLoading

val isSignedIn = MutableStateFlow(firebaseAuth.currentUser != null)
val isSigningIn = MutableStateFlow(false)
val areMessagesLoading = MutableStateFlow(false)
val isLoggingOut = MutableStateFlow(false)

init {
    Firebase.auth.addAuthStateListener { auth ->
        viewModelScope.launch {
            isSigningIn.value = true

            val currentUserData = userData.first()
            val currentUser = auth.currentUser

            if (currentUser == null) {
                // Not logged in
                if (currentUserData.privateKey.isNotEmpty()) {
                    userRepository.updateUserData(UserData())
                }
            } else if (currentUserData.privateKey.isEmpty()) {
                // New login
                userRepository.deleteAllData(currentUser.uid)
                userRepository.saveNewUser(currentUser)
                Toast.makeText(context, "Login Successful", Toast.LENGTH_LONG).show()
            }

            isSigningIn.value = false
            isSignedIn.value = firebaseAuth.currentUser != null
        }
    }
}

fun addTextToChat(text: String, from: String, to: User, key: String) = viewModelScope.launch {
    if (text.isNotBlank()) {
        userRepository.addChat(text, from, to, key)
        textState.value = ""
    }
}

fun setTextState(value: String) {
    textState.value = value
}

fun signWithCredential(credential: AuthCredential) = viewModelScope.launch {
    try {
        isSigningIn.value = true
        userRepository.signWithCredential(credential)
        isSignedIn.value = true
    } catch (e: Exception) {
        Log.e("Auth Error", e.toString())
    } finally {
        isSigningIn.value = false
    }
}

fun signOut() = viewModelScope.launch {
    isLoggingOut.value = true
    userRepository.signOut(gso)
    isLoggingOut.value = false
}

fun clearChats() {
    userRepository.clearChats()
}

fun getCurrentUserUid(): String {
    return firebaseAuth.currentUser?.uid.orEmpty()
}

fun getCurrentUser(): User {
    val user = firebaseAuth.currentUser
    return User(
        displayName = user?.displayName.orEmpty(),
        photoUrl = user?.photoUrl?.toString().orEmpty(),
        email = user?.email.orEmpty()
    )
}

fun addMessageEventListener(key: String) {
    userRepository.addMessageEventListener(key)
}

fun removeMessageEventListener(key: String) {
    userRepository.removeMessageEventListener(key)
}

}