Upload blob

.gitignore

@@ -1 +1,5 @@
 .venv
+playground/
+uploaded_files/
+assets/
+__pycache__/

app.py

@@ -1,14 +1,20 @@
+from contextlib import asynccontextmanager
+
 import flet as ft
-import tempfile
+import flet.fastapi as flet_fastapi
 import sys
-import base64
 import logging
+import os
+from fastapi import FastAPI, File, UploadFile, HTTPException, Form
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from collections import OrderedDict
+import base64
 
 # Set up basic logging configuration
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-def main(page: ft.Page):
+async def main(page: ft.Page):
     page.title = "Simple Audio Recorder"
 
     # Log the operating system platform
@@ -26,8 +32,6 @@ def main(page: ft.Page):
 
     page.update()
 
-    temp_recording_file = None
-
     def start_recording(e):
         record_button.disabled = True
         stop_button.disabled = True
@@ -36,33 +40,33 @@ def main(page: ft.Page):
         recording_status.value = "Preparing to record..."
         page.update()
 
-        nonlocal temp_recording_file
-        temp_recording_file = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-        logger.info(f"Starting recording to {temp_recording_file.name}")
-        
-        audio_recorder.start_recording(temp_recording_file.name, wait_timeout=2)
+        logger.info("Starting recording")
+        audio_recorder.start_recording("")
         
         # The actual recording start will be handled in update_recording_status
 
-    def stop_recording(e):
+    async def stop_recording_flet(e):
         record_button.disabled = False
         stop_button.disabled = True
         play_button.disabled = False
 
         page.update()
         nonlocal audio_player
-        result_uri = audio_recorder.stop_recording()
+        result_uri = await audio_recorder.stop_recording_async()
         logger.info("Result URI: %s", result_uri)
-        
+
+        logger.info("="*100)
+        logger.info(f"Session ID: {page.session_id}")
+
         # Create audio_player after recording is complete
-        if temp_recording_file:
-            with open(temp_recording_file.name, "rb") as audio_file:
-                audio_base64 = base64.b64encode(audio_file.read()).decode('utf-8')
-            audio_data_uri = f"data:audio/wav;base64,{audio_base64}"
-            audio_player = ft.Audio(src=result_uri)
-            page.overlay.append(audio_player)
+        audio_player = ft.Audio(src=result_uri)
+        page.overlay.append(audio_player)
         
         page.update()
+        logger.info(page.controls)
+        
+        # Use launch_url to load the upload page in the hidden iframe
+        page.launch_url(f"/upload-blob/?blob_uri={result_uri}&session_id={page.session_id}", web_window_name="hidden-iframe")
 
     def play_recording(e):
         if audio_player:
@@ -78,7 +82,7 @@ def main(page: ft.Page):
         page.update()
 
     record_button = ft.ElevatedButton("Start Recording", on_click=start_recording)
-    stop_button = ft.ElevatedButton("Stop Recording", on_click=stop_recording, disabled=True)
+    stop_button = ft.ElevatedButton("Stop Recording", on_click=stop_recording_flet, disabled=True)
     play_button = ft.ElevatedButton("Play Recording", on_click=play_recording, disabled=True)
 
     def handle_list_devices(e):
@@ -106,4 +110,144 @@ def main(page: ft.Page):
 
     page.update()
 
-app = ft.app(target=main, export_asgi_app=True)
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await flet_fastapi.app_manager.start()
+    yield
+    await flet_fastapi.app_manager.shutdown()
+
+
+app = FastAPI(lifespan=lifespan)
+
+app.mount("/flet-app", flet_fastapi.app(main))
+
+
+# Directory where files will be saved (current working directory)
+UPLOAD_DIRECTORY = os.path.join(os.getcwd(), "uploaded_files")
+
+@app.get("/", response_class=HTMLResponse)
+async def serve_main_page():
+    html_content = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Audio Recorder App</title>
+        <style>
+            body, html {
+                margin: 0;
+                padding: 0;
+                height: 100%;
+                overflow: hidden;
+            }
+            #flet-app-frame {
+                width: 100%;
+                height: 100%;
+                border: none;
+                position: absolute;
+                top: 0;
+                left: 0;
+            }
+        </style>
+    </head>
+    <body>
+        <iframe id="flet-app-frame" src="/flet-app"></iframe>
+        <iframe name="hidden-iframe" style="display:none;"></iframe>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+@app.get("/upload-blob/", response_class=HTMLResponse)
+async def serve_upload_page(blob_uri: str, session_id: str):
+    logger.info(f"Blob URI: {blob_uri}")
+    logger.info(f"Session ID: {session_id}")
+    html_content = f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Upload Blob</title>
+    </head>
+    <body>
+        <script>
+            async function sendBlobToServer(blobUri, sessionId) {{
+                try {{
+                    const blob = await fetch(blobUri).then(r => r.blob());
+                    const base64data = await new Promise((resolve) => {{
+                        const reader = new FileReader();
+                        reader.onloadend = () => resolve(reader.result.split(',')[1]);
+                        reader.readAsDataURL(blob);
+                    }});
+
+                    const response = await fetch('/store-audio/', {{
+                        method: 'POST',
+                        headers: {{
+                            'Content-Type': 'application/json',
+                        }},
+                        body: JSON.stringify({{
+                            session_id: sessionId,
+                            audio_data: base64data
+                        }})
+                    }});
+
+                    const result = await response.json();
+                    console.log(result);
+                }} catch (error) {{
+                    console.error("Error uploading blob:", error);
+                }}
+            }}
+
+            sendBlobToServer("{blob_uri}", "{session_id}");
+        </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+
+@app.post("/upload-blob/")
+async def upload_blob(file: UploadFile = File(...), session_id: str = Form(...)):
+    logger.info(f"Uploading file: {file.filename}")
+    logger.info(f"Session ID: {session_id}")
+    
+    # Create a directory for the session if it doesn't exist
+    session_directory = os.path.join(UPLOAD_DIRECTORY, session_id)
+    os.makedirs(session_directory, exist_ok=True)
+    
+    # Save the file in the session directory
+    file_location = os.path.join(session_directory, file.filename)
+    with open(file_location, "wb") as f:
+        f.write(await file.read())
+    
+    return JSONResponse(content={"info": f"file '{file.filename}' saved at '{file_location}'"})
+
+# Use OrderedDict instead of a regular dictionary
+audio_storage = OrderedDict()
+
+@app.post("/store-audio/")
+async def store_audio(data: dict):
+    session_id = data.get('session_id')
+    audio_data = data.get('audio_data')
+
+    if not session_id or not audio_data:
+        raise HTTPException(status_code=400, detail="Missing session_id or audio_data")
+
+    # Store the base64 audio data in memory
+    audio_storage[session_id] = audio_data
+
+    print(f"Audio data stored for session {session_id}")
+
+    return JSONResponse(content={"info": f"Audio data stored for session {session_id}: {audio_data[:100]}"})
+
+@app.get("/get-audio/{session_id}")
+async def get_audio(session_id: str):
+    if session_id not in audio_storage:
+        raise HTTPException(status_code=404, detail="Audio not found")
+    
+    # Pop the audio data from the storage
+    audio_data = audio_storage.pop(session_id)
+    
+    return JSONResponse(content={"audio_data": audio_data})