Bloc Core/com.onegravity.bloc

Package-level declarations

Types

Bloc

abstract class Bloc<out State : Any, in Action : Any, SideEffect : Any> : BlocState<State, Action>

The core class of the framework. (can't be an interface or the generic types are erased in Swift)

BlocContext

interface BlocContext : LifecycleOwner

Each Bloc receives a BlocContext.

BlocObservable

abstract class BlocObservable<out State : Any, out SideEffect : Any>

A Bloc than can be observed by subscribing to state and side effect updates (has a subscribe function).

BlocObservableOwner

interface BlocObservableOwner<out State : Any, out SideEffect : Any>

A class is a BlocObservableOwner if it holds and exposes a BlocObservable.

BlocOwner

interface BlocOwner<out State : Any, in Action : Any, SideEffect : Any, Proposal : Any>

A class is a BlocOwner if it holds and exposes a Bloc.

ComponentLazy

class ComponentLazy<A : ViewModelStoreOwner, Component : Any>(owner: Lazy<A>, key: Any, create: (context: BlocContext) -> Component) : Lazy<Component>

Sink

interface Sink<in Value : Any>

A Sink is a generic destination for data.

StateStream

interface StateStream<out Value : Any>

A StateStream is a source of asynchronous (state) data. It's a hot stream, identical to kotlinx.coroutines.flow.StateFlow without exposing the replayCache and meant to deal with State data (compared to SideEffectStream for SideEffects).

Functions

bind

fun <T : ViewDataBinding> ComponentActivity.bind(@LayoutRes layoutId: Int, bindLayout2Component: (T) -> Unit)

ComponentActivity / AppCompatActivity / Fragment

bloc

@JvmName(name = "blocProposalEqualsStateInitialValue")

fun <State : Any, Action : Any, SideEffect : Any> bloc(context: BlocContext, initialValue: State, block: BlocBuilder<State, Action, SideEffect, State>.() -> Unit = {}): Bloc<State, Action, SideEffect>

@JvmName(name = "blocNoSideEffectsInitialValue")

fun <State : Any, Action : Any> bloc(context: BlocContext, initialValue: State, block: BlocBuilder<State, Action, Unit, State>.() -> Unit = {}): Bloc<State, Action, Unit>

@JvmName(name = "bloc")

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> bloc(context: BlocContext, blocState: BlocState<State, Proposal>, block: BlocBuilder<State, Action, SideEffect, Proposal>.() -> Unit = {}): Bloc<State, Action, SideEffect>

@JvmName(name = "blocProposalEqualsState")

fun <State : Any, Action : Any, SideEffect : Any> bloc(context: BlocContext, blocState: BlocState<State, State>, block: BlocBuilder<State, Action, SideEffect, State>.() -> Unit = {}): Bloc<State, Action, SideEffect>

@JvmName(name = "blocNoSideEffects")

fun <State : Any, Action : Any> bloc(context: BlocContext, blocState: BlocState<State, State>, block: BlocBuilder<State, Action, Unit, State>.() -> Unit = {}): Bloc<State, Action, Unit>

Creates a Bloc instance using a BlocBuilder.

blocContext

fun ViewModel.blocContext(): BlocContext

Create a BlocContext from a ViewModel. The lifecycle will be the "lifecycle" of the ViewModel.

collectSideEffects

fun <State : Any, Action : Any, SideEffect : Any> collectSideEffects(bloc: <Error class: unknown class><State, Action, SideEffect>): <Error class: unknown class><<Error class: unknown class>, MutableList<SideEffect>>

collectState

fun <State : Any, Action : Any, SideEffect : Any> collectState(bloc: <Error class: unknown class><State, Action, SideEffect>): <Error class: unknown class><<Error class: unknown class>, MutableList<State>>

getOrCreate

inline fun <A : ViewModelStoreOwner, Component : Any> A.getOrCreate(key: Any = Component::class, noinline create: (context: BlocContext) -> Component): Lazy<Component>

Use this from an Activity or a Fragment to get or create a "Component" without directly involving a ViewModel, e.g.:

reduce

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> BlocOwner<State, Action, SideEffect, Proposal>.reduce(reducer: ReducerNoAction<State, Proposal>)

Submit a Reducer without side effects to a BlocOwner/Bloc to be run. The reducer will receive the state but no action (since it was triggered "manually", not by sending an action to the Bloc).

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> Bloc<State, Action, SideEffect>.reduce(reducer: ReducerNoAction<State, Proposal>)

Submit a Reducer without side effects to a Bloc to be run. The reducer will receive the state but no action (since it was triggered "manually", not by sending an action to the Bloc).

reduceAnd

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> BlocOwner<State, Action, SideEffect, Proposal>.reduceAnd(reducer: ReducerNoAction<State, Effect<Proposal, SideEffect>>)

Submit a Reducer with side effects to a BlocOwner/Bloc to be run. The reducer will receive the state but no action (since it was triggered "manually", not by sending an action to the Bloc).

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> Bloc<State, Action, SideEffect>.reduceAnd(reducer: ReducerNoAction<State, Effect<Proposal, SideEffect>>)

Submit a Reducer with side effects to a Bloc to be run. The reducer will receive the state but no action (since it was triggered "manually", not by sending an action to the Bloc).

runTests

fun runTests(block: suspend () -> Unit): <Error class: unknown class>

runTest() ignores all delay() calls so most tests would fail since they test asynchronous code

sideEffect

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> BlocOwner<State, Action, SideEffect, Proposal>.sideEffect(sideEffect: SideEffectNoAction<State, SideEffect>)

Submit a SideEffect to a BlocOwner/Bloc to be emitted. The side effect will receive the state but no action (since it was triggered "manually", not by sending an action to the Bloc).

fun <State : Any, Action : Any, SideEffect : Any> Bloc<State, Action, SideEffect>.sideEffect(sideEffect: SideEffectNoAction<State, SideEffect>)

Submit a SideEffect to a Bloc to be emitted. The side effect will receive the state but no action (since it was triggered "manually", not by sending an action to the Bloc). Note: the proposal is irrelevant for sideEffect so we set it to Unit

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

Subscribes to a BlocObservableOwner (typically a ViewModel, a Fragment or an Activity). The subscription is tied to the lifecycle of a LifecycleOwner (normally an Activity or Fragment).

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

Same as above for a BlocOwner

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

Same as above for a Bloc

testCollectSideEffects

suspend fun <State : Any, Action : Any, SideEffect : Any> testCollectSideEffects(bloc: <Error class: unknown class><State, Action, SideEffect>, expected: List<SideEffect>, block: suspend () -> Unit)

testCollectState

suspend fun <State : Any, Action : Any, SideEffect : Any> testCollectState(bloc: <Error class: unknown class><State, Action, SideEffect>, expected: List<State>, block: suspend () -> Unit)

suspend fun <State : Any, Action : Any, SideEffect : Any> testCollectState(bloc: <Error class: unknown class><State, Action, SideEffect>, expected: List<State>, delay: Long = 100, block: suspend () -> Unit)

testState

suspend fun <State : Any, Action : Any, SideEffect : Any> testState(bloc: <Error class: unknown class><State, Action, SideEffect>, action: Action?, expected: State, delay: Long = 10)

thunk

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> BlocOwner<State, Action, SideEffect, Proposal>.thunk(thunk: ThunkNoAction<State, Action, Proposal>)

Submit a Thunk to a BlocOwner/Bloc to be run. The thunk will receive the dispatch and the getState function but no action (since it was triggered "manually", not by sending an action to the Bloc). The dispatch function dispatches to the first matching thunk/reducer/side-effect in the Bloc.

@JvmName(name = "BlocOwnerThunkSimplified")

fun <State : Any, Action : Any, SideEffect : Any> BlocOwner<State, Action, SideEffect, State>.thunk(thunk: ThunkNoAction<State, Action, State>)

Submit a Thunk to a BlocOwner/Bloc to be run. Simplified version with Proposal = State.

fun <State : Any, Action : Any, SideEffect : Any, Proposal : Any> Bloc<State, Action, SideEffect>.thunk(thunk: ThunkNoAction<State, Action, Proposal>)

Submit a Thunk to a Bloc to be run. The thunk will receive the dispatch and the getState function but no action (since it was triggered "manually", not by sending an action to the Bloc). The dispatch function dispatches to the first matching thunk/reducer/side-effect in the Bloc.

@JvmName(name = "BlocThunkSimplified")

fun <State : Any, Action : Any, SideEffect : Any> Bloc<State, Action, SideEffect>.thunk(thunk: ThunkNoAction<State, Action, State>)

Submit a Thunk to a Bloc to be run. Simplified version with Proposal = State.

toLiveData

fun <State : Any, Action : Any, SideEffect : Any> LifecycleOwner.toLiveData(bloc: Bloc<State, Action, SideEffect>): LiveData<State>

The same for Activities / Fragments

fun <State : Any, Action : Any, SideEffect : Any> ViewModel.toLiveData(bloc: Bloc<State, Action, SideEffect>): LiveData<State>

Expose a Bloc as LiveData so it can be used with Android data binding, e.g.:

toObservable

fun <State : Any, Action : Any, SideEffect : Any> Bloc<State, Action, SideEffect>.toObservable(): BlocObservable<State, SideEffect>

If a components implements the BlocObservableOwner interface it needs to provide

fun <State : Any, Action : Any, SideEffect : Any> List<Bloc<State, Action, SideEffect>>.toObservable(): BlocObservable<State, SideEffect>

The assumption is that all Blocs use the same BlocState with the same type parameters (enforced at compile time) but also that they share the same instance of a BlocState (not enforced at all). Under that assumption we only need to observe the state of the first Bloc to observe all state changes. The edge-case that one passes in multiple Blocs using different BlocStates could be covered by using a UUID for BlocState instances and then verify that all BlocStates have the same UUID but that would be over-engineering imo.

fun <State : Any, Action : Any, SideEffect : Any> Bloc<State, Action, SideEffect>.toObservable(bloc: Bloc<State, Action, SideEffect>): BlocObservable<State, SideEffect>

Same as above but combine just two Blocs to BlocObservable.