Reports

How to Centralize HTTP Response Handling and Navigation in a Kotlin MVVM Android App with Multiple Fragments?

In an MVVM architecture with a single-activity, multiple-fragment Android application, centralizing HTTP response handling and navigation while avoiding redundant code across Fragments can be achieved by leveraging the ViewModel and sealed classes for navigation events. Below is a clean and scalable approach that adheres to MVVM principles.

Define Navigation Events:

Create a sealed class to represent navigation events, allowing the ViewModel to communicate them to the View layer

sealed class NavigationEvent {
    object NavigateToLogin : NavigationEvent()
    object NavigateToServerError : NavigationEvent()
}

ApiCall Function

inline fun apiCall( crossinline apiCall: suspend () -> Response, crossinline onNavigationEvent: (NavigationEvent) -> Unit ) = flow { emit(State.Progress(0)) val response = apiCall() val responseBody = response.body()

 when {
     response.isSuccessful && responseBody != null -> emit(State.Success(responseBody))
     response.code() in 500..599 -> {
         onNavigationEvent(NavigationEvent.NavigateToServerError)
         emit(State.Error(HttpException(response)))
     }
     response.code() == 401 || response.code() == 403 -> {
         onNavigationEvent(NavigationEvent.NavigateToLogin)
         emit(State.Error(HttpException(response)))
     }
     else -> emit(State.Error(HttpException(response)))
 }

}.catch { exception -> emit(State.Error(exception)) }.flowOn(Dispatchers.IO)

Emit Navigation Events from the Repository

Pass navigation events to the ViewModel during API calls:

   class ExampleRepository {
    fun checkOtpCode(
        phoneNumber: String,
        code: String,
        onNavigationEvent: (NavigationEvent) -> Unit
    ) = apiCall(
        { remoteDataSource.checkOtp(phoneNumber, code) },
        onNavigationEvent
    )
}

Handle Navigation Events in the ViewModel

Expose a SharedFlow or LiveData for navigation events to the Fragment:

    class ExampleViewModel(private val repository: ExampleRepository) : ViewModel() {

    private val _navigationEvent = MutableSharedFlow<NavigationEvent>()
    val navigationEvent: SharedFlow<NavigationEvent> = _navigationEvent

    fun checkOtpCode(phoneNumber: String, code: String) = repository.checkOtpCode(
        phoneNumber,
        code
    ) { event ->
        viewModelScope.launch {
            _navigationEvent.emit(event)
        }
    }
}

Observe Navigation Events in the Fragment

Collect navigation events in your Fragment and perform the navigation:

class ExampleFragment : Fragment() {

    private val viewModel: ExampleViewModel by viewModels()

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

        lifecycleScope.launchWhenStarted {
            viewModel.navigationEvent.collect { event ->
                when (event) {
                    is NavigationEvent.NavigateToLogin -> findNavController().navigate(R.id.loginFragment)
                    is NavigationEvent.NavigateToServerError -> findNavController().navigate(R.id.serverErrorFragment)
                }
            }
        }

        // Api call here
        viewModel.checkOtpCode("1234567890", "1234")
    }
}

This solution adheres to MVVM by keeping navigation logic within the ViewModel, making it centralized, reusable, and testable. It avoids global state by scoping navigation events to specific ViewModel instances, ensuring clean architecture and reducing tight coupling. To further improve, shared navigation logic can be moved to a BaseViewModel, and a SingleLiveEvent can be used for one-time navigation with LiveData. This approach ensures maintainable, modular, and scalable code.

I HOPE THIS IS HELP YOU. THANK YOU:)

79235865