Merge branch 'develop'

Fix setting login credentials using config_flow and fix mistakes in spelling

README.md

@@ -1,8 +1,32 @@
-# Georide Home assistant
-![Logo Georide](georide-logo.png)
+# GeoRide Home assistant
+![Logo GeoRide](https://brands.home-assistant.io/georide/logo.png)
 
-⚠️ this is not an official implementation
+⚠️ 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)
 
-Official georide website: https://georide.fr/
+Official GeoRide website: https://georide.fr/
+
+## Description
+This component add some sensor for GeoRide Tracker
 
 
+## Options
+
+| Name | Type | Requirement | `default` Description
+| ---- | ---- | ------- | -----------
+| email | string | **Required** | GeoRide email
+| password | string | **Required** | GeoRide password
+
+
+## Installation
+### Option 1
+- Just folow the integration config steps.
+
+### Option 2
+- Add the folowing line in your configuration.yml
+```yaml
+    georide:
+        email: <your-email>@exmple.com
+        password: <your-password>
+```

custom_components/georide/.translations/en.json

@@ -1,23 +0,0 @@
-{
-  "config": {
-    "title": "GeoRide",
-    "step": {
-      "user": {
-        "title": "Set up GeoRide",
-        "description": "Are you sure you want to set up GeoRide ?",
-        "data": {
-          "email": "email",
-          "password": "password"
-        }
-      }
-    },
-    "abort": {
-      "one_instance_allowed": "Only a single instance is allowed.",
-      "no_credential": "You need to add your credentails."
-
-    },
-    "create_entry": {
-      "default": "\n\nLogin succes"
-    }
-  }
-}

custom_components/georide/__init__.py

@@ -3,16 +3,18 @@ from collections import defaultdict
 
 import logging
 from datetime import timedelta
-import voluptuous as vol
+import math
+import time
 import json
-import jwt
 from threading import Thread
+import voluptuous as vol
+import jwt
 
 from aiohttp.web import json_response
-from georideapilib.objects import GeorideAccount
-import georideapilib.api as GeorideApi
-from georideapilib.socket import GeorideSocket
+from georideapilib.objects import GeorideAccount as GeoRideAccount
+import georideapilib.api as GeoRideApi
 
+from georideapilib.socket import GeorideSocket as GeoRideSocket
 
 from homeassistant import config_entries
 from homeassistant.const import CONF_WEBHOOK_ID
@@ -25,10 +27,13 @@ from homeassistant.setup import async_when_setup
 from .const import (
     CONF_EMAIL,
     CONF_PASSWORD,
-    TRACKER_ID
+    CONF_TOKEN,
+    TRACKER_ID,
+    TOKEN_SAFE_DAY,
+    MIN_UNTIL_REFRESH,
+    DOMAIN
 )
 
-DOMAIN = "georide"
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -45,89 +50,94 @@ CONFIG_SCHEMA = vol.Schema(
 
 
 async def async_setup(hass, config):
-    """Setup  Georide component."""
+    """Setup  GeoRide component."""
     hass.data[DOMAIN] = {"config": config[DOMAIN], "devices": {}, "unsub": None}
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": config_entries.SOURCE_IMPORT}, data={}
+    hass.async_create_task(
+        hass.config_entries.flow.async_init(
+            DOMAIN, 
+            context={
+                "source": config_entries.SOURCE_IMPORT
+            },
+            data={}
+        )
     )
-
-    _LOGGER.info("Georide-setup success: %s", result)
 
     # Return boolean to indicate that initialization was successful.
     return True
 
 
-def connect_socket(hass, component):
-    """subscribe to georide socket"""
-    context = hass.data[DOMAIN]["context"]
-
-    socket = GeorideSocket()
-    socket.subscribe_locked(context.on_lock_callback)
-    socket.subscribe_device(context.on_device_callback)
-    socket.subscribe_position(context.on_position_callback)
-
-    socket.init()
-    socket.connect(context.async_get_token())
-
-
 async def async_setup_entry(hass, entry):
-    """Set up Georide entry."""
+    """Set up GeoRide entry."""
     config = hass.data[DOMAIN]["config"]
     email = config.get(CONF_EMAIL) or entry.data[CONF_EMAIL]
     password = config.get(CONF_PASSWORD) or entry.data[CONF_PASSWORD]
-
-    if email is None or password is None:
-        return False
-    try:
-        account = GeorideApi.get_authorisation_token(email, password)
-        context = GeorideContext(
+    token = config.get(CONF_TOKEN) or entry.data[CONF_TOKEN]
+    context = GeoRideContext(
         hass,
         email,
         password,
-            account.auth_token
+        token
     )
     
+    _LOGGER.info("Context-setup and start the thread")
+    _LOGGER.info("Thread started")
 
     hass.data[DOMAIN]["context"] = context
 
     # We add trackers to the context
-        trackers = GeorideApi.get_trackers(account.auth_token)
-        context.georide_trackers = trackers
+    context.refresh_trackers()
 
     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"))
 
-        thread = Thread(target=connect_socket, args=(hass, entry))
-        thread.start()
-    except:
-        return False
     return True
 
+
 async def async_unload_entry(hass, entry):
-    """Unload an Georide config entry."""
+    """Unload an GeoRide config entry."""
 
     await hass.config_entries.async_forward_entry_unload(entry, "device_tracker")
     await hass.config_entries.async_forward_entry_unload(entry, "switch")
+    await hass.config_entries.async_forward_entry_unload(entry, "sensor")
+
+    context = hass.data[DOMAIN]["context"]
+    context.socket.disconnect()
 
     hass.data[DOMAIN]["unsub"]()
 
     return True
 
+def connect_socket(context):
+    """subscribe to GeoRide socket"""
+    _LOGGER.info("GeoRide socket connexion")
+    socket = GeoRideSocket()
+    socket.subscribe_locked(context.on_lock_callback)
+    socket.subscribe_device(context.on_device_callback)
+    socket.subscribe_position(context.on_position_callback)
 
-class GeorideContext:
-    """Hold the current Georide context."""
+    context.socket = socket
+
+    socket.init()
+    socket.connect(context.get_token())
+
+
+class GeoRideContext:
+    """Hold the current GeoRide context."""
 
     def __init__(self, hass, email, password, token):
-        """Initialize an Georide context."""
+        """Initialize an GeoRide context."""
         self._hass = hass
         self._email = email
         self._password = password
         self._georide_trackers = defaultdict(set)
         self._token = token
-        self._pending_msg = []
-
+        self._socket = None
+        self._thread_started = False
+        self._previous_refresh = math.floor(time.time()/60)
     @property
     def hass(self):
         """ hass """
@@ -150,35 +160,65 @@ class GeorideContext:
 
     @property
     def georide_trackers(self):
-        """ georide tracker list """
+        """ GeoRide tracker list """
         return self._georide_trackers
 
     @georide_trackers.setter
     def georide_trackers(self, trackers):
-        """ georide tracker list """
+        """ GeoRide tracker list """
         self._georide_trackers = trackers    
 
-    @callback
-    def async_get_token(self):
-        """ here we return the current valid tocken, TODO: add here token expiration control"""
+    def get_token(self):
+        """ here we return the current valid tocken """
         jwt_data = jwt.decode(self._token, verify=False)
         exp_timestamp = jwt_data['exp']
+
+        epoch = math.ceil(time.time())
+        if (exp_timestamp - TOKEN_SAFE_DAY) < epoch:
+            _LOGGER.info("Time reached, renew token")
+            account = GeoRideApi.get_authorisation_token(self._email, self._password)
+            config = self._hass.data[DOMAIN]["config"]
+            config[CONF_TOKEN] = account.auth_token
+            self._token = account.auth_token
+
+
         _LOGGER.info("Token exp data: %s", exp_timestamp)
         return self._token
 
-    @callback
-    def async_get_tracker(self, tracker_id):
+    def get_tracker(self, tracker_id):
         """ here we return last tracker by id"""
+        epoch_min = math.floor(time.time()/60)
+        if (epoch_min % MIN_UNTIL_REFRESH) == 0:
+            if epoch_min != self._previous_refresh:
+                self._previous_refresh = epoch_min
+                self.refresh_trackers()
+
+        if not self._thread_started:
+            _LOGGER.info("Start the thread")
+            self._hass.async_add_executor_job(connect_socket, self)
+            # We refresh the tracker list each hours
+            self._thread_started = True
+
         for tracker in self._georide_trackers:
             if tracker.tracker_id == tracker_id:
                 return tracker
         return None
 
-    @callback
-    def async_see(self, **data):
-        """Send a see message to the device tracker."""
-        _LOGGER.info("sync_see")
-        self._pending_msg.append(data)
+    def refresh_trackers(self):
+        """Used to refresh the tracker list"""
+        _LOGGER.info("Tracker list refresh")
+        self._georide_trackers = GeoRideApi.get_trackers(self.get_token())
+
+
+    @property
+    def socket(self):
+        """ hold the GeoRide socket """
+        return self._socket
+    
+    @socket.setter
+    def socket(self, socket):
+        """set the GeoRide socket"""
+        self._socket = socket
 
     @callback
     def on_lock_callback(self, data):

custom_components/georide/config_flow.py

@@ -3,58 +3,70 @@
 import logging
 from homeassistant import config_entries
 import voluptuous as vol
+import georideapilib.api as GeoRideApi
+import georideapilib.exception as GeoRideException
 
 
-from .const import CONF_EMAIL, CONF_PASSWORD
+from .const import CONF_EMAIL, CONF_PASSWORD, CONF_TOKEN
 
 
 _LOGGER = logging.getLogger(__name__)
 
 @config_entries.HANDLERS.register("georide")
-class GeorideConfigFlow(config_entries.ConfigFlow):
-    """Georide config flow """
+class GeoRideConfigFlow(config_entries.ConfigFlow):
+    """GeoRide config flow """
     
-    async def async_step_user(self, user_input=None):
-        """ handle info to help to configure georide """
+    async def async_step_user(self, user_input=None): #pylint: disable=W0613
+        """ handle info to help to configure GeoRide """
 
         if self._async_current_entries():
             return self.async_abort(reason="one_instance_allowed")
 
-        if user_input is None:
-            return self.async_show_form(step_id='user', data_schema=vol.Schema({
+        return self.async_show_form(step_id='georide_login', data_schema=vol.Schema({
             vol.Required(CONF_EMAIL): vol.All(str, vol.Length(min=3)),
             vol.Required(CONF_PASSWORD): vol.All(str)
         }))
 
-        return self.async_create_entry(
-            title=user_input[CONF_EMAIL],
-            data={
-                CONF_EMAIL: user_input[CONF_EMAIL],
-                CONF_PASSWORD: user_input[CONF_PASSWORD]            
-            }
-        )
-
-
-
-    async def async_step_import(self, user_input):
+    async def async_step_import(self, user_input=None): #pylint: disable=W0613
         """Import a config flow from configuration."""
-
-        _LOGGER.info("user email: %", str(user_input))
-
         if self._async_current_entries():
             return self.async_abort(reason="one_instance_allowed")
 
-        if user_input is None:
-            return self.async_show_form(step_id='user', data_schema=vol.Schema({
+        return self.async_show_form(step_id='georide_login', data_schema=vol.Schema({
             vol.Required(CONF_EMAIL): vol.All(str, vol.Length(min=3)),
             vol.Required(CONF_PASSWORD): vol.All(str)
         }))
 
-        return self.async_create_entry(
-            title=user_input,
-            data={
-                CONF_EMAIL: user_input[CONF_EMAIL],
-                CONF_PASSWORD: user_input[CONF_PASSWORD]            
-            }
-        )
+
+
+    async def async_step_georide_login(self, user_input):
+        """ try to seupt GeoRide Account """
+
+        schema = vol.Schema({
+            vol.Required(CONF_EMAIL): vol.All(str, vol.Length(min=3)),
+            vol.Required(CONF_PASSWORD): vol.All(str)
+        })
+        
+        if user_input is None:
+            return self.async_show_form(step_id='georide_login', data_schema=schema)
+        
+        email = user_input[CONF_EMAIL]
+        password = user_input[CONF_PASSWORD]
+        
+        try:
+            account = GeoRideApi.get_authorisation_token(email, password)
+            data = {
+                CONF_EMAIL: email,
+                CONF_PASSWORD: password,
+                CONF_TOKEN: account.auth_token
+            }
+            return self.async_create_entry(title=email, data=data)
+        except (GeoRideException.SeverException, GeoRideException.LoginException):
+            _LOGGER.error("Invalid credentials provided, config not created")
+            errors = {"base":  "faulty_credentials"}
+            return self.async_show_form(step_id="georide_login", data_schema=schema, errors=errors)
+        except: 
+            _LOGGER.error("Unknown error")
+            errors = {"base": "unkonwn"}
+            return self.async_show_form(step_id="georide_login", data_schema=schema, errors=errors)
         

custom_components/georide/const.py

@@ -1,4 +1,5 @@
-""" Georide const file """
+""" GeoRide const file """
+DOMAIN = "georide"
 
 CONF_EMAIL = "email"
 CONF_PASSWORD = "password"
@@ -6,3 +7,7 @@ CONF_PASSWORD = "password"
 CONF_TOKEN = "token"
 
 TRACKER_ID = "trackerId"
+
+MIN_UNTIL_REFRESH = 10
+
+TOKEN_SAFE_DAY = 432000 # five days

custom_components/georide/device_tracker.py

@@ -1,14 +1,13 @@
-""" device tracker for Georide object """
+""" device tracker for GeoRide object """
 
 import logging
 
-from homeassistant.core import callback
-from homeassistant.components.device_tracker.const import ENTITY_ID_FORMAT, SOURCE_TYPE_GPS
+from homeassistant.components.device_tracker.const import DOMAIN, SOURCE_TYPE_GPS
 from homeassistant.components.device_tracker.config_entry import TrackerEntity
 
-import georideapilib.api as GeorideApi
+import georideapilib.api as GeoRideApi
 
-from . import DOMAIN as GEORIDE_DOMAIN
+from .const import DOMAIN as GEORIDE_DOMAIN
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -18,19 +17,19 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
 
     georide_context = hass.data[GEORIDE_DOMAIN]["context"]
         
-    if georide_context.token is None:
+    if georide_context.get_token() is None:
         return False
 
-    _LOGGER.info('Current georide token: %s', georide_context.async_get_token())
+    _LOGGER.debug('Current GeoRide token: %s', georide_context.get_token())
 
         
-    trackers = GeorideApi.get_trackers(georide_context.async_get_token())
+    trackers = GeoRideApi.get_trackers(georide_context.get_token())
 
     
     tracker_entities = []
     for tracker in trackers:
-        entity = GeorideTrackerEntity(tracker.tracker_id, georide_context.async_get_token,
-                                      georide_context.async_get_tracker, tracker)
+        entity = GeoRideTrackerEntity(tracker.tracker_id, georide_context.get_token,
+                                      georide_context.get_tracker, tracker)
 
 
         hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = entity
@@ -41,17 +40,17 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
     return True
 
 
-class GeorideTrackerEntity(TrackerEntity):
+class GeoRideTrackerEntity(TrackerEntity):
     """Represent a tracked device."""
 
     def __init__(self, tracker_id, get_token_callback, get_tracker_callback, tracker):
-        """Set up Georide entity."""
+        """Set up GeoRide entity."""
         self._tracker_id = tracker_id
         self._get_token_callback = get_token_callback
         self._get_tracker_callback = get_tracker_callback
         self._name = tracker.tracker_name
         self._data = tracker or {}
-        self.entity_id = ENTITY_ID_FORMAT.format(tracker_id)
+        self.entity_id = DOMAIN + ".{}".format(tracker_id)
 
     @property
     def unique_id(self):
@@ -89,6 +88,7 @@ class GeorideTrackerEntity(TrackerEntity):
 
     @property
     def icon(self):
+        """return the entity icon"""
         return "mdi:map-marker"
     
 
@@ -118,10 +118,9 @@ class GeorideTrackerEntity(TrackerEntity):
         """No polling needed."""
         return True
 
-    async def async_update(self):
+    def update(self):
         """ update the current tracker"""
-        _LOGGER.info('async_update ')
+        _LOGGER.info('update')
         self._data = self._get_tracker_callback(self._tracker_id)
         self._name = self._data.tracker_name
-        return
         

custom_components/georide/manifest.json

@@ -1,12 +1,12 @@
 {
   "domain": "georide",
-  "name": "Georide",
+  "name": "GeoRide",
   "config_flow": true,
-  "documentation": "https://git.tontontux.fr/mduval/GeorideHA",
+  "documentation": "https://github.com/ptimatth/GeorideHA",
   "requirements": [
-    "georideapilib>=0.4.1",
+    "georideapilib>=0.4.4",
     "pyjwt>=1.7.1"
   ],
   "dependencies": [],
-  "codeowners": ["@ptimatth"]
+  "codeowners": ["ptimatth"]
 }

custom_components/georide/sensor.py

@@ -0,0 +1,102 @@
+""" odometter sensor for GeoRide object """
+
+import logging
+
+from homeassistant.core import callback
+from homeassistant.components.switch import SwitchEntity
+from homeassistant.components.switch import ENTITY_ID_FORMAT
+
+import georideapilib.api as GeoRideApi
+
+from .const import DOMAIN as GEORIDE_DOMAIN
+
+
+_LOGGER = logging.getLogger(__name__) 
+
+
+async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: disable=W0613
+    """Set up GeoRide tracker based off an entry."""
+    georide_context = hass.data[GEORIDE_DOMAIN]["context"]      
+
+    if georide_context.get_token() is None:
+        return False
+
+    trackers = GeoRideApi.get_trackers(georide_context.get_token())
+
+    odometer_switch_entities = []
+    for tracker in trackers:
+        entity = GeoRideOdometerSensorEntity(tracker.tracker_id, georide_context.get_token,
+                                             georide_context.get_tracker, data=tracker)
+        hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = entity
+        odometer_switch_entities.append(entity)
+
+    async_add_entities(odometer_switch_entities)
+
+    return True
+
+class GeoRideOdometerSensorEntity(SwitchEntity):
+    """Represent a tracked device."""
+
+    def __init__(self, tracker_id, get_token_callback, get_tracker_callback, data):
+        """Set up Georide entity."""
+        self._tracker_id = tracker_id
+        self._data = data or {}
+        self._get_token_callback = get_token_callback
+        self._get_tracker_callback = get_tracker_callback
+        self._name = data.tracker_name
+        self._unit_of_measurement = "m"
+
+        self.entity_id = ENTITY_ID_FORMAT.format("odometer") + "." + str(tracker_id)
+        self._state = 0
+
+
+    def update(self):
+        """ update the current tracker"""
+        _LOGGER.info('update')
+        self._data = self._get_tracker_callback(self._tracker_id)
+        self._name = self._data.tracker_name
+        self._state = self._data.odometer
+
+    @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 unit_of_measurement(self):
+        return self._unit_of_measurement
+    
+    @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 icon(self):
+        return "mdi:counter"
+    
+
+    @property
+    def device_info(self):
+        """Return the device info."""
+        return {
+            "name": self.name,
+            "identifiers": {(GEORIDE_DOMAIN, self._tracker_id)},
+            "manufacturer": "GeoRide"
+        }
+
+

custom_components/georide/strings.json

@@ -2,19 +2,21 @@
   "config": {
     "title": "GeoRide",
     "step": {
-      "user": {
+      "georide_login": {
         "title": "Set up GeoRide",
-        "description": "Are you sure you want to set up GeoRide ?",
+        "description": "Sign-in to GeoRide",
         "data": {
           "email": "email",
           "password": "password"
         }
       }
     },
+    "error": {
+      "faulty_credentials": "Authorization failed",
+      "unknown": "Unknown error"
+    },
     "abort": {
-      "one_instance_allowed": "Only a single instance is allowed.",
-      "no_credential": "You need to add your credentails."
-
+      "one_instance_allowed": "Only a single instance is allowed."
     },
     "create_entry": {
       "default": "\n\nLogin succes"

custom_components/georide/switch.py

@@ -1,34 +1,34 @@
-""" device tracker for Georide object """
+""" device tracker for GeoRide object """
 
 import logging
 
 from homeassistant.core import callback
-from homeassistant.components.switch import SwitchDevice
+from homeassistant.components.switch import SwitchEntity
 from homeassistant.components.switch import ENTITY_ID_FORMAT
 
-import georideapilib.api as GeorideApi
+import georideapilib.api as GeoRideApi
 
-from . import DOMAIN as GEORIDE_DOMAIN
+from .const import DOMAIN as GEORIDE_DOMAIN
 
 
 _LOGGER = logging.getLogger(__name__) 
 
 
 async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: disable=W0613
-    """Set up Georide tracker based off an entry."""
+    """Set up GeoRide tracker based off an entry."""
     georide_context = hass.data[GEORIDE_DOMAIN]["context"]      
 
-    if georide_context.async_get_token() is None:
+    if georide_context.get_token() is None:
         return False
 
 
-    _LOGGER.info('Current georide token: %s', georide_context.async_get_token())    
-    trackers = GeorideApi.get_trackers(georide_context.async_get_token())
+    _LOGGER.info('Current georide token: %s', georide_context.get_token())    
+    trackers = GeoRideApi.get_trackers(georide_context.get_token())
 
     lock_switch_entities = []
     for tracker in trackers:
-        entity = GeorideLockSwitchEntity(tracker.tracker_id, georide_context.async_get_token,
-                                         georide_context.async_get_tracker, data=tracker)
+        entity = GeoRideLockSwitchEntity(tracker.tracker_id, georide_context.get_token,
+                                         georide_context.get_tracker, data=tracker)
         hass.data[GEORIDE_DOMAIN]["devices"][tracker.tracker_id] = entity
         lock_switch_entities.append(entity)
 
@@ -38,33 +38,33 @@ async def async_setup_entry(hass, config_entry, async_add_entities): # pylint: d
 
 
 
-class GeorideLockSwitchEntity(SwitchDevice):
+class GeoRideLockSwitchEntity(SwitchEntity):
     """Represent a tracked device."""
 
     def __init__(self, tracker_id, get_token_callback, get_tracker_callback, data):
-        """Set up Georide entity."""
+        """Set up GeoRide entity."""
         self._tracker_id = tracker_id
         self._data = data or {}
         self._get_token_callback = get_token_callback
         self._get_tracker_callback = get_tracker_callback
         self._name = data.tracker_name
         self._is_on = data.is_locked
-        self.entity_id = ENTITY_ID_FORMAT.format("lock."+str(tracker_id))
+        self.entity_id = ENTITY_ID_FORMAT.format("lock") +"." + str(tracker_id)
         self._state = {}
 
 
     def turn_on(self, **kwargs):
-        """ lock the georide tracker """
+        """ lock the GeoRide tracker """
         _LOGGER.info('async_turn_on %s', kwargs)
-        success = GeorideApi.lock_tracker(self._get_token_callback(), self._tracker_id)
+        success = GeoRideApi.lock_tracker(self._get_token_callback(), self._tracker_id)
         if success:
             self._data.is_locked = True
             self._is_on = True
             
     def turn_off(self, **kwargs):
-        """ unlock the georide tracker """
+        """ unlock the GeoRide tracker """
         _LOGGER.info('async_turn_off %s', kwargs)
-        success = GeorideApi.unlock_tracker(self._get_token_callback(), self._tracker_id)
+        success = GeoRideApi.unlock_tracker(self._get_token_callback(), self._tracker_id)
         if success:
             self._data.is_locked = False
             self._is_on = False
@@ -72,7 +72,7 @@ class GeorideLockSwitchEntity(SwitchDevice):
     async def async_toggle(self, **kwargs):
         """ toggle lock the georide tracker """
         _LOGGER.info('async_toggle %s', kwargs)
-        result = GeorideApi.toogle_lock_tracker(self._get_token_callback(),
+        result = GeoRideApi.toogle_lock_tracker(self._get_token_callback(),
                                                 self._tracker_id)
         self._data.is_locked = result
         self._is_on = result     
@@ -80,7 +80,7 @@ class GeorideLockSwitchEntity(SwitchDevice):
 
     def update(self):
         """ update the current tracker"""
-        _LOGGER.info('async_update ')
+        _LOGGER.info('update')
         self._data = self._get_tracker_callback(self._tracker_id)
         self._name = self._data.tracker_name
         self._is_on = self._data.is_locked
@@ -92,26 +92,27 @@ class GeorideLockSwitchEntity(SwitchDevice):
 
     @property
     def name(self):
-        """ Georide switch name """
+        """ GeoRide switch name """
         return self._name
     
     @property
     def is_on(self):
-        """ Georide switch status """
+        """ GeoRide switch status """
         return self._is_on
     
     @property
     def get_token_callback(self):
-        """ Georide switch token callback method """
+        """ GeoRide switch token callback method """
         return self._get_token_callback
     
     @property
     def get_tracker_callback(self):
-        """ Georide switch token callback method """
+        """ GeoRide switch token callback method """
         return self._get_tracker_callback
 
     @property
     def icon(self):
+        """return the entity icon"""
         if self._is_on:
             return "mdi:lock"
         return "mdi:lock-open"

custom_components/georide/translations/en.json

@@ -0,0 +1,25 @@
+{
+  "config": {
+    "title": "GeoRide",
+    "step": {
+      "georide_login": {
+        "title": "Set up GeoRide",
+        "description": "Sign-in to GeoRide",
+        "data": {
+          "email": "email",
+          "password": "password"
+        }
+      }
+    },
+    "error": {
+      "faulty_credentials": "Authorization failed",
+      "unknown": "Unknown error"
+    },
+    "abort": {
+      "one_instance_allowed": "Only one instance is allowed."
+    },
+    "create_entry": {
+      "default": "\n\nLogin success"
+    }
+  }
+}

custom_components/georide/translations/fr.json

@@ -0,0 +1,25 @@
+{
+  "config": {
+    "title": "GeoRide",
+    "step": {
+      "georide_login": {
+        "title": "Configuration de GeoRide",
+        "description": "T'es un motard ! V",
+        "data": {
+          "email": "email",
+          "password": "password"
+        }
+      }
+    },
+    "error": {
+      "faulty_credentials": "Connexion \u00e9chou\u00e9e",
+      "unkonwn": "Erreur inconnue"
+    },
+    "abort": {
+      "one_instance_allowed": "Seulement une instance est autoris\u00e9e"
+    },
+    "create_entry": {
+      "default": "\n\nConnexion r\u00e9ussie !"
+    }
+  }
+}

hacs.json

@@ -1,7 +1,8 @@
 {
-  "name": "Georide integration",
+  "name": "GeoRide integration",
   "content_in_root": false,
   "render_readme": true,
   "domains": ["devices_tracker", "sensor"],
-  "country": ["FR"]
+  "country": ["FR"],
+  "homeassistant": "0.110.0"
 }