Shipping v0.2.0

custom_components/georide/__init__.py

@@ -4,11 +4,14 @@ from collections import defaultdict
 import logging
 from datetime import timedelta
 import voluptuous as vol
-
+import json
+import jwt
+from threading import Thread
 
 from aiohttp.web import json_response
 from georideapilib.objects import GeorideAccount
 import georideapilib.api as GeorideApi
+from georideapilib.socket import GeorideSocket
 
 
 from homeassistant import config_entries
@@ -44,68 +47,67 @@ CONFIG_SCHEMA = vol.Schema(
 async def async_setup(hass, config):
     """Setup  Georide component."""
     hass.data[DOMAIN] = {"config": config[DOMAIN], "devices": {}, "unsub": None}
-    hass.async_create_task(
+    result = await hass.config_entries.flow.async_init(
-        hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_IMPORT}, data={}
-            DOMAIN, context={"source": config_entries.SOURCE_IMPORT}, data={}
-        )
     )
 
-    _LOGGER.info("Georide-setup ")
+    _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."""
-
-    def georide_update(event):
-        """Update tracker info"""
-        nonlocal hass
-        _LOGGER.info('Georide update event %s', event)
-        georide_context = hass.data[DOMAIN]["context"]
-        token = georide_context.async_get_token()
-        trackers = GeorideApi.get_trackers(token)
-        georide_context.georide_trackers = trackers
-
-    ha_event.async_track_time_interval(hass, georide_update, timedelta(seconds=30))
-
-
-
-
-
     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)
+        account = GeorideApi.get_authorisation_token(email, password)
-    context = GeorideContext(
+        context = GeorideContext(
-        hass,
+            hass,
-        email,
+            email,
-        password,
+            password,
-        account.auth_token
+            account.auth_token
-    )
+        )
 
 
-    hass.data[DOMAIN]["context"] = context
+        hass.data[DOMAIN]["context"] = context
-
-    # We add trackers to the context
-    trackers = GeorideApi.get_trackers(account.auth_token)
-    context.georide_trackers = 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"))
 
+        # We add trackers to the context
+        trackers = GeorideApi.get_trackers(account.auth_token)
+        context.georide_trackers = 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"))
 
+        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."""
+
     await hass.config_entries.async_forward_entry_unload(entry, "device_tracker")
     await hass.config_entries.async_forward_entry_unload(entry, "switch")
 
@@ -159,11 +161,14 @@ class GeorideContext:
     @callback
     def async_get_token(self):
         """ here we return the current valid tocken, TODO: add here token expiration control"""
+        jwt_data = jwt.decode(self._token, verify=False)
+        exp_timestamp = jwt_data['exp']
+        _LOGGER.info("Token exp data: %s", exp_timestamp)
         return self._token
 
     @callback
     def async_get_tracker(self, tracker_id):
-        """ here we return the current valid tocken, TODO: add here token expiration control"""
+        """ here we return last tracker by id"""
         for tracker in self._georide_trackers:
             if tracker.tracker_id == tracker_id:
                 return tracker
@@ -174,3 +179,39 @@ class GeorideContext:
         """Send a see message to the device tracker."""
         _LOGGER.info("sync_see")
         self._pending_msg.append(data)
+
+    @callback
+    def on_lock_callback(self, data):
+        """on lock callback"""
+        _LOGGER.info("On lock received")
+        for tracker in self._georide_trackers:
+            if tracker.tracker_id == data['trackerId']:
+                tracker.locked_latitude = data['lockedLatitude']
+                tracker.locked_longitude = data['lockedLongitude']
+                tracker.is_locked = data['isLocked']
+                return
+
+    @callback
+    def on_device_callback(self, data):
+        """on device callback"""
+        _LOGGER.info("On device received")
+        for tracker in self._georide_trackers:
+            if tracker.tracker_id == data['trackerId']:
+                tracker.status = data['status']
+                return
+
+    @callback
+    def on_position_callback(self, data):
+        """on position callback"""
+        _LOGGER.info("On position received")
+        for tracker in self._georide_trackers:
+            if tracker.tracker_id == data['trackerId']:
+                tracker.latitude = data['latitude']
+                tracker.longitude = data['longitude']
+                tracker.moving = data['moving']
+                tracker.speed = data['speed']
+                tracker.fixtime = data['fixtime']
+                return
+
+
+

custom_components/georide/manifest.json

@@ -4,7 +4,8 @@
   "config_flow": true,
   "documentation": "https://git.tontontux.fr/mduval/GeorideHA",
   "requirements": [
-    "georideapilib>=0.2.0"
+    "georideapilib>=0.4.1",
+    "pyjwt>=1.7.1"
   ],
   "dependencies": [],
   "codeowners": ["@ptimatth"]

custom_components/georide/switch.py

@@ -53,39 +53,37 @@ class GeorideLockSwitchEntity(SwitchDevice):
         self._state = {}
 
 
-    async def async_turn_on(self, **kwargs):
+    def turn_on(self, **kwargs):
         """ lock the georide tracker """
         _LOGGER.info('async_turn_on %s', kwargs)
         success = GeorideApi.lock_tracker(self._get_token_callback(), self._tracker_id)
         if success:
+            self._data.is_locked = True
             self._is_on = True
             
-    async def async_turn_off(self, **kwargs):
+    def turn_off(self, **kwargs):
         """ unlock the georide tracker """
         _LOGGER.info('async_turn_off %s', kwargs)
         success = GeorideApi.unlock_tracker(self._get_token_callback(), self._tracker_id)
         if success:
+            self._data.is_locked = False
             self._is_on = False
 
     async def async_toggle(self, **kwargs):
         """ toggle lock the georide tracker """
         _LOGGER.info('async_toggle %s', kwargs)
-        self._is_on = GeorideApi.toogle_lock_tracker(self._get_token_callback(),
+        result = GeorideApi.toogle_lock_tracker(self._get_token_callback(),
-                                                     self._tracker_id)
+                                                self._tracker_id)
+        self._data.is_locked = result
+        self._is_on = result     
 
 
-    @property
+    def update(self):
-    def should_poll(self):
-        """No polling needed."""
-        return True
-
-    async def async_update(self):
         """ update the current tracker"""
         _LOGGER.info('async_update ')
         self._data = self._get_tracker_callback(self._tracker_id)
         self._name = self._data.tracker_name
         self._is_on = self._data.is_locked
-        return
 
     @property
     def unique_id(self):