Prevent sync module creation for minis already attached to one

blinkpy/blinkpy.py

@@ -128,7 +128,6 @@ class Blink:
             sync_cameras = cameras.get(network_id, {})
             self.setup_sync_module(name, network_id, sync_cameras)
 
-        self.setup_owls()
         self.cameras = self.merge_cameras()
 
         self.available = True
@@ -145,10 +144,16 @@ class Blink:
         response = api.request_homescreen(self)
         self.homescreen = response
         network_list = []
+        camera_list = []
         try:
             for owl in response["owls"]:
                 name = owl["name"]
-                network_id = owl["network_id"]
+                network_id = str(owl["network_id"])
+                if network_id in self.network_ids:
+                    camera_list.append(
+                        {network_id: {"name": name, "id": network_id, "type": "mini"}}
+                    )
+                    continue
                 if owl["onboarded"]:
                     network_list.append(str(network_id))
                     self.sync[name] = BlinkOwl(self, name, network_id, owl)
@@ -158,6 +163,7 @@ class Blink:
             pass
 
         self.network_ids.extend(network_list)
+        return camera_list
 
     def setup_camera_list(self):
         """Create camera list for onboarded networks."""
@@ -172,6 +178,10 @@ class Blink:
                     all_cameras[camera_network].append(
                         {"name": camera["name"], "id": camera["id"]}
                     )
+            mini_cameras = self.setup_owls()
+            for camera in mini_cameras:
+                for network, camera_info in camera.items():
+                    all_cameras[network].append(camera_info)
             return all_cameras
         except (KeyError, TypeError):
             _LOGGER.error("Unable to retrieve cameras from response %s", response)

blinkpy/camera.py

@@ -29,6 +29,7 @@ class BlinkCamera:
         self.last_record = None
         self._cached_image = None
         self._cached_video = None
+        self.camera_type = ""
 
     @property
     def attributes(self):
@@ -229,6 +230,11 @@ class BlinkCamera:
 class BlinkCameraMini(BlinkCamera):
     """Define a class for a Blink Mini camera."""
 
+    def __init__(self, sync):
+        """Initialize a Blink Mini cameras."""
+        super().__init__(sync)
+        self.camera_type = "mini"
+
     @property
     def arm(self):
         """Return camera arm status."""
@@ -237,7 +243,9 @@ class BlinkCameraMini(BlinkCamera):
     @arm.setter
     def arm(self, value):
         """Set camera arm status."""
-        self.sync.arm = value
+        _LOGGER.warning(
+            "Individual camera motion detection enable/disable for Blink Mini cameras is unsupported at this time."
+        )
 
     def snap_picture(self):
         """Snap picture for a blink mini camera."""

blinkpy/sync_module.py

@@ -124,16 +124,33 @@ class BlinkSyncModule:
             for camera_config in self.camera_list:
                 if "name" not in camera_config:
                     break
+                blink_camera_type = camera_config.get("type", "")
                 name = camera_config["name"]
-                self.cameras[name] = camera_type(self)
                 self.motion[name] = False
-                camera_info = self.get_camera_info(camera_config["id"])
+                owl_info = self.get_owl_info(name)
+                if blink_camera_type == "mini":
+                    camera_type = BlinkCameraMini
+                self.cameras[name] = camera_type(self)
+                camera_info = self.get_camera_info(
+                    camera_config["id"], owl_info=owl_info
+                )
                 self.cameras[name].update(camera_info, force_cache=True, force=True)
+
         except KeyError:
             _LOGGER.error("Could not create camera instances for %s", self.name)
             return False
         return True
 
+    def get_owl_info(self, name):
+        """Extract owl information."""
+        try:
+            for owl in self.blink.homescreen["owls"]:
+                if owl["name"] == name:
+                    return owl
+        except KeyError:
+            pass
+        return None
+
     def get_events(self, **kwargs):
         """Retrieve events from server."""
         force = kwargs.pop("force", False)
@@ -144,8 +161,11 @@ class BlinkSyncModule:
             _LOGGER.error("Could not extract events: %s", response, exc_info=True)
             return False
 
-    def get_camera_info(self, camera_id):
+    def get_camera_info(self, camera_id, **kwargs):
         """Retrieve camera information."""
+        owl = kwargs.get("owl_info", None)
+        if owl is not None:
+            return owl
         response = api.request_camera_info(self.blink, self.network_id, camera_id)
         try:
             return response["camera"][0]
@@ -243,7 +263,7 @@ class BlinkOwl(BlinkSyncModule):
         """Update sync-less cameras."""
         return super().update_cameras(camera_type=BlinkCameraMini)
 
-    def get_camera_info(self, camera_id):
+    def get_camera_info(self, camera_id, **kwargs):
         """Retrieve camera information."""
         try:
             for owl in self.blink.homescreen["owls"]:

tests/test_blinkpy.py

@@ -83,8 +83,10 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(self.blink.sync["tEsT"], 1234)
 
     @mock.patch("blinkpy.api.request_camera_usage")
-    def test_setup_cameras(self, mock_req):
+    @mock.patch("blinkpy.api.request_homescreen")
+    def test_setup_cameras(self, mock_home, mock_req):
         """Check retrieval of camera information."""
+        mock_home.return_value = {}
         mock_req.return_value = {
             "networks": [
                 {
@@ -233,6 +235,55 @@ class TestBlinkSetup(unittest.TestCase):
         self.assertEqual(self.blink.sync["foo"].name, "foo")
         self.assertEqual(self.blink.sync["bar"].name, "bar")
 
+    @mock.patch("blinkpy.api.request_homescreen")
+    def test_blink_mini_cameras_returned(self, mock_home):
+        """Test that blink mini cameras are found if attached to sync module."""
+        self.blink.network_ids = ["1234"]
+        mock_home.return_value = {
+            "owls": [
+                {
+                    "id": 1,
+                    "name": "foo",
+                    "network_id": 1234,
+                    "onboarded": True,
+                    "enabled": True,
+                    "status": "online",
+                    "thumbnail": "/foo/bar",
+                    "serial": "abc123",
+                }
+            ]
+        }
+        result = self.blink.setup_owls()
+        self.assertEqual(self.blink.network_ids, ["1234"])
+        self.assertEqual(
+            result, [{"1234": {"name": "foo", "id": "1234", "type": "mini"}}]
+        )
+
+    @mock.patch("blinkpy.api.request_homescreen")
+    @mock.patch("blinkpy.api.request_camera_usage")
+    def test_blink_mini_attached_to_sync(self, mock_usage, mock_home):
+        """Test that blink mini cameras are properly attached to sync module."""
+        self.blink.network_ids = ["1234"]
+        mock_home.return_value = {
+            "owls": [
+                {
+                    "id": 1,
+                    "name": "foo",
+                    "network_id": 1234,
+                    "onboarded": True,
+                    "enabled": True,
+                    "status": "online",
+                    "thumbnail": "/foo/bar",
+                    "serial": "abc123",
+                }
+            ]
+        }
+        mock_usage.return_value = {"networks": [{"cameras": [], "network_id": 1234}]}
+        result = self.blink.setup_camera_list()
+        self.assertEqual(
+            result, {"1234": [{"name": "foo", "id": "1234", "type": "mini"}]}
+        )
+
 
 class MockSync:
     """Mock sync module class."""