voidremote 1.0.0__py3-none-any.whl

voidremote/ui/views/shell_view.py

@@ -0,0 +1,234 @@
+"""Embedded ADB shell terminal view."""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from PySide6.QtCore import Qt, QThread, Signal, Slot
+from PySide6.QtGui import QFont, QKeyEvent, QTextCharFormat, QColor, QTextCursor
+from PySide6.QtWidgets import (
+    QComboBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPlainTextEdit,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from voidremote.ui.theme import Colors
+
+logger = logging.getLogger(__name__)
+
+
+class ShellWorker(QThread):
+    output = Signal(str, bool)  # text, is_error
+
+    def __init__(self, controller: object, serial: str, command: str, parent: Optional[object] = None) -> None:
+        super().__init__(parent)
+        self._controller = controller
+        self._serial = serial
+        self._command = command
+
+    def run(self) -> None:
+        try:
+            result = self._controller.shell(self._serial, self._command)
+            self.output.emit(result, False)
+        except Exception as exc:
+            self.output.emit(str(exc), True)
+
+
+class HistoryLineEdit(QLineEdit):
+    """Line edit with command history navigation."""
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._history: list[str] = []
+        self._history_idx = -1
+
+    def add_to_history(self, cmd: str) -> None:
+        if cmd and (not self._history or self._history[-1] != cmd):
+            self._history.append(cmd)
+        self._history_idx = -1
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        if event.key() == Qt.Key.Key_Up:
+            if self._history:
+                self._history_idx = min(self._history_idx + 1, len(self._history) - 1)
+                self.setText(self._history[-(self._history_idx + 1)])
+            return
+        if event.key() == Qt.Key.Key_Down:
+            if self._history_idx > 0:
+                self._history_idx -= 1
+                self.setText(self._history[-(self._history_idx + 1)])
+            elif self._history_idx == 0:
+                self._history_idx = -1
+                self.clear()
+            return
+        super().keyPressEvent(event)
+
+
+class ShellView(QWidget):
+    """
+    ADB shell terminal emulator embedded in the GUI.
+
+    Features:
+        - Device selector dropdown
+        - Command history (up/down arrows)
+        - Colored output (errors in red)
+        - Clear and copy buttons
+    """
+
+    def __init__(self, controller: object, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._controller = controller
+        self._serial: Optional[str] = None
+        self._worker: Optional[ShellWorker] = 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("Shell")
+        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(200)
+        self._device_combo.currentTextChanged.connect(self._on_device_changed)
+        header.addWidget(self._device_combo)
+
+        btn_clear = QPushButton("Clear")
+        btn_clear.setFixedWidth(60)
+        btn_clear.clicked.connect(self._output.clear if hasattr(self, "_output") else lambda: None)
+        header.addWidget(btn_clear)
+
+        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)
+
+        # ── Terminal output ──────────────────────────────
+        self._output = QPlainTextEdit()
+        self._output.setReadOnly(True)
+        self._output.setObjectName("LogView")
+        mono = QFont("JetBrains Mono, Cascadia Code, Consolas, monospace", 13)
+        self._output.setFont(mono)
+        self._output.setStyleSheet(
+            f"background: {Colors.BG_BASE}; border: none; padding: 16px;"
+        )
+        root.addWidget(self._output, stretch=1)
+
+        # Fix clear button now that _output exists
+        btn_clear.clicked.disconnect()
+        btn_clear.clicked.connect(self._output.clear)
+
+        # ── Input bar ────────────────────────────────────
+        input_bar = QHBoxLayout()
+        input_bar.setContentsMargins(16, 10, 16, 12)
+        input_bar.setSpacing(8)
+
+        prompt = QLabel("$")
+        prompt.setStyleSheet(
+            f"color: {Colors.ACCENT}; font-family: monospace; font-size: 15px; font-weight: 700;"
+        )
+        input_bar.addWidget(prompt)
+
+        self._cmd_edit = HistoryLineEdit()
+        self._cmd_edit.setPlaceholderText("Enter shell command…")
+        self._cmd_edit.setFont(mono)
+        self._cmd_edit.returnPressed.connect(self._run_command)
+        input_bar.addWidget(self._cmd_edit, stretch=1)
+
+        self._run_btn = QPushButton("Run")
+        self._run_btn.setObjectName("accent")
+        self._run_btn.setFixedWidth(60)
+        self._run_btn.clicked.connect(self._run_command)
+        input_bar.addWidget(self._run_btn)
+
+        input_bar_w = QWidget()
+        input_bar_w.setStyleSheet(
+            f"background: {Colors.BG_SURFACE}; border-top: 1px solid {Colors.BORDER};"
+        )
+        input_bar_w.setLayout(input_bar)
+        root.addWidget(input_bar_w)
+
+        self._print_welcome()
+
+    def _print_welcome(self) -> None:
+        self._append(
+            "VoidRemote Shell — ADB shell emulator\n"
+            "Select a device above, then type a command and press Enter.\n"
+            "Use ↑ / ↓ to navigate command history.\n",
+            error=False,
+        )
+
+    def set_devices(self, devices: list) -> None:
+        current = self._device_combo.currentText()
+        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)
+        elif self._device_combo.count() > 0:
+            self._serial = self._device_combo.currentData()
+        self._device_combo.blockSignals(False)
+
+    def _on_device_changed(self) -> None:
+        self._serial = self._device_combo.currentData()
+
+    def _run_command(self) -> None:
+        cmd = self._cmd_edit.text().strip()
+        if not cmd:
+            return
+        if not self._serial:
+            self._append("No device selected.\n", error=True)
+            return
+        if self._worker and self._worker.isRunning():
+            self._append("Previous command still running…\n", error=True)
+            return
+
+        self._cmd_edit.add_to_history(cmd)
+        self._cmd_edit.clear()
+        self._run_btn.setEnabled(False)
+        self._append(f"$ {cmd}\n", error=False, dim=True)
+
+        self._worker = ShellWorker(self._controller, self._serial, cmd, self)
+        self._worker.output.connect(self._on_output)
+        self._worker.finished.connect(lambda: self._run_btn.setEnabled(True))
+        self._worker.start()
+
+    @Slot(str, bool)
+    def _on_output(self, text: str, is_error: bool) -> None:
+        self._append(text + "\n", error=is_error)
+
+    def _append(self, text: str, error: bool = False, dim: bool = False) -> None:
+        fmt = QTextCharFormat()
+        if error:
+            fmt.setForeground(QColor(Colors.ERROR))
+        elif dim:
+            fmt.setForeground(QColor(Colors.TEXT_MUTED))
+        else:
+            fmt.setForeground(QColor(Colors.TEXT_PRIMARY))
+
+        cursor = self._output.textCursor()
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        cursor.insertText(text, fmt)
+        self._output.setTextCursor(cursor)
+        self._output.ensureCursorVisible()

voidremote/ui/widgets/__init__.py

@@ -0,0 +1,14 @@
+"""VoidRemote UI widgets."""
+
+from voidremote.ui.widgets.device_card import DeviceCard, StatusDot, BatteryBar
+from voidremote.ui.widgets.log_view import LogView, QtLogHandler
+from voidremote.ui.widgets.metric_gauge import MetricGauge
+
+__all__ = [
+    "BatteryBar",
+    "DeviceCard",
+    "LogView",
+    "MetricGauge",
+    "QtLogHandler",
+    "StatusDot",
+]

voidremote/ui/widgets/device_card.py

@@ -0,0 +1,259 @@
+"""Device card widget for the dashboard."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from PySide6.QtCore import Qt, Signal, QPropertyAnimation, QEasingCurve, Property
+from PySide6.QtGui import QColor, QPainter, QPen, QBrush, QFont
+from PySide6.QtWidgets import (
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QProgressBar,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from voidremote.models.device import Device, DeviceState
+from voidremote.ui.theme import Colors
+
+
+class BatteryBar(QWidget):
+    """Compact battery level indicator."""
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._level = 0
+        self._charging = False
+        self.setFixedSize(28, 14)
+
+    def set_level(self, level: int, charging: bool = False) -> None:
+        self._level = max(0, min(100, level))
+        self._charging = charging
+        self.update()
+
+    def paintEvent(self, event: object) -> None:  # type: ignore[override]
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        # Outer shell
+        pen = QPen(QColor(Colors.BORDER))
+        pen.setWidth(1)
+        painter.setPen(pen)
+        painter.setBrush(QBrush(QColor(Colors.BG_ELEVATED)))
+        painter.drawRoundedRect(0, 0, 24, 14, 3, 3)
+
+        # Tip
+        painter.setBrush(QBrush(QColor(Colors.BORDER)))
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.drawRoundedRect(24, 4, 3, 6, 1, 1)
+
+        # Fill
+        if self._level > 50:
+            color = QColor(Colors.BATTERY_FULL)
+        elif self._level > 20:
+            color = QColor(Colors.BATTERY_MID)
+        else:
+            color = QColor(Colors.BATTERY_LOW)
+
+        fill_width = int((22 * self._level) / 100)
+        if fill_width > 0:
+            painter.setBrush(QBrush(color))
+            painter.drawRoundedRect(1, 1, fill_width, 12, 2, 2)
+
+
+class StatusDot(QWidget):
+    """Animated status indicator dot."""
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._color = QColor(Colors.TEXT_MUTED)
+        self.setFixedSize(10, 10)
+
+    def set_state(self, state: DeviceState) -> None:
+        color_map = {
+            DeviceState.ONLINE: Colors.SUCCESS,
+            DeviceState.OFFLINE: Colors.ERROR,
+            DeviceState.UNAUTHORIZED: Colors.WARNING,
+            DeviceState.CONNECTING: Colors.INFO,
+        }
+        self._color = QColor(color_map.get(state, Colors.TEXT_MUTED))
+        self.update()
+
+    def paintEvent(self, event: object) -> None:  # type: ignore[override]
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QBrush(self._color))
+        painter.drawEllipse(1, 1, 8, 8)
+
+
+class DeviceCard(QFrame):
+    """
+    Device card widget shown in the devices dashboard.
+
+    Emits:
+        connect_requested(serial): User clicked Connect.
+        disconnect_requested(serial): User clicked Disconnect.
+        mirror_requested(serial): User clicked Mirror.
+        info_requested(serial): User clicked Info / device name.
+    """
+
+    connect_requested: Signal = Signal(str)
+    disconnect_requested: Signal = Signal(str)
+    mirror_requested: Signal = Signal(str)
+    info_requested: Signal = Signal(str)
+
+    def __init__(self, device: Device, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._device = device
+        self.setObjectName("DeviceCard")
+        self.setCursor(Qt.CursorShape.PointingHandCursor)
+        self._build_ui()
+        self.refresh(device)
+
+    def _build_ui(self) -> None:
+        self.setFrameShape(QFrame.Shape.StyledPanel)
+        self.setMinimumHeight(140)
+
+        root = QVBoxLayout(self)
+        root.setContentsMargins(16, 14, 16, 14)
+        root.setSpacing(10)
+
+        # ── Header ──────────────────────────────────────
+        header = QHBoxLayout()
+        header.setSpacing(8)
+
+        self._status_dot = StatusDot()
+        header.addWidget(self._status_dot)
+
+        self._name_label = QLabel()
+        self._name_label.setStyleSheet(
+            f"font-size: 15px; font-weight: 700; color: {Colors.TEXT_PRIMARY};"
+        )
+        header.addWidget(self._name_label, stretch=1)
+
+        self._battery_bar = BatteryBar()
+        header.addWidget(self._battery_bar)
+
+        self._battery_label = QLabel()
+        self._battery_label.setStyleSheet(
+            f"font-size: 11px; color: {Colors.TEXT_SECONDARY}; min-width: 32px;"
+        )
+        header.addWidget(self._battery_label)
+
+        root.addLayout(header)
+
+        # ── Meta row ────────────────────────────────────
+        meta = QHBoxLayout()
+        meta.setSpacing(16)
+
+        self._serial_label = QLabel()
+        self._serial_label.setStyleSheet(
+            f"font-size: 11px; color: {Colors.TEXT_MUTED}; font-family: monospace;"
+        )
+        meta.addWidget(self._serial_label, stretch=1)
+
+        self._android_label = QLabel()
+        self._android_label.setStyleSheet(
+            f"font-size: 11px; color: {Colors.TEXT_SECONDARY};"
+        )
+        meta.addWidget(self._android_label)
+
+        root.addLayout(meta)
+
+        # ── Info row ────────────────────────────────────
+        info = QHBoxLayout()
+        info.setSpacing(20)
+
+        self._res_label = self._make_info_label("Resolution", "–")
+        self._ip_label = self._make_info_label("IP", "–")
+        self._type_label = self._make_info_label("Type", "–")
+
+        for lbl in (self._res_label, self._ip_label, self._type_label):
+            info.addWidget(lbl)
+        info.addStretch()
+
+        root.addLayout(info)
+        root.addStretch()
+
+        # ── Actions ─────────────────────────────────────
+        actions = QHBoxLayout()
+        actions.setSpacing(8)
+        actions.addStretch()
+
+        self._btn_info = QPushButton("Info")
+        self._btn_info.setFixedWidth(60)
+        self._btn_info.clicked.connect(lambda: self.info_requested.emit(self._device.serial))
+        actions.addWidget(self._btn_info)
+
+        self._btn_mirror = QPushButton("Mirror")
+        self._btn_mirror.setFixedWidth(66)
+        self._btn_mirror.clicked.connect(lambda: self.mirror_requested.emit(self._device.serial))
+        actions.addWidget(self._btn_mirror)
+
+        self._btn_connect = QPushButton("Connect")
+        self._btn_connect.setObjectName("accent")
+        self._btn_connect.setFixedWidth(80)
+        self._btn_connect.clicked.connect(self._on_connect_toggle)
+        actions.addWidget(self._btn_connect)
+
+        root.addLayout(actions)
+
+    def _make_info_label(self, title: str, value: str) -> QLabel:
+        label = QLabel(f"<span style='color:{Colors.TEXT_MUTED};font-size:10px'>{title}</span>"
+                       f"<br><span style='color:{Colors.TEXT_PRIMARY};font-size:12px'>{value}</span>")
+        label.setTextFormat(Qt.TextFormat.RichText)
+        return label
+
+    def _on_connect_toggle(self) -> None:
+        if self._device.is_connected:
+            self.disconnect_requested.emit(self._device.serial)
+        else:
+            self.connect_requested.emit(self._device.serial)
+
+    def refresh(self, device: Device) -> None:
+        """Update card contents from a new Device snapshot."""
+        self._device = device
+        info = device.info
+
+        self._status_dot.set_state(device.state)
+        self._name_label.setText(device.display_name)
+        self._serial_label.setText(device.serial)
+        self._android_label.setText(f"Android {info.android_version}")
+
+        batt = info.battery.level
+        self._battery_bar.set_level(batt, info.battery.is_charging)
+        batt_color = (
+            Colors.BATTERY_FULL if batt > 50
+            else Colors.BATTERY_MID if batt > 20
+            else Colors.BATTERY_LOW
+        )
+        self._battery_label.setText(f"<span style='color:{batt_color}'>{batt}%</span>")
+        self._battery_label.setTextFormat(Qt.TextFormat.RichText)
+
+        self._res_label.setText(
+            f"<span style='color:{Colors.TEXT_MUTED};font-size:10px'>Resolution</span>"
+            f"<br><span style='color:{Colors.TEXT_PRIMARY};font-size:12px'>{info.screen_resolution}</span>"
+        )
+        self._ip_label.setText(
+            f"<span style='color:{Colors.TEXT_MUTED};font-size:10px'>IP</span>"
+            f"<br><span style='color:{Colors.TEXT_PRIMARY};font-size:12px'>{info.network.ip_address or 'N/A'}</span>"
+        )
+        self._type_label.setText(
+            f"<span style='color:{Colors.TEXT_MUTED};font-size:10px'>Type</span>"
+            f"<br><span style='color:{Colors.TEXT_PRIMARY};font-size:12px'>{device.connection_type.value}</span>"
+        )
+
+        if device.is_connected:
+            self._btn_connect.setText("Disconnect")
+            self._btn_connect.setObjectName("danger")
+        else:
+            self._btn_connect.setText("Connect")
+            self._btn_connect.setObjectName("accent")
+
+        # Re-polish to pick up objectName style changes
+        self._btn_connect.style().unpolish(self._btn_connect)
+        self._btn_connect.style().polish(self._btn_connect)

voidremote/ui/widgets/log_view.py

@@ -0,0 +1,159 @@
+"""Live scrolling log viewer widget."""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from PySide6.QtCore import Qt, QObject, Signal, Slot
+from PySide6.QtGui import QTextCharFormat, QColor, QFont, QTextCursor
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QPlainTextEdit,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+    QComboBox,
+    QLabel,
+)
+
+from voidremote.ui.theme import Colors
+
+
+class QtLogHandler(logging.Handler, QObject):
+    """
+    Logging handler that emits Qt signals so log records can be
+    displayed safely in the GUI from any thread.
+    """
+
+    log_record = Signal(int, str)
+
+    def __init__(self) -> None:
+        logging.Handler.__init__(self)
+        QObject.__init__(self)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+            self.log_record.emit(record.levelno, msg)
+        except Exception:
+            self.handleError(record)
+
+
+class LogView(QWidget):
+    """
+    Embeddable log viewer with level filtering, search, and auto-scroll.
+    """
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        super().__init__(parent)
+        self._handler: Optional[QtLogHandler] = None
+        self._max_lines = 2000
+        self._level_filter = logging.DEBUG
+        self._build_ui()
+        self._install_handler()
+
+    def _build_ui(self) -> None:
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # ── Toolbar ─────────────────────────────────────
+        toolbar = QHBoxLayout()
+        toolbar.setContentsMargins(8, 6, 8, 6)
+        toolbar.setSpacing(8)
+
+        toolbar.addWidget(QLabel("Level:"))
+
+        self._level_combo = QComboBox()
+        self._level_combo.addItems(["DEBUG", "INFO", "WARNING", "ERROR"])
+        self._level_combo.setCurrentText("INFO")
+        self._level_combo.setFixedWidth(100)
+        self._level_combo.currentTextChanged.connect(self._on_level_changed)
+        toolbar.addWidget(self._level_combo)
+
+        toolbar.addStretch()
+
+        self._auto_scroll_btn = QPushButton("Auto-scroll: ON")
+        self._auto_scroll_btn.setCheckable(True)
+        self._auto_scroll_btn.setChecked(True)
+        self._auto_scroll_btn.setFixedWidth(120)
+        self._auto_scroll_btn.clicked.connect(self._toggle_autoscroll)
+        toolbar.addWidget(self._auto_scroll_btn)
+
+        btn_clear = QPushButton("Clear")
+        btn_clear.setFixedWidth(60)
+        btn_clear.clicked.connect(self.clear)
+        toolbar.addWidget(btn_clear)
+
+        toolbar_widget = QWidget()
+        toolbar_widget.setStyleSheet(
+            f"background: {Colors.BG_SURFACE}; border-bottom: 1px solid {Colors.BORDER};"
+        )
+        toolbar_widget.setLayout(toolbar)
+        layout.addWidget(toolbar_widget)
+
+        # ── Text area ───────────────────────────────────
+        self._text = QPlainTextEdit()
+        self._text.setObjectName("LogView")
+        self._text.setReadOnly(True)
+        self._text.setMaximumBlockCount(self._max_lines)
+        font = QFont("JetBrains Mono, Cascadia Code, Fira Code, Consolas, monospace", 12)
+        self._text.setFont(font)
+        layout.addWidget(self._text, stretch=1)
+
+        self._auto_scroll = True
+
+    def _install_handler(self) -> None:
+        handler = QtLogHandler()
+        handler.setFormatter(
+            logging.Formatter("%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+                               datefmt="%H:%M:%S")
+        )
+        handler.log_record.connect(self._append_record)
+        self._handler = handler
+        logging.getLogger().addHandler(handler)
+
+    def remove_handler(self) -> None:
+        if self._handler:
+            logging.getLogger().removeHandler(self._handler)
+
+    @Slot(int, str)
+    def _append_record(self, level: int, message: str) -> None:
+        if level < self._level_filter:
+            return
+
+        fmt = QTextCharFormat()
+        if level >= logging.CRITICAL:
+            fmt.setForeground(QColor(Colors.ERROR))
+            fmt.setFontWeight(QFont.Weight.Bold)
+        elif level >= logging.ERROR:
+            fmt.setForeground(QColor(Colors.ERROR))
+        elif level >= logging.WARNING:
+            fmt.setForeground(QColor(Colors.WARNING))
+        elif level >= logging.INFO:
+            fmt.setForeground(QColor(Colors.TEXT_PRIMARY))
+        else:
+            fmt.setForeground(QColor(Colors.TEXT_MUTED))
+
+        cursor = self._text.textCursor()
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        cursor.insertText(message + "\n", fmt)
+
+        if self._auto_scroll:
+            self._text.setTextCursor(cursor)
+            self._text.ensureCursorVisible()
+
+    def _on_level_changed(self, text: str) -> None:
+        self._level_filter = getattr(logging, text, logging.DEBUG)
+
+    def _toggle_autoscroll(self, checked: bool) -> None:
+        self._auto_scroll = checked
+        self._auto_scroll_btn.setText(f"Auto-scroll: {'ON' if checked else 'OFF'}")
+
+    def clear(self) -> None:
+        self._text.clear()
+
+    def append(self, message: str, level: int = logging.INFO) -> None:
+        """Manually append a message (also respects level filter)."""
+        self._append_record(level, message)