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,scn=0x%x,lpsm=0x%x,instId=%{public}d",
152 __PRETTY_FUNCTION__,
153 ((MapMceInstanceStm &)instanceStm_).GetBtDevice().c_str(),
154 masClientConfig_.isGoepL2capPSM_,
155 masClientConfig_.scn_,
156 masClientConfig_.lpsm_,
157 int(masSdpParamSave_.instanceId));
158 }
159 // register gap
160 ret = RegisterServiceSecurity(securityInfo_);
161 if (ret == BT_NO_ERROR) {
162 if (masClientConfig_.isGoepL2capPSM_ != true) {
163 // base on rfcomm， request gap is doing in rfcomm
164 ret = ExcuteObexConnectInternal();
165 BTM_AddRemoteRfcommScnForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
166 } else {
167 // base on l2cap, mce need request gap self
168 ret = RequestSecurity(securityInfo_);
169 BTM_AddRemoteL2capPsmForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
170 }
171 } else {
172 LOG_ERROR("%{public}s Register gap error", __PRETTY_FUNCTION__);
173 }
174 return ret;
175 }
176
ReconnectAfterTransportFailed()177 int MapMceInstanceClient::ReconnectAfterTransportFailed()
178 {
179 LOG_ERROR("%{public}s, execute", __PRETTY_FUNCTION__);
180 return RequestSecurity(securityInfo_);
181 }
182
183 // call by stm
ExcuteObexConnect()184 int MapMceInstanceClient::ExcuteObexConnect()
185 {
186 LOG_INFO("%{public}s, obex->Connect() execute", __PRETTY_FUNCTION__);
187 return ExcuteObexConnectInternal();
188 }
189
ExcuteObexConnectInternal()190 int MapMceInstanceClient::ExcuteObexConnectInternal()
191 {
192 LOG_INFO("%{public}s, obex->Connect() execute", __PRETTY_FUNCTION__);
193 // set obex param value
194 TlvTriplet supportedFeatures(MCE_MAP_SUPPORTED_FEATURES, MAP_MCE_SUPPORTED_FEATURES_V14);
195 ObexTlvParamters params;
196 if (CheckSupportedFeatures(MAP_SUPPORTED_FEATURES_MAPSUPPORTED_FEATURES)) {
197 params.AppendTlvtriplet(supportedFeatures);
198 }
199 // obex connect execute
200 ObexConnectParams obexParam;
201 obexParam.appParams_ = ¶ms;
202 int ret = obexClientIns_->Connect(obexParam);
203 if (ret != BT_NO_ERROR) {
204 LOG_ERROR("%{public}s, obex->Connect() execute error, ret=%{public}d", __PRETTY_FUNCTION__, ret);
205 }
206 return ret;
207 }
208
209 // internal
RegisterServiceSecurity(GapServiceSecurityInfo & info)210 int MapMceInstanceClient::RegisterServiceSecurity(GapServiceSecurityInfo &info)
211 {
212 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
213 info.direction = OUTGOING;
214 info.serviceId = masSdpParamSave_.gapNumber;
215 // init
216 info.channelId.l2capPsm = 0;
217 info.channelId.rfcommChannel = 0;
218
219 // set gap param
220 if (masSdpParamSave_.isGoepL2capPSM) {
221 // l2cap
222 info.protocolId = SEC_PROTOCOL_L2CAP; // if l2cap ,then true
223 info.channelId.l2capPsm = masSdpParamSave_.scn;
224 } else {
225 // rfcomm
226 info.protocolId = SEC_PROTOCOL_RFCOMM; // if not l2cap ,then false
227 info.channelId.rfcommChannel = masSdpParamSave_.scn;
228 }
229 // register gap
230 uint16_t securityMode =
231 GAP_SEC_IN_AUTHENTICATION | GAP_SEC_IN_ENCRYPTION | GAP_SEC_OUT_AUTHENTICATION | GAP_SEC_OUT_ENCRYPTION;
232 LOG_INFO("%{public}s gap execute,dir=%{public}d,servic=%{public}d,protocol=%{public}d,rfchannel=%{public}d,l2psm=0x%x,securityMode=0x%x",
233 __PRETTY_FUNCTION__,
234 info.direction,
235 info.serviceId,
236 info.protocolId,
237 info.channelId.rfcommChannel,
238 info.channelId.l2capPsm,
239 securityMode);
240 // bluetooth device address
241 BtAddr addr = ((MapMceInstanceStm &)instanceStm_).GetBtAddress();
242 int ret = GAPIF_RegisterServiceSecurity(&addr, &info, securityMode);
243 LOG_INFO("%{public}s end,ret=%{public}d", __PRETTY_FUNCTION__, ret);
244 return ret;
245 }
246
247 // internal
RequestSecurity(GapServiceSecurityInfo info)248 int MapMceInstanceClient::RequestSecurity(GapServiceSecurityInfo info)
249 {
250 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
251 GapRequestSecurityParam requestParam;
252 requestParam.info = info;
253 requestParam.callback = MapMceRequestSecurityCb;
254 requestParam.context = this;
255
256 BtAddr addr = ((MapMceInstanceStm &)instanceStm_).GetBtAddress();
257 int ret = GAPIF_RequestSecurity(&addr, &requestParam);
258 if (ret != BT_NO_ERROR) {
259 LOG_ERROR("%{public}s GAPIF_RequestSecurity execute error", __PRETTY_FUNCTION__);
260 }
261 return ret;
262 }
263
264 // call back
OnGapRequestSecurityCb(uint16_t result)265 void MapMceInstanceClient::OnGapRequestSecurityCb(uint16_t result)
266 {
267 // Request Security callback
268 LOG_INFO("%{public}s enter, result = %{public}d", __PRETTY_FUNCTION__, int(result));
269 if (result == BT_NO_ERROR) {
270 utility::Message msg(MSG_MASSTM_GAP_REQUEST_FINISH);
271 ((MapMceInstanceStm &)instanceStm_).PostMessage(msg);
272 } else { // gap request security failure
273 utility::Message msg(MSG_MASSTM_GAP_REQUEST_FAILED);
274 ((MapMceInstanceStm &)instanceStm_).PostMessage(msg);
275 LOG_ERROR("%{public}s gap failed", __PRETTY_FUNCTION__);
276 }
277 }
278
279 // call by stm
StartClientDisConnect()280 int MapMceInstanceClient::StartClientDisConnect()
281 {
282 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
283 int ret;
284 if (obexClientIns_ == nullptr) {
285 LOG_ERROR("%{public}s obexClientIns_ null", __PRETTY_FUNCTION__);
286 return BT_OPERATION_FAILED;
287 }
288 // obex callback will send msg Start Client DisConnect to mce stm
289 ret = obexClientIns_->Disconnect();
290 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
291 return ret;
292 }
293
294 // call by stm
ObexConnectFailedDisConnect()295 int MapMceInstanceClient::ObexConnectFailedDisConnect()
296 {
297 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
298 int ret;
299 if (obexClientIns_ == nullptr) {
300 LOG_ERROR("%{public}s obexClientIns_ null", __PRETTY_FUNCTION__);
301 return BT_OPERATION_FAILED;
302 }
303 // obex callback will send msg Start Client DisConnect to mce stm
304 ret = obexClientIns_->Disconnect(false);
305 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
306 return ret;
307 }
308
309 // call by stm
ProcessDisConnectFinish()310 void MapMceInstanceClient::ProcessDisConnectFinish()
311 {
312 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
313 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
314
315 BtAddr addr = ((MapMceInstanceStm &)instanceStm_).GetBtAddress();
316 // unregister service security
317 int ret = GAPIF_DeregisterServiceSecurity(&addr, &securityInfo_);
318 if (ret != BT_NO_ERROR) {
319 LOG_ERROR("%{public}s error,error=%{public}d", __PRETTY_FUNCTION__, ret);
320 }
321 if (masClientConfig_.isGoepL2capPSM_) {
322 BTM_RemoveRemoteL2capPsmForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
323 } else {
324 BTM_RemoveRemoteRfcommScnChannelForLogging(BTM_HCI_LOG_FILTER_MODULE_MAP, masClientConfig_.scn_, &addr);
325 }
326
327 // clear current request
328 currentRequestPtr_ = nullptr;
329
330 resMasInstanceInfo_.isValid = false;
331 resMasInstanceInfo_.masInstanceInfoUtf8 = "";
332 resMasInstanceInfo_.ownerUciUtf8 = "";
333 // delete all the left request
334 ClientDeleteAllSavedRequestInternal();
335 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
336 }
337
338 // call by stm
GetCurrentRequest()339 MceRequestType MapMceInstanceClient::GetCurrentRequest()
340 {
341 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
342 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
343 MceRequestType ret;
344 if (currentRequestPtr_ != nullptr) {
345 ret = currentRequestPtr_->GetRequestType();
346 } else {
347 ret = MCE_REQUEST_TYPE_IDLE;
348 }
349 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
350 return ret;
351 }
352
353 // call by stm
ClientSendRequest(std::unique_ptr<MapMceInstanceRequest> & req)354 int MapMceInstanceClient::ClientSendRequest(std::unique_ptr<MapMceInstanceRequest> &req)
355 {
356 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
357 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
358
359 int ret = req->SendRequest(*obexClientIns_);
360 if (ret == BT_NO_ERROR) {
361 currentRequestPtr_ = std::move(req);
362 currentRequestPtr_->SaveReq();
363 }
364 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
365 return ret;
366 }
367
368 // call by stm
ClientSaveRequest(std::unique_ptr<MapMceInstanceRequest> & req)369 void MapMceInstanceClient::ClientSaveRequest(std::unique_ptr<MapMceInstanceRequest> &req)
370 {
371 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
372 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
373
374 req->SaveReq();
375 masRequestQue_.push_back(std::move(req));
376 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
377 }
378
379 // call by device ctrl
ClientSendReqSetNotificationRegistration(bool value)380 int MapMceInstanceClient::ClientSendReqSetNotificationRegistration(bool value)
381 {
382 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
383 std::lock_guard<std::recursive_mutex> lock(stmMutex_);
384
385 int ret = BT_NO_ERROR;
386 if (obexClientIns_ == nullptr) {
387 return BT_OPERATION_FAILED;
388 }
389 // api only valid in connected state, if not valid return error at now
390 utility::Message outMsg(MSG_MASSTM_REQ_SEND_REQUEST_SELF);
391 std::unique_ptr<MapMceInstanceRequest> reqPtr =
392 std::make_unique<MapMceRequestSetNotificationRegistration>(value);
393 ((MapMceInstanceStm &)instanceStm_).MceProcessMessageWithRequestInternal(outMsg, reqPtr);
394 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
395 return ret;
396 }
397
398 // call by stm
ClientSendReqSetPath(const uint8_t flags,const std::u16string & paths,std::vector<std::u16string> & pathList)399 int MapMceInstanceClient::ClientSendReqSetPath(
400 const uint8_t flags, const std::u16string &paths, std::vector<std::u16string> &pathList)
401 {
402 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
403 int ret = BT_NO_ERROR;
404 if (obexClientIns_ == nullptr) {
405 return BT_OPERATION_FAILED;
406 }
407 // api only valid in connected state, if not valid return error at now
408 utility::Message outMsg(MSG_MASSTM_REQ_SEND_REQUEST_SELF);
409 std::unique_ptr<MapMceInstanceRequest> reqPtr = std::make_unique<MapMceRequestSetPath>(flags, paths, pathList);
410 ((MapMceInstanceStm &)instanceStm_).MceProcessMessageWithRequestInternal(outMsg, reqPtr);
411
412 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
413 return ret;
414 }
415
416 // call by stm
ClientSendReqGetMasInstanceInformation()417 int MapMceInstanceClient::ClientSendReqGetMasInstanceInformation()
418 {
419 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
420 // api only valid in connected state, if not valid return error at now
421 utility::Message outMsg(MSG_MASSTM_REQ_SEND_REQUEST_SELF);
422 std::unique_ptr<MapMceInstanceRequest> reqPtr =
423 std::make_unique<MapMceRequestGetMasInstanceInformation>(masSdpParamSave_.instanceId);
424 ((MapMceInstanceStm &)instanceStm_).MceProcessMessageWithRequestInternal(outMsg, reqPtr);
425
426 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
427 return BT_NO_ERROR;
428 }
429
430 // call by stm
ClientProcResponseCommonProcess(const ObexHeader & resp)431 int MapMceInstanceClient::ClientProcResponseCommonProcess(const ObexHeader &resp)
432 {
433 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
434 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
435
436 MapExecuteStatus resCode = MapExecuteStatus::NOT_SUPPORT;
437 int ret = MCE_RESPONSE_FINISH;
438 if (currentRequestPtr_ == nullptr) {
439 LOG_ERROR("%{public}s lost the current request pointer", __PRETTY_FUNCTION__);
440 return ret;
441 }
442 // process response
443 MapRequestResponseAction retAction;
444 ret = currentRequestPtr_->ProcessResponse(*this, resp, retAction);
445 uint8_t obexCode = resp.GetFieldCode();
446 LOG_INFO("%{public}s obexCode=%{public}d", __PRETTY_FUNCTION__, int(obexCode));
447 if ((obexCode == uint8_t(ObexRspCode::SUCCESS)) || (obexCode == uint8_t(ObexRspCode::CONTINUE))) {
448 if (ret == MCE_RESPONSE_FINISH_NG) {
449 resCode = MapExecuteStatus::NOT_SUPPORT;
450 } else if (ret == MCE_RESPONSE_CONTINUE_WITH_CALLBACK) {
451 resCode = MapExecuteStatus::CONTINUE;
452 } else {
453 resCode = MapExecuteStatus::SUCCEED;
454 }
455 }
456 if ((ret == MCE_RESPONSE_FINISH) || (ret == MCE_RESPONSE_FINISH_NG) ||
457 (ret == MCE_RESPONSE_CONTINUE_WITH_CALLBACK)) { // FINISH OR FINISH NOCALLBACK
458 // execute callback to framework
459 ExcuteCallbackToFramework(retAction, resCode);
460 }
461 if ((ret == MCE_RESPONSE_FINISH) || (ret == MCE_RESPONSE_FINISH_NG) ||
462 (ret == MCE_RESPONSE_FINISH_NO_CALLBACK)) { // FINISH OR FINISH NOCALLBACK
463 // destry request
464 currentRequestPtr_ = nullptr;
465 }
466 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
467 return ret;
468 }
469
470 // call by device ctrl
ClientCountSendingRequest(MceRequestType requestType)471 int MapMceInstanceClient::ClientCountSendingRequest(MceRequestType requestType)
472 {
473 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
474 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
475
476 int sum = 0;
477 MapMceInstanceRequest *requestPtr = nullptr;
478 // no request sending
479 if (currentRequestPtr_ == nullptr) {
480 return sum;
481 }
482 // count all
483 if (requestType == MCE_REQUEST_TYPE_ALL) {
484 // need add current
485 sum = 1 + masRequestQue_.size();
486 return sum;
487 }
488 // normal request
489 if (currentRequestPtr_->GetRequestType() == requestType) {
490 sum++;
491 }
492 for (auto it = masRequestQue_.begin(); it != masRequestQue_.end(); it++) {
493 requestPtr = it->get();
494 if (requestPtr != nullptr) {
495 if (requestPtr->GetRequestType() == requestType) {
496 sum++;
497 }
498 }
499 }
500 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
501 return sum;
502 }
503
504 // call by stm
ClientSendSavedRequest()505 int MapMceInstanceClient::ClientSendSavedRequest()
506 {
507 LOG_INFO("%{public}s enter,request.size=%{public}d", __PRETTY_FUNCTION__, int(masRequestQue_.size()));
508 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
509
510 int ret = BT_OPERATION_FAILED;
511 currentRequestPtr_ = nullptr;
512 std::unique_ptr<MapMceInstanceRequest> nextReq = nullptr;
513 while (masRequestQue_.size() != 0) {
514 // send request continue
515 nextReq = std::move(masRequestQue_.front());
516 masRequestQue_.pop_front();
517 ret = nextReq->SendRequest(*obexClientIns_);
518 if (ret == BT_NO_ERROR) {
519 currentRequestPtr_ = std::move(nextReq);
520 break;
521 } else {
522 currentRequestPtr_ = nullptr;
523 nextReq = nullptr;
524 LOG_ERROR("%{public}s obex send request error,ret=%{public}d", __PRETTY_FUNCTION__, ret);
525 }
526 }
527 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
528 return ret;
529 }
530
531 // call by stm
ClientDeleteAllSavedRequest()532 void MapMceInstanceClient::ClientDeleteAllSavedRequest()
533 {
534 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
535 std::lock_guard<std::recursive_mutex> lock(mceSendRequestMutex_);
536
537 ClientDeleteAllSavedRequestInternal();
538 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
539 }
540
ClientDeleteAllSavedRequestInternal()541 void MapMceInstanceClient::ClientDeleteAllSavedRequestInternal()
542 {
543 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
544 while (masRequestQue_.size() != 0) {
545 masRequestQue_.pop_front();
546 }
547 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
548 }
549
550 // call by request, by stm
SaveMasInstanceInformation(const MasInstanceInformation & instInfo)551 void MapMceInstanceClient::SaveMasInstanceInformation(const MasInstanceInformation &instInfo)
552 {
553 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
554 resMasInstanceInfo_ = instInfo;
555 }
556
557 // call by device ctrl
GetMasInstanceInformation()558 MasInstanceInformation MapMceInstanceClient::GetMasInstanceInformation()
559 {
560 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
561 std::lock_guard<std::recursive_mutex> lock(stmMutex_);
562
563 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
564 return resMasInstanceInfo_;
565 }
566
567 // internal
CheckSupportedFeatures(int mask) const568 bool MapMceInstanceClient::CheckSupportedFeatures(int mask) const
569 {
570 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
571 if (masSdpParamSave_.supportedFeatrue & mask) {
572 return true;
573 } else {
574 return false;
575 }
576 }
577
578 // internal
ExcuteCallbackToFramework(MapRequestResponseAction & retAction,MapExecuteStatus resCode)579 void MapMceInstanceClient::ExcuteCallbackToFramework(MapRequestResponseAction &retAction, MapExecuteStatus resCode)
580 {
581 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
582 if ((retAction.action_ == MapActionType::GET_MESSAGE) ||
583 (retAction.action_ == MapActionType::GET_UNREAD_MESSAGES)) {
584 IProfileBMessage bmsg;
585 bmsg.bMessageParam_ = retAction.bmessage_.GetBMessageData();
586 bmsg.bMessageStringObject_ = retAction.bmessage_.GetBmessageObject();
587 bmsg.FractionDeliver = retAction.bmessage_.GetFractionDeliver();
588 observerMgrPtr_.ExcuteObserverOnBmessageCompleted(
589 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), bmsg, resCode);
590 } else if (retAction.action_ == MapActionType::GET_MESSAGES_LISTING) {
591 IProfileMessagesListing msgListing;
592 msgListing.messageOutlineList_ = retAction.messageList_.GetList();
593 msgListing.messagesListingParam_ = retAction.messageList_.GetParam();
594 msgListing.messagesListingStringObject_ = retAction.messageList_.GetStringObject();
595 observerMgrPtr_.ExcuteObserverOnMessagesListingCompleted(
596 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), msgListing, resCode);
597 } else if (retAction.action_ == MapActionType::GET_CONVERSATION_LISTING) {
598 IProfileConversationListing convListing;
599 convListing.conversationOutlineList_ = retAction.conversationList_.GetList();
600 convListing.conversationListingParam_ = retAction.conversationList_.GetParam();
601 convListing.conversationListingStringObject_ = retAction.conversationList_.GetStringObject();
602 observerMgrPtr_.ExcuteObserverOnConversationListingCompleted(
603 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), convListing, resCode);
604 } else {
605 IProfileMapAction prifileAction;
606 prifileAction.action_ = retAction.action_;
607 prifileAction.ownerStatus_ = retAction.ownerStatus_;
608 prifileAction.supportedFeatures_ = retAction.supportedFeatures;
609 observerMgrPtr_.ExcuteObserverOnMapActionCompleted(
610 ((MapMceInstanceStm &)instanceStm_).GetBtDevice(), prifileAction, resCode);
611 }
612 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
613 }
614
~MasObexClientObserver()615 MapMceInstanceClient::MasObexClientObserver::~MasObexClientObserver()
616 {
617 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
618 }
619
OnTransportFailed(ObexClient & client,int errCd)620 void MapMceInstanceClient::MasObexClientObserver::OnTransportFailed(ObexClient &client, int errCd)
621 {
622 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
623 utility::Message msg = MSG_MASSTM_OBEX_TRANSPORT_FAILED;
624 msg.arg1_ = errCd;
625 // post msg to mns state machine instance. execute in mns service thread
626 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
627 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
628 }
629
OnConnected(ObexClient & client,const ObexHeader & resp)630 void MapMceInstanceClient::MasObexClientObserver::OnConnected(ObexClient &client, const ObexHeader &resp)
631 {
632 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
633 utility::Message msg = MSG_MASSTM_OBEX_CONNECTED;
634 // post msg to mns state machine instance. execute in mns service thread
635 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
636 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
637 }
638
OnConnectFailed(ObexClient & client,const ObexHeader & resp)639 void MapMceInstanceClient::MasObexClientObserver::OnConnectFailed(ObexClient &client, const ObexHeader &resp)
640 {
641 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
642 ObexHeader *tempPtr = const_cast<ObexHeader *>(&resp);
643 utility::Message msg(MSG_MASSTM_OBEX_CONNECTED_FAILED);
644 // save error code
645 msg.arg1_ = int(tempPtr->GetFieldCode());
646 // post msg to mns state machine instance. execute in mns service thread
647 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
648 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
649 }
650
OnDisconnected(ObexClient & client)651 void MapMceInstanceClient::MasObexClientObserver::OnDisconnected(ObexClient &client)
652 {
653 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
654 utility::Message msg = MSG_MASSTM_OBEX_DISCONNECTED;
655 // post msg to mns state machine instance. execute in mns service thread
656 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
657 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
658 }
659
OnActionCompleted(ObexClient & client,const ObexHeader & resp)660 void MapMceInstanceClient::MasObexClientObserver::OnActionCompleted(ObexClient &client, const ObexHeader &resp)
661 {
662 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
663 // action finish
664 utility::Message msg(MSG_MASSTM_RECEIVE_REQUEST_COMPLETED);
665 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessageWithObexHeader(msg, resp);
666 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
667 }
668
OnBusy(ObexClient & client,bool isBusy)669 void MapMceInstanceClient::MasObexClientObserver::OnBusy(ObexClient &client, bool isBusy)
670 {
671 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
672 utility::Message msg = MSG_MASSTM_OBEX_INFO_CHG_CONTINUEBUSY_STATUS;
673 msg.arg1_ = int(isBusy);
674 ((MapMceInstanceStm &)obexObserverInstStm_).PostMessage(msg);
675 }
676 } // namespace bluetooth
677 } // namespace OHOS
678