to version 1.6.3

Author: Thomas Salm

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "saic_ismart_client"
-version = "1.6.2"
+version = "1.6.3"
 authors = [
     { name = "Thomas Salm", email="[email protected]"},
 ]

src/saic_ismart_client/common_model.py

@@ -196,7 +196,7 @@ def init_from_dict(self, data: dict):
         if FIELD_RESULT in data:
             self.result = data.get(FIELD_RESULT)
         if FIELD_ERROR_MESSAGE in data:
-            self.error_message = data.get(FIELD_ERROR_MESSAGE)
+            self.error_message = data.get(FIELD_ERROR_MESSAGE).decode()
 
 
 class MessageBodyV1(AbstractMessageBody):
@@ -338,6 +338,20 @@ def get_application_data_bytes(self, application_data: ApplicationData, asn1_too
             application_data_bytes = bytes()
         return application_data_bytes
 
+    @staticmethod
+    def validate_dispatcher_message_size(dispatcher_message_size, netto_message_size):
+        # The API sometimes provides a wrong dispatcher_message_length value
+        # Normally the body size is about 120 bytes
+        # A value below 50 is very unlikely.
+        if dispatcher_message_size > 50:
+            dispatcher_message_bytes_to_read = dispatcher_message_size
+        else:
+            LOG.debug(f'Calculated message size {int(netto_message_size)} does not match '
+                      + f'with header size information {dispatcher_message_size}. Using calculated size.')
+            # This will fail if the message contains application data. In this case we cannot tell the body size
+            dispatcher_message_bytes_to_read = int(netto_message_size)
+        return dispatcher_message_bytes_to_read
+
 
 class MessageCoderV1(AbstractMessageCoder):
     def __init__(self, asn_files_dir: str):
@@ -378,16 +392,28 @@ def encode_request(self, message: MessageV1) -> str:
         return result.upper()
 
     def decode_response(self, message: str, decoded_message: MessageV1) -> None:
+        LOG.debug(f'Message length in bytes: {len(message[5:]) / 2}')
         buffered_message_bytes = io.BytesIO(bytes.fromhex(message[5:]))
 
+        header = decoded_message.header
         header_bytes = buffered_message_bytes.read(self.header_length)
-        decoded_message.header.protocol_version = int(header_bytes[0])
-        decoded_message.header.security_context = int(header_bytes[1])
-        decoded_message.header.dispatcher_message_length = int(header_bytes[2])
-        decoded_message.header.dispatcher_body_encoding = int(header_bytes[3])
+        header.protocol_version = int(header_bytes[0])
+        LOG.debug(f'Protocol version: {header.protocol_version}')
+        header.security_context = int(header_bytes[1])
+        header.dispatcher_message_length = int(header_bytes[2])
+        LOG.debug(f'Dispatcher message length: {header.dispatcher_message_length}')
+        header.dispatcher_body_encoding = int(header_bytes[3])
 
-        dispatcher_message_bytes = buffered_message_bytes.read(
-            decoded_message.header.dispatcher_message_length - self.header_length)
+        netto_message_size = len(message[5:]) / 2 - self.header_length
+        LOG.debug(f'Message size without header: {netto_message_size}')
+
+        dispatcher_message_size = header.dispatcher_message_length -self.header_length
+        LOG.debug(f'Dispatcher message bytes: {dispatcher_message_size}')
+
+        dispatcher_message_bytes_to_read = AbstractMessageCoder.validate_dispatcher_message_size(
+            dispatcher_message_size, netto_message_size)
+
+        dispatcher_message_bytes = buffered_message_bytes.read(dispatcher_message_bytes_to_read)
         message_body = decoded_message.body
         message_body_dict = self.asn1_tool_uper.decode(message_body.asn_type, dispatcher_message_bytes)
         message_body.init_from_dict(message_body_dict)
@@ -477,16 +503,8 @@ def decode_response(self, message: str, decoded_message: MessageV2) -> None:
         dispatcher_message_size = header.dispatcher_message_length - self.header_length
         LOG.debug(f'Dispatcher message bytes: {dispatcher_message_size}')
 
-        # The API sometimes provides a wrong dispatcher_message_length value
-        # Normally the body size is about 120 bytes
-        # A value below 50 is very unlikely.
-        if dispatcher_message_size > 50:
-            dispatcher_message_bytes_to_read = dispatcher_message_size
-        else:
-            LOG.debug(f'Calculated message size {int(netto_message_size)} does not match '
-                      + f'with header size information {dispatcher_message_size}. Using calculated size.')
-            # This will fail if the message contains application data. In this case we cannot tell the body size
-            dispatcher_message_bytes_to_read = int(netto_message_size)
+        dispatcher_message_bytes_to_read = AbstractMessageCoder.validate_dispatcher_message_size(
+            dispatcher_message_size, netto_message_size)
 
         dispatcher_message_bytes = buffered_message_bytes.read(dispatcher_message_bytes_to_read)
         message_body_dict = self.asn1_tool_uper.decode('MPDispatcherBody', dispatcher_message_bytes)

src/saic_ismart_client/saic_api.py

@@ -119,7 +119,7 @@ def login(self) -> MessageV11:
         self.message_v1_1_coder.decode_response(login_response_hex, login_response_message)
         self.publish_json_response(application_id, application_data_protocol_version, login_response_message.get_data())
         if login_response_message.body.error_message is not None:
-            raise SaicApiException(login_response_message.body.error_message.decode(),
+            raise SaicApiException(login_response_message.body.error_message,
                                    login_response_message.body.result)
         else:
             self.uid = login_response_message.body.uid
@@ -164,7 +164,7 @@ def set_alarm_switches(self, alarm_switches: list, pin: str = None) -> None:
                                    alarm_switch_response_message.get_data())
 
         if alarm_switch_response_message.body.error_message is not None:
-            raise SaicApiException(alarm_switch_response_message.body.error_message.decode(),
+            raise SaicApiException(alarm_switch_response_message.body.error_message,
                                    alarm_switch_response_message.body.result)
 
     def get_vehicle_status(self, vin_info: VinInfo, event_id: str = None) -> MessageV2:
@@ -479,7 +479,7 @@ def __handle_retry_without_app_data(self, func, vin_info: VinInfo, max_retries:
 
             retry += 1
         if rsp_msg.body.error_message is not None:
-            raise SaicApiException(rsp_msg.body.error_message.decode(),
+            raise SaicApiException(rsp_msg.body.error_message,
                                    rsp_msg.body.result)
         return rsp_msg
 
@@ -783,7 +783,7 @@ def __change_message_status(self, message_id: int | None, action_type: str, even
         self.message_v1_1_coder.decode_response(message_delete_rsp_hex, message_delete_rsp_msg)
         self.publish_json_response(application_id, application_protocol_version, message_delete_rsp_msg.get_data())
         if message_delete_rsp_msg.body.error_message is not None:
-            raise SaicApiException(message_delete_rsp_msg.body.error_message.decode(),
+            raise SaicApiException(message_delete_rsp_msg.body.error_message,
                                    message_delete_rsp_msg.body.result)
 
     def publish_raw_value(self, key: str, raw: str):
@@ -854,7 +854,7 @@ def handle_error(self, message_body: AbstractMessageBody, iteration: int):
             waiting_time = AVG_SMS_DELIVERY_TIME
         message = f'application ID: {message_body.application_id},' \
                   + f' protocol version: {message_body.application_data_protocol_version},' \
-                  + f' message: {message_body.error_message.decode()}' \
+                  + f' message: {message_body.error_message}' \
                   + f' result code: {message_body.result}'
 
         if message_body.result == 2:
@@ -877,7 +877,7 @@ def handle_error(self, message_body: AbstractMessageBody, iteration: int):
             LOG.warning(message)
         else:
             LOG.error(message)
-            raise SaicApiException(message_body.error_message.decode(), message_body.result)
+            raise SaicApiException(message_body.error_message, message_body.result)
 
 
 def bool_to_bit(flag):