extensions/browser/api/webcam_private/visca_webcam.h

   1 // Copyright 2015 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 #ifndef EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_VISCA_WEBCAM_H_
   6 #define EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_VISCA_WEBCAM_H_
   7
   8 #include <deque>
   9
  10 #include "base/callback.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "extensions/browser/api/serial/serial_connection.h"
  13 #include "extensions/browser/api/webcam_private/webcam.h"
  14 #include "extensions/common/api/serial.h"
  15
  16 namespace extensions {
  17
  18 class ViscaWebcam : public Webcam {
  19  public:
  20   ViscaWebcam(const std::string& path, const std::string& extension_id);
  21   ~ViscaWebcam() override;
  22
  23   using OpenCompleteCallback = base::Callback<void(bool)>;
  24
  25   // Open and initialize the web camera. This is done by the following three
  26   // steps (in order): 1. Open the serial port;  2. Request address; 3. Clear
  27   // the command buffer. After these three steps completes, |open_callback| will
  28   // be called.
  29   void Open(const OpenCompleteCallback& open_callback);
  30
  31  private:
  32   enum CommandType {
  33     COMMAND,
  34     INQUIRY_PAN,
  35     INQUIRY_TILT,
  36     INQUIRY_PAN_TILT,
  37     INQUIRY_ZOOM,
  38   };
  39
  40   using CommandCompleteCallback =
  41       base::Callback<void(bool, const std::vector<char>&)>;
  42
  43   void OpenOnIOThread(const OpenCompleteCallback& open_callback);
  44   // Callback function that will be called after the serial connection has been
  45   // opened successfully.
  46   void OnConnected(const OpenCompleteCallback& open_callback, bool success);
  47   // Callback function that will be called after the address has been set
  48   // successfully.
  49   void OnAddressSetCompleted(const OpenCompleteCallback& open_callback,
  50                              bool success,
  51                              const std::vector<char>& response);
  52   // Callback function that will be called after the command buffer has been
  53   // cleared successfully.
  54   void OnClearAllCompleted(const OpenCompleteCallback& open_callback,
  55                            bool success,
  56                            const std::vector<char>& response);
  57
  58   // Send or queue a command and wait for the camera's response.
  59   void Send(const std::vector<char>& command,
  60             const CommandCompleteCallback& callback);
  61   void OnSendCompleted(const CommandCompleteCallback& callback,
  62                        int bytes_sent,
  63                        core_api::serial::SendError error);
  64   void ReceiveLoop(const CommandCompleteCallback& callback);
  65   void OnReceiveCompleted(const CommandCompleteCallback& callback,
  66                           const std::vector<char>& data,
  67                           core_api::serial::ReceiveError error);
  68   // Callback function that will be called after the send and reply of a command
  69   // are both completed. Update |value| according to |type| and |response| if
  70   // necessory.
  71   void OnCommandCompleted(CommandType type,
  72                           int* value,
  73                           bool success,
  74                           const std::vector<char>& response);
  75
  76   // Webcam Overrides:
  77   void Reset(bool pan, bool tilt, bool zoom) override;
  78   bool GetPan(int* value) override;
  79   bool GetTilt(int* value) override;
  80   bool GetZoom(int* value) override;
  81   bool SetPan(int value) override;
  82   bool SetTilt(int value) override;
  83   bool SetZoom(int value) override;
  84   bool SetPanDirection(PanDirection direction) override;
  85   bool SetTiltDirection(TiltDirection direction) override;
  86
  87   const std::string path_;
  88   const std::string extension_id_;
  89
  90   scoped_ptr<SerialConnection> serial_connection_;
  91
  92   // Stores the response for the current command.
  93   std::vector<char> data_buffer_;
  94   // Queues commands till the current command completes.
  95   std::deque<std::pair<std::vector<char>, CommandCompleteCallback>> commands_;
  96
  97   // Visca webcam always get/set pan-tilt together. |pan| and |tilt| are used to
  98   // store the current value of pan and tilt positions.
  99   int pan_;
 100   int tilt_;
 101
 102   base::WeakPtrFactory<ViscaWebcam> weak_ptr_factory_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(ViscaWebcam);
 105 };
 106
 107 }  // namespace extensions
 108
 109 #endif  // EXTENSIONS_BROWSER_API_WEBCAM_PRIVATE_VISCA_WEBCAM_H_