🎙️ Processus Technique Sous-Jacent : L'Interaction Vocale Jarvis en Arrière-Plan

Date d'élaboration : 28 Octobre 2026 — 09:35 AST (Guadeloupe UTC-4)
Auteur : Antigravity (Architecte Systèmes Mobiles, Audio & IA Autonome)
Destinataire : Raphaël
Périmètre : Moteur Android Natif (JarvisVoiceService), Passerelle WebSocket Temps Réel, Orchestrateur FastAPI (server.py), Double-Boucle Cognitive (Gemini Live & Agent Autonome Antigravity).
Statut : Livrable de Référence Opérationnel


1. Vue d'Ensemble & Schéma de Flux Bout-en-Bout

L'interaction vocale continue avec Jarvis lorsque le smartphone est en arrière-plan (écran verrouillé dans la poche ou autre application au premier plan) repose sur une chaîne cinématique en 6 étapes synchronisées.

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                        CHAÎNE CINÉMATIQUE VOCALE EN ARRIÈRE-PLAN                       │
└────────────────────────────────────────────────────────────────────────────────────────┘

 [ 1. CAPTURE & OS ]         [ 2. TRANSPORT RÉSEAU ]      [ 3. INGESTION & SÉCURITÉ ]
  Smartphone Android          Tunnel Chiffré WSS           Serveur PC (server.py)
  ┌───────────────────┐       ┌────────────────────┐       ┌────────────────────────┐
  │ Micro / Bluetooth │       │ OkHttp WebSocket   │       │ FastAPI Async Loop     │
  │ AudioRecord 16kHz ├──────►│ Trames PCM 20ms    ├──────►│ Biométrie Vocale       │
  │ ForegroundService │       │ KeepAlive Heartbeat│       │ VAD & Détection Coupure│
  │ WakeLock & Wi-Fi  │       └────────────────────┘       └───────────┬────────────┘
  └───────────────────┘                                                │
                                                                       ▼
 [ 6. RESTITUTION ]          [ 5. SYNTHÈSE AUDIO ]        [ 4. DOUBLE-BOUCLE COGNITIVE ]
  Android AudioTrack          Streaming TTS / Tokens       Gemini Live + Antigravity
  ┌───────────────────┐       ┌────────────────────┐       ┌────────────────────────┐
  │ AudioTrack 24kHz  │       │ Stream Audio PCM   │       │ Boucle A : Gemini Live │
  │ Écouteurs / VoIP  │◄──────┤ Edge-TTS / Gemini  │◄──────┤ (Dialogue < 350 ms)    │
  │ Blackout OLED     │       │ Chunking dynamique │       │ Boucle B : Antigravity │
  │ Notification OS   │       └────────────────────┘       │ (Exécution autonome)   │
  └───────────────────┘                                    └────────────────────────┘

2. Décorticage Technique des 6 Étapes du Processus

🔹 Étape 1 : Acquisition Acoustique & Maintien OS sous Android (JarvisVoiceService)

Le principal défi sur mobile réside dans les mécanismes agressifs d'économie d'énergie d'Android 14, 15 et 16 (Doze Mode, App Standby, Throttling Chromium).

  1. Service de Premier Plan Persistant (Foreground Service) :
    JarvisVoiceService est déclaré avec les types stricts foregroundServiceType="microphone|connectedDevice|mediaPlayback". Une notification permanente avec PendingIntent interdit au système de tuer le processus pour libérer de la mémoire RAM.
  2. Verrous Matériels (Locks Système) :
  3. PARTIAL_WAKE_LOCK : Empêche le processeur (SoC) de passer en sommeil profond (Deep Sleep), garantissant la cadence du thread de capture audio.
  4. WIFI_MODE_FULL_LOW_LATENCY : Force la puce Wi-Fi à désactiver ses cycles d'économie pour éliminer le jitter réseau.
  5. Capture Audio Native Basse Latence :
    La capture ne passe pas par l'AudioContext de la WebView (susceptible d'être gelé), mais par l'objet natif AudioRecord en 16 000 Hz, 16-bit Mono PCM. Des processeurs matériels (AcousticEchoCanceler et NoiseSuppressor) sont injectés directement sur l'AudioSession ID pour filtrer l'écho et les bruits extérieurs.

🔹 Étape 2 : Canal de Transport Résilient WebSocket (JarvisWebSocketClient)

  1. Contournement du Timer Throttling :
    Dans une WebView classique en arrière-plan, Android force les timers JavaScript (setInterval) de 3s à plus de 60s, causant la rupture du lien WebSocket. Jarvis résout ce blocage via un client WebSocket natif OkHttp en Kotlin, insensible aux restrictions de la WebView.
  2. Découpage en Paquets Ultra-Légers (Chunking) :
    Le flux audio brut est découpé en trames de 20 ms à 40 ms (soit des blocs de 640 à 1280 octets). Cela garantit un streaming fluide sans saturer les files d'attente réseau.
  3. Persistance de Session (sessionId) :
    Chaque paquet transporte l'identifiant unique de la session. Lors d'un basculement d'antenne (4G vers Wi-Fi), le protocole d'auto-reconnexion rapide raccroche le flux sans interruption perceptible ni réinitialisation de politesse.

🔹 Étape 3 : Réception, Filtrage Biométrique & Détection d'Activité Vocale (VAD)

Dès que les trames atteignent server.py sur le serveur local :

  1. Porte Biométrique Spectrale (spectral_biometric_gate.py / voice_id.py) :
    Le signal entrant est analysé pour vérifier l'empreinte spectrale de Raphaël (formants, fréquence fondamentale F0). Si une tierce personne parle à côté ou si la radio joue, le signal est atténué ou ignoré pour éviter les faux déclenchements.
  2. Détecteur d'Activité Vocale (VAD) & Seuil Dynamique :
    Un algorithme d'énergie RMS et d'analyse fréquentielle détecte avec précision le début et la fin de phrase de Raphaël.
  3. Gestion Immédiate de l'Interruption (Barge-In) :
    Si Raphaël prend la parole alors que Jarvis est en train d'émettre un son, le serveur détecte instantanément la voix montante et émet un signal de coupure (STOP_AUDIO). Le smartphone interrompt le haut-parleur en moins de 50 ms pour écouter l'utilisateur.

🔹 Étape 4 : Le Cœur Cognitif à Double-Boucle (Live vs. Agentic)

L'interaction vocale en arrière-plan orchestre deux cerveaux en parallèle :

                               ┌───────────────────────────────────────────────┐
                               │           ROUTEUR COGNITIF SERVER.PY          │
                               └───────────────────────┬───────────────────────┘
                                                       │
                           ┌───────────────────────────┴───────────────────────────┐
                           ▼                                                       ▼
               ┌───────────────────────┐                               ┌───────────────────────┐
               │       BOUCLE A        │                               │       BOUCLE B        │
               │   GEMINI LIVE API     │                               │  AGENT D'EXÉCUTION    │
               │ (Conversation Directe)│                               │ (Missions Autonomes)  │
               ├───────────────────────┤                               ├───────────────────────┤
               │ • Échange bidirectionnel│                             │ • Déclenché sur ordre │
               │   en flux continu.    │                               │   complexe ou plan.   │
               │ • Tokens audio natifs.│                               │ • Lecture de SOPs.    │
               │ • Latence < 350 ms.   │                               │ • Écriture d'artefacts│
               │ • "Oui Raphaël..."    │                               │ • Livrables concrets. │
               └───────────────────────┘                               └───────────────────────┘
  1. Boucle A (Gemini Multimodal Live) :
    Assure la fluidité conversationnelle immédiate. Le flux PCM est injecté via le SDK Google GenAI Live directement en tokens audio. L'assistant répond avec une inflexion naturelle, gère les interruptions et accuse réception instantanément.
  2. Boucle B (Agent Autonome Antigravity / Jarvis Mission Engine) :
    Dès que l'intention exprimée nécessite un travail technique réel (audit, analyse de faisabilité, recherche de produits, codage, génération de documents), le système crée une mission dans jarvis_missions.db et passe la main à l'agent autonome d'arrière-plan. C'est exactement ce processus qui s'exécute lors de la commande actuelle.

🔹 Étape 5 : Synthèse & Flux Audio Descendant (TTS)

  1. Double Source Audio :
  2. En mode conversationnel direct : Réception directe des tokens audio synthétisés par le moteur Live (24 kHz PCM).
  3. En mode compte-rendu de mission : Les 2 à 4 phrases de synthèse orale sont synthétisées via Edge-TTS / ElevenLabs à haut débit.
  4. Streaming par Chunks :
    L'audio n'est pas envoyé en un seul bloc lourd, mais streamé en paquets continus dès les premières syllabes calculées, garantissant une latence de premier son inférieure à 400 ms.

🔹 Étape 6 : Restitution Matérielle sur le Smartphone

  1. Lecture Native AudioTrack :
    JarvisVoiceService reçoit les paquets binaires et les injecte directement dans un AudioTrack configuré en mode communication (STREAM_VOICE_CALL ou USAGE_VOICE_COMMUNICATION).
  2. Routage Bluetooth Automatique :
    Le flux audio est dirigé en priorité vers les oreillettes Bluetooth (profil SCO/HFP ou A2DP faible latence), le kit mains-libres de la voiture, ou le haut-parleur si aucun périphérique externe n'est connecté.
  3. Maintien en Écran Noir (Blackout OLED) :
    L'interaction se déroule sans allumer la dalle du téléphone, préservant la discrétion et l'autonomie de la batterie.

3. Matrice Technique des Paramètres Clés du Flux Vocal

Composant Rôle Technique Spécification / Valeur Tolérance Panne / Sécurité
Échantillonnage Entrant Capture Micro 16 000 Hz, 16-bit Mono (PCM) Filtrage AEC + NS matériel
Latence Trame Réseau Découpage paquets 20 ms à 40 ms (640 à 1280 octets) Buffer circulaire anti-jitter
Transport Socket Connexion duplex WebSocket natif OkHttp (WSS) Pings natifs 3s, réarmement auto
Filtrage Biométrique Authentification Raphaël Analyse spectrale F0 / Formants Rejet automatique bruits ambiants
Gestion Barge-In Interruption en cours Détection locale / ordre STOP serveur Coupure audio < 50 ms
Échantillonnage Sortant Restitution Audio 24 000 Hz, 16-bit PCM streaming Routage SCO / VoIP prioritaire
Supervision Système Résilience OS Foreground Service + Partial WakeLock Auto-restart sur crash (Backoff)

4. Bilan Opérationnel

Ce dispositif hybride garantit que l'interaction vocale reste continue, réactive et indestructible :
- Le smartphone se comporte comme un terminal audio léger et durci, protégé contre le gel imposé par Android aux applications en arrière-plan.
- Le serveur local assure l'intelligence computationnelle lourde et le relais vers les grands modèles multimodaux sans consommer la batterie du téléphone.
- La séparation entre dialogue temps réel (Boucle A) et exécution autonome (Boucle B) permet à Raphaël de piloter des opérations informatiques complexes par la voix, les mains totalement libres.