Code Templates for android studio

StudioTemplates

//initViewsAndListeners
     private fun initViews() {
        with(binding) {
        
        }
    }

    private fun initListeners() {
        with(binding) {
        
        }
    }
    
    //fetchAndObserveData    
     private fun fetch$FUNCNAME$(){
        if (requireActivity().isNetworkConnected()){
           
        }else{
            requireActivity().toastInternetError()
        }
    }
    
    
     private fun observerUiState$FUNCNAME$() {
        viewLifecycleOwner.lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.RESUMED) {
                $VIEWMODEL$.collect { uiState ->
                    when (uiState) {
                        UiState.Init -> {}
                        is UiState.Loading -> handleUiStateLoading(true)
                        is UiState.Error -> handleUiStateError(
                            uiState.exception,
                            uiState.errorMessage
                        )

                        is UiState.Success -> handleUiStateSuccess(uiState.data)
                    }

                }
            }
        }

    }

    private fun handleUiStateLoading(isLoading: Boolean) {
       
    }


    private fun handleUiStateError(exception: Exception, errorMessage: String) {
        handleUiStateLoading(false)
        if (exception !is CancellationException) {
            requireActivity().toast(errorMessage)
        }
    }

    private fun handleUiStateSuccess(data: Any?) {
        handleUiStateLoading(false)
        data?.let {
          
        } ?: run{
        
        }
    }
    
    //stateFlowWithJob
    private val _uiState$VAR$ =
        MutableStateFlow<UiState<Any>>(UiState.Init)
    val uiState$VAR$ = _uiState$VAR$.asStateFlow()

    private var job$VAR$: Job? = null

    fun fetch$VAR$(
    ) {
        job$VAR$?.cancel()
        job$VAR$ = viewModelScope.launch {
            try {
                _uiState$VAR$.update { UiState.Loading }
                $REPO$.collect { apiResult ->
                    when (apiResult) {
                        is ApiCallResult.Error -> _uiState$VAR$.update {
                            UiState.Error(
                                exception = apiResult.exception,
                                errorMessage = apiResult.errorMessage
                            )
                        }

                        is ApiCallResult.Success -> _uiState$VAR$.update {
                            UiState.Success(
                                data = apiResult.data
                            )
                        }
                    }
                }
            } catch (exception: Exception) {
                _uiState$VAR$.update {
                    UiState.Error(
                        exception = exception,
                        errorMessage = exception.message.toString()
                    )
                }
            }
        }
    }
    
    //sharedFlowWithJob
    private val _uiState$VAR$ = MutableSharedFlow<UiState<Any>>()
    val uiState$VAR$ = _uiState$VAR$.asSharedFlow()

    private var job$VAR$: Job? = null

    fun fetch$VAR$(
    ) {
        job$VAR$?.cancel()
        job$VAR$ = viewModelScope.launch {
            try {
                _uiState$VAR$.emit(UiState.Loading)
                $REPO$.collect { apiResult ->
                    when (apiResult) {
                        is ApiCallResult.Error -> _uiState$VAR$.emit(
                            UiState.Error(
                                exception = apiResult.exception,
                                errorMessage = apiResult.errorMessage
                            )
                        )

                        is ApiCallResult.Success -> _uiState$VAR$.emit(
                            UiState.Success(
                                data = apiResult.data
                            )
                        )
                    }
                }
            } catch (exception: Exception) {
                _uiState$VAR$.emit(
                    UiState.Error(
                        errorMessage = exception.message.toString(),
                        exception = exception
                    )
                )
            }
        }
    }