ComponentContext

java.lang.Object
- com.facebook.litho.ComponentContext

All Implemented Interfaces:

java.lang.Cloneable

Direct Known Subclasses:

SectionContext
```
public class ComponentContext
extends java.lang.Object
implements java.lang.Cloneable
```
A Context subclass for use within the Components framework. Contains extra bookkeeping information used internally in the library.

Constructor Summary

Constructors
Constructor and Description
`ComponentContext(ComponentContext context, TreeProps treeProps)`
`ComponentContext(Context context)`
`ComponentContext(Context context, java.lang.String logTag, ComponentsLogger logger)` Constructor that can be used to receive log data from components.
`ComponentContext(Context context, java.lang.String logTag, ComponentsLogger logger, TreeProps treeProps)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`StateContainer`	`applyLazyStateUpdatesForContainer(StateContainer container)`
`long`	`calculateLayoutOutputId(java.lang.String componentKey, int type)` Calculates a returns a unique ID for a given component key and output type.
`void`	`clearCalculationStateContext()`
`protected ComponentContext`	`clone()`
`<T extends View> T`	`findViewWithTag(java.lang.Object tag)` A utility function to find the View with a given tag under the current Component's LithoView.
`Context`	`getAndroidContext()`
`Context`	`getApplicationContext()`
`java.lang.Object`	`getCachedValue(java.lang.Object cachedValueInputs)`
`int`	`getColor(int id)`
`Component`	`getComponentScope()`
`EventHandler<ErrorEvent>`	`getErrorEventHandler()`
`java.lang.String`	`getGlobalKey()`
`LayoutStateContext`	`getLayoutStateContext()`
`TreeFuture`	`getLayoutStateFuture()`
`int`	`getLayoutVersion()`
`ComponentsLogger`	`getLogger()`
`java.lang.String`	`getLogTag()`
`Looper`	`getMainLooper()`
`static RunnableHandler`	`getMountContentPreallocationHandler(ComponentContext c)`
`<T> T`	`getParentTreeProp(java.lang.Class<T> key)`
`TreeProps`	`getParentTreeProps()`
`RenderStateContext`	`getRenderStateContext()`
`ResourceCache`	`getResourceCache()`
`ResourceResolver`	`getResourceResolver()`
`Resources`	`getResources()`
`ScopedComponentInfo`	`getScopedComponentInfo()`
`java.lang.String`	`getString(int resId)`
`java.lang.String`	`getString(int resId, java.lang.Object... formatArgs)`
`java.lang.CharSequence`	`getText(int resId)`
`<T> T`	`getTreeProp(java.lang.Class<T> key)`
`TreeProps`	`getTreeProps()`
`TreeProps`	`getTreePropsCopy()` Obtain a copy of the tree props currently held by this context.
`static boolean`	`isIncrementalMountEnabled(ComponentContext c)` Checks if incremental mount is enabled given a ComponentContext, so you can throw an error if you require that incremental mount is enabled (e.g.
`protected boolean`	`isParentTreePropsCloned()`
`boolean`	`isReconciliationEnabled()`
`static boolean`	`isVisibilityProcessingEnabled(ComponentContext c)`
`static ComponentContext`	`makeCopyForNestedTree(ComponentContext parentTreeContext)` Creates a new ComponentContext based on the given ComponentContext, propagating log tag, logger, and tree props.
`<E> EventHandler<E>`	`newEventHandler(int id, java.lang.Object[] params)`
`TypedArray`	`obtainStyledAttributes(int[] attrs, int defStyleAttr)`
`void`	`putCachedValue(java.lang.Object cachedValueInputs, java.lang.Object cachedValue)`
`void`	`setLayoutStateContext(LayoutStateContext layoutStateContext)`
`void`	`setLayoutStateContextForTesting()`
`void`	`setParentTreeProps(TreeProps treeProps)`
`protected void`	`setParentTreePropsCloned(boolean isParentTreePropsCloned)`
`void`	`setRenderStateContext(RenderStateContext renderStateContext)`
`RenderStateContext`	`setRenderStateContextForTests()` For test usage.
`void`	`setTreeProps(TreeProps treeProps)`
`void`	`updateStateAsync(StateContainer.StateUpdate stateUpdate, java.lang.String attribution)` Notify the Component Tree that it needs to asynchronously perform a state update.
`void`	`updateStateLazy(StateContainer.StateUpdate stateUpdate)`
`void`	`updateStateSync(StateContainer.StateUpdate stateUpdate, java.lang.String attribution)` Notify the Component Tree that it needs to synchronously perform a state update.
`void`	`updateStateWithTransition(StateContainer.StateUpdate stateUpdate, java.lang.String attribution)`
`static ComponentContext`	`withComponentScope(ComponentContext parentContext, Component scope, java.lang.String globalKey)` Creates a new ComponentContext instance scoped to the given component and sets it on the component.
`static ComponentContext`	`withComponentTree(ComponentContext context, ComponentTree componentTree)` Creates a new ComponentContext instance and sets the `ComponentTree` on the component.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ComponentContext
```
public ComponentContext(Context context)
```
  - ComponentContext
```
public ComponentContext(Context context,
                        java.lang.String logTag,
                        ComponentsLogger logger)
```
    Constructor that can be used to receive log data from components. Check ComponentsLogger for the type of events you can listen for.
    
    Parameters:
    
    context - Android context.
    
    logTag - a log tag to be used with the logger.
    
    logger - a lifecycle logger to be used.
  - ComponentContext
```
public ComponentContext(Context context,
                        java.lang.String logTag,
                        ComponentsLogger logger,
                        TreeProps treeProps)
```
  - ComponentContext
```
public ComponentContext(ComponentContext context,
                        TreeProps treeProps)
```
- Method Detail
  - withComponentTree
```
public static ComponentContext withComponentTree(ComponentContext context,
                                                 ComponentTree componentTree)
```
    Creates a new ComponentContext instance and sets the ComponentTree on the component.
    
    Parameters:
    
    context - context scoped to the parent component
    
    componentTree - component tree associated with the newly created context
    
    Returns:
    
    a new ComponentContext instance
  - withComponentScope
```
public static ComponentContext withComponentScope(ComponentContext parentContext,
                                                  Component scope,
                                                  java.lang.String globalKey)
```
    Creates a new ComponentContext instance scoped to the given component and sets it on the component.
    
    Parameters:
    
    parentContext - context scoped to the parent component
    
    scope - component associated with the newly created scoped context
    
    Returns:
    
    a new ComponentContext instance scoped to the given component
  - makeCopyForNestedTree
```
public static ComponentContext makeCopyForNestedTree(ComponentContext parentTreeContext)
```
    Creates a new ComponentContext based on the given ComponentContext, propagating log tag, logger, and tree props. This should be used when creating a ComponentContext for a nested ComponentTree (e.g. see HorizontalScrollSpec).
  - setLayoutStateContext
```
public void setLayoutStateContext(LayoutStateContext layoutStateContext)
```
  - clearCalculationStateContext
```
public void clearCalculationStateContext()
```
  - setLayoutStateContextForTesting
```
public void setLayoutStateContextForTesting()
```
  - setRenderStateContextForTests
```
public RenderStateContext setRenderStateContextForTests()
```
    For test usage. This method will ensure this ComponentContext has a ComponentTree, and then generate a RenderStateContext, set it on the ComponentTree, and return the same RSC. This is critical for tests that trigger layout calculation functionality outside of a LayoutState calculation (i.e., including willRender, Layout API, caching, etc).
  - setRenderStateContext
```
public void setRenderStateContext(RenderStateContext renderStateContext)
```
  - getAndroidContext
```
public final Context getAndroidContext()
```
  - getApplicationContext
```
public final Context getApplicationContext()
```
  - getResources
```
public Resources getResources()
```
  - getResourceResolver
```
public ResourceResolver getResourceResolver()
```
  - getMainLooper
```
public final Looper getMainLooper()
```
  - getText
```
public java.lang.CharSequence getText(int resId)
```
  - getString
```
public java.lang.String getString(int resId)
```
  - getString
```
public java.lang.String getString(int resId,
                                  java.lang.Object... formatArgs)
```
  - getColor
```
public int getColor(int id)
```
  - getComponentScope
```
public Component getComponentScope()
```
  - getGlobalKey
```
public java.lang.String getGlobalKey()
```
  - getErrorEventHandler
```
public EventHandler<ErrorEvent> getErrorEventHandler()
```
  - getLayoutStateFuture
```
public TreeFuture getLayoutStateFuture()
```
  - updateStateSync
```
public void updateStateSync(StateContainer.StateUpdate stateUpdate,
                            java.lang.String attribution)
```
    Notify the Component Tree that it needs to synchronously perform a state update.
    
    Parameters:
    
    stateUpdate - state update to perform
  - updateStateAsync
```
public void updateStateAsync(StateContainer.StateUpdate stateUpdate,
                             java.lang.String attribution)
```
    Notify the Component Tree that it needs to asynchronously perform a state update.
    
    Parameters:
    
    stateUpdate - state update to perform
  - updateStateWithTransition
```
public void updateStateWithTransition(StateContainer.StateUpdate stateUpdate,
                                      java.lang.String attribution)
```
  - updateStateLazy
```
public void updateStateLazy(StateContainer.StateUpdate stateUpdate)
```
  - applyLazyStateUpdatesForContainer
```
public StateContainer applyLazyStateUpdatesForContainer(StateContainer container)
```
    Returns:
    
    A StateContainer with lazy state updates applied. This may be the same container passed in if there were no updates to apply. This method won't mutate the passed container.
  - obtainStyledAttributes
```
public TypedArray obtainStyledAttributes(int[] attrs,
                                         int defStyleAttr)
```
  - getLogTag
```
public java.lang.String getLogTag()
```
  - getLogger
```
public ComponentsLogger getLogger()
```
  - findViewWithTag
```
public <T extends View> T findViewWithTag(java.lang.Object tag)
```
    A utility function to find the View with a given tag under the current Component's LithoView. To set a view tag, use the .viewTag() common prop or Style.viewTag. An appropriate time to call this is in your Component's onVisible callback.
    As with View.findViewWithTag in general, this must be called on the main thread.
    Note that null may be returned if the associated View doesn't exist or isn't mounted: with incremental mount turned on (which is the default), if the component is off-screen, it won't be mounted.
    Finally, note that you should never hold a reference to the view returned by this function as Litho may unmount your Component and mount it to a different View.
  - calculateLayoutOutputId
```
public long calculateLayoutOutputId(java.lang.String componentKey,
                                    int type)
```
    Calculates a returns a unique ID for a given component key and output type. The IDs will be unique for components in the ComponentTree this ID generator is linked with. If an ID was already generated for a given component, the same ID will be returned. Otherwise, a new unique ID will be generated.
    ComponentContext must have a ComponentTree instance.
    
    Parameters:
    
    componentKey - The component key
    
    type - The output type @see OutputUnitType
  - setTreeProps
```
public void setTreeProps(TreeProps treeProps)
```
  - setParentTreeProps
```
public void setParentTreeProps(TreeProps treeProps)
```
  - getTreeProps
```
public TreeProps getTreeProps()
```
  - getParentTreeProps
```
public TreeProps getParentTreeProps()
```
  - isParentTreePropsCloned
```
protected boolean isParentTreePropsCloned()
```
    Returns:
    
    true if parent's TreeProps are cloned and assigned to mTreeProps. Notice this method should be accessed by Kotlin API only.
  - setParentTreePropsCloned
```
protected void setParentTreePropsCloned(boolean isParentTreePropsCloned)
```
  - getTreeProp
```
public <T> T getTreeProp(java.lang.Class<T> key)
```
  - getParentTreeProp
```
public <T> T getParentTreeProp(java.lang.Class<T> key)
```
  - getTreePropsCopy
```
public TreeProps getTreePropsCopy()
```
    Obtain a copy of the tree props currently held by this context.
  - getLayoutVersion
```
public int getLayoutVersion()
```
  - getResourceCache
```
public ResourceCache getResourceCache()
```
  - newEventHandler
```
public <E> EventHandler<E> newEventHandler(int id,
                                           java.lang.Object[] params)
```
  - getCachedValue
```
public java.lang.Object getCachedValue(java.lang.Object cachedValueInputs)
```
  - putCachedValue
```
public void putCachedValue(java.lang.Object cachedValueInputs,
                           java.lang.Object cachedValue)
```
  - isIncrementalMountEnabled
```
public static boolean isIncrementalMountEnabled(ComponentContext c)
```
    Checks if incremental mount is enabled given a ComponentContext, so you can throw an error if you require that incremental mount is enabled (e.g. you use visibility callbacks). This is static to avoid polluting the ComponentContext API.
  - getMountContentPreallocationHandler
```
public static RunnableHandler getMountContentPreallocationHandler(ComponentContext c)
```
  - isVisibilityProcessingEnabled
```
public static boolean isVisibilityProcessingEnabled(ComponentContext c)
```
  - isReconciliationEnabled
```
public boolean isReconciliationEnabled()
```
  - getLayoutStateContext
```
public LayoutStateContext getLayoutStateContext()
```
  - getRenderStateContext
```
public RenderStateContext getRenderStateContext()
```
  - getScopedComponentInfo
```
public ScopedComponentInfo getScopedComponentInfo()
```
  - clone
```
protected ComponentContext clone()
```
    Overrides:
    
    clone in class java.lang.Object

Class ComponentContext

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ComponentContext

ComponentContext

ComponentContext

ComponentContext

Method Detail

withComponentTree

withComponentScope

makeCopyForNestedTree

setLayoutStateContext

clearCalculationStateContext

setLayoutStateContextForTesting

setRenderStateContextForTests

setRenderStateContext

getAndroidContext

getApplicationContext

getResources

getResourceResolver

getMainLooper

getText

getString

getString

getColor

getComponentScope

getGlobalKey

getErrorEventHandler

getLayoutStateFuture

updateStateSync

updateStateAsync

updateStateWithTransition

updateStateLazy

applyLazyStateUpdatesForContainer

obtainStyledAttributes

getLogTag

getLogger

findViewWithTag

calculateLayoutOutputId

setTreeProps

setParentTreeProps

getTreeProps

getParentTreeProps

isParentTreePropsCloned

setParentTreePropsCloned

getTreeProp

getParentTreeProp

getTreePropsCopy

getLayoutVersion

getResourceCache

newEventHandler

getCachedValue

putCachedValue

isIncrementalMountEnabled

getMountContentPreallocationHandler

isVisibilityProcessingEnabled

isReconciliationEnabled

getLayoutStateContext

getRenderStateContext

getScopedComponentInfo

clone