com.facebook.litho

Class Component

java.lang.Object

com.facebook.litho.ComponentLifecycle

com.facebook.litho.Component

All Implemented Interfaces:

Equivalence<Component>, EventDispatcher, EventTriggerTarget, HasEventDispatcher, HasEventTrigger, Cloneable

Direct Known Subclasses:

Card, CardClip, CardShadow, Column, EditText, EmptyComponent, HorizontalScroll, Image, Progress, Recycler, RecyclerCollectionComponent, Row, SizeSpecMountWrapperComponent, SolidColor, Spinner, TestComponent, TestComponent, TestNullLayoutComponent, TestSizeDependentComponent, Text, TextInput, TransparencyEnabledCard, TransparencyEnabledCardClip, VerticalScroll, ViewCompatComponent, Wrapper

public abstract class Component
extends ComponentLifecycle
implements Cloneable, HasEventDispatcher, HasEventTrigger, Equivalence<Component>

Represents a unique instance of a component. To create new Component instances, use the create() method in the generated subclass which returns a builder that allows you to set values for individual props. Component instances are immutable after creation.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Component.Builder<T extends Component.Builder<T>>
static class	Component.ContainerBuilder<T extends Component.ContainerBuilder<T>>

Nested classes/interfaces inherited from class com.facebook.litho.ComponentLifecycle

ComponentLifecycle.MountType, ComponentLifecycle.RenderData, ComponentLifecycle.TransitionContainer

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Component()
protected	Component(String simpleName)
protected	Component(String simpleName, int identityHashCode) This constructor should be called only if working with a manually crafted "special" Component.

Method Summary

Modifier and Type	Method and Description
protected void	bindDynamicProp(int dynamicPropIndex, Object value, Object content)
protected boolean	canResolve() Indicate that this component implements its own ComponentLifecycle.resolve(ComponentContext) logic instead of going through ComponentLifecycle.createComponentLayout(ComponentContext).
void	clearCachedLayout(ComponentContext c) Only use if absolutely needed! This removes the cached layout so this component will be remeasured even if it has alread been measured with the same size specs.
protected void	copyInterStageImpl(Component component)
CommonProps	getCommonProps()
protected DynamicValue[]	getDynamicProps()
EventDispatcher	getEventDispatcher() Deprecated.
protected Handle	getHandle()
protected int	getId()
protected String	getKey()
ComponentContext	getScopedContext()
String	getSimpleName() Should only be used by logging to provide more readable messages.
protected Component	getSimpleNameDelegate()
protected StateContainer	getStateContainer()
boolean	hasBackgroundSet()
boolean	hasClickHandlerSet()
boolean	isEquivalentTo(Component other) Compares this component to a different one to check if they are the same
Component	makeShallowCopy()
void	measure(ComponentContext c, int widthSpec, int heightSpec, Size outputSize) Measure a component with the given SizeSpec constrain.
void	measureMightNotCacheInternalNode(ComponentContext c, int widthSpec, int heightSpec, Size outputSize) Deprecated.
void	recordEventTrigger(EventTriggersContainer container)
protected static void	registerWorkingRange(String name, WorkingRange workingRange, Component component) Store a working range information into a list for later use by LayoutState.
protected static <T> T	retrieveValue(DynamicValue<T> dynamicValue)
void	setScopedContext(ComponentContext scopedContext)
protected void	updateInternalChildState(ComponentContext parentContext) Called to install internal state based on a component's parent context.
static boolean	willRender(ComponentContext c, Component component) Deprecated. Using willRender is regarded as an anti-pattern, since it will load all classes into memory in order to potentially decide not to use any of them.

Methods inherited from class com.facebook.litho.ComponentLifecycle

acceptTriggerEvent, applyPreviousRenderData, callsShouldUpdateOnMount, canMeasure, canPreallocate, createInitialState, createMountContent, dispatchErrorEvent, dispatchErrorEvent, dispatchOnEnteredRange, dispatchOnEvent, dispatchOnExitedRange, getEventTrigger, getEventTrigger, getExtraAccessibilityNodeAt, getExtraAccessibilityNodesCount, getMountType, getTreePropsForChildren, hasAttachDetachCallback, hasChildLithoViews, hasState, implementsAccessibility, implementsExtraAccessibilityNodes, isLayoutSpecWithSizeSpecCheck, isMountSizeDependent, isPureRender, needsPreviousRenderData, newEventHandler, newEventTrigger, onAttached, onBind, onBoundsDefined, onCreateLayout, onCreateLayoutWithSizeSpec, onCreateMountContent, onCreateMountContentPool, onCreateTransition, onDetached, onError, onLoadStyle, onMeasure, onMeasureBaseline, onMount, onPopulateAccessibilityNode, onPopulateExtraAccessibilityNode, onPrepare, onShouldCreateLayoutWithNewSizeSpec, onUnbind, onUnmount, poolSize, populateTreeProps, recordRenderData, resolve, shouldAlwaysRemeasure, shouldUpdate, shouldUseGlobalPool, transferState

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Component

protected Component()

Component

protected Component(String simpleName)

Component

protected Component(String simpleName,
                    int identityHashCode)

This constructor should be called only if working with a manually crafted "special" Component. This should NOT be used in general use cases. Use the standard Component(String) instead.

Method Detail

clearCachedLayout

public void clearCachedLayout(ComponentContext c)

Only use if absolutely needed! This removes the cached layout so this component will be remeasured even if it has alread been measured with the same size specs.

getCommonProps

public CommonProps getCommonProps()

getEventDispatcher

@Deprecated
public EventDispatcher getEventDispatcher()

Deprecated.

Specified by:

getEventDispatcher in interface HasEventDispatcher

getScopedContext

public ComponentContext getScopedContext()

setScopedContext

public void setScopedContext(ComponentContext scopedContext)

getSimpleName

public String getSimpleName()

Should only be used by logging to provide more readable messages.

hasBackgroundSet

public boolean hasBackgroundSet()

hasClickHandlerSet

public boolean hasClickHandlerSet()

isEquivalentTo

public boolean isEquivalentTo(Component other)

Compares this component to a different one to check if they are the same

This is used to be able to skip rendering a component again. We avoid using the Object.equals(Object) so we can optimize the code better over time since we don't have to adhere to the contract required for a equals method.

Specified by:

isEquivalentTo in interface Equivalence<Component>

Parameters:

other - the component to compare to

Returns:

true if the components are of the same type and have the same props

makeShallowCopy

public Component makeShallowCopy()

measure

public void measure(ComponentContext c,
                    int widthSpec,
                    int heightSpec,
                    Size outputSize)

Measure a component with the given SizeSpec constrain.

Parameters:

c - ComponentContext.

widthSpec - Width SizeSpec constrain.

heightSpec - Height SizeSpec constrain.

outputSize - Size object that will be set with the measured dimensions.

measureMightNotCacheInternalNode

@Deprecated
public void measureMightNotCacheInternalNode(ComponentContext c,
                                                         int widthSpec,
                                                         int heightSpec,
                                                         Size outputSize)

Deprecated.

Should not be used! Components should be manually measured only as part of a LayoutState calculation. This will measure a component and set the size in the outputSize object but the measurement result will not be cached and reused for future measurements of this component.

This is very inefficient because it throws away the InternalNode from measuring here and will have to remeasure when the component needs to be measured as part of a LayoutState. This will lead to suboptimal performance.

You probably don't need to use this. If you really need to measure your Component outside of a LayoutState calculation reach out to the Litho team to discuss an alternative solution.

If this is called during a LayoutState calculation, it will delegate to ComponentLifecycle.onMeasure(ComponentContext, ComponentLayout, int, int, Size), which does cache the measurement result for the duration of this LayoutState.

recordEventTrigger

public void recordEventTrigger(EventTriggersContainer container)

Specified by:

recordEventTrigger in interface HasEventTrigger

getHandle

protected Handle getHandle()

Returns:

a handle that is unique to this component.

getKey

protected String getKey()

Returns:

a key that is local to the component's parent.

bindDynamicProp

protected void bindDynamicProp(int dynamicPropIndex,
                               Object value,
                               Object content)

canResolve

protected boolean canResolve()

Indicate that this component implements its own ComponentLifecycle.resolve(ComponentContext) logic instead of going through ComponentLifecycle.createComponentLayout(ComponentContext).

copyInterStageImpl

protected void copyInterStageImpl(Component component)

getDynamicProps

protected DynamicValue[] getDynamicProps()

getId

protected int getId()

getSimpleNameDelegate

protected Component getSimpleNameDelegate()

Returns:

the Component this Component should delegate its getSimpleName calls to. See LayoutSpec#simpleNameDelegate()

getStateContainer

protected StateContainer getStateContainer()

updateInternalChildState

protected void updateInternalChildState(ComponentContext parentContext)

Called to install internal state based on a component's parent context.

willRender

@Deprecated
public static boolean willRender(ComponentContext c,
                                             Component component)

Deprecated. Using willRender is regarded as an anti-pattern, since it will load all classes into memory in order to potentially decide not to use any of them.

Returns:

whether the given component will render because it returns non-null from its resolved onCreateLayout, based on its current props and state. Returns true if the resolved layout is non-null, otherwise false.

registerWorkingRange

protected static void registerWorkingRange(String name,
                                           WorkingRange workingRange,
                                           Component component)

Store a working range information into a list for later use by LayoutState.

retrieveValue

protected static <T> T retrieveValue(DynamicValue<T> dynamicValue)