chrome/browser/devtools/device/usb/android_usb_device.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_USB_ANDROID_USB_DEVICE_H_
   6 #define CHROME_BROWSER_DEVTOOLS_DEVICE_USB_ANDROID_USB_DEVICE_H_
   7
   8 #include <map>
   9 #include <queue>
  10 #include <vector>
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "components/usb_service/usb_device_handle.h"
  14
  15 namespace base {
  16 class MessageLoop;
  17 }
  18
  19 namespace crypto {
  20 class RSAPrivateKey;
  21 }
  22
  23 namespace net {
  24 class StreamSocket;
  25 }
  26
  27 class AndroidUsbSocket;
  28
  29 class AdbMessage : public base::RefCounted<AdbMessage> {
  30  public:
  31   enum Command {
  32     kCommandSYNC = 0x434e5953,
  33     kCommandCNXN = 0x4e584e43,
  34     kCommandOPEN = 0x4e45504f,
  35     kCommandOKAY = 0x59414b4f,
  36     kCommandCLSE = 0x45534c43,
  37     kCommandWRTE = 0x45545257,
  38     kCommandAUTH = 0x48545541
  39   };
  40
  41   enum Auth {
  42     kAuthToken = 1,
  43     kAuthSignature = 2,
  44     kAuthRSAPublicKey = 3
  45   };
  46
  47   AdbMessage(uint32 command,
  48              uint32 arg0,
  49              uint32 arg1,
  50              const std::string& body);
  51
  52   uint32 command;
  53   uint32 arg0;
  54   uint32 arg1;
  55   std::string body;
  56  private:
  57   friend class base::RefCounted<AdbMessage>;
  58   ~AdbMessage();
  59
  60   DISALLOW_COPY_AND_ASSIGN(AdbMessage);
  61 };
  62
  63 class AndroidUsbDevice;
  64 typedef std::vector<scoped_refptr<AndroidUsbDevice> > AndroidUsbDevices;
  65 typedef base::Callback<void(const AndroidUsbDevices&)>
  66     AndroidUsbDevicesCallback;
  67
  68 class AndroidUsbDevice : public base::RefCountedThreadSafe<AndroidUsbDevice> {
  69  public:
  70   static void Enumerate(crypto::RSAPrivateKey* rsa_key,
  71                         const AndroidUsbDevicesCallback& callback);
  72
  73   static void CountDevices(const base::Callback<void(int)>& callback);
  74
  75   AndroidUsbDevice(crypto::RSAPrivateKey* rsa_key,
  76                    scoped_refptr<usb_service::UsbDeviceHandle> device,
  77                    const std::string& serial,
  78                    int inbound_address,
  79                    int outbound_address,
  80                    int zero_mask,
  81                    int interface_id);
  82
  83   void InitOnCallerThread();
  84
  85   net::StreamSocket* CreateSocket(const std::string& command);
  86
  87   void Send(uint32 command,
  88             uint32 arg0,
  89             uint32 arg1,
  90             const std::string& body);
  91
  92   scoped_refptr<usb_service::UsbDeviceHandle> usb_device() {
  93     return usb_handle_;
  94   }
  95
  96   std::string serial() { return serial_; }
  97
  98   bool is_connected() { return is_connected_; }
  99
 100  private:
 101   friend class base::RefCountedThreadSafe<AndroidUsbDevice>;
 102   virtual ~AndroidUsbDevice();
 103
 104   void Queue(scoped_refptr<AdbMessage> message);
 105   void ProcessOutgoing();
 106   void OutgoingMessageSent(usb_service::UsbTransferStatus status,
 107                            scoped_refptr<net::IOBuffer> buffer,
 108                            size_t result);
 109
 110   void ReadHeader();
 111   void ParseHeader(usb_service::UsbTransferStatus status,
 112                    scoped_refptr<net::IOBuffer> buffer,
 113                    size_t result);
 114
 115   void ReadBody(scoped_refptr<AdbMessage> message,
 116                 uint32 data_length,
 117                 uint32 data_check);
 118   void ParseBody(scoped_refptr<AdbMessage> message,
 119                  uint32 data_length,
 120                  uint32 data_check,
 121                  usb_service::UsbTransferStatus status,
 122                  scoped_refptr<net::IOBuffer> buffer,
 123                  size_t result);
 124
 125   void HandleIncoming(scoped_refptr<AdbMessage> message);
 126
 127   void TransferError(usb_service::UsbTransferStatus status);
 128
 129   void TerminateIfReleased(
 130       scoped_refptr<usb_service::UsbDeviceHandle> usb_handle);
 131   void Terminate();
 132
 133   void SocketDeleted(uint32 socket_id);
 134
 135   base::MessageLoop* message_loop_;
 136
 137   scoped_ptr<crypto::RSAPrivateKey> rsa_key_;
 138
 139   // Device info
 140   scoped_refptr<usb_service::UsbDeviceHandle> usb_handle_;
 141   std::string serial_;
 142   int inbound_address_;
 143   int outbound_address_;
 144   int zero_mask_;
 145   int interface_id_;
 146
 147   bool is_connected_;
 148   bool signature_sent_;
 149
 150   // Created sockets info
 151   uint32 last_socket_id_;
 152   typedef std::map<uint32, AndroidUsbSocket*> AndroidUsbSockets;
 153   AndroidUsbSockets sockets_;
 154
 155   // Outgoing bulk queue
 156   typedef std::pair<scoped_refptr<net::IOBuffer>, size_t> BulkMessage;
 157   std::queue<BulkMessage> outgoing_queue_;
 158
 159   // Outgoing messages pending connect
 160   typedef std::vector<scoped_refptr<AdbMessage> > PendingMessages;
 161   PendingMessages pending_messages_;
 162
 163   base::WeakPtrFactory<AndroidUsbDevice> weak_factory_;
 164
 165   DISALLOW_COPY_AND_ASSIGN(AndroidUsbDevice);
 166 };
 167
 168 #endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_USB_ANDROID_USB_DEVICE_H_