tesla-fleet-api 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

tesla_fleet_api/tesla/vehicle/bluetooth.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import hashlib
-from asyncio import Future, get_running_loop
+import asyncio
 from typing import TYPE_CHECKING
 from google.protobuf.message import DecodeError
 
@@ -12,38 +12,61 @@ from cryptography.hazmat.primitives.asymmetric import ec
 
 from tesla_fleet_api.tesla.vehicle.proto.keys_pb2 import Role
 
-from .commands import Commands
+from tesla_fleet_api.tesla.vehicle.commands import Commands
 
-from ...const import (
+from tesla_fleet_api.const import (
     LOGGER,
+    BluetoothVehicleData
 )
-from ...exceptions import (
+from tesla_fleet_api.exceptions import (
     MESSAGE_FAULTS,
     WHITELIST_OPERATION_STATUS,
+    WhitelistOperationStatus,
+    NotOnWhitelistFault,
 )
 
 # Protocol
-from .proto.car_server_pb2 import (
+from tesla_fleet_api.tesla.vehicle.proto.car_server_pb2 import (
+    Action,
+    VehicleAction,
     Response,
+    GetVehicleData,
+    GetChargeState,
+    GetClimateState,
+    GetDriveState,
+    GetLocationState,
+    GetClosuresState,
+    GetChargeScheduleState,
+    GetPreconditioningScheduleState,
+    GetTirePressureState,
+    GetMediaState,
+    GetMediaDetailState,
+    GetSoftwareUpdateState,
+    GetParentalControlsState,
 )
-from .proto.signatures_pb2 import (
+from tesla_fleet_api.tesla.vehicle.proto.signatures_pb2 import (
     SessionInfo,
+    Session_Info_Status
 )
-from .proto.universal_message_pb2 import (
+from tesla_fleet_api.tesla.vehicle.proto.universal_message_pb2 import (
     Destination,
     Domain,
     RoutableMessage,
 )
-from .proto.vcsec_pb2 import (
+from tesla_fleet_api.tesla.vehicle.proto.vcsec_pb2 import (
     FromVCSECMessage,
+    InformationRequest,
+    InformationRequestType,
     KeyFormFactor,
     KeyMetadata,
     PermissionChange,
     PublicKey,
+    RKEAction_E,
     UnsignedMessage,
+    VehicleStatus,
     WhitelistOperation,
-
 )
+from tesla_fleet_api.tesla.vehicle.proto.vehicle_pb2 import ChargeScheduleState, ChargeState, ClimateState, ClosuresState, DriveState, LocationState, MediaDetailState, MediaState, ParentalControlsState, PreconditioningScheduleState, SoftwareUpdateState, TirePressureState, VehicleData
 
 SERVICE_UUID = "00000211-b2d1-43f0-9b88-960cebf8b91e"
 WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e"
@@ -51,7 +74,7 @@ READ_UUID = "00000213-b2d1-43f0-9b88-960cebf8b91e"
 VERSION_UUID = "00000214-b2d1-43f0-9b88-960cebf8b91e"
 
 if TYPE_CHECKING:
-    from ..tesla import Tesla
+    from tesla_fleet_api.tesla.tesla import Tesla
 
 def prependLength(message: bytes) -> bytearray:
     """Prepend a 2-byte length to the payload."""
@@ -62,40 +85,43 @@ class VehicleBluetooth(Commands):
 
     ble_name: str
     client: BleakClient
-    _device: BLEDevice
-    _futures: dict[Domain, Future]
+    _queues: dict[Domain, asyncio.Queue]
     _ekey: ec.EllipticCurvePublicKey
     _recv: bytearray = bytearray()
     _recv_len: int = 0
     _auth_method = "aes"
 
     def __init__(
-        self, parent: Tesla, vin: str, key: ec.EllipticCurvePrivateKey | None = None
+        self, parent: Tesla, vin: str, key: ec.EllipticCurvePrivateKey | None = None, device: None | str | BLEDevice = None
     ):
         super().__init__(parent, vin, key)
         self.ble_name = "S" + hashlib.sha1(vin.encode('utf-8')).hexdigest()[:16] + "C"
-        self._futures = {}
-
-    async def discover(self, scanner: BleakScanner = BleakScanner()) -> BleakClient:
+        self._queues = {
+            Domain.DOMAIN_VEHICLE_SECURITY: asyncio.Queue(),
+            Domain.DOMAIN_INFOTAINMENT: asyncio.Queue(),
+        }
+        if device is not None:
+            self.client = BleakClient(device, services=[SERVICE_UUID])
+
+    async def find_client(self, scanner: BleakScanner = BleakScanner()) -> BleakClient:
         """Find the Tesla BLE device."""
 
         device = await scanner.find_device_by_name(self.ble_name)
         if not device:
             raise ValueError(f"Device {self.ble_name} not found")
-        self._device = device
-        self.client = BleakClient(self._device, services=[SERVICE_UUID])
-        LOGGER.debug(f"Discovered device {self._device.name} {self._device.address}")
+        self.client = BleakClient(device, services=[SERVICE_UUID])
+        LOGGER.debug(f"Discovered device {device.name} {device.address}")
         return self.client
 
-    def create_client(self, mac:str):
-        """Create a client with a MAC."""
-        self.client = BleakClient(mac, services=[SERVICE_UUID])
+    def create_client(self, device: str|BLEDevice) -> BleakClient:
+        """Create a client using a MAC address or Bleak Device."""
+        self.client = BleakClient(device, services=[SERVICE_UUID])
         return self.client
 
-    async def connect(self, mac:str | None = None) -> None:
+    async def connect(self, device: str|BLEDevice | None = None) -> None:
         """Connect to the Tesla BLE device."""
-        if mac is not None:
-            self.create_client(mac)
+        if device is not None:
+            self.create_client(device)
         await self.client.connect()
         await self.client.start_notify(READ_UUID, self._on_notify)
 
@@ -108,11 +134,11 @@ class VehicleBluetooth(Commands):
         await self.connect()
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         """Exit the async context."""
         await self.disconnect()
 
-    def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray):
+    async def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray) -> None:
         """Receive data from the Tesla BLE device."""
         if self._recv_len:
             self._recv += data
@@ -122,68 +148,55 @@ class VehicleBluetooth(Commands):
         LOGGER.debug(f"Received {len(self._recv)} of {self._recv_len} bytes")
         while len(self._recv) > self._recv_len:
             LOGGER.warn(f"Received more data than expected: {len(self._recv)} > {self._recv_len}")
-            self._on_message(bytes(self._recv[:self._recv_len]))
+            await self._on_message(bytes(self._recv[:self._recv_len]))
             self._recv_len = int.from_bytes(self._recv[self._recv_len:self._recv_len+2], 'big')
             self._recv = self._recv[self._recv_len+2:]
             continue
         if len(self._recv) == self._recv_len:
-            self._on_message(bytes(self._recv))
+            await self._on_message(bytes(self._recv))
             self._recv = bytearray()
             self._recv_len = 0
 
-    def _on_message(self, data:bytes):
+    async def _on_message(self, data:bytes) -> None:
         """Receive messages from the Tesla BLE data."""
         try:
             msg = RoutableMessage.FromString(data)
         except DecodeError as e:
             LOGGER.error(f"Error parsing message: {e}")
+            self._recv = bytearray()
+            self._recv_len = 0
             return
 
-        # Update Session
-        if(msg.session_info):
-            info = SessionInfo.FromString(msg.session_info)
-            LOGGER.debug(f"Received session info: {info}")
-            self._sessions[msg.from_destination.domain].update(info)
-
         if(msg.to_destination.routing_address != self._from_destination):
-            # Get the ephemeral key here and save to self._ekey
+            # Ignore ephemeral key broadcasts
             return
 
-        if msg.from_destination.domain == Domain.DOMAIN_VEHICLE_SECURITY:
-            submsg = FromVCSECMessage.FromString(msg.protobuf_message_as_bytes)
-            print(submsg)
-        elif msg.from_destination.domain == Domain.DOMAIN_INFOTAINMENT:
-            submsg = Response.FromString(msg.protobuf_message_as_bytes)
-            print(submsg)
+        LOGGER.info(f"Received response: {msg}")
+        await self._queues[msg.from_destination.domain].put(msg)
 
-        if(self._futures[msg.from_destination.domain]):
-            LOGGER.debug(f"Received response for request {msg.request_uuid}")
-            self._futures[msg.from_destination.domain].set_result(msg)
-            return
-
-    async def _create_future(self, domain: Domain) -> Future:
-        if(not self._sessions[domain].lock.locked):
-            raise ValueError("Session is not locked")
-        self._futures[domain] = get_running_loop().create_future()
-        return self._futures[domain]
-
-    async def _send(self, msg: RoutableMessage) -> RoutableMessage:
+    async def _send(self, msg: RoutableMessage, requires: str) -> RoutableMessage:
         """Serialize a message and send to the vehicle and wait for a response."""
         domain = msg.to_destination.domain
         async with self._sessions[domain].lock:
             LOGGER.debug(f"Sending message {msg}")
-            future = await self._create_future(domain)
+
             payload = prependLength(msg.SerializeToString())
 
+            # Empty the queue before sending the message
+            while not self._queues[domain].empty():
+                await self._queues[domain].get()
             await self.client.write_gatt_char(WRITE_UUID, payload, True)
 
-            resp = await future
-            LOGGER.debug(f"Received message {resp}")
+            # Process the response
+            async with asyncio.timeout(10):
+                while True:
+                    resp = await self._queues[domain].get()
+                    LOGGER.debug(f"Received message {resp}")
 
-            if resp.signedMessageStatus.signed_message_fault:
-                raise MESSAGE_FAULTS[resp.signedMessageStatus.signed_message_fault]
+                    self.validate_msg(resp)
 
-            return resp
+                    if resp.HasField(requires):
+                        return resp
 
     async def pair(self, role: Role = Role.ROLE_OWNER, form: KeyFormFactor = KeyFormFactor.KEY_FORM_FACTOR_CLOUD_KEY):
         """Pair the key."""
@@ -210,10 +223,179 @@ class VehicleBluetooth(Commands):
         )
         resp = await self._send(msg)
         respMsg = FromVCSECMessage.FromString(resp.protobuf_message_as_bytes)
-        print(respMsg)
         if(respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation):
             if(respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation < len(WHITELIST_OPERATION_STATUS)):
                 raise WHITELIST_OPERATION_STATUS[respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation]
             else:
-                raise ValueError(f"Unknown whitelist operation status: {respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation}")
+                raise WhitelistOperationStatus(f"Unknown whitelist operation failure: {respMsg.commandStatus.whitelistOperationStatus.whitelistOperationInformation}")
         return
+
+    async def wake_up(self):
+        """Wake up the vehicle."""
+        return await self._sendVehicleSecurity(
+            UnsignedMessage(RKEAction=RKEAction_E.RKE_ACTION_WAKE_VEHICLE)
+        )
+
+    async def vehicle_data(self, endpoints: list[BluetoothVehicleData]) -> VehicleData:
+        """Get vehicle data."""
+        return await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getChargeState = GetChargeState() if BluetoothVehicleData.CHARGE_STATE in endpoints else None,
+                        getClimateState = GetClimateState() if BluetoothVehicleData.CLIMATE_STATE in endpoints else None,
+                        getDriveState = GetDriveState() if BluetoothVehicleData.DRIVE_STATE in endpoints else None,
+                        getLocationState = GetLocationState() if BluetoothVehicleData.LOCATION_STATE in endpoints else None,
+                        getClosuresState = GetClosuresState() if BluetoothVehicleData.CLOSURES_STATE in endpoints else None,
+                        getChargeScheduleState = GetChargeScheduleState() if BluetoothVehicleData.CHARGE_SCHEDULE_STATE in endpoints else None,
+                        getPreconditioningScheduleState = GetPreconditioningScheduleState() if BluetoothVehicleData.PRECONDITIONING_SCHEDULE_STATE in endpoints else None,
+                        getTirePressureState = GetTirePressureState() if BluetoothVehicleData.TIRE_PRESSURE_STATE in endpoints else None,
+                        getMediaState = GetMediaState() if BluetoothVehicleData.MEDIA_STATE in endpoints else None,
+                        getMediaDetailState = GetMediaDetailState() if BluetoothVehicleData.MEDIA_DETAIL_STATE in endpoints else None,
+                        getSoftwareUpdateState = GetSoftwareUpdateState() if BluetoothVehicleData.SOFTWARE_UPDATE_STATE in endpoints else None,
+                        getParentalControlsState = GetParentalControlsState() if BluetoothVehicleData.PARENTAL_CONTROLS_STATE in endpoints else None,
+                    )
+                )
+            )
+        )
+
+    async def charge_state(self) -> ChargeState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getChargeState=GetChargeState()
+                    )
+                )
+            )
+        )).charge_state
+
+    async def climate_state(self) -> ClimateState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getClimateState=GetClimateState()
+                    )
+                )
+            )
+        )).climate_state
+
+    async def drive_state(self) -> DriveState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getDriveState=GetDriveState()
+                    )
+                )
+            )
+        )).drive_state
+
+    async def location_state(self) -> LocationState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getLocationState=GetLocationState()
+                    )
+                )
+            )
+        )).location_state
+
+    async def closures_state(self) -> ClosuresState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getClosuresState=GetClosuresState()
+                    )
+                )
+            )
+        )).closures_state
+
+    async def charge_schedule_state(self) -> ChargeScheduleState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getChargeScheduleState=GetChargeScheduleState()
+                    )
+                )
+            )
+        )).charge_schedule_state
+
+    async def preconditioning_schedule_state(self) -> PreconditioningScheduleState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getPreconditioningScheduleState=GetPreconditioningScheduleState()
+                    )
+                )
+            )
+        )).preconditioning_schedule_state
+
+    async def tire_pressure_state(self) -> TirePressureState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getTirePressureState=GetTirePressureState()
+                    )
+                )
+            )
+        )).tire_pressure_state
+
+    async def media_state(self) -> MediaState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getMediaState=GetMediaState()
+                    )
+                )
+            )
+        )).media_state
+
+    async def media_detail_state(self) -> MediaDetailState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getMediaDetailState=GetMediaDetailState()
+                    )
+                )
+            )
+        )).media_detail_state
+
+    async def software_update_state(self) -> SoftwareUpdateState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getSoftwareUpdateState=GetSoftwareUpdateState()
+                    )
+                )
+            )
+        )).software_update_state
+
+    async def parental_controls_state(self) -> ParentalControlsState:
+        return (await self._getInfotainment(
+            Action(
+                vehicleAction=VehicleAction(
+                    getVehicleData=GetVehicleData(
+                        getParentalControlsState=GetParentalControlsState()
+                    )
+                )
+            )
+        )).parental_controls_state
+
+    async def vehicle_state(self) -> VehicleStatus:
+        return await self._getVehicleSecurity(
+            UnsignedMessage(
+                InformationRequest=InformationRequest(
+                    informationRequestType=InformationRequestType.INFORMATION_REQUEST_TYPE_GET_STATUS
+                )
+            )
+        )