mirror of
https://github.com/smittix/intercept.git
synced 2026-07-25 17:28:11 -07:00
Overhaul Bluetooth scanning with DBus-based BlueZ integration
Major changes: - Add utils/bluetooth/ package with DBus scanner, fallback scanners (bleak, hcitool, bluetoothctl), device aggregation, and heuristics - New unified API at /api/bluetooth/ with REST endpoints and SSE streaming - Device observation aggregation with RSSI statistics and range bands - Behavioral heuristics: new, persistent, beacon-like, strong+stable - Frontend components: DeviceCard, MessageCard, RSSISparkline - TSCM integration via get_tscm_bluetooth_snapshot() helper - Unit tests for aggregator, heuristics, and API endpoints Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Smittix
@@ -0,0 +1,659 @@
|
||||
"""
|
||||
Bluetooth API v2 - Unified scanning with DBus/BlueZ and fallbacks.
|
||||
|
||||
Provides REST endpoints and SSE streaming for Bluetooth device discovery,
|
||||
aggregation, and heuristics.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import csv
|
||||
import io
|
||||
import json
|
||||
import logging
|
||||
from datetime import datetime
|
||||
from typing import Generator
|
||||
|
||||
from flask import Blueprint, Response, jsonify, request, session
|
||||
|
||||
from utils.bluetooth import (
|
||||
BluetoothScanner,
|
||||
BTDeviceAggregate,
|
||||
get_bluetooth_scanner,
|
||||
check_capabilities,
|
||||
RANGE_UNKNOWN,
|
||||
)
|
||||
from utils.database import get_db
|
||||
from utils.sse import format_sse
|
||||
|
||||
logger = logging.getLogger('intercept.bluetooth_v2')
|
||||
|
||||
# Blueprint
|
||||
bluetooth_v2_bp = Blueprint('bluetooth_v2', __name__, url_prefix='/api/bluetooth')
|
||||
|
||||
# =============================================================================
|
||||
# DATABASE FUNCTIONS
|
||||
# =============================================================================
|
||||
|
||||
|
||||
def init_bt_tables() -> None:
|
||||
"""Initialize Bluetooth-specific database tables."""
|
||||
with get_db() as conn:
|
||||
# Bluetooth baselines
|
||||
conn.execute('''
|
||||
CREATE TABLE IF NOT EXISTS bt_baselines (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
name TEXT NOT NULL,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
device_count INTEGER DEFAULT 0,
|
||||
is_active BOOLEAN DEFAULT 0
|
||||
)
|
||||
''')
|
||||
|
||||
# Baseline device snapshots
|
||||
conn.execute('''
|
||||
CREATE TABLE IF NOT EXISTS bt_baseline_devices (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
baseline_id INTEGER NOT NULL,
|
||||
device_id TEXT NOT NULL,
|
||||
address TEXT NOT NULL,
|
||||
address_type TEXT,
|
||||
name TEXT,
|
||||
manufacturer_id INTEGER,
|
||||
manufacturer_name TEXT,
|
||||
protocol TEXT,
|
||||
FOREIGN KEY (baseline_id) REFERENCES bt_baselines(id) ON DELETE CASCADE,
|
||||
UNIQUE(baseline_id, device_id)
|
||||
)
|
||||
''')
|
||||
|
||||
# Observation history for long-term tracking
|
||||
conn.execute('''
|
||||
CREATE TABLE IF NOT EXISTS bt_observation_history (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
device_id TEXT NOT NULL,
|
||||
timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
rssi INTEGER,
|
||||
seen_count INTEGER
|
||||
)
|
||||
''')
|
||||
|
||||
conn.execute('''
|
||||
CREATE INDEX IF NOT EXISTS idx_bt_obs_device_time
|
||||
ON bt_observation_history(device_id, timestamp)
|
||||
''')
|
||||
|
||||
conn.execute('''
|
||||
CREATE INDEX IF NOT EXISTS idx_bt_baseline_devices_baseline
|
||||
ON bt_baseline_devices(baseline_id)
|
||||
''')
|
||||
|
||||
|
||||
def get_active_baseline_id() -> int | None:
|
||||
"""Get the ID of the active baseline."""
|
||||
with get_db() as conn:
|
||||
cursor = conn.execute(
|
||||
'SELECT id FROM bt_baselines WHERE is_active = 1 LIMIT 1'
|
||||
)
|
||||
row = cursor.fetchone()
|
||||
return row['id'] if row else None
|
||||
|
||||
|
||||
def get_baseline_device_ids(baseline_id: int) -> set[str]:
|
||||
"""Get device IDs from a baseline."""
|
||||
with get_db() as conn:
|
||||
cursor = conn.execute(
|
||||
'SELECT device_id FROM bt_baseline_devices WHERE baseline_id = ?',
|
||||
(baseline_id,)
|
||||
)
|
||||
return {row['device_id'] for row in cursor}
|
||||
|
||||
|
||||
def save_baseline(name: str, devices: list[BTDeviceAggregate]) -> int:
|
||||
"""Save current devices as a new baseline."""
|
||||
with get_db() as conn:
|
||||
# Deactivate existing baselines
|
||||
conn.execute('UPDATE bt_baselines SET is_active = 0')
|
||||
|
||||
# Create new baseline
|
||||
cursor = conn.execute(
|
||||
'INSERT INTO bt_baselines (name, device_count, is_active) VALUES (?, ?, 1)',
|
||||
(name, len(devices))
|
||||
)
|
||||
baseline_id = cursor.lastrowid
|
||||
|
||||
# Save device snapshots
|
||||
for device in devices:
|
||||
conn.execute('''
|
||||
INSERT INTO bt_baseline_devices
|
||||
(baseline_id, device_id, address, address_type, name,
|
||||
manufacturer_id, manufacturer_name, protocol)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
||||
''', (
|
||||
baseline_id,
|
||||
device.device_id,
|
||||
device.address,
|
||||
device.address_type,
|
||||
device.name,
|
||||
device.manufacturer_id,
|
||||
device.manufacturer_name,
|
||||
device.protocol,
|
||||
))
|
||||
|
||||
return baseline_id
|
||||
|
||||
|
||||
def clear_active_baseline() -> bool:
|
||||
"""Clear the active baseline."""
|
||||
with get_db() as conn:
|
||||
cursor = conn.execute('UPDATE bt_baselines SET is_active = 0 WHERE is_active = 1')
|
||||
return cursor.rowcount > 0
|
||||
|
||||
|
||||
def get_all_baselines() -> list[dict]:
|
||||
"""Get all baselines."""
|
||||
with get_db() as conn:
|
||||
cursor = conn.execute('''
|
||||
SELECT id, name, created_at, device_count, is_active
|
||||
FROM bt_baselines
|
||||
ORDER BY created_at DESC
|
||||
''')
|
||||
return [dict(row) for row in cursor]
|
||||
|
||||
|
||||
def save_observation_history(device: BTDeviceAggregate) -> None:
|
||||
"""Save device observation to history."""
|
||||
with get_db() as conn:
|
||||
conn.execute('''
|
||||
INSERT INTO bt_observation_history (device_id, rssi, seen_count)
|
||||
VALUES (?, ?, ?)
|
||||
''', (device.device_id, device.rssi_current, device.seen_count))
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# API ENDPOINTS
|
||||
# =============================================================================
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/capabilities', methods=['GET'])
|
||||
def get_capabilities():
|
||||
"""
|
||||
Get Bluetooth system capabilities.
|
||||
|
||||
Returns:
|
||||
JSON with capability information including adapters, backends, and issues.
|
||||
"""
|
||||
caps = check_capabilities()
|
||||
return jsonify(caps.to_dict())
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/scan/start', methods=['POST'])
|
||||
def start_scan():
|
||||
"""
|
||||
Start Bluetooth scanning.
|
||||
|
||||
Request JSON:
|
||||
- mode: Scanner mode ('auto', 'dbus', 'bleak', 'hcitool', 'bluetoothctl')
|
||||
- duration_s: Scan duration in seconds (optional, None for indefinite)
|
||||
- adapter_id: Adapter path/name (optional)
|
||||
- transport: BLE transport ('auto', 'bredr', 'le')
|
||||
- rssi_threshold: Minimum RSSI for discovery
|
||||
|
||||
Returns:
|
||||
JSON with scan status.
|
||||
"""
|
||||
data = request.get_json() or {}
|
||||
|
||||
mode = data.get('mode', 'auto')
|
||||
duration_s = data.get('duration_s')
|
||||
adapter_id = data.get('adapter_id')
|
||||
transport = data.get('transport', 'auto')
|
||||
rssi_threshold = data.get('rssi_threshold', -100)
|
||||
|
||||
# Validate mode
|
||||
valid_modes = ('auto', 'dbus', 'bleak', 'hcitool', 'bluetoothctl')
|
||||
if mode not in valid_modes:
|
||||
return jsonify({'error': f'Invalid mode. Must be one of: {valid_modes}'}), 400
|
||||
|
||||
# Get scanner instance
|
||||
scanner = get_bluetooth_scanner(adapter_id)
|
||||
|
||||
# Check if already scanning
|
||||
if scanner.is_scanning:
|
||||
return jsonify({
|
||||
'status': 'already_running',
|
||||
'scan_status': scanner.get_status().to_dict()
|
||||
})
|
||||
|
||||
# Initialize database tables if needed
|
||||
init_bt_tables()
|
||||
|
||||
# Load active baseline if exists
|
||||
baseline_id = get_active_baseline_id()
|
||||
if baseline_id:
|
||||
device_ids = get_baseline_device_ids(baseline_id)
|
||||
if device_ids:
|
||||
scanner._aggregator.load_baseline(device_ids, datetime.now())
|
||||
|
||||
# Start scan
|
||||
success = scanner.start_scan(
|
||||
mode=mode,
|
||||
duration_s=duration_s,
|
||||
transport=transport,
|
||||
rssi_threshold=rssi_threshold,
|
||||
)
|
||||
|
||||
if success:
|
||||
status = scanner.get_status()
|
||||
return jsonify({
|
||||
'status': 'started',
|
||||
'mode': status.mode,
|
||||
'backend': status.backend,
|
||||
'adapter_id': status.adapter_id,
|
||||
})
|
||||
else:
|
||||
status = scanner.get_status()
|
||||
return jsonify({
|
||||
'status': 'failed',
|
||||
'error': status.error or 'Failed to start scan',
|
||||
}), 500
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/scan/stop', methods=['POST'])
|
||||
def stop_scan():
|
||||
"""
|
||||
Stop Bluetooth scanning.
|
||||
|
||||
Returns:
|
||||
JSON with status.
|
||||
"""
|
||||
scanner = get_bluetooth_scanner()
|
||||
scanner.stop_scan()
|
||||
|
||||
return jsonify({'status': 'stopped'})
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/scan/status', methods=['GET'])
|
||||
def get_scan_status():
|
||||
"""
|
||||
Get current scan status.
|
||||
|
||||
Returns:
|
||||
JSON with scan status including elapsed time and device count.
|
||||
"""
|
||||
scanner = get_bluetooth_scanner()
|
||||
status = scanner.get_status()
|
||||
return jsonify(status.to_dict())
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/devices', methods=['GET'])
|
||||
def list_devices():
|
||||
"""
|
||||
List discovered Bluetooth devices.
|
||||
|
||||
Query parameters:
|
||||
- sort: Sort field ('last_seen', 'rssi_current', 'name', 'seen_count')
|
||||
- order: Sort order ('asc', 'desc')
|
||||
- min_rssi: Minimum RSSI filter
|
||||
- protocol: Protocol filter ('ble', 'classic')
|
||||
- max_age: Maximum age in seconds
|
||||
- heuristic: Filter by heuristic flag ('new', 'persistent', etc.)
|
||||
|
||||
Returns:
|
||||
JSON array of device summaries.
|
||||
"""
|
||||
scanner = get_bluetooth_scanner()
|
||||
|
||||
# Parse query parameters
|
||||
sort_by = request.args.get('sort', 'last_seen')
|
||||
sort_desc = request.args.get('order', 'desc').lower() != 'asc'
|
||||
min_rssi = request.args.get('min_rssi', type=int)
|
||||
protocol = request.args.get('protocol')
|
||||
max_age = request.args.get('max_age', 300, type=float)
|
||||
heuristic_filter = request.args.get('heuristic')
|
||||
|
||||
# Get devices
|
||||
devices = scanner.get_devices(
|
||||
sort_by=sort_by,
|
||||
sort_desc=sort_desc,
|
||||
min_rssi=min_rssi,
|
||||
protocol=protocol,
|
||||
max_age_seconds=max_age,
|
||||
)
|
||||
|
||||
# Apply heuristic filter if specified
|
||||
if heuristic_filter:
|
||||
devices = [d for d in devices if heuristic_filter in d.heuristic_flags]
|
||||
|
||||
return jsonify({
|
||||
'count': len(devices),
|
||||
'devices': [d.to_summary_dict() for d in devices],
|
||||
})
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/devices/<device_id>', methods=['GET'])
|
||||
def get_device(device_id: str):
|
||||
"""
|
||||
Get detailed information about a specific device.
|
||||
|
||||
Path parameters:
|
||||
- device_id: Device identifier (address:address_type)
|
||||
|
||||
Returns:
|
||||
JSON with full device details including RSSI history.
|
||||
"""
|
||||
scanner = get_bluetooth_scanner()
|
||||
device = scanner.get_device(device_id)
|
||||
|
||||
if not device:
|
||||
return jsonify({'error': 'Device not found'}), 404
|
||||
|
||||
return jsonify(device.to_dict())
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/baseline/set', methods=['POST'])
|
||||
def set_baseline():
|
||||
"""
|
||||
Set current devices as baseline.
|
||||
|
||||
Request JSON:
|
||||
- name: Baseline name (optional)
|
||||
|
||||
Returns:
|
||||
JSON with baseline info.
|
||||
"""
|
||||
data = request.get_json() or {}
|
||||
name = data.get('name', f'Baseline {datetime.now().strftime("%Y-%m-%d %H:%M")}')
|
||||
|
||||
scanner = get_bluetooth_scanner()
|
||||
|
||||
# Initialize tables if needed
|
||||
init_bt_tables()
|
||||
|
||||
# Get current devices and save to database
|
||||
devices = scanner.get_devices()
|
||||
baseline_id = save_baseline(name, devices)
|
||||
|
||||
# Update scanner's in-memory baseline
|
||||
device_count = scanner.set_baseline()
|
||||
|
||||
return jsonify({
|
||||
'status': 'success',
|
||||
'baseline_id': baseline_id,
|
||||
'name': name,
|
||||
'device_count': device_count,
|
||||
})
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/baseline/clear', methods=['POST'])
|
||||
def clear_baseline():
|
||||
"""
|
||||
Clear the active baseline.
|
||||
|
||||
Returns:
|
||||
JSON with status.
|
||||
"""
|
||||
scanner = get_bluetooth_scanner()
|
||||
|
||||
# Clear in database
|
||||
init_bt_tables()
|
||||
cleared = clear_active_baseline()
|
||||
|
||||
# Clear in scanner
|
||||
scanner.clear_baseline()
|
||||
|
||||
return jsonify({
|
||||
'status': 'cleared' if cleared else 'no_baseline',
|
||||
})
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/baseline/list', methods=['GET'])
|
||||
def list_baselines():
|
||||
"""
|
||||
List all saved baselines.
|
||||
|
||||
Returns:
|
||||
JSON array of baselines.
|
||||
"""
|
||||
init_bt_tables()
|
||||
baselines = get_all_baselines()
|
||||
return jsonify({
|
||||
'count': len(baselines),
|
||||
'baselines': baselines,
|
||||
})
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/export', methods=['GET'])
|
||||
def export_devices():
|
||||
"""
|
||||
Export devices in CSV or JSON format.
|
||||
|
||||
Query parameters:
|
||||
- format: Export format ('csv', 'json')
|
||||
|
||||
Returns:
|
||||
CSV or JSON file download.
|
||||
"""
|
||||
export_format = request.args.get('format', 'json').lower()
|
||||
scanner = get_bluetooth_scanner()
|
||||
devices = scanner.get_devices()
|
||||
|
||||
if export_format == 'csv':
|
||||
output = io.StringIO()
|
||||
writer = csv.writer(output)
|
||||
|
||||
# Header
|
||||
writer.writerow([
|
||||
'device_id', 'address', 'address_type', 'protocol', 'name',
|
||||
'manufacturer_name', 'rssi_current', 'rssi_median', 'range_band',
|
||||
'first_seen', 'last_seen', 'seen_count', 'heuristic_flags',
|
||||
'in_baseline'
|
||||
])
|
||||
|
||||
# Data rows
|
||||
for device in devices:
|
||||
writer.writerow([
|
||||
device.device_id,
|
||||
device.address,
|
||||
device.address_type,
|
||||
device.protocol,
|
||||
device.name or '',
|
||||
device.manufacturer_name or '',
|
||||
device.rssi_current or '',
|
||||
round(device.rssi_median, 1) if device.rssi_median else '',
|
||||
device.range_band,
|
||||
device.first_seen.isoformat(),
|
||||
device.last_seen.isoformat(),
|
||||
device.seen_count,
|
||||
','.join(device.heuristic_flags),
|
||||
'yes' if device.in_baseline else 'no',
|
||||
])
|
||||
|
||||
output.seek(0)
|
||||
return Response(
|
||||
output.getvalue(),
|
||||
mimetype='text/csv',
|
||||
headers={
|
||||
'Content-Disposition': f'attachment; filename=bluetooth_devices_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv'
|
||||
}
|
||||
)
|
||||
|
||||
else: # JSON
|
||||
data = {
|
||||
'exported_at': datetime.now().isoformat(),
|
||||
'device_count': len(devices),
|
||||
'devices': [d.to_dict() for d in devices],
|
||||
}
|
||||
return Response(
|
||||
json.dumps(data, indent=2),
|
||||
mimetype='application/json',
|
||||
headers={
|
||||
'Content-Disposition': f'attachment; filename=bluetooth_devices_{datetime.now().strftime("%Y%m%d_%H%M%S")}.json'
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/stream', methods=['GET'])
|
||||
def stream_events():
|
||||
"""
|
||||
SSE event stream for real-time device updates.
|
||||
|
||||
Returns:
|
||||
Server-Sent Events stream.
|
||||
"""
|
||||
scanner = get_bluetooth_scanner()
|
||||
|
||||
def event_generator() -> Generator[str, None, None]:
|
||||
"""Generate SSE events from scanner."""
|
||||
for event in scanner.stream_events(timeout=1.0):
|
||||
yield format_sse(event)
|
||||
|
||||
return Response(
|
||||
event_generator(),
|
||||
mimetype='text/event-stream',
|
||||
headers={
|
||||
'Cache-Control': 'no-cache',
|
||||
'Connection': 'keep-alive',
|
||||
'X-Accel-Buffering': 'no',
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/clear', methods=['POST'])
|
||||
def clear_devices():
|
||||
"""
|
||||
Clear all tracked devices (does not affect baseline).
|
||||
|
||||
Returns:
|
||||
JSON with status.
|
||||
"""
|
||||
scanner = get_bluetooth_scanner()
|
||||
scanner.clear_devices()
|
||||
|
||||
return jsonify({'status': 'cleared'})
|
||||
|
||||
|
||||
@bluetooth_v2_bp.route('/prune', methods=['POST'])
|
||||
def prune_stale():
|
||||
"""
|
||||
Prune stale devices.
|
||||
|
||||
Request JSON:
|
||||
- max_age: Maximum age in seconds (default: 300)
|
||||
|
||||
Returns:
|
||||
JSON with count of pruned devices.
|
||||
"""
|
||||
data = request.get_json() or {}
|
||||
max_age = data.get('max_age', 300)
|
||||
|
||||
scanner = get_bluetooth_scanner()
|
||||
pruned = scanner.prune_stale(max_age_seconds=max_age)
|
||||
|
||||
return jsonify({
|
||||
'status': 'success',
|
||||
'pruned_count': pruned,
|
||||
})
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# TSCM INTEGRATION HELPER
|
||||
# =============================================================================
|
||||
|
||||
|
||||
def get_tscm_bluetooth_snapshot(duration: int = 8) -> list[dict]:
|
||||
"""
|
||||
Get Bluetooth snapshot for TSCM integration.
|
||||
|
||||
This is called from routes/tscm.py to get unified Bluetooth data.
|
||||
|
||||
Args:
|
||||
duration: Scan duration in seconds.
|
||||
|
||||
Returns:
|
||||
List of device dictionaries in TSCM format.
|
||||
"""
|
||||
import time
|
||||
|
||||
scanner = get_bluetooth_scanner()
|
||||
|
||||
# Start scan if not running
|
||||
if not scanner.is_scanning:
|
||||
scanner.start_scan(mode='auto', duration_s=duration)
|
||||
time.sleep(duration + 1)
|
||||
|
||||
devices = scanner.get_devices()
|
||||
|
||||
# Convert to TSCM format
|
||||
tscm_devices = []
|
||||
for device in devices:
|
||||
tscm_devices.append({
|
||||
'mac': device.address,
|
||||
'address_type': device.address_type,
|
||||
'name': device.name or 'Unknown',
|
||||
'rssi': device.rssi_current or -100,
|
||||
'rssi_median': device.rssi_median,
|
||||
'type': _classify_device_type(device),
|
||||
'manufacturer': device.manufacturer_name,
|
||||
'protocol': device.protocol,
|
||||
'first_seen': device.first_seen.isoformat(),
|
||||
'last_seen': device.last_seen.isoformat(),
|
||||
'seen_count': device.seen_count,
|
||||
'range_band': device.range_band,
|
||||
'heuristics': {
|
||||
'is_new': device.is_new,
|
||||
'is_persistent': device.is_persistent,
|
||||
'is_beacon_like': device.is_beacon_like,
|
||||
'is_strong_stable': device.is_strong_stable,
|
||||
'has_random_address': device.has_random_address,
|
||||
},
|
||||
'in_baseline': device.in_baseline,
|
||||
})
|
||||
|
||||
return tscm_devices
|
||||
|
||||
|
||||
def _classify_device_type(device: BTDeviceAggregate) -> str:
|
||||
"""Classify device type from available data."""
|
||||
name_lower = (device.name or '').lower()
|
||||
manufacturer_lower = (device.manufacturer_name or '').lower()
|
||||
|
||||
# Check by name patterns
|
||||
if any(x in name_lower for x in ['airpods', 'headphone', 'earbuds', 'buds', 'beats']):
|
||||
return 'audio'
|
||||
if any(x in name_lower for x in ['watch', 'band', 'fitbit', 'garmin']):
|
||||
return 'wearable'
|
||||
if any(x in name_lower for x in ['iphone', 'pixel', 'galaxy', 'phone']):
|
||||
return 'phone'
|
||||
if any(x in name_lower for x in ['macbook', 'laptop', 'thinkpad', 'surface']):
|
||||
return 'computer'
|
||||
if any(x in name_lower for x in ['mouse', 'keyboard', 'trackpad']):
|
||||
return 'peripheral'
|
||||
if any(x in name_lower for x in ['tile', 'airtag', 'smarttag', 'chipolo']):
|
||||
return 'tracker'
|
||||
if any(x in name_lower for x in ['speaker', 'sonos', 'echo', 'home']):
|
||||
return 'speaker'
|
||||
if any(x in name_lower for x in ['tv', 'chromecast', 'roku', 'firestick']):
|
||||
return 'media'
|
||||
|
||||
# Check by manufacturer
|
||||
if 'apple' in manufacturer_lower:
|
||||
return 'apple_device'
|
||||
if 'samsung' in manufacturer_lower:
|
||||
return 'samsung_device'
|
||||
|
||||
# Check by class of device
|
||||
if device.major_class:
|
||||
major = device.major_class.lower()
|
||||
if 'audio' in major:
|
||||
return 'audio'
|
||||
if 'phone' in major:
|
||||
return 'phone'
|
||||
if 'computer' in major:
|
||||
return 'computer'
|
||||
if 'peripheral' in major:
|
||||
return 'peripheral'
|
||||
if 'wearable' in major:
|
||||
return 'wearable'
|
||||
|
||||
return 'unknown'
|
||||
Reference in New Issue
Block a user