UMA log for audio_device Init and Start(Playout|Recording). Make Init return a more specific error …

webrtc/modules/audio_device/audio_device_impl.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/refcount.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_device/audio_device_config.h"
+#include "webrtc/modules/audio_device/audio_device_generic.h"
 #include "webrtc/modules/audio_device/audio_device_impl.h"
+#include "webrtc/system_wrappers/include/metrics.h"
 
 #include <assert.h>
 #include <string.h>
 
 #if defined(_WIN32)
 #include "audio_device_wave_win.h"
 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 #include "audio_device_core_win.h"
 #endif
 #elif defined(WEBRTC_ANDROID)
@@ skipping 232 matching lines @@
 // Create the *Linux* implementation of the Audio Device
 //
 #elif defined(WEBRTC_LINUX)
   if ((audioLayer == kLinuxPulseAudio) ||
       (audioLayer == kPlatformDefaultAudio)) {
 #if defined(LINUX_PULSE)
     LOG(INFO) << "attempting to use the Linux PulseAudio APIs...";
 
     // create *Linux PulseAudio* implementation
     AudioDeviceLinuxPulse* pulseDevice = new AudioDeviceLinuxPulse(Id());
-    if (pulseDevice->Init() != -1) {
+    if (pulseDevice->Init() == AudioDeviceGeneric::InitStatus::OK) {
       ptrAudioDevice = pulseDevice;
       LOG(INFO) << "Linux PulseAudio APIs will be utilized";
     } else {
       delete pulseDevice;
 #endif
 #if defined(LINUX_ALSA)
       // create *Linux ALSA Audio* implementation
       ptrAudioDevice = new AudioDeviceLinuxALSA(Id());
       if (ptrAudioDevice != NULL) {
         // Pulse Audio was not supported => revert to ALSA instead
@@ skipping 194 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 //  Init
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::Init() {
   LOG(INFO) << __FUNCTION__;
   if (_initialized)
     return 0;
+  RTC_CHECK(_ptrAudioDevice);
 
-  if (!_ptrAudioDevice)
-    return -1;
-
-  if (_ptrAudioDevice->Init() == -1) {
+  AudioDeviceGeneric::InitStatus status = _ptrAudioDevice->Init();
+  RTC_HISTOGRAM_ENUMERATION(
+      "WebRTC.Audio.InitializationResult", static_cast<int>(status),
+      static_cast<int>(AudioDeviceGeneric::InitStatus::NUM_STATUSES));
+  if (status != AudioDeviceGeneric::InitStatus::OK) {
+    LOG(LS_ERROR) << "Audio device initialization failed.";
     return -1;
   }
 
   _initialized = true;
   return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  Terminate
 // ----------------------------------------------------------------------------
@@ skipping 928 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 //  InitPlayout
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::InitPlayout() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
   _audioDeviceBuffer.InitPlayout();
-  return (_ptrAudioDevice->InitPlayout());
+  int32_t result = _ptrAudioDevice->InitPlayout();
+  LOG(INFO) << "output: " << result;
+  RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitPlayoutSuccess",
+                        static_cast<int>(result == 0));
+  return result;
 }
 
 // ----------------------------------------------------------------------------
 //  InitRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::InitRecording() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
   _audioDeviceBuffer.InitRecording();
-  return (_ptrAudioDevice->InitRecording());
+  int32_t result = _ptrAudioDevice->InitRecording();
+  LOG(INFO) << "output: " << result;
+  RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitRecordingSuccess",
+                        static_cast<int>(result == 0));
+  return result;
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutIsInitialized
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceModuleImpl::PlayoutIsInitialized() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   return (_ptrAudioDevice->PlayoutIsInitialized());
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingIsInitialized
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceModuleImpl::RecordingIsInitialized() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   return (_ptrAudioDevice->RecordingIsInitialized());
 }
 
 // ----------------------------------------------------------------------------
 //  StartPlayout
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StartPlayout() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
-  return (_ptrAudioDevice->StartPlayout());
+  int32_t result = _ptrAudioDevice->StartPlayout();
+  LOG(INFO) << "output: " << result;
+  RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartPlayoutSuccess",
+                        static_cast<int>(result == 0));
+  return result;
 }
 
 // ----------------------------------------------------------------------------
 //  StopPlayout
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StopPlayout() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
-  return (_ptrAudioDevice->StopPlayout());
+  int32_t result = _ptrAudioDevice->StopPlayout();
+  LOG(INFO) << "output: " << result;
+  RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopPlayoutSuccess",
+                        static_cast<int>(result == 0));
+  return result;
 }
 
 // ----------------------------------------------------------------------------
 //  Playing
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceModuleImpl::Playing() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   return (_ptrAudioDevice->Playing());
 }
 
 // ----------------------------------------------------------------------------
 //  StartRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StartRecording() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
-  return (_ptrAudioDevice->StartRecording());
+  int32_t result = _ptrAudioDevice->StartRecording();
+  LOG(INFO) << "output: " << result;
+  RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess",
+                        static_cast<int>(result == 0));
+  return result;
 }
 // ----------------------------------------------------------------------------
 //  StopRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StopRecording() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
-  return (_ptrAudioDevice->StopRecording());
+  int32_t result = _ptrAudioDevice->StopRecording();
+  LOG(INFO) << "output: " << result;
+  RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopRecordingSuccess",
+                        static_cast<int>(result == 0));
+  return result;
 }
 
 // ----------------------------------------------------------------------------
 //  Recording
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceModuleImpl::Recording() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   return (_ptrAudioDevice->Recording());
@@ skipping 438 matching lines @@
 //  PlatformAudioLayer
 // ----------------------------------------------------------------------------
 
 AudioDeviceModule::AudioLayer AudioDeviceModuleImpl::PlatformAudioLayer()
     const {
   LOG(INFO) << __FUNCTION__;
   return _platformAudioLayer;
 }
 
 }  // namespace webrtc