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