Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

18 files changed, 2137 insertions, 0 deletions

diff --git a/xbmc/input/touch/CMakeLists.txt b/xbmc/input/touch/CMakeLists.txt
new file mode 100644
index 0000000..12a228b
--- /dev/null
+++ b/xbmc/input/touch/CMakeLists.txt
@@ -0,0 +1,8 @@
+set(SOURCES ITouchInputHandling.cpp)
+
+set(HEADERS ITouchActionHandler.h
+            ITouchInputHandler.h
+            ITouchInputHandling.h
+            TouchTypes.h)
+
+core_add_library(input_touch)
diff --git a/xbmc/input/touch/ITouchActionHandler.h b/xbmc/input/touch/ITouchActionHandler.h
new file mode 100644
index 0000000..28afdd7
--- /dev/null
+++ b/xbmc/input/touch/ITouchActionHandler.h
@@ -0,0 +1,261 @@
+/*
+ *  Copyright (C) 2012-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+/*!
+ * \ingroup touch
+ * \brief Directions in which a touch can moved
+ *
+ * These values can be combined (bitwise OR) to specify multiple directions.
+ */
+typedef enum
+{
+  TouchMoveDirectionNone = 0x0,
+  TouchMoveDirectionLeft = 0x1,
+  TouchMoveDirectionRight = 0x2,
+  TouchMoveDirectionUp = 0x4,
+  TouchMoveDirectionDown = 0x8
+} TouchMoveDirection;
+
+/*!
+ * \ingroup touch
+ * \brief Interface defining all supported touch action events
+ */
+class ITouchActionHandler
+{
+public:
+  virtual ~ITouchActionHandler() = default;
+
+  /*!
+   * \brief A touch action has been aborted
+   */
+  virtual void OnTouchAbort() {}
+
+  /*!
+   * \brief A single touch has started
+   *
+   * \param x     The x coordinate (with sub-pixel) of the touch
+   * \param y     The y coordinate (with sub-pixel) of the touch
+   *
+   * \return True if the event was handled otherwise false
+   *
+   * \sa OnSingleTap
+   */
+  virtual bool OnSingleTouchStart(float x, float y) { return true; }
+  /*!
+   * \brief A single touch has been held down for a certain amount of time
+   *
+   * \param x     The x coordinate (with sub-pixel) of the touch
+   * \param y     The y coordinate (with sub-pixel) of the touch
+   *
+   * \return True if the event was handled otherwise false
+   *
+   * \sa OnSingleLongPress
+   */
+  virtual bool OnSingleTouchHold(float x, float y) { return true; }
+  /*!
+   * \brief A single touch has moved
+   *
+   * \param x             The x coordinate (with sub-pixel) of the current touch
+   * \param y             The y coordinate (with sub-pixel) of the current touch
+   * \param offsetX       The covered distance on the x axis (with sub-pixel)
+   * \param offsetX       The covered distance on the y axis (with sub-pixel)
+   * \param velocityX     The velocity of the gesture in x direction (pixels/second)
+   * \param velocityX     The velocity of the gesture in y direction (pixels/second)
+   *
+   * \return True if the event was handled otherwise false
+   *
+   * \sa OnTouchGesturePan
+   */
+  virtual bool OnSingleTouchMove(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+  {
+    return true;
+  }
+  /*!
+   * \brief A single touch has been lifted
+   *
+   * \param x     The x coordinate (with sub-pixel) of the touch
+   * \param y     The y coordinate (with sub-pixel) of the touch
+   *
+   * \return True if the event was handled otherwise false
+   *
+   * \sa OnSingleTap
+   */
+  virtual bool OnSingleTouchEnd(float x, float y) { return true; }
+
+  /*!
+   * \brief An additional touch has been performed
+   *
+   * \param x             The x coordinate (with sub-pixel) of the touch
+   * \param y             The y coordinate (with sub-pixel) of the touch
+   * \param pointer       The pointer that has performed the touch
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnMultiTouchDown(float x, float y, int32_t pointer) { return true; }
+  /*!
+   * \brief Multiple simultaneous touches have been held down for a certain amount of time
+   *
+   * \param x             The x coordinate (with sub-pixel) of the touch
+   * \param y             The y coordinate (with sub-pixel) of the touch
+   * \param pointers      The number of pointers involved (default 2)
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnMultiTouchHold(float x, float y, int32_t pointers = 2) { return true; }
+  /*!
+   * \brief A touch has moved
+   *
+   * \param x             The x coordinate (with sub-pixel) of the current touch
+   * \param y             The y coordinate (with sub-pixel) of the current touch
+   * \param offsetX       The covered distance on the x axis (with sub-pixel)
+   * \param offsetX       The covered distance on the y axis (with sub-pixel)
+   * \param velocityX     The velocity of the gesture in x direction (pixels/second)
+   * \param velocityX     The velocity of the gesture in y direction (pixels/second)
+   * \param pointer       The pointer that has performed the touch
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnMultiTouchMove(float x,
+                                float y,
+                                float offsetX,
+                                float offsetY,
+                                float velocityX,
+                                float velocityY,
+                                int32_t pointer)
+  {
+    return true;
+  }
+  /*!
+   * \brief A touch has been lifted (but there are still active touches)
+   *
+   * \param x             The x coordinate (with sub-pixel) of the touch
+   * \param y             The y coordinate (with sub-pixel) of the touch
+   * \param pointer       The pointer that has performed the touch
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnMultiTouchUp(float x, float y, int32_t pointer) { return true; }
+
+  /*!
+   * \brief A pan gesture with a single touch has been started
+   *
+   * \param x     The x coordinate (with sub-pixel) of the initial touch
+   * \param y     The y coordinate (with sub-pixel) of the initial touch
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnTouchGestureStart(float x, float y) { return true; }
+  /*!
+   * \brief A pan gesture with a single touch is in progress
+   *
+   * \param x             The x coordinate (with sub-pixel) of the current touch
+   * \param y             The y coordinate (with sub-pixel) of the current touch
+   * \param offsetX       The covered distance on the x axis (with sub-pixel)
+   * \param offsetX       The covered distance on the y axis (with sub-pixel)
+   * \param velocityX     The velocity of the gesture in x direction (pixels/second)
+   * \param velocityX     The velocity of the gesture in y direction (pixels/second)
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnTouchGesturePan(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+  {
+    return true;
+  }
+  /*!
+   * \brief A pan gesture with a single touch has ended
+   *
+   * \param x             The x coordinate (with sub-pixel) of the current touch
+   * \param y             The y coordinate (with sub-pixel) of the current touch
+   * \param offsetX       The covered distance on the x axis (with sub-pixel)
+   * \param offsetX       The covered distance on the y axis (with sub-pixel)
+   * \param velocityX     The velocity of the gesture in x direction (pixels/second)
+   * \param velocityX     The velocity of the gesture in y direction (pixels/second)
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnTouchGestureEnd(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+  {
+    return true;
+  }
+
+  // convenience events
+  /*!
+   * \brief A tap with a one or more touches has been performed
+   *
+   * \param x           The x coordinate (with sub-pixel) of the touch
+   * \param y           The y coordinate (with sub-pixel) of the touch
+   * \param pointers    The number of pointers involved (default 1)
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual void OnTap(float x, float y, int32_t pointers = 1) {}
+  /*!
+   * \brief One or more touches have been held down for a certain amount of time
+   *
+   * \param x           The x coordinate (with sub-pixel) of the touch
+   * \param y           The y coordinate (with sub-pixel) of the touch
+   * \param pointers    The number of pointers involved (default 1)
+   *
+   * \return True if the event was handled otherwise false
+   *
+   * \sa OnSingleTouchHold
+   */
+  virtual void OnLongPress(float x, float y, int32_t pointers = 1) {}
+  /*!
+   * \brief One or more touches has been moved quickly in a single direction in a short time
+   *
+   * \param direction     The direction (left, right, up, down) of the swipe gesture
+   * \param xDown         The x coordinate (with sub-pixel) of the first touch
+   * \param yDown         The y coordinate (with sub-pixel) of the first touch
+   * \param xUp           The x coordinate (with sub-pixel) of the last touch
+   * \param yUp           The y coordinate (with sub-pixel) of the last touch
+   * \param velocityX     The velocity of the gesture in x direction (pixels/second)
+   * \param velocityX     The velocity of the gesture in y direction (pixels/second)
+   * \param pointers      The number of pointers involved (default 1)
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual void OnSwipe(TouchMoveDirection direction,
+                       float xDown,
+                       float yDown,
+                       float xUp,
+                       float yUp,
+                       float velocityX,
+                       float velocityY,
+                       int32_t pointers = 1)
+  {
+  }
+  /*!
+   * \brief Two simultaneous touches have been held down and moved to perform a zooming/pinching
+   * gesture
+   *
+   * \param centerX       The x coordinate (with sub-pixel) of the center of the two touches
+   * \param centerY       The y coordinate (with sub-pixel) of the center of the two touches
+   * \param zoomFactor    The zoom (> 1.0) or pinch (< 1.0) factor of the two touches
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual void OnZoomPinch(float centerX, float centerY, float zoomFactor) {}
+  /*!
+   * \brief Two simultaneous touches have been held down and moved to perform a rotating gesture
+   *
+   * \param centerX       The x coordinate (with sub-pixel) of the center of the two touches
+   * \param centerY       The y coordinate (with sub-pixel) of the center of the two touches
+   * \param angle         The clockwise angle in degrees of the rotation
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual void OnRotate(float centerX, float centerY, float angle) {}
+};
diff --git a/xbmc/input/touch/ITouchInputHandler.h b/xbmc/input/touch/ITouchInputHandler.h
new file mode 100644
index 0000000..1275839
--- /dev/null
+++ b/xbmc/input/touch/ITouchInputHandler.h
@@ -0,0 +1,104 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/ITouchInputHandling.h"
+
+#include <atomic>
+#include <stdint.h>
+
+/*!
+ * \ingroup touch
+ * \brief Touch input event
+ */
+typedef enum
+{
+  TouchInputUnchanged = 0,
+  TouchInputAbort,
+  TouchInputDown,
+  TouchInputUp,
+  TouchInputMove
+} TouchInput;
+
+/*!
+ * \ingroup touch
+ * \brief Interface (implements ITouchInputHandling) defining methods to handle
+ *        raw touch input events (down, up, move).
+ *
+ * This interface should be implemented on platforms only supporting low level
+ * (raw) touch input events like touch down/up/move and with no gesture
+ * recognition logic.
+ */
+class ITouchInputHandler : public ITouchInputHandling
+{
+public:
+  ITouchInputHandler() : m_dpi(160.0f) {}
+  ~ITouchInputHandler() override = default;
+
+  /*!
+   * \brief Handle a touch event
+   *
+   * Handles the given touch event at the given location.
+   * This takes into account all the currently active pointers
+   * which need to be updated before calling this method to
+   * actually interpret and handle the changes in touch.
+   *
+   * \param event    The actual touch event (abort, down, up, move)
+   * \param x        The x coordinate (with sub-pixel) of the touch
+   * \param y        The y coordinate (with sub-pixel) of the touch
+   * \param time     The time (in nanoseconds) when this touch occurred
+   * \param pointer  The number of the touch pointer which caused this event (default 0)
+   * \param size     The size of the touch pointer (with sub-pixel) (default 0.0)
+   *
+   * \return True if the event was handled otherwise false.
+   *
+   * \sa Update
+   */
+  virtual bool HandleTouchInput(
+      TouchInput event, float x, float y, int64_t time, int32_t pointer = 0, float size = 0.0f) = 0;
+
+  /*!
+   * \brief Update the coordinates of a pointer
+   *
+   * Depending on how a platform handles touch input and provides the necessary events
+   * this method needs to be called at different times. If there's an event for every
+   * touch action this method does not need to be called at all. If there's only a
+   * touch event for the primary pointer (and no special events for any secondary
+   * pointers in a multi touch gesture) this method should be called for every active
+   * secondary pointer before calling Handle.
+   *
+   * \param pointer  The number of the touch pointer which caused this event (default 0)
+   * \param x        The x coordinate (with sub-pixel) of the touch
+   * \param y        The y coordinate (with sub-pixel) of the touch
+   * \param time     The time (in nanoseconds) when this touch occurred
+   * \param size     The size of the touch pointer (with sub-pixel) (default 0.0)
+   *
+   * \return True if the pointer was updated otherwise false.
+   *
+   * \sa Handle
+   */
+  virtual bool UpdateTouchPointer(
+      int32_t pointer, float x, float y, int64_t time, float size = 0.0f)
+  {
+    return false;
+  }
+
+  void SetScreenDPI(float dpi)
+  {
+    if (dpi > 0.0f)
+      m_dpi = dpi;
+  }
+  float GetScreenDPI() { return m_dpi; }
+
+protected:
+  /*!
+   * \brief DPI value of the touch screen
+   */
+  std::atomic<float> m_dpi;
+};
diff --git a/xbmc/input/touch/ITouchInputHandling.cpp b/xbmc/input/touch/ITouchInputHandling.cpp
new file mode 100644
index 0000000..e799f72
--- /dev/null
+++ b/xbmc/input/touch/ITouchInputHandling.cpp
@@ -0,0 +1,159 @@
+/*
+ *  Copyright (C) 2012-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "ITouchInputHandling.h"
+
+void ITouchInputHandling::RegisterHandler(ITouchActionHandler* touchHandler)
+{
+  m_handler = touchHandler;
+}
+
+void ITouchInputHandling::UnregisterHandler()
+{
+  m_handler = NULL;
+}
+
+void ITouchInputHandling::OnTouchAbort()
+{
+  if (m_handler)
+    m_handler->OnTouchAbort();
+}
+
+bool ITouchInputHandling::OnSingleTouchStart(float x, float y)
+{
+  if (m_handler)
+    return m_handler->OnSingleTouchStart(x, y);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnSingleTouchHold(float x, float y)
+{
+  if (m_handler)
+    return m_handler->OnSingleTouchHold(x, y);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnSingleTouchMove(
+    float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+{
+  if (m_handler)
+    return m_handler->OnSingleTouchMove(x, y, offsetX, offsetY, velocityX, velocityY);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnSingleTouchEnd(float x, float y)
+{
+  if (m_handler)
+    return m_handler->OnSingleTouchEnd(x, y);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnMultiTouchDown(float x, float y, int32_t pointer)
+{
+  if (m_handler)
+    return m_handler->OnMultiTouchDown(x, y, pointer);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnMultiTouchHold(float x, float y, int32_t pointers /* = 2 */)
+{
+  if (m_handler)
+    return m_handler->OnMultiTouchHold(x, y, pointers);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnMultiTouchMove(float x,
+                                           float y,
+                                           float offsetX,
+                                           float offsetY,
+                                           float velocityX,
+                                           float velocityY,
+                                           int32_t pointer)
+{
+  if (m_handler)
+    return m_handler->OnMultiTouchMove(x, y, offsetX, offsetY, velocityX, velocityY, pointer);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnMultiTouchUp(float x, float y, int32_t pointer)
+{
+  if (m_handler)
+    return m_handler->OnMultiTouchUp(x, y, pointer);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnTouchGestureStart(float x, float y)
+{
+  if (m_handler)
+    return m_handler->OnTouchGestureStart(x, y);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnTouchGesturePan(
+    float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+{
+  if (m_handler)
+    return m_handler->OnTouchGesturePan(x, y, offsetX, offsetY, velocityX, velocityY);
+
+  return true;
+}
+
+bool ITouchInputHandling::OnTouchGestureEnd(
+    float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+{
+  if (m_handler)
+    return m_handler->OnTouchGestureEnd(x, y, offsetX, offsetY, velocityX, velocityY);
+
+  return true;
+}
+
+void ITouchInputHandling::OnTap(float x, float y, int32_t pointers /* = 1 */)
+{
+  if (m_handler)
+    m_handler->OnTap(x, y, pointers);
+}
+
+void ITouchInputHandling::OnLongPress(float x, float y, int32_t pointers /* = 1 */)
+{
+  if (m_handler)
+    m_handler->OnLongPress(x, y, pointers);
+}
+
+void ITouchInputHandling::OnSwipe(TouchMoveDirection direction,
+                                  float xDown,
+                                  float yDown,
+                                  float xUp,
+                                  float yUp,
+                                  float velocityX,
+                                  float velocityY,
+                                  int32_t pointers /* = 1 */)
+{
+  if (m_handler)
+    m_handler->OnSwipe(direction, xDown, yDown, xUp, yUp, velocityX, velocityY, pointers);
+}
+
+void ITouchInputHandling::OnZoomPinch(float centerX, float centerY, float zoomFactor)
+{
+  if (m_handler)
+    m_handler->OnZoomPinch(centerX, centerY, zoomFactor);
+}
+
+void ITouchInputHandling::OnRotate(float centerX, float centerY, float angle)
+{
+  if (m_handler)
+    m_handler->OnRotate(centerX, centerY, angle);
+}
diff --git a/xbmc/input/touch/ITouchInputHandling.h b/xbmc/input/touch/ITouchInputHandling.h
new file mode 100644
index 0000000..cabbf47
--- /dev/null
+++ b/xbmc/input/touch/ITouchInputHandling.h
@@ -0,0 +1,90 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/ITouchActionHandler.h"
+
+#include <stdlib.h>
+
+/*!
+ * \ingroup touch
+ * \brief Convenience interface implementing ITouchActionHandler with an
+ *        implementation that forwards any ITouchActionHandler-related calls
+ *        to a previously registered ITouchActionHandler
+ *
+ * \sa ITouchActionHandler
+ */
+class ITouchInputHandling : protected ITouchActionHandler
+{
+public:
+  ITouchInputHandling() : m_handler(NULL) {}
+  ~ITouchInputHandling() override = default;
+
+  /*!
+   * \brief Register a touch input handler
+   *
+   * There can only be one touch input handler.
+   *
+   * \param touchHandler    An instance of a touch handler implementing the
+   *                        ITouchActionHandler interface
+   *
+   * \sa UnregisterHandler
+   */
+  void RegisterHandler(ITouchActionHandler* touchHandler);
+  /*!
+   * \brief Unregister the previously registered touch handler
+   *
+   * \sa RegisterHandler
+   */
+  void UnregisterHandler();
+
+protected:
+  // implementation of ITouchActionHandler
+  void OnTouchAbort() override;
+
+  bool OnSingleTouchStart(float x, float y) override;
+  bool OnSingleTouchHold(float x, float y) override;
+  bool OnSingleTouchMove(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY) override;
+  bool OnSingleTouchEnd(float x, float y) override;
+
+  bool OnMultiTouchDown(float x, float y, int32_t pointer) override;
+  bool OnMultiTouchHold(float x, float y, int32_t pointers = 2) override;
+  bool OnMultiTouchMove(float x,
+                        float y,
+                        float offsetX,
+                        float offsetY,
+                        float velocityX,
+                        float velocityY,
+                        int32_t pointer) override;
+  bool OnMultiTouchUp(float x, float y, int32_t pointer) override;
+
+  bool OnTouchGestureStart(float x, float y) override;
+  bool OnTouchGesturePan(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY) override;
+  bool OnTouchGestureEnd(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY) override;
+
+  // convenience events
+  void OnTap(float x, float y, int32_t pointers = 1) override;
+  void OnLongPress(float x, float y, int32_t pointers = 1) override;
+  void OnSwipe(TouchMoveDirection direction,
+               float xDown,
+               float yDown,
+               float xUp,
+               float yUp,
+               float velocityX,
+               float velocityY,
+               int32_t pointers = 1) override;
+  void OnZoomPinch(float centerX, float centerY, float zoomFactor) override;
+  void OnRotate(float centerX, float centerY, float angle) override;
+
+private:
+  ITouchActionHandler* m_handler;
+};
diff --git a/xbmc/input/touch/TouchTypes.h b/xbmc/input/touch/TouchTypes.h
new file mode 100644
index 0000000..b3450c4
--- /dev/null
+++ b/xbmc/input/touch/TouchTypes.h
@@ -0,0 +1,112 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "utils/Vector.h"
+
+/*!
+ * \ingroup touch
+ * \brief A class representing a touch consisting of an x and y coordinate and
+ *        a time
+ */
+class Touch : public CVector
+{
+public:
+  /*!
+   * \brief Checks if the touch is valid i.e. if the x/y coordinates and the
+   *        time are >= 0
+   *
+   * \return True if the touch is valid otherwise false
+   */
+  bool valid() const { return x >= 0.0f && y >= 0.0f && time >= 0; }
+
+  /*!
+   * \brief Copies the x/y coordinates and the time from the given touch
+   *
+   * \param other Touch to copy x/y coordinates and time from
+   */
+  void copy(const Touch& other)
+  {
+    x = other.x;
+    y = other.y;
+    time = other.time;
+  }
+
+  int64_t time = -1; // in nanoseconds
+};
+
+/*!
+ * \ingroup touch
+ * \brief A class representing a touch pointer interaction consisting of an
+ *        down touch, the last touch and the current touch.
+ */
+class Pointer
+{
+public:
+  Pointer() { reset(); }
+
+  /*!
+   * \brief Resets the pointer and all its touches
+   */
+  void reset()
+  {
+    down = {};
+    last = {};
+    moving = false;
+    size = 0.0f;
+  }
+
+  /*!
+   * \brief Checks if the "down" touch is valid
+   *
+   * \return True if the "down" touch is valid otherwise false
+   */
+  bool valid() const { return down.valid(); }
+
+  /*!
+   * \brief Calculates the velocity in x/y direction using the "down" and
+   *        either the "last" or "current" touch
+   *
+   * \param velocityX   Placeholder for velocity in x direction
+   * \param velocityY   Placeholder for velocity in y direction
+   * \param fromLast    Whether to calculate the velocity with the "last" or
+   *                    the "current" touch
+   *
+   * \return True if the velocity is valid otherwise false
+   */
+  bool velocity(float& velocityX, float& velocityY, bool fromLast = true) const
+  {
+    int64_t fromTime = last.time;
+    float fromX = last.x;
+    float fromY = last.y;
+    if (!fromLast)
+    {
+      fromTime = down.time;
+      fromX = down.x;
+      fromY = down.y;
+    }
+
+    velocityX = 0.0f; // number of pixels per second
+    velocityY = 0.0f; // number of pixels per second
+
+    int64_t timeDiff = current.time - fromTime;
+    if (timeDiff <= 0)
+      return false;
+
+    velocityX = ((current.x - fromX) * 1000000000) / timeDiff;
+    velocityY = ((current.y - fromY) * 1000000000) / timeDiff;
+    return true;
+  }
+
+  Touch down;
+  Touch last;
+  Touch current;
+  bool moving;
+  float size;
+};
diff --git a/xbmc/input/touch/generic/CMakeLists.txt b/xbmc/input/touch/generic/CMakeLists.txt
new file mode 100644
index 0000000..d5e8adc
--- /dev/null
+++ b/xbmc/input/touch/generic/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(SOURCES GenericTouchActionHandler.cpp
+            GenericTouchInputHandler.cpp
+            GenericTouchPinchDetector.cpp
+            GenericTouchRotateDetector.cpp
+            GenericTouchSwipeDetector.cpp)
+
+set(HEADERS GenericTouchActionHandler.h
+            GenericTouchInputHandler.h
+            GenericTouchPinchDetector.h
+            GenericTouchRotateDetector.h
+            GenericTouchSwipeDetector.h
+            IGenericTouchGestureDetector.h)
+
+core_add_library(input_touch_generic)
diff --git a/xbmc/input/touch/generic/GenericTouchActionHandler.cpp b/xbmc/input/touch/generic/GenericTouchActionHandler.cpp
new file mode 100644
index 0000000..d601074
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchActionHandler.cpp
@@ -0,0 +1,212 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GenericTouchActionHandler.h"
+
+#include "ServiceBroker.h"
+#include "application/AppInboundProtocol.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "input/Key.h"
+
+#include <cmath>
+
+using namespace KODI::MESSAGING;
+
+CGenericTouchActionHandler& CGenericTouchActionHandler::GetInstance()
+{
+  static CGenericTouchActionHandler sTouchAction;
+  return sTouchAction;
+}
+
+void CGenericTouchActionHandler::OnTouchAbort()
+{
+  sendEvent(ACTION_GESTURE_ABORT, 0.0f, 0.0f);
+}
+
+bool CGenericTouchActionHandler::OnSingleTouchStart(float x, float y)
+{
+  focusControl(x, y);
+
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnSingleTouchHold(float x, float y)
+{
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnSingleTouchMove(
+    float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+{
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnSingleTouchEnd(float x, float y)
+{
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnMultiTouchDown(float x, float y, int32_t pointer)
+{
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnMultiTouchHold(float x, float y, int32_t pointers /* = 2 */)
+{
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnMultiTouchMove(float x,
+                                                  float y,
+                                                  float offsetX,
+                                                  float offsetY,
+                                                  float velocityX,
+                                                  float velocityY,
+                                                  int32_t pointer)
+{
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnMultiTouchUp(float x, float y, int32_t pointer)
+{
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnTouchGestureStart(float x, float y)
+{
+  sendEvent(ACTION_GESTURE_BEGIN, x, y, 0.0f, 0.0f);
+
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnTouchGesturePan(
+    float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+{
+  sendEvent(ACTION_GESTURE_PAN, x, y, offsetX, offsetY, velocityX, velocityY);
+
+  return true;
+}
+
+bool CGenericTouchActionHandler::OnTouchGestureEnd(
+    float x, float y, float offsetX, float offsetY, float velocityX, float velocityY)
+{
+  sendEvent(ACTION_GESTURE_END, velocityX, velocityY, x, y, offsetX, offsetY);
+
+  return true;
+}
+
+void CGenericTouchActionHandler::OnTap(float x, float y, int32_t pointers /* = 1 */)
+{
+  if (pointers <= 0 || pointers > 10)
+    return;
+
+  sendEvent(ACTION_TOUCH_TAP, x, y, 0.0f, 0.0f, 0.0f, 0.0f, pointers);
+}
+
+void CGenericTouchActionHandler::OnLongPress(float x, float y, int32_t pointers /* = 1 */)
+{
+  if (pointers <= 0 || pointers > 10)
+    return;
+
+  sendEvent(ACTION_TOUCH_LONGPRESS, x, y, 0.0f, 0.0f, 0.0f, 0.0f, pointers);
+}
+
+void CGenericTouchActionHandler::OnSwipe(TouchMoveDirection direction,
+                                         float xDown,
+                                         float yDown,
+                                         float xUp,
+                                         float yUp,
+                                         float velocityX,
+                                         float velocityY,
+                                         int32_t pointers /* = 1 */)
+{
+  if (pointers <= 0 || pointers > 10)
+    return;
+
+  int actionId = 0;
+  if (direction == TouchMoveDirectionLeft)
+    actionId = ACTION_GESTURE_SWIPE_LEFT;
+  else if (direction == TouchMoveDirectionRight)
+    actionId = ACTION_GESTURE_SWIPE_RIGHT;
+  else if (direction == TouchMoveDirectionUp)
+    actionId = ACTION_GESTURE_SWIPE_UP;
+  else if (direction == TouchMoveDirectionDown)
+    actionId = ACTION_GESTURE_SWIPE_DOWN;
+  else
+    return;
+
+  sendEvent(actionId, xUp, yUp, velocityX, velocityY, xDown, yDown, pointers);
+}
+
+void CGenericTouchActionHandler::OnZoomPinch(float centerX, float centerY, float zoomFactor)
+{
+  sendEvent(ACTION_GESTURE_ZOOM, centerX, centerY, zoomFactor, 0.0f);
+}
+
+void CGenericTouchActionHandler::OnRotate(float centerX, float centerY, float angle)
+{
+  sendEvent(ACTION_GESTURE_ROTATE, centerX, centerY, angle, 0.0f);
+}
+
+int CGenericTouchActionHandler::QuerySupportedGestures(float x, float y)
+{
+  CGUIMessage msg(GUI_MSG_GESTURE_NOTIFY, 0, 0, static_cast<int>(std::round(x)),
+                  static_cast<int>(std::round(y)));
+  if (!CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg))
+    return 0;
+
+  int result = 0;
+  if (msg.GetPointer())
+  {
+    int* p = static_cast<int*>(msg.GetPointer());
+    msg.SetPointer(nullptr);
+    result = *p;
+    delete p;
+  }
+  return result;
+}
+
+void CGenericTouchActionHandler::sendEvent(int actionId,
+                                           float x,
+                                           float y,
+                                           float x2 /* = 0.0f */,
+                                           float y2 /* = 0.0f */,
+                                           float x3,
+                                           float y3,
+                                           int pointers /* = 1 */)
+{
+  XBMC_Event newEvent{};
+  newEvent.type = XBMC_TOUCH;
+
+  newEvent.touch.action = actionId;
+  newEvent.touch.x = x;
+  newEvent.touch.y = y;
+  newEvent.touch.x2 = x2;
+  newEvent.touch.y2 = y2;
+  newEvent.touch.x3 = x3;
+  newEvent.touch.y3 = y3;
+  newEvent.touch.pointers = pointers;
+
+  std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort();
+  if (appPort)
+    appPort->OnEvent(newEvent);
+}
+
+void CGenericTouchActionHandler::focusControl(float x, float y)
+{
+  XBMC_Event newEvent{};
+  newEvent.type = XBMC_SETFOCUS;
+
+  newEvent.focus.x = static_cast<int>(std::round(x));
+  newEvent.focus.y = static_cast<int>(std::round(y));
+
+  std::shared_ptr<CAppInboundProtocol> appPort = CServiceBroker::GetAppPort();
+  if (appPort)
+    appPort->OnEvent(newEvent);
+}
diff --git a/xbmc/input/touch/generic/GenericTouchActionHandler.h b/xbmc/input/touch/generic/GenericTouchActionHandler.h
new file mode 100644
index 0000000..e8697ce
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchActionHandler.h
@@ -0,0 +1,94 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/ITouchActionHandler.h"
+
+/*!
+ * \ingroup touch_generic
+ * \brief Generic implementation of ITouchActionHandler to translate
+ *        touch actions into XBMC specific and mappable actions.
+ *
+ * \sa ITouchActionHandler
+ */
+class CGenericTouchActionHandler : public ITouchActionHandler
+{
+public:
+  /*!
+   \brief Get an instance of the touch input manager
+   */
+  static CGenericTouchActionHandler& GetInstance();
+
+  // implementation of ITouchActionHandler
+  void OnTouchAbort() override;
+
+  bool OnSingleTouchStart(float x, float y) override;
+  bool OnSingleTouchHold(float x, float y) override;
+  bool OnSingleTouchMove(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY) override;
+  bool OnSingleTouchEnd(float x, float y) override;
+
+  bool OnMultiTouchDown(float x, float y, int32_t pointer) override;
+  bool OnMultiTouchHold(float x, float y, int32_t pointers = 2) override;
+  bool OnMultiTouchMove(float x,
+                        float y,
+                        float offsetX,
+                        float offsetY,
+                        float velocityX,
+                        float velocityY,
+                        int32_t pointer) override;
+  bool OnMultiTouchUp(float x, float y, int32_t pointer) override;
+
+  bool OnTouchGestureStart(float x, float y) override;
+  bool OnTouchGesturePan(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY) override;
+  bool OnTouchGestureEnd(
+      float x, float y, float offsetX, float offsetY, float velocityX, float velocityY) override;
+
+  // convenience events
+  void OnTap(float x, float y, int32_t pointers = 1) override;
+  void OnLongPress(float x, float y, int32_t pointers = 1) override;
+  void OnSwipe(TouchMoveDirection direction,
+               float xDown,
+               float yDown,
+               float xUp,
+               float yUp,
+               float velocityX,
+               float velocityY,
+               int32_t pointers = 1) override;
+  void OnZoomPinch(float centerX, float centerY, float zoomFactor) override;
+  void OnRotate(float centerX, float centerY, float angle) override;
+
+  /*!
+   \brief Asks the control at the given coordinates for a list of the supported gestures.
+
+   \param x     The x coordinate (with sub-pixel) of the touch
+   \param y     The y coordinate (with sub-pixel) of the touch
+
+   \return EVENT_RESULT value of bitwise ORed gestures.
+   */
+  int QuerySupportedGestures(float x, float y);
+
+private:
+  // private construction, and no assignments; use the provided singleton methods
+  CGenericTouchActionHandler() = default;
+  CGenericTouchActionHandler(const CGenericTouchActionHandler&) = delete;
+  CGenericTouchActionHandler const& operator=(CGenericTouchActionHandler const&) = delete;
+  ~CGenericTouchActionHandler() override = default;
+
+  void sendEvent(int actionId,
+                 float x,
+                 float y,
+                 float x2 = 0.0f,
+                 float y2 = 0.0f,
+                 float x3 = 0.0f,
+                 float y3 = 0.0f,
+                 int pointers = 1);
+  void focusControl(float x, float y);
+};
diff --git a/xbmc/input/touch/generic/GenericTouchInputHandler.cpp b/xbmc/input/touch/generic/GenericTouchInputHandler.cpp
new file mode 100644
index 0000000..6290860
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchInputHandler.cpp
@@ -0,0 +1,397 @@
+/*
+ *  Copyright (C) 2012-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GenericTouchInputHandler.h"
+
+#include "input/touch/generic/GenericTouchPinchDetector.h"
+#include "input/touch/generic/GenericTouchRotateDetector.h"
+#include "input/touch/generic/GenericTouchSwipeDetector.h"
+#include "utils/log.h"
+
+#include <algorithm>
+#include <cmath>
+#include <mutex>
+
+using namespace std::chrono_literals;
+
+namespace
+{
+constexpr auto TOUCH_HOLD_TIMEOUT = 500ms;
+}
+
+CGenericTouchInputHandler::CGenericTouchInputHandler() : m_holdTimer(new CTimer(this))
+{
+}
+
+CGenericTouchInputHandler::~CGenericTouchInputHandler() = default;
+
+CGenericTouchInputHandler& CGenericTouchInputHandler::GetInstance()
+{
+  static CGenericTouchInputHandler sTouchInput;
+  return sTouchInput;
+}
+
+float CGenericTouchInputHandler::AdjustPointerSize(float size)
+{
+  if (size > 0.0f)
+    return size;
+  else
+    // Set a default size if touch input layer does not have anything useful,
+    // approx. 3.2mm
+    return m_dpi / 8.0f;
+}
+
+bool CGenericTouchInputHandler::HandleTouchInput(TouchInput event,
+                                                 float x,
+                                                 float y,
+                                                 int64_t time,
+                                                 int32_t pointer /* = 0 */,
+                                                 float size /* = 0.0f */)
+{
+  if (time < 0 || pointer < 0 || pointer >= MAX_POINTERS)
+    return false;
+
+  std::unique_lock<CCriticalSection> lock(m_critical);
+
+  bool result = true;
+
+  m_pointers[pointer].current.x = x;
+  m_pointers[pointer].current.y = y;
+  m_pointers[pointer].current.time = time;
+
+  switch (event)
+  {
+    case TouchInputAbort:
+    {
+      triggerDetectors(event, pointer);
+
+      setGestureState(TouchGestureUnknown);
+      for (auto& pointer : m_pointers)
+        pointer.reset();
+
+      OnTouchAbort();
+      break;
+    }
+
+    case TouchInputDown:
+    {
+      m_pointers[pointer].down.x = x;
+      m_pointers[pointer].down.y = y;
+      m_pointers[pointer].down.time = time;
+      m_pointers[pointer].moving = false;
+      m_pointers[pointer].size = AdjustPointerSize(size);
+
+      // If this is the down event of the primary pointer
+      // we start by assuming that it's a single touch
+      if (pointer == 0)
+      {
+        // create new gesture detectors
+        m_detectors.emplace(new CGenericTouchSwipeDetector(this, m_dpi));
+        m_detectors.emplace(new CGenericTouchPinchDetector(this, m_dpi));
+        m_detectors.emplace(new CGenericTouchRotateDetector(this, m_dpi));
+        triggerDetectors(event, pointer);
+
+        setGestureState(TouchGestureSingleTouch);
+        result = OnSingleTouchStart(x, y);
+
+        m_holdTimer->Start(TOUCH_HOLD_TIMEOUT);
+      }
+      // Otherwise it's the down event of another pointer
+      else
+      {
+        triggerDetectors(event, pointer);
+
+        // If we so far assumed single touch or still have the primary
+        // pointer of a previous multi touch pressed down, we can update to multi touch
+        if (m_gestureState == TouchGestureSingleTouch ||
+            m_gestureState == TouchGestureSingleTouchHold ||
+            m_gestureState == TouchGestureMultiTouchDone)
+        {
+          result = OnMultiTouchDown(x, y, pointer);
+          m_holdTimer->Stop(true);
+
+          if (m_gestureState == TouchGestureSingleTouch ||
+              m_gestureState == TouchGestureSingleTouchHold)
+            m_holdTimer->Start(TOUCH_HOLD_TIMEOUT);
+
+          setGestureState(TouchGestureMultiTouchStart);
+        }
+        // Otherwise we should ignore this pointer
+        else
+        {
+          m_pointers[pointer].reset();
+          break;
+        }
+      }
+      return result;
+    }
+
+    case TouchInputUp:
+    {
+      // unexpected event => abort
+      if (!m_pointers[pointer].valid() || m_gestureState == TouchGestureUnknown)
+        break;
+
+      triggerDetectors(event, pointer);
+
+      m_holdTimer->Stop(false);
+
+      // Just a single tap with a pointer
+      if (m_gestureState == TouchGestureSingleTouch ||
+          m_gestureState == TouchGestureSingleTouchHold)
+      {
+        result = OnSingleTouchEnd(x, y);
+
+        if (m_gestureState == TouchGestureSingleTouch)
+          OnTap(x, y, 1);
+      }
+      // A pan gesture started with a single pointer (ignoring any other pointers)
+      else if (m_gestureState == TouchGesturePan)
+      {
+        float velocityX = 0.0f; // number of pixels per second
+        float velocityY = 0.0f; // number of pixels per second
+        m_pointers[pointer].velocity(velocityX, velocityY, false);
+
+        result = OnTouchGestureEnd(x, y, x - m_pointers[pointer].down.x,
+                                   y - m_pointers[pointer].down.y, velocityX, velocityY);
+      }
+      // we are in multi-touch
+      else
+        result = OnMultiTouchUp(x, y, pointer);
+
+      // If we were in multi touch mode and lifted one pointer
+      // we can go into the TouchGestureMultiTouchDone state which will allow
+      // the user to go back into multi touch mode without lifting the primary pointer
+      if (m_gestureState == TouchGestureMultiTouchStart ||
+          m_gestureState == TouchGestureMultiTouchHold || m_gestureState == TouchGestureMultiTouch)
+      {
+        setGestureState(TouchGestureMultiTouchDone);
+
+        // after lifting the primary pointer, the secondary pointer will
+        // become the primary pointer in the next event
+        if (pointer == 0)
+        {
+          m_pointers[0] = m_pointers[1];
+          pointer = 1;
+        }
+      }
+      // Otherwise abort
+      else
+      {
+        if (m_gestureState == TouchGestureMultiTouchDone)
+        {
+          float velocityX = 0.0f; // number of pixels per second
+          float velocityY = 0.0f; // number of pixels per second
+          m_pointers[pointer].velocity(velocityX, velocityY, false);
+
+          result = OnTouchGestureEnd(x, y, x - m_pointers[pointer].down.x,
+                                     y - m_pointers[pointer].down.y, velocityX, velocityY);
+
+          // if neither of the two pointers moved we have a single tap with multiple pointers
+          if (m_gestureStateOld != TouchGestureMultiTouchHold &&
+              m_gestureStateOld != TouchGestureMultiTouch)
+            OnTap(std::abs((m_pointers[0].down.x + m_pointers[1].down.x) / 2),
+                  std::abs((m_pointers[0].down.y + m_pointers[1].down.y) / 2), 2);
+        }
+
+        setGestureState(TouchGestureUnknown);
+      }
+      m_pointers[pointer].reset();
+
+      return result;
+    }
+
+    case TouchInputMove:
+    {
+      // unexpected event => abort
+      if (!m_pointers[pointer].valid() || m_gestureState == TouchGestureUnknown ||
+          m_gestureState == TouchGestureMultiTouchDone)
+        break;
+
+      bool moving = std::any_of(m_pointers.cbegin(), m_pointers.cend(),
+                                [](Pointer const& p) { return p.valid() && p.moving; });
+
+      if (moving)
+      {
+        m_holdTimer->Stop();
+
+        // the touch is moving so we start a gesture
+        if (m_gestureState == TouchGestureSingleTouch ||
+            m_gestureState == TouchGestureMultiTouchStart)
+          result = OnTouchGestureStart(m_pointers[pointer].down.x, m_pointers[pointer].down.y);
+      }
+
+      triggerDetectors(event, pointer);
+
+      // Check if the touch has moved far enough to count as movement
+      if ((m_gestureState == TouchGestureSingleTouch ||
+           m_gestureState == TouchGestureMultiTouchStart) &&
+          !m_pointers[pointer].moving)
+        break;
+
+      if (m_gestureState == TouchGestureSingleTouch)
+      {
+        m_pointers[pointer].last.copy(m_pointers[pointer].down);
+        setGestureState(TouchGesturePan);
+      }
+      else if (m_gestureState == TouchGestureMultiTouchStart)
+      {
+        setGestureState(TouchGestureMultiTouch);
+
+        // set the starting point
+        saveLastTouch();
+      }
+
+      float offsetX = x - m_pointers[pointer].last.x;
+      float offsetY = y - m_pointers[pointer].last.y;
+      float velocityX = 0.0f; // number of pixels per second
+      float velocityY = 0.0f; // number of pixels per second
+      m_pointers[pointer].velocity(velocityX, velocityY);
+
+      if (m_pointers[pointer].moving &&
+          (m_gestureState == TouchGestureSingleTouch ||
+           m_gestureState == TouchGestureSingleTouchHold || m_gestureState == TouchGesturePan))
+        result = OnSingleTouchMove(x, y, offsetX, offsetY, velocityX, velocityY);
+
+      // Let's see if we have a pan gesture (i.e. the primary and only pointer moving)
+      if (m_gestureState == TouchGesturePan)
+      {
+        result = OnTouchGesturePan(x, y, offsetX, offsetY, velocityX, velocityY);
+
+        m_pointers[pointer].last.x = x;
+        m_pointers[pointer].last.y = y;
+      }
+      else if (m_gestureState == TouchGestureMultiTouch)
+      {
+        if (moving)
+          result = OnMultiTouchMove(x, y, offsetX, offsetY, velocityX, velocityY, pointer);
+      }
+      else
+        break;
+
+      return result;
+    }
+
+    default:
+      CLog::Log(LOGDEBUG, "CGenericTouchInputHandler: unknown TouchInput");
+      break;
+  }
+
+  return false;
+}
+
+bool CGenericTouchInputHandler::UpdateTouchPointer(
+    int32_t pointer, float x, float y, int64_t time, float size /* = 0.0f */)
+{
+  if (pointer < 0 || pointer >= MAX_POINTERS)
+    return false;
+
+  std::unique_lock<CCriticalSection> lock(m_critical);
+
+  m_pointers[pointer].last.copy(m_pointers[pointer].current);
+
+  m_pointers[pointer].current.x = x;
+  m_pointers[pointer].current.y = y;
+  m_pointers[pointer].current.time = time;
+  m_pointers[pointer].size = AdjustPointerSize(size);
+
+  // calculate whether the pointer has moved at all
+  if (!m_pointers[pointer].moving)
+  {
+    CVector down = m_pointers[pointer].down;
+    CVector current = m_pointers[pointer].current;
+    CVector distance = down - current;
+
+    if (distance.length() > m_pointers[pointer].size)
+      m_pointers[pointer].moving = true;
+  }
+
+  for (auto const& detector : m_detectors)
+    detector->OnTouchUpdate(pointer, m_pointers[pointer]);
+
+  return true;
+}
+
+void CGenericTouchInputHandler::saveLastTouch()
+{
+  for (auto& pointer : m_pointers)
+    pointer.last.copy(pointer.current);
+}
+
+void CGenericTouchInputHandler::OnTimeout()
+{
+  std::unique_lock<CCriticalSection> lock(m_critical);
+
+  switch (m_gestureState)
+  {
+    case TouchGestureSingleTouch:
+      setGestureState(TouchGestureSingleTouchHold);
+
+      OnSingleTouchHold(m_pointers[0].down.x, m_pointers[0].down.y);
+      OnLongPress(m_pointers[0].down.x, m_pointers[0].down.y, 1);
+      break;
+
+    case TouchGestureMultiTouchStart:
+      if (!m_pointers[0].moving && !m_pointers[1].moving)
+      {
+        setGestureState(TouchGestureMultiTouchHold);
+
+        OnMultiTouchHold(m_pointers[0].down.x, m_pointers[0].down.y);
+        OnLongPress(std::abs((m_pointers[0].down.x + m_pointers[1].down.x) / 2),
+                    std::abs((m_pointers[0].down.y + m_pointers[1].down.y) / 2), 2);
+      }
+      break;
+
+    default:
+      break;
+  }
+}
+
+void CGenericTouchInputHandler::triggerDetectors(TouchInput event, int32_t pointer)
+{
+  switch (event)
+  {
+    case TouchInputAbort:
+    {
+      m_detectors.clear();
+      break;
+    }
+
+    case TouchInputDown:
+    {
+      for (auto const& detector : m_detectors)
+        detector->OnTouchDown(pointer, m_pointers[pointer]);
+      break;
+    }
+
+    case TouchInputUp:
+    {
+      for (auto const& detector : m_detectors)
+        detector->OnTouchUp(pointer, m_pointers[pointer]);
+      break;
+    }
+
+    case TouchInputMove:
+    {
+      for (auto const& detector : m_detectors)
+        detector->OnTouchMove(pointer, m_pointers[pointer]);
+      break;
+    }
+
+    default:
+      return;
+  }
+
+  for (auto it = m_detectors.begin(); it != m_detectors.end();)
+  {
+    if ((*it)->IsDone())
+      it = m_detectors.erase(it);
+    else
+      it++;
+  }
+}
diff --git a/xbmc/input/touch/generic/GenericTouchInputHandler.h b/xbmc/input/touch/generic/GenericTouchInputHandler.h
new file mode 100644
index 0000000..154f5f2
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchInputHandler.h
@@ -0,0 +1,98 @@
+/*
+ *  Copyright (C) 2012-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/ITouchInputHandler.h"
+#include "input/touch/TouchTypes.h"
+#include "threads/CriticalSection.h"
+#include "threads/Timer.h"
+
+#include <array>
+#include <memory>
+#include <set>
+
+class IGenericTouchGestureDetector;
+
+/*!
+ * \ingroup touch_generic
+ * \brief Generic implementation of ITouchInputHandler to handle low level (raw)
+ *        touch events and translate them into touch actions which are passed
+ *        on to the registered ITouchActionHandler implementation.
+ *
+ * The generic implementation supports single a double touch and hold
+ * actions and basic gesture recognition for panning, swiping, pinching/zooming
+ * and rotating.
+ *
+ * \sa ITouchInputHandler
+ */
+class CGenericTouchInputHandler : public ITouchInputHandler, private ITimerCallback
+{
+public:
+  /*!
+   \brief Get an instance of the touch input manager
+   */
+  static CGenericTouchInputHandler& GetInstance();
+  static constexpr int MAX_POINTERS = 2;
+
+  // implementation of ITouchInputHandler
+  bool HandleTouchInput(TouchInput event,
+                        float x,
+                        float y,
+                        int64_t time,
+                        int32_t pointer = 0,
+                        float size = 0.0f) override;
+  bool UpdateTouchPointer(
+      int32_t pointer, float x, float y, int64_t time, float size = 0.0f) override;
+
+private:
+  // private construction, and no assignments; use the provided singleton methods
+  CGenericTouchInputHandler();
+  ~CGenericTouchInputHandler() override;
+  CGenericTouchInputHandler(const CGenericTouchInputHandler&) = delete;
+  CGenericTouchInputHandler const& operator=(CGenericTouchInputHandler const&) = delete;
+
+  typedef enum
+  {
+    TouchGestureUnknown = 0,
+    // only primary pointer active but stationary so far
+    TouchGestureSingleTouch,
+    // primary pointer active but stationary for a certain time
+    TouchGestureSingleTouchHold,
+    // primary pointer moving
+    TouchGesturePan,
+    // at least two pointers active but stationary so far
+    TouchGestureMultiTouchStart,
+    // at least two pointers active but stationary for a certain time
+    TouchGestureMultiTouchHold,
+    // at least two pointers active and moving
+    TouchGestureMultiTouch,
+    // all but primary pointer have been lifted
+    TouchGestureMultiTouchDone
+  } TouchGestureState;
+
+  // implementation of ITimerCallback
+  void OnTimeout() override;
+
+  void saveLastTouch();
+  void setGestureState(TouchGestureState gestureState)
+  {
+    m_gestureStateOld = m_gestureState;
+    m_gestureState = gestureState;
+  }
+  void triggerDetectors(TouchInput event, int32_t pointer);
+  float AdjustPointerSize(float size);
+
+  CCriticalSection m_critical;
+  std::unique_ptr<CTimer> m_holdTimer;
+  std::array<Pointer, MAX_POINTERS> m_pointers;
+  std::set<std::unique_ptr<IGenericTouchGestureDetector>> m_detectors;
+
+  TouchGestureState m_gestureState = TouchGestureUnknown;
+  TouchGestureState m_gestureStateOld = TouchGestureUnknown;
+};
diff --git a/xbmc/input/touch/generic/GenericTouchPinchDetector.cpp b/xbmc/input/touch/generic/GenericTouchPinchDetector.cpp
new file mode 100644
index 0000000..3cff00d
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchPinchDetector.cpp
@@ -0,0 +1,87 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GenericTouchPinchDetector.h"
+
+bool CGenericTouchPinchDetector::OnTouchDown(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  m_pointers[index] = pointer;
+  return true;
+}
+
+bool CGenericTouchPinchDetector::OnTouchUp(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  // after lifting the primary pointer, the secondary pointer will
+  // become the primary pointer in the next event
+  if (index == 0)
+  {
+    m_pointers[0] = m_pointers[1];
+    index = 1;
+  }
+
+  m_pointers[index].reset();
+
+  if (!m_pointers[0].valid() && !m_pointers[1].valid())
+    m_done = true;
+
+  return true;
+}
+
+bool CGenericTouchPinchDetector::OnTouchMove(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  // update the internal pointers
+  m_pointers[index] = pointer;
+
+  const Pointer& primaryPointer = m_pointers[0];
+  const Pointer& secondaryPointer = m_pointers[1];
+
+  if (!primaryPointer.valid() || !secondaryPointer.valid() ||
+      (!primaryPointer.moving && !secondaryPointer.moving))
+    return false;
+
+  // calculate zoom/pinch
+  CVector primary = primaryPointer.down;
+  CVector secondary = secondaryPointer.down;
+  CVector diagonal = primary - secondary;
+
+  float baseDiffLength = diagonal.length();
+  if (baseDiffLength != 0.0f)
+  {
+    CVector primaryNow = primaryPointer.current;
+    CVector secondaryNow = secondaryPointer.current;
+    CVector diagonalNow = primaryNow - secondaryNow;
+    float curDiffLength = diagonalNow.length();
+
+    float centerX = (primary.x + secondary.x) / 2;
+    float centerY = (primary.y + secondary.y) / 2;
+
+    float zoom = curDiffLength / baseDiffLength;
+
+    OnZoomPinch(centerX, centerY, zoom);
+  }
+
+  return true;
+}
diff --git a/xbmc/input/touch/generic/GenericTouchPinchDetector.h b/xbmc/input/touch/generic/GenericTouchPinchDetector.h
new file mode 100644
index 0000000..191e950
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchPinchDetector.h
@@ -0,0 +1,32 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/generic/IGenericTouchGestureDetector.h"
+
+/*!
+ * \ingroup touch_generic
+ * \brief Implementation of IGenericTouchGestureDetector to detect pinch/zoom
+ *        gestures with at least two active touch pointers.
+ *
+ * \sa IGenericTouchGestureDetector
+ */
+class CGenericTouchPinchDetector : public IGenericTouchGestureDetector
+{
+public:
+  CGenericTouchPinchDetector(ITouchActionHandler* handler, float dpi)
+    : IGenericTouchGestureDetector(handler, dpi)
+  {
+  }
+  ~CGenericTouchPinchDetector() override = default;
+
+  bool OnTouchDown(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchUp(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchMove(unsigned int index, const Pointer& pointer) override;
+};
diff --git a/xbmc/input/touch/generic/GenericTouchRotateDetector.cpp b/xbmc/input/touch/generic/GenericTouchRotateDetector.cpp
new file mode 100644
index 0000000..79db638
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchRotateDetector.cpp
@@ -0,0 +1,117 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "GenericTouchRotateDetector.h"
+
+#include <math.h>
+
+#ifndef M_PI
+#define M_PI 3.1415926535897932384626433832795028842
+#endif
+
+CGenericTouchRotateDetector::CGenericTouchRotateDetector(ITouchActionHandler* handler, float dpi)
+  : IGenericTouchGestureDetector(handler, dpi), m_angle(0.0f)
+{
+}
+
+bool CGenericTouchRotateDetector::OnTouchDown(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  m_pointers[index] = pointer;
+  m_angle = 0.0f;
+  return true;
+}
+
+bool CGenericTouchRotateDetector::OnTouchUp(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  // after lifting the primary pointer, the secondary pointer will
+  // become the primary pointer in the next event
+  if (index == 0)
+  {
+    m_pointers[0] = m_pointers[1];
+    index = 1;
+  }
+
+  m_pointers[index].reset();
+
+  if (!m_pointers[0].valid() && !m_pointers[1].valid())
+    m_done = true;
+
+  return true;
+}
+
+bool CGenericTouchRotateDetector::OnTouchMove(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  // update the internal pointers
+  m_pointers[index] = pointer;
+
+  Pointer& primaryPointer = m_pointers[0];
+  Pointer& secondaryPointer = m_pointers[1];
+
+  if (!primaryPointer.valid() || !secondaryPointer.valid() ||
+      (!primaryPointer.moving && !secondaryPointer.moving))
+    return false;
+
+  CVector last = primaryPointer.last - secondaryPointer.last;
+  CVector current = primaryPointer.current - secondaryPointer.current;
+
+  float length = last.length() * current.length();
+  if (length != 0.0f)
+  {
+    float centerX = (primaryPointer.current.x + secondaryPointer.current.x) / 2;
+    float centerY = (primaryPointer.current.y + secondaryPointer.current.y) / 2;
+    float scalar = last.scalar(current);
+    float angle = acos(scalar / length) * 180.0f / static_cast<float>(M_PI);
+
+    // make sure the result of acos is a valid number
+    if (angle == angle)
+    {
+      // calculate the direction of the rotation using the
+      // z-component of the cross-product of last and current
+      float direction = last.x * current.y - current.x * last.y;
+      if (direction < 0.0f)
+        m_angle -= angle;
+      else
+        m_angle += angle;
+
+      OnRotate(centerX, centerY, m_angle);
+    }
+  }
+
+  return true;
+}
+
+bool CGenericTouchRotateDetector::OnTouchUpdate(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  // update the internal pointers
+  m_pointers[index] = pointer;
+  return true;
+}
diff --git a/xbmc/input/touch/generic/GenericTouchRotateDetector.h b/xbmc/input/touch/generic/GenericTouchRotateDetector.h
new file mode 100644
index 0000000..695879a
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchRotateDetector.h
@@ -0,0 +1,36 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/generic/IGenericTouchGestureDetector.h"
+
+/*!
+ * \ingroup touch_generic
+ * \brief Implementation of IGenericTouchGestureDetector to detect rotation
+ *        gestures with at least two active touch pointers.
+ *
+ * \sa IGenericTouchGestureDetector
+ */
+class CGenericTouchRotateDetector : public IGenericTouchGestureDetector
+{
+public:
+  CGenericTouchRotateDetector(ITouchActionHandler* handler, float dpi);
+  ~CGenericTouchRotateDetector() override = default;
+
+  bool OnTouchDown(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchUp(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchMove(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchUpdate(unsigned int index, const Pointer& pointer) override;
+
+private:
+  /*!
+   * \brief Angle of the detected rotation
+   */
+  float m_angle;
+};
diff --git a/xbmc/input/touch/generic/GenericTouchSwipeDetector.cpp b/xbmc/input/touch/generic/GenericTouchSwipeDetector.cpp
new file mode 100644
index 0000000..7d772b5
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchSwipeDetector.cpp
@@ -0,0 +1,176 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#ifndef _USE_MATH_DEFINES
+#define _USE_MATH_DEFINES
+#endif
+#include "GenericTouchSwipeDetector.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+// maximum time between touch down and up (in nanoseconds)
+#define SWIPE_MAX_TIME 500000000
+// maximum swipe distance between touch down and up (in multiples of screen DPI)
+#define SWIPE_MIN_DISTANCE 0.5f
+// original maximum variance of the touch movement
+#define SWIPE_MAX_VARIANCE 0.2f
+// tangents of the maximum angle (20 degrees) the touch movement may vary in a
+// direction perpendicular to the swipe direction (in radians)
+// => tan(20 deg) = tan(20 * M_PI / 180)
+#define SWIPE_MAX_VARIANCE_ANGLE 0.36397023f
+
+CGenericTouchSwipeDetector::CGenericTouchSwipeDetector(ITouchActionHandler* handler, float dpi)
+  : IGenericTouchGestureDetector(handler, dpi),
+    m_directions(TouchMoveDirectionLeft | TouchMoveDirectionRight | TouchMoveDirectionUp |
+                 TouchMoveDirectionDown),
+    m_swipeDetected(false),
+    m_size(0)
+{
+}
+
+bool CGenericTouchSwipeDetector::OnTouchDown(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  m_size += 1;
+  if (m_size > 1)
+    return true;
+
+  // reset all values
+  m_done = false;
+  m_swipeDetected = false;
+  m_directions = TouchMoveDirectionLeft | TouchMoveDirectionRight | TouchMoveDirectionUp |
+                 TouchMoveDirectionDown;
+
+  return true;
+}
+
+bool CGenericTouchSwipeDetector::OnTouchUp(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  m_size -= 1;
+  if (m_done)
+    return false;
+
+  m_done = true;
+
+  // check if a swipe has been detected and if it has a valid direction
+  if (!m_swipeDetected || m_directions == TouchMoveDirectionNone)
+    return false;
+
+  // check if the swipe has been performed in the proper time span
+  if ((pointer.current.time - pointer.down.time) > SWIPE_MAX_TIME)
+    return false;
+
+  // calculate the velocity of the swipe
+  float velocityX = 0.0f; // number of pixels per second
+  float velocityY = 0.0f; // number of pixels per second
+  pointer.velocity(velocityX, velocityY, false);
+
+  // call the OnSwipe() callback
+  OnSwipe((TouchMoveDirection)m_directions, pointer.down.x, pointer.down.y, pointer.current.x,
+          pointer.current.y, velocityX, velocityY, m_size + 1);
+  return true;
+}
+
+bool CGenericTouchSwipeDetector::OnTouchMove(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  // only handle swipes of moved pointers
+  if (index >= m_size || m_done || !pointer.moving)
+    return false;
+
+  float deltaXmovement = pointer.current.x - pointer.last.x;
+  float deltaYmovement = pointer.current.y - pointer.last.y;
+
+  if (deltaXmovement > 0.0f)
+    m_directions &= ~TouchMoveDirectionLeft;
+  else if (deltaXmovement < 0.0f)
+    m_directions &= ~TouchMoveDirectionRight;
+
+  if (deltaYmovement > 0.0f)
+    m_directions &= ~TouchMoveDirectionUp;
+  else if (deltaYmovement < 0.0f)
+    m_directions &= ~TouchMoveDirectionDown;
+
+  if (m_directions == TouchMoveDirectionNone)
+  {
+    m_done = true;
+    return false;
+  }
+
+  float deltaXabs = fabs(pointer.current.x - pointer.down.x);
+  float deltaYabs = fabs(pointer.current.y - pointer.down.y);
+  float varXabs = deltaYabs * SWIPE_MAX_VARIANCE_ANGLE + (m_dpi * SWIPE_MAX_VARIANCE) / 2;
+  float varYabs = deltaXabs * SWIPE_MAX_VARIANCE_ANGLE + (m_dpi * SWIPE_MAX_VARIANCE) / 2;
+
+  if (m_directions & TouchMoveDirectionLeft)
+  {
+    // check if the movement went too much in Y direction
+    if (deltaYabs > varYabs)
+      m_directions &= ~TouchMoveDirectionLeft;
+    // check if the movement went far enough in the X direction
+    else if (deltaXabs > m_dpi * SWIPE_MIN_DISTANCE)
+      m_swipeDetected = true;
+  }
+
+  if (m_directions & TouchMoveDirectionRight)
+  {
+    // check if the movement went too much in Y direction
+    if (deltaYabs > varYabs)
+      m_directions &= ~TouchMoveDirectionRight;
+    // check if the movement went far enough in the X direction
+    else if (deltaXabs > m_dpi * SWIPE_MIN_DISTANCE)
+      m_swipeDetected = true;
+  }
+
+  if (m_directions & TouchMoveDirectionUp)
+  {
+    // check if the movement went too much in X direction
+    if (deltaXabs > varXabs)
+      m_directions &= ~TouchMoveDirectionUp;
+    // check if the movement went far enough in the Y direction
+    else if (deltaYabs > m_dpi * SWIPE_MIN_DISTANCE)
+      m_swipeDetected = true;
+  }
+
+  if (m_directions & TouchMoveDirectionDown)
+  {
+    // check if the movement went too much in X direction
+    if (deltaXabs > varXabs)
+      m_directions &= ~TouchMoveDirectionDown;
+    // check if the movement went far enough in the Y direction
+    else if (deltaYabs > m_dpi * SWIPE_MIN_DISTANCE)
+      m_swipeDetected = true;
+  }
+
+  if (m_directions == TouchMoveDirectionNone)
+  {
+    m_done = true;
+    return false;
+  }
+
+  return true;
+}
+
+bool CGenericTouchSwipeDetector::OnTouchUpdate(unsigned int index, const Pointer& pointer)
+{
+  if (index >= MAX_POINTERS)
+    return false;
+
+  if (m_done)
+    return true;
+
+  return OnTouchMove(index, pointer);
+}
diff --git a/xbmc/input/touch/generic/GenericTouchSwipeDetector.h b/xbmc/input/touch/generic/GenericTouchSwipeDetector.h
new file mode 100644
index 0000000..7fe88b1
--- /dev/null
+++ b/xbmc/input/touch/generic/GenericTouchSwipeDetector.h
@@ -0,0 +1,49 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/generic/IGenericTouchGestureDetector.h"
+
+/*!
+ * \ingroup touch_generic
+ * \brief Implementation of IGenericTouchGestureDetector to detect swipe
+ *        gestures in any direction.
+ *
+ * \sa IGenericTouchGestureDetector
+ */
+class CGenericTouchSwipeDetector : public IGenericTouchGestureDetector
+{
+public:
+  CGenericTouchSwipeDetector(ITouchActionHandler* handler, float dpi);
+  ~CGenericTouchSwipeDetector() override = default;
+
+  bool OnTouchDown(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchUp(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchMove(unsigned int index, const Pointer& pointer) override;
+  bool OnTouchUpdate(unsigned int index, const Pointer& pointer) override;
+
+private:
+  /*!
+   * \brief Swipe directions that are still possible to detect
+   *
+   * The directions are stored as a combination (bitwise OR) of
+   * TouchMoveDirection enum values
+   *
+   * \sa TouchMoveDirection
+   */
+  unsigned int m_directions;
+  /*!
+   * \brief Whether a swipe gesture has been detected or not
+   */
+  bool m_swipeDetected;
+  /*!
+   * \brief Number of active pointers
+   */
+  unsigned int m_size;
+};
diff --git a/xbmc/input/touch/generic/IGenericTouchGestureDetector.h b/xbmc/input/touch/generic/IGenericTouchGestureDetector.h
new file mode 100644
index 0000000..7e2cb88
--- /dev/null
+++ b/xbmc/input/touch/generic/IGenericTouchGestureDetector.h
@@ -0,0 +1,91 @@
+/*
+ *  Copyright (C) 2013-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include "input/touch/ITouchInputHandling.h"
+#include "input/touch/TouchTypes.h"
+
+#include <array>
+
+/*!
+ * \ingroup touch_generic
+ * \brief Interface defining methods to perform gesture recognition
+ */
+class IGenericTouchGestureDetector : public ITouchInputHandling
+{
+public:
+  IGenericTouchGestureDetector(ITouchActionHandler* handler, float dpi) : m_done(false), m_dpi(dpi)
+  {
+    RegisterHandler(handler);
+  }
+  ~IGenericTouchGestureDetector() override = default;
+  static constexpr int MAX_POINTERS = 2;
+
+  /*!
+   * \brief Check whether the gesture recognition is finished or not
+   *
+   * \return True if the gesture recognition is finished otherwise false
+   */
+  bool IsDone() { return m_done; }
+
+  /*!
+   * \brief A new touch pointer has been recognised.
+   *
+   * \param index     Index of the given touch pointer
+   * \param pointer   Touch pointer that has changed
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnTouchDown(unsigned int index, const Pointer& pointer) = 0;
+  /*!
+   * \brief An active touch pointer has vanished.
+   *
+   * If the first touch pointer is lifted and there are more active touch
+   * pointers, the remaining pointers change their index.
+   *
+   * \param index     Index of the given touch pointer
+   * \param pointer   Touch pointer that has changed
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnTouchUp(unsigned int index, const Pointer& pointer) { return false; }
+  /*!
+   * \brief An active touch pointer has moved.
+   *
+   * \param index     Index of the given touch pointer
+   * \param pointer   Touch pointer that has changed
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnTouchMove(unsigned int index, const Pointer& pointer) { return false; }
+  /*!
+   * \brief An active touch pointer's values have been updated but no event has
+   *        occurred.
+   *
+   * \param index     Index of the given touch pointer
+   * \param pointer   Touch pointer that has changed
+   *
+   * \return True if the event was handled otherwise false
+   */
+  virtual bool OnTouchUpdate(unsigned int index, const Pointer& pointer) { return false; }
+
+protected:
+  /*!
+   * \brief Whether the gesture recognition is finished or not
+   */
+  bool m_done;
+  /*!
+   * \brief DPI value of the touch screen
+   */
+  float m_dpi;
+  /*!
+   * \brief Local list of all known touch pointers
+   */
+  std::array<Pointer, MAX_POINTERS> m_pointers;
+};