voidremote 1.0.0__py3-none-any.whl

voidremote/services/monitor_service.py

@@ -0,0 +1,198 @@
+"""
+Real-time device monitoring service.
+
+Polls CPU, RAM, battery, temperature, and network stats at regular
+intervals and emits snapshots.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import threading
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Callable, Optional
+
+from voidremote.adb.client import AdbClient
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeviceSnapshot:
+    """Point-in-time device performance metrics."""
+
+    serial: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    cpu_usage: float = 0.0
+    ram_used_mb: float = 0.0
+    ram_total_mb: float = 0.0
+    battery_level: int = 0
+    battery_temperature: float = 0.0
+    battery_is_charging: bool = False
+    storage_used_gb: float = 0.0
+    storage_total_gb: float = 0.0
+    fps: float = 0.0
+
+    @property
+    def ram_usage_percent(self) -> float:
+        if self.ram_total_mb == 0:
+            return 0.0
+        return (self.ram_used_mb / self.ram_total_mb) * 100.0
+
+    @property
+    def storage_usage_percent(self) -> float:
+        if self.storage_total_gb == 0:
+            return 0.0
+        return (self.storage_used_gb / self.storage_total_gb) * 100.0
+
+
+SnapshotCallback = Callable[[DeviceSnapshot], None]
+
+
+class MonitorService:
+    """
+    Polls device metrics at a configurable interval.
+
+    Usage::
+
+        monitor = MonitorService(adb_client)
+        monitor.start("serial123", interval=2.0, callback=on_snapshot)
+        # ... later ...
+        monitor.stop("serial123")
+    """
+
+    def __init__(self, adb: AdbClient) -> None:
+        self._adb = adb
+        self._threads: dict[str, threading.Thread] = {}
+        self._stop_events: dict[str, threading.Event] = {}
+        self._callbacks: dict[str, list[SnapshotCallback]] = {}
+
+    def start(
+        self,
+        serial: str,
+        interval: float = 2.0,
+        callback: Optional[SnapshotCallback] = None,
+    ) -> None:
+        """Start monitoring a device."""
+        if serial in self._threads and self._threads[serial].is_alive():
+            logger.warning("Already monitoring %s", serial)
+            return
+        stop_event = threading.Event()
+        self._stop_events[serial] = stop_event
+        self._callbacks[serial] = [callback] if callback else []
+
+        thread = threading.Thread(
+            target=self._poll_loop,
+            args=(serial, interval, stop_event),
+            name=f"monitor-{serial}",
+            daemon=True,
+        )
+        self._threads[serial] = thread
+        thread.start()
+        logger.info("Started monitoring %s (interval=%.1fs)", serial, interval)
+
+    def stop(self, serial: str) -> None:
+        """Stop monitoring a device."""
+        event = self._stop_events.get(serial)
+        if event:
+            event.set()
+        thread = self._threads.get(serial)
+        if thread and thread.is_alive():
+            thread.join(timeout=5.0)
+        self._threads.pop(serial, None)
+        self._stop_events.pop(serial, None)
+        self._callbacks.pop(serial, None)
+        logger.info("Stopped monitoring %s", serial)
+
+    def stop_all(self) -> None:
+        """Stop all monitoring threads."""
+        for serial in list(self._threads.keys()):
+            self.stop(serial)
+
+    def add_callback(self, serial: str, callback: SnapshotCallback) -> None:
+        """Register an additional callback for a monitored device."""
+        if serial not in self._callbacks:
+            self._callbacks[serial] = []
+        self._callbacks[serial].append(callback)
+
+    def _poll_loop(
+        self, serial: str, interval: float, stop_event: threading.Event
+    ) -> None:
+        """Main polling loop running in background thread."""
+        while not stop_event.is_set():
+            try:
+                snapshot = self._collect_snapshot(serial)
+                for cb in self._callbacks.get(serial, []):
+                    try:
+                        cb(snapshot)
+                    except Exception as exc:
+                        logger.warning("Monitor callback error: %s", exc)
+            except Exception as exc:
+                logger.debug("Snapshot collection failed for %s: %s", serial, exc)
+            stop_event.wait(interval)
+
+    def _collect_snapshot(self, serial: str) -> DeviceSnapshot:
+        """Collect all metrics for one snapshot."""
+        snapshot = DeviceSnapshot(serial=serial)
+
+        # CPU
+        try:
+            snapshot.cpu_usage = self._get_cpu_usage(serial)
+        except Exception:
+            pass
+
+        # RAM
+        try:
+            total, avail = self._get_ram(serial)
+            snapshot.ram_total_mb = total / (1024 * 1024)
+            snapshot.ram_used_mb = (total - avail) / (1024 * 1024)
+        except Exception:
+            pass
+
+        # Battery
+        try:
+            level, temp, charging = self._get_battery(serial)
+            snapshot.battery_level = level
+            snapshot.battery_temperature = temp
+            snapshot.battery_is_charging = charging
+        except Exception:
+            pass
+
+        return snapshot
+
+    def _get_cpu_usage(self, serial: str) -> float:
+        """Calculate CPU usage percentage from /proc/stat."""
+        def read_stat() -> tuple[int, int]:
+            out = self._adb.shell(serial, "cat /proc/stat").stdout
+            for line in out.splitlines():
+                if line.startswith("cpu "):
+                    nums = [int(x) for x in line.split()[1:]]
+                    total = sum(nums)
+                    idle = nums[3] if len(nums) > 3 else 0
+                    return total, idle
+            return 0, 0
+
+        t1, i1 = read_stat()
+        time.sleep(0.2)
+        t2, i2 = read_stat()
+        dt = t2 - t1
+        di = i2 - i1
+        if dt == 0:
+            return 0.0
+        return max(0.0, min(100.0, (1.0 - di / dt) * 100.0))
+
+    def _get_ram(self, serial: str) -> tuple[int, int]:
+        """Return (total_bytes, available_bytes) from /proc/meminfo."""
+        from voidremote.adb.device_parser import parse_meminfo
+        out = self._adb.shell(serial, "cat /proc/meminfo").stdout
+        return parse_meminfo(out)
+
+    def _get_battery(self, serial: str) -> tuple[int, float, bool]:
+        """Return (level, temperature_c, is_charging)."""
+        from voidremote.adb.device_parser import parse_battery
+        out = self._adb.shell(serial, "dumpsys battery").stdout
+        info = parse_battery(out)
+        return info.level, info.temperature_celsius, info.is_charging

voidremote/ui/__init__.py

@@ -0,0 +1 @@
+"""VoidRemote GUI package."""

voidremote/ui/app.py

@@ -0,0 +1,70 @@
+"""
+VoidRemote GUI application entry point.
+
+Bootstraps QApplication, applies theme, initializes controller,
+and launches the main window.
+"""
+
+from __future__ import annotations
+
+import sys
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    """Launch the VoidRemote GUI application."""
+    # Must import PySide6 before any other Qt symbols
+    from PySide6.QtWidgets import QApplication
+    from PySide6.QtCore import Qt
+    from PySide6.QtGui import QFont
+
+    from voidremote.config.settings import ensure_dirs, get_settings, LOG_FILE
+    from voidremote.utils.logging import setup_logging
+    from voidremote.controllers.app_controller import AppController
+    from voidremote.ui.theme import apply_dark_theme
+    from voidremote.ui.main_window import MainWindow
+
+    ensure_dirs()
+    settings = get_settings()
+
+    setup_logging(
+        level=settings.logging.level,
+        log_file=LOG_FILE if settings.logging.file_enabled else None,
+        console=settings.logging.console_enabled,
+        console_color=settings.logging.console_color,
+    )
+
+    # High-DPI support
+    QApplication.setHighDpiScaleFactorRoundingPolicy(
+        Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
+    )
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("VoidRemote")
+    app.setApplicationDisplayName("VoidRemote")
+    app.setApplicationVersion("1.0.0")
+    app.setOrganizationName("V0IDNETWORK")
+    app.setOrganizationDomain("voidNetwork.ir")
+
+    # Apply dark theme
+    apply_dark_theme(app)
+
+    # Set default font
+    font = QFont(settings.ui.font_family, settings.ui.font_size)
+    app.setFont(font)
+
+    # Create controller (no initialize() yet — done lazily in MainWindow)
+    controller = AppController(settings)
+
+    window = MainWindow(controller)
+    window.show()
+
+    logger.info("VoidRemote GUI started")
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

voidremote/ui/dialogs/__init__.py

@@ -0,0 +1,6 @@
+"""VoidRemote UI dialogs."""
+
+from voidremote.ui.dialogs.pair_dialog import PairDialog
+from voidremote.ui.dialogs.connect_dialog import ConnectDialog
+
+__all__ = ["ConnectDialog", "PairDialog"]

voidremote/ui/dialogs/connect_dialog.py

@@ -0,0 +1,149 @@
+"""Connect to device dialog."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from PySide6.QtCore import Qt, QThread, Signal, Slot
+from PySide6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QLabel,
+    QLineEdit,
+    QProgressBar,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+    QCheckBox,
+)
+
+from voidremote.ui.theme import Colors
+
+
+class ConnectWorker(QThread):
+    success = Signal(object)
+    failure = Signal(str)
+
+    def __init__(self, controller: object, host: str, port: int, remember: bool, parent: Optional[object] = None) -> None:
+        super().__init__(parent)
+        self._controller = controller
+        self._host = host
+        self._port = port
+        self._remember = remember
+
+    def run(self) -> None:
+        try:
+            device = self._controller.connect_device(self._host, self._port, self._remember)
+            self.success.emit(device)
+        except Exception as exc:
+            self.failure.emit(str(exc))
+
+
+class ConnectDialog(QDialog):
+    connected = Signal(object)
+
+    def __init__(self, controller: object, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._controller = controller
+        self._worker: Optional[ConnectWorker] = None
+        self.setWindowTitle("Connect to Device")
+        self.setMinimumWidth(400)
+        self.setModal(True)
+        self._build_ui()
+
+    def _build_ui(self) -> None:
+        layout = QVBoxLayout(self)
+        layout.setSpacing(16)
+        layout.setContentsMargins(24, 24, 24, 20)
+
+        title = QLabel("Connect via TCP/IP")
+        title.setStyleSheet(f"font-size: 18px; font-weight: 700; color: {Colors.TEXT_PRIMARY};")
+        layout.addWidget(title)
+
+        hint = QLabel(
+            "Enter the IP address and port of your Android device.\n"
+            "Default ADB port is 5555."
+        )
+        hint.setStyleSheet(
+            f"color: {Colors.TEXT_SECONDARY}; font-size: 12px; "
+            f"background: {Colors.BG_ELEVATED}; border-radius: 6px; padding: 10px;"
+        )
+        hint.setWordWrap(True)
+        layout.addWidget(hint)
+
+        form = QFormLayout()
+        form.setSpacing(10)
+        form.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
+
+        self._host_edit = QLineEdit()
+        self._host_edit.setPlaceholderText("192.168.1.x")
+        form.addRow("IP Address:", self._host_edit)
+
+        self._port_edit = QLineEdit("5555")
+        self._port_edit.setPlaceholderText("5555")
+        form.addRow("Port:", self._port_edit)
+
+        layout.addLayout(form)
+
+        self._remember_check = QCheckBox("Remember this device")
+        self._remember_check.setChecked(True)
+        layout.addWidget(self._remember_check)
+
+        self._progress = QProgressBar()
+        self._progress.setRange(0, 0)
+        self._progress.hide()
+        layout.addWidget(self._progress)
+
+        self._status = QLabel()
+        self._status.setWordWrap(True)
+        self._status.hide()
+        layout.addWidget(self._status)
+
+        buttons = QDialogButtonBox()
+        self._connect_btn = QPushButton("Connect")
+        self._connect_btn.setObjectName("accent")
+        self._connect_btn.clicked.connect(self._start_connect)
+        buttons.addButton(self._connect_btn, QDialogButtonBox.ButtonRole.AcceptRole)
+        cancel = buttons.addButton(QDialogButtonBox.StandardButton.Cancel)
+        cancel.clicked.connect(self.reject)
+        layout.addWidget(buttons)
+
+    def _start_connect(self) -> None:
+        host = self._host_edit.text().strip()
+        port_str = self._port_edit.text().strip()
+
+        if not host:
+            self._show_error("Enter an IP address.")
+            return
+        if not port_str.isdigit():
+            self._show_error("Port must be a number.")
+            return
+
+        self._connect_btn.setEnabled(False)
+        self._progress.show()
+        self._status.hide()
+
+        self._worker = ConnectWorker(
+            self._controller, host, int(port_str), self._remember_check.isChecked(), self
+        )
+        self._worker.success.connect(self._on_success)
+        self._worker.failure.connect(self._on_failure)
+        self._worker.start()
+
+    @Slot(object)
+    def _on_success(self, device: object) -> None:
+        self._progress.hide()
+        self.connected.emit(device)
+        self.accept()
+
+    @Slot(str)
+    def _on_failure(self, msg: str) -> None:
+        self._progress.hide()
+        self._connect_btn.setEnabled(True)
+        self._show_error(msg)
+
+    def _show_error(self, msg: str) -> None:
+        self._status.setText(f"✗ {msg}")
+        self._status.setStyleSheet(f"color: {Colors.ERROR};")
+        self._status.show()

voidremote/ui/dialogs/pair_dialog.py

@@ -0,0 +1,189 @@
+"""Wireless ADB pairing dialog."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from PySide6.QtCore import Qt, QThread, Signal, Slot
+from PySide6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QLabel,
+    QLineEdit,
+    QProgressBar,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from voidremote.ui.theme import Colors
+
+
+class PairWorker(QThread):
+    """Background thread for ADB pairing."""
+
+    success = Signal(str)
+    failure = Signal(str)
+
+    def __init__(
+        self,
+        controller: object,
+        host: str,
+        port: int,
+        code: str,
+        parent: Optional[QObject] = None,  # type: ignore[name-defined]
+    ) -> None:
+        super().__init__(parent)
+        self._controller = controller
+        self._host = host
+        self._port = port
+        self._code = code
+
+    def run(self) -> None:
+        try:
+            ok = self._controller.pair_device(self._host, self._port, self._code)
+            if ok:
+                self.success.emit(f"Paired with {self._host}:{self._port}")
+            else:
+                self.failure.emit("Pairing failed — wrong code or timeout")
+        except Exception as exc:
+            self.failure.emit(str(exc))
+
+
+class PairDialog(QDialog):
+    """
+    Dialog for pairing an Android device via Wireless Debugging.
+
+    Shows setup instructions, input fields, and async pairing progress.
+    """
+
+    paired = Signal(str, int)  # host, port
+
+    def __init__(self, controller: object, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._controller = controller
+        self._worker: Optional[PairWorker] = None
+        self.setWindowTitle("Pair New Device")
+        self.setMinimumWidth(440)
+        self.setModal(True)
+        self._build_ui()
+
+    def _build_ui(self) -> None:
+        layout = QVBoxLayout(self)
+        layout.setSpacing(16)
+        layout.setContentsMargins(24, 24, 24, 20)
+
+        # Title
+        title = QLabel("Pair via Wireless Debugging")
+        title.setStyleSheet(
+            f"font-size: 18px; font-weight: 700; color: {Colors.TEXT_PRIMARY};"
+        )
+        layout.addWidget(title)
+
+        # Instructions
+        instructions = QLabel(
+            "On your Android device:\n"
+            "  1. Go to Settings → Developer Options\n"
+            "  2. Enable Wireless Debugging\n"
+            "  3. Tap 'Pair device with pairing code'\n"
+            "  4. Enter the IP, port, and 6-digit code shown below"
+        )
+        instructions.setStyleSheet(
+            f"color: {Colors.TEXT_SECONDARY}; font-size: 12px; "
+            f"background: {Colors.BG_ELEVATED}; border-radius: 6px; padding: 12px;"
+        )
+        instructions.setWordWrap(True)
+        layout.addWidget(instructions)
+
+        # Form
+        form = QFormLayout()
+        form.setSpacing(10)
+        form.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
+
+        self._host_edit = QLineEdit()
+        self._host_edit.setPlaceholderText("192.168.1.x")
+        form.addRow("Device IP:", self._host_edit)
+
+        self._port_edit = QLineEdit()
+        self._port_edit.setPlaceholderText("37001")
+        self._port_edit.setText("37001")
+        form.addRow("Pairing Port:", self._port_edit)
+
+        self._code_edit = QLineEdit()
+        self._code_edit.setPlaceholderText("123456")
+        self._code_edit.setMaxLength(6)
+        form.addRow("6-digit Code:", self._code_edit)
+
+        layout.addLayout(form)
+
+        # Progress
+        self._progress = QProgressBar()
+        self._progress.setRange(0, 0)
+        self._progress.hide()
+        layout.addWidget(self._progress)
+
+        # Status label
+        self._status = QLabel()
+        self._status.setWordWrap(True)
+        self._status.hide()
+        layout.addWidget(self._status)
+
+        # Buttons
+        self._buttons = QDialogButtonBox()
+        self._pair_btn = QPushButton("Pair Device")
+        self._pair_btn.setObjectName("accent")
+        self._pair_btn.clicked.connect(self._start_pairing)
+        self._buttons.addButton(self._pair_btn, QDialogButtonBox.ButtonRole.AcceptRole)
+
+        cancel_btn = self._buttons.addButton(QDialogButtonBox.StandardButton.Cancel)
+        cancel_btn.clicked.connect(self.reject)
+
+        layout.addWidget(self._buttons)
+
+    def _start_pairing(self) -> None:
+        host = self._host_edit.text().strip()
+        port_str = self._port_edit.text().strip()
+        code = self._code_edit.text().strip()
+
+        if not host:
+            self._show_error("Enter the device IP address.")
+            return
+        if not port_str.isdigit():
+            self._show_error("Port must be a number.")
+            return
+        if len(code) != 6 or not code.isdigit():
+            self._show_error("Pairing code must be exactly 6 digits.")
+            return
+
+        port = int(port_str)
+        self._pair_btn.setEnabled(False)
+        self._progress.show()
+        self._status.hide()
+
+        self._worker = PairWorker(self._controller, host, port, code, self)
+        self._worker.success.connect(self._on_success)
+        self._worker.failure.connect(self._on_failure)
+        self._worker.start()
+
+    @Slot(str)
+    def _on_success(self, msg: str) -> None:
+        self._progress.hide()
+        self._status.setText(f"✓ {msg}")
+        self._status.setStyleSheet(f"color: {Colors.SUCCESS}; font-weight: 600;")
+        self._status.show()
+        host = self._host_edit.text().strip()
+        port = int(self._port_edit.text().strip())
+        self.paired.emit(host, port)
+        self.accept()
+
+    @Slot(str)
+    def _on_failure(self, msg: str) -> None:
+        self._progress.hide()
+        self._pair_btn.setEnabled(True)
+        self._show_error(msg)
+
+    def _show_error(self, msg: str) -> None:
+        self._status.setText(f"✗ {msg}")
+        self._status.setStyleSheet(f"color: {Colors.ERROR};")
+        self._status.show()