mirror of
https://github.com/LorenEteval/Furious.git
synced 2026-09-27 17:37:58 +03:00
640 lines
22 KiB
Python
640 lines
22 KiB
Python
# Copyright (C) 2024–present Loren Eteval & contributors <loren.eteval@proton.me>
|
||
#
|
||
# This file is part of Furious.
|
||
#
|
||
# This program is free software: you can redistribute it and/or modify
|
||
# it under the terms of the GNU General Public License as published by
|
||
# the Free Software Foundation, either version 3 of the License, or
|
||
# (at your option) any later version.
|
||
#
|
||
# This program is distributed in the hope that it will be useful,
|
||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
# GNU General Public License for more details.
|
||
#
|
||
# You should have received a copy of the GNU General Public License
|
||
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
"""Provide widgets for application."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from Furious.Frozenlib import *
|
||
from Furious.Interface import *
|
||
from Furious.Core import Tun2socks
|
||
from Furious.Backends import OFFICIAL_PLUGIN_TYPES
|
||
from Furious.Controllers import (
|
||
APPLICATION_THEME_SETTING,
|
||
LOG_AUTO_CLEAR_SETTING,
|
||
ConnectionController,
|
||
RoutingController,
|
||
SettingsController,
|
||
)
|
||
from Furious.Extensions import BUNDLED_EXTENSION_TYPES
|
||
from Furious.Plugins import getPluginRegistry, initializePluginRegistry
|
||
from Furious.Qt import AppStyleSheet
|
||
from Furious.Qt.TextEditorTheme import configureEditorLogMetadata
|
||
from Furious.Qt import gettext as _
|
||
from Furious.Repository import *
|
||
from Furious.Service import ApplicationLogHandler, LogManager
|
||
from Furious.Application.TrayIcon import *
|
||
from Furious.Window.LogPage import *
|
||
from Furious.Window.MainWindow import *
|
||
|
||
from PySide6 import QtCore
|
||
from PySide6.QtGui import *
|
||
from PySide6.QtNetwork import *
|
||
from PySide6.QtWidgets import *
|
||
|
||
import os
|
||
import sys
|
||
import logging
|
||
import platform
|
||
import threading
|
||
import traceback
|
||
import darkdetect
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class SystemTrayUnavailable(Exception):
|
||
"""Represent system tray unavailable."""
|
||
|
||
pass
|
||
|
||
|
||
class ApplicationExitHelper(QApplication):
|
||
"""Represent application exit helper."""
|
||
|
||
def __init__(self, argv):
|
||
"""Initialize the ApplicationExitHelper."""
|
||
super().__init__(argv)
|
||
|
||
# Exiting flag
|
||
self._exiting = False
|
||
|
||
def setExitingFlag(self, value: bool):
|
||
"""Set exiting flag."""
|
||
self._exiting = value
|
||
|
||
def isExiting(self) -> bool:
|
||
"""Return whether exiting."""
|
||
return self._exiting is True
|
||
|
||
|
||
class SingletonApplication(ApplicationExitHelper):
|
||
"""Represent singleton application."""
|
||
|
||
def __init__(self, argv):
|
||
"""Initialize the SingletonApplication."""
|
||
super().__init__(argv)
|
||
|
||
self.serverName = LOCAL_SERVER_NAME
|
||
|
||
self.socket = QLocalSocket(self)
|
||
self.server = QLocalServer(self)
|
||
|
||
def hasRunningApp(self) -> bool:
|
||
"""Return whether running app."""
|
||
self.socket.connectToServer(self.serverName)
|
||
|
||
if self.socket.waitForConnected(1000):
|
||
if len(sys.argv) == 1:
|
||
command = AppBuiltinCommand.Empty.value
|
||
else:
|
||
command = sys.argv[1]
|
||
|
||
self.socket.write(command.encode())
|
||
self.socket.flush()
|
||
|
||
if command == AppBuiltinCommand.Empty.value:
|
||
# Show tray message in the started instance. Do not start
|
||
return True
|
||
elif command == AppBuiltinCommand.RunAs.value:
|
||
if self.socket.waitForDisconnected(3000):
|
||
# The other instance have been exited. Start
|
||
return False
|
||
else:
|
||
# Do not start
|
||
return True
|
||
else:
|
||
# TODO: Not implemented
|
||
# Do not start
|
||
return True
|
||
else:
|
||
# Remove the old socket file if it exists
|
||
socket_path = QLocalServer.removeServer(self.serverName)
|
||
|
||
if socket_path:
|
||
logger.info(f'old socket file removed: {self.serverName}')
|
||
else:
|
||
logger.info(f'no existing socket file found for: {self.serverName}')
|
||
|
||
# New instance
|
||
self.server.newConnection.connect(self.handleNewConnection)
|
||
|
||
if not self.server.listen(self.serverName):
|
||
# Do not start
|
||
logger.error(f'unable to listen on server: {self.serverName}')
|
||
|
||
return True
|
||
|
||
# Start
|
||
return False
|
||
|
||
@QtCore.Slot()
|
||
def handleNewConnection(self):
|
||
"""Handle new connection."""
|
||
raise NotImplementedError
|
||
|
||
|
||
class ApplicationThemeDetector(QtCore.QObject):
|
||
"""Represent application theme detector."""
|
||
|
||
themeChanged = QtCore.Signal(str)
|
||
|
||
def __init__(self, *args, **kwargs):
|
||
"""Initialize the ApplicationThemeDetector."""
|
||
super().__init__(*args, **kwargs)
|
||
|
||
|
||
class DesktopApplication(ApplicationRunner, SingletonApplication):
|
||
"""Represent application."""
|
||
|
||
def __init__(self, argv):
|
||
"""Initialize the desktop application."""
|
||
super().__init__(argv)
|
||
|
||
self.setApplicationName(APPLICATION_NAME)
|
||
self.setApplicationVersion(APPLICATION_VERSION)
|
||
self.setOrganizationName(ORGANIZATION_NAME)
|
||
self.setOrganizationDomain(ORGANIZATION_DOMAIN)
|
||
|
||
self.systemTray = None
|
||
|
||
# Font
|
||
self.customFontLoadMsg = ''
|
||
self.customFontEnabled = False
|
||
self.customFontName = ''
|
||
|
||
# Theme Detect
|
||
self.currentTheme = None
|
||
self.themeDetectTimer = None
|
||
self.themeDetector = None
|
||
self.themeListenerThread = None
|
||
|
||
self.mainWindow = None
|
||
self.systemTray = None
|
||
self.connectionController = None
|
||
self.routingController = None
|
||
self.settingsController = None
|
||
|
||
# Unified logging service and presentation
|
||
self.logManager = None
|
||
self.logPage = None
|
||
|
||
# Protected storage access
|
||
self._userActivatedItemIndex = None
|
||
self._userServers = None
|
||
self._userSubs = None
|
||
self._userTUNSettings = None
|
||
|
||
# ThreadPool
|
||
self.threadPool = QtCore.QThreadPool(self)
|
||
self.threadPool.setMaxThreadCount(max(OS_CPU_COUNT // 2, 1))
|
||
|
||
@callRateLimited(maxCallPerSecond=2)
|
||
@QtCore.Slot()
|
||
def handleNewConnection(self):
|
||
"""Handle new connection."""
|
||
while self.server.hasPendingConnections():
|
||
socket = self.server.nextPendingConnection()
|
||
|
||
if socket is None:
|
||
continue
|
||
|
||
# QLocalServer owns pending sockets until they are explicitly
|
||
# released. Use sender() instead of a partial that retains each
|
||
# socket and dispose it after the one-command protocol completes.
|
||
socket.readyRead.connect(self.handleNewData)
|
||
socket.disconnected.connect(socket.deleteLater)
|
||
|
||
@QtCore.Slot()
|
||
def handleNewData(self):
|
||
"""Handle new data."""
|
||
socket = self.sender()
|
||
|
||
if not isinstance(socket, QLocalSocket):
|
||
return
|
||
|
||
data = socket.readAll().data()
|
||
|
||
if isinstance(data, bytes):
|
||
datastr = data.decode('utf-8', 'replace')
|
||
else:
|
||
datastr = str(data)
|
||
|
||
if datastr == AppBuiltinCommand.Empty.value:
|
||
if isinstance(self.systemTray, TrayIcon):
|
||
logger.info('attempting to start multiple instance. Show tray message')
|
||
|
||
self.systemTray.showMessage(_('Already started'))
|
||
else:
|
||
# The tray hasn't been initialized. Do nothing
|
||
pass
|
||
elif datastr == AppBuiltinCommand.RunAs.value:
|
||
logger.info('detected requests to start as admin in new instance. Exiting')
|
||
|
||
self.exit()
|
||
else:
|
||
# TODO: Not implemented
|
||
pass
|
||
|
||
# The singleton IPC channel carries exactly one command. Closing it
|
||
# here both wakes RunAs clients and prevents completed QLocalSocket
|
||
# children from accumulating under the application-wide server.
|
||
socket.disconnectFromServer()
|
||
|
||
if socket.state() == QLocalSocket.LocalSocketState.UnconnectedState:
|
||
socket.deleteLater()
|
||
|
||
def configureLogging(self):
|
||
"""Configure logging."""
|
||
self.logManager = LogManager(
|
||
parent=self,
|
||
autoClearEnabled=AppSettings.isStateON_(LOG_AUTO_CLEAR_SETTING),
|
||
)
|
||
|
||
self.logPage = LogPage(
|
||
manager=self.logManager,
|
||
fontFamily=self.customFontName,
|
||
)
|
||
|
||
logging.basicConfig(
|
||
format='[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s',
|
||
level=logging.INFO,
|
||
handlers=(
|
||
ApplicationLogHandler(self.logManager),
|
||
logging.StreamHandler(),
|
||
),
|
||
)
|
||
logging.raiseExceptions = False
|
||
|
||
def addCustomFont(self):
|
||
"""Add custom font."""
|
||
fontFile = str(DATA_DIR / 'font' / 'CascadiaMono')
|
||
fontName = 'Cascadia Mono'
|
||
|
||
if QFontDatabase.addApplicationFont(fontFile) != -1:
|
||
# Delayed
|
||
self.customFontLoadMsg = f'custom font {fontName} load success'
|
||
self.customFontEnabled = True
|
||
self.customFontName = fontName
|
||
else:
|
||
# Delayed
|
||
self.customFontLoadMsg = f'custom font {fontName} load failed'
|
||
|
||
def configureApplicationFont(self):
|
||
"""Configure application font."""
|
||
font = self.font()
|
||
font.setPointSize(AppStyleSheet.FontPointSize)
|
||
|
||
self.setFont(font)
|
||
|
||
@staticmethod
|
||
def addEnviron():
|
||
"""Add environ."""
|
||
pluginRegistry = initializePluginRegistry(
|
||
(*OFFICIAL_PLUGIN_TYPES, *BUNDLED_EXTENSION_TYPES)
|
||
)
|
||
configureEditorLogMetadata(
|
||
lambda: (*pluginRegistry.coreVersions(), Tun2socks.version()),
|
||
pluginRegistry.logTimestampPatterns,
|
||
)
|
||
pluginRegistry.configureEnvironment()
|
||
|
||
if SystemRuntime.flatpakID():
|
||
# https://github.com/flatpak/flatpak/issues/3438
|
||
os.environ['TMPDIR'] = os.path.join(
|
||
os.environ.get('XDG_RUNTIME_DIR'), 'app', APPLICATION_FLATPAK_ID
|
||
)
|
||
|
||
def addStorage(self):
|
||
# Protected storage access
|
||
"""Add storage."""
|
||
self._userActivatedItemIndex = Storage.UserActivatedItemIndex()
|
||
self._userServers = Storage.UserServers()
|
||
self._userSubs = Storage.UserSubs()
|
||
self._userTUNSettings = Storage.UserTUNSettings()
|
||
|
||
def isSystemDarkMode(self):
|
||
"""Return whether the current system palette appears dark."""
|
||
backgroudColor = self.palette().color(QPalette.ColorRole.Window)
|
||
|
||
return backgroudColor.lightness() < 128
|
||
|
||
def systemTheme(self) -> str:
|
||
"""Return the system theme value used by the application."""
|
||
try:
|
||
theme = darkdetect.theme()
|
||
|
||
if theme in [AppStyleSheet.Dark, AppStyleSheet.Light]:
|
||
return theme
|
||
except Exception:
|
||
# Any non-exit exceptions
|
||
|
||
logger.error('darkdetect.theme() is not implemented on this platform')
|
||
|
||
return AppStyleSheet.Dark if self.isSystemDarkMode() else AppStyleSheet.Light
|
||
|
||
def themePreference(self) -> ApplicationTheme:
|
||
"""Return the authoritative persisted application theme preference."""
|
||
return ApplicationTheme(AppSettings.get(APPLICATION_THEME_SETTING))
|
||
|
||
def followsSystemAppearance(self) -> bool:
|
||
"""Return whether system appearance controls the application theme."""
|
||
return self.themePreference() == ApplicationTheme.System
|
||
|
||
def usesForcedDarkTheme(self) -> bool:
|
||
"""Return whether the application explicitly forces its dark theme."""
|
||
return self.themePreference() == ApplicationTheme.Dark
|
||
|
||
def theme(self):
|
||
"""Resolve the effective light or dark application theme."""
|
||
preference = self.themePreference()
|
||
|
||
if preference != ApplicationTheme.System:
|
||
return preference.value
|
||
|
||
return self.systemTheme()
|
||
|
||
def applyStyleSheetForTheme(self, theme):
|
||
"""Handle apply style sheet for theme for the application."""
|
||
self.setStyleSheet(AppStyleSheet.forTheme(theme))
|
||
|
||
def applyThemePreference(self):
|
||
"""Apply the resolved preference and refresh every theme-aware object."""
|
||
theme = self.theme()
|
||
|
||
self.applyStyleSheetForTheme(theme)
|
||
|
||
Mixins.ThemeAware.callThemeChangedCallbackUnchecked(theme)
|
||
|
||
@QtCore.Slot(str)
|
||
def handleSystemThemeChanged(self, theme):
|
||
"""Handle system theme changed."""
|
||
if not self.followsSystemAppearance():
|
||
logger.info(
|
||
f'ignore system theme \'{theme}\' change while application theme '
|
||
f'is forced to \'{self.themePreference().value}\''
|
||
)
|
||
|
||
return
|
||
|
||
if theme not in [AppStyleSheet.Dark, AppStyleSheet.Light]:
|
||
theme = self.systemTheme()
|
||
|
||
self.applyStyleSheetForTheme(theme)
|
||
|
||
Mixins.ThemeAware.callThemeChangedCallback(theme)
|
||
|
||
@staticmethod
|
||
@callOnceOnly
|
||
@QtCore.Slot()
|
||
def cleanup():
|
||
"""Release resources owned by the application."""
|
||
controller = AppConnectionController()
|
||
|
||
if controller is not None:
|
||
controller.shutdown()
|
||
|
||
getPluginRegistry().shutdown()
|
||
|
||
Mixins.CleanupOnExit.cleanupAll()
|
||
|
||
if AppSettings.get('SystemProxyMode') == AppBuiltinProxyMode.Auto.value:
|
||
# Automatically configure
|
||
SystemProxy.off()
|
||
SystemProxy.daemonOff()
|
||
|
||
AppThreadPool().clear()
|
||
|
||
logger.info('final cleanup done')
|
||
|
||
@staticmethod
|
||
def setDockIconVisible(visible: bool):
|
||
"""Set dock icon visible."""
|
||
if PLATFORM != 'Darwin':
|
||
return
|
||
|
||
from AppKit import NSApplication
|
||
|
||
policy = 0 if visible else 1
|
||
NSApplication.sharedApplication().setActivationPolicy_(policy)
|
||
|
||
def eventFilter(self, watched, event):
|
||
# Show Dock icon on macOS when window is shown
|
||
# and hide only when window is closed (not minimized)
|
||
"""Return the event filter value used by the application."""
|
||
if PLATFORM == 'Darwin' and watched is self.mainWindow:
|
||
if event.type() == QtCore.QEvent.Type.Show:
|
||
self.setDockIconVisible(True)
|
||
if event.type() == QtCore.QEvent.Type.Hide:
|
||
# Hide Dock icon when window is closed (not minimized)
|
||
if not self.mainWindow.isMinimized():
|
||
self.setDockIconVisible(False)
|
||
|
||
return super().eventFilter(watched, event)
|
||
|
||
def installDockIconVisibilityFeature(self, remove=False):
|
||
"""Handle install dock icon visibility feature for the application."""
|
||
if remove:
|
||
self.mainWindow.removeEventFilter(self)
|
||
self.setDockIconVisible(True)
|
||
else:
|
||
# Install event filter for main window to track show/hide
|
||
self.mainWindow.installEventFilter(self)
|
||
|
||
if not self.mainWindow.isVisible() and not self.mainWindow.isMinimized():
|
||
self.setDockIconVisible(False)
|
||
|
||
def exit(self, exitcode=0):
|
||
"""Shut down and exit the application."""
|
||
self.setExitingFlag(True)
|
||
|
||
self.threadPool.clear()
|
||
|
||
# Dirty exit
|
||
for timeout in [1000, 2000, 3000]:
|
||
QtCore.QTimer.singleShot(timeout, APP().exit)
|
||
|
||
super().exit(exitcode)
|
||
|
||
def run(self):
|
||
"""Run the application task."""
|
||
try:
|
||
if self.hasRunningApp():
|
||
# See: https://github.com/python/cpython/issues/79908
|
||
# sys.exit(None) in multiprocessing will produce
|
||
# exitcode 1 in some Python version, which is
|
||
# not what we want.
|
||
return ApplicationRunner.ExitCode.ExitSuccess.value
|
||
|
||
if not TrayIcon.isSystemTrayAvailable():
|
||
raise SystemTrayUnavailable(
|
||
'TrayIcon is not available on this platform'
|
||
)
|
||
|
||
self.addEnviron()
|
||
self.addStorage()
|
||
|
||
# The application owns these lifetime-scoped services; Frozenlib
|
||
# exposes them through App*Controller accessors.
|
||
(
|
||
self.connectionController,
|
||
self.routingController,
|
||
self.settingsController,
|
||
) = (
|
||
ConnectionController(parent=self),
|
||
RoutingController(parent=self),
|
||
SettingsController(),
|
||
)
|
||
|
||
self.connectionController.interactionEnabledChanged.connect(
|
||
self.routingController.setInteractionEnabled
|
||
)
|
||
|
||
self.addCustomFont()
|
||
# self.configureApplicationFont()
|
||
self.configureLogging()
|
||
|
||
logger.info(f'application version: {APPLICATION_VERSION}')
|
||
logger.info(
|
||
f'Qt version: {QtCore.qVersion()}. PySide6 version: {PYSIDE6_VERSION}'
|
||
)
|
||
logger.info(f'Qt build info: {QtCore.QLibraryInfo.build()}')
|
||
logger.info(f'platform: {PLATFORM}')
|
||
logger.info(f'platform release: {PLATFORM_RELEASE}')
|
||
logger.info(f'platform machine: {PLATFORM_MACHINE}')
|
||
|
||
if PLATFORM == 'Darwin':
|
||
logger.info(f'mac_ver: {platform.mac_ver()}')
|
||
|
||
appImagePath = SystemRuntime.appImagePath()
|
||
|
||
if appImagePath:
|
||
logger.info(f'running from Linux AppImage: \'{appImagePath}\'')
|
||
else:
|
||
logger.info('not running from Linux AppImage')
|
||
|
||
flatpakId = SystemRuntime.flatpakID()
|
||
|
||
if flatpakId:
|
||
logger.info(f'running from Linux flatpak: \'{flatpakId}\'')
|
||
else:
|
||
logger.info('not running from Linux flatpak')
|
||
|
||
logger.info(f'python version: {PLATFORM_PYTHON_VERSION}')
|
||
logger.info(f'system version: {sys.version}')
|
||
logger.info(f'sys.executable: \'{sys.executable}\'')
|
||
logger.info(f'sys.argv: {sys.argv}')
|
||
logger.info(f'appFilePath: \'{self.applicationFilePath()}\'')
|
||
logger.info(f'isPythonw: {SystemRuntime.isPythonw()}')
|
||
logger.info(f'system language is {SYSTEM_LANGUAGE}')
|
||
logger.info(self.customFontLoadMsg)
|
||
logger.info(f'current theme is {self.theme()}')
|
||
|
||
if PLATFORM != 'Windows' and not SystemRuntime.isScriptMode():
|
||
logger.info('theme detect method uses timer implementation')
|
||
|
||
@QtCore.Slot()
|
||
def handleTimeout():
|
||
"""Handle timeout."""
|
||
currentTheme = self.systemTheme()
|
||
|
||
if self.currentTheme != currentTheme:
|
||
self.currentTheme = currentTheme
|
||
|
||
self.handleSystemThemeChanged(currentTheme)
|
||
|
||
self.currentTheme = self.systemTheme()
|
||
self.themeDetectTimer = QtCore.QTimer(self)
|
||
self.themeDetectTimer.timeout.connect(handleTimeout)
|
||
self.themeDetectTimer.start(1000)
|
||
else:
|
||
logger.info('theme detect method uses listener implementation')
|
||
|
||
def listener(*args, **kwargs):
|
||
"""Handle listener for the application."""
|
||
try:
|
||
darkdetect.listener(*args, **kwargs)
|
||
except NotImplementedError:
|
||
# Not supported by darkdetect. Ignore
|
||
|
||
logger.error(
|
||
'darkdetect listener is not implemented on this platform'
|
||
)
|
||
|
||
self.themeDetector = ApplicationThemeDetector(self)
|
||
self.themeDetector.themeChanged.connect(self.handleSystemThemeChanged)
|
||
|
||
self.themeListenerThread = threading.Thread(
|
||
target=listener,
|
||
args=(self.themeDetector.themeChanged.emit,),
|
||
daemon=True,
|
||
)
|
||
self.themeListenerThread.start()
|
||
|
||
# Mandatory
|
||
self.setQuitOnLastWindowClosed(False)
|
||
|
||
self.aboutToQuit.connect(DesktopApplication.cleanup)
|
||
|
||
Win32Session.set(DesktopApplication.cleanup)
|
||
Win32Session.run()
|
||
|
||
if AppSettings.get('SystemProxyMode') == AppBuiltinProxyMode.Auto.value:
|
||
# Automatically configure
|
||
SystemProxy.off()
|
||
SystemProxy.daemonOn_()
|
||
|
||
# Resolve the stored preference before constructing application UI so
|
||
# newly created widgets use the correct palette from their first frame.
|
||
self.applyThemePreference()
|
||
|
||
self.mainWindow = MainWindow()
|
||
self.systemTray = TrayIcon()
|
||
|
||
if PLATFORM == 'Darwin':
|
||
if AppSettings.isStateON_('HideDockIcon'):
|
||
# Hide Dock icon initially, keeping only the tray icon visible
|
||
self.installDockIconVisibilityFeature()
|
||
|
||
def onApplicationStateChange(state):
|
||
"""Handle on application state change for the application."""
|
||
if state == QtCore.Qt.ApplicationState.ApplicationActive:
|
||
if (
|
||
not self.mainWindow.isVisible()
|
||
and not AppConnectionController().isConnecting()
|
||
):
|
||
self.mainWindow.show()
|
||
|
||
# Ensure the main window is shown when the dock icon is clicked
|
||
self.applicationStateChanged.connect(onApplicationStateChange)
|
||
|
||
self.systemTray.show()
|
||
self.systemTray.setCustomToolTip()
|
||
self.systemTray.bootstrap()
|
||
|
||
AppConnectionController().restoreStartupState()
|
||
|
||
return self.exec()
|
||
except SystemTrayUnavailable:
|
||
return ApplicationRunner.ExitCode.PlatformNotSupported.value
|
||
except Exception:
|
||
# Any non-exit exceptions
|
||
|
||
traceback.print_exc()
|
||
|
||
return ApplicationRunner.ExitCode.UnknownException.value
|