chrome/browser/devtools/adb/android_usb_device.h

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