Adding device enumeration to Android device manager

media/audio/android/audio_manager_android.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/android/audio_manager_android.h"
 
+#include "base/android/build_info.h"
+#include "base/android/jni_array.h"
+#include "base/android/jni_string.h"
+#include "base/android/scoped_java_ref.h"
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
 #include "jni/AudioManagerAndroid_jni.h"
 #include "media/audio/android/opensles_input.h"
 #include "media/audio/android/opensles_output.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/base/channel_layout.h"
 
+using base::android::AppendJavaStringArrayToStringVector;
+using base::android::AttachCurrentThread;
+using base::android::ConvertJavaStringToUTF8;
+using base::android::ConvertUTF8ToJavaString;
+using base::android::ScopedJavaLocalRef;
+
 namespace media {
 
 static void AddDefaultDevice(AudioDeviceNames* device_names) {
   DCHECK(device_names->empty());
   device_names->push_front(
       AudioDeviceName(AudioManagerBase::kDefaultDeviceName,
                       AudioManagerBase::kDefaultDeviceId));
 }
 
 // Maximum number of output streams that can be open simultaneously.
 static const int kMaxOutputStreams = 10;
 
 static const int kAudioModeNormal = 0x00000000;
 static const int kAudioModeInCommunication = 0x00000003;
 
 static const int kDefaultInputBufferSize = 1024;
 static const int kDefaultOutputBufferSize = 2048;
 
 AudioManager* CreateAudioManager() {
   return new AudioManagerAndroid();
 }
 
 AudioManagerAndroid::AudioManagerAndroid() {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 
   j_audio_manager_.Reset(
       Java_AudioManagerAndroid_createAudioManagerAndroid(
           base::android::AttachCurrentThread(),
           base::android::GetApplicationContext()));
+  Init();
 }
 
 AudioManagerAndroid::~AudioManagerAndroid() {
+  Close();
   Shutdown();
 }
 
 bool AudioManagerAndroid::HasAudioOutputDevices() {
   return true;
 }
 
 bool AudioManagerAndroid::HasAudioInputDevices() {
   return true;
 }
 
 void AudioManagerAndroid::GetAudioInputDeviceNames(
     AudioDeviceNames* device_names) {
+  // Always add default device parameters as first element.
   AddDefaultDevice(device_names);
+
+  // Get all available devices and add these to the list.

[tommi (sloooow) - chröme, 2013/11/29 15:04:33]

nit: redundant comment (since we're inside GetAudioInputDeviceNames)

[henrika (OOO until Aug 14), 2013/11/29 15:39:50]

Done.

+  AudioDeviceName device;

[tommi (sloooow) - chröme, 2013/11/29 15:04:33]

nit: declare above the loop where it's used.

[henrika (OOO until Aug 14), 2013/11/29 15:39:50]

Done.

+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobjectArray> j_device_array =
+      Java_AudioManagerAndroid_getAudioInputDeviceNames(
+          env, j_audio_manager_.obj());
+  jsize len = env->GetArrayLength(j_device_array.obj());
+  for (jsize i = 0; i < len; ++i) {
+    ScopedJavaLocalRef<jobject> j_device(
+        env, env->GetObjectArrayElement(j_device_array.obj(), i));
+    ScopedJavaLocalRef<jstring> j_device_name =
+        Java_AudioDeviceName_name(env, j_device.obj());
+    ConvertJavaStringToUTF8(env, j_device_name.obj(), &device.device_name);
+    ScopedJavaLocalRef<jstring> j_device_id =
+        Java_AudioDeviceName_id(env, j_device.obj());
+    ConvertJavaStringToUTF8(env, j_device_id.obj(), &device.unique_id);
+    device_names->push_back(device);
+  }
 }
 
 void AudioManagerAndroid::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
+  // TODO(henrika): enumerate using GetAudioInputDeviceNames().
   AddDefaultDevice(device_names);
 }
 
 AudioParameters AudioManagerAndroid::GetInputStreamParameters(
     const std::string& device_id) {
   // Use mono as preferred number of input channels on Android to save
   // resources. Using mono also avoids a driver issue seen on Samsung
   // Galaxy S3 and S4 devices. See http://crbug.com/256851 for details.
   ChannelLayout channel_layout = CHANNEL_LAYOUT_MONO;
   int buffer_size = Java_AudioManagerAndroid_getMinInputFrameSize(
       base::android::AttachCurrentThread(), GetNativeOutputSampleRate(),
       ChannelLayoutToChannelCount(channel_layout));
 
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
       GetNativeOutputSampleRate(), 16,
       buffer_size <= 0 ? kDefaultInputBufferSize : buffer_size);
 }
 
 AudioOutputStream* AudioManagerAndroid::MakeAudioOutputStream(
     const AudioParameters& params,
     const std::string& device_id,
     const std::string& input_device_id) {
   AudioOutputStream* stream =
       AudioManagerBase::MakeAudioOutputStream(params, std::string(),
           std::string());
   if (stream && output_stream_count() == 1) {
     SetAudioMode(kAudioModeInCommunication);
-    RegisterHeadsetReceiver();
   }
   return stream;
 }
 
 AudioInputStream* AudioManagerAndroid::MakeAudioInputStream(
     const AudioParameters& params, const std::string& device_id) {
   AudioInputStream* stream =
       AudioManagerBase::MakeAudioInputStream(params, device_id);
   return stream;
 }
 
 void AudioManagerAndroid::ReleaseOutputStream(AudioOutputStream* stream) {
   AudioManagerBase::ReleaseOutputStream(stream);
   if (!output_stream_count()) {
-    UnregisterHeadsetReceiver();
     SetAudioMode(kAudioModeNormal);
   }
 }
 
 void AudioManagerAndroid::ReleaseInputStream(AudioInputStream* stream) {
   AudioManagerBase::ReleaseInputStream(stream);
 }
 
 AudioOutputStream* AudioManagerAndroid::MakeLinearOutputStream(
     const AudioParameters& params) {
@@ skipping 12 matching lines @@
 
 AudioInputStream* AudioManagerAndroid::MakeLinearInputStream(
     const AudioParameters& params, const std::string& device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format());
   return new OpenSLESInputStream(this, params);
 }
 
 AudioInputStream* AudioManagerAndroid::MakeLowLatencyInputStream(
     const AudioParameters& params, const std::string& device_id) {
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
+  DLOG_IF(ERROR, device_id.empty()) << "Invalid device ID!";
+  // Utilize the device ID to select the correct input device.
+  // Note that the input device is always associated with a certain output
+  // device, i.e., this selection does also switch the output device.
+  // All input and output streams will be affected by the device selection.
+  SetAudioDevice(device_id);
   return new OpenSLESInputStream(this, params);
 }
 
 int AudioManagerAndroid::GetOptimalOutputFrameSize(int sample_rate,
                                                    int channels) {
   if (IsAudioLowLatencySupported()) {
     return GetAudioLowLatencyOutputFrameSize();
   } else {
     return std::max(kDefaultOutputBufferSize,
                     Java_AudioManagerAndroid_getMinOutputFrameSize(
@@ skipping 29 matching lines @@
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, input_channels,
       sample_rate, bits_per_sample, buffer_size);
 }
 
 // static
 bool AudioManagerAndroid::RegisterAudioManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
+void AudioManagerAndroid::Init() {
+  Java_AudioManagerAndroid_init(
+        base::android::AttachCurrentThread(),
+        j_audio_manager_.obj());
+}
+
+void AudioManagerAndroid::Close() {
+  Java_AudioManagerAndroid_close(
+        base::android::AttachCurrentThread(),
+        j_audio_manager_.obj());
+}
+
 void AudioManagerAndroid::SetAudioMode(int mode) {
   Java_AudioManagerAndroid_setMode(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj(), mode);
 }
 
-void AudioManagerAndroid::RegisterHeadsetReceiver() {
-  Java_AudioManagerAndroid_registerHeadsetReceiver(
-      base::android::AttachCurrentThread(),
-      j_audio_manager_.obj());
-}
+void AudioManagerAndroid::SetAudioDevice(std::string device_id) {
+  JNIEnv* env = AttachCurrentThread();
 
-void AudioManagerAndroid::UnregisterHeadsetReceiver() {
-  Java_AudioManagerAndroid_unregisterHeadsetReceiver(
-      base::android::AttachCurrentThread(),
-      j_audio_manager_.obj());
+  // Provide an empty string to the Java audio manager if the default device
+  // is selected.
+  if (device_id == AudioManagerBase::kDefaultDeviceId)
+    device_id.clear();
+
+  // Send the unique device ID to the Java audio manager and make the
+  // device switch.
+  ScopedJavaLocalRef<jstring> j_device_id =
+      ConvertUTF8ToJavaString(env, device_id);
+  Java_AudioManagerAndroid_setDevice(
+      env, j_audio_manager_.obj(), j_device_id.obj());
 }
 
 int AudioManagerAndroid::GetNativeOutputSampleRate() {
   return Java_AudioManagerAndroid_getNativeOutputSampleRate(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
 bool AudioManagerAndroid::IsAudioLowLatencySupported() {
   return Java_AudioManagerAndroid_isAudioLowLatencySupported(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
 int AudioManagerAndroid::GetAudioLowLatencyOutputFrameSize() {
   return Java_AudioManagerAndroid_getAudioLowLatencyOutputFrameSize(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
 }  // namespace media