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