WebRTC Microphone Defense Strategies 🔗 ↑ TOC

class MicrophoneManager {
  constructor() {
    this.primaryStream = null;
    this.fallbackStream = null;
    this.currentDeviceId = null;
    this.isLocked = false;
  }

  async acquireMicrophone(deviceId) {
    try {
      // Try to get exclusive access
      this.primaryStream = await navigator.mediaDevices.getUserMedia({
        audio: {
          deviceId: { exact: deviceId },
          echoCancellation: true,
          noiseSuppression: true,
          autoGainControl: true
        }
      });

      // Keep a fallback stream on default device
      this.fallbackStream = await navigator.mediaDevices.getUserMedia({
        audio: true // Default device
      });

      this.currentDeviceId = deviceId;
      this.isLocked = true;
      this.startMonitoring();

      return this.primaryStream;
    } catch (error) {
      console.error('Mic acquisition failed:', error);
      return this.handleAcquisitionFailure();
    }
  }

  startMonitoring() {
    // Monitor for device state changes
    this.primaryStream.getAudioTracks()[0].addEventListener('ended', () => {
      console.warn('Mic track ended - likely taken by another app');
      this.handleMicStolen();
    });

    // Check track state periodically
    this.monitorInterval = setInterval(() => {
      const track = this.primaryStream.getAudioTracks()[0];
      if (track.readyState !== 'live' || !track.enabled) {
        this.handleMicStolen();
      }
    }, 1000);
  }

  async handleMicStolen() {
    console.log('Microphone stolen by another app, attempting recovery...');

    // Don't thrash - wait before retrying
    await this.delay(2000);

    // Try to reacquire
    for (let attempt = 0; attempt < 3; attempt++) {
      try {
        const newStream = await navigator.mediaDevices.getUserMedia({
          audio: { deviceId: this.currentDeviceId }
        });

        await this.smoothTransition(newStream);
        return;
      } catch (error) {
        console.log(`Reacquisition attempt ${attempt + 1} failed`);
        await this.delay(Math.pow(2, attempt) * 1000); // Exponential backoff
      }
    }

    // Fall back to any available device
    await this.fallbackToAvailable();
  }

  async smoothTransition(newStream) {
    const audioContext = new AudioContext();
    const oldSource = audioContext.createMediaStreamSource(this.primaryStream);
    const newSource = audioContext.createMediaStreamSource(newStream);
    const destination = audioContext.createMediaStreamDestination();

    // Crossfade between streams
    const oldGain = audioContext.createGain();
    const newGain = audioContext.createGain();

    oldSource.connect(oldGain).connect(destination);
    newSource.connect(newGain).connect(destination);

    oldGain.gain.value = 1;
    newGain.gain.value = 0;

    // Smooth transition over 200ms
    const now = audioContext.currentTime;
    oldGain.gain.linearRampToValueAtTime(0, now + 0.2);
    newGain.gain.linearRampToValueAtTime(1, now + 0.2);

    // Update WebRTC without disruption
    const sender = this.pc.getSenders().find(s => s.track?.kind === 'audio');
    await sender.replaceTrack(destination.stream.getAudioTracks()[0]);

    // Cleanup old stream
    setTimeout(() => {
      this.primaryStream.getTracks().forEach(t => t.stop());
      this.primaryStream = newStream;
    }, 300);
  }

  async fallbackToAvailable() {
    const devices = await navigator.mediaDevices.enumerateDevices();
    const audioInputs = devices.filter(d => d.kind === 'audioinput');

    for (const device of audioInputs) {
      try {
        const stream = await navigator.mediaDevices.getUserMedia({
          audio: { deviceId: device.deviceId }
        });

        console.log(`Fell back to device: ${device.label}`);
        await this.smoothTransition(stream);
        return;
      } catch (error) {
        continue;
      }
    }

    console.error('No available microphone found');
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  cleanup() {
    if (this.monitorInterval) {
      clearInterval(this.monitorInterval);
    }

    [this.primaryStream, this.fallbackStream].forEach(stream => {
      if (stream) {
        stream.getTracks().forEach(track => track.stop());
      }
    });
  }
}

class DeviceSwitchManager {
  constructor() {
    this.state = 'idle';
    this.pendingSwitch = null;
    this.switchHistory = [];
    this.SWITCH_COOLDOWN = 5000; // 5 seconds
    this.RAPID_SWITCH_THRESHOLD = 3;
  }

  async requestSwitch(newDeviceId, reason) {
    // Record switch request
    this.switchHistory.push({
      timestamp: Date.now(),
      deviceId: newDeviceId,
      reason: reason
    });

    // Detect rapid switching pattern
    if (this.isRapidSwitching()) {
      console.warn('Rapid switching detected - likely external app conflict');
      return this.handleConflict();
    }

    // State machine prevents concurrent switches
    switch (this.state) {
      case 'idle':
        return this.performSwitch(newDeviceId);

      case 'switching':
        // Queue this switch
        this.pendingSwitch = { deviceId: newDeviceId, reason };
        return false;

      case 'cooldown':
        console.log('In cooldown period, queueing switch');
        this.pendingSwitch = { deviceId: newDeviceId, reason };
        return false;

      case 'defensive':
        console.log('In defensive mode - ignoring switch request');
        return false;
    }
  }

  async performSwitch(deviceId) {
    this.state = 'switching';

    try {
      const stream = await navigator.mediaDevices.getUserMedia({
        audio: { deviceId: { exact: deviceId } }
      });

      // Perform the actual switch in your WebRTC code
      await this.applySwitch(stream);

      this.state = 'cooldown';
      setTimeout(() => {
        this.state = 'idle';
        this.processPendingSwitch();
      }, this.SWITCH_COOLDOWN);

      return true;
    } catch (error) {
      console.error('Switch failed:', error);
      this.state = 'idle';
      return false;
    }
  }

  isRapidSwitching() {
    const recentSwitches = this.switchHistory.filter(
      s => Date.now() - s.timestamp < 5000
    );

    // Multiple switches to different devices = external app conflict
    const uniqueDevices = new Set(recentSwitches.map(s => s.deviceId));
    return uniqueDevices.size >= this.RAPID_SWITCH_THRESHOLD;
  }

  async handleConflict() {
    console.log('External app conflict detected - entering defensive mode');

    // 1. Stop accepting device change events temporarily
    this.state = 'defensive';

    // 2. Find a stable device
    const devices = await navigator.mediaDevices.enumerateDevices();
    const audioDevices = devices.filter(d => d.kind === 'audioinput');

    // 3. Test each device for stability
    for (const device of audioDevices) {
      if (await this.testDeviceStability(device.deviceId)) {
        await this.performSwitch(device.deviceId);
        break;
      }
    }

    // 4. Exit defensive mode after delay
    setTimeout(() => {
      this.state = 'idle';
      console.log('Exiting defensive mode');
    }, 30000); // 30 seconds
  }

  async testDeviceStability(deviceId) {
    try {
      const stream = await navigator.mediaDevices.getUserMedia({
        audio: { deviceId: { exact: deviceId } }
      });

      // Wait to see if it gets taken
      await new Promise(resolve => setTimeout(resolve, 1000));

      const track = stream.getAudioTracks()[0];
      const isStable = track.readyState === 'live' && track.enabled;

      stream.getTracks().forEach(t => t.stop());
      return isStable;
    } catch {
      return false;
    }
  }

  processPendingSwitch() {
    if (this.pendingSwitch && this.state === 'idle') {
      const { deviceId, reason } = this.pendingSwitch;
      this.pendingSwitch = null;
      this.requestSwitch(deviceId, reason);
    }
  }

  getSwitchHistory() {
    return this.switchHistory;
  }

  clearHistory() {
    this.switchHistory = [];
  }
}

class ExternalAppDetector {
  constructor() {
    this.knownPatterns = {
      teams: {
        switchInterval: [500, 1500], // Teams switches every 0.5-1.5s
        deviceNamePattern: /Microsoft Teams/,
        behavior: 'periodic',
        action: 'wait' // Teams usually gives up after a few seconds
      },
      zoom: {
        switchInterval: [100, 300], // Zoom is aggressive
        deviceNamePattern: /Zoom/,
        behavior: 'aggressive',
        action: 'compete' // Need to fight back
      },
      slack: {
        switchInterval: [2000, 4000], // Slack huddles
        deviceNamePattern: /Slack/,
        behavior: 'polite',
        action: 'coordinate'
      },
      generic: {
        switchInterval: [0, 5000],
        deviceNamePattern: /.*/,
        behavior: 'unknown',
        action: 'adapt'
      }
    };

    this.detectionLog = [];
  }

  detectApp(switchHistory) {
    // Analyze switching patterns
    const intervals = [];
    for (let i = 1; i < switchHistory.length; i++) {
      intervals.push(switchHistory[i].timestamp - switchHistory[i-1].timestamp);
    }

    if (intervals.length === 0) {
      return { app: 'none', action: 'none' };
    }

    const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
    const intervalVariance = this.calculateVariance(intervals);

    // Check device names for app signatures
    const deviceNames = switchHistory.map(s => s.deviceName || '').join(' ');

    // Match against known patterns
    for (const [app, pattern] of Object.entries(this.knownPatterns)) {
      const intervalMatch = avgInterval >= pattern.switchInterval[0] && 
                           avgInterval <= pattern.switchInterval[1];
      const nameMatch = pattern.deviceNamePattern.test(deviceNames);

      if (intervalMatch || nameMatch) {
        const detection = {
          app,
          action: pattern.action,
          behavior: pattern.behavior,
          confidence: (intervalMatch && nameMatch) ? 'high' : 'medium',
          avgInterval,
          intervalVariance
        };

        this.detectionLog.push({
          timestamp: Date.now(),
          detection
        });

        return detection;
      }
    }

    return { app: 'unknown', action: 'adapt', behavior: 'unknown' };
  }

  async executeStrategy(detection, micManager) {
    console.log(`Detected ${detection.app} - executing ${detection.action} strategy`);

    switch (detection.action) {
      case 'wait':
        await this.waitStrategy(detection);
        break;

      case 'compete':
        await this.competeStrategy(detection, micManager);
        break;

      case 'coordinate':
        await this.coordinateStrategy(detection, micManager);
        break;

      case 'adapt':
        await this.adaptiveStrategy(detection, micManager);
        break;
    }
  }

  async waitStrategy(detection) {
    // Teams usually gives up - just wait
    console.log(`${detection.app} detected - waiting for it to settle`);

    // Monitor but don't act for a period
    const waitTime = detection.app === 'teams' ? 5000 : 3000;
    await new Promise(resolve => setTimeout(resolve, waitTime));
  }

  async competeStrategy(detection, micManager) {
    // Zoom is aggressive - need to fight back
    console.log(`${detection.app} detected - competing for device`);

    // Rapidly reacquire with random delays to break lockstep
    for (let i = 0; i < 5; i++) {
      await micManager.acquireMicrophone(micManager.currentDeviceId);

      // Random delay to avoid synchronization
      const delay = 100 + Math.random() * 400;
      await new Promise(resolve => setTimeout(resolve, delay));

      // Check if we won
      const track = micManager.primaryStream?.getAudioTracks()[0];
      if (track?.readyState === 'live') {
        console.log('Successfully competed for device');
        break;
      }
    }
  }

  async coordinateStrategy(detection, micManager) {
    // Try to coordinate with polite apps
    console.log(`${detection.app} detected - attempting coordination`);

    // Release and reacquire with specific timing
    micManager.primaryStream?.getTracks().forEach(t => t.stop());
    await new Promise(resolve => setTimeout(resolve, 1000));

    await micManager.acquireMicrophone(micManager.currentDeviceId);
  }

  async adaptiveStrategy(detection, micManager) {
    // Unknown app - be smart
    console.log('Unknown app detected - using adaptive strategy');

    // Try different approaches
    const strategies = [
      () => this.waitStrategy(detection),
      () => this.coordinateStrategy(detection, micManager),
      () => this.competeStrategy(detection, micManager)
    ];

    for (const strategy of strategies) {
      await strategy();

      // Check if successful
      const track = micManager.primaryStream?.getAudioTracks()[0];
      if (track?.readyState === 'live') {
        break;
      }
    }
  }

  calculateVariance(values) {
    const mean = values.reduce((a, b) => a + b, 0) / values.length;
    const squaredDiffs = values.map(v => Math.pow(v - mean, 2));
    return Math.sqrt(squaredDiffs.reduce((a, b) => a + b, 0) / values.length);
  }

  getDetectionLog() {
    return this.detectionLog;
  }
}

class DefensiveWebRTCManager {
  constructor() {
    this.pc = null;
    this.micManager = new MicrophoneManager();
    this.switchManager = new DeviceSwitchManager();
    this.appDetector = new ExternalAppDetector();
    this.lastPacketsSent = 0;
    this.connectionHealth = {
      packetsStuck: 0,
      recoveryAttempts: 0,
      lastRecovery: null
    };
  }

  async initializeCall(deviceId) {
    try {
      // 1. Acquire mic defensively
      const stream = await this.micManager.acquireMicrophone(deviceId);

      // 2. Create PC with defensive configuration
      this.pc = new RTCPeerConnection({
        iceServers: [...this.getIceServers()],
        bundlePolicy: 'max-bundle',
        rtcpMuxPolicy: 'require',
        iceCandidatePoolSize: 10
      });

      // 3. Add track with immediate monitoring
      const audioTrack = stream.getAudioTracks()[0];
      const sender = this.pc.addTrack(audioTrack, stream);

      // 4. Set up all monitors
      this.setupMonitoring(sender, audioTrack);

      // 5. Handle device changes
      this.setupDeviceChangeHandling();

      // 6. Start keepalive
      this.startKeepalive();

      return { pc: this.pc, stream };
    } catch (error) {
      console.error('Failed to initialize call:', error);
      throw error;
    }
  }

  setupMonitoring(sender, track) {
    // Track health monitoring
    track.addEventListener('ended', async () => {
      console.warn('Track ended - attempting recovery');
      await this.handleTrackEnded(sender);
    });

    track.addEventListener('mute', () => {
      console.warn('Track muted - possible external interference');
      this.handleTrackMuted(track);
    });

    // Stats monitoring for quality issues
    this.statsInterval = setInterval(async () => {
      if (this.pc.connectionState !== 'connected') return;

      const stats = await sender.getStats();
      stats.forEach(report => {
        if (report.type === 'outbound-rtp' && report.kind === 'audio') {
          this.analyzeAudioStats(report, sender);
        }
      });
    }, 1000);

    // Connection state monitoring
    this.pc.addEventListener('connectionstatechange', () => {
      console.log(`Connection state: ${this.pc.connectionState}`);
      if (this.pc.connectionState === 'failed') {
        this.handleConnectionFailure();
      }
    });
  }

  analyzeAudioStats(report, sender) {
    // Check if packets are being sent
    if (report.packetsSent === this.lastPacketsSent) {
      this.connectionHealth.packetsStuck++;

      if (this.connectionHealth.packetsStuck >= 3) {
        console.warn('No packets sent for 3 seconds - attempting recovery');
        this.handleStuckMicrophone(sender);
      }
    } else {
      this.connectionHealth.packetsStuck = 0;
    }

    this.lastPacketsSent = report.packetsSent;

    // Monitor packet loss
    if (report.packetsLost > 0) {
      const lossRate = report.packetsLost / (report.packetsSent || 1);
      if (lossRate > 0.05) { // 5% loss
        console.warn(`High packet loss detected: ${(lossRate * 100).toFixed(2)}%`);
      }
    }
  }

  async handleTrackEnded(sender) {
    // Don't panic - check if it's temporary
    await new Promise(resolve => setTimeout(resolve, 500));

    if (this.pc.connectionState === 'connected') {
      try {
        // Try to get the preferred device first
        let newStream = await navigator.mediaDevices.getUserMedia({
          audio: { deviceId: this.micManager.currentDeviceId }
        });

        // If that fails, use fallback
        if (!newStream.getAudioTracks()[0]) {
          newStream = this.micManager.fallbackStream.clone();
        }

        const newTrack = newStream.getAudioTracks()[0];
        await sender.replaceTrack(newTrack);

        console.log('Successfully replaced ended track');
      } catch (error) {
        console.error('Failed to replace track:', error);
        // Use fallback stream
        const fallbackTrack = this.micManager.fallbackStream.getAudioTracks()[0];
        await sender.replaceTrack(fallbackTrack);
      }
    }
  }

  async handleStuckMicrophone(sender) {
    // Prevent too frequent recovery attempts
    const now = Date.now();
    if (this.connectionHealth.lastRecovery && 
        now - this.connectionHealth.lastRecovery < 5000) {
      return;
    }

    this.connectionHealth.lastRecovery = now;
    this.connectionHealth.recoveryAttempts++;

    const currentTrack = sender.track;

    // Strategy 1: Toggle track
    currentTrack.enabled = false;
    await new Promise(resolve => setTimeout(resolve, 100));
    currentTrack.enabled = true;

    // Wait to see if it works
    await new Promise(resolve => setTimeout(resolve, 1000));

    // Strategy 2: Replace track if still stuck
    if (this.connectionHealth.packetsStuck >= 3) {
      console.log('Track toggle failed, replacing track');

      try {
        const newStream = await navigator.mediaDevices.getUserMedia({ 
          audio: { deviceId: this.micManager.currentDeviceId } 
        });
        await sender.replaceTrack(newStream.getAudioTracks()[0]);

        // Clean up old track
        currentTrack.stop();
      } catch (error) {
        console.error('Track replacement failed:', error);
        // Use fallback
        const fallbackTrack = this.micManager.fallbackStream.getAudioTracks()[0].clone();
        await sender.replaceTrack(fallbackTrack);
      }
    }
  }

  setupDeviceChangeHandling() {
    // Monitor for device changes
    navigator.mediaDevices.addEventListener('devicechange', async () => {
      const devices = await navigator.mediaDevices.enumerateDevices();
      const audioInputs = devices.filter(d => d.kind === 'audioinput');

      // Check if our current device still exists
      const currentExists = audioInputs.some(
        d => d.deviceId === this.micManager.currentDeviceId
      );

      if (!currentExists) {
        console.warn('Current device disconnected');
        await this.handleDeviceDisconnected();
      } else {
        // Device change might be from external app
        this.handleExternalDeviceChange(audioInputs);
      }
    });
  }

  async handleExternalDeviceChange(audioInputs) {
    // Add to switch history for pattern detection
    const switchRequest = {
      timestamp: Date.now(),
      deviceId: audioInputs[0]?.deviceId,
      deviceName: audioInputs[0]?.label,
      reason: 'external'
    };

    this.switchManager.switchHistory.push(switchRequest);

    // Detect if this is from an external app
    const detection = this.appDetector.detectApp(
      this.switchManager.switchHistory
    );

    if (detection.app !== 'none') {
      await this.appDetector.executeStrategy(detection, this.micManager);
    }
  }

  startKeepalive() {
    // Send periodic data to keep connection alive
    this.keepaliveInterval = setInterval(() => {
      if (this.pc.connectionState === 'connected') {
        // Option 1: Send RTCP parameters update
        const sender = this.pc.getSenders().find(s => s.track?.kind === 'audio');
        if (sender && sender.transport) {
          const params = sender.getParameters();
          sender.setParameters(params).catch(() => {});
        }

        // Option 2: Send data channel message if available
        const dataChannel = this.pc.getDataChannels?.()[0];
        if (dataChannel?.readyState === 'open') {
          dataChannel.send(JSON.stringify({ type: 'keepalive' }));
        }
      }
    }, 20000); // Every 20 seconds
  }

  async cleanup() {
    // Stop all intervals
    [this.statsInterval, this.keepaliveInterval].forEach(interval => {
      if (interval) clearInterval(interval);
    });

    // Clean up managers
    this.micManager.cleanup();

    // Close peer connection
    if (this.pc) {
      this.pc.close();
    }
  }

  getIceServers() {
    // Include multiple STUN/TURN servers for redundancy
    return [
      { urls: 'stun:stun.l.google.com:19302' },
      { urls: 'stun:stun1.l.google.com:19302' },
      {
        urls: 'turn:your-turn-server.com:443',
        username: 'username',
        credential: 'password'
      }
    ];
  }
}

const DEFENSIVE_CONFIG = {
  // Device switching
  switchCooldown: 5000,
  maxSwitchesPerMinute: 3,
  switchDebounceMs: 2000,

  // Conflict detection
  rapidSwitchThreshold: 3,
  conflictDetectionWindow: 5000,
  defensiveModeDuration: 30000,

  // Recovery
  maxRecoveryAttempts: 3,
  recoveryBackoff: [1000, 2000, 4000],

  // Monitoring
  trackHealthCheckInterval: 1000,
  statsMonitorInterval: 2000,
  keepaliveInterval: 20000,

  // Audio constraints
  audioConstraints: {
    echoCancellation: true,
    noiseSuppression: true,
    autoGainControl: true,
    sampleRate: 48000,
    channelCount: 1
  }
};

// Initialize the defensive WebRTC manager
const webrtcManager = new DefensiveWebRTCManager();

// Start a call
async function startCall() {
  try {
    const preferredDevice = await getPreferredAudioDevice();
    const { pc, stream } = await webrtcManager.initializeCall(preferredDevice);

    // Set up signaling
    pc.addEventListener('negotiationneeded', async () => {
      const offer = await pc.createOffer();
      await pc.setLocalDescription(offer);
      sendOfferToRemote(offer);
    });

    // Handle remote answer
    socket.on('answer', async (answer) => {
      await pc.setRemoteDescription(answer);
    });

    // Handle ICE candidates
    pc.addEventListener('icecandidate', (event) => {
      if (event.candidate) {
        sendCandidateToRemote(event.candidate);
      }
    });

  } catch (error) {
    console.error('Failed to start call:', error);
    showErrorToUser('Could not access microphone');
  }
}

// Clean up when done
async function endCall() {
  await webrtcManager.cleanup();
}

const micManager = new MicrophoneManager();
const stream = await micManager.acquireMicrophone(deviceId);
pc.addTrack(stream.getAudioTracks()[0], stream);

const switchManager = new DeviceSwitchManager();

navigator.mediaDevices.addEventListener('devicechange', async () => {
  const devices = await navigator.mediaDevices.enumerateDevices();
  const audioInput = devices.find(d => d.kind === 'audioinput');

  if (audioInput) {
    switchManager.requestSwitch(audioInput.deviceId, 'devicechange event');
  }
});

const appDetector = new ExternalAppDetector();

// When switches are detected
const detection = appDetector.detectApp(switchManager.getSwitchHistory());
if (detection.app !== 'none') {
  await appDetector.executeStrategy(detection, micManager);
}

const manager = new DefensiveWebRTCManager();
const { pc, stream } = await manager.initializeCall(deviceId);
// Your WebRTC code continues as normal

// Test script to simulate Teams-like behavior
async function simulateTeamsInterference() {
  const devices = await navigator.mediaDevices.enumerateDevices();
  const audioInputs = devices.filter(d => d.kind === 'audioinput');

  // Switch every 1 second like Teams
  setInterval(async () => {
    const randomDevice = audioInputs[Math.floor(Math.random() * audioInputs.length)];
    try {
      const stream = await navigator.mediaDevices.getUserMedia({
        audio: { deviceId: randomDevice.deviceId }
      });
      // Simulate Teams holding the device
      setTimeout(() => {
        stream.getTracks().forEach(t => t.stop());
      }, 800);
    } catch (e) {
      console.log('Device busy - good, our defense is working!');
    }
  }, 1000);
}

// Add metrics collection
class DefenseMetrics {
  constructor() {
    this.metrics = {
      switchAttempts: 0,
      switchesBlocked: 0,
      recoveryAttempts: 0,
      successfulRecoveries: 0,
      detectedApps: new Map(),
      connectionUptime: 0
    };
  }

  logSwitchAttempt(blocked) {
    this.metrics.switchAttempts++;
    if (blocked) this.metrics.switchesBlocked++;
  }

  logRecovery(success) {
    this.metrics.recoveryAttempts++;
    if (success) this.metrics.successfulRecoveries++;
  }

  getReport() {
    return {
      ...this.metrics,
      blockRate: this.metrics.switchesBlocked / this.metrics.switchAttempts,
      recoveryRate: this.metrics.successfulRecoveries / this.metrics.recoveryAttempts
    };
  }
}