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 #include "pbap_pce_service.h"
17 #include "adapter_config.h"
18 #include "class_creator.h"
19 #include "interface_adapter.h"
20 #include "log.h"
21 #include "log_util.h"
22 #include "pbap_pce_base_state.h"
23 #include "pbap_pce_gap.h"
24 #include "pbap_pce_sdp.h"
25 #include "pbap_pce_state_machine.h"
26 #include "profile_config.h"
27
28 namespace OHOS {
29 namespace bluetooth {
PbapPceService()30 PbapPceService::PbapPceService() : utility::Context("PbapPceService", "1.2.3")
31 {
32 PBAP_PCE_LOG_INFO("ProfileService:%{public}s Create", Name().c_str());
33 pbapPceSdp_ = std::make_unique<PbapPceSdp>(*this);
34 }
35
~PbapPceService()36 PbapPceService::~PbapPceService()
37 {}
38
GetContext()39 utility::Context *PbapPceService::GetContext()
40 {
41 return this;
42 }
43
RegisterObserver(IPbapPceObserver & observer)44 void PbapPceService::RegisterObserver(IPbapPceObserver &observer)
45 {
46 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
47 observerMgrList_.Register(observer);
48 }
49
DeregisterObserver(IPbapPceObserver & observer)50 void PbapPceService::DeregisterObserver(IPbapPceObserver &observer)
51 {
52 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
53 observerMgrList_.Deregister(observer);
54 }
55
ForwardMsgToStm(const RawAddress & device,const utility::Message & msg)56 void PbapPceService::ForwardMsgToStm(const RawAddress &device, const utility::Message &msg)
57 {
58 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
59 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
60 if (machineMap_.find(device.GetAddress()) != machineMap_.end()) {
61 machineMap_[device.GetAddress()]->ProcessMessage(msg);
62 }
63 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
64 }
65
SetConnectionStrategy(const RawAddress & device,int strategy)66 int PbapPceService::SetConnectionStrategy(const RawAddress &device, int strategy)
67 {
68 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
69 switch (strategy) {
70 case static_cast<int>(BTStrategyType::CONNECTION_ALLOWED):
71 case static_cast<int>(BTStrategyType::CONNECTION_FORBIDDEN):
72 if (!SaveConnectPolicy(device.GetAddress(), strategy)) {
73 PBAP_PCE_LOG_ERROR("%{public}s end, save strategy value failed.", __PRETTY_FUNCTION__);
74 return RET_NO_SUPPORT;
75 }
76 break;
77 default:
78 PBAP_PCE_LOG_ERROR("%{public}s end, save strategy invalid value.", __PRETTY_FUNCTION__);
79 return RET_BAD_PARAM;
80 }
81
82 // Adjoint action
83 if (strategy == static_cast<int>(BTStrategyType::CONNECTION_FORBIDDEN)) {
84 if (IsConnected(device)) {
85 Disconnect(device); // Immediately
86 } else if (GetDeviceState(device) == static_cast<int>(BTConnectState::CONNECTING)) {
87 utility::Message msg(PCE_REQ_SET_TARGET_STATE, PCE_TARGET_STATE_DISCONNECTED);
88 ForwardMsgToStm(device, msg);
89 }
90 } else if (strategy == static_cast<int>(BTStrategyType::CONNECTION_ALLOWED)) {
91 if (GetDeviceState(device) == static_cast<int>(BTConnectState::DISCONNECTED)) {
92 Connect(device); // Immediately
93 } else if (GetDeviceState(device) == static_cast<int>(BTConnectState::DISCONNECTING)) {
94 utility::Message msg(PCE_REQ_SET_TARGET_STATE, PCE_TARGET_STATE_CONNECTED);
95 ForwardMsgToStm(device, msg);
96 }
97 }
98 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
99 return BT_SUCCESS;
100 }
101
GetConnectionStrategy(const RawAddress & device)102 int PbapPceService::GetConnectionStrategy(const RawAddress &device)
103 {
104 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
105 int strategy = static_cast<int>(BTStrategyType::CONNECTION_UNKNOWN);
106 if (!LoadConnectPolicy(device.GetAddress(), strategy)) {
107 PBAP_PCE_LOG_ERROR("%{public}s end, load strategy value failed.", __PRETTY_FUNCTION__);
108 return strategy;
109 }
110 if (strategy == static_cast<int>(BTStrategyType::CONNECTION_ALLOWED) ||
111 strategy == static_cast<int>(BTStrategyType::CONNECTION_FORBIDDEN)) {
112 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
113 return strategy;
114 }
115 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
116 return strategy;
117 }
118
EnableService()119 void PbapPceService::EnableService()
120 {
121 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
122 serviceState_ = PBAP_PCE_STATE_STARTUPING;
123 LoadPceConfig();
124 int retVal = pbapPceSdp_->Register();
125 if (retVal != BT_SUCCESS) {
126 PBAP_PCE_LOG_ERROR("end, Call pbapPceSdp_->Register() Error");
127 serviceState_ = PBAP_PCE_STATE_STARTUP;
128 GetContext()->OnEnable(PROFILE_NAME_PBAP_PCE, false);
129 return;
130 }
131 #ifdef PBAP_PCE_ENABLE_L2CAP_PSM
132 ObexMpClient::RegisterL2capLPsm(PBAP_PCE_LOCAL_GOEP_L2CAP_PSM);
133 #endif
134 serviceState_ = PBAP_PCE_STATE_STARTUP;
135 GetContext()->OnEnable(PROFILE_NAME_PBAP_PCE, true);
136 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
137 }
138
Enable()139 void PbapPceService::Enable()
140 {
141 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
142
143 if (GetDispatcher() == nullptr) {
144 PBAP_PCE_LOG_ERROR("%{public}s end, GetDispatcher() == nullptr", __PRETTY_FUNCTION__);
145 return;
146 }
147 GetDispatcher()->PostTask(std::bind(&PbapPceService::EnableService, this));
148
149 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
150 }
151
TryShutDown(bool ret)152 bool PbapPceService::TryShutDown(bool ret)
153 {
154 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
155 if (serviceState_ == PBAP_PCE_STATE_SHUTDOWN) {
156 PBAP_PCE_LOG_INFO("%{public}s end, already shutdown status", __PRETTY_FUNCTION__);
157 return true;
158 }
159
160 if (serviceState_ != PBAP_PCE_STATE_SHUTDOWNING) {
161 PBAP_PCE_LOG_INFO("%{public}s end, not shutdowning status", __PRETTY_FUNCTION__);
162 return false;
163 }
164
165 std::vector<int> states {
166 static_cast<int>(BTConnectState::CONNECTING),
167 static_cast<int>(BTConnectState::CONNECTED),
168 static_cast<int>(BTConnectState::DISCONNECTING)
169 };
170 if (GetDevicesByStates(states).size() == 0) {
171 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
172 serviceState_ = PBAP_PCE_STATE_SHUTDOWN;
173 #ifdef PBAP_PCE_ENABLE_L2CAP_PSM
174 ObexMpClient::DeregisterL2capLPsm(PBAP_PCE_LOCAL_GOEP_L2CAP_PSM);
175 #endif
176 GetContext()->OnDisable(PROFILE_NAME_PBAP_PCE, ret);
177 PBAP_PCE_LOG_INFO("%{public}s end, Shutdown OK", __PRETTY_FUNCTION__);
178 return true;
179 }
180 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
181 return false;
182 }
183
IsBusy(const RawAddress & device)184 bool PbapPceService::IsBusy(const RawAddress &device)
185 {
186 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
187
188 bool ret = false;
189 std::string strAddr = device.GetAddress();
190 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
191 if (machineMap_.find(strAddr) != machineMap_.end()) {
192 auto stm = static_cast<PbapPceStateMachine *>(machineMap_[strAddr].get());
193 ret = stm->IsBusy();
194 }
195
196 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
197 return ret;
198 }
199
SetBusy(const RawAddress & device,bool busy)200 bool PbapPceService::SetBusy(const RawAddress &device, bool busy)
201 {
202 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
203 bool ret = false;
204 std::string strAddr = device.GetAddress();
205 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
206 if (machineMap_.find(strAddr) != machineMap_.end()) {
207 auto stm = static_cast<PbapPceStateMachine *>(machineMap_[strAddr].get());
208 ret = stm->SetBusy(busy);
209 }
210 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
211 return ret;
212 }
213
SetPowerStatusBusy(const RawAddress & device,bool busy)214 void PbapPceService::SetPowerStatusBusy(const RawAddress &device, bool busy)
215 {
216 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
217 std::string strAddr = device.GetAddress();
218 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
219 if (machineMap_.find(strAddr) != machineMap_.end()) {
220 auto stm = static_cast<PbapPceStateMachine *>(machineMap_[strAddr].get());
221 stm->SetPowerStatusBusy(busy);
222 }
223 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
224 return;
225 }
226
CheckAndSetDeviceBusy(const RawAddress & device)227 bool PbapPceService::CheckAndSetDeviceBusy(const RawAddress &device)
228 {
229 if (IsBusy(device)) {
230 PBAP_PCE_LOG_ERROR("%{public}s Busy!", __PRETTY_FUNCTION__);
231 return false;
232 }
233
234 if (!SetBusy(device, true)) {
235 PBAP_PCE_LOG_ERROR("%{public}s Set Busy error!", __PRETTY_FUNCTION__);
236 return false;
237 }
238
239 return true;
240 }
241
CheckDeviceStatusForPbapAction(const RawAddress & device)242 int PbapPceService::CheckDeviceStatusForPbapAction(const RawAddress &device)
243 {
244 if (GetDispatcher() == nullptr) {
245 PBAP_PCE_LOG_ERROR("%{public}s GetDispatcher() == nullptr", __PRETTY_FUNCTION__);
246 return RET_BAD_STATUS;
247 }
248
249 if (!IsConnected(device)) {
250 PBAP_PCE_LOG_ERROR("%{public}s NOT connected!", __PRETTY_FUNCTION__);
251 return RET_BAD_STATUS;
252 }
253
254 if (!CheckAndSetDeviceBusy(device)) {
255 PBAP_PCE_LOG_ERROR("%{public}s CheckAndSetDeviceBusy failed!", __PRETTY_FUNCTION__);
256 return RET_BAD_STATUS;
257 }
258
259 return BT_SUCCESS;
260 }
261
DisableService()262 void PbapPceService::DisableService()
263 {
264 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
265 serviceState_ = PBAP_PCE_STATE_SHUTDOWNING;
266
267 int retVal = 0;
268 if (pbapPceSdp_) {
269 retVal = pbapPceSdp_->Deregister();
270 if (retVal != BT_SUCCESS) {
271 PBAP_PCE_LOG_ERROR("pbapPceSdp_->Deregister() error");
272 }
273 }
274
275 if (!TryShutDown(retVal == BT_SUCCESS)) {
276 retVal = DisconnectAllDevices();
277 if (retVal != BT_SUCCESS) {
278 PBAP_PCE_LOG_ERROR("DisconnectAllDevices error");
279 }
280 TryShutDown(true);
281 }
282 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
283 }
284
DisconnectAllDevices()285 int PbapPceService::DisconnectAllDevices()
286 {
287 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
288 int retVal2 = BT_SUCCESS;
289 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
290 for (auto &stm : machineMap_) {
291 int retVal1 = AbortDownloadingInternal(RawAddress(stm.first));
292 retVal2 = DisconnectInternal(RawAddress(stm.first));
293 PBAP_PCE_LOG_INFO("%{public}s [%{public}s] retVal1=%{public}d, retVal2=%{public}d",
294 __PRETTY_FUNCTION__, stm.first.c_str(), retVal1, retVal2);
295 }
296
297 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
298 return retVal2;
299 }
300
Disable()301 void PbapPceService::Disable()
302 {
303 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
304 if (GetDispatcher() == nullptr) {
305 PBAP_PCE_LOG_ERROR("%{public}s GetDispatcher() == nullptr", __PRETTY_FUNCTION__);
306 return;
307 }
308 GetDispatcher()->PostTask(std::bind(&PbapPceService::DisableService, this));
309 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
310 }
311
Connect(const RawAddress & device)312 int PbapPceService::Connect(const RawAddress &device)
313 {
314 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
315 RawAddress rDevice(device.GetAddress());
316 BTStrategyType strate = BTStrategyType(GetConnectionStrategy(rDevice));
317 if (strate == BTStrategyType::CONNECTION_FORBIDDEN) {
318 PBAP_PCE_LOG_ERROR("%{public}s end, connect forbidden.", __PRETTY_FUNCTION__);
319 return RET_BAD_STATUS;
320 }
321
322 int state = GetDeviceState(device);
323 if ((state == static_cast<int>(BTConnectState::CONNECTING)) ||
324 (state == static_cast<int>(BTConnectState::CONNECTED)) ||
325 (state == static_cast<int>(BTConnectState::DISCONNECTING))) {
326 PBAP_PCE_LOG_ERROR("%{public}s end, bad status.", __PRETTY_FUNCTION__);
327 return RET_BAD_STATUS;
328 }
329
330 if (GetConnectedDevices().size() == (std::size_t)GetMaxConnectNum()) {
331 PBAP_PCE_LOG_ERROR("%{public}s end, maximum devices is %{public}d.", __PRETTY_FUNCTION__, GetMaxConnectNum());
332 return RET_NO_SUPPORT;
333 }
334
335 if (GetDispatcher() == nullptr) {
336 PBAP_PCE_LOG_ERROR("%{public}s end, GetDispatcher() == nullptr", __PRETTY_FUNCTION__);
337 return RET_BAD_STATUS;
338 }
339
340 if (IsBusy(device)) {
341 PBAP_PCE_LOG_ERROR("%{public}s end, Is busy!", __PRETTY_FUNCTION__);
342 return RET_BAD_STATUS;
343 }
344
345 GetDispatcher()->PostTask(std::bind(&PbapPceService::ConnectInternal, this, device));
346 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
347 return BT_SUCCESS;
348 }
349
ConnectInternal(const RawAddress & device)350 int PbapPceService::ConnectInternal(const RawAddress &device)
351 {
352 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
353 if (serviceState_ != PBAP_PCE_STATE_STARTUP) {
354 PBAP_PCE_LOG_ERROR("%{public}s end, pbap pce service isn't started.", __PRETTY_FUNCTION__);
355 return RET_NO_SUPPORT;
356 }
357
358 if (GetConnectedDevices().size() == (std::size_t)GetMaxConnectNum()) {
359 PBAP_PCE_LOG_ERROR("%{public}s end, maximum devices is %{public}d.", __PRETTY_FUNCTION__, GetMaxConnectNum());
360 return RET_NO_SUPPORT;
361 }
362
363 std::string addr = device.GetAddress();
364 HILOGI("Connect to rawaddr: %{public}s", GetEncryptAddr(addr).c_str());
365 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
366 if (machineMap_.find(addr) == machineMap_.end()) {
367 machineMap_[addr] = std::make_unique<PbapPceStateMachine>(device, *this, *pbapPceSdp_, observerMgrList_);
368 } else {
369 int state = GetDeviceState(device);
370 if ((state == static_cast<int>(BTConnectState::DISCONNECTING)) ||
371 (state == static_cast<int>(BTConnectState::DISCONNECTED))) {
372 PBAP_PCE_LOG_INFO("start connect for disconnected device.");
373 machineMap_[addr]->InitState(PCE_CONNECTING_STATE);
374 } else {
375 PBAP_PCE_LOG_ERROR("%{public}s end, already connecting or for connected device.", __PRETTY_FUNCTION__);
376 return RET_BAD_STATUS;
377 }
378 }
379 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
380 return BT_SUCCESS;
381 }
382
Disconnect(const RawAddress & device)383 int PbapPceService::Disconnect(const RawAddress &device)
384 {
385 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
386 int state = GetDeviceState(device);
387 if ((state == static_cast<int>(BTConnectState::CONNECTING)) ||
388 (state == static_cast<int>(BTConnectState::DISCONNECTING)) ||
389 (state == static_cast<int>(BTConnectState::DISCONNECTED))) {
390 PBAP_PCE_LOG_ERROR("%{public}s end, bad status.", __PRETTY_FUNCTION__);
391 return RET_BAD_STATUS;
392 }
393
394 if (GetDispatcher() == nullptr) {
395 PBAP_PCE_LOG_ERROR("%{public}s end, GetDispatcher() == nullptr", __PRETTY_FUNCTION__);
396 return RET_BAD_STATUS;
397 }
398
399 GetDispatcher()->PostTask(std::bind(&PbapPceService::DisconnectInternal, this, device));
400 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
401 return BT_SUCCESS;
402 }
403
IsConnected(const RawAddress & device)404 bool PbapPceService::IsConnected(const RawAddress &device)
405 {
406 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
407 if (GetDeviceState(device) == static_cast<int>(BTConnectState::CONNECTED)) {
408 return true;
409 }
410 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
411 return false;
412 }
413
DisconnectInternal(const RawAddress & device)414 int PbapPceService::DisconnectInternal(const RawAddress &device)
415 {
416 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
417 if (IsBusy(device)) {
418 PBAP_PCE_LOG_ERROR("%{public}s end, Is busy!", __PRETTY_FUNCTION__);
419 utility::Message msg(PCE_REQ_SET_TARGET_STATE, PCE_TARGET_STATE_DISCONNECTED);
420 ForwardMsgToStm(device, msg);
421 } else {
422 utility::Message msg(PCE_REQ_DISCONNECTED);
423 ForwardMsgToStm(device, msg);
424 }
425 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
426 return BT_SUCCESS;
427 }
428
429 // for override IProfilePbapPce
GetConnectDevices()430 std::list<RawAddress> PbapPceService::GetConnectDevices()
431 {
432 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
433 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
434 std::list<RawAddress> devList;
435
436 for (auto &it : machineMap_) {
437 std::string name = it.second->GetState()->Name();
438 if (name == PCE_CONNECTED_STATE) {
439 auto stm = static_cast<PbapPceStateMachine *>(it.second.get());
440 devList.push_front(stm->GetDevice());
441 }
442 }
443 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
444 return devList;
445 }
446
GetConnectState()447 int PbapPceService::GetConnectState()
448 {
449 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
450 uint8_t result = 0;
451 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
452 for (auto &stm : machineMap_) {
453 std::string name = stm.second->GetState()->Name();
454 if (name == PCE_DISCONNECTED_STATE) {
455 result |= PROFILE_STATE_DISCONNECTED;
456 } else if (name == PCE_CONNECTING_STATE) {
457 result |= PROFILE_STATE_CONNECTING;
458 } else if (name == PCE_CONNECTED_STATE) {
459 result |= PROFILE_STATE_CONNECTED;
460 } else if (name == PCE_DISCONNECTING_STATE) {
461 result |= PROFILE_STATE_DISCONNECTING;
462 }
463 }
464 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
465 return result;
466 }
467
GetMaxConnectNum()468 int PbapPceService::GetMaxConnectNum()
469 {
470 return GetPceConfig().pceMaxDevices_;
471 }
472
ProcessObexRespMessage(const RawAddress & device,const utility::Message & msg)473 void PbapPceService::ProcessObexRespMessage(const RawAddress &device, const utility::Message &msg)
474 {
475 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
476 SetPowerStatusBusy(device, false);
477 switch (msg.what_) {
478 case PCE_OBEX_CONNECTED:
479 ProcessConnected(device, msg);
480 break;
481 case PCE_OBEX_DISCONNECTED:
482 ProcessDisconnected(device, msg);
483 break;
484 case PCE_OBEX_CONNECT_FAILED:
485 ProcessConnectFailed(device, msg);
486 break;
487 case PCE_TRANSPORT_FAILED:
488 ProcessTransportFailed(device, msg);
489 break;
490 case PCE_PULLPHONEBOOKSIZE_COMPLETED:
491 case PCE_PULLPHONEBOOK_COMPLETED:
492 case PCE_SETPHONEBOOK_COMPLETED:
493 case PCE_PULLVCARDLISTINGSIZE_COMPLETED:
494 case PCE_PULLVCARDLISTING_COMPLETED:
495 case PCE_PULLVCARDENTRY_COMPLETED:
496 case PCE_ABORTDOWNLOADING_COMPLETED:
497 ProcessPhoneBookActionCompleted(device, msg);
498 break;
499 default:
500 break;
501 }
502 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
503 }
504
PostMessage(const RawAddress & device,const utility::Message & msg)505 void PbapPceService::PostMessage(const RawAddress &device, const utility::Message &msg)
506 {
507 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
508 if (GetDispatcher() == nullptr) {
509 PBAP_PCE_LOG_ERROR("%{public}s end, GetDispatcher() == nullptr", __PRETTY_FUNCTION__);
510 return;
511 }
512 switch (msg.what_) {
513 case PCE_SDP_FAILED:
514 case PCE_GAP_FAILED:
515 GetDispatcher()->PostTask(std::bind(&PbapPceService::ProcessSdpGapFailed, this, device, msg));
516 break;
517 case PCE_SDP_FINISH:
518 case PCE_GAP_FINISH:
519 GetDispatcher()->PostTask(std::bind(&PbapPceService::ProcessSdpGapFinish, this, device, msg));
520 break;
521 case PCE_PASSWORD_INPUT:
522 GetDispatcher()->PostTask(std::bind(&PbapPceService::ProcessUserInput, this, device, msg));
523 break;
524 default:
525 break;
526 }
527 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
528 }
529
ProcessSdpGapFailed(const RawAddress & device,const utility::Message & msg)530 void PbapPceService::ProcessSdpGapFailed(const RawAddress &device, const utility::Message &msg)
531 {
532 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
533 ForwardMsgToStm(device, msg);
534 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
535 }
536
ProcessSdpGapFinish(const RawAddress & device,const utility::Message & msg)537 void PbapPceService::ProcessSdpGapFinish(const RawAddress &device, const utility::Message &msg)
538 {
539 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
540 ForwardMsgToStm(device, msg);
541 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
542 }
543
ProcessConnectFailed(const RawAddress & device,const utility::Message & msg)544 void PbapPceService::ProcessConnectFailed(const RawAddress &device, const utility::Message &msg)
545 {
546 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
547 ForwardMsgToStm(device, msg);
548 TryShutDown(true);
549 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
550 }
551
ProcessConnected(const RawAddress & device,const utility::Message & msg)552 void PbapPceService::ProcessConnected(const RawAddress &device, const utility::Message &msg)
553 {
554 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
555 ForwardMsgToStm(device, msg);
556 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
557 }
558
ProcessDisconnected(const RawAddress & device,const utility::Message & msg)559 void PbapPceService::ProcessDisconnected(const RawAddress &device, const utility::Message &msg)
560 {
561 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
562 ForwardMsgToStm(device, msg);
563 TryShutDown(true);
564 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
565 }
566
ProcessTransportFailed(const RawAddress & device,const utility::Message & msg)567 void PbapPceService::ProcessTransportFailed(const RawAddress &device, const utility::Message &msg)
568 {
569 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
570 ForwardMsgToStm(device, msg);
571 TryShutDown(true);
572 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
573 }
574
ProcessUserInput(const RawAddress & device,const utility::Message & msg)575 void PbapPceService::ProcessUserInput(const RawAddress &device, const utility::Message &msg)
576 {
577 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
578 ForwardMsgToStm(device, msg);
579 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
580 }
581
ProcessPhoneBookActionCompleted(const RawAddress & device,const utility::Message & msg)582 void PbapPceService::ProcessPhoneBookActionCompleted(const RawAddress &device, const utility::Message &msg)
583 {
584 PBAP_PCE_LOG_INFO("%{public}s start, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
585 ForwardMsgToStm(device, msg);
586 utility::Message msg2(PCE_REQ_TRANSIT_TARGET_STATE);
587 ForwardMsgToStm(device, msg2);
588 TryShutDown(true);
589 PBAP_PCE_LOG_INFO("%{public}s end, msg.what=%{public}d", __PRETTY_FUNCTION__, msg.what_);
590 }
591
GetDeviceState(const RawAddress & device)592 int PbapPceService::GetDeviceState(const RawAddress &device)
593 {
594 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
595 BTConnectState result = BTConnectState::DISCONNECTED;
596 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
597 auto target = machineMap_.find(device.GetAddress());
598 if (target != machineMap_.end()) {
599 std::string name = target->second->GetState()->Name();
600 if (name == PCE_DISCONNECTED_STATE) {
601 result = BTConnectState::DISCONNECTED;
602 } else if (name == PCE_CONNECTING_STATE) {
603 result = BTConnectState::CONNECTING;
604 } else if (name == PCE_CONNECTED_STATE) {
605 result = BTConnectState::CONNECTED;
606 } else if (name == PCE_DISCONNECTING_STATE) {
607 result = BTConnectState::DISCONNECTING;
608 }
609 }
610 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
611 return static_cast<int>(result);
612 }
613
GetDevicesByStates(const std::vector<int> & states)614 std::vector<RawAddress> PbapPceService::GetDevicesByStates(const std::vector<int> &states)
615 {
616 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
617 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
618 std::vector<RawAddress> devices;
619 for (auto &state : states) {
620 for (auto &it : machineMap_) {
621 if (static_cast<int>(GetDeviceState(RawAddress(it.first))) == state) {
622 auto stm = static_cast<PbapPceStateMachine *>(it.second.get());
623 devices.push_back(stm->GetDevice());
624 }
625 }
626 }
627 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
628 return devices;
629 }
630
GetDownloadFileName(const RawAddress & device)631 std::string PbapPceService::GetDownloadFileName(const RawAddress &device)
632 {
633 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
634 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
635 if (machineMap_.find(device.GetAddress()) != machineMap_.end()) {
636 auto stm = static_cast<PbapPceStateMachine *>(machineMap_[device.GetAddress()].get());
637 return stm->GetDownloadFileName();
638 }
639 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
640 return "";
641 }
642
GetPceConfig() const643 const PbapPceConfig &PbapPceService::GetPceConfig() const
644 {
645 return pbapPceConfig_;
646 }
647
GetConnectedDevices()648 std::vector<RawAddress> PbapPceService::GetConnectedDevices()
649 {
650 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
651 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
652 std::vector<RawAddress> devices;
653 std::vector<int> states {static_cast<int>(BTConnectState::CONNECTED)};
654 auto allDevices = GetDevicesByStates(states);
655 std::copy(allDevices.begin(), allDevices.end(), devices.begin());
656 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
657 return devices;
658 }
659
SetDevicePassword(const RawAddress & device,const std::string & password,const std::string & userId)660 int PbapPceService::SetDevicePassword(const RawAddress &device, const std::string &password, const std::string &userId)
661 {
662 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
663 if (password.empty() || userId.size() > ObexDigestResponse::MAX_USER_ID_LEN) {
664 return RET_BAD_PARAM;
665 }
666 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
667 auto target = machineMap_.find(device.GetAddress());
668 if (target == machineMap_.end()) {
669 return RET_NO_SUPPORT;
670 }
671 auto msgData = std::make_unique<PbapPcePasswordInputMsg>(password, userId);
672 utility::Message msg(PCE_PASSWORD_INPUT, 0, static_cast<void *>(msgData.release()));
673 PostMessage(device, msg);
674 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
675 return BT_SUCCESS;
676 }
677
PullPhoneBook(const RawAddress & device,const IPbapPullPhoneBookParam & param)678 int PbapPceService::PullPhoneBook(const RawAddress &device, const IPbapPullPhoneBookParam ¶m)
679 {
680 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
681 // validate param
682 if (!param.Validate()) {
683 PBAP_PCE_LOG_ERROR("%{public}s end, RET_BAD_PARAM", __PRETTY_FUNCTION__);
684 return RET_BAD_PARAM;
685 }
686 int ret = CheckDeviceStatusForPbapAction(device);
687 if (ret != BT_SUCCESS) {
688 PBAP_PCE_LOG_ERROR("%{public}s end, RET_BAD_STATUS", __PRETTY_FUNCTION__);
689 return ret;
690 }
691 GetDispatcher()->PostTask(std::bind(&PbapPceService::PullPhoneBookInternal, this, device, param));
692 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
693 return BT_SUCCESS;
694 }
695
SetPhoneBook(const RawAddress & device,const std::u16string & name,int flag)696 int PbapPceService::SetPhoneBook(const RawAddress &device, const std::u16string &name, int flag)
697 {
698 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
699 if ((flag != PBAP_FLAG_GO_TO_ROOT) && (flag != PBAP_FLAG_GO_DOWN) && (flag != PBAP_FLAG_GO_UP)) {
700 PBAP_PCE_LOG_ERROR("%{public}s end, param flag=%{public}d is invalid.", __PRETTY_FUNCTION__, flag);
701 return RET_BAD_PARAM;
702 }
703
704 int ret = CheckDeviceStatusForPbapAction(device);
705 if (ret != BT_SUCCESS) {
706 PBAP_PCE_LOG_ERROR("%{public}s end, RET_BAD_STATUS", __PRETTY_FUNCTION__);
707 return ret;
708 }
709
710 GetDispatcher()->PostTask(std::bind(&PbapPceService::SetPhoneBookInternal, this, device, name, flag));
711 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
712 return BT_SUCCESS;
713 }
714
PullvCardListing(const RawAddress & device,const IPbapPullvCardListingParam & param)715 int PbapPceService::PullvCardListing(const RawAddress &device, const IPbapPullvCardListingParam ¶m)
716 {
717 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
718 // validate param
719 if (!param.Validate()) {
720 PBAP_PCE_LOG_ERROR("%{public}s end, RET_BAD_PARAM", __PRETTY_FUNCTION__);
721 return RET_BAD_PARAM;
722 }
723
724 int ret = CheckDeviceStatusForPbapAction(device);
725 if (ret != BT_SUCCESS) {
726 PBAP_PCE_LOG_INFO("%{public}s end, RET_BAD_STATUS ", __PRETTY_FUNCTION__);
727 return ret;
728 }
729
730 GetDispatcher()->PostTask(std::bind(&PbapPceService::PullvCardListingInternal, this, device, param));
731 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
732 return BT_SUCCESS;
733 }
734
PullvCardEntry(const RawAddress & device,const IPbapPullvCardEntryParam & param)735 int PbapPceService::PullvCardEntry(const RawAddress &device, const IPbapPullvCardEntryParam ¶m)
736 {
737 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
738 if (!param.Validate()) {
739 PBAP_PCE_LOG_ERROR("%{public}s end, RET_BAD_PARAM", __PRETTY_FUNCTION__);
740 return RET_BAD_PARAM;
741 }
742
743 int ret = CheckDeviceStatusForPbapAction(device);
744 if (ret != BT_SUCCESS) {
745 PBAP_PCE_LOG_ERROR("%{public}s end, RET_BAD_STATUS", __PRETTY_FUNCTION__);
746 return ret;
747 }
748
749 GetDispatcher()->PostTask(std::bind(&PbapPceService::PullvCardEntryInternal, this, device, param));
750 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
751 return BT_SUCCESS;
752 }
753
IsDownloading(const RawAddress & device)754 bool PbapPceService::IsDownloading(const RawAddress &device)
755 {
756 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
757 bool ret = IsBusy(device);
758 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
759 return ret;
760 }
761
AbortDownloading(const RawAddress & device)762 int PbapPceService::AbortDownloading(const RawAddress &device)
763 {
764 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
765 if (!IsConnected(device)) {
766 PBAP_PCE_LOG_ERROR("%{public}s end, NOT connected!", __PRETTY_FUNCTION__);
767 return RET_BAD_STATUS;
768 }
769
770 if (GetDispatcher() == nullptr) {
771 PBAP_PCE_LOG_ERROR("%{public}s end, GetDispatcher() == nullptr", __PRETTY_FUNCTION__);
772 return RET_BAD_STATUS;
773 }
774 GetDispatcher()->PostTask(std::bind(&PbapPceService::AbortDownloadingInternal, this, device));
775
776 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
777 return BT_SUCCESS;
778 }
779
PullPhoneBookInternal(const RawAddress & device,const IPbapPullPhoneBookParam & param)780 int PbapPceService::PullPhoneBookInternal(const RawAddress &device, const IPbapPullPhoneBookParam ¶m)
781 {
782 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
783 PbapPcePullPhoneBookMsg pbapMsg;
784 pbapMsg.SetName(param.GetName());
785 pbapMsg.SetPropertySelector(param.GetPropertySelector());
786 pbapMsg.SetFormat(param.GetFormat());
787 pbapMsg.SetMaxListCount(param.GetMaxListCount());
788 pbapMsg.SetListStartOffset(param.GetListStartOffset());
789 pbapMsg.SetResetNewMissedCalls(param.GetResetNewMissedCalls());
790 pbapMsg.SetvCardSelector(param.GetvCardSelector());
791 pbapMsg.SetvCardSelectorOp(param.GetvCardSelectorOp());
792 pbapMsg.SetSpecifiedBitset(param.GetSpecifiedBitset());
793
794 utility::Message msg(PCE_REQ_PULLPHONEBOOK, 0, (void *)&pbapMsg);
795 std::string strAddr = device.GetAddress();
796 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
797 if (machineMap_.find(strAddr) != machineMap_.end()) {
798 auto stm = static_cast<PbapPceStateMachine *>(machineMap_[strAddr].get());
799 stm->ProcessMessage(msg); // go to PceConnectedState::Dispatch
800 }
801
802 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
803 return BT_SUCCESS;
804 }
805
SetPhoneBookInternal(const RawAddress & device,const std::u16string & name,int flag)806 int PbapPceService::SetPhoneBookInternal(const RawAddress &device, const std::u16string &name, int flag)
807 {
808 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
809 PbapPceSetPhoneBookMsg pbapMsg(name, flag);
810 utility::Message msg(PCE_REQ_SETPHONEBOOK, 0, (void *)&pbapMsg);
811 std::string strAddr = device.GetAddress();
812 std::lock_guard<std::recursive_mutex> lock(machineMapMutex_);
813 if (machineMap_.find(strAddr) != machineMap_.end()) {
814 auto stm = static_cast<PbapPceStateMachine *>(machineMap_[strAddr].get());
815 stm->ProcessMessage(msg); // go to PceConnectedState::Dispatch
816 }
817
818 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
819 return BT_SUCCESS;
820 }
821
PullvCardListingInternal(const RawAddress & device,const IPbapPullvCardListingParam & param)822 int PbapPceService::PullvCardListingInternal(const RawAddress &device, const IPbapPullvCardListingParam ¶m)
823 {
824 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
825 PbapPcePullvCardListingMsg pbapMsg;
826 pbapMsg.SetName(param.GetName());
827 pbapMsg.SetOrder(param.GetOrder());
828 pbapMsg.SetSearchValue(param.GetSearchValue());
829 pbapMsg.SetSearchProperty(param.GetSearchProperty());
830 pbapMsg.SetMaxListCount(param.GetMaxListCount());
831 pbapMsg.SetListStartOffset(param.GetListStartOffset());
832 pbapMsg.SetResetNewMissedCalls(param.GetResetNewMissedCalls());
833 pbapMsg.SetvCardSelector(param.GetvCardSelector());
834 pbapMsg.SetvCardSelectorOp(param.GetvCardSelectorOp());
835 pbapMsg.SetSpecifiedBitset(param.GetSpecifiedBitset());
836 utility::Message msg(PCE_REQ_PULLVCARDLISTING, 0, (void *)&pbapMsg);
837 ForwardMsgToStm(device, msg);
838 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
839 return BT_SUCCESS;
840 }
841
PullvCardEntryInternal(const RawAddress & device,const IPbapPullvCardEntryParam & param)842 int PbapPceService::PullvCardEntryInternal(const RawAddress &device, const IPbapPullvCardEntryParam ¶m)
843 {
844 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
845 PbapPcePullvCardEntryMsg pbapMsg(
846 param.GetName(), param.GetPropertySelector(), param.GetFormat(), param.GetSpecifiedBitset());
847 utility::Message msg(PCE_REQ_PULLVCARDENTRY, 0, (void *)&pbapMsg);
848 ForwardMsgToStm(device, msg);
849 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
850 return BT_SUCCESS;
851 }
852
AbortDownloadingInternal(const RawAddress & device)853 int PbapPceService::AbortDownloadingInternal(const RawAddress &device)
854 {
855 PBAP_PCE_LOG_INFO("%{public}s start", __PRETTY_FUNCTION__);
856 utility::Message msg(PCE_REQ_ABORTDOWNLOADING);
857 ForwardMsgToStm(device, msg);
858 PBAP_PCE_LOG_INFO("%{public}s end", __PRETTY_FUNCTION__);
859 return BT_SUCCESS;
860 }
861
LoadPceConfig()862 void PbapPceService::LoadPceConfig()
863 {
864 IAdapterConfig *adpterConfig = AdapterConfig::GetInstance();
865 auto &config = reinterpret_cast<PbapPceConfig &>(const_cast<PbapPceConfig &>(GetPceConfig()));
866 if (!adpterConfig->GetValue(SECTION_PBAP_PCE_SERVICE, PROPERTY_SRM_ENABLE, config.srmEnable_)) {
867 PBAP_PCE_LOG_ERROR("Load config %{public}s failure", PROPERTY_SRM_ENABLE.c_str());
868 }
869 if (!adpterConfig->GetValue(SECTION_PBAP_PCE_SERVICE, PROPERTY_RFCOMM_MTU, config.rfcommMtu_)) {
870 PBAP_PCE_LOG_ERROR("Load config %{public}s failure", PROPERTY_RFCOMM_MTU.c_str());
871 }
872 if (!adpterConfig->GetValue(SECTION_PBAP_PCE_SERVICE, PROPERTY_L2CAP_MTU, config.l2capMtu_)) {
873 PBAP_PCE_LOG_ERROR("Load config %{public}s failure", PROPERTY_L2CAP_MTU.c_str());
874 }
875 if (!adpterConfig->GetValue(SECTION_PBAP_PCE_SERVICE, PROPERTY_MAX_CONNECTED_DEVICES, config.pceMaxDevices_)) {
876 PBAP_PCE_LOG_ERROR("Load config %{public}s failure", PROPERTY_MAX_CONNECTED_DEVICES.c_str());
877 }
878 PBAP_PCE_LOG_INFO("srmEnable = %{public}d, rfcommMtu=0x%X, l2capMtu_=0x%X, maxDevices=%{public}d",
879 config.srmEnable_,
880 config.rfcommMtu_,
881 config.l2capMtu_,
882 config.pceMaxDevices_);
883 }
884
SaveConnectPolicy(const std::string & addr,int strategy)885 bool PbapPceService::SaveConnectPolicy(const std::string &addr, int strategy)
886 {
887 IProfileConfig *config = ProfileConfig::GetInstance();
888 if (!config->SetValue(addr, SECTION_CONNECTION_POLICIES, PROPERTY_PBAP_CLIENT_CONNECTION_POLICY, strategy)) {
889 HILOGE("addr: %{public}s %{public}s save fail.",
890 GetEncryptAddr(addr).c_str(), PROPERTY_PBAP_CLIENT_CONNECTION_POLICY.c_str());
891 return false;
892 }
893 return true;
894 }
895
LoadConnectPolicy(const std::string & addr,int & strategy)896 bool PbapPceService::LoadConnectPolicy(const std::string &addr, int &strategy)
897 {
898 IProfileConfig *config = ProfileConfig::GetInstance();
899 if (!config->GetValue(addr, SECTION_CONNECTION_POLICIES, PROPERTY_PBAP_CLIENT_CONNECTION_POLICY, strategy)) {
900 HILOGE("addr: %{public}s %{public}s load fail.",
901 GetEncryptAddr(addr).c_str(), PROPERTY_PBAP_CLIENT_CONNECTION_POLICY.c_str());
902 return false;
903 }
904 return true;
905 }
906
907 REGISTER_CLASS_CREATOR(PbapPceService);
908 } // namespace bluetooth
909 } // namespace OHOS
910