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)
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 _connect_emulator(self, platform, sdk):
connection = PebbleConnection(ManagedEmulatorTransport(platform, sdk), **self._get_debug_args())
connection.connect()
connection.run_async()
# Make sure the timezone is set usefully.
if connection.firmware_version.major >= 3:
ts = time.time()
tz_offset = -time.altzone if time.localtime(ts).tm_isdst and time.daylight else -time.altzone
tz_offset_minutes = tz_offset // 60
tz_name = "UTC%+d" % (tz_offset_minutes / 60)
connection.send_packet(TimeMessage(message=SetUTC(unix_time=ts, utc_offset=tz_offset_minutes, tz_name=tz_name)))
return connection
def _connect_emulator(self, platform, sdk):
connection = PebbleConnection(ManagedEmulatorTransport(platform, sdk), **self._get_debug_args())
connection.connect()
connection.run_async()
# Make sure the timezone is set usefully.
if connection.firmware_version.major >= 3:
ts = time.time()
tz_offset = -time.altzone if time.localtime(ts).tm_isdst and time.daylight else -time.timezone
tz_offset_minutes = tz_offset // 60
tz_name = "UTC%+d" % (tz_offset_minutes / 60)
connection.send_packet(TimeMessage(message=SetUTC(unix_time=ts, utc_offset=tz_offset_minutes, tz_name=tz_name)))
return connection
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)
type=argparse.FileType("rb"))
parser.add_argument("--resources",
metavar="FILE",
help="System resources pack",
required=True,
type=argparse.FileType("rb"))
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--serial",
metavar="DEVICE",
dest="transport",
type=SerialTransport)
args = parser.parse_args()
pebble = PebbleConnection(args.transport)
pebble.connect()
pebble.run_async()
pebble.send_and_read(
SystemMessage(message_type=SystemMessage.Type.FirmwareUpdateStart),
SystemMessage)
PutBytes(pebble, PutBytesType.Firmware, args.firmware.read(), bank=0).send()
PutBytes(pebble, PutBytesType.SystemResources, args.resources.read(),
bank=0).send()
pebble.send_packet(
SystemMessage(message_type=SystemMessage.Type.FirmwareUpdateComplete))
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
