Change tracker update mangment

custom_components/georide/__init__.py

@@ -23,6 +23,8 @@ import homeassistant.helpers.config_validation as cv
 import homeassistant.helpers.event as ha_event
 
 from homeassistant.setup import async_when_setup
+from homeassistant.helpers.typing import HomeAssistantType
+
 
 from .const import (
     CONF_EMAIL,
@@ -35,6 +37,7 @@ from .const import (
 )
 
 
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -171,7 +174,7 @@ class GeoRideContext:
         self._socket = socket
 
         socket.init()
-        socket.connect(await self.get_token())
+        self._hass.async_add_executor_job(socket.connect, await self.get_token())
 
     async def get_token(self):
         """ here we return the current valid tocken """
@@ -201,9 +204,9 @@ class GeoRideContext:
 
         if not self._thread_started:
             _LOGGER.info("Start the thread")
-            await self.connect_socket()
             # We refresh the tracker list each hours
             self._thread_started = True
+            await self.connect_socket()
 
         for tracker in self._georide_trackers:
             if tracker.tracker_id == tracker_id:
@@ -213,8 +216,14 @@ class GeoRideContext:
     async def refresh_trackers(self):
         """Used to refresh the tracker list"""
         _LOGGER.info("Tracker list refresh")
-        self._georide_trackers = await self._hass.async_add_executor_job(GeoRideApi.get_trackers,
+        new_georide_trackers = await self._hass.async_add_executor_job(GeoRideApi.get_trackers,
-                                                                         await self.get_token())
+                                                                     await self.get_token())
+
+        for tracker in self._georide_trackers:
+            for refreshed_tracker in new_georide_trackers:
+                if tracker.tracker_id == refreshed_tracker.tracker_id:
+                    tracker.update_all_data(refreshed_tracker)
+
 
     @property
     def socket(self):

custom_components/georide/binary_sensor.py

@@ -7,6 +7,7 @@ from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.components.binary_sensor import ENTITY_ID_FORMAT
 
 import georideapilib.api as GeoRideApi
+import georideapilib.objects as GeoRideTracker
 
 from .const import DOMAIN as GEORIDE_DOMAIN
 
@@ -20,142 +21,111 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
         return False
 
     trackers = await hass.async_add_executor_job(GeoRideApi.get_trackers,token)
-    
+    entities = []
-
-    stolen_entities = []
     for tracker in trackers:
-        stolen_entity = GeoRideStolenBinarySensorEntity(hass, tracker.tracker_id,
+        coordinator = DataUpdateCoordinator[Mapping[str, Any]](
-                                                        georide_context.get_token,
+            hass,
-                                                        georide_context.get_tracker,
+            _LOGGER,
-                                                        data=tracker)
+            name=tracker.tracker_name,
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = stolen_entity
+            update_method=georide_context.get_tracker,
-        stolen_entities.append(stolen_entity)
+            update_interval=update_interval,
-    async_add_entities(stolen_entities)
+        )
+        stolen_entity = GeoRideStolenBinarySensorEntity(coordinator,
+                                                        coordinator)
+        crashed_entity = GeoRideCrashedBinarySensorEntity(hass,
+                                                          tracker)
+        entities.append(stolen_entity)
+        entities.append(crashed_entity)
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = coordinator
 
-    crashed_entities = []
+    async_add_entities(entities, True)
-    for tracker in trackers:
-        crashed_entity = GeoRideCrashedBinarySensorEntity(hass, tracker.tracker_id,
-                                                          georide_context.get_token,
-                                                          georide_context.get_tracker,
-                                                          data=tracker)
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = crashed_entity
-        crashed_entities.append(crashed_entity)
-    async_add_entities(crashed_entities)
 
     return True
 
-class GeoRideStolenBinarySensorEntity(BinarySensorEntity):
-    """Represent a tracked device."""
 
-    def __init__(self, hass, tracker_id, get_token_callback, get_tracker_callback, data):
+class GeoRideBinarySensorEntity( CoordinatorEntity,B inarySensorEntity):
+    """Represent a tracked device."""
+    def __init__(self, coordinator: DataUpdateCoordinator[Mapping[str, Any]], tracker: GeoRideTracker,  get_token_callback, get_tracker_callback):
         """Set up Georide entity."""
-        self._tracker_id = tracker_id
+        super().__init__(coordinator)
-        self._data = data or {}
+        self._tracker = tracker
         self._get_token_callback = get_token_callback
         self._get_tracker_callback = get_tracker_callback
-        self._name = data.tracker_name
+        self._name = tracker.tracker_name
+
+        self.entity_id = ENTITY_ID_FORMAT.format("is_stolen") + "." + str(tracker.tracker_id)
+        self._state = 0
+
+    @property
+    def unique_id(self):
+        """Return the unique ID."""
+        return self._tracker_id
+
+    @property
+    def name(self):
+        """ GeoRide odometer name """
+        return self._name
+
+    @property
+    def state(self):
+        return self._state
+    
+    @property
+    def get_token_callback(self):
+        """ GeoRide switch token callback method """
+        return self._get_token_callback
+    
+    @property
+    def get_tracker_callback(self):
+        """ GeoRide switch token callback method """
+        return self._get_tracker_callback
+    
+
+    @property
+    def device_info(self):
+        """Return the device info."""
+        return {
+            "name": self.name,
+            "identifiers": {(GEORIDE_DOMAIN, self._tracker_id)},
+            "manufacturer": "GeoRide"
+        }
+
+class GeoRideStolenBinarySensorEntity(GeoRideBinarySensorEntity):
+    """Represent a tracked device."""
+
+    def __init__(self, coordinator: DataUpdateCoordinator[Mapping[str, Any]], tracker: GeoRideTracker):
+        """Set up Georide entity."""
+        super().__init__(coordinator, tracker, hass, get_tracker_callback,get_tracker_callback)
 
         self.entity_id = ENTITY_ID_FORMAT.format("is_stolen") + "." + str(tracker_id)
-        self._state = 0
-        self._hass = hass
 
-
+     async def async_update(self):
-    async def async_update(self):
         """ update the current tracker"""
         _LOGGER.info('update')
-        self._data = await self._get_tracker_callback(self._tracker_id)
+        self._name = self._tracker.tracker_name
-        self._name = self._data.tracker_name
+        self._state = self._tracker.is_stolen
-        self._state = self._data.is_stolen
 
     @property
     def unique_id(self):
         """Return the unique ID."""
-        return self._tracker_id
+        return f"is_stolen_{self._tracker_id}"
-
-    @property
-    def name(self):
-        """ GeoRide odometer name """
-        return self._name
-
-    @property
-    def state(self):
-        return self._state
-    
-    @property
-    def get_token_callback(self):
-        """ GeoRide switch token callback method """
-        return self._get_token_callback
-    
-    @property
-    def get_tracker_callback(self):
-        """ GeoRide switch token callback method """
-        return self._get_tracker_callback
-    
-
-    @property
-    def device_info(self):
-        """Return the device info."""
-        return {
-            "name": self.name,
-            "identifiers": {(GEORIDE_DOMAIN, self._tracker_id)},
-            "manufacturer": "GeoRide"
-        }
 
 
-class GeoRideCrashedBinarySensorEntity(BinarySensorEntity):
+class GeoRideCrashedBinarySensorEntity(GeoRideBinarySensorEntity):
     """Represent a tracked device."""
 
-    def __init__(self, hass, tracker_id, get_token_callback, get_tracker_callback, data):
+    def __init__(self, coordinator: DataUpdateCoordinator[Mapping[str, Any]], tracker: GeoRideTracker):
         """Set up Georide entity."""
-        self._tracker_id = tracker_id
+        super().__init__(coordinator, tracker)
-        self._data = data or {}
-        self._get_token_callback = get_token_callback
-        self._get_tracker_callback = get_tracker_callback
-        self._name = data.tracker_name
-
         self.entity_id = ENTITY_ID_FORMAT.format("is_crashed") + "." + str(tracker_id)
-        self._state = 0
-        self._hass = hass
 
     async def async_update(self):
         """ update the current tracker"""
         _LOGGER.info('update')
-        self._data = await self._get_tracker_callback(self._tracker_id)
+        self._name = self._tracker.tracker_name
-        self._name = self._data.tracker_name
+        self._state = self._tracker.is_crashed
-        self._state = self._data.is_crashed
 
     @property
     def unique_id(self):
         """Return the unique ID."""
-        return self._tracker_id
+        return f"is_crashed_{self._tracker_id}"
-
-    @property
-    def name(self):
-        """ GeoRide odometer name """
-        return self._name
-
-    @property
-    def state(self):
-        return self._state
-    
-    @property
-    def get_token_callback(self):
-        """ GeoRide switch token callback method """
-        return self._get_token_callback
-    
-    @property
-    def get_tracker_callback(self):
-        """ GeoRide switch token callback method """
-        return self._get_tracker_callback
-    
-
-    @property
-    def device_info(self):
-        """Return the device info."""
-        return {
-            "name": self.name,
-            "identifiers": {(GEORIDE_DOMAIN, self._tracker_id)},
-            "manufacturer": "GeoRide"
-        }
-
-

custom_components/georide/manifest.json

@@ -4,7 +4,7 @@
   "config_flow": true,
   "documentation": "https://github.com/ptimatth/GeorideHA",
   "requirements": [
-    "georideapilib>=0.4.4",
+    "georideapilib>=0.5.0",
     "pyjwt>=1.7.1"
   ],
   "dependencies": [],