1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include <assert.h> 6#include <string.h> 7 8#include <vector> 9 10#include "ppapi/c/dev/ppb_video_capture_dev.h" 11#include "ppapi/c/pp_errors.h" 12#include "ppapi/cpp/dev/device_ref_dev.h" 13#include "ppapi/cpp/dev/video_capture_dev.h" 14#include "ppapi/cpp/dev/video_capture_client_dev.h" 15#include "ppapi/cpp/completion_callback.h" 16#include "ppapi/cpp/instance.h" 17#include "ppapi/cpp/module.h" 18#include "ppapi/cpp/private/flash.h" 19#include "ppapi/cpp/var.h" 20#include "ppapi/utility/completion_callback_factory.h" 21 22// When compiling natively on Windows, PostMessage can be #define-d to 23// something else. 24#ifdef PostMessage 25#undef PostMessage 26#endif 27 28namespace { 29 30// This object is the global object representing this plugin library as long 31// as it is loaded. 32class EnumerateDevicesDemoModule : public pp::Module { 33 public: 34 EnumerateDevicesDemoModule() : pp::Module() {} 35 virtual ~EnumerateDevicesDemoModule() {} 36 virtual pp::Instance* CreateInstance(PP_Instance instance); 37}; 38 39class EnumerateDevicesDemoInstance : public pp::Instance, 40 public pp::VideoCaptureClient_Dev { 41 public: 42 EnumerateDevicesDemoInstance(PP_Instance instance, pp::Module* module); 43 virtual ~EnumerateDevicesDemoInstance(); 44 45 // pp::Instance implementation (see PPP_Instance). 46 virtual void HandleMessage(const pp::Var& message_data); 47 48 // pp::VideoCaptureClient_Dev implementation. 49 virtual void OnDeviceInfo(PP_Resource resource, 50 const PP_VideoCaptureDeviceInfo_Dev& info, 51 const std::vector<pp::Buffer_Dev>& buffers) {} 52 virtual void OnStatus(PP_Resource resource, uint32_t status) {} 53 virtual void OnError(PP_Resource resource, uint32_t error) {} 54 virtual void OnBufferReady(PP_Resource resource, uint32_t buffer) {} 55 56 private: 57 void EnumerateDevicesFinished(int32_t result, 58 std::vector<pp::DeviceRef_Dev>& devices); 59 60 pp::VideoCapture_Dev video_capture_; 61 pp::CompletionCallbackFactory<EnumerateDevicesDemoInstance> callback_factory_; 62 63 std::vector<pp::DeviceRef_Dev> devices_; 64}; 65 66EnumerateDevicesDemoInstance::EnumerateDevicesDemoInstance(PP_Instance instance, 67 pp::Module* module) 68 : pp::Instance(instance), 69 pp::VideoCaptureClient_Dev(this), 70 video_capture_(this), 71 callback_factory_(this) { 72} 73 74EnumerateDevicesDemoInstance::~EnumerateDevicesDemoInstance() { 75} 76 77void EnumerateDevicesDemoInstance::HandleMessage(const pp::Var& message_data) { 78 if (message_data.is_string()) { 79 std::string event = message_data.AsString(); 80 if (event == "EnumerateDevicesAsync") { 81 pp::CompletionCallbackWithOutput<std::vector<pp::DeviceRef_Dev> > 82 callback = callback_factory_.NewCallbackWithOutput( 83 &EnumerateDevicesDemoInstance::EnumerateDevicesFinished); 84 video_capture_.EnumerateDevices(callback); 85 } else if (event == "EnumerateDevicesSync") { 86 std::vector<pp::DeviceRef_Dev> devices; 87 int32_t result = pp::flash::Flash::EnumerateVideoCaptureDevices( 88 this, video_capture_, &devices); 89 EnumerateDevicesFinished(result, devices); 90 } 91 } 92} 93 94void EnumerateDevicesDemoInstance::EnumerateDevicesFinished( 95 int32_t result, 96 std::vector<pp::DeviceRef_Dev>& devices) { 97 static const char* const kDelimiter = "#__#"; 98 99 if (result == PP_OK) { 100 devices_.swap(devices); 101 std::string device_names; 102 for (size_t index = 0; index < devices_.size(); ++index) { 103 pp::Var name = devices_[index].GetName(); 104 assert(name.is_string()); 105 106 if (index != 0) 107 device_names += kDelimiter; 108 device_names += name.AsString(); 109 } 110 PostMessage(pp::Var("EnumerationSuccess" + device_names)); 111 } else { 112 PostMessage(pp::Var("EnumerationFailed")); 113 } 114} 115 116pp::Instance* EnumerateDevicesDemoModule::CreateInstance(PP_Instance instance) { 117 return new EnumerateDevicesDemoInstance(instance, this); 118} 119 120} // anonymous namespace 121 122namespace pp { 123// Factory function for your specialization of the Module object. 124Module* CreateModule() { 125 return new EnumerateDevicesDemoModule(); 126} 127} // namespace pp 128