Upload 4 files

app.py

@@ -0,0 +1,504 @@
+"""
+Real-time Microphone Streaming Server with Gradio Interface
+Hosted on Hugging Face Spaces with WebSocket support for Android devices
+"""
+
+import gradio as gr
+import asyncio
+import websockets
+import json
+import logging
+import threading
+import time
+import base64
+from datetime import datetime
+from typing import Dict, List, Optional
+import queue
+import numpy as np
+
+from audio_utils import AudioStreamManager, AudioProcessor
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global variables
+stream_manager = AudioStreamManager()
+websocket_server = None
+connected_clients = {}
+client_lock = threading.Lock()
+
+# Message queues for real-time updates
+device_update_queue = queue.Queue()
+audio_data_queue = queue.Queue()
+
+class GradioWebSocketHandler:
+    """Handles WebSocket connections from Android devices"""
+    
+    def __init__(self):
+        self.running = False
+    
+    async def handle_client(self, websocket, path):
+        """Handle individual WebSocket client connection"""
+        client_id = f"{websocket.remote_address[0]}:{websocket.remote_address[1]}"
+        client_type = None
+        device_id = None
+        
+        logger.info(f"New WebSocket connection from {client_id}")
+        
+        with client_lock:
+            connected_clients[client_id] = {
+                'websocket': websocket,
+                'connected_at': time.time(),
+                'type': 'unknown'
+            }
+        
+        try:
+            # Send welcome message
+            await websocket.send(json.dumps({
+                'type': 'welcome',
+                'message': 'Connected to Real-time Audio Streaming Server (Gradio)',
+                'timestamp': datetime.now().isoformat(),
+                'server_info': {
+                    'platform': 'Gradio/HuggingFace',
+                    'version': '1.0.0'
+                }
+            }))
+            
+            async for message in websocket:
+                try:
+                    data = json.loads(message)
+                    message_type = data.get('type', '')
+                    
+                    if message_type == 'register_device':
+                        # Android device registration
+                        client_type = 'device'
+                        device_id = data.get('device_id', '')
+                        device_name = data.get('device_name', 'Unknown Device')
+                        device_model = data.get('device_model', 'Unknown')
+                        
+                        # Register device with stream manager
+                        device_info = {
+                            'name': device_name,
+                            'model': device_model,
+                            'client_id': client_id,
+                            'platform': 'Android'
+                        }
+                        
+                        stream_manager.device_manager.register_device(device_id, device_info)
+                        
+                        with client_lock:
+                            connected_clients[client_id]['type'] = 'device'
+                            connected_clients[client_id]['device_id'] = device_id
+                        
+                        # Send registration confirmation
+                        await websocket.send(json.dumps({
+                            'type': 'registration_success',
+                            'device_id': device_id,
+                            'message': 'Device registered successfully',
+                            'timestamp': datetime.now().isoformat()
+                        }))
+                        
+                        # Notify Gradio interface
+                        device_update_queue.put({
+                            'type': 'device_connected',
+                            'device_id': device_id,
+                            'device_info': device_info
+                        })
+                        
+                        logger.info(f"Device registered: {device_id} ({device_name})")
+                    
+                    elif message_type == 'audio_chunk':
+                        # Audio data from Android device
+                        if client_type == 'device' and device_id:
+                            audio_data = data.get('data', {})
+                            
+                            # Decode base64 audio
+                            base64_audio = audio_data.get('audio_data', '')
+                            if base64_audio:
+                                audio_bytes = AudioProcessor.decode_base64_audio(base64_audio)
+                                if audio_bytes:
+                                    timestamp = data.get('timestamp', time.time())
+                                    
+                                    # Add to stream manager
+                                    stream_manager.device_manager.add_audio_chunk(
+                                        device_id, audio_bytes, timestamp
+                                    )
+                                    
+                                    # Queue for Gradio display
+                                    audio_data_queue.put({
+                                        'device_id': device_id,
+                                        'timestamp': timestamp,
+                                        'size_bytes': len(audio_bytes),
+                                        'sample_rate': audio_data.get('sample_rate', 16000)
+                                    })
+                    
+                    elif message_type == 'start_streaming':
+                        if client_type == 'device' and device_id:
+                            stream_manager.start_stream(device_id)
+                            await websocket.send(json.dumps({
+                                'type': 'streaming_started',
+                                'device_id': device_id,
+                                'timestamp': datetime.now().isoformat()
+                            }))
+                    
+                    elif message_type == 'stop_streaming':
+                        if client_type == 'device' and device_id:
+                            stream_manager.stop_stream(device_id)
+                            await websocket.send(json.dumps({
+                                'type': 'streaming_stopped',
+                                'device_id': device_id,
+                                'timestamp': datetime.now().isoformat()
+                            }))
+                    
+                    elif message_type == 'ping':
+                        # Heartbeat response
+                        if device_id:
+                            stream_manager.device_manager.update_device_heartbeat(device_id)
+                        
+                        await websocket.send(json.dumps({
+                            'type': 'pong',
+                            'timestamp': datetime.now().isoformat()
+                        }))
+                    
+                    else:
+                        logger.warning(f"Unknown message type: {message_type}")
+                
+                except json.JSONDecodeError as e:
+                    logger.error(f"JSON decode error: {e}")
+                except Exception as e:
+                    logger.error(f"Error processing message: {e}")
+        
+        except websockets.exceptions.ConnectionClosed:
+            logger.info(f"WebSocket connection closed: {client_id}")
+        except Exception as e:
+            logger.error(f"WebSocket error: {e}")
+        finally:
+            # Cleanup on disconnect
+            with client_lock:
+                if client_id in connected_clients:
+                    client_info = connected_clients[client_id]
+                    if client_info.get('type') == 'device' and 'device_id' in client_info:
+                        device_id = client_info['device_id']
+                        stream_manager.device_manager.unregister_device(device_id)
+                        
+                        # Notify Gradio interface
+                        device_update_queue.put({
+                            'type': 'device_disconnected',
+                            'device_id': device_id
+                        })
+                        
+                        logger.info(f"Device disconnected: {device_id}")
+                    
+                    del connected_clients[client_id]
+    
+    async def send_command_to_device(self, device_id: str, command: str) -> bool:
+        """Send command to specific device"""
+        with client_lock:
+            for client_id, client_info in connected_clients.items():
+                if (client_info.get('type') == 'device' and 
+                    client_info.get('device_id') == device_id):
+                    try:
+                        await client_info['websocket'].send(json.dumps({
+                            'type': command,
+                            'timestamp': datetime.now().isoformat()
+                        }))
+                        return True
+                    except Exception as e:
+                        logger.error(f"Error sending command to device {device_id}: {e}")
+                        return False
+        return False
+
+# WebSocket handler instance
+ws_handler = GradioWebSocketHandler()
+
+def start_websocket_server():
+    """Start WebSocket server in background thread"""
+    global websocket_server
+    
+    async def run_server():
+        global websocket_server
+        # Use port 7861 for WebSocket (Gradio uses 7860)
+        websocket_server = await websockets.serve(
+            ws_handler.handle_client,
+            "0.0.0.0", 
+            7861,
+            ping_interval=30,
+            ping_timeout=60
+        )
+        logger.info("WebSocket server started on port 7861")
+        await websocket_server.wait_closed()
+    
+    def run_in_thread():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(run_server())
+    
+    server_thread = threading.Thread(target=run_in_thread, daemon=True)
+    server_thread.start()
+
+def get_connected_devices() -> List[Dict]:
+    """Get list of connected devices for Gradio display"""
+    devices = stream_manager.device_manager.get_all_devices_info()
+    device_list = []
+    
+    for device_id, device_info in devices.items():
+        if device_info.get('status') == 'connected':
+            device_data = {
+                'device_id': device_id,
+                'name': device_info.get('info', {}).get('name', 'Unknown'),
+                'model': device_info.get('info', {}).get('model', 'Unknown'),
+                'connected_at': datetime.fromtimestamp(device_info.get('connected_at', 0)).strftime('%H:%M:%S'),
+                'streaming': device_info.get('streaming', False),
+                'total_chunks': device_info.get('stats', {}).get('total_chunks', 0),
+                'bytes_received': device_info.get('stats', {}).get('bytes_received', 0),
+                'last_seen': 'Now' if time.time() - device_info.get('last_seen', 0) < 10 else f"{int(time.time() - device_info.get('last_seen', 0))}s ago"
+            }
+            device_list.append(device_data)
+    
+    return device_list
+
+def start_streaming(device_id: str) -> str:
+    """Start streaming from a device"""
+    if stream_manager.start_stream(device_id):
+        # Send command to device
+        asyncio.run(ws_handler.send_command_to_device(device_id, 'start_streaming'))
+        return f"✅ Started streaming from device: {device_id}"
+    else:
+        return f"❌ Failed to start streaming from device: {device_id}"
+
+def stop_streaming(device_id: str) -> str:
+    """Stop streaming from a device"""
+    if stream_manager.stop_stream(device_id):
+        # Send command to device
+        asyncio.run(ws_handler.send_command_to_device(device_id, 'stop_streaming'))
+        return f"🛑 Stopped streaming from device: {device_id}"
+    else:
+        return f"❌ Failed to stop streaming from device: {device_id}"
+
+def get_server_stats() -> Dict:
+    """Get server statistics"""
+    devices = stream_manager.device_manager.get_all_devices_info()
+    connected_count = len([d for d in devices.values() if d.get('status') == 'connected'])
+    streaming_count = len(stream_manager.get_streaming_devices())
+    
+    total_bytes = sum([
+        device.get('stats', {}).get('bytes_received', 0) 
+        for device in devices.values()
+    ])
+    
+    with client_lock:
+        total_connections = len(connected_clients)
+    
+    return {
+        'connected_devices': connected_count,
+        'streaming_devices': streaming_count,
+        'total_connections': total_connections,
+        'total_data_mb': round(total_bytes / (1024 * 1024), 2),
+        'server_uptime': time.strftime('%H:%M:%S', time.gmtime(time.time() - server_start_time))
+    }
+
+def update_device_list():
+    """Update device list for Gradio"""
+    devices = get_connected_devices()
+    if not devices:
+        return "No devices connected. Install the Android app and connect to start streaming."
+    
+    # Create HTML table for devices
+    html = """
+    <div style="font-family: Arial, sans-serif;">
+        <h3>📱 Connected Devices</h3>
+        <table style="width: 100%; border-collapse: collapse; margin-top: 10px;">
+            <thead>
+                <tr style="background-color: #f0f0f0;">
+                    <th style="border: 1px solid #ddd; padding: 8px; text-align: left;">Device</th>
+                    <th style="border: 1px solid #ddd; padding: 8px; text-align: left;">Status</th>
+                    <th style="border: 1px solid #ddd; padding: 8px; text-align: left;">Data</th>
+                    <th style="border: 1px solid #ddd; padding: 8px; text-align: left;">Last Seen</th>
+                </tr>
+            </thead>
+            <tbody>
+    """
+    
+    for device in devices:
+        status_icon = "🎙️ Streaming" if device['streaming'] else "✅ Connected"
+        status_color = "#28a745" if device['streaming'] else "#007bff"
+        
+        html += f"""
+            <tr>
+                <td style="border: 1px solid #ddd; padding: 8px;">
+                    <strong>{device['name']}</strong><br>
+                    <small style="color: #666;">{device['device_id'][:12]}...</small>
+                </td>
+                <td style="border: 1px solid #ddd; padding: 8px;">
+                    <span style="color: {status_color}; font-weight: bold;">{status_icon}</span><br>
+                    <small>Since: {device['connected_at']}</small>
+                </td>
+                <td style="border: 1px solid #ddd; padding: 8px;">
+                    <strong>{device['total_chunks']}</strong> chunks<br>
+                    <small>{round(device['bytes_received']/1024, 1)} KB</small>
+                </td>
+                <td style="border: 1px solid #ddd; padding: 8px;">
+                    {device['last_seen']}
+                </td>
+            </tr>
+        """
+    
+    html += """
+            </tbody>
+        </table>
+    </div>
+    """
+    
+    return html
+
+def create_gradio_interface():
+    """Create the main Gradio interface"""
+    
+    with gr.Blocks(title="🎤 Real-time Mic Streaming Server", theme=gr.themes.Soft()) as interface:
+        
+        # Header
+        gr.HTML("""
+            <div style="text-align: center; padding: 20px; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
+                <h1 style="margin: 0; font-size: 2.5em;">🎤 Real-time Microphone Streaming</h1>
+                <p style="margin: 10px 0 0 0; font-size: 1.2em;">Android Device Audio Streaming Server</p>
+            </div>
+        """)
+        
+        # Connection info
+        with gr.Row():
+            gr.HTML("""
+                <div style="background: #e8f4f8; padding: 15px; border-radius: 8px; border-left: 5px solid #007bff;">
+                    <h3 style="margin: 0 0 10px 0;">📡 Connection Information</h3>
+                    <p style="margin: 5px 0;"><strong>WebSocket URL:</strong> <code>wss://your-space-name.hf.space:7861</code></p>
+                    <p style="margin: 5px 0;"><strong>Protocol:</strong> WebSocket with JSON messages</p>
+                    <p style="margin: 5px 0;">Configure your Android app to connect to this WebSocket URL.</p>
+                </div>
+            """)
+        
+        # Server Statistics
+        with gr.Row():
+            with gr.Column(scale=1):
+                connected_devices_display = gr.Number(label="📱 Connected Devices", value=0, interactive=False)
+            with gr.Column(scale=1):
+                streaming_devices_display = gr.Number(label="🎙️ Streaming Devices", value=0, interactive=False)
+            with gr.Column(scale=1):
+                total_data_display = gr.Number(label="📊 Total Data (MB)", value=0.0, interactive=False)
+            with gr.Column(scale=1):
+                uptime_display = gr.Textbox(label="⏱️ Server Uptime", value="00:00:00", interactive=False)
+        
+        # Device List
+        device_list_display = gr.HTML(
+            value="No devices connected. Install the Android app and connect to start streaming.",
+            label="Connected Devices"
+        )
+        
+        # Control Buttons
+        with gr.Row():
+            with gr.Column(scale=1):
+                device_id_input = gr.Textbox(
+                    label="Device ID", 
+                    placeholder="Enter device ID to control",
+                    info="Copy device ID from the table above"
+                )
+            with gr.Column(scale=1):
+                start_btn = gr.Button("🎤 Start Streaming", variant="primary")
+                stop_btn = gr.Button("🛑 Stop Streaming", variant="secondary")
+        
+        # Control feedback
+        control_output = gr.Textbox(label="Control Status", interactive=False)
+        
+        # Audio Data Monitor (recent activity)
+        audio_monitor = gr.HTML(
+            value="<p>No recent audio data...</p>",
+            label="Recent Audio Activity"
+        )
+        
+        # Event handlers
+        start_btn.click(
+            fn=start_streaming,
+            inputs=[device_id_input],
+            outputs=[control_output]
+        )
+        
+        stop_btn.click(
+            fn=stop_streaming,
+            inputs=[device_id_input],
+            outputs=[control_output]
+        )
+        
+        # Auto-refresh components
+        def update_all():
+            stats = get_server_stats()
+            devices_html = update_device_list()
+            
+            # Get recent audio activity
+            recent_audio = []
+            while not audio_data_queue.empty():
+                try:
+                    audio_info = audio_data_queue.get_nowait()
+                    recent_audio.append(audio_info)
+                except queue.Empty:
+                    break
+            
+            if recent_audio:
+                audio_html = "<div style='font-family: monospace; font-size: 12px;'>"
+                audio_html += "<h4>Recent Audio Chunks:</h4>"
+                for audio in recent_audio[-10:]:  # Show last 10 chunks
+                    timestamp = datetime.fromtimestamp(audio['timestamp']).strftime('%H:%M:%S')
+                    audio_html += f"<p>{timestamp} - Device: {audio['device_id'][:12]}... | Size: {audio['size_bytes']} bytes | Rate: {audio['sample_rate']} Hz</p>"
+                audio_html += "</div>"
+            else:
+                audio_html = "<p>No recent audio data...</p>"
+            
+            return (
+                stats['connected_devices'],
+                stats['streaming_devices'], 
+                stats['total_data_mb'],
+                stats['server_uptime'],
+                devices_html,
+                audio_html
+            )
+        
+        # Set up auto-refresh every 2 seconds
+        interface.load(
+            fn=update_all,
+            outputs=[
+                connected_devices_display,
+                streaming_devices_display, 
+                total_data_display,
+                uptime_display,
+                device_list_display,
+                audio_monitor
+            ],
+            every=2
+        )
+    
+    return interface
+
+# Global server start time
+server_start_time = time.time()
+
+def main():
+    """Main application entry point"""
+    logger.info("Starting Real-time Microphone Streaming Server...")
+    
+    # Start WebSocket server
+    start_websocket_server()
+    
+    # Wait a moment for WebSocket server to start
+    time.sleep(2)
+    
+    # Create and launch Gradio interface
+    interface = create_gradio_interface()
+    
+    # Launch with public access for Hugging Face
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,  # Set to True for public tunnels during development
+        debug=False
+    )
+
+if __name__ == "__main__":
+    main()

audio_utils.py

@@ -0,0 +1,341 @@
+"""
+Audio Processing Utilities for Real-time Microphone Streaming
+Handles audio data encoding, decoding, and processing for Gradio backend.
+"""
+
+import base64
+import numpy as np
+import threading
+import queue
+import time
+import logging
+from datetime import datetime
+from typing import Optional, Dict, List, Tuple
+
+logger = logging.getLogger(__name__)
+
+class AudioBuffer:
+    """Thread-safe audio buffer for storing audio chunks"""
+    
+    def __init__(self, max_size: int = 1000):
+        self.max_size = max_size
+        self.buffer = queue.Queue(maxsize=max_size)
+        self.lock = threading.Lock()
+        self._stats = {
+            'total_chunks': 0,
+            'dropped_chunks': 0,
+            'buffer_size': 0
+        }
+    
+    def add_chunk(self, audio_data: bytes, device_id: str, timestamp: float) -> bool:
+        """Add audio chunk to buffer. Returns True if successful, False if buffer full"""
+        try:
+            chunk = {
+                'audio_data': audio_data,
+                'device_id': device_id,
+                'timestamp': timestamp,
+                'server_received': time.time()
+            }
+            
+            self.buffer.put_nowait(chunk)
+            with self.lock:
+                self._stats['total_chunks'] += 1
+                self._stats['buffer_size'] = self.buffer.qsize()
+            return True
+            
+        except queue.Full:
+            with self.lock:
+                self._stats['dropped_chunks'] += 1
+            logger.warning(f"Audio buffer full, dropped chunk from device {device_id}")
+            return False
+    
+    def get_chunk(self, timeout: float = 0.1) -> Optional[Dict]:
+        """Get next audio chunk from buffer"""
+        try:
+            chunk = self.buffer.get(timeout=timeout)
+            with self.lock:
+                self._stats['buffer_size'] = self.buffer.qsize()
+            return chunk
+        except queue.Empty:
+            return None
+    
+    def get_stats(self) -> Dict:
+        """Get buffer statistics"""
+        with self.lock:
+            return self._stats.copy()
+    
+    def clear(self):
+        """Clear the buffer"""
+        with self.lock:
+            while not self.buffer.empty():
+                try:
+                    self.buffer.get_nowait()
+                except queue.Empty:
+                    break
+            self._stats['buffer_size'] = 0
+
+class AudioProcessor:
+    """Audio processing utilities"""
+    
+    @staticmethod
+    def decode_base64_audio(base64_data: str) -> Optional[bytes]:
+        """Decode base64 audio data to bytes"""
+        try:
+            # Clean the base64 string
+            clean_base64 = base64_data.replace('\n', '').replace('\r', '').strip()
+            
+            # Add padding if necessary
+            missing_padding = len(clean_base64) % 4
+            if missing_padding:
+                clean_base64 += '=' * (4 - missing_padding)
+            
+            # Decode base64 to bytes
+            audio_bytes = base64.b64decode(clean_base64)
+            return audio_bytes
+            
+        except Exception as e:
+            logger.error(f"Error decoding base64 audio: {e}")
+            return None
+    
+    @staticmethod
+    def encode_audio_to_base64(audio_bytes: bytes) -> str:
+        """Encode audio bytes to base64 string"""
+        return base64.b64encode(audio_bytes).decode('utf-8')
+    
+    @staticmethod
+    def pcm_to_numpy(audio_bytes: bytes, sample_rate: int = 16000, channels: int = 1) -> Optional[np.ndarray]:
+        """Convert PCM bytes to numpy array"""
+        try:
+            # Convert bytes to 16-bit signed integers
+            audio_array = np.frombuffer(audio_bytes, dtype=np.int16)
+            
+            # Normalize to float32 range [-1.0, 1.0]
+            audio_float = audio_array.astype(np.float32) / 32768.0
+            
+            # Handle multi-channel audio
+            if channels > 1:
+                audio_float = audio_float.reshape(-1, channels)
+            
+            return audio_float
+            
+        except Exception as e:
+            logger.error(f"Error converting PCM to numpy: {e}")
+            return None
+    
+    @staticmethod
+    def numpy_to_pcm(audio_array: np.ndarray) -> bytes:
+        """Convert numpy array to PCM bytes"""
+        try:
+            # Ensure array is float32
+            if audio_array.dtype != np.float32:
+                audio_array = audio_array.astype(np.float32)
+            
+            # Clamp values to [-1.0, 1.0]
+            audio_array = np.clip(audio_array, -1.0, 1.0)
+            
+            # Convert to 16-bit signed integers
+            audio_int16 = (audio_array * 32767).astype(np.int16)
+            
+            # Convert to bytes
+            return audio_int16.tobytes()
+            
+        except Exception as e:
+            logger.error(f"Error converting numpy to PCM: {e}")
+            return b''
+    
+    @staticmethod
+    def calculate_audio_stats(audio_bytes: bytes) -> Dict:
+        """Calculate basic audio statistics"""
+        try:
+            audio_array = np.frombuffer(audio_bytes, dtype=np.int16)
+            audio_float = audio_array.astype(np.float32) / 32768.0
+            
+            stats = {
+                'length_samples': len(audio_array),
+                'length_bytes': len(audio_bytes),
+                'rms': float(np.sqrt(np.mean(audio_float**2))),
+                'peak': float(np.max(np.abs(audio_float))),
+                'mean': float(np.mean(audio_float)),
+                'std': float(np.std(audio_float))
+            }
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Error calculating audio stats: {e}")
+            return {}
+
+class DeviceManager:
+    """Manages connected audio streaming devices"""
+    
+    def __init__(self):
+        self.devices = {}
+        self.lock = threading.Lock()
+        self.device_stats = {}
+    
+    def register_device(self, device_id: str, device_info: Dict) -> bool:
+        """Register a new device"""
+        with self.lock:
+            self.devices[device_id] = {
+                'info': device_info,
+                'connected_at': time.time(),
+                'last_seen': time.time(),
+                'status': 'connected',
+                'streaming': False,
+                'audio_buffer': AudioBuffer()
+            }
+            self.device_stats[device_id] = {
+                'total_chunks': 0,
+                'bytes_received': 0,
+                'connection_time': time.time(),
+                'last_chunk_time': None
+            }
+            
+        logger.info(f"Device registered: {device_id} ({device_info.get('name', 'Unknown')})")
+        return True
+    
+    def unregister_device(self, device_id: str) -> bool:
+        """Unregister a device"""
+        with self.lock:
+            if device_id in self.devices:
+                self.devices[device_id]['status'] = 'disconnected'
+                self.devices[device_id]['disconnected_at'] = time.time()
+                # Clear the audio buffer
+                self.devices[device_id]['audio_buffer'].clear()
+                
+        logger.info(f"Device unregistered: {device_id}")
+        return True
+    
+    def update_device_heartbeat(self, device_id: str):
+        """Update device last seen timestamp"""
+        with self.lock:
+            if device_id in self.devices:
+                self.devices[device_id]['last_seen'] = time.time()
+    
+    def add_audio_chunk(self, device_id: str, audio_data: bytes, timestamp: float) -> bool:
+        """Add audio chunk for a device"""
+        with self.lock:
+            if device_id not in self.devices:
+                return False
+            
+            device = self.devices[device_id]
+            if device['status'] != 'connected':
+                return False
+            
+            # Update device streaming status
+            device['streaming'] = True
+            device['last_seen'] = time.time()
+            
+            # Update stats
+            stats = self.device_stats[device_id]
+            stats['total_chunks'] += 1
+            stats['bytes_received'] += len(audio_data)
+            stats['last_chunk_time'] = time.time()
+            
+            # Add to buffer
+            return device['audio_buffer'].add_chunk(audio_data, device_id, timestamp)
+    
+    def get_audio_chunk(self, device_id: str) -> Optional[Dict]:
+        """Get next audio chunk from device"""
+        with self.lock:
+            if device_id not in self.devices:
+                return None
+            return self.devices[device_id]['audio_buffer'].get_chunk()
+    
+    def get_connected_devices(self) -> List[str]:
+        """Get list of connected device IDs"""
+        with self.lock:
+            return [
+                device_id for device_id, device in self.devices.items()
+                if device['status'] == 'connected'
+            ]
+    
+    def get_device_info(self, device_id: str) -> Optional[Dict]:
+        """Get device information"""
+        with self.lock:
+            if device_id in self.devices:
+                device = self.devices[device_id].copy()
+                device['stats'] = self.device_stats[device_id].copy()
+                return device
+            return None
+    
+    def get_all_devices_info(self) -> Dict:
+        """Get information for all devices"""
+        with self.lock:
+            devices_info = {}
+            for device_id, device in self.devices.items():
+                device_copy = device.copy()
+                device_copy['stats'] = self.device_stats[device_id].copy()
+                devices_info[device_id] = device_copy
+            return devices_info
+    
+    def cleanup_inactive_devices(self, timeout_seconds: int = 300):
+        """Remove devices that haven't been seen for a while"""
+        current_time = time.time()
+        with self.lock:
+            inactive_devices = []
+            for device_id, device in self.devices.items():
+                if device['status'] == 'connected':
+                    if current_time - device['last_seen'] > timeout_seconds:
+                        inactive_devices.append(device_id)
+            
+            for device_id in inactive_devices:
+                logger.info(f"Cleaning up inactive device: {device_id}")
+                self.unregister_device(device_id)
+
+class AudioStreamManager:
+    """Manages real-time audio streaming between devices and clients"""
+    
+    def __init__(self):
+        self.device_manager = DeviceManager()
+        self.active_streams = {}
+        self.stream_lock = threading.Lock()
+        self.running = False
+        
+        # Start cleanup thread
+        self.cleanup_thread = threading.Thread(target=self._cleanup_loop, daemon=True)
+        self.cleanup_thread.start()
+    
+    def start_stream(self, device_id: str) -> bool:
+        """Start streaming from a device"""
+        with self.stream_lock:
+            if device_id in self.device_manager.get_connected_devices():
+                self.active_streams[device_id] = {
+                    'started_at': time.time(),
+                    'active': True
+                }
+                logger.info(f"Started streaming from device: {device_id}")
+                return True
+        return False
+    
+    def stop_stream(self, device_id: str) -> bool:
+        """Stop streaming from a device"""
+        with self.stream_lock:
+            if device_id in self.active_streams:
+                self.active_streams[device_id]['active'] = False
+                del self.active_streams[device_id]
+                logger.info(f"Stopped streaming from device: {device_id}")
+                return True
+        return False
+    
+    def is_streaming(self, device_id: str) -> bool:
+        """Check if device is currently streaming"""
+        with self.stream_lock:
+            return device_id in self.active_streams and self.active_streams[device_id]['active']
+    
+    def get_streaming_devices(self) -> List[str]:
+        """Get list of currently streaming devices"""
+        with self.stream_lock:
+            return [
+                device_id for device_id, stream in self.active_streams.items()
+                if stream['active']
+            ]
+    
+    def _cleanup_loop(self):
+        """Background cleanup loop"""
+        while True:
+            try:
+                self.device_manager.cleanup_inactive_devices()
+                time.sleep(30)  # Run cleanup every 30 seconds
+            except Exception as e:
+                logger.error(f"Error in cleanup loop: {e}")
+                time.sleep(5)

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.0.0
+websockets>=12.0
+numpy>=1.21.0

start_server.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Local startup script for the Real-time Microphone Streaming Server
+Use this for local development and testing before deploying to Hugging Face
+"""
+
+import os
+import sys
+import subprocess
+import time
+
+def check_dependencies():
+    """Check if required packages are installed"""
+    required_packages = ['gradio', 'websockets', 'numpy']
+    missing_packages = []
+    
+    for package in required_packages:
+        try:
+            __import__(package)
+        except ImportError:
+            missing_packages.append(package)
+    
+    if missing_packages:
+        print("❌ Missing required packages:")
+        for package in missing_packages:
+            print(f"   - {package}")
+        print("\n📦 Installing missing packages...")
+        
+        try:
+            subprocess.check_call([sys.executable, '-m', 'pip', 'install'] + missing_packages)
+            print("✅ Packages installed successfully!")
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Failed to install packages: {e}")
+            return False
+    
+    return True
+
+def main():
+    """Main startup function"""
+    print("🎤 Real-time Microphone Streaming Server")
+    print("=" * 50)
+    
+    # Check dependencies
+    print("🔍 Checking dependencies...")
+    if not check_dependencies():
+        print("❌ Dependency check failed. Exiting.")
+        sys.exit(1)
+    
+    print("✅ Dependencies OK")
+    
+    # Set environment variables for local development
+    os.environ['GRADIO_SERVER_NAME'] = '0.0.0.0'
+    os.environ['GRADIO_SERVER_PORT'] = '7860'
+    
+    print("\n🚀 Starting server...")
+    print("📡 Gradio interface will be available at: http://localhost:7860")
+    print("🔌 WebSocket server will be available at: ws://localhost:7861")
+    print("\n📱 Update your Android app to use: ws://YOUR_LOCAL_IP:7861")
+    print("   (Replace YOUR_LOCAL_IP with your computer's IP address)")
+    print("\n⏹️  Press Ctrl+C to stop the server")
+    print("=" * 50)
+    
+    # Import and run the main app
+    try:
+        from app import main as run_app
+        run_app()
+    except KeyboardInterrupt:
+        print("\n\n🛑 Server stopped by user")
+    except Exception as e:
+        print(f"\n❌ Server error: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()