mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 21:06:09 +00:00
Metalstorm's EOS sign-in asked for a one-time consent, could not load an overlay to show it, and fell back to a browser flow that never finished. Epic's own overlay component (the mechanism from Legendary's lfs/eos.py; credits in EpicOverlay.kt) is now downloaded once with the account's token into the runtime, after an Epic library sync or at the first launch that finds it missing. At each launch droiddeck-store-launch writes the one pointer, HKCU Software\Epic Games\EOS OverlayPath, into the game's prefix, appended to user.reg as the DirectAudio key is, and the app logs epic overlay installed=<build> prefix=<appid>. Wine's browser is set to xdg-open, and on a game's PATH a small xdg-open hands http(s) addresses to the app, which opens them in Android's browser, so a device-code sign-in can be finished on the phone.
174 lines
7.6 KiB
Python
174 lines
7.6 KiB
Python
"""droiddeck-store-launch: a launch from anywhere - the Steam client's own Play button included -
|
|
asks the app for an Epic game's sign-in code before Proton starts. These pin how it recognises a
|
|
store game, how it asks, and that both Proton launchers call it."""
|
|
import importlib.machinery
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import unittest
|
|
|
|
BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin'
|
|
|
|
|
|
def load(name):
|
|
loader = importlib.machinery.SourceFileLoader(name.replace('-', '_'), str(BIN / name))
|
|
spec = importlib.util.spec_from_loader(loader.name, loader)
|
|
module = importlib.util.module_from_spec(spec)
|
|
loader.exec_module(module)
|
|
return module
|
|
|
|
|
|
store = load('droiddeck-store-launch')
|
|
|
|
|
|
def load_path(path, name):
|
|
loader = importlib.machinery.SourceFileLoader(name, str(path))
|
|
spec = importlib.util.spec_from_loader(name, loader)
|
|
module = importlib.util.module_from_spec(spec)
|
|
loader.exec_module(module)
|
|
return module
|
|
compat = load('steam-compatibility')
|
|
|
|
|
|
def game(root, store_id='epic', ident='8b6a0e14'):
|
|
folder = Path(root) / 'Games/Stores/Epic/Metalstorm'
|
|
folder.mkdir(parents=True)
|
|
(folder / '.droiddeck-store.json').write_text(json.dumps({'store': store_id, 'id': ident, 'title': 'Metalstorm', 'exe': 'Metalstorm.exe'}))
|
|
(folder / '.droiddeck-launch.bat').write_text('@echo off\r\n')
|
|
return folder
|
|
|
|
|
|
class Detection(unittest.TestCase):
|
|
def test_the_launcher_among_steams_arguments_names_the_game(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root)
|
|
found = store.find_store_game(['/usr/bin/steam-runtime', '"%s/.droiddeck-launch.bat"' % folder, '-flag'])
|
|
self.assertIsNotNone(found)
|
|
self.assertEqual(folder, found[0])
|
|
self.assertEqual('epic', found[1]['store'])
|
|
self.assertEqual('8b6a0e14', found[1]['id'])
|
|
|
|
def test_anything_else_is_left_alone(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root)
|
|
self.assertIsNone(store.find_store_game([str(folder / 'Metalstorm.exe')]))
|
|
(folder / '.droiddeck-store.json').unlink()
|
|
self.assertIsNone(store.find_store_game([str(folder / '.droiddeck-launch.bat')]))
|
|
|
|
def test_only_epic_asks(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root, store_id='gog')
|
|
os.environ['BL_LAUNCH_DIR'] = str(Path(root) / 'session')
|
|
try:
|
|
self.assertEqual(0, store.main([str(folder / '.droiddeck-launch.bat')]))
|
|
finally:
|
|
del os.environ['BL_LAUNCH_DIR']
|
|
self.assertFalse((Path(root) / 'session/stores').exists())
|
|
|
|
|
|
class Asking(unittest.TestCase):
|
|
def test_a_request_is_answered_through_the_resp_folder(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
channel = Path(root) / 'stores'
|
|
|
|
def app():
|
|
req = channel / 'req'
|
|
for _ in range(100):
|
|
names = [p for p in req.glob('*.json')] if req.exists() else []
|
|
if names:
|
|
request = json.loads(names[0].read_text())
|
|
self.assertEqual({'op': 'epic-code', 'store': 'epic', 'id': 'x'}, request)
|
|
names[0].unlink()
|
|
tmp = channel / 'resp' / (names[0].name + '.tmp')
|
|
tmp.write_text(json.dumps({'ok': True, 'code': True, 'reason': 'ok'}))
|
|
os.rename(tmp, channel / 'resp' / names[0].name)
|
|
return
|
|
time.sleep(0.02)
|
|
|
|
t = threading.Thread(target=app)
|
|
t.start()
|
|
answer = store.ask(channel, {'op': 'epic-code', 'store': 'epic', 'id': 'x'}, timeout=3)
|
|
t.join()
|
|
self.assertEqual({'ok': True, 'code': True, 'reason': 'ok'}, answer)
|
|
|
|
def test_no_answer_withdraws_the_request(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
channel = Path(root) / 'stores'
|
|
self.assertIsNone(store.ask(channel, {'op': 'epic-code'}, timeout=0.2))
|
|
self.assertEqual([], list((channel / 'req').iterdir()))
|
|
|
|
def test_a_stale_code_is_dropped_before_asking(self):
|
|
with tempfile.TemporaryDirectory() as root:
|
|
folder = game(root)
|
|
code = folder / '.droiddeck-epic-code'
|
|
code.write_text('old')
|
|
self.assertFalse(store.drop_stale(folder, now=code.stat().st_mtime + 60))
|
|
self.assertTrue(store.drop_stale(folder, now=code.stat().st_mtime + store.STALE_SECONDS + 1))
|
|
self.assertFalse(code.exists())
|
|
|
|
|
|
class Prefix(unittest.TestCase):
|
|
def setUp(self):
|
|
self.tmp = tempfile.TemporaryDirectory()
|
|
root = Path(self.tmp.name)
|
|
self.compat = root / 'compatdata/3785150007'
|
|
(self.compat / 'pfx').mkdir(parents=True)
|
|
self.reg = self.compat / 'pfx/user.reg'
|
|
self.reg.write_text('WINE REGISTRY Version 2\n\n[Software\\\\Wine] 1\n"Version"="win10"\n')
|
|
self.overlay = root / 'epic-overlay'
|
|
self.overlay.mkdir()
|
|
|
|
def tearDown(self):
|
|
self.tmp.cleanup()
|
|
|
|
def test_the_overlay_pointer_names_the_shared_copy_through_z(self):
|
|
(self.overlay / store.OVERLAY_DLL).write_bytes(b'MZ')
|
|
(self.overlay / 'droiddeck-version').write_text('1.0.42')
|
|
self.assertEqual('overlay-set', store.provision_prefix(str(self.compat), str(self.overlay)))
|
|
text = self.reg.read_text()
|
|
self.assertIn('[Software\\\\Epic Games\\\\EOS] ', text)
|
|
self.assertIn('"OverlayPath"="Z:' + str(self.overlay).replace('/', '\\\\') + '"', text)
|
|
self.assertIn('"Browsers"="xdg-open"', text)
|
|
# A second launch adds nothing: the last word already says so.
|
|
store.provision_prefix(str(self.compat), str(self.overlay))
|
|
self.assertEqual(text, self.reg.read_text())
|
|
self.assertEqual('1.0.42', store.overlay_version(str(self.overlay)))
|
|
|
|
def test_no_overlay_yet_or_no_prefix_yet(self):
|
|
self.assertEqual('overlay-missing', store.provision_prefix(str(self.compat), str(self.overlay)))
|
|
self.assertNotIn('OverlayPath', self.reg.read_text())
|
|
self.assertEqual('prefix-not-created', store.provision_prefix(self.tmp.name + '/compatdata/1', str(self.overlay)))
|
|
self.assertEqual('no-prefix', store.provision_prefix('', str(self.overlay)))
|
|
|
|
|
|
class Browser(unittest.TestCase):
|
|
def test_a_web_address_is_handed_to_the_app(self):
|
|
xdg = load_path(BIN.parent / 'lib/droiddeck/browser/xdg-open', 'xdg_open')
|
|
with tempfile.TemporaryDirectory() as root:
|
|
os.environ['BL_LAUNCH_DIR'] = root
|
|
try:
|
|
self.assertEqual(0, xdg.main(['https://www.epicgames.com/activate']))
|
|
finally:
|
|
del os.environ['BL_LAUNCH_DIR']
|
|
reqs = list((Path(root) / 'stores/req').glob('*.json'))
|
|
self.assertEqual(1, len(reqs))
|
|
self.assertEqual({'op': 'open-url', 'url': 'https://www.epicgames.com/activate'}, json.loads(reqs[0].read_text()))
|
|
|
|
|
|
class Launchers(unittest.TestCase):
|
|
def test_both_proton_launchers_ask_before_proton_starts(self):
|
|
sh = compat.LAUNCHER_SH
|
|
self.assertIn('bl_store_launch() {', sh)
|
|
self.assertLess(sh.index('bl_store_launch "$@"'), sh.index('droiddeck-game-env "$depot/proton"'))
|
|
self.assertIn('bl_store_launch "$@"', compat.EXTRA_WRAPPER_SH)
|
|
self.assertIn('bl_store_launch() {', compat.BL_STORE_SETUP)
|
|
self.assertIn('waitforexitandrun', compat.BL_STORE_SETUP)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|