Common MVI

LoginFragment.kt

 class LoginFragment {
    val viewModel by viewModel<LoginViewModel>()
    
    override fun onViewCreadted(){
      with(binding){
        action.setOnClickListener{
          viewModel.performIntent(
            intent = PerformLoginWith(
              username = usernameField.textAsString 
            )
          ) 
        }
      }
      lifecycleScope.launch{
        viewModel.state.collect { state ->
           handleState(state)
        }
      }
    }       
    fun handleState(intent: LoginState){
      //..... 
    }
 }

LoginIntent.kt

sealed class LoginIntent{
   	data class PerformLoginWith(username: String, password: String): LoginIntent()
   	object RequestSupport: LoginIntent()
}

LoginRepository.kt

class LoginRepository (
  val service: AppService
){
    suspend fun getSessionWith(username: String) = service.getSession(username)
}

LoginState.kt

sealed class LoginState{
	object Ilde: LoginState(),
  data class ShowMessage(val message:STring): LoginState()
	data class ShowOrHideLoader(val isVisible): LoginState()
}

LoginUseCase.kt

class LoginUseCase(
  val repository: LoginRepository
){
  
  fun performLoginWithUserName(username: String) = flow {
    emit(ShowLoader(isVisible = true)) 
    
    when(val response = repository.getSessionWith(username)){
      is Success -> {
        emit(ShowMessage(message = "Success")) 
      }
      else -> {
        emit(ShowMessage(message = "failure")) 
      }
    }
    
    emit(ShowLoader(isVisible = false)) 
    emit(Ilde) 
  }
  
  // if success then you will get flow state of:
  // (ShowLoader(isVisible = true), ShowMessage(message = "Success"), ShowLoader(isVisible = false), Ilde)
  // else
  // (ShowLoader(isVisible = true), ShowMessage(message = "false"), ShowLoader(isVisible = false), Ilde)
}

LoginViewModel.kt

class LoginViewModel(
	private val useCase: LoginUseCase 
) : ViewModel(){
    private val channel = Channel<LoginIntent>()
    private val _state = MutableStateFlow<LoginState>(Ilde)
    val state: StateFlow<LoginState> get() = _state

  
    init {
    	viewModelScope.launch {
    		handleIntents()
    	}
    }

    suspend fun handleIntents(){
    	channel.collectAsFlow(){ intent ->
    		when(intent){
    			is PerformLoginWith -> {
    				useCase.performLoginWith(intent.username) {
    					_state.value = it 
    				}
    			}
    		}
    	}
    }

    fun performIntent(val intent: LoginIntent) = viewModelScope.launch {
        channel.offer(intent)
    }
}