src/chrome/browser/devtools/device/android_device_manager.h

   1 // Copyright 2014 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 CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_
   6 #define CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_
   7
   8 #include <vector>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "base/threading/non_thread_safe.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "ui/gfx/size.h"
  15
  16 namespace net {
  17 class StreamSocket;
  18 }
  19
  20 class AndroidDeviceManager
  21     : public base::RefCountedThreadSafe<
  22           AndroidDeviceManager,
  23           content::BrowserThread::DeleteOnUIThread>,
  24       public base::NonThreadSafe {
  25  public:
  26   typedef base::Callback<void(int, const std::string&)> CommandCallback;
  27   typedef base::Callback<void(int result, scoped_ptr<net::StreamSocket>)>
  28       SocketCallback;
  29   typedef base::Callback<void(const std::vector<std::string>&)> SerialsCallback;
  30
  31   struct BrowserInfo {
  32     BrowserInfo();
  33
  34     enum Type {
  35       kTypeChrome,
  36       kTypeWebView,
  37       kTypeOther
  38     };
  39
  40     std::string socket_name;
  41     std::string display_name;
  42     Type type;
  43   };
  44
  45   struct DeviceInfo {
  46     DeviceInfo();
  47     ~DeviceInfo();
  48
  49     std::string model;
  50     bool connected;
  51     gfx::Size screen_size;
  52     std::vector<BrowserInfo> browser_info;
  53   };
  54
  55   typedef base::Callback<void(const DeviceInfo&)> DeviceInfoCallback;
  56   class Device;
  57
  58   class AndroidWebSocket {
  59    public:
  60     class Delegate {
  61      public:
  62       virtual void OnSocketOpened() = 0;
  63       virtual void OnFrameRead(const std::string& message) = 0;
  64       virtual void OnSocketClosed() = 0;
  65
  66      protected:
  67       virtual ~Delegate() {}
  68     };
  69
  70     ~AndroidWebSocket();
  71
  72     void SendFrame(const std::string& message);
  73
  74    private:
  75     friend class Device;
  76     class WebSocketImpl;
  77
  78     AndroidWebSocket(
  79         scoped_refptr<Device> device,
  80         const std::string& socket_name,
  81         const std::string& url,
  82         AndroidWebSocket::Delegate* delegate);
  83     void Connected(int result, scoped_ptr<net::StreamSocket> socket);
  84     void OnFrameRead(const std::string& message);
  85     void OnSocketClosed();
  86     void Terminate();
  87
  88     Device* device_;
  89     WebSocketImpl* socket_impl_;
  90     Delegate* delegate_;
  91     base::WeakPtrFactory<AndroidWebSocket> weak_factory_;
  92     DISALLOW_COPY_AND_ASSIGN(AndroidWebSocket);
  93   };
  94
  95   class DeviceProvider;
  96
  97   class Device : public base::RefCountedThreadSafe<Device>,
  98                  public base::NonThreadSafe {
  99    public:
 100     void QueryDeviceInfo(const DeviceInfoCallback& callback);
 101
 102     void OpenSocket(const std::string& socket_name,
 103                     const SocketCallback& callback);
 104
 105     void SendJsonRequest(const std::string& socket_name,
 106                          const std::string& request,
 107                          const CommandCallback& callback);
 108
 109     void HttpUpgrade(const std::string& socket_name,
 110                      const std::string& url,
 111                      const SocketCallback& callback);
 112     AndroidWebSocket* CreateWebSocket(
 113         const std::string& socket_name,
 114         const std::string& url,
 115         AndroidWebSocket::Delegate* delegate);
 116
 117     std::string serial() { return serial_; }
 118
 119    private:
 120     friend class base::RefCountedThreadSafe<Device>;
 121     friend class AndroidDeviceManager;
 122     friend class AndroidWebSocket;
 123
 124     Device(scoped_refptr<base::MessageLoopProxy> device_message_loop,
 125            scoped_refptr<DeviceProvider> provider,
 126            const std::string& serial);
 127
 128     virtual ~Device();
 129
 130     scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
 131     scoped_refptr<DeviceProvider> provider_;
 132     std::string serial_;
 133     std::set<AndroidWebSocket*> sockets_;
 134     base::WeakPtrFactory<Device> weak_factory_;
 135
 136     DISALLOW_COPY_AND_ASSIGN(Device);
 137   };
 138
 139   typedef std::vector<scoped_refptr<Device> > Devices;
 140   typedef base::Callback<void(const Devices&)> DevicesCallback;
 141
 142   class DeviceProvider : public base::RefCountedThreadSafe<DeviceProvider> {
 143    public:
 144     typedef AndroidDeviceManager::SerialsCallback SerialsCallback;
 145     typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
 146     typedef AndroidDeviceManager::SocketCallback SocketCallback;
 147     typedef AndroidDeviceManager::CommandCallback CommandCallback;
 148
 149     virtual void QueryDevices(const SerialsCallback& callback) = 0;
 150
 151     virtual void QueryDeviceInfo(const std::string& serial,
 152                                  const DeviceInfoCallback& callback) = 0;
 153
 154     virtual void OpenSocket(const std::string& serial,
 155                             const std::string& socket_name,
 156                             const SocketCallback& callback) = 0;
 157
 158     virtual void SendJsonRequest(const std::string& serial,
 159                                  const std::string& socket_name,
 160                                  const std::string& request,
 161                                  const CommandCallback& callback);
 162
 163     virtual void HttpUpgrade(const std::string& serial,
 164                              const std::string& socket_name,
 165                              const std::string& url,
 166                              const SocketCallback& callback);
 167
 168     virtual void ReleaseDevice(const std::string& serial);
 169
 170    protected:
 171     friend class base::RefCountedThreadSafe<DeviceProvider>;
 172     DeviceProvider();
 173     virtual ~DeviceProvider();
 174   };
 175
 176   typedef std::vector<scoped_refptr<DeviceProvider> > DeviceProviders;
 177
 178   static scoped_refptr<AndroidDeviceManager> Create();
 179
 180   void SetDeviceProviders(const DeviceProviders& providers);
 181
 182   void QueryDevices(const DevicesCallback& callback);
 183
 184   struct DeviceDescriptor {
 185     DeviceDescriptor();
 186     ~DeviceDescriptor();
 187
 188     scoped_refptr<DeviceProvider> provider;
 189     std::string serial;
 190   };
 191
 192   typedef std::vector<DeviceDescriptor> DeviceDescriptors;
 193
 194  private:
 195   class HandlerThread : public base::RefCountedThreadSafe<HandlerThread> {
 196    public:
 197     static scoped_refptr<HandlerThread> GetInstance();
 198     scoped_refptr<base::MessageLoopProxy> message_loop();
 199
 200    private:
 201     friend class base::RefCountedThreadSafe<HandlerThread>;
 202     static HandlerThread* instance_;
 203     static void StopThread(base::Thread* thread);
 204
 205     HandlerThread();
 206     virtual ~HandlerThread();
 207     base::Thread* thread_;
 208   };
 209
 210   friend struct content::BrowserThread::DeleteOnThread<
 211       content::BrowserThread::UI>;
 212   friend class base::DeleteHelper<AndroidDeviceManager>;
 213   AndroidDeviceManager();
 214   virtual ~AndroidDeviceManager();
 215
 216   void UpdateDevices(const DevicesCallback& callback,
 217                      DeviceDescriptors* descriptors);
 218
 219   typedef std::map<std::string, base::WeakPtr<Device> > DeviceWeakMap;
 220
 221   scoped_refptr<HandlerThread> handler_thread_;
 222   DeviceProviders providers_;
 223   DeviceWeakMap devices_;
 224 };
 225
 226 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_ANDROID_DEVICE_MANAGER_H_