voidremote 1.0.0__py3-none-any.whl

voidremote/ui/views/monitor_view.py

@@ -0,0 +1,236 @@
+"""Real-time device monitoring view with live gauges and graphs."""
+
+from __future__ import annotations
+
+from collections import deque
+from typing import Optional
+
+from PySide6.QtCore import Qt, QTimer, Slot
+from PySide6.QtWidgets import (
+    QComboBox,
+    QFrame,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QProgressBar,
+    QVBoxLayout,
+    QWidget,
+)
+
+from voidremote.services.monitor_service import DeviceSnapshot
+from voidremote.ui.theme import Colors
+from voidremote.ui.widgets.metric_gauge import MetricGauge
+
+
+class SparklineWidget(QWidget):
+    """Minimal sparkline chart for a time-series metric."""
+
+    def __init__(self, color: str = Colors.ACCENT, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._color = color
+        self._data: deque[float] = deque(maxlen=60)
+        self.setMinimumHeight(60)
+
+    def push(self, value: float) -> None:
+        self._data.append(value)
+        self.update()
+
+    def paintEvent(self, event: object) -> None:  # type: ignore[override]
+        if len(self._data) < 2:
+            return
+        from PySide6.QtGui import QPainter, QPen, QColor, QPainterPath
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        w, h = self.width(), self.height()
+        data = list(self._data)
+        max_v = max(data) or 1.0
+        step = w / max(len(data) - 1, 1)
+
+        path = QPainterPath()
+        for i, v in enumerate(data):
+            x = i * step
+            y = h - (v / max_v) * (h - 4) - 2
+            if i == 0:
+                path.moveTo(x, y)
+            else:
+                path.lineTo(x, y)
+
+        pen = QPen(QColor(self._color))
+        pen.setWidth(2)
+        pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+        pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+        painter.setPen(pen)
+        painter.drawPath(path)
+
+
+class MetricCard(QFrame):
+    """Card showing a gauge + sparkline + current value label."""
+
+    def __init__(
+        self,
+        title: str,
+        color: str = Colors.ACCENT,
+        parent: Optional[QWidget] = None,
+    ) -> None:
+        super().__init__(parent)
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        self.setObjectName("DeviceCard")
+        self._color = color
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(16, 14, 16, 14)
+        layout.setSpacing(8)
+
+        title_label = QLabel(title)
+        title_label.setStyleSheet(
+            f"font-size: 13px; font-weight: 600; color: {Colors.TEXT_SECONDARY}; text-transform: uppercase; letter-spacing: 0.5px;"
+        )
+        layout.addWidget(title_label)
+
+        self._gauge = MetricGauge(label="", color=color)
+        self._gauge.setFixedHeight(110)
+        layout.addWidget(self._gauge, alignment=Qt.AlignmentFlag.AlignCenter)
+
+        self._spark = SparklineWidget(color=color)
+        layout.addWidget(self._spark)
+
+        self._value_label = QLabel("–")
+        self._value_label.setStyleSheet(
+            f"font-size: 12px; color: {Colors.TEXT_SECONDARY}; text-align: center;"
+        )
+        self._value_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self._value_label)
+
+    def update_value(self, value: float, suffix: str = "%", detail: str = "") -> None:
+        self._gauge.set_value(value)
+        self._gauge.set_suffix(suffix)
+        self._spark.push(value)
+        self._value_label.setText(detail or f"{value:.1f}{suffix}")
+
+
+class MonitorView(QWidget):
+    """
+    Live device monitoring dashboard.
+
+    Shows CPU, RAM, Battery, and Temperature in metric cards
+    with sparkline history graphs updated by MonitorService.
+    """
+
+    def __init__(self, controller: object, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._controller = controller
+        self._serial: Optional[str] = None
+        self._build_ui()
+
+    def _build_ui(self) -> None:
+        root = QVBoxLayout(self)
+        root.setContentsMargins(0, 0, 0, 0)
+        root.setSpacing(0)
+
+        # ── Header ──────────────────────────────────────
+        header = QHBoxLayout()
+        header.setContentsMargins(24, 16, 24, 12)
+        header.setSpacing(12)
+
+        title = QLabel("Monitor")
+        title.setStyleSheet(f"font-size: 22px; font-weight: 700; color: {Colors.TEXT_PRIMARY};")
+        header.addWidget(title)
+        header.addStretch()
+
+        header.addWidget(QLabel("Device:"))
+        self._device_combo = QComboBox()
+        self._device_combo.setMinimumWidth(220)
+        self._device_combo.currentTextChanged.connect(self._on_device_changed)
+        header.addWidget(self._device_combo)
+
+        header_w = QWidget()
+        header_w.setStyleSheet(
+            f"background: {Colors.BG_SURFACE}; border-bottom: 1px solid {Colors.BORDER};"
+        )
+        header_w.setLayout(header)
+        root.addWidget(header_w)
+
+        # ── Metric cards grid ────────────────────────────
+        content = QWidget()
+        content.setStyleSheet(f"background: {Colors.BG_BASE};")
+        grid = QGridLayout(content)
+        grid.setContentsMargins(24, 20, 24, 20)
+        grid.setSpacing(16)
+
+        self._cpu_card = MetricCard("CPU Usage", Colors.ACCENT)
+        self._ram_card = MetricCard("RAM Usage", Colors.INFO)
+        self._batt_card = MetricCard("Battery", Colors.SUCCESS)
+        self._temp_card = MetricCard("Temperature", Colors.WARNING)
+
+        grid.addWidget(self._cpu_card, 0, 0)
+        grid.addWidget(self._ram_card, 0, 1)
+        grid.addWidget(self._batt_card, 1, 0)
+        grid.addWidget(self._temp_card, 1, 1)
+
+        root.addWidget(content, stretch=1)
+
+        # ── Status bar ───────────────────────────────────
+        self._status_bar = QLabel("Select a device to begin monitoring")
+        self._status_bar.setStyleSheet(
+            f"color: {Colors.TEXT_MUTED}; padding: 8px 24px; "
+            f"background: {Colors.BG_SURFACE}; border-top: 1px solid {Colors.BORDER};"
+        )
+        root.addWidget(self._status_bar)
+
+    def set_devices(self, devices: list) -> None:
+        current = self._device_combo.currentData()
+        self._device_combo.blockSignals(True)
+        self._device_combo.clear()
+        for d in devices:
+            self._device_combo.addItem(f"{d.info.display_name} ({d.serial})", userData=d.serial)
+        idx = self._device_combo.findData(current)
+        if idx >= 0:
+            self._device_combo.setCurrentIndex(idx)
+        self._device_combo.blockSignals(False)
+
+    def _on_device_changed(self) -> None:
+        serial = self._device_combo.currentData()
+        if serial == self._serial:
+            return
+        if self._serial:
+            try:
+                self._controller.stop_monitoring(self._serial)
+            except Exception:
+                pass
+        self._serial = serial
+        if serial:
+            try:
+                self._controller.start_monitoring(serial, interval=2.0, callback=self._on_snapshot)
+                self._status_bar.setText(f"Monitoring {serial}")
+            except Exception as exc:
+                self._status_bar.setText(f"Error: {exc}")
+
+    def _on_snapshot(self, snapshot: DeviceSnapshot) -> None:
+        # This runs in a background thread; update UI via queued connection
+        from PySide6.QtCore import QMetaObject, Q_ARG
+        QMetaObject.invokeMethod(self, "_apply_snapshot", Qt.ConnectionType.QueuedConnection,
+                                 Q_ARG(object, snapshot))
+
+    @Slot(object)
+    def _apply_snapshot(self, snapshot: DeviceSnapshot) -> None:
+        self._cpu_card.update_value(snapshot.cpu_usage, "%", f"CPU: {snapshot.cpu_usage:.1f}%")
+        self._ram_card.update_value(
+            snapshot.ram_usage_percent, "%",
+            f"{snapshot.ram_used_mb:.0f} / {snapshot.ram_total_mb:.0f} MB"
+        )
+        self._batt_card.update_value(
+            float(snapshot.battery_level), "%",
+            f"{snapshot.battery_level}% {'⚡' if snapshot.battery_is_charging else ''}"
+        )
+        self._temp_card.update_value(
+            snapshot.battery_temperature, "°C",
+            f"{snapshot.battery_temperature:.1f}°C"
+        )
+
+    def cleanup(self) -> None:
+        if self._serial:
+            try:
+                self._controller.stop_monitoring(self._serial)
+            except Exception:
+                pass

voidremote/ui/views/settings_view.py

@@ -0,0 +1,257 @@
+"""Settings panel view."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QScrollArea,
+    QSlider,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+from voidremote.config.settings import AppSettings, get_settings, save_settings
+from voidremote.ui.theme import Colors
+
+
+class SettingsView(QWidget):
+    """Full settings panel with save/reset functionality."""
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._settings = get_settings()
+        self._build_ui()
+        self._load_values()
+
+    def _build_ui(self) -> None:
+        root = QVBoxLayout(self)
+        root.setContentsMargins(0, 0, 0, 0)
+        root.setSpacing(0)
+
+        # ── Header ──────────────────────────────────────
+        header = QHBoxLayout()
+        header.setContentsMargins(24, 16, 24, 12)
+
+        title = QLabel("Settings")
+        title.setStyleSheet(f"font-size: 22px; font-weight: 700; color: {Colors.TEXT_PRIMARY};")
+        header.addWidget(title)
+        header.addStretch()
+
+        btn_reset = QPushButton("Reset Defaults")
+        btn_reset.clicked.connect(self._reset_defaults)
+        header.addWidget(btn_reset)
+
+        btn_save = QPushButton("Save")
+        btn_save.setObjectName("accent")
+        btn_save.setFixedWidth(70)
+        btn_save.clicked.connect(self._save)
+        header.addWidget(btn_save)
+
+        header_w = QWidget()
+        header_w.setStyleSheet(f"background: {Colors.BG_SURFACE}; border-bottom: 1px solid {Colors.BORDER};")
+        header_w.setLayout(header)
+        root.addWidget(header_w)
+
+        # ── Scrollable content ───────────────────────────
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setFrameShape(QScrollArea.Shape.NoFrame)  # type: ignore[attr-defined]
+
+        content = QWidget()
+        content.setStyleSheet(f"background: {Colors.BG_BASE};")
+        content_layout = QVBoxLayout(content)
+        content_layout.setContentsMargins(32, 24, 32, 24)
+        content_layout.setSpacing(20)
+
+        content_layout.addWidget(self._build_adb_group())
+        content_layout.addWidget(self._build_ui_group())
+        content_layout.addWidget(self._build_mirror_group())
+        content_layout.addWidget(self._build_logging_group())
+        content_layout.addStretch()
+
+        scroll.setWidget(content)
+        root.addWidget(scroll, stretch=1)
+
+        self._status_label = QLabel()
+        self._status_label.setStyleSheet(
+            f"color: {Colors.SUCCESS}; padding: 6px 24px; "
+            f"background: {Colors.BG_SURFACE}; border-top: 1px solid {Colors.BORDER};"
+        )
+        root.addWidget(self._status_label)
+
+    def _build_adb_group(self) -> QGroupBox:
+        group = QGroupBox("ADB")
+        form = QFormLayout(group)
+        form.setSpacing(10)
+
+        self._adb_path = QLineEdit()
+        self._adb_path.setPlaceholderText("adb")
+        form.addRow("ADB Binary Path:", self._adb_path)
+
+        self._adb_port = QSpinBox()
+        self._adb_port.setRange(1, 65535)
+        form.addRow("Default Port:", self._adb_port)
+
+        self._adb_timeout = QSpinBox()
+        self._adb_timeout.setRange(1, 300)
+        self._adb_timeout.setSuffix(" s")
+        form.addRow("Command Timeout:", self._adb_timeout)
+
+        self._adb_retry = QSpinBox()
+        self._adb_retry.setRange(0, 10)
+        form.addRow("Retry Count:", self._adb_retry)
+
+        self._auto_start = QCheckBox("Auto-start ADB server")
+        form.addRow("", self._auto_start)
+
+        self._kill_on_exit = QCheckBox("Kill ADB server on exit")
+        form.addRow("", self._kill_on_exit)
+
+        return group
+
+    def _build_ui_group(self) -> QGroupBox:
+        group = QGroupBox("Interface")
+        form = QFormLayout(group)
+        form.setSpacing(10)
+
+        self._theme_combo = QComboBox()
+        self._theme_combo.addItems(["dark", "light", "auto"])
+        form.addRow("Theme:", self._theme_combo)
+
+        self._font_size = QSpinBox()
+        self._font_size.setRange(8, 24)
+        self._font_size.setSuffix(" px")
+        form.addRow("Font Size:", self._font_size)
+
+        self._animations = QCheckBox("Enable animations")
+        form.addRow("", self._animations)
+
+        self._notifications = QCheckBox("Enable notifications")
+        form.addRow("", self._notifications)
+
+        self._tray_icon = QCheckBox("Show system tray icon")
+        form.addRow("", self._tray_icon)
+
+        return group
+
+    def _build_mirror_group(self) -> QGroupBox:
+        group = QGroupBox("Screen Mirror")
+        form = QFormLayout(group)
+        form.setSpacing(10)
+
+        self._mirror_fps = QSpinBox()
+        self._mirror_fps.setRange(1, 120)
+        self._mirror_fps.setSuffix(" FPS")
+        form.addRow("Max FPS:", self._mirror_fps)
+
+        self._mirror_bitrate = QSpinBox()
+        self._mirror_bitrate.setRange(1, 64)
+        self._mirror_bitrate.setSuffix(" Mbps")
+        form.addRow("Bitrate:", self._mirror_bitrate)
+
+        self._mirror_width = QSpinBox()
+        self._mirror_width.setRange(320, 3840)
+        self._mirror_width.setSingleStep(16)
+        form.addRow("Max Width:", self._mirror_width)
+
+        self._stay_awake = QCheckBox("Keep device awake while mirroring")
+        form.addRow("", self._stay_awake)
+
+        self._show_touches = QCheckBox("Show touch points")
+        form.addRow("", self._show_touches)
+
+        return group
+
+    def _build_logging_group(self) -> QGroupBox:
+        group = QGroupBox("Logging")
+        form = QFormLayout(group)
+        form.setSpacing(10)
+
+        self._log_level = QComboBox()
+        self._log_level.addItems(["DEBUG", "INFO", "WARNING", "ERROR"])
+        form.addRow("Log Level:", self._log_level)
+
+        self._log_file_enabled = QCheckBox("Write log file")
+        form.addRow("", self._log_file_enabled)
+
+        self._log_max_size = QSpinBox()
+        self._log_max_size.setRange(1, 100)
+        self._log_max_size.setSuffix(" MB")
+        form.addRow("Max File Size:", self._log_max_size)
+
+        self._log_backup = QSpinBox()
+        self._log_backup.setRange(0, 20)
+        form.addRow("Backup Files:", self._log_backup)
+
+        return group
+
+    def _load_values(self) -> None:
+        s = self._settings
+        self._adb_path.setText(s.adb.path)
+        self._adb_port.setValue(s.adb.default_port)
+        self._adb_timeout.setValue(int(s.adb.command_timeout))
+        self._adb_retry.setValue(s.adb.retry_count)
+        self._auto_start.setChecked(s.adb.auto_start_server)
+        self._kill_on_exit.setChecked(s.adb.kill_server_on_exit)
+
+        self._theme_combo.setCurrentText(s.ui.theme)
+        self._font_size.setValue(s.ui.font_size)
+        self._animations.setChecked(s.ui.animations_enabled)
+        self._notifications.setChecked(s.ui.notifications_enabled)
+        self._tray_icon.setChecked(s.ui.tray_icon_enabled)
+
+        self._mirror_fps.setValue(s.mirror.max_fps)
+        self._mirror_bitrate.setValue(s.mirror.max_bitrate_mbps)
+        self._mirror_width.setValue(s.mirror.max_width)
+        self._stay_awake.setChecked(s.mirror.stay_awake)
+        self._show_touches.setChecked(s.mirror.show_touches)
+
+        self._log_level.setCurrentText(s.logging.level)
+        self._log_file_enabled.setChecked(s.logging.file_enabled)
+        self._log_max_size.setValue(s.logging.max_file_size_mb)
+        self._log_backup.setValue(s.logging.backup_count)
+
+    def _save(self) -> None:
+        s = self._settings
+        s.adb.path = self._adb_path.text().strip() or "adb"
+        s.adb.default_port = self._adb_port.value()
+        s.adb.command_timeout = float(self._adb_timeout.value())
+        s.adb.retry_count = self._adb_retry.value()
+        s.adb.auto_start_server = self._auto_start.isChecked()
+        s.adb.kill_server_on_exit = self._kill_on_exit.isChecked()
+
+        s.ui.theme = self._theme_combo.currentText()
+        s.ui.font_size = self._font_size.value()
+        s.ui.animations_enabled = self._animations.isChecked()
+        s.ui.notifications_enabled = self._notifications.isChecked()
+        s.ui.tray_icon_enabled = self._tray_icon.isChecked()
+
+        s.mirror.max_fps = self._mirror_fps.value()
+        s.mirror.max_bitrate_mbps = self._mirror_bitrate.value()
+        s.mirror.max_width = self._mirror_width.value()
+        s.mirror.stay_awake = self._stay_awake.isChecked()
+        s.mirror.show_touches = self._show_touches.isChecked()
+
+        s.logging.level = self._log_level.currentText()
+        s.logging.file_enabled = self._log_file_enabled.isChecked()
+        s.logging.max_file_size_mb = self._log_max_size.value()
+        s.logging.backup_count = self._log_backup.value()
+
+        s.save()
+        self._status_label.setText("✓ Settings saved")
+
+    def _reset_defaults(self) -> None:
+        self._settings.reset_to_defaults()
+        self._load_values()
+        self._status_label.setText("Settings reset to defaults")