streamdeck 0.9.4__tar.gz → 0.9.6__tar.gz

{streamdeck-0.9.4 → streamdeck-0.9.6}/CHANGELOG

@@ -1,3 +1,13 @@
+Version 0.9.6:
+	- Fixed StreamDeck+ returning 10 key states instead of the expected 8.
+	- Fixed StreamDeck+ dial push event not being detected correctly.
+	- Fixed old key states and dial states returned if requested from inside a key or dial callback function.
+	- Added support for FreeBSD platforms.
+	- Added support for the StreamDeck Neo.
+
+Version 0.9.5:
+	- Added support for the StreamDeck Plus.
+
 Version 0.9.4:
 	- Updated Windows HIDAPI backend to attempt to load from the local working directory.
 	- Added detection for MacOS Homebrew installations of the libhidapi back-end library.

streamdeck-0.9.6/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.1
+Name: streamdeck
+Version: 0.9.6
+Summary: Library to control Elgato StreamDeck devices.
+Home-page: https://github.com/abcminiuser/python-elgato-streamdeck
+Author: Dean Camera
+Author-email: dean@fourwalledcubicle.com
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Python Elgato Stream Deck Library
+
+![Example Deck](ExampleDeck.jpg)
+
+This is an open source Python 3 library to control an
+[Elgato Stream Deck](https://www.elgato.com/en/gaming/stream-deck) directly,
+without the official software. This can allow you to create your own custom
+front-ends, such as a custom control front-end for home automation software.
+
+_________________
+
+[PyPi Project Entry](https://pypi.org/project/streamdeck/) - [Online Documentation](https://python-elgato-streamdeck.readthedocs.io) - [Source Code](https://github.com/abcminiuser/python-elgato-streamdeck)
+
+
+## Project Status:
+
+Working - you can enumerate devices, set the brightness of the panel(s), set
+the images shown on each button, and read the current button states.
+
+Currently the following StreamDeck products are supported in multiple hardware
+variants:
+
+* StreamDeck Mini
+* StreamDeck Neo
+* StreamDeck Original
+* StreamDeck Pedal
+* StreamDeck Plus
+* StreamDeck XL
+
+## Package Installation:
+
+Install the library via pip:
+
+```
+pip install streamdeck
+```
+
+Alternatively, manually clone the project repository:
+
+```
+git clone https://github.com/abcminiuser/python-elgato-streamdeck.git
+```
+
+For detailed installation instructions, refer to the prebuilt
+[online documentation](https://python-elgato-streamdeck.readthedocs.io), or
+build the documentation yourself locally by running `make html` from the `docs`
+directory.
+
+
+## Credits:
+
+I've used the reverse engineering notes from
+[this GitHub](https://github.com/alvancamp/node-elgato-stream-deck/blob/master/NOTES.md)
+repository to implement this library. Thanks Alex Van Camp!
+
+Thank you to the following contributors, large and small, for helping with the
+development and maintenance of this library:
+
+- [admiral0](https://github.com/admiral0)
+- [Aetherdyne](https://github.com/Aetherdyne)
+- [benedikt-bartscher](https://github.com/benedikt-bartscher)
+- [brimston3](https://github.com/brimston3)
+- [BS-Tek](https://github.com/BS-Tek)
+- [Core447](https://github.com/Core447)
+- [dirkk0](https://github.com/dirkk0)
+- [dodgyrabbit](https://github.com/dodgyrabbit)
+- [dubstech](https://github.com/dubstech)
+- [Giraut](https://github.com/Giraut)
+- [impala454](https://github.com/impala454)
+- [itsusony](https://github.com/itsusony)
+- [jakobbuis](https://github.com/jakobbuis)
+- [jmudge14](https://github.com/jmudge14)
+- [Kalle-Wirsch](https://github.com/Kalle-Wirsch)
+- [karstlok](https://github.com/karstlok)
+- [Lewiscowles1986](https://github.com/Lewiscowles1986)
+- [m-weigand](https://github.com/m-weigand)
+- [matrixinius](https://github.com/matrixinius)
+- [phillco](https://github.com/phillco)
+- [pointshader](https://github.com/pointshader)
+- [shanna](https://github.com/shanna)
+- [spidererrol](https://github.com/Spidererrol)
+- [spyoungtech](https://github.com/spyoungtech)
+- [Subsentient](https://github.com/Subsentient)
+- [swedishmike](https://github.com/swedishmike)
+- [TheSchmidt](https://github.com/TheSchmidt)
+- [theslimshaney](https://github.com/theslimshaney)
+- [tjemg](https://github.com/tjemg)
+- [VladFlorinIlie](https://github.com/VladFlorinIlie)
+
+If you've contributed in some manner, but I've accidentally missed you in the
+list above, please let me know.
+
+
+## License:
+
+Released under the [MIT license](LICENSE).

{streamdeck-0.9.4 → streamdeck-0.9.6}/README.md

@@ -20,11 +20,12 @@ the images shown on each button, and read the current button states.
 Currently the following StreamDeck products are supported in multiple hardware
 variants:
 
-* StreamDeck Original
 * StreamDeck Mini
-* StreamDeck XL
+* StreamDeck Neo
+* StreamDeck Original
 * StreamDeck Pedal
-
+* StreamDeck Plus
+* StreamDeck XL
 
 ## Package Installation:
 
@@ -49,21 +50,28 @@ directory.
 ## Credits:
 
 I've used the reverse engineering notes from
-[this GitHub](https://github.com/Lange/node-elgato-stream-deck/blob/master/NOTES.md)
+[this GitHub](https://github.com/alvancamp/node-elgato-stream-deck/blob/master/NOTES.md)
 repository to implement this library. Thanks Alex Van Camp!
 
 Thank you to the following contributors, large and small, for helping with the
 development and maintenance of this library:
 
+- [admiral0](https://github.com/admiral0)
 - [Aetherdyne](https://github.com/Aetherdyne)
+- [benedikt-bartscher](https://github.com/benedikt-bartscher)
+- [brimston3](https://github.com/brimston3)
 - [BS-Tek](https://github.com/BS-Tek)
+- [Core447](https://github.com/Core447)
 - [dirkk0](https://github.com/dirkk0)
 - [dodgyrabbit](https://github.com/dodgyrabbit)
 - [dubstech](https://github.com/dubstech)
+- [Giraut](https://github.com/Giraut)
 - [impala454](https://github.com/impala454)
+- [itsusony](https://github.com/itsusony)
 - [jakobbuis](https://github.com/jakobbuis)
 - [jmudge14](https://github.com/jmudge14)
 - [Kalle-Wirsch](https://github.com/Kalle-Wirsch)
+- [karstlok](https://github.com/karstlok)
 - [Lewiscowles1986](https://github.com/Lewiscowles1986)
 - [m-weigand](https://github.com/m-weigand)
 - [matrixinius](https://github.com/matrixinius)
@@ -74,7 +82,10 @@ development and maintenance of this library:
 - [spyoungtech](https://github.com/spyoungtech)
 - [Subsentient](https://github.com/Subsentient)
 - [swedishmike](https://github.com/swedishmike)
+- [TheSchmidt](https://github.com/TheSchmidt)
 - [theslimshaney](https://github.com/theslimshaney)
+- [tjemg](https://github.com/tjemg)
+- [VladFlorinIlie](https://github.com/VladFlorinIlie)
 
 If you've contributed in some manner, but I've accidentally missed you in the
 list above, please let me know.

streamdeck-0.9.6/VERSION

@@ -0,0 +1 @@
+0.9.6

{streamdeck-0.9.4 → streamdeck-0.9.6}/src/StreamDeck/DeviceManager.py

@@ -6,10 +6,12 @@
 #
 
 from .Devices.StreamDeckMini import StreamDeckMini
+from .Devices.StreamDeckNeo import StreamDeckNeo
 from .Devices.StreamDeckOriginal import StreamDeckOriginal
 from .Devices.StreamDeckOriginalV2 import StreamDeckOriginalV2
 from .Devices.StreamDeckXL import StreamDeckXL
 from .Devices.StreamDeckPedal import StreamDeckPedal
+from .Devices.StreamDeckPlus import StreamDeckPlus
 from .Transport.Dummy import Dummy
 from .Transport.LibUSBHIDAPI import LibUSBHIDAPI
 from .ProductIDs import USBVendorIDs, USBProductIDs
@@ -35,9 +37,11 @@ class DeviceManager:
     USB_PID_STREAMDECK_ORIGINAL = 0x0060
     USB_PID_STREAMDECK_ORIGINAL_V2 = 0x006d
     USB_PID_STREAMDECK_MINI = 0x0063
+    USB_PID_STREAMDECK_NEO = 0x009a
     USB_PID_STREAMDECK_XL = 0x006c
     USB_PID_STREAMDECK_MK2 = 0x0080
     USB_PID_STREAMDECK_PEDAL = 0x0086
+    USB_PID_STREAMDECK_PLUS = 0x0084
 
     @staticmethod
     def _get_transport(transport):
@@ -103,11 +107,13 @@ class DeviceManager:
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_ORIGINAL, StreamDeckOriginal),
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_ORIGINAL_V2, StreamDeckOriginalV2),
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_MINI, StreamDeckMini),
+            (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_NEO, StreamDeckNeo),
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_XL, StreamDeckXL),
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_MK2, StreamDeckOriginalV2),
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_PEDAL, StreamDeckPedal),
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_MINI_MK2, StreamDeckMini),
             (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_XL_V2, StreamDeckXL),
+            (USBVendorIDs.USB_VID_ELGATO, USBProductIDs.USB_PID_STREAMDECK_PLUS, StreamDeckPlus),
         ]
 
         streamdecks = list()

{streamdeck-0.9.4 → streamdeck-0.9.6}/src/StreamDeck/Devices/StreamDeck.py

@@ -8,10 +8,41 @@
 import threading
 import time
 from abc import ABC, abstractmethod
+from enum import Enum
 
 from ..Transport.Transport import TransportError
 
 
+class TouchscreenEventType(Enum):
+    """
+    Type of event that has occurred for a Touchscreen.
+    """
+
+    SHORT = 1
+    LONG = 2
+    DRAG = 3
+
+
+class DialEventType(Enum):
+    """
+    Type of event that has occurred for a Dial.
+    """
+    TURN = 1
+    PUSH = 2
+
+
+class ControlType(Enum):
+    """
+    Type of control. This is used when returning internal events from a
+    StreamDeck subclass.
+
+    :meta private:
+    """
+    KEY = 1
+    DIAL = 2
+    TOUCHSCREEN = 3
+
+
 class StreamDeck(ABC):
     """
     Represents a physically attached StreamDeck device.
@@ -21,22 +52,43 @@ class StreamDeck(ABC):
     KEY_COLS = 0
     KEY_ROWS = 0
 
+    TOUCH_KEY_COUNT = 0
+
     KEY_PIXEL_WIDTH = 0
     KEY_PIXEL_HEIGHT = 0
     KEY_IMAGE_FORMAT = ""
     KEY_FLIP = (False, False)
     KEY_ROTATION = 0
 
+    TOUCHSCREEN_PIXEL_WIDTH = 0
+    TOUCHSCREEN_PIXEL_HEIGHT = 0
+    TOUCHSCREEN_IMAGE_FORMAT = ""
+    TOUCHSCREEN_FLIP = (False, False)
+    TOUCHSCREEN_ROTATION = 0
+
+    SCREEN_PIXEL_WIDTH = 0
+    SCREEN_PIXEL_HEIGHT = 0
+    SCREEN_IMAGE_FORMAT = ""
+    SCREEN_FLIP = (False, False)
+    SCREEN_ROTATION = 0
+
+    DIAL_COUNT = 0
+
     DECK_TYPE = ""
     DECK_VISUAL = False
+    DECK_TOUCH = False
 
     def __init__(self, device):
         self.device = device
-        self.last_key_states = [False] * self.KEY_COUNT
+        self.last_key_states = [False] * (self.KEY_COUNT + self.TOUCH_KEY_COUNT)
+        self.last_dial_states = [False] * self.DIAL_COUNT
         self.read_thread = None
         self.run_read_thread = False
         self.read_poll_hz = 20
+
         self.key_callback = None
+        self.dial_callback = None
+        self.touchscreen_callback = None
 
         self.update_lock = threading.RLock()
 
@@ -72,12 +124,11 @@ class StreamDeck(ABC):
         self.update_lock.release()
 
     @abstractmethod
-    def _read_key_states(self):
+    def _read_control_states(self):
         """
         Reads the raw key states from an attached StreamDeck.
 
-        :rtype: list(bool)
-        :return: List containing the raw key states.
+        :return: dictionary containing states for all controls
         """
         pass
 
@@ -101,24 +152,51 @@ class StreamDeck(ABC):
 
     def _read(self):
         """
-        Read handler for the underlying transport, listening for button state
+        Read handler for the underlying transport, listening for control state
         changes on the underlying device, caching the new states and firing off
         any registered callbacks.
         """
         while self.run_read_thread:
             try:
-                new_key_states = self._read_key_states()
-                if new_key_states is None:
+                control_states = self._read_control_states()
+                if control_states is None:
                     time.sleep(1.0 / self.read_poll_hz)
                     continue
 
-                if self.key_callback is not None:
-                    for k, (old, new) in enumerate(zip(self.last_key_states, new_key_states)):
-                        if old != new:
+                if ControlType.KEY in control_states:
+                    for k, (old, new) in enumerate(zip(self.last_key_states, control_states[ControlType.KEY])):
+                        if old == new:
+                            continue
+
+                        self.last_key_states[k] = new
+
+                        if self.key_callback is not None:
                             self.key_callback(self, k, new)
 
-                self.last_key_states = new_key_states
-            except (TransportError):
+                elif ControlType.DIAL in control_states:
+                    if DialEventType.PUSH in control_states[ControlType.DIAL]:
+                        for k, (old, new) in enumerate(zip(self.last_dial_states, control_states[ControlType.DIAL][DialEventType.PUSH])):
+                            if old == new:
+                                continue
+
+                            self.last_dial_states[k] = new
+
+                            if self.dial_callback is not None:
+                                self.dial_callback(self, k, DialEventType.PUSH, new)
+
+                    if DialEventType.TURN in control_states[ControlType.DIAL]:
+                        for k, amount in enumerate(control_states[ControlType.DIAL][DialEventType.TURN]):
+                            if amount == 0:
+                                continue
+
+                            if self.dial_callback is not None:
+                                self.dial_callback(self, k, DialEventType.TURN, amount)
+
+                elif ControlType.TOUCHSCREEN in control_states:
+                    if self.touchscreen_callback is not None:
+                        self.touchscreen_callback(self, *control_states[ControlType.TOUCHSCREEN])
+
+            except TransportError:
                 self.run_read_thread = False
                 self.close()
 
@@ -223,12 +301,30 @@ class StreamDeck(ABC):
         """
         return self.KEY_COUNT
 
+    def touch_key_count(self):
+        """
+        Retrieves number of touch buttons on the attached StreamDeck device.
+
+        :rtype: int
+        :return: Number of touch buttons.
+        """
+        return self.TOUCH_KEY_COUNT
+
+    def dial_count(self):
+        """
+        Retrieves number of physical dials on the attached StreamDeck device.
+
+        :rtype: int
+        :return: Number of physical dials
+        """
+        return self.DIAL_COUNT
+
     def deck_type(self):
         """
         Retrieves the model of Stream Deck.
 
         :rtype: str
-        :return: String containing the model name of the StreamDeck device..
+        :return: String containing the model name of the StreamDeck device.
         """
         return self.DECK_TYPE
 
@@ -241,6 +337,15 @@ class StreamDeck(ABC):
         """
         return self.DECK_VISUAL
 
+    def is_touch(self):
+        """
+        Returns whether the Stream Deck can receive touch events
+
+        :rtype: bool
+        :return: `True` if the deck can receive touch events, `False` otherwise
+        """
+        return self.DECK_TOUCH
+
     def key_layout(self):
         """
         Retrieves the physical button layout on the attached StreamDeck device.
@@ -269,6 +374,46 @@ class StreamDeck(ABC):
             'rotation': self.KEY_ROTATION,
         }
 
+    def touchscreen_image_format(self):
+        """
+        Retrieves the image format accepted by the touchscreen of the Stream
+        Deck. Images should be given in this format when drawing on
+        touchscreen.
+
+        .. seealso:: See :func:`~StreamDeck.set_touchscreen_image` method to
+                     draw an image on the StreamDeck touchscreen.
+
+        :rtype: dict()
+        :return: Dictionary describing the various image parameters
+                 (size, image format).
+        """
+        return {
+            'size': (self.TOUCHSCREEN_PIXEL_WIDTH, self.TOUCHSCREEN_PIXEL_HEIGHT),
+            'format': self.TOUCHSCREEN_IMAGE_FORMAT,
+            'flip': self.TOUCHSCREEN_FLIP,
+            'rotation': self.TOUCHSCREEN_ROTATION,
+        }
+
+    def screen_image_format(self):
+        """
+        Retrieves the image format accepted by the screen of the Stream
+        Deck. Images should be given in this format when drawing on
+        screen.
+
+        .. seealso:: See :func:`~StreamDeck.set_screen_image` method to
+                     draw an image on the StreamDeck screen.
+
+        :rtype: dict()
+        :return: Dictionary describing the various image parameters
+                 (size, image format).
+        """
+        return {
+            'size': (self.SCREEN_PIXEL_WIDTH, self.SCREEN_PIXEL_HEIGHT),
+            'format': self.SCREEN_IMAGE_FORMAT,
+            'flip': self.SCREEN_FLIP,
+            'rotation': self.SCREEN_ROTATION,
+        }
+
     def set_poll_frequency(self, hz):
         """
         Sets the frequency of the button polling reader thread, determining how
@@ -325,6 +470,94 @@ class StreamDeck(ABC):
 
         self.set_key_callback(callback)
 
+    def set_dial_callback(self, callback):
+        """
+        Sets the callback function called each time there is an interaction
+        with a dial on the StreamDeck.
+
+        .. note:: This callback will be fired from an internal reader thread.
+                  Ensure that the given callback function is thread-safe.
+
+        .. note:: Only one callback can be registered at one time.
+
+        .. seealso:: See :func:`~StreamDeck.set_dial_callback_async` method
+                     for a version compatible with Python 3 `asyncio`
+                     asynchronous functions.
+
+        :param function callback: Callback function to fire each time a button
+                                state changes.
+        """
+        self.dial_callback = callback
+
+    def set_dial_callback_async(self, async_callback, loop=None):
+        """
+        Sets the asynchronous callback function called each time there is an
+        interaction with a dial on the StreamDeck. The given callback should
+        be compatible with Python 3's `asyncio` routines.
+
+        .. note:: The asynchronous callback will be fired in a thread-safe
+                  manner.
+
+        .. note:: This will override the callback (if any) set by
+                  :func:`~StreamDeck.set_dial_callback`.
+
+        :param function async_callback: Asynchronous callback function to fire
+                                        each time a button state changes.
+        :param asyncio.loop loop: Asyncio loop to dispatch the callback into
+        """
+        import asyncio
+
+        loop = loop or asyncio.get_event_loop()
+
+        def callback(*args):
+            asyncio.run_coroutine_threadsafe(async_callback(*args), loop)
+
+        self.set_dial_callback(callback)
+
+    def set_touchscreen_callback(self, callback):
+        """
+        Sets the callback function called each time there is an interaction
+        with a touchscreen on the StreamDeck.
+
+        .. note:: This callback will be fired from an internal reader thread.
+                  Ensure that the given callback function is thread-safe.
+
+        .. note:: Only one callback can be registered at one time.
+
+        .. seealso:: See :func:`~StreamDeck.set_touchscreen_callback_async`
+                     method for a version compatible with Python 3 `asyncio`
+                     asynchronous functions.
+
+        :param function callback: Callback function to fire each time a button
+                                state changes.
+        """
+        self.touchscreen_callback = callback
+
+    def set_touchscreen_callback_async(self, async_callback, loop=None):
+        """
+        Sets the asynchronous callback function called each time there is an
+        interaction with the touchscreen on the StreamDeck. The given callback
+        should be compatible with Python 3's `asyncio` routines.
+
+        .. note:: The asynchronous callback will be fired in a thread-safe
+                  manner.
+
+        .. note:: This will override the callback (if any) set by
+                  :func:`~StreamDeck.set_touchscreen_callback`.
+
+        :param function async_callback: Asynchronous callback function to fire
+                                        each time a button state changes.
+        :param asyncio.loop loop: Asyncio loop to dispatch the callback into
+        """
+        import asyncio
+
+        loop = loop or asyncio.get_event_loop()
+
+        def callback(*args):
+            asyncio.run_coroutine_threadsafe(async_callback(*args), loop)
+
+        self.set_touchscreen_callback(callback)
+
     def key_states(self):
         """
         Retrieves the current states of the buttons on the StreamDeck.
@@ -336,6 +569,18 @@ class StreamDeck(ABC):
         """
         return self.last_key_states
 
+    def dial_states(self):
+        """
+        Retrieves the current states of the dials (pressed or not) on the
+        Stream Deck
+
+        :rtype: list(bool)
+        :return: List describing the current states of each of the dials on
+                 the device (`True` if the dial is being pressed, `False`
+                 otherwise).
+        """
+        return self.last_dial_states
+
     @abstractmethod
     def reset(self):
         """
@@ -382,7 +627,7 @@ class StreamDeck(ABC):
         image being set should be in the correct format for the device, as an
         enumerable collection of bytes.
 
-        .. seealso:: See :func:`~StreamDeck.get_key_image_format` method for
+        .. seealso:: See :func:`~StreamDeck.key_image_format` method for
                      information on the image format accepted by the device.
 
         :param int key: Index of the button whose image is to be updated.
@@ -391,3 +636,50 @@ class StreamDeck(ABC):
                                  color.
         """
         pass
+
+    @abstractmethod
+    def set_touchscreen_image(self, image, x_pos=0, y_pos=0, width=0, height=0):
+        """
+        Draws an image on the touchscreen in a certain position. The image
+        should be in the correct format for the devices, as an enumerable
+        collection of bytes.
+
+        .. seealso:: See :func:`~StreamDeck.touchscreen_image_format` method for
+                     information on the image format accepted by the device.
+
+        :param enumerable image: Raw data of the image to set on the button.
+                                 If `None`, the touchscreen will be cleared.
+        :param int x_pos: Position on x axis of the image to draw
+        :param int y_pos: Position on y axis of the image to draw
+        :param int width: width of the image
+        :param int height: height of the image
+
+        """
+        pass
+
+    @abstractmethod
+    def set_key_color(self, key, r, g, b):
+        """
+        Sets the color of the touch buttons. These buttons are indexed
+        in order after the standard keys.
+
+        :param int key: Index of the button
+        :param int r: Red value
+        :param int g: Green value
+        :param int b: Blue value
+
+        """
+        pass
+
+    @abstractmethod
+    def set_screen_image(self, image):
+        """
+        Draws an image on the touchless screen of the StreamDeck.
+
+        .. seealso:: See :func:`~StreamDeck.screen_image_format` method for
+                     information on the image format accepted by the device.
+
+        :param enumerable image: Raw data of the image to set on the button.
+                                 If `None`, the screen will be cleared.
+        """
+        pass

{streamdeck-0.9.4 → streamdeck-0.9.6}/src/StreamDeck/Devices/StreamDeckMini.py

@@ -5,7 +5,7 @@
 #         www.fourwalledcubicle.com
 #
 
-from .StreamDeck import StreamDeck
+from .StreamDeck import StreamDeck, ControlType
 from ..ProductIDs import USBProductIDs
 
 
@@ -42,13 +42,15 @@ class StreamDeckMini(StreamDeck):
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     ] + [0] * (KEY_PIXEL_WIDTH * KEY_PIXEL_HEIGHT * 3)
 
-    def _read_key_states(self):
+    def _read_control_states(self):
         states = self.device.read(1 + self.KEY_COUNT)
         if states is None:
             return None
 
         states = states[1:]
-        return [bool(s) for s in states]
+        return {
+            ControlType.KEY: [bool(s) for s in states],
+        }
 
     def _reset_key_stream(self):
         payload = bytearray(self.IMAGE_REPORT_LENGTH)
@@ -116,3 +118,12 @@ class StreamDeckMini(StreamDeck):
 
             bytes_remaining = bytes_remaining - this_length
             page_number = page_number + 1
+
+    def set_touchscreen_image(self, image, x_pos=0, y_pos=0, width=0, height=0):
+        pass
+
+    def set_key_color(self, key, r, g, b):
+        pass
+
+    def set_screen_image(self, image):
+        pass