react-native 0.70.6 → 0.71.0-rc.1

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/LayoutShadowNode.java

@@ -224,6 +224,30 @@ public class LayoutShadowNode extends ReactShadowNodeImpl {
     super.setFlexGrow(flexGrow);
   }
 
+  @ReactProp(name = ViewProps.ROW_GAP, defaultFloat = YogaConstants.UNDEFINED)
+  public void setRowGap(float rowGap) {
+    if (isVirtual()) {
+      return;
+    }
+    super.setRowGap(PixelUtil.toPixelFromDIP(rowGap));
+  }
+
+  @ReactProp(name = ViewProps.COLUMN_GAP, defaultFloat = YogaConstants.UNDEFINED)
+  public void setColumnGap(float columnGap) {
+    if (isVirtual()) {
+      return;
+    }
+    super.setColumnGap(PixelUtil.toPixelFromDIP(columnGap));
+  }
+
+  @ReactProp(name = ViewProps.GAP, defaultFloat = YogaConstants.UNDEFINED)
+  public void setGap(float gap) {
+    if (isVirtual()) {
+      return;
+    }
+    super.setGap(PixelUtil.toPixelFromDIP(gap));
+  }
+
   @ReactProp(name = ViewProps.FLEX_SHRINK, defaultFloat = 0f)
   public void setFlexShrink(float flexShrink) {
     if (isVirtual()) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactAccessibilityDelegate.java

@@ -225,10 +225,15 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     super.onInitializeAccessibilityNodeInfo(host, info);
     final AccessibilityRole accessibilityRole =
         (AccessibilityRole) host.getTag(R.id.accessibility_role);
+    final String accessibilityHint = (String) host.getTag(R.id.accessibility_hint);
     if (accessibilityRole != null) {
       setRole(info, accessibilityRole, host.getContext());
     }
 
+    if (accessibilityHint != null) {
+      info.setTooltipText(accessibilityHint);
+    }
+
     final Object accessibilityLabelledBy = host.getTag(R.id.labelled_by);
     if (accessibilityLabelledBy != null) {
       mAccessibilityLabelledBy =
@@ -443,9 +448,7 @@ public class ReactAccessibilityDelegate extends ExploreByTouchHelper {
     } else if (role.equals(AccessibilityRole.SUMMARY)) {
       nodeInfo.setRoleDescription(context.getString(R.string.summary_description));
     } else if (role.equals(AccessibilityRole.HEADER)) {
-      final AccessibilityNodeInfoCompat.CollectionItemInfoCompat itemInfo =
-          AccessibilityNodeInfoCompat.CollectionItemInfoCompat.obtain(0, 1, 0, 1, true);
-      nodeInfo.setCollectionItemInfo(itemInfo);
+      nodeInfo.setHeading(true);
     } else if (role.equals(AccessibilityRole.ALERT)) {
       nodeInfo.setRoleDescription(context.getString(R.string.alert_description));
     } else if (role.equals(AccessibilityRole.COMBOBOX)) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNode.java

@@ -308,6 +308,12 @@ public interface ReactShadowNode<T extends ReactShadowNode> {
 
   void setFlexGrow(float flexGrow);
 
+  void setRowGap(float rowGap);
+
+  void setColumnGap(float columnGap);
+
+  void setGap(float gap);
+
   void setFlexShrink(float flexShrink);
 
   void setFlexBasis(float flexBasis);

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ReactShadowNodeImpl.java

@@ -18,6 +18,7 @@ import com.facebook.yoga.YogaDirection;
 import com.facebook.yoga.YogaDisplay;
 import com.facebook.yoga.YogaEdge;
 import com.facebook.yoga.YogaFlexDirection;
+import com.facebook.yoga.YogaGutter;
 import com.facebook.yoga.YogaJustify;
 import com.facebook.yoga.YogaMeasureFunction;
 import com.facebook.yoga.YogaNode;
@@ -794,6 +795,21 @@ public class ReactShadowNodeImpl implements ReactShadowNode<ReactShadowNodeImpl>
     mYogaNode.setFlexGrow(flexGrow);
   }
 
+  @Override
+  public void setRowGap(float rowGap) {
+    mYogaNode.setGap(YogaGutter.ROW, rowGap);
+  }
+
+  @Override
+  public void setColumnGap(float columnGap) {
+    mYogaNode.setGap(YogaGutter.COLUMN, columnGap);
+  }
+
+  @Override
+  public void setGap(float gap) {
+    mYogaNode.setGap(YogaGutter.ALL, gap);
+  }
+
   @Override
   public void setFlexShrink(float flexShrink) {
     mYogaNode.setFlexShrink(flexShrink);

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIImplementation.java

@@ -30,7 +30,6 @@ import com.facebook.systrace.SystraceMessage;
 import com.facebook.yoga.YogaConstants;
 import com.facebook.yoga.YogaDirection;
 import java.util.Arrays;
-import java.util.List;
 import java.util.Map;
 
 /**
@@ -65,30 +64,6 @@ public class UIImplementation {
     void onLayoutUpdated(ReactShadowNode root);
   }
 
-  public UIImplementation(
-      ReactApplicationContext reactContext,
-      ViewManagerResolver viewManagerResolver,
-      EventDispatcher eventDispatcher,
-      int minTimeLeftInFrameForNonBatchedOperationMs) {
-    this(
-        reactContext,
-        new ViewManagerRegistry(viewManagerResolver),
-        eventDispatcher,
-        minTimeLeftInFrameForNonBatchedOperationMs);
-  }
-
-  public UIImplementation(
-      ReactApplicationContext reactContext,
-      List<ViewManager> viewManagers,
-      EventDispatcher eventDispatcher,
-      int minTimeLeftInFrameForNonBatchedOperationMs) {
-    this(
-        reactContext,
-        new ViewManagerRegistry(viewManagers),
-        eventDispatcher,
-        minTimeLeftInFrameForNonBatchedOperationMs);
-  }
-
   UIImplementation(
       ReactApplicationContext reactContext,
       ViewManagerRegistry viewManagers,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIManagerModule.java

@@ -115,36 +115,10 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   private int mBatchId = 0;
   private int mNumRootViews = 0;
 
-  @SuppressWarnings("deprecated")
   public UIManagerModule(
       ReactApplicationContext reactContext,
       ViewManagerResolver viewManagerResolver,
       int minTimeLeftInFrameForNonBatchedOperationMs) {
-    this(
-        reactContext,
-        viewManagerResolver,
-        new UIImplementationProvider(),
-        minTimeLeftInFrameForNonBatchedOperationMs);
-  }
-
-  @SuppressWarnings("deprecated")
-  public UIManagerModule(
-      ReactApplicationContext reactContext,
-      List<ViewManager> viewManagersList,
-      int minTimeLeftInFrameForNonBatchedOperationMs) {
-    this(
-        reactContext,
-        viewManagersList,
-        new UIImplementationProvider(),
-        minTimeLeftInFrameForNonBatchedOperationMs);
-  }
-
-  @Deprecated
-  public UIManagerModule(
-      ReactApplicationContext reactContext,
-      ViewManagerResolver viewManagerResolver,
-      UIImplementationProvider uiImplementationProvider,
-      int minTimeLeftInFrameForNonBatchedOperationMs) {
     super(reactContext);
     DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(reactContext);
     mEventDispatcher = new EventDispatcherImpl(reactContext);
@@ -152,7 +126,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
     mCustomDirectEvents = UIManagerModuleConstants.getDirectEventTypeConstants();
     mViewManagerRegistry = new ViewManagerRegistry(viewManagerResolver);
     mUIImplementation =
-        uiImplementationProvider.createUIImplementation(
+        new UIImplementation(
             reactContext,
             mViewManagerRegistry,
             mEventDispatcher,
@@ -161,11 +135,9 @@ public class UIManagerModule extends ReactContextBaseJavaModule
     reactContext.addLifecycleEventListener(this);
   }
 
-  @Deprecated
   public UIManagerModule(
       ReactApplicationContext reactContext,
       List<ViewManager> viewManagersList,
-      UIImplementationProvider uiImplementationProvider,
       int minTimeLeftInFrameForNonBatchedOperationMs) {
     super(reactContext);
     DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(reactContext);
@@ -174,7 +146,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
     mModuleConstants = createConstants(viewManagersList, null, mCustomDirectEvents);
     mViewManagerRegistry = new ViewManagerRegistry(viewManagersList);
     mUIImplementation =
-        uiImplementationProvider.createUIImplementation(
+        new UIImplementation(
             reactContext,
             mViewManagerRegistry,
             mEventDispatcher,
@@ -927,7 +899,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   }
 
   /** Listener that drops the CSSNode pool on low memory when the app is backgrounded. */
-  private class MemoryTrimCallback implements ComponentCallbacks2 {
+  private static class MemoryTrimCallback implements ComponentCallbacks2 {
 
     @Override
     public void onTrimMemory(int level) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ViewProps.java

@@ -32,6 +32,9 @@ public class ViewProps {
   public static final String FLEX_BASIS = "flexBasis";
   public static final String FLEX_DIRECTION = "flexDirection";
   public static final String FLEX_WRAP = "flexWrap";
+  public static final String ROW_GAP = "rowGap";
+  public static final String COLUMN_GAP = "columnGap";
+  public static final String GAP = "gap";
   public static final String HEIGHT = "height";
   public static final String JUSTIFY_CONTENT = "justifyContent";
   public static final String LEFT = "left";
@@ -203,6 +206,9 @@ public class ViewProps {
               FLEX_BASIS,
               FLEX_DIRECTION,
               FLEX_GROW,
+              ROW_GAP,
+              COLUMN_GAP,
+              GAP,
               FLEX_SHRINK,
               FLEX_WRAP,
               JUSTIFY_CONTENT,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/annotations/BUCK

@@ -4,10 +4,8 @@ rn_android_library(
     name = "annotations",
     srcs = glob(["*.java"]),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     language = "JAVA",
     required_for_source_only_abi = True,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/common/BUCK

@@ -4,10 +4,8 @@ rn_android_library(
     name = "common",
     srcs = glob(["*.java"]),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     language = "JAVA",
     provided_deps = [

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/Event.java

@@ -40,6 +40,7 @@ public abstract class Event<T extends Event> {
   private int mViewTag;
   private long mTimestampMs;
   private int mUniqueID = sUniqueID++;
+  private @Nullable EventAnimationDriverMatchSpec mEventAnimationDriverMatchSpec;
 
   protected Event() {}
 
@@ -165,6 +166,19 @@ public abstract class Event<T extends Event> {
   /** @return the name of this event as registered in JS */
   public abstract String getEventName();
 
+  public EventAnimationDriverMatchSpec getEventAnimationDriverMatchSpec() {
+    if (mEventAnimationDriverMatchSpec == null) {
+      mEventAnimationDriverMatchSpec =
+          new EventAnimationDriverMatchSpec() {
+            @Override
+            public boolean match(int viewTag, String eventName) {
+              return viewTag == getViewTag() && eventName.equals(getEventName());
+            };
+          };
+    }
+    return mEventAnimationDriverMatchSpec;
+  }
+
   /**
    * Dispatch this event to JS using the given event emitter. Compatible with old and new renderer.
    * Instead of using this or dispatchModern, it is recommended that you simply override
@@ -225,4 +239,8 @@ public abstract class Event<T extends Event> {
     }
     dispatch(rctEventEmitter);
   }
+
+  public interface EventAnimationDriverMatchSpec {
+    boolean match(int viewTag, String eventName);
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/PointerEvent.java

@@ -15,79 +15,71 @@ import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.TouchTargetHelper;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 
 public class PointerEvent extends Event<PointerEvent> {
   private static final String TAG = PointerEvent.class.getSimpleName();
   private static final int POINTER_EVENTS_POOL_SIZE = 6;
   private static final Pools.SynchronizedPool<PointerEvent> EVENTS_POOL =
       new Pools.SynchronizedPool<>(POINTER_EVENTS_POOL_SIZE);
-  private static final int UNSET_COALESCING_KEY = -1;
+  private static final short UNSET_COALESCING_KEY = -1;
 
   public static PointerEvent obtain(
       String eventName,
-      int surfaceId,
-      int viewTag,
-      MotionEvent motionEventToCopy,
-      float[] offsetCoords) {
+      int targetTag,
+      PointerEventState eventState,
+      MotionEvent motionEventToCopy) {
     PointerEvent event = EVENTS_POOL.acquire();
     if (event == null) {
       event = new PointerEvent();
     }
     event.init(
-        eventName,
-        surfaceId,
-        viewTag,
-        Assertions.assertNotNull(motionEventToCopy),
-        offsetCoords,
-        0);
+        eventName, targetTag, eventState, Assertions.assertNotNull(motionEventToCopy), (short) 0);
     return event;
   }
 
   public static PointerEvent obtain(
       String eventName,
-      int surfaceId,
-      int viewTag,
+      int targetTag,
+      PointerEventState eventState,
       MotionEvent motionEventToCopy,
-      float[] offsetCoords,
-      int coalescingKey) {
+      short coalescingKey) {
     PointerEvent event = EVENTS_POOL.acquire();
     if (event == null) {
       event = new PointerEvent();
     }
     event.init(
         eventName,
-        surfaceId,
-        viewTag,
+        targetTag,
+        eventState,
         Assertions.assertNotNull(motionEventToCopy),
-        offsetCoords,
         coalescingKey);
     return event;
   }
 
   private @Nullable MotionEvent mMotionEvent;
   private @Nullable String mEventName;
-  private int mCoalescingKey = UNSET_COALESCING_KEY;
-  private float mOffsetX;
-  private float mOffsetY;
+  private short mCoalescingKey = UNSET_COALESCING_KEY;
   private @Nullable List<WritableMap> mPointersEventData;
+  private PointerEventState mEventState;
+  private @Nullable Event.EventAnimationDriverMatchSpec mEventAnimationDriverMatchSpec;
 
   private void init(
       String eventName,
-      int surfaceId,
-      int viewTag,
+      int targetTag,
+      PointerEventState eventState,
       MotionEvent motionEventToCopy,
-      float[] offsetCoords,
-      int coalescingKey) {
+      short coalescingKey) {
 
-    super.init(surfaceId, viewTag, motionEventToCopy.getEventTime());
+    super.init(eventState.getSurfaceId(), targetTag, motionEventToCopy.getEventTime());
     mEventName = eventName;
     mMotionEvent = MotionEvent.obtain(motionEventToCopy);
     mCoalescingKey = coalescingKey;
-    mOffsetX = offsetCoords[0];
-    mOffsetY = offsetCoords[1];
+    mEventState = eventState;
   }
 
   private PointerEvent() {}
@@ -123,6 +115,31 @@ public class PointerEvent extends Event<PointerEvent> {
     return;
   }
 
+  @Override
+  public Event.EventAnimationDriverMatchSpec getEventAnimationDriverMatchSpec() {
+    if (mEventAnimationDriverMatchSpec == null) {
+      mEventAnimationDriverMatchSpec =
+          new EventAnimationDriverMatchSpec() {
+            @Override
+            public boolean match(int viewTag, String eventName) {
+              if (!PointerEventHelper.isBubblingEvent(eventName)) {
+                return false;
+              }
+
+              List<TouchTargetHelper.ViewTarget> viewTargets =
+                  mEventState.getHitPathForActivePointer();
+              for (TouchTargetHelper.ViewTarget viewTarget : viewTargets) {
+                if (viewTarget.getViewId() == viewTag && eventName.equals(mEventName)) {
+                  return true;
+                }
+              }
+              return false;
+            }
+          };
+    }
+    return mEventAnimationDriverMatchSpec;
+  }
+
   @Override
   public void onDispose() {
     mPointersEventData = null;
@@ -147,36 +164,79 @@ public class PointerEvent extends Event<PointerEvent> {
     }
   }
 
-  private ArrayList<WritableMap> createPointerEvents() {
-    MotionEvent motionEvent = mMotionEvent;
-    ArrayList<WritableMap> pointerEvents = new ArrayList<>();
+  private List<WritableMap> createW3CPointerEvents() {
 
-    for (int index = 0; index < motionEvent.getPointerCount(); index++) {
-      pointerEvents.add(this.createPointerEventData(index));
+    ArrayList<WritableMap> w3cPointerEvents = new ArrayList<>();
+    for (int index = 0; index < mMotionEvent.getPointerCount(); index++) {
+      w3cPointerEvents.add(this.createW3CPointerEvent(index));
     }
 
-    return pointerEvents;
+    return w3cPointerEvents;
   }
 
-  private WritableMap createPointerEventData(int index) {
+  private WritableMap createW3CPointerEvent(int index) {
     WritableMap pointerEvent = Arguments.createMap();
+    int pointerId = mMotionEvent.getPointerId(index);
+
+    // https://www.w3.org/TR/pointerevents/#pointerevent-interface
+    pointerEvent.putDouble("pointerId", pointerId);
+
+    String pointerType = PointerEventHelper.getW3CPointerType(mMotionEvent.getToolType(index));
+    pointerEvent.putString("pointerType", pointerType);
 
-    pointerEvent.putDouble("pointerId", mMotionEvent.getPointerId(index));
-    pointerEvent.putDouble("pressure", mMotionEvent.getPressure(index));
-    pointerEvent.putString(
-        "pointerType", PointerEventHelper.getW3CPointerType(mMotionEvent.getToolType(index)));
+    pointerEvent.putBoolean(
+        "isPrimary",
+        PointerEventHelper.isPrimary(pointerId, mEventState.getPrimaryPointerId(), mMotionEvent));
 
+    // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent
     // Client refers to upper left edge of the content area (viewport)
     // We define the viewport to be ReactRootView
-    pointerEvent.putDouble("clientX", mMotionEvent.getX(index));
-    pointerEvent.putDouble("clientY", mMotionEvent.getY(index));
+    float[] eventCoords = mEventState.getEventCoordinatesByPointerId().get(pointerId);
+    double clientX = PixelUtil.toDIPFromPixel(eventCoords[0]);
+    double clientY = PixelUtil.toDIPFromPixel(eventCoords[1]);
+    pointerEvent.putDouble("clientX", clientX);
+    pointerEvent.putDouble("clientY", clientY);
+
+    // x,y values are aliases of clientX, clientY
+    pointerEvent.putDouble("x", clientX);
+    pointerEvent.putDouble("y", clientY);
+
+    // page values in react-native are equivalent to client values since rootview is not scrollable
+    pointerEvent.putDouble("pageX", clientX);
+    pointerEvent.putDouble("pageY", clientY);
 
     // Offset refers to upper left edge of the target view
-    pointerEvent.putDouble("offsetX", PixelUtil.toDIPFromPixel(mOffsetX));
-    pointerEvent.putDouble("offsetY", PixelUtil.toDIPFromPixel(mOffsetY));
+    float[] offsetCoords = mEventState.getOffsetByPointerId().get(pointerId);
+    pointerEvent.putDouble("offsetX", PixelUtil.toDIPFromPixel(offsetCoords[0]));
+    pointerEvent.putDouble("offsetY", PixelUtil.toDIPFromPixel(offsetCoords[1]));
 
     pointerEvent.putInt("target", this.getViewTag());
     pointerEvent.putDouble("timestamp", this.getTimestampMs());
+
+    pointerEvent.putInt("detail", 0);
+    pointerEvent.putDouble("tiltX", 0);
+    pointerEvent.putDouble("tiltY", 0);
+
+    if (pointerType.equals(PointerEventHelper.POINTER_TYPE_MOUSE)) {
+      pointerEvent.putDouble("width", 1);
+      pointerEvent.putDouble("height", 1);
+    } else {
+      float majorAxis = PixelUtil.toDIPFromPixel(mMotionEvent.getTouchMajor(index));
+      pointerEvent.putDouble("width", majorAxis);
+      pointerEvent.putDouble("height", majorAxis);
+    }
+
+    int buttonState = mMotionEvent.getButtonState();
+    pointerEvent.putInt(
+        "button",
+        PointerEventHelper.getButtonChange(
+            pointerType, mEventState.getLastButtonState(), buttonState));
+    pointerEvent.putInt(
+        "buttons", PointerEventHelper.getButtons(mEventName, pointerType, buttonState));
+
+    pointerEvent.putDouble(
+        "pressure", PointerEventHelper.getPressure(pointerEvent.getInt("buttons"), mEventName));
+
     return pointerEvent;
   }
 
@@ -187,20 +247,27 @@ public class PointerEvent extends Event<PointerEvent> {
         // Cases where all pointer info is relevant
       case PointerEventHelper.POINTER_MOVE:
       case PointerEventHelper.POINTER_CANCEL:
-        pointersEventData = createPointerEvents();
+        pointersEventData = this.createW3CPointerEvents();
         break;
         // Cases where only the "active" pointer info is relevant
       case PointerEventHelper.POINTER_ENTER:
       case PointerEventHelper.POINTER_DOWN:
       case PointerEventHelper.POINTER_UP:
       case PointerEventHelper.POINTER_LEAVE:
-        pointersEventData = Arrays.asList(createPointerEventData(activePointerIndex));
+      case PointerEventHelper.POINTER_OUT:
+      case PointerEventHelper.POINTER_OVER:
+        pointersEventData = Arrays.asList(createW3CPointerEvent(activePointerIndex));
         break;
     }
 
     return pointersEventData;
   }
 
+  @Override
+  public short getCoalescingKey() {
+    return mCoalescingKey;
+  }
+
   @Override
   public void dispatchModern(RCTModernEventEmitter rctEventEmitter) {
     if (mMotionEvent == null) {
@@ -233,4 +300,64 @@ public class PointerEvent extends Event<PointerEvent> {
           PointerEventHelper.getEventCategory(mEventName));
     }
   }
+
+  public static class PointerEventState {
+    private int mPrimaryPointerId;
+    private int mActivePointerId;
+    private int mLastButtonState;
+    private int mSurfaceId;
+
+    private Map<Integer, float[]> mOffsetByPointerId;
+    private Map<Integer, List<TouchTargetHelper.ViewTarget>> mHitPathByPointerId;
+    private Map<Integer, float[]> mEventCoordinatesByPointerId;
+
+    public PointerEventState(
+        int primaryPointerId,
+        int activePointerId,
+        int lastButtonState,
+        int surfaceId,
+        Map<Integer, float[]> offsetByPointerId,
+        Map<Integer, List<TouchTargetHelper.ViewTarget>> hitPathByPointerId,
+        Map<Integer, float[]> eventCoordinatesByPointerId) {
+      mPrimaryPointerId = primaryPointerId;
+      mActivePointerId = activePointerId;
+      mLastButtonState = lastButtonState;
+      mSurfaceId = surfaceId;
+      mOffsetByPointerId = offsetByPointerId;
+      mHitPathByPointerId = hitPathByPointerId;
+      mEventCoordinatesByPointerId = eventCoordinatesByPointerId;
+    }
+
+    public int getLastButtonState() {
+      return mLastButtonState;
+    }
+
+    public int getPrimaryPointerId() {
+      return mPrimaryPointerId;
+    }
+
+    public int getSurfaceId() {
+      return mSurfaceId;
+    }
+
+    public int getActivePointerId() {
+      return mActivePointerId;
+    }
+
+    public final Map<Integer, float[]> getOffsetByPointerId() {
+      return mOffsetByPointerId;
+    }
+
+    public final Map<Integer, List<TouchTargetHelper.ViewTarget>> getHitPathByPointerId() {
+      return mHitPathByPointerId;
+    }
+
+    public final Map<Integer, float[]> getEventCoordinatesByPointerId() {
+      return mEventCoordinatesByPointerId;
+    }
+
+    public final List<TouchTargetHelper.ViewTarget> getHitPathForActivePointer() {
+      return mHitPathByPointerId.get(mActivePointerId);
+    }
+  }
 }