robotframework-parrot-touchcontroller 1.0.0__py3-none-any.whl

parrot/TouchController.py

@@ -0,0 +1,249 @@
+from robot.api.deco import keyword
+from parrot.touch.dummy import DummyTouch
+from parrot.touch.axitouch import AxiDrawTouch
+from parrot.touch.base import Error
+from parrot.touch.adbtouch import ADBTouch
+from parrot.touch.usbhidtouch import UsbHidTouch
+from typing import Dict, Any
+
+class TouchError(Exception):
+    """Raised when a device-level touch error occurs."""
+
+
+class TouchController:
+    """
+    A Robot Framework library for simulating touch input across various
+    device types through a unified interface.
+
+    == Configuration ==
+
+    Touch devices are configured using the `Touch Setup` keyword with a dictionary 
+    typically loaded from a YAML file (e.g. `config.yaml`) by importing the library 
+    and variables into your test suite. Each entry in the configuration must include 
+    a `type` field that specifies the device type. Supported types include:
+
+    - `UsbHidTouch`: USB HID-based touch simulation over TCP.
+    - `AxiDrawTouch`: Physical touch simulation using a pen plotter.
+    - `ADBTouch`: Android device touch simulation over ADB.
+
+    === UsbHidTouch ===
+      Simulates touch over a USB HID device exposed via a TCP server.
+      Supported configs:
+      - `host`: IP address or hostname of the USB HID server (e.g., `127.0.0.1`)
+      - `port`: TCP port number (e.g., `8000`)
+      - `width`, `height`: Touch coordinate resolution (e.g., 1024x600)
+
+    === AxiDrawTouch ===
+      Controls an AxiDraw pen plotter to simulate physical touchscreen input.
+      Supported configs:
+      - `device`: Serial device path (e.g., `/dev/ttyUSB0`)
+      - `width`, `height`: Touch surface resolution in pixels
+      - `start_pos`: Physical start coordinates (e.g., `[0, 0]`)
+      - `end_pos`: Physical end coordinates defining working area (e.g., `[8.66, 5.12]`)
+
+    === ADBTouch ===
+      Simulates touch events on an Android device using ADB commands.
+      Supported configs:
+      - `ip`: IP address of the Android device (e.g., `192.168.43.168`)
+
+    === Configuration Sample (config.yaml) ===
+
+    The configuration file is written in YAML format and contains a top-level key
+    `TouchConfig` with device definitions:
+
+    | TouchConfig:
+    |   T1:
+    |     type: UsbHidTouch
+    |     host: 127.0.0.1
+    |     port: 8000
+    |     width: 1024
+    |     height: 600
+    |
+    |   T2:
+    |     type: AxiDrawTouch
+    |     device: /dev/ttyUSB0
+    |     width: 1024
+    |     height: 600
+    |     start_pos: [0, 0]
+    |     end_pos: [8.66, 5.12]
+    |
+    |   T3:
+    |     type: ADBTouch
+    |     ip: 192.168.43.168
+
+    = General Usage =
+
+    Setup and initialize touch devices from a YAML configuration. Simulate touch input such as tap and swipe gestures 
+    across multiple supported devices. This library supports both real physical systems and simulated touch environments, 
+    making it suitable for automated device interaction and UI testing.
+
+    = Example =
+
+    | ***** Settings *****
+    | Library    parrot.TouchController
+    | Variables  config.yaml
+    |
+    | ***** Test Cases *****
+    | Run Touch Tests
+    |     Touch Setup           ${TouchConfig}                           # Initializes all touch devices from the YAML configuration.
+    |     Tap                   T1    640    500    0.2                  # Simulates a tap at (640, 500) for 0.2 seconds on T1.
+    |     Swipe                 T1    100    100    600    400    0.2    # Simulates swipe from (100,100) to (600,400).
+    |     Touch Command         T1    move    0     1                    # Moves the touch to specified screen coordinates.
+    |     Touch Command         T1    home                               # Returns the axitouch to its home position.
+
+    """
+
+
+    ROBOT_LIBRARY_SCOPE = 'GLOBAL'
+
+    def __init__(self) -> None:
+        self.devices: Dict[str, Any] = {}
+
+    @keyword("Touch Setup")
+    def setup(self, config: Dict[str, Dict[str, Any]]) -> None:
+        """Initializes and configures touch controller devices.
+        Loads controller instances from the given `Configuration` dictionary 
+        and prepares them for input simulation.
+
+        *Syntax*
+
+        | `Touch Setup` | <CONFIG> |
+
+        *Examples*
+
+        | `Touch Setup` | ${TouchConfig} | # Loads and initializes all camera devices defined in the `${CameraConfig}` dictionary. |
+        """
+        if not isinstance(config, dict):
+            raise Error("Expected a dictionary of controller configurations.")
+
+        controller_classes: Dict[str, Any] = {
+            "DummyTouch": DummyTouch,
+            "AxiDrawTouch": AxiDrawTouch,
+            "ADBTouch": ADBTouch,
+            "UsbHidTouch": UsbHidTouch,
+        }
+
+        for name, dev in config.items():
+            class_type = dev.get("type")
+
+            if not class_type or not name:
+                raise Error("Each TouchController entry must have 'type' and 'name' fields.")
+
+            if class_type not in controller_classes:
+                raise Error(f"Controller class '{class_type}' is not supported.")
+
+            try:
+                device = controller_classes[class_type](dev)
+                device.touch_init()
+            except Error as err:
+                raise TouchError(f"Failed to initialize controller '{name}' of type '{class_type}': {err}") from err
+
+
+            self.devices[name] = device
+
+        print(f"[INFO] Loaded controllers: {list(self.devices.keys())}")
+
+    @keyword("Tap")
+    def send_touch(self, device: str, x: float, y: float, tap_time: float = 0.2) -> None:
+        """
+        Simulates a tap action on the given device at specified screen coordinates.
+        Requires the device name, X and Y coordinates in pixels, and an 
+        optional tap duration (default: 0.2 seconds). 
+
+        *Syntax*
+
+        | `Tap` | <DEVICE_NAME> | <X> | <Y> | <TAP_TIME> |
+
+        *Examples*
+
+        | `Tap` | T1 | 640 | 500 | 0.2 | # Simulates a tap at (640, 500) on device `T1` with a duration of 0.2 seconds. |
+
+        """
+        controller = self.devices.get(device)
+        if not controller:
+            raise TouchError(f"Touch controller '{device}' not found.")
+        controller.touch_tap(float(x), float(y), float(tap_time))
+
+    @keyword("Swipe")
+    def send_swipe(
+        self,
+        device: str,
+        x1: float,
+        y1: float,
+        x2: float,
+        y2: float,
+    ) -> None:
+        """
+        Simulates a swipe gesture on the given device from (x1, y1) to (x2, y2).
+        Requires the device name, starting and ending coordinates in pixels.
+
+        *Syntax*
+
+        | <DEVICE_NAME> | <DEVICE_NAME> | <X1> | <Y1> | <X2> | <Y2> |
+
+        *Examples*
+
+        | `Swipe` | T1 | 100 | 100 | 600 | 400 | 0.3 | # Simulates a swipe on device `T1` from (100, 100) to (600, 400) |
+
+        """
+
+        controller = self.devices.get(device)
+        if not controller:
+            raise TouchError(f"Touch controller '{device}' not found.")
+        controller.touch_swipe(float(x1), float(y1), float(x2), float(y2))
+
+    @keyword("Touch Command")
+    def command(self, device, command, *args):
+        """
+        Executes a backend-specific touch command on the given device controller.
+
+        This keyword is used to send a command (e.g., `Move`, `Home`) to a specific device. 
+        The available commands and required arguments depends on the backend implementation 
+        of the touch controller. Currently only the AxiDrawTouch backend has commands.
+
+        AxiDrawTouch backend supports the following commands. 
+
+        - `Move` — Moves to the specified position (in inches) without touching.
+          Requires two arguments: `x`, `y`.
+        - `Home` — Returns the touch to its home (default) position.
+          Takes no arguments.
+
+        *Syntax*
+
+        | Touch Command | <DEVICE_NAME> | <COMMAND> | [<ARG1>] | [<ARG2>] |
+
+        *Examples*
+
+        | Touch Command | T1 | move | 200 | 300 |
+        | Touch Command | T1 | home |
+
+        """
+        controller = self.devices.get(device)
+        if not controller:
+            raise TouchError(f"Touch controller '{device}' not found.")
+        controller.touch_command(command, *args)
+
+
+    @keyword("Touch Set Param")
+    def set_param_auto_home(self, device: str, param: str, value: str) -> None:
+        """
+        Sets values to configure runtime parameters for Touch control devices.
+        
+        Currently, this keyword supports only for `AxiDrawTouch` type devices,
+
+        | *Parameter*       | *Description*                                                         | *Example Value* |
+        | `auto_home`       | Specifies the touch action to be directed to the home position        | "True or False" |
+       
+        *Syntax*
+
+        | `Touch Set Param` | <DEVICE_NAME> | auto_home | <VALUE> |
+
+        *Examples*
+
+        | `Touch Set Param` | T1 | auto_home | True    | # Enables auto-home on the touch controller device. |
+        | `Touch Set Param` | T2 | auto_home | False   | # Disables auto-home on the touch controller device. |
+        """
+        controller = self.devices.get(device)
+        if not controller:
+            raise TouchError(f"Touch controller '{device}' not found.")
+        controller.set_param(param, value)

parrot/touch/adbtouch.py

@@ -0,0 +1,84 @@
+from parrot import ADBController
+from parrot.touch.base import BaseTouch, Error
+
+class ADBTouch(BaseTouch):
+    """
+    A touch controller implementation using ADB (Android Debug Bridge).
+
+    This class provides methods to simulate touch gestures such as tap and swipe
+    on Android devices over a network or USB using ADB shell commands.
+    """
+
+    def __init__(self, config: dict):
+        """
+        Initializes the ADB touch controller.
+
+        The configuration dictionary must contain:
+        - `ip`: IP address of the ADB-connected device
+
+        Raises:
+            Error: If required configuration is missing or initialization fails.
+        """
+        try:
+            self.device_ip = config["ip"]
+            self.adb = ADBController.ADBController()
+        except KeyError as err:
+            raise Error(f"Missing required configuration key: {err}") from err
+        except Exception as err:
+            raise Error(f"Initialization failed: {err}") from err
+
+    def touch_init(self):
+        """
+        Initializes the ADB device connection using the provided IP.
+
+        Raises:
+            Error: If the device connection fails.
+        """
+        try:
+            self.adb.adb_ip_connect(self.device_ip)
+            print(f"ADBTouch: Connected to device {self.device_ip}")
+        except Exception as err:
+            raise Error("Initialization failed") from err
+
+    def touch_tap(self, x, y, tap_time):
+        """
+        Simulates a tap at the given screen coordinates using ADB shell.
+
+        Args:
+            x (int | float): X-coordinate in pixels.
+            y (int | float): Y-coordinate in pixels.
+            tap_time: (unused) Compatibility with base method signature.
+
+        Raises:
+            Error: If the tap command fails.
+        """
+        try:
+            cmd = ["input", "tap", str(int(x)), str(int(y))]
+            self.adb.adb_shell(cmd)
+            print(f"ADBTouch: Tap at ({x}, {y})")
+        except Exception as err:
+            raise Error(f"Touch tap failed at ({x}, {y})") from err
+
+    def touch_swipe(self, startx, starty, endx, endy, swipe_time):
+        """
+        Simulates a swipe gesture from start to end coordinates using ADB shell.
+
+        Args:
+            startx (int | float): Start X-coordinate in pixels.
+            starty (int | float): Start Y-coordinate in pixels.
+            endx (int | float): End X-coordinate in pixels.
+            endy (int | float): End Y-coordinate in pixels.
+            swipe_time: (unused) Compatibility with base method signature.
+
+        Raises:
+            Error: If the swipe command fails.
+        """
+        try:
+            cmd = ["input", "swipe", str(int(startx)), str(int(starty)), str(int(endx)), str(int(endy))]
+            self.adb.adb_shell(cmd)
+            print(f"ADBTouch: Swipe from ({startx}, {starty}) to ({endx}, {endy})")
+        except Exception as err:
+            raise Error(f"Swipe failed from ({startx}, {starty}) to ({endx}, {endy})") from err
+        
+    def touch_command(self, cmd, *args):
+        raise Error("Commands are not supported by the ADBTouch backend")

parrot/touch/axitouch.py

@@ -0,0 +1,185 @@
+from robot.api.deco import keyword
+from parrot.touch.base import BaseTouch,Error
+from typing import Tuple, Any
+
+import xmlrpc.client
+
+
+class AxiTouchError(Exception):
+    """Represents an error in the AxiDrawTouch controller."""
+
+
+class AxiDrawTouch(BaseTouch):
+    """A touch controller implementation using the AxiDraw plotting device.
+
+    This class provides methods to simulate touch gestures such as tap and swipe
+    by controlling an AxiDraw plotter based on screen coordinates.
+    """
+
+    PROPERTIES = ["auto_home"]
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        """Initializes the AxiDraw touch controller.
+
+        The configuration dictionary must contain:
+        - `width`: screen width in pixels
+        - `height`: screen height in pixels
+        - `start_pos`: tuple (x, y) of starting cartesian coordinates (in inches)
+        - `end_pos`: tuple (x, y) of ending cartesian coordinates (in inches)
+
+        Raises:
+            AxiTouchError: If initialization or connection to AxiDraw fails.
+        """
+
+        try:
+            uri = f"http://{config['host']}:{config['port']}"
+            self.screen_width_px: int = config["width"]
+            self.screen_height_px: int = config["height"]
+            self.cartesian_start: Tuple[float, float] = config["start_pos"]
+            self.cartesian_end: Tuple[float, float] = config["end_pos"]
+
+            self.auto_home = False   # Flag to track auto-home behavior
+
+            # Optional: configure pen heights and speed
+            pen_pos_up = 75
+            pen_pos_down = 40
+            speed_pendown = 100
+            speed_penup = 100
+            accel = 75
+
+            self.axi = xmlrpc.client.ServerProxy(uri)
+
+            self.axi.connect(accel,
+                pen_pos_up, pen_pos_down,
+                speed_penup, speed_pendown)
+
+        except KeyError as err:
+            raise Error(f"Missing required configuration key: {err}") from err
+        except Exception as err:
+            raise Error(f"Initialization failed: {err}") from err
+
+    def convert_to_inches(self, x: float, y: float) -> Tuple[float, float]:
+            x = float(x)
+            y = float(y)
+            sx, sy = self.cartesian_start
+            ex, ey = self.cartesian_end
+            x_scale = (ex - sx) / self.screen_width_px
+            y_scale = (ey - sy) / self.screen_height_px
+            return round(sx + x * x_scale, 3), round(sy + y * y_scale, 3)
+
+
+    def touch_init(self) -> None:
+        """Initialize the pen by lifting it up and moving to origin (0, 0).
+
+        Raises:
+            AxiTouchError: If initialization movement fails.
+        """
+
+        try:
+            self.axi.penup()
+            self.axi.home()
+            print("AxiDrawTouch: Initialized and moved to origin")
+        except Exception as err:
+            raise Error("Initialization failed") from err
+
+    def touch_tap(self, x: float, y: float, tap_time) -> None:
+        """Simulate a tap at the given screen coordinates.
+
+        Args:
+            x (int | float): X-coordinate in pixels.
+            y (int | float): Y-coordinate in pixels.
+            tap_time (float, optional): Duration to hold pen down. Defaults to 0.2s.
+
+        Raises:
+            AxiTouchError: If the tap operation fails.
+        """
+
+        try:
+            px, py = self.convert_to_inches(x, y)
+            print(px, py)
+            self.axi.tap(px, py, tap_time)
+            if self.auto_home:
+                self.axi.home()
+            print(f"AxiDrawTouch: Tap at ({x}, {y}) for {tap_time}s")
+        except Exception as err:
+            raise Error(f"Touch tap failed at ({x}, {y})") from err
+
+    def touch_swipe(
+        self,
+        startx: float,
+        starty: float,
+        endx: float,
+        endy: float
+    ) -> None:
+        """Simulate a swipe gesture from start to end coordinates.
+
+        Args:
+            startx (int | float): Start X-coordinate in pixels.
+            starty (int | float): Start Y-coordinate in pixels.
+            endx (int | float): End X-coordinate in pixels.
+            endy (int | float): End Y-coordinate in pixels.
+            swipe_time (float, optional): Duration of the swipe. Defaults to 0.2s.
+
+        Raises:
+            AxiTouchError: If the swipe operation fails.
+        """
+
+        try:
+            psx, psy = self.convert_to_inches(startx, starty)
+            pex, pey = self.convert_to_inches(endx, endy)
+            self.axi.swipe(psx, psy, pex, pey)
+            print(f"AxiDrawTouch: Swipe from ({startx}, {starty}) to ({endx}, {endy})")
+        except Exception as err:
+            raise Error(f"Swipe failed from ({startx}, {starty}) to ({endx}, {endy})") from err
+
+
+    def move(self, x: float, y: float):
+        """
+        Moving Axi arm to the absolute position in axi usable
+        area. where x and y are inches.
+        """
+        try:
+            if x == 0 and y == 0:
+                self.axi.home()
+                return
+            self.axi.move(x, y)
+        except Exception as err:
+            raise Error(f"Failed to Move pointing device from ({x}, {y})") from err
+
+    def home(self):
+        """Returns the touch to its home default position."""
+        try:
+            self.axi.home_with_limit_switch()
+        except Exception as err:
+            raise Error(f"Failed to Home pointing device") from err
+
+    def touch_command(self, cmd, *args):
+        """Executes a backend-specific touch command on the given device controller."""
+        cmd = cmd.lower()
+        if cmd == "move":
+            if len(args) != 2:
+                raise Error("move command expects x and y as argument")
+            x = float(args[0])
+            y = float(args[1])
+            self.move(x, y)
+        elif cmd == "home":
+            self.home()
+
+        else:
+            raise Error(f"Invalid command {cmd}")
+
+    def set_param(self, param: str, value: bool) -> None:
+        """
+        Set a runtime parameter for ArucoCapture.
+
+        | *Arguments*    | *Description* |
+        | `param (str)`  | Supported: `auto_home`. |
+        | `value (bool)` | True or False Value Supported. |
+
+        *Raises:*
+        | `Error` | If an unsupported parameter is provided. |
+        """
+        if param == 'auto_home' and param in self.PROPERTIES:
+            self.auto_home = value
+        else:
+            raise Error(f"ArucoCapture Error: Unsupported parameter: {param}")

parrot/touch/base.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+
+class Error(Exception):
+    """Base error for all TouchController implementations."""
+    pass
+
+class BaseTouch(ABC):
+    @abstractmethod
+    def touch_init(self) -> None:
+        """Initialize the touch controller."""
+        pass
+
+    @abstractmethod
+    def touch_tap(self, x: float, y: float, tap_time) -> None:
+        """Simulate a tap at (x, y) in pixels for the given duration."""
+        pass
+
+    @abstractmethod
+    def touch_swipe(
+        self,
+        startx: float,
+        starty: float,
+        endx: float,
+        endy: float,
+        tap_time
+    ) -> None:
+        """Simulate a swipe from (startx, starty) to (endx, endy) for the given duration."""
+        pass
+    @abstractmethod
+    def touch_command(self, cmd, *args) -> None:
+        """Executes a backend-specific touch command on the given device controller."""
+        pass

parrot/touch/dummy.py

@@ -0,0 +1,35 @@
+from parrot.touch.base import BaseTouch
+from typing import Any
+
+class DummyTouch(BaseTouch):
+    """A dummy touch controller for testing purposes.
+
+    This class simulates touch interactions by printing output
+    instead of interacting with physical hardware.
+    """
+
+    def __init__(self, config: Any = None) -> None:
+        pass
+
+    def touch_init(self) -> None:
+        """Initialize the dummy touch system."""
+        print("DummyTouch: Initialized")
+
+    def touch_tap(self, x: float, y: float, tap_time) -> None:
+        """Simulate a tap gesture at the given coordinates."""
+        print(f"DummyTouch: Tap at ({x}, {y}) for {tap_time}s")
+
+    def touch_swipe(
+        self,
+        startx: float,
+        starty: float,
+        endx: float,
+        endy: float,
+        tap_time
+    ) -> None:
+        """Simulate a swipe gesture from start to end coordinates."""
+        print(f"DummyTouch: Swipe from ({startx}, {starty}) to ({endx}, {endy}) for {tap_time}s")
+
+    def touch_command(self, cmd, *args) -> None:
+        """Executes a backend-specific touch command on the given device controller."""
+        print(f"DummyTouch: Touch command {cmd}, {args}")

parrot/touch/usbhidtouch.py

@@ -0,0 +1,120 @@
+import xmlrpc.client
+from typing import Any, Tuple
+from parrot.touch.base import BaseTouch, Error
+
+
+class UsbHidTouch(BaseTouch):
+    """
+    A touch controller implementation using USB-HID over XML-RPC.
+
+    This class allows simulating tap and swipe gestures by sending touch commands
+    over the network to a USB-HID device capable of interpreting XML-RPC messages.
+    """
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        """
+        Initializes the USB-HID touch controller.
+
+        The configuration dictionary must contain:
+        - `host`: IP or hostname of the XML-RPC server.
+        - `port`: Port number of the server.
+        - `width`: Screen width in pixels.
+        - `height`: Screen height in pixels.
+
+        Raises:
+            Error: If any required configuration is missing or initialization fails.
+        """
+        try:
+            self.host: str = config["host"]
+            self.port: int = config["port"]
+            self.screen_width_px: int = config["width"]
+            self.screen_height_px: int = config["height"]
+            self.handler = None
+        except KeyError as err:
+            raise Error(f"Missing required configuration key: {err}") from err
+        except Exception as err:
+            raise Error(f"Initialization failed: {err}") from err
+
+    def touch_init(self) -> None:
+        """
+        Initializes the XML-RPC connection to the USB-HID server.
+
+        Raises:
+            Error: If the connection to the HID server fails.
+        """
+        try:
+            self.handler = xmlrpc.client.ServerProxy(f"http://{self.host}:{self.port}/")
+            print(f"UsbHidTouch: Connected to {self.host}:{self.port}")
+        except Exception as err:
+            raise Error(f"Failed to initialize USB-HID connection: {err}") from err
+
+    def _convert_to_hid_coordinates(self, x: float, y: float) -> Tuple[float, float]:
+        """
+        Converts pixel coordinates to USB-HID scaled coordinates (0 to 0.5).
+
+        Args:
+            x (float): X-coordinate in pixels.
+            y (float): Y-coordinate in pixels.
+
+        Returns:
+            Tuple[float, float]: Normalized HID coordinates.
+
+        Raises:
+            Error: If the conversion fails.
+        """
+        try:
+            x_point = (x / self.screen_width_px) * 0.5
+            y_point = (y / self.screen_height_px) * 0.5
+            return round(x_point, 6), round(y_point, 6)
+        except Exception as err:
+            raise Error(f"Failed to convert coordinates ({x}, {y})") from err
+
+    def touch_tap(self, x: float, y: float, tap_time) -> None:
+        """
+        Simulates a tap gesture at the given screen coordinates.
+
+        Args:
+            x (float): X-coordinate in pixels.
+            y (float): Y-coordinate in pixels.
+            tap_time: Duration to hold touch (passed for consistency, but used by remote endpoint).
+
+        Raises:
+            Error: If the tap operation fails or response is invalid.
+        """
+        try:
+            hx, hy = self._convert_to_hid_coordinates(x, y)
+            command = f"T,{hx},{hy},{hx},{hy},{tap_time}"
+            response = self.handler.process_data(command.encode()).data.decode().strip()
+            if response != 'EXECUTED':
+                raise Error(f"Unexpected response from HID device: {response}")
+            print(f"UsbHidTouch: Tap at ({x}, {y}) with response '{response}'")
+        except Exception as err:
+            raise Error(f"Touch tap failed at ({x}, {y})") from err
+
+    def touch_swipe(self, startx: float, starty: float, endx: float, endy: float, tap_time) -> None:
+        """
+        Simulates a swipe gesture from start to end coordinates.
+
+        Args:
+            startx (float): Start X-coordinate in pixels.
+            starty (float): Start Y-coordinate in pixels.
+            endx (float): End X-coordinate in pixels.
+            endy (float): End Y-coordinate in pixels.
+            tap_time: Duration of swipe (passed for consistency, but used by remote endpoint).
+
+        Raises:
+            Error: If the swipe operation fails or response is invalid.
+        """
+        try:
+            sx, sy = self._convert_to_hid_coordinates(startx, starty)
+            ex, ey = self._convert_to_hid_coordinates(endx, endy)
+            command = f"T,{sx},{sy},{ex},{ey},{tap_time}"
+            response = self.handler.process_data(command.encode()).data.decode().strip()
+            if response != 'EXECUTED':
+                raise Error(f"Unexpected response from HID device: {response}")
+            print(f"UsbHidTouch: Swipe from ({startx}, {starty}) to ({endx}, {endy}) with response '{response}'")
+        except Exception as err:
+            raise Error(f"Swipe failed from ({startx}, {starty}) to ({endx}, {endy})") from err
+
+    def touch_command(self, cmd, *args):
+        raise Error("Commands are not supported by the UsbHidTouch backend")

robotframework_parrot_touchcontroller-1.0.0.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: robotframework-parrot-touchcontroller
+Version: 1.0.0
+Summary: Touch control api to use within the Robot Framework ecosystem
+Author-email: Zilogic Systems <code@zilogic.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/zilogic-systems/parrot
+Project-URL: Repository, https://github.com//zilogic-systems/parrot.git
+Project-URL: Issues, https://github.com/zilogic-systems/parrot/issues
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: robotframework
+Requires-Dist: pyyaml
+Requires-Dist: robotframework-parrot-adbcontroller
+
+# Touch Controller
+
+## Installation
+
+To install from package registry use the following command:
+
+```
+$ pip install robotframework-parrot-touchcontroller
+```
+
+To install from git repo use the following command:
+
+```
+$ pip install .
+```
+
+## Example
+
+Example of using the library in Robot Framework is available `example.robot`.

robotframework_parrot_touchcontroller-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+parrot/TouchController.py,sha256=I8XdsywwAckADREYkCebVBJyDyn-gydxQAY4dyQuk4g,9196
+parrot/touch/adbtouch.py,sha256=F2L1rCqDhL_2H4vyTfaEb5VOdu88rNxvaJlm2-delAI,3116
+parrot/touch/axitouch.py,sha256=XQN8jsZPbdUwRRoXNS5BeVtL5_UaGpidN37DuwEayHc,6396
+parrot/touch/base.py,sha256=S4FkV02Xpfydgpoek2FAdl8mUsSnzPmnWV-JLBSnhgQ,891
+parrot/touch/dummy.py,sha256=6yYigXIpt8qcbs-L9i8IlmI6SQoNaP2w_Iy2vg72o3g,1172
+parrot/touch/usbhidtouch.py,sha256=4HE8BAxk1VdpXzLzzMf5qulqMgfg4hFjyxrBbXdKu90,4892
+robotframework_parrot_touchcontroller-1.0.0.dist-info/METADATA,sha256=nv7DcM6gDVdQ0ABA4tZRYCZ2rljUb8LmglT8Si0h9fs,933
+robotframework_parrot_touchcontroller-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+robotframework_parrot_touchcontroller-1.0.0.dist-info/top_level.txt,sha256=sdNEP7dgW_pa1UCcMwz5m7u-_kJz4nShrBgz76lX8yc,7
+robotframework_parrot_touchcontroller-1.0.0.dist-info/RECORD,,

robotframework_parrot_touchcontroller-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

robotframework_parrot_touchcontroller-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+parrot