[java] implement event support for pointer device actions (#10198)

titusfortner · diemol · web-flow · commit 70e54e6ada25 · 2022-02-03T13:29:29.000+01:00
Co-authored-by: Diego Molina &lt;diemol@users.noreply.github.com&gt;
diff --git a/java/src/org/openqa/selenium/interactions/PointerInput.java b/java/src/org/openqa/selenium/interactions/PointerInput.java
@@ -17,8 +17,6 @@
 
 package org.openqa.selenium.interactions;
 
-import static org.openqa.selenium.internal.Require.nonNegative;
-
 import org.openqa.selenium.WebElement;
 import org.openqa.selenium.WrapsElement;
 import org.openqa.selenium.internal.Require;
@@ -29,6 +27,8 @@
 import java.util.Optional;
 import java.util.UUID;
 
+import static org.openqa.selenium.internal.Require.nonNegative;
+
 /**
  * Models a <a href="https://www.w3.org/TR/webdriver/#dfn-pointer-input-source">pointer input
  * source</a>.
@@ -71,18 +71,31 @@ public Interaction createPointerMove(Duration duration, Origin origin, int x, in
     return new Move(this, duration, origin, x, y);
   }
 
+  public Interaction createPointerMove(Duration duration, Origin origin, int x, int y, PointerEventProperties eventProperties) {
+    return new Move(this, duration, origin, x, y, eventProperties);
+  }
+
   public Interaction createPointerDown(int button) {
     return new PointerPress(this, PointerPress.Direction.DOWN, button);
   }
 
+  public Interaction createPointerDown(PointerEventProperties eventProperties) {
+    return new PointerPress(this, PointerPress.Direction.DOWN, eventProperties);
+  }
+
   public Interaction createPointerUp(int button) {
     return new PointerPress(this, PointerPress.Direction.UP, button);
   }
 
+  public Interaction createPointerUp(PointerEventProperties eventProperties) {
+    return new PointerPress(this, PointerPress.Direction.UP, eventProperties);
+  }
+
   private static class PointerPress extends Interaction implements Encodable {
 
     private final Direction direction;
     private final int button;
+    private final PointerEventProperties eventProperties;
 
     public PointerPress(InputSource source, Direction direction, int button) {
       super(source);
@@ -94,11 +107,19 @@ public PointerPress(InputSource source, Direction direction, int button) {
 
       this.direction = Require.nonNull("Direction of move", direction);
       this.button = button;
+      this.eventProperties = new PointerEventProperties();
+    }
+
+    public PointerPress(InputSource source, Direction direction, PointerEventProperties eventProperties) {
+      super(source);
+      this.button = 0;
+      this.eventProperties = Require.nonNull("pointer event properties", eventProperties);
+      this.direction = Require.nonNull("Direction of press", direction);
     }
 
     @Override
     public Map<String, Object> encode() {
-      Map<String, Object> toReturn = new HashMap<>();
+      Map<String, Object> toReturn = eventProperties.encode();
 
       toReturn.put("type", direction.getType());
       toReturn.put("button", button);
@@ -128,19 +149,26 @@ private static class Move extends Interaction implements Encodable {
     private final int x;
     private final int y;
     private final Duration duration;
+    private final PointerEventProperties eventProperties;
 
     protected Move(
         InputSource source,
         Duration duration,
         Origin origin,
         int x,
-        int y) {
+        int y,
+      PointerEventProperties eventProperties) {
       super(source);
 
       this.origin = Require.nonNull("Origin of move", origin);
       this.x = x;
       this.y = y;
       this.duration = nonNegative(duration);
+      this.eventProperties = Require.nonNull("pointer event properties", eventProperties);
+    }
+
+    protected Move(PointerInput source, Duration duration, Origin origin, int x, int y) {
+      this(source, duration, origin, x, y, new PointerEventProperties());
     }
 
     @Override
@@ -150,7 +178,7 @@ protected boolean isValidFor(SourceType sourceType) {
 
     @Override
     public Map<String, Object> encode() {
-      Map<String, Object> toReturn = new HashMap<>();
+      Map<String, Object> toReturn = eventProperties.encode();
 
       toReturn.put("type", "pointerMove");
       toReturn.put("duration", duration.toMillis());
@@ -225,4 +253,116 @@ public static Origin fromElement(WebElement element) {
     }
   }
 
+  public static PointerEventProperties eventProperties() {
+    return new PointerEventProperties();
+  }
+
+  public static class PointerEventProperties implements Encodable {
+    private Float width = null;
+    private Float height = null;
+    private Float pressure = null;
+    private Float tangentialPressure = null;
+    private Integer tiltX = null;
+    private Integer tiltY = null;
+    private Integer twist = null;
+    private Float altitudeAngle = null;
+    private Float azimuthAngle = null;
+
+    public PointerEventProperties setWidth(float width) {
+      Require.nonNull("width", width);
+      if (width < 0) {
+        throw new IllegalArgumentException("Width must be a positive Number");
+      }
+      this.width = width;
+      return this;
+    }
+
+    public PointerEventProperties setHeight(float height) {
+      Require.nonNull("height", height);
+      if (height < 0) {
+        throw new IllegalArgumentException("Height must be a positive Number");
+      }
+      this.height = height;
+      return this;
+    }
+
+    public PointerEventProperties setPressure(float pressure) {
+      Require.nonNull("pressure", pressure);
+      if (pressure < 0 || pressure > 1) {
+        throw new IllegalArgumentException("pressure must be a number between 0 and 1");
+      }
+      this.pressure = pressure;
+      return this;
+    }
+
+    public PointerEventProperties setTangentialPressure(float tangentialPressure) {
+      Require.nonNull("tangentialPressure", tangentialPressure);
+      if (tangentialPressure < -1 || tangentialPressure > 1) {
+        throw new IllegalArgumentException("tangentialPressure must be a Number between -1 and 1");
+      }
+      this.tangentialPressure = tangentialPressure;
+      return this;
+    }
+
+    public PointerEventProperties setTiltX(int tiltX) {
+      Require.nonNull("tiltX", tiltX);
+      if (tiltX < -90 || tiltX > 90) {
+        throw new IllegalArgumentException("tiltX must be an integer between -90 and 90");
+      }
+      this.tiltX = tiltX;
+      return this;
+    }
+
+    public PointerEventProperties setTiltY(int tiltY) {
+      Require.nonNull("tiltY", tiltY);
+      if (tiltY < -90 || tiltY > 90) {
+        throw new IllegalArgumentException("tiltY must be an integer between -90 and 90");
+      }
+      this.tiltY = tiltY;
+      return this;
+    }
+
+    public PointerEventProperties setTwist(int twist) {
+      Require.nonNull("twist", twist);
+      if (twist < 0 || twist > 359) {
+        throw new IllegalArgumentException("twist must be an integer between 0 and 359");
+      }
+      this.twist = twist;
+      return this;
+    }
+
+    public PointerEventProperties setAltitudeAngle(float altitudeAngle) {
+      Require.nonNull("altitudeAngle", altitudeAngle);
+      if (altitudeAngle < 0 || altitudeAngle > Math.PI / 2) {
+        throw new IllegalArgumentException("altitudeAngle must be a number between 0 and π/2");
+      }
+      this.altitudeAngle = altitudeAngle;
+      return this;
+    }
+
+    public PointerEventProperties setAzimuthAngle(float azimuthAngle) {
+      Require.nonNull("azimuthAngle", azimuthAngle);
+      if (azimuthAngle < 0 || azimuthAngle > Math.PI * 2) {
+        throw new IllegalArgumentException("azimuthAngle must be a number between 0 and 2π");
+      }
+      this.azimuthAngle = azimuthAngle;
+      return this;
+    }
+
+    @Override
+    public Map<String, Object> encode() {
+      Map<String, Object> toReturn = new HashMap<>();
+      Optional.ofNullable(width).ifPresent(v -> toReturn.put("width", v));
+      Optional.ofNullable(height).ifPresent(v -> toReturn.put("height", v));
+      Optional.ofNullable(pressure).ifPresent(v -> toReturn.put("pressure", v));
+      Optional.ofNullable(tangentialPressure).ifPresent(v -> toReturn.put("tangentialPressure", v));
+      Optional.ofNullable(tiltX).ifPresent(v -> toReturn.put("tiltX", v));
+      Optional.ofNullable(tiltY).ifPresent(v -> toReturn.put("tiltY", v));
+      Optional.ofNullable(twist).ifPresent(v -> toReturn.put("twist", v));
+      Optional.ofNullable(altitudeAngle).ifPresent(v -> toReturn.put("altitudeAngle", v));
+      Optional.ofNullable(azimuthAngle).ifPresent(v -> toReturn.put("azimuthAngle", v));
+
+      return toReturn;
+    }
+  }
 }
diff --git a/java/test/org/openqa/selenium/interactions/PointerInputTest.java b/java/test/org/openqa/selenium/interactions/PointerInputTest.java
@@ -60,6 +60,16 @@ public void encodesWrappedElementInMoveOrigin() {
     assertThat(firstAction.origin).containsEntry(W3C.getEncodedElementKey(), "12345");
   }
 
+  @Test
+  public void acceptsPointerEventProperties() {
+    PointerInput pen = new PointerInput(PointerInput.Kind.PEN, "my pen");
+    Interaction pointerDown = pen.createPointerDown(PointerInput.eventProperties().setHeight(12).setTiltX(30));
+
+    Map<String, Object> encode = ((Encodable) pointerDown).encode();
+
+    assertThat(encode.get("height")).isEqualTo((float) 12);
+  }
+
   private static class ActionSequenceJson {
     List<ActionJson> actions;
   }
