def read_packet(self):
while True:
if len(self.assembled_data) > 0:
try:
packet, length = QemuInboundPacket.parse(
self.assembled_data)
except PacketDecodeError:
pass
else:
self.assembled_data = self.assembled_data[length:]
if packet.signature == HEADER_SIGNATURE and packet.footer == FOOTER_SIGNATURE:
if isinstance(packet.data, QemuSPP):
return MessageTargetWatch(), packet.data.payload
else:
return MessageTargetQemu(
packet.protocol), packet.data
else:
raise PacketDecodeError(
"QemuTransport: signature mismatch ({:x} = {:x}, {:x} = {:x})"
.format(
packet.signature,
HEADER_SIGNATURE,
packet.footer,
FOOTER_SIGNATURE,
))
try:
received = self.socket.recv(self.BUFFER_SIZE)
if len(received) == 0:
self._connected = False
raise ConnectionError("Disconnected.")
self.assembled_data += received
except socket.error:
self._connected = False
raise ConnectionError("Disconnected.")
def read_packet(self):
try:
data = self.connection.read(2)
except serial.SerialException:
self.connection.close()
raise ConnectionError("Disconnected from watch.")
if len(data) < 2:
raise ConnectionError("Got malformed packet.")
length, = struct.unpack('!H', data)
data += self.connection.read(length + 2)
return MessageTargetWatch(), data
def send_packet(self, message, target=MessageTargetWatch()):
try:
if isinstance(target, MessageTargetWatch):
start_idx = 0
bytes_left = len(message)
while bytes_left:
bytes_to_send = bytes_left
if bytes_to_send > self.BUFFER_SIZE:
bytes_to_send = self.BUFFER_SIZE
chunk = message[start_idx:start_idx + bytes_to_send]
self.socket.send(
QemuPacket(data=QemuSPP(payload=chunk)).serialise())
bytes_left -= bytes_to_send
start_idx += bytes_to_send
elif isinstance(target, MessageTargetQemu):
if not target.raw:
self.socket.send(QemuPacket(data=message).serialise())
else:
self.socket.send(
QemuRawPacket(protocol=target.protocol,
data=message).serialise())
else:
assert False
except socket.error as e:
self._connected = False
raise ConnectionError(str(e))
def connect(self):
try:
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((self.host, self.port))
except socket.error as e:
raise ConnectionError(str(e))
self._connected = True
def connect(self):
try:
self.connection = serial.Serial(self.device, 115200)
except OSError as e:
if e.errno == errno.EBUSY:
raise ConnectionError("Could not connect to Pebble.")
else:
raise
def read_packet(self):
opcode, message = self.ws.recv_data()
if opcode == websocket.ABNF.OPCODE_BINARY:
endpoint, = struct.unpack_from('B', message, 0)
if from_watch.get(endpoint, None) == WebSocketRelayFromWatch:
return MessageTargetWatch(), message[1:]
else:
packet, length = from_watch[endpoint].parse(message[1:])
return MessageTargetPhone(), packet
elif opcode == websocket.ABNF.OPCODE_CLOSE:
raise ConnectionError("Connection gracefully closed by peer.")
else:
raise PebbleError(
"Got unexpected WebSocket opcode {}".format(opcode))
def connect(self):
try:
self.ws = websocket.create_connection(self.url)
except (websocket.WebSocketException, socket.error) as e:
raise ConnectionError(str(e))