abhimuktheeswarar

class Store<S : State>(
    initialState: S,
    reduce: (Action, S) -> S,
    val scope: CoroutineScope,
) {

    private val inputActionsChannel: Channel<Action> = 
        Channel(capacity = Channel.UNLIMITED)

    private val outputChannel: Channel<S> = Channel()

abhimuktheeswarar

class CounterViewModel(private val store: Store<CounterState>) : ViewModel() {

    val actions: Flow<Action> = store.actions
    val states: Flow<CounterState> = store.states

    override fun onCleared() {
        super.onCleared()
        store.terminate()
    }

abhimuktheeswarar

class CounterActivity : AppCompatActivity() {

    private val viewModel by viewModels<CounterViewModel>()

    private lateinit var binding: ActivityCounterBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityCounterBinding.inflate(layoutInflater)
        setContentView(binding.root)

abhimuktheeswarar

fun CoroutineScope.counterStateMachine(
    initialState: CounterState,
    mutableStateFlow: MutableStateFlow<CounterState>,
    mutableMessages: MutableSharedFlow<CounterMessage>,
) =
    actor<CounterMessage> {
        var state: CounterState = initialState
        channel.consumeEach { message ->
            when (message) {
                is IncrementCounter -> {

abhimuktheeswarar

class Repository {

    suspend fun update(count: Int): Boolean {
        TODO("Save to DB")
    }
}

class CounterSideEffect(
    private val repository: Repository,
    private val counterStateStore: CounterStateStore,

abhimuktheeswarar

class CounterViewModel(private val counterStateStore: CounterStateStore) : ViewModel() {

    val stateFlow: Flow<CounterState> = counterStateStore.stateFlow

    fun dispatch(message: CounterMessage) {
        counterStateStore.dispatch(message)
    }

    override fun onCleared() {
        super.onCleared()

abhimuktheeswarar

sealed interface CounterMessage
object IncrementCounter : CounterMessage
object DecrementCounter : CounterMessage
class GetCounterState(val deferred: CompletableDeferred<CounterState>) : CounterMessage

abhimuktheeswarar

fun CoroutineScope.customCounterStateMachine(channel : ReceiveChannel<CounterMessage>) 
= launch {
    var counter = 0 // actor state
    channel.consumeEach { message ->
        ensureActive()
        when (message) {
            is IncrementCounter -> counter++
            is GetCounter -> message.response.complete(counter)
        }
    }

abhimuktheeswarar

class DownloadAndOpenPdf(
    private val applicationContext: Context,
    private val okHttpClient: OkHttpClient,
    private val scope: CoroutineScope
) {

    private val tag = "DownloadAndOpenPdf"
    private var inProgress: Boolean = false
    private lateinit var file: File

abhimuktheeswarar

public class TaskManager {

    /**
     * Bring up launcher task to front
     */
    public void navToLauncherTask(@Nonnull Context appContext) {
        ActivityManager activityManager = (ActivityManager) appContext.getSystemService(Context.ACTIVITY_SERVICE);
        // iterate app tasks available and navigate to launcher task (browse task)
        final List<ActivityManager.AppTask> appTasks = activityManager.getAppTasks();
        for (ActivityManager.AppTask task : appTasks) {