def test_receive_appmessage_string(): pebble = Mock() calls = [0] def handle_result(txid, uuid, result): assert uuid == UUID(int=128) assert txid == 42 assert result == { 14: "hello!", 15: "éclair", # null terminated -> 'foo' should be omitted. 16: "hello\uFFFDworld", # invalid unicode -> U+FFFD REPLACEMENT CHARACTER } calls[0] += 1 service = AppMessageService(pebble) service.register_handler("appmessage", handle_result) assert pebble.register_endpoint.call_args is not None callback = pebble.register_endpoint.call_args[0][1] callback( AppMessage( transaction_id=42, data=AppMessagePush( uuid=UUID(int=128), dictionary=[ AppMessageTuple(key=14, type=AppMessageTuple.Type.CString, data=b"hello!\x00"), AppMessageTuple(key=15, type=AppMessageTuple.Type.CString, data="éclair".encode('utf-8') + b'\x00foo',), AppMessageTuple(key=16, type=AppMessageTuple.Type.CString, data=b"hello\xffworld"), ] ) ) ) pebble.send_packet.assert_called_once_with(AppMessage(transaction_id=42, data=AppMessageACK())) assert calls[0] == 1
class PebbleManager(object): def __init__(self, qemu): self.qemu = qemu.split(":") print self.qemu self.pebble = PebbleConnection(QemuTransport(*self.qemu), log_packet_level=logging.DEBUG) self.handle_start = None self.handle_stop = None self.blobdb = None self.launcher = None def connect(self): self.pebble.connect() greenlet = gevent.spawn(self.pebble.run_sync) self.pebble.fetch_watch_info() self.register_endpoints() self.pebble.transport.send_packet(QemuBluetoothConnection(connected=True), target=MessageTargetQemu()) self.blobdb = BlobDBClient(self.pebble) self.request_running_app() logger.info("connected to %s", self.qemu) return greenlet def disconnect(self): if self.launcher is not None: self.launcher.shutdown() def register_endpoints(self): self.pebble.register_endpoint(AppRunState, self.handle_lifecycle) self.launcher = AppMessageService(self.pebble, message_type=LegacyAppLaunchMessage) self.launcher.register_handler("appmessage", self.handle_launcher) def request_running_app(self): if self.pebble.firmware_version.major >= 3: self.pebble.send_packet(AppRunState(data=AppRunStateRequest())) else: self.launcher.send_message(uuid.UUID(int=0), {LegacyAppLaunchMessage.Keys.StateFetch: Uint8(1)}) def handle_lifecycle(self, packet): if isinstance(packet.data, AppRunStateStart): if callable(self.handle_start): self.handle_start(packet.data.uuid) elif isinstance(packet.data, AppRunStateStop): if callable(self.handle_stop): self.handle_stop(packet.data.uuid) def handle_launcher(self, txid, uuid, message): state = message[LegacyAppLaunchMessage.Keys.RunState] if state == LegacyAppLaunchMessage.States.Running: if callable(self.handle_start): self.handle_start(uuid) elif state == LegacyAppLaunchMessage.States.NotRunning: if callable(self.handle_stop): self.handle_stop(uuid) @property def timeline_is_supported(self): return self.pebble.firmware_version.major >= 3
def test_receive_appmessage_string(): pebble = Mock() calls = [0] def handle_result(txid, uuid, result): assert uuid == UUID(int=128) assert txid == 42 assert result == { 14: "hello!", 15: "éclair", # null terminated -> 'foo' should be omitted. 16: "hello\uFFFDworld", # invalid unicode -> U+FFFD REPLACEMENT CHARACTER } calls[0] += 1 service = AppMessageService(pebble) service.register_handler("appmessage", handle_result) assert pebble.register_endpoint.call_args is not None callback = pebble.register_endpoint.call_args[0][1] callback( AppMessage(transaction_id=42, data=AppMessagePush( uuid=UUID(int=128), dictionary=[ AppMessageTuple(key=14, type=AppMessageTuple.Type.CString, data=b"hello!\x00"), AppMessageTuple( key=15, type=AppMessageTuple.Type.CString, data="éclair".encode('utf-8') + b'\x00foo', ), AppMessageTuple(key=16, type=AppMessageTuple.Type.CString, data=b"hello\xffworld"), ]))) pebble.send_packet.assert_called_once_with( AppMessage(transaction_id=42, data=AppMessageACK())) assert calls[0] == 1
def main(settings): """ Main function for the communicatior, loops here """ if settings.transport == "websocket": pebble = PebbleConnection(WebsocketTransport(settings.device), log_packet_level=logging.DEBUG) else: # No elif, for compatibility with older configs pebble = PebbleConnection(SerialTransport(settings.device), log_packet_level=logging.DEBUG) pebble.connect() # For some reason it seems to timeout for the first time, with "somebody is eating our input" error, # replying seems to help. for loop in range(5): try: pebble.run_async() break except libpebble2.exceptions.TimeoutError: logging.info("Pebble timeouted, retrying..") continue # Register service for app messages appservice = AppMessageService(pebble) handler = CommandHandler(settings) commwatch = CommunicationKeeper(settings, appservice) appservice.register_handler("nack", commwatch.nack_received) appservice.register_handler("ack", commwatch.ack_received) # Start the watchapp pebble.send_packet(AppRunState(command = 0x01, data=AppRunStateStart(uuid = uuid.UUID(settings.uuid)))) # Send our current config for (id_key, id_type) in get_button_ids(): id_full = id_key[0] + "," + id_type[0] if id_full in settings.key_mappings: status = "T" else: status = "F" data = id_key[0] + id_type[0] + status commwatch.send_message({COMMUNICATION_KEY_CONFIG: CString(data)}) # Wait for all for loop in range(10): if len(commwatch.pending) == 0: break if commwatch.error: raise PebbleConnectionException("Commwatch:" + commwatch.error) time.sleep(0.1) else: raise PebbleConnectionException("Pebble not respoding to config") logging.info("Connection ok, entering to active state..") appservice.register_handler("appmessage", handler.message_received_event) while True: commwatch.send_message({COMMUNICATION_KEY_PING: Uint8(0)}) time.sleep(10)
def meminiSense(startDateTime,hostIP,BASE_PORT,streaming=True,logging=True): global meminifilename #logging.basicConfig(level=logging.INFO) #file_path = "/media/card/memini/" #if file_path is None: # print("DID NOT FIND PEBBLE_DATA_LOC") # #print(os.environ) # exit(1) #if not os.path.exists(file_path): # os.mkdir(file_path) # #filename = str(file_path) + "memini_data.csv" running = True #pebble = PebbleConnection(SerialTransport("/dev/rfcomm0")) #pebble.connect() while True: try: pebble = PebbleConnection(SerialTransport("/dev/rfcomm0")) pebble.connect() #print "connection try 0!" appUUID = APP_UUID[:] while running: try: print "Attempt to Connect" #logging.info("Attempting to connect to pebble") pebble.run_async() print "Connection Success" #logging.info("Pebble connection success") break except libpebble2.exceptions.TimeoutError: print "Pebble timeouted, retrying.." continue #print "Opening file!" #with open(meminifilename,'a') as dataFile: # dataFile.write("message,timestamp,button_id,click_type,battery_charge\n") if pebble.connected: restart_app_on_watch(pebble,appUUID) with open(meminifilename,'a') as dataFile: dataFile.write("message,timestamp,button_id,click_type,battery_charge\n") # Register service for app messages mainMsgService = AppMessageService(pebble) mainCommHandler = CommunicationKeeper(appUUID, mainMsgService) mainMsgService.register_handler("nack", mainCommHandler.nack_received) mainMsgService.register_handler("ack", mainCommHandler.ack_received) mainMsgHandler = AppMsgHandler(appUUID) mainMsgService.register_handler("appmessage", mainMsgHandler.message_received_event) while pebble.connected: # time.sleep(10) memini_main(mainMsgService,mainCommHandler,mainMsgHandler) except SerialException: print("Error: Pebble Disconnected!") time.sleep(30) exit(2)
def meminiSense(startDateTime,hostIP,BASE_PORT,streaming=True,logging=True): global meminifilename global agiType global agiIndx global agiStatus global server_address server_address = (hostIP, BASE_PORT) startTimeDT = rNTPTime.stripDateTime(startDateTime) #logging.basicConfig(level=logging.INFO) #file_path = "/media/card/memini/" #if file_path is None: # print("DID NOT FIND PEBBLE_DATA_LOC") # #print(os.environ) # exit(1) #if not os.path.exists(file_path): # os.mkdir(file_path) # #filename = str(file_path) + "memini_data.csv" running = True #pebble = PebbleConnection(SerialTransport("/dev/rfcomm0")) #pebble.connect() while True: try: pebble = PebbleConnection(SerialTransport("/dev/rfcomm0")) pebble.connect() pebble.pump_reader() #print "connection try 0!" appUUID = APP_UUID[:] print "initializing Pebble connection.." # print pebble.send_and_read(AppRunState(data=AppRunStateRequest()), AppRunState).data.uuid while running: try: print "Attempt to Connect" #logging.info("Attempting to connect to pebble") pebble.run_async() print "Connection Success" #logging.info("Pebble connection success") break except libpebble2.exceptions.TimeoutError: print "Pebble timeouted, retrying.." continue while pebble.connected: try: print "Pebble Connected.." restart_app_on_watch(pebble,appUUID) with open(meminifilename,'a') as dataFile: dataFile.write("message,timestamp,button_id,click_type,battery_charge\n") # Register service for app messages print "initializing Services..." mainMsgService = AppMessageService(pebble) mainCommHandler = CommunicationKeeper(appUUID, mainMsgService) mainMsgService.register_handler("nack", mainCommHandler.nack_received) mainMsgService.register_handler("ack", mainCommHandler.ack_received) mainMsgHandler = AppMsgHandler(appUUID) mainMsgService.register_handler("appmessage", mainMsgHandler.message_received_event) break except Exception as err: print err print "Error Initializing Services, retrying.." pebble.run_async() continue while pebble.connected: # time.sleep(10) is_app_on(pebble,appUUID) pebbleMessage = [] pebbleMessage.append("checkNoti") #check for notiFlag from basestation pebbleMessage.append(str(BASE_PORT)) temp = rNTPTime.checkNoti(hostIP, pebbleMessage, 5) # if True: #for testing if int(rNTPTime.notiFlag) == 1: memini_main(mainMsgService,mainCommHandler,mainMsgHandler) # print("sending Message") else: #print "NO NOTIFICATION" time.sleep(NOTI_CHECK_DELAY) except SerialException: print("Pebble Disconnected!") time.sleep(30) continue except Exception as err: print err pass
class PebbleManager(object): def __init__(self, qemu): self.qemu = qemu.split(':') print self.qemu self.pebble = PebbleConnection(QemuTransport(*self.qemu), log_packet_level=logging.DEBUG) self.handle_start = None self.handle_stop = None self.blobdb = None self.launcher = None def connect(self): self.pebble.connect() greenlet = gevent.spawn(self.pebble.run_sync) self.pebble.fetch_watch_info() self.register_endpoints() self.pebble.transport.send_packet( QemuBluetoothConnection(connected=True), target=MessageTargetQemu()) self.blobdb = BlobDBClient(self.pebble) self.request_running_app() logger.info('connected to %s', self.qemu) return greenlet def disconnect(self): if self.launcher is not None: self.launcher.shutdown() def register_endpoints(self): self.pebble.register_endpoint(AppRunState, self.handle_lifecycle) self.launcher = AppMessageService(self.pebble, message_type=LegacyAppLaunchMessage) self.launcher.register_handler("appmessage", self.handle_launcher) def request_running_app(self): if self.pebble.firmware_version.major >= 3: self.pebble.send_packet(AppRunState(data=AppRunStateRequest())) else: self.launcher.send_message( uuid.UUID(int=0), {LegacyAppLaunchMessage.Keys.StateFetch: Uint8(1)}) def handle_lifecycle(self, packet): if isinstance(packet.data, AppRunStateStart): if callable(self.handle_start): self.handle_start(packet.data.uuid) elif isinstance(packet.data, AppRunStateStop): if callable(self.handle_stop): self.handle_stop(packet.data.uuid) def handle_launcher(self, txid, uuid, message): state = message[LegacyAppLaunchMessage.Keys.RunState] if state == LegacyAppLaunchMessage.States.Running: if callable(self.handle_start): self.handle_start(uuid) elif state == LegacyAppLaunchMessage.States.NotRunning: if callable(self.handle_stop): self.handle_stop(uuid) @property def timeline_is_supported(self): return self.pebble.firmware_version.major >= 3