carconnectivity-connector-skoda 0.1a2__py3-none-any.whl → 0.1a3__py3-none-any.whl

{carconnectivity_connector_skoda-0.1a2.dist-info → carconnectivity_connector_skoda-0.1a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: carconnectivity-connector-skoda
-Version: 0.1a2
+Version: 0.1a3
 Summary: CarConnectivity connector for Skoda services
 Author: Till Steinbach
 License: MIT License
@@ -40,6 +40,7 @@ License-File: LICENSE
 Requires-Dist: carconnectivity
 Requires-Dist: oauthlib~=3.2.2
 Requires-Dist: requests~=2.32.3
+Requires-Dist: jwt~=1.3.1
 
 
 

{carconnectivity_connector_skoda-0.1a2.dist-info → carconnectivity_connector_skoda-0.1a3.dist-info}/RECORD

@@ -1,17 +1,18 @@
 carconnectivity_connectors/skoda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carconnectivity_connectors/skoda/_version.py,sha256=X9LJfZydf4q-ykKMGj930R5S5i9bmNUrA30KznqYx0A,408
+carconnectivity_connectors/skoda/_version.py,sha256=MxrCYTTCC48jBbLpi48mgHtAaKA57W1ry3ksdEQnH64,408
 carconnectivity_connectors/skoda/capability.py,sha256=JlNEaisVYF8qWv0wNDHTaas36uIpTIQ3NVR69wesiYQ,4513
-carconnectivity_connectors/skoda/connector.py,sha256=kPW0NOBBQVGAgSGW3-DIttFfPn5-87VgR4cpwW5L5ok,40493
+carconnectivity_connectors/skoda/connector.py,sha256=UT4C3xlLMs5m245_LrMKAcnyKLmYKoIPvWj9Ln_HUzY,42728
+carconnectivity_connectors/skoda/mqtt_client.py,sha256=zpfE5MGC6iLm1uLiLyVKo50Dw39-LVW5b7pdc8tavhk,18276
 carconnectivity_connectors/skoda/vehicle.py,sha256=H3GRDNimMghFwFi--y9BsgoSK3pMibNf_l6SsDN6gvQ,2759
 carconnectivity_connectors/skoda/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 carconnectivity_connectors/skoda/auth/auth_util.py,sha256=dGLUbUre0HBsTg_Ii5vW34f8DLrCykYJYCyzEvUBBEE,4434
-carconnectivity_connectors/skoda/auth/my_skoda_session.py,sha256=UhCHpJqrTPa81Y2eQlWevr8NKRse207cboF7zqyH30w,10205
-carconnectivity_connectors/skoda/auth/openid_session.py,sha256=U4LucKWNDZtPtWfiKV7mdSI4y_s5lTNzt6QZT_lZka4,15886
-carconnectivity_connectors/skoda/auth/session_manager.py,sha256=Kk2QoN7IeqBhkWlvIX_1SKMZuFn9VXwtEO2Yxj2uDaA,2807
+carconnectivity_connectors/skoda/auth/my_skoda_session.py,sha256=sKO73OjQzvZ70n0VLBj2vxkuLYiXabS11fh2XvvboGw,10306
+carconnectivity_connectors/skoda/auth/openid_session.py,sha256=PLWSSKw9Dg7hBbhzJ_nEycNrqiG6GiEM15h2wduL8jI,16592
+carconnectivity_connectors/skoda/auth/session_manager.py,sha256=Uf1vujuDBYUCAXhYToOsZkgbTtfmY3Qe0ICTfwomBpI,2899
 carconnectivity_connectors/skoda/auth/skoda_web_session.py,sha256=cjzMkzx473Sh-4RgZAQULeRRcxB1MboddldCVM_y5LE,10640
 carconnectivity_connectors/skoda/auth/helpers/blacklist_retry.py,sha256=f3wsiY5bpHDBxp7Va1Mv9nKJ4u3qnCHZZmDu78_AhMk,1251
-carconnectivity_connector_skoda-0.1a2.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
-carconnectivity_connector_skoda-0.1a2.dist-info/METADATA,sha256=styXXYFCvHsk0E88oeLCXrFs_wqtfSviOH4E6_-hO9Q,5300
-carconnectivity_connector_skoda-0.1a2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-carconnectivity_connector_skoda-0.1a2.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
-carconnectivity_connector_skoda-0.1a2.dist-info/RECORD,,
+carconnectivity_connector_skoda-0.1a3.dist-info/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_connector_skoda-0.1a3.dist-info/METADATA,sha256=MN054LLlHhhTqKeBoJATkbvGIaRtpr6JRyY7RuZDV3c,5326
+carconnectivity_connector_skoda-0.1a3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+carconnectivity_connector_skoda-0.1a3.dist-info/top_level.txt,sha256=KqA8GviZsDH4PtmnwSQsz0HB_w-TWkeEHLIRNo5dTaI,27
+carconnectivity_connector_skoda-0.1a3.dist-info/RECORD,,

carconnectivity_connectors/skoda/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1a2'
+__version__ = version = '0.1a3'
 __version_tuple__ = version_tuple = (0, 1)

carconnectivity_connectors/skoda/auth/my_skoda_session.py

@@ -26,10 +26,10 @@ from carconnectivity_connectors.skoda.auth.openid_session import AccessType
 from carconnectivity_connectors.skoda.auth.skoda_web_session import SkodaWebSession
 
 if TYPE_CHECKING:
-    from typing import Tuple, Dict
+    from typing import Set
 
 
-LOG: logging.Logger = logging.getLogger("carconnectivity-connector-skoda")
+LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.skoda.auth")
 
 
 class MySkodaSession(SkodaWebSession):
@@ -38,7 +38,7 @@ class MySkodaSession(SkodaWebSession):
     """
     def __init__(self, session_user, **kwargs) -> None:
         super(MySkodaSession, self).__init__(client_id='7f045eee-7003-4379-9968-9355ed2adb06@apps_vw-dilab_com',
-                                             refresh_url='https://tokenrefreshservice.apps.emea.vwapps.io/refreshTokens',
+                                             refresh_url='https://mysmob.api.connect.skoda-auto.cz/api/v1/authentication/refresh-token?tokenType=CONNECT',
                                              scope='address badge birthdate cars driversLicense dealers email mileage mbb nationalIdentifier openid phone profession profile vin',
                                              redirect_uri='myskoda://redirect/login/',
                                              session_user=session_user,
@@ -73,7 +73,7 @@ class MySkodaSession(SkodaWebSession):
     def refresh(self) -> None:
         # refresh tokens from refresh endpoint
         self.refresh_tokens(
-            'https://emea.bff.cariad.digital/user-login/refresh/v1',
+            'https://mysmob.api.connect.skoda-auto.cz/api/v1/authentication/refresh-token?tokenType=CONNECT',
         )
 
     def fetch_tokens(
@@ -133,15 +133,20 @@ class MySkodaSession(SkodaWebSession):
             token = json.loads(token_response)
         except json.decoder.JSONDecodeError as err:
             raise TemporaryAuthenticationError('Token could not be refreshed due to temporary WeConnect failure: json could not be decoded') from err
+        found_tokens: Set[str] = set()
         # Fix token keys, we want access_token instead of accessToken
         if 'accessToken' in token:
+            found_tokens.add('accessToken')
             token['access_token'] = token.pop('accessToken')
         # Fix token keys, we want id_token instead of idToken
         if 'idToken' in token:
+            found_tokens.add('idToken')
             token['id_token'] = token.pop('idToken')
         # Fix token keys, we want refresh_token instead of refreshToken
         if 'refreshToken' in token:
+            found_tokens.add('refreshToken')
             token['refresh_token'] = token.pop('refreshToken')
+        LOG.info(f'Found tokens in answer: {found_tokens}')
         # generate json from fixed dict
         fixed_token_response = to_unicode(json.dumps(token)).encode("utf-8")
         # Let OAuthlib parse the token
@@ -185,33 +190,32 @@ class MySkodaSession(SkodaWebSession):
         if not is_secure_transport(token_url):
             raise InsecureTransportError()
 
-        # Store old refresh token in case no new one is given
         refresh_token = refresh_token or self.refresh_token
 
-        if headers is None:
-            headers = self.headers
-
-        # Request new tokens using the refresh token
-        token_response = self.get(
-            token_url,
-            auth=auth,
-            timeout=timeout,
-            headers=headers,
-            verify=verify,
-            withhold_token=False,  # pyright: ignore reportCallIssue
-            proxies=proxies,
-            access_type=AccessType.REFRESH  # pyright: ignore reportCallIssue
-        )
-        if token_response.status_code == requests.codes['unauthorized']:
-            raise AuthenticationError('Refreshing tokens failed: Server requests new authorization')
-        elif token_response.status_code in (requests.codes['internal_server_error'], requests.codes['service_unavailable'], requests.codes['gateway_timeout']):
-            raise TemporaryAuthenticationError('Token could not be refreshed due to temporary WeConnect failure: {tokenResponse.status_code}')
-        elif token_response.status_code == requests.codes['ok']:
-            # parse new tokens from response
-            self.parse_from_body(token_response.text)
-            if self.token is not None and "refresh_token" not in self.token:
-                LOG.debug("No new refresh token given. Re-using old.")
-                self.token["refresh_token"] = refresh_token
+        # Generate json body for token request
+        body: str = json.dumps(
+            {
+                'token': refresh_token,
+            })
+
+        request_headers: CaseInsensitiveDict = self.headers  # pyright: ignore reportAssignmentType
+        request_headers['accept'] = 'application/json'
+        request_headers['content-type'] = 'application/json'
+
+        try:
+            # request tokens from token_url
+            token_response = self.post(token_url, headers=request_headers, data=body, allow_redirects=False,
+                                            access_type=AccessType.NONE)  # pyright: ignore reportCallIssue
+            if token_response.status_code == requests.codes['ok']:
+                # parse token from response body
+                token = self.parse_from_body(token_response.text)
+                return token
+            elif token_response.status_code == requests.codes['unauthorized']:
+                LOG.info('Refreshing tokens failed: Server requests new authorization, will login now')
+                self.login()
+                return self.token
+            else:
+                raise TemporaryAuthenticationError(f'Token could not be fetched due to temporary MySkoda failure: {token_response.status_code}')
+        except ConnectionError:
+            self.login()
             return self.token
-        else:
-            raise RetrievalError(f'Status Code from WeConnect while refreshing tokens was: {token_response.status_code}')

carconnectivity_connectors/skoda/auth/openid_session.py

@@ -4,8 +4,10 @@ from typing import TYPE_CHECKING
 
 from enum import Enum, auto
 import time
+from datetime import datetime, timezone
 import logging
 import requests
+from jwt import JWT
 
 from oauthlib.common import UNICODE_ASCII_CHARACTER_SET, generate_nonce, generate_token
 from oauthlib.oauth2.rfc6749.parameters import parse_authorization_code_response, parse_token_response, prepare_grant_uri
@@ -22,7 +24,7 @@ from carconnectivity_connectors.volkswagen.auth.helpers.blacklist_retry import B
 if TYPE_CHECKING:
     from typing import Dict
 
-LOG = logging.getLogger("carconnectivity-connector-skoda")
+LOG = logging.getLogger("carconnectivity.connectors.skoda.auth")
 
 
 class AccessType(Enum):
@@ -146,7 +148,17 @@ class OpenIDSession(requests.Session):
                 if self._token is not None and 'expires_in' in self._token:
                     new_token['expires_in'] = self._token['expires_in']
                 else:
-                    new_token['expires_in'] = 3600
+                    if 'id_token' in new_token:
+                        jwt_instance = JWT()
+                        meta_data = jwt_instance.decode(new_token['id_token'], do_verify=False)
+                        if 'exp' in meta_data:
+                            new_token['expires_at'] = meta_data['exp']
+                            expires_at = datetime.fromtimestamp(meta_data['exp'], tz=timezone.utc)
+                            new_token['expires_in'] = (expires_at - datetime.now(tz=timezone.utc)).total_seconds()
+                        else:
+                            new_token['expires_in'] = 3600
+                    else:
+                        new_token['expires_in'] = 3600
             # If expires_in is set and expires_at is not set we calculate expires_at from expires_in using the current time
             if 'expires_in' in new_token and 'expires_at' not in new_token:
                 new_token['expires_at'] = time.time() + int(new_token.get('expires_in'))

carconnectivity_connectors/skoda/auth/session_manager.py

@@ -14,7 +14,7 @@ from requests import Session
 
 from carconnectivity_connectors.skoda.auth.my_skoda_session import MySkodaSession
 
-LOG = logging.getLogger("myskoda")
+LOG = logging.getLogger("carconnectivity.connectors.skoda.auth")
 
 
 class SessionUser():
@@ -74,8 +74,9 @@ class SessionManager():
 
     def persist(self) -> None:
         for (service, user), session in self.sessions.items():
-            identifier: str = SessionManager.generate_identifier(service, user)
-            self.tokenstore[identifier] = {}
-            self.tokenstore[identifier]['token'] = session.token
-            self.tokenstore[identifier]['metadata'] = session.metadata
-            self.cache[identifier] = session.cache
+            if session.token is not None:
+                identifier: str = SessionManager.generate_identifier(service, user)
+                self.tokenstore[identifier] = {}
+                self.tokenstore[identifier]['token'] = session.token
+                self.tokenstore[identifier]['metadata'] = session.metadata
+                self.cache[identifier] = session.cache

carconnectivity_connectors/skoda/connector.py

@@ -23,15 +23,15 @@ from carconnectivity.attributes import BooleanAttribute, DurationAttribute
 
 from carconnectivity_connectors.base.connector import BaseConnector
 from carconnectivity_connectors.skoda.auth.session_manager import SessionManager, SessionUser, Service
+from carconnectivity_connectors.skoda.auth.my_skoda_session import MySkodaSession
 from carconnectivity_connectors.skoda.vehicle import SkodaVehicle, SkodaElectricVehicle, SkodaCombustionVehicle, SkodaHybridVehicle
 from carconnectivity_connectors.skoda.capability import Capability
 from carconnectivity_connectors.skoda._version import __version__
+from carconnectivity_connectors.skoda.mqtt_client import SkodaMQTTClient
 
 if TYPE_CHECKING:
     from typing import Dict, List, Optional, Any
 
-    from requests import Session
-
     from carconnectivity.carconnectivity import CarConnectivity
 
 LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.skoda")
@@ -50,12 +50,17 @@ class Connector(BaseConnector):
     def __init__(self, connector_id: str, car_connectivity: CarConnectivity, config: Dict) -> None:
         BaseConnector.__init__(self, connector_id=connector_id, car_connectivity=car_connectivity, config=config)
 
+        self._mqtt_client: SkodaMQTTClient = SkodaMQTTClient(skoda_connector=self)
+
         self._background_thread: Optional[threading.Thread] = None
+        self._background_connect_thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
 
         self.connected: BooleanAttribute = BooleanAttribute(name="connected", parent=self)
         self.interval: DurationAttribute = DurationAttribute(name="interval", parent=self)
 
+        self.user_id: Optional[str] = None
+
         # Configure logging
         if 'log_level' in config and config['log_level'] is not None:
             config['log_level'] = config['log_level'].upper()
@@ -115,13 +120,36 @@ class Connector(BaseConnector):
             raise AuthenticationError('Username or password not provided')
 
         self._manager: SessionManager = SessionManager(tokenstore=car_connectivity.get_tokenstore(), cache=car_connectivity.get_cache())
-        self._session: Session = self._manager.get_session(Service.MY_SKODA, SessionUser(username=username, password=password))
+        session: requests.Session = self._manager.get_session(Service.MY_SKODA, SessionUser(username=username, password=password))
+        if not isinstance(session, MySkodaSession):
+            raise AuthenticationError('Could not create session')
+        self._session: MySkodaSession = session
+        self._session.refresh()
 
         self._elapsed: List[timedelta] = []
 
     def startup(self) -> None:
+        self._stop_event.clear()
+        # Start background thread for Rest API polling
         self._background_thread = threading.Thread(target=self._background_loop, daemon=False)
         self._background_thread.start()
+        # Start background thread for MQTT connection
+        self._background_connect_thread = threading.Thread(target=self._background_connect_loop, daemon=False)
+        self._background_connect_thread.start()
+        # Start MQTT thread
+        self._mqtt_client.loop_start()
+
+    def _background_connect_loop(self) -> None:
+        while not self._stop_event.is_set():
+            try:
+                if not self._session.expired and self._session.access_token is not None:
+                    access_token: str = self._session.access_token
+                    LOG.info('Connecting to Skoda MQTT-Server')
+                    self._mqtt_client.connect_client(access_token)
+                    break
+            except ConnectionRefusedError as e:
+                LOG.error('Could not connect to MQTT-Server: %s, will retry in 10 seconds', e)
+                self._stop_event.wait(10)
 
     def _background_loop(self) -> None:
         self._stop_event.clear()
@@ -134,7 +162,6 @@ class Connector(BaseConnector):
                     if self.interval.value is not None:
                         interval: int = self.interval.value.total_seconds()
                 except Exception:
-                    self.connected._set_value(value=False)  # pylint: disable=protected-access
                     if self.interval.value is not None:
                         interval: int = self.interval.value.total_seconds()
                     raise
@@ -151,7 +178,6 @@ class Connector(BaseConnector):
                 LOG.error('Temporary authentification error during update (%s). Will try again after configured interval of %ss', str(err), interval)
                 self._stop_event.wait(interval)
             else:
-                self.connected._set_value(value=True)  # pylint: disable=protected-access
                 self._stop_event.wait(interval)
 
     def persist(self) -> None:
@@ -174,6 +200,9 @@ class Connector(BaseConnector):
         3. Sets the session and manager to None.
         4. Calls the shutdown method of the base connector.
         """
+        self._mqtt_client.disconnect()
+        # Stop MQTT thread
+        self._mqtt_client.loop_stop()
         # Disable and remove all vehicles managed soley by this connector
         for vehicle in self.car_connectivity.garage.list_vehicles():
             if len(vehicle.managing_connectors) == 1 and self in vehicle.managing_connectors:
@@ -182,6 +211,8 @@ class Connector(BaseConnector):
         self._stop_event.set()
         if self._background_thread is not None:
             self._background_thread.join()
+        if self._background_connect_thread is not None:
+            self._background_connect_thread.join()
         self.persist()
         self._session.close()
         return super().shutdown()
@@ -195,6 +226,21 @@ class Connector(BaseConnector):
         self.fetch_vehicles()
         self.car_connectivity.transaction_end()
 
+    def fetch_user(self) -> None:
+        """
+        Fetches the user data from the Skoda Connect API.
+
+        This method sends a request to the Skoda Connect API to retrieve the user data associated with the user's account.
+
+        Returns:
+            None
+        """
+        url = 'https://mysmob.api.connect.skoda-auto.cz/api/v1/users'
+        data: Dict[str, Any] | None = self._fetch_data(url, session=self._session)
+        if data:
+            if 'id' in data and data['id'] is not None:
+                self.user_id = data['id']
+
     def fetch_vehicles(self) -> None:
         """
         Fetches the list of vehicles from the Skoda Connect API and updates the garage with new vehicles.
@@ -215,7 +261,7 @@ class Connector(BaseConnector):
                         seen_vehicle_vins.add(vehicle_dict['vin'])
                         vehicle: Optional[SkodaVehicle] = garage.get_vehicle(vehicle_dict['vin'])  # pyright: ignore[reportAssignmentType]
                         if not vehicle:
-                            vehicle = SkodaVehicle(vin=vehicle_dict['vin'], garage=garage)
+                            vehicle = SkodaVehicle(vin=vehicle_dict['vin'], garage=garage, managing_connector=self)
                             garage.add_vehicle(vehicle_dict['vin'], vehicle)
 
                         if 'licensePlate' in vehicle_dict and vehicle_dict['licensePlate'] is not None:
@@ -363,6 +409,7 @@ class Connector(BaseConnector):
 
                     log_extra_keys(LOG_API, f'{drive_id}EngineRange', range_data[f'{drive_id}EngineRange'], {'engineType',
                                                                                                              'currentSoCInPercent',
+                                                                                                             'currentFuelLevelInPercent',
                                                                                                              'remainingRangeInKm'})
             log_extra_keys(LOG_API, '/api/v2/vehicle-status/{vin}/driving-range', range_data, {'carCapturedTimestamp',
                                                                                                'carType',

carconnectivity_connectors/skoda/mqtt_client.py

@@ -0,0 +1,405 @@
+"""Module implements the MQTT client."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import logging
+import uuid
+import ssl
+
+from paho.mqtt.client import Client
+from paho.mqtt.enums import MQTTProtocolVersion, CallbackAPIVersion, MQTTErrorCode
+
+from carconnectivity.observable import Observable
+from carconnectivity.vehicle import GenericVehicle
+
+
+if TYPE_CHECKING:
+    from typing import Set
+
+    from carconnectivity_connectors.skoda.connector import Connector
+
+
+LOG: logging.Logger = logging.getLogger("carconnectivity.connectors.skoda.mqtt")
+
+
+class SkodaMQTTClient(Client):  # pylint: disable=too-many-instance-attributes
+    """
+    MQTT client for the myskoda event push service.
+    """
+    def __init__(self, skoda_connector: Connector) -> None:
+        super().__init__(callback_api_version=CallbackAPIVersion.VERSION2,
+                         client_id="Id" + str(uuid.uuid4()) + "#" + str(uuid.uuid4()),
+                         transport="tcp",
+                         protocol=MQTTProtocolVersion.MQTTv311,
+                         reconnect_on_failure=True,
+                         clean_session=True)
+        self._skoda_connector: Connector = skoda_connector
+
+        self.username = 'android-app'
+
+        self.on_connect = self._on_connect_callback
+        self.on_message = self._on_message_callback
+        self.on_disconnect = self._on_disconnect_callback
+        self.on_subscribe = self._on_subscribe_callback
+        self.subscribed_topics: Set[str] = set()
+
+    def connect_client(self, access_token: str) -> MQTTErrorCode:
+        """
+        Connects the MQTT client using the provided access token.
+
+        This method sets the client's password to the provided access token,
+        configures TLS settings, and attempts to connect to the MQTT broker.
+
+        Args:
+            access_token (str): The access token used as the password for the MQTT client.
+
+        Returns:
+            MQTTErrorCode: The result of the connection attempt.
+        """
+        self.password = access_token  # pylint: disable=attribute-defined-outside-init # this is a false positive, password has a setter in super class
+        self.tls_set(cert_reqs=ssl.CERT_NONE)
+        return super().connect(host='mqtt.messagehub.de', port=8883, keepalive=60)
+
+    def _on_carconnectivity_vehicle_enabled(self, element, flags):
+        """
+        Handles the event when a vehicle is enabled or disabled in the car connectivity system.
+
+        This method is triggered when the state of a vehicle changes. It subscribes to the vehicle
+        if it is enabled and unsubscribes if it is disabled.
+
+        Args:
+            element: The element whose state has changed.
+            flags (Observable.ObserverEvent): The event flags indicating the state change.
+
+        Returns:
+            None
+        """
+        if (flags & Observable.ObserverEvent.ENABLED) and isinstance(element, GenericVehicle):
+            self._subscribe_vehicle(element)
+        elif (flags & Observable.ObserverEvent.DISABLED) and isinstance(element, GenericVehicle):
+            self._subscribe_vehicle(element)
+
+    def _subscribe_vehicles(self) -> None:
+        """
+        Subscribes to all vehicles the connector is responsible for.
+
+        This method iterates through the list of vehicles in the carconnectivity
+        garage and subscribes to eliable vehicles by calling the _subscribe_vehicle method.
+
+        Returns:
+            None
+        """
+        for vehicle in self._skoda_connector.car_connectivity.garage.list_vehicles():
+            self._subscribe_vehicle(vehicle)
+
+    def _unsubscribe_vehicles(self) -> None:
+        """
+        Unsubscribes from all vehicles the client is subscribed for.
+
+        This method iterates through the list of vehicles in the garage and
+        unsubscribes from each one by calling the _unsubscribe_vehicle method.
+
+        Returns:
+            None
+        """
+        for vehicle in self._skoda_connector.car_connectivity.garage.list_vehicles():
+            self._unsubscribe_vehicle(vehicle)
+
+    def _subscribe_vehicle(self, vehicle: GenericVehicle) -> None:
+        """
+        Subscribes to MQTT topics for a given vehicle.
+
+        This method subscribes to various MQTT topics related to the vehicle's
+        account events, operation requests, and service events. It ensures that
+        the user ID is fetched if not already available and checks if the vehicle
+        has a valid VIN before subscribing.
+
+        Args:
+            vehicle (GenericVehicle): The vehicle object containing VIN and other
+                                      relevant information.
+
+        Raises:
+            None
+
+        Logs:
+            - Warnings if the vehicle does not have a VIN.
+            - Info messages upon successful subscription to a topic.
+            - Error messages if subscription to a topic fails.
+        """
+        # to subscribe the user_id must be known
+        if self._skoda_connector.user_id is None:
+            self._skoda_connector.fetch_user()
+        # Can only subscribe with user_id
+        if self._skoda_connector.user_id is not None:
+            user_id: str = self._skoda_connector.user_id
+            if not vehicle.vin.enabled or vehicle.vin.value is None:
+                LOG.warning('Could not subscribe to vehicle without vin')
+            else:
+                vin: str = vehicle.vin.value
+                # If the skoda connector is managing this vehicle
+                if self._skoda_connector in vehicle.managing_connectors:
+                    account_events: Set[str] = {'privacy'}
+                    operation_requests: Set[str] = {
+                        'air-conditioning/set-air-conditioning-at-unlock',
+                        'air-conditioning/set-air-conditioning-seats-heating',
+                        'air-conditioning/set-air-conditioning-timers',
+                        'air-conditioning/set-air-conditioning-without-external-power',
+                        'air-conditioning/set-target-temperature',
+                        'air-conditioning/start-stop-air-conditioning',
+                        'auxiliary-heating/start-stop-auxiliary-heating',
+                        'air-conditioning/start-stop-window-heating',
+                        'air-conditioning/windows-heating',
+                        'charging/start-stop-charging',
+                        'charging/update-battery-support',
+                        'charging/update-auto-unlock-plug',
+                        'charging/update-care-mode',
+                        'charging/update-charge-limit',
+                        'charging/update-charge-mode',
+                        'charging/update-charging-profiles',
+                        'charging/update-charging-current',
+                        'departure/update-departure-timers',
+                        'departure/update-minimal-soc',
+                        'vehicle-access/honk-and-flash',
+                        'vehicle-access/lock-vehicle',
+                        'vehicle-services-backup/apply-backup',
+                        'vehicle-wakeup/wakeup'
+                    }
+                    service_events: Set[str] = {
+                        'air-conditioning',
+                        'charging',
+                        'departure',
+                        'vehicle-status/access',
+                        'vehicle-status/lights'
+                    }
+                    possible_topics: Set[str] = set()
+                    # Compile all possible topics
+                    for event in account_events:
+                        possible_topics.add(f'{user_id}/{vin}/account-event/{event}')
+                    for event in operation_requests:
+                        possible_topics.add(f'{user_id}/{vin}/operation-request/{event}')
+                    for event in service_events:
+                        possible_topics.add(f'{user_id}/{vin}/service-event/{event}')
+
+                    # Subscribe to all topics
+                    for topic in possible_topics:
+                        if topic not in self.subscribed_topics:
+                            mqtt_err, mid = self.subscribe(topic)
+                            if mqtt_err == MQTTErrorCode.MQTT_ERR_SUCCESS:
+                                self.subscribed_topics.add(topic)
+                                LOG.debug('Subscribe to topic %s with %d', topic, mid)
+                            else:
+                                LOG.error('Could not subscribe to topic %s (%s)', topic, mqtt_err)
+        else:
+            LOG.warning('Could not subscribe to vehicle without user_id')
+
+    def _unsubscribe_vehicle(self, vehicle: GenericVehicle) -> None:
+        """
+        Unsubscribe from all MQTT topics related to a specific vehicle.
+
+        This method checks if the vehicle's VIN (Vehicle Identification Number) is enabled and not None.
+        If the VIN is valid, it iterates through the list of subscribed topics and unsubscribes from
+        any topic that contains the VIN. It also removes the topic from the list of subscribed topics
+        and logs the unsubscription.
+
+        Args:
+            vehicle (GenericVehicle): The vehicle object containing the VIN information.
+
+        Raises:
+            None
+
+        Logs:
+            - Warning if the vehicle's VIN is not enabled or is None.
+            - Info for each topic successfully unsubscribed.
+        """
+        if not vehicle.vin.enabled or vehicle.vin.value is None:
+            LOG.warning('Could not unsubscribe to vehicle without vin')
+        else:
+            vin: str = vehicle.vin.value
+            for topic in self.subscribed_topics:
+                if vin in topic:
+                    self.unsubscribe(topic)
+                    self.subscribed_topics.remove(topic)
+                    LOG.debug('Unsubscribed from topic %s', topic)
+
+    def _on_connect_callback(self, mqttc, obj, flags, reason_code, properties) -> None:
+        """
+        Callback function that is called when the MQTT client connects to the broker.
+
+        It registers a callback to observe new vehicles being added and subscribes MQTT topics for all vehicles
+        handled by this connector.
+
+        Args:
+            mqttc: The MQTT client instance (unused).
+            obj: User-defined object passed to the callback (unused).
+            flags: Response flags sent by the broker (unused).
+            reason_code: The connection result code.
+            properties: MQTT v5 properties (unused).
+
+        Returns:
+            None
+
+        The function logs the connection status and handles different reason codes:
+            - 0: Connection successful.
+            - 128: Unspecified error.
+            - 129: Malformed packet.
+            - 130: Protocol error.
+            - 131: Implementation specific error.
+            - 132: Unsupported protocol version.
+            - 133: Client identifier not valid.
+            - 134: Bad user name or password.
+            - 135: Not authorized.
+            - 136: Server unavailable.
+            - 137: Server busy. Retrying.
+            - 138: Banned.
+            - 140: Bad authentication method.
+            - 144: Topic name invalid.
+            - 149: Packet too large.
+            - 151: Quota exceeded.
+            - 154: Retain not supported.
+            - 155: QoS not supported.
+            - 156: Use another server.
+            - 157: Server move.
+            - 159: Connection rate exceeded.
+            - Other: Generic connection error.
+        """
+        del mqttc  # unused
+        del obj  # unused
+        del flags  # unused
+        del properties
+        # reason_code 0 means success
+        if reason_code == 0:
+            LOG.info('Connected to MQTT broker')
+            self._skoda_connector.connected._set_value(value=True)  # pylint: disable=protected-access
+            observer_flags: Observable.ObserverEvent = Observable.ObserverEvent.ENABLED | Observable.ObserverEvent.DISABLED
+            self._skoda_connector.car_connectivity.garage.add_observer(observer=self._on_carconnectivity_vehicle_enabled,
+                                                                       flag=observer_flags,
+                                                                       priority=Observable.ObserverPriority.USER_MID)
+            self._subscribe_vehicles()
+
+        # Handle different reason codes
+        elif reason_code == 128:
+            LOG.error('Could not connect (%s): Unspecified error', reason_code)
+        elif reason_code == 129:
+            LOG.error('Could not connect (%s): Malformed packet', reason_code)
+        elif reason_code == 130:
+            LOG.error('Could not connect (%s): Protocol error', reason_code)
+        elif reason_code == 131:
+            LOG.error('Could not connect (%s): Implementation specific error', reason_code)
+        elif reason_code == 132:
+            LOG.error('Could not connect (%s): Unsupported protocol version', reason_code)
+        elif reason_code == 133:
+            LOG.error('Could not connect (%s): Client identifier not valid', reason_code)
+        elif reason_code == 134:
+            LOG.error('Could not connect (%s): Bad user name or password', reason_code)
+        elif reason_code == 135:
+            LOG.error('Could not connect (%s): Not authorized', reason_code)
+        elif reason_code == 136:
+            LOG.error('Could not connect (%s): Server unavailable', reason_code)
+        elif reason_code == 137:
+            LOG.error('Could not connect (%s): Server busy. Retrying', reason_code)
+        elif reason_code == 138:
+            LOG.error('Could not connect (%s): Banned', reason_code)
+        elif reason_code == 140:
+            LOG.error('Could not connect (%s): Bad authentication method', reason_code)
+        elif reason_code == 144:
+            LOG.error('Could not connect (%s): Topic name invalid', reason_code)
+        elif reason_code == 149:
+            LOG.error('Could not connect (%s): Packet too large', reason_code)
+        elif reason_code == 151:
+            LOG.error('Could not connect (%s): Quota exceeded', reason_code)
+        elif reason_code == 154:
+            LOG.error('Could not connect (%s): Retain not supported', reason_code)
+        elif reason_code == 155:
+            LOG.error('Could not connect (%s): QoS not supported', reason_code)
+        elif reason_code == 156:
+            LOG.error('Could not connect (%s): Use another server', reason_code)
+        elif reason_code == 157:
+            LOG.error('Could not connect (%s): Server move', reason_code)
+        elif reason_code == 159:
+            LOG.error('Could not connect (%s): Connection rate exceeded', reason_code)
+        else:
+            LOG.error('Could not connect (%s)', reason_code)
+
+    def _on_disconnect_callback(self, client, userdata, flags, reason_code, properties) -> None:
+        """
+        Callback function that is called when the MQTT client disconnects.
+
+        This function handles the disconnection of the MQTT client and logs the appropriate
+        messages based on the reason code for the disconnection. It also removes the observer
+        from the garage to not get any notifications for vehicles being added or removed.
+
+        Args:
+            client: The MQTT client instance that disconnected.
+            userdata: The private user data as set in Client() or userdata_set().
+            flags: Response flags sent by the broker.
+            reason_code: The reason code for the disconnection.
+            properties: The properties associated with the disconnection.
+
+        Returns:
+            None
+        """
+        del client
+        del properties
+        del flags
+
+        self._skoda_connector.connected._set_value(value=False)  # pylint: disable=protected-access
+        self._skoda_connector.car_connectivity.garage.remove_observer(observer=self._on_carconnectivity_vehicle_enabled)
+
+        if reason_code == 0:
+            LOG.info('Client successfully disconnected')
+        elif reason_code == 4:
+            LOG.info('Client successfully disconnected: %s', userdata)
+        elif reason_code == 137:
+            LOG.error('Client disconnected: Server busy')
+        elif reason_code == 139:
+            LOG.error('Client disconnected: Server shutting down')
+        elif reason_code == 160:
+            LOG.error('Client disconnected: Maximum connect time')
+        else:
+            LOG.error('Client unexpectedly disconnected (%s), trying to reconnect', reason_code)
+
+    def _on_subscribe_callback(self, mqttc, obj, mid, reason_codes, properties) -> None:
+        """
+        Callback function for MQTT subscription.
+
+        This method is called when the client receives a SUBACK response from the server.
+        It checks the reason codes to determine if the subscription was successful.
+
+        Args:
+            mqttc: The MQTT client instance (unused).
+            obj: User-defined data of any type (unused).
+            mid: The message ID of the subscribe request.
+            reason_codes: A list of reason codes indicating the result of the subscription.
+            properties: MQTT v5.0 properties (unused).
+
+        Returns:
+            None
+        """
+        del mqttc  # unused
+        del obj  # unused
+        del properties  # unused
+        if any(x in [0, 1, 2] for x in reason_codes):
+            LOG.debug('sucessfully subscribed to topic of mid %d', mid)
+        else:
+            LOG.error('Subscribe was not successfull (%s)', ', '.join(reason_codes))
+
+    def _on_message_callback(self, mqttc, obj, msg) -> None:  # noqa: C901
+        """
+        Callback function for handling incoming MQTT messages.
+
+        This function is called when a message is received on a subscribed topic.
+        It logs an error message indicating that the message is not understood.
+        In the next step this needs to be implemented with real behaviour.
+
+        Args:
+            mqttc: The MQTT client instance (unused).
+            obj: The user data (unused).
+            msg: The MQTT message instance containing topic and payload.
+
+        Returns:
+            None
+        """
+        del mqttc  # unused
+        del obj  # unused
+        error_message = f'I don\'t understand message {msg.topic}: {msg.payload}'
+        LOG.info(error_message)