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 DEVICE_HID_HID_CONNECTION_H_ 6 #define DEVICE_HID_HID_CONNECTION_H_ 7 8 #include <stdint.h> 9 10 #include "base/callback.h" 11 #include "base/memory/ref_counted.h" 12 #include "base/threading/thread_checker.h" 13 #include "device/hid/hid_device_info.h" 14 #include "net/base/io_buffer.h" 15 16 namespace device { 17 18 class HidConnection : public base::RefCountedThreadSafe<HidConnection> { 19 public: 20 enum SpecialReportIds { 21 kNullReportId = 0x00, 22 kAnyReportId = 0xFF, 23 }; 24 25 typedef base::Callback< 26 void(bool success, scoped_refptr<net::IOBuffer> buffer, size_t size)> 27 ReadCallback; 28 typedef base::Callback<void(bool success)> WriteCallback; 29 device_info()30 const HidDeviceInfo& device_info() const { return device_info_; } has_protected_collection()31 bool has_protected_collection() const { return has_protected_collection_; } thread_checker()32 const base::ThreadChecker& thread_checker() const { return thread_checker_; } closed()33 bool closed() const { return closed_; } 34 35 // Closes the connection. This must be called before the object is freed. 36 void Close(); 37 38 // The report ID (or 0 if report IDs are not supported by the device) is 39 // always returned in the first byte of the buffer. 40 void Read(const ReadCallback& callback); 41 42 // The report ID (or 0 if report IDs are not supported by the device) is 43 // always expected in the first byte of the buffer. 44 void Write(scoped_refptr<net::IOBuffer> buffer, 45 size_t size, 46 const WriteCallback& callback); 47 48 // The report ID is not returned in the buffer. 49 void GetFeatureReport(uint8_t report_id, const ReadCallback& callback); 50 51 // The report ID (or 0 if report IDs are not supported by the device) is 52 // always expected in the first byte of the buffer. 53 void SendFeatureReport(scoped_refptr<net::IOBuffer> buffer, 54 size_t size, 55 const WriteCallback& callback); 56 57 protected: 58 friend class base::RefCountedThreadSafe<HidConnection>; 59 60 explicit HidConnection(const HidDeviceInfo& device_info); 61 virtual ~HidConnection(); 62 63 virtual void PlatformClose() = 0; 64 virtual void PlatformRead(const ReadCallback& callback) = 0; 65 virtual void PlatformWrite(scoped_refptr<net::IOBuffer> buffer, 66 size_t size, 67 const WriteCallback& callback) = 0; 68 virtual void PlatformGetFeatureReport(uint8_t report_id, 69 const ReadCallback& callback) = 0; 70 virtual void PlatformSendFeatureReport(scoped_refptr<net::IOBuffer> buffer, 71 size_t size, 72 const WriteCallback& callback) = 0; 73 74 // PlatformRead implementation must call this method on read 75 // success, rather than directly running the callback. 76 // In case incoming buffer is empty or protected, it is filtered 77 // and this method returns false. Otherwise it runs the callback 78 // and returns true. 79 bool CompleteRead(scoped_refptr<net::IOBuffer> buffer, 80 size_t size, 81 const ReadCallback& callback); 82 83 private: 84 bool IsReportIdProtected(uint8_t report_id); 85 86 const HidDeviceInfo device_info_; 87 bool has_protected_collection_; 88 base::ThreadChecker thread_checker_; 89 bool closed_; 90 91 DISALLOW_COPY_AND_ASSIGN(HidConnection); 92 }; 93 94 struct PendingHidReport { 95 PendingHidReport(); 96 ~PendingHidReport(); 97 98 scoped_refptr<net::IOBuffer> buffer; 99 size_t size; 100 }; 101 102 struct PendingHidRead { 103 PendingHidRead(); 104 ~PendingHidRead(); 105 106 HidConnection::ReadCallback callback; 107 }; 108 109 } // namespace device 110 111 #endif // DEVICE_HID_HID_CONNECTION_H_ 112