Rename fields in LithoNode

Summary: Rename fields in LithoNode

Reviewed By: astreet

Differential Revision: D78284004

fbshipit-source-id: 49fc6f85a9bea35df472151c80ccd19cfcd59fe6

Author: adityasharat

litho-core/src/main/java/com/facebook/litho/CommonProps.kt

@@ -925,22 +925,22 @@ class CommonProps : LayoutProps, Equivalence<CommonProps?> {
         node.wrapInView()
       }
       if ((privateFlags and PFLAG_VISIBLE_HANDLER_IS_SET).toLong() != 0L) {
-        node.visibleHandler(visibleHandler)
+        node.addVisibleEventListener(visibleHandler)
       }
       if ((privateFlags and PFLAG_FOCUSED_HANDLER_IS_SET).toLong() != 0L) {
-        node.focusedHandler(focusedHandler)
+        node.addFocusedVisibleEventListener(focusedHandler)
       }
       if ((privateFlags and PFLAG_FULL_IMPRESSION_HANDLER_IS_SET).toLong() != 0L) {
-        node.fullImpressionHandler(fullImpressionHandler)
+        node.addFullImpressionEventListener(fullImpressionHandler)
       }
       if ((privateFlags and PFLAG_INVISIBLE_HANDLER_IS_SET).toLong() != 0L) {
-        node.invisibleHandler(invisibleHandler)
+        node.addInvisibleEventListener(invisibleHandler)
       }
       if ((privateFlags and PFLAG_UNFOCUSED_HANDLER_IS_SET).toLong() != 0L) {
-        node.unfocusedHandler(unfocusedHandler)
+        node.addUnfocusedVisibleEventListener(unfocusedHandler)
       }
       if (privateFlags and PFLAG_VISIBILITY_CHANGED_HANDLER_IS_SET != 0) {
-        node.visibilityChangedHandler(visibilityChangedHandler)
+        node.addVisibilityChangedEventListener(visibilityChangedHandler)
       }
       if ((privateFlags and PFLAG_TRANSITION_KEY_IS_SET).toLong() != 0L) {
         node.transitionKey(transitionKey, transitionOwnerKey)

litho-core/src/main/java/com/facebook/litho/DeferredLithoNode.kt

@@ -89,22 +89,22 @@ constructor(
       target.wrapInView()
     }
     if (privateFlags and PFLAG_VISIBLE_HANDLER_IS_SET != 0L) {
-      target.visibleHandler(visibleHandler)
+      target.addVisibleEventListener(onVisible)
     }
     if (privateFlags and PFLAG_FOCUSED_HANDLER_IS_SET != 0L) {
-      target.focusedHandler(focusedHandler)
+      target.addFocusedVisibleEventListener(onFocusedVisible)
     }
     if (privateFlags and PFLAG_FULL_IMPRESSION_HANDLER_IS_SET != 0L) {
-      target.fullImpressionHandler(fullImpressionHandler)
+      target.addFullImpressionEventListener(onFullImpression)
     }
     if (privateFlags and PFLAG_INVISIBLE_HANDLER_IS_SET != 0L) {
-      target.invisibleHandler(invisibleHandler)
+      target.addInvisibleEventListener(onInvisible)
     }
     if (privateFlags and PFLAG_UNFOCUSED_HANDLER_IS_SET != 0L) {
-      target.unfocusedHandler(unfocusedHandler)
+      target.addUnfocusedVisibleEventListener(onUnfocusedVisible)
     }
     if (privateFlags and PFLAG_VISIBLE_RECT_CHANGED_HANDLER_IS_SET != 0L) {
-      target.visibilityChangedHandler(visibilityChangedHandler)
+      target.addVisibilityChangedEventListener(onVisibilityChanged)
     }
     if (testKey != null) {
       target.testKey(testKey)

litho-core/src/main/java/com/facebook/litho/LithoNode.kt

@@ -137,22 +137,22 @@ open class LithoNode : Node<LithoLayoutContext>, Cloneable {
   var nodeInfo: NodeInfo? = null
     internal set
 
-  var visibleHandler: EventHandler<VisibleEvent>? = null
+  var onVisible: EventHandler<VisibleEvent>? = null
     internal set
 
-  var focusedHandler: EventHandler<FocusedVisibleEvent>? = null
+  var onFocusedVisible: EventHandler<FocusedVisibleEvent>? = null
     internal set
 
-  var unfocusedHandler: EventHandler<UnfocusedVisibleEvent>? = null
+  var onUnfocusedVisible: EventHandler<UnfocusedVisibleEvent>? = null
     internal set
 
-  var fullImpressionHandler: EventHandler<FullImpressionVisibleEvent>? = null
+  var onFullImpression: EventHandler<FullImpressionVisibleEvent>? = null
     internal set
 
-  var invisibleHandler: EventHandler<InvisibleEvent>? = null
+  var onInvisible: EventHandler<InvisibleEvent>? = null
     internal set
 
-  var visibilityChangedHandler: EventHandler<VisibilityChangedEvent>? = null
+  var onVisibilityChanged: EventHandler<VisibilityChangedEvent>? = null
     internal set
 
   var background: Drawable? = null
@@ -680,28 +680,13 @@ open class LithoNode : Node<LithoLayoutContext>, Cloneable {
     flexDirection = direction
   }
 
-  fun focusedHandler(focusedHandler: EventHandler<FocusedVisibleEvent>?) {
-    privateFlags = privateFlags or PFLAG_FOCUSED_HANDLER_IS_SET
-    this.focusedHandler = addVisibilityHandler(this.focusedHandler, focusedHandler)
-  }
-
   fun layerType(@LayerType type: Int, paint: Paint?) {
     if (type != LayerType.LAYER_TYPE_NOT_SET) {
       layerType = type
       layerPaint = paint
     }
   }
 
-  fun visibilityOutputTag(visibilityOutputTag: String?) {
-    this.visibilityOutputTag = visibilityOutputTag
-  }
-
-  fun fullImpressionHandler(fullImpressionHandler: EventHandler<FullImpressionVisibleEvent>?) {
-    privateFlags = privateFlags or PFLAG_FULL_IMPRESSION_HANDLER_IS_SET
-    this.fullImpressionHandler =
-        addVisibilityHandler(this.fullImpressionHandler, fullImpressionHandler)
-  }
-
   fun getChildAt(index: Int): LithoNode = children[index]
 
   fun mutableNodeInfo(): NodeInfo {
@@ -758,20 +743,6 @@ open class LithoNode : Node<LithoLayoutContext>, Cloneable {
 
   fun hasTransitionKey(): Boolean = !transitionKey.isNullOrEmpty()
 
-  fun hasVisibilityHandlers(): Boolean =
-      visibleHandler != null ||
-          focusedHandler != null ||
-          unfocusedHandler != null ||
-          fullImpressionHandler != null ||
-          invisibleHandler != null ||
-          visibilityChangedHandler != null
-
-  fun invisibleHandler(invisibleHandler: EventHandler<InvisibleEvent>?): LithoNode {
-    privateFlags = privateFlags or PFLAG_INVISIBLE_HANDLER_IS_SET
-    this.invisibleHandler = addVisibilityHandler(this.invisibleHandler, invisibleHandler)
-    return this
-  }
-
   fun justifyContent(justifyContent: YogaJustify) {
     this.justifyContent = justifyContent
   }
@@ -817,20 +788,35 @@ open class LithoNode : Node<LithoLayoutContext>, Cloneable {
     transitionKeyType = type
   }
 
-  fun unfocusedHandler(unfocusedHandler: EventHandler<UnfocusedVisibleEvent>?) {
+  fun addUnfocusedVisibleEventListener(callback: EventHandler<UnfocusedVisibleEvent>?) {
     privateFlags = privateFlags or PFLAG_UNFOCUSED_HANDLER_IS_SET
-    this.unfocusedHandler = addVisibilityHandler(this.unfocusedHandler, unfocusedHandler)
+    this.onUnfocusedVisible = addVisibilityHandler(this.onUnfocusedVisible, callback)
   }
 
-  fun visibilityChangedHandler(visibilityChangedHandler: EventHandler<VisibilityChangedEvent>?) {
+  fun addVisibilityChangedEventListener(callback: EventHandler<VisibilityChangedEvent>?) {
     privateFlags = privateFlags or PFLAG_VISIBLE_RECT_CHANGED_HANDLER_IS_SET
-    this.visibilityChangedHandler =
-        addVisibilityHandler(this.visibilityChangedHandler, visibilityChangedHandler)
+    this.onVisibilityChanged = addVisibilityHandler(this.onVisibilityChanged, callback)
   }
 
-  fun visibleHandler(visibleHandler: EventHandler<VisibleEvent>?) {
+  fun addVisibleEventListener(callback: EventHandler<VisibleEvent>?) {
     privateFlags = privateFlags or PFLAG_VISIBLE_HANDLER_IS_SET
-    this.visibleHandler = addVisibilityHandler(this.visibleHandler, visibleHandler)
+    this.onVisible = addVisibilityHandler(this.onVisible, callback)
+  }
+
+  fun addInvisibleEventListener(callback: EventHandler<InvisibleEvent>?): LithoNode {
+    privateFlags = privateFlags or PFLAG_INVISIBLE_HANDLER_IS_SET
+    this.onInvisible = addVisibilityHandler(this.onInvisible, callback)
+    return this
+  }
+
+  fun addFocusedVisibleEventListener(callback: EventHandler<FocusedVisibleEvent>?) {
+    privateFlags = privateFlags or PFLAG_FOCUSED_HANDLER_IS_SET
+    this.onFocusedVisible = addVisibilityHandler(this.onFocusedVisible, callback)
+  }
+
+  fun addFullImpressionEventListener(callback: EventHandler<FullImpressionVisibleEvent>?) {
+    privateFlags = privateFlags or PFLAG_FULL_IMPRESSION_HANDLER_IS_SET
+    this.onFullImpression = addVisibilityHandler(this.onFullImpression, callback)
   }
 
   fun visibleHeightRatio(visibleHeightRatio: Float) {
@@ -841,6 +827,18 @@ open class LithoNode : Node<LithoLayoutContext>, Cloneable {
     this.visibleWidthRatio = visibleWidthRatio
   }
 
+  fun hasVisibilityHandlers(): Boolean =
+      onVisible != null ||
+          onFocusedVisible != null ||
+          onUnfocusedVisible != null ||
+          onFullImpression != null ||
+          onInvisible != null ||
+          onVisibilityChanged != null
+
+  fun visibilityOutputTag(visibilityOutputTag: String?) {
+    this.visibilityOutputTag = visibilityOutputTag
+  }
+
   fun wrap(wrap: YogaWrap) {
     yogaWrap = wrap
   }

litho-core/src/main/java/com/facebook/litho/LithoReducer.kt

@@ -310,7 +310,7 @@ internal object LithoReducer {
   ): VisibilityOutput {
 
     val onVisible =
-        node.visibleHandler?.let {
+        node.onVisible?.let {
           VisibilityEventCallbackData(
               widthRatio = node.visibleWidthRatio,
               heightRatio = node.visibleHeightRatio,
@@ -319,39 +319,39 @@ internal object LithoReducer {
         }
 
     val onFocusedVisible =
-        node.focusedHandler?.let {
+        node.onFocusedVisible?.let {
           VisibilityEventCallbackData(
               widthRatio = node.visibleWidthRatio,
               heightRatio = node.visibleHeightRatio,
               callback = it,
           )
         }
     val onUnfocusedVisible =
-        node.unfocusedHandler?.let {
+        node.onUnfocusedVisible?.let {
           VisibilityEventCallbackData(
               widthRatio = node.visibleWidthRatio,
               heightRatio = node.visibleHeightRatio,
               callback = it,
           )
         }
     val onFullImpression =
-        node.fullImpressionHandler?.let {
+        node.onFullImpression?.let {
           VisibilityEventCallbackData(
               widthRatio = node.visibleWidthRatio,
               heightRatio = node.visibleHeightRatio,
               callback = it,
           )
         }
     val onInvisible =
-        node.invisibleHandler?.let {
+        node.onInvisible?.let {
           VisibilityEventCallbackData(
               widthRatio = node.visibleWidthRatio,
               heightRatio = node.visibleHeightRatio,
               callback = it,
           )
         }
     val onVisibilityChange =
-        node.visibilityChangedHandler?.let {
+        node.onVisibilityChanged?.let {
           VisibilityEventCallbackData(
               widthRatio = node.visibleWidthRatio,
               heightRatio = node.visibleHeightRatio,

litho-it/src/test/com/facebook/litho/CommonPropsTest.kt

@@ -229,12 +229,12 @@ class CommonPropsTest {
     assertThat(node.nodeInfo).isNotNull
     assertThat(node.visibleHeightRatio).isEqualTo(55f)
     assertThat(node.visibleWidthRatio).isEqualTo(56f)
-    assertThat(node.visibleHandler).isEqualTo(visibleHandler)
-    assertThat(node.focusedHandler).isEqualTo(focusedHandler)
-    assertThat(node.unfocusedHandler).isEqualTo(unfocusedHandler)
-    assertThat(node.fullImpressionHandler).isEqualTo(fullImpressionHandler)
-    assertThat(node.invisibleHandler).isEqualTo(invisibleHandler)
-    assertThat(node.visibilityChangedHandler).isEqualTo(visibleRectChangedHandler)
+    assertThat(node.onVisible).isEqualTo(visibleHandler)
+    assertThat(node.onFocusedVisible).isEqualTo(focusedHandler)
+    assertThat(node.onUnfocusedVisible).isEqualTo(unfocusedHandler)
+    assertThat(node.onFullImpression).isEqualTo(fullImpressionHandler)
+    assertThat(node.onInvisible).isEqualTo(invisibleHandler)
+    assertThat(node.onVisibilityChanged).isEqualTo(visibleRectChangedHandler)
     assertThat(node.transitionKey).isEqualTo("transitionKey")
     assertThat(node.testKey).isEqualTo("testKey")
     assertThat(node.stateListAnimator).isEqualTo(stateListAnimator)

litho-it/src/test/com/facebook/litho/LayoutStateCreateTreeTest.kt

@@ -488,12 +488,12 @@ class LayoutStateCreateTreeTest {
     verify(node)?.applyNodeInfo(anyOrNull())
     verify(node)?.visibleHeightRatio(55f)
     verify(node)?.visibleWidthRatio(56f)
-    verify(node)?.visibleHandler(visibleHandler)
-    verify(node)?.focusedHandler(focusedHandler)
-    verify(node)?.unfocusedHandler(unfocusedHandler)
-    verify(node)?.fullImpressionHandler(fullImpressionHandler)
-    verify(node)?.invisibleHandler(invisibleHandler)
-    verify(node)?.visibilityChangedHandler(visibleRectChangedHandler)
+    verify(node)?.addVisibleEventListener(visibleHandler)
+    verify(node)?.addFocusedVisibleEventListener(focusedHandler)
+    verify(node)?.addUnfocusedVisibleEventListener(unfocusedHandler)
+    verify(node)?.addFullImpressionEventListener(fullImpressionHandler)
+    verify(node)?.addInvisibleEventListener(invisibleHandler)
+    verify(node)?.addVisibilityChangedEventListener(visibleRectChangedHandler)
     verify(node)?.transitionKey(eq("transitionKey"), anyOrNull<String>())
     verify(node)?.transitionKeyType(Transition.TransitionKeyType.GLOBAL)
     verify(node)?.testKey("testKey")

litho-it/src/test/com/facebook/litho/LithoNodeTest.kt

@@ -302,12 +302,12 @@ class LithoNodeTest {
     orig.duplicateParentState(true)
     orig.background(ColorDrawable())
     orig.foreground(null)
-    orig.visibleHandler(null)
-    orig.focusedHandler(null)
-    orig.fullImpressionHandler(null)
-    orig.invisibleHandler(null)
-    orig.unfocusedHandler(null)
-    orig.visibilityChangedHandler(null)
+    orig.addVisibleEventListener(null)
+    orig.addFocusedVisibleEventListener(null)
+    orig.addFullImpressionEventListener(null)
+    orig.addInvisibleEventListener(null)
+    orig.addUnfocusedVisibleEventListener(null)
+    orig.addVisibilityChangedEventListener(null)
     orig.transferInto(dest)
     assertThat(isFlagSet(dest, "PFLAG_IMPORTANT_FOR_ACCESSIBILITY_IS_SET")).isTrue
     assertThat(isFlagSet(dest, "PFLAG_BACKGROUND_IS_SET")).isTrue