1 /*
2 * Copyright (C) 2021-2022 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 "avrcp_ct_profile.h"
17 #include "avrcp_ct_browse.h"
18 #include "avrcp_ct_connection.h"
19 #include "avrcp_ct_notification.h"
20 #include "avrcp_ct_pass_through.h"
21 #include "avrcp_ct_sub_unit_info.h"
22 #include "avrcp_ct_unit_info.h"
23 #include "avrcp_ct_vendor.h"
24 #include "avrcp_ct_vendor_continuation.h"
25 #include "avrcp_ct_vendor_player_application_settings.h"
26 #include "compat.h"
27 #include "power_manager.h"
28
29 namespace OHOS {
30 namespace bluetooth {
31 bool AvrcCtProfile::g_isEnabled = false;
32
AvrcCtProfile(uint16_t features,uint32_t companyId,uint16_t controlMtu,uint16_t browseMtu,uint8_t maxFragments,utility::Dispatcher * dispatcher,AvctChannelEventCallback eventCallback,AvctMsgCallback msgCallback)33 AvrcCtProfile::AvrcCtProfile(uint16_t features, uint32_t companyId, uint16_t controlMtu, uint16_t browseMtu,
34 uint8_t maxFragments, utility::Dispatcher *dispatcher, AvctChannelEventCallback eventCallback,
35 AvctMsgCallback msgCallback)
36 : features_(features),
37 companyId_(companyId),
38 controlMtu_(controlMtu),
39 browseMtu_(browseMtu),
40 maxFragments_(maxFragments),
41 dispatcher_(dispatcher),
42 connectId_(0xFF),
43 eventCallback_(eventCallback),
44 msgCallback_(msgCallback)
45 {
46 HILOGI("features: %{public}d, companyId: %{public}u, controlMtu: %{public}d, browseMtu: %{public}d, "
47 "maxFragments: %{public}d", features, companyId, controlMtu, browseMtu, maxFragments);
48
49 SetEnableFlag(false);
50 }
51
IsEnabled(void)52 bool AvrcCtProfile::IsEnabled(void)
53 {
54 HILOGI("enter");
55
56 return g_isEnabled;
57 }
58
~AvrcCtProfile()59 AvrcCtProfile::~AvrcCtProfile()
60 {
61 HILOGI("enter");
62
63 SetEnableFlag(false);
64 }
65
66 /******************************************************************
67 * REGISTER / UNREGISTER OBSERVER *
68 ******************************************************************/
69
RegisterObserver(AvrcCtProfile::Observer * observer)70 void AvrcCtProfile::RegisterObserver(AvrcCtProfile::Observer *observer)
71 {
72 HILOGI("enter");
73
74 myObserver_ = observer;
75 }
76
UnregisterObserver(void)77 void AvrcCtProfile::UnregisterObserver(void)
78 {
79 HILOGI("enter");
80
81 myObserver_ = nullptr;
82 }
83
84 /******************************************************************
85 * ENABLE / DISABLE *
86 ******************************************************************/
87
Enable(bool isTgEnabled)88 int AvrcCtProfile::Enable(bool isTgEnabled)
89 {
90 HILOGI("isTgEnabled: %{public}d", isTgEnabled);
91
92 int result = BT_SUCCESS;
93 SetEnableFlag(true);
94 AVCT_Register(controlMtu_, browseMtu_, AVCT_CT);
95 AvctConnectParam param = {eventCallback_, msgCallback_, AVRC_CT_AV_REMOTE_CONTROL, AVCT_ACPT, nullptr};
96 BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
97 if (AVCT_ConnectReq(&connectId_, ¶m, &btAddr) != AVCT_SUCCESS) {
98 result = RET_BAD_STATUS;
99 }
100 return result;
101 }
102
Disable(void)103 int AvrcCtProfile::Disable(void)
104 {
105 HILOGI("enter");
106
107 do {
108 std::lock_guard<std::recursive_mutex> lock(mutex_);
109 SetEnableFlag(false);
110 } while (false);
111
112 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
113 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
114
115 if (!cnManager->IsConnectInfoEmpty()) {
116 utility::Message msg(AVRC_CT_SM_EVENT_TO_DISABLE_STATE);
117 smManager->SendMessageToAllBrowseStateMachine(msg);
118 smManager->SendMessageToAllControlStateMachine(msg);
119 } else {
120 AvrcpCtSafeDelete(cnManager);
121 smManager->ShutDown();
122 myObserver_->onDisabled();
123 }
124
125 return BT_SUCCESS;
126 }
127
SetEnableFlag(bool isEnabled)128 void AvrcCtProfile::SetEnableFlag(bool isEnabled)
129 {
130 HILOGI("isEnabled: %{public}d", isEnabled);
131
132 g_isEnabled = isEnabled;
133 }
134
135 /******************************************************************
136 * CONNECTION *
137 ******************************************************************/
138
GetConnectedDevices(void)139 std::vector<bluetooth::RawAddress> AvrcCtProfile::GetConnectedDevices(void)
140 {
141 HILOGI("enter");
142 std::lock_guard<std::recursive_mutex> lock(mutex_);
143
144 std::vector<bluetooth::RawAddress> result;
145
146 std::list<std::string> addrs = AvrcCtConnectManager::GetInstance()->GetDeviceAddresses();
147 for (auto &addr : addrs) {
148 RawAddress rawAddr(addr);
149 if (GetDeviceState(rawAddr) == static_cast<int>(BTConnectState::CONNECTED)) {
150 result.push_back(rawAddr);
151 }
152 }
153
154 return result;
155 }
156
GetDevicesByStates(const std::vector<int> & states)157 std::vector<RawAddress> AvrcCtProfile::GetDevicesByStates(const std::vector<int> &states)
158 {
159 HILOGI("enter");
160 std::lock_guard<std::recursive_mutex> lock(mutex_);
161
162 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
163
164 std::vector<RawAddress> rawAddrs;
165 std::list<std::string> addrs;
166
167 for (auto &state : states) {
168 if (state == static_cast<int>(BTConnectState::DISCONNECTED)) {
169 addrs = cnManager->GetAllDisconnectedDevices();
170 } else {
171 addrs = cnManager->GetDeviceAddresses();
172 }
173 for (auto &addr : addrs) {
174 RawAddress rawAddr(addr);
175 if (GetDeviceState(rawAddr) == state) {
176 rawAddrs.push_back(rawAddr);
177 }
178 }
179 }
180
181 return rawAddrs;
182 }
183
GetDeviceState(const RawAddress & rawAddr)184 int AvrcCtProfile::GetDeviceState(const RawAddress &rawAddr)
185 {
186 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
187 std::lock_guard<std::recursive_mutex> lock(mutex_);
188
189 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
190 int result;
191
192 if (smManager->IsControlConnectingState(rawAddr)) {
193 result = static_cast<int>(BTConnectState::CONNECTING);
194 } else if (smManager->IsControlConnectedState(rawAddr) || smManager->IsControlPendingState(rawAddr) ||
195 smManager->IsControlContinuationState(rawAddr)) {
196 result = static_cast<int>(BTConnectState::CONNECTED);
197 } else if (smManager->IsControlDisconnectingState(rawAddr)) {
198 result = static_cast<int>(BTConnectState::DISCONNECTING);
199 } else if (smManager->IsControlDisableState(rawAddr)) {
200 result = static_cast<int>(BTConnectState::DISCONNECTING);
201 } else {
202 result = static_cast<int>(BTConnectState::DISCONNECTED);
203 }
204
205 return result;
206 }
207
GetMaxConnectNum(void)208 int AvrcCtProfile::GetMaxConnectNum(void)
209 {
210 HILOGI("enter");
211 std::lock_guard<std::recursive_mutex> lock(mutex_);
212
213 int result = 0x00;
214
215 std::list<std::string> addrs = AvrcCtConnectManager::GetInstance()->GetDeviceAddresses();
216
217 for (auto &addr : addrs) {
218 RawAddress rawAddr(addr);
219 if (GetDeviceState(rawAddr) == static_cast<int>(BTConnectState::CONNECTED)) {
220 ++result;
221 }
222 }
223
224 return result;
225 }
226
Connect(const RawAddress & rawAddr) const227 int AvrcCtProfile::Connect(const RawAddress &rawAddr) const
228 {
229 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
230
231 int result = BT_SUCCESS;
232
233 bool absVolume = Compat::CompatCheck(bluetooth::CompatType::COMPAT_REJECT_ABSOLUTE_VOLUME, rawAddr.GetAddress());
234 result |= AvrcCtConnectManager::GetInstance()->Add(
235 rawAddr, 0x00, AVCT_INIT, controlMtu_, browseMtu_, companyId_, 0x0000, absVolume, eventCallback_, msgCallback_);
236 result |= AvrcCtStateMachineManager::GetInstance()->AddControlStateMachine(rawAddr);
237 if (result == BT_SUCCESS) {
238 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTING));
239 }
240
241 return result;
242 }
243
Disconnect(const RawAddress & rawAddr) const244 int AvrcCtProfile::Disconnect(const RawAddress &rawAddr) const
245 {
246 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
247
248 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
249 utility::Message msg(AVRC_CT_SM_EVENT_TO_DISCONNECTING_STATE);
250 bool result = true;
251
252 result &= smManager->SendMessageToBrowseStateMachine(rawAddr, msg);
253 result &= smManager->SendMessageToControlStateMachine(rawAddr, msg);
254 if (result) {
255 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTING));
256 }
257
258 return BT_SUCCESS;
259 }
260
ConnectBr(const RawAddress & rawAddr)261 int AvrcCtProfile::ConnectBr(const RawAddress &rawAddr)
262 {
263 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
264
265 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
266
267 return smManager->AddBrowseStateMachine(rawAddr);
268 }
269
DisconnectBr(const RawAddress & rawAddr)270 int AvrcCtProfile::DisconnectBr(const RawAddress &rawAddr)
271 {
272 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
273
274 utility::Message msg(AVRC_CT_SM_EVENT_TO_DISCONNECTING_STATE);
275 AvrcCtStateMachineManager::GetInstance()->SendMessageToBrowseStateMachine(rawAddr, msg);
276
277 return BT_SUCCESS;
278 }
279
GetConnectState(void)280 int AvrcCtProfile::GetConnectState(void)
281 {
282 HILOGI("enter");
283 std::lock_guard<std::recursive_mutex> lock(mutex_);
284
285 int result = PROFILE_STATE_DISCONNECTED;
286
287 std::list<std::string> addrs = AvrcCtConnectManager::GetInstance()->GetDeviceAddresses();
288 for (auto &addr : addrs) {
289 RawAddress rawAddr(addr);
290 switch (static_cast<BTConnectState>(GetDeviceState(rawAddr))) {
291 case BTConnectState::CONNECTING:
292 result |= PROFILE_STATE_CONNECTING;
293 break;
294 case BTConnectState::CONNECTED:
295 result |= PROFILE_STATE_CONNECTED;
296 break;
297 case BTConnectState::DISCONNECTING:
298 result |= PROFILE_STATE_DISCONNECTING;
299 break;
300 case BTConnectState::DISCONNECTED:
301 /// FALL THROUGH
302 default:
303 result |= PROFILE_STATE_DISCONNECTED;
304 break;
305 }
306 }
307
308 return result;
309 }
310
311 /******************************************************************
312 * PASS THROUGH COMMAND *
313 ******************************************************************/
314
SendPressButtonCmd(const RawAddress & rawAddr,uint8_t button)315 void AvrcCtProfile::SendPressButtonCmd(const RawAddress &rawAddr, uint8_t button)
316 {
317 HILOGI("address: %{public}s, button: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), button);
318
319 std::shared_ptr<AvrcCtPassPacket> packet = std::make_shared<AvrcCtPassPacket>(button, AVRC_KEY_STATE_PRESS);
320 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
321 SendPassCmd(rawAddr, packet);
322 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
323 }
324
SendReleaseButtonCmd(const RawAddress & rawAddr,uint8_t button)325 void AvrcCtProfile::SendReleaseButtonCmd(const RawAddress &rawAddr, uint8_t button)
326 {
327 HILOGI("address: %{public}s, button: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), button);
328
329 std::shared_ptr<AvrcCtPassPacket> packet = std::make_shared<AvrcCtPassPacket>(button, AVRC_KEY_STATE_RELEASE);
330 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
331 SendPassCmd(rawAddr, packet);
332 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
333 }
334
IsPassQueueFull(const RawAddress & rawAddr)335 bool AvrcCtProfile::IsPassQueueFull(const RawAddress &rawAddr)
336 {
337 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
338 std::lock_guard<std::recursive_mutex> lock(mutex_);
339
340 return (AvrcCtConnectManager::GetInstance()->GetSizeOfPassQueue(rawAddr) == AVRC_CT_DEFAULT_SIZE_OF_QUEUE);
341 }
342
SendPassCmd(const RawAddress & rawAddr,const std::shared_ptr<AvrcCtPassPacket> & pkt)343 void AvrcCtProfile::SendPassCmd(const RawAddress &rawAddr, const std::shared_ptr<AvrcCtPassPacket> &pkt)
344 {
345 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
346
347 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
348
349 if (cnManager->IsPassPacketEmpty(rawAddr)) {
350 /// Unprocessed pass through command.
351
352 /// Sets the information which is used in the "CONNECTED" state of the control state machine.
353 cnManager->SetPassPacket(rawAddr, pkt);
354
355 utility::Message msg(AVRC_CT_SM_EVENT_PASS_THROUGH);
356 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
357
358 /// Sets the information which is used in the timeout.
359 auto func =
360 std::bind(&AvrcCtProfile::PassTimeoutCallback, this, rawAddr, pkt->GetKeyOperation(), pkt->GetKeyState());
361 cnManager->SetPassTimer(rawAddr, func, AVRC_CT_TIMER_PASS_THROUGH);
362 } else {
363 /// There is a command in processing,
364 if (cnManager->GetSizeOfPassQueue(rawAddr) >= AVRC_CT_DEFAULT_SIZE_OF_QUEUE) {
365 InformPassRsp(rawAddr, pkt->GetKeyOperation(), pkt->GetKeyState(), RET_BAD_STATUS);
366 HILOGI("The pass through command is full! - Address: %{public}s - sizeOf: %{public}d",
367 GET_ENCRYPT_AVRCP_ADDR(rawAddr), AVRC_CT_DEFAULT_SIZE_OF_QUEUE);
368 } else {
369 cnManager->PushPassQueue(rawAddr, pkt);
370 HILOGI("Waiting for the response! - Address[%{public}s]", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
371 }
372 }
373 }
374
SendNextPassCmd(const RawAddress & rawAddr)375 void AvrcCtProfile::SendNextPassCmd(const RawAddress &rawAddr)
376 {
377 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
378
379 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
380 cnManager->ClearPassInfo(rawAddr);
381
382 if (cnManager->GetSizeOfPassQueue(rawAddr) != 0x00) {
383 std::shared_ptr<AvrcCtPassPacket> packet = cnManager->PopPassQueue(rawAddr);
384 SendPassCmd(rawAddr, packet);
385 }
386 }
387
ReceivePassRsp(const RawAddress & rawAddr,Packet * pkt)388 void AvrcCtProfile::ReceivePassRsp(const RawAddress &rawAddr, Packet *pkt)
389 {
390 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
391
392 SendNextPassCmd(rawAddr);
393
394 AvrcCtPassPacket packet(pkt);
395 HILOGI("Address: %{public}s - key: %{public}x - state: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr),
396 packet.GetKeyOperation(), packet.GetKeyState());
397
398 InformPassRsp(
399 rawAddr, packet.GetKeyOperation(), packet.GetKeyState(), ExpainPassCrCodeToResult(packet.GetCrCode()));
400 }
401
InformPassRsp(const RawAddress & rawAddr,uint8_t button,uint8_t state,int result) const402 void AvrcCtProfile::InformPassRsp(const RawAddress &rawAddr, uint8_t button, uint8_t state, int result) const
403 {
404 HILOGI("address: %{public}s, button: %{public}d, state: %{public}d, result: %{public}d",
405 GET_ENCRYPT_AVRCP_ADDR(rawAddr), button, state, result);
406
407 switch (state) {
408 case AVRC_KEY_STATE_PRESS:
409 myObserver_->onButtonPressed(rawAddr, button, result);
410 break;
411 case AVRC_KEY_STATE_RELEASE:
412 myObserver_->onButtonReleased(rawAddr, button, result);
413 break;
414 default:
415 HILOGI("The button state is incorrect!");
416 break;
417 }
418 }
419
ProcessPassTimeout(RawAddress rawAddr,uint8_t key,uint8_t state)420 void AvrcCtProfile::ProcessPassTimeout(RawAddress rawAddr, uint8_t key, uint8_t state)
421 {
422 HILOGI("address: %{public}s, key: %{public}x, state: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), key, state);
423
424 if (IsEnabled()) {
425 SendNextPassCmd(rawAddr);
426 InformPassRsp(rawAddr, key, state, RET_BAD_STATUS);
427 }
428 }
429
PassTimeoutCallback(const RawAddress & rawAddr,uint8_t key,uint8_t state)430 void AvrcCtProfile::PassTimeoutCallback(const RawAddress &rawAddr, uint8_t key, uint8_t state)
431 {
432 HILOGI("address: %{public}s, key: %{public}x - state: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), key, state);
433
434 if (IsEnabled()) {
435 dispatcher_->PostTask(std::bind(&AvrcCtProfile::ProcessPassTimeout, this, rawAddr, key, state));
436 }
437 }
438
439 /******************************************************************
440 * UNIT INFO / SUB UNIT INFO COMMAND *
441 ******************************************************************/
442
SendUnitCmd(const RawAddress & rawAddr)443 void AvrcCtProfile::SendUnitCmd(const RawAddress &rawAddr)
444 {
445 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
446
447 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
448 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
449
450 std::shared_ptr<AvrcCtUnitPacket> pkt = std::make_shared<AvrcCtUnitPacket>();
451 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
452 if (!smManager->IsControlPendingState(rawAddr) && !smManager->IsControlContinuationState(rawAddr)) {
453 /// Unprocessed vendor dependent command.
454
455 /// Sets the information which is used in the "CONNECTED" state of the control state machine.
456 cnManager->SetUnitPacket(rawAddr, pkt);
457
458 utility::Message msg(AVRC_CT_SM_EVENT_UNIT_INFO);
459 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
460
461 /// Sets the information which is used in the timeout.
462 auto func = std::bind(&AvrcCtProfile::UnitTimeoutCallback, this, rawAddr);
463 cnManager->SetUnitTimer(rawAddr, func, AVRC_CT_TIMER_T_MTP);
464 } else {
465 /// There is a command in processing,
466
467 if (cnManager->GetSizeOfUnitQueue(rawAddr) > AVRC_CT_DEFAULT_SIZE_OF_QUEUE) {
468 HILOGI("The vendor queue is oversize: %{public}d", cnManager->GetSizeOfVendorQueue(rawAddr));
469 } else {
470 cnManager->PushUnitQueue(rawAddr, pkt);
471 HILOGI("Waiting for the response!");
472 }
473 }
474 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
475 }
476
SendSubUnitCmd(const RawAddress & rawAddr)477 void AvrcCtProfile::SendSubUnitCmd(const RawAddress &rawAddr)
478 {
479 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
480
481 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
482 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
483
484 std::shared_ptr<AvrcCtUnitPacket> pkt = std::make_shared<AvrcCtSubUnitPacket>();
485 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
486 if (!smManager->IsControlPendingState(rawAddr) && !smManager->IsControlContinuationState(rawAddr)) {
487 /// Unprocessed vendor dependent command.
488
489 /// Sets the information which is used in the "CONNECTED" state of the control state machine.
490 cnManager->SetUnitPacket(rawAddr, pkt);
491
492 utility::Message msg(AVRC_CT_SM_EVENT_SUB_UNIT_INFO);
493 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
494
495 /// Sets the information which is used in the timeout.
496 auto func = std::bind(&AvrcCtProfile::UnitTimeoutCallback, this, rawAddr);
497 cnManager->SetUnitTimer(rawAddr, func, AVRC_CT_TIMER_T_MTP);
498 } else {
499 /// There is a command in processing,
500
501 if (cnManager->GetSizeOfUnitQueue(rawAddr) > AVRC_CT_DEFAULT_SIZE_OF_QUEUE) {
502 HILOGI("The vendor queue is oversize: %{public}d", cnManager->GetSizeOfVendorQueue(rawAddr));
503 } else {
504 cnManager->PushUnitQueue(rawAddr, pkt);
505 HILOGI("Waiting for the response!");
506 }
507 }
508 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
509 }
510
IsUnitQueueFull(const RawAddress & rawAddr)511 bool AvrcCtProfile::IsUnitQueueFull(const RawAddress &rawAddr)
512 {
513 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
514
515 return (AvrcCtConnectManager::GetInstance()->GetSizeOfUnitQueue(rawAddr) == AVRC_CT_DEFAULT_SIZE_OF_QUEUE);
516 }
517
SendNextUnitCmd(const RawAddress & rawAddr)518 void AvrcCtProfile::SendNextUnitCmd(const RawAddress &rawAddr)
519 {
520 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
521
522 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
523 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
524 utility::Message msg(AVRC_CT_SM_EVENT_INVALID);
525
526 cnManager->ClearUnitInfo(rawAddr);
527 msg.what_ = AVRC_CT_SM_EVENT_TO_CONNECTED_STATE;
528 smManager->SendMessageToControlStateMachine(rawAddr, msg);
529
530 if (cnManager->GetSizeOfUnitQueue(rawAddr) != 0x00) {
531 std::shared_ptr<AvrcCtUnitPacket> packet = cnManager->PopUnitQueue(rawAddr);
532
533 switch (packet->GetOpCode()) {
534 case AVRC_CT_OP_CODE_UNIT_INFO:
535 msg.what_ = AVRC_CT_SM_EVENT_UNIT_INFO;
536 break;
537 case AVRC_CT_OP_CODE_SUB_UNIT_INFO:
538 msg.what_ = AVRC_CT_SM_EVENT_SUB_UNIT_INFO;
539 break;
540 default:
541 HILOGI("Opcode is wrong! - opCode: %{public}x", packet->GetOpCode());
542 break;
543 }
544
545 cnManager->SetUnitPacket(rawAddr, packet);
546 smManager->SendMessageToControlStateMachine(rawAddr, msg);
547 } else if (cnManager->GetSizeOfVendorQueue(rawAddr) != 0x00) {
548 SendNextVendorCmd(rawAddr);
549 }
550 }
551
ReceiveUnitRsp(const RawAddress & rawAddr,Packet * pkt)552 void AvrcCtProfile::ReceiveUnitRsp(const RawAddress &rawAddr, Packet *pkt)
553 {
554 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
555
556 SendNextUnitCmd(rawAddr);
557
558 AvrcCtUnitPacket packet(pkt);
559 HILOGI("response: %{public}x", packet.GetCrCode());
560 }
561
ReceiveSubUnitRsp(const RawAddress & rawAddr,Packet * pkt)562 void AvrcCtProfile::ReceiveSubUnitRsp(const RawAddress &rawAddr, Packet *pkt)
563 {
564 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
565
566 SendNextUnitCmd(rawAddr);
567
568 AvrcCtSubUnitPacket packet(pkt);
569 HILOGI("response: %{public}x", packet.GetCrCode());
570 }
571
ProcessUnitTimeout(RawAddress rawAddr)572 void AvrcCtProfile::ProcessUnitTimeout(RawAddress rawAddr)
573 {
574 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
575
576 if (IsEnabled()) {
577 std::shared_ptr<AvrcCtUnitPacket> packet = AvrcCtConnectManager::GetInstance()->GetUnitPacket(rawAddr);
578 if (packet != nullptr) {
579 switch (packet->GetOpCode()) {
580 case AVRC_CT_OP_CODE_UNIT_INFO:
581 HILOGI("opCode[UNIT_INFO]");
582 break;
583 case AVRC_CT_OP_CODE_SUB_UNIT_INFO:
584 HILOGI("opCode[SUB_UNIT_INFO]");
585 break;
586 default:
587 HILOGI("Opcode is wrong! - opCode: %{public}x", packet->GetOpCode());
588 break;
589 }
590 } else {
591 HILOGI("The saved packet is nullptr!");
592 }
593 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
594 SendNextUnitCmd(rawAddr);
595 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
596 }
597 }
598
UnitTimeoutCallback(const RawAddress & rawAddr)599 void AvrcCtProfile::UnitTimeoutCallback(const RawAddress &rawAddr)
600 {
601 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
602
603 if (IsEnabled()) {
604 dispatcher_->PostTask(std::bind(&AvrcCtProfile::ProcessUnitTimeout, this, rawAddr));
605 }
606 }
607
608 /******************************************************************
609 * VENDOR COMMAND *
610 ******************************************************************/
611
SendVendorCmd(const RawAddress & rawAddr,const std::shared_ptr<AvrcCtVendorPacket> & pkt,AvrcCtSmEvent event)612 void AvrcCtProfile::SendVendorCmd(
613 const RawAddress &rawAddr, const std::shared_ptr<AvrcCtVendorPacket> &pkt, AvrcCtSmEvent event)
614 {
615 HILOGI("address: %{public}s, event: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), event);
616
617 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
618 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
619
620 if (!smManager->IsControlPendingState(rawAddr) && !smManager->IsControlContinuationState(rawAddr)) {
621 /// Unprocessed vendor dependent command.
622 /// Sets the information which is used in the "CONNECTED" state of the control state machine.
623 cnManager->ClearVendorInfo(rawAddr);
624 cnManager->SetVendorPacket(rawAddr, pkt);
625
626 utility::Message msg(event);
627 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
628
629 /// Sets the information which is used in the timeout.
630 auto func = std::bind(&AvrcCtProfile::VendorTimeoutCallback, this, rawAddr);
631 cnManager->SetVendorTimer(rawAddr, func, AVRC_CT_TIMER_T_MTP);
632 } else {
633 /// There is a command in processing,
634
635 if (cnManager->GetSizeOfVendorQueue(rawAddr) > AVRC_CT_DEFAULT_SIZE_OF_QUEUE) {
636 HILOGI("The vendor queue is oversize: %{public}d", cnManager->GetSizeOfVendorQueue(rawAddr));
637 } else {
638 cnManager->PushVendorQueue(rawAddr, pkt);
639 HILOGI("Waiting for the response!");
640 }
641 }
642 }
643
SendNextVendorCmd(const RawAddress & rawAddr)644 void AvrcCtProfile::SendNextVendorCmd(const RawAddress &rawAddr)
645 {
646 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
647
648 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
649 cnManager->ClearVendorInfo(rawAddr);
650
651 utility::Message msg(AVRC_CT_SM_EVENT_TO_CONNECTED_STATE);
652 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
653
654 if (cnManager->GetSizeOfVendorQueue(rawAddr) != 0x00) {
655 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->PopVendorQueue(rawAddr);
656 SendVendorCmd(rawAddr, packet, static_cast<AvrcCtSmEvent>(packet->GetPduId()));
657 } else if (cnManager->GetSizeOfUnitQueue(rawAddr) != 0x00) {
658 SendNextUnitCmd(rawAddr);
659 }
660 }
661
SendVendorContinueCmd(const RawAddress & rawAddr,uint8_t pduId)662 void AvrcCtProfile::SendVendorContinueCmd(const RawAddress &rawAddr, uint8_t pduId)
663 {
664 HILOGI("address: %{public}s, pduId: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), pduId);
665
666 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
667 cnManager->ClearVendorPacket(rawAddr);
668 cnManager->ClearVendorTimer(rawAddr);
669
670 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtRcrPacket>(pduId);
671 cnManager->SetVendorPacket(rawAddr, packet);
672
673 utility::Message msg(AVRC_CT_SM_EVENT_REQUEST_CONTINUING_RESPONSE);
674 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
675
676 /// Sets the information which is used in the timeout.
677 auto func = std::bind(&AvrcCtProfile::VendorTimeoutCallback, this, rawAddr);
678 cnManager->SetVendorTimer(rawAddr, func, AVRC_CT_TIMER_T_MTP);
679 }
680
SendVendorAbortCmd(const RawAddress & rawAddr,uint8_t pduId) const681 void AvrcCtProfile::SendVendorAbortCmd(const RawAddress &rawAddr, uint8_t pduId) const
682 {
683 HILOGI("address: %{public}s, pduId: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), pduId);
684
685 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
686 cnManager->ClearVendorPacket(rawAddr);
687 cnManager->ClearVendorTimer(rawAddr);
688
689 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtAcrPacket>(pduId);
690 cnManager->SetVendorPacket(rawAddr, packet);
691
692 utility::Message msg(AVRC_CT_SM_EVENT_ABORT_CONTINUING_RESPONSE);
693 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
694 }
695
IsVendorQueueFull(const RawAddress & rawAddr)696 bool AvrcCtProfile::IsVendorQueueFull(const RawAddress &rawAddr)
697 {
698 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
699 std::lock_guard<std::recursive_mutex> lock(mutex_);
700
701 return (AvrcCtConnectManager::GetInstance()->GetSizeOfVendorQueue(rawAddr) == AVRC_CT_DEFAULT_SIZE_OF_QUEUE);
702 }
703
SendGetCapabilitiesCmd(const RawAddress & rawAddr,uint8_t capabilityId)704 void AvrcCtProfile::SendGetCapabilitiesCmd(const RawAddress &rawAddr, uint8_t capabilityId)
705 {
706 HILOGI("address: %{public}s, capabilityId: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), capabilityId);
707
708 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtGcPacket>(capabilityId);
709 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
710 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_CAPABILITIES);
711 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
712 }
713
ReceiveGetCapabilitiesRsp(const RawAddress & rawAddr,Packet * pkt)714 void AvrcCtProfile::ReceiveGetCapabilitiesRsp(const RawAddress &rawAddr, Packet *pkt)
715 {
716 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
717
718 SendNextVendorCmd(rawAddr);
719
720 AvrcCtGcPacket packet(pkt);
721 if (packet.GetEvents().size() != 0x00) {
722 AvrcCtConnectManager::GetInstance()->DisableExcludeEvents(rawAddr, packet.GetEvents());
723 }
724 myObserver_->onGetCapabilities(
725 rawAddr, packet.GetCompanies(), packet.GetEvents(), ExplainCrCodeToResult(packet.GetCrCode()));
726 }
727
SendListPlayerApplicationSettingAttributesCmd(const RawAddress & rawAddr)728 void AvrcCtProfile::SendListPlayerApplicationSettingAttributesCmd(const RawAddress &rawAddr)
729 {
730 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
731
732 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtLpasaPacket>();
733 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
734 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES);
735 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
736 }
737
ReceiveListPlayerApplicationSettingAttributesRsp(const RawAddress & rawAddr,Packet * pkt)738 void AvrcCtProfile::ReceiveListPlayerApplicationSettingAttributesRsp(const RawAddress &rawAddr, Packet *pkt)
739 {
740 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
741
742 SendNextVendorCmd(rawAddr);
743
744 AvrcCtLpasaPacket packet(pkt);
745 myObserver_->onListPlayerApplicationSettingAttributes(
746 rawAddr, packet.GetAttributes(), ExplainCrCodeToResult(packet.GetCrCode()));
747 }
748
SendListPlayerApplicationSettingValuesCmd(const RawAddress & rawAddr,uint8_t attribute)749 void AvrcCtProfile::SendListPlayerApplicationSettingValuesCmd(const RawAddress &rawAddr, uint8_t attribute)
750 {
751 HILOGI("address: %{public}s, attribute: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), attribute);
752
753 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtLpasvPacket>(attribute);
754 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
755 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_VALUES);
756 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
757 }
758
ReceiveListPlayerApplicationSettingValuesRsp(const RawAddress & rawAddr,Packet * pkt)759 void AvrcCtProfile::ReceiveListPlayerApplicationSettingValuesRsp(const RawAddress &rawAddr, Packet *pkt)
760 {
761 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
762
763 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
764
765 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorContinuePacket(rawAddr);
766 AvrcCtLpasvPacket *lpasvPkt = nullptr;
767
768 if (packet == nullptr) {
769 packet = cnManager->GetVendorPacket(rawAddr);
770 lpasvPkt = static_cast<AvrcCtLpasvPacket *>(cnManager->GetVendorPacket(rawAddr).get());
771 lpasvPkt->DisassemblePacket(pkt);
772 } else {
773 lpasvPkt = static_cast<AvrcCtLpasvPacket *>(packet.get());
774 lpasvPkt->DisassemblePacket(pkt);
775 }
776
777 HILOGI("attribute: %{public}x - values.size: %{public}zu - result: %{public}d", lpasvPkt->GetAttribute(),
778 lpasvPkt->GetValues().size(), ExplainCrCodeToResult(lpasvPkt->GetCrCode()));
779
780 switch (lpasvPkt->GetPacketType()) {
781 case AVRC_CT_VENDOR_PACKET_TYPE:
782 /// FALL THROUGH
783 case AVRC_CT_VENDOR_PACKET_TYPE_END: {
784 SendNextVendorCmd(rawAddr);
785
786 myObserver_->onListPlayerApplicationSettingValues(
787 rawAddr, lpasvPkt->GetAttribute(), lpasvPkt->GetValues(), ExplainCrCodeToResult(lpasvPkt->GetCrCode()));
788 break;
789 }
790 case AVRC_CT_VENDOR_PACKET_TYPE_START:
791 /// FALL THROUGH
792 case AVRC_CT_VENDOR_PACKET_TYPE_CONTINUE: {
793 if (packet->GetReceivedFragments() >= maxFragments_) {
794 SendVendorAbortCmd(rawAddr, lpasvPkt->GetPduId());
795 myObserver_->onListPlayerApplicationSettingValues(rawAddr,
796 lpasvPkt->GetAttribute(),
797 lpasvPkt->GetValues(),
798 ExplainCrCodeToResult(lpasvPkt->GetCrCode()));
799 } else {
800 cnManager->SetVendorContinuePacket(rawAddr, packet);
801 SendVendorContinueCmd(rawAddr, lpasvPkt->GetPduId());
802 }
803 break;
804 }
805 default:
806 HILOGI("Packet Type is wrong! - packetType: %{public}d", lpasvPkt->GetPacketType());
807 break;
808 }
809 }
810
SendGetCurrentPlayerApplicationSettingValueCmd(const RawAddress & rawAddr,const std::vector<uint8_t> & attributes)811 void AvrcCtProfile::SendGetCurrentPlayerApplicationSettingValueCmd(
812 const RawAddress &rawAddr, const std::vector<uint8_t> &attributes)
813 {
814 HILOGI("address: %{public}s, attributes.size: %{public}zu", GET_ENCRYPT_AVRCP_ADDR(rawAddr), attributes.size());
815
816 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtGcpasvPacket>(attributes);
817 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
818 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE);
819 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
820 }
821
ReceiveGetCurrentPlayerApplicationSettingValueRsp(const RawAddress & rawAddr,Packet * pkt)822 void AvrcCtProfile::ReceiveGetCurrentPlayerApplicationSettingValueRsp(const RawAddress &rawAddr, Packet *pkt)
823 {
824 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
825
826 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
827
828 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorContinuePacket(rawAddr);
829 AvrcCtGcpasvPacket *gcpasvPkt = nullptr;
830
831 if (packet == nullptr) {
832 packet = cnManager->GetVendorPacket(rawAddr);
833 gcpasvPkt = static_cast<AvrcCtGcpasvPacket *>(packet.get());
834 gcpasvPkt->ClearAttributes();
835 gcpasvPkt->DisassemblePacket(pkt);
836 } else {
837 gcpasvPkt = static_cast<AvrcCtGcpasvPacket *>(packet.get());
838 gcpasvPkt->DisassemblePacket(pkt);
839 }
840
841 HILOGI("attributes.size: %{public}zu - values.size: %{public}zu - result: %{public}d",
842 gcpasvPkt->GetAttributes().size(), gcpasvPkt->GetValues().size(),
843 ExplainCrCodeToResult(gcpasvPkt->GetCrCode()));
844
845 switch (gcpasvPkt->GetPacketType()) {
846 case AVRC_CT_VENDOR_PACKET_TYPE:
847 /// FALL THROUGH
848 case AVRC_CT_VENDOR_PACKET_TYPE_END: {
849 SendNextVendorCmd(rawAddr);
850
851 myObserver_->onGetCurrentPlayerApplicationSettingValue(rawAddr,
852 gcpasvPkt->GetAttributes(),
853 gcpasvPkt->GetValues(),
854 ExplainCrCodeToResult(gcpasvPkt->GetCrCode()));
855 break;
856 }
857 case AVRC_CT_VENDOR_PACKET_TYPE_START:
858 /// FALL THROUGH
859 case AVRC_CT_VENDOR_PACKET_TYPE_CONTINUE: {
860 if (packet->GetReceivedFragments() >= maxFragments_) {
861 SendVendorAbortCmd(rawAddr, gcpasvPkt->GetPduId());
862 myObserver_->onGetCurrentPlayerApplicationSettingValue(rawAddr,
863 gcpasvPkt->GetAttributes(),
864 gcpasvPkt->GetValues(),
865 ExplainCrCodeToResult(gcpasvPkt->GetCrCode()));
866 } else {
867 cnManager->SetVendorContinuePacket(rawAddr, packet);
868 SendVendorContinueCmd(rawAddr, gcpasvPkt->GetPduId());
869 }
870 break;
871 }
872 default:
873 HILOGI("Packet Type is wrong! - packetType: %{public}d", gcpasvPkt->GetPacketType());
874 break;
875 }
876 }
877
SendSetPlayerApplicationSettingValueCmd(const RawAddress & rawAddr,const std::vector<uint8_t> & attributes,const std::vector<uint8_t> & values)878 void AvrcCtProfile::SendSetPlayerApplicationSettingValueCmd(
879 const RawAddress &rawAddr, const std::vector<uint8_t> &attributes, const std::vector<uint8_t> &values)
880 {
881 HILOGI("address: %{public}s, attributes.size: %{public}zu, values.size: %{public}zu",
882 GET_ENCRYPT_AVRCP_ADDR(rawAddr), attributes.size(), values.size());
883
884 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtSpasvPacket>(attributes, values);
885 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
886 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_SET_PLAYER_APPLICATION_SETTING_VALUE);
887 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
888 }
889
ReceiveSetPlayerApplicationSettingValueRsp(const RawAddress & rawAddr,Packet * pkt)890 void AvrcCtProfile::ReceiveSetPlayerApplicationSettingValueRsp(const RawAddress &rawAddr, Packet *pkt)
891 {
892 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
893
894 SendNextVendorCmd(rawAddr);
895
896 AvrcCtSpasvPacket packet(pkt);
897 myObserver_->onSetPlayerApplicationSettingValue(rawAddr, ExplainCrCodeToResult(packet.GetCrCode()));
898 }
899
SendGetPlayerApplicationSettingAttributeTextCmd(const RawAddress & rawAddr,const std::vector<uint8_t> & attributes)900 void AvrcCtProfile::SendGetPlayerApplicationSettingAttributeTextCmd(
901 const RawAddress &rawAddr, const std::vector<uint8_t> &attributes)
902 {
903 HILOGI("address: %{public}s, attributes.size: %{public}zu", GET_ENCRYPT_AVRCP_ADDR(rawAddr), attributes.size());
904
905 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtGpasatPacket>(attributes);
906 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
907 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT);
908 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
909 }
910
ReceiveGetPlayerApplicationSettingAttributeTextRsp(const RawAddress & rawAddr,Packet * pkt)911 void AvrcCtProfile::ReceiveGetPlayerApplicationSettingAttributeTextRsp(const RawAddress &rawAddr, Packet *pkt)
912 {
913 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
914
915 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
916
917 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorContinuePacket(rawAddr);
918 AvrcCtGpasatPacket *gpasatPkt = nullptr;
919
920 if (packet == nullptr) {
921 packet = cnManager->GetVendorPacket(rawAddr);
922 gpasatPkt = static_cast<AvrcCtGpasatPacket *>(packet.get());
923 gpasatPkt->ClearAttributes();
924 gpasatPkt->ClearValueName();
925 gpasatPkt->DisassemblePacket(pkt);
926 } else {
927 gpasatPkt = static_cast<AvrcCtGpasatPacket *>(packet.get());
928 gpasatPkt->DisassemblePacket(pkt);
929 }
930 HILOGI("attributes.size: %{public}zu, attributeStringLength.size: %{public}zu, result: %{public}d",
931 gpasatPkt->GetAttributes().size(), gpasatPkt->GetAttributeName().size(),
932 ExplainCrCodeToResult(gpasatPkt->GetCrCode()));
933
934 switch (gpasatPkt->GetPacketType()) {
935 case AVRC_CT_VENDOR_PACKET_TYPE:
936 /// FALL THROUGH
937 case AVRC_CT_VENDOR_PACKET_TYPE_END: {
938 SendNextVendorCmd(rawAddr);
939
940 myObserver_->onGetPlayerApplicationSettingAttributeText(rawAddr,
941 gpasatPkt->GetAttributes(),
942 gpasatPkt->GetAttributeName(),
943 ExplainCrCodeToResult(gpasatPkt->GetCrCode()));
944 break;
945 }
946 case AVRC_CT_VENDOR_PACKET_TYPE_START:
947 /// FALL THROUGH
948 case AVRC_CT_VENDOR_PACKET_TYPE_CONTINUE: {
949 if (packet->GetReceivedFragments() >= maxFragments_) {
950 SendVendorAbortCmd(rawAddr, gpasatPkt->GetPduId());
951 myObserver_->onGetPlayerApplicationSettingAttributeText(rawAddr,
952 gpasatPkt->GetAttributes(),
953 gpasatPkt->GetAttributeName(),
954 ExplainCrCodeToResult(gpasatPkt->GetCrCode()));
955 } else {
956 cnManager->SetVendorContinuePacket(rawAddr, packet);
957 SendVendorContinueCmd(rawAddr, gpasatPkt->GetPduId());
958 }
959 break;
960 }
961 default:
962 HILOGI("Packet Type is wrong! - packetType: %{public}d", gpasatPkt->GetPacketType());
963 break;
964 }
965 }
966
SendGetPlayerApplicationSettingValueTextCmd(const RawAddress & rawAddr,uint8_t attributeId,const std::vector<uint8_t> & values)967 void AvrcCtProfile::SendGetPlayerApplicationSettingValueTextCmd(
968 const RawAddress &rawAddr, uint8_t attributeId, const std::vector<uint8_t> &values)
969 {
970 HILOGI("address: %{public}s, attributeId: %{public}d, values.size[%{public}zu]",
971 GET_ENCRYPT_AVRCP_ADDR(rawAddr), attributeId, values.size());
972
973 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtGpasvtPacket>(attributeId, values);
974 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
975 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT);
976 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
977 }
978
ReceiveGetPlayerApplicationSettingValueTextRsp(const RawAddress & rawAddr,Packet * pkt)979 void AvrcCtProfile::ReceiveGetPlayerApplicationSettingValueTextRsp(const RawAddress &rawAddr, Packet *pkt)
980 {
981 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
982
983 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
984
985 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorContinuePacket(rawAddr);
986 AvrcCtGpasvtPacket *gpasvtPkt = nullptr;
987
988 if (packet == nullptr) {
989 packet = cnManager->GetVendorPacket(rawAddr);
990 gpasvtPkt = static_cast<AvrcCtGpasvtPacket *>(packet.get());
991 gpasvtPkt->ClearValues();
992 gpasvtPkt->ClearValueName();
993 gpasvtPkt->DisassemblePacket(pkt);
994 } else {
995 gpasvtPkt = static_cast<AvrcCtGpasvtPacket *>(packet.get());
996 gpasvtPkt->DisassemblePacket(pkt);
997 }
998 HILOGI("values.size: %{public}zu, valuestr.size: %{public}zu, result: %{public}d",
999 gpasvtPkt->GetValues().size(), gpasvtPkt->GetValueName().size(), ExplainCrCodeToResult(gpasvtPkt->GetCrCode()));
1000
1001 switch (gpasvtPkt->GetPacketType()) {
1002 case AVRC_CT_VENDOR_PACKET_TYPE:
1003 /// FALL THROUGH
1004 case AVRC_CT_VENDOR_PACKET_TYPE_END: {
1005 SendNextVendorCmd(rawAddr);
1006
1007 myObserver_->onGetPlayerApplicationSettingValueText(rawAddr,
1008 gpasvtPkt->GetValues(),
1009 gpasvtPkt->GetValueName(),
1010 ExplainCrCodeToResult(gpasvtPkt->GetCrCode()));
1011 break;
1012 }
1013 case AVRC_CT_VENDOR_PACKET_TYPE_START:
1014 /// FALL THROUGH
1015 case AVRC_CT_VENDOR_PACKET_TYPE_CONTINUE: {
1016 if (packet->GetReceivedFragments() >= maxFragments_) {
1017 SendVendorAbortCmd(rawAddr, gpasvtPkt->GetPduId());
1018 myObserver_->onGetPlayerApplicationSettingValueText(rawAddr,
1019 gpasvtPkt->GetValues(),
1020 gpasvtPkt->GetValueName(),
1021 ExplainCrCodeToResult(gpasvtPkt->GetCrCode()));
1022 } else {
1023 cnManager->SetVendorContinuePacket(rawAddr, packet);
1024 SendVendorContinueCmd(rawAddr, gpasvtPkt->GetPduId());
1025 }
1026 break;
1027 }
1028 default:
1029 HILOGI("Packet Type is wrong! packetType: %{public}d", gpasvtPkt->GetPacketType());
1030 break;
1031 }
1032 }
1033
SendGetElementAttributesCmd(const RawAddress & rawAddr,uint64_t identifier,const std::vector<uint32_t> & attributes)1034 void AvrcCtProfile::SendGetElementAttributesCmd(
1035 const RawAddress &rawAddr, uint64_t identifier, const std::vector<uint32_t> &attributes)
1036 {
1037 HILOGI("address: %{public}s, identifier: %{public}ju, attributes.size: %{public}zu",
1038 GET_ENCRYPT_AVRCP_ADDR(rawAddr), identifier, attributes.size());
1039
1040 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtGeaPacket>(identifier, attributes);
1041 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1042 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_ELEMENT_ATTRIBUTES);
1043 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1044 }
1045
ReceiveGetElementAttributesRsp(const RawAddress & rawAddr,Packet * pkt)1046 void AvrcCtProfile::ReceiveGetElementAttributesRsp(const RawAddress &rawAddr, Packet *pkt)
1047 {
1048 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1049
1050 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1051
1052 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorContinuePacket(rawAddr);
1053 AvrcCtGeaPacket *geaPkt = nullptr;
1054 if (packet == nullptr) {
1055 packet = cnManager->GetVendorPacket(rawAddr);
1056 geaPkt = static_cast<AvrcCtGeaPacket *>(packet.get());
1057 geaPkt->ClearAttributes();
1058 geaPkt->ClearValues();
1059 geaPkt->DisassemblePacket(pkt);
1060 } else {
1061 geaPkt = static_cast<AvrcCtGeaPacket *>(packet.get());
1062 geaPkt->DisassemblePacket(pkt);
1063 }
1064
1065 HILOGI("attributes.size: %{public}zu, values.size: %{public}zu, result: %{public}d",
1066 geaPkt->GetAttributes().size(), geaPkt->GetValues().size(), ExplainCrCodeToResult(geaPkt->GetCrCode()));
1067
1068 switch (geaPkt->GetPacketType()) {
1069 case AVRC_CT_VENDOR_PACKET_TYPE:
1070 /// FALL THROUGH
1071 case AVRC_CT_VENDOR_PACKET_TYPE_END: {
1072 SendNextVendorCmd(rawAddr);
1073
1074 myObserver_->onGetElementAttributes(
1075 rawAddr, geaPkt->GetAttributes(), geaPkt->GetValues(), ExplainCrCodeToResult(geaPkt->GetCrCode()));
1076 break;
1077 }
1078 case AVRC_CT_VENDOR_PACKET_TYPE_START:
1079 /// FALL THROUGH
1080 case AVRC_CT_VENDOR_PACKET_TYPE_CONTINUE: {
1081 if (packet->GetReceivedFragments() >= maxFragments_) {
1082 SendVendorAbortCmd(rawAddr, geaPkt->GetPduId());
1083 myObserver_->onGetElementAttributes(
1084 rawAddr, geaPkt->GetAttributes(), geaPkt->GetValues(), ExplainCrCodeToResult(geaPkt->GetCrCode()));
1085 } else {
1086 cnManager->SetVendorContinuePacket(rawAddr, packet);
1087 SendVendorContinueCmd(rawAddr, geaPkt->GetPduId());
1088 }
1089 break;
1090 }
1091 default:
1092 HILOGI("Packet Type is wrong! packetType: %{public}d", geaPkt->GetPacketType());
1093 break;
1094 }
1095 }
1096
SendGetPlayStatusCmd(const RawAddress & rawAddr)1097 void AvrcCtProfile::SendGetPlayStatusCmd(const RawAddress &rawAddr)
1098 {
1099 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1100
1101 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtGpsPacket>();
1102 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1103 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_PLAY_STATUS);
1104 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1105 }
1106
ReceiveGetPlayStatusRsp(const RawAddress & rawAddr,Packet * pkt)1107 void AvrcCtProfile::ReceiveGetPlayStatusRsp(const RawAddress &rawAddr, Packet *pkt)
1108 {
1109 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1110
1111 SendNextVendorCmd(rawAddr);
1112
1113 AvrcCtGpsPacket packet(pkt);
1114 myObserver_->onGetPlayStatus(rawAddr,
1115 packet.GetSongLength(),
1116 packet.GetSongPosition(),
1117 packet.GetPlayStatus(),
1118 ExplainCrCodeToResult(packet.GetCrCode()));
1119 }
1120
SendRequestContinuingResponseCmd(const RawAddress & rawAddr,uint8_t pduId)1121 void AvrcCtProfile::SendRequestContinuingResponseCmd(const RawAddress &rawAddr, uint8_t pduId)
1122 {
1123 HILOGI("address: %{public}s, pduId: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), pduId);
1124
1125 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtRcrPacket>(pduId);
1126 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1127 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_REQUEST_CONTINUING_RESPONSE);
1128 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1129 }
1130
SendAbortContinuingResponseCmd(const RawAddress & rawAddr,uint8_t pduId)1131 void AvrcCtProfile::SendAbortContinuingResponseCmd(const RawAddress &rawAddr, uint8_t pduId)
1132 {
1133 HILOGI("address: %{public}s, pduId: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), pduId);
1134
1135 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtAcrPacket>(pduId);
1136 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1137 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_ABORT_CONTINUING_RESPONSE);
1138 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1139 }
1140
ReceiveAbortContinuingResponseRsp(const RawAddress & rawAddr,Packet * pkt)1141 void AvrcCtProfile::ReceiveAbortContinuingResponseRsp(const RawAddress &rawAddr, Packet *pkt)
1142 {
1143 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1144
1145 AvrcCtAcrPacket acrPkt(pkt);
1146
1147 std::shared_ptr<AvrcCtVendorPacket> packet = AvrcCtConnectManager::GetInstance()->GetVendorContinuePacket(rawAddr);
1148
1149 if (packet != nullptr) {
1150 if (acrPkt.GetPduId() != packet->GetPduId()) {
1151 HILOGI("PDU ID is wrong! Address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1152 }
1153 } else {
1154 HILOGI("The saved continue packet is nullptr!");
1155 }
1156
1157 SendNextVendorCmd(rawAddr);
1158 }
1159
SendSetAddressedPlayerCmd(const RawAddress & rawAddr,uint16_t playerId)1160 void AvrcCtProfile::SendSetAddressedPlayerCmd(const RawAddress &rawAddr, uint16_t playerId)
1161 {
1162 HILOGI("address: %{public}s, playerId: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), playerId);
1163
1164 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtSapPacket>(playerId);
1165 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1166 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_SET_ADDRESSED_PLAYER);
1167 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1168 }
1169
ReceiveSetAddressedPlayerRsp(const RawAddress & rawAddr,Packet * pkt)1170 void AvrcCtProfile::ReceiveSetAddressedPlayerRsp(const RawAddress &rawAddr, Packet *pkt)
1171 {
1172 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1173
1174 SendNextVendorCmd(rawAddr);
1175
1176 AvrcCtSapPacket packet(pkt);
1177
1178 int result = RET_BAD_STATUS;
1179 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1180 result = BT_SUCCESS;
1181 }
1182
1183 myObserver_->onSetAddressedPlayer(rawAddr, result, packet.GetStatus());
1184 }
1185
SendPlayItemCmd(const RawAddress & rawAddr,uint8_t scope,uint64_t uid,uint16_t uidCounter)1186 void AvrcCtProfile::SendPlayItemCmd(const RawAddress &rawAddr, uint8_t scope, uint64_t uid, uint16_t uidCounter)
1187 {
1188 HILOGI("address: %{public}s, scope: %{public}x, uid: %{public}jx, uidCounter: %{public}hd",
1189 GET_ENCRYPT_AVRCP_ADDR(rawAddr), scope, uid, uidCounter);
1190
1191 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtPiPacket>(scope, uid, uidCounter);
1192 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1193 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_PLAY_ITEM);
1194 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1195 }
1196
ReceivePlayItemRsp(const RawAddress & rawAddr,Packet * pkt)1197 void AvrcCtProfile::ReceivePlayItemRsp(const RawAddress &rawAddr, Packet *pkt)
1198 {
1199 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1200
1201 SendNextVendorCmd(rawAddr);
1202
1203 AvrcCtPiPacket packet(pkt);
1204 int result;
1205 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1206 result = BT_SUCCESS;
1207 } else {
1208 result = RET_BAD_STATUS;
1209 }
1210 myObserver_->onPlayItem(rawAddr, result, packet.GetStatus());
1211 }
1212
SendAddToNowPlayingCmd(const RawAddress & rawAddr,uint8_t scope,uint64_t uid,uint16_t uidCounter)1213 void AvrcCtProfile::SendAddToNowPlayingCmd(const RawAddress &rawAddr, uint8_t scope, uint64_t uid, uint16_t uidCounter)
1214 {
1215 HILOGI("address: %{public}s, scope: %{public}d, uid: %{public}ju, uidCounter: %{public}hu",
1216 GET_ENCRYPT_AVRCP_ADDR(rawAddr), scope, uid, uidCounter);
1217
1218 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtAtnpPacket>(scope, uid, uidCounter);
1219 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1220 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_ADD_TO_NOW_PLAYING);
1221 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1222 }
1223
ReceiveAddToNowPlayingRsp(const RawAddress & rawAddr,Packet * pkt)1224 void AvrcCtProfile::ReceiveAddToNowPlayingRsp(const RawAddress &rawAddr, Packet *pkt)
1225 {
1226 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1227
1228 SendNextVendorCmd(rawAddr);
1229
1230 AvrcCtAtnpPacket packet(pkt);
1231
1232 int result = RET_BAD_STATUS;
1233 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1234 result = BT_SUCCESS;
1235 }
1236
1237 myObserver_->onAddToNowPlaying(rawAddr, result, packet.GetStatus());
1238 }
1239
SendSetAbsoluteVolumeCmd(const RawAddress & rawAddr,uint8_t volume)1240 void AvrcCtProfile::SendSetAbsoluteVolumeCmd(const RawAddress &rawAddr, uint8_t volume)
1241 {
1242 HILOGI("address: %{public}s, volume: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), volume);
1243
1244 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtSavPacket>(volume);
1245 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1246 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_SET_ABSOLUTE_VOLUME);
1247 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1248 }
1249
ReceiveSetAbsoluteVolumeRsp(const RawAddress & rawAddr,Packet * pkt)1250 void AvrcCtProfile::ReceiveSetAbsoluteVolumeRsp(const RawAddress &rawAddr, Packet *pkt)
1251 {
1252 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1253
1254 SendNextVendorCmd(rawAddr);
1255
1256 AvrcCtSavPacket packet(pkt);
1257 myObserver_->onSetAbsoluteVolume(rawAddr, packet.GetAbsoluteVolume(), ExplainCrCodeToResult(packet.GetCrCode()));
1258 }
1259
EnableNotification(const RawAddress & rawAddr,const std::vector<uint8_t> & events,uint32_t interval)1260 void AvrcCtProfile::EnableNotification(const RawAddress &rawAddr, const std::vector<uint8_t> &events, uint32_t interval)
1261 {
1262 HILOGI("address: %{public}s, events.size: %{public}zu", GET_ENCRYPT_AVRCP_ADDR(rawAddr), events.size());
1263
1264 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1265 for (auto event : events) {
1266 cnManager->EnableNotifyState(rawAddr, event);
1267
1268 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtNotifyPacket>(event);
1269 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_REGISTER_NOTIFICATION);
1270 }
1271 }
1272
DisableNotification(const RawAddress & rawAddr,const std::vector<uint8_t> & events)1273 void AvrcCtProfile::DisableNotification(const RawAddress &rawAddr, const std::vector<uint8_t> &events)
1274 {
1275 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1276
1277 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1278 for (auto event : events) {
1279 cnManager->DisableNotifyState(rawAddr, event);
1280 }
1281 }
1282
ReceiveRegisterNotificationRsp(const RawAddress & rawAddr,Packet * pkt)1283 void AvrcCtProfile::ReceiveRegisterNotificationRsp(const RawAddress &rawAddr, Packet *pkt)
1284 {
1285 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1286
1287 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1288 std::shared_ptr<AvrcCtNotifyPacket> notifyPkt = std::make_shared<AvrcCtNotifyPacket>(pkt);
1289 uint8_t crCode = notifyPkt->GetCrCode();
1290 bool supported = false;
1291 if (cnManager->IsNotifyStateEnabled(rawAddr, notifyPkt->GetEventId()) &&
1292 crCode != AVRC_CT_RSP_CODE_NOT_IMPLEMENTED) {
1293 supported = true;
1294 }
1295
1296 int result = AVRC_ES_CODE_NO_ERROR;
1297 if (crCode == AVRC_CT_RSP_CODE_CHANGED) {
1298 result = AVRC_ES_CODE_NOTIFICATION_CHANGED;
1299 }
1300 if (crCode == AVRC_CT_RSP_CODE_REJECTED) {
1301 result = AVRC_ES_CODE_INTERNAL_ERROR;
1302 }
1303
1304 if ((notifyPkt->GetPacketType() == AVRC_CT_VENDOR_PACKET_TYPE ||
1305 notifyPkt->GetPacketType() == AVRC_CT_VENDOR_PACKET_TYPE_END)) {
1306 SendNextVendorCmd(rawAddr);
1307 }
1308 if (supported && (crCode == AVRC_CT_RSP_CODE_INTERIM)) {
1309 InformNotificationChanged(rawAddr, notifyPkt, result);
1310 }
1311
1312 if (supported && crCode == AVRC_CT_RSP_CODE_CHANGED) {
1313 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtNotifyPacket>(notifyPkt->GetEventId());
1314 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_REGISTER_NOTIFICATION);
1315 }
1316 }
1317
InformNotificationChanged(const RawAddress & rawAddr,const std::shared_ptr<AvrcCtNotifyPacket> & notifyPkt,int result)1318 void AvrcCtProfile::InformNotificationChanged(
1319 const RawAddress &rawAddr, const std::shared_ptr<AvrcCtNotifyPacket> ¬ifyPkt, int result)
1320 {
1321 HILOGI("address: %{public}s, result: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), result);
1322
1323 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1324
1325 switch (notifyPkt->GetEventId()) {
1326 case AVRC_CT_EVENT_ID_PLAYBACK_STATUS_CHANGED:
1327 myObserver_->onPlaybackStatusChanged(rawAddr, notifyPkt->GetPlayStatus(), result);
1328 break;
1329 case AVRC_CT_EVENT_ID_TRACK_CHANGED:
1330 myObserver_->onTrackChanged(rawAddr, notifyPkt->GetUid(), result);
1331 break;
1332 case AVRC_CT_EVENT_ID_TRACK_REACHED_END:
1333 myObserver_->onTrackReachedEnd(rawAddr, result);
1334 break;
1335 case AVRC_CT_EVENT_ID_TRACK_REACHED_START:
1336 myObserver_->onTrackReachedStart(rawAddr, result);
1337 break;
1338 case AVRC_CT_EVENT_ID_PLAYBACK_POS_CHANGED:
1339 myObserver_->onPlaybackPosChanged(rawAddr, notifyPkt->GetPlaybackPosition(), result);
1340 break;
1341 case AVRC_CT_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED:
1342 myObserver_->onNowPlayingContentChanged(rawAddr, result);
1343 break;
1344 case AVRC_CT_EVENT_ID_AVAILABLE_PLAYERS_CHANGED:
1345 myObserver_->onAvailablePlayersChanged(rawAddr, result);
1346 break;
1347 case AVRC_CT_EVENT_ID_ADDRESSED_PLAYER_CHANGED:
1348 cnManager->SetUidCounter(rawAddr, notifyPkt->GetUidCounter());
1349 myObserver_->onAddressedPlayerChanged(
1350 rawAddr, notifyPkt->GetPlayerId(), notifyPkt->GetUidCounter(), result);
1351 break;
1352 case AVRC_CT_EVENT_ID_UIDS_CHANGED:
1353 cnManager->SetUidCounter(rawAddr, notifyPkt->GetUidCounter());
1354 myObserver_->onUidChanged(rawAddr, notifyPkt->GetUidCounter(), result);
1355 break;
1356 case AVRC_CT_EVENT_ID_VOLUME_CHANGED:
1357 myObserver_->onVolumeChanged(rawAddr, notifyPkt->GetAbsoluteVolume(), result);
1358 break;
1359 case AVRC_CT_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED:
1360 InformPlayerApplicationSettingChanged(rawAddr, notifyPkt, result);
1361 break;
1362 default:
1363 HILOGI("The event id is wrong! event: %{public}d", notifyPkt->GetEventId());
1364 break;
1365 }
1366 }
1367
InformPlayerApplicationSettingChanged(const RawAddress & rawAddr,const std::shared_ptr<AvrcCtNotifyPacket> & notifyPkt,int result)1368 void AvrcCtProfile::InformPlayerApplicationSettingChanged(
1369 const RawAddress &rawAddr, const std::shared_ptr<AvrcCtNotifyPacket> ¬ifyPkt, int result)
1370 {
1371 HILOGI("address: %{public}s, result: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), result);
1372
1373 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1374
1375 if (notifyPkt->GetPacketType() == AVRC_CT_VENDOR_PACKET_TYPE_START ||
1376 notifyPkt->GetPacketType() == AVRC_CT_VENDOR_PACKET_TYPE_CONTINUE) {
1377 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorContinuePacket(rawAddr);
1378 if (packet == nullptr) {
1379 packet = notifyPkt;
1380 }
1381
1382 if (packet->GetReceivedFragments() >= maxFragments_) {
1383 SendVendorAbortCmd(rawAddr, notifyPkt->GetPduId());
1384 myObserver_->onVolumeChanged(rawAddr, notifyPkt->GetAbsoluteVolume(), result);
1385 } else {
1386 cnManager->SetVendorContinuePacket(rawAddr, packet);
1387 SendVendorContinueCmd(rawAddr, notifyPkt->GetPduId());
1388 }
1389 } else {
1390 myObserver_->onPlayerApplicationSettingChanged(
1391 rawAddr, notifyPkt->GetAttributes(), notifyPkt->GetValues(), result);
1392 }
1393 }
1394
ReceiveVendorRspAvcStatus(const RawAddress & rawAddr,Packet * pkt)1395 void AvrcCtProfile::ReceiveVendorRspAvcStatus(const RawAddress &rawAddr, Packet *pkt)
1396 {
1397 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1398
1399 switch (AvrcCtPacket::GetVendorPdu(pkt)) {
1400 case AVRC_CT_PDU_ID_GET_CAPABILITIES:
1401 ReceiveGetCapabilitiesRsp(rawAddr, pkt);
1402 break;
1403 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES:
1404 ReceiveListPlayerApplicationSettingAttributesRsp(rawAddr, pkt);
1405 break;
1406 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES:
1407 ReceiveListPlayerApplicationSettingValuesRsp(rawAddr, pkt);
1408 break;
1409 case AVRC_CT_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:
1410 ReceiveGetCurrentPlayerApplicationSettingValueRsp(rawAddr, pkt);
1411 break;
1412 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT:
1413 ReceiveGetPlayerApplicationSettingAttributeTextRsp(rawAddr, pkt);
1414 break;
1415 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT:
1416 ReceiveGetPlayerApplicationSettingValueTextRsp(rawAddr, pkt);
1417 break;
1418 case AVRC_CT_PDU_ID_GET_ELEMENT_ATTRIBUTES:
1419 ReceiveGetElementAttributesRsp(rawAddr, pkt);
1420 break;
1421 case AVRC_CT_PDU_ID_GET_PLAY_STATUS:
1422 ReceiveGetPlayStatusRsp(rawAddr, pkt);
1423 break;
1424 default:
1425 break;
1426 }
1427 }
1428
ReceiveVendorRspAvcControl(const RawAddress & rawAddr,Packet * pkt)1429 void AvrcCtProfile::ReceiveVendorRspAvcControl(const RawAddress &rawAddr, Packet *pkt)
1430 {
1431 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1432
1433 switch (AvrcCtPacket::GetVendorPdu(pkt)) {
1434 case AVRC_CT_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE:
1435 ReceiveSetPlayerApplicationSettingValueRsp(rawAddr, pkt);
1436 break;
1437 case AVRC_CT_PDU_ID_ABORT_CONTINUING_RESPONSE:
1438 ReceiveAbortContinuingResponseRsp(rawAddr, pkt);
1439 break;
1440 case AVRC_CT_PDU_ID_SET_ADDRESSED_PLAYER:
1441 ReceiveSetAddressedPlayerRsp(rawAddr, pkt);
1442 break;
1443 case AVRC_CT_PDU_ID_PLAY_ITEM:
1444 ReceivePlayItemRsp(rawAddr, pkt);
1445 break;
1446 case AVRC_CT_PDU_ID_ADD_TO_NOW_PLAYING:
1447 ReceiveAddToNowPlayingRsp(rawAddr, pkt);
1448 break;
1449 case AVRC_CT_PDU_ID_SET_ABSOLUTE_VOLUME:
1450 ReceiveSetAbsoluteVolumeRsp(rawAddr, pkt);
1451 break;
1452 default:
1453 break;
1454 }
1455 }
1456
ReceiveVendorRsp(const RawAddress & rawAddr,Packet * pkt)1457 void AvrcCtProfile::ReceiveVendorRsp(const RawAddress &rawAddr, Packet *pkt)
1458 {
1459 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1460
1461 switch (AvrcCtPacket::GetVendorPdu(pkt)) {
1462 case AVRC_CT_PDU_ID_GET_CAPABILITIES:
1463 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES:
1464 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES:
1465 case AVRC_CT_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:
1466 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT:
1467 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT:
1468 case AVRC_CT_PDU_ID_GET_ELEMENT_ATTRIBUTES:
1469 case AVRC_CT_PDU_ID_GET_PLAY_STATUS:
1470 ReceiveVendorRspAvcStatus(rawAddr, pkt);
1471 break;
1472 case AVRC_CT_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE:
1473 case AVRC_CT_PDU_ID_ABORT_CONTINUING_RESPONSE:
1474 case AVRC_CT_PDU_ID_SET_ADDRESSED_PLAYER:
1475 case AVRC_CT_PDU_ID_PLAY_ITEM:
1476 case AVRC_CT_PDU_ID_ADD_TO_NOW_PLAYING:
1477 case AVRC_CT_PDU_ID_SET_ABSOLUTE_VOLUME:
1478 ReceiveVendorRspAvcControl(rawAddr, pkt);
1479 break;
1480 case AVRC_CT_PDU_ID_REGISTER_NOTIFICATION:
1481 ReceiveRegisterNotificationRsp(rawAddr, pkt);
1482 break;
1483 default:
1484 HILOGI("The PDU ID is wrong! Address: %{public}s, pduId: %{public}x",
1485 GET_ENCRYPT_AVRCP_ADDR(rawAddr), AvrcCtPacket::GetVendorPdu(pkt));
1486 break;
1487 }
1488 }
1489
ProcessVendorNotificationTimeout(RawAddress rawAddr)1490 void AvrcCtProfile::ProcessVendorNotificationTimeout(RawAddress rawAddr)
1491 {
1492 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1493
1494 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1495 AvrcCtNotifyPacket *pkt = static_cast<AvrcCtNotifyPacket *>(cnManager->GetVendorPacket(rawAddr).get());
1496 uint8_t event = pkt->GetEventId();
1497 if (cnManager->IsNotifyStateEnabled(rawAddr, event)) {
1498 std::shared_ptr<AvrcCtVendorPacket> packet = std::make_shared<AvrcCtNotifyPacket>(event);
1499 SendVendorCmd(rawAddr, packet, AVRC_CT_SM_EVENT_REGISTER_NOTIFICATION);
1500 }
1501 }
1502
ProcessVendorAvcControlTimeout(RawAddress rawAddr,const std::shared_ptr<AvrcCtVendorPacket> & packet)1503 void AvrcCtProfile::ProcessVendorAvcControlTimeout(RawAddress rawAddr, const std::shared_ptr<AvrcCtVendorPacket> &packet)
1504 {
1505 switch (packet->GetPduId()) {
1506 case AVRC_CT_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE: {
1507 myObserver_->onSetPlayerApplicationSettingValue(rawAddr, RET_BAD_STATUS);
1508 break;
1509 }
1510 case AVRC_CT_PDU_ID_REQUEST_CONTINUING_RESPONSE:
1511 /// FALL THROUGH
1512 case AVRC_CT_PDU_ID_ABORT_CONTINUING_RESPONSE: {
1513 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1514 std::shared_ptr<AvrcCtVendorPacket> pkt = cnManager->GetVendorContinuePacket(rawAddr);
1515 cnManager->SetVendorPacket(rawAddr, pkt);
1516 ProcessVendorTimeout(rawAddr);
1517 break;
1518 }
1519 case AVRC_CT_PDU_ID_SET_ADDRESSED_PLAYER: {
1520 myObserver_->onSetAddressedPlayer(rawAddr, RET_BAD_STATUS, AVRC_ES_CODE_INTERNAL_ERROR);
1521 break;
1522 }
1523 case AVRC_CT_PDU_ID_PLAY_ITEM: {
1524 AvrcCtPiPacket *pkt = static_cast<AvrcCtPiPacket *>(packet.get());
1525 myObserver_->onPlayItem(rawAddr, pkt->GetStatus(), RET_BAD_STATUS);
1526 break;
1527 }
1528 case AVRC_CT_PDU_ID_SET_ABSOLUTE_VOLUME: {
1529 AvrcCtSavPacket *pkt = static_cast<AvrcCtSavPacket *>(packet.get());
1530 myObserver_->onSetAbsoluteVolume(rawAddr, pkt->GetAbsoluteVolume(), RET_BAD_STATUS);
1531 break;
1532 }
1533 case AVRC_CT_PDU_ID_ADD_TO_NOW_PLAYING: {
1534 myObserver_->onAddToNowPlaying(rawAddr, RET_BAD_STATUS, AVRC_ES_CODE_INTERNAL_ERROR);
1535 break;
1536 }
1537 default:
1538 break;
1539 }
1540 }
1541
ProcessVendorAvcStatus1Timeout(RawAddress rawAddr,const std::shared_ptr<AvrcCtVendorPacket> & packet)1542 void AvrcCtProfile::ProcessVendorAvcStatus1Timeout(RawAddress rawAddr, const std::shared_ptr<AvrcCtVendorPacket> &packet)
1543 {
1544 switch (packet->GetPduId()) {
1545 case AVRC_CT_PDU_ID_GET_CAPABILITIES: {
1546 AvrcCtGcPacket *gcPkt = static_cast<AvrcCtGcPacket *>(packet.get());
1547 myObserver_->onGetCapabilities(rawAddr, gcPkt->GetCompanies(), gcPkt->GetEvents(), RET_BAD_STATUS);
1548 break;
1549 }
1550 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES: {
1551 AvrcCtLpasaPacket *pkt = static_cast<AvrcCtLpasaPacket *>(packet.get());
1552 myObserver_->onListPlayerApplicationSettingAttributes(rawAddr, pkt->GetAttributes(), RET_BAD_STATUS);
1553 break;
1554 }
1555 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES: {
1556 AvrcCtLpasvPacket *pkt = static_cast<AvrcCtLpasvPacket *>(packet.get());
1557 myObserver_->onListPlayerApplicationSettingValues(
1558 rawAddr, pkt->GetAttribute(), pkt->GetValues(), RET_BAD_STATUS);
1559 break;
1560 }
1561 case AVRC_CT_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE: {
1562 AvrcCtGcpasvPacket *pkt = static_cast<AvrcCtGcpasvPacket *>(packet.get());
1563 myObserver_->onGetCurrentPlayerApplicationSettingValue(
1564 rawAddr, pkt->GetAttributes(), pkt->GetValues(), RET_BAD_STATUS);
1565 break;
1566 }
1567
1568 default:
1569 break;
1570 }
1571 }
1572
ProcessVendorAvcStatus2Timeout(RawAddress rawAddr,const std::shared_ptr<AvrcCtVendorPacket> & packet)1573 void AvrcCtProfile::ProcessVendorAvcStatus2Timeout(RawAddress rawAddr, const std::shared_ptr<AvrcCtVendorPacket> &packet)
1574 {
1575 switch (packet->GetPduId()) {
1576 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT: {
1577 AvrcCtGpasatPacket *gpasatPkt = static_cast<AvrcCtGpasatPacket *>(packet.get());
1578 myObserver_->onGetPlayerApplicationSettingAttributeText(
1579 rawAddr, gpasatPkt->GetAttributes(), gpasatPkt->GetAttributeName(), RET_BAD_STATUS);
1580 break;
1581 }
1582 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT: {
1583 AvrcCtGpasvtPacket *gpasvtPkt = static_cast<AvrcCtGpasvtPacket *>(packet.get());
1584 myObserver_->onGetPlayerApplicationSettingAttributeText(
1585 rawAddr, gpasvtPkt->GetValues(), gpasvtPkt->GetValueName(), RET_BAD_STATUS);
1586 break;
1587 }
1588 case AVRC_CT_PDU_ID_GET_ELEMENT_ATTRIBUTES: {
1589 AvrcCtGeaPacket *geaPkt = static_cast<AvrcCtGeaPacket *>(packet.get());
1590 myObserver_->onGetElementAttributes(rawAddr, geaPkt->GetAttributes(), geaPkt->GetValues(), RET_BAD_STATUS);
1591 break;
1592 }
1593 case AVRC_CT_PDU_ID_GET_PLAY_STATUS: {
1594 AvrcCtGpsPacket *pkt = static_cast<AvrcCtGpsPacket *>(packet.get());
1595 myObserver_->onGetPlayStatus(
1596 rawAddr, pkt->GetSongLength(), pkt->GetSongPosition(), pkt->GetPlayStatus(), RET_BAD_STATUS);
1597 break;
1598 }
1599 default:
1600 break;
1601 }
1602 }
1603
ProcessVendorTimeout(RawAddress rawAddr)1604 void AvrcCtProfile::ProcessVendorTimeout(RawAddress rawAddr)
1605 {
1606 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1607
1608 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1609
1610 if (IsEnabled()) {
1611 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorPacket(rawAddr);
1612 if (packet != nullptr) {
1613 switch (packet->GetPduId()) {
1614 case AVRC_CT_PDU_ID_GET_CAPABILITIES:
1615 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES:
1616 case AVRC_CT_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES:
1617 case AVRC_CT_PDU_ID_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:
1618 ProcessVendorAvcStatus1Timeout(rawAddr, packet);
1619 break;
1620 case AVRC_CT_PDU_ID_SET_PLAYER_APPLICATION_SETTING_VALUE:
1621 case AVRC_CT_PDU_ID_REQUEST_CONTINUING_RESPONSE:
1622 /// FALL THROUGH
1623 case AVRC_CT_PDU_ID_ABORT_CONTINUING_RESPONSE:
1624 case AVRC_CT_PDU_ID_SET_ADDRESSED_PLAYER:
1625 case AVRC_CT_PDU_ID_PLAY_ITEM:
1626 case AVRC_CT_PDU_ID_SET_ABSOLUTE_VOLUME:
1627 case AVRC_CT_PDU_ID_ADD_TO_NOW_PLAYING:
1628 ProcessVendorAvcControlTimeout(rawAddr, packet);
1629 break;
1630 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT:
1631 case AVRC_CT_PDU_ID_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT:
1632 case AVRC_CT_PDU_ID_GET_ELEMENT_ATTRIBUTES:
1633 case AVRC_CT_PDU_ID_GET_PLAY_STATUS:
1634 ProcessVendorAvcStatus2Timeout(rawAddr, packet);
1635 break;
1636 case AVRC_CT_PDU_ID_REGISTER_NOTIFICATION: {
1637 ProcessVendorNotificationTimeout(rawAddr);
1638 break;
1639 }
1640 default:
1641 HILOGI("The PDU ID is wrong! Address: %{public}s, pduId: %{public}x",
1642 GET_ENCRYPT_AVRCP_ADDR(rawAddr), packet->GetPduId());
1643 break;
1644 }
1645 } else {
1646 HILOGI("The saved packet is nullptr! Address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1647 }
1648
1649 SendNextVendorCmd(rawAddr);
1650 }
1651 }
1652
VendorTimeoutCallback(const RawAddress & rawAddr)1653 void AvrcCtProfile::VendorTimeoutCallback(const RawAddress &rawAddr)
1654 {
1655 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1656
1657 if (IsEnabled()) {
1658 dispatcher_->PostTask(std::bind(&AvrcCtProfile::ProcessVendorTimeout, this, rawAddr));
1659 }
1660 }
1661
1662 /******************************************************************
1663 * BROWSING COMMAND *
1664 ******************************************************************/
1665
SendBrowseCmd(const RawAddress & rawAddr,const std::shared_ptr<AvrcCtBrowsePacket> & pkt,AvrcCtSmEvent event)1666 void AvrcCtProfile::SendBrowseCmd(
1667 const RawAddress &rawAddr, const std::shared_ptr<AvrcCtBrowsePacket> &pkt, AvrcCtSmEvent event)
1668 {
1669 HILOGI("address: %{public}s, event%{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), event);
1670
1671 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1672 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
1673
1674 if (!smManager->IsBrowsePendingState(rawAddr)) {
1675 cnManager->ClearBrowseInfo(rawAddr);
1676 cnManager->SetBrowsePacket(rawAddr, pkt);
1677
1678 utility::Message msg(event);
1679 AvrcCtStateMachineManager::GetInstance()->SendMessageToBrowseStateMachine(rawAddr, msg);
1680
1681 auto func = std::bind(&AvrcCtProfile::BrowseTimeoutCallback, this, rawAddr);
1682 cnManager->SetBrowseTimer(rawAddr, func, AVRC_CT_TIMER_T_MTP);
1683 } else {
1684 if (cnManager->GetSizeOfBrowseQueue(rawAddr) > AVRC_CT_DEFAULT_SIZE_OF_QUEUE) {
1685 HILOGI("The queue is oversize: %{public}d", cnManager->GetSizeOfBrowseQueue(rawAddr));
1686 } else {
1687 cnManager->PushBrowseQueue(rawAddr, pkt);
1688 HILOGI("Waiting for the response! Address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1689 }
1690 }
1691 }
1692
SendNextBrowseCmd(const RawAddress & rawAddr)1693 void AvrcCtProfile::SendNextBrowseCmd(const RawAddress &rawAddr)
1694 {
1695 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1696
1697 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1698 cnManager->ClearBrowseInfo(rawAddr);
1699
1700 utility::Message msg(AVRC_CT_SM_EVENT_TO_CONNECTED_STATE);
1701 AvrcCtStateMachineManager::GetInstance()->SendMessageToBrowseStateMachine(rawAddr, msg);
1702
1703 if (cnManager->GetSizeOfBrowseQueue(rawAddr) != 0x00) {
1704 std::shared_ptr<AvrcCtBrowsePacket> packet = cnManager->PopBrowseQueue(rawAddr);
1705 AvrcCtSmEvent event = static_cast<AvrcCtSmEvent>(packet->GetPduId());
1706
1707 SendBrowseCmd(rawAddr, packet, event);
1708 }
1709 }
1710
IsBrowseQueueFull(const RawAddress & rawAddr)1711 bool AvrcCtProfile::IsBrowseQueueFull(const RawAddress &rawAddr)
1712 {
1713 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1714 std::lock_guard<std::recursive_mutex> lock(mutex_);
1715
1716 return (AvrcCtConnectManager::GetInstance()->GetSizeOfBrowseQueue(rawAddr) == AVRC_CT_DEFAULT_SIZE_OF_QUEUE);
1717 }
1718
IsDisableAbsoluteVolume(const RawAddress & rawAddr)1719 bool AvrcCtProfile::IsDisableAbsoluteVolume(const RawAddress &rawAddr)
1720 {
1721 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1722 std::lock_guard<std::recursive_mutex> lock(mutex_);
1723
1724 return AvrcCtConnectManager::GetInstance()->IsDisableAbsoluteVolume(rawAddr);
1725 }
1726
IsBrowsingConnected(const RawAddress & rawAddr)1727 bool AvrcCtProfile::IsBrowsingConnected(const RawAddress &rawAddr)
1728 {
1729 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1730 std::lock_guard<std::recursive_mutex> lock(mutex_);
1731
1732 return AvrcCtConnectManager::GetInstance()->IsBrowsingConnected(rawAddr);
1733 }
1734
SendSetBrowsedPlayerCmd(const RawAddress & rawAddr,uint16_t playerId)1735 void AvrcCtProfile::SendSetBrowsedPlayerCmd(const RawAddress &rawAddr, uint16_t playerId)
1736 {
1737 HILOGI("address: %{public}s, playerId: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), playerId);
1738
1739 std::shared_ptr<AvrcCtBrowsePacket> packet = std::make_shared<AvrcCtSbpPacket>(playerId);
1740 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1741 SendBrowseCmd(rawAddr, packet, AVRC_CT_SM_EVENT_SET_BROWSED_PLAYER);
1742 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1743 }
1744
ReceiveSetBrowsedPlayerRsp(const RawAddress & rawAddr,Packet * pkt) const1745 void AvrcCtProfile::ReceiveSetBrowsedPlayerRsp(const RawAddress &rawAddr, Packet *pkt) const
1746 {
1747 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1748
1749 AvrcCtSbpPacket packet(pkt);
1750
1751 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1752 cnManager->SetUidCounter(rawAddr, packet.GetUidCounter());
1753
1754 int result = RET_BAD_STATUS;
1755 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1756 result = BT_SUCCESS;
1757 }
1758
1759 myObserver_->onSetBrowsedPlayer(
1760 rawAddr, packet.GetUidCounter(), packet.GetNumOfItems(), packet.GetFolderNames(), result, packet.GetStatus());
1761 }
1762
SendChangePathCmd(const RawAddress & rawAddr,uint16_t uidCounter,uint8_t direction,uint64_t folderUid)1763 void AvrcCtProfile::SendChangePathCmd(
1764 const RawAddress &rawAddr, uint16_t uidCounter, uint8_t direction, uint64_t folderUid)
1765 {
1766 HILOGI("address: %{public}s, uidCounter: %{public}d, direction: %{public}x, folderUid: %{public}jx",
1767 GET_ENCRYPT_AVRCP_ADDR(rawAddr), uidCounter, direction, folderUid);
1768
1769 std::shared_ptr<AvrcCtBrowsePacket> packet = std::make_shared<AvrcCtCpPacket>(uidCounter, direction, folderUid);
1770 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1771 SendBrowseCmd(rawAddr, packet, AVRC_CT_SM_EVENT_CHANGE_PATH);
1772 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1773 }
1774
ReceiveChangePathRsp(const RawAddress & rawAddr,Packet * pkt) const1775 void AvrcCtProfile::ReceiveChangePathRsp(const RawAddress &rawAddr, Packet *pkt) const
1776 {
1777 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1778
1779 AvrcCtCpPacket packet(pkt);
1780
1781 int result = RET_BAD_STATUS;
1782 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1783 result = BT_SUCCESS;
1784 }
1785
1786 myObserver_->onChangePath(rawAddr, packet.GetNumOfItems(), result, packet.GetStatus());
1787 }
1788
SendGetFolderItemsCmd(const RawAddress & rawAddr,uint8_t scope,uint32_t startItem,uint32_t endItem,const std::vector<uint32_t> & attributes)1789 void AvrcCtProfile::SendGetFolderItemsCmd(const RawAddress &rawAddr, uint8_t scope, uint32_t startItem,
1790 uint32_t endItem, const std::vector<uint32_t> &attributes)
1791 {
1792 HILOGI("addr:%{public}s, scope:%{public}d, startItem:%{public}d, endItem:%{public}d, attributes.size:%{public}zu",
1793 GET_ENCRYPT_AVRCP_ADDR(rawAddr), scope, startItem, endItem, attributes.size());
1794
1795 std::shared_ptr<AvrcCtBrowsePacket> packet =
1796 std::make_shared<AvrcCtGfiPacket>(scope, startItem, endItem, attributes);
1797 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1798 SendBrowseCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_ITEM_ATTRIBUTES);
1799 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1800 }
1801
ReceiveGetFolderItemsRsp(const RawAddress & rawAddr,Packet * pkt) const1802 void AvrcCtProfile::ReceiveGetFolderItemsRsp(const RawAddress &rawAddr, Packet *pkt) const
1803 {
1804 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1805
1806 AvrcCtGfiPacket packet(pkt);
1807
1808 int result = RET_BAD_STATUS;
1809 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1810 result = BT_SUCCESS;
1811 }
1812
1813 myObserver_->onGetFolderItems(rawAddr,
1814 packet.GetScope(),
1815 packet.GetUidCounter(),
1816 packet.GetMediaPlayers(),
1817 packet.GetMediaItems(),
1818 result,
1819 packet.GetStatus());
1820 }
1821
SendGetItemAttributesCmd(const RawAddress & rawAddr,uint8_t scope,uint64_t uid,uint16_t uidCounter,const std::vector<uint32_t> & attributes)1822 void AvrcCtProfile::SendGetItemAttributesCmd(const RawAddress &rawAddr, uint8_t scope, uint64_t uid,
1823 uint16_t uidCounter, const std::vector<uint32_t> &attributes)
1824 {
1825 HILOGI("addr: %{public}s, scope: %{public}x, uid: %{public}jx, uidCounter: %{public}hu",
1826 GET_ENCRYPT_AVRCP_ADDR(rawAddr), scope, uid, uidCounter);
1827
1828 std::shared_ptr<AvrcCtBrowsePacket> packet = std::make_shared<AvrcCtGiaPacket>(scope, uid, uidCounter, attributes);
1829 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1830 SendBrowseCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_ITEM_ATTRIBUTES);
1831 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1832 }
1833
ReceiveGetItemAttributesRsp(const RawAddress & rawAddr,Packet * pkt) const1834 void AvrcCtProfile::ReceiveGetItemAttributesRsp(const RawAddress &rawAddr, Packet *pkt) const
1835 {
1836 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1837
1838 AvrcCtGiaPacket packet(pkt);
1839
1840 int result = RET_BAD_STATUS;
1841 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1842 result = BT_SUCCESS;
1843 }
1844
1845 myObserver_->onGetItemAttributes(rawAddr, packet.GetAttributes(), packet.GetValues(), result, packet.GetStatus());
1846 }
1847
SendGetTotalNumberOfItemsCmd(const RawAddress & rawAddr,uint8_t scope)1848 void AvrcCtProfile::SendGetTotalNumberOfItemsCmd(const RawAddress &rawAddr, uint8_t scope)
1849 {
1850 HILOGI("address: %{public}s, scope: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), scope);
1851
1852 std::shared_ptr<AvrcCtBrowsePacket> packet = std::make_shared<AvrcCtGtnoiPacket>(scope);
1853 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
1854 SendBrowseCmd(rawAddr, packet, AVRC_CT_SM_EVENT_GET_TOTAL_NUMBER_OF_ITEMS);
1855 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
1856 }
1857
ReceiveGetTotalNumberOfItemsRsp(const RawAddress & rawAddr,Packet * pkt) const1858 void AvrcCtProfile::ReceiveGetTotalNumberOfItemsRsp(const RawAddress &rawAddr, Packet *pkt) const
1859 {
1860 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1861
1862 AvrcCtGtnoiPacket packet(pkt);
1863
1864 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
1865 cnManager->SetUidCounter(rawAddr, packet.GetUidCounter());
1866
1867 int result = RET_BAD_STATUS;
1868 if (packet.GetStatus() == AVRC_ES_CODE_NO_ERROR) {
1869 result = BT_SUCCESS;
1870 }
1871
1872 myObserver_->onGetTotalNumberOfItems(
1873 rawAddr, packet.GetUidCounter(), packet.GetNumOfItems(), result, packet.GetStatus());
1874 }
1875
ReceiveBrowseRsp(const RawAddress & rawAddr,Packet * pkt)1876 void AvrcCtProfile::ReceiveBrowseRsp(const RawAddress &rawAddr, Packet *pkt)
1877 {
1878 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1879
1880 SendNextBrowseCmd(rawAddr);
1881
1882 switch (AvrcCtPacket::GetBrowsePdu(pkt)) {
1883 case AVRC_CT_PDU_ID_SET_BROWSED_PLAYER:
1884 ReceiveSetBrowsedPlayerRsp(rawAddr, pkt);
1885 break;
1886 case AVRC_CT_PDU_ID_CHANGE_PATH:
1887 ReceiveChangePathRsp(rawAddr, pkt);
1888 break;
1889 case AVRC_CT_PDU_ID_GET_FOLDER_ITEMS:
1890 ReceiveGetFolderItemsRsp(rawAddr, pkt);
1891 break;
1892 case AVRC_CT_PDU_ID_GET_ITEM_ATTRIBUTES:
1893 ReceiveGetItemAttributesRsp(rawAddr, pkt);
1894 break;
1895 case AVRC_CT_PDU_ID_GET_TOTAL_NUMBER_OF_ITEMS:
1896 ReceiveGetTotalNumberOfItemsRsp(rawAddr, pkt);
1897 break;
1898 default:
1899 HILOGI("The PDU ID is wrong! Address: %{public}s, pduId: %{public}x",
1900 GET_ENCRYPT_AVRCP_ADDR(rawAddr), AvrcCtPacket::GetBrowsePdu(pkt));
1901 break;
1902 }
1903 }
1904
ProcessBrowseTimeout(RawAddress rawAddr)1905 void AvrcCtProfile::ProcessBrowseTimeout(RawAddress rawAddr)
1906 {
1907 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1908
1909 if (IsEnabled()) {
1910 std::shared_ptr<AvrcCtBrowsePacket> packet = AvrcCtConnectManager::GetInstance()->GetBrowsePacket(rawAddr);
1911 if (packet != nullptr) {
1912 switch (packet->GetPduId()) {
1913 case AVRC_CT_PDU_ID_SET_BROWSED_PLAYER: {
1914 AvrcCtSbpPacket *pkt = static_cast<AvrcCtSbpPacket *>(packet.get());
1915 myObserver_->onSetBrowsedPlayer(rawAddr,
1916 pkt->GetUidCounter(),
1917 0x00,
1918 pkt->GetFolderNames(),
1919 RET_BAD_STATUS,
1920 AVRC_ES_CODE_INTERNAL_ERROR);
1921 break;
1922 }
1923 case AVRC_CT_PDU_ID_CHANGE_PATH:
1924 myObserver_->onChangePath(rawAddr, 0x00, RET_BAD_STATUS, AVRC_ES_CODE_INTERNAL_ERROR);
1925 break;
1926 case AVRC_CT_PDU_ID_GET_FOLDER_ITEMS: {
1927 AvrcCtGfiPacket *pkt = static_cast<AvrcCtGfiPacket *>(packet.get());
1928 myObserver_->onGetFolderItems(rawAddr,
1929 pkt->GetScope(),
1930 pkt->GetUidCounter(),
1931 pkt->GetMediaPlayers(),
1932 pkt->GetMediaItems(),
1933 RET_BAD_STATUS,
1934 AVRC_ES_CODE_INTERNAL_ERROR);
1935 break;
1936 }
1937 case AVRC_CT_PDU_ID_GET_ITEM_ATTRIBUTES: {
1938 AvrcCtGiaPacket *pkt = static_cast<AvrcCtGiaPacket *>(packet.get());
1939 myObserver_->onGetItemAttributes(
1940 rawAddr, pkt->GetAttributes(), pkt->GetValues(), RET_BAD_STATUS, AVRC_ES_CODE_INTERNAL_ERROR);
1941 break;
1942 }
1943 case AVRC_CT_PDU_ID_GET_TOTAL_NUMBER_OF_ITEMS:
1944 myObserver_->onGetTotalNumberOfItems(
1945 rawAddr, 0x00, 0x00, RET_BAD_STATUS, AVRC_ES_CODE_INTERNAL_ERROR);
1946 break;
1947 default:
1948 HILOGI("The PDU ID is wrong! Address: %{public}s, pduId: %{public}x",
1949 GET_ENCRYPT_AVRCP_ADDR(rawAddr), packet->GetPduId());
1950 break;
1951 }
1952 }
1953 SendNextBrowseCmd(rawAddr);
1954 }
1955 }
1956
BrowseTimeoutCallback(const RawAddress & rawAddr)1957 void AvrcCtProfile::BrowseTimeoutCallback(const RawAddress &rawAddr)
1958 {
1959 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1960
1961 if (IsEnabled()) {
1962 dispatcher_->PostTask(std::bind(&AvrcCtProfile::ProcessBrowseTimeout, this, rawAddr));
1963 }
1964 }
1965
ProcessChannelEvent(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context) const1966 void AvrcCtProfile::ProcessChannelEvent(
1967 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context) const
1968 {
1969 HILOGI("Receive: %{public}s, connectId: %{public}d, Result: %{public}x, Address: %{public}s",
1970 GetEventName(event).c_str(), connectId, result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1971 switch (event) {
1972 case AVCT_CONNECT_IND_EVT:
1973 ProcessChannelEventConnectIndEvt(rawAddr, connectId, event, result, context);
1974 break;
1975 case AVCT_CONNECT_CFM_EVT:
1976 ProcessChannelEventConnectCfmEvt(rawAddr, connectId, event, result, context);
1977 break;
1978 case AVCT_DISCONNECT_IND_EVT:
1979 ProcessChannelEventDisconnectIndEvt(rawAddr, connectId, event, result, context);
1980 break;
1981 case AVCT_DISCONNECT_CFM_EVT:
1982 ProcessChannelEventDisconnectCfmEvt(rawAddr, connectId, event, result, context);
1983 break;
1984 case AVCT_BR_CONNECT_IND_EVT:
1985 ProcessChannelEventBrConnectIndEvt(rawAddr, connectId, event, result, context);
1986 break;
1987 case AVCT_BR_CONNECT_CFM_EVT:
1988 ProcessChannelEventBrConnectCfmEvt(rawAddr, connectId, event, result, context);
1989 break;
1990 case AVCT_BR_DISCONNECT_IND_EVT:
1991 DeleteBrowseStateMachine(rawAddr);
1992 break;
1993 case AVCT_BR_DISCONNECT_CFM_EVT:
1994 DeleteBrowseStateMachine(rawAddr);
1995 break;
1996 default:
1997 break;
1998 };
1999 }
2000
ProcessChannelEventConnectIndEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context) const2001 void AvrcCtProfile::ProcessChannelEventConnectIndEvt(
2002 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context) const
2003 {
2004 HILOGI("Receive: %{public}s, connectId: %{public}d, Result: %{public}x, Address: %{public}s",
2005 GetEventName(event).c_str(), connectId, result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2006
2007 result = ExpainAvctResult(result);
2008
2009 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
2010 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
2011 utility::Message msg(AVRC_CT_SM_EVENT_INVALID);
2012
2013 if (result == BT_SUCCESS) {
2014 bool absVolume =
2015 Compat::CompatCheck(bluetooth::CompatType::COMPAT_REJECT_ABSOLUTE_VOLUME, rawAddr.GetAddress());
2016 result |= cnManager->Add(rawAddr,
2017 connectId,
2018 AVCT_ACPT,
2019 controlMtu_,
2020 browseMtu_,
2021 companyId_,
2022 0x0000,
2023 absVolume,
2024 eventCallback_,
2025 msgCallback_);
2026 result |= smManager->AddControlStateMachine(rawAddr);
2027 if (result == BT_SUCCESS) {
2028 msg.what_ = AVRC_CT_SM_EVENT_TO_CONNECTED_STATE;
2029 AvrcCtStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
2030
2031 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
2032 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON, PROFILE_NAME_AVRCP_CT, rawAddr);
2033 }
2034 }
2035 }
2036
ProcessChannelEventConnectCfmEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context) const2037 void AvrcCtProfile::ProcessChannelEventConnectCfmEvt(
2038 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context) const
2039 {
2040 HILOGI("Receive: %{public}s, connectId: %{public}d, Result: %{public}x, Address: %{public}s",
2041 GetEventName(event).c_str(), connectId, result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2042
2043 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
2044 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
2045 utility::Message msg(AVRC_CT_SM_EVENT_INVALID);
2046
2047 if (result == BT_SUCCESS) {
2048 cnManager->SetConnectId(rawAddr, connectId);
2049
2050 msg.what_ = AVRC_CT_SM_EVENT_TO_CONNECTED_STATE;
2051 smManager->SendMessageToControlStateMachine(rawAddr, msg);
2052
2053 if (IsSupportedBrowsing() && cnManager->IsBrowsingSupported(rawAddr)) {
2054 ConnectBr(rawAddr);
2055 }
2056 cnManager->DeleteDisconnectedDevice(rawAddr.GetAddress());
2057 if (!(IsSupportedBrowsing() && cnManager->IsBrowsingSupported(rawAddr))) {
2058 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
2059 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON, PROFILE_NAME_AVRCP_CT, rawAddr);
2060 }
2061 } else {
2062 DeleteResource(rawAddr);
2063 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
2064 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_CT, rawAddr);
2065 }
2066 }
2067
ProcessChannelEventDisconnectIndEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context) const2068 void AvrcCtProfile::ProcessChannelEventDisconnectIndEvt(
2069 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context) const
2070 {
2071 HILOGI("Receive: %{public}s, connectId: %{public}d, Result: %{public}x, Address: %{public}s",
2072 GetEventName(event).c_str(), connectId, result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2073
2074 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
2075
2076 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTING));
2077 DeleteResource(rawAddr);
2078 cnManager->AddDisconnectedDevice(rawAddr.GetAddress());
2079 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
2080 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_CT, rawAddr);
2081 }
2082
ProcessChannelEventDisconnectCfmEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context) const2083 void AvrcCtProfile::ProcessChannelEventDisconnectCfmEvt(
2084 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context) const
2085 {
2086 HILOGI("Receive: %{public}s, connectId: %{public}d, Result: %{public}x, Address: %{public}s",
2087 GetEventName(event).c_str(), connectId, result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2088
2089 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
2090 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
2091 utility::Message msg(AVRC_CT_SM_EVENT_INVALID);
2092
2093 if (smManager->IsControlDisableState(rawAddr)) {
2094 DeleteResource(rawAddr);
2095 if (cnManager->IsConnectInfoEmpty()) {
2096 AvrcpCtSafeDelete(cnManager);
2097 smManager->ShutDown();
2098 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
2099 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_CT, rawAddr);
2100 myObserver_->onDisabled();
2101 }
2102 } else {
2103 DeleteResource(rawAddr);
2104 cnManager->AddDisconnectedDevice(rawAddr.GetAddress());
2105 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
2106 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_CT, rawAddr);
2107 }
2108 }
2109
ProcessChannelEventBrConnectIndEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context) const2110 void AvrcCtProfile::ProcessChannelEventBrConnectIndEvt(
2111 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context) const
2112 {
2113 HILOGI("Receive: %{public}s, connectId: %{public}d, Result: %{public}x, Address: %{public}s",
2114 GetEventName(event).c_str(), connectId, result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2115 result = ExpainAvctResult(result);
2116
2117 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
2118 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
2119 utility::Message msg(AVRC_CT_SM_EVENT_INVALID);
2120
2121 if (result == BT_SUCCESS) {
2122 result |= smManager->AddBrowseStateMachine(rawAddr);
2123 if (result == BT_SUCCESS) {
2124 msg.what_ = AVRC_CT_SM_EVENT_TO_CONNECTED_STATE;
2125 smManager->SendMessageToBrowseStateMachine(rawAddr, msg);
2126 cnManager->SetBrowsingState(rawAddr, true);
2127 }
2128 }
2129 if (IsSupportedBrowsing() && cnManager->IsBrowsingSupported(rawAddr)) {
2130 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
2131 }
2132 }
2133
ProcessChannelEventBrConnectCfmEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context) const2134 void AvrcCtProfile::ProcessChannelEventBrConnectCfmEvt(
2135 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context) const
2136 {
2137 HILOGI("Receive: %{public}s, connectId: %{public}d, Result: %{public}x, Address: %{public}s",
2138 GetEventName(event).c_str(), connectId, result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2139 AvrcCtStateMachineManager *smManager = AvrcCtStateMachineManager::GetInstance();
2140 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
2141 utility::Message msg(AVRC_CT_SM_EVENT_INVALID);
2142
2143 if (result == BT_SUCCESS) {
2144 msg.what_ = AVRC_CT_SM_EVENT_TO_CONNECTED_STATE;
2145 smManager->SendMessageToBrowseStateMachine(rawAddr, msg);
2146 cnManager->SetBrowsingState(rawAddr, true);
2147 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON, PROFILE_NAME_AVRCP_CT, rawAddr);
2148 } else {
2149 DeleteBrowseStateMachine(rawAddr);
2150 }
2151 if (IsSupportedBrowsing() && cnManager->IsBrowsingSupported(rawAddr)) {
2152 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
2153 }
2154 }
2155
ProcessChannelMessage(uint8_t connectId,uint8_t label,uint8_t crType,uint8_t chType,Packet * pkt,void * context)2156 void AvrcCtProfile::ProcessChannelMessage(
2157 uint8_t connectId, uint8_t label, uint8_t crType, uint8_t chType, Packet *pkt, void *context)
2158 {
2159 HILOGI("connectId: %{public}d, label: %{public}d, crType: %{public}d, chType: %{public}d",
2160 connectId, label, crType, chType);
2161
2162 RawAddress rawAddr = AvrcCtConnectManager::GetInstance()->GetRawAddress(connectId);
2163 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_CT, rawAddr);
2164
2165 if (chType == AVCT_DATA_CTRL) {
2166 uint8_t opCode = AvrcCtPacket::GetOpCode(pkt);
2167 HILOGI("opCode: %{public}x", opCode);
2168 switch (opCode) {
2169 case AVRC_CT_OP_CODE_PASS_THROUGH:
2170 ReceivePassRsp(rawAddr, pkt);
2171 break;
2172 case AVRC_CT_OP_CODE_UNIT_INFO:
2173 ReceiveUnitRsp(rawAddr, pkt);
2174 break;
2175 case AVRC_CT_OP_CODE_SUB_UNIT_INFO:
2176 ReceiveSubUnitRsp(rawAddr, pkt);
2177 break;
2178 case AVRC_CT_OP_CODE_VENDOR:
2179 ReceiveVendorRsp(rawAddr, pkt);
2180 break;
2181 default:
2182 HILOGI("opCode: %{public}x is wrong! ConnectId: %{public}x", opCode, connectId);
2183 break;
2184 }
2185 } else if (chType == AVCT_DATA_BR) {
2186 ReceiveBrowseRsp(rawAddr, pkt);
2187 } else {
2188 HILOGI("chType: %{public}x is wrong! ConnectId: %{public}x", chType, connectId);
2189 }
2190
2191 PacketFree(pkt);
2192 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_CT, rawAddr);
2193 }
2194
SetFeatures(const RawAddress & rawAddr,uint32_t features)2195 void AvrcCtProfile::SetFeatures(const RawAddress &rawAddr, uint32_t features)
2196 {
2197 AvrcCtConnectManager::GetInstance()->SetFeatures(rawAddr, features);
2198 }
2199
IsDeviceConnected(const RawAddress & rawAddr) const2200 bool AvrcCtProfile::IsDeviceConnected(const RawAddress &rawAddr) const
2201 {
2202 HILOGI("rawAddr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2203 return AvrcCtConnectManager::GetInstance()->GetConnectInfo(rawAddr) == nullptr ? false : true;
2204 }
2205
DeleteResource(const RawAddress & rawAddr)2206 void AvrcCtProfile::DeleteResource(const RawAddress &rawAddr)
2207 {
2208 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2209
2210 AvrcCtConnectManager::GetInstance()->Delete(rawAddr);
2211 AvrcCtStateMachineManager::GetInstance()->DeletePairOfStateMachine(rawAddr);
2212 }
2213
DeleteBrowseStateMachine(const RawAddress & rawAddr)2214 void AvrcCtProfile::DeleteBrowseStateMachine(const RawAddress &rawAddr)
2215 {
2216 HILOGI("address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2217
2218 AvrcCtStateMachineManager::GetInstance()->DeleteBrowseStateMachine(rawAddr);
2219 }
2220
ExpainAvctResult(uint16_t avctRet)2221 int AvrcCtProfile::ExpainAvctResult(uint16_t avctRet)
2222 {
2223 HILOGI("avctRet: %{public}d", avctRet);
2224 int result = RET_BAD_STATUS;
2225
2226 switch (avctRet) {
2227 case AVCT_SUCCESS:
2228 result = BT_SUCCESS;
2229 break;
2230 case AVCT_FAILED:
2231 /// FALL THROUGH
2232 default:
2233 /// Do nothing!
2234 break;
2235 }
2236
2237 return result;
2238 }
2239
ExpainPassCrCodeToResult(uint8_t code)2240 int AvrcCtProfile::ExpainPassCrCodeToResult(uint8_t code)
2241 {
2242 HILOGI("code: %{public}d", code);
2243 int result = RET_BAD_STATUS;
2244
2245 switch (code) {
2246 case AVRC_CT_RSP_CODE_ACCEPTED:
2247 /// FALL THROUGH
2248 case AVRC_CT_RSP_CODE_INTERIM:
2249 result = BT_SUCCESS;
2250 break;
2251 case AVRC_CT_RSP_CODE_NOT_IMPLEMENTED:
2252 result = RET_NO_SUPPORT;
2253 break;
2254 case AVRC_CT_RSP_CODE_REJECTED:
2255 /// FALL THROUGH
2256 default:
2257 /// Do nothing!
2258 break;
2259 }
2260
2261 return result;
2262 }
2263
ExplainCrCodeToResult(uint8_t crCode)2264 int AvrcCtProfile::ExplainCrCodeToResult(uint8_t crCode)
2265 {
2266 HILOGI("crCode: %{public}d", crCode);
2267 int result = RET_BAD_STATUS;
2268
2269 switch (crCode) {
2270 case AVRC_CT_RSP_CODE_ACCEPTED:
2271 case AVRC_CT_RSP_CODE_STABLE:
2272 case AVRC_CT_RSP_CODE_CHANGED:
2273 /// FALL THROUGH
2274 case AVRC_CT_RSP_CODE_INTERIM:
2275 result = BT_SUCCESS;
2276 break;
2277 case AVRC_CT_RSP_CODE_NOT_IMPLEMENTED:
2278 result = RET_NO_SUPPORT;
2279 break;
2280 case AVRC_CT_RSP_CODE_REJECTED:
2281 /// FALL THROUGH
2282 default:
2283 /// Do nothing!
2284 break;
2285 }
2286
2287 return result;
2288 }
2289
GetEventName(uint8_t event)2290 std::string AvrcCtProfile::GetEventName(uint8_t event)
2291 {
2292 switch (event) {
2293 case AVCT_CONNECT_IND_EVT:
2294 return "AVCT_CONNECT_IND_EVT";
2295 case AVCT_CONNECT_CFM_EVT:
2296 return "AVCT_CONNECT_CFM_EVT";
2297 case AVCT_DISCONNECT_IND_EVT:
2298 return "AVCT_DISCONNECT_IND_EVT";
2299 case AVCT_DISCONNECT_CFM_EVT:
2300 return "AVCT_DISCONNECT_CFM_EVT";
2301 case AVCT_BR_CONNECT_IND_EVT:
2302 return "AVCT_BR_CONNECT_IND_EVT";
2303 case AVCT_BR_CONNECT_CFM_EVT:
2304 return "AVCT_BR_CONNECT_CFM_EVT";
2305 case AVCT_BR_DISCONNECT_IND_EVT:
2306 return "AVCT_BR_DISCONNECT_IND_EVT";
2307 case AVCT_BR_DISCONNECT_CFM_EVT:
2308 return "AVCT_BR_DISCONNECT_CFM_EVT";
2309 default:
2310 return "Unknown";
2311 }
2312 }
2313 } // namespace bluetooth
2314 } // namespace OHOS
2315