def run(self): """Run Worker Thread.""" print("started worker") # Re-instantiate console in-thread to prevent gevent fuckery self._console = Console(self.addr, self.name, self.uuid, self.liveid) self._console.protocol.crypto = self.crypto # make a callback for on_system_input def on_text(console, payload): wx.PostEvent(self._notify_window, TextPromptEvent(payload)) print("reached connect") self._console.add_manager(TextManager) self._console.text.on_systemtext_input += functools.partial(on_text, self._console) status = self._console.connect(self.userhash, self.token) self._console.wait(1) if status == ConnectionState.Connected: self._notify_window.GetParent().GetParent().SetStatusText("Connected") wx.PostEvent(self._notify_window, ResultEvent("Connected")) print("Connected") self._console.protocol.serve_forever() else: self._notify_window.GetParent().GetParent().SetStatusText("Connection Failed") self._notify_window.GetParent().GetParent().SetStatusText("Disconnected") print("Disconnected") wx.PostEvent(self._notify_window, ResultEvent("Disconnected"))
def turn_on(self): """Turn on the Xbox.""" from xbox.sg.console import Console _LOGGER.debug( f'About to turn on { self._name } on ip { self._ip_address } with live id { self._live_id }!' ) Console.power_on(self._live_id, addr=self._ip_address, tries=10)
def getInstance(self, mode='default', connect=True): print("[Xbox.getInstance] called (mode: %s, connect: %s)" % (mode, connect)) if self.console_data == False: data = self.findDevice() if data == False: print("[Xbox.getInstance] Result of self.findDevice() = %s" % data) return False self.console = Console( address=self.console_data.get("address"), name=self.console_data.get("name"), uuid=self.console_data.get("uuid"), liveid=self.console_data.get("liveid"), flags=self.console_data.get("flags"), public_key=self.console_data.get("public_key"), ) if connect == False: return self.console else: print( "[Xbox.getInstance] Checking if console data is still up to date" ) console = self.findDevice() if console != False: print("[Xbox.getInstance] Connecting to Xbox") if mode == 'media': print("[Xbox.getInstance] Activated MediaManager (beta)") self.console.add_manager(MediaManager) #self.console.media.on_media_state += self.onMediaState if mode == 'stump': print("[Xbox.getInstance] Activated StumpManager (beta)") self.console.add_manager(StumpManager) #self.console.media.on_media_state += self.onMediaState state = self.console.connect() if state == ConnectionState.Connected: print("[Xbox.getInstance] Xbox Connected") self.console.wait(0.5) connected = True else: print( "[Xbox.getInstance] [ERROR] Could not connect to Xbox") conected = False else: print("[Xbox.getInstance] Xbox not found on network") connected = False if connected == True: return self.console else: return False
class XboxThread(threading.Thread): """Xbox Worker Thread""" def __init__(self, notify_window, addr, name, uuid, liveid, crypto, userhash, token): """Init Worker Thread Class.""" threading.Thread.__init__(self) self._notify_window = notify_window self.addr = addr self.name = name self.uuid = uuid self.liveid = liveid self.crypto = crypto self.userhash = userhash self.token = token self._console = None self.daemon = True self.start() def run(self): """Run Worker Thread.""" print("started worker") # Re-instantiate console in-thread to prevent gevent fuckery self._console = Console(self.addr, self.name, self.uuid, self.liveid) self._console.protocol.crypto = self.crypto # make a callback for on_system_input def on_text(console, payload): wx.PostEvent(self._notify_window, TextPromptEvent(payload)) print("reached connect") self._console.add_manager(TextManager) self._console.text.on_systemtext_input += functools.partial(on_text, self._console) status = self._console.connect(self.userhash, self.token) self._console.wait(1) if status == ConnectionState.Connected: self._notify_window.GetParent().GetParent().SetStatusText("Connected") wx.PostEvent(self._notify_window, ResultEvent("Connected")) print("Connected") self._console.protocol.serve_forever() else: self._notify_window.GetParent().GetParent().SetStatusText("Connection Failed") self._notify_window.GetParent().GetParent().SetStatusText("Disconnected") print("Disconnected") wx.PostEvent(self._notify_window, ResultEvent("Disconnected")) def abort(self): """abort worker thread.""" # Method for use by main thread to signal an abort if self._console: self._console.protocol.stop() self.join() def send_text(self, text): self._console.send_systemtext_input(text) self._console.finish_text_input()
def on_connect_request(req: ConnectionRequest): auth_mgr = AuthenticationManager.from_file(TOKENS_FILE) auth_mgr.dump(TOKENS_FILE) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt for c in Console.discovered(): if str(c.uuid) == str(req.console_dict['uuid']): self._console = c if self._console is None: self.outq.put( XboxEvent(EVT_XBOX_DISCONNECT_ID, "Failed to connect")) return self._console.add_manager(TextManager) self._console.text.on_systemtext_input += on_text self._console.protocol.on_timeout += lambda: self._timedout.set() try: status = self._console.connect(userhash, token) except OSError as e: self.outq.put( XboxEvent(EVT_XBOX_DISCONNECT_ID, f"Failed to connect {e}")) return self._console.wait(1) self.outq.put(XboxEvent(EVT_XBOX_CONNECT_ID, self._console.address))
def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the Xbox One platform""" from xbox.webapi.authentication.manager import AuthenticationManager from xbox.sg.enum import ConnectionState from xbox.sg.console import Console hass.loop.set_debug(True) ip_address = config.get(CONF_IP_ADDRESS) live_id = config.get(CONF_LIVE_ID) name = config.get(CONF_NAME) tokens_file_name = hass.config.path(config.get(CONF_TOKEN_FILE)) _LOGGER.debug('Trying to authenticate') try: auth_mgr = AuthenticationManager.from_file(tokens_file_name) auth_mgr.authenticate(do_refresh=False) auth_mgr.dump(tokens_file_name) except Exception as e: _LOGGER.error(e) _LOGGER.debug('Authenticated, starting discovery.') consoles = Console.discover(timeout=1, addr=ip_address) if not consoles: _LOGGER.debug('No consoles found, could be turned off') async_add_devices([XboxOne(auth_mgr, live_id, ip_address, name)]) else: async_add_devices([ XboxOne(auth_mgr, live_id, ip_address, name, console) for console in consoles if console.liveid == live_id ])
def load_consoles(filepath): try: with open(filepath, 'r') as fh: consoles = json.load(fh) return [Console.from_dict(c) for c in consoles] except FileNotFoundError: return []
def protocol_runner(video_pipe, audio_pipe): import gevent import logging from xbox.sg.console import Console from xbox.nano.manager import NanoManager from xbox.nano.render.client import Client logging.basicConfig(level=logging.DEBUG) consoles = Console.discover(timeout=1) if len(consoles): console = consoles[0] console.add_manager(NanoManager) console.connect() gevent.sleep(1) print('connected') console.nano.start_stream() console.wait(2) client = Client(PipedSink(video_pipe), PipedSink(audio_pipe), Sink()) console.nano.start_gamestream(client) print('stream started') try: console.protocol.serve_forever() except KeyboardInterrupt: pass print('protocol_runner exit')
def cli_discover_consoles(args): """ Discover consoles """ LOGGER.info('Sending discovery packets to IP: {0}'.format( 'IP: ' + args.address if args.address else '<MULTICAST>')) discovered = Console.discover(addr=args.address, timeout=1) if not len(discovered): LOGGER.error('No consoles discovered') sys.exit(ExitCodes.DiscoveryError) LOGGER.info('Discovered consoles ({0}): {1}'.format( len(discovered), ', '.join([str(c) for c in discovered]))) if args.liveid: LOGGER.info('Filtering discovered consoles for LIVEID: {0}'.format( args.liveid)) discovered = [c for c in discovered if c.liveid == args.liveid] if args.address: LOGGER.info('Filtering discovered consoles for IP address: {0}'.format( args.address)) discovered = [c for c in discovered if c.address == args.address] return discovered
def console(console_address, console_name, uuid_dummy, console_liveid, console_flags, public_key_bytes): c = Crypto.from_bytes(public_key_bytes) console = Console(console_address, console_name, uuid_dummy, console_liveid, console_flags, c.foreign_pubkey) console.add_manager(StumpManager) console.add_manager(MediaManager) console.add_manager(TextManager) console.add_manager(InputManager) return console
def main(): parser = argparse.ArgumentParser(description="Basic smartglass client") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): console = discovered[0] console.on_timeout += on_timeout console.add_manager(InputManager) state = console.connect(userhash, token) if state != ConnectionState.Connected: print("Connection failed") sys.exit(1) console.wait(1) getch = get_getch_func() while True: ch = getch() print(ch) if ord(ch) == 3: # CTRL-C sys.exit(1) elif ch not in input_map: continue button = input_map[ch] console.gamepad_input(button) console.wait(0.1) console.gamepad_input(GamePadButton.Clear) signal.signal(signal.SIGINT, lambda *args: console.protocol.stop()) console.protocol.serve_forever() else: print("No consoles discovered") sys.exit(1)
def do_discovery(self, addr, tries): consoles = Console.discover(addr=addr, tries=tries) print("[Xbox.do_discovery] Consoles found:") print(consoles) if len(consoles) > 0: print("[Xbox.do_discovery] Console found") return consoles[0] else: print("[Xbox.do_discovery] No consoles found") return False
def main(): parser = argparse.ArgumentParser(description="Power off xbox one console") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--liveid', '-l', help="Console Live ID") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--all', action='store_true', help="Power off all consoles") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") args = parser.parse_args() logging.basicConfig(level=logging.INFO) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt if not args.liveid and not args.address and not args.all: print("No arguments supplied!") parser.print_help() sys.exit(1) consoles = Console.discover(timeout=1, addr=args.address) if not len(consoles): print("No consoles found!") sys.exit(1) if not args.all and args.liveid: consoles = [c for c in consoles if c.liveid == args.liveid] if not args.all and args.address: consoles = [c for c in consoles if c.address == args.address] for c in consoles: state = c.connect(userhash, token) if state != ConnectionState.Connected: print("Connecting to %s failed" % c) continue c.wait(1) print("Shutting down %s ..." % c) c.power_off()
def main(): parser = argparse.ArgumentParser(description="Basic smartglass client") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") parser.add_argument('--verbose', '-v', action='store_true', help="Verbose flag, also log message content") args = parser.parse_args() if args.verbose: fmt = VerboseFormatter(logging.BASIC_FORMAT) else: fmt = logging.Formatter(logging.BASIC_FORMAT) handler = logging.StreamHandler() handler.setFormatter(fmt) logging.root.addHandler(handler) logging.root.setLevel(logging.DEBUG) # logging.basicConfig(level=logging.DEBUG, format=logfmt) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): console = discovered[0] console.on_timeout += on_timeout state = console.connect(userhash, token) if state != ConnectionState.Connected: logging.error("Connection failed") sys.exit(1) signal.signal(signal.SIGINT, lambda *args: console.protocol.stop()) console.protocol.serve_forever() else: logging.error("No consoles discovered") sys.exit(1)
def console(): pkey = unhexlify( b'041815d5382df79bd792a8d8342fbc717eacef6a258f779279e5463573e06b' b'f84c6a88fac904870bf3a26f856e65f483195c4323eef47a048f23a031da6bd0929d' ) c = Crypto.from_bytes(pkey) return Console('10.0.0.23', 'XboxOne', uuid.UUID('de305d54-75b4-431b-adb2-eb6b9e546014'), 'FFFFFFFFFFF', enum.PrimaryDeviceFlag.AllowConsoleUsers, c.foreign_pubkey)
def main(): parser = argparse.ArgumentParser(description="Basic smartglass client") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): console = discovered[0] console.add_manager(NanoManager) console.connect(userhash, token) if console.connection_state != ConnectionState.Connected: print("Connection failed") sys.exit(1) console.wait(1) console.nano.start_stream() console.wait(5) client = SDLClient(1920, 1080) console.nano.start_gamestream(client) try: console.protocol.serve_forever() except KeyboardInterrupt: pass else: print("No consoles discovered") sys.exit(1)
def console(console_address, console_name, console_uuid, console_liveid, console_flags, console_public_key): console = Console( address=console_address, name=console_name, uuid=console_uuid, liveid=console_liveid, flags=console_flags, public_key=console_public_key ) console.add_manager(StumpManager) console.add_manager(MediaManager) console.add_manager(TextManager) console.add_manager(InputManager) return console
def power_on(liveid): for i in range(3): if os.environ['XBOX_IP']: Console.power_on(liveid, os.environ['XBOX_IP'], tries=10) else: Console.power_on(liveid, tries=10) Console.wait(1)
def main(): parser = argparse.ArgumentParser(description="Basic smartglass client") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): console = discovered[0] console.on_timeout += on_timeout console.add_manager(TextManager) console.text.on_systemtext_configuration += on_text_config console.text.on_systemtext_input += functools.partial( on_text_input, console) console.text.on_systemtext_done += on_text_done state = console.connect(userhash, token) if state != ConnectionState.Connected: print("Connection failed") sys.exit(1) console.wait(1) signal.signal(signal.SIGINT, lambda *args: console.protocol.stop()) console.protocol.serve_forever() else: print("No consoles discovered") sys.exit(1)
def main(): parser = argparse.ArgumentParser( description="Discover consoles on the network") parser.add_argument('--address', '-a', help="IP address of console") args = parser.parse_args() logging.basicConfig(level=logging.INFO) print("Discovering consoles...") discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): print("Discovered %d consoles:" % len(discovered)) for console in discovered: print("\t%s" % console) else: print("No consoles discovered!")
def async_update(self): from xbox.sg.console import Console from xbox.sg.manager import MediaManager userhash = self._auth_mgr.userinfo.userhash token = self._auth_mgr.xsts_token.jwt _LOGGER.debug(f'Start update') if self._console: _LOGGER.debug( f'Console is present: {self._console.to_dict()} and {self._console.connected}' ) if not self.connected: self._console.add_manager(MediaManager) self._console.connect(userhash=userhash, xsts_token=token) if self.connected: active_media = self._console.media.active_media title_id = self._console.media.title_id aum_id = self._console.media.aum_id asset_id = self._console.media.asset_id media_type = self._console.media.media_type sound_level = self._console.media.sound_level playback_status = self._console.media.playback_status position = self._console.media.position media_start = self._console.media.media_start metadata = self._console.media.metadata _LOGGER.debug(f'The active_media is {active_media}.') _LOGGER.debug(f'The title_id is {title_id}.') _LOGGER.debug(f'The aum_id is {aum_id}.') _LOGGER.debug(f'The asset_id is {asset_id}.') _LOGGER.debug(f'The media_type is {media_type}.') _LOGGER.debug(f'The sound_level is {active_media}.') _LOGGER.debug(f'The playback_status is {playback_status}.') _LOGGER.debug(f'The position is {position}.') _LOGGER.debug(f'The media_start is {media_start}.') _LOGGER.debug(f'The metadata is {metadata}.') else: consoles = Console.discover(timeout=1, addr=self._ip_address) if consoles: filtered_cons = [ c for c in consoles if c.liveid == self._live_id ] if filtered_cons: _LOGGER.debug('Console discovered during update.') self._console = filtered_cons[0] _LOGGER.debug(f'End update')
def _refresh(self): discovered = Console.discover(blocking=True) liveids = [d.liveid for d in discovered] for i, c in enumerate(self.consoles): if c.liveid in liveids: # Refresh existing entries idx = liveids.index(c.liveid) if c.device_status != discovered[idx].device_status: self.consoles[i] = discovered[idx] del discovered[idx] del liveids[idx] elif c.liveid not in liveids: # Set unresponsive consoles to Unavailable self.consoles[i].device_status = DeviceStatus.Unavailable # Add newly discovered consoles self.consoles.extend(discovered) # Update the consolelist view self.walker[:] = [ConsoleButton(self.app, c) for c in self.consoles]
def power_on(liveid, addr=None, iterations=3, tries=10): for i in range(iterations): Console.power_on(liveid, addr=addr, tries=tries) Console.wait(1)
def discover(*args, **kwargs): return Console.discover(*args, **kwargs)
def connect(timeout): discovered = Console.discover(timeout=1) if len(discovered): return discovered[0] return discovered
def power_on(self): if os.environ['XBOX_IP'] != "127.0.0.1": print( "[Xbox.power_on] Booting xbox from config settings (%s, %s)" % (os.environ['XBOX_IP'], os.environ['XBOX_LIVEID'])) Console.power_on(os.environ['XBOX_LIVEID'], os.environ['XBOX_IP'], tries=10) time.sleep(1) Console.power_on(os.environ['XBOX_LIVEID'], os.environ['XBOX_IP'], tries=10) time.sleep(1) Console.power_on(os.environ['XBOX_LIVEID'], os.environ['XBOX_IP'], tries=10) data = True else: console = self.getInstance(connect=False) if console != False: print( "[Xbox.power_on] Booting xbox from discovery settings(%s, %s)" % (self.console_data.get("address"), self.console.get("liveid"))) Console.power_on(self.console_data.get("liveid"), self.console.get("address"), tries=10) time.sleep(1) Console.power_on(self.console_data.get("liveid"), self.console.get("address"), tries=10) time.sleep(1) Console.power_on(self.console_data.get("liveid"), self.console.get("address"), tries=10) data = True else: data = [ 'No device found in cache. Turn on your xbox and run /api/v1/discovery' ] return data
class Xbox: def __init__(self): self.console = False self.console_data = False self.request_id = 0 def findDevice(self, tries=1): print("[Xbox.findDevice] called (Try #%d)" % tries) console = self.discovery(timeout=5, addr=os.environ['XBOX_IP']) if tries == 3: print("[Xbox.findDevice] Max tries reached. No consoles found") return False if isinstance(console, Console): self.console_data = { "address": console.address, "name": console.name, "uuid": console.uuid, "liveid": console.liveid, "flags": console.flags, "public_key": console.public_key, } else: self.console_data = self.findDevice(tries=tries + 1) return self.console_data # def fetchMediaStatus(self, tries = 1): # # print("[Xbox.fetchMediaStatus] called (Try #%d)" % tries) # if tries == 5: # return False # # if self.console.title_id == None: # self.console.protocol.serve_forever() # return self.fetchMediaStatus(tries = tries+1) # else: # return self.console.media_state # def onMediaState(self, state): print(state) print("[Xbox.onMediaState] called (State: %s)" % state) self.console.protocol.shutdown() return def onTimeout(self): self.console.protocol.stop() print("[Xbox.onTimeout] Connection timed out") self.console = False def getInstance(self, mode='default', connect=True): print("[Xbox.getInstance] called (mode: %s, connect: %s)" % (mode, connect)) if self.console_data == False: data = self.findDevice() if data == False: print("[Xbox.getInstance] Result of self.findDevice() = %s" % data) return False self.console = Console( address=self.console_data.get("address"), name=self.console_data.get("name"), uuid=self.console_data.get("uuid"), liveid=self.console_data.get("liveid"), flags=self.console_data.get("flags"), public_key=self.console_data.get("public_key"), ) if connect == False: return self.console else: print( "[Xbox.getInstance] Checking if console data is still up to date" ) console = self.findDevice() if console != False: print("[Xbox.getInstance] Connecting to Xbox") if mode == 'media': print("[Xbox.getInstance] Activated MediaManager (beta)") self.console.add_manager(MediaManager) #self.console.media.on_media_state += self.onMediaState if mode == 'stump': print("[Xbox.getInstance] Activated StumpManager (beta)") self.console.add_manager(StumpManager) #self.console.media.on_media_state += self.onMediaState state = self.console.connect() if state == ConnectionState.Connected: print("[Xbox.getInstance] Xbox Connected") self.console.wait(0.5) connected = True else: print( "[Xbox.getInstance] [ERROR] Could not connect to Xbox") conected = False else: print("[Xbox.getInstance] Xbox not found on network") connected = False if connected == True: return self.console else: return False def discovery(self, timeout, addr): return self.do_discovery(addr=addr, tries=timeout) def do_discovery(self, addr, tries): consoles = Console.discover(addr=addr, tries=tries) print("[Xbox.do_discovery] Consoles found:") print(consoles) if len(consoles) > 0: print("[Xbox.do_discovery] Console found") return consoles[0] else: print("[Xbox.do_discovery] No consoles found") return False def media_command(self, media_command): print("[Xbox.media_command] called (media_command: %s)" % media_command) action = self.console.media_command(0x54321, media_command, self.request_id) return action def power_on(self): if os.environ['XBOX_IP'] != "127.0.0.1": print( "[Xbox.power_on] Booting xbox from config settings (%s, %s)" % (os.environ['XBOX_IP'], os.environ['XBOX_LIVEID'])) Console.power_on(os.environ['XBOX_LIVEID'], os.environ['XBOX_IP'], tries=10) time.sleep(1) Console.power_on(os.environ['XBOX_LIVEID'], os.environ['XBOX_IP'], tries=10) time.sleep(1) Console.power_on(os.environ['XBOX_LIVEID'], os.environ['XBOX_IP'], tries=10) data = True else: console = self.getInstance(connect=False) if console != False: print( "[Xbox.power_on] Booting xbox from discovery settings(%s, %s)" % (self.console_data.get("address"), self.console.get("liveid"))) Console.power_on(self.console_data.get("liveid"), self.console.get("address"), tries=10) time.sleep(1) Console.power_on(self.console_data.get("liveid"), self.console.get("address"), tries=10) time.sleep(1) Console.power_on(self.console_data.get("liveid"), self.console.get("address"), tries=10) data = True else: data = [ 'No device found in cache. Turn on your xbox and run /api/v1/discovery' ] return data def power_off(self): self.console.power_off() self.console.wait(1) self.console = False return True def close(self): print("[Xbox.close] called ()") self.console.disconnect() self.console = False return True def connect(timeout): discovered = Console.discover(timeout=1) if len(discovered): return discovered[0] return discovered
def mainloop(skip_connection=False): while True: if skip_connection: new_item = None try: new_item = self.inq.get_nowait() except: pass if new_item is not None: if isinstance(new_item, DiscoverRequest): try: discovered = Console.discover( addr=new_item.addr) except OSError as e: self.outq.put( XboxEvent(EVT_XBOX_DISCOVERYFAILURE_ID, e)) for console in discovered: dc = DiscoveredConsole(console) self.outq.put( XboxEvent(EVT_XBOX_DISCOVERED_CONSOLE_ID, dc)) if len(discovered) < 1: try: Console.__protocol__.start() Console.__protocol__._discover( xbox.sg.factory.discovery(), xbox.sg.protocol.BROADCAST, 5) except OSError as e: self.outq.put( XboxEvent(EVT_XBOX_DISCOVERYFAILURE_ID, e)) self.inq.task_done() if isinstance(new_item, ConnectionRequest) or isinstance( new_item, DiscoveredConsole): on_connect_request( new_item) # this instantiates self._console self.inq.task_done() if isinstance(new_item, SystemTextSend): if self._console is None or not self._console.connected: error = "Failed to send text. Disconnected!" self.outq.put(error) print(error) else: self._console.send_systemtext_input( new_item.text) self._console.finish_text_input() self.outq.put( f"Sent {new_item.text} to console") self.inq.task_done() if isinstance(new_item, DisconnectRequest): if self._console: if self._console.connected: self._console.protocol._stop_event.set() self._console.disconnect() self.inq.task_done() self.outq.put( XboxEvent( EVT_XBOX_DISCONNECT_ID, self._console.address if self._console else None)) else: self.inq.task_done() self.outq.put( XboxEvent( EVT_XBOX_DISCONNECT_ID, self._console.address if self._console else None)) else: self.inq.task_done() self.outq.put( XboxEvent( EVT_XBOX_DISCONNECT_ID, self._console.address if self._console else None)) if new_item == POISON_PILL: if self._console: if self._console.connected: self._console.disconnect() self._console = None self.inq.put("STOP") self.inq.task_done() break gevent.sleep(0) if self._console: if self._console.connected: # print("console instantiated. started:", self._console.protocol.started) # print("console status:", self._console.connection_state) # print("Closed?:", self._console.protocol.closed) # print("Timedout?:", self._timedout.is_set()) try: "" gevent.sleep( self._console.protocol.HEARTBEAT_INTERVAL) self._console.protocol.ack([], [], ServiceChannel.Core, need_ack=True) except (OSError, AttributeError) as e: self._console.protocol.on_timeout() self.outq.put( XboxEvent(EVT_XBOX_DISCONNECT_ID, f"Failed to connect {e}")) finally: if self._stay_connected.is_set( ) and self._timedout.is_set(): gevent.sleep(10) on_connect_request( ConnectionRequest(self._console)) gevent.sleep(0.1)
def power_on(liveid): for i in range(3): Console.power_on(liveid, tries=10) Console.wait(1)
def discover(self, addr=None): discovered = Console.discover(addr=addr, timeout=10) self.discovered = discovered