Update app.py

app.py

@@ -1,396 +1,349 @@
-import gradio as gr
-import openai
-import os
-import subprocess
-import threading
-import time
-import base64
-import io
-from PIL import Image
-
-# --- MODIFIED: Use pure-python-adb (ppadb) library ---
-# This library connects to the ADB server, avoiding direct USB permission issues.
-try:
-    from ppadb.client import Client as AdbClient
-    ADB_AVAILABLE = True
-except ImportError:
-    ADB_AVAILABLE = False
-    print("❌ Critical Error: pure-python-adb library not found. Android integration will not work.")
-    print("   Please install it with: pip install pure-python-adb")
-
-"""
-Nebius AI Studio OpenAI-compatible API integration with Mistral model + Android Integration
-(Enhanced with ppadb for robust device connection)
-"""
-
-# Initialize OpenAI client with Nebius configuration
-def get_openai_client():
-    api_key = os.getenv("nebiusaistudioapikey")
-    if not api_key:
-        raise ValueError("NEBIUSAISTUDIOAPIKEY environment variable is not set. Please configure your API key.")
-    
-    return openai.OpenAI(
-        api_key=api_key,
-        base_url="https://api.studio.nebius.ai/v1/"
-    )
-
-# Initialize client (will be created when needed)
-client = None
-
-def respond(message, history, system_message, max_tokens, temperature, top_p, image_data=None):
-    global client
-    max_history = 20
-    history = history[-max_history:]
-    
-    if client is None:
-        try:
-            client = get_openai_client()
-        except ValueError as e:
-            yield history + [{"role": "assistant", "content": f"Configuration Error: {str(e)}"}]
-            return
-    
-    messages = [{"role": "system", "content": system_message}]
-    for msg in history:
-        if isinstance(msg, dict):
-            messages.append(msg)
-        elif isinstance(msg, (list, tuple)) and len(msg) == 2:
-            if msg[0]: messages.append({"role": "user", "content": msg[0]})
-            if msg[1]: messages.append({"role": "assistant", "content": msg[1]})
-
-    if image_data:
-        # The API expects the image first in the content list for multimodal input
-        content = [
-            {"type": "image_url", "image_url": {"url": image_data}},
-            {"type": "text", "text": message}
-        ]
-        messages.append({"role": "user", "content": content})
-    else:
-        messages.append({"role": "user", "content": message})
-
-
-    try:
-        response = client.chat.completions.create(
-            model="mistralai/Mistral-Small-3.1-24B-Instruct-2503", # Note: Check if this model supports vision
-            messages=messages,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            top_p=top_p,
-            stream=True,
-        )
-        partial_message = ""
-        # The user message is already in the history before calling respond
-        # So we just append the assistant's response
-        full_history = history + [{"role": "user", "content": message}]
-        for chunk in response:
-            if chunk.choices[0].delta.content is not None:
-                partial_message += chunk.choices[0].delta.content
-                yield full_history + [{"role": "assistant", "content": partial_message}]
-    except Exception as e:
-        yield history + [{"role": "user", "content": message}, {"role": "assistant", "content": f"Error: {str(e)}"}]
-
-# --- ENHANCED: Android Device Management with ppadb ---
-class AndroidDeviceManager:
-    def __init__(self):
-        self.adb_client = None
-        self.connected_devices_list = []
-        self.current_device_serial = None
-        self.current_ppadb_device = None # This will hold the ppadb device object
-        self.latest_screenshot = None
-        self.latest_screenshot_uri = None
-        self.automation_status = "Ready"
-
-        if ADB_AVAILABLE:
-            try:
-                # Connect to the ADB server on localhost
-                self.adb_client = AdbClient(host="127.0.0.1", port=5037)
-                print("✅ Successfully initialized ADB client.")
-            except Exception as e:
-                print(f"❌ Failed to initialize ADB client: {e}")
-                print("   Ensure the ADB server is running. You can start it with 'adb start-server'")
-                self.adb_client = None
-
-    def _create_mock_device_for_demo(self):
-        """Creates a simulated device for demonstration purposes."""
-        self.current_device_serial = "demo_device_cloud (Simulated)"
-        self.current_ppadb_device = None
-        try:
-            # Create a more realistic demo image
-            demo_img = Image.new('RGB', (1080, 2340), color='#f0f2f5')
-            from PIL import ImageDraw, ImageFont
-            draw = ImageDraw.Draw(demo_img)
-            # You might need to specify a font file path for ImageFont
-            try:
-                font_h1 = ImageFont.truetype("arial.ttf", 60)
-                font_p = ImageFont.truetype("arial.ttf", 45)
-            except IOError:
-                font_h1 = ImageFont.load_default()
-                font_p = ImageFont.load_default()
-
-            draw.rectangle([0, 0, 1080, 100], fill='#4a90e2') # Status bar
-            draw.text((40, 150), "Demo App", fill='black', font=font_h1)
-            draw.rectangle([100, 300, 980, 450], fill='#ffffff', outline='gray', width=3)
-            draw.text((400, 345), "Login", fill='black', font=font_p)
-            draw.rectangle([100, 500, 980, 650], fill='#ffffff', outline='gray', width=3)
-            draw.text((380, 545), "Sign Up", fill='black', font=font_p)
-
-            self.latest_screenshot = self._resize_image(demo_img)
-            self.latest_screenshot_uri = self._image_to_data_uri(self.latest_screenshot)
-            return True
-        except Exception as e:
-            print(f"Error creating demo device: {e}")
-            return False
-
-    def get_connected_devices(self):
-        """Gets device serial numbers from the ADB server."""
-        demo_option = "demo_device_cloud (Simulated)"
-        if not self.adb_client:
-            return [demo_option]
-        try:
-            # This ensures the server is running before listing devices
-            self.adb_client.version() 
-            devices = self.adb_client.devices()
-            self.connected_devices_list = [d.serial for d in devices]
-            all_options = self.connected_devices_list + [demo_option]
-            if not devices:
-                print("⚠️ No physical ADB devices found. Only demo device is available.")
-            return all_options
-        except Exception as e:
-            print(f"❌ ADB command failed: {e}. Is the ADB server running?")
-            print("   Try running 'adb start-server' in your terminal.")
-            return [demo_option]
-
-    def connect_device(self, device_serial):
-        """Connects to a device by its serial number."""
-        if not device_serial:
-            return False, "No device selected."
-        if "demo_device_cloud" in device_serial:
-            success = self._create_mock_device_for_demo()
-            return success, "Connected to Demo Device." if success else "Failed to create Demo Device."
-
-        if not self.adb_client:
-            return False, "ADB client not available."
-
-        try:
-            self.current_ppadb_device = self.adb_client.device(device_serial)
-            if self.current_ppadb_device:
-                self.current_device_serial = device_serial
-                print(f"✅ Successfully connected to {device_serial}")
-                return True, f"Connected to {device_serial}"
-            else:
-                self.current_device_serial = None
-                self.current_ppadb_device = None
-                print(f"❌ Failed to connect to device '{device_serial}'. It may have disconnected.")
-                return False, f"Failed to connect to {device_serial}."
-        except Exception as e:
-            print(f"❌ Device connection error for '{device_serial}': {e}")
-            self.current_device_serial = None
-            self.current_ppadb_device = None
-            return False, f"Error connecting to {device_serial}."
-    
-    def _resize_image(self, img, max_width=450):
-        """Resizes a PIL image to a max width, preserving aspect ratio."""
-        if img.width <= max_width:
-            return img
-        ratio = max_width / float(img.width)
-        height = int(float(img.height) * ratio)
-        return img.resize((max_width, height), Image.Resampling.LANCZOS)
-
-    def _image_to_data_uri(self, img):
-        """Converts a PIL image to a base64 data URI."""
-        buffered = io.BytesIO()
-        img.save(buffered, format="PNG")
-        return f"data:image/png;base64,{base64.b64encode(buffered.getvalue()).decode()}"
-
-    def capture_screenshot(self):
-        """Captures a screenshot from the connected device."""
-        if not self.current_device_serial: return None, "No device connected."
-        if "demo_device_cloud" in self.current_device_serial:
-            return self.latest_screenshot, "Captured from Demo Device."
-        if not self.current_ppadb_device: return None, "Device not properly connected."
-        
-        try:
-            # ppadb has a direct screencap method
-            result_bytes = self.current_ppadb_device.screencap()
-            img = Image.open(io.BytesIO(result_bytes))
-            
-            img_resized = self._resize_image(img)
-            self.latest_screenshot = img_resized
-            self.latest_screenshot_uri = self._image_to_data_uri(img_resized)
-            return self.latest_screenshot, "Screenshot captured successfully."
-        except Exception as e:
-            print(f"Screenshot error: {e}")
-            return self.latest_screenshot, f"Screenshot error: {e}"
-
-    def get_device_info(self):
-        if not self.current_device_serial: return "No device connected"
-        if "demo_device_cloud" in self.current_device_serial: return "Model: Demo Android Device\nAndroid: 14.0"
-        if not self.current_ppadb_device: return "ADB device not properly connected"
-        try:
-            model = self.current_ppadb_device.shell('getprop ro.product.model').strip()
-            version = self.current_ppadb_device.shell('getprop ro.build.version.release').strip()
-            # The 'wm size' command is simple with ppadb
-            resolution = self.current_ppadb_device.shell('wm size').strip().split(': ')[-1]
-            return f"Model: {model}\nAndroid: {version}\nResolution: {resolution}"
-        except Exception as e:
-            return f"Error getting device info: {e}"
-            
-    def device_action(self, action_func, *args):
-        """Wrapper to perform an action and then take a screenshot."""
-        if self.current_ppadb_device:
-            action_func(*args)
-            time.sleep(1.0) # Give UI time to update before screenshot
-            img, _ = self.capture_screenshot()
-            return img
-        return self.latest_screenshot
-    
-    def send_tap(self, x, y):
-        self.current_ppadb_device.shell(f'input tap {int(x)} {int(y)}')
-
-    def send_text(self, text):
-        # ppadb's input_text is more reliable than shell command
-        self.current_ppadb_device.input_text(text)
-        
-    def press_key(self, key):
-        key_map = {'back': 4, 'home': 3, 'menu': 82, 'enter': 66}
-        self.current_ppadb_device.shell(f'input keyevent {key_map.get(key, 0)}')
-
-# Initialize device manager
-device_manager = AndroidDeviceManager()
-
-# Custom CSS for UI styling
-custom_css = """
-.gradio-container { font-family: 'Segoe UI', sans-serif; }
-.device-info { background: #f8f9fa; border-radius: 8px; padding: 10px; margin: 5px 0; border-left: 4px solid #4CAF50; }
-h1 { text-align: center; font-size: 2.5em; margin-bottom: 10px; }
-"""
-
-# System prompts for different AI roles
-system_prompts = {
-    "Android App Reviewer": "You are an expert QA Engineer and UX/UI analyst. Your goal is to review the Android application screen provided. Analyze the layout, text, and elements. Provide a concise, actionable report in markdown format. Identify potential bugs, suggest UI/UX improvements, and comment on overall usability. Be specific in your feedback (e.g., 'The 'Login' button contrast is too low,' not 'button looks bad').",
-    "UX/UI Analyzer": "You are a world-class UX/UI designer. Your task is to analyze the provided mobile app screen. Focus on design principles, user flow, accessibility, and visual hierarchy. Provide constructive feedback with clear justifications.",
-    "General Assistant": "You are a helpful AI assistant. Provide accurate and thoughtful responses to the user's query about the provided image or text.",
-}
-
-# --- MAIN GRADIO UI ---
-def create_android_interface():
-    with gr.Blocks(css=custom_css, title="Android App Review Agent") as demo:
-        gr.HTML("<h1>🤖 Android App Review Agent</h1>")
-        
-        with gr.Row():
-            # Left Column: Chat Interface
-            with gr.Column(scale=2):
-                gr.HTML("<h3>💬 AI Assistant</h3>")
-                chatbot = gr.Chatbot(height=500, show_label=False, show_copy_button=True, type="messages")
-                with gr.Row():
-                    msg = gr.Textbox(placeholder="Ask about the screen, or give a command...", show_label=False, scale=4)
-                    submit_btn = gr.Button("Send 🚀", variant="primary", scale=1)
-                with gr.Row():
-                    clear_btn = gr.Button("🗑️ Clear Chat", variant="secondary")
-                    include_screen = gr.Checkbox(label="Include screen in AI context", value=True)
-            
-            # Middle Column: Android Device
-            with gr.Column(scale=2):
-                gr.HTML("<h3>📱 Android Device</h3>")
-                with gr.Row():
-                    refresh_btn = gr.Button("🔄 Refresh Devices", variant="secondary", scale=2)
-                    device_dropdown = gr.Dropdown(choices=[], label="Connected Devices", scale=3, interactive=True)
-                connect_btn = gr.Button("🔌 Connect to Selected Device", variant="primary")
-                device_status = gr.HTML("<div class='device-info'><p><strong>Status:</strong> No device connected</p></div>")
-                device_screen = gr.Image(height=600, show_label=False, interactive=False)
-                with gr.Row():
-                    back_btn = gr.Button("⬅️ Back")
-                    home_btn = gr.Button("🏠 Home")
-                    screenshot_btn = gr.Button("📸 Capture Screen", variant="primary")
-            
-            # Right Column: Controls
-            with gr.Column(scale=1):
-                gr.HTML("<h3>⚙️ Controls</h3>")
-                with gr.Accordion("🎭 AI Role", open=True):
-                    prompt_preset = gr.Dropdown(choices=list(system_prompts.keys()), value="Android App Reviewer", label="Preset")
-                    system_message = gr.Textbox(value=system_prompts["Android App Reviewer"], label="Custom System Prompt", lines=5)
-                with gr.Accordion("🎛️ AI Settings", open=False):
-                    max_tokens = gr.Slider(1, 4096, 2048, label="Max Tokens")
-                    temperature = gr.Slider(0.0, 1.0, 0.5, label="Temperature")
-                    top_p = gr.Slider(0.0, 1.0, 0.95, label="Top-p")
-                with gr.Accordion("👆 Device Interaction", open=True):
-                    gr.Markdown("**Tap Coordinates (x, y)**")
-                    with gr.Row():
-                        tap_x = gr.Number(label="X", value=300)
-                        tap_y = gr.Number(label="Y", value=500)
-                    tap_btn = gr.Button("👆 Tap", variant="primary")
-                    text_input = gr.Textbox(label="Text to Send to Device")
-                    send_text_btn = gr.Button("⌨️ Send Text", variant="primary")
-
-        # --- EVENT HANDLERS ---
-        def refresh_devices_ui():
-            devices = device_manager.get_connected_devices()
-            current_val = device_manager.current_device_serial
-            # If current device is still connected, keep it selected
-            if current_val and current_val in devices:
-                return gr.Dropdown(choices=devices, value=current_val)
-            # Otherwise, select the first available device or none
-            return gr.Dropdown(choices=devices, value=devices[0] if devices else None)
-
-        def connect_device_ui(device_id):
-            success, message = device_manager.connect_device(device_id)
-            if success:
-                info = device_manager.get_device_info().replace('\n', '<br>')
-                status_html = f"<div class='device-info' style='border-left-color: #28a745;'><strong>Status:</strong> ✅ {message}<br>{info}</div>"
-                screenshot, _ = device_manager.capture_screenshot()
-                return status_html, screenshot
-            else:
-                return f"<div class='device-info' style='border-left-color: #dc3545;'><strong>Status:</strong> ❌ {message} Check console for details.</div>", None
-
-        def chat_with_optional_screen(message, history, system_msg, max_tok, temp, top_p_val, use_screen):
-            image_data = None
-            if use_screen and device_manager.current_device_serial and device_manager.latest_screenshot_uri:
-                image_data = device_manager.latest_screenshot_uri
-            
-            # Clear the input box immediately for better UX
-            yield history + [{"role": "user", "content": message}], ""
-            
-            # Start streaming the response
-            final_response = None
-            for response in respond(message, history, system_msg, max_tok, temp, top_p_val, image_data):
-                final_response = response
-                yield final_response, ""
-        
-        def update_screen_and_status(img, status_msg):
-            return img, gr.update(value=f"<div class='device-info'>{status_msg}</div>") if status_msg else gr.update()
-        
-        # Connect UI components to functions
-        demo.load(refresh_devices_ui, outputs=device_dropdown)
-        refresh_btn.click(refresh_devices_ui, outputs=device_dropdown)
-        connect_btn.click(connect_device_ui, inputs=device_dropdown, outputs=[device_status, device_screen])
-        
-        prompt_preset.change(lambda preset: system_prompts.get(preset, ""), inputs=prompt_preset, outputs=system_message)
-        
-        # Chat submission logic
-        msg.submit(chat_with_optional_screen, [msg, chatbot, system_message, max_tokens, temperature, top_p, include_screen], [chatbot, msg])
-        submit_btn.click(chat_with_optional_screen, [msg, chatbot, system_message, max_tokens, temperature, top_p, include_screen], [chatbot, msg])
-        clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg])
-        
-        # Device action logic
-        screenshot_btn.click(device_manager.capture_screenshot, outputs=[device_screen, device_status])
-        back_btn.click(lambda: device_manager.device_action(device_manager.press_key, "back"), outputs=[device_screen])
-        home_btn.click(lambda: device_manager.device_action(device_manager.press_key, "home"), outputs=[device_screen])
-        tap_btn.click(lambda x, y: device_manager.device_action(device_manager.send_tap, x, y), [tap_x, tap_y], device_screen)
-        send_text_btn.click(lambda text: device_manager.device_action(device_manager.send_text, text), [text_input], device_screen).then(lambda: "", outputs=text_input)
-
-
-    return demo
-
-if __name__ == "__main__":
-    print("===== Application Startup =====")
-    if not os.getenv("nebiusaistudioapikey"):
-        print("⚠️ Warning: NEBIUSAISTUDIOAPIKEY environment variable not set! API calls will fail.")
-    else:
-        print("✅ Nebius AI Studio API key found.")
-    
-    if ADB_AVAILABLE:
-        print("✅ pure-python-adb library is available.")
-    
-    app = create_android_interface()
-    
-    print("\n🚀 Starting Gradio interface...")
+import gradio as gr
+import openai
+import os
+import io
+import base64
+import asyncio
+from PIL import Image, ImageDraw, ImageFont
+
+# --- ADB Library Integration ---
+try:
+    from ppadb.client import Client as AdbClient
+    ADB_AVAILABLE = True
+except ImportError:
+    ADB_AVAILABLE = False
+    print("❌ Critical Error: pure-python-adb library not found. Android integration will not work.")
+    print("   Please install it with: pip install pure-python-adb")
+
+"""
+Nebius AI Studio OpenAI-compatible API integration with Mistral model + Android Integration
+(Enhanced with asyncio for robust async operation in Gradio and improved error handling for HF Spaces)
+"""
+
+# --- OpenAI Client Initialization ---
+def get_openai_client():
+    api_key = os.getenv("nebiusaistudioapikey") # Standard practice is all-caps for env vars
+    if not api_key:
+        raise ValueError("NEBIUSAISTUDIOAPIKEY environment variable not set in your Space secrets.")
+    return openai.OpenAI(api_key=api_key, base_url="https://api.studio.nebius.ai/v1/")
+
+client = None
+
+# --- AI Chat Function ---
+async def respond(message, history, system_message, max_tokens, temperature, top_p, image_data=None):
+    global client
+    max_history = 20
+    history = history[-max_history:]
+    
+    if client is None:
+        try:
+            client = get_openai_client()
+        except ValueError as e:
+            yield history + [{"role": "assistant", "content": f"Configuration Error: {str(e)}"}]
+            return
+    
+    messages = [{"role": "system", "content": system_message}]
+    for role, content in history:
+        messages.append({"role": role, "content": content})
+
+    user_content = [{"type": "text", "text": message}]
+    if image_data:
+        # Vision models prefer the image first
+        user_content.insert(0, {"type": "image_url", "image_url": {"url": image_data}})
+    
+    messages.append({"role": "user", "content": user_content})
+
+    try:
+        response = await asyncio.to_thread(
+            client.chat.completions.create,
+            model="mistralai/Mistral-Small-3.1-24B-Instruct-2503", # NOTE: Ensure this model supports vision
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            stream=True,
+        )
+        
+        # The user message is already in the history before calling respond
+        # We just need to append the assistant's response part by part
+        partial_message = ""
+        for chunk in response:
+            if chunk.choices[0].delta.content is not None:
+                partial_message += chunk.choices[0].delta.content
+                yield history + [("user", message), ("assistant", partial_message)]
+
+    except Exception as e:
+        yield history + [("user", message), ("assistant", f"API Error: {str(e)}")]
+
+
+# --- Android Device Management (Refactored for Async) ---
+class AndroidDeviceManager:
+    def __init__(self):
+        self.adb_client = None
+        self.adb_server_running = False
+        self.current_device_serial = None
+        self.current_ppadb_device = None
+        self.latest_screenshot_uri = None
+
+        if ADB_AVAILABLE:
+            try:
+                # Check for ADB server connection on initialization
+                self.adb_client = AdbClient(host="127.0.0.1", port=5037)
+                self.adb_client.version() # This will raise an exception if server isn't running
+                self.adb_server_running = True
+                print("✅ ADB server found and client initialized.")
+            except Exception as e:
+                self.adb_client = None
+                self.adb_server_running = False
+                print(f"⚠️ ADB server not found on localhost:5037. Reason: {e}")
+                print("   Will operate in 'Simulated Device' mode only. This is expected on Hugging Face Spaces.")
+
+    def _create_mock_device_for_demo(self):
+        """Creates and sets up the simulated device."""
+        self.current_device_serial = "demo_device_cloud (Simulated)"
+        self.current_ppadb_device = None
+        try:
+            demo_img = Image.new('RGB', (1080, 2340), color='#f0f2f5')
+            draw = ImageDraw.Draw(demo_img)
+            # Use a default font to avoid file not found errors on servers
+            font_h1 = ImageFont.load_default(size=60)
+            font_p = ImageFont.load_default(size=45)
+            draw.rectangle([0, 0, 1080, 100], fill='#4a90e2')
+            draw.text((40, 150), "Demo App", fill='black', font=font_h1)
+            draw.rectangle([100, 300, 980, 450], fill='#ffffff', outline='gray', width=3)
+            draw.text((400, 345), "Login", fill='black', font=font_p)
+            self.latest_screenshot_uri = self._image_to_data_uri(demo_img)
+            return True, "Connected to Simulated Device."
+        except Exception as e:
+            print(f"Error creating demo device: {e}")
+            return False, "Failed to create Simulated Device."
+
+    def get_connected_devices(self):
+        """BLOCKING: Gets device serial numbers. Must be run in a thread."""
+        demo_option = "demo_device_cloud (Simulated)"
+        if not self.adb_server_running:
+            return [demo_option]
+        try:
+            devices = self.adb_client.devices()
+            return [d.serial for d in devices] + [demo_option]
+        except Exception as e:
+            print(f"❌ ADB command failed: {e}. Falling back to demo mode.")
+            self.adb_server_running = False # Mark as not running to avoid retries
+            return [demo_option]
+
+    def connect_device(self, device_serial):
+        """BLOCKING: Connects to a device. Must be run in a thread."""
+        if not device_serial:
+            return False, "No device selected."
+        if "demo_device_cloud" in device_serial:
+            return self._create_mock_device_for_demo()
+        
+        if not self.adb_server_running:
+            return False, "ADB Server not available. Cannot connect to physical devices."
+
+        try:
+            device = self.adb_client.device(device_serial)
+            if device:
+                self.current_ppadb_device = device
+                self.current_device_serial = device_serial
+                print(f"✅ Successfully connected to {device_serial}")
+                return True, f"Connected to {device_serial}"
+            else:
+                raise RuntimeError("Device not found by client.")
+        except Exception as e:
+            self.current_device_serial = None
+            self.current_ppadb_device = None
+            return False, f"Failed to connect to {device_serial}: {e}"
+    
+    def _image_to_data_uri(self, img, max_width=800):
+        """Resizes a PIL image and converts to a base64 data URI."""
+        if img.width > max_width:
+            ratio = max_width / float(img.width)
+            height = int(float(img.height) * ratio)
+            img = img.resize((max_width, height), Image.Resampling.LANCZOS)
+        
+        buffered = io.BytesIO()
+        img.save(buffered, format="PNG")
+        return f"data:image/png;base64,{base64.b64encode(buffered.getvalue()).decode()}"
+
+    def capture_screenshot(self):
+        """BLOCKING: Captures a screenshot. Must be run in a thread."""
+        if not self.current_device_serial: return None, "No device connected."
+        if "demo_device_cloud" in self.current_device_serial:
+            # Re-create demo image to simulate a fresh capture
+            self._create_mock_device_for_demo()
+            return self.latest_screenshot_uri, "Captured from Simulated Device."
+        if not self.current_ppadb_device: return None, "Device not properly connected."
+        
+        try:
+            result_bytes = self.current_ppadb_device.screencap()
+            img = Image.open(io.BytesIO(result_bytes))
+            self.latest_screenshot_uri = self._image_to_data_uri(img)
+            return self.latest_screenshot_uri, "Screenshot captured successfully."
+        except Exception as e:
+            return None, f"Screenshot error: {e}"
+
+    def get_device_info(self):
+        """BLOCKING: Gets device info. Must be run in a thread."""
+        if not self.current_device_serial: return "No device connected"
+        if "demo_device_cloud" in self.current_device_serial: return "Model: Simulated Android\nOS: 14.0"
+        if not self.current_ppadb_device: return "ADB device object not found."
+        try:
+            model = self.current_ppadb_device.shell('getprop ro.product.model').strip()
+            version = self.current_ppadb_device.shell('getprop ro.build.version.release').strip()
+            return f"Model: {model}\nOS: {version}"
+        except Exception as e:
+            return f"Error getting device info: {e}"
+
+    def perform_action(self, action_name, *args):
+        """BLOCKING: Generic action executor. Must be run in a thread."""
+        if not self.current_ppadb_device:
+            return self.latest_screenshot_uri, "Action failed: No real device connected."
+        try:
+            action_map = {
+                'tap': lambda x, y: self.current_ppadb_device.shell(f'input tap {int(x)} {int(y)}'),
+                'text': lambda text: self.current_ppadb_device.input_text(text),
+                'key': lambda key: self.current_ppadb_device.shell(f'input keyevent {{"back": 4, "home": 3}.get(key, 0)}')
+            }
+            action_map[action_name](*args)
+            # Give UI time to update before screenshot
+            asyncio.run(asyncio.sleep(1.0)) # Use asyncio.sleep in sync context
+            return self.capture_screenshot()
+        except Exception as e:
+            return self.latest_screenshot_uri, f"Action '{action_name}' failed: {e}"
+
+# Initialize device manager
+device_manager = AndroidDeviceManager()
+
+# --- MAIN GRADIO UI ---
+def create_android_interface():
+    with gr.Blocks(css=".gradio-container{font-family:'Segoe UI',sans-serif}", title="Android App Review Agent") as demo:
+        gr.HTML("<h1>🤖 Android App Review Agent</h1>")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(height=550, label="AI Assistant", show_copy_button=True)
+                with gr.Row():
+                    msg = gr.Textbox(placeholder="Ask about the screen...", show_label=False, scale=4)
+                    submit_btn = gr.Button("Send", variant="primary", scale=1)
+                with gr.Row():
+                    clear_btn = gr.Button("🗑️ Clear Chat", variant="secondary")
+                    include_screen = gr.Checkbox(label="Include screen in prompt", value=True)
+            
+            with gr.Column(scale=2):
+                gr.HTML("<h3>📱 Android Device</h3>")
+                with gr.Row():
+                    refresh_btn = gr.Button("🔄 Refresh Devices", scale=1)
+                    device_dropdown = gr.Dropdown(label="Connected Devices", scale=2, interactive=True)
+                connect_btn = gr.Button("🔌 Connect", variant="primary")
+                device_status = gr.HTML(f"<div style='padding:10px;border-radius:5px;background-color:#f0f0f0;'>Status: App Loaded</div>")
+                device_screen = gr.Image(label="Device Screen", height=600, interactive=False)
+                with gr.Row():
+                    back_btn = gr.Button("⬅️ Back")
+                    home_btn = gr.Button("🏠 Home")
+                    screenshot_btn = gr.Button("📸 Capture", variant="primary")
+            
+            with gr.Column(scale=1):
+                gr.HTML("<h3>⚙️ Controls</h3>")
+                system_prompts = {
+                    "Android App Reviewer": "You are an expert QA Engineer. Analyze the provided app screen. Report potential bugs, UI/UX improvements, and usability issues in a concise markdown report.",
+                    "General Assistant": "You are a helpful AI assistant. Provide accurate responses to the user's query.",
+                }
+                system_message = gr.Textbox(value=system_prompts["Android App Reviewer"], label="System Prompt", lines=8)
+                gr.Accordion("🎛️ AI Settings", open=False)
+                max_tokens = gr.Slider(1, 4096, 2048, label="Max Tokens")
+                temperature = gr.Slider(0.0, 1.0, 0.5, label="Temperature")
+                top_p = gr.Slider(0.0, 1.0, 0.95, label="Top-p")
+                with gr.Accordion("👆 Device Interaction", open=True):
+                    with gr.Row():
+                        tap_x = gr.Number(label="X", value=540)
+                        tap_y = gr.Number(label="Y", value=1170)
+                    tap_btn = gr.Button("👆 Tap")
+                    text_input = gr.Textbox(label="Text to Send")
+                    send_text_btn = gr.Button("⌨️ Send Text")
+
+        # --- ASYNC EVENT HANDLERS ---
+        async def async_refresh_devices():
+            devices = await asyncio.to_thread(device_manager.get_connected_devices)
+            current_val = device_manager.current_device_serial
+            new_value = current_val if current_val in devices else devices[0] if devices else None
+            return gr.Dropdown(choices=devices, value=new_value)
+
+        async def async_connect_device(device_id):
+            if not device_id:
+                return "<div>Status: Please select a device.</div>", None
+            
+            success, message = await asyncio.to_thread(device_manager.connect_device, device_id)
+            color = "#28a745" if success else "#dc3545"
+            status_html = f"<div style='padding:10px;border-radius:5px;background-color:{color};color:white;'><strong>Status:</strong> {message}</div>"
+            
+            if success:
+                info = await asyncio.to_thread(device_manager.get_device_info)
+                status_html += f"<div style='padding:10px;margin-top:5px;border-radius:5px;background-color:#f0f0f0;'>{info.replace(chr(10), '<br>')}</div>"
+                screen_uri, _ = await asyncio.to_thread(device_manager.capture_screenshot)
+                return status_html, screen_uri
+            else:
+                return status_html, None
+
+        async def async_chat_stream(message, history, sys_msg, max_tok, temp, top_p_val, use_screen):
+            if not message:
+                return history, ""
+            
+            # Immediately update UI
+            yield history + [("user", message)], ""
+
+            image_data = device_manager.latest_screenshot_uri if use_screen else None
+            
+            # Stream the response
+            async for response in respond(message, history, sys_msg, max_tok, temp, top_p_val, image_data):
+                yield response, ""
+
+        async def async_capture_and_update():
+            screen_uri, status_msg = await asyncio.to_thread(device_manager.capture_screenshot)
+            color = "#28a745" if "success" in status_msg.lower() else "#ffc107"
+            status_html = f"<div style='padding:10px;border-radius:5px;background-color:{color};color:white;'>{status_msg}</div>"
+            return screen_uri, status_html
+        
+        async def async_device_action(action, *params):
+            screen_uri, status_msg = await asyncio.to_thread(device_manager.perform_action, action, *params)
+            status_html = f"<div style='padding:10px;border-radius:5px;background-color:#007bff;color:white;'>{status_msg}</div>"
+            return screen_uri, status_html
+
+        # --- UI Event Wiring ---
+        async def initial_load():
+            """Runs when the app first loads."""
+            dropdown_update = await async_refresh_devices()
+            # If no ADB server, automatically connect to the demo device for a better UX
+            if not device_manager.adb_server_running:
+                status_update, screen_update = await async_connect_device("demo_device_cloud (Simulated)")
+                return dropdown_update, status_update, screen_update
+            return dropdown_update, gr.HTML(), gr.Image()
+        
+        demo.load(initial_load, outputs=[device_dropdown, device_status, device_screen])
+        
+        refresh_btn.click(async_refresh_devices, outputs=device_dropdown)
+        connect_btn.click(async_connect_device, inputs=device_dropdown, outputs=[device_status, device_screen])
+        
+        msg.submit(async_chat_stream, [msg, chatbot, system_message, max_tokens, temperature, top_p, include_screen], [chatbot, msg])
+        submit_btn.click(async_chat_stream, [msg, chatbot, system_message, max_tokens, temperature, top_p, include_screen], [chatbot, msg])
+        clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg])
+        
+        screenshot_btn.click(async_capture_and_update, outputs=[device_screen, device_status])
+        back_btn.click(lambda: async_device_action("key", "back"), outputs=[device_screen, device_status])
+        home_btn.click(lambda: async_device_action("key", "home"), outputs=[device_screen, device_status])
+        tap_btn.click(lambda x, y: async_device_action("tap", x, y), [tap_x, tap_y], [device_screen, device_status])
+        send_text_btn.click(lambda t: async_device_action("text", t), [text_input], [device_screen, device_status]).then(lambda: "", outputs=text_input)
+
+    return demo
+
+if __name__ == "__main__":
+    print("===== Application Startup =====")
+    if not os.getenv("nebiusaistudioapikey"):
+        print("⚠️ Warning: NEBIUSAISTUDIOAPIKEY environment variable not set! API calls will fail.")
+    else:
+        print("✅ Nebius AI Studio API key found.")
+    
+    app = create_android_interface()
+    
+    print("\n🚀 Starting Gradio interface...")
     app.launch()