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