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 "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::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()));
+
+  Java_AudioManagerAndroid_init(
+        base::android::AttachCurrentThread(),
+        j_audio_manager_.obj());
 }
 
 AudioManagerAndroid::~AudioManagerAndroid() {
+  Java_AudioManagerAndroid_close(
+        base::android::AttachCurrentThread(),
+        j_audio_manager_.obj());
   Shutdown();
 }
 
 bool AudioManagerAndroid::HasAudioOutputDevices() {
   return true;
 }
 
 bool AudioManagerAndroid::HasAudioInputDevices() {
   return true;
 }
 
 void AudioManagerAndroid::GetAudioInputDeviceNames(
     AudioDeviceNames* device_names) {
   AddDefaultDevice(device_names);
 }
 
 void AudioManagerAndroid::GetAudioOutputDeviceNames(
     AudioDeviceNames* device_names) {
+  // Always add default device parameters as first element.
+  // TODO(henrika): figure out how we shall handle the term "default"
+  // on Android.
   AddDefaultDevice(device_names);
+
+  JNIEnv* env = AttachCurrentThread();
+  int sdk = base::android::BuildInfo::GetInstance()->sdk_int();
+  if (sdk <= 16) {
+    // TODO(henrika): figure out where/if we must draw a limit here.
+    AddDefaultDevice(device_names);

[Jói, 2013/11/25 13:09:35]

Not sure you want to add the default device again (already done on line 85
above).

[henrika (OOO until Aug 14), 2013/11/25 13:28:14]

oops

+  } else {
+    ScopedJavaLocalRef<jobjectArray> j_device_array =
+        Java_AudioManagerAndroid_getAudioOutputDeviceNames(
+            env, j_audio_manager_.obj());
+    std::vector<std::string> devices;
+    AppendJavaStringArrayToStringVector(env, j_device_array.obj(), &devices);
+
+    std::vector<std::string>::iterator it = devices.begin();
+    while (it != devices.end()) {
+      device_names->push_back(AudioDeviceName(*it, *it));
+      DVLOG(1) << "ouput device name: " << *it;
+      ++it;
+    }
+  }
 }
 
 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();
+      SetAudioMode(kAudioModeInCommunication);
+      // TODO(henrika): resolve conflict with device enumeration.
+      // 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();
+    // TODO(henrika): resolve conflict with device enumeration.
+    // UnregisterHeadsetReceiver();
     SetAudioMode(kAudioModeNormal);
   }
 }
 
 void AudioManagerAndroid::ReleaseInputStream(AudioInputStream* stream) {
   AudioManagerBase::ReleaseInputStream(stream);
 }
 
 AudioOutputStream* AudioManagerAndroid::MakeLinearOutputStream(
     const AudioParameters& params) {
@@ skipping 98 matching lines @@
       j_audio_manager_.obj());
 }
 
 int AudioManagerAndroid::GetAudioLowLatencyOutputFrameSize() {
   return Java_AudioManagerAndroid_getAudioLowLatencyOutputFrameSize(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
 }  // namespace media