1 /*
2 * Copyright (C) 2021 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 /**
17 * @addtogroup Bluetooth
18 * @{
19 *
20 * @brief Defines map client instance object.
21 *
22 */
23
24 /**
25 * @file map_mce_instance_client.cpp
26 *
27 * @brief map instance client source file .
28 *
29 */
30 #include "map_mce_instance_client.h"
31 #include "btm.h"
32 #include "log.h"
33 #include "map_mce_instance_stm.h"
34 #include "map_mce_mns_server.h"
35 #include "securec.h"
36
37 namespace OHOS {
38 namespace bluetooth {
39 // client uuid
40 const uint8_t MapMceInstanceClient::mceClientUuidTbl_[MAX_OF_MASCLIENT_OBEX_UUID_TBL] = {
41 0xbb, 0x58, 0x2b, 0x40, 0x42, 0x0c, 0x11, 0xdb, 0xb0, 0xde, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
42 };
43
44 // call back
MapMceRequestSecurityCb(uint16_t result,GapServiceSecurityInfo security,void * context)45 void MapMceRequestSecurityCb(uint16_t result, GapServiceSecurityInfo security, void *context)
46 {
47 LOG_INFO("%{public}s enter, result = %{public}d", __PRETTY_FUNCTION__, int(result));
48 auto pThis = static_cast<MapMceInstanceClient *>(context);
49 if (pThis != nullptr) {
50 pThis->OnGapRequestSecurityCb(result);
51 }
52 }
53
MapMceInstanceClient(utility::StateMachine & mapStm,utility::Dispatcher & dispacher,MapMceObserverManager & observeMgr,const MasInstanceConfig & config,std::recursive_mutex & mutex)54 MapMceInstanceClient::MapMceInstanceClient(utility::StateMachine &mapStm, utility::Dispatcher &dispacher,
55 MapMceObserverManager &observeMgr, const MasInstanceConfig &config, std::recursive_mutex &mutex)
56 : instanceStm_(mapStm), mceDispacher_(dispacher), observerMgrPtr_(observeMgr), stmMutex_(mutex)
57 {
58 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
59 // same statemachine
60 obexClientIns_ = nullptr;
61 insDefaultConfig_ = config;
62 currentRequestPtr_ = nullptr;
63 masRequestQue_.clear();
64 // response data init;
65 resMasInstanceInfo_.isValid = false;
66 resMasInstanceInfo_.masInstanceInfoUtf8 = "";
67 resMasInstanceInfo_.ownerUciUtf8 = "";
68 masObexObserver_ = nullptr;
69 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
70 };
71
~MapMceInstanceClient()72 MapMceInstanceClient::~MapMceInstanceClient()
73 {
74 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
75 if (currentRequestPtr_ != nullptr) {
76 LOG_INFO("%{public}s currentRequestPtr_ is not null", __PRETTY_FUNCTION__);
77 currentRequestPtr_ = nullptr;
78 }
79 // clear the request list
80 ClientDeleteAllSavedRequestInternal();
81 }
82
83 // call by device ctrl
SetDefaultSdpParam(const MasSdpParam & sdpSave)84 void MapMceInstanceClient::SetDefaultSdpParam(const MasSdpParam &sdpSave)
85 {
86 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
87 std::lock_guard<std::recursive_mutex> lock(stmMutex_);
88
89 masSdpParamSave_ = sdpSave;
90 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
91 }
92
93 // call by device ctrl
GetMasSdpParam()94 MasSdpParam MapMceInstanceClient::GetMasSdpParam()
95 {
96 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
97 std::lock_guard<std::recursive_mutex> lock(stmMutex_);
98
99 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
100 return masSdpParamSave_;
101 }
102
103 // call by client internal
SetObexConfig()104 void MapMceInstanceClient::SetObexConfig()
105 {
106 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
107 BtAddr btAddr;
108 BtUuid btUuid;
109 btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
110 btUuid.type = BT_PUBLIC_DEVICE_ADDRESS;
111 (void)memcpy_s(btUuid.uuid128, MAX_OF_MASCLIENT_OBEX_UUID_TBL,
112 mceClientUuidTbl_, MAX_OF_MASCLIENT_OBEX_UUID_TBL);
113 RawAddress rawAddr(((MapMceInstanceStm &)instanceStm_).GetBtDevice());
114 rawAddr.ConvertToUint8(btAddr.addr, sizeof(btAddr.addr));
115
116 // set obex config value
117 masClientConfig_.addr_ = btAddr;
118 masClientConfig_.isGoepL2capPSM_ = masSdpParamSave_.isGoepL2capPSM; // rfcomm is false or l2cap is true
119 masClientConfig_.mtu_ = insDefaultConfig_.rfcommMtu;
120 #ifdef MCE_DISABLE_L2CAP
121 // GOEP 2.0 srm set true
122 masClientConfig_.isSupportSrm_ = insDefaultConfig_.isSupportSrm;
123 #else
124 // GOEP 2.0 srm set true
125 if (masClientConfig_.isGoepL2capPSM_) {
126 masClientConfig_.isSupportSrm_ = true;
127 masClientConfig_.mtu_ = insDefaultConfig_.l2capMtu;
128 }
129 #endif
130 masClientConfig_.isSupportReliableSession_ = false;
131 masClientConfig_.scn_ = masSdpParamSave_.scn;
132 masClientConfig_.serviceUUID_ = btUuid;
133 masClientConfig_.lpsm_ = MAP_MCE_GOEP_L2CAP_PSM_VALUE;
134 }
135
136 // call by stm
StartClientConnect()137 int MapMceInstanceClient::StartClientConnect()
138 {
139 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
140 int ret;
141 BtAddr addr = ((MapMceInstanceStm &)instanceStm_).GetBtAddress();
142 // prepare obex config
143 SetObexConfig();
144 // set obex config data , set obex observer
145 if (masObexObserver_ == nullptr) {
146 masObexObserver_ = std::make_unique<MasObexClientObserver>(instanceStm_);
147 }
148 if (obexClientIns_ == nullptr) {
149 obexClientIns_ =
150 std::make_unique<ObexMpClient>((const ObexClientConfig)masClientConfig_, *masObexObserver_, mceDispacher_);
151 LOG_INFO("%{public}s,new ObexMpClient, rawAddr=%{public}s,isL2cap=%{public}d,"
152 "scn=0x%x,lpsm=0x%x,instId=%{public}d",
153 __PRETTY_FUNCTION__,
154 ((MapMceInstanceStm &)instanceStm_).GetBtDevice().c_str(),
155 masClientConfig_.isGoepL2capPSM_,
156 masClientConfig_.scn_,
157 masClientConfig_.lpsm_,
158 int(masSdpParamSave_.instanceId));
159 }
160 // register gap
161 ret = RegisterServiceSecurity(securityInfo_);
162 if (ret == BT_SUCCESS) {
163 if (masClientConfig_.isGoepL2capPSM_ != true) {
164 // base on rfcomm， request gap is doing in rfcomm
165 ret = ExcuteObexConnectInternal();
166 BTM_AddRemoteRfcommScnForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
167 } else {
168 // base on l2cap, mce need request gap self
169 ret = RequestSecurity(securityInfo_);
170 BTM_AddRemoteL2capPsmForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
171 }
172 } else {
173 LOG_ERROR("%{public}s Register gap error", __PRETTY_FUNCTION__);
174 }
175 return ret;
176 }
177
ReconnectAfterTransportFailed()178 int MapMceInstanceClient::ReconnectAfterTransportFailed()
179 {
180 LOG_ERROR("%{public}s, execute", __PRETTY_FUNCTION__);
181 return RequestSecurity(securityInfo_);
182 }
183
184 // call by stm
ExcuteObexConnect()185 int MapMceInstanceClient::ExcuteObexConnect()
186 {
187 LOG_INFO("%{public}s, obex->Connect() execute", __PRETTY_FUNCTION__);
188 return ExcuteObexConnectInternal();
189 }
190
ExcuteObexConnectInternal()191 int MapMceInstanceClient::ExcuteObexConnectInternal()
192 {
193 LOG_INFO("%{public}s, obex->Connect() execute", __PRETTY_FUNCTION__);
194 // set obex param value
195 TlvTriplet supportedFeatures(MCE_MAP_SUPPORTED_FEATURES, MAP_MCE_SUPPORTED_FEATURES_V14);
196 ObexTlvParamters params;
197 if (CheckSupportedFeatures(MAP_SUPPORTED_FEATURES_MAPSUPPORTED_FEATURES)) {
198 params.AppendTlvtriplet(supportedFeatures);
199 }
200 // obex connect execute
201 ObexConnectParams obexParam;
202 obexParam.appParams_ = ¶ms;
203 int ret = obexClientIns_->Connect(obexParam);
204 if (ret != BT_SUCCESS) {
205 LOG_ERROR("%{public}s, obex->Connect() execute error, ret=%{public}d", __PRETTY_FUNCTION__, ret);
206 }
207 return ret;
208 }
209
210 // internal
RegisterServiceSecurity(GapServiceSecurityInfo & info)211 int MapMceInstanceClient::RegisterServiceSecurity(GapServiceSecurityInfo &info)
212 {
213 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
214 info.direction = OUTGOING;
215 info.serviceId = masSdpParamSave_.gapNumber;
216 // init
217 info.channelId.l2capPsm = 0;
218 info.channelId.rfcommChannel = 0;
219
220 // set gap param
221 if (masSdpParamSave_.isGoepL2capPSM) {
222 // l2cap
223 info.protocolId = SEC_PROTOCOL_L2CAP; // if l2cap ,then true
224 info.channelId.l2capPsm = masSdpParamSave_.scn;
225 } else {
226 // rfcomm
227 info.protocolId = SEC_PROTOCOL_RFCOMM; // if not l2cap ,then false
228 info.channelId.rfcommChannel = masSdpParamSave_.scn;
229 }
230 // register gap
231 uint16_t securityMode =
232 GAP_SEC_IN_AUTHENTICATION | GAP_SEC_IN_ENCRYPTION | GAP_SEC_OUT_AUTHENTICATION | GAP_SEC_OUT_ENCRYPTION;
233 LOG_INFO("%{public}s gap execute,dir=%{public}d,servic=%{public}d,protocol=%{public}d,rfchannel=%{public}d,"
234 "l2psm=0x%x,securityMode=0x%x",
235 __PRETTY_FUNCTION__,
236 info.direction,
237 info.serviceId,
238 info.protocolId,
239 info.channelId.rfcommChannel,
240 info.channelId.l2capPsm,
241 securityMode);
242 // bluetooth device address
243 BtAddr addr = ((MapMceInstanceStm &)instanceStm_).GetBtAddress();
244 int ret = GAPIF_RegisterServiceSecurity(&addr, &info, securityMode);
245 LOG_INFO("%{public}s end,ret=%{public}d", __PRETTY_FUNCTION__, ret);
246 return ret;
247 }
248
249 // internal
RequestSecurity(GapServiceSecurityInfo info)250 int MapMceInstanceClient::RequestSecurity(GapServiceSecurityInfo info)
251 {
252 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
253 GapRequestSecurityParam requestParam;
254 requestParam.info = info;
255 requestParam.callback = MapMceRequestSecurityCb;
256 requestParam.context = this;
257
258 BtAddr addr = ((MapMceInstanceStm &)instanceStm_).GetBtAddress();
259 int ret = GAPIF_RequestSecurity(&addr, &requestParam);
260 if (ret != BT_SUCCESS) {
261 LOG_ERROR("%{public}s GAPIF_RequestSecurity execute error", __PRETTY_FUNCTION__);
262 }
263 return ret;
264 }
265
266 // call back
OnGapRequestSecurityCb(uint16_t result)267 void MapMceInstanceClient::OnGapRequestSecurityCb(uint16_t result)
268 {
269 // Request Security callback
270 LOG_INFO("%{public}s enter, result = %{public}d", __PRETTY_FUNCTION__, int(result));
271 if (result == BT_SUCCESS) {
272 utility::Message msg(MSG_MASSTM_GAP_REQUEST_FINISH);
273 ((MapMceInstanceStm &)instanceStm_).PostMessage(msg);
274 } else { // gap request security failure
275 utility::Message msg(MSG_MASSTM_GAP_REQUEST_FAILED);
276 ((MapMceInstanceStm &)instanceStm_).PostMessage(msg);
277 LOG_ERROR("%{public}s gap failed", __PRETTY_FUNCTION__);
278 }
279 }
280
281 // call by stm
StartClientDisConnect()282 int MapMceInstanceClient::StartClientDisConnect()
283 {
284 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
285 int ret;
286 if (obexClientIns_ == nullptr) {
287 LOG_ERROR("%{public}s obexClientIns_ null", __PRETTY_FUNCTION__);
288 return BT_OPERATION_FAILED;
289 }
290 // obex callback will send msg Start Client DisConnect to mce stm
291 ret = obexClientIns_->Disconnect();
292 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
293 return ret;
294 }
295
296 // call by stm
ObexConnectFailedDisConnect()297 int MapMceInstanceClient::ObexConnectFailedDisConnect()
298 {
299 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
300 int ret;
301 if (obexClientIns_ == nullptr) {
302 LOG_ERROR("%{public}s obexClientIns_ null", __PRETTY_FUNCTION__);
303 return BT_OPERATION_FAILED;
304 }
305 // obex callback will send msg Start Client DisConnect to mce stm
306 ret = obexClientIns_->Disconnect(false);
307 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
308 return ret;
309 }
310
311 // call by stm
ProcessDisConnectFinish()312 void MapMceInstanceClient::ProcessDisConnectFinish()
313 {
314 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
315 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
316
317 BtAddr addr = ((MapMceInstanceStm &)instanceStm_).GetBtAddress();
318 // unregister service security
319 int ret = GAPIF_DeregisterServiceSecurity(&addr, &securityInfo_);
320 if (ret != BT_SUCCESS) {
321 LOG_ERROR("%{public}s error,error=%{public}d", __PRETTY_FUNCTION__, ret);
322 }
323 if (masClientConfig_.isGoepL2capPSM_) {
324 BTM_RemoveRemoteL2capPsmForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
325 } else {
326 BTM_RemoveRemoteRfcommScnChannelForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
327 }
328
329 // clear current request
330 currentRequestPtr_ = nullptr;
331
332 resMasInstanceInfo_.isValid = false;
333 resMasInstanceInfo_.masInstanceInfoUtf8 = "";
334 resMasInstanceInfo_.ownerUciUtf8 = "";
335 // delete all the left request
336 ClientDeleteAllSavedRequestInternal();
337 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
338 }
339
340 // call by stm
GetCurrentRequest()341 MceRequestType MapMceInstanceClient::GetCurrentRequest()
342 {
343 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
344 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
345 MceRequestType ret;
346 if (currentRequestPtr_ != nullptr) {
347 ret = currentRequestPtr_->GetRequestType();
348 } else {
349 ret = MCE_REQUEST_TYPE_IDLE;
350 }
351 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
352 return ret;
353 }
354
355 // call by stm
ClientSendRequest(std::unique_ptr<MapMceInstanceRequest> & req)356 int MapMceInstanceClient::ClientSendRequest(std::unique_ptr<MapMceInstanceRequest> &req)
357 {
358 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
359 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
360
361 int ret = req->SendRequest(*obexClientIns_);
362 if (ret == BT_SUCCESS) {
363 currentRequestPtr_ = std::move(req);
364 currentRequestPtr_->SaveReq();
365 }
366 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
367 return ret;
368 }
369
370 // call by stm
ClientSaveRequest(std::unique_ptr<MapMceInstanceRequest> & req)371 void MapMceInstanceClient::ClientSaveRequest(std::unique_ptr<MapMceInstanceRequest> &req)
372 {
373 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
374 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
375
376 req->SaveReq();
377 masRequestQue_.push_back(std::move(req));
378 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
379 }
380
381 // call by device ctrl
ClientSendReqSetNotificationRegistration(bool value)382 int MapMceInstanceClient::ClientSendReqSetNotificationRegistration(bool value)
383 {
384 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
385 std::lock_guard<std::recursive_mutex> lock(stmMutex_);
386
387 int ret = BT_SUCCESS;
388 if (obexClientIns_ == nullptr) {
389 return BT_OPERATION_FAILED;
390 }
391 // api only valid in connected state, if not valid return error at now
392 utility::Message outMsg(MSG_MASSTM_REQ_SEND_REQUEST_SELF);
393 std::unique_ptr<MapMceInstanceRequest> reqPtr =
394 std::make_unique<MapMceRequestSetNotificationRegistration>(value);
395 ((MapMceInstanceStm &)instanceStm_).MceProcessMessageWithRequestInternal(outMsg, reqPtr);
396 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
397 return ret;
398 }
399
400 // call by stm
ClientSendReqSetPath(const uint8_t flags,const std::u16string & paths,std::vector<std::u16string> & pathList)401 int MapMceInstanceClient::ClientSendReqSetPath(
402 const uint8_t flags, const std::u16string &paths, std::vector<std::u16string> &pathList)
403 {
404 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
405 int ret = BT_SUCCESS;
406 if (obexClientIns_ == nullptr) {
407 return BT_OPERATION_FAILED;
408 }
409 // api only valid in connected state, if not valid return error at now
410 utility::Message outMsg(MSG_MASSTM_REQ_SEND_REQUEST_SELF);
411 std::unique_ptr<MapMceInstanceRequest> reqPtr = std::make_unique<MapMceRequestSetPath>(flags, paths, pathList);
412 ((MapMceInstanceStm &)instanceStm_).MceProcessMessageWithRequestInternal(outMsg, reqPtr);
413
414 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
415 return ret;
416 }
417
418 // call by stm
ClientSendReqGetMasInstanceInformation()419 int MapMceInstanceClient::ClientSendReqGetMasInstanceInformation()
420 {
421 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
422 // api only valid in connected state, if not valid return error at now
423 utility::Message outMsg(MSG_MASSTM_REQ_SEND_REQUEST_SELF);
424 std::unique_ptr<MapMceInstanceRequest> reqPtr =
425 std::make_unique<MapMceRequestGetMasInstanceInformation>(masSdpParamSave_.instanceId);
426 ((MapMceInstanceStm &)instanceStm_).MceProcessMessageWithRequestInternal(outMsg, reqPtr);
427
428 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
429 return BT_SUCCESS;
430 }
431
432 // call by stm
ClientProcResponseCommonProcess(const ObexHeader & resp)433 int MapMceInstanceClient::ClientProcResponseCommonProcess(const ObexHeader &resp)
434 {
435 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
436 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
437
438 MapExecuteStatus resCode = MapExecuteStatus::NOT_SUPPORT;
439 int ret = MCE_RESPONSE_FINISH;
440 if (currentRequestPtr_ == nullptr) {
441 LOG_ERROR("%{public}s lost the current request pointer", __PRETTY_FUNCTION__);
442 return ret;
443 }
444 // process response
445 MapRequestResponseAction retAction;
446 ret = currentRequestPtr_->ProcessResponse(*this, resp, retAction);
447 uint8_t obexCode = resp.GetFieldCode();
448 LOG_INFO("%{public}s obexCode=%{public}d", __PRETTY_FUNCTION__, int(obexCode));
449 if ((obexCode == uint8_t(ObexRspCode::SUCCESS)) || (obexCode == uint8_t(ObexRspCode::CONTINUE))) {
450 if (ret == MCE_RESPONSE_FINISH_NG) {
451 resCode = MapExecuteStatus::NOT_SUPPORT;
452 } else if (ret == MCE_RESPONSE_CONTINUE_WITH_CALLBACK) {
453 resCode = MapExecuteStatus::CONTINUE;
454 } else {
455 resCode = MapExecuteStatus::SUCCEED;
456 }
457 }
458 if ((ret == MCE_RESPONSE_FINISH) || (ret == MCE_RESPONSE_FINISH_NG) ||
459 (ret == MCE_RESPONSE_CONTINUE_WITH_CALLBACK)) { // FINISH OR FINISH NOCALLBACK
460 // execute callback to framework
461 ExcuteCallbackToFramework(retAction, resCode);
462 }
463 if ((ret == MCE_RESPONSE_FINISH) || (ret == MCE_RESPONSE_FINISH_NG) ||
464 (ret == MCE_RESPONSE_FINISH_NO_CALLBACK)) { // FINISH OR FINISH NOCALLBACK
465 // destry request
466 currentRequestPtr_ = nullptr;
467 }
468 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
469 return ret;
470 }
471
472 // call by device ctrl
ClientCountSendingRequest(MceRequestType requestType)473 int MapMceInstanceClient::ClientCountSendingRequest(MceRequestType requestType)
474 {
475 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
476 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
477
478 int sum = 0;
479 MapMceInstanceRequest *requestPtr = nullptr;
480 // no request sending
481 if (currentRequestPtr_ == nullptr) {
482 return sum;
483 }
484 // count all
485 if (requestType == MCE_REQUEST_TYPE_ALL) {
486 // need add current
487 sum = 1 + masRequestQue_.size();
488 return sum;
489 }
490 // normal request
491 if (currentRequestPtr_->GetRequestType() == requestType) {
492 sum++;
493 }
494 for (auto it = masRequestQue_.begin(); it != masRequestQue_.end(); it++) {
495 requestPtr = it->get();
496 if (requestPtr != nullptr) {
497 if (requestPtr->GetRequestType() == requestType) {
498 sum++;
499 }
500 }
501 }
502 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
503 return sum;
504 }
505
506 // call by stm
ClientSendSavedRequest()507 int MapMceInstanceClient::ClientSendSavedRequest()
508 {
509 LOG_INFO("%{public}s enter,request.size=%{public}d", __PRETTY_FUNCTION__, int(masRequestQue_.size()));
510 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
511
512 int ret = BT_OPERATION_FAILED;
513 currentRequestPtr_ = nullptr;
514 std::unique_ptr<MapMceInstanceRequest> nextReq = nullptr;
515 while (masRequestQue_.size() != 0) {
516 // send request continue
517 nextReq = std::move(masRequestQue_.front());
518 masRequestQue_.pop_front();
519 ret = nextReq->SendRequest(*obexClientIns_);
520 if (ret == BT_SUCCESS) {
521 currentRequestPtr_ = std::move(nextReq);
522 break;
523 } else {
524 currentRequestPtr_ = nullptr;
525 nextReq = nullptr;
526 LOG_ERROR("%{public}s obex send request error,ret=%{public}d", __PRETTY_FUNCTION__, ret);
527 }
528 }
529 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
530 return ret;
531 }
532
533 // call by stm
ClientDeleteAllSavedRequest()534 void MapMceInstanceClient::ClientDeleteAllSavedRequest()
535 {
536 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
537 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
538
539 ClientDeleteAllSavedRequestInternal();
540 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
541 }
542
ClientDeleteAllSavedRequestInternal()543 void MapMceInstanceClient::ClientDeleteAllSavedRequestInternal()
544 {
545 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
546 while (masRequestQue_.size() != 0) {
547 masRequestQue_.pop_front();
548 }
549 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
550 }
551
552 // call by request, by stm
SaveMasInstanceInformation(const MasInstanceInformation & instInfo)553 void MapMceInstanceClient::SaveMasInstanceInformation(const MasInstanceInformation &instInfo)
554 {
555 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
556 resMasInstanceInfo_ = instInfo;
557 }
558
559 // call by device ctrl
GetMasInstanceInformation()560 MasInstanceInformation MapMceInstanceClient::GetMasInstanceInformation()
561 {
562 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
563 std::lock_guard<std::recursive_mutex> lock(stmMutex_);
564
565 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
566 return resMasInstanceInfo_;
567 }
568
569 // internal
CheckSupportedFeatures(int mask) const570 bool MapMceInstanceClient::CheckSupportedFeatures(int mask) const
571 {
572 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
573 if (masSdpParamSave_.supportedFeatrue & mask) {
574 return true;
575 } else {
576 return false;
577 }
578 }
579
580 // internal
ExcuteCallbackToFramework(MapRequestResponseAction & retAction,MapExecuteStatus resCode)581 void MapMceInstanceClient::ExcuteCallbackToFramework(MapRequestResponseAction &retAction, MapExecuteStatus resCode)
582 {
583 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
584 if ((retAction.action_ == MapActionType::GET_MESSAGE) ||
585 (retAction.action_ == MapActionType::GET_UNREAD_MESSAGES)) {
586 IProfileBMessage bmsg;
587 bmsg.bMessageParam_ = retAction.bmessage_.GetBMessageData();
588 bmsg.bMessageStringObject_ = retAction.bmessage_.GetBmessageObject();
589 bmsg.FractionDeliver = retAction.bmessage_.GetFractionDeliver();
590 observerMgrPtr_.ExcuteObserverOnBmessageCompleted(
591 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), bmsg, resCode);
592 } else if (retAction.action_ == MapActionType::GET_MESSAGES_LISTING) {
593 IProfileMessagesListing msgListing;
594 msgListing.messageOutlineList_ = retAction.messageList_.GetList();
595 msgListing.messagesListingParam_ = retAction.messageList_.GetParam();
596 msgListing.messagesListingStringObject_ = retAction.messageList_.GetStringObject();
597 observerMgrPtr_.ExcuteObserverOnMessagesListingCompleted(
598 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), msgListing, resCode);
599 } else if (retAction.action_ == MapActionType::GET_CONVERSATION_LISTING) {
600 IProfileConversationListing convListing;
601 convListing.conversationOutlineList_ = retAction.conversationList_.GetList();
602 convListing.conversationListingParam_ = retAction.conversationList_.GetParam();
603 convListing.conversationListingStringObject_ = retAction.conversationList_.GetStringObject();
604 observerMgrPtr_.ExcuteObserverOnConversationListingCompleted(
605 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), convListing, resCode);
606 } else {
607 IProfileMapAction prifileAction;
608 prifileAction.action_ = retAction.action_;
609 prifileAction.ownerStatus_ = retAction.ownerStatus_;
610 prifileAction.supportedFeatures_ = retAction.supportedFeatures;
611 observerMgrPtr_.ExcuteObserverOnMapActionCompleted(
612 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), prifileAction, resCode);
613 }
614 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
615 }
616
~MasObexClientObserver()617 MapMceInstanceClient::MasObexClientObserver::~MasObexClientObserver()
618 {
619 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
620 }
621
OnTransportFailed(ObexClient & client,int errCd)622 void MapMceInstanceClient::MasObexClientObserver::OnTransportFailed(ObexClient &client, int errCd)
623 {
624 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
625 utility::Message msg = MSG_MASSTM_OBEX_TRANSPORT_FAILED;
626 msg.arg1_ = errCd;
627 // post msg to mns state machine instance. execute in mns service thread
628 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
629 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
630 }
631
OnConnected(ObexClient & client,const ObexHeader & resp)632 void MapMceInstanceClient::MasObexClientObserver::OnConnected(ObexClient &client, const ObexHeader &resp)
633 {
634 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
635 utility::Message msg = MSG_MASSTM_OBEX_CONNECTED;
636 // post msg to mns state machine instance. execute in mns service thread
637 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
638 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
639 }
640
OnConnectFailed(ObexClient & client,const ObexHeader & resp)641 void MapMceInstanceClient::MasObexClientObserver::OnConnectFailed(ObexClient &client, const ObexHeader &resp)
642 {
643 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
644 ObexHeader *tempPtr = const_cast<ObexHeader *>(&resp);
645 utility::Message msg(MSG_MASSTM_OBEX_CONNECTED_FAILED);
646 // save error code
647 msg.arg1_ = int(tempPtr->GetFieldCode());
648 // post msg to mns state machine instance. execute in mns service thread
649 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
650 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
651 }
652
OnDisconnected(ObexClient & client)653 void MapMceInstanceClient::MasObexClientObserver::OnDisconnected(ObexClient &client)
654 {
655 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
656 utility::Message msg = MSG_MASSTM_OBEX_DISCONNECTED;
657 // post msg to mns state machine instance. execute in mns service thread
658 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
659 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
660 }
661
OnActionCompleted(ObexClient & client,const ObexHeader & resp)662 void MapMceInstanceClient::MasObexClientObserver::OnActionCompleted(ObexClient &client, const ObexHeader &resp)
663 {
664 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
665 // action finish
666 utility::Message msg(MSG_MASSTM_RECEIVE_REQUEST_COMPLETED);
667 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessageWithObexHeader(msg, resp);
668 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
669 }
670
OnBusy(ObexClient & client,bool isBusy)671 void MapMceInstanceClient::MasObexClientObserver::OnBusy(ObexClient &client, bool isBusy)
672 {
673 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
674 utility::Message msg = MSG_MASSTM_OBEX_INFO_CHG_CONTINUEBUSY_STATUS;
675 msg.arg1_ = int(isBusy);
676 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
677 }
678 } // namespace bluetooth
679 } // namespace OHOS
680