def restart_app_on_watch(pebble, appUUID):
current_app_uuid = pebble.send_and_read(
AppRunState(data=AppRunStateRequest()), AppRunState).data.uuid
# Re-start the watchapp
pebble.send_packet(
AppRunState(command=0x01,
data=AppRunStateStop(uuid=uuid.UUID(appUUID))))
print("Restart Pebble App!")
time.sleep(1)
pebble.send_packet(
AppRunState(command=0x01,
data=AppRunStateStart(uuid=uuid.UUID(appUUID))))
time.sleep(1)
#print(current_app_uuid)
if current_app_uuid != uuid.UUID(appUUID):
# Re-start the watchapp
pebble.send_packet(
AppRunState(command=0x01,
data=AppRunStateStop(uuid=uuid.UUID(appUUID))))
print("Pebble App Closed!")
time.sleep(5)
pebble.send_packet(
AppRunState(command=0x01,
data=AppRunStateStart(uuid=uuid.UUID(appUUID))))
time.sleep(2)
return
def is_app_on(pebble,appUUID):
try:
current_app_uuid = pebble.send_and_read(AppRunState(data=AppRunStateRequest()), AppRunState).data.uuid
#print(current_app_uuid)
if current_app_uuid != uuid.UUID(appUUID):
# Re-start the watchapp
pebble.send_packet(AppRunState(command = 0x01, data=AppRunStateStop(uuid = uuid.UUID(appUUID))))
print("Pebble App Closed!")
time.sleep(5)
pebble.send_packet(AppRunState(command = 0x01, data=AppRunStateStart(uuid = uuid.UUID(appUUID))))
time.sleep(2)
return
except :
print "Pebble Disconnected"
return
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 _ensure_correct_app(self, try_install=True):
project = PebbleProject()
if project.project_type != 'native':
raise ToolError("Only native apps can be debugged using gdb.")
current_app_uuid = self.pebble.send_and_read(
AppRunState(data=AppRunStateRequest()), AppRunState).data.uuid
if current_app_uuid != project.uuid:
print("Launching {}...".format(project.long_name))
# Try launching the app we want. This just does nothing if the app doesn't exist.
# Edge case: the app exists in blobdb but isn't installed. This shouldn't come up with the pebble tool.
queue = self.pebble.get_endpoint_queue(AppRunState)
try:
self.pebble.send_packet(
AppRunState(data=AppRunStateStart(uuid=project.uuid)))
while True:
packet = queue.get(timeout=0.5)
if isinstance(packet.data, AppRunStateStart
) and packet.data.uuid == project.uuid:
break
except TimeoutError:
if try_install:
print("App did not launch. Trying to install it...")
try:
ToolAppInstaller(self.pebble).install()
except IOError:
raise ToolError(
"The app to debug must be built and installed on the watch."
)
self._ensure_correct_app(try_install=False)
else:
raise ToolError(
"The app to debug must be running on the watch to start gdb."
)
finally:
queue.close()
def _install_modern(self):
metadata = self._bundle.get_app_metadata()
app_uuid = metadata['uuid']
blob_packet = AppMetadata(
uuid=app_uuid,
flags=metadata['flags'],
icon=metadata['icon_resource_id'],
app_version_major=metadata['app_version_major'],
app_version_minor=metadata['app_version_minor'],
sdk_version_major=metadata['sdk_version_major'],
sdk_version_minor=metadata['sdk_version_minor'],
app_face_bg_color=0,
app_face_template_id=0,
app_name=metadata['app_name'])
result = SyncWrapper(self._blobdb.insert, BlobDatabaseID.App, app_uuid,
blob_packet.serialise()).wait()
if result != BlobStatus.Success:
raise AppInstallError("BlobDB error: {!s}".format(result))
# Start the app.
app_fetch = self._pebble.send_and_read(
AppRunState(data=AppRunStateStart(uuid=app_uuid)), AppFetchRequest)
if app_fetch.uuid != app_uuid:
self._pebble.send_packet(
AppFetchResponse(response=AppFetchStatus.InvalidUUID))
raise AppInstallError(
"App requested the wrong UUID! Asked for {}; expected {}".
format(app_fetch.uuid, app_uuid))
self._broadcast_event('progress', 0, self.total_sent, self.total_size)
# Send the app over
binary = self._bundle.zip.read(self._bundle.get_app_path())
self._send_part(PutBytesType.Binary, binary, app_fetch.app_id)
if self._bundle.has_resources:
resources = self._bundle.zip.read(self._bundle.get_resource_path())
self._send_part(PutBytesType.Resources, resources,
app_fetch.app_id)
if self._bundle.has_worker:
worker = self._bundle.zip.read(self._bundle.get_worker_path())
self._send_part(PutBytesType.Worker, worker, app_fetch.app_id)
def main(settings):
""" Main function for the communicator, 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()
if (pebble.connected):
print("Pebble successfully connected.")
try:
pebble.run_async()
except libpebble2.exceptions.TimeoutError:
print("Pebble timeouted")
logging.info("Pebble timeouted")
# Install app
AppInstaller(pebble, "../hotpebble.pbw").install()
# 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))))
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)