libpebble2 0.0.29__py3-none-any.whl

libpebble2/communication/transports/qemu/protocol.py

@@ -0,0 +1,165 @@
+from __future__ import absolute_import
+__author__ = 'katharine'
+
+from enum import IntEnum
+
+from libpebble2.protocol.base import PebblePacket
+from libpebble2.protocol.base.types import *
+
+HEADER_SIGNATURE = 0xFEED
+FOOTER_SIGNATURE = 0xBEEF
+
+
+class QemuSPP(PebblePacket):
+    payload = BinaryArray()
+
+
+class QemuTap(PebblePacket):
+    class Axis(IntEnum):
+        X = 0
+        Y = 1
+        Z = 2
+
+    axis = Uint8()
+    direction = Int8()
+
+
+class QemuBluetoothConnection(PebblePacket):
+    connected = Boolean()
+
+
+class QemuCompass(PebblePacket):
+    class Calibration(IntEnum):
+        Uncalibrated = 0
+        Refining = 1
+        Complete = 2
+
+    heading = Uint32()
+    calibrated = Uint8()
+
+
+class QemuBattery(PebblePacket):
+    percent = Uint8()
+    charging = Boolean()
+
+
+class QemuAccelSample(PebblePacket):
+    x = Int16()
+    y = Int16()
+    z = Int16()
+
+
+class QemuAccel(PebblePacket):
+    count = Uint8()
+    samples = FixedList(QemuAccelSample, count=count)
+
+
+class QemuAccelResponse(PebblePacket):
+    remaining_space = Uint16()
+
+
+class QemuVibration(PebblePacket):
+    state = Optional(Boolean())
+
+
+class QemuButton(PebblePacket):
+    class Button(IntEnum):
+        Back = 1
+        Up = 2
+        Select = 4
+        Down = 8
+
+    state = Uint8()
+
+
+class QemuTimeFormat(PebblePacket):
+    is_24_hour = Boolean()
+
+
+class QemuTimelinePeek(PebblePacket):
+    enabled = Boolean()
+
+
+class QemuContentSize(PebblePacket):
+    class ContentSize(IntEnum):
+        Small = 0
+        Medium = 1
+        Large = 2
+        ExtraLarge = 3
+
+    size = Uint8()
+
+class QemuRebbleTestListRequest(PebblePacket):
+    pass
+
+
+class QemuRebbleTestListResponse(PebblePacket):
+    id = Uint16()
+    is_last_test = Uint8()
+    name_len = Uint8()
+    name = BinaryArray(length = name_len)
+
+
+class QemuRebbleTestRunRequest(PebblePacket):
+    id = Uint16()
+
+
+class QemuRebbleTestComplete(PebblePacket):
+    passed = Uint8()
+    artifact = Uint32()
+
+
+class QemuRebbleTestAlive(PebblePacket):
+    pass
+
+
+class QemuRebbleTest(PebblePacket):
+    opcode = Uint16()
+    payload = Union(opcode, {
+        0x0000: QemuRebbleTestListRequest,
+        0x0001: QemuRebbleTestRunRequest,
+        0x8000: QemuRebbleTestListResponse,
+        0x8001: QemuRebbleTestComplete,
+        0xFFFF: QemuRebbleTestAlive
+    })
+
+
+class QemuPacket(PebblePacket):
+    signature = Uint16(default=HEADER_SIGNATURE)
+    protocol = Uint16()
+    length = Uint16()
+    data = Union(protocol, {
+        1: QemuSPP,
+        2: QemuTap,
+        3: QemuBluetoothConnection,
+        4: QemuCompass,
+        5: QemuBattery,
+        6: QemuAccel,
+        8: QemuButton,
+        9: QemuTimeFormat,
+        10: QemuTimelinePeek,
+        11: QemuContentSize,
+        100: QemuRebbleTest,
+    }, length=length)
+    footer = Uint16(default=FOOTER_SIGNATURE)
+
+
+class QemuInboundPacket(PebblePacket):
+    signature = Uint16(default=HEADER_SIGNATURE)
+    protocol = Uint16()
+    length = Uint16()
+    data = Union(protocol, {
+        1: QemuSPP,
+        6: QemuAccelResponse,
+        7: QemuVibration,
+        100: QemuRebbleTest,
+    }, length=length)
+    footer = Uint16(default=FOOTER_SIGNATURE)
+
+
+class QemuRawPacket(PebblePacket):
+    signature = Uint16(default=HEADER_SIGNATURE)
+    protocol = Uint16()
+    length = Uint16()
+    data = BinaryArray(length=length)
+    footer = Uint16(default=FOOTER_SIGNATURE)

libpebble2/communication/transports/serial.py

@@ -0,0 +1,58 @@
+from __future__ import absolute_import
+__author__ = 'katharine'
+
+import errno
+import serial
+import struct
+
+from . import BaseTransport, MessageTargetWatch
+from libpebble2.exceptions import ConnectionError
+
+
+class SerialTransport(BaseTransport):
+    """
+    Represents a direct connection to a physical Pebble paired to the computer via Bluetooth serial.
+    This transport expects to be given a device file over which it can communicate with the watch via Bluetooth.
+
+    .. warning::
+        Using this transport may cause occasional kernel panics on some versions of OS X.
+
+    :param device: The path to the device file (on OS X, often of the form ``/dev/cu.PebbleTimeXXXX-SerialPo`` or
+                   ``/dev/cu.PebbleXXXX-SerialPortSe``).
+    :type device: str
+    """
+    must_initialise = True
+
+    def __init__(self, device):
+        self.device = device
+        self.connection = None
+
+    def connect(self):
+        try:
+            self.connection = serial.Serial(self.device, 115200)
+        except OSError as e:
+            if e.errno == errno.EBUSY:
+                raise ConnectionError("Could not connect to Pebble.")
+            else:
+                raise
+
+    @property
+    def connected(self):
+        return self.connection is not None and self.connection.isOpen()
+
+    def read_packet(self):
+        try:
+            data = self.connection.read(2)
+        except serial.SerialException:
+            self.connection.close()
+            raise ConnectionError("Disconnected from watch.")
+        if len(data) < 2:
+            raise ConnectionError("Got malformed packet.")
+
+        length, = struct.unpack('!H', data)
+        data += self.connection.read(length + 2)
+        return MessageTargetWatch(), data
+
+    def send_packet(self, message, target=MessageTargetWatch()):
+        assert isinstance(target, MessageTargetWatch)
+        self.connection.write(message)

libpebble2/communication/transports/websocket/__init__.py

@@ -0,0 +1,74 @@
+from __future__ import absolute_import
+
+__author__ = 'katharine'
+
+import socket
+import struct
+import websocket
+
+from .. import BaseTransport, MessageTarget, MessageTargetWatch
+from .protocol import WebSocketRelayToWatch, WebSocketRelayFromWatch, endpoints, from_watch
+from libpebble2.exceptions import ConnectionError, PebbleError
+
+
+class MessageTargetPhone(MessageTarget):
+    """
+    Indicates that the message is directed at a connected phone running the Pebble mobile app. For this purpose,
+    `pypkjs <https://github.com/pebble/pypkjs>`_ counts as a phone.
+    """
+    pass
+
+
+class WebsocketTransport(BaseTransport):
+    """
+    Represents a connection via WebSocket to a phone running the Pebble mobile app, which is in turn connected
+    to a Pebble over Bluetooth.
+
+    :param url: The WebSocket URL to connect to, in standard format (e.g. ``ws://localhost:9000/``)
+    """
+    must_initialise = False
+
+    def __init__(self, url):
+        self.url = url
+        """:type: str"""
+        self.ws = None
+        """:type: websocket.WebSocket"""
+
+    def connect(self):
+        try:
+            self.ws = websocket.create_connection(self.url)
+        except (websocket.WebSocketException, socket.error) as e:
+            raise ConnectionError(str(e))
+
+    @property
+    def connected(self):
+        return self.ws is not None and self.ws.connected
+
+    def send_packet(self, message, target=MessageTargetWatch()):
+        handlers = {
+            MessageTargetWatch: self._send_to_watch,
+            MessageTargetPhone: self._send_to_phone,
+        }
+
+        handlers[type(target)](message)
+
+    def _send_to_watch(self, message):
+        self.send_packet(WebSocketRelayToWatch(payload=message), target=MessageTargetPhone())
+
+    def _send_to_phone(self, message):
+        message = struct.pack('B', endpoints[type(message)]) + message.serialise()
+        self.ws.send_binary(message)
+
+    def read_packet(self):
+        opcode, message = self.ws.recv_data()
+        if opcode == websocket.ABNF.OPCODE_BINARY:
+            endpoint, = struct.unpack_from('B', message, 0)
+            if from_watch.get(endpoint, None) == WebSocketRelayFromWatch:
+                return MessageTargetWatch(), message[1:]
+            else:
+                packet, length = from_watch[endpoint].parse(message[1:])
+                return MessageTargetPhone(), packet
+        elif opcode == websocket.ABNF.OPCODE_CLOSE:
+            raise ConnectionError("Connection gracefully closed by peer.")
+        else:
+            raise PebbleError("Got unexpected WebSocket opcode {}".format(opcode))

libpebble2/communication/transports/websocket/protocol.py

@@ -0,0 +1,160 @@
+from __future__ import absolute_import
+__author__ = 'katharine'
+
+from six import iteritems
+
+from enum import IntEnum
+
+from libpebble2.protocol.base import PebblePacket
+from libpebble2.protocol.base.types import *
+
+
+class WebSocketRelayFromWatch(PebblePacket):
+    payload = BinaryArray()
+
+
+class WebSocketRelayToWatch(PebblePacket):
+    payload = BinaryArray()
+
+
+class WebSocketPhoneAppLog(PebblePacket):
+    payload = FixedString()
+
+
+class WebSocketPhoneServerLog(PebblePacket):
+    payload = BinaryArray()
+
+
+class WebSocketInstallBundle(PebblePacket):
+    pbw = BinaryArray()
+
+
+class WebSocketInstallStatus(PebblePacket):
+    class StatusCode(IntEnum):
+        Success = 0x00
+        Failed = 0x01
+    status = Uint32()
+
+
+class WebSocketPhoneInfoRequest(PebblePacket):
+    version = Uint8(default=0x00)
+
+
+class WebSocketInstallPhoneInfoResponse(PebblePacket):
+    payload = BinaryArray()
+
+
+class WebSocketConnectionStatusUpdate(PebblePacket):
+    class StatusCode(IntEnum):
+        Connected = 0xff
+        Disconnected = 0x00
+    status = Uint8()
+
+
+class WebSocketProxyConnectionStatusUpdate(PebblePacket):
+    class StatusCode(IntEnum):
+        Connected = 0xff
+        Disconnected = 0x00
+    status = Uint8()
+
+
+class WebSocketProxyAuthenticationRequest(PebblePacket):
+    token = PascalString()
+
+
+class WebSocketProxyAuthenticationResponse(PebblePacket):
+    class StatusCode(IntEnum):
+        Success = 0x00
+        Failed = 0x01
+    status = Uint8()
+
+
+class AppConfigSetup(PebblePacket):
+    pass
+
+
+class AppConfigResponse(PebblePacket):
+    length = Uint32()
+    data = FixedString(length=length)
+
+
+class AppConfigCancelled(PebblePacket):
+    pass
+
+
+class AppConfigURL(PebblePacket):
+    length = Uint32()
+    data = FixedString(length=length)
+
+
+class WebSocketPhonesimAppConfig(PebblePacket):
+    command = Uint8()
+    config = Union(command, {
+        0x01: AppConfigSetup,
+        0x02: AppConfigResponse,
+        0x03: AppConfigCancelled,
+    })
+
+
+class WebSocketPhonesimConfigResponse(PebblePacket):
+    command = Uint8()
+
+    config = Union(command, {
+        0x01: AppConfigURL
+    })
+
+
+class WebSocketRelayQemu(PebblePacket):
+    protocol = Uint8()
+    data = BinaryArray()
+
+
+class InsertPin(PebblePacket):
+    json = FixedString()
+
+
+class DeletePin(PebblePacket):
+    uuid = FixedString(36)
+
+
+class WebSocketTimelinePin(PebblePacket):
+    command = Uint8()
+    data = Union(command, {
+        0x01: InsertPin,
+        0x02: DeletePin
+    })
+
+
+class WebSocketTimelineResponse(PebblePacket):
+    class Status(IntEnum):
+        Succeeded = 0x00
+        Failed = 0x01
+
+    status = Uint8(enum=Status)
+
+to_watch = {
+    0x01: WebSocketRelayToWatch,
+    0x04: WebSocketInstallBundle,
+    0x06: WebSocketPhoneInfoRequest,
+    0x09: WebSocketProxyAuthenticationRequest,
+    0x0a: WebSocketPhonesimAppConfig,
+    0x0b: WebSocketRelayQemu,
+    0x0c: WebSocketTimelinePin
+}
+
+from_watch = {
+    0x00: WebSocketRelayFromWatch,
+    0x01: WebSocketRelayToWatch,
+    0x02: WebSocketPhoneAppLog,
+    0x03: WebSocketPhoneServerLog,
+    0x05: WebSocketInstallStatus,
+    0x06: WebSocketPhoneInfoRequest,
+    0x07: WebSocketConnectionStatusUpdate,
+    0x08: WebSocketProxyConnectionStatusUpdate,
+    0x09: WebSocketProxyAuthenticationResponse,
+    0x0a: WebSocketPhonesimConfigResponse,
+    0x0c: WebSocketTimelineResponse,
+}
+
+endpoints = {v: k for k, v in iteritems(to_watch)}
+endpoints.update({v: k for k, v in iteritems(from_watch)})

libpebble2/events/__init__.py

@@ -0,0 +1,93 @@
+from __future__ import absolute_import
+__author__ = 'katharine'
+
+from six import with_metaclass
+
+from abc import ABCMeta, abstractmethod
+
+
+class BaseEventHandler(with_metaclass(ABCMeta)):
+    """
+    An event handler, used throughout libpebble2 to indicate that something happened. These should ordinarily not need
+    to be directly invoked by a client of libpebble2.
+    """
+    @abstractmethod
+    def register_handler(self, event, handler):
+        """
+        Register a handler for an event.
+
+        :param event: The event to be handled. This can be any object, as long as it's hashable.
+        :param handler: A callback function to be called when the event is triggered. The arguments are dependent
+                        on the event.
+        :return: A handle that can be passed to :meth:`unregister_handler` to remove the registration.
+        """
+        pass
+
+    @abstractmethod
+    def unregister_handler(self, handle):
+        """
+        Remove a handler for an event using a handle returned by :meth:`register_handler`.
+
+        :param handle: The handle for the registration to remove.
+        """
+        pass
+
+    @abstractmethod
+    def wait_for_event(self, event, timeout=10):
+        """
+        A blocking wait for an event to be fired.
+
+        :param event: The event to wait on.
+        :param timeout: How long to wait before raising :exc:`.TimeoutError`
+        :return: The arguments that were passed to :meth:`broadcast_event`.
+        """
+        pass
+
+    @abstractmethod
+    def queue_events(self, event):
+        """
+        Returns a :class:`BaseEventQueue` from which events can be read as they arrive, even if the arrive faster
+        than they are removed.
+
+        :param event: The events to add to the queue.
+        :return: An event queue.
+        :rtype: BaseEventQueue
+        """
+        pass
+
+    @abstractmethod
+    def broadcast_event(self, event, *args):
+        """
+        Broadcasts an event to all subscribers for that event, as added by :meth:`register_handler`
+        :meth:`wait_for_event` and :meth:`queue_events`. All arguments after `event` are passed on to the listeners.
+
+        :param event: The event to broadcast.
+        :param args: Any arguments to pass on.
+        """
+        pass
+
+
+class BaseEventQueue(with_metaclass(ABCMeta)):
+    @abstractmethod
+    def close(self):
+        """
+        Stop adding events to this queue. It is illegal to call :meth:`get` or iterate over this queue after calling
+        :meth:`close`.
+        """
+        pass
+
+    @abstractmethod
+    def get(self, timeout=10):
+        """
+        Get the next event in the queue. Blocks until an item is available.
+        """
+        pass
+
+    @abstractmethod
+    def __iter__(self):
+        """
+        Iterate over events in the queue. Blocks if no more items are available.
+        """
+        pass
+
+

libpebble2/events/mixin.py

@@ -0,0 +1,43 @@
+from __future__ import absolute_import
+__author__ = 'katharine'
+
+from libpebble2.events.threaded import ThreadedEventHandler
+
+
+class EventSourceMixin(object):
+    """
+    A convenient mixin to save on repeatedly exposing generic event handler functionality.
+    """
+    def __init__(self):
+        self.__handler = ThreadedEventHandler()
+
+    def register_handler(self, event, handler):
+        """
+        Registers a handler to be triggered by an event
+
+        :param event: The event to handle
+        :param handler: The handler callable.
+        :return: A handle that can be used to unregister the handler.
+        """
+        return self.__handler.register_handler(event, handler)
+
+    def unregister_handler(self, handle):
+        """
+        Unregisters an event handler.
+
+        :param handle: The handle returned from :meth:`register_handler`
+        """
+        self.__handler.unregister_handler(handle)
+
+    def wait_for_event(self, event, timeout=10):
+        """
+        Block waiting for the given event. Returns the event params.
+
+        :param event: The event to handle.
+        :return: The event params.
+        :param timeout: The maximum time to wait before raising :exc:`.TimeoutError`.
+        """
+        return self.__handler.wait_for_event(event, timeout=timeout)
+
+    def _broadcast_event(self, event, *args):
+        return self.__handler.broadcast_event(event, *args)

libpebble2/events/threaded.py

@@ -0,0 +1,84 @@
+from __future__ import absolute_import
+
+__author__ = 'katharine'
+
+import threading
+from six.moves import queue
+
+from . import BaseEventHandler, BaseEventQueue
+from libpebble2.exceptions import TimeoutError
+
+
+class ThreadedEventHandler(BaseEventHandler):
+    """
+    A threaded implementation of :class:`.BaseEventHandler`.
+    """
+    def __init__(self):
+        self._handlers = {}
+        self._handle_map = {}
+        self._counter = 0
+        self._handler_lock = threading.RLock()
+
+    def register_handler(self, event, handler):
+        with self._handler_lock:
+            self._counter += 1
+            self._handlers.setdefault(event, {})[self._counter] = handler
+            self._handle_map[self._counter] = event
+            return self._counter
+
+    def unregister_handler(self, handle):
+        with self._handler_lock:
+            if handle not in self._handle_map:
+                return
+            del self._handlers[self._handle_map[handle]][handle]
+            del self._handle_map[handle]
+
+    def wait_for_event(self, event, timeout=10):
+        return _BlockingEventWait(self, event).wait(timeout=timeout)
+
+    def queue_events(self, event):
+        return _QueuedEventWait(self, event)
+
+    def broadcast_event(self, event, *args):
+        for handler in list(self._handlers.get(event, {}).values()):
+            handler(*args)
+
+
+class _BlockingEventWait(object):
+    def __init__(self, events, event):
+        self.block = threading.Event()
+        self.event_handler = events
+        self.result = None
+        self.handle = self.event_handler.register_handler(event, self.handle_result)
+
+    def handle_result(self, *args):
+        self.result, = args
+        self.event_handler.unregister_handler(self.handle)
+        self.block.set()
+
+    def wait(self, timeout=10):
+        if not self.block.wait(timeout=timeout):
+            raise TimeoutError()
+        return self.result
+
+
+class _QueuedEventWait(BaseEventQueue):
+    def __init__(self, events, event):
+        self.queue = queue.Queue()
+        self.event_handler = events
+        self.handle = self.event_handler.register_handler(event, self._handle_event)
+
+    def _handle_event(self, arg):
+        self.queue.put(arg)
+
+    def close(self):
+        self.event_handler.unregister_handler(self.handle)
+
+    def get(self, timeout=10):
+        try:
+            return self.queue.get(timeout=timeout)
+        except queue.Empty:
+            raise TimeoutError()
+
+    def __iter__(self):
+        yield self.get()