Package com.facebook.litho

Interface Summary

Interface	Description
AnimatableItem	Interface used to expose a limited API to the animations package.
CommonProps	Common props that are accessible outside of the framework.
ComponentLayout	Represents a Component's computed layout state.
ComponentLifecycle.RenderData	A per-Component-class data structure to keep track of some of the last mounted @Prop/@State params a component was rendered with.
ComponentLifecycle.TransitionContainer	Generated component's state container could implement this interface along with StateContainer when componentspec specifies state update method with OnUpdateStateWithTransition annotation.
ComponentsLogger	An interface for logging events and performance events in litho as well as in user defined components.
ComponentsSystrace.ArgsBuilder	Object that accumulates arguments.
ComponentsSystrace.Systrace
ComponentTree.MeasureListener
ComponentTree.NewLayoutStateReadyListener	Listener that will be notified when a new LayoutState is computed and ready to be committed to this ComponentTree.
Copyable<T>
CopyableLayoutProps
DebugComponent.Overrider
DebugComponentDescriptionHelper.ExtraDescription	An interface for callsite to append extra description into StringBuilder by given DebugComponent.
DeprecatedLithoTooltip	Defines a tooltip that can be passed to the ComponentTree to be anchored to a component.
DerivedDynamicValue.Modifier<I,O>
DiffNode	A lightweight representation of a layout node, used to cache measurements between two Layout tree calculations.
EndToEndTestingExtension.EndToEndTestingExtensionInput
Equivalence<T>	Equivalence is a Component/Section concept to have a custom equal-like method.
EventDispatcher	A class implementing this interface will expose a method to dispatch an Event given an EventHandler.
EventTriggerTarget	A class implementing this interface wll expose a method annotated with OnTrigger to accept an Event given an EventTrigger
FrameworkLogEvents	Set of events and event params logged by the framework if a ComponentsLogger was supplied to the ComponentContext used to create the tree.
FutureInstrumenter.Instrumenter
HandlerInstrumenter.Instrumenter
HasEventDispatcher	A class implementing this interface will expose a method to retrieve an EventDispatcher.
HasEventTrigger	A class implementing this interface will expose a method to record all the EventTrigger into a EventTriggersContainer
HasLithoViewChildren	An interface that a mountable view can extend which informs that this mountable content has other LithoView children.
HookInitializer<T>	Interface for a block of code that will initialize a hook value.
HookUpdater	EXPERIMENTAL - interface for a block of code that will update state created with useState.
ImageContent	A UI element that contains simple resource drawables.
InternalNode	Internal class representing a ComponentLayout.
InternalNode.NestedTreeHolder	The API for the nested tree holder, which is used to hold the partial results of an unresolved node which will be resolved after layout calculation for components which implement OnCreateLayoutWithSizeSpec.
InterStagePropsContainer	Container for inter-stage props.
LithoHandler	The Litho handler is responsible for scheduling computations on a ComponentTree.
LithoLayoutResult	The Node.LayoutResult class for Litho
LithoLayoutResult.NestedTreeHolderResult	Holds the LithoLayoutResult for InternalNode.NestedTreeHolder
LithoTooltip
LithoView.LayoutManagerOverrideParams	LayoutParams that override the LayoutManager.
LithoView.OnDirtyMountListener
LithoView.OnPostDrawListener
MountContentPool<T>	A pool dedicated to recycling mount content.
NodeConfig.InternalNodeFactory
NodeConfig.InternalYogaNodeFactory
NodeInfo	NodeInfo holds information that are set to the InternalNode and needs to be used while mounting a MountItem in MountState.
PerfEvent	A logging event created through ComponentsLogger.newPerformanceEvent(ComponentContext, int) to track performance metrics in the framework.
PoolWithDebugInfo	A object pool that has debug info for display in tools like Stetho.
RootWrapperComponentFactory	Takes a component and returns a new component that it is wrapped in.
TextContent	A UI element that contains text.
Touchable	Any interface for mounted items that need to capture motion events from its ComponentHost.
Transition.TransitionAnimator	Class that knows how to create a TransitionAnimationBinding given a PropertyAnimation.
TransitionManager.OnAnimationCompleteListener<T>	A listener that will be invoked when a mount content has stopped animating.
WorkContinuationInstrumenter.Instrumenter	Allows to record work being continued across threads.
WorkingRange

Class Summary

Class	Description
AccessibilityRole	A list of all roles used for accessibility.
AccessibilityUtils
Animations
Animations.AnimationBuilder
Animations.DynamicValueBindingBuilder
AnimationsDebug	Utilities for animations debug.
ArrayBatchAllocator
AttachDetachHandler	A handler stores components that have implemented OnAttached or OnDetached delegate methods.
BaseMatcher<T extends BaseMatcher<T>>	Base class used to share common properties used in TestSpec builders.
BaseMatcherBuilder
BenchmarkTestHelper	Helper class to access Litho internals for benchmark testing.
Border	Represents a collection of attributes that describe how a border should be applied to a layout
Border.Builder
BoundaryWorkingRange	An implementation of working range that uses offset to define the upper bound and the lower boundary.
ClickEvent	Components should implement an event of this type in order to receive Android click events.
Column	A Component that renders its children in a column.
Column.Builder
CommonUtils
Component	Represents a unique instance of a component.
Component.Builder<T extends Component.Builder<T>>
Component.ContainerBuilder<T extends Component.ContainerBuilder<T>>
ComponentContext	A Context subclass for use within the Components framework.
ComponentHost	A ViewGroup that can host the mounted state of a Component.
ComponentKeyUtils
ComponentLifecycle	ComponentLifecycle is extended by the Component class and declare methods used by a Component instances to calculate their layout bounds and mount elements, among other things.
ComponentLogParams	Data class for params used to log error in LithoView.
ComponentsLifecycles	Callbacks that must be invoked to avoid leaking memory if using Components below ICS (API level 14).
ComponentsPools	Pools of recycled resources.
ComponentsReporter	This is intended as a hook into android.util.Log, but allows you to provide your own functionality.
ComponentsSystrace	This is intended as a hook into android.os.Trace, but allows you to provide your own functionality.
ComponentTree	Represents a tree of components and controls their life cycle.
ComponentTree.Builder	A builder class that can be used to create a ComponentTree.
ComponentTreeDumpingHelper	Helper class in charge of dumping the component hierarchy related to a provided ComponentContext
ComponentUtils
ContextUtils
DebugComponent	A DebugComponent represents a node in Litho's component hierarchy.
DebugComponentDescriptionHelper	Describes DebugComponents for use in testing and debugging.
DebugComponentTimeMachine	This class provides the means to save and restore ComponentTrees for time-traveling debugging.
DebugComponentTimeMachine.TreeRevision
DebugComponentTimeMachine.TreeRevisions
DebugHierarchy	DebugHierarchy provides a light(er) weight way to track and access information about the component parentage of a given MountItem.
DebugHierarchy.Node
DebugLayoutNode	A DebugLayoutNode is a wrapper around InternalNode which allows debug tools to inspect and mutate internal nodes without making InternalNode a public class.
DebugMetadata	DebugMetadata is a special class that allows custom key-value pairs to be appended to LithoMetadataExceptionWrapper when it wraps an exception.
DebugOverlayDrawable	Based on the content of the #mainThreadCalculations draws a row of columns starting from the top left corner with text representing the number of columns.
DefaultComponentsReporter
DefaultComponentsSystrace
DefaultDiffNode
DefaultErrorEventHandler	Default implementation of ErrorEvent handler.
DefaultInternalNode	Default implementation of InternalNode.
DefaultLithoHandlerDynamicPriority	LithoHandler implementation backed by a HandlerThread, which allows changing the priority of a HandlerThread.
DefaultMountContentPool	The default MountContentPool used for mount content unless your MountSpec implements @OnCreateMountContentPool.
DefaultNestedTreeHolder	This class is a placeholder for the unresolved layout and result of a Components which implement the OnCreateLayoutWithSizeSpec.The TreeProps, padding and border width properties and held separately so that they can be copied into the actual nested tree layout before measuring it.
DelayTransitionSet	A TransitionSet that, however, designed to have exactly one transition child to which the specified apply would be applied
DelegatingEventHandler<E>	An event handler that takes two event handlers and calls both of them when an event is dispatched.
DerivedDynamicValue<I,O>	Allows a new DynamicValue to be derived from an existing DynamicValue, with modifications applied.
Diff<T>	Represents a diff between two T values.
DisabledMountContentPool	A MountContentPool that has no size and doesn't recycle objects.
DispatchPopulateAccessibilityEventEvent	Components should implement an event of this type in order to receive callbacks to View#dispatchPopulateAccessibilityEvent(AccessibilityEvent)
DoubleMeasureFixUtil
DrawableMatrix	Static class containing a factory method for creating a matrix to apply to a drawable.
DynamicPropsExtension
DynamicPropsManager	Takes care of dynamic Props
DynamicValue<T>	Class represents a DynamicValue, and provides users with ability to change the value, by exposing one public method DynamicValue.set(Object) It also allows attaching listeners (package level access), and takes care of notifying them when the held value changes.
Edges
EndToEndTestingExtension
EquivalenceUtils
ErrorBoundariesConfiguration	Temporary internal settings augmenting ComponentsConfiguration.
ErrorEvent	An event used internally to propagate exceptions up the hierarchy.
ErrorEventHandler	This class is an error event handler that clients can optionally set on a ComponentTree to gracefully handle uncaught/unhandled exceptions thrown from the framework while resolving a layout.
EventHandler<E>
EventHandlersController	Manages the mapping of event handlers to dispatchers.
EventHandlersController.EventHandlersWrapper	Used to hold a dispatcher's event handlers.
EventTrigger<E>	Allows a top-down communication with a component and its immediate parent.
EventTriggersContainer	Keeps all valid instances of EventTrigger from the hierarchy when the layout is completed
ExecutorLithoHandler	A LithoHandler implementation that runs all layout computations against the provided Executor.
FastMath	Implements some math functions in a faster way than the java Math package.
FocusChangedEvent	Event triggered when focus changes on a Component.
FocusedVisibleEvent	Event triggered when a Component enters the Focused Range.
FullImpressionVisibleEvent	Event triggered when a Component enters the Full Impression Range.
FutureInstrumenter	Provides common instrumentation for Future(s) and related implementations.
Handle	Instances of this class are used to uniquely identify Components for triggering external events including showing a LithoTooltip or triggering an event.
HandlerInstrumenter
InitialStateContainer	The InitialStateContainer is a lookaside table used by a ComponentTree to create initial states for Components.
InterceptTouchEvent	Components should implement an event of this type in order to intercept Android touch events.
InternalNodeUtils
InvisibleEvent	Event triggered when a Component becomes invisible.
LayoutPriorityThreadPoolExecutor	A ThreadPoolExecutor that schedules tasks based on priority.
LayoutPriorityThreadPoolExecutor.ComparableFutureTask<T>
LayoutState	The main role of LayoutState is to hold the output of layout calculation.
LayoutStateContext	Wraps objects which should only be available for the duration of a LayoutState, to access them in other classes such as ComponentContext during layout state calculation.
LayoutThreadPoolConfigurationImpl	Configures a thread pool used for layout calculations.
LayoutThreadPoolExecutor	Thread pool executor implementation used to calculate layout on multiple background threads.
LithoDebugInfo	A set of methods which expose internals of the framework.
LithoGestureDetector	Simple wrapper of GestureDetector to be used in Litho lifecycle methods.
LithoHandler.DefaultLithoHandler	Default implementation of the LithoHandler which simply wraps an Handler.
LithoHostListenerCoordinator	Helper for dispatching events to multiple MountListenerExtensions in Litho.
LithoMountData	This class hosts any extra mount data related to MountItem.
LithoRenderUnit	This RenderUnit encapsulates a Litho output to be mounted using Render Core.
LithoRenderUnit.LithoBindBinder
LithoRenderUnit.LithoMountBinder
LithoRenderUnitFactory
LithoStartupLogger	Logger for tracking Litho events happening during startup.
LithoTooltipController
LithoView	A ViewGroup that can host the mounted state of a Component.
LithoViewAttributesExtension
LithoViewTestHelper	Helper class to access metadata from LithoView that is relevant during end to end tests.
LithoViewTestHelper.InternalNodeRef	Holds an opaque reference to an InternalNode without giving the holder any access to it.
LithoYogaBaselineFunction
LithoYogaMeasureFunction
LogTreePopulator	This class provides utilities for extracting information through ComponentsLogger.getExtraAnnotations(TreeProps) and transforming them so they can be logged.
LongClickEvent	Components should implement an event of this type in order to receive Android long click events.
MatrixDrawable<T extends Drawable>	A Drawable that wraps another drawable.
MeasureComparisonUtils	An utility class to verify that an old measured size is still compatible to be used with a new measureSpec.
NodeConfig	A helper class that defines a configurable sizes for ComponentsPools.
NodeInfoUtils
NoOpEventHandler<E>
NoOpPerfEvent	Empty implementation of PerfEvent performing no actions.
OnInitializeAccessibilityEventEvent	Components should implement an event of this type in order to receive callbacks to androidx.core.view.AccessibilityDelegateCompat#onInitializeAccessibilityEvent( View, AccessibilityEvent)
OnInitializeAccessibilityNodeInfoEvent	Components should implement an event of this type in order to receive callbacks to androidx.core.view.AccessibilityDelegateCompat#onInitializeAccessibilityNodeInfo( View, AccessibilityNodeInfoCompat)
OnPopulateAccessibilityEventEvent	Components should implement an event of this type in order to receive callbacks to androidx.core.view.AccessibilityDelegateCompat#onPopulateAccessibilityEvent( View, AccessibilityEvent)
OnRequestSendAccessibilityEventEvent	Components should implement an event of this type in order to receive callbacks to androidx.core.view.AccessibilityDelegateCompat#onRequestSendAccessibilityEvent( ViewGroup, View, AccessibilityEvent)
Output<T>	Type for parameters that are logical outputs.
OutputUnitsAffinityGroup<T>	A family of output units (LayoutOutputs or MountItems) generated for the same Component.
ParallelTransitionSet	A TransitionSet that runs its child transitions in parallel, optionally with a stagger.
PerformAccessibilityActionEvent	Components should implement an event of this type in order to receive callbacks to android.view.View.AccessibilityDelegate#performAccessibilityAction(View, int, Bundle)
PoolBisectUtil	A utility to help with bisecting a problem with mount content pooling.
RecyclePool<T>	Used to recycle objects in Litho.
RenderCompleteEvent	An Event that is triggered when a component is render complete.
RenderState	Keeps track of the last mounted @Prop/@State a component was rendered with for components that care about them (currently, this is just for ComponentSpecs that use Diff's of props in any of their lifecycle methods).
ResourceCache
ResourceResolver
Row	A Component that renders its children in a row.
Row.Builder
SendAccessibilityEventEvent	Components should implement an event of this type in order to receive callbacks to androidx.core.view.AccessibilityDelegateCompat#sendAccessibilityEvent(View, int)
SendAccessibilityEventUncheckedEvent	Components should implement an event of this type in order to receive callbacks to androidx.core.view.AccessibilityDelegateCompat#sendAccessibilityEventUnchecked( View, AccessibilityEvent)
SequenceTransitionSet	A TransitionSet that runs its child transitions in sequence, one after another.
Size	Public API for MeasureOutput.
StateContainer	Implemented by the class used to store state within both Components and Sections to store state.
StateContainer.StateUpdate
StateHandler	Holds information about the current State of the components in a Component Tree.
StateValue<T>	Used to represent the value of a Component's State.
TestComponent	Deprecated Use ComponentAssert APIs instead.
TestItem	Holds information about a TestOutput.
TestItem.AcquireKey
TestLayoutState	Deprecated Only to be used with the deprecated ComponentTestHelper
TestPerfEvent	Implementation of PerfEvent for tests.
ThreadPoolDynamicPriorityLayoutHandler	LithoHandler implementation that uses a thread pool to calculate the layout.
ThreadPoolLayoutHandler	LithoHandler implementation that uses a thread pool to calculate the layout.
ThreadTracingRunnable	ThreadTracingRunnable tries to help debugging crashes happening across threads showing the stacktrace of the crash origin which scheduled this runnable.
ThreadUtils	Thread assertion utilities.
TouchEvent	Components should implement an event of this type in order to receive Android touch events.
Transition	Defines how a property on a component should animate as it changes, allowing you to optionally define appear-from values for appear animations and disappear-to values for disappear animations.
Transition.AnimationTarget	Specifies what components and properties a Transition should target.
Transition.AutoBoundsTransitionBuilder	Transition builder that targets every component in the component tree whose bounds have been changed.
Transition.BaseTransitionUnitsBuilder
Transition.ComponentTarget	Specifies the component(s) a Transition should target.
Transition.PropertyTarget	Specifies the property(s) a Transition should target.
Transition.RootBoundsTransition	Contains information about whether root component has bounds transition and if so whether it defines appear animation as well.
Transition.SpringTransitionAnimator	Creates spring-driven animations.
Transition.TimingTransitionAnimator	Creates timing-driven animations with the given duration.
Transition.TransitionUnit
Transition.TransitionUnitsBuilder	Transition builder that allows targeting arbitrary keys and properties.
TransitionEndEvent	Components should implement an event of this type in order to receive a callback when a Transition ends.
TransitionId	Represents a unique id used for transitions, that is assigned to AnimatableItem based on Node's transitionKey and transitionKeyType, later passed on to a MountItem, and used by com.facebook.rendercore.MountDelegate.MountDelegateTarget and TransitionManager
TransitionManager	Handles animating transitions defined by ComponentSpec's onCreateTransition code.
TransitionSet	A set of Transitions.
TransitionsExtension	Extension for performing transitions.
TreeProps	A data structure to store tree props.
UnfocusedVisibleEvent	Event triggered when a Component exits the Focused Range.
ViewCompatComponent<V extends View>	Deprecated ViewCompatComponent is not efficient as it will do measurement of views twice.
ViewCompatComponent.Builder<V extends View>
VisibilityChangedEvent	Event triggered when the visible rect of a Component changes.
VisibleEvent	Event triggered when a Component enters the Visible Range.
WorkContinuationInstrumenter	Utility class that allows to capture work continuation updates.
WorkingRangeStatusHandler	A handler that stores the range status of components with given working range.
Wrapper	Utility class for wrapping an existing Component.
Wrapper.Builder

Enum Summary

Enum	Description
ComponentLifecycle.MountType
ComponentsLogger.LogLevel
ComponentsReporter.LogLevel
RenderCompleteEvent.RenderState
TooltipPosition	Specify a position to anchor a DeprecatedLithoTooltip on a component.
Transition.TransitionKeyType

Exception Summary

Exception	Description
LithoMetadataExceptionWrapper	Exception class used to add additional Litho metadata to a crash.
LithoMountData.ReleasingReleasedMountContentException
ReThrownException

Annotation Types Summary

Annotation Type	Description
AccessibilityRole.AccessibilityRoleType
Border.Corner
ComponentTree.RecyclingMode
FrameworkLogEvents.LogEventId
LayerType	Enumerates all the valid valid for Component.Builder.layerType(int, Paint)
LayoutState.CalculateLayoutSource
NodeInfo.AccessibilityHeadingState
NodeInfo.ClickableState
NodeInfo.EnabledState
NodeInfo.FocusState
NodeInfo.SelectedState
OutputUnitType
ThreadUtils.MainThreadOverride
TransitionId.Type
WorkingRangeStatusHandler.WorkingRangeStatus