Wraps visibility event handlers with width and height ratios

Summary: Wraps visibility events handler with width and height ratio. No behaviour or logic change.

Reviewed By: astreet

Differential Revision: D78268044

fbshipit-source-id: 203e040580882adcdbb8df83a50ff43701048d4a

Author: adityasharat

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

@@ -606,23 +606,23 @@ constructor(context: ComponentContext, attrs: AttributeSet? = null) :
         else null
     if (visibilityEventType == VisibleEvent::class.java) {
       if (visibilityOutput.onVisible != null) {
-        dispatchOnVisible(requireNotNull(visibilityOutput.onVisible), content)
+        dispatchOnVisible(requireNotNull(visibilityOutput.onVisible).callback, content)
       }
     } else if (visibilityEventType == InvisibleEvent::class.java) {
       if (visibilityOutput.onInvisible != null) {
-        dispatchOnInvisible(requireNotNull(visibilityOutput.onInvisible))
+        dispatchOnInvisible(requireNotNull(visibilityOutput.onInvisible).callback)
       }
     } else if (visibilityEventType == FocusedVisibleEvent::class.java) {
       if (visibilityOutput.onFocusedVisible != null) {
-        dispatchOnFocused(requireNotNull(visibilityOutput.onFocusedVisible))
+        dispatchOnFocused(requireNotNull(visibilityOutput.onFocusedVisible).callback)
       }
     } else if (visibilityEventType == UnfocusedVisibleEvent::class.java) {
       if (visibilityOutput.onUnfocusedVisible != null) {
-        dispatchOnUnfocused(requireNotNull(visibilityOutput.onUnfocusedVisible))
+        dispatchOnUnfocused(requireNotNull(visibilityOutput.onUnfocusedVisible).callback)
       }
     } else if (visibilityEventType == FullImpressionVisibleEvent::class.java) {
       if (visibilityOutput.onFullImpression != null) {
-        dispatchOnFullImpression(requireNotNull(visibilityOutput.onFullImpression))
+        dispatchOnFullImpression(requireNotNull(visibilityOutput.onFullImpression).callback)
       }
     }
   }

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

@@ -29,6 +29,7 @@ import com.facebook.rendercore.RenderTreeNode
 import com.facebook.rendercore.incrementalmount.ExcludeFromIncrementalMountBinder
 import com.facebook.rendercore.incrementalmount.IncrementalMountOutput
 import com.facebook.rendercore.incrementalmount.IncrementalMountRenderCoreExtension
+import com.facebook.rendercore.visibility.VisibilityEventCallbackData
 import com.facebook.rendercore.visibility.VisibilityOutput
 import kotlin.math.max
 import kotlin.math.min
@@ -308,32 +309,74 @@ internal object LithoReducer {
       renderTreeNode: RenderTreeNode?
   ): VisibilityOutput {
 
-    val visibleHandler: EventHandler<VisibleEvent>? = node.visibleHandler
-    val focusedHandler: EventHandler<FocusedVisibleEvent>? = node.focusedHandler
-    val unfocusedHandler: EventHandler<UnfocusedVisibleEvent>? = node.unfocusedHandler
-    val fullImpressionHandler: EventHandler<FullImpressionVisibleEvent>? =
-        node.fullImpressionHandler
-    val invisibleHandler: EventHandler<InvisibleEvent>? = node.invisibleHandler
-    val visibleRectChangedEventHandler: EventHandler<VisibilityChangedEvent>? =
-        node.visibilityChangedHandler
+    val onVisible =
+        node.visibleHandler?.let {
+          VisibilityEventCallbackData(
+              widthRatio = node.visibleWidthRatio,
+              heightRatio = node.visibleHeightRatio,
+              callback = it,
+          )
+        }
+
+    val onFocusedVisible =
+        node.focusedHandler?.let {
+          VisibilityEventCallbackData(
+              widthRatio = node.visibleWidthRatio,
+              heightRatio = node.visibleHeightRatio,
+              callback = it,
+          )
+        }
+    val onUnfocusedVisible =
+        node.unfocusedHandler?.let {
+          VisibilityEventCallbackData(
+              widthRatio = node.visibleWidthRatio,
+              heightRatio = node.visibleHeightRatio,
+              callback = it,
+          )
+        }
+    val onFullImpression =
+        node.fullImpressionHandler?.let {
+          VisibilityEventCallbackData(
+              widthRatio = node.visibleWidthRatio,
+              heightRatio = node.visibleHeightRatio,
+              callback = it,
+          )
+        }
+    val onInvisible =
+        node.invisibleHandler?.let {
+          VisibilityEventCallbackData(
+              widthRatio = node.visibleWidthRatio,
+              heightRatio = node.visibleHeightRatio,
+              callback = it,
+          )
+        }
+    val onVisibilityChange =
+        node.visibilityChangedHandler?.let {
+          VisibilityEventCallbackData(
+              widthRatio = node.visibleWidthRatio,
+              heightRatio = node.visibleHeightRatio,
+              callback = it,
+          )
+        }
     val component: Component = node.tailComponent
     val componentGlobalKey: String = node.tailComponentKey
 
     return VisibilityOutput(
-        componentGlobalKey,
-        component.simpleName,
-        Rect(bounds),
-        renderTreeNode != null,
-        renderTreeNode?.renderUnit?.id ?: 0,
-        node.visibleHeightRatio,
-        node.visibleWidthRatio,
-        node.visibilityOutputTag,
-        visibleHandler,
-        invisibleHandler,
-        focusedHandler,
-        unfocusedHandler,
-        fullImpressionHandler,
-        visibleRectChangedEventHandler)
+        id = componentGlobalKey,
+        key = component.simpleName,
+        bounds = Rect(bounds),
+        hasMountableContent = renderTreeNode != null,
+        renderUnitId = renderTreeNode?.renderUnit?.id ?: 0,
+        visibleWidthRatio = node.visibleWidthRatio,
+        visibleHeightRatio = node.visibleHeightRatio,
+        tag = node.visibilityOutputTag,
+        onVisible = onVisible,
+        onInvisible = onInvisible,
+        onFocusedVisible = onFocusedVisible,
+        onUnfocusedVisible = onUnfocusedVisible,
+        onFullImpression = onFullImpression,
+        onVisibilityChange = onVisibilityChange,
+    )
   }
 
   private fun createTestOutput(

litho-rendercore-visibility/src/main/java/com/facebook/rendercore/visibility/VisibilityItem.kt

@@ -17,7 +17,6 @@
 package com.facebook.rendercore.visibility
 
 import android.graphics.Rect
-import com.facebook.rendercore.Function
 
 /**
  * Holds information about a VisibilityOutput (that is, about an item for which a visibility event
@@ -28,9 +27,9 @@ class VisibilityItem(
     val key: String,
     // The invisible event and unfocused event handlers are required to make it possible to dispatch
     // the corresponding event when unbind is called or when the MountState is reset.
-    var invisibleHandler: Function<Void>?,
-    var unfocusedHandler: Function<Void>?,
-    val visibilityChangedHandler: Function<Void>?,
+    var invisibleHandler: VisibilityEventCallbackData?,
+    var unfocusedHandler: VisibilityEventCallbackData?,
+    val visibilityChangedHandler: VisibilityEventCallbackData?,
     val componentName: String,
     val renderUnitId: Long,
     val bounds: Rect

litho-rendercore-visibility/src/main/java/com/facebook/rendercore/visibility/VisibilityMountExtension.java

@@ -31,7 +31,6 @@
 import androidx.annotation.UiThread;
 import androidx.annotation.VisibleForTesting;
 import com.facebook.infer.annotation.Nullsafe;
-import com.facebook.rendercore.Function;
 import com.facebook.rendercore.Host;
 import com.facebook.rendercore.MountDelegate;
 import com.facebook.rendercore.RenderCoreSystrace;
@@ -334,12 +333,16 @@ private static void processVisibilityOutputsNonInc(
           continue;
         }
 
-        final Function<Void> visibleHandler = visibilityOutput.getOnVisible();
-        final Function<Void> focusedHandler = visibilityOutput.getOnFocusedVisible();
-        final Function<Void> unfocusedHandler = visibilityOutput.getOnUnfocusedVisible();
-        final Function<Void> fullImpressionHandler = visibilityOutput.getOnFullImpression();
-        final Function<Void> invisibleHandler = visibilityOutput.getOnInvisible();
-        final Function<Void> visibilityChangedHandler = visibilityOutput.getOnVisibilityChange();
+        final @Nullable VisibilityEventCallbackData onVisible = visibilityOutput.getOnVisible();
+        final @Nullable VisibilityEventCallbackData onFocusedVisible =
+            visibilityOutput.getOnFocusedVisible();
+        final @Nullable VisibilityEventCallbackData onUnfocusedVisible =
+            visibilityOutput.getOnUnfocusedVisible();
+        final @Nullable VisibilityEventCallbackData onFullImpression =
+            visibilityOutput.getOnFullImpression();
+        final @Nullable VisibilityEventCallbackData onInvisible = visibilityOutput.getOnInvisible();
+        final @Nullable VisibilityEventCallbackData onVisibilityChange =
+            visibilityOutput.getOnVisibilityChange();
 
         final boolean isCurrentlyVisible =
             boundsIntersect
@@ -349,24 +352,25 @@ private static void processVisibilityOutputsNonInc(
 
           // If we did a relayout due to e.g. a state update then the handlers will have changed,
           // so we should keep them up to date.
-          visibilityItem.setUnfocusedHandler(unfocusedHandler);
-          visibilityItem.setInvisibleHandler(invisibleHandler);
+          visibilityItem.setUnfocusedHandler(onUnfocusedVisible);
+          visibilityItem.setInvisibleHandler(onInvisible);
 
           if (!isCurrentlyVisible) {
             // Either the component is invisible now, but used to be visible, or the key on the
             // component has changed so we should generate new visibility events for the new
             // component.
             maybeDispatchOnInvisible(extensionState.getRenderStateId(), visibilityItem);
 
-            if (visibilityChangedHandler != null) {
+            if (onVisibilityChange != null) {
               VisibilityUtils.dispatchOnVisibilityChanged(
-                  visibilityChangedHandler, 0, 0, 0, 0, 0, 0, 0f, 0f);
+                  onVisibilityChange.getCallback(), 0, 0, 0, 0, 0, 0, 0f, 0f);
             }
 
             if (visibilityItem.isInFocusedRange()) {
               visibilityItem.setFocusedRange(false);
               if (visibilityItem.getUnfocusedHandler() != null) {
-                VisibilityUtils.dispatchOnUnfocused(visibilityItem.getUnfocusedHandler());
+                VisibilityUtils.dispatchOnUnfocused(
+                    visibilityItem.getUnfocusedHandler().getCallback());
               }
             }
 
@@ -385,9 +389,9 @@ private static void processVisibilityOutputsNonInc(
             visibilityItem =
                 new VisibilityItem(
                     globalKey,
-                    invisibleHandler,
-                    unfocusedHandler,
-                    visibilityChangedHandler,
+                    onInvisible,
+                    onUnfocusedVisible,
+                    onVisibilityChange,
                     visibilityOutput.getKey(),
                     visibilityOutput.renderUnitId,
                     visibilityOutput.getBounds());
@@ -396,7 +400,7 @@ private static void processVisibilityOutputsNonInc(
             visibilityItem.setWasFullyVisible(isFullyVisible);
             state.mVisibilityIdToItemMap.put(visibilityOutputId, visibilityItem);
 
-            if (visibleHandler != null) {
+            if (onVisible != null) {
               final Object content =
                   visibilityOutput.hasMountableContent
                       ? getContentById(extensionState, visibilityOutput.renderUnitId)
@@ -413,7 +417,7 @@ private static void processVisibilityOutputsNonInc(
                     createVisibilityDebugAttributes(visibilityItem));
               }
 
-              VisibilityUtils.dispatchOnVisible(visibleHandler, content);
+              VisibilityUtils.dispatchOnVisible(onVisible.getCallback(), content);
 
               if (traceIdentifier != null) {
                 DebugEventDispatcher.endTrace(traceIdentifier);
@@ -422,9 +426,9 @@ private static void processVisibilityOutputsNonInc(
           }
 
           Rect transformedViewportRect = null;
-          if (focusedHandler != null
-              || unfocusedHandler != null
-              || visibilityChangedHandler != null) {
+          if (onFocusedVisible != null
+              || onUnfocusedVisible != null
+              || onVisibilityChange != null) {
             if (shouldUseTransformedVisibleRect && transformer != null) {
               final Host host = getRootHost(extensionState);
               if (host != null && (host.getParent() instanceof View)) {
@@ -435,7 +439,7 @@ private static void processVisibilityOutputsNonInc(
           }
 
           // Check if the component has entered or exited the focused range.
-          if (focusedHandler != null || unfocusedHandler != null) {
+          if (onFocusedVisible != null || onUnfocusedVisible != null) {
             if (isInFocusedRange(
                 extensionState,
                 visibilityOutputBounds,
@@ -444,30 +448,30 @@ private static void processVisibilityOutputsNonInc(
                 transformedViewportRect)) {
               if (!visibilityItem.isInFocusedRange()) {
                 visibilityItem.setFocusedRange(true);
-                if (focusedHandler != null) {
-                  VisibilityUtils.dispatchOnFocused(focusedHandler);
+                if (onFocusedVisible != null) {
+                  VisibilityUtils.dispatchOnFocused(onFocusedVisible.getCallback());
                 }
               }
             } else {
               if (visibilityItem.isInFocusedRange()) {
                 visibilityItem.setFocusedRange(false);
-                if (unfocusedHandler != null) {
-                  VisibilityUtils.dispatchOnUnfocused(unfocusedHandler);
+                if (onUnfocusedVisible != null) {
+                  VisibilityUtils.dispatchOnUnfocused(onUnfocusedVisible.getCallback());
                 }
               }
             }
           }
           // If the component has not entered the full impression range yet, make sure to update the
           // information about the visible edges.
-          if (fullImpressionHandler != null && !visibilityItem.isInFullImpressionRange()) {
+          if (onFullImpression != null && !visibilityItem.isInFullImpressionRange()) {
             visibilityItem.setVisibleEdges(visibilityOutputBounds, intersection);
 
             if (visibilityItem.isInFullImpressionRange()) {
-              VisibilityUtils.dispatchOnFullImpression(fullImpressionHandler);
+              VisibilityUtils.dispatchOnFullImpression(onFullImpression.getCallback());
             }
           }
 
-          if (visibilityChangedHandler != null) {
+          if (onVisibilityChange != null) {
             final int visibleWidth = getVisibleWidth(intersection);
             final int visibleHeight = getVisibleHeight(intersection);
             int rootHostViewWidth = getRootHostViewWidth(extensionState);
@@ -478,7 +482,7 @@ private static void processVisibilityOutputsNonInc(
             }
 
             VisibilityUtils.dispatchOnVisibilityChanged(
-                visibilityChangedHandler,
+                onVisibilityChange.getCallback(),
                 getVisibleTop(visibilityOutputBounds, intersection),
                 getVisibleLeft(visibilityOutputBounds, intersection),
                 visibleWidth,
@@ -539,7 +543,7 @@ private static void maybeDispatchOnInvisible(int renderStateId, VisibilityItem v
           createVisibilityDebugAttributes(visibilityItem));
     }
 
-    VisibilityUtils.dispatchOnInvisible(visibilityItem.getInvisibleHandler());
+    VisibilityUtils.dispatchOnInvisible(visibilityItem.getInvisibleHandler().getCallback());
 
     if (traceIdentifier != null) {
       DebugEventDispatcher.endTrace(traceIdentifier);
@@ -619,22 +623,23 @@ private static void clearVisibilityItemsNonincremental(
       final VisibilityItem visibilityItem = state.mVisibilityIdToItemMap.get(key);
 
       if (visibilityItem != null) {
-        final Function<Void> unfocusedHandler = visibilityItem.getUnfocusedHandler();
-        final Function<Void> visibilityChangedHandler =
+        final @Nullable VisibilityEventCallbackData onUnfocused =
+            visibilityItem.getUnfocusedHandler();
+        final @Nullable VisibilityEventCallbackData onVisibilityChanged =
             visibilityItem.getVisibilityChangedHandler();
 
         maybeDispatchOnInvisible(renderStateId, visibilityItem);
 
         if (visibilityItem.isInFocusedRange()) {
           visibilityItem.setFocusedRange(false);
-          if (unfocusedHandler != null) {
-            VisibilityUtils.dispatchOnUnfocused(unfocusedHandler);
+          if (onUnfocused != null) {
+            VisibilityUtils.dispatchOnUnfocused(onUnfocused.getCallback());
           }
         }
 
-        if (visibilityChangedHandler != null) {
+        if (onVisibilityChanged != null) {
           VisibilityUtils.dispatchOnVisibilityChanged(
-              visibilityChangedHandler, 0, 0, 0, 0, 0, 0, 0f, 0f);
+              onVisibilityChanged.getCallback(), 0, 0, 0, 0, 0, 0, 0f, 0f);
         }
 
         visibilityItem.setWasFullyVisible(false);