Fix tracker asign to tracker_device

custom_components/georide/__init__.py

@@ -32,7 +32,7 @@ from homeassistant.helpers.update_coordinator import (
 )
 
 
-from .device import Device
+from .device import Device, DeviceBeacon
 from .const import (
     CONF_EMAIL,
     CONF_PASSWORD,
@@ -182,6 +182,7 @@ class GeoRideContext:
         socket.subscribe_device(self.on_device_callback)
         socket.subscribe_position(self.on_position_callback)
         socket.subscribe_alarm(self.on_alarm_callback)
+        socket.subscribe_refresh_tracker(self.on_refresh_tracker_callback)
         self._socket = socket
 
         socket.init()
@@ -220,12 +221,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"""
@@ -239,6 +241,10 @@ class GeoRideContext:
                 if time.time() - SIREN_ACTIVATION_DELAY > tracker.siren_last_on_date:
                     tracker.is_siren_on = False
     
+    async def refresh_trackers_beacon(self):
+        """ here we return last tracker by id"""
+        _LOGGER.debug("Do nothing, updated by another way")
+
     async def force_refresh_trackers(self):
         """Used to refresh the tracker list"""
         _LOGGER.info("Tracker list refresh")
@@ -255,8 +261,7 @@ class GeoRideContext:
             if not found:
                 self._georide_trackers.append(refreshed_tracker)
                 if refreshed_tracker.version > 2:
-                    await self.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,11 +271,12 @@ 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_beacons,
                                                                        await self.get_token(), tracker_id)
+        for new_georide_tracker_beacon in new_georide_tracker_beacons:
             found = False
             for tracker_beacon in self._georide_trackers_beacon:
-            if tracker_beacon.tracker_id == new_georide_tracker_beacon.beacon_id:
+                if tracker_beacon.beacon_id == new_georide_tracker_beacon.beacon_id:
                     tracker_beacon.update_all_data(new_georide_tracker_beacon)
                     found = True
             if not found:
@@ -281,6 +287,8 @@ class GeoRideContext:
             self._thread_started = True
             await self.connect_socket()
 
+
+
     async def init_context(self, hass):
         """Used to refresh the tracker list"""
         _LOGGER.info("Init_context")
@@ -301,17 +309,20 @@ 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_beacons_by_tracker_id(tracker.tracker_id)
+                for tracker_beacon in tracker_beacons:
                     beacon_coordinator = DataUpdateCoordinator[Mapping[str, Any]](
                         hass,
                         _LOGGER,
-                    name=tracker_beacon.name
+                        name=tracker_beacon.name,
+                        update_method=self.refresh_trackers_beacon,
+                        update_interval=update_interval
                     )
                     coordoned_beacon = {
-                    "beacon_device": DeviceBeacon(tracker_beacon),
+                        "tracker_beacon": DeviceBeacon(tracker_beacon),
-                    "coordinator": coordinator
+                        "coordinator": beacon_coordinator
                     }
-                self._georide_trackers_beacon_coordoned(coordoned_beacon)
+                    self._georide_trackers_beacon_coordoned.append(coordoned_beacon)
             self._georide_trackers_coordoned.append(coordoned_tracker)
 
 
@@ -380,6 +391,25 @@ class GeoRideContext:
                     coordinator.async_request_refresh(), self._hass.loop
                 ).result()
                 break
+    @callback
+    def on_refresh_tracker_callback(self):
+        """on device callback"""
+        _LOGGER.info("On refresh tracker received")
+        self._previous_refresh = math.floor(time.time()/60)
+        self.force_refresh_trackers()
+    
+        for coordoned_tracker in self._georide_trackers_coordoned:
+            tracker_device = coordoned_tracker['tracker_device']
+            tracker = tracker_device.tracker
+            coordinator = coordoned_tracker['coordinator']
+            event_data = {
+                "device_id": tracker_device.unique_id,
+                "device_name": tracker_device.name,
+            }
+            self._hass.bus.async_fire(f"{DOMAIN}_refresh_tracker_event", event_data)
+            asyncio.run_coroutine_threadsafe(
+                coordinator.async_request_refresh(), self._hass.loop
+            ).result()
 
     @callback
     def on_alarm_callback(self, data):
@@ -437,7 +467,8 @@ class GeoRideContext:
         """on position callback"""
         _LOGGER.info("On position received")
         for coordoned_tracker in self._georide_trackers_coordoned:
-            tracker = coordoned_tracker['tracker_device'].tracker
+            tracker_device = coordoned_tracker['tracker_device']
+            tracker = tracker_device.tracker
             coordinator = coordoned_tracker['coordinator']
             if tracker.tracker_id == data['trackerId']:
                 tracker.latitude = data['latitude']

custom_components/georide/binary_sensor.py

@@ -38,10 +38,10 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
     
     coordoned_beacons = georide_context.georide_trackers_beacon_coordoned
     for coordoned_beacon in coordoned_beacons:
-        tracker_beacon = coordoned_tracker['tracker_beacon']
+        tracker_beacon = coordoned_beacon['tracker_beacon']
-        coordinator = coordoned_tracker['coordinator']
+        coordinator = coordoned_beacon['coordinator']
         entities.append(GeoRideBeaconUpdatedBinarySensorEntity(coordinator, tracker_beacon))
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.beacon.beacon_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_beacon.beacon.beacon_id] = coordinator
 
 
     async_add_entities(entities, True)
@@ -74,7 +74,7 @@ class GeoRideBeaconBinarySensorEntity(CoordinatorEntity, BinarySensorEntity):
         super().__init__(coordinator)
         self._tracker_device_beacon = tracker_device_beacon
         self._name = tracker_device_beacon.beacon.name
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('binary_sensor')}.{tracker_device.beacon.beacon_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('binary_sensor')}.{tracker_device_beacon.beacon.beacon_id}"# pylint: disable=C0301
         self._is_on = False
 
     @property
@@ -84,7 +84,7 @@ class GeoRideBeaconBinarySensorEntity(CoordinatorEntity, BinarySensorEntity):
     @property
     def device_info(self):
         """Return the device info."""
-        return self._tracker_device.device_info
+        return self._tracker_device_beacon.device_info
 
 class GeoRideStolenBinarySensorEntity(GeoRideBinarySensorEntity):
     """Represent a tracked device."""
@@ -142,7 +142,7 @@ class GeoRideCrashedBinarySensorEntity(GeoRideBinarySensorEntity):
     @property
     def name(self):
         """ GeoRide odometer name """
-        return f"{self._name} is crashed"
+        return f"{self._name} is not crashed"
 
 class GeoRideActiveSubscriptionBinarySensorEntity(GeoRideBinarySensorEntity):
     """Represent a tracked device."""
@@ -250,6 +250,10 @@ class GeoRideMovingBinarySensorEntity(GeoRideBinarySensorEntity):
         super().__init__(coordinator, tracker_device)
         self.entity_id = f"{ENTITY_ID_FORMAT.format('moving')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
 
+    @property
+    def entity_category(self):
+        return EntityCategory.DIAGNOSTIC
+
     @property
     def unique_id(self):
         """Return the unique ID."""
@@ -279,13 +283,13 @@ class GeoRideBeaconUpdatedBinarySensorEntity(GeoRideBeaconBinarySensorEntity):
     def __init__(self, coordinator: DataUpdateCoordinator[Mapping[str, Any]],
                  tracker_beacon_device: DeviceBeacon):
         """Set up Georide entity."""
-        super().__init__(coordinator, tracker_device)
+        super().__init__(coordinator, tracker_beacon_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('update')}.{tracker_beacon_device.tracker_beacon.beacon_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('update')}.{tracker_beacon_device.beacon.beacon_id}"# pylint: disable=C0301
 
     @property
     def unique_id(self):
         """Return the unique ID."""
-        return f"update_{self._tracker_beacon_device.beacon.beacon_id}"
+        return f"update_{self._tracker_device_beacon.beacon.beacon_id}"
 
     @property
     def device_class(self):
@@ -295,7 +299,7 @@ class GeoRideBeaconUpdatedBinarySensorEntity(GeoRideBeaconBinarySensorEntity):
     @property
     def is_on(self):
         """state value property"""
-        return not self._tracker_beacon_device.beacon.is_updated
+        return not self._tracker_device_beacon.beacon.is_updated
 
     @property
     def name(self):

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

@@ -31,6 +31,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
         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(GeoRideSpeedSensorEntity(coordinator, tracker_device,hass))        
         entities.append(GeoRideFixtimeSensorEntity(coordinator, tracker_device))
         if tracker_device.tracker.version > 2:
             entities.append(GeoRideInternalBatterySensorEntity(coordinator, tracker_device))
@@ -38,10 +39,10 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
     
     coordoned_beacons = georide_context.georide_trackers_beacon_coordoned
     for coordoned_beacon in coordoned_beacons:
-        tracker_beacon = coordoned_tracker['tracker_beacon']
+        tracker_beacon = coordoned_beacon['tracker_beacon']
-        coordinator = coordoned_tracker['coordinator']
+        coordinator = coordoned_beacon['coordinator']
-        entities.append(GeoRideBeaconUpdatedBinarySensorEntity(coordinator, tracker_beacon))
+        entities.append(GeoRideBeaconBatterySensorEntity(coordinator, tracker_beacon))
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.beacon.beacon_id] = coordinator
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_beacon.beacon.beacon_id] = coordinator
 
     async_add_entities(entities)
 
@@ -108,7 +109,6 @@ class GeoRideOdometerKmSensorEntity(CoordinatorEntity, SensorEntity):
         self._name = tracker_device.tracker.tracker_name
         self._unit_of_measurement = "km"
         self.entity_id = f"{ENTITY_ID_FORMAT.format('odometer_km')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
-
         self._state = 0
         self._hass = hass
 
@@ -143,6 +143,55 @@ class GeoRideOdometerKmSensorEntity(CoordinatorEntity, SensorEntity):
         """Return the device info."""
         return self._tracker_device.device_info
 
+class GeoRideSpeedSensorEntity(CoordinatorEntity, SensorEntity):
+    """Represent a tracked device."""
+
+    def __init__(self, coordinator: DataUpdateCoordinator[Mapping[str, Any]],
+                 tracker_device:Device, hass):
+        """Set up GeoRide entity."""
+        super().__init__(coordinator)
+        self._tracker_device = tracker_device
+        self._name = tracker_device.tracker.tracker_name
+        self._unit_of_measurement = "km/h"
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('speed')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self._state = 0
+        self._hass = hass
+        self._state_class = "measurement"
+
+    @property
+    def unique_id(self):
+        """Return the unique ID."""
+        return f"speed_{self._tracker_device.tracker.tracker_id}"
+
+    @property
+    def state(self):
+        """state property"""
+        return self._tracker_device.tracker.speed
+
+    @property
+    def state_class(self):
+        return self._state_class
+
+    @property
+    def unit_of_measurement(self):
+        """unit of mesurment property"""
+        return self._unit_of_measurement
+
+    @property
+    def name(self):
+        """ GeoRide odometer name """
+        return f"{self._name} speed"
+
+    @property
+    def icon(self):
+        """icon getter"""
+        return "mdi:speedometer"
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return self._tracker_device.device_info
+
 class GeoRideInternalBatterySensorEntity(CoordinatorEntity, SensorEntity):
     """Represent a tracked device."""
     entity_category = EntityCategory.DIAGNOSTIC
@@ -155,8 +204,17 @@ class GeoRideInternalBatterySensorEntity(CoordinatorEntity, SensorEntity):
         self._name = tracker_device.tracker.tracker_name
         self._unit_of_measurement = "V"
         self.entity_id = f"{ENTITY_ID_FORMAT.format('internal_battery_voltage')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
-
         self._state = 0
+        self._state_class = "measurement"
+        self._device_class = "voltage"
+
+    @property
+    def state_class(self):
+        return self._state_class
+
+    @property
+    def device_class(self):
+        return self._device_class
 
     @property
     def entity_category(self):
@@ -204,6 +262,16 @@ class GeoRideExternalBatterySensorEntity(CoordinatorEntity, SensorEntity):
         self._unit_of_measurement = "V"
         self.entity_id = f"{ENTITY_ID_FORMAT.format('external_battery_voltage')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
         self._state = 0
+        self._state_class = "measurement"
+        self._device_class = "voltage"
+
+    @property
+    def state_class(self):
+        return self._state_class
+
+    @property
+    def device_class(self):
+        return self._device_class
 
     @property
     def entity_category(self):
@@ -249,7 +317,6 @@ class GeoRideFixtimeSensorEntity(CoordinatorEntity, SensorEntity):
         self._tracker_device = tracker_device
         self._name = tracker_device.tracker.tracker_name
         self.entity_id = f"{ENTITY_ID_FORMAT.format('fixtime')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
-
         self._state = 0
         self._device_class = "timestamp"
 
@@ -289,8 +356,8 @@ class GeoRideBeaconBatterySensorEntity(CoordinatorEntity, SensorEntity):
                  tracker_beacon: DeviceBeacon):
         """Set up GeoRide entity."""
         super().__init__(coordinator)
-        self._tracker_device = tracker_device
+        self._tracker_device = tracker_beacon
-        self._name = tracker_device.tracker.tracker_name
+        self._name = tracker_beacon.beacon.name
         self._unit_of_measurement = "%"
         self.entity_id = f"{ENTITY_ID_FORMAT.format('battery_percent')}.{tracker_beacon.beacon.beacon_id}"# pylint: disable=C0301
         self._state = 0

custom_components/georide/siren.py

@@ -35,7 +35,7 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
         if tracker_device.tracker.version > 2:
             entities.append(GeoRideSirenEntity(coordinator, tracker_device, hass))
 
-    await async_add_entities(entities)
+    async_add_entities(entities)
 
     return True