Update yto v1.1.2

Add manual installation

README.md

@@ -4,6 +4,7 @@
 ⚠️ This is not an official implementation
 [![hacs_badge](https://img.shields.io/badge/HACS-Default-orange.svg?style=for-the-badge)](https://github.com/custom-components/hacs)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg?style=for-the-badge)](https://www.gnu.org/licenses/gpl-3.0)
+[![install_badge](https://img.shields.io/badge/dynamic/json?color=41BDF5&logo=home-assistant&label=integration%20usage&suffix=%20installs&cacheSeconds=15600&url=https://analytics.home-assistant.io/custom_integrations.json&query=$.georide.total)](https://analytics.home-assistant.io/)
 
 Official GeoRide website: https://georide.fr/
 
@@ -101,12 +102,21 @@ mode: single
 
 ## Installation
 ### Option 1
-- Just folow the integration config steps.
+- Just follow the integration config steps.
 
 ### Option 2
-- Add the folowing line in your configuration.yml
+- Add the following line in your configuration.yml
 ```yaml
     georide:
         email: <your-email>@exmple.com
         password: <your-password>
 ```
+
+### Option 3 (manual)
+- Download .zip git repo
+- Go to /config (with File Editor or SSH)
+- Unzip GeorideHA.zip
+- Restart Home Assistant
+- Go to "Integrations"
+- If GeoRide not display, choose "add integration"
+- Configure GeoRide add-on

custom_components/georide/__init__.py

@@ -25,14 +25,13 @@ 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 homeassistant.helpers.update_coordinator import (
     CoordinatorEntity,
     DataUpdateCoordinator,
 )
 
 
-from .device import Device
+from .device import Device, DeviceBeacon
 from .const import (
     CONF_EMAIL,
     CONF_PASSWORD,
@@ -44,11 +43,8 @@ from .const import (
     SIREN_ACTIVATION_DELAY
 )
 
-
-
 _LOGGER = logging.getLogger(__name__)
 
-
 CONFIG_SCHEMA = vol.Schema(
     {
         vol.Required(DOMAIN, default={}): {
@@ -59,7 +55,6 @@ CONFIG_SCHEMA = vol.Schema(
     extra=vol.ALLOW_EXTRA,
 )
 
-
 async def async_setup(hass, config):
     """Setup  GeoRide component."""
     hass.data[DOMAIN] = {"config": config[DOMAIN], "devices": {}, "unsub": None}
@@ -76,7 +71,6 @@ async def async_setup(hass, config):
     # Return boolean to indicate that initialization was successful.
     return True
 
-
 async def async_setup_entry(hass, entry):
     """Set up GeoRide entry."""
     config = hass.data[DOMAIN]["config"]
@@ -98,16 +92,7 @@ async def async_setup_entry(hass, entry):
     # We add trackers to the context
     await context.init_context(hass)
 
-    hass.async_create_task(
-        hass.config_entries.async_forward_entry_setup(entry, "device_tracker"))
-    hass.async_create_task(
-        hass.config_entries.async_forward_entry_setup(entry, "switch"))
-    hass.async_create_task(
-        hass.config_entries.async_forward_entry_setup(entry, "sensor"))
-    hass.async_create_task(
-        hass.config_entries.async_forward_entry_setup(entry, "binary_sensor"))
-    hass.async_create_task(
-        hass.config_entries.async_forward_entry_setup(entry, "siren"))
+    await hass.config_entries.async_forward_entry_setups(entry, ["device_tracker", "switch", "sensor", "binary_sensor", "siren"])
     return True
 
 
@@ -120,12 +105,15 @@ async def async_unload_entry(hass, entry):
     await hass.config_entries.async_forward_entry_unload(entry, "binary_sensor")
     await hass.config_entries.async_forward_entry_unload(entry, "siren")
 
-
     context = hass.data[DOMAIN]["context"]
-    context.socket.disconnect()
+    context.socket.disconnect() # Disconnect only if all devices is disabled
 
     return True
 
+async def async_remove_config_entry_device(hass, config_entry, device_entry) -> bool:
+    """Remove an GeoRide device entry."""
+    return True
+
 
 
 class GeoRideContext:
@@ -182,6 +170,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 +209,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
-        return {}
+                filtered_beacon.append(tracker_beacon)
+        return filtered_beacon
 
     async def refresh_trackers(self):
         """ here we return last tracker by id"""
@@ -239,6 +229,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")
@@ -250,13 +244,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,11 +259,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 +275,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")
@@ -300,18 +296,21 @@ class GeoRideContext:
                 "tracker_device": Device(tracker),
                 "coordinator": coordinator
             }
-            if tracker.version > 2:
-                tracker_beacon = await get_tracker_beacon_by_tracker_id(tracker.tracker_id)
+            if tracker.has_beacon:
+                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),
-                    "coordinator": coordinator
+                        "tracker_beacon": DeviceBeacon(tracker_beacon),
+                        "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 +379,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 +455,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

@@ -6,8 +6,7 @@ from typing import Any, Mapping
 
 from homeassistant.core import callback
 from homeassistant.helpers.entity import DeviceInfo, EntityCategory
-from homeassistant.components.binary_sensor import BinarySensorEntity
-from homeassistant.components.binary_sensor import ENTITY_ID_FORMAT
+from homeassistant.components.binary_sensor import BinarySensorEntity, BinarySensorDeviceClass, ENTITY_ID_FORMAT
 from homeassistant.helpers.update_coordinator import (
     CoordinatorEntity,
     DataUpdateCoordinator
@@ -33,15 +32,16 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
         entities.append(GeoRideActiveSubscriptionBinarySensorEntity(coordinator, tracker_device))
         entities.append(GeoRideNetworkBinarySensorEntity(coordinator, tracker_device))
         entities.append(GeoRideMovingBinarySensorEntity(coordinator, tracker_device))
+        entities.append(GeoRideUpdatedBinarySensorEntity(coordinator, tracker_device))
 
         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']
+        tracker_beacon = coordoned_beacon['tracker_beacon']
+        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)
@@ -58,7 +58,7 @@ class GeoRideBinarySensorEntity(CoordinatorEntity, BinarySensorEntity):
         self._tracker_device = tracker_device
         self._name = tracker_device.tracker.tracker_name
 
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('binary_sensor')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('binary_sensor')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
         self._is_on = False
 
     @property
@@ -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."""
@@ -92,7 +92,7 @@ class GeoRideStolenBinarySensorEntity(GeoRideBinarySensorEntity):
                  tracker_device: Device):
         """Set up Georide entity."""
         super().__init__(coordinator, tracker_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_stolen')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_stolen')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
 
     @property
     def unique_id(self):
@@ -102,7 +102,7 @@ class GeoRideStolenBinarySensorEntity(GeoRideBinarySensorEntity):
     @property
     def device_class(self):
         """Return the device class."""
-        return "problem"
+        return BinarySensorDeviceClass.PROBLEM
 
     @property
     def is_on(self):
@@ -122,7 +122,7 @@ class GeoRideCrashedBinarySensorEntity(GeoRideBinarySensorEntity):
                  tracker_device: Device):
         """Set up Georide entity."""
         super().__init__(coordinator, tracker_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_crashed')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_crashed')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
 
     @property
     def unique_id(self):
@@ -132,7 +132,7 @@ class GeoRideCrashedBinarySensorEntity(GeoRideBinarySensorEntity):
     @property
     def device_class(self):
         """Return the device class."""
-        return "problem"
+        return BinarySensorDeviceClass.PROBLEM
 
     @property
     def is_on(self):
@@ -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."""
@@ -151,7 +151,7 @@ class GeoRideActiveSubscriptionBinarySensorEntity(GeoRideBinarySensorEntity):
                  tracker_device: Device):
         """Set up Georide entity."""
         super().__init__(coordinator, tracker_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_active_subscription_')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_active_subscription_')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
 
     @property
     def entity_category(self):
@@ -187,7 +187,7 @@ class GeoRideOwnerBinarySensorEntity(GeoRideBinarySensorEntity):
                  tracker_device: Device):
         """Set up Georide entity."""
         super().__init__(coordinator, tracker_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_owner')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('is_owner')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
 
     @property
     def unique_id(self):
@@ -213,7 +213,7 @@ class GeoRideNetworkBinarySensorEntity(GeoRideBinarySensorEntity):
                  tracker_device: Device):
         """Set up Georide entity."""
         super().__init__(coordinator, tracker_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('have_network')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('have_network')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
 
     @property
     def entity_category(self):
@@ -236,6 +236,11 @@ class GeoRideNetworkBinarySensorEntity(GeoRideBinarySensorEntity):
             return True
         return False
 
+    @property
+    def device_class(self) -> str:
+        """device class"""
+        return BinarySensorDeviceClass.CONNECTIVITY
+
     @property
     def name(self):
         """ GeoRide name """
@@ -248,7 +253,11 @@ class GeoRideMovingBinarySensorEntity(GeoRideBinarySensorEntity):
                  tracker_device: Device):
         """Set up Georide entity."""
         super().__init__(coordinator, tracker_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('moving')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        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):
@@ -265,11 +274,48 @@ class GeoRideMovingBinarySensorEntity(GeoRideBinarySensorEntity):
         """state value property"""
         return self._tracker_device.tracker.moving
     
+    @property
+    def device_class(self) -> str:
+        """device class"""
+        return BinarySensorDeviceClass.MOVING
+
     @property
     def name(self):
         """ GeoRide name """
         return f"{self._name} is moving"
 
+class GeoRideUpdatedBinarySensorEntity(GeoRideBinarySensorEntity):
+    """Represent a tracked device."""
+    @property
+    def entity_category(self):
+        return EntityCategory.DIAGNOSTIC
+
+    def __init__(self, coordinator: DataUpdateCoordinator[Mapping[str, Any]],
+                 tracker_device: Device):
+        """Set up Georide entity."""
+        super().__init__(coordinator, tracker_device)
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('update')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+
+    @property
+    def unique_id(self):
+        """Return the unique ID."""
+        return f"update_{self._tracker_device.tracker.tracker_id}"
+
+    @property
+    def is_on(self):
+        """state value property"""
+        return not self._tracker_device.tracker.is_up_to_date
+    
+    @property
+    def device_class(self) -> str:
+        """device class"""
+        return BinarySensorDeviceClass.UPDATE
+
+    @property
+    def name(self):
+        """ GeoRide name """
+        return f"{self._name} have an update"
+
 class GeoRideBeaconUpdatedBinarySensorEntity(GeoRideBeaconBinarySensorEntity):
     """Represent a tracked device."""
     @property
@@ -279,23 +325,23 @@ class GeoRideBeaconUpdatedBinarySensorEntity(GeoRideBeaconBinarySensorEntity):
     def __init__(self, coordinator: DataUpdateCoordinator[Mapping[str, Any]],
                  tracker_beacon_device: DeviceBeacon):
         """Set up Georide entity."""
-        super().__init__(coordinator, tracker_device)
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('update')}.{tracker_beacon_device.tracker_beacon.beacon_id}"# pylint: disable=C0301
+        super().__init__(coordinator, tracker_beacon_device)
+        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}"
-
-    @property
-    def device_class(self):
-        """Return the device class."""
-        return "update"
+        return f"update_{self._tracker_device_beacon.beacon.beacon_id}"
 
     @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 device_class(self) -> str:
+        """device class"""
+        return BinarySensorDeviceClass.UPDATE
 
     @property
     def name(self):

custom_components/georide/config_flow.py

@@ -12,7 +12,7 @@ from .const import CONF_EMAIL, CONF_PASSWORD, CONF_TOKEN, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-@config_entries.HANDLERS.register("georide")
+@config_entries.HANDLERS.register(DOMAIN)
 class GeoRideConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """GeoRide config flow """
     
@@ -37,8 +37,6 @@ class GeoRideConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
             vol.Required(CONF_PASSWORD): vol.All(str)
         }))
 
-
-
     async def async_step_georide_login(self, user_input):
         """ try to seupt GeoRide Account """
 

custom_components/georide/device.py

@@ -10,6 +10,7 @@ class Device:
         """Initialize GeoRideTracker device."""
         self._tracker: GeoRideTracker = tracker
         
+
     @property
     def tracker(self):
         """return the tracker"""
@@ -20,11 +21,26 @@ class Device:
         """Get the name."""
         return self._tracker.tracker_name
 
+    @property
+    def default_manufacturer(self) -> str:
+        """Get the default_manufacturer."""
+        return "GeoRide"
+
     @property
     def manufacturer(self) -> str:
         """Get the manufacturer."""
         return "GeoRide"
         
+    @property
+    def default_model(self) -> str:
+        """Get the default model."""
+        return "GeoRide 1"
+
+    @property
+    def suggested_area(self) -> str:
+        """Get the suggested_area."""
+        return "Garage"
+        
     @property
     def model_name(self) -> str:
         """Get the model name."""
@@ -34,28 +50,44 @@ class Device:
         elif self._tracker.version == 2:
             name = "GeoRide 2"
         elif self._tracker.version == 3:
+            if self._tracker.model == 'georide-3':
                 name = "GeoRide 3"
+            else if self._tracker.model == 'georide-3s':
+                name = "GeoRide 3S"
+            else:
+                name = "GeoRide Mini"
         else:
             name = "Prototype / Unknown"
         return name
     
+    @property
+    def sw_version(self) -> str:
+        """Get the software version."""
+        return str(self._tracker.software_version)
+
+    @property
+    def hw_version(self) -> str:
+        """Get the hardware version."""
+        return str(self._tracker.version)
+
+    @property
+    def unique_id(self) -> str:
+        """Get the unique id."""
+        return {(GEORIDE_DOMAIN, self._tracker.tracker_id)}
+
     @property
     def device_info(self):
         """Return the device info."""
         return {
             "name": self.name,
             "identifiers": self.unique_id,
-            "manufacturer": "GeoRide",
+            "manufacturer": self.manufacturer,
             "model": self.model_name,
-            "suggested_area": "Garage"
+            "suggested_area": self.suggested_area,
+            "sw_version" : self.sw_version,
+            "hw_version": self.hw_version
         }
 
-
-    @property
-    def unique_id(self) -> str:
-        """Get the unique id."""
-        return f"{GEORIDE_DOMAIN}_{self._tracker.tracker_id}"
-
     def __str__(self) -> str:
         """Get string representation."""
         return f"GeoRide Device: {self.name}::{self.model_name}::{self.unique_id}"
@@ -77,34 +109,54 @@ class DeviceBeacon:
         """Get the name."""
         return self._beacon.name
 
+    @property
+    def default_manufacturer(self) -> str:
+        """Get the default_manufacturer."""
+        return "GeoRide"
+
     @property
     def manufacturer(self) -> str:
         """Get the manufacturer."""
         return "GeoRide"
         
+    @property
+    def default_model(self) -> str:
+        """Get the default model."""
+        return "GeoRide Beacon"
+
+    @property
+    def suggested_area(self) -> str:
+        """Get the suggested_area."""
+        return "Garage"
+
     @property
     def model_name(self) -> str:
         """Get the model name."""
         name = "GeoRide Beacon"
         return name
 
+    @property
+    def unique_id(self) -> str:
+        """Get the unique id."""
+        return {(GEORIDE_DOMAIN, self._beacon.beacon_id)}
+
+    @property
+    def via_device(self) -> str:
+        """Get the unique id."""
+        return (GEORIDE_DOMAIN, self._beacon.linked_tracker_id )
+
     @property
     def device_info(self):
         """Return the device info."""
         return {
             "name": self.name,
             "identifiers": self.unique_id,
-            "manufacturer": "GeoRide",
+            "manufacturer": self.manufacturer,
             "model": self.model_name,
-            "suggested_area": "Garage"
+            "suggested_area": self.suggested_area,
+            "via_device": self.via_device
         }
 
-    @property
-    def unique_id(self) -> str:
-        """Get the unique id."""
-        
-        return f"{GEORIDE_DOMAIN}_beacon_{self._tracker.tracker_id}"
-
     def __str__(self) -> str:
         """Get string representation."""
         return f"GeoRide Device: {self.name}::{self.model_name}::{self.unique_id}"

custom_components/georide/device_tracker.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Any, Mapping
 
-from homeassistant.components.device_tracker.const import DOMAIN, SOURCE_TYPE_GPS
+from homeassistant.components.device_tracker.const import DOMAIN, SourceType
 from homeassistant.components.device_tracker.config_entry import TrackerEntity
 
 from homeassistant.helpers.update_coordinator import (
@@ -78,7 +78,7 @@ class GeoRideTrackerEntity(CoordinatorEntity, TrackerEntity):
     @property
     def source_type(self):
         """Return the source type, eg gps or router, of the device."""
-        return SOURCE_TYPE_GPS
+        return SourceType.GPS
 
     @property
     def location_accuracy(self):

custom_components/georide/manifest.json

@@ -6,10 +6,10 @@
   "issue_tracker": "https://github.com/ptimatth/GeorideHA/issues",
   "iot_class": "cloud_polling",
   "requirements": [
-    "georideapilib==0.8.1",
-    "pyjwt==2.1.0"
+    "georideapilib>=1.0.0",
+    "pyjwt>=2.2.0"
   ],
   "dependencies": [],
   "codeowners": ["ptimatth"],
-  "version": "0.9.0"
+  "version": "1.1.2"
 }

custom_components/georide/sensor.py

@@ -5,8 +5,7 @@ from typing import Any, Mapping
 
 from homeassistant.core import callback
 from homeassistant.helpers.entity import DeviceInfo, EntityCategory
-from homeassistant.components.sensor import SensorEntity
-from homeassistant.components.sensor import ENTITY_ID_FORMAT
+from homeassistant.components.sensor import SensorEntity, SensorDeviceClass, ENTITY_ID_FORMAT
 from homeassistant.helpers.update_coordinator import (
     CoordinatorEntity,
     DataUpdateCoordinator,
@@ -31,6 +30,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 +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']
-        coordinator = coordoned_tracker['coordinator']
-        entities.append(GeoRideBeaconUpdatedBinarySensorEntity(coordinator, tracker_beacon))
-        hass.data[GEORIDE_DOMAIN]["devices"][tracker_device.beacon.beacon_id] = coordinator
+        tracker_beacon = coordoned_beacon['tracker_beacon']
+        coordinator = coordoned_beacon['coordinator']
+        entities.append(GeoRideBeaconBatterySensorEntity(coordinator, tracker_beacon))
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker_beacon.beacon.beacon_id] = coordinator
 
     async_add_entities(entities)
 
@@ -57,7 +57,7 @@ class GeoRideOdometerSensorEntity(CoordinatorEntity, SensorEntity):
         self._tracker_device = tracker_device
         self._name = tracker_device.tracker.tracker_name
         self._unit_of_measurement = "m"
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('odometer')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('odometer')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
 
         self._state = 0
         self._hass = hass
@@ -69,7 +69,7 @@ class GeoRideOdometerSensorEntity(CoordinatorEntity, SensorEntity):
     @property
     def unique_id(self):
         """Return the unique ID."""
-        return f"odometer_{self._tracker_device.tracker.tracker_id}"
+        return f"odometer_{self._tracker_device.tracker.tracker_id}".lower()
 
     @property
     def state(self):
@@ -107,19 +107,14 @@ class GeoRideOdometerKmSensorEntity(CoordinatorEntity, SensorEntity):
         self._tracker_device = tracker_device
         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.entity_id = f"{ENTITY_ID_FORMAT.format('odometer_km')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
         self._state = 0
         self._hass = hass
 
-    @property
-    def entity_category(self):
-        return EntityCategory.DIAGNOSTIC
-
     @property
     def unique_id(self):
         """Return the unique ID."""
-        return f"odometer_km_{self._tracker_device.tracker.tracker_id}"
+        return f"odometer_km_{self._tracker_device.tracker.tracker_id}".lower()
 
     @property
     def state(self):
@@ -147,6 +142,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
@@ -158,9 +202,18 @@ class GeoRideInternalBatterySensorEntity(CoordinatorEntity, SensorEntity):
         self._tracker_device = tracker_device
         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.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):
@@ -191,6 +244,11 @@ class GeoRideInternalBatterySensorEntity(CoordinatorEntity, SensorEntity):
         """icon getter"""
         return "mdi:battery"
 
+    @property
+    def device_class(self) -> str:
+        """device class"""
+        return SensorDeviceClass.VOLTAGE
+
     @property
     def device_info(self) -> DeviceInfo:
         """Return the device info."""
@@ -206,8 +264,18 @@ class GeoRideExternalBatterySensorEntity(CoordinatorEntity, SensorEntity):
         self._tracker_device = tracker_device
         self._name = tracker_device.tracker.tracker_name
         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.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):
@@ -238,6 +306,11 @@ class GeoRideExternalBatterySensorEntity(CoordinatorEntity, SensorEntity):
         """icon getter"""
         return "mdi:battery"
 
+    @property
+    def device_class(self) -> str:
+        """device class"""
+        return SensorDeviceClass.VOLTAGE
+
     @property
     def device_info(self) -> DeviceInfo:
         """Return the device info."""
@@ -252,8 +325,7 @@ class GeoRideFixtimeSensorEntity(CoordinatorEntity, SensorEntity):
         super().__init__(coordinator)
         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.entity_id = f"{ENTITY_ID_FORMAT.format('fixtime')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
         self._state = 0
         self._device_class = "timestamp"
 
@@ -293,10 +365,10 @@ class GeoRideBeaconBatterySensorEntity(CoordinatorEntity, SensorEntity):
                  tracker_beacon: DeviceBeacon):
         """Set up GeoRide entity."""
         super().__init__(coordinator)
-        self._tracker_device = tracker_device
-        self._name = tracker_device.tracker.tracker_name
+        self._tracker_device = tracker_beacon
+        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.entity_id = f"{ENTITY_ID_FORMAT.format('battery_percent')}_{tracker_beacon.beacon.beacon_id}"# pylint: disable=C0301
         self._state = 0
 
     @property
@@ -328,6 +400,11 @@ class GeoRideBeaconBatterySensorEntity(CoordinatorEntity, SensorEntity):
         """icon getter"""
         return "mdi:battery"
 
+    @property
+    def device_class(self) -> str:
+        """device class"""
+        return SensorDeviceClass.BATTERY
+
     @property
     def device_info(self) -> DeviceInfo:
         """Return the device info."""

custom_components/georide/siren.py

@@ -17,7 +17,7 @@ import georideapilib.api as GeoRideApi
 from .const import DOMAIN as GEORIDE_DOMAIN
 from .device import Device
 
-ENTITY_ID_FORMAT: Final = GEORIDE_DOMAIN + ".{}"
+ENTITY_ID_FORMAT = GEORIDE_DOMAIN + ".{}"
 
 _LOGGER = logging.getLogger(__name__) 
 
@@ -31,11 +31,11 @@ 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))
 
-    await async_add_entities(entities)
+    async_add_entities(entities)
 
     return True
 
@@ -48,7 +48,7 @@ class GeoRideSirenEntity(CoordinatorEntity, SirenEntity):
         super().__init__(coordinator)
         self._tracker_device = tracker_device
         self._name = tracker_device.tracker.tracker_name
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('eco_mode')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('eco_mode')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
         self._hass = hass
 
     @property

custom_components/georide/switch.py

@@ -48,7 +48,7 @@ class GeoRideLockSwitchEntity(CoordinatorEntity, SwitchEntity):
         super().__init__(coordinator)
         self._tracker_device = tracker_device
         self._name = tracker_device.tracker.tracker_name
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('lock')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('lock')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
         self._hass = hass
 
     @property
@@ -120,7 +120,7 @@ class GeoRideEcoModeSwitchEntity(CoordinatorEntity, SwitchEntity):
         super().__init__(coordinator)
         self._tracker_device = tracker_device
         self._name = tracker_device.tracker.tracker_name
-        self.entity_id = f"{ENTITY_ID_FORMAT.format('eco_mode')}.{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
+        self.entity_id = f"{ENTITY_ID_FORMAT.format('eco_mode')}_{tracker_device.tracker.tracker_id}"# pylint: disable=C0301
         self._hass = hass
 
     @property

hacs.json

@@ -4,5 +4,5 @@
   "render_readme": true,
   "domains": ["devices_tracker", "sensor"],
   "country": ["FR"],
-  "homeassistant": "2022.2.0"
+  "homeassistant": "2024.11.0"
 }