1// Copyright 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 DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_MAC_H_
6#define DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_MAC_H_
7
8#include <queue>
9#include <string>
10
11#import <IOBluetooth/IOBluetooth.h>
12#import <IOKit/IOReturn.h>
13
14#include "base/mac/scoped_nsobject.h"
15#include "base/memory/linked_ptr.h"
16#include "base/memory/ref_counted.h"
17#include "base/memory/scoped_ptr.h"
18#include "base/threading/thread_checker.h"
19#include "device/bluetooth/bluetooth_adapter.h"
20#include "device/bluetooth/bluetooth_socket.h"
21#include "device/bluetooth/bluetooth_uuid.h"
22
23@class BluetoothRfcommConnectionListener;
24@class BluetoothL2capConnectionListener;
25
26namespace net {
27class IOBuffer;
28class IOBufferWithSize;
29}
30
31namespace device {
32
33class BluetoothAdapterMac;
34class BluetoothChannelMac;
35
36// Implements the BluetoothSocket class for the Mac OS X platform.
37class BluetoothSocketMac : public BluetoothSocket {
38 public:
39  static scoped_refptr<BluetoothSocketMac> CreateSocket();
40
41  // Connects this socket to the service on |device| published as UUID |uuid|.
42  // The underlying protocol and PSM or Channel is obtained through service
43  // discovery. On a successful connection, the socket properties will be
44  // updated and |success_callback| called. On failure, |error_callback| will be
45  // called with a message explaining the cause of failure.
46  void Connect(IOBluetoothDevice* device,
47               const BluetoothUUID& uuid,
48               const base::Closure& success_callback,
49               const ErrorCompletionCallback& error_callback);
50
51  // Listens for incoming RFCOMM connections using this socket: Publishes an
52  // RFCOMM service on the |adapter| as UUID |uuid| with Channel
53  // |options.channel|, or an automatically allocated Channel if
54  // |options.channel| is left null. The service is published with English name
55  // |options.name| if that is non-null. |success_callback| will be called if
56  // the service is successfully registered, |error_callback| on failure with a
57  // message explaining the cause.
58  void ListenUsingRfcomm(scoped_refptr<BluetoothAdapterMac> adapter,
59                         const BluetoothUUID& uuid,
60                         const BluetoothAdapter::ServiceOptions& options,
61                         const base::Closure& success_callback,
62                         const ErrorCompletionCallback& error_callback);
63
64  // Listens for incoming L2CAP connections using this socket: Publishes an
65  // L2CAP service on the |adapter| as UUID |uuid| with PSM |options.psm|, or an
66  // automatically allocated PSM if |options.psm| is left null. The service is
67  // published with English name |options.name| if that is non-null.
68  // |success_callback| will be called if the service is successfully
69  // registered, |error_callback| on failure with a message explaining the
70  // cause.
71  void ListenUsingL2cap(scoped_refptr<BluetoothAdapterMac> adapter,
72                        const BluetoothUUID& uuid,
73                        const BluetoothAdapter::ServiceOptions& options,
74                        const base::Closure& success_callback,
75                        const ErrorCompletionCallback& error_callback);
76
77  // BluetoothSocket:
78  virtual void Close() OVERRIDE;
79  virtual void Disconnect(const base::Closure& callback) OVERRIDE;
80  virtual void Receive(
81      int /* buffer_size */,
82      const ReceiveCompletionCallback& success_callback,
83      const ReceiveErrorCompletionCallback& error_callback) OVERRIDE;
84  virtual void Send(scoped_refptr<net::IOBuffer> buffer,
85                    int buffer_size,
86                    const SendCompletionCallback& success_callback,
87                    const ErrorCompletionCallback& error_callback) OVERRIDE;
88  virtual void Accept(const AcceptCompletionCallback& success_callback,
89                      const ErrorCompletionCallback& error_callback) OVERRIDE;
90
91  // Callback that is invoked when the OS completes an SDP query.
92  // |status| is the returned status from the SDP query, |device| is the
93  // IOBluetoothDevice for which the query was made. The remaining
94  // parameters are those from |Connect()|.
95  void OnSDPQueryComplete(
96      IOReturn status,
97      IOBluetoothDevice* device,
98      const base::Closure& success_callback,
99      const ErrorCompletionCallback& error_callback);
100
101  // Called by BluetoothRfcommConnectionListener and
102  // BluetoothL2capConnectionListener.
103  void OnChannelOpened(scoped_ptr<BluetoothChannelMac> channel);
104
105  // Called by |channel_|.
106  // Note: OnChannelOpenComplete might be called before the |channel_| is set.
107  void OnChannelOpenComplete(const std::string& device_address,
108                             IOReturn status);
109  void OnChannelClosed();
110  void OnChannelDataReceived(void* data, size_t length);
111  void OnChannelWriteComplete(void* refcon, IOReturn status);
112
113 private:
114  struct AcceptRequest {
115    AcceptRequest();
116    ~AcceptRequest();
117
118    AcceptCompletionCallback success_callback;
119    ErrorCompletionCallback error_callback;
120  };
121
122  struct SendRequest {
123    SendRequest();
124    ~SendRequest();
125    int buffer_size;
126    SendCompletionCallback success_callback;
127    ErrorCompletionCallback error_callback;
128    IOReturn status;
129    int active_async_writes;
130    bool error_signaled;
131  };
132
133  struct ReceiveCallbacks {
134    ReceiveCallbacks();
135    ~ReceiveCallbacks();
136    ReceiveCompletionCallback success_callback;
137    ReceiveErrorCompletionCallback error_callback;
138  };
139
140  struct ConnectCallbacks {
141    ConnectCallbacks();
142    ~ConnectCallbacks();
143    base::Closure success_callback;
144    ErrorCompletionCallback error_callback;
145  };
146
147  BluetoothSocketMac();
148  virtual ~BluetoothSocketMac();
149
150  // Accepts a single incoming connection.
151  void AcceptConnectionRequest();
152
153  void ReleaseChannel();
154  void ReleaseListener();
155
156  bool is_connecting() const { return connect_callbacks_; }
157
158  // Used to verify that all methods are called on the same thread.
159  base::ThreadChecker thread_checker_;
160
161  // Adapter the socket is registered against. This is only present when the
162  // socket is listening.
163  scoped_refptr<BluetoothAdapterMac> adapter_;
164
165  // UUID of the profile being connected to, or that the socket is listening on.
166  device::BluetoothUUID uuid_;
167
168  // Simple helpers that register for OS notifications and forward them to
169  // |this| profile.
170  base::scoped_nsobject<BluetoothRfcommConnectionListener>
171      rfcomm_connection_listener_;
172  base::scoped_nsobject<BluetoothL2capConnectionListener>
173      l2cap_connection_listener_;
174
175  // A handle to the service record registered in the system SDP server.
176  // Used to eventually unregister the service.
177  BluetoothSDPServiceRecordHandle service_record_handle_;
178
179  // The channel used to issue commands.
180  scoped_ptr<BluetoothChannelMac> channel_;
181
182  // Connection callbacks -- when a pending async connection is active.
183  scoped_ptr<ConnectCallbacks> connect_callbacks_;
184
185  // Packets received while there is no pending "receive" callback.
186  std::queue<scoped_refptr<net::IOBufferWithSize> > receive_queue_;
187
188  // Receive callbacks -- when a receive call is active.
189  scoped_ptr<ReceiveCallbacks> receive_callbacks_;
190
191  // Send queue -- one entry per pending send operation.
192  std::queue<linked_ptr<SendRequest>> send_queue_;
193
194  // The pending request to an Accept() call, or null if there is no pending
195  // request.
196  scoped_ptr<AcceptRequest> accept_request_;
197
198  // Queue of incoming connections.
199  std::queue<linked_ptr<BluetoothChannelMac>> accept_queue_;
200
201  DISALLOW_COPY_AND_ASSIGN(BluetoothSocketMac);
202};
203
204}  // namespace device
205
206#endif  // DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_MAC_H_
207