Bloc Core/com.onegravity.bloc.utils

Package-level declarations

Types

typealias Acceptor<Proposal, State> = (proposal: Proposal, state: State) -> State?

Function for accepting / rejecting a Proposal. If the proposal is accepted, returns the new State (which is based on the Proposal). If the proposal is rejected, returns Null.

BlocDSL

@DslMarker

annotation class BlocDSL

BlocObserver

typealias BlocObserver<State> = (State) -> Unit

This is the Observer specifically for Swift

Cancel

typealias Cancel = () -> Unit

A function used to cancel Coroutines launched with InitializerContext.launch, ThunkContext.launch or ReducerContext.launch

Dispatcher

typealias Dispatcher<Action> = suspend (Action) -> Unit

Function to dispatch actions to a bloc. Dispatchers are used by Initializers and Thunks or ThunkNoActions to dispatch an action to the "next" thunk or reducer in the execution chain.

Effect

data class Effect<Proposal : Any, SideEffect : Any>(val proposal: Proposal?, val sideEffects: List<SideEffect>)

FragmentViewBindingDelegate

class FragmentViewBindingDelegate<T : ViewBinding>(val fragment: Fragment, val viewBindingFactory: (View) -> T) : ReadOnlyProperty<Fragment, T>

GetState

typealias GetState<State> = () -> State

Function that returns the current state. GetState is used by thunks to retrieve the current state of the bloc and is accessible through the ThunkContext / ThunkContextNoAction.

Initializer

typealias Initializer<State, Action, Proposal> = suspend InitializerContext<State, Action, Proposal>.() -> Unit

Function that is executed when the bloc is created.

InitializerContext

data class InitializerContext<State, Action, Proposal>(val getState: GetState<State>, val dispatch: Dispatcher<Action>, val reduce: suspend (proposal: Proposal) -> Unit, launchBlock: Launch)

InitializerContext is used as receiver for an initializer:

JobConfig

data class JobConfig(val cancelPrevious: Boolean = false, val jobId: String = DEFAULT_JOB_ID)

The JobConfig defines how a coroutine/job is executed.

Launch

typealias Launch = (jobConfig: JobConfig?, block: SuspendBlock) -> Cancel

Function to launch a coroutine from one of the contexts: InitializerContext, ThunkContext or ReducerContext

Mapper

typealias Mapper<Model, State> = (model: Model) -> State

Function to map a (Redux) model to (bloc) state.

MutableStateStream

class MutableStateStream<Value : Any>(initialValue: Value) : StateStream<Value> , Sink<Value>

A StateStream and a Sink at the same time.

Reducer

typealias Reducer<State, Action, Proposal> = ReducerContext<State, Action>.() -> Proposal

Function that reduces state.

ReducerContext

data class ReducerContext<State, Action>(val state: State, val action: Action, launchBlock: Launch)

ReducerContext is used as receiver for the receiver when defining it with an action:

ReducerContextNoAction

data class ReducerContextNoAction<State>(val state: State, launchBlock: Launch)

ReducerContextNoAction is used as receiver for the receiver defined MVVM+ style (no action):

ReducerNoAction

typealias ReducerNoAction<State, Proposal> = ReducerContextNoAction<State>.() -> Proposal

Function that reduces state.

Selector

typealias Selector<State, Model> = (State) -> Model

Function to select memoized sub-state from (Redux) state.

SideEffect

typealias SideEffect<State, Action, SideEffect> = ReducerContext<State, Action>.() -> SideEffect

Function that emits a side effect.

SideEffectNoAction

typealias SideEffectNoAction<State, SideEffect> = ReducerContextNoAction<State>.() -> SideEffect

Function that emits a side effect.

SideEffectStream

typealias SideEffectStream<Value> = Flow<Value>

A SideEffectStream is a source of asynchronous (side effect) data. It's a hot stream meant to deal with SideEffect data (compared to StateStream for State).

A SideEffectStream emits:

all values even duplicates
no initial value upon subscription (analogous PublishSubject)

A StateStream emits:

no duplicate values
an initial value upon subscription (analogous BehaviorSubject)

SuspendBlock

typealias SuspendBlock = suspend CoroutineScope.() -> Unit

Suspend function passed as parameter to one of the launch function calls: InitializerContext.launch, ThunkContext.launch or ReducerContext.launch

Thunk

typealias Thunk<State, Action, A, Proposal> = suspend ThunkContext<State, Action, A, Proposal>.() -> Unit

Function that runs asynchronous code.

ThunkContext

data class ThunkContext<State, Action, A : Action, Proposal>(val getState: GetState<State>, val action: A, val dispatch: Dispatcher<Action>, val reduce: suspend (proposal: Proposal) -> Unit, launchBlock: Launch)

ThunkContext is used as receiver for the thunk when defining it with an action:

ThunkContextNoAction

data class ThunkContextNoAction<State, Action, Proposal>(val getState: GetState<State>, val dispatch: Dispatcher<Action>, val reduce: suspend (proposal: Proposal) -> Unit, launchBlock: Launch)

ThunkContextNoAction is used as receiver for the thunk defined MVVM+ style (no action):

ThunkNoAction

typealias ThunkNoAction<State, Action, Proposal> = suspend ThunkContextNoAction<State, Action, Proposal>.() -> Unit

Function that runs asynchronous code.

Functions

launch

fun <State, Action, Proposal> InitializerContext<State, Action, Proposal>.launch(block: SuspendBlock): Cancel

fun <State, Action, Proposal> InitializerContext<State, Action, Proposal>.launch(jobConfig: JobConfig, block: SuspendBlock): Cancel

Extension function for InitializerContext to launch a coroutine and run a suspend function without exposing the bloc's CoroutineScope.

fun <State> ReducerContextNoAction<State>.launch(block: SuspendBlock): Cancel

fun <State> ReducerContextNoAction<State>.launch(jobConfig: JobConfig, block: SuspendBlock): Cancel

Extension function for ReducerContextNoAction to launch a coroutine and run a suspend function without exposing the bloc's CoroutineScope.

fun <State, Action> ReducerContext<State, Action>.launch(block: SuspendBlock): Cancel

fun <State, Action> ReducerContext<State, Action>.launch(jobConfig: JobConfig, block: SuspendBlock): Cancel

Extension function for ReducerContext to launch a coroutine and run a suspend function without exposing the bloc's CoroutineScope.

fun <State, Action, Proposal> ThunkContextNoAction<State, Action, Proposal>.launch(block: SuspendBlock): Cancel

fun <State, Action, Proposal> ThunkContextNoAction<State, Action, Proposal>.launch(jobConfig: JobConfig, block: SuspendBlock): Cancel

Extension function for ThunkContextNoAction to launch a coroutine and run a suspend function without exposing the bloc's CoroutineScope.

fun <State, Action, A : Action, Proposal> ThunkContext<State, Action, A, Proposal>.launch(block: SuspendBlock): Cancel

fun <State, Action, A : Action, Proposal> ThunkContext<State, Action, A, Proposal>.launch(jobConfig: JobConfig, block: SuspendBlock): Cancel

Extension function for ThunkContext to launch a coroutine and run a suspend function without exposing the bloc's CoroutineScope.

fun <State : Any, SideEffect : Any> BlocObservableOwner<State, SideEffect>.subscribe(lifecycle: Lifecycle, state: suspend (state: State) -> Unit? = null, sideEffect: suspend (sideEffect: SideEffect) -> Unit? = null)

Analogous call for BlocObservableOwner

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> BlocOwner<State, Action, SideEffect, Proposal>.subscribe(lifecycle: Lifecycle, state: suspend (state: State) -> Unit? = null, sideEffect: suspend (sideEffect: SideEffect) -> Unit? = null)

Call from a component to observe state and side effect updates in a BlocOwner (BlocOwner in Android is typically a ViewModel, the observing component a Fragment or an Activity):

fun <State : Any, Action : Any, SideEffect : Any> Bloc<State, Action, SideEffect>.subscribe(lifecycle: Lifecycle, state: suspend (state: State) -> Unit? = null, sideEffect: suspend (sideEffect: SideEffect) -> Unit? = null)

Subscribes to the state and side effects streams of a Bloc.

viewBinding

inline fun <T : ViewBinding> Fragment.viewBinding(): FragmentViewBindingDelegate<T>