Fix support multiple tracker beacon

custom_components/georide/__init__.py

@@ -220,12 +220,13 @@ class GeoRideContext:
                 return tracker_beacon
         return {}
     
-    async def get_tracker_beacon_by_tracker_id(self, tracker_id):
+    async def get_tracker_beacons_by_tracker_id(self, tracker_id):
         """ here we return last tracker_beacon by id"""
+        filtered_beacon = []
         for tracker_beacon in self._georide_trackers_beacon:
             if tracker_beacon.linked_tracker_id == tracker_id:
-                return tracker_beacon
+                filtered_beacon.append(tracker_beacon)
-        return {}
+        return filtered_beacon
 
     async def refresh_trackers(self):
         """ here we return last tracker by id"""
@@ -250,13 +251,12 @@ class GeoRideContext:
                 if tracker.tracker_id == refreshed_tracker.tracker_id:
                     tracker.update_all_data(refreshed_tracker)
                     if tracker.version > 2:
-                        await force_refresh_trackers_beacon(tracker.tracker_id)
+                        await self.force_refresh_trackers_beacon(tracker.tracker_id)
                     found = True
             if not found:
                 self._georide_trackers.append(refreshed_tracker)
                 if refreshed_tracker.version > 2:
-                    await force_refresh_trackers_beacon(tracker.tracker_id)
+                    await self.force_refresh_trackers_beacon(refreshed_tracker.tracker_id)
-    
         if not self._thread_started:
             _LOGGER.info("Start the thread")
             # We refresh the tracker list each hours
@@ -266,15 +266,17 @@ class GeoRideContext:
     async def force_refresh_trackers_beacon(self, tracker_id):
         """Used to refresh the tracker list"""
         _LOGGER.info("Tracker beacon refresh")
-        new_georide_tracker_beacon = await self._hass.async_add_executor_job(GeoRideApi.get_tracker_beacon,
+        new_georide_tracker_beacons = await self._hass.async_add_executor_job(GeoRideApi.get_tracker_beacon,
                                                                        await self.get_token(), tracker_id)
-        found = False
+        
-        for tracker_beacon in self._georide_trackers_beacon:
+        for new_georide_tracker_beacon in new_georide_tracker_beacons:
-            if tracker_beacon.tracker_id == new_georide_tracker_beacon.beacon_id:
+            found = False
-                tracker_beacon.update_all_data(new_georide_tracker_beacon)
+            for tracker_beacon in self._georide_trackers_beacon:
-                found = True
+                if tracker_beacon.tracker_id == new_georide_tracker_beacon.beacon_id:
-        if not found:
+                    tracker_beacon.update_all_data(new_georide_tracker_beacon)
-            self._georide_trackers_beacon.append(new_georide_tracker_beacon)
+                    found = True
+            if not found:
+                self._georide_trackers_beacon.append(new_georide_tracker_beacon)
         if not self._thread_started:
             _LOGGER.info("Start the thread")
             # We refresh the tracker list each hours
@@ -301,17 +303,18 @@ class GeoRideContext:
                 "coordinator": coordinator
             }
             if tracker.version > 2:
-                tracker_beacon = await get_tracker_beacon_by_tracker_id(tracker.tracker_id)
+                tracker_beacons = await self.get_tracker_beacon_by_tracker_id(tracker.tracker_id)
-                beacon_coordinator = DataUpdateCoordinator[Mapping[str, Any]](
+                for tracker_beacon in tracker_beacons
-                    hass,
+                    beacon_coordinator = DataUpdateCoordinator[Mapping[str, Any]](
-                    _LOGGER,
+                        hass,
-                    name=tracker_beacon.name
+                        _LOGGER,
-                )
+                        name= tracker_beacon.name
-                coordoned_beacon = {
+                    )
-                    "beacon_device": DeviceBeacon(tracker_beacon),
+                    coordoned_beacon = {
-                    "coordinator": coordinator
+                        "beacon_device": DeviceBeacon(tracker_beacon),
-                }
+                        "coordinator": coordinator
-                self._georide_trackers_beacon_coordoned(coordoned_beacon)
+                    }
+                    self._georide_trackers_beacon_coordoned.append(coordoned_beacon)
             self._georide_trackers_coordoned.append(coordoned_tracker)
 
 
@@ -320,7 +323,7 @@ class GeoRideContext:
         """Return coordoned trackers"""
 
         return self._georide_trackers_coordoned
-        
+
     @property
     def georide_trackers_beacon_coordoned(self):
         """Return coordoned trackers"""

custom_components/georide/binary_sensor.py

@@ -34,14 +34,14 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
         entities.append(GeoRideNetworkBinarySensorEntity(coordinator, tracker_device))
         entities.append(GeoRideMovingBinarySensorEntity(coordinator, tracker_device))
 
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.unique_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.tracker.tracker_id] = coordinator
     
     coordoned_beacons = georide_context.georide_trackers_beacon_coordoned
     for coordoned_beacon in coordoned_beacons:
         tracker_beacon = coordoned_tracker['tracker_beacon']
         coordinator = coordoned_tracker['coordinator']
         entities.append(GeoRideBeaconUpdatedBinarySensorEntity(coordinator, tracker_beacon))
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_beacon.unique_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.beacon.beacon_id] = coordinator
 
 
     async_add_entities(entities, True)

custom_components/georide/device.py

@@ -44,7 +44,7 @@ class Device:
         """Return the device info."""
         return {
             "name": self.name,
-            "identifiers": {(GEORIDE_DOMAIN, self._tracker.tracker_id)},
+            "identifiers": self.unique_id,
             "manufacturer": "GeoRide",
             "model": self.model_name,
             "suggested_area": "Garage"
@@ -93,17 +93,17 @@ class DeviceBeacon:
         """Return the device info."""
         return {
             "name": self.name,
-            "identifiers": {(GEORIDE_DOMAIN, self._beacon.beacon_id)},
+            "identifiers": self.unique_id,
             "manufacturer": "GeoRide",
             "model": self.model_name,
             "suggested_area": "Garage"
         }
 
-
     @property
     def unique_id(self) -> str:
         """Get the unique id."""
-        return {(GEORIDE_DOMAIN, "beacon", self._beacon.beacon_id)}
+        
+        return {(GEORIDE_DOMAIN, self._beacon.beacon_id)}
 
     def __str__(self) -> str:
         """Get string representation."""

custom_components/georide/device_tracker.py

@@ -27,7 +27,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
         tracker_device = coordoned_tracker['tracker_device']
         coordinator = coordoned_tracker['coordinator']
         entity = GeoRideTrackerEntity(coordinator, tracker_device, hass)
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.unique_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.tracker.tracker_id] = coordinator
         entities.append(entity)
 
     async_add_entities(entities)

custom_components/georide/manifest.json

@@ -6,7 +6,7 @@
   "issue_tracker": "https://github.com/ptimatth/GeorideHA/issues",
   "iot_class": "cloud_polling",
   "requirements": [
-    "georideapilib==0.8.1",
+    "georideapilib>=0.8.2",
     "pyjwt==2.1.0"
   ],
   "dependencies": [],

custom_components/georide/sensor.py

@@ -28,7 +28,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
     for coordoned_tracker in coordoned_trackers:
         tracker_device = coordoned_tracker['tracker_device']
         coordinator = coordoned_tracker['coordinator']
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.unique_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.tracker.tracker_id] = coordinator
         entities.append(GeoRideOdometerSensorEntity(coordinator, tracker_device, hass))
         entities.append(GeoRideOdometerKmSensorEntity(coordinator, tracker_device, hass))
         entities.append(GeoRideFixtimeSensorEntity(coordinator, tracker_device))
@@ -41,9 +41,9 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
         tracker_beacon = coordoned_tracker['tracker_beacon']
         coordinator = coordoned_tracker['coordinator']
         entities.append(GeoRideBeaconUpdatedBinarySensorEntity(coordinator, tracker_beacon))
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_beacon.unique_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.beacon.beacon_id] = coordinator
 
-    await async_add_entities(entities)
+    async_add_entities(entities)
 
     return True
 
@@ -111,11 +111,7 @@ class GeoRideOdometerKmSensorEntity(CoordinatorEntity, SensorEntity):
 
         self._state = 0
         self._hass = hass
-
+        
-    @property
-    def entity_category(self):
-        return EntityCategory.DIAGNOSTIC
-
     @property
     def unique_id(self):
         """Return the unique ID."""

custom_components/georide/siren.py

@@ -16,7 +16,8 @@ import georideapilib.api as GeoRideApi
 
 from .const import DOMAIN as GEORIDE_DOMAIN
 from .device import Device
-ENTITY_ID_FORMAT: Final = DOMAIN + ".{}"
+
+ENTITY_ID_FORMAT = GEORIDE_DOMAIN + ".{}"
 
 _LOGGER = logging.getLogger(__name__) 
 
@@ -30,7 +31,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
     for coordoned_tracker in coordoned_trackers:
         tracker_device = coordoned_tracker['tracker_device']
         coordinator = coordoned_tracker['coordinator']
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.unique_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.tracker.tracker_id] = coordinator
         if tracker_device.tracker.version > 2:
             entities.append(GeoRideSirenEntity(coordinator, tracker_device, hass))
 

custom_components/georide/switch.py

@@ -30,7 +30,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
     for coordoned_tracker in coordoned_trackers:
         tracker_device = coordoned_tracker['tracker_device']
         coordinator = coordoned_tracker['coordinator']
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.unique_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.tracker.tracker_id] = coordinator
         entities.append(GeoRideLockSwitchEntity(coordinator, tracker_device, hass))
         if tracker_device.tracker.version > 2:
             entities.append(GeoRideEcoModeSwitchEntity(coordinator, tracker_device, hass))