androidkotlinmobileandroid-livedataandroid-mvvm

Android ViewModel Methods Fail After First Successful Execution - State Management or Concurrency Issue

In my Android application, I have a UserViewModel that handles various user-related operations (registration, login, username update, password change, etc.). The problem is that after one of these methods executes successfully, subsequent calls to other methods within the UserViewModel fail to reflect changes in the UI or local data, even though the underlying UserRepository successfully completes the operations (confirmed by logs). This issue affects all methods within the UserViewModel, not just the username update.

this is my viewmodel code

package com.kianmahmoudi.android.shirazgard.viewmodel

import android.net.Uri
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kianmahmoudi.android.shirazgard.repository.UserRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
import com.kianmahmoudi.android.shirazgard.data.UiState
import com.parse.ParseUser
import timber.log.Timber

@HiltViewModel
class UserViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {

    private val _registerState = MutableLiveData<UiState<ParseUser>>(UiState.Idle)
    val registerState: LiveData<UiState<ParseUser>> = _registerState

    private val _loginState = MutableLiveData<UiState<ParseUser>>(UiState.Idle)
    val loginState: LiveData<UiState<ParseUser>> = _loginState

    private val _logoutState = MutableLiveData<UiState<Unit>>(UiState.Idle)
    val logoutState: LiveData<UiState<Unit>> = _logoutState

    private val _deleteAccountState = MutableLiveData<UiState<Boolean>>(UiState.Idle)
    val deleteAccountState: LiveData<UiState<Boolean>> = _deleteAccountState

    private val _passwordChangeState = MutableLiveData<UiState<Boolean>>(UiState.Idle)
    val passwordChangeState: LiveData<UiState<Boolean>> = _passwordChangeState

    private val _passwordVerificationState = MutableLiveData<UiState<Boolean>>(UiState.Idle)
    val passwordVerificationState: LiveData<UiState<Boolean>> = _passwordVerificationState

    private val _profileImageState = MutableLiveData<UiState<String>>(UiState.Idle)
    val profileImageState: LiveData<UiState<String>> = _profileImageState

    private val _usernameState = MutableLiveData<UiState<String>>(UiState.Idle)
    val usernameState: LiveData<UiState<String>> = _usernameState

    private val _profileImageDeletionState = MutableLiveData<UiState<Boolean>>(UiState.Idle)
    val profileImageDeletionState: LiveData<UiState<Boolean>> = _profileImageDeletionState

    fun registerUser(username: String, password: String) {
        if (_registerState.value is UiState.Loading) return

        viewModelScope.launch {
            _registerState.value = UiState.Loading
            runCatching {
                userRepository.registerUser(username, password)
            }.onSuccess {
                _registerState.value = UiState.Success(it)
            }.onFailure {
                _registerState.value = UiState.Error(it.localizedMessage ?: "Error registering")
            }
        }
    }

    fun loginUser(username: String, password: String) {
        if (_loginState.value is UiState.Loading) return

        viewModelScope.launch {
            _loginState.value = UiState.Loading
            runCatching {
                userRepository.loginUser(username, password)
            }.onSuccess {
                _loginState.value = UiState.Success(it)
            }.onFailure {
                _loginState.value = UiState.Error(it.localizedMessage ?: "Error logging in")
            }
        }
    }

    fun logout() {
        if (_logoutState.value is UiState.Loading) return

        viewModelScope.launch {
            _logoutState.value = UiState.Loading
            runCatching {
                userRepository.logout()
            }.onSuccess {
                _logoutState.value = UiState.Success(Unit)
            }.onFailure {
                _logoutState.value = UiState.Error(it.localizedMessage ?: "Error logging out")
            }
        }
    }

    fun updateUsername(newUsername: String) {
        if (_usernameState.value is UiState.Loading) return

        viewModelScope.launch {
            _usernameState.value = UiState.Loading
            try {
                val success = userRepository.updateUsername(newUsername)
                if (success) {
                    // Force refresh the current user data
                    ParseUser.getCurrentUser()?.fetchInBackground<ParseUser>()
                    _usernameState.value = UiState.Success(newUsername)
                } else {
                    _usernameState.value = UiState.Error("Failed to update username")
                }
            } catch (e: Exception) {
                _usernameState.value = UiState.Error(e.localizedMessage ?: "Error updating username")
            }
        }
    }

    fun uploadProfileImage(imageUri: Uri) {
        if (_profileImageState.value is UiState.Loading) return

        viewModelScope.launch {
            _profileImageState.value = UiState.Loading
            runCatching {
                userRepository.uploadProfileImage(imageUri)
                userRepository.getProfileImageUrl()
            }.onSuccess { url ->
                _profileImageState.value = UiState.Success(url)
            }.onFailure {
                _profileImageState.value =
                    UiState.Error(it.localizedMessage ?: "Image upload error")
            }
        }
    }

    fun deleteProfileImage() {
        if (_profileImageDeletionState.value is UiState.Loading) return

        viewModelScope.launch {
            _profileImageDeletionState.value = UiState.Loading
            runCatching { userRepository.deleteProfileImage() }
                .onSuccess {
                    _profileImageDeletionState.value = UiState.Success(true)
                    _profileImageState.value = UiState.Success("")
                }.onFailure {
                    _profileImageDeletionState.value =
                        UiState.Error(it.localizedMessage ?: "Error deleting image")
                }
        }
    }

    fun fetchProfileImageUrl() {
        if (_profileImageState.value is UiState.Loading) return

        viewModelScope.launch {
            _profileImageState.value = UiState.Loading
            runCatching { userRepository.getProfileImageUrl() }
                .onSuccess {
                    _profileImageState.value = UiState.Success(it)
                }.onFailure {
                    _profileImageState.value =
                        UiState.Error(it.localizedMessage ?: "Error fetching profile image url")
                }
        }
    }

    fun changePassword(newPassword: String) {
        if (_passwordChangeState.value is UiState.Loading) return

        viewModelScope.launch {
            _passwordChangeState.value = UiState.Loading
            runCatching { userRepository.changePassword(newPassword) }
                .onSuccess {
                    _passwordChangeState.value = UiState.Success(true)
                }.onFailure {
                    _passwordChangeState.value =
                        UiState.Error(it.localizedMessage ?: "Error changing password")
                }
        }
    }

    fun verifyCurrentPassword(password: String) {
        if (_passwordVerificationState.value is UiState.Loading) return

        viewModelScope.launch {
            _passwordVerificationState.value = UiState.Loading
            runCatching { userRepository.isCurrentPasswordCorrect(password) }
                .onSuccess {
                    _passwordVerificationState.value = UiState.Success(it)
                }.onFailure {
                    _passwordVerificationState.value =
                        UiState.Error(it.localizedMessage ?: "Password verification failed")
                }
        }
    }

    fun deleteAccount() {
        if (_deleteAccountState.value is UiState.Loading) return

        viewModelScope.launch {
            _deleteAccountState.value = UiState.Loading
            runCatching { userRepository.deleteAccount() }
                .onSuccess {
                    _deleteAccountState.value = UiState.Success(true)
                }.onFailure {
                    _deleteAccountState.value =
                        UiState.Error(it.localizedMessage ?: "Account deletion failed")
                }
        }
    }

    fun resetUsernameState() {
        Timber.d("UserViewModel: resetUsernameState called")
        _usernameState.postValue(UiState.Idle)
    }

}

my user-repository code

package com.kianmahmoudi.android.shirazgard.repository

import android.content.Context
import android.net.Uri
import com.parse.ParseCloud
import com.parse.ParseFile
import com.parse.ParseUser
import com.parse.SaveCallback
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.suspendCancellableCoroutine
import org.json.JSONObject
import javax.inject.Inject
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.coroutines.suspendCoroutine

class UserRepositoryImpl @Inject constructor(
    @ApplicationContext private val context: Context
) : UserRepository {

    override suspend fun registerUser(userName: String, password: String): ParseUser {
        return suspendCoroutine { continuation ->
            ParseUser().apply {
                username = userName
                setPassword(password)
                signUpInBackground { e ->
                    if (e == null) {
                        continuation.resume(this)
                    } else {
                        continuation.resumeWithException(e)
                    }
                }
            }
        }
    }

    override suspend fun loginUser(userName: String, password: String): ParseUser {
        return suspendCoroutine { continuation ->
            ParseUser.logInInBackground(userName, password) { user, e ->
                if (e == null) {
                    continuation.resume(user)
                } else {
                    continuation.resumeWithException(e)
                }
            }
        }
    }

    override suspend fun changePassword(newPassword: String): Boolean {
        return suspendCancellableCoroutine { continuation ->
            val currentUser = ParseUser.getCurrentUser()
            if (currentUser != null) {
                currentUser.setPassword(newPassword)
                currentUser.saveInBackground { e ->
                    if (e == null && continuation.isActive) {
                        continuation.resume(true)
                    } else if (continuation.isActive) {
                        continuation.resumeWithException(
                            e ?: Exception("Failed to change password")
                        )
                    }
                }
            } else {
                continuation.resumeWithException(Exception("User not logged in"))
            }
        }
    }

    override suspend fun uploadProfileImage(imageUri: Uri): Boolean {
        return suspendCoroutine { continuation ->
            val user = ParseUser.getCurrentUser()
            val bytes = context.contentResolver.openInputStream(imageUri)?.readBytes()
                ?: throw Exception("Failed to read image")

            val parseFile = ParseFile("profile_${user.objectId}.jpg", bytes)
            parseFile.saveInBackground(SaveCallback { e ->
                if (e == null) {
                    user.put("profileImage", parseFile)
                    user.saveInBackground { e ->
                        if (e == null) {
                            continuation.resume(true)
                        } else {
                            continuation.resumeWithException(e)
                        }
                    }
                } else {
                    continuation.resumeWithException(e)
                }
            })
        }
    }

    override suspend fun getProfileImageUrl(): String {
        return suspendCoroutine { continuation ->
            val url = ParseUser.getCurrentUser().getParseFile("profileImage")?.url
            if (url != null) {
                continuation.resume(url)
            } else {
                continuation.resumeWithException(Exception("No profile image found"))
            }
        }
    }

    override suspend fun updateUsername(newUsername: String): Boolean {
        return suspendCancellableCoroutine { continuation ->
            val user = ParseUser.getCurrentUser()
            if (user != null) {
                user.username = newUsername
                user.saveInBackground { e ->
                    if (e == null) {
                        continuation.resume(true)
                    } else {
                        continuation.resumeWithException(e)
                    }
                }
            } else {
                continuation.resumeWithException(Exception("User not logged in"))
            }
        }
    }

    override suspend fun deleteProfileImage(): Boolean {
        return suspendCoroutine { continuation ->
            ParseUser.getCurrentUser().apply {
                remove("profileImage")
                saveInBackground { e ->
                    if (e == null) {
                        continuation.resume(true)
                    } else {
                        continuation.resumeWithException(e)
                    }
                }
            }
        }
    }

    override suspend fun deleteAccount(): Boolean {
        return suspendCoroutine { continuation ->
            ParseUser.getCurrentUser().deleteInBackground { e ->
                if (e == null) {
                    logout()
                    continuation.resume(true)
                } else {
                    continuation.resumeWithException(e)
                }
            }
        }
    }

    override fun logout() {
        ParseUser.logOutInBackground()
    }

    override suspend fun isCurrentPasswordCorrect(password: String): Boolean {
        return suspendCancellableCoroutine { continuation ->
            try {
                val currentUser = ParseUser.getCurrentUser()
                if (currentUser != null) {
                    val params = hashMapOf("username" to currentUser.username, "password" to password)
                    ParseCloud.callFunctionInBackground<HashMap<String, Any>>("verifyPassword", params) { result, e ->
                        if (e == null) {
                            try {
                                val jsonObject = JSONObject(result as Map<*, *>)
                                val success = jsonObject.getBoolean("success")
                                if (success) {
                                    continuation.resume(true)
                                } else {
                                    val error = jsonObject.getString("error")
                                    continuation.resumeWithException(Exception(error))
                                }
                            } catch (jsonException: Exception) {
                                continuation.resumeWithException(jsonException)
                            }
                        } else {
                            continuation.resumeWithException(e)
                        }
                    }
                } else {
                    continuation.resumeWithException(Exception("User not logged in"))
                }
            } catch (e: Exception) {
                continuation.resumeWithException(Exception("Failed to verify password: ${e.localizedMessage}"))
            }
        }
    }
}

one of the classes that this problem happen is editprofilefragment

edit profile fragment code

package com.kianmahmoudi.android.shirazgard.fragments

import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import com.bumptech.glide.Glide
import com.kianmahmoudi.android.shirazgard.R
import com.kianmahmoudi.android.shirazgard.data.UiState
import com.kianmahmoudi.android.shirazgard.databinding.FragmentEditProfileBinding
import com.kianmahmoudi.android.shirazgard.viewmodel.UserViewModel
import com.parse.ParseUser
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import timber.log.Timber

@AndroidEntryPoint
class EditProfileFragment : Fragment(R.layout.fragment_edit_profile) {

    private lateinit var binding: FragmentEditProfileBinding
    private val userViewModel: UserViewModel by viewModels()

    private val pickImageLauncher = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { result ->
        if (result.resultCode == Activity.RESULT_OK) {
            result.data?.data?.let { uri ->
                uploadProfileImage(uri)
            }
        }
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        binding.btnUpload.setOnClickListener { openImagePicker() }
        binding.btnDelete.setOnClickListener { deleteProfileImage() }
        binding.btnSave.setOnClickListener {
            updateUsername()
        }

        viewLifecycleOwner.lifecycleScope.launch {
            userViewModel.profileImageState.observe(viewLifecycleOwner) { result ->
                when (result) {
                    is UiState.Success -> {
                        Glide.with(requireContext())
                            .load(result.data)
                            .placeholder(R.drawable.person_24px)
                            .circleCrop()
                            .into(binding.profileImage)
                    }

                    is UiState.Error -> {
                        showToast(result.message)
                    }

                    is UiState.Loading -> {

                    }

                    UiState.Idle -> {}


                }
            }
        }
        viewLifecycleOwner.lifecycleScope.launch {
            userViewModel.profileImageDeletionState.observe(viewLifecycleOwner) { result ->
                when (result) {
                    is UiState.Loading -> {

                    }

                    is UiState.Success -> {
                        showToast("تصویر پروفایل با موفقیت حذف شد")
                        binding.profileImage.setImageResource(R.drawable.person_24px)

                    }

                    is UiState.Error -> {
                        showToast(result.message)
                    }

                    UiState.Idle -> {}
                }
            }
        }
        viewLifecycleOwner.lifecycleScope.launch {
            userViewModel.usernameState.observe(viewLifecycleOwner) { result ->
                when (result) {
                    is UiState.Success -> {
                        Timber.i("Username updated to: ${ParseUser.getCurrentUser()?.username}")
                        Timber.i("Username: ${result.data}")
                        showToast("نام کاربری با موفقیت به‌روزرسانی شد")
                        findNavController().navigateUp()
                    }

                    is UiState.Error -> {
                        Timber.i("Username error: ${result.message}")
                        showToast(result.message)
                    }

                    UiState.Loading -> {
                        Timber.d("EditProfileFragment: usernameState is loading")
                    }

                    UiState.Idle -> {
                        Timber.d("EditProfileFragment: usernameState is idle")
                    }
                }
                if (result != UiState.Idle) {
                    userViewModel.resetUsernameState()
                }
            }
        }

        val currentUser = ParseUser.getCurrentUser()
        binding.etUsername.setText(currentUser?.username)
        userViewModel.fetchProfileImageUrl()

    }

    private fun openImagePicker() {
        val intent = Intent(Intent.ACTION_PICK).apply {
            type = "image/*"
        }
        pickImageLauncher.launch(intent)
    }

    private fun uploadProfileImage(uri: Uri) {
        userViewModel.uploadProfileImage(uri)
    }

    private fun deleteProfileImage() {
        userViewModel.deleteProfileImage()
    }

    private fun updateUsername() {
        val newUsername = binding.etUsername.text.toString().trim()
        Timber.d("EditProfileFragment: updateUsername called with newUsername: $newUsername")
        if (userViewModel.usernameState.value !is UiState.Loading) {
            if (newUsername.isNotEmpty()) {
                userViewModel.updateUsername(newUsername)
                Timber.d("EditProfileFragment: userViewModel.updateUsername called")
            } else {
                showToast("نام کاربری نمی‌تواند خالی باشد")
                Timber.d("EditProfileFragment: newUsername is empty")
            }
        } else {
            Timber.d("EditProfileFragment: updateUsername is already loading")
        }
    }

    private fun showToast(message: String) {
        Toast.makeText(requireContext(), message, Toast.LENGTH_SHORT)
            .show()
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentEditProfileBinding.inflate(inflater)
        return binding.root
    }

}
Solution

  • the problem was with synchronization handling. i edit user repository to this and its fixed

    user repository code

    package com.kianmahmoudi.android.shirazgard.repository

import android.content.Context
import android.net.Uri
import com.parse.ParseCloud
import com.parse.ParseFile
import com.parse.ParseUser
import com.parse.SaveCallback
import dagger.hilt.android.qualifiers.ApplicationContext
import org.json.JSONObject
import javax.inject.Inject

class UserRepositoryImpl @Inject constructor(
    @ApplicationContext private val context: Context
) : UserRepository {

    override fun registerUser(
        userName: String,
        password: String,
        callback: (ParseUser?, String?) -> Unit
    ) {
        val user = ParseUser()
        user.username = userName
        user.setPassword(password)
        user.signUpInBackground { e ->
            if (e == null) {
                callback(user, null)
            } else {
                callback(null, e?.message)
            }
        }
    }

    override fun loginUser(
        userName: String,
        password: String,
        callback: (ParseUser?, String?) -> Unit
    ) {
        ParseUser.logInInBackground(userName, password) { user, e ->
            if (user != null) {
                callback(user, null)
            } else {
                callback(null, e?.message)
            }
        }
    }

    override fun changePassword(
        password: String,
        callback: (Boolean, String?) -> Unit
    ) {
        val user = ParseUser.getCurrentUser()
        user.setPassword(password)
        user.saveInBackground { e ->
            if (e == null) {
                callback(true, null)
            } else {
                callback(false, e.message)
            }
        }
    }

    override fun uploadProfileImage(imageUri: Uri, callback: (Boolean, String?) -> Unit) {
        val user = ParseUser.getCurrentUser() ?: run {
            callback(false, "User not logged in")
            return
        }

        try {
            val inputStream = context.contentResolver.openInputStream(imageUri)
            val bytes = inputStream?.readBytes() ?: run {
                callback(false, "Failed to read image")
                return
            }

            val file = ParseFile("profile_${user.objectId}.jpg", bytes)

            file.saveInBackground(SaveCallback { e ->
                if (e != null) {
                    callback(false, e.message)
                    return@SaveCallback
                }

                user.put("profileImage", file)
                user.saveInBackground { saveError ->
                    callback(saveError == null, saveError?.message)
                }
            })
        } catch (e: Exception) {
            callback(false, e.message)
        }
    }

    override fun getProfileImageUrl(callback: (String?) -> Unit) {
        val user = ParseUser.getCurrentUser()
        callback(user?.getParseFile("profileImage")?.url)
    }


    override fun updateUsername(newUsername: String, callback: (Boolean, String?) -> Unit) {
        val user = ParseUser.getCurrentUser()
        user?.username = newUsername
        user?.saveInBackground { e ->
            callback(e == null, e?.message)
        }
    }

    override fun deleteProfileImage(callback: (Boolean, String?) -> Unit) {
        val user = ParseUser.getCurrentUser()
        user?.remove("profileImage")
        user?.saveInBackground { e ->
            callback(e == null, e?.message)
        }
    }


    override fun deleteAccount(callback: (Boolean, String?) -> Unit) {
        val user = ParseUser.getCurrentUser()
        user?.deleteInBackground { e ->
            if (e == null) {
                callback(true, null)
                ParseUser.logOut()
            } else {
                callback(false, e.message)
            }
        }
    }


    override fun logout() {
        ParseUser.logOutInBackground()
    }


    override fun isCurrentPasswordCorrect(
        password: String,
        callback: (Boolean, String?) -> Unit
    ) {
        val params =
            hashMapOf("username" to ParseUser.getCurrentUser().username, "password" to password)
        ParseCloud.callFunctionInBackground<HashMap<String, Any>>(
            "verifyPassword",
            params
        ) { result, e ->
            if (e == null) {
                val response = result as HashMap<String, Any>
                if (response["success"] as Boolean) {
                    callback(true, null)
                } else {
                    callback(false, response["error"] as String?)
                }
            } else {
                callback(false, e.message)
            }
        }
    }


}