Merge pull request #176 from fa0311/develop-v6

update 6.3.0

Author: fa0311

DMMGamePlayerFastLauncher/DMMGamePlayerFastLauncher.py

@@ -25,6 +25,8 @@ def loder(master: LanchLauncher):
     DataPathConfig.ACCOUNT_SHORTCUT.mkdir(exist_ok=True, parents=True)
     DataPathConfig.SHORTCUT.mkdir(exist_ok=True, parents=True)
     DataPathConfig.SCHTASKS.mkdir(exist_ok=True, parents=True)
+    DataPathConfig.BROWSER_PROFILE.mkdir(exist_ok=True, parents=True)
+    DataPathConfig.BROWSER_CONFIG.mkdir(exist_ok=True, parents=True)
 
     config_loder()
     i18n.load_path.append(str(AssetsPathConfig.I18N))

DMMGamePlayerFastLauncher/component/component.py

@@ -182,9 +182,9 @@ class PathComponentBase(EntryComponent):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.command.append((i18n.t("app.component.reference"), self.reference_callback))
+        self.command.append((i18n.t("app.component.reference"), lambda v: self.reference_callback(v)))
 
-    def reference_callback(self, variable: PathVar):
+    def reference_callback(self, variable: Variable):
         raise NotImplementedError
 
 

DMMGamePlayerFastLauncher/component/tab_menu.py

@@ -35,12 +35,14 @@ def add(self, text: str, callback: Callable):
         btn.pack(pady=2, padx=4)
 
         if self.selected == row:
-            self.callback_wrapper(callback, row=row)
-            self.first = False
+            self.render(callback, row=row)
         self.row += 1
 
     def callback_wrapper(self, callback, row):
-        children_destroy(self.body_master)
+        if self.selected != row:
+            self.render(callback, row)
+
+    def render(self, callback, row):
         for key, child in enumerate(self.tab_master.winfo_children()):
             if key == row:
                 self.selected = key
@@ -57,6 +59,7 @@ def callback_wrapper(self, callback, row):
                 )
             child.update()
 
+        children_destroy(self.body_master)
         callback(self.body_master)
 
     def is_dark(self):

DMMGamePlayerFastLauncher/component/variable_base.py

@@ -1,3 +1,5 @@
+import json
+from pathlib import Path
 from tkinter import Variable
 
 
@@ -13,3 +15,13 @@ def from_dict(cls, obj: dict[str, str]):
         default = cls().__dict__
         item = [(k, v(value=obj.get(k, default[k].get()))) for k, v in cls.__annotations__.items()]
         return cls(**dict(item))
+
+    @classmethod
+    def from_path(cls, path: Path):
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return cls.from_dict(data)
+
+    def write_path(self, path: Path):
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.to_dict(), f, ensure_ascii=False, indent=4)

DMMGamePlayerFastLauncher/launch.py

@@ -1,4 +1,3 @@
-import json
 import logging
 import subprocess
 import sys
@@ -19,11 +18,12 @@
 from lib.thread import threading_wrapper
 from lib.toast import ErrorWindow
 from models.setting_data import AppConfig
-from models.shortcut_data import LauncherShortcutData, ShortcutData
+from models.shortcut_data import BrowserConfigData, LauncherShortcutData, ShortcutData
 from static.config import DataPathConfig
 from static.constant import Constant
 from static.env import Env
 from tab.home import HomeTab
+from utils.utils import get_driver, login_driver
 
 
 class GameLauncher(CTk):
@@ -56,14 +56,30 @@ def thread(self, id: str, kill: bool = False, force_non_uac: bool = False):
 
     def launch(self, id: str, kill: bool = False, force_non_uac: bool = False):
         path = DataPathConfig.SHORTCUT.joinpath(id).with_suffix(".json")
-        with open(path, "r", encoding="utf-8") as f:
-            data = ShortcutData.from_dict(json.load(f))
+        data = ShortcutData.from_path(path)
 
         if data.account_path.get() == Constant.ALWAYS_EXTRACT_FROM_DMM:
             session = DgpSessionWrap.read_dgp()
         else:
             account_path = DataPathConfig.ACCOUNT.joinpath(data.account_path.get()).with_suffix(".bytes")
+            browser_config_path = DataPathConfig.BROWSER_CONFIG.joinpath(data.account_path.get()).with_suffix(".json")
             session = DgpSessionWrap.read_cookies(account_path)
+            if browser_config_path.exists():
+                browser_config = BrowserConfigData.from_path(browser_config_path)
+                profile_path = DataPathConfig.BROWSER_PROFILE.joinpath(browser_config.profile_name.get()).absolute()
+                userdata = session.post_dgp(DgpSessionWrap.USER_INFO).json()
+                if userdata["result_code"] != 100 or True:
+                    res = session.post_dgp(DgpSessionWrap.LOGIN_URL, json={"prompt": ""}).json()
+                    if res["result_code"] != 100:
+                        raise Exception(res["error"])
+                    driver = get_driver(browser_config.browser.get(), profile_path)
+                    code = login_driver(res["data"]["url"], driver)
+                    driver.quit()
+                    res = session.post_dgp(DgpSessionWrap.ACCESS_TOKEN, json={"code": code}).json()
+                    if res["result_code"] != 100:
+                        raise Exception(res["error"])
+                    session.actauth = {"accessToken": res["data"]["access_token"]}
+                    session.write_bytes(str(account_path))
 
         dgp_config = session.get_config()
         game = [x for x in dgp_config["contents"] if x["productId"] == data.product_id.get()][0]
@@ -174,8 +190,7 @@ def launch(self, id: str):
             raise Exception(i18n.t("app.lib.dmm_already_running"))
 
         path = DataPathConfig.ACCOUNT_SHORTCUT.joinpath(id).with_suffix(".json")
-        with open(path, "r", encoding="utf-8") as f:
-            data = LauncherShortcutData.from_dict(json.load(f))
+        data = LauncherShortcutData.from_path(path)
 
         account_path = DataPathConfig.ACCOUNT.joinpath(data.account_path.get()).with_suffix(".bytes")
 

DMMGamePlayerFastLauncher/lib/DGPSessionV2.py

@@ -83,6 +83,8 @@ class DgpSessionV2:
     HARDWARE_CONF = API_DGP.format("/v5/hardwareconf")
     HARDWARE_LIST = API_DGP.format("/v5/hardwarelist")
     HARDWARE_REJECT = API_DGP.format("/v5/hardwarereject")
+    USER_INFO = API_DGP.format("/v5/userinfo")
+    CHECK_ACCESS_TOKEN = API_DGP.format("/v5/auth/accesstoken/check")
     ACCESS_TOKEN = API_DGP.format("/v5/auth/accesstoken/issue")
     LOGIN_URL = API_DGP.format("/v5/auth/login/url")
     SIGNED_URL = "https://cdn-gameplayer.games.dmm.com/product/*"
@@ -188,6 +190,8 @@ def lunch(self, product_id: str, game_type: str) -> requests.Response:
             url = self.LAUNCH_CL
         elif game_type == "AMAIN":
             url = self.LAUNCH_PKG
+        elif game_type == "GMAIN":
+            url = self.LAUNCH_PKG
         else:
             raise Exception("Unknown game_type: " + game_type + " " + product_id)
         json = {

DMMGamePlayerFastLauncher/models/shortcut_data.py

@@ -1,3 +1,4 @@
+import uuid
 from dataclasses import dataclass, field
 from tkinter import BooleanVar, StringVar
 
@@ -20,3 +21,9 @@ class ShortcutData(VariableBase):
 class LauncherShortcutData(VariableBase):
     account_path: PathVar = field(default_factory=PathVar)
     dgp_args: StringVar = field(default_factory=StringVar)
+
+
+@dataclass
+class BrowserConfigData(VariableBase):
+    browser: StringVar = field(default_factory=StringVar)
+    profile_name: StringVar = field(default_factory=lambda: StringVar(value=uuid.uuid4().hex))

DMMGamePlayerFastLauncher/static/config.py

@@ -8,6 +8,8 @@ class DataPathConfig(Dump):
     ACCOUNT = DATA.joinpath("account")
     ACCOUNT_SHORTCUT = DATA.joinpath("account_shortcut")
     SHORTCUT = DATA.joinpath("shortcut")
+    BROWSER_PROFILE = DATA.joinpath("browser_profile")
+    BROWSER_CONFIG = DATA.joinpath("browser_config")
     LOG = DATA.joinpath("log")
     APP_CONFIG = DATA.joinpath("config.json")
     SCHTASKS = DATA.joinpath("schtasks")

DMMGamePlayerFastLauncher/static/env.py

@@ -8,7 +8,7 @@
 
 
 class Env(Dump):
-    VERSION = "v6.2.3"
+    VERSION = "v6.3.0"
     RELEASE_VERSION = requests.get(UrlConfig.RELEASE_API).json().get("tag_name", VERSION)
 
     DEVELOP: bool = os.environ.get("ENV") == "DEVELOP"

DMMGamePlayerFastLauncher/tab/account.py

@@ -1,20 +1,18 @@
-import time
-import urllib.parse
 from pathlib import Path
-from tkinter import StringVar
-from typing import TypeVar
+from tkinter import BooleanVar, StringVar
+from typing import Callable, Optional, TypeVar
 
 import customtkinter as ctk
 import i18n
-from component.component import EntryComponent, OptionMenuComponent, OptionMenuTupleComponent, PaddingComponent
+from component.component import CheckBoxComponent, EntryComponent, OptionMenuComponent, OptionMenuTupleComponent, PaddingComponent
 from component.tab_menu import TabMenuComponent
 from customtkinter import CTkBaseClass, CTkButton, CTkFrame, CTkLabel, CTkScrollableFrame
 from lib.DGPSessionWrap import DgpSessionWrap
 from lib.toast import ToastController, error_toast
-from selenium import webdriver
+from models.shortcut_data import BrowserConfigData
 from static.config import DataPathConfig
 from static.constant import Constant
-from utils.utils import children_destroy, file_create
+from utils.utils import children_destroy, file_create, get_driver, login_driver
 
 T = TypeVar("T")
 
@@ -94,35 +92,27 @@ def callback(self):
 class AccountBrowserImport(CTkScrollableFrame):
     toast: ToastController
     name: StringVar
-    browser: StringVar
+    data: BrowserConfigData
 
     def __init__(self, master: CTkBaseClass):
         super().__init__(master, fg_color="transparent")
         self.toast = ToastController(self)
         self.name = StringVar()
-        self.browser = StringVar()
+        self.auto_refresh = BooleanVar(value=True)
+        self.data = BrowserConfigData()
 
     def create(self):
         CTkLabel(self, text=i18n.t("app.account.import_browser_detail"), justify=ctk.LEFT).pack(anchor=ctk.W)
         text = i18n.t("app.account.filename")
         tooltip = i18n.t("app.account.filename_tooltip")
         EntryComponent(self, text=text, tooltip=tooltip, required=True, variable=self.name, alnum_only=True).create()
+        CheckBoxComponent(self, text=i18n.t("app.account.auto_refresh"), variable=self.auto_refresh).create()
         text = i18n.t("app.account.browser_select")
         tooltip = i18n.t("app.account.browser_select_tooltip")
-        OptionMenuComponent(self, text=text, tooltip=tooltip, values=["Chrome", "Edge", "Firefox"], variable=self.browser).create()
+        OptionMenuComponent(self, text=text, tooltip=tooltip, values=["Chrome", "Edge", "Firefox"], variable=self.data.browser).create()
         CTkButton(self, text=i18n.t("app.account.import_browser"), command=self.callback).pack(fill=ctk.X, pady=10)
         return self
 
-    def get_driver(self):
-        if self.browser.get() == "Chrome":
-            return webdriver.Chrome()
-        elif self.browser.get() == "Edge":
-            return webdriver.Edge()
-        elif self.browser.get() == "Firefox":
-            return webdriver.Firefox()
-        else:
-            raise Exception(i18n.t("app.account.browser_not_selected"))
-
     @error_toast
     def callback(self):
         path = DataPathConfig.ACCOUNT.joinpath(self.name.get()).with_suffix(".bytes")
@@ -137,19 +127,20 @@ def callback(self):
         res = session.post_dgp(DgpSessionWrap.LOGIN_URL, json={"prompt": ""}).json()
         if res["result_code"] != 100:
             raise Exception(res["error"])
-        driver = self.get_driver()
-        driver.get(res["data"]["url"])
-        parsed_url = urllib.parse.urlparse(driver.current_url)
-        while not (parsed_url.netloc == "webdgp-gameplayer.games.dmm.com" and parsed_url.path == "/login/success"):
-            time.sleep(0.2)
-            parsed_url = urllib.parse.urlparse(driver.current_url)
+
+        profile_path = DataPathConfig.BROWSER_PROFILE.joinpath(self.data.profile_name.get()).absolute()
+        driver = get_driver(self.data.browser.get(), profile_path)
+        code = login_driver(res["data"]["url"], driver)
         driver.quit()
-        code = urllib.parse.parse_qs(parsed_url.query)["code"][0]
         res = session.post_dgp(DgpSessionWrap.ACCESS_TOKEN, json={"code": code}).json()
         if res["result_code"] != 100:
             raise Exception(res["error"])
         session.actauth = {"accessToken": res["data"]["access_token"]}
         session.write_bytes(str(path))
+        if self.auto_refresh.get():
+            config_path = DataPathConfig.BROWSER_CONFIG.joinpath(self.name.get()).with_suffix(".json")
+            file_create(config_path, name=i18n.t("app.account.filename"))
+            self.data.write_path(config_path)
         self.toast.info(i18n.t("app.account.import_browser_success"))
 
 
@@ -159,6 +150,7 @@ class AccountEdit(CTkScrollableFrame):
     filename: StringVar
     body: CTkFrame
     body_var: dict[str, StringVar]
+    browser_config: Optional[BrowserConfigData]
     body_filename: StringVar
 
     def __init__(self, master: CTkBaseClass):
@@ -167,6 +159,7 @@ def __init__(self, master: CTkBaseClass):
         self.values = [x.stem for x in DataPathConfig.ACCOUNT.iterdir() if x.suffix == ".bytes"]
         self.filename = StringVar()
         self.body_var = {}
+        self.browser_config = None
         self.body_filename = StringVar()
 
     def create(self):
@@ -190,6 +183,13 @@ def select_callback(self, value: str):
         for key in session.actauth.keys():
             self.body_var[key] = StringVar(value=session.actauth[key] or "")
             EntryComponent(self.body, text=key, variable=self.body_var[key]).create()
+        config_path = DataPathConfig.BROWSER_CONFIG.joinpath(self.filename.get()).with_suffix(".json")
+        if config_path.exists():
+            self.browser_config = BrowserConfigData.from_path(config_path)
+            PaddingComponent(self.body, height=20).create()
+            EntryComponent(self.body, text="browser", variable=self.browser_config.browser).create()
+            EntryComponent(self.body, text="profile_name", variable=self.browser_config.profile_name).create()
+
         CTkButton(self.body, text=i18n.t("app.account.save"), command=self.save_callback).pack(fill=ctk.X, pady=10)
         CTkButton(self.body, text=i18n.t("app.account.delete"), command=self.delete_callback).pack(fill=ctk.X)
 
@@ -202,19 +202,34 @@ def save_callback(self):
 
         path = DataPathConfig.ACCOUNT.joinpath(self.filename.get()).with_suffix(".bytes")
         body_path = DataPathConfig.ACCOUNT.joinpath(self.body_filename.get()).with_suffix(".bytes")
+        config_path = DataPathConfig.BROWSER_CONFIG.joinpath(self.filename.get()).with_suffix(".json")
+        config_body_path = DataPathConfig.BROWSER_CONFIG.joinpath(self.body_filename.get()).with_suffix(".json")
+
+        def check_file(callback: Callable[[], None]):
+            if self.browser_config:
+                callback()
 
         def write():
             session = DgpSessionWrap.read_cookies((Path(path)))
             for key in session.actauth.keys():
                 session.actauth[key] = self.body_var[key].get()
-            session.write_bytes(str(Path(body_path)))
+            session.write_bytes(str(body_path))
+            if self.browser_config:
+                self.browser_config.write_path(config_body_path)
 
         if path == body_path:
             write()
         else:
-            file_create(body_path, name=i18n.t("app.account.filename"))
-            write()
+            try:
+                file_create(body_path, name=i18n.t("app.account.filename"))
+                check_file(lambda: file_create(config_body_path, name=i18n.t("app.account.filename")))
+                write()
+            except Exception as e:
+                body_path.unlink()
+                config_body_path.unlink()
+                raise e
             path.unlink()
+            check_file(lambda: config_path.unlink())
             self.values.remove(self.filename.get())
             self.values.append(self.body_filename.get())
             self.filename.set(self.body_filename.get())