Upload gui/main_window.py with huggingface_hub

gui/main_window.py

@@ -0,0 +1,474 @@
+"""
+Main Window Module
+==================
+
+Main application window for Android Data Recovery.
+"""
+
+import os
+import logging
+from PyQt6.QtWidgets import (  # type: ignore
+    QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QTabWidget,
+    QStatusBar, QMenuBar, QMenu, QMessageBox, QFileDialog,
+    QSplitter, QFrame, QLabel
+)
+from PyQt6.QtCore import Qt, pyqtSignal, QSettings  # type: ignore
+from PyQt6.QtGui import QAction, QIcon, QFont  # type: ignore
+
+from .styles import DARK_THEME, LIGHT_THEME, get_icon
+from .device_panel import DevicePanel
+from .scan_panel import ScanPanel
+from .recovery_panel import RecoveryPanel
+from .preview_panel import PreviewPanel
+
+logger = logging.getLogger(__name__)
+
+
+class MainWindow(QMainWindow):
+    """Main application window."""
+    
+    def __init__(self, adb_manager=None, parent=None):
+        super().__init__(parent)
+        self.adb_manager = adb_manager
+        self.current_theme = "dark"
+        self.settings = QSettings("AndroidDataRecovery", "MainWindow")
+        
+        # Initialize UI
+        self._setup_ui()
+        self._setup_menu_bar()
+        self._setup_status_bar()
+        self._apply_theme()
+        self._restore_settings()
+        
+        logger.info("Main window initialized")
+    
+    def _setup_ui(self):
+        """Setup the user interface."""
+        self.setWindowTitle("Android Data Recovery")
+        self.setMinimumSize(1200, 800)
+        
+        # Central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QVBoxLayout(central_widget)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+        
+        # Header
+        header = self._create_header()
+        main_layout.addWidget(header)
+        
+        # Main content area with splitter
+        splitter = QSplitter(Qt.Orientation.Horizontal)
+        
+        # Left panel - Device connection
+        self.device_panel = DevicePanel(self.adb_manager)
+        self.device_panel.setMaximumWidth(400)
+        self.device_panel.setMinimumWidth(300)
+        splitter.addWidget(self.device_panel)
+        
+        # Right panel - Tab widget for different functions
+        self.tab_widget = QTabWidget()
+        self.tab_widget.setTabPosition(QTabWidget.TabPosition.North)
+        
+        # Create panels
+        self.scan_panel = ScanPanel(self.adb_manager)
+        self.recovery_panel = RecoveryPanel(self.adb_manager)
+        self.preview_panel = PreviewPanel()
+        
+        # Add panels to tab widget
+        self.tab_widget.addTab(self.scan_panel, f"{get_icon('scan')} Scan")
+        self.tab_widget.addTab(self.recovery_panel, f"{get_icon('recover')} Recuperação")
+        self.tab_widget.addTab(self.preview_panel, f"{get_icon('file')} Visualização")
+        
+        splitter.addWidget(self.tab_widget)
+        
+        # Set splitter proportions
+        splitter.setStretchFactor(0, 0)
+        splitter.setStretchFactor(1, 1)
+        splitter.setSizes([350, 850])
+        
+        main_layout.addWidget(splitter)
+        
+        # Connect device panel signals
+        self.device_panel.device_connected.connect(self._on_device_connected)
+        self.device_panel.device_disconnected.connect(self._on_device_disconnected)
+        
+        # Connect scan panel signals
+        self.scan_panel.files_selected.connect(self._on_files_selected)
+        
+        # Connect recovery panel signals
+        self.recovery_panel.recovery_finished.connect(self._on_recovery_finished)
+    
+    def _create_header(self) -> QFrame:
+        """Create the application header."""
+        header = QFrame()
+        header.setObjectName("header")
+        header.setStyleSheet("""
+            QFrame#header {
+                background-color: #2d2d2d;
+                border-bottom: 2px solid #424242;
+                padding: 15px;
+            }
+        """)
+        
+        layout = QHBoxLayout(header)
+        layout.setContentsMargins(20, 10, 20, 10)
+        
+        # App icon and title
+        icon_label = QLabel(get_icon('android'))
+        icon_label.setFont(QFont('Segoe UI Emoji', 32))
+        layout.addWidget(icon_label)
+        
+        title_layout = QVBoxLayout()
+        title_layout.setSpacing(5)
+        
+        title_label = QLabel("Android Data Recovery")
+        title_label.setObjectName("appTitle")
+        title_label.setStyleSheet("""
+            QLabel#appTitle {
+                font-size: 24px;
+                font-weight: bold;
+                color: #4fc3f7;
+            }
+        """)
+        title_layout.addWidget(title_label)
+        
+        subtitle_label = QLabel("Recuperação de dados para dispositivos Android")
+        subtitle_label.setObjectName("appSubtitle")
+        subtitle_label.setStyleSheet("""
+            QLabel#appSubtitle {
+                font-size: 12px;
+                color: #b0b0b0;
+            }
+        """)
+        title_layout.addWidget(subtitle_label)
+        
+        layout.addLayout(title_layout)
+        layout.addStretch()
+        
+        # Version info
+        version_label = QLabel("v1.0.0")
+        version_label.setStyleSheet("color: #757575; font-size: 11px;")
+        layout.addWidget(version_label)
+        
+        return header
+    
+    def _setup_menu_bar(self):
+        """Setup the menu bar."""
+        menubar = self.menuBar()
+        
+        # File menu
+        file_menu = menubar.addMenu("&Arquivo")
+        
+        # New scan action
+        new_scan_action = QAction(f"{get_icon('scan')} Novo Scan", self)
+        new_scan_action.setShortcut("Ctrl+N")
+        new_scan_action.triggered.connect(self._new_scan)
+        file_menu.addAction(new_scan_action)
+        
+        file_menu.addSeparator()
+        
+        # Open recovered data
+        open_action = QAction(f"{get_icon('folder')} Abrir Dados Recuperados", self)
+        open_action.setShortcut("Ctrl+O")
+        open_action.triggered.connect(self._open_recovered_data)
+        file_menu.addAction(open_action)
+        
+        file_menu.addSeparator()
+        
+        # Export action
+        export_action = QAction(f"{get_icon('export')} Exportar Relatório", self)
+        export_action.setShortcut("Ctrl+E")
+        export_action.triggered.connect(self._export_report)
+        file_menu.addAction(export_action)
+        
+        file_menu.addSeparator()
+        
+        # Exit action
+        exit_action = QAction(f"{get_icon('exit')} Sair", self)
+        exit_action.setShortcut("Ctrl+Q")
+        exit_action.triggered.connect(self.close)
+        file_menu.addAction(exit_action)
+        
+        # View menu
+        view_menu = menubar.addMenu("&Visualizar")
+        
+        # Theme submenu
+        theme_menu = view_menu.addMenu("Tema")
+        
+        dark_theme_action = QAction("Escuro", self)
+        dark_theme_action.setCheckable(True)
+        dark_theme_action.setChecked(True)
+        dark_theme_action.triggered.connect(lambda: self._set_theme("dark"))
+        theme_menu.addAction(dark_theme_action)
+        
+        light_theme_action = QAction("Claro", self)
+        light_theme_action.setCheckable(True)
+        light_theme_action.triggered.connect(lambda: self._set_theme("light"))
+        theme_menu.addAction(light_theme_action)
+        
+        view_menu.addSeparator()
+        
+        # Refresh action
+        refresh_action = QAction(f"{get_icon('refresh')} Atualizar", self)
+        refresh_action.setShortcut("F5")
+        refresh_action.triggered.connect(self._refresh)
+        view_menu.addAction(refresh_action)
+        
+        # Tools menu
+        tools_menu = menubar.addMenu("&Ferramentas")
+        
+        # ADB tools
+        adb_menu = tools_menu.addMenu("ADB")
+        
+        start_server_action = QAction("Iniciar Servidor ADB", self)
+        start_server_action.triggered.connect(self._start_adb_server)
+        adb_menu.addAction(start_server_action)
+        
+        stop_server_action = QAction("Parar Servidor ADB", self)
+        stop_server_action.triggered.connect(self._stop_adb_server)
+        adb_menu.addAction(stop_server_action)
+        
+        restart_server_action = QAction("Reiniciar Servidor ADB", self)
+        restart_server_action.triggered.connect(self._restart_adb_server)
+        adb_menu.addAction(restart_server_action)
+        
+        tools_menu.addSeparator()
+        
+        # Settings action
+        settings_action = QAction(f"{get_icon('settings')} Configurações", self)
+        settings_action.setShortcut("Ctrl+,")
+        settings_action.triggered.connect(self._show_settings)
+        tools_menu.addAction(settings_action)
+        
+        # Help menu
+        help_menu = menubar.addMenu("&Ajuda")
+        
+        # Documentation
+        docs_action = QAction(f"{get_icon('help')} Documentação", self)
+        docs_action.setShortcut("F1")
+        docs_action.triggered.connect(self._show_documentation)
+        help_menu.addAction(docs_action)
+        
+        help_menu.addSeparator()
+        
+        # About
+        about_action = QAction(f"{get_icon('info')} Sobre", self)
+        about_action.triggered.connect(self._show_about)
+        help_menu.addAction(about_action)
+    
+    def _setup_status_bar(self):
+        """Setup the status bar."""
+        self.status_bar = QStatusBar()
+        self.setStatusBar(self.status_bar)
+        
+        # Status message
+        self.status_label = QLabel("Pronto")
+        self.status_bar.addWidget(self.status_label)
+        
+        # Device status
+        self.device_status_label = QLabel("Nenhum dispositivo conectado")
+        self.status_bar.addPermanentWidget(self.device_status_label)
+    
+    def _apply_theme(self):
+        """Apply the current theme."""
+        if self.current_theme == "dark":
+            self.setStyleSheet(DARK_THEME)
+        else:
+            self.setStyleSheet(LIGHT_THEME)
+    
+    def _set_theme(self, theme: str):
+        """Set the application theme."""
+        self.current_theme = theme
+        self._apply_theme()
+        self.settings.setValue("theme", theme)
+        self.status_label.setText(f"Tema alterado para {theme}")
+    
+    def _restore_settings(self):
+        """Restore window settings."""
+        # Restore theme
+        theme = self.settings.value("theme", "dark")
+        self._set_theme(theme)
+        
+        # Restore window geometry
+        geometry = self.settings.value("geometry")
+        if geometry:
+            self.restoreGeometry(geometry)
+        
+        # Restore window state
+        state = self.settings.value("windowState")
+        if state:
+            self.restoreState(state)
+    
+    def closeEvent(self, event):
+        """Handle window close event."""
+        # Save settings
+        self.settings.setValue("geometry", self.saveGeometry())
+        self.settings.setValue("windowState", self.saveState())
+        
+        # Stop ADB server if running
+        if self.adb_manager:
+            self.adb_manager.stop_server()
+        
+        logger.info("Application closing")
+        event.accept()
+    
+    def _on_device_connected(self, serial: str):
+        """Handle device connection."""
+        self.device_status_label.setText(f"Conectado: {serial}")
+        self.status_label.setText(f"Dispositivo conectado: {serial}")
+        logger.info(f"Device connected: {serial}")
+    
+    def _on_device_disconnected(self):
+        """Handle device disconnection."""
+        self.device_status_label.setText("Nenhum dispositivo conectado")
+        self.status_label.setText("Dispositivo desconectado")
+        logger.info("Device disconnected")
+    
+    def _on_files_selected(self, files):
+        """Handle files selected from scan panel."""
+        # Switch to recovery tab
+        self.tab_widget.setCurrentIndex(1)
+        
+        # Set files to recover
+        self.recovery_panel.set_files_to_recover(files)
+        
+        self.status_label.setText(f"{len(files)} arquivo(s) selecionado(s) para recuperação")
+        logger.info(f"Files selected for recovery: {len(files)}")
+    
+    def _on_recovery_finished(self, result):
+        """Handle recovery completion."""
+        self.status_label.setText(
+            f"Recuperação concluída: {result.recovered_files}/{result.total_files} arquivos"
+        )
+        logger.info(f"Recovery finished: {result.recovered_files}/{result.total_files} files")
+    
+    def _new_scan(self):
+        """Start a new scan."""
+        if not self.device_panel.is_connected():
+            QMessageBox.warning(
+                self,
+                "Aviso",
+                "Por favor, conecte um dispositivo primeiro."
+            )
+            return
+        
+        # Switch to scan tab
+        self.tab_widget.setCurrentIndex(0)
+        
+        # Trigger scan on scan panel
+        self.scan_panel._start_scan()
+    
+    def _open_recovered_data(self):
+        """Open recovered data directory."""
+        default_dir = "./recovered_data"
+        if os.path.exists(default_dir):
+            os.startfile(default_dir) if os.name == 'nt' else os.system(f'xdg-open "{default_dir}"')
+        else:
+            QMessageBox.information(
+                self,
+                "Info",
+                "Nenhum dado recuperado encontrado."
+            )
+    
+    def _export_report(self):
+        """Export recovery report."""
+        # TODO: Implement report export
+        QMessageBox.information(
+            self,
+            "Info",
+            "Funcionalidade de exportação será implementada."
+        )
+    
+    def _refresh(self):
+        """Refresh the application."""
+        self.device_panel.refresh_devices()
+        self.status_label.setText("Atualizado")
+    
+    def _start_adb_server(self):
+        """Start ADB server."""
+        if self.adb_manager and self.adb_manager.start_server():
+            self.status_label.setText("Servidor ADB iniciado")
+            QMessageBox.information(self, "Sucesso", "Servidor ADB iniciado com sucesso")
+        else:
+            QMessageBox.warning(self, "Erro", "Falha ao iniciar servidor ADB")
+    
+    def _stop_adb_server(self):
+        """Stop ADB server."""
+        if self.adb_manager and self.adb_manager.stop_server():
+            self.status_label.setText("Servidor ADB parado")
+            QMessageBox.information(self, "Sucesso", "Servidor ADB parado com sucesso")
+        else:
+            QMessageBox.warning(self, "Erro", "Falha ao parar servidor ADB")
+    
+    def _restart_adb_server(self):
+        """Restart ADB server."""
+        if self.adb_manager and self.adb_manager.restart_server():
+            self.status_label.setText("Servidor ADB reiniciado")
+            QMessageBox.information(self, "Sucesso", "Servidor ADB reiniciado com sucesso")
+        else:
+            QMessageBox.warning(self, "Erro", "Falha ao reiniciar servidor ADB")
+    
+    def _show_settings(self):
+        """Show settings dialog."""
+        # TODO: Implement settings dialog
+        QMessageBox.information(
+            self,
+            "Info",
+            "Configurações serão implementadas em uma janela dedicada."
+        )
+    
+    def _show_documentation(self):
+        """Show documentation."""
+        # TODO: Implement documentation viewer
+        QMessageBox.information(
+            self,
+            "Documentação",
+            "Android Data Recovery v1.0.0\n\n"
+            "Este software permite recuperar dados de dispositivos Android usando ADB.\n\n"
+            "Funcionalidades:\n"
+            "- Scan de arquivos existentes e deletados\n"
+            "- Recuperação de contatos, mensagens e chamadas\n"
+            "- Recuperação de mídia (fotos, vídeos, áudio)\n"
+            "- Recuperação de dados do WhatsApp\n\n"
+            "Requisitos:\n"
+            "- ADB instalado no sistema\n"
+            "- Depuração USB ativada no dispositivo\n"
+            "- Root para acesso completo aos dados"
+        )
+    
+    def _show_about(self):
+        """Show about dialog."""
+        QMessageBox.about(
+            self,
+            "Sobre Android Data Recovery",
+            "<h3>Android Data Recovery</h3>"
+            "<p>Versão 1.0.0</p>"
+            "<p>Software de recuperação de dados para dispositivos Android.</p>"
+            "<p><b>Recursos:</b></p>"
+            "<ul>"
+            "<li>Scan de arquivos existentes e deletados</li>"
+            "<li>Recuperação de contatos, mensagens e chamadas</li>"
+            "<li>Recuperação de mídia (fotos, vídeos, áudio)</li>"
+            "<li>Recuperação de dados do WhatsApp</li>"
+            "</ul>"
+            "<p><b>Desenvolvido com:</b></p>"
+            "<ul>"
+            "<li>Python 3.8+</li>"
+            "<li>PyQt6</li>"
+            "<li>ADB (Android Debug Bridge)</li>"
+            "</ul>"
+        )
+    
+    def add_tab(self, widget, title: str):
+        """Add a tab to the main tab widget."""
+        self.tab_widget.addTab(widget, title)
+    
+    def get_current_tab(self):
+        """Get the currently active tab widget."""
+        return self.tab_widget.currentWidget()
+    
+    def set_status_message(self, message: str):
+        """Set the status bar message."""
+        self.status_label.setText(message)