Adds basic Bluetooth support to AppRTCMobile

webrtc/examples/androidapp/src/org/appspot/apprtc/AppRTCAudioManager.java

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.appspot.apprtc;
 
 import org.appspot.apprtc.util.AppRTCUtils;
 
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.content.pm.PackageManager;

[magjed_webrtc, 2016/12/07 11:09:43]

Revert this change, it's not sorted now.

[henrika_webrtc, 2016/12/07 12:55:41]

I might be slow but what's wrong? Can't see that actually.

 import android.content.SharedPreferences;
-import android.content.pm.PackageManager;
 import android.media.AudioManager;
 import android.preference.PreferenceManager;
 import android.util.Log;
 
+import org.webrtc.ThreadUtils;
+
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
-/**
- * AppRTCAudioManager manages all audio related parts of the AppRTC demo.
- */
+// AppRTCAudioManager manages all audio related parts of the AppRTC demo.

[magjed_webrtc, 2016/12/07 11:09:43]

Revert these comment changes.

[henrika_webrtc, 2016/12/07 12:55:41]

Done.

 public class AppRTCAudioManager {
   private static final String TAG = "AppRTCAudioManager";
   private static final String SPEAKERPHONE_AUTO = "auto";
   private static final String SPEAKERPHONE_TRUE = "true";
   private static final String SPEAKERPHONE_FALSE = "false";
 
-  /**
-   * AudioDevice is the names of possible audio devices that we currently
-   * support.
-   */
-  // TODO(henrika): add support for BLUETOOTH as well.
-  public enum AudioDevice {
-    SPEAKER_PHONE,
-    WIRED_HEADSET,
-    EARPIECE,
+  // AudioDevice is the names of possible audio devices that we currently

[magjed_webrtc, 2016/12/07 11:09:43]

Revert this comment change as well. Same for the rest of the CL.

[henrika_webrtc, 2016/12/07 12:55:42]

Done.

+  // support.
+  public enum AudioDevice { SPEAKER_PHONE, WIRED_HEADSET, EARPIECE, BLUETOOTH, NONE }
+
+  // AudioManager state.
+  public enum AudioManagerState {
+    UNINITIALIZED,
+    PREINITIALIZED,
+    RUNNING,
   }
 
+  // Selected audio device change event.
+  public static interface AudioManagerEvents {
+    // Callback fired once audio device is changed or list of available audio devices changed.
+    void onAudioDeviceChanged(
+        AudioDevice selectedAudioDevice, Set<AudioDevice> availableAudioDevices);
+  }
+
+  private final ThreadUtils.ThreadChecker threadChecker = new ThreadUtils.ThreadChecker();
+
   private final Context apprtcContext;
-  private final Runnable onStateChangeListener;
-  private boolean initialized = false;
   private AudioManager audioManager;
+
+  private AudioManagerEvents audioManagerEvents;
+  private AudioManagerState amState;
   private int savedAudioMode = AudioManager.MODE_INVALID;
   private boolean savedIsSpeakerPhoneOn = false;
   private boolean savedIsMicrophoneMute = false;
+  private boolean hasWiredHeadset = false;
 
-  private final AudioDevice defaultAudioDevice;
+  // Default audio device; speaker phone for video calls or earpiece for audio
+  // only calls.
+  private AudioDevice defaultAudioDevice;
+
+  // Contains the currently selected audio device.
+  private AudioDevice selectedAudioDevice;
+
+  // Contains user selected audio device.
+  // TODO(henrika): always set to AudioDevice.NONE today. Add support for
+  // explicit selection based on choice by userSelectedAudioDevice.
+  private AudioDevice userSelectedAudioDevice;
 
   // Contains speakerphone setting: auto, true or false
   private final String useSpeakerphone;
 
-  // Proximity sensor object. It measures the proximity of an object in cm

[magjed_webrtc, 2016/12/07 11:09:43]

I'm sorry to have to give more annoying comments, but you can remove the
proximity code in a separate CL in order to reduce the diff? It's really hard
for me review the code when the diff is this large.

[henrika_webrtc, 2016/12/07 12:55:41]

Will fix of course ;-)

-  // relative to the view screen of a device and can therefore be used to
-  // assist device switching (close to ear <=> use headset earpiece if
-  // available, far from ear <=> use speaker phone).
-  private AppRTCProximitySensor proximitySensor = null;
-
-  // Contains the currently selected audio device.
-  private AudioDevice selectedAudioDevice;
+  private final AppRTCBluetoothManager bluetoothManager;
 
   // Contains a list of available audio devices. A Set collection is used to
   // avoid duplicate elements.
   private final Set<AudioDevice> audioDevices = new HashSet<AudioDevice>();
 
   // Broadcast receiver for wired headset intent broadcasts.
   private BroadcastReceiver wiredHeadsetReceiver;
 
   // Callback method for changes in audio focus.
   private AudioManager.OnAudioFocusChangeListener audioFocusChangeListener;
 
-  // This method is called when the proximity sensor reports a state change,
-  // e.g. from "NEAR to FAR" or from "FAR to NEAR".
-  private void onProximitySensorChangedState() {
-    if (!useSpeakerphone.equals(SPEAKERPHONE_AUTO)) {
-      return;
+  // Receiver which handles changes in wired headset availability.
+  private class WiredHeadsetReceiver extends BroadcastReceiver {
+    private static final int STATE_UNPLUGGED = 0;
+    private static final int STATE_PLUGGED = 1;
+    private static final int HAS_NO_MIC = 0;
+    private static final int HAS_MIC = 1;
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      int state = intent.getIntExtra("state", STATE_UNPLUGGED);
+      int microphone = intent.getIntExtra("microphone", HAS_NO_MIC);
+      String name = intent.getStringExtra("name");
+      Log.d(TAG, "WiredHeadsetReceiver.onReceive" + AppRTCUtils.getThreadInfo() + ": "
+              + "a=" + intent.getAction() + ", s="
+              + (state == STATE_UNPLUGGED ? "unplugged" : "plugged") + ", m="
+              + (microphone == HAS_MIC ? "mic" : "no mic") + ", n=" + name + ", sb="
+              + isInitialStickyBroadcast());
+      hasWiredHeadset = (state == STATE_PLUGGED);
+      updateAudioDeviceState();
     }
+  };
 
-    // The proximity sensor should only be activated when there are exactly two
-    // available audio devices.
-    if (audioDevices.size() == 2 && audioDevices.contains(AppRTCAudioManager.AudioDevice.EARPIECE)
-        && audioDevices.contains(AppRTCAudioManager.AudioDevice.SPEAKER_PHONE)) {
-      if (proximitySensor.sensorReportsNearState()) {
-        // Sensor reports that a "handset is being held up to a person's ear",
-        // or "something is covering the light sensor".
-        setAudioDevice(AppRTCAudioManager.AudioDevice.EARPIECE);
-      } else {
-        // Sensor reports that a "handset is removed from a person's ear", or
-        // "the light sensor is no longer covered".
-        setAudioDevice(AppRTCAudioManager.AudioDevice.SPEAKER_PHONE);
-      }
-    }
+  // Construction.
+  static AppRTCAudioManager create(Context context) {
+    return new AppRTCAudioManager(context);
   }
 
-  /** Construction */
-  static AppRTCAudioManager create(Context context, Runnable deviceStateChangeListener) {
-    return new AppRTCAudioManager(context, deviceStateChangeListener);
-  }
-
-  private AppRTCAudioManager(Context context, Runnable deviceStateChangeListener) {
+  private AppRTCAudioManager(Context context) {
+    Log.d(TAG, "ctor");
     apprtcContext = context;
-    onStateChangeListener = deviceStateChangeListener;
     audioManager = ((AudioManager) context.getSystemService(Context.AUDIO_SERVICE));
+    bluetoothManager = AppRTCBluetoothManager.create(context, this);
+    wiredHeadsetReceiver = new WiredHeadsetReceiver();
+    amState = AudioManagerState.UNINITIALIZED;
 
     SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
     useSpeakerphone = sharedPreferences.getString(context.getString(R.string.pref_speakerphone_key),
         context.getString(R.string.pref_speakerphone_default));
-
+    Log.d(TAG, "useSpeakerphone: " + useSpeakerphone);
     if (useSpeakerphone.equals(SPEAKERPHONE_FALSE)) {
       defaultAudioDevice = AudioDevice.EARPIECE;
     } else {
       defaultAudioDevice = AudioDevice.SPEAKER_PHONE;
     }
-
-    // Create and initialize the proximity sensor.
-    // Tablet devices (e.g. Nexus 7) does not support proximity sensors.
-    // Note that, the sensor will not be active until start() has been called.
-    proximitySensor = AppRTCProximitySensor.create(context, new Runnable() {
-      // This method will be called each time a state change is detected.
-      // Example: user holds his hand over the device (closer than ~5 cm),
-      // or removes his hand from the device.
-      public void run() {
-        onProximitySensorChangedState();
-      }
-    });
+    Log.d(TAG, "defaultAudioDevice: " + defaultAudioDevice);
     AppRTCUtils.logDeviceInfo(TAG);
   }
 
-  public void init() {
-    Log.d(TAG, "init");
-    if (initialized) {
+  public void start(AudioManagerEvents audioManagerEvents) {
+    Log.d(TAG, "start");
+    if (amState == AudioManagerState.RUNNING) {
+      Log.e(TAG, "AudioManager is already active");
       return;
     }
+    // TODO(henrika): perhaps call new method called preInitAudio() here if UNINITIALIZED.
 
-    // Store current audio state so we can restore it when close() is called.
+    Log.d(TAG, "AudioManager starts...");
+    this.audioManagerEvents = audioManagerEvents;
+    amState = AudioManagerState.RUNNING;
+
+    // Store current audio state so we can restore it when stop() is called.
     savedAudioMode = audioManager.getMode();
     savedIsSpeakerPhoneOn = audioManager.isSpeakerphoneOn();
     savedIsMicrophoneMute = audioManager.isMicrophoneMute();
+    hasWiredHeadset = hasWiredHeadset();
 
     // Create an AudioManager.OnAudioFocusChangeListener instance.
     audioFocusChangeListener = new AudioManager.OnAudioFocusChangeListener() {
       // Called on the listener to notify if the audio focus for this listener has been changed.
       // The |focusChange| value indicates whether the focus was gained, whether the focus was lost,
       // and whether that loss is transient, or whether the new focus holder will hold it for an
       // unknown amount of time.
       // TODO(henrika): possibly extend support of handling audio-focus changes. Only contains
       // logging for now.
       @Override
@@ skipping 34 matching lines @@
         AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
     if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
       Log.d(TAG, "Audio focus request granted for VOICE_CALL streams");
     } else {
       Log.e(TAG, "Audio focus request failed");
     }
 
     // Start by setting MODE_IN_COMMUNICATION as default audio mode. It is
     // required to be in this mode when playout and/or recording starts for
     // best possible VoIP performance.
-    // TODO(henrika): we migh want to start with RINGTONE mode here instead.
     audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
 
     // Always disable microphone mute during a WebRTC call.
     setMicrophoneMute(false);
 
+    // Set initial device states.
+    userSelectedAudioDevice = AudioDevice.NONE;
+    selectedAudioDevice = AudioDevice.NONE;
+    audioDevices.clear();
+
+    // Initialize and start Bluetooth if a BT device is available or initiate
+    // detection of new (enabled) BT devices.
+    bluetoothManager.start();
+
     // Do initial selection of audio device. This setting can later be changed
-    // either by adding/removing a wired headset or by covering/uncovering the
-    // proximity sensor.
-    updateAudioDeviceState(hasWiredHeadset());
+    // either by adding/removing a BT or wired headset or by covering/uncovering
+    // the proximity sensor.
+    updateAudioDeviceState();
 
     // Register receiver for broadcast intents related to adding/removing a
-    // wired headset (Intent.ACTION_HEADSET_PLUG).
-    registerForWiredHeadsetIntentBroadcast();
-
-    initialized = true;
+    // wired headset.
+    registerReceiver(wiredHeadsetReceiver, new IntentFilter(Intent.ACTION_HEADSET_PLUG));
+    Log.d(TAG, "AudioManager started");
   }
 
-  public void close() {
-    Log.d(TAG, "close");
-    if (!initialized) {
+  public void stop() {
+    Log.d(TAG, "stop");
+    if (amState != AudioManagerState.RUNNING) {
+      Log.e(TAG, "Trying to stop AudioManager in incorrect state: " + amState);
       return;
     }
+    amState = AudioManagerState.UNINITIALIZED;
 
-    unregisterForWiredHeadsetIntentBroadcast();
+    unregisterReceiver(wiredHeadsetReceiver);
+
+    bluetoothManager.stop();
 
     // Restore previously stored audio states.
     setSpeakerphoneOn(savedIsSpeakerPhoneOn);
     setMicrophoneMute(savedIsMicrophoneMute);
     audioManager.setMode(savedAudioMode);
 
     // Abandon audio focus. Gives the previous focus owner, if any, focus.
     audioManager.abandonAudioFocus(audioFocusChangeListener);
     audioFocusChangeListener = null;
     Log.d(TAG, "Abandoned audio focus for VOICE_CALL streams");
 
-    if (proximitySensor != null) {
-      proximitySensor.stop();
-      proximitySensor = null;
-    }
-
-    initialized = false;
-  }
-
-  /** Changes selection of the currently active audio device. */
-  public void setAudioDevice(AudioDevice device) {
-    Log.d(TAG, "setAudioDevice(device=" + device + ")");
+    audioManagerEvents = null;
+    Log.d(TAG, "AudioManager stopped");
+  }
+
+  // Changes selection of the currently active audio device.
+  private void setAudioDeviceInternal(AudioDevice device) {
+    Log.d(TAG, "setAudioDeviceInternal(device=" + device + ")");
     AppRTCUtils.assertIsTrue(audioDevices.contains(device));
 
     switch (device) {
       case SPEAKER_PHONE:
         setSpeakerphoneOn(true);
-        selectedAudioDevice = AudioDevice.SPEAKER_PHONE;
         break;
       case EARPIECE:
         setSpeakerphoneOn(false);
-        selectedAudioDevice = AudioDevice.EARPIECE;
         break;
       case WIRED_HEADSET:
         setSpeakerphoneOn(false);
-        selectedAudioDevice = AudioDevice.WIRED_HEADSET;
+        break;
+      case BLUETOOTH:
+        setSpeakerphoneOn(false);
         break;
       default:
         Log.e(TAG, "Invalid audio device selection");
         break;
     }
-    onAudioManagerChangedState();
-  }
-
-  /** Returns current set of available/selectable audio devices. */
-  public Set<AudioDevice> getAudioDevices() {
+    selectedAudioDevice = device;
+  }
+
+  // Changes default audio device.
+  // TODO(henrika): add usage of this method in the AppRTCMobile client.
+  public synchronized void setDefaultAudioDevice(AudioDevice defaultDevice) {
+    switch (defaultDevice) {
+      case SPEAKER_PHONE:
+        defaultAudioDevice = defaultDevice;
+        break;
+      case EARPIECE:
+        if (hasEarpiece()) {
+          defaultAudioDevice = defaultDevice;
+        } else {
+          defaultAudioDevice = AudioDevice.SPEAKER_PHONE;
+        }
+        break;
+      default:
+        Log.e(TAG, "Invalid default audio device selection");
+        break;
+    }
+    Log.d(TAG, "setDefaultAudioDevice(device=" + defaultAudioDevice + ")");
+    updateAudioDeviceState();
+  }
+
+  // Changes selection of the currently active audio device.
+  public synchronized void selectAudioDevice(AudioDevice device) {
+    if (!audioDevices.contains(device)) {
+      Log.e(TAG, "Can not select " + device + " from available " + audioDevices);
+    }
+    userSelectedAudioDevice = device;
+    updateAudioDeviceState();
+  }
+
+  // Returns current set of available/selectable audio devices.
+  public synchronized Set<AudioDevice> getAudioDevices() {
     return Collections.unmodifiableSet(new HashSet<AudioDevice>(audioDevices));
   }
 
-  /** Returns the currently selected audio device. */
-  public AudioDevice getSelectedAudioDevice() {
+  // Returns the currently selected audio device.
+  public synchronized AudioDevice getSelectedAudioDevice() {
     return selectedAudioDevice;
   }
 
-  /**
-   * Registers receiver for the broadcasted intent when a wired headset is
-   * plugged in or unplugged. The received intent will have an extra
-   * 'state' value where 0 means unplugged, and 1 means plugged.
-   */
-  private void registerForWiredHeadsetIntentBroadcast() {
-    IntentFilter filter = new IntentFilter(Intent.ACTION_HEADSET_PLUG);
-
-    /** Receiver which handles changes in wired headset availability. */
-    wiredHeadsetReceiver = new BroadcastReceiver() {
-      private static final int STATE_UNPLUGGED = 0;
-      private static final int STATE_PLUGGED = 1;
-      private static final int HAS_NO_MIC = 0;
-      private static final int HAS_MIC = 1;
-
-      @Override
-      public void onReceive(Context context, Intent intent) {
-        int state = intent.getIntExtra("state", STATE_UNPLUGGED);
-        int microphone = intent.getIntExtra("microphone", HAS_NO_MIC);
-        String name = intent.getStringExtra("name");
-        Log.d(TAG, "BroadcastReceiver.onReceive" + AppRTCUtils.getThreadInfo() + ": "
-                + "a=" + intent.getAction() + ", s="
-                + (state == STATE_UNPLUGGED ? "unplugged" : "plugged") + ", m="
-                + (microphone == HAS_MIC ? "mic" : "no mic") + ", n=" + name + ", sb="
-                + isInitialStickyBroadcast());
-
-        boolean hasWiredHeadset = (state == STATE_PLUGGED);
-        switch (state) {
-          case STATE_UNPLUGGED:
-            updateAudioDeviceState(hasWiredHeadset);
-            break;
-          case STATE_PLUGGED:
-            if (selectedAudioDevice != AudioDevice.WIRED_HEADSET) {
-              updateAudioDeviceState(hasWiredHeadset);
-            }
-            break;
-          default:
-            Log.e(TAG, "Invalid state");
-            break;
-        }
+  // Update list of possible audio devices and make new device selection.
+  public void updateAudioDeviceState() {

[magjed_webrtc, 2016/12/07 11:09:43]

Please move this function back to make the diff smaller (I understand you want
to keep the private/public separated). You can move it in a final patch set
after you get it stamped.

[henrika_webrtc, 2016/12/07 12:55:41]

Done.

+    threadChecker.checkIsOnValidThread();
+    Log.d(TAG, "--- updateAudioDeviceState: "
+            + "wired headset=" + hasWiredHeadset + ", "
+            + "BT state=" + bluetoothManager.getState());
+    Log.d(TAG, "Device status: "
+            + "available=" + audioDevices + ", "
+            + "selected=" + selectedAudioDevice + ", "
+            + "user selected=" + userSelectedAudioDevice);
+
+    // Check if any Bluetooth headset is connected. The internal BT state will
+    // change accordingly.
+    // TODO(henrika): perhaps wrap required state into BT manager.
+    if (bluetoothManager.getState() == AppRTCBluetoothManager.State.HEADSET_AVAILABLE
+        || bluetoothManager.getState() == AppRTCBluetoothManager.State.HEADSET_UNAVAILABLE
+        || bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_DISCONNECTING) {
+      bluetoothManager.updateDevice();
+    }
+
+    // Update the set of available audio devices.
+    Set<AudioDevice> newAudioDevices = new HashSet<>();
+
+    if (bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_CONNECTED
+        || bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_CONNECTING
+        || bluetoothManager.getState() == AppRTCBluetoothManager.State.HEADSET_AVAILABLE) {
+      newAudioDevices.add(AudioDevice.BLUETOOTH);
+    }
+
+    if (hasWiredHeadset) {
+      // If a wired headset is connected, then it is the only possible option.
+      newAudioDevices.add(AudioDevice.WIRED_HEADSET);
+    } else {
+      // No wired headset, hence the audio-device list can contain speaker
+      // phone (on a tablet), or speaker phone and earpiece (on mobile phone).
+      newAudioDevices.add(AudioDevice.SPEAKER_PHONE);
+      if (hasEarpiece()) {
+        newAudioDevices.add(AudioDevice.EARPIECE);
       }
-    };
-
-    apprtcContext.registerReceiver(wiredHeadsetReceiver, filter);
-  }
-
-  /** Unregister receiver for broadcasted ACTION_HEADSET_PLUG intent. */
-  private void unregisterForWiredHeadsetIntentBroadcast() {
-    apprtcContext.unregisterReceiver(wiredHeadsetReceiver);
-    wiredHeadsetReceiver = null;
-  }
-
-  /** Sets the speaker phone mode. */
+    }
+
+    // Update the existing audio device set if needed.
+    boolean audioDeviceSetUpdated =
+        !audioDevices.containsAll(newAudioDevices) || !newAudioDevices.containsAll(audioDevices);
+    if (audioDeviceSetUpdated) {
+      audioDevices.clear();
+      audioDevices.addAll(newAudioDevices);
+    }
+
+    // Correct user selected audio devices if needed.
+    if (bluetoothManager.getState() == AppRTCBluetoothManager.State.HEADSET_UNAVAILABLE
+        && userSelectedAudioDevice == AudioDevice.BLUETOOTH) {
+      // If BT is not available, it can't be the user selection.
+      userSelectedAudioDevice = AudioDevice.NONE;
+    }
+    if (hasWiredHeadset && userSelectedAudioDevice == AudioDevice.SPEAKER_PHONE) {
+      // If user selected speaker phone, but then plugged wired headset then make
+      // wired headset as user selected device.
+      userSelectedAudioDevice = AudioDevice.WIRED_HEADSET;
+    }
+    if (!hasWiredHeadset && userSelectedAudioDevice == AudioDevice.WIRED_HEADSET) {
+      // If user selected wired headset, but then unplugged wired headset then make
+      // speaker phone as user selected device.
+      userSelectedAudioDevice = AudioDevice.SPEAKER_PHONE;
+    }
+
+    // Need to start Bluetooth if it is available and user either selected it explicitly or
+    // user did not select any output device.
+    boolean needBluetoothAudioStart =
+        bluetoothManager.getState() == AppRTCBluetoothManager.State.HEADSET_AVAILABLE
+        && (userSelectedAudioDevice == AudioDevice.NONE
+               || userSelectedAudioDevice == AudioDevice.BLUETOOTH);
+
+    // Need to stop Bluetooth audio if user selected different device and
+    // Bluetooth SCO connection is established or in the process.
+    boolean needBluetoothAudioStop =
+        (bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_CONNECTED
+            || bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_CONNECTING)
+        && (userSelectedAudioDevice != AudioDevice.NONE
+               && userSelectedAudioDevice != AudioDevice.BLUETOOTH);
+
+    if (bluetoothManager.getState() == AppRTCBluetoothManager.State.HEADSET_AVAILABLE
+        || bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_CONNECTING
+        || bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_CONNECTED) {
+      Log.d(TAG, "Need BT audio: start=" + needBluetoothAudioStart + ", "
+              + "stop=" + needBluetoothAudioStop + ", "
+              + "BT state=" + bluetoothManager.getState());
+    }
+
+    // Start or stop Bluetooth SCO connection given states set earlier.
+    if (needBluetoothAudioStop) {
+      bluetoothManager.stopScoAudio();
+      bluetoothManager.updateDevice();
+    }
+
+    if (needBluetoothAudioStart && !needBluetoothAudioStop) {
+      // Attempt to start Bluetooth SCO audio (takes a few second to start).
+      if (!bluetoothManager.startScoAudio()) {
+        // Remove BLUETOOTH from list of available devices since SCO failed.
+        audioDevices.remove(AudioDevice.BLUETOOTH);
+        audioDeviceSetUpdated = true;
+      }
+    }
+
+    // Update selected audio device.
+    AudioDevice newAudioDevice = selectedAudioDevice;
+
+    if (bluetoothManager.getState() == AppRTCBluetoothManager.State.SCO_CONNECTED) {
+      // If a Bluetooth is connected, then it should be used as output audio
+      // device. Note that it is not sufficient that a headset is available;
+      // an active SCO channel must also be up and running.
+      newAudioDevice = AudioDevice.BLUETOOTH;
+    } else if (hasWiredHeadset) {
+      // If a wired headset is connected, but Bluetooth is not, then wired headset is used as
+      // audio device.
+      newAudioDevice = AudioDevice.WIRED_HEADSET;
+    } else {
+      // No wired headset and no Bluetooth, hence the audio-device list can contain speaker
+      // phone (on a tablet), or speaker phone and earpiece (on mobile phone).
+      // |defaultAudioDevice| contains either AudioDevice.SPEAKER_PHONE or AudioDevice.EARPIECE
+      // depending on the user's selection.
+      newAudioDevice = defaultAudioDevice;
+    }
+    // Switch to new device but only if there has been any changes.
+    if (newAudioDevice != selectedAudioDevice || audioDeviceSetUpdated) {
+      // Do the required device switch.
+      setAudioDeviceInternal(newAudioDevice);
+      Log.d(TAG, "New device status: "
+              + "available=" + audioDevices + ", "
+              + "selected=" + newAudioDevice);
+      if (audioManagerEvents != null) {
+        // Notify a listening client that audio device has been changed.
+        audioManagerEvents.onAudioDeviceChanged(selectedAudioDevice, audioDevices);
+      }
+    }
+    Log.d(TAG, "--- updateAudioDeviceState done");
+  }
+
+  // Helper method for receiver registration.
+  private void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
+    apprtcContext.registerReceiver(receiver, filter);
+  }
+
+  // Helper method for unregistration of an existing receiver.
+  private void unregisterReceiver(BroadcastReceiver receiver) {
+    apprtcContext.unregisterReceiver(receiver);
+  }
+
+  // Sets the speaker phone mode.
   private void setSpeakerphoneOn(boolean on) {
     boolean wasOn = audioManager.isSpeakerphoneOn();
     if (wasOn == on) {
       return;
     }
     audioManager.setSpeakerphoneOn(on);
   }
 
-  /** Sets the microphone mute state. */
+  // Sets the microphone mute state.
   private void setMicrophoneMute(boolean on) {
     boolean wasMuted = audioManager.isMicrophoneMute();
     if (wasMuted == on) {
       return;
     }
     audioManager.setMicrophoneMute(on);
   }
 
-  /** Gets the current earpiece state. */
+  // Gets the current earpiece state.
   private boolean hasEarpiece() {
     return apprtcContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY);
   }
 
-  /**
-   * Checks whether a wired headset is connected or not.
-   * This is not a valid indication that audio playback is actually over
-   * the wired headset as audio routing depends on other conditions. We
-   * only use it as an early indicator (during initialization) of an attached
-   * wired headset.
-   */
+  // Checks whether a wired headset is connected or not.
+  // This is not a valid indication that audio playback is actually over
+  // the wired headset as audio routing depends on other conditions. We
+  // only use it as an early indicator (during initialization) of an attached
+  // wired headset.
   @Deprecated
   private boolean hasWiredHeadset() {
     return audioManager.isWiredHeadsetOn();
   }
-
-  /** Update list of possible audio devices and make new device selection. */
-  private void updateAudioDeviceState(boolean hasWiredHeadset) {
-    // Update the list of available audio devices.
-    audioDevices.clear();
-    if (hasWiredHeadset) {
-      // If a wired headset is connected, then it is the only possible option.
-      audioDevices.add(AudioDevice.WIRED_HEADSET);
-    } else {
-      // No wired headset, hence the audio-device list can contain speaker
-      // phone (on a tablet), or speaker phone and earpiece (on mobile phone).
-      audioDevices.add(AudioDevice.SPEAKER_PHONE);
-      if (hasEarpiece()) {
-        audioDevices.add(AudioDevice.EARPIECE);
-      }
-    }
-    Log.d(TAG, "audioDevices: " + audioDevices);
-
-    // Switch to correct audio device given the list of available audio devices.
-    if (hasWiredHeadset) {
-      setAudioDevice(AudioDevice.WIRED_HEADSET);
-    } else {
-      setAudioDevice(defaultAudioDevice);
-    }
-  }
-
-  /** Called each time a new audio device has been added or removed. */
-  private void onAudioManagerChangedState() {
-    Log.d(TAG, "onAudioManagerChangedState: devices=" + audioDevices + ", selected="
-            + selectedAudioDevice);
-
-    // Enable the proximity sensor if there are two available audio devices
-    // in the list. Given the current implementation, we know that the choice
-    // will then be between EARPIECE and SPEAKER_PHONE.
-    if (audioDevices.size() == 2) {
-      AppRTCUtils.assertIsTrue(audioDevices.contains(AudioDevice.EARPIECE)
-          && audioDevices.contains(AudioDevice.SPEAKER_PHONE));
-      // Start the proximity sensor.
-      proximitySensor.start();
-    } else if (audioDevices.size() == 1) {
-      // Stop the proximity sensor since it is no longer needed.
-      proximitySensor.stop();
-    } else {
-      Log.e(TAG, "Invalid device list");
-    }
-
-    if (onStateChangeListener != null) {
-      // Run callback to notify a listening client. The client can then
-      // use public getters to query the new state.
-      onStateChangeListener.run();
-    }
-  }
 }