meccatronis commited on
Commit
bd29fb8
·
verified ·
1 Parent(s): 0b2ff04

Upload gui/scan_panel.py with huggingface_hub

Browse files
Files changed (1) hide show
  1. gui/scan_panel.py +482 -0
gui/scan_panel.py ADDED
@@ -0,0 +1,482 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Scan Panel Module
3
+ ================
4
+
5
+ Panel for scanning devices and displaying scan results.
6
+ """
7
+
8
+ import os
9
+ import logging
10
+ from PyQt6.QtWidgets import ( # type: ignore
11
+ QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton,
12
+ QComboBox, QGroupBox, QGridLayout, QProgressBar,
13
+ QTableWidget, QTableWidgetItem, QHeaderView, QCheckBox,
14
+ QSplitter, QFrame, QMessageBox
15
+ )
16
+ from PyQt6.QtCore import Qt, pyqtSignal, QThread, QTimer # type: ignore
17
+ from PyQt6.QtGui import QFont # type: ignore
18
+
19
+ from .styles import get_icon
20
+ from core.device_scanner import DeviceScanner, FileType, FileStatus
21
+
22
+ logger = logging.getLogger(__name__)
23
+
24
+
25
+ class ScanThread(QThread):
26
+ """Thread for performing device scan."""
27
+
28
+ progress_updated = pyqtSignal(int, int, str, float)
29
+ scan_completed = pyqtSignal(object)
30
+ scan_failed = pyqtSignal(str)
31
+
32
+ def __init__(self, scanner: DeviceScanner, scan_type: str):
33
+ super().__init__()
34
+ self.scanner = scanner
35
+ self.scan_type = scan_type
36
+ self._cancelled = False
37
+
38
+ def run(self):
39
+ """Run scan in a separate thread."""
40
+ try:
41
+ # Set progress callback
42
+ self.scanner.set_progress_callback(self._on_progress)
43
+
44
+ # Perform scan based on type
45
+ if self.scan_type == "quick":
46
+ result = self.scanner.quick_scan()
47
+ elif self.scan_type == "normal":
48
+ result = self.scanner.normal_scan()
49
+ elif self.scan_type == "deep":
50
+ result = self.scanner.deep_scan()
51
+ else:
52
+ result = self.scanner.normal_scan()
53
+
54
+ if not self._cancelled:
55
+ self.scan_completed.emit(result)
56
+
57
+ except Exception as e:
58
+ logger.error(f"Scan failed: {e}")
59
+ self.scan_failed.emit(str(e))
60
+
61
+ def cancel(self):
62
+ """Cancel the scan."""
63
+ self._cancelled = True
64
+ self.scanner.cancel_scan()
65
+
66
+ def _on_progress(self, current: int, total: int, message: str, progress: float):
67
+ """Handle progress updates."""
68
+ self.progress_updated.emit(current, total, message, progress)
69
+
70
+
71
+ class ScanPanel(QWidget):
72
+ """Panel for scanning devices and displaying results."""
73
+
74
+ # Signals
75
+ files_selected = pyqtSignal(list) # Emits list of selected files
76
+
77
+ def __init__(self, adb_manager=None, parent=None):
78
+ super().__init__(parent)
79
+ self.adb_manager = adb_manager
80
+ self.scanner = None
81
+ self.scan_thread = None
82
+ self.current_result = None
83
+ self.selected_files = []
84
+
85
+ self._setup_ui()
86
+ self._setup_refresh_timer()
87
+
88
+ def _setup_ui(self):
89
+ """Setup the user interface."""
90
+ layout = QVBoxLayout(self)
91
+ layout.setSpacing(15)
92
+
93
+ # Title
94
+ title_layout = QHBoxLayout()
95
+ title_icon = QLabel(get_icon('scan'))
96
+ title_icon.setFont(QFont('Segoe UI Emoji', 24))
97
+ title_label = QLabel("Scan do Dispositivo")
98
+ title_label.setObjectName("title")
99
+ title_layout.addWidget(title_icon)
100
+ title_layout.addWidget(title_label)
101
+ title_layout.addStretch()
102
+ layout.addLayout(title_layout)
103
+
104
+ # Scan Options Group
105
+ options_group = QGroupBox("Opções de Scan")
106
+ options_layout = QGridLayout(options_group)
107
+
108
+ # Scan type
109
+ options_layout.addWidget(QLabel("Tipo de Scan:"), 0, 0)
110
+ self.scan_type_combo = QComboBox()
111
+ self.scan_type_combo.addItems([
112
+ "Rápido (apenas locais comuns)",
113
+ "Normal (todo o armazenamento)",
114
+ "Profundo (inclui arquivos deletados - requer root)"
115
+ ])
116
+ options_layout.addWidget(self.scan_type_combo, 0, 1, 1, 2)
117
+
118
+ # File type filters
119
+ options_layout.addWidget(QLabel("Filtrar por Tipo:"), 1, 0)
120
+
121
+ filter_layout = QHBoxLayout()
122
+ self.filter_images = QCheckBox("Imagens")
123
+ self.filter_images.setChecked(True)
124
+ filter_layout.addWidget(self.filter_images)
125
+
126
+ self.filter_videos = QCheckBox("Vídeos")
127
+ self.filter_videos.setChecked(True)
128
+ filter_layout.addWidget(self.filter_videos)
129
+
130
+ self.filter_audio = QCheckBox("Áudio")
131
+ self.filter_audio.setChecked(True)
132
+ filter_layout.addWidget(self.filter_audio)
133
+
134
+ self.filter_documents = QCheckBox("Documentos")
135
+ self.filter_documents.setChecked(True)
136
+ filter_layout.addWidget(self.filter_documents)
137
+
138
+ self.filter_databases = QCheckBox("Bancos de Dados")
139
+ self.filter_databases.setChecked(True)
140
+ filter_layout.addWidget(self.filter_databases)
141
+
142
+ options_layout.addLayout(filter_layout, 1, 1, 1, 4)
143
+
144
+ # Scan buttons
145
+ btn_layout = QHBoxLayout()
146
+
147
+ self.scan_btn = QPushButton(f"{get_icon('start')} Iniciar Scan")
148
+ self.scan_btn.setObjectName("primary")
149
+ self.scan_btn.clicked.connect(self._start_scan)
150
+ btn_layout.addWidget(self.scan_btn)
151
+
152
+ self.cancel_btn = QPushButton(f"{get_icon('stop')} Cancelar")
153
+ self.cancel_btn.setObjectName("danger")
154
+ self.cancel_btn.setEnabled(False)
155
+ self.cancel_btn.clicked.connect(self._cancel_scan)
156
+ btn_layout.addWidget(self.cancel_btn)
157
+
158
+ btn_layout.addStretch()
159
+ options_layout.addLayout(btn_layout, 2, 0, 1, 4)
160
+
161
+ layout.addWidget(options_group)
162
+
163
+ # Progress bar
164
+ self.progress_bar = QProgressBar()
165
+ self.progress_bar.setVisible(False)
166
+ layout.addWidget(self.progress_bar)
167
+
168
+ # Progress label
169
+ self.progress_label = QLabel("")
170
+ self.progress_label.setVisible(False)
171
+ layout.addWidget(self.progress_label)
172
+
173
+ # Results area with splitter
174
+ results_splitter = QSplitter(Qt.Orientation.Vertical)
175
+
176
+ # Summary frame
177
+ summary_frame = QFrame()
178
+ summary_frame.setFrameStyle(QFrame.Shape.StyledPanel)
179
+ summary_layout = QGridLayout(summary_frame)
180
+
181
+ # Summary labels
182
+ self.summary_labels = {}
183
+ summary_fields = [
184
+ ('total_files', 'Total de Arquivos:'),
185
+ ('total_size', 'Tamanho Total:'),
186
+ ('recoverable_files', 'Arquivos Recuperáveis:'),
187
+ ('recoverable_size', 'Tamanho Recuperável:'),
188
+ ('scan_time', 'Tempo de Scan:'),
189
+ ]
190
+
191
+ for i, (key, label) in enumerate(summary_fields):
192
+ row = i // 2
193
+ col = (i % 2) * 2
194
+
195
+ label_widget = QLabel(label)
196
+ label_widget.setStyleSheet("font-weight: bold;")
197
+ summary_layout.addWidget(label_widget, row, col)
198
+
199
+ value_widget = QLabel("-")
200
+ self.summary_labels[key] = value_widget
201
+ summary_layout.addWidget(value_widget, row, col + 1)
202
+
203
+ results_splitter.addWidget(summary_frame)
204
+
205
+ # Results table
206
+ self.results_table = QTableWidget()
207
+ self.results_table.setColumnCount(7)
208
+ self.results_table.setHorizontalHeaderLabels([
209
+ "Nome", "Tipo", "Tamanho", "Status", "Caminho", "Modificado", "Recuperável"
210
+ ])
211
+ self.results_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
212
+ self.results_table.setSelectionMode(QTableWidget.SelectionMode.ExtendedSelection)
213
+ self.results_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
214
+ self.results_table.horizontalHeader().setStretchLastSection(True)
215
+ self.results_table.itemSelectionChanged.connect(self._on_selection_changed)
216
+
217
+ results_splitter.addWidget(self.results_table)
218
+
219
+ # Set splitter proportions
220
+ results_splitter.setStretchFactor(0, 0)
221
+ results_splitter.setStretchFactor(1, 1)
222
+ results_splitter.setSizes([150, 500])
223
+
224
+ layout.addWidget(results_splitter)
225
+
226
+ # Action buttons
227
+ action_layout = QHBoxLayout()
228
+
229
+ self.select_all_btn = QPushButton("Selecionar Todos")
230
+ self.select_all_btn.clicked.connect(self._select_all)
231
+ action_layout.addWidget(self.select_all_btn)
232
+
233
+ self.deselect_all_btn = QPushButton("Deselecionar Todos")
234
+ self.deselect_all_btn.clicked.connect(self._deselect_all)
235
+ action_layout.addWidget(self.deselect_all_btn)
236
+
237
+ self.recover_selected_btn = QPushButton(f"{get_icon('recover')} Recuperar Selecionados")
238
+ self.recover_selected_btn.setObjectName("primary")
239
+ self.recover_selected_btn.setEnabled(False)
240
+ self.recover_selected_btn.clicked.connect(self._recover_selected)
241
+ action_layout.addWidget(self.recover_selected_btn)
242
+
243
+ action_layout.addStretch()
244
+ layout.addLayout(action_layout)
245
+
246
+ def _setup_refresh_timer(self):
247
+ """Setup timer for auto-refresh."""
248
+ self.refresh_timer = QTimer(self)
249
+ self.refresh_timer.timeout.connect(self.refresh_devices)
250
+ self.refresh_timer.start(5000) # Refresh every 5 seconds
251
+
252
+ def set_adb_manager(self, adb_manager):
253
+ """Set ADB manager instance."""
254
+ self.adb_manager = adb_manager
255
+ if adb_manager:
256
+ self.scanner = DeviceScanner(adb_manager)
257
+ self.refresh_devices()
258
+
259
+ def refresh_devices(self):
260
+ """Refresh the list of connected devices."""
261
+ if not self.adb_manager:
262
+ return
263
+
264
+ current_selection = self.scan_type_combo.currentData()
265
+ self.scan_type_combo.clear()
266
+
267
+ try:
268
+ devices = self.adb_manager.list_devices()
269
+
270
+ for device in devices:
271
+ display_text = f"{device.model or device.serial} ({device.state.value})"
272
+ self.scan_type_combo.addItem(display_text, device.serial)
273
+
274
+ if not devices:
275
+ self.scan_type_combo.addItem("Nenhum dispositivo encontrado", None)
276
+ self._update_status("warning", "Nenhum dispositivo encontrado")
277
+ else:
278
+ self._update_status("info", f"{len(devices)} dispositivo(s) encontrado(s)")
279
+
280
+ except Exception as e:
281
+ self._update_status("error", f"Erro ao listar dispositivos: {str(e)}")
282
+
283
+ def _on_device_selected(self, index):
284
+ """Handle device selection change."""
285
+ serial = self.scan_type_combo.currentData()
286
+ self.scan_btn.setEnabled(serial is not None)
287
+
288
+ def _start_scan(self):
289
+ """Start the scan process."""
290
+ if not self.adb_manager:
291
+ QMessageBox.warning(self, "Aviso", "Nenhum gerenciador ADB disponível")
292
+ return
293
+
294
+ if not self.scanner:
295
+ self.scanner = DeviceScanner(self.adb_manager)
296
+
297
+ # Get scan type
298
+ scan_type_index = self.scan_type_combo.currentIndex()
299
+ scan_types = ["quick", "normal", "deep"]
300
+ scan_type = scan_types[scan_type_index]
301
+
302
+ # Check if device is connected
303
+ device_info = self.adb_manager.get_device_info()
304
+ if not device_info:
305
+ QMessageBox.warning(self, "Aviso", "Nenhum dispositivo conectado")
306
+ return
307
+
308
+ # Check root for deep scan
309
+ if scan_type == "deep" and not device_info.is_rooted:
310
+ reply = QMessageBox.question(
311
+ self,
312
+ "Aviso",
313
+ "Scan profundo requer acesso root. O dispositivo não está com root.\n"
314
+ "Deseja continuar com scan normal?",
315
+ QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
316
+ )
317
+ if reply == QMessageBox.StandardButton.Yes:
318
+ scan_type = "normal"
319
+ else:
320
+ return
321
+
322
+ # Clear previous results
323
+ self.results_table.setRowCount(0)
324
+ self._clear_summary()
325
+
326
+ # Show progress
327
+ self.progress_bar.setVisible(True)
328
+ self.progress_bar.setValue(0)
329
+ self.progress_label.setVisible(True)
330
+ self.progress_label.setText("Iniciando scan...")
331
+
332
+ # Disable scan button
333
+ self.scan_btn.setEnabled(False)
334
+ self.cancel_btn.setEnabled(True)
335
+
336
+ # Start scan thread
337
+ self.scan_thread = ScanThread(self.scanner, scan_type)
338
+ self.scan_thread.progress_updated.connect(self._on_scan_progress)
339
+ self.scan_thread.scan_completed.connect(self._on_scan_completed)
340
+ self.scan_thread.scan_failed.connect(self._on_scan_failed)
341
+ self.scan_thread.start()
342
+
343
+ def _cancel_scan(self):
344
+ """Cancel the current scan."""
345
+ if self.scan_thread and self.scan_thread.isRunning():
346
+ self.scan_thread.cancel()
347
+ self.progress_label.setText("Cancelando scan...")
348
+
349
+ def _on_scan_progress(self, current: int, total: int, message: str, progress: float):
350
+ """Handle scan progress updates."""
351
+ self.progress_bar.setValue(int(progress))
352
+ self.progress_label.setText(f"{message} ({current}/{total})")
353
+
354
+ def _on_scan_completed(self, result):
355
+ """Handle scan completion."""
356
+ # Hide progress
357
+ self.progress_bar.setVisible(False)
358
+ self.progress_label.setVisible(False)
359
+
360
+ # Enable scan button
361
+ self.scan_btn.setEnabled(True)
362
+ self.cancel_btn.setEnabled(False)
363
+
364
+ # Update summary
365
+ self._update_summary(result)
366
+
367
+ # Populate results table
368
+ self._populate_results(result)
369
+
370
+ logger.info(f"Scan completed: {result.total_files} files found")
371
+
372
+ def _on_scan_failed(self, error: str):
373
+ """Handle scan failure."""
374
+ self.progress_bar.setVisible(False)
375
+ self.progress_label.setVisible(False)
376
+ self.scan_btn.setEnabled(True)
377
+ self.cancel_btn.setEnabled(False)
378
+
379
+ QMessageBox.critical(self, "Erro", f"Scan falhou: {error}")
380
+ logger.error(f"Scan failed: {error}")
381
+
382
+ def _update_summary(self, result):
383
+ """Update summary labels."""
384
+ self.summary_labels['total_files'].setText(str(result.total_files))
385
+ self.summary_labels['total_size'].setText(self._format_size(result.total_size))
386
+ self.summary_labels['recoverable_files'].setText(str(result.recoverable_files))
387
+ self.summary_labels['recoverable_size'].setText(self._format_size(result.recoverable_size))
388
+ self.summary_labels['scan_time'].setText(f"{result.scan_time:.2f}s")
389
+
390
+ def _clear_summary(self):
391
+ """Clear summary labels."""
392
+ for label in self.summary_labels.values():
393
+ label.setText("-")
394
+
395
+ def _populate_results(self, result):
396
+ """Populate results table with scan results."""
397
+ self.results_table.setRowCount(0)
398
+
399
+ for file in result.files:
400
+ row = self.results_table.rowCount()
401
+ self.results_table.insertRow(row)
402
+
403
+ # Name
404
+ self.results_table.setItem(row, 0, QTableWidgetItem(file.name))
405
+
406
+ # Type
407
+ type_item = QTableWidgetItem(file.file_type.value)
408
+ type_item.setData(Qt.ItemDataRole.UserRole, file.file_type)
409
+ self.results_table.setItem(row, 1, type_item)
410
+
411
+ # Size
412
+ size_item = QTableWidgetItem(self._format_size(file.size))
413
+ size_item.setData(Qt.ItemDataRole.UserRole, file.size)
414
+ self.results_table.setItem(row, 2, size_item)
415
+
416
+ # Status
417
+ status_item = QTableWidgetItem(file.status.value)
418
+ status_item.setData(Qt.ItemDataRole.UserRole, file.status)
419
+ self.results_table.setItem(row, 3, status_item)
420
+
421
+ # Path
422
+ self.results_table.setItem(row, 4, QTableWidgetItem(file.path))
423
+
424
+ # Modified
425
+ modified = file.modified_time.strftime('%Y-%m-%d %H:%M') if file.modified_time else "-"
426
+ self.results_table.setItem(row, 5, QTableWidgetItem(modified))
427
+
428
+ # Recoverable
429
+ recoverable = "Sim" if file.is_recoverable else "Não"
430
+ recoverable_item = QTableWidgetItem(recoverable)
431
+ recoverable_item.setData(Qt.ItemDataRole.UserRole, file.is_recoverable)
432
+ self.results_table.setItem(row, 6, recoverable_item)
433
+
434
+ # Store file object in row
435
+ self.results_table.item(row, 0).setData(Qt.ItemDataRole.UserRole + 1, file)
436
+
437
+ def _on_selection_changed(self):
438
+ """Handle selection changes in results table."""
439
+ selected_rows = self.results_table.selectionModel().selectedRows()
440
+ self.selected_files = []
441
+
442
+ for index in selected_rows:
443
+ row = index.row()
444
+ file_item = self.results_table.item(row, 0)
445
+ file_obj = file_item.data(Qt.ItemDataRole.UserRole + 1)
446
+ if file_obj:
447
+ self.selected_files.append(file_obj)
448
+
449
+ self.recover_selected_btn.setEnabled(len(self.selected_files) > 0)
450
+ self.files_selected.emit(self.selected_files)
451
+
452
+ def _select_all(self):
453
+ """Select all files in results table."""
454
+ self.results_table.selectAll()
455
+
456
+ def _deselect_all(self):
457
+ """Deselect all files."""
458
+ self.results_table.clearSelection()
459
+
460
+ def _recover_selected(self):
461
+ """Recover selected files."""
462
+ if not self.selected_files:
463
+ return
464
+
465
+ # Emit signal with selected files
466
+ self.files_selected.emit(self.selected_files)
467
+
468
+ def _format_size(self, size: int) -> str:
469
+ """Format file size in human-readable format."""
470
+ for unit in ['B', 'KB', 'MB', 'GB']:
471
+ if size < 1024:
472
+ return f"{size:.1f} {unit}"
473
+ size /= 1024
474
+ return f"{size:.1f} TB"
475
+
476
+ def get_selected_files(self):
477
+ """Get list of selected files."""
478
+ return self.selected_files
479
+
480
+ def get_scan_result(self):
481
+ """Get current scan result."""
482
+ return self.current_result