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
21 *
22 */
23
24 /**
25 * @file map_mce_device_ctrl.h
26 *
27 * @brief Declares of map mce service device control.
28 *
29 */
30
31 #include "map_mce_device_ctrl.h"
32 #include "interface_profile_manager.h"
33 #include "interface_profile_map_mce.h"
34 #include "log.h"
35 #include "map_mce_instance_stm.h"
36 #include "map_mce_mns_server.h"
37 #include "power_manager.h"
38 #include "sdp.h"
39
40 namespace OHOS {
41 namespace bluetooth {
42 const uint8_t MapMceDeviceCtrl::mnsTargetUuidTbl_[MAX_OF_MASCLIENT_OBEX_UUID_TBL] = {
43 0xbb, 0x58, 0x2b, 0x41, 0x42, 0x0c, 0x11, 0xdb, 0xb0, 0xde, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
44 };
45
46 // sdp call back function declare
MceAnalyseSdpAttribute(MasSdpParam & saveParam,const SdpService & servicePointer,uint16_t & l2capServerNum,bool & findL2capId)47 int MceAnalyseSdpAttribute(
48 MasSdpParam &saveParam, const SdpService &servicePointer, uint16_t &l2capServerNum, bool &findL2capId)
49 {
50 bool findMessageType = false;
51 bool findInstanceFeature = false;
52 bool findInstance = false;
53 int ret = BT_SUCCESS;
54
55 SdpAttribute *tempAttribute = servicePointer.attribute;
56 for (int attSeqCount = 0; attSeqCount < servicePointer.attributeNumber; attSeqCount++, tempAttribute++) {
57 if (tempAttribute->attributeId == MAP_MCE_GOEP_L2CAP_PSM_ATTRIBUTE_ID) {
58 #ifndef MCE_DISABLE_L2CAP
59 // l2cap is invalid
60 saveParam.isGoepL2capPSM = true;
61 findL2capId = true;
62 l2capServerNum = *(uint16_t *)tempAttribute->attributeValue;
63 #endif
64 } else if (tempAttribute->attributeId == MAP_MCE_INSTANCE_ATTRIBUTE_ID) {
65 saveParam.instanceId = *(uint8_t *)(tempAttribute->attributeValue);
66 findInstance = true;
67 } else if (tempAttribute->attributeId == MAP_MCE_SUPPORTED_FEATURES_ATTRIBUTE_ID) {
68 saveParam.supportedFeatrue = *(uint32_t *)tempAttribute->attributeValue;
69 findInstanceFeature = true;
70 } else if (tempAttribute->attributeId == MAP_MCE_SUPPORTED_MESSAGE_TYPE_ATTRIBUTE_ID) {
71 saveParam.messageType = *(uint8_t *)(tempAttribute->attributeValue);
72 findMessageType = true;
73 } else {
74 }
75 }
76 if (!findInstanceFeature) {
77 // set default value
78 saveParam.supportedFeatrue = 0x1F;
79 LOG_ERROR("%{public}s: not found supportedFeatrue , set default value=0x1f", __PRETTY_FUNCTION__);
80 }
81 // check sdp param value
82 if ((!findMessageType) || (!findInstance)) {
83 // param error
84 ret = RET_BAD_PARAM;
85 LOG_ERROR("%{public}s param error:inst=%{public}d,type:%{public}d",
86 __PRETTY_FUNCTION__, findInstance, findMessageType);
87 }
88 return ret;
89 }
90
MceAnalyseSdpDescriptorRfcomm(SdpProtocolDescriptor & descriptor,uint16_t & serverNum)91 bool MceAnalyseSdpDescriptorRfcomm(SdpProtocolDescriptor &descriptor, uint16_t &serverNum)
92 {
93 bool findRfcommVal = false;
94 for (int i = 0; i < descriptor.parameterNumber; i++) {
95 if (descriptor.parameter[i].type != 0) {
96 serverNum = uint8_t(descriptor.parameter[i].value);
97 findRfcommVal = true;
98 break;
99 }
100 }
101 return findRfcommVal;
102 }
103
MceAnalyseSdpProtocolDescriptor(MasSdpParam & saveParam,const SdpService & servicePointer,uint16_t & rfcommServerNum,bool findL2capId)104 int MceAnalyseSdpProtocolDescriptor(
105 MasSdpParam &saveParam, const SdpService &servicePointer, uint16_t &rfcommServerNum, bool findL2capId)
106 {
107 bool findRfcommId = false;
108 bool findRfcommValue = false;
109 int ret = BT_SUCCESS;
110
111 // sdp protocol descriptor analyse
112 SdpProtocolDescriptor *tempDescriptor = servicePointer.descriptor;
113 for (int descriptorCount = 0; descriptorCount < servicePointer.descriptorNumber;
114 descriptorCount++, tempDescriptor++) {
115 // if l2cap valid , scn_ is 1;
116 if (tempDescriptor->protocolUuid.uuid16 == UUID_PROTOCOL_L2CAP) { // MCE_PROTOCOL_DESCRIPTOR_L2CAP_UUID
117 LOG_INFO("%{public}s find UUID_PROTOCOL_L2CAP", __PRETTY_FUNCTION__);
118 } else if (tempDescriptor->protocolUuid.uuid16 == UUID_PROTOCOL_RFCOMM) {
119 findRfcommId = true;
120 findRfcommValue = MceAnalyseSdpDescriptorRfcomm(*tempDescriptor, rfcommServerNum);
121 LOG_INFO("%{public}s find UUID_PROTOCOL_RFCOMM", __PRETTY_FUNCTION__);
122 }
123 }
124
125 if ((findRfcommId && (!findRfcommValue)) || !(findL2capId || findRfcommId)) {
126 LOG_ERROR("%{public}s param error:l2id=%{public}d,rf=%{public}d,%{public}d",
127 __PRETTY_FUNCTION__, findL2capId, findRfcommId, findRfcommValue);
128 ret = RET_BAD_PARAM;
129 }
130 return ret;
131 }
132
MceAnalyseSdpParam(MasSdpParam & saveParam,const SdpService & servicePointer)133 int MceAnalyseSdpParam(MasSdpParam &saveParam, const SdpService &servicePointer)
134 {
135 uint16_t rfcommServerNum = 0;
136 uint16_t l2capServerNum = 0;
137 bool findL2capId = false;
138 int ret;
139
140 // Start sdp analyse
141 saveParam.isGoepL2capPSM = false;
142
143 ret = MceAnalyseSdpAttribute(saveParam, servicePointer, l2capServerNum, findL2capId);
144 if (ret != BT_SUCCESS) {
145 return ret;
146 }
147 ret = MceAnalyseSdpProtocolDescriptor(saveParam, servicePointer, rfcommServerNum, findL2capId);
148 if (ret != BT_SUCCESS) {
149 return ret;
150 }
151 // get rfcomm
152 if (saveParam.isGoepL2capPSM) {
153 saveParam.scn = l2capServerNum;
154 } else {
155 saveParam.scn = rfcommServerNum;
156 }
157 // get service name
158 if (servicePointer.serviceName != nullptr) {
159 saveParam.serviceName = servicePointer.serviceName;
160 } else {
161 saveParam.serviceName = "";
162 }
163 LOG_INFO("%{public}s execute finish:isL2cap=%{public}d,scn=0x%x,msgType=%{public}d,gapNumb=%{public}d,"
164 "servicName=%{public}s", __PRETTY_FUNCTION__, saveParam.isGoepL2capPSM, saveParam.scn,
165 saveParam.messageType, saveParam.gapNumber, saveParam.serviceName.c_str());
166 return ret;
167 }
168
MapMceSdpSearchCb(const BtAddr * addr,const SdpService * serviceAry,uint16_t serviceNum,int finishId,int failedId)169 void MapMceSdpSearchCb(
170 const BtAddr *addr, const SdpService *serviceAry, uint16_t serviceNum, int finishId, int failedId)
171 {
172 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
173 GAP_Service gapCounter = MAP_CLIENT_ID_START;
174 IProfileManager *serviceMgr = IProfileManager::GetInstance();
175 if (serviceMgr == nullptr) {
176 return;
177 }
178 auto mceService = static_cast<MapMceService *>(serviceMgr->GetProfileService(PROFILE_NAME_MAP_MCE));
179 if (mceService == nullptr) {
180 LOG_ERROR("%{public}s mceService is nullptr", __PRETTY_FUNCTION__);
181 return;
182 }
183 MapSdpMsgArgPrt *argPtr = new (std::nothrow)MapSdpMsgArgPrt;
184 if (argPtr == nullptr) {
185 LOG_ERROR("%{public}s argPtr is nullptr", __PRETTY_FUNCTION__);
186 return;
187 }
188 MasSdpParam sdpSaveParam;
189 // check servcie array
190 utility::Message msg(failedId);
191 argPtr->address = *addr;
192 msg.arg2_ = (void *)argPtr;
193 if ((serviceAry == nullptr) || (serviceNum == 0)) {
194 mceService->PostMessage(msg);
195 LOG_ERROR("%{public}s service error,serviceAry is NUL or serviceNum =%{public}d",
196 __PRETTY_FUNCTION__, int(serviceNum));
197 return;
198 }
199 const SdpService *servPtr = serviceAry;
200 for (int serviceCount = 0; serviceCount < serviceNum; serviceCount++, servPtr++) {
201 // check param array
202 if ((servPtr->attribute == nullptr) || (servPtr->attributeNumber == 0) || (servPtr->descriptor == nullptr) ||
203 (servPtr->descriptorNumber == 0)) {
204 mceService->PostMessage(msg);
205 LOG_ERROR("%{public}s error:attrPtr is NULL or attrNum=%{public}d",
206 __PRETTY_FUNCTION__, servPtr->attributeNumber);
207 LOG_ERROR("%{public}s error:script is NULL or script Num=%{public}d",
208 __PRETTY_FUNCTION__, servPtr->descriptorNumber);
209 return;
210 }
211 // Start sdp analyse
212 sdpSaveParam.gapNumber = gapCounter;
213 int ret = MceAnalyseSdpParam(sdpSaveParam, *servPtr);
214 // check sdp param value
215 if (ret != BT_SUCCESS) {
216 // param error
217 mceService->PostMessage(msg);
218 return;
219 }
220 // make sdp param list
221 argPtr->masSdpParamListPrt.push_back(sdpSaveParam);
222 gapCounter = (GAP_Service)(gapCounter + 1); // for gap regester
223 }
224 // Find stm instance
225 msg.what_ = finishId;
226 mceService->PostMessage(msg);
227 }
228
MapMceServiceSdpSearchCb(const BtAddr * addr,const SdpService * serviceAry,uint16_t serviceNum,void * context)229 void MapMceServiceSdpSearchCb(const BtAddr *addr, const SdpService *serviceAry, uint16_t serviceNum, void *context)
230 {
231 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
232
233 // sdp value display
234 MapMceSdpSearchCb(
235 addr, serviceAry, serviceNum, MSG_MCEDEVICE_SDP_GET_INSTANCE_FINISH, MSG_MCEDEVICE_SDP_GET_INSTANCE_FAILED);
236 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
237 }
238
MapMceDeviceCtrl(const std::string & device,MapMceService & service,bool notifySet,MasInstanceConfig config,MapMceObserverManager & callback)239 MapMceDeviceCtrl::MapMceDeviceCtrl(const std::string &device, MapMceService &service, bool notifySet,
240 MasInstanceConfig config, MapMceObserverManager &callback)
241 : btDevice_(device), devService_(service), notificationRegistration_(notifySet), deviceRpcCallbackMgr_(callback)
242 {
243 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
244 btDeviceState_ = MAP_MCE_DEV_STATE_DISCONNECTED;
245 btDeviceTargetState_ = MAP_MCE_DEV_STATE_CONNECTED;
246 deviceInstanceStmMap_.clear();
247 mnsServerStatus_ = MAP_MCE_DEV_STATE_DISCONNECTED;
248 mnsObexSession_ = nullptr;
249 mnsSessionObexheader_ = nullptr;
250 supportedFeatures_ = 0;
251 insDefaultConfig_ = config;
252 connectId_ = config.deviceId << MCE_16BIT;
253 ctrlSendFlag_ = false;
254 ctrlBusyStatus_ = MAP_MCE_PWBUSY_STATUS_DISCONNECT;
255 mnsContinueBusyFlag_ = false;
256 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
257 }
258
~MapMceDeviceCtrl()259 MapMceDeviceCtrl::~MapMceDeviceCtrl()
260 {
261 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
262 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
263 // check iterator in map
264 deviceInstanceStmMap_.clear();
265 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
266 }
267
StartConnecting()268 int MapMceDeviceCtrl::StartConnecting()
269 {
270 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
271 // check sdp
272 RawAddress rawAddr(btDevice_);
273 int ret = GetSupportedMasInstances(rawAddr);
274 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
275 return ret;
276 }
277
AllInstancesStartConnecting()278 void MapMceDeviceCtrl::AllInstancesStartConnecting()
279 {
280 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
281 utility::Message msg(MSG_MASSTM_REQ_CONNECT);
282 for (auto &it : deviceInstanceStmMap_) {
283 TransClientState(MAP_MCE_DEV_STATE_CONNECTING);
284 static_cast<MapMceInstanceStm *>(it.second.get())->ProcessMessage(msg);
285 }
286 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
287 }
288
AllInstancesStartDisConnecting()289 bool MapMceDeviceCtrl::AllInstancesStartDisConnecting()
290 {
291 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
292 // disconnect the instance client
293 bool finish = true;
294 utility::Message msg(MSG_MASSTM_REQ_DISCONNECT);
295 for (auto &it : deviceInstanceStmMap_) {
296 auto stm = static_cast<MapMceInstanceStm *>(it.second.get());
297 if (stm->GetCurrentMceStmStateName() != MCE_DISCONNECTED_STATE) {
298 stm->ProcessMessage(msg);
299 finish = false;
300 }
301 }
302 // disconnect the mns server
303 if (GetMnsState() != MAP_MCE_DEV_STATE_DISCONNECTED) {
304 MnsProcRequestDisconnect();
305 finish = false;
306 }
307
308 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
309 return finish;
310 }
311
312 // call by service
PostMessageWithRequest(utility::Message msg,std::unique_ptr<MapMceInstanceRequest> & req)313 int MapMceDeviceCtrl::PostMessageWithRequest(utility::Message msg, std::unique_ptr<MapMceInstanceRequest> &req)
314 {
315 LOG_INFO("%{public}s enter,msg=0x%x", __PRETTY_FUNCTION__, msg.what_);
316 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
317 int ret = RET_BAD_STATUS;
318 if (!ctrlSendFlag_) {
319 ctrlSendFlag_ = true;
320 ctrlRequestPtr_ = std::move(req);
321 devService_.GetDispatcher()->PostTask(std::bind(&MapMceDeviceCtrl::ProcessMessage, this, msg));
322 ret = BT_SUCCESS;
323 LOG_INFO("%{public}s ctrlSendFlag_ set", __PRETTY_FUNCTION__);
324 } else {
325 LOG_ERROR("%{public}s ctrlSendFlag_ is true", __PRETTY_FUNCTION__);
326 }
327 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
328 return ret;
329 }
330
PostMessage(utility::Message msg)331 void MapMceDeviceCtrl::PostMessage(utility::Message msg)
332 {
333 LOG_INFO("%{public}s execute,msg=0x%x", __PRETTY_FUNCTION__, msg.what_);
334 devService_.GetDispatcher()->PostTask(std::bind(&MapMceDeviceCtrl::ProcessMessage, this, msg));
335 }
336
GetCurrentDeviceState()337 MapMceDeviceStateType MapMceDeviceCtrl::GetCurrentDeviceState()
338 {
339 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
340 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
341 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
342 return MapMceDeviceStateType(int(btDeviceState_));
343 }
344
GetTargetDeviceState() const345 MapMceDeviceStateType MapMceDeviceCtrl::GetTargetDeviceState() const
346 {
347 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
348 return MapMceDeviceStateType(int(btDeviceTargetState_));
349 }
350
351 // call by service
GetMasInstanceInfo(const RawAddress & device)352 std::vector<IProfileMasInstanceInfo> MapMceDeviceCtrl::GetMasInstanceInfo(const RawAddress &device)
353 {
354 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
355 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
356
357 std::vector<IProfileMasInstanceInfo> instancInfoList;
358 IProfileMasInstanceInfo profileInfo;
359 MasInstanceInformation deviceInfo;
360 MasSdpParam sdpInfo;
361 for (auto &it : deviceInstanceStmMap_) {
362 auto stm = static_cast<MapMceInstanceStm *>(it.second.get());
363 deviceInfo = stm->GetMasClient().GetMasInstanceInformation();
364 sdpInfo = stm->GetMasClient().GetMasSdpParam();
365 profileInfo.OwnerUCI = deviceInfo.ownerUciUtf8;
366 profileInfo.MASInstanceInformation = deviceInfo.masInstanceInfoUtf8;
367 profileInfo.supportedMsgTypes_ = sdpInfo.messageType;
368 profileInfo.instanceId = sdpInfo.instanceId;
369 if (deviceInfo.isValid) {
370 instancInfoList.push_back(profileInfo);
371 }
372 }
373 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
374 return instancInfoList;
375 }
376
DeviceStateConvertToProfileState(MapMceDeviceStateType deviceState)377 int MapMceDeviceCtrl::DeviceStateConvertToProfileState(MapMceDeviceStateType deviceState)
378 {
379 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
380 int ret = PROFILE_STATE_DISCONNECTED;
381 switch (deviceState) {
382 case MAP_MCE_DEV_STATE_CONNECTED:
383 ret = PROFILE_STATE_CONNECTED;
384 break;
385 case MAP_MCE_DEV_STATE_CONNECTING:
386 ret = PROFILE_STATE_CONNECTING;
387 break;
388 case MAP_MCE_DEV_STATE_DISCONNECTED:
389 ret = PROFILE_STATE_DISCONNECTED;
390 break;
391 case MAP_MCE_DEV_STATE_DISCONNECTING:
392 ret = PROFILE_STATE_DISCONNECTING;
393 break;
394 default:
395 // error
396 break;
397 }
398 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
399 return ret;
400 }
401
402 // call by service
GetBtDevice()403 std::string MapMceDeviceCtrl::GetBtDevice()
404 {
405 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
406 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
407
408 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
409 return btDevice_;
410 }
411
GetBtAddress()412 BtAddr MapMceDeviceCtrl::GetBtAddress()
413 {
414 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
415 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
416
417 BtAddr btAddress;
418 btAddress.type = BT_PUBLIC_DEVICE_ADDRESS;
419 RawAddress rawAddress(btDevice_);
420 rawAddress.ConvertToUint8(btAddress.addr, sizeof(btAddress.addr));
421 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
422 return btAddress;
423 }
424
425 // call by stm
GetDeviceCallbackMgr() const426 MapMceObserverManager &MapMceDeviceCtrl::GetDeviceCallbackMgr() const
427 {
428 return deviceRpcCallbackMgr_;
429 }
430
TransClientState(MapMceDeviceStateType state)431 void MapMceDeviceCtrl::TransClientState(MapMceDeviceStateType state)
432 {
433 if (btDeviceState_ != state) {
434 btDeviceState_ = state;
435 deviceRpcCallbackMgr_.ExcuteObserverOnConnectionStateChanged(btDevice_, state);
436 LOG_INFO("%{public}s to state:%{public}d", __PRETTY_FUNCTION__, state);
437
438 // set power busy state
439 if (btDeviceState_ == MAP_MCE_DEV_STATE_CONNECTED) {
440 TransPowerBusyState(MAP_MCE_PWBUSY_STATUS_CONNECT);
441 } else if (btDeviceState_ == MAP_MCE_DEV_STATE_DISCONNECTED) {
442 TransPowerBusyState(MAP_MCE_PWBUSY_STATUS_DISCONNECT);
443 } else {
444 }
445 }
446 }
447
TransMnsState(MapMceDeviceStateType state)448 void MapMceDeviceCtrl::TransMnsState(MapMceDeviceStateType state)
449 {
450 if (mnsServerStatus_ != state) {
451 mnsServerStatus_ = state;
452 LOG_INFO("%{public}s to state:%{public}d", __PRETTY_FUNCTION__, state);
453 }
454 }
455
456 // internal
GetMnsState() const457 MapMceDeviceStateType MapMceDeviceCtrl::GetMnsState() const
458 {
459 return MapMceDeviceStateType(int(mnsServerStatus_));
460 }
461
462 // call by service
GetDeviceInstanseStmMapSize()463 int MapMceDeviceCtrl::GetDeviceInstanseStmMapSize()
464 {
465 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
466 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
467
468 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
469 return int(deviceInstanceStmMap_.size());
470 }
471
472 // internal
GetSupportedMasInstances(const RawAddress & device)473 int MapMceDeviceCtrl::GetSupportedMasInstances(const RawAddress &device)
474 {
475 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
476 // config search attribute
477 SdpAttributeIdList attributeIdList = {SDP_TYPE_LIST, .attributeIdList = {0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}};
478 int index = 0;
479 attributeIdList.attributeIdList.attributeId[index++] = MAP_MCE_GOEP_L2CAP_PSM_ATTRIBUTE_ID;
480 attributeIdList.attributeIdList.attributeId[index++] = MAP_MCE_INSTANCE_ATTRIBUTE_ID;
481 attributeIdList.attributeIdList.attributeId[index++] = MAP_MCE_SUPPORTED_FEATURES_ATTRIBUTE_ID;
482 attributeIdList.attributeIdList.attributeId[index++] = SDP_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST;
483 attributeIdList.attributeIdList.attributeId[index++] = MAP_MCE_SUPPORTED_MESSAGE_TYPE_ATTRIBUTE_ID;
484 attributeIdList.attributeIdList.attributeId[index++] = SDP_ATTRIBUTE_PRIMARY_LANGUAGE_BASE;
485 attributeIdList.attributeIdList.attributeIdNumber = index;
486 attributeIdList.type = SDP_TYPE_LIST;
487 // set uuid
488 BtUuid btUuid = {0, {.uuid128 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}};
489 btUuid.type = BT_UUID_16;
490 btUuid.uuid16 = MAP_MCE_SERVICE_CLASS_UUID;
491
492 SdpUuid sdpUuid = {0, nullptr};
493 sdpUuid.uuid = &btUuid;
494 sdpUuid.uuidNum = 1;
495
496 // get the bluetooth address
497 BtAddr btAddr = {{0, 0, 0, 0, 0, 0}, 0};
498 btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
499 RawAddress rawAddr(device.GetAddress());
500 rawAddr.ConvertToUint8(btAddr.addr, sizeof(btAddr.addr));
501
502 // sdp Search
503 int retVal = SDP_ServiceSearchAttribute(&btAddr, &sdpUuid, attributeIdList, nullptr, MapMceServiceSdpSearchCb);
504 if (retVal != BT_SUCCESS) {
505 LOG_ERROR("%{public}s error:SDP_ServiceSearchAttribute", __PRETTY_FUNCTION__);
506 }
507 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
508 return retVal;
509 }
510
ProcessMessageStateProcess(utility::Message msg)511 void MapMceDeviceCtrl::ProcessMessageStateProcess(utility::Message msg)
512 {
513 // mas client state process
514 switch (btDeviceState_) {
515 case MAP_MCE_DEV_STATE_CONNECTED:
516 ClientConnectedProcMsg(msg);
517 break;
518 case MAP_MCE_DEV_STATE_CONNECTING:
519 ClientConnectingProcMsg(msg);
520 break;
521 case MAP_MCE_DEV_STATE_DISCONNECTED:
522 ClientDisconnectedProcMsg(msg);
523 break;
524 case MAP_MCE_DEV_STATE_DISCONNECTING:
525 ClientDisConnectingProcMsg(msg);
526 break;
527 default:
528 break;
529 }
530 // mns state process
531 switch (mnsServerStatus_) {
532 case MAP_MCE_DEV_STATE_CONNECTED:
533 MnsConnectedProcMsg(msg);
534 break;
535 case MAP_MCE_DEV_STATE_CONNECTING:
536 MnsConnectingProcMsg(msg);
537 break;
538 case MAP_MCE_DEV_STATE_DISCONNECTED:
539 MnsDisconnectedProcMsg(msg);
540 break;
541 case MAP_MCE_DEV_STATE_DISCONNECTING:
542 MnsDisconnectingProcMsg(msg);
543 break;
544 default:
545 break;
546 }
547 }
548
549 // main process
ProcessMessage(utility::Message msg)550 void MapMceDeviceCtrl::ProcessMessage(utility::Message msg)
551 {
552 LOG_INFO("%{public}s enter,input msg=0x%x", __PRETTY_FUNCTION__, msg.what_);
553 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
554
555 // preprocess
556 switch (msg.what_) {
557 case MSG_MCEDEVICE_REQ_DEVICE_DISCONNECT:
558 btDeviceTargetState_ = MapMceDeviceStateType::MAP_MCE_DEV_STATE_DISCONNECTED;
559 LOG_INFO("%{public}s targstate=%{public}d", __PRETTY_FUNCTION__, int(btDeviceTargetState_));
560 break;
561 case MSG_MCEDEVICE_REQ_DEVICE_CONNECT:
562 btDeviceTargetState_ = MapMceDeviceStateType::MAP_MCE_DEV_STATE_CONNECTED;
563 LOG_INFO("%{public}s targstate=%{public}d", __PRETTY_FUNCTION__, int(btDeviceTargetState_));
564 break;
565 default:
566 break;
567 }
568 // process message
569 ProcessMessageStateProcess(msg);
570 // back process
571 if (msg.what_ == MSG_MCEDEVICE_REQ_SEND_REQUEST) {
572 ctrlSendFlag_ = false; // release the request resource
573 LOG_INFO("%{public}s ctrlSendFlag_ clear", __PRETTY_FUNCTION__);
574 }
575 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
576 }
577
ProcessMnsObexObserverMessage(const ObexHeader & req,utility::Message msg)578 void MapMceDeviceCtrl::ProcessMnsObexObserverMessage(const ObexHeader &req, utility::Message msg)
579 {
580 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
581 MnsChangeSessionObexHeader(req);
582 ProcessMessage(msg);
583 }
584
ClientConnectedProcMsg(utility::Message msg)585 void MapMceDeviceCtrl::ClientConnectedProcMsg(utility::Message msg)
586 {
587 LOG_INFO("%{public}s enter,input msg=%{public}d", __PRETTY_FUNCTION__, msg.what_);
588 utility::Message outMsg(MSG_MCESERVICE_DEVICE_DISCONNECTED);
589 switch (msg.what_) {
590 case MSG_MCEDEVICE_REQ_DEVICE_DISCONNECT:
591 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTING);
592 AllInstancesStartDisConnecting();
593 break;
594 case MSG_MCEDEVICE_REQ_DEVICE_CONNECT:
595 break;
596 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FINISH:
597 break;
598 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FAILED:
599 break;
600 case MSG_MCEDEVICE_INSCLIENT_DISCONNECTED:
601 case MSG_MCEDEVICE_INSCLIENT_TRANSPORT_ERRO:
602 // server disconnect or transport error
603 // check disconnect finish
604 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTING);
605 btDeviceTargetState_ = MAP_MCE_DEV_STATE_DISCONNECTED;
606 if (AllInstancesStartDisConnecting()) {
607 // had disconnected
608 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTED);
609 // all disconnected ,info disconnect to service
610 outMsg.what_ = MSG_MCESERVICE_DEVICE_DISCONNECTED;
611 devService_.PostMessage(outMsg);
612 }
613 break;
614 case MSG_MCEDEVICE_INSCLIENT_CONNECTED:
615 break;
616 case MSG_MCEDEVICE_INSCLIENT_CONNECT_FAILED:
617 break;
618 case MSG_MCEDEVICE_REQ_SEND_REQUEST:
619 SendRequest(msg);
620 break;
621 case MSG_MCEDEVICE_INSCLIENT_INFO_BUSY_STATUS_CHANGE:
622 case MSG_MCEDEVICE_MNS_INFO_BUSY_STATUS_CHANGE:
623 CheckPowerBusyStateChange();
624 break;
625 default:
626 break;
627 }
628 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
629 }
630
ClientConnectingProcMsg(utility::Message msg)631 void MapMceDeviceCtrl::ClientConnectingProcMsg(utility::Message msg)
632 {
633 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
634 int ret = BT_SUCCESS;
635 utility::Message outMsg(MSG_MCESERVICE_DEVICE_DISCONNECTED);
636 switch (msg.what_) {
637 case MSG_MCEDEVICE_REQ_DEVICE_DISCONNECT:
638 break;
639 case MSG_MCEDEVICE_REQ_DEVICE_CONNECT:
640 break;
641 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FINISH:
642 ret = ProcessGetInstance(msg);
643 if (ret == BT_SUCCESS) {
644 AllInstancesStartConnecting();
645 } else {
646 // trans to disconnect
647 btDeviceTargetState_ = MAP_MCE_DEV_STATE_DISCONNECTED;
648 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTED);
649 // all disconnected ,info disconnect to service
650 outMsg.what_ = MSG_MCESERVICE_DEVICE_DISCONNECTED;
651 devService_.PostMessage(outMsg);
652 }
653 break;
654 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FAILED:
655 // connect failed
656 // set disconnect state
657 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTED);
658 btDeviceTargetState_ = MAP_MCE_DEV_STATE_DISCONNECTED;
659 // connecting error ,info disconnect to service
660 outMsg.what_ = MSG_MCESERVICE_DEVICE_DISCONNECTED;
661 devService_.PostMessage(outMsg);
662 break;
663 case MSG_MCEDEVICE_INSCLIENT_CONNECTED:
664 ProcessConnected();
665 break;
666 case MSG_MCEDEVICE_INSCLIENT_DISCONNECTED: // server req disconnect
667 case MSG_MCEDEVICE_INSCLIENT_TRANSPORT_ERRO: // transport error
668 case MSG_MCEDEVICE_INSCLIENT_CONNECT_FAILED: // connect failed
669 case MSG_MCEDEVICE_MNS_DEVICE_DISCONNECTED_FINISH:
670 LOG_INFO("%{public}s connecting failed!", __PRETTY_FUNCTION__);
671 // disconnect all instance
672 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTING);
673 btDeviceTargetState_ = MAP_MCE_DEV_STATE_DISCONNECTED;
674 if (AllInstancesStartDisConnecting()) {
675 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTED);
676 // all disconnected ,info disconnect to service
677 outMsg.what_ = MSG_MCESERVICE_DEVICE_DISCONNECTED;
678 devService_.PostMessage(outMsg);
679 }
680 break;
681 default:
682 break;
683 }
684 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
685 }
686
ClientDisconnectedProcMsg(utility::Message msg)687 void MapMceDeviceCtrl::ClientDisconnectedProcMsg(utility::Message msg)
688 {
689 int ret;
690 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
691 switch (msg.what_) {
692 case MSG_MCEDEVICE_REQ_DEVICE_DISCONNECT:
693 break;
694 case MSG_MCEDEVICE_REQ_DEVICE_CONNECT:
695 // device connecting start
696 ret = StartConnecting();
697 TransClientState(MAP_MCE_DEV_STATE_CONNECTING);
698 if (ret != BT_SUCCESS) {
699 LOG_INFO("%{public}s sdp error", __PRETTY_FUNCTION__);
700 }
701 break;
702 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FINISH:
703 break;
704 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FAILED:
705 break;
706 case MSG_MCEDEVICE_INSCLIENT_DISCONNECTED:
707 break;
708 case MSG_MCEDEVICE_INSCLIENT_CONNECTED:
709 break;
710 case MSG_MCEDEVICE_INSCLIENT_CONNECT_FAILED:
711 break;
712 case MSG_MCEDEVICE_INSCLIENT_TRANSPORT_ERRO:
713 break;
714
715 default:
716 break;
717 }
718 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
719 }
720
ClientDisConnectingProcMsg(utility::Message msg)721 void MapMceDeviceCtrl::ClientDisConnectingProcMsg(utility::Message msg)
722 {
723 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
724 switch (msg.what_) {
725 case MSG_MCEDEVICE_REQ_DEVICE_DISCONNECT:
726 break;
727 case MSG_MCEDEVICE_REQ_DEVICE_CONNECT:
728 break;
729 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FINISH:
730 break;
731 case MSG_MCEDEVICE_SDP_GET_INSTANCE_FAILED:
732 break;
733 case MSG_MCEDEVICE_INSCLIENT_CONNECTED:
734 break;
735 case MSG_MCEDEVICE_INSCLIENT_CONNECT_FAILED:
736 case MSG_MCEDEVICE_INSCLIENT_TRANSPORT_ERRO:
737 case MSG_MCEDEVICE_INSCLIENT_DISCONNECTED:
738 case MSG_MCEDEVICE_MNS_DEVICE_DISCONNECTED_FINISH:
739 // check disconnect finish
740 ProcessDisconnected();
741 break;
742 default:
743 break;
744 }
745 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
746 }
747
ProcessGetInstance(const utility::Message & msg)748 int MapMceDeviceCtrl::ProcessGetInstance(const utility::Message &msg)
749 {
750 LOG_INFO("%{public}s enter,insmod=%{public}d", __PRETTY_FUNCTION__, insDefaultConfig_.singleInstMode);
751 LOG_INFO("%{public}s ,instance id=%{public}d", __PRETTY_FUNCTION__, insDefaultConfig_.singleInstanceId);
752 int ret = RET_BAD_STATUS;
753 MasSdpParam sdpParam;
754 auto argPrt = static_cast<MapSdpMsgArgPrt *>(msg.arg2_);
755 if (argPrt == nullptr) {
756 LOG_ERROR("%{public}s error argPrt NULL", __PRETTY_FUNCTION__);
757 return ret;
758 }
759 // remove last instance
760 deviceInstanceStmMap_.clear();
761 // init supported features
762 supportedFeatures_ = 0;
763 // insert new instance
764 for (auto it = argPrt->masSdpParamListPrt.begin(); it != argPrt->masSdpParamListPrt.end(); it++) {
765 sdpParam = *it;
766 if (insDefaultConfig_.singleInstMode) {
767 if (insDefaultConfig_.singleInstanceId == sdpParam.instanceId) {
768 ret = BT_SUCCESS;
769 auto stateMachine1 = std::make_unique<MapMceInstanceStm>(
770 *this, *(devService_.GetDispatcher()), sdpParam.instanceId, insDefaultConfig_);
771 stateMachine1->CreateStm();
772 stateMachine1->GetMasClient().SetDefaultSdpParam(sdpParam);
773 deviceInstanceStmMap_.insert(std::pair<const int, std::unique_ptr<utility::StateMachine>>(
774 sdpParam.instanceId, std::move(stateMachine1)));
775 // save support features
776 supportedFeatures_ |= sdpParam.supportedFeatrue;
777 break;
778 }
779 } else {
780 ret = BT_SUCCESS;
781 auto stateMachine = std::make_unique<MapMceInstanceStm>(
782 *this, *(devService_.GetDispatcher()), sdpParam.instanceId, insDefaultConfig_);
783 stateMachine->CreateStm();
784 stateMachine->GetMasClient().SetDefaultSdpParam(sdpParam);
785 deviceInstanceStmMap_.insert(std::pair<const int, std::unique_ptr<utility::StateMachine>>(
786 sdpParam.instanceId, std::move(stateMachine)));
787 // save support features
788 supportedFeatures_ |= sdpParam.supportedFeatrue;
789 }
790 }
791 LOG_INFO("%{public}s end,supportedFeatures_=%x", __PRETTY_FUNCTION__, supportedFeatures_);
792 return ret;
793 }
794
ProcessDisconnected()795 void MapMceDeviceCtrl::ProcessDisconnected()
796 {
797 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
798 int notfinish = false;
799 for (auto &it : deviceInstanceStmMap_) {
800 auto stm = static_cast<MapMceInstanceStm *>(it.second.get());
801 if (stm->GetCurrentMceStmStateName() != MCE_DISCONNECTED_STATE) {
802 notfinish = true;
803 }
804 }
805 // check mns server disconnect
806 if (GetMnsState() != MAP_MCE_DEV_STATE_DISCONNECTED) {
807 notfinish = true;
808 // disconnect the mns server
809 if (GetMnsState() == MAP_MCE_DEV_STATE_CONNECTED) {
810 MnsProcRequestDisconnect();
811 }
812 }
813 if (!notfinish) {
814 TransClientState(MAP_MCE_DEV_STATE_DISCONNECTED);
815 if (btDeviceTargetState_ == MAP_MCE_DEV_STATE_CONNECTED) {
816 // request connect;
817 utility::Message outMsg(MSG_MCEDEVICE_REQ_DEVICE_CONNECT);
818 PostMessage(outMsg);
819 } else {
820 utility::Message msg(MSG_MCESERVICE_DEVICE_DISCONNECTED);
821 devService_.PostMessage(msg);
822 }
823 }
824 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
825 }
826
ProcessConnected()827 void MapMceDeviceCtrl::ProcessConnected()
828 {
829 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
830 int notfinish = false;
831 for (auto &it : deviceInstanceStmMap_) {
832 auto stm = static_cast<MapMceInstanceStm *>(it.second.get());
833 std::string instanceState = stm->GetCurrentMceStmStateName();
834 if ((instanceState == MCE_DISCONNECTED_STATE) || (instanceState == MCE_DISCONNECTING_STATE) ||
835 (instanceState == MCE_CONNECTING_STATE)) {
836 notfinish = true;
837 }
838 }
839
840 if (!notfinish) {
841 TransClientState(MAP_MCE_DEV_STATE_CONNECTED);
842 // process target action
843 if (btDeviceTargetState_ == MAP_MCE_DEV_STATE_DISCONNECTED) {
844 // request disconnect
845 utility::Message outMsg(MSG_MCEDEVICE_REQ_DEVICE_DISCONNECT);
846 PostMessage(outMsg);
847 } else {
848 // process connected ok
849 utility::Message sendServiceMsg(MSG_MCESERVICE_DEVICE_CONNECTED);
850 devService_.PostMessage(sendServiceMsg);
851
852 // if connect ok , SetNotificationRegistration
853 std::map<const int, std::unique_ptr<utility::StateMachine>>::iterator it = deviceInstanceStmMap_.begin();
854 if (it != deviceInstanceStmMap_.end()) {
855 static_cast<MapMceInstanceStm *>(it->second.get())
856 ->GetMasClient()
857 .ClientSendReqSetNotificationRegistration(notificationRegistration_);
858 }
859 }
860 }
861 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
862 }
863
ChangeRequestTypeToIprofileType(MceRequestType type)864 MapActionType MapMceDeviceCtrl::ChangeRequestTypeToIprofileType(MceRequestType type)
865 {
866 MapActionType actType = MapActionType::GET_MAS_INSTANCE_INFO;
867 switch (type) {
868 case MCE_REQUEST_TYPE_SET_NOTIFICATION_FILTER:
869 actType = MapActionType::SET_NOTIFICATION_FILTER;
870 break;
871 case MCE_REQUEST_TYPE_GET_MESSAGE:
872 actType = MapActionType::GET_MESSAGE;
873 break;
874 case MCE_REQUEST_TYPE_GET_MESSAGELISTING:
875 actType = MapActionType::GET_MESSAGES_LISTING;
876 break;
877 case MCE_REQUEST_TYPE_SEND_MESSAGE:
878 actType = MapActionType::SEND_MESSAGE;
879 break;
880 case MCE_REQUEST_TYPE_SET_MESSAGE_STATUS:
881 actType = MapActionType::SET_MESSAGE_STATUS;
882 break;
883 case MCE_REQUEST_TYPE_GET_UNREAD_MESSAGES:
884 actType = MapActionType::GET_UNREAD_MESSAGES;
885 break;
886 case MCE_REQUEST_TYPE_UPDATE_INBOX:
887 actType = MapActionType::UPDATE_INBOX;
888 break;
889 case MCE_REQUEST_TYPE_SET_OWNER_STATUS:
890 actType = MapActionType::SET_OWNER_STATUS;
891 break;
892 case MCE_REQUEST_TYPE_GET_OWNER_STATUS:
893 actType = MapActionType::GET_OWNER_STATUS;
894 break;
895 case MCE_REQUEST_TYPE_GET_CONVERSATION_LISTING:
896 actType = MapActionType::GET_CONVERSATION_LISTING;
897 break;
898 default:
899 break;
900 }
901 return actType;
902 }
903
ProcessErrorObserver(MapMceInstanceRequest & request)904 void MapMceDeviceCtrl::ProcessErrorObserver(MapMceInstanceRequest &request)
905 {
906 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
907 MapExecuteStatus excuteStatus = MapExecuteStatus::NOT_SUPPORT;
908 IProfileMapAction retAction;
909
910 retAction.action_ = ChangeRequestTypeToIprofileType(request.GetRequestType());
911 if (retAction.action_ != MapActionType::GET_MAS_INSTANCE_INFO) {
912 if ((retAction.action_ == MapActionType::GET_MESSAGE) ||
913 (retAction.action_ == MapActionType::GET_UNREAD_MESSAGES)) {
914 IProfileBMessage bmsg;
915 deviceRpcCallbackMgr_.ExcuteObserverOnBmessageCompleted(btDevice_, bmsg, excuteStatus);
916 } else if (retAction.action_ == MapActionType::GET_MESSAGES_LISTING) {
917 IProfileMessagesListing msgListing;
918 deviceRpcCallbackMgr_.ExcuteObserverOnMessagesListingCompleted(btDevice_, msgListing, excuteStatus);
919 } else if (retAction.action_ == MapActionType::GET_CONVERSATION_LISTING) {
920 IProfileConversationListing convListing;
921 deviceRpcCallbackMgr_.ExcuteObserverOnConversationListingCompleted(btDevice_, convListing, excuteStatus);
922 } else {
923 deviceRpcCallbackMgr_.ExcuteObserverOnMapActionCompleted(btDevice_, retAction, excuteStatus);
924 }
925 }
926 }
927
SendRequest(utility::Message msg)928 void MapMceDeviceCtrl::SendRequest(utility::Message msg)
929 {
930 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
931
932 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
933 MapMceInstanceStm *stmNormalFindOkPtr = nullptr;
934
935 bool ownerFindOk = false;
936 bool normalFindOk = false;
937 if ((ctrlRequestPtr_ == nullptr) || (deviceInstanceStmMap_.size() == 0)) {
938 LOG_ERROR("%{public}s ctrlRequestPtr_ is NULL or size=%{public}d",
939 __PRETTY_FUNCTION__, int(deviceInstanceStmMap_.size()));
940 return;
941 }
942 MapMceInstanceRequest *req = ctrlRequestPtr_.get();
943 // out messange setup
944 utility::Message outMsg(MSG_MASSTM_REQ_SEND_REQUEST);
945 for (auto &it : deviceInstanceStmMap_) {
946 auto stm = static_cast<MapMceInstanceStm *>(it.second.get());
947
948 if (stm->GetMasClient().GetMasSdpParam().messageType & req->GetSupportMessageType()) {
949 stmNormalFindOkPtr = stm;
950 normalFindOk = true;
951 if (stm->GetMasClient().GetMasInstanceInformation().isValid &&
952 (stm->GetMasClient().GetMasInstanceInformation().ownerUciUtf8 == req->GetOwnerUci()) &&
953 (req->GetOwnerUci() != "")) {
954 ownerFindOk = true;
955 // process message
956 stm->MceProcessMessageWithRequest(outMsg, ctrlRequestPtr_);
957 LOG_INFO("%{public}s find owner=%{public}s", __PRETTY_FUNCTION__, req->GetOwnerUci().c_str());
958 break;
959 }
960 }
961 }
962 if ((!ownerFindOk) && normalFindOk) {
963 stmNormalFindOkPtr->MceProcessMessageWithRequest(outMsg, ctrlRequestPtr_);
964 }
965 if (normalFindOk != true) { // error
966 ProcessErrorObserver(*req);
967 LOG_ERROR("%{public}s request no support", __PRETTY_FUNCTION__);
968 }
969 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
970 }
971
MnsConnectedProcMsg(utility::Message msg)972 void MapMceDeviceCtrl::MnsConnectedProcMsg(utility::Message msg)
973 {
974 LOG_INFO("%{public}s enter,input msg=0x%x", __PRETTY_FUNCTION__, msg.what_);
975 int ret = BT_SUCCESS;
976 switch (msg.what_) {
977 case MSG_MCEDEVICE_MNS_INFO_DISCONNECT:
978 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTING);
979 ret = MnsProcDisconnectAccept(msg);
980 if (ret != BT_SUCCESS) {
981 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
982 MnsProcDisconnected();
983 LOG_ERROR("%{public}s Disconnect error", __PRETTY_FUNCTION__);
984 }
985 break;
986 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_ERROR:
987 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_DISCONNECTED:
988 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
989 MnsProcDisconnected();
990 break;
991 case MSG_MCEDEVICE_MNS_INFO_PUT:
992 MnsProcObexPut(msg);
993 break;
994 default:
995 break;
996 }
997 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
998 }
999
MnsDisconnectedProcMsg(utility::Message msg)1000 void MapMceDeviceCtrl::MnsDisconnectedProcMsg(utility::Message msg)
1001 {
1002 LOG_INFO("%{public}s enter,input msg=0x%x", __PRETTY_FUNCTION__, msg.what_);
1003 switch (msg.what_) {
1004 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_INCOMING:
1005 MnsProcIncomingAccept(msg);
1006 break;
1007 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_DISCONNECTED:
1008 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_ERROR:
1009 LOG_ERROR("%{public}s TRANSPORT_DISCONNECTED state error", __PRETTY_FUNCTION__);
1010 MnsProcDisconnected();
1011 break;
1012 default:
1013 break;
1014 }
1015 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
1016 }
1017
MnsConnectingProcMsg(utility::Message msg)1018 void MapMceDeviceCtrl::MnsConnectingProcMsg(utility::Message msg)
1019 {
1020 LOG_INFO("%{public}s enter,input msg=0x%x", __PRETTY_FUNCTION__, msg.what_);
1021 switch (msg.what_) {
1022 case MSG_MCEDEVICE_MNS_INFO_DISCONNECT:
1023 LOG_ERROR("%{public}s OnDisconnect state error", __PRETTY_FUNCTION__);
1024 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
1025 MnsProcDisconnected();
1026 break;
1027 case MSG_MCEDEVICE_MNS_INFO_CONNECT:
1028 // if client allow , server is connected
1029 MnsProcConnectAccept(msg);
1030 break;
1031 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_ERROR:
1032 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_DISCONNECTED:
1033 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
1034 MnsProcDisconnected();
1035 break;
1036 default:
1037 break;
1038 }
1039 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
1040 }
1041
MnsDisconnectingProcMsg(utility::Message msg)1042 void MapMceDeviceCtrl::MnsDisconnectingProcMsg(utility::Message msg)
1043 {
1044 LOG_INFO("%{public}s enter,input msg=0x%x", __PRETTY_FUNCTION__, msg.what_);
1045 switch (msg.what_) {
1046 case MSG_MCEDEVICE_MNS_INFO_DISCONNECT:
1047 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
1048 MnsProcDisconnected();
1049 LOG_ERROR("%{public}s OnDisconnect state error", __PRETTY_FUNCTION__);
1050 break;
1051 case MSG_MCEDEVICE_MNS_INFO_CONNECT:
1052 MnsProcConnectRefuse(msg);
1053 break;
1054 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_DISCONNECTED:
1055 case MSG_MCEDEVICE_MNS_INFO_TRANSPORT_ERROR:
1056 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
1057 MnsProcDisconnected();
1058 break;
1059 default:
1060 break;
1061 }
1062 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
1063 }
1064
MnsProcObexPut(utility::Message msg)1065 void MapMceDeviceCtrl::MnsProcObexPut(utility::Message msg)
1066 {
1067 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
1068
1069 uint8_t masInstanceId = 0;
1070
1071 auto appParam = mnsSessionObexheader_->GetItemAppParams();
1072
1073 if (appParam != nullptr) {
1074 auto tlvParam1 = appParam->GetTlvtriplet(MCE_MAS_INSTANCEID);
1075 if (tlvParam1 != nullptr) {
1076 const uint8_t *val1 = tlvParam1->GetVal();
1077 if ((tlvParam1->GetLen() != 0) && (val1 != nullptr)) {
1078 masInstanceId = *val1;
1079 }
1080 }
1081 } else {
1082 LOG_INFO("%{public}s ItemAppParams nullptr", __PRETTY_FUNCTION__);
1083 }
1084
1085 // get body
1086 auto objectData = mnsSessionObexheader_->GetExtendBodyObject();
1087 uint8_t tempBuf[MCE_MAX_LENGTH_OF_RESPONSE_BUFFER];
1088 size_t bufLen = 1;
1089 std::ostringstream stream;
1090
1091 while ((bufLen != 0) && (objectData != 0)) {
1092 bufLen = objectData->Read(tempBuf, MCE_MAX_LENGTH_OF_RESPONSE_BUFFER - 1);
1093 if (bufLen != 0) {
1094 tempBuf[bufLen] = 0;
1095 stream << (char *)tempBuf;
1096 }
1097 }
1098 MceTypesEventReport eventReport;
1099 if (stream.str().size() != 0) {
1100 eventReport.BuildObjectData(masInstanceId, stream.str());
1101 }
1102 deviceRpcCallbackMgr_.ExcuteObserverOnMapEventReported(btDevice_, eventReport.GetParam());
1103 std::unique_ptr<bluetooth::ObexHeader> resp = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
1104 if (mnsObexSession_ != nullptr) {
1105 int ret = mnsObexSession_->SendResponse(*resp);
1106 if (ret != BT_SUCCESS) {
1107 LOG_ERROR("%{public}s SendResponse execute error", __PRETTY_FUNCTION__);
1108 }
1109 }
1110 }
1111
MnsProcConnectAcceptCheckTargetId()1112 int MapMceDeviceCtrl::MnsProcConnectAcceptCheckTargetId()
1113 {
1114 // accept
1115 if (!mnsSessionObexheader_->GetItemTarget()) {
1116 mnsObexSession_->SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE, true));
1117 LOG_ERROR("%{public}s ObexRspCode::NOT_ACCEPTABLE", __PRETTY_FUNCTION__);
1118 return RET_BAD_PARAM;
1119 }
1120 if (mnsSessionObexheader_->GetItemTarget()->GetHeaderDataSize() != MAX_OF_MASCLIENT_OBEX_UUID_TBL) {
1121 mnsObexSession_->SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE, true));
1122 LOG_ERROR("%{public}s ObexRspCode::NOT_ACCEPTABLE", __PRETTY_FUNCTION__);
1123 return RET_BAD_PARAM;
1124 }
1125 // dont need check support feature
1126 std::unique_ptr<uint8_t[]> masTarget = mnsSessionObexheader_->GetItemTarget()->GetBytes();
1127 for (int i = 0; i < MAX_OF_MASCLIENT_OBEX_UUID_TBL; i++) {
1128 if (masTarget[i] != mnsTargetUuidTbl_[i]) {
1129 mnsObexSession_->SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE, true));
1130 LOG_ERROR("%{public}s ObexRspCode::NOT_ACCEPTABLE", __PRETTY_FUNCTION__);
1131 return RET_BAD_PARAM;
1132 }
1133 }
1134 return BT_SUCCESS;
1135 }
1136
CheckPowerBusyStateChange()1137 void MapMceDeviceCtrl::CheckPowerBusyStateChange()
1138 {
1139 bool findBusyFlag = false;
1140 // check mns server
1141 if (mnsContinueBusyFlag_) {
1142 findBusyFlag = true;
1143 }
1144 // check mas client
1145 for (auto &it : deviceInstanceStmMap_) {
1146 auto stm = static_cast<MapMceInstanceStm *>(it.second.get());
1147 if (stm->GetBusyStatus()) {
1148 findBusyFlag = true;
1149 }
1150 }
1151 if (findBusyFlag) {
1152 TransPowerBusyState(MAP_MCE_PWBUSY_STATUS_HIGH);
1153 } else {
1154 TransPowerBusyState(MAP_MCE_PWBUSY_STATUS_LOW);
1155 }
1156 }
1157
TransPowerBusyState(MapMcePowerBusyState state)1158 void MapMceDeviceCtrl::TransPowerBusyState(MapMcePowerBusyState state)
1159 {
1160 RawAddress rwDevice(btDevice_);
1161 if (ctrlBusyStatus_ != state) {
1162 LOG_INFO("%{public}s status = %{public}d", __PRETTY_FUNCTION__, ctrlBusyStatus_);
1163 IPowerManager &pwMgr = IPowerManager::GetInstance();
1164 ctrlBusyStatus_ = state;
1165 LOG_INFO("%{public}s to state = %{public}d", __PRETTY_FUNCTION__, ctrlBusyStatus_);
1166 if (ctrlBusyStatus_ == MAP_MCE_PWBUSY_STATUS_DISCONNECT) {
1167 mnsContinueBusyFlag_ = false;
1168 pwMgr.StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_MAP_MCE, rwDevice);
1169 } else if (ctrlBusyStatus_ == MAP_MCE_PWBUSY_STATUS_CONNECT) {
1170 pwMgr.StatusUpdate(RequestStatus::CONNECT_ON, PROFILE_NAME_MAP_MCE, rwDevice);
1171 } else if (ctrlBusyStatus_ == MAP_MCE_PWBUSY_STATUS_LOW) {
1172 pwMgr.StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_MAP_MCE, rwDevice);
1173 } else if (ctrlBusyStatus_ == MAP_MCE_PWBUSY_STATUS_HIGH) {
1174 pwMgr.StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_MAP_MCE, rwDevice);
1175 } else {
1176 pwMgr.StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_MAP_MCE, rwDevice);
1177 }
1178 }
1179 }
1180
MnsProcIncomingAccept(utility::Message msg)1181 void MapMceDeviceCtrl::MnsProcIncomingAccept(utility::Message msg)
1182 {
1183 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
1184 incomingPtr = static_cast<ObexIncomingConnect *>(msg.arg2_);
1185 if (incomingPtr != nullptr) {
1186 MapMceDeviceStateType state = GetCurrentDeviceState();
1187 if (((state == MAP_MCE_DEV_STATE_CONNECTED) || (state == MAP_MCE_DEV_STATE_CONNECTING)) &&
1188 (btDeviceTargetState_ == MAP_MCE_DEV_STATE_CONNECTED)) {
1189 TransMnsState(MAP_MCE_DEV_STATE_CONNECTING);
1190 incomingPtr->AcceptConnection();
1191 } else {
1192 incomingPtr->RejectConnection();
1193 LOG_ERROR("%{public}s state wrong incoming Reject Connection", __PRETTY_FUNCTION__);
1194 }
1195 }
1196 }
1197
MnsProcConnectAccept(utility::Message msg)1198 void MapMceDeviceCtrl::MnsProcConnectAccept(utility::Message msg)
1199 {
1200 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
1201 std::unique_ptr<bluetooth::ObexHeader> resp;
1202 int ret;
1203 mnsObexSession_ = static_cast<ObexServerSession *>(msg.arg2_);
1204 if ((mnsObexSession_ == nullptr) || (mnsSessionObexheader_ == nullptr)) {
1205 LOG_ERROR("%{public}s mnsObexSession_ or obex header null", __PRETTY_FUNCTION__);
1206 return;
1207 }
1208 MapMceDeviceStateType state = GetCurrentDeviceState();
1209 if (((state == MAP_MCE_DEV_STATE_CONNECTED) || (state == MAP_MCE_DEV_STATE_CONNECTING)) &&
1210 (btDeviceTargetState_ == MAP_MCE_DEV_STATE_CONNECTED)) {
1211 if (MnsProcConnectAcceptCheckTargetId() != BT_SUCCESS) {
1212 LOG_ERROR("%{public}s ObexRspCode::NOT_ACCEPTABLE", __PRETTY_FUNCTION__);
1213 return;
1214 }
1215 resp = ObexHeader::CreateResponse(ObexRspCode::SUCCESS, true);
1216 connectId_++;
1217 resp->AppendItemConnectionId(connectId_);
1218 resp->AppendItemWho(mnsTargetUuidTbl_, MAX_OF_MASCLIENT_OBEX_UUID_TBL);
1219 ret = mnsObexSession_->SendResponse(*resp);
1220 if (ret == BT_SUCCESS) {
1221 TransMnsState(MAP_MCE_DEV_STATE_CONNECTED);
1222 } else {
1223 LOG_ERROR("%{public}s SendResponse execute error", __PRETTY_FUNCTION__);
1224 ret = mnsObexSession_->Disconnect();
1225 if (ret != BT_SUCCESS) {
1226 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
1227 LOG_ERROR("%{public}s Disconnect error", __PRETTY_FUNCTION__);
1228 } else {
1229 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTING);
1230 }
1231 }
1232 } else { // refuse
1233 resp = ObexHeader::CreateResponse(ObexRspCode::FORBIDDEN, true);
1234 ret = mnsObexSession_->SendResponse(*resp);
1235 if (ret != BT_SUCCESS) {
1236 LOG_ERROR("%{public}s SendResponse execute error", __PRETTY_FUNCTION__);
1237 }
1238 ret = mnsObexSession_->Disconnect();
1239 if (ret != BT_SUCCESS) {
1240 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
1241 LOG_ERROR("%{public}s Disconnect error", __PRETTY_FUNCTION__);
1242 } else {
1243 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTING);
1244 }
1245 LOG_ERROR("%{public}s state wrong, refuse on connect!", __PRETTY_FUNCTION__);
1246 }
1247 }
1248
MnsProcConnectRefuse(utility::Message msg)1249 void MapMceDeviceCtrl::MnsProcConnectRefuse(utility::Message msg)
1250 {
1251 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
1252
1253 mnsObexSession_ = static_cast<ObexServerSession *>(msg.arg2_);
1254 std::unique_ptr<bluetooth::ObexHeader> resp = ObexHeader::CreateResponse(ObexRspCode::FORBIDDEN, true);
1255 if (mnsObexSession_ != nullptr) {
1256 mnsObexSession_->SendResponse(*resp);
1257 }
1258 }
1259
MnsProcDisconnected()1260 void MapMceDeviceCtrl::MnsProcDisconnected()
1261 {
1262 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
1263
1264 // disconnected finish
1265 // send msg to the device control
1266 MapMceDeviceStateType state = GetCurrentDeviceState();
1267 if (state == MAP_MCE_DEV_STATE_DISCONNECTING) {
1268 utility::Message outMsg(MSG_MCEDEVICE_MNS_DEVICE_DISCONNECTED_FINISH);
1269 PostMessage(outMsg);
1270 }
1271 }
1272
MnsProcDisconnectAccept(utility::Message msg)1273 int MapMceDeviceCtrl::MnsProcDisconnectAccept(utility::Message msg)
1274 {
1275 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
1276
1277 int ret = BT_OPERATION_FAILED;
1278 mnsObexSession_ = static_cast<ObexServerSession *>(msg.arg2_);
1279 std::unique_ptr<bluetooth::ObexHeader> resp;
1280 if (mnsObexSession_ == nullptr) {
1281 // error
1282 return ret;
1283 }
1284 resp = ObexHeader::CreateResponse(ObexRspCode::SUCCESS, true);
1285 ret = mnsObexSession_->SendResponse(*resp);
1286 if (ret != BT_SUCCESS) {
1287 LOG_ERROR("%{public}s SendResponse error", __PRETTY_FUNCTION__);
1288 }
1289 ret = mnsObexSession_->Disconnect();
1290 if (ret != BT_SUCCESS) {
1291 LOG_ERROR("%{public}s Disconnect error", __PRETTY_FUNCTION__);
1292 }
1293 return ret;
1294 }
1295
MnsProcRequestDisconnect()1296 void MapMceDeviceCtrl::MnsProcRequestDisconnect()
1297 {
1298 LOG_INFO("%{public}s execute", __PRETTY_FUNCTION__);
1299
1300 if (GetMnsState() == MAP_MCE_DEV_STATE_CONNECTED) {
1301 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTING);
1302 // disconnect the mns
1303 int ret = mnsObexSession_->Disconnect();
1304
1305 if (ret != BT_SUCCESS) {
1306 LOG_ERROR("%{public}s Disconnect error", __PRETTY_FUNCTION__);
1307 TransMnsState(MAP_MCE_DEV_STATE_DISCONNECTED);
1308 MnsProcDisconnected();
1309 }
1310 } else if (GetMnsState() == MAP_MCE_DEV_STATE_CONNECTING) {
1311 // waiting
1312 }
1313 }
1314
MnsChangeSessionObexHeader(const ObexHeader & req)1315 void MapMceDeviceCtrl::MnsChangeSessionObexHeader(const ObexHeader &req)
1316 {
1317 mnsSessionObexheader_ = std::make_unique<ObexHeader>(req);
1318 }
1319
1320 // call by service
CountSendingRequest(MceRequestType requestType)1321 int MapMceDeviceCtrl::CountSendingRequest(MceRequestType requestType)
1322 {
1323 LOG_INFO("%{public}s enter", __PRETTY_FUNCTION__);
1324 std::lock_guard<std::recursive_mutex> lock(mceInstanceMapMutex_);
1325
1326 int retSum = 0;
1327
1328 if (GetCurrentDeviceState() == MAP_MCE_DEV_STATE_CONNECTED) {
1329 for (auto &it : deviceInstanceStmMap_) {
1330 auto stm = static_cast<MapMceInstanceStm *>(it.second.get());
1331 if (stm->GetCurrentMceStmStateName() == MCE_CONNECTED_STATE_S_REQSENDING) {
1332
1333 retSum += stm->GetMasClient().ClientCountSendingRequest(requestType);
1334 }
1335 }
1336 }
1337 LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
1338 return retSum;
1339 }
1340
SetDeviceCtlConfig(const MasInstanceConfig & config)1341 void MapMceDeviceCtrl::SetDeviceCtlConfig(const MasInstanceConfig &config)
1342 {
1343 insDefaultConfig_ = config;
1344 }
1345 } // namespace bluetooth
1346 } // namespace OHOS