Fix for "Android audio playout doesn't support non-call media stream"

webrtc/modules/audio_device/android/audio_manager.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
@@ skipping 53 matching lines @@
 
 // AudioManager implementation
 AudioManager::AudioManager()
     : j_environment_(JVM::GetInstance()->environment()),
       audio_layer_(AudioDeviceModule::kPlatformDefaultAudio),
       initialized_(false),
       hardware_aec_(false),
       hardware_agc_(false),
       hardware_ns_(false),
       low_latency_playout_(false),
-      delay_estimate_in_milliseconds_(0) {
+      delay_estimate_in_milliseconds_(0),
+      output_stream_type_(0) {

[magjed_webrtc, 2015/10/28 09:08:33]

Use AudioManager.STREAM_VOICE_CALL instead of 0

[henrika_webrtc, 2015/10/28 10:48:01]

Discussed off line. Keeping as is.

   ALOGD("ctor%s", GetThreadInfo().c_str());
   RTC_CHECK(j_environment_);
   JNINativeMethod native_methods[] = {
       {"nativeCacheAudioParameters",
-       "(IIZZZZIIJ)V",
+       "(IIZZZZIIIJ)V",
        reinterpret_cast<void*>(&webrtc::AudioManager::CacheAudioParameters)}};
   j_native_registration_ = j_environment_->RegisterNatives(
       "org/webrtc/voiceengine/WebRtcAudioManager",
       native_methods, arraysize(native_methods));
   j_audio_manager_.reset(new JavaAudioManager(
       j_native_registration_.get(),
       j_native_registration_->NewObject(
           "<init>", "(Landroid/content/Context;J)V",
           JVM::GetInstance()->context(), PointerTojlong(this))));
 }
@@ skipping 82 matching lines @@
 void JNICALL AudioManager::CacheAudioParameters(JNIEnv* env,
                                                 jobject obj,
                                                 jint sample_rate,
                                                 jint channels,
                                                 jboolean hardware_aec,
                                                 jboolean hardware_agc,
                                                 jboolean hardware_ns,
                                                 jboolean low_latency_output,
                                                 jint output_buffer_size,
                                                 jint input_buffer_size,
+                                                jint output_stream_type,
                                                 jlong native_audio_manager) {
   webrtc::AudioManager* this_object =
       reinterpret_cast<webrtc::AudioManager*>(native_audio_manager);
   this_object->OnCacheAudioParameters(
       env, sample_rate, channels, hardware_aec, hardware_agc, hardware_ns,
-      low_latency_output, output_buffer_size, input_buffer_size);
+      low_latency_output, output_buffer_size, input_buffer_size,
+      output_stream_type);
 }
 
 void AudioManager::OnCacheAudioParameters(JNIEnv* env,
                                           jint sample_rate,
                                           jint channels,
                                           jboolean hardware_aec,
                                           jboolean hardware_agc,
                                           jboolean hardware_ns,
                                           jboolean low_latency_output,
                                           jint output_buffer_size,
-                                          jint input_buffer_size) {
+                                          jint input_buffer_size,
+                                          jint output_stream_type) {
   ALOGD("OnCacheAudioParameters%s", GetThreadInfo().c_str());
   ALOGD("hardware_aec: %d", hardware_aec);
   ALOGD("hardware_agc: %d", hardware_agc);
   ALOGD("hardware_ns: %d", hardware_ns);
   ALOGD("low_latency_output: %d", low_latency_output);
   ALOGD("sample_rate: %d", sample_rate);
   ALOGD("channels: %d", channels);
   ALOGD("output_buffer_size: %d", output_buffer_size);
   ALOGD("input_buffer_size: %d", input_buffer_size);
+  ALOGD("output_stream_type: %d", output_stream_type);
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   hardware_aec_ = hardware_aec;
   hardware_agc_ = hardware_agc;
   hardware_ns_ = hardware_ns;
   low_latency_playout_ = low_latency_output;
+  output_stream_type_ = output_stream_type;
   // TODO(henrika): add support for stereo output.
   playout_parameters_.reset(sample_rate, channels,
                             static_cast<size_t>(output_buffer_size));
   record_parameters_.reset(sample_rate, channels,
                            static_cast<size_t>(input_buffer_size));
 }
 
 const AudioParameters& AudioManager::GetPlayoutAudioParameters() {
   RTC_CHECK(playout_parameters_.is_valid());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return playout_parameters_;
 }
 
 const AudioParameters& AudioManager::GetRecordAudioParameters() {
   RTC_CHECK(record_parameters_.is_valid());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return record_parameters_;
 }
 
 }  // namespace webrtc