litho-core/com.facebook.litho/LithoRenderer

LithoRenderer

class LithoRenderer(val context: Context, val id: Int = LithoTree.generateComponentTreeId(), val componentsConfig: ComponentsConfiguration = ComponentsConfiguration.defaultInstance, val renderUnitIdGenerator: RenderUnitIdGenerator = RenderUnitIdGenerator(id), val treeState: TreeState? = TreeState(), val parentTreePropContainer: TreePropContainer? = TreePropContainer(), val treePropContainer: TreePropContainer? = TreePropContainer(), val visibilityController: LithoVisibilityEventsController? = null, val synchronizer: UpdateSynchronizer? = null) : TreeStateProvider, StateUpdater, StateUpdateRequester, MountedViewReference, ErrorComponentReceiver

A renderer for Litho components that handles RESOLVE and LAYOUT.

Constructors

LithoRenderer

constructor(context: Context, id: Int = LithoTree.generateComponentTreeId(), componentsConfig: ComponentsConfiguration = ComponentsConfiguration.defaultInstance, renderUnitIdGenerator: RenderUnitIdGenerator = RenderUnitIdGenerator(id), treeState: TreeState? = TreeState(), parentTreePropContainer: TreePropContainer? = TreePropContainer(), treePropContainer: TreePropContainer? = TreePropContainer(), visibilityController: LithoVisibilityEventsController? = null, synchronizer: UpdateSynchronizer? = null)

Types

Companion

object Companion

Properties

componentsConfig

val componentsConfig: ComponentsConfiguration

context

val context: Context

currentLayoutState

@Volatile

var currentLayoutState: LayoutState?

val id: Int

isFirstMount

open override var isFirstMount: Boolean

mountedView

open override val mountedView: View?

onStateUpdateCompleted

var onStateUpdateCompleted: (LayoutState) -> Unit?

Callback that is invoked when a state update is completed

parentTreePropContainer

val parentTreePropContainer: TreePropContainer?

renderUnitIdGenerator

val renderUnitIdGenerator: RenderUnitIdGenerator

sizeConstraints

@Volatile

var sizeConstraints: SizeConstraints?

The size constraints used for layout calculations.

synchronizer

val synchronizer: UpdateSynchronizer? = null

treePropContainer

val treePropContainer: TreePropContainer?

treeState

open override val treeState: TreeState?

The default TreeState needed by the StateProvider.

uiThreadLayoutState

var uiThreadLayoutState: LayoutState?

visibilityController

val visibilityController: LithoVisibilityEventsController? = null

Functions

applyLazyStateUpdatesForContainer

open override fun applyLazyStateUpdatesForContainer(globalKey: String, container: StateContainer, isLayoutState: Boolean): StateContainer

bind

@UiThread

fun bind(host: Host)

canSkipStateUpdate

open override fun <T> canSkipStateUpdate(stateId: StateId, newValue: T?, isLayoutState: Boolean): Boolean

open override fun <T> canSkipStateUpdate(newValueFunction: (T) -> T, stateId: StateId, isLayoutState: Boolean): Boolean

cleanup

@AnyThread

fun cleanup()

Cleans up any pending resolve or layout operations and resets the renderer state.

getCachedValue

open override fun getCachedValue(globalKey: String, index: Int, cachedValueInputs: Any, isLayoutState: Boolean): Any?

Returns a Cached value that is accessible across all re-render operations.

getEventTrigger

open override fun getEventTrigger(key: String): EventTrigger<*>?

open override fun getEventTrigger(handle: Handle, id: Int): EventTrigger<*>?

layout

fun layout(constraints: SizeConstraints)

Performs an asynchronous layout calculation with the given constraints. Uses the current resolve result if available, otherwise performs an async resolve first.

layoutSync

fun layoutSync(constraints: SizeConstraints): LayoutState

Performs a synchronous layout calculation with the given constraints. Uses the current resolve result if available, otherwise performs an inline resolve.

maybePromoteCommittedLayoutStateToUI

@UiThread

@Synchronized

fun maybePromoteCommittedLayoutStateToUI(layoutState: LayoutState?): Boolean

Promotes the committed layout state to the UI thread.

onErrorComponent

open override fun onErrorComponent(component: Component?)

putCachedValue

open override fun putCachedValue(globalKey: String, index: Int, cachedValueInputs: Any, cachedValue: Any?, isLayoutState: Boolean)

Stores a Cached value that will be accessible across all re-render operations.

removePendingStateUpdate

open override fun removePendingStateUpdate(key: String, isLayoutState: Boolean)

Removes a state update that was previously enqueued if the state update has not been processed yet.

render

fun render(root: Component, constraints: SizeConstraints)

Performs an asynchronous resolution and layout in one call, which is a non-blocking operation.

renderSync

fun renderSync(root: Component, constraints: SizeConstraints): LayoutState

Performs a synchronous resolution and layout in one call. This is a blocking operation that completes the entire rendering pipeline.

request

open override fun request(update: PendingStateUpdate<*>)

resolve

fun resolve(root: Component)

Initiates an asynchronous resolution process for a component.

unbind

@UiThread

fun unbind()

updateHookStateAsync

open override fun updateHookStateAsync(stateId: StateId, updateBlock: HookUpdater, attribution: String?, isLayoutState: Boolean)

Same as updateStateAsync but for Hook State.

updateHookStateSync

open override fun updateHookStateSync(stateId: StateId, updateBlock: HookUpdater, attribution: String?, isLayoutState: Boolean)

Same as updateStateSync but for Hook State.

updateStateAsync

open override fun updateStateAsync(globalKey: String, stateUpdate: StateContainer.StateUpdate, attribution: String?, isLayoutState: Boolean)

Enqueues a state update that will schedule a new render on a Thread controlled by the Litho infrastructure.

updateStateLazy

open override fun updateStateLazy(globalKey: String, stateUpdate: StateContainer.StateUpdate, isLayoutState: Boolean)

Enqueues a state update that will not schedule a new render. The new state will immediately be visible in Event Handlers and it will be visible in the next render phase.

updateStateSync

open override fun updateStateSync(globalKey: String, stateUpdate: StateContainer.StateUpdate, attribution: String?, isLayoutState: Boolean)

Enqueues a state update that will schedule a new render on the calling thread at the end of its current run-loop. It is expected that the calling thread has an active Looper.