v2.8.1

Author: ikalchev

CHANGELOG.md

@@ -16,6 +16,12 @@ Sections
 ### Developers
 -->
 
+## [2.8.1] - 2020-04-06
+
+### Fixed
+- Fix an issue where reading just one byte at the beginning of a block can crash the connection. [#235](https://github.com/ikalchev/HAP-python/pull/235)
+- Improve camera accessory integration. [#231](https://github.com/ikalchev/HAP-python/pull/231)
+
 ## [2.8.0] - 2020-04-02
 
 ### Added

README.md

@@ -109,6 +109,68 @@ class TemperatureSensor(Accessory):
         print('Stopping accessory.')
 ```
 
+## Service Callbacks
+
+When you are working with tightly coupled characteristics such as "On" and "Brightness,"
+you may need to use a service callback to receive all changes in a single request.
+
+With characteristic callbacks, you do now know that a "Brightness" characteristic is
+about to be processed right after an "On" and may end up setting a LightBulb to 100%
+and then dim it back down to the expected level.
+
+```python
+from pyhap.accessory import Accessory
+from pyhap.const import Category
+import pyhap.loader as loader
+
+class Light(Accessory):
+    """Implementation of a mock light accessory."""
+
+    category = Category.CATEGORY_LIGHTBULB  # This is for the icon in the iOS Home app.
+
+    def __init__(self, *args, **kwargs):
+        """Here, we just store a reference to the on and brightness characteristics and
+        add a method that will be executed every time their value changes.
+        """
+        # If overriding this method, be sure to call the super's implementation first.
+        super().__init__(*args, **kwargs)
+
+        # Add the services that this Accessory will support with add_preload_service here
+        serv_light = self.add_preload_service('Lightbulb')
+        self.char_on = serv_light.configure_char('On', value=self._state)
+        self.char_brightness = serv_light.configure_char('Brightness', value=100)
+
+        serv_light.setter_callback = self._set_chars
+
+    def _set_chars(self, char_values):
+        """This will be called every time the value of the on of the
+        characteristics on the service changes.
+        """
+        if "On" in char_values:
+            print('On changed to: ', char_values["On"])
+        if "Brightness" in char_values:
+            print('Brightness changed to: ', char_values["Brightness"])
+
+    @Acessory.run_at_interval(3)  # Run this method every 3 seconds
+    # The `run` method can be `async` as well
+    def run(self):
+        """We override this method to implement what the accessory will do when it is
+        started.
+
+        We set the current temperature to a random number. The decorator runs this method
+        every 3 seconds.
+        """
+        self.char_on.set_value(random.randint(0, 1))
+        self.char_brightness.set_value(random.randint(1, 100))
+
+    # The `stop` method can be `async` as well
+    def stop(self):
+        """We override this method to clean up any resources or perform final actions, as
+        this is called by the AccessoryDriver when the Accessory is being stopped.
+        """
+        print('Stopping accessory.')
+```
+
 ## Setting up a camera <a name="Camera"></a>
 
 The [Camera accessory](pyhap/camera.py) implements the HomeKit Protocol for negotiating stream settings,

pyhap/camera.py

@@ -425,7 +425,7 @@ def __init__(self, options, *args, **kwargs):
         self.add_preload_service('Microphone')
         management = self.add_preload_service('CameraRTPStreamManagement')
         management.configure_char('StreamingStatus',
-                                  getter_callback=self._get_streaimg_status)
+                                  getter_callback=self._get_streaming_status)
         management.configure_char('SupportedRTPConfiguration',
                                   value=self.get_supported_rtp_config(
                                                 options.get('srtp', False)))
@@ -484,7 +484,7 @@ async def _start_stream(self, objs, reconfigure):  # pylint: disable=unused-argu
             if video_rtp_param:
                 video_rtp_param_objs = tlv.decode(video_rtp_param)
                 # TODO: Optionals, handle the case where they are missing
-                opts['v_ssrc'] = 1 or struct.unpack('<I',
+                opts['v_ssrc'] = struct.unpack('<I',
                     video_rtp_param_objs.get(
                         RTP_PARAM_TYPES['SYNCHRONIZATION_SOURCE']))[0]
                 opts['v_payload_type'] = \
@@ -539,7 +539,7 @@ async def _start_stream(self, objs, reconfigure):  # pylint: disable=unused-argu
             del self.sessions[session_id]
             self.streaming_status = STREAMING_STATUS['AVAILABLE']
 
-    def _get_streaimg_status(self):
+    def _get_streaming_status(self):
         """Get the streaming status in TLV format.
 
         Called when iOS reads the StreaminStatus ``Characteristic``.
@@ -667,9 +667,8 @@ def set_endpoints(self, value):
             video_srtp_tlv = NO_SRTP
             audio_srtp_tlv = NO_SRTP
 
-        # TODO: Use os.urandom(4) but within the allowed value bounds
-        video_ssrc = b'\x01'
-        audio_ssrc = b'\x01'
+        video_ssrc = int.from_bytes(os.urandom(3), byteorder="big")
+        audio_ssrc = int.from_bytes(os.urandom(3), byteorder="big")
 
         res_address_tlv = tlv.encode(
             SETUP_ADDR_INFO['ADDRESS_VER'], self.stream_address_isv6,
@@ -692,9 +691,9 @@ def set_endpoints(self, value):
             'address': address,
             'v_port': target_video_port,
             'v_srtp_key': to_base64_str(video_master_key + video_master_salt),
-            # TODO: 'v_ssrc': video_ssrc,
+            'v_ssrc': video_ssrc,
             'a_port': target_audio_port,
-            'audio_srtp_key': to_base64_str(audio_master_key + audio_master_salt),
+            'a_srtp_key': to_base64_str(audio_master_key + audio_master_salt),
             'a_ssrc': audio_ssrc
         }
 

pyhap/const.py

@@ -1,7 +1,7 @@
 """This module contains constants used by other modules."""
 MAJOR_VERSION = 2
 MINOR_VERSION = 8
-PATCH_VERSION = 0
+PATCH_VERSION = 1
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
 REQUIRED_PYTHON_VER = (3, 5)

pyhap/hap_server.py

@@ -709,11 +709,10 @@ def _wrapper(self, *args, **kwargs):
                 return func(self, *args, **kwargs)
         return _wrapper
 
-    def recv_into(self, buffer, nbytes=1042, flags=0):
+    def recv_into(self, buffer, nbytes=None, flags=0):
         """Receive and decrypt up to nbytes in the given buffer."""
-        data = self.recv(nbytes, flags)
-        for i, b in enumerate(data):
-            buffer[i] = b
+        data = self.recv(nbytes or len(buffer), flags)
+        buffer[:len(data)] = data
         return len(data)
 
     def recv(self, buflen=1042, flags=0):
@@ -734,11 +733,12 @@ def recv(self, buflen=1042, flags=0):
                     # It may be that we already read some data and we have
                     # 1 byte left, return whatever we have.
                     return result
-                block_length_bytes = self.socket.recv(self.LENGTH_LENGTH)
+                # Always wait for a full block to arrive
+                block_length_bytes = self.socket.recv(
+                    self.LENGTH_LENGTH, socket.MSG_WAITALL
+                )
                 if not block_length_bytes:
                     return result
-                # TODO: handle this
-                assert len(block_length_bytes) == self.LENGTH_LENGTH
                 # Init. info about the block we just started.
                 # Note we are setting the total length to block_length + mac length
                 self.curr_in_total = \