1 /*
2  * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef TRANSPORT_RFCOMM_H
17 #define TRANSPORT_RFCOMM_H
18 
19 #include <map>
20 #include <mutex>
21 #include <stdint.h>
22 #include "dispatcher.h"
23 #include "packet.h"
24 #include "raw_address.h"
25 #include "rfcomm.h"
26 #include "transport.h"
27 
28 namespace OHOS {
29 namespace bluetooth {
30 /**
31  * @brief This RfcommTransport class provides a set of methods that is interactive with RFCOMM.
32  */
33 class RfcommTransport : public DataTransport {
34 public:
35     /**
36      * @brief Constructor.
37      */
38     RfcommTransport(const RawAddress *addr, uint8_t scn, uint16_t mtu, DataTransportObserver &observer,
39         utility::Dispatcher &dispatcher);
40 
41     /**
42      * @brief Destructor.
43      */
44     virtual ~RfcommTransport();
45 
46     /**
47      * @brief The client initiates the connection.
48      *
49      * @return int
50      */
51     int Connect() override;
52 
53     /**
54      * @brief The client initiates the disconnection request.
55      *
56      * @return int
57      */
58     int Disconnect() override;
59 
60     /**
61      * @brief The server register to RFCOMM.
62      *
63      * @return int
64      */
65     int RegisterServer() override;
66 
67     /**
68      * @brief Close server.
69      *
70      * @return int
71      */
72     int RemoveServer(bool isDisable = true) override;
73 
74     /**
75      * @brief The server accept the connection.
76      *
77      * @param addr remote device address.
78      * @param scn the server channel.
79      * @return int
80      */
81     int AcceptConnection(const RawAddress &addr, uint16_t scn) override;
82 
83     /**
84      * @brief The server reject the connection.
85      *
86      * @param addr remote device address.
87      * @param scn the server channel.
88      * @return int
89      */
90     int RejectConnection(const RawAddress &addr, uint16_t scn) override;
91 
92     /**
93      * @brief Receive data from RFCOMM.
94      * @param pkt
95      * @return int
96      */
97     int Read(Packet **pkt) override;
98 
99     /**
100      * @brief Send data to RFCOMM.
101      *
102      * @param pkt
103      * @return int
104      */
105     int Write(Packet *pkt) override;
106 
107     /**
108      * @brief Get the remote device address.
109      *
110      * @return BtAddr
111      */
112     RawAddress GetRemoteAddress() override;
113 
114 private:
115     // remote device address.
116     RawAddress remoteAddr_ {};
117     // server channel number.
118     uint8_t scn_ {0};
119     // mtu
120     uint16_t mtu_ {0};
121     // is server or not.
122     bool isServer_ {false};
123 
124     // RFCOMM connection handle.
125     uint16_t rfcHandle_ {0};
126     // std::mutex mutex_;
127     std::mutex transportMutex_ {};
128     // The map manages the correspondence between new transport and rfcomm handle.
129     std::map<uint16_t, RfcommTransport *> transportMap_ {};
130     // The map manages the correspondence between new transport and rfcomm handle.
131     std::map<RfcommTransport *, RawAddress> remoteAddrMap_ {};
132     // The map manages the correspondence between remote address and rfcomm handle.
133     std::map<uint16_t, RawAddress> addressMap_ {};
134     // The map manages the correspondence between remote address and rfcomm handle.
135     std::map<RawAddress, uint16_t> handleMap_ {};
136     // the pointer of the DataTransportObserver
137     DataTransportObserver &observer_;
138     utility::Dispatcher &dispatcher_;
139 
140     /**
141      * @brief is server or not.
142      *
143      * @return true the role is server.
144      * @return false the role is client
145      */
IsServer()146     bool IsServer() const
147     {
148         return isServer_;
149     }
150 
151     /**
152      * @brief When server accept a connection request, generate a new transport.
153      *
154      * @param addr remote device address.
155      * @param handle rfcomm connection handle.
156      * @return RfcommTransport*
157      */
158     RfcommTransport *AddTransportInternal(RawAddress addr, uint16_t handle);
159 
160     /**
161      * @brief Rfcomm event
162      *
163      * @param cid Rfcomm connection handle.
164      * @param event Rfcomm event.
165      * @param event_data Rfcomm event data.
166      * @param context transport object.
167      */
168     static void TransportRfcEventCallback(uint16_t handle, uint32_t event, const void *eventData, void *context);
169 
170     /**
171      * @brief Rfcomm event of connect success.
172      *
173      * @param cid Rfcomm connection handle.
174      * @param event Rfcomm event.
175      * @param event_data Rfcomm event data.
176      * @param context transport object.
177      */
178     static void TransportRfcConnectSuccess(uint16_t handle, const void *eventData, RfcommTransport *transport);
179 
180     /**
181      * @brief Rfcomm event of connect fail.
182      *
183      * @param cid Rfcomm connection handle.
184      * @param event Rfcomm event.
185      * @param event_data Rfcomm event data.
186      * @param context transport object.
187      */
188     static void TransportRfcConnectFail(uint16_t handle, RfcommTransport *transport);
189 
190     /**
191      * @brief Rfcomm event of disconnected.
192      *
193      * @param cid Rfcomm connection handle.
194      * @param event Rfcomm event.
195      * @param event_data Rfcomm event data.
196      * @param context transport object.
197      */
198     static void TransportRfcDisconnected(uint16_t handle, RfcommTransport *transport);
199 
200     /**
201      * @brief Rfcomm event of disconnect success.
202      *
203      * @param cid Rfcomm connection handle.
204      * @param event Rfcomm event.
205      * @param event_data Rfcomm event data.
206      * @param context transport object.
207      */
208     static void TransportRfcDisconnectSuccess(uint16_t handle, RfcommTransport *transport);
209 
210     /**
211      * @brief Rfcomm event of disconnect fail.
212      *
213      * @param cid Rfcomm connection handle.
214      * @param event Rfcomm event.
215      * @param event_data Rfcomm event data.
216      * @param context transport object.
217      */
218     static void TransportRfcDisconnectFail(uint16_t handle, RfcommTransport *transport);
219 
220     /**
221      * @brief Rfcomm event of flow control on.
222      *
223      * @param cid Rfcomm connection handle.
224      * @param event Rfcomm event.
225      * @param event_data Rfcomm event data.
226      * @param context transport object.
227      */
228     static void TransportRfcFcOn(uint16_t handle, RfcommTransport *transport);
229 
230     /**
231      * @brief Rfcomm event of recv data.
232      *
233      * @param cid Rfcomm connection handle.
234      * @param event Rfcomm event.
235      * @param event_data Rfcomm event data.
236      * @param context transport object.
237      */
238     static void TransportRfcRecvData(uint16_t handle, RfcommTransport *transport);
239 
240     BT_DISALLOW_COPY_AND_ASSIGN(RfcommTransport);
241 };
242 }  // namespace bluetooth
243 }  // namespace OHOS
244 #endif  // TRANSPORT_RFCOMM_H