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
15namespace base {
16class MessageLoop;
17}
18
19namespace crypto {
20class RSAPrivateKey;
21}
22
23namespace net {
24class StreamSocket;
25}
26
27class AndroidUsbSocket;
28
29class 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
63class AndroidUsbDevice;
64typedef std::vector<scoped_refptr<AndroidUsbDevice> > AndroidUsbDevices;
65typedef base::Callback<void(const AndroidUsbDevices&)>
66    AndroidUsbDevicesCallback;
67
68class 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 scoped_refptr<net::IOBufferWithSize> 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_
169