Fixes and improvements

Author: Bre77

tesla_fleet_api/tesla/bluetooth.py

@@ -1,5 +1,6 @@
 """Bluetooth only interface."""
 
+import hashlib
 import re
 from .tesla import Tesla
 from .vehicle.bluetooth import VehicleBluetooth
@@ -16,7 +17,11 @@ def __init__(
 
     def valid_name(self, name: str) -> bool:
         """Check if a BLE device name is a valid Tesla vehicle."""
-        return bool(re.match("^S[a-f0-9]{16}[A-F]$", name))
+        return bool(re.match("^S[a-f0-9]{16}[CDRP]$", name))
+
+    def get_name(self, vin: str) -> str:
+        """Get the name of a vehicle."""
+        return "S" + hashlib.sha1(vin.encode('utf-8')).hexdigest()[:16] + "C"
 
 class Vehicles(dict[str, VehicleBluetooth]):
     """Class containing and creating vehicles."""

tesla_fleet_api/tesla/vehicle/__init__.py

@@ -0,0 +1,13 @@
+"""Tesla Fleet API classes."""
+
+from .vehicles import Vehicles
+from .fleet import VehicleFleet
+from .bluetooth import VehicleBluetooth
+from .signed import VehicleSigned
+
+__all__ = [
+    "Vehicles",
+    "VehicleFleet",
+    "VehicleBluetooth",
+    "VehicleSigned",
+]

tesla_fleet_api/tesla/vehicle/bluetooth.py

@@ -84,20 +84,34 @@ async def discover(self, scanner: BleakScanner = BleakScanner()) -> BleakClient:
             raise ValueError(f"Device {self.ble_name} not found")
         self._device = device
         self.client = BleakClient(self._device, services=[SERVICE_UUID])
-        LOGGER.info(f"Discovered device {self._device.name} {self._device.address}")
+        LOGGER.debug(f"Discovered device {self._device.name} {self._device.address}")
+        return self.client
+
+    def create_client(self, mac:str):
+        """Create a client with a MAC."""
+        self.client = BleakClient(mac, services=[SERVICE_UUID])
         return self.client
 
     async def connect(self, mac:str | None = None) -> None:
         """Connect to the Tesla BLE device."""
         if mac is not None:
-            self.client = BleakClient(mac, services=[SERVICE_UUID])
+            self.create_client(mac)
         await self.client.connect()
         await self.client.start_notify(READ_UUID, self._on_notify)
 
     async def disconnect(self) -> bool:
         """Disconnect from the Tesla BLE device."""
         return await self.client.disconnect()
 
+    async def __aenter__(self) -> VehicleBluetooth:
+        """Enter the async context."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit the async context."""
+        await self.disconnect()
+
     def _on_notify(self,sender: BleakGATTCharacteristic,data : bytearray):
         """Receive data from the Tesla BLE device."""
         if self._recv_len:
@@ -157,15 +171,14 @@ async def _send(self, msg: RoutableMessage) -> 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.info(f"Sending message {msg}")
+            LOGGER.debug(f"Sending message {msg}")
             future = await self._create_future(domain)
             payload = prependLength(msg.SerializeToString())
-            LOGGER.info(f"Payload: {payload}")
 
             await self.client.write_gatt_char(WRITE_UUID, payload, True)
 
             resp = await future
-            LOGGER.info(f"Received message {resp}")
+            LOGGER.debug(f"Received message {resp}")
 
             if resp.signedMessageStatus.signed_message_fault:
                 raise MESSAGE_FAULTS[resp.signedMessageStatus.signed_message_fault]

tesla_fleet_api/tesla/vehicle/commands.py

@@ -458,6 +458,13 @@ async def _sendInfotainment(self, command: Action) -> dict[str, Any]:
         """Sign and send a message to Infotainment computer."""
         return await self._command(Domain.DOMAIN_INFOTAINMENT, command.SerializeToString())
 
+    async def handshakeVehicleSecurity(self) -> None:
+        """Perform a handshake with the vehicle security domain."""
+        await self._handshake(Domain.DOMAIN_VEHICLE_SECURITY)
+
+    async def handshakeInfotainment(self) -> None:
+        """Perform a handshake with the infotainment domain."""
+        await self._handshake(Domain.DOMAIN_INFOTAINMENT)
 
     async def _handshake(self, domain: Domain) -> None:
         """Perform a handshake with the vehicle."""

tesla_fleet_api/tesla/vehicle/vehicles.py

@@ -20,19 +20,27 @@ def __init__(self, parent: TeslaFleetApi):
         self._parent = parent
 
     def createFleet(self, vin: str) -> VehicleFleet:
-        """Creates a specific vehicle."""
+        """Creates a Fleet API vehicle."""
         vehicle = VehicleFleet(self._parent, vin)
         self[vin] = vehicle
         return vehicle
 
     def createSigned(self, vin: str) -> VehicleSigned:
-        """Creates a specific vehicle."""
+        """Creates a Fleet API vehicle that uses command protocol."""
         vehicle = VehicleSigned(self._parent, vin)
         self[vin] = vehicle
         return vehicle
 
     def createBluetooth(self, vin: str) -> VehicleBluetooth:
-        """Creates a specific vehicle."""
+        """Creates a bluetooth vehicle that uses command protocol."""
         vehicle = VehicleBluetooth(self._parent, vin)
         self[vin] = vehicle
         return vehicle
+
+    def specific(self, vin: str) -> Vehicle:
+        """Legacy method for creating a Fleet API vehicle."""
+        return self.createFleet(vin)
+
+    def specificSigned(self, vin: str) -> VehicleSigned:
+        """Legacy method for creating a Fleet API vehicle that uses command protocol."""
+        return self.createSigned(vin)