Refactor android specific code in AudioManagerBase class.

media/audio/audio_manager_base.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/audio_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/thread.h"
-#if defined(OS_ANDROID)
-#include "jni/AudioManagerAndroid_jni.h"
-#endif
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/base/media_switches.h"
 
 namespace media {
 
 static const int kStreamCloseDelaySeconds = 5;
 
 // Default maximum number of output streams that can be open simultaneously
 // for all platforms.
 static const int kDefaultMaxOutputStreams = 16;
 
 // Default maximum number of input streams that can be open simultaneously
 // for all platforms.
 static const int kDefaultMaxInputStreams = 16;
 
 static const int kMaxInputChannels = 2;
 
-#if defined(OS_ANDROID)
-static const int kAudioModeNormal = 0x00000000;
-static const int kAudioModeInCommunication = 0x00000003;
-#endif
-
 const char AudioManagerBase::kDefaultDeviceName[] = "Default";
 const char AudioManagerBase::kDefaultDeviceId[] = "default";
 
 AudioManagerBase::AudioManagerBase()
     : num_active_input_streams_(0),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
       num_input_streams_(0),
       output_listeners_(
           ObserverList<AudioDeviceListener>::NOTIFY_EXISTING_ONLY),
       audio_thread_(new base::Thread("AudioThread")) {
 #if defined(OS_WIN)
   audio_thread_->init_com_with_mta(true);
 #endif
 #if defined(OS_MACOSX)
   // On Mac, use a UI loop to get native message pump so that CoreAudio property
   // listener callbacks fire.
   CHECK(audio_thread_->StartWithOptions(
       base::Thread::Options(MessageLoop::TYPE_UI, 0)));
 #else
   CHECK(audio_thread_->Start());
 #endif
   message_loop_ = audio_thread_->message_loop_proxy();
-
-#if defined(OS_ANDROID)
-  JNIEnv* env = base::android::AttachCurrentThread();
-  jobject context = base::android::GetApplicationContext();
-  j_audio_manager_.Reset(
-      Java_AudioManagerAndroid_createAudioManagerAndroid(env, context));
-#endif
 }
 
 AudioManagerBase::~AudioManagerBase() {
   // The platform specific AudioManager implementation must have already
   // stopped the audio thread. Otherwise, we may destroy audio streams before
   // stopping the thread, resulting an unexpected behavior.
   // This way we make sure activities of the audio streams are all stopped
   // before we destroy them.
   CHECK(!audio_thread_.get());
   // All the output streams should have been deleted.
@@ skipping 44 matching lines @@
     case AudioParameters::AUDIO_FAKE:
       stream = FakeAudioOutputStream::MakeFakeStream(this, params);
       break;
     default:
       stream = NULL;
       break;
   }
 
   if (stream) {
     ++num_output_streams_;
-#if defined(OS_ANDROID)
-    if (num_output_streams_ == 1)
-      RegisterHeadsetReceiver();
-#endif
   }
 
   return stream;
 }
 
 AudioInputStream* AudioManagerBase::MakeAudioInputStream(
     const AudioParameters& params, const std::string& device_id) {
   // TODO(miu): Fix ~20 call points across several unit test modules to call
   // this method on the audio thread, then uncomment the following:
   // DCHECK(message_loop_->BelongsToCurrentThread());
@@ skipping 22 matching lines @@
     case AudioParameters::AUDIO_FAKE:
       stream = FakeAudioInputStream::MakeFakeStream(this, params);
       break;
     default:
       stream = NULL;
       break;
   }
 
   if (stream) {
     ++num_input_streams_;
-#if defined(OS_ANDROID)
-    if (num_input_streams_ == 1)
-      SetAudioMode(kAudioModeInCommunication);
-#endif
   }
 
   return stream;
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
     const AudioParameters& params) {
 #if defined(OS_IOS)
   // IOS implements audio input only.
   NOTIMPLEMENTED();
@@ skipping 64 matching lines @@
     media::AudioDeviceNames* device_names) {
 }
 
 void AudioManagerBase::ReleaseOutputStream(AudioOutputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioOutputStream.
   // For example, pass the ownership to AudioManager so it can delete the
   // streams.
   --num_output_streams_;
   delete stream;
-#if defined(OS_ANDROID)
-  if (!num_output_streams_)
-    UnregisterHeadsetReceiver();
-#endif
 }
 
 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
   DCHECK(stream);
   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
   --num_input_streams_;
   delete stream;
-#if defined(OS_ANDROID)
-  if (!num_input_streams_)
-    SetAudioMode(kAudioModeNormal);
-#endif
 }
 
 void AudioManagerBase::IncreaseActiveInputStreamCount() {
   base::AtomicRefCountInc(&num_active_input_streams_);
 }
 
 void AudioManagerBase::DecreaseActiveInputStreamCount() {
   DCHECK(IsRecordingInProcess());
   base::AtomicRefCountDec(&num_active_input_streams_);
 }
@@ skipping 47 matching lines @@
       // So, better crash now than later.
       DCHECK(dispatcher->HasOneRef()) << "AudioOutputProxies are still alive";
       dispatcher = NULL;
     }
   }
 
   output_dispatchers_.clear();
 #endif  // defined(OS_IOS)
 }
 
-#if defined(OS_ANDROID)
-// static
-bool AudioManagerBase::RegisterAudioManager(JNIEnv* env) {
-  return RegisterNativesImpl(env);
-}
-#endif
-
 void AudioManagerBase::AddOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   output_listeners_.AddObserver(listener);
 }
 
 void AudioManagerBase::RemoveOutputDeviceChangeListener(
     AudioDeviceListener* listener) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   output_listeners_.RemoveObserver(listener);
 }
 
 void AudioManagerBase::NotifyAllOutputDeviceChangeListeners() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DVLOG(1) << "Firing OnDeviceChange() notifications.";
   FOR_EACH_OBSERVER(AudioDeviceListener, output_listeners_, OnDeviceChange());
 }
 
 AudioParameters AudioManagerBase::GetDefaultOutputStreamParameters() {
   return GetPreferredOutputStreamParameters(AudioParameters());
 }
 
 AudioParameters AudioManagerBase::GetInputStreamParameters(
     const std::string& device_id) {
   NOTREACHED();
   return AudioParameters();
 }
 
-#if defined(OS_ANDROID)
-void AudioManagerBase::SetAudioMode(int mode) {
-  Java_AudioManagerAndroid_setMode(
-      base::android::AttachCurrentThread(),
-      j_audio_manager_.obj(), mode);
-}
-
-void AudioManagerBase::RegisterHeadsetReceiver() {
-  Java_AudioManagerAndroid_registerHeadsetReceiver(
-      base::android::AttachCurrentThread(),
-      j_audio_manager_.obj());
-}
-
-void AudioManagerBase::UnregisterHeadsetReceiver() {
-  Java_AudioManagerAndroid_unregisterHeadsetReceiver(
-      base::android::AttachCurrentThread(),
-      j_audio_manager_.obj());
-}
-#endif  // defined(OS_ANDROID)
-
 }  // namespace media