ComponentTree.Builder

java.lang.Object
- com.facebook.litho.ComponentTree.Builder

Enclosing class:

ComponentTree
```
public static class ComponentTree.Builder
extends java.lang.Object
```
A builder class that can be used to create a ComponentTree.

Constructor Summary

Constructors
Modifier Constructor and Description

protected Builder(ComponentContext context)

Constructors
Modifier	Constructor and Description
`protected`	`Builder(ComponentContext context)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`ComponentTree.Builder`	`asyncStateUpdates(boolean enabled)` Specify whether the ComponentTree allows async state updates.
`ComponentTree`	`build()` Builds a `ComponentTree` using the parameters specified in this builder.
`ComponentTree.Builder`	`canInterruptAndMoveLayoutsBetweenThreads(boolean isEnabled)` Experimental, do not use! If enabled, a layout computation can be interrupted on a bg thread and resumed on the UI thread if it's needed immediately.
`ComponentTree.Builder`	`componentsConfiguration(ComponentsConfiguration componentsConfiguration)`
`ComponentTree.Builder`	`errorHandler(ErrorEventHandler errorEventHandler)` Sets the custom ErrorEventHandler.
`ComponentTree.Builder`	`hasMounted(boolean hasMounted)` Sets whether the 'hasMounted' flag should be set on this ComponentTree (for use with appear animations).
`ComponentTree.Builder`	`incrementalMount(boolean isEnabled)` Whether or not to enable the incremental mount optimization.
`ComponentTree.Builder`	`isFirstMount(boolean isFirstMount)`
`ComponentTree.Builder`	`isReconciliationEnabled(boolean isEnabled)` Sets if reconciliation is enabled
`ComponentTree.Builder`	`layoutDiffing(boolean enabled)` Deprecated.
`ComponentTree.Builder`	`layoutThreadHandler(RunnableHandler handler)` Specify the looper to use for running layouts on.
`ComponentTree.Builder`	`layoutThreadLooper(Looper looper)` Specify the looper to use for running layouts on.
`ComponentTree.Builder`	`logger(ComponentsLogger logger, java.lang.String logTag)`
`ComponentTree.Builder`	`measureListener(ComponentTree.MeasureListener measureListener)`
`ComponentTree.Builder`	`overrideComponentTreeId(int overrideComponentTreeId)` Gives the ability to override the auto-generated ComponentTree id: this is generally not useful in the majority of circumstances, so don't use it unless you really know what you're doing.
`ComponentTree.Builder`	`overrideRenderUnitIdMap(ComponentTree prevComponentTree)` This should not be used in majority of cases and should only be used when overriding previous component tree id `overrideComponentTreeId`
`ComponentTree.Builder`	`preAllocateMountContentHandler(RunnableHandler handler)` Specify the handler for to preAllocateMountContent
`ComponentTree.Builder`	`previousRenderState(RenderState previousRenderState)` Specify an existing previous render state that the ComponentTree can use to set the current values for providing previous versions of @Prop/@State variables.
`ComponentTree.Builder`	`shouldPreallocateMountContentPerMountSpec(boolean preallocatePerMountSpec)` If true, this ComponentTree will only preallocate mount specs that are enabled for preallocation with `MountSpec#canPreallocate()`.
`ComponentTree.Builder`	`treeState(TreeState treeState)` Specify an initial tree state object that the ComponentTree can use to set the current values for states.
`ComponentTree.Builder`	`useDefaultHandlerForContentPreallocation()` Enable Mount Content preallocation using the same thread we use to compute layouts
`ComponentTree.Builder`	`visibilityProcessing(boolean isEnabled)`
`ComponentTree.Builder`	`withLithoLifecycleProvider(LithoLifecycleProvider lifecycleProvider)`
`ComponentTree.Builder`	`withRoot(Component root)` Specify root for the component tree

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

- Constructor Detail
  - Builder
```
protected Builder(ComponentContext context)
```
- Method Detail
  - componentsConfiguration
```
public ComponentTree.Builder componentsConfiguration(ComponentsConfiguration componentsConfiguration)
```
  - withRoot
```
public ComponentTree.Builder withRoot(Component root)
```
    Specify root for the component tree
    IMPORTANT: If you do not set this, a default root will be set and you can reset root after build and attach of the component tree
  - withLithoLifecycleProvider
```
public ComponentTree.Builder withLithoLifecycleProvider(LithoLifecycleProvider lifecycleProvider)
```
  - incrementalMount
```
public ComponentTree.Builder incrementalMount(boolean isEnabled)
```
    Whether or not to enable the incremental mount optimization. True by default.
    IMPORTANT: if you set this to false, visibility events will NOT FIRE. Please don't use this unless you really need to.
  - visibilityProcessing
```
public ComponentTree.Builder visibilityProcessing(boolean isEnabled)
```
  - layoutDiffing
```
@Deprecated
public ComponentTree.Builder layoutDiffing(boolean enabled)
```
    Deprecated.
    
    Whether or not to enable layout tree diffing. This will reduce the cost of updates at the expense of using extra memory. True by default.
    We will remove this option soon, please consider turning it on (which is on by default)
  - layoutThreadLooper
```
public ComponentTree.Builder layoutThreadLooper(Looper looper)
```
    Specify the looper to use for running layouts on. Note that in rare cases layout must run on the UI thread. For example, if you rotate the screen, we must measure on the UI thread. If you don't specify a Looper here, the Components default Looper will be used.
  - preAllocateMountContentHandler
```
public ComponentTree.Builder preAllocateMountContentHandler(RunnableHandler handler)
```
    Specify the handler for to preAllocateMountContent
  - useDefaultHandlerForContentPreallocation
```
public ComponentTree.Builder useDefaultHandlerForContentPreallocation()
```
    Enable Mount Content preallocation using the same thread we use to compute layouts
  - shouldPreallocateMountContentPerMountSpec
```
public ComponentTree.Builder shouldPreallocateMountContentPerMountSpec(boolean preallocatePerMountSpec)
```
    If true, this ComponentTree will only preallocate mount specs that are enabled for preallocation with MountSpec#canPreallocate(). If false, it preallocates all mount content.
  - layoutThreadHandler
```
public ComponentTree.Builder layoutThreadHandler(RunnableHandler handler)
```
    Specify the looper to use for running layouts on. Note that in rare cases layout must run on the UI thread. For example, if you rotate the screen, we must measure on the UI thread. If you don't specify a Looper here, the Components default Looper will be used.
  - treeState
```
public ComponentTree.Builder treeState(TreeState treeState)
```
    Specify an initial tree state object that the ComponentTree can use to set the current values for states.
  - previousRenderState
```
public ComponentTree.Builder previousRenderState(RenderState previousRenderState)
```
    Specify an existing previous render state that the ComponentTree can use to set the current values for providing previous versions of @Prop/@State variables.
  - asyncStateUpdates
```
public ComponentTree.Builder asyncStateUpdates(boolean enabled)
```
    Specify whether the ComponentTree allows async state updates. This is enabled by default.
  - overrideComponentTreeId
```
public ComponentTree.Builder overrideComponentTreeId(int overrideComponentTreeId)
```
    Gives the ability to override the auto-generated ComponentTree id: this is generally not useful in the majority of circumstances, so don't use it unless you really know what you're doing.
  - overrideRenderUnitIdMap
```
public ComponentTree.Builder overrideRenderUnitIdMap(ComponentTree prevComponentTree)
```
    This should not be used in majority of cases and should only be used when overriding previous component tree id overrideComponentTreeId
    
    Parameters:
    
    prevComponentTree - Previous ComponentTree to override the render unit id map
  - hasMounted
```
public ComponentTree.Builder hasMounted(boolean hasMounted)
```
    Sets whether the 'hasMounted' flag should be set on this ComponentTree (for use with appear animations).
  - isFirstMount
```
public ComponentTree.Builder isFirstMount(boolean isFirstMount)
```
  - measureListener
```
public ComponentTree.Builder measureListener(ComponentTree.MeasureListener measureListener)
```
  - isReconciliationEnabled
```
public ComponentTree.Builder isReconciliationEnabled(boolean isEnabled)
```
    Sets if reconciliation is enabled
  - errorHandler
```
public ComponentTree.Builder errorHandler(ErrorEventHandler errorEventHandler)
```
    Sets the custom ErrorEventHandler. Ignores null values to never overwrite Litho's DefaultErrorEventHandler.
  - canInterruptAndMoveLayoutsBetweenThreads
```
public ComponentTree.Builder canInterruptAndMoveLayoutsBetweenThreads(boolean isEnabled)
```
    Experimental, do not use! If enabled, a layout computation can be interrupted on a bg thread and resumed on the UI thread if it's needed immediately.
  - logger
```
public ComponentTree.Builder logger(ComponentsLogger logger,
                                    java.lang.String logTag)
```
  - build
```
public ComponentTree build()
```
    Builds a ComponentTree using the parameters specified in this builder.

Class ComponentTree.Builder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Builder

Method Detail

componentsConfiguration

withRoot

withLithoLifecycleProvider

incrementalMount

visibilityProcessing

layoutDiffing

layoutThreadLooper

preAllocateMountContentHandler

useDefaultHandlerForContentPreallocation

shouldPreallocateMountContentPerMountSpec

layoutThreadHandler

treeState

previousRenderState

asyncStateUpdates

overrideComponentTreeId

overrideRenderUnitIdMap

hasMounted

isFirstMount

measureListener

isReconciliationEnabled

errorHandler

canInterruptAndMoveLayoutsBetweenThreads

logger

build