Introduce PPB_AudioInput_Dev v0.3 and refactor the device enumeration code:

ppapi/examples/audio_input/audio_input.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 <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "ppapi/cpp/audio_config.h"
 #include "ppapi/cpp/dev/audio_input_dev.h"
 #include "ppapi/cpp/dev/device_ref_dev.h"
 #include "ppapi/cpp/graphics_2d.h"
@@ skipping 10 matching lines @@
 #ifdef PostMessage
 #undef PostMessage
 #endif
 
 namespace {
 
 // This sample frequency is guaranteed to work.
 const PP_AudioSampleRate kSampleFrequency = PP_AUDIOSAMPLERATE_44100;
 const uint32_t kSampleCount = 1024;
 const uint32_t kChannelCount = 1;
+const char* const kDelimiter = "#__#";
 
 }  // namespace
 
 class MyInstance : public pp::Instance {
  public:
   explicit MyInstance(PP_Instance instance)
       : pp::Instance(instance),
         callback_factory_(this),
         sample_count_(0),
         channel_count_(0),
         samples_(NULL),
         timer_interval_(0),
         pending_paint_(false),
         waiting_for_flush_completion_(false) {
   }
   virtual ~MyInstance() {
+    device_detector_.MonitorDeviceChange(NULL, NULL);
     audio_input_.Close();
 
     delete[] samples_;
   }
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     sample_count_ = pp::AudioConfig::RecommendSampleFrameCount(this,
                                                                kSampleFrequency,
                                                                kSampleCount);
     PP_DCHECK(sample_count_ > 0);
     channel_count_ = kChannelCount;
     samples_ = new int16_t[sample_count_ * channel_count_];
     memset(samples_, 0, sample_count_ * channel_count_ * sizeof(int16_t));
 
-    audio_input_ = pp::AudioInput_Dev(this);
+    device_detector_ = pp::AudioInput_Dev(this);
 
     // Try to ensure that we pick up a new set of samples between each
     // timer-generated repaint.
     timer_interval_ = (sample_count_ * 1000) / kSampleFrequency + 5;
     ScheduleNextTimer();
 
     return true;
   }
 
   virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) {
     if (position.size() == size_)
       return;
 
     size_ = position.size();
     device_context_ = pp::Graphics2D(this, size_, false);
     if (!BindGraphics(device_context_))
       return;
 
     Paint();
   }
 
   virtual void HandleMessage(const pp::Var& message_data) {
     if (message_data.is_string()) {
       std::string event = message_data.AsString();
       if (event == "PageInitialized") {
+        int32_t result = device_detector_.MonitorDeviceChange(
+            &MyInstance::MonitorDeviceChangeCallback, this);
+        if (result != PP_OK)
+          PostMessage(pp::Var("MonitorDeviceChangeFailed"));
+
         pp::CompletionCallbackWithOutput<std::vector<pp::DeviceRef_Dev> >
             callback = callback_factory_.NewCallbackWithOutput(
                 &MyInstance::EnumerateDevicesFinished);
-        int32_t result = audio_input_.EnumerateDevices(callback);
+        result = device_detector_.EnumerateDevices(callback);
         if (result != PP_OK_COMPLETIONPENDING)
           PostMessage(pp::Var("EnumerationFailed"));
       } else if (event == "UseDefault") {
         Open(pp::DeviceRef_Dev());
       } else if (event == "Stop") {
         Stop();
       } else if (event == "Start") {
         Start();
-      }
-    } else if (message_data.is_number()) {
-      int index = message_data.AsInt();
-      if (index >= 0 && index < static_cast<int>(devices_.size())) {
-        Open(devices_[index]);
-      } else {
-        PP_NOTREACHED();
+      } else if (event.find("Monitor:") == 0) {
+        std::string index_str = event.substr(strlen("Monitor:"));
+        int index = atoi(index_str.c_str());
+        if (index >= 0 && index < static_cast<int>(monitor_devices_.size()))
+          Open(monitor_devices_[index]);
+        else
+          PP_NOTREACHED();
+      } else if (event.find("Enumerate:") == 0) {
+        std::string index_str = event.substr(strlen("Enumerate:"));
+        int index = atoi(index_str.c_str());
+        if (index >= 0 && index < static_cast<int>(enumerate_devices_.size()))
+          Open(enumerate_devices_[index]);
+        else
+          PP_NOTREACHED();
       }
     }
   }
 
  private:
   void ScheduleNextTimer() {
     PP_DCHECK(timer_interval_ > 0);
     pp::Module::Get()->core()->CallOnMainThread(
         timer_interval_,
         callback_factory_.NewCallback(&MyInstance::OnTimer),
@@ skipping 57 matching lines @@
          x < std::min(size.width(), static_cast<int>(sample_count_));
          x++, i += channel_count_) {
       int y = samples_[i] * max_amplitude /
               (std::numeric_limits<int16_t>::max() + 1) + mid_height;
       *image.GetAddr32(pp::Point(x, y)) = 0xffffffff;
     }
 
     return image;
   }
 
-  // TODO(viettrungluu): Danger! We really should lock, but which thread
-  // primitives to use? In any case, the |StopCapture()| in the destructor
-  // shouldn't return until this callback is done, so at least we should be
-  // writing to a valid region of memory.
-  static void CaptureCallback(const void* samples,
-                              uint32_t num_bytes,
-                              void* ctx) {
-    MyInstance* thiz = static_cast<MyInstance*>(ctx);
-    uint32_t buffer_size =
-        thiz->sample_count_ * thiz->channel_count_ * sizeof(int16_t);
-    PP_DCHECK(num_bytes <= buffer_size);
-    PP_DCHECK(num_bytes % (thiz->channel_count_ * sizeof(int16_t)) == 0);
-    memcpy(thiz->samples_, samples, num_bytes);
-    memset(reinterpret_cast<char*>(thiz->samples_) + num_bytes, 0,
-           buffer_size - num_bytes);
-  }
+  void Open(const pp::DeviceRef_Dev& device) {
+    audio_input_.Close();
+    audio_input_ = pp::AudioInput_Dev(this);
 
-  void Open(const pp::DeviceRef_Dev& device) {
     pp::AudioConfig config = pp::AudioConfig(this,
                                              kSampleFrequency,
                                              sample_count_);
     pp::CompletionCallback callback = callback_factory_.NewCallback(
         &MyInstance::OpenFinished);
     int32_t result = audio_input_.Open(device, config, CaptureCallback, this,
                                        callback);
     if (result != PP_OK_COMPLETIONPENDING)
       PostMessage(pp::Var("OpenFailed"));
   }
 
   void Stop() {
     if (!audio_input_.StopCapture())
       PostMessage(pp::Var("StopFailed"));
   }
 
   void Start() {
     if (!audio_input_.StartCapture())
       PostMessage(pp::Var("StartFailed"));
   }
 
   void EnumerateDevicesFinished(int32_t result,
                                 std::vector<pp::DeviceRef_Dev>& devices) {
-    static const char* const kDelimiter = "#__#";
-
     if (result == PP_OK) {
-      devices_.swap(devices);
-      std::string device_names;
-      for (size_t index = 0; index < devices_.size(); ++index) {
-        pp::Var name = devices_[index].GetName();
+      enumerate_devices_.swap(devices);
+      std::string device_names = "Enumerate:";
+      for (size_t index = 0; index < enumerate_devices_.size(); ++index) {
+        pp::Var name = enumerate_devices_[index].GetName();
         PP_DCHECK(name.is_string());
 
         if (index != 0)
           device_names += kDelimiter;
         device_names += name.AsString();
       }
       PostMessage(pp::Var(device_names));
     } else {
       PostMessage(pp::Var("EnumerationFailed"));
     }
   }
 
   void OpenFinished(int32_t result) {
     if (result == PP_OK) {
       if (!audio_input_.StartCapture())
         PostMessage(pp::Var("StartFailed"));
     } else {
       PostMessage(pp::Var("OpenFailed"));
     }
   }
 
+  // TODO(viettrungluu): Danger! We really should lock, but which thread
+  // primitives to use? In any case, the |StopCapture()| in the destructor
+  // shouldn't return until this callback is done, so at least we should be
+  // writing to a valid region of memory.
+  static void CaptureCallback(const void* samples,
+                              uint32_t num_bytes,
+                              void* ctx) {
+    MyInstance* thiz = static_cast<MyInstance*>(ctx);
+    uint32_t buffer_size =
+        thiz->sample_count_ * thiz->channel_count_ * sizeof(int16_t);
+    PP_DCHECK(num_bytes <= buffer_size);
+    PP_DCHECK(num_bytes % (thiz->channel_count_ * sizeof(int16_t)) == 0);
+    memcpy(thiz->samples_, samples, num_bytes);
+    memset(reinterpret_cast<char*>(thiz->samples_) + num_bytes, 0,
+           buffer_size - num_bytes);
+  }
+
+  static void MonitorDeviceChangeCallback(void* user_data,
+                                          uint32_t device_count,
+                                          const PP_Resource devices[]) {
+    MyInstance* thiz = static_cast<MyInstance*>(user_data);
+
+    std::string device_names = "Monitor:";
+    thiz->monitor_devices_.clear();
+    thiz->monitor_devices_.reserve(device_count);
+    for (size_t index = 0; index < device_count; ++index) {
+      thiz->monitor_devices_.push_back(pp::DeviceRef_Dev(devices[index]));
+      pp::Var name = thiz->monitor_devices_.back().GetName();
+      PP_DCHECK(name.is_string());
+
+      if (index != 0)
+        device_names += kDelimiter;
+      device_names += name.AsString();
+    }
+    thiz->PostMessage(pp::Var(device_names));
+  }
+
   pp::CompletionCallbackFactory<MyInstance> callback_factory_;
 
   uint32_t sample_count_;
   uint32_t channel_count_;
   int16_t* samples_;
 
   int32_t timer_interval_;
 
   // Painting stuff.
   pp::Size size_;
   pp::Graphics2D device_context_;
   bool pending_paint_;
   bool waiting_for_flush_completion_;
 
+  // There is no need to have two resources to do capturing and device detecting
+  // separately. However, this makes the code of monitoring device change
+  // easier.
   pp::AudioInput_Dev audio_input_;
+  pp::AudioInput_Dev device_detector_;
 
-  std::vector<pp::DeviceRef_Dev> devices_;
+  std::vector<pp::DeviceRef_Dev> enumerate_devices_;
+  std::vector<pp::DeviceRef_Dev> monitor_devices_;
 };
 
 class MyModule : public pp::Module {
  public:
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new MyInstance(instance);
   }
 };
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp