1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "avrcp_tg_profile.h"
17 #include "avrcp_tg_browse.h"
18 #include "avrcp_tg_connection.h"
19 #include "avrcp_tg_notification.h"
20 #include "avrcp_tg_pass_through.h"
21 #include "avrcp_tg_sub_unit_info.h"
22 #include "avrcp_tg_unit_info.h"
23 #include "avrcp_tg_vendor.h"
24 #include "avrcp_tg_vendor_continuation.h"
25 #include "avrcp_tg_vendor_player_application_settings.h"
26 #include "power_manager.h"
27 #include "log_util.h"
28
29 namespace OHOS {
30 namespace bluetooth {
31 bool AvrcTgProfile::g_isEnabled = false;
32
AvrcTgProfile(uint16_t features,uint32_t companyId,uint16_t controlMtu,uint16_t browseMtu,utility::Dispatcher * dispatcher,AvctChannelEventCallback eventCallback,AvctMsgCallback msgCallback)33 AvrcTgProfile::AvrcTgProfile(uint16_t features, uint32_t companyId, uint16_t controlMtu, uint16_t browseMtu,
34 utility::Dispatcher *dispatcher, AvctChannelEventCallback eventCallback, AvctMsgCallback msgCallback)
35 : features_(features),
36 companyId_(companyId),
37 controlMtu_(controlMtu),
38 browseMtu_(browseMtu),
39 dispatcher_(dispatcher),
40 connectId_(0xFF),
41 eventCallback_(eventCallback),
42 msgCallback_(msgCallback)
43 {
44 HILOGI("features: %{public}d, companyId: %{public}u, controlMtu: %{public}d, browseMtu: %{public}d",
45 features, companyId, controlMtu, browseMtu);
46
47 SetEnableFlag(false);
48 playStatusChanged = std::make_pair(false, 0);
49 trackChanged = std::make_pair(false, 0);
50 }
51
~AvrcTgProfile()52 AvrcTgProfile::~AvrcTgProfile()
53 {
54 HILOGI("enter");
55
56 SetEnableFlag(false);
57 playStatusChanged = std::make_pair(false, 0);
58 trackChanged = std::make_pair(false, 0);
59 }
60
61 /******************************************************************
62 * REGISTER / UNREGISTER OBSERVER *
63 ******************************************************************/
64
RegisterObserver(AvrcTgProfile::Observer * observer)65 void AvrcTgProfile::RegisterObserver(AvrcTgProfile::Observer *observer)
66 {
67 HILOGI("enter");
68
69 myObserver_ = observer;
70 }
71
UnregisterObserver(void)72 void AvrcTgProfile::UnregisterObserver(void)
73 {
74 HILOGI("enter");
75
76 myObserver_ = nullptr;
77 }
78
79 /******************************************************************
80 * ENABLE / DISABLE *
81 ******************************************************************/
82
Enable(void)83 int AvrcTgProfile::Enable(void)
84 {
85 HILOGI("enter");
86
87 int result = BT_SUCCESS;
88
89 AVCT_Register(controlMtu_, browseMtu_, AVCT_TG);
90
91 AvctConnectParam param = {eventCallback_, msgCallback_, AVRC_TG_AV_REMOTE_CONTROL, AVCT_ACPT, nullptr};
92 BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
93 if (AVCT_ConnectReq(&connectId_, ¶m, &btAddr) != AVCT_SUCCESS) {
94 result = RET_BAD_STATUS;
95 } else {
96 SetEnableFlag(true);
97 }
98
99 return result;
100 }
101
Disable(void)102 int AvrcTgProfile::Disable(void)
103 {
104 HILOGI("enter");
105
106 do {
107 std::lock_guard<std::recursive_mutex> lock(mutex_);
108 SetEnableFlag(false);
109 } while (false);
110
111 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
112 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
113
114 if (!cnManager->IsConnectInfoEmpty()) {
115 utility::Message msg(AVRC_TG_SM_EVENT_TO_DISABLE_STATE);
116 smManager->SendMessageToAllBrowseStateMachine(msg);
117 smManager->SendMessageToAllControlStateMachine(msg);
118 } else {
119 AvrcpTgSafeDelete(cnManager);
120 smManager->ShutDown();
121 myObserver_->onDisabled();
122 }
123
124 return BT_SUCCESS;
125 }
126
SetEnableFlag(bool isEnabled)127 void AvrcTgProfile::SetEnableFlag(bool isEnabled)
128 {
129 HILOGI("isEnabled: %{public}d", isEnabled);
130
131 g_isEnabled = isEnabled;
132 }
133
134 /******************************************************************
135 * CONNECTION *
136 ******************************************************************/
137
SetActiveDevice(const RawAddress & rawAddr)138 void AvrcTgProfile::SetActiveDevice(const RawAddress &rawAddr)
139 {
140 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
141 std::lock_guard<std::recursive_mutex> lock(mutex_);
142
143 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
144
145 cnManager->SetActiveDevice(rawAddr.GetAddress());
146 }
147
GetConnectedDevices(void)148 std::vector<bluetooth::RawAddress> AvrcTgProfile::GetConnectedDevices(void)
149 {
150 HILOGI("enter");
151 std::lock_guard<std::recursive_mutex> lock(mutex_);
152
153 std::vector<bluetooth::RawAddress> result;
154
155 std::list<std::string> addrs = AvrcTgConnectManager::GetInstance()->GetDeviceAddresses();
156 for (auto &addr : addrs) {
157 RawAddress rawAddr(addr);
158 if (GetDeviceState(rawAddr) == static_cast<int>(BTConnectState::CONNECTED)) {
159 result.push_back(rawAddr);
160 }
161 }
162
163 return result;
164 }
165
GetDevicesByStates(const std::vector<int> & states)166 std::vector<RawAddress> AvrcTgProfile::GetDevicesByStates(const std::vector<int> &states)
167 {
168 HILOGI("enter");
169 std::lock_guard<std::recursive_mutex> lock(mutex_);
170
171 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
172
173 std::vector<RawAddress> rawAddrs;
174 std::list<std::string> addrs;
175
176 for (auto &state : states) {
177 if (state == static_cast<int>(BTConnectState::DISCONNECTED)) {
178 addrs = cnManager->GetAllDisconnectedDevices();
179 } else {
180 addrs = cnManager->GetDeviceAddresses();
181 }
182 for (auto &addr : addrs) {
183 RawAddress rawAddr(addr);
184 if (GetDeviceState(rawAddr) == state) {
185 rawAddrs.push_back(rawAddr);
186 }
187 }
188 }
189
190 return rawAddrs;
191 }
192
GetDeviceState(const RawAddress & rawAddr)193 int AvrcTgProfile::GetDeviceState(const RawAddress &rawAddr)
194 {
195 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
196 std::lock_guard<std::recursive_mutex> lock(mutex_);
197
198 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
199 int result;
200
201 if (smManager->IsControlConnectingState(rawAddr)) {
202 result = static_cast<int>(BTConnectState::CONNECTING);
203 } else if (smManager->IsControlConnectedState(rawAddr) || smManager->IsControlContinuationState(rawAddr)) {
204 result = static_cast<int>(BTConnectState::CONNECTED);
205 } else if (smManager->IsControlDisconnectingState(rawAddr)) {
206 result = static_cast<int>(BTConnectState::DISCONNECTING);
207 } else if (smManager->IsControlDisableState(rawAddr)) {
208 result = static_cast<int>(BTConnectState::DISCONNECTING);
209 } else {
210 result = static_cast<int>(BTConnectState::DISCONNECTED);
211 }
212
213 return result;
214 }
215
GetMaxConnectNum(void)216 int AvrcTgProfile::GetMaxConnectNum(void)
217 {
218 HILOGI("enter");
219 std::lock_guard<std::recursive_mutex> lock(mutex_);
220
221 int result = 0x00;
222
223 std::list<std::string> addrs = AvrcTgConnectManager::GetInstance()->GetDeviceAddresses();
224
225 for (auto &addr : addrs) {
226 RawAddress rawAddr(addr);
227 if (GetDeviceState(rawAddr) == static_cast<int>(BTConnectState::CONNECTED)) {
228 ++result;
229 }
230 }
231
232 return result;
233 }
234
Connect(const RawAddress & rawAddr) const235 int AvrcTgProfile::Connect(const RawAddress &rawAddr) const
236 {
237 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
238
239 uint8_t result = BT_SUCCESS;
240
241 result |= AvrcTgConnectManager::GetInstance()->Add(
242 rawAddr, 0x00, AVCT_INIT, controlMtu_, browseMtu_, companyId_, 0x0000, eventCallback_, msgCallback_);
243 result |= AvrcTgStateMachineManager::GetInstance()->AddControlStateMachine(rawAddr);
244 if (result == BT_SUCCESS) {
245 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTING));
246 }
247
248 return result;
249 }
250
ConnectBr(const RawAddress & rawAddr)251 int AvrcTgProfile::ConnectBr(const RawAddress &rawAddr)
252 {
253 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
254
255 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
256
257 return smManager->AddBrowseStateMachine(rawAddr);
258 }
259
Disconnect(const RawAddress & rawAddr) const260 int AvrcTgProfile::Disconnect(const RawAddress &rawAddr) const
261 {
262 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
263
264 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
265 utility::Message msg(AVRC_TG_SM_EVENT_TO_DISCONNECTING_STATE);
266 bool result = true;
267 result &= smManager->SendMessageToBrowseStateMachine(rawAddr, msg);
268 result &= smManager->SendMessageToControlStateMachine(rawAddr, msg);
269 if (result) {
270 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTING));
271 }
272
273 return BT_SUCCESS;
274 }
275
DisconnectBr(const RawAddress & rawAddr)276 int AvrcTgProfile::DisconnectBr(const RawAddress &rawAddr)
277 {
278 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
279
280 utility::Message msg(AVRC_TG_SM_EVENT_TO_DISCONNECTING_STATE);
281 AvrcTgStateMachineManager::GetInstance()->SendMessageToBrowseStateMachine(rawAddr, msg);
282
283 return BT_SUCCESS;
284 }
285
GetConnectState(void)286 int AvrcTgProfile::GetConnectState(void)
287 {
288 HILOGI("enter");
289 std::lock_guard<std::recursive_mutex> lock(mutex_);
290
291 int result = PROFILE_STATE_DISCONNECTED;
292
293 std::list<std::string> addrs = AvrcTgConnectManager::GetInstance()->GetDeviceAddresses();
294 for (auto &addr : addrs) {
295 RawAddress rawAddr(addr);
296 switch (static_cast<BTConnectState>(GetDeviceState(rawAddr))) {
297 case BTConnectState::CONNECTING:
298 result |= PROFILE_STATE_CONNECTING;
299 break;
300 case BTConnectState::CONNECTED:
301 result |= PROFILE_STATE_CONNECTED;
302 break;
303 case BTConnectState::DISCONNECTING:
304 result |= PROFILE_STATE_DISCONNECTING;
305 break;
306 case BTConnectState::DISCONNECTED:
307 /// FALL THROUGH
308 default:
309 result |= PROFILE_STATE_DISCONNECTED;
310 break;
311 }
312 }
313
314 return result;
315 }
316
AcceptPassiveConnect(const RawAddress & rawAddr)317 void AvrcTgProfile::AcceptPassiveConnect(const RawAddress &rawAddr)
318 {
319 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
320
321 utility::Message msg(AVRC_TG_SM_EVENT_TO_CONNECTED_STATE);
322 AvrcTgStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
323 }
324
RejectPassiveConnect(const RawAddress & rawAddr)325 void AvrcTgProfile::RejectPassiveConnect(const RawAddress &rawAddr)
326 {
327 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
328
329 AVCT_DisconnectReq(connectId_);
330 DeleteResource(rawAddr);
331 }
332
333 /******************************************************************
334 * PASS THROUGH COMMAND *
335 ******************************************************************/
336
SendPressButtonRsp(const RawAddress & rawAddr,uint8_t button,uint8_t label,int result)337 void AvrcTgProfile::SendPressButtonRsp(const RawAddress &rawAddr, uint8_t button, uint8_t label, int result)
338 {
339 HILOGI("rawAddr: %{public}s, button: %{public}d, label: %{public}d, result: %{public}d",
340 GET_ENCRYPT_AVRCP_ADDR(rawAddr), button, label, result);
341
342 std::shared_ptr<AvrcTgPassPacket> packet = std::make_shared<AvrcTgPassPacket>(button, AVRC_KEY_STATE_PRESS, label);
343 packet->SetCrCode(ExplainResultToPassCrCode(result));
344 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
345 SendPassRsp(rawAddr, packet);
346 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
347 }
348
SendReleaseButtonRsp(const RawAddress & rawAddr,uint8_t button,uint8_t label,int result)349 void AvrcTgProfile::SendReleaseButtonRsp(const RawAddress &rawAddr, uint8_t button, uint8_t label, int result)
350 {
351 HILOGI("rawAddr: %{public}s, button: %{public}d, label: %{public}d, result: %{public}d",
352 GET_ENCRYPT_AVRCP_ADDR(rawAddr), button, label, result);
353 std::shared_ptr<AvrcTgPassPacket> packet =
354 std::make_shared<AvrcTgPassPacket>(button, AVRC_KEY_STATE_RELEASE, label);
355 packet->SetCrCode(ExplainResultToPassCrCode(result));
356 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
357 SendPassRsp(rawAddr, packet);
358 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
359 }
360
IsEnabled(void)361 bool AvrcTgProfile::IsEnabled(void)
362 {
363 HILOGI("enter");
364
365 return g_isEnabled;
366 }
367
IsSamePassPressCommand(const RawAddress & rawAddr,uint8_t button)368 bool AvrcTgProfile::IsSamePassPressCommand(const RawAddress &rawAddr, uint8_t button)
369 {
370 HILOGI("rawAddr: %{public}s, button: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), button);
371
372 bool result = false;
373
374 std::shared_ptr<AvrcTgPassPacket> packet = AvrcTgConnectManager::GetInstance()->GetPassPacket(rawAddr);
375 do {
376 if (packet == nullptr) {
377 break;
378 }
379
380 if (packet->GetKeyOperation() != button) {
381 break;
382 }
383
384 if (packet->GetKeyState() != AVRC_KEY_STATE_PRESS) {
385 break;
386 }
387
388 result = true;
389 } while (false);
390
391 return result;
392 }
393
IsIgnorePassReleaseCommand(const RawAddress & rawAddr,uint8_t button)394 bool AvrcTgProfile::IsIgnorePassReleaseCommand(const RawAddress &rawAddr, uint8_t button)
395 {
396 HILOGI("rawAddr: %{public}s, button: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), button);
397
398 bool result = true;
399
400 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
401 std::shared_ptr<AvrcTgPassPacket> packet = cnManager->GetPassPacket(rawAddr);
402
403 do {
404 if (packet == nullptr) {
405 break;
406 }
407
408 if (packet->GetKeyOperation() != button) {
409 break;
410 }
411
412 if (packet->GetKeyState() != AVRC_KEY_STATE_PRESS) {
413 break;
414 }
415
416 if (cnManager->IsPassTimerEmpty(rawAddr)) {
417 break;
418 }
419
420 result = false;
421 } while (false);
422
423 return result;
424 }
425
SendPassRsp(const RawAddress & rawAddr,std::shared_ptr<AvrcTgPassPacket> & pkt)426 void AvrcTgProfile::SendPassRsp(const RawAddress &rawAddr, std::shared_ptr<AvrcTgPassPacket> &pkt)
427 {
428 HILOGI("rawAddr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
429
430 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
431
432 cnManager->ClearPassInfo(rawAddr);
433 cnManager->SetPassPacket(rawAddr, pkt);
434
435 utility::Message msg(AVRC_TG_SM_EVENT_PASS_THROUGH);
436 AvrcTgStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
437
438 /// If the target has not received the pressed command within two seconds or the target receives the
439 /// pressed command with another operation id, then the target regards that the released command was sent but
440 /// missed to receive.
441 /// @see AV/C Panel Subunit Specification 1.23 Section 9.4 PASS THROUGH control command.
442 if (pkt->GetCrCode() == AVRC_TG_RSP_CODE_ACCEPTED && pkt->GetKeyState() == AVRC_KEY_STATE_PRESS) {
443 /// Sets the information which is used in the timeout.
444 auto func = std::bind(&AvrcTgProfile::PassTimeoutCallback,
445 this,
446 rawAddr,
447 pkt->GetKeyOperation(),
448 pkt->GetKeyState(),
449 pkt->GetLabel());
450 cnManager->SetPassTimer(rawAddr, func, AVRC_TG_TIMER_PASS_THROUGH);
451 }
452 }
453
ReceivePassCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)454 void AvrcTgProfile::ReceivePassCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
455 {
456 HILOGI("rawAddr: %{public}s, label: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
457
458 std::shared_ptr<AvrcTgPassPacket> packet = std::make_shared<AvrcTgPassPacket>(pkt, label);
459 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
460
461 if (!packet->IsValid()) {
462 /// The packet is invalid, so send the reject frame directly.
463 SendPassRsp(rawAddr, packet);
464 return;
465 }
466
467 uint8_t key = packet->GetKeyOperation();
468 uint8_t state = packet->GetKeyState();
469
470 HILOGI("key: %{public}x, state: %{public}x, label: %{public}u", key, state, label);
471
472 switch (state) {
473 case AVRC_KEY_STATE_PRESS:
474 if (cnManager->IsPassTimerEmpty(rawAddr)) {
475 myObserver_->onButtonPressed(rawAddr, key, label);
476 break;
477 }
478
479 /// If the target receives the pressed command with another operation id, then the target regards
480 /// that the released command was sent but missed to receive.
481 if (!IsSamePassPressCommand(rawAddr, key)) {
482 /// Informs the previous button is released.
483 myObserver_->onButtonReleased(rawAddr, cnManager->GetPassPacket(rawAddr)->GetKeyOperation(), label);
484 /// Informs the current button is pressed.
485 myObserver_->onButtonPressed(rawAddr, key, label);
486 break;
487 }
488
489 /// A command with the pressed value is valid for two seconds from the time when a target sends
490 /// back a response of the command. The controller shall continue sending pressed value with
491 /// identical operation id value in the operation_id field while the command is wished to stay
492 /// valid.
493 myObserver_->onButtonHeld(rawAddr, key, label);
494 break;
495 case AVRC_KEY_STATE_RELEASE:
496 /// If the target has not received the pressed command within two seconds or the target receives
497 /// the pressed command with another operation id, then the target regards that the released command was
498 /// sent but missed to receive. In these cases, the target will ignore the released command when the
499 /// target receives this released command after the time out or reception of the new pressed command.
500 /// @see AV/C Panel Subunit Specification 1.23 Section 9.4 PASS THROUGH control command.
501 if (!IsIgnorePassReleaseCommand(rawAddr, key)) {
502 myObserver_->onButtonReleased(rawAddr, key, label);
503 break;
504 }
505
506 packet->SetCrCode(AVRC_TG_RSP_CODE_REJECTED);
507 SendPassRsp(rawAddr, packet);
508 HILOGI("The PASS THROUGH command is rejected! key: %{public}x state: %{public}x", state, label);
509 break;
510 default:
511 HILOGI("The key state is incorrect!");
512 break;
513 }
514 }
515
ProcessPassTimeout(RawAddress rawAddr,uint8_t button,uint8_t state,uint8_t label)516 void AvrcTgProfile::ProcessPassTimeout(RawAddress rawAddr, uint8_t button, uint8_t state, uint8_t label)
517 {
518 HILOGI("rawAddr: %{public}s, button: %{public}d, state: %{public}d, label: %{public}d",
519 GET_ENCRYPT_AVRCP_ADDR(rawAddr), button, state, label);
520
521 ASSERT(state == AVRC_KEY_STATE_PRESS);
522
523 if (IsEnabled()) {
524 AvrcTgConnectManager::GetInstance()->ClearPassInfo(rawAddr);
525 myObserver_->onButtonReleased(rawAddr, button, label);
526 }
527 }
528
PassTimeoutCallback(const RawAddress & rawAddr,uint8_t button,uint8_t state,uint8_t label)529 void AvrcTgProfile::PassTimeoutCallback(const RawAddress &rawAddr, uint8_t button, uint8_t state, uint8_t label)
530 {
531 HILOGI("rawAddr: %{public}s, button: %{public}d, state: %{public}d, label: %{public}d",
532 GET_ENCRYPT_AVRCP_ADDR(rawAddr), button, state, label);
533
534 if (IsEnabled()) {
535 dispatcher_->PostTask(std::bind(&AvrcTgProfile::ProcessPassTimeout, this, rawAddr, button, state, label));
536 }
537 }
538
539 /******************************************************************
540 * UNIT INFO / SUB UNIT INFO COMMAND *
541 ******************************************************************/
542
SendUnitRsp(const RawAddress & rawAddr,std::shared_ptr<AvrcTgUnitPacket> & pkt,AvrcTgSmEvent event)543 void AvrcTgProfile::SendUnitRsp(const RawAddress &rawAddr, std::shared_ptr<AvrcTgUnitPacket> &pkt, AvrcTgSmEvent event)
544 {
545 HILOGI("rawAddr: %{public}s, event: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), event);
546
547 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
548 cnManager->ClearUnitInfo(rawAddr);
549 cnManager->SetUnitPacket(rawAddr, pkt);
550
551 utility::Message msg(event);
552 AvrcTgStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
553 }
554
ReceiveUnitCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)555 void AvrcTgProfile::ReceiveUnitCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
556 {
557 HILOGI("rawAddr: %{public}s, label: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
558
559 std::shared_ptr<AvrcTgUnitPacket> packet = std::make_shared<AvrcTgUnitPacket>(pkt, label);
560
561 SendUnitRsp(rawAddr, packet, AVRC_TG_SM_EVENT_UNIT_INFO);
562 }
563
ReceiveSubUnitCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)564 void AvrcTgProfile::ReceiveSubUnitCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
565 {
566 HILOGI("rawAddr: %{public}s, label: %{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
567
568 std::shared_ptr<AvrcTgUnitPacket> packet = std::make_shared<AvrcTgSubUnitPacket>(pkt, label);
569
570 SendUnitRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SUB_UNIT_INFO);
571 }
572
573 /******************************************************************
574 * VENDOR COMMAND *
575 ******************************************************************/
576
SendVendorRsp(const RawAddress & rawAddr,std::shared_ptr<AvrcTgVendorPacket> & pkt,AvrcTgSmEvent event)577 void AvrcTgProfile::SendVendorRsp(
578 const RawAddress &rawAddr, std::shared_ptr<AvrcTgVendorPacket> &pkt, AvrcTgSmEvent event)
579 {
580 HILOGI("rawAddr: %{public}s, event: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), event);
581
582 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
583 cnManager->ClearVendorInfo(rawAddr);
584 cnManager->SetVendorPacket(rawAddr, pkt);
585
586 utility::Message msg(event);
587 AvrcTgStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
588 }
589
SendGetCapabilitiesRsp(const RawAddress & rawAddr,const std::vector<uint32_t> & companies,uint8_t label,int result)590 void AvrcTgProfile::SendGetCapabilitiesRsp(
591 const RawAddress &rawAddr, const std::vector<uint32_t> &companies, uint8_t label, int result)
592 {
593 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
594
595 std::shared_ptr<AvrcTgVendorPacket> packet =
596 std::make_shared<AvrcTgGcPacket>(ExplainResultToStatusCrCode(result), companies, label);
597 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_CAPABILITIES);
598 }
599
SendGetCapabilitiesRsp(const RawAddress & rawAddr,const std::vector<uint8_t> & events,uint8_t label,int result)600 void AvrcTgProfile::SendGetCapabilitiesRsp(
601 const RawAddress &rawAddr, const std::vector<uint8_t> &events, uint8_t label, int result)
602 {
603 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
604
605 std::shared_ptr<AvrcTgVendorPacket> packet =
606 std::make_shared<AvrcTgGcPacket>(ExplainResultToStatusCrCode(result), events, label);
607 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
608 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_CAPABILITIES);
609 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
610 }
611
ReceiveGetCapabilitiesCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)612 void AvrcTgProfile::ReceiveGetCapabilitiesCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
613 {
614 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
615
616 std::shared_ptr<AvrcTgGcPacket> gcPkt = std::make_shared<AvrcTgGcPacket>(pkt, label);
617
618 if (gcPkt->IsValid()) {
619 if (gcPkt->GetCapabilityId() == AVRC_CAPABILITY_COMPANYID) {
620 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
621 std::vector<uint32_t> companies;
622 companies.push_back(cnManager->GetCompanyId(rawAddr));
623
624 SendGetCapabilitiesRsp(rawAddr, companies, label, BT_SUCCESS);
625 } else {
626 myObserver_->getCapabilities(rawAddr, label);
627 }
628 } else {
629 std::shared_ptr<AvrcTgVendorPacket> packet = gcPkt;
630 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_CAPABILITIES);
631 }
632 }
633
SendListPlayerApplicationSettingAttributesRsp(const RawAddress & rawAddr,std::deque<uint8_t> attributes,uint8_t label,int result)634 void AvrcTgProfile::SendListPlayerApplicationSettingAttributesRsp(
635 const RawAddress &rawAddr, std::deque<uint8_t> attributes, uint8_t label, int result)
636 {
637 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
638
639 std::shared_ptr<AvrcTgVendorPacket> packet =
640 std::make_shared<AvrcTgLpasaPacket>(ExplainResultToStatusCrCode(result), attributes, label);
641 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
642 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES);
643 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
644 }
645
ReceiveListPlayerApplicationSettingAttributesCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)646 void AvrcTgProfile::ReceiveListPlayerApplicationSettingAttributesCmd(
647 const RawAddress &rawAddr, uint8_t label, Packet *pkt)
648 {
649 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
650
651 std::shared_ptr<AvrcTgLpasaPacket> lpasaPkt = std::make_shared<AvrcTgLpasaPacket>(pkt, label);
652
653 if (lpasaPkt->IsValid()) {
654 myObserver_->listPlayerApplicationSettingAttributes(rawAddr, label);
655 } else {
656 std::shared_ptr<AvrcTgVendorPacket> packet = lpasaPkt;
657 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_VALUES);
658 }
659 }
660
SendListPlayerApplicationSettingValuesRsp(const RawAddress & rawAddr,const std::deque<uint8_t> & values,uint8_t label,int result)661 void AvrcTgProfile::SendListPlayerApplicationSettingValuesRsp(
662 const RawAddress &rawAddr, const std::deque<uint8_t> &values, uint8_t label, int result)
663 {
664 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
665
666 std::shared_ptr<AvrcTgVendorPacket> packet =
667 std::make_shared<AvrcTgLpasvPacket>(ExplainResultToStatusCrCode(result), values, label);
668 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
669 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_VALUES);
670 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
671 }
672
ReceiveListPlayerApplicationSettingValuesCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)673 void AvrcTgProfile::ReceiveListPlayerApplicationSettingValuesCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
674 {
675 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
676
677 std::shared_ptr<AvrcTgLpasvPacket> lpasvPkt = std::make_shared<AvrcTgLpasvPacket>(pkt, label);
678
679 if (lpasvPkt->IsValid()) {
680 myObserver_->listPlayerApplicationSettingValues(rawAddr, lpasvPkt->GetAttribute(), label);
681 } else {
682 std::shared_ptr<AvrcTgVendorPacket> packet = lpasvPkt;
683 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_VALUES);
684 }
685 }
686
SendGetCurrentPlayerApplicationSettingValueRsp(const RawAddress & rawAddr,const std::deque<uint8_t> & attributes,const std::deque<uint8_t> & values,uint8_t label,int result)687 void AvrcTgProfile::SendGetCurrentPlayerApplicationSettingValueRsp(const RawAddress &rawAddr,
688 const std::deque<uint8_t> &attributes, const std::deque<uint8_t> &values, uint8_t label, int result)
689 {
690 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
691
692 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
693 std::shared_ptr<AvrcTgVendorPacket> packet = std::make_shared<AvrcTgGcpasvPacket>(
694 cnManager->GetControlMtu(rawAddr), ExplainResultToStatusCrCode(result), attributes, values, label);
695 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
696 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE);
697 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
698 }
699
ReceiveGetCurrentPlayerApplicationSettingValueCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)700 void AvrcTgProfile::ReceiveGetCurrentPlayerApplicationSettingValueCmd(
701 const RawAddress &rawAddr, uint8_t label, Packet *pkt)
702 {
703 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
704
705 std::shared_ptr<AvrcTgGcpasvPacket> gcpasvPkt = std::make_shared<AvrcTgGcpasvPacket>(pkt, label);
706
707 if (gcpasvPkt->IsValid()) {
708 myObserver_->getCurrentPlayerApplicationSettingValue(
709 rawAddr, gcpasvPkt->GetAttributes(), label, AVRC_ACTION_TYPE_GET_PLAYER_APP_SETTING_CURRENT_VALUE);
710 } else {
711 std::shared_ptr<AvrcTgVendorPacket> packet = gcpasvPkt;
712 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE);
713 }
714 }
715
SendSetPlayerApplicationSettingValueRsp(const RawAddress & rawAddr,uint8_t label,int result)716 void AvrcTgProfile::SendSetPlayerApplicationSettingValueRsp(const RawAddress &rawAddr, uint8_t label, int result)
717 {
718 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
719
720 std::shared_ptr<AvrcTgVendorPacket> packet =
721 std::make_shared<AvrcTgSpasvPacket>(ExplainResultToControlCrCode(result), label);
722 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
723 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_PLAYER_APPLICATION_SETTING_VALUE);
724 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
725 }
726
ReceiveSetPlayerApplicationSettingValueCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)727 void AvrcTgProfile::ReceiveSetPlayerApplicationSettingValueCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
728 {
729 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
730
731 std::shared_ptr<AvrcTgSpasvPacket> spasvPkt = std::make_shared<AvrcTgSpasvPacket>(pkt, label);
732 if (spasvPkt != nullptr) {
733 if (spasvPkt->IsValid()) {
734 myObserver_->setPlayerApplicationSettingValue(
735 rawAddr, spasvPkt->GetAttributes(), spasvPkt->GetValues(), label);
736 } else {
737 std::shared_ptr<AvrcTgVendorPacket> packet = spasvPkt;
738 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_PLAYER_APPLICATION_SETTING_VALUE);
739 }
740 }
741 }
742
SendGetPlayerApplicationSettingAttributeTextRsp(const RawAddress & rawAddr,const std::vector<uint8_t> & attributes,const std::vector<std::string> & attrStr,uint8_t label,int result)743 void AvrcTgProfile::SendGetPlayerApplicationSettingAttributeTextRsp(const RawAddress &rawAddr,
744 const std::vector<uint8_t> &attributes, const std::vector<std::string> &attrStr, uint8_t label, int result)
745 {
746 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
747
748 int crCode = ExplainResultToControlCrCode(result);
749 if (crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
750 crCode = AVRC_TG_RSP_CODE_STABLE;
751 }
752
753 std::shared_ptr<AvrcTgVendorPacket> packet =
754 std::make_shared<AvrcTgGpasatPacket>(crCode, attributes, attrStr, label);
755 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
756 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT);
757 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
758 }
759
ReceiveGetPlayerApplicationSettingAttributeTextCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)760 void AvrcTgProfile::ReceiveGetPlayerApplicationSettingAttributeTextCmd(
761 const RawAddress &rawAddr, uint8_t label, Packet *pkt)
762 {
763 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
764
765 std::shared_ptr<AvrcTgGpasatPacket> gpasatPkt = std::make_shared<AvrcTgGpasatPacket>(pkt, label);
766 if (gpasatPkt != nullptr) {
767 if (gpasatPkt->IsValid()) {
768 myObserver_->getPlayerApplicationSettingAttributeText(rawAddr, gpasatPkt->GetAttributes(), label);
769 } else {
770 std::shared_ptr<AvrcTgVendorPacket> packet = gpasatPkt;
771 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
772 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT);
773 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
774 }
775 }
776 }
777
SendGetPlayerApplicationSettingValueTextRsp(const RawAddress & rawAddr,const std::vector<uint8_t> & values,const std::vector<std::string> & valueStr,uint8_t label,int result)778 void AvrcTgProfile::SendGetPlayerApplicationSettingValueTextRsp(const RawAddress &rawAddr,
779 const std::vector<uint8_t> &values, const std::vector<std::string> &valueStr, uint8_t label, int result)
780 {
781 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
782
783 int crCode = ExplainResultToControlCrCode(result);
784 if (crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
785 crCode = AVRC_TG_RSP_CODE_STABLE;
786 }
787
788 std::shared_ptr<AvrcTgVendorPacket> packet = std::make_shared<AvrcTgGpasvtPacket>(crCode, values, valueStr, label);
789 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
790 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT);
791 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
792 }
793
ReceiveGetPlayerApplicationSettingValueTextCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)794 void AvrcTgProfile::ReceiveGetPlayerApplicationSettingValueTextCmd(
795 const RawAddress &rawAddr, uint8_t label, Packet *pkt)
796 {
797 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
798
799 std::shared_ptr<AvrcTgGpasvtPacket> gpasvtPkt = std::make_shared<AvrcTgGpasvtPacket>(pkt, label);
800
801 if (gpasvtPkt->IsValid()) {
802 myObserver_->getPlayerApplicationSettingValueText(
803 rawAddr, gpasvtPkt->GetAttributeId(), gpasvtPkt->GetValues(), label);
804 } else {
805 std::shared_ptr<AvrcTgVendorPacket> packet = gpasvtPkt;
806 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT);
807 }
808 }
809
SendGetElementAttributesRsp(const RawAddress & rawAddr,const std::vector<uint32_t> & attribtues,const std::vector<std::string> & values,uint8_t label,int result)810 void AvrcTgProfile::SendGetElementAttributesRsp(const RawAddress &rawAddr, const std::vector<uint32_t> &attribtues,
811 const std::vector<std::string> &values, uint8_t label, int result)
812 {
813 HILOGI("rawAddr:%{public}s, label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, result);
814 int crCode = ExplainResultToControlCrCode(result);
815 if (crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
816 crCode = AVRC_TG_RSP_CODE_STABLE;
817 }
818 std::shared_ptr<AvrcTgVendorPacket> packet = std::make_shared<AvrcTgGeaPacket>(crCode, attribtues, values, label);
819 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
820 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_ELEMENT_ATTRIBTUES);
821 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
822 }
823
ReceiveGetElementAttributesCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)824 void AvrcTgProfile::ReceiveGetElementAttributesCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
825 {
826 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
827
828 std::shared_ptr<AvrcTgGeaPacket> geaPkt = std::make_shared<AvrcTgGeaPacket>(pkt, label);
829 if (geaPkt != nullptr) {
830 if (geaPkt->IsValid()) {
831 myObserver_->getElementAttributes(rawAddr, geaPkt->GetIdentifier(), geaPkt->GetAttributes(), label);
832 } else {
833 std::shared_ptr<AvrcTgVendorPacket> packet = geaPkt;
834 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_ELEMENT_ATTRIBTUES);
835 }
836 }
837 }
838
SendGetPlayStatusRsp(const RawAddress & rawAddr,uint32_t songLength,uint32_t songPosition,uint8_t playStatus,uint8_t label,int result)839 void AvrcTgProfile::SendGetPlayStatusRsp(const RawAddress &rawAddr, uint32_t songLength, uint32_t songPosition,
840 uint8_t playStatus, uint8_t label, int result)
841 {
842 HILOGI("rawAddr:%{public}s, songLength:%{public}u, songPosition:%{public}u, playStatus:%{public}d, "
843 "label:%{public}d, result:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), songLength, songPosition, playStatus,
844 label, result);
845
846 std::shared_ptr<AvrcTgVendorPacket> packet = std::make_shared<AvrcTgGpsPacket>(
847 ExplainResultToStatusCrCode(result), songLength, songPosition, playStatus, label);
848 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
849 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_PLAY_STATUS);
850 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
851 }
852
ReceiveGetPlayStatusCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)853 void AvrcTgProfile::ReceiveGetPlayStatusCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
854 {
855 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
856
857 std::shared_ptr<AvrcTgGpsPacket> gpsPkt = std::make_shared<AvrcTgGpsPacket>(pkt, label);
858 if (gpsPkt != nullptr) {
859 if (gpsPkt->IsValid()) {
860 myObserver_->getPlayStatus(rawAddr, label, AVRC_ACTION_TYPE_GET_PLAY_STATUS);
861 } else {
862 std::shared_ptr<AvrcTgVendorPacket> packet = gpsPkt;
863 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_PLAY_STATUS);
864 }
865 }
866 }
867
ReceiveRequestContinuingResponseCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)868 void AvrcTgProfile::ReceiveRequestContinuingResponseCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
869 {
870 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
871
872 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
873 std::shared_ptr<AvrcTgRcrPacket> rcrPkt = std::make_shared<AvrcTgRcrPacket>(pkt, label);
874
875 std::shared_ptr<AvrcTgVendorPacket> packet = cnManager->GetVendorPacket(rawAddr);
876 uint16_t event = AVRC_TG_SM_EVENT_INVALID;
877
878 do {
879 if (packet == nullptr) {
880 cnManager->ClearVendorInfo(rawAddr);
881 event = AVRC_TG_SM_EVENT_TO_CONNECTED_STATE;
882 HILOGI("Receive the RequestContinuingResponse command, but the vendor packet is nullptr!");
883 break;
884 }
885
886 if (!AvrcTgStateMachineManager::GetInstance()->IsControlContinuationState(rawAddr)) {
887 cnManager->ClearVendorInfo(rawAddr);
888 event = AVRC_TG_SM_EVENT_TO_CONNECTED_STATE;
889 HILOGI("Receive the RequestContinuingResponse command, but current is not CONTINUATION!");
890 break;
891 }
892
893 if (packet->GetPduId() != rcrPkt->GetRequestContinuingPduId()) {
894 cnManager->ClearVendorInfo(rawAddr);
895 event = AVRC_TG_SM_EVENT_TO_CONNECTED_STATE;
896 HILOGI("Receive the AbortContinuingResponse command, but pdu id is incorrect! saved pduId: %{public}x, "
897 "received pduId: %{public}x", packet->GetPduId(), rcrPkt->GetRequestContinuingPduId());
898 break;
899 }
900
901 event = AVRC_TG_SM_EVENT_REQUEST_CONTINUING_RESPONSE;
902 } while (false);
903
904 utility::Message msg(event);
905 AvrcTgStateMachineManager::GetInstance()->SendMessageToControlStateMachine(rawAddr, msg);
906 }
907
ReceiveAbortContinuingResponseCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)908 void AvrcTgProfile::ReceiveAbortContinuingResponseCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
909 {
910 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
911
912 std::shared_ptr<AvrcTgAcrPacket> acrPkt = std::make_shared<AvrcTgAcrPacket>(pkt, label);
913 std::shared_ptr<AvrcTgVendorPacket> packet = AvrcTgConnectManager::GetInstance()->GetVendorPacket(rawAddr);
914
915 do {
916 if (packet == nullptr) {
917 acrPkt->SetCrCode(AVRC_TG_RSP_CODE_REJECTED);
918 HILOGI("Receive the AbortContinuingResponse command, but the vendor packet is nullptr!");
919 break;
920 }
921
922 if (!AvrcTgStateMachineManager::GetInstance()->IsControlContinuationState(rawAddr)) {
923 acrPkt->SetCrCode(AVRC_TG_RSP_CODE_REJECTED);
924 HILOGI("Receive the AbortContinuingResponse command, but current is not CONTINUATION!");
925 break;
926 }
927
928 if (packet->GetPduId() != acrPkt->GetRequestContinuingPduId()) {
929 acrPkt->SetCrCode(AVRC_TG_RSP_CODE_REJECTED);
930 HILOGI("Receive the AbortContinuingResponse command, but pdu id is incorrect! saved pduId: %{public}x, "
931 "received pduId: %{public}x", packet->GetPduId(), acrPkt->GetRequestContinuingPduId());
932 break;
933 }
934 } while (false);
935
936 packet = std::make_shared<AvrcTgAcrPacket>(acrPkt->GetRequestContinuingPduId(), label);
937
938 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_ABORT_CONTINUING_RESPONSE);
939 }
940
SendSetAddressedPlayerRsp(const RawAddress & rawAddr,int status,uint8_t label,int result)941 void AvrcTgProfile::SendSetAddressedPlayerRsp(const RawAddress &rawAddr, int status, uint8_t label, int result)
942 {
943 HILOGI("rawAddr:%{public}s, status:%{public}d, label:%{public}d, result:%{public}d",
944 GET_ENCRYPT_AVRCP_ADDR(rawAddr), status, label, result);
945
946 uint8_t crCode = ExplainResultToControlCrCode(result);
947 if (status != AVRC_ES_CODE_NO_ERROR) {
948 crCode = AVRC_TG_RSP_CODE_REJECTED;
949 }
950
951 std::shared_ptr<AvrcTgVendorPacket> packet = std::make_shared<AvrcTgSapPacket>(crCode, status, label);
952 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
953 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_ADDRESSED_PLAYER);
954 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
955 }
956
ReceiveSetAddressedPlayerCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)957 void AvrcTgProfile::ReceiveSetAddressedPlayerCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
958 {
959 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
960
961 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
962
963 std::shared_ptr<AvrcTgSapPacket> sapPkt = std::make_shared<AvrcTgSapPacket>(pkt, label);
964 if (sapPkt->IsValid()) {
965 myObserver_->setAddressedPlayer(rawAddr, sapPkt->GetPlayerId(), cnManager->GetUidCounter(rawAddr), label);
966 } else {
967 std::shared_ptr<AvrcTgVendorPacket> packet = sapPkt;
968 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_ADDRESSED_PLAYER);
969 }
970 }
971
SendPlayItemRsp(const RawAddress & rawAddr,int status,uint8_t label,int result)972 void AvrcTgProfile::SendPlayItemRsp(const RawAddress &rawAddr, int status, uint8_t label, int result)
973 {
974 HILOGI("rawAddr:%{public}s, status:%{public}d, label:%{public}d, result:%{public}d",
975 GET_ENCRYPT_AVRCP_ADDR(rawAddr), status, label, result);
976
977 uint8_t crCode = ExplainResultToControlCrCode(result);
978 if (status != AVRC_ES_CODE_NO_ERROR) {
979 crCode = AVRC_TG_RSP_CODE_REJECTED;
980 }
981
982 std::shared_ptr<AvrcTgVendorPacket> packet = std::make_shared<AvrcTgPiPacket>(crCode, status, label);
983 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
984 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_PLAY_ITEM);
985 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
986 }
987
ReceivePlayItemCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)988 void AvrcTgProfile::ReceivePlayItemCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
989 {
990 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
991
992 std::shared_ptr<AvrcTgPiPacket> piPkt = std::make_shared<AvrcTgPiPacket>(pkt, label);
993 if (piPkt->IsValid()) {
994 myObserver_->playItem(rawAddr, piPkt->GetScope(), piPkt->GetUid(), piPkt->GetUidCounter(), label);
995 } else {
996 std::shared_ptr<AvrcTgVendorPacket> packet = piPkt;
997 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_PLAY_ITEM);
998 }
999 }
1000
SendAddToNowPlayingRsp(const RawAddress & rawAddr,int status,uint8_t label,int result)1001 void AvrcTgProfile::SendAddToNowPlayingRsp(const RawAddress &rawAddr, int status, uint8_t label, int result)
1002 {
1003 HILOGI("rawAddr:%{public}s, status:%{public}d, label:%{public}d, result:%{public}d",
1004 GET_ENCRYPT_AVRCP_ADDR(rawAddr), status, label, result);
1005
1006 uint8_t crCode = ExplainResultToControlCrCode(result);
1007 if (status != AVRC_ES_CODE_NO_ERROR) {
1008 crCode = AVRC_TG_RSP_CODE_REJECTED;
1009 }
1010
1011 std::shared_ptr<AvrcTgVendorPacket> packet = std::make_shared<AvrcTgAtnpPacket>(crCode, status, label);
1012 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1013 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_ADD_TO_NOW_PLAYING);
1014 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1015 }
1016
ReceiveAddToNowPlayingCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1017 void AvrcTgProfile::ReceiveAddToNowPlayingCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1018 {
1019 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1020
1021 std::shared_ptr<AvrcTgAtnpPacket> atnpPkt = std::make_shared<AvrcTgAtnpPacket>(pkt, label);
1022 if (atnpPkt->IsValid()) {
1023 myObserver_->addToNowPlaying(rawAddr, atnpPkt->GetScope(), atnpPkt->GetUid(), atnpPkt->GetUidCounter(), label);
1024 } else {
1025 std::shared_ptr<AvrcTgVendorPacket> packet = atnpPkt;
1026 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_ADD_TO_NOW_PLAYING);
1027 }
1028 }
1029
SendSetAbsoluteVolumeRsp(const RawAddress & rawAddr,uint8_t volume,uint8_t label,int result)1030 void AvrcTgProfile::SendSetAbsoluteVolumeRsp(const RawAddress &rawAddr, uint8_t volume, uint8_t label, int result)
1031 {
1032 HILOGI("rawAddr:%{public}s, volume:%{public}d, label:%{public}d, result:%{public}d",
1033 GET_ENCRYPT_AVRCP_ADDR(rawAddr), volume, label, result);
1034
1035 std::shared_ptr<AvrcTgVendorPacket> packet =
1036 std::make_shared<AvrcTgSavPacket>(ExplainResultToControlCrCode(result), volume, label);
1037 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1038 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_ABSOLUTE_VOLUME);
1039 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1040 }
1041
ReceiveSetAbsoluteVolumeCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1042 void AvrcTgProfile::ReceiveSetAbsoluteVolumeCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1043 {
1044 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1045
1046 std::shared_ptr<AvrcTgSavPacket> savPkt = std::make_shared<AvrcTgSavPacket>(pkt, label);
1047 if (savPkt->IsValid()) {
1048 myObserver_->setAbsoluteVolume(rawAddr, savPkt->GetAbsoluteVolume(), label);
1049 } else {
1050 std::shared_ptr<AvrcTgVendorPacket> packet = savPkt;
1051 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_ABSOLUTE_VOLUME);
1052 }
1053 }
1054
SendPlaybackStatusChangedRsp(bool isInterim,uint8_t playStatus,uint8_t label,int result)1055 void AvrcTgProfile::SendPlaybackStatusChangedRsp(bool isInterim, uint8_t playStatus, uint8_t label, int result)
1056 {
1057 HILOGI("isInterim:%{public}d, playStatus:%{public}d, label:%{public}d, result:%{public}d",
1058 isInterim, playStatus, label, result);
1059
1060 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1061 RawAddress rawAddr(cnManager->GetActiveDevice());
1062
1063 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED)) {
1064 uint8_t crCode = ExplainResultToControlCrCode(result);
1065 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1066 crCode = AVRC_TG_RSP_CODE_INTERIM;
1067 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1068 crCode = AVRC_TG_RSP_CODE_CHANGED;
1069 }
1070
1071 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1072 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED, crCode, label);
1073 notifyPkt->InitPlaybackStatusChanged(playStatus);
1074 notifyPkt->AssemblePackets();
1075 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1076 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1077 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1078 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1079
1080 if (!isInterim) {
1081 playStatusChanged = std::make_pair(false, 0);
1082 }
1083 }
1084
1085 if (!isInterim) {
1086 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED);
1087 }
1088 }
1089
SendTrackChangedRsp(bool isInterim,uint64_t identifier,uint8_t label,int result)1090 void AvrcTgProfile::SendTrackChangedRsp(bool isInterim, uint64_t identifier, uint8_t label, int result)
1091 {
1092 HILOGI("isInterim:%{public}d, identifier:%{public}llu, label:%{public}d, result:%{public}d",
1093 isInterim, static_cast<unsigned long long>(identifier), label, result);
1094 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1095 RawAddress rawAddr(cnManager->GetActiveDevice());
1096
1097 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_TRACK_CHANGED)) {
1098 uint8_t crCode = ExplainResultToControlCrCode(result);
1099 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1100 crCode = AVRC_TG_RSP_CODE_INTERIM;
1101 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1102 crCode = AVRC_TG_RSP_CODE_CHANGED;
1103 }
1104
1105 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1106 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_TRACK_CHANGED, crCode, label);
1107 notifyPkt->InitTrackChanged(identifier);
1108 notifyPkt->AssemblePackets();
1109 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1110 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1111 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1112 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1113 }
1114
1115 if (!isInterim) {
1116 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_TRACK_CHANGED);
1117 }
1118 }
1119
SendTrackReachedEndRsp(bool isInterim,uint8_t label,int result)1120 void AvrcTgProfile::SendTrackReachedEndRsp(bool isInterim, uint8_t label, int result)
1121 {
1122 HILOGI("isInterim:%{public}d, label:%{public}d, result:%{public}d", isInterim, label, result);
1123 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1124 RawAddress rawAddr(cnManager->GetActiveDevice());
1125
1126 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_TRACK_REACHED_END)) {
1127 uint8_t crCode = ExplainResultToControlCrCode(result);
1128 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1129 crCode = AVRC_TG_RSP_CODE_INTERIM;
1130 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1131 crCode = AVRC_TG_RSP_CODE_CHANGED;
1132 }
1133
1134 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1135 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_TRACK_REACHED_END, crCode, label);
1136 notifyPkt->AssemblePackets();
1137 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1138 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1139 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1140 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1141 }
1142
1143 if (!isInterim) {
1144 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_TRACK_REACHED_END);
1145 }
1146 }
1147
SendTrackReachedStartRsp(bool isInterim,uint8_t label,int result)1148 void AvrcTgProfile::SendTrackReachedStartRsp(bool isInterim, uint8_t label, int result)
1149 {
1150 HILOGI("isInterim:%{public}d, label:%{public}d, result:%{public}d", isInterim, label, result);
1151
1152 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1153 RawAddress rawAddr(cnManager->GetActiveDevice());
1154
1155 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_TRACK_REACHED_START)) {
1156 uint8_t crCode = ExplainResultToControlCrCode(result);
1157 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1158 crCode = AVRC_TG_RSP_CODE_INTERIM;
1159 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1160 crCode = AVRC_TG_RSP_CODE_CHANGED;
1161 }
1162
1163 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1164 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_TRACK_REACHED_START, crCode, label);
1165 notifyPkt->AssemblePackets();
1166 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1167 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1168 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1169 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1170 }
1171
1172 if (!isInterim) {
1173 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_TRACK_REACHED_START);
1174 }
1175 }
1176
SendPlaybackPosChangedRsp(bool isInterim,uint32_t playbackPos,uint8_t label,int result)1177 void AvrcTgProfile::SendPlaybackPosChangedRsp(bool isInterim, uint32_t playbackPos, uint8_t label, int result)
1178 {
1179 HILOGI("isInterim:%{public}d, playbackPos:%{public}u, label:%{public}d, result:%{public}d",
1180 isInterim, playbackPos, label, result);
1181
1182 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1183 RawAddress rawAddr(cnManager->GetActiveDevice());
1184
1185 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED)) {
1186 uint8_t crCode = ExplainResultToControlCrCode(result);
1187 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1188 crCode = AVRC_TG_RSP_CODE_INTERIM;
1189 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1190 crCode = AVRC_TG_RSP_CODE_CHANGED;
1191 }
1192
1193 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1194 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED, crCode, label);
1195 notifyPkt->InitPlaybackPosChanged(playbackPos);
1196 notifyPkt->AssemblePackets();
1197 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1198 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1199 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1200 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1201 }
1202
1203 if (!isInterim) {
1204 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED);
1205 }
1206 }
1207
SendPlayerApplicationSettingChangedRsp(bool isInterim,const std::deque<uint8_t> & attributes,const std::deque<uint8_t> & values,uint8_t label,int result)1208 void AvrcTgProfile::SendPlayerApplicationSettingChangedRsp(
1209 bool isInterim, const std::deque<uint8_t> &attributes, const std::deque<uint8_t> &values, uint8_t label, int result)
1210 {
1211 HILOGI("isInterim:%{public}d, label:%{public}d, result:%{public}d", isInterim, label, result);
1212
1213 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1214 RawAddress rawAddr(cnManager->GetActiveDevice());
1215
1216 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED)) {
1217 uint8_t crCode = ExplainResultToControlCrCode(result);
1218 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1219 crCode = AVRC_TG_RSP_CODE_INTERIM;
1220 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1221 crCode = AVRC_TG_RSP_CODE_CHANGED;
1222 }
1223
1224 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1225 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED, crCode, label);
1226 notifyPkt->InitPlayerApplicationSettingChanged(attributes, values);
1227 notifyPkt->AssemblePackets();
1228 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1229 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1230 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1231 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1232 }
1233
1234 if (!isInterim) {
1235 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED);
1236 }
1237 }
1238
SendNowPlayingContentChangedRsp(bool isInterim,uint8_t label,int result)1239 void AvrcTgProfile::SendNowPlayingContentChangedRsp(bool isInterim, uint8_t label, int result)
1240 {
1241 HILOGI("isInterim:%{public}d, label:%{public}d, result:%{public}d", isInterim, label, result);
1242
1243 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1244 RawAddress rawAddr(cnManager->GetActiveDevice());
1245
1246 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED)) {
1247 uint8_t crCode = ExplainResultToControlCrCode(result);
1248 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1249 crCode = AVRC_TG_RSP_CODE_INTERIM;
1250 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1251 crCode = AVRC_TG_RSP_CODE_CHANGED;
1252 }
1253
1254 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1255 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED, crCode, label);
1256 notifyPkt->AssemblePackets();
1257 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1258 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1259 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1260 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1261 }
1262
1263 if (!isInterim) {
1264 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED);
1265 }
1266 }
1267
SendAvailablePlayersChangedRsp(bool isInterim,uint8_t label,int result)1268 void AvrcTgProfile::SendAvailablePlayersChangedRsp(bool isInterim, uint8_t label, int result)
1269 {
1270 HILOGI("isInterim:%{public}d, label:%{public}d, result:%{public}d", isInterim, label, result);
1271
1272 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1273 RawAddress rawAddr(cnManager->GetActiveDevice());
1274
1275 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED)) {
1276 uint8_t crCode = ExplainResultToControlCrCode(result);
1277 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1278 crCode = AVRC_TG_RSP_CODE_INTERIM;
1279 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1280 crCode = AVRC_TG_RSP_CODE_CHANGED;
1281 }
1282
1283 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1284 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED, crCode, label);
1285 notifyPkt->AssemblePackets();
1286 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1287 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1288 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1289 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1290 }
1291
1292 if (!isInterim) {
1293 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED);
1294 }
1295 }
1296
SendAddressedPlayerChangedRsp(bool isInterim,uint16_t playerId,uint16_t uidCounter,uint8_t label,int result)1297 void AvrcTgProfile::SendAddressedPlayerChangedRsp(
1298 bool isInterim, uint16_t playerId, uint16_t uidCounter, uint8_t label, int result)
1299 {
1300 HILOGI("isInterim:%{public}d, playerId:%{public}d, uidCounter:%{public}d, label:%{public}d, result:%{public}d",
1301 isInterim, playerId, uidCounter, label, result);
1302
1303 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1304 RawAddress rawAddr(cnManager->GetActiveDevice());
1305
1306 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED)) {
1307 uint8_t crCode = ExplainResultToControlCrCode(result);
1308 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1309 crCode = AVRC_TG_RSP_CODE_INTERIM;
1310 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1311 crCode = AVRC_TG_RSP_CODE_CHANGED;
1312 }
1313
1314 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1315 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED, crCode, label);
1316 notifyPkt->InitAddressedPlayerChanged(playerId, uidCounter);
1317 notifyPkt->AssemblePackets();
1318 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1319 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1320 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1321 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1322 }
1323
1324 if (!isInterim) {
1325 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED);
1326 }
1327 }
1328
SendUidsChangedRsp(bool isInterim,uint16_t uidCounter,uint8_t label,int result)1329 void AvrcTgProfile::SendUidsChangedRsp(bool isInterim, uint16_t uidCounter, uint8_t label, int result)
1330 {
1331 HILOGI("isInterim:%{public}d, uidCounter:%{public}d, label:%{public}d, result:%{public}d",
1332 isInterim, uidCounter, label, result);
1333 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1334 RawAddress rawAddr(cnManager->GetActiveDevice());
1335
1336 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_UIDS_CHANGED)) {
1337 uint8_t crCode = ExplainResultToControlCrCode(result);
1338 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1339 crCode = AVRC_TG_RSP_CODE_INTERIM;
1340 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1341 crCode = AVRC_TG_RSP_CODE_CHANGED;
1342 }
1343
1344 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1345 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_UIDS_CHANGED, crCode, label);
1346 notifyPkt->InitUidsChanged(uidCounter);
1347 notifyPkt->AssemblePackets();
1348 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1349 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1350 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1351 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1352 }
1353
1354 if (!isInterim) {
1355 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_UIDS_CHANGED);
1356 }
1357 }
1358
SendVolumeChangedRsp(bool isInterim,uint8_t volume,uint8_t label,int result)1359 void AvrcTgProfile::SendVolumeChangedRsp(bool isInterim, uint8_t volume, uint8_t label, int result)
1360 {
1361 HILOGI("isInterim:%{public}d, volume:%{public}d, label:%{public}d, result:%{public}d",
1362 isInterim, volume, label, result);
1363 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1364 RawAddress rawAddr(cnManager->GetActiveDevice());
1365
1366 if (cnManager->IsNotifyStateEnabled(rawAddr, AVRC_TG_EVENT_ID_VOLUME_CHANGED)) {
1367 uint8_t crCode = ExplainResultToControlCrCode(result);
1368 if (isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1369 crCode = AVRC_TG_RSP_CODE_INTERIM;
1370 } else if (!isInterim && crCode == AVRC_TG_RSP_CODE_ACCEPTED) {
1371 crCode = AVRC_TG_RSP_CODE_CHANGED;
1372 }
1373
1374 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt =
1375 std::make_shared<AvrcTgNotifyPacket>(AVRC_TG_EVENT_ID_VOLUME_CHANGED, crCode, label);
1376 notifyPkt->InitVolumeChanged(volume);
1377 notifyPkt->AssemblePackets();
1378 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1379 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1380 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1381 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1382 }
1383
1384 if (!isInterim) {
1385 cnManager->DisableNotifyState(rawAddr, AVRC_TG_EVENT_ID_VOLUME_CHANGED);
1386 }
1387 }
1388
ReceiveRegisterNotificationCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1389 void AvrcTgProfile::ReceiveRegisterNotificationCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1390 {
1391 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1392 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1393
1394 std::shared_ptr<AvrcTgNotifyPacket> notifyPkt = std::make_shared<AvrcTgNotifyPacket>(pkt, label);
1395 uint8_t event = notifyPkt->GetEventId();
1396 cnManager->EnableNotifyState(rawAddr, event);
1397 HILOGI("event:%{public}d", event);
1398 switch (event) {
1399 case AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED:
1400 if (notifyPkt->IsValid()) {
1401 SetNotificationLabel(AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED, label);
1402 myObserver_->getPlayStatus(rawAddr, label, AVRC_ACTION_TYPE_NOTIFY_PLAYBACK_STATUS_CHANGED);
1403 }
1404 break;
1405 case AVRC_TG_EVENT_ID_TRACK_CHANGED:
1406 if (notifyPkt->IsValid()) {
1407 SetNotificationLabel(AVRC_TG_EVENT_ID_TRACK_CHANGED, label);
1408 myObserver_->getSelectedTrack(rawAddr, label);
1409 }
1410 break;
1411 case AVRC_TG_EVENT_ID_TRACK_REACHED_END: {
1412 SetNotificationLabel(AVRC_TG_EVENT_ID_TRACK_REACHED_END, label);
1413 SendTrackReachedEndRsp(true, label, BT_SUCCESS);
1414 break;
1415 }
1416 case AVRC_TG_EVENT_ID_TRACK_REACHED_START:
1417 SetNotificationLabel(AVRC_TG_EVENT_ID_TRACK_REACHED_START, label);
1418 SendTrackReachedStartRsp(true, label, BT_SUCCESS);
1419 break;
1420 case AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED:
1421 if (notifyPkt->IsValid()) {
1422 SetNotificationLabel(AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED, label);
1423 myObserver_->setPlaybackInterval(rawAddr, notifyPkt->GetPlaybackInterval());
1424 myObserver_->getPlayStatus(rawAddr, label, AVRC_ACTION_TYPE_NOTIFY_PLAYBACK_POS_CHANGED);
1425 }
1426 break;
1427 case AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED:
1428 if (notifyPkt->IsValid()) {
1429 std::deque<uint8_t> attributes = {
1430 AVRC_PLAYER_ATTRIBUTE_EQUALIZER,
1431 AVRC_PLAYER_ATTRIBUTE_REPEAT,
1432 AVRC_PLAYER_ATTRIBUTE_SHUFFLE,
1433 AVRC_PLAYER_ATTRIBUTE_SCAN
1434 };
1435 SetNotificationLabel(AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED, label);
1436 myObserver_->getCurrentPlayerApplicationSettingValue(
1437 rawAddr, attributes, label, AVRC_ACTION_TYPE_NOTIFY_PLAYER_APPLICATION_SETTING_CHANGED);
1438 }
1439 break;
1440 case AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED:
1441 SetNotificationLabel(AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED, label);
1442 SendNowPlayingContentChangedRsp(true, label, BT_SUCCESS);
1443 break;
1444 case AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED:
1445 SetNotificationLabel(AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED, label);
1446 SendAvailablePlayersChangedRsp(true, label, BT_SUCCESS);
1447 break;
1448 case AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED:
1449 if (notifyPkt->IsValid()) {
1450 SetNotificationLabel(AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED, label);
1451 myObserver_->getAddressedPlayer(rawAddr, label);
1452 }
1453 break;
1454 case AVRC_TG_EVENT_ID_UIDS_CHANGED:
1455 if (notifyPkt->IsValid()) {
1456 SetNotificationLabel(AVRC_TG_EVENT_ID_UIDS_CHANGED, label);
1457 myObserver_->getUidCounter(rawAddr, label);
1458 }
1459 break;
1460 case AVRC_TG_EVENT_ID_VOLUME_CHANGED:
1461 if (notifyPkt->IsValid()) {
1462 SetNotificationLabel(AVRC_TG_EVENT_ID_VOLUME_CHANGED, label);
1463 myObserver_->getCurrentAbsoluteVolume(rawAddr, label);
1464 }
1465 break;
1466 default:
1467 std::shared_ptr<AvrcTgVendorPacket> packet = notifyPkt;
1468 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION);
1469 break;
1470 }
1471 }
1472
ReceiveVendorCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1473 void AvrcTgProfile::ReceiveVendorCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1474 {
1475 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1476 uint8_t pduId = AvrcTgPacket::GetVendorPdu(pkt);
1477 HILOGI("enter, pduId:%{public}d", pduId);
1478 switch (pduId) {
1479 case AVRC_TG_PDU_ID_GET_CAPABILITIES:
1480 ReceiveGetCapabilitiesCmd(rawAddr, label, pkt);
1481 break;
1482 case AVRC_TG_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES:
1483 ReceiveListPlayerApplicationSettingAttributesCmd(rawAddr, label, pkt);
1484 break;
1485 case AVRC_TG_PDU_ID_LIST_PLAYER_APPLICATION_SETTING_VALUES:
1486 ReceiveListPlayerApplicationSettingValuesCmd(rawAddr, label, pkt);
1487 break;
1488 case AVRC_TG_SM_EVENT_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:
1489 ReceiveGetCurrentPlayerApplicationSettingValueCmd(rawAddr, label, pkt);
1490 break;
1491 case AVRC_TG_SM_EVENT_SET_PLAYER_APPLICATION_SETTING_VALUE:
1492 ReceiveSetPlayerApplicationSettingValueCmd(rawAddr, label, pkt);
1493 break;
1494 case AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT:
1495 ReceiveGetPlayerApplicationSettingAttributeTextCmd(rawAddr, label, pkt);
1496 break;
1497 case AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT:
1498 ReceiveGetPlayerApplicationSettingValueTextCmd(rawAddr, label, pkt);
1499 break;
1500 case AVRC_TG_PDU_ID_GET_ELEMENT_ATTRIBUTES:
1501 ReceiveGetElementAttributesCmd(rawAddr, label, pkt);
1502 break;
1503 case AVRC_TG_PDU_ID_SET_ADDRESSED_PLAYER:
1504 ReceiveSetAddressedPlayerCmd(rawAddr, label, pkt);
1505 break;
1506 case AVRC_TG_PDU_ID_GET_PLAY_STATUS:
1507 ReceiveGetPlayStatusCmd(rawAddr, label, pkt);
1508 break;
1509 case AVRC_TG_PDU_ID_REQUEST_CONTINUING_RESPONSE:
1510 ReceiveRequestContinuingResponseCmd(rawAddr, label, pkt);
1511 break;
1512 case AVRC_TG_PDU_ID_ABORT_CONTINUING_RESPONSE:
1513 ReceiveAbortContinuingResponseCmd(rawAddr, label, pkt);
1514 break;
1515 case AVRC_TG_PDU_ID_PLAY_ITEM:
1516 ReceivePlayItemCmd(rawAddr, label, pkt);
1517 break;
1518 case AVRC_TG_PDU_ID_ADD_TO_NOW_PLAYING:
1519 ReceiveAddToNowPlayingCmd(rawAddr, label, pkt);
1520 break;
1521 case AVRC_TG_PDU_ID_SET_ABSOLUTE_VOLUME:
1522 ReceiveSetAbsoluteVolumeCmd(rawAddr, label, pkt);
1523 break;
1524 case AVRC_TG_PDU_ID_REGISTER_NOTIFICATION:
1525 ReceiveRegisterNotificationCmd(rawAddr, label, pkt);
1526 break;
1527 default:
1528 std::shared_ptr<AvrcTgVendorPacket> packet =
1529 std::make_shared<AvrcTgVendorPacket>(pduId, AVRC_ES_CODE_INVALID_COMMAND, label);
1530 SendVendorRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GENERAL_REJECT);
1531 HILOGI("The PDU ID is wrong! Address: %{public}s, pduId: %{public}x",
1532 GET_ENCRYPT_AVRCP_ADDR(rawAddr), pduId);
1533 break;
1534 }
1535 }
1536
1537 /******************************************************************
1538 * BROWSING COMMAND *
1539 ******************************************************************/
1540
SendBrowseRsp(const RawAddress & rawAddr,std::shared_ptr<AvrcTgBrowsePacket> & pkt,AvrcTgSmEvent event)1541 void AvrcTgProfile::SendBrowseRsp(
1542 const RawAddress &rawAddr, std::shared_ptr<AvrcTgBrowsePacket> &pkt, AvrcTgSmEvent event)
1543 {
1544 HILOGI("rawAddr:%{public}s, event:%{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), event);
1545
1546 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1547 cnManager->ClearBrowseInfo(rawAddr);
1548 cnManager->SetBrowsePacket(rawAddr, pkt);
1549
1550 utility::Message msg(event);
1551 AvrcTgStateMachineManager::GetInstance()->SendMessageToBrowseStateMachine(rawAddr, msg);
1552 }
1553
SendSetBrowsedPlayerRsp(const RawAddress & rawAddr,uint16_t uidCounter,uint32_t numOfItems,const std::vector<std::string> & folderNames,uint8_t label,int status)1554 void AvrcTgProfile::SendSetBrowsedPlayerRsp(const RawAddress &rawAddr, uint16_t uidCounter, uint32_t numOfItems,
1555 const std::vector<std::string> &folderNames, uint8_t label, int status)
1556 {
1557 HILOGI("rawAddr:%{public}s, uidCounter:%{public}d, numOfItems:%{public}u, label:%{public}d, status:%{public}d",
1558 GET_ENCRYPT_AVRCP_ADDR(rawAddr), uidCounter, numOfItems, label, status);
1559 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1560 if (status == AVRC_ES_CODE_NO_ERROR) {
1561 cnManager->SetUidCounter(rawAddr, uidCounter);
1562 }
1563
1564 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgSbpPacket>(
1565 AVCT_BrGetPeerMtu(cnManager->GetConnectId(rawAddr)), status, uidCounter, numOfItems, folderNames, label);
1566 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1567 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_BROWSED_PLAYER);
1568 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1569 }
1570
ReceiveSetBrowsedPlayerCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1571 void AvrcTgProfile::ReceiveSetBrowsedPlayerCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1572 {
1573 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1574
1575 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1576 uint16_t uidCounter = cnManager->GetUidCounter(rawAddr);
1577 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgSbpPacket>(pkt, label);
1578 if (packet->IsValid()) {
1579 AvrcTgSbpPacket *myPkt = static_cast<AvrcTgSbpPacket *>(packet.get());
1580 myObserver_->setBrowsedPlayer(rawAddr, myPkt->GetPlayerId(), uidCounter, label);
1581 } else {
1582 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_SET_BROWSED_PLAYER);
1583 }
1584 }
1585
SendChangePathRsp(const RawAddress & rawAddr,uint32_t numOfItems,uint8_t label,int status)1586 void AvrcTgProfile::SendChangePathRsp(const RawAddress &rawAddr, uint32_t numOfItems, uint8_t label, int status)
1587 {
1588 HILOGI("rawAddr:%{public}s, numOfItems:%{public}u, label:%{public}d, status:%{public}d",
1589 GET_ENCRYPT_AVRCP_ADDR(rawAddr), numOfItems, label, status);
1590
1591 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgCpPacket>(status, numOfItems, label);
1592 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1593 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_CHANGE_PATH);
1594 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1595 }
1596
ReceiveChangePathCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1597 void AvrcTgProfile::ReceiveChangePathCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1598 {
1599 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1600
1601 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1602 uint16_t uidCounter = cnManager->GetUidCounter(rawAddr);
1603 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgCpPacket>(pkt, uidCounter, label);
1604
1605 if (packet->IsValid()) {
1606 AvrcTgCpPacket *myPkt = static_cast<AvrcTgCpPacket *>(packet.get());
1607 myObserver_->changePath(rawAddr, myPkt->GetUidCounter(), myPkt->GetDirection(), myPkt->GetFolderUid(), label);
1608 } else {
1609 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_CHANGE_PATH);
1610 }
1611 }
1612
SendGetFolderItemsRsp(const RawAddress & rawAddr,uint16_t uidCounter,const std::vector<AvrcMpItem> & items,uint8_t label,int status)1613 void AvrcTgProfile::SendGetFolderItemsRsp(
1614 const RawAddress &rawAddr, uint16_t uidCounter, const std::vector<AvrcMpItem> &items, uint8_t label, int status)
1615 {
1616 HILOGI("rawAddr:%{public}s, uidCounter:%{public}d, label:%{public}d, status:%{public}d",
1617 GET_ENCRYPT_AVRCP_ADDR(rawAddr), uidCounter, label, status);
1618 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1619 if (status == AVRC_ES_CODE_NO_ERROR) {
1620 cnManager->SetUidCounter(rawAddr, uidCounter);
1621 }
1622
1623 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgGfiPacket>(
1624 AVCT_BrGetPeerMtu(cnManager->GetConnectId(rawAddr)), status, uidCounter, items, label);
1625 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1626 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_FOLDER_ITEMS);
1627 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1628 }
1629
SendGetFolderItemsRsp(const RawAddress & rawAddr,uint16_t uidCounter,const std::vector<AvrcMeItem> & items,uint8_t label,int status)1630 void AvrcTgProfile::SendGetFolderItemsRsp(
1631 const RawAddress &rawAddr, uint16_t uidCounter, const std::vector<AvrcMeItem> &items, uint8_t label, int status)
1632 {
1633 HILOGI("rawAddr:%{public}s, uidCounter:%{public}d, label:%{public}d, status:%{public}d",
1634 GET_ENCRYPT_AVRCP_ADDR(rawAddr), uidCounter, label, status);
1635 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1636 if (status == AVRC_ES_CODE_NO_ERROR) {
1637 cnManager->SetUidCounter(rawAddr, uidCounter);
1638 }
1639
1640 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgGfiPacket>(
1641 AVCT_BrGetPeerMtu(cnManager->GetConnectId(rawAddr)), status, uidCounter, items, label);
1642 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1643 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_FOLDER_ITEMS);
1644 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1645 }
1646
ReceiveGetFolderItemsCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1647 void AvrcTgProfile::ReceiveGetFolderItemsCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1648 {
1649 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1650
1651 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgGfiPacket>(pkt, label);
1652
1653 if (packet->IsValid()) {
1654 AvrcTgGfiPacket *myPkt = static_cast<AvrcTgGfiPacket *>(packet.get());
1655 myObserver_->getFolderItems(
1656 rawAddr, myPkt->GetScope(), myPkt->GetStartItem(), myPkt->GetEndItem(), myPkt->GetAttributes(), label);
1657 } else {
1658 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_FOLDER_ITEMS);
1659 }
1660 }
1661
SendGetItemAttributesRsp(const RawAddress & rawAddr,const std::vector<uint32_t> & attributes,const std::vector<std::string> & values,uint8_t label,int status)1662 void AvrcTgProfile::SendGetItemAttributesRsp(const RawAddress &rawAddr, const std::vector<uint32_t> &attributes,
1663 const std::vector<std::string> &values, uint8_t label, int status)
1664 {
1665 HILOGI("rawAddr:%{public}s, label:%{public}d, status:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label, status);
1666 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1667
1668 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgGiaPacket>(
1669 AVCT_BrGetPeerMtu(cnManager->GetConnectId(rawAddr)), status, attributes, values, label);
1670 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1671 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_ITEM_ATTRIBUTES);
1672 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1673 }
1674
ReceiveGetItemAttributesCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1675 void AvrcTgProfile::ReceiveGetItemAttributesCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1676 {
1677 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1678
1679 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1680 uint16_t uidCounter = cnManager->GetUidCounter(rawAddr);
1681 HILOGI("The saved uidCounter: %{public}u", uidCounter);
1682
1683 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgGiaPacket>(pkt, uidCounter, label);
1684 if (packet->IsValid()) {
1685 AvrcTgGiaPacket *myPkt = static_cast<AvrcTgGiaPacket *>(packet.get());
1686 myObserver_->getGetItemAttributes(
1687 rawAddr, myPkt->GetScope(), myPkt->GetUid(), myPkt->GetUidCounter(), myPkt->GetAttributes(), label);
1688 } else {
1689 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_ITEM_ATTRIBUTES);
1690 }
1691 }
1692
SendGetTotalNumberOfItemsRsp(const RawAddress & rawAddr,uint16_t uidCounter,uint32_t numOfItems,uint8_t label,int status)1693 void AvrcTgProfile::SendGetTotalNumberOfItemsRsp(
1694 const RawAddress &rawAddr, uint16_t uidCounter, uint32_t numOfItems, uint8_t label, int status)
1695 {
1696 HILOGI("rawAddr:%{public}s, uidCounter:%{public}d, numOfItems:%{public}u, label:%{public}d, status:%{public}d",
1697 GET_ENCRYPT_AVRCP_ADDR(rawAddr), uidCounter, numOfItems, label, status);
1698 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1699 if (status == AVRC_ES_CODE_NO_ERROR) {
1700 cnManager->SetUidCounter(rawAddr, uidCounter);
1701 }
1702
1703 std::shared_ptr<AvrcTgBrowsePacket> packet =
1704 std::make_shared<AvrcTgGtnoiPacket>(status, uidCounter, numOfItems, label);
1705 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1706 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_TOTAL_NUMBER_OF_ITEMS);
1707 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
1708 }
1709
ReceiveGetTotalNumberOfItemsCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1710 void AvrcTgProfile::ReceiveGetTotalNumberOfItemsCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1711 {
1712 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1713
1714 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgGtnoiPacket>(pkt, label);
1715
1716 if (packet->IsValid()) {
1717 AvrcTgGtnoiPacket *myPkt = static_cast<AvrcTgGtnoiPacket *>(packet.get());
1718 myObserver_->getTotalNumberOfItems(rawAddr, myPkt->GetScope(), label);
1719 } else {
1720 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GET_TOTAL_NUMBER_OF_ITEMS);
1721 }
1722 }
1723
ReceiveBrowseCmd(const RawAddress & rawAddr,uint8_t label,Packet * pkt)1724 void AvrcTgProfile::ReceiveBrowseCmd(const RawAddress &rawAddr, uint8_t label, Packet *pkt)
1725 {
1726 HILOGI("rawAddr:%{public}s, label:%{public}d", GET_ENCRYPT_AVRCP_ADDR(rawAddr), label);
1727
1728 uint8_t pduId = AvrcTgPacket::GetBrowsePdu(pkt);
1729 switch (pduId) {
1730 case AVRC_TG_PDU_ID_SET_BROWSED_PLAYER:
1731 ReceiveSetBrowsedPlayerCmd(rawAddr, label, pkt);
1732 break;
1733 case AVRC_TG_PDU_ID_CHANGE_PATH:
1734 ReceiveChangePathCmd(rawAddr, label, pkt);
1735 break;
1736 case AVRC_TG_PDU_ID_GET_FOLDER_ITEMS:
1737 ReceiveGetFolderItemsCmd(rawAddr, label, pkt);
1738 break;
1739 case AVRC_TG_PDU_ID_GET_ITEM_ATTRIBUTES:
1740 ReceiveGetItemAttributesCmd(rawAddr, label, pkt);
1741 break;
1742 case AVRC_TG_PDU_ID_GET_TOTAL_NUMBER_OF_ITEMS:
1743 ReceiveGetTotalNumberOfItemsCmd(rawAddr, label, pkt);
1744 break;
1745 default:
1746 std::shared_ptr<AvrcTgBrowsePacket> packet = std::make_shared<AvrcTgBrowsePacket>(
1747 AVRC_TG_PDU_ID_GENERAL_REJECT, AVRC_ES_CODE_INVALID_COMMAND, label);
1748 SendBrowseRsp(rawAddr, packet, AVRC_TG_SM_EVENT_GENERAL_REJECT);
1749 HILOGI("The PDU ID is wrong! Address: %{public}s, pduId: %{public}x",
1750 GET_ENCRYPT_AVRCP_ADDR(rawAddr), pduId);
1751 break;
1752 }
1753 }
1754
ProcessChannelEvent(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context)1755 void AvrcTgProfile::ProcessChannelEvent(
1756 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context)
1757 {
1758 HILOGI("enter");
1759 switch (event) {
1760 case AVCT_CONNECT_IND_EVT:
1761 HILOGI("Receive [AVCT_CONNECT_IND_EVT] - Result[%{public}x] - Address[%{public}s]",
1762 result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1763 ProcessChannelEventConnectIndEvt(rawAddr, connectId, event, result, context);
1764 break;
1765 case AVCT_DISCONNECT_IND_EVT:
1766 HILOGI("Receive [AVCT_DISCONNECT_IND_EVT] - Result[%{public}x] - Address[%{public}s]",
1767 result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1768 ProcessChannelEventDisconnectIndEvt(rawAddr, connectId, event, result, context);
1769 break;
1770 case AVCT_DISCONNECT_CFM_EVT:
1771 HILOGI("Receive [AVCT_DISCONNECT_CFM_EVT] - Result[%{public}x] - Address[%{public}s]",
1772 result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1773 ProcessChannelEventDisconnectCfmEvt(rawAddr, connectId, event, result, context);
1774 break;
1775 case AVCT_BR_CONNECT_IND_EVT:
1776 HILOGI("Receive [AVCT_BR_CONNECT_IND_EVT] Address:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1777 ProcessChannelEventBrConnectIndEvt(rawAddr, connectId, event, result, context);
1778 break;
1779 case AVCT_BR_CONNECT_CFM_EVT:
1780 HILOGI("Receive [AVCT_BR_CONNECT_CFM_EVT] - Result[%{public}x] - Address[%{public}s]",
1781 result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1782 ProcessChannelEventBrConnectCfmEvt(rawAddr, connectId, event, result, context);
1783 break;
1784 case AVCT_BR_DISCONNECT_IND_EVT:
1785 HILOGI("Receive [AVCT_BR_DISCONNECT_IND_EVT] - Result[%{public}x] - Address[%{public}s]",
1786 result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1787
1788 DeleteBrowseStateMachine(rawAddr);
1789 break;
1790 case AVCT_BR_DISCONNECT_CFM_EVT:
1791 HILOGI("Receive [AVCT_BR_DISCONNECT_CFM_EVT] - Result[%{public}x] - Address[%{public}s]",
1792 result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1793
1794 DeleteBrowseStateMachine(rawAddr);
1795 break;
1796 case AVCT_CONNECT_CFM_EVT:
1797 /// The AVCTP does not return this message when an passive connection is created.
1798 HILOGI("Receive [AVCT_CONNECT_CFM_EVT] - Result[%{public}x] - Address[%{public}s]",
1799 result, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1800 ProcessChannelEventConnectCfmEvt(rawAddr, connectId, event, result, context);
1801 break;
1802 default:
1803 HILOGI("Unknown [%{public}x]! - Address[%{public}s]", event, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
1804 break;
1805 };
1806 }
1807
ProcessChannelEventConnectIndEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context)1808 void AvrcTgProfile::ProcessChannelEventConnectIndEvt(
1809 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context)
1810 {
1811 HILOGI("rawAddr:%{public}s, connectId:%{public}d, event:%{public}d, result:%{public}d",
1812 GET_ENCRYPT_AVRCP_ADDR(rawAddr), connectId, event, result);
1813
1814 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTING));
1815
1816 result = ExpainAvctResult(result);
1817
1818 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1819 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
1820 utility::Message msg(AVRC_TG_SM_EVENT_INVALID);
1821
1822 if (result == BT_SUCCESS) {
1823 result |= cnManager->Add(
1824 rawAddr, connectId, AVCT_ACPT, controlMtu_, browseMtu_, companyId_, 0x0000, eventCallback_, msgCallback_);
1825 result |= smManager->AddControlStateMachine(rawAddr);
1826 if (result == BT_SUCCESS) {
1827 cnManager->SetControlMtu(rawAddr, AVCT_GetPeerMtu(connectId));
1828 AcceptPassiveConnect(rawAddr);
1829 if (cnManager->GetActiveDevice().compare(AVRC_TG_DEFAULT_BLUETOOTH_ADDRESS) == 0x00) {
1830 cnManager->SetActiveDevice(rawAddr.GetAddress());
1831 myObserver_->setActiveDevice(rawAddr);
1832 }
1833 cnManager->DeleteDisconnectedDevice(rawAddr.GetAddress());
1834 if (!IsSupportedBrowsing()) {
1835 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
1836 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON, PROFILE_NAME_AVRCP_TG, rawAddr);
1837 }
1838 }
1839 }
1840 }
1841
ProcessChannelEventDisconnectIndEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context)1842 void AvrcTgProfile::ProcessChannelEventDisconnectIndEvt(
1843 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context)
1844 {
1845 HILOGI("rawAddr:%{public}s, connectId:%{public}d, event:%{public}d, result:%{public}d",
1846 GET_ENCRYPT_AVRCP_ADDR(rawAddr), connectId, event, result);
1847 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1848 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
1849
1850 if (smManager->IsControlDisableState(rawAddr)) {
1851 DeleteResource(rawAddr);
1852 if (cnManager->IsConnectInfoEmpty()) {
1853 if (cnManager->GetActiveDevice().compare(rawAddr.GetAddress()) == 0x00) {
1854 myObserver_->setActiveDevice(RawAddress(AVRC_TG_DEFAULT_BLUETOOTH_ADDRESS));
1855 }
1856 AvrcpTgSafeDelete(cnManager);
1857 smManager->ShutDown();
1858 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
1859 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_TG, rawAddr);
1860 myObserver_->onDisabled();
1861 }
1862 } else {
1863 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTING));
1864 DeleteResource(rawAddr);
1865 if (cnManager->GetActiveDevice().compare(rawAddr.GetAddress()) == 0x00) {
1866 cnManager->SetActiveDevice(AVRC_TG_DEFAULT_BLUETOOTH_ADDRESS);
1867 myObserver_->setActiveDevice(RawAddress(AVRC_TG_DEFAULT_BLUETOOTH_ADDRESS));
1868 }
1869 cnManager->AddDisconnectedDevice(rawAddr.GetAddress());
1870 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
1871 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_TG, rawAddr);
1872 }
1873 }
1874
ProcessChannelEventDisconnectCfmEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context)1875 void AvrcTgProfile::ProcessChannelEventDisconnectCfmEvt(
1876 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context)
1877 {
1878 HILOGI("rawAddr:%{public}s, connectId:%{public}d, event:%{public}d, result:%{public}d",
1879 GET_ENCRYPT_AVRCP_ADDR(rawAddr), connectId, event, result);
1880 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1881 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
1882 utility::Message msg(AVRC_TG_SM_EVENT_INVALID);
1883
1884 if (smManager->IsControlDisableState(rawAddr)) {
1885 DeleteResource(rawAddr);
1886 if (cnManager->IsConnectInfoEmpty()) {
1887 if (cnManager->GetActiveDevice().compare(rawAddr.GetAddress()) == 0x00) {
1888 myObserver_->setActiveDevice(RawAddress(AVRC_TG_DEFAULT_BLUETOOTH_ADDRESS));
1889 }
1890 AvrcpTgSafeDelete(cnManager);
1891 smManager->ShutDown();
1892 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
1893 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_TG, rawAddr);
1894 myObserver_->onDisabled();
1895 }
1896 } else {
1897 DeleteResource(rawAddr);
1898 if (cnManager->GetActiveDevice().compare(rawAddr.GetAddress()) == 0x00) {
1899 cnManager->SetActiveDevice(AVRC_TG_DEFAULT_BLUETOOTH_ADDRESS);
1900 myObserver_->setActiveDevice(RawAddress(AVRC_TG_DEFAULT_BLUETOOTH_ADDRESS));
1901 }
1902 cnManager->AddDisconnectedDevice(rawAddr.GetAddress());
1903 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
1904 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_TG, rawAddr);
1905 }
1906 }
1907
ProcessChannelEventBrConnectIndEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context)1908 void AvrcTgProfile::ProcessChannelEventBrConnectIndEvt(
1909 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context)
1910 {
1911 HILOGI("rawAddr:%{public}s, connectId:%{public}d, event:%{public}d, result:%{public}d",
1912 GET_ENCRYPT_AVRCP_ADDR(rawAddr), connectId, event, result);
1913 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
1914 utility::Message msg(AVRC_TG_SM_EVENT_INVALID);
1915
1916 if (result == BT_SUCCESS) {
1917 result |= smManager->AddBrowseStateMachine(rawAddr);
1918 if (result == BT_SUCCESS) {
1919 msg.what_ = AVRC_TG_SM_EVENT_TO_CONNECTED_STATE;
1920 smManager->SendMessageToBrowseStateMachine(rawAddr, msg);
1921 }
1922 }
1923 if (IsSupportedBrowsing()) {
1924 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
1925 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON, PROFILE_NAME_AVRCP_TG, rawAddr);
1926 }
1927 }
1928
ProcessChannelEventBrConnectCfmEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context)1929 void AvrcTgProfile::ProcessChannelEventBrConnectCfmEvt(
1930 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context)
1931 {
1932 HILOGI("rawAddr:%{public}s, connectId:%{public}d, event:%{public}d, result:%{public}d",
1933 GET_ENCRYPT_AVRCP_ADDR(rawAddr), connectId, event, result);
1934 result = ExpainAvctResult(result);
1935
1936 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1937 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
1938 utility::Message msg(AVRC_TG_SM_EVENT_INVALID);
1939
1940 if (result == BT_SUCCESS) {
1941 cnManager->SetBrowseMtu(rawAddr, AVCT_BrGetPeerMtu(connectId));
1942 smManager->AddBrowseStateMachine(rawAddr);
1943 msg.what_ = AVRC_TG_SM_EVENT_TO_CONNECTED_STATE;
1944 smManager->SendMessageToBrowseStateMachine(rawAddr, msg);
1945 }
1946 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
1947 }
1948
ProcessChannelEventConnectCfmEvt(const RawAddress & rawAddr,uint8_t connectId,uint8_t event,uint16_t result,void * context)1949 void AvrcTgProfile::ProcessChannelEventConnectCfmEvt(
1950 const RawAddress &rawAddr, uint8_t connectId, uint8_t event, uint16_t result, void *context)
1951 {
1952 HILOGI("rawAddr:%{public}s, connectId:%{public}d, event:%{public}d, result:%{public}d",
1953 GET_ENCRYPT_AVRCP_ADDR(rawAddr), connectId, event, result);
1954 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1955 AvrcTgStateMachineManager *smManager = AvrcTgStateMachineManager::GetInstance();
1956 utility::Message msg(AVRC_TG_SM_EVENT_INVALID);
1957
1958 if (result == BT_SUCCESS) {
1959 cnManager->SetConnectId(rawAddr, connectId);
1960 cnManager->SetActiveDevice(rawAddr.GetAddress());
1961 msg.what_ = AVRC_TG_SM_EVENT_TO_CONNECTED_STATE;
1962 smManager->SendMessageToControlStateMachine(rawAddr, msg);
1963
1964 if (IsSupportedBrowsing()) {
1965 ConnectBr(rawAddr);
1966 } else {
1967 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::CONNECTED));
1968 }
1969 cnManager->DeleteDisconnectedDevice(rawAddr.GetAddress());
1970 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON, PROFILE_NAME_AVRCP_TG, rawAddr);
1971 } else {
1972 DeleteResource(rawAddr);
1973 myObserver_->onConnectionStateChanged(rawAddr, static_cast<int>(BTConnectState::DISCONNECTED));
1974 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_OFF, PROFILE_NAME_AVRCP_TG, rawAddr);
1975 }
1976 }
1977
ProcessChannelMessage(uint8_t connectId,uint8_t label,uint8_t crType,uint8_t chType,Packet * pkt,void * context)1978 void AvrcTgProfile::ProcessChannelMessage(
1979 uint8_t connectId, uint8_t label, uint8_t crType, uint8_t chType, Packet *pkt, void *context)
1980 {
1981 HILOGI("connectId: %{public}u, label: %{public}u, crType: %{public}u, chType: %{public}u",
1982 connectId, label, crType, chType);
1983
1984 AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
1985
1986 RawAddress rawAddr = AvrcTgConnectManager::GetInstance()->GetRawAddress(connectId);
1987 IPowerManager::GetInstance().StatusUpdate(RequestStatus::BUSY, PROFILE_NAME_AVRCP_TG, rawAddr);
1988 std::string addr = rawAddr.GetAddress();
1989 transform(addr.begin(), addr.end(), addr.begin(), ::toupper);
1990 if (cnManager->GetActiveDevice().compare(addr) == 0x00) {
1991 if (chType == AVCT_DATA_CTRL) {
1992 uint8_t opCode = AvrcTgPacket::GetOpCode(pkt);
1993 HILOGI("opCode: %{public}x", opCode);
1994 switch (opCode) {
1995 case AVRC_TG_OP_CODE_PASS_THROUGH:
1996 ReceivePassCmd(rawAddr, label, pkt);
1997 break;
1998 case AVRC_TG_OP_CODE_UNIT_INFO:
1999 ReceiveUnitCmd(rawAddr, label, pkt);
2000 break;
2001 case AVRC_TG_OP_CODE_SUB_UNIT_INFO:
2002 ReceiveSubUnitCmd(rawAddr, label, pkt);
2003 break;
2004 case AVRC_TG_OP_CODE_VENDOR:
2005 ReceiveVendorCmd(rawAddr, label, pkt);
2006 break;
2007 default:
2008 HILOGI("opCode: %{public}x is wrong! - ConnectId: %{public}x", opCode, connectId);
2009 break;
2010 }
2011 } else if (chType == AVCT_DATA_BR) {
2012 ReceiveBrowseCmd(rawAddr, label, pkt);
2013 } else {
2014 HILOGI("chType: %{public}x is wrong! ConnectId: %{public}x", chType, connectId);
2015 }
2016 } else {
2017 HILOGI("Active device: %{public}s Request device: %{public}s!",
2018 GetEncryptAddr(cnManager->GetActiveDevice()).c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2019 }
2020
2021 PacketFree(pkt);
2022 IPowerManager::GetInstance().StatusUpdate(RequestStatus::IDLE, PROFILE_NAME_AVRCP_TG, rawAddr);
2023 }
2024
DeleteResource(const RawAddress & rawAddr)2025 void AvrcTgProfile::DeleteResource(const RawAddress &rawAddr)
2026 {
2027 HILOGI("rawAddr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2028
2029 AvrcTgConnectManager::GetInstance()->Delete(rawAddr);
2030 AvrcTgStateMachineManager::GetInstance()->DeletePairOfStateMachine(rawAddr);
2031 }
2032
DeleteBrowseStateMachine(const RawAddress & rawAddr)2033 void AvrcTgProfile::DeleteBrowseStateMachine(const RawAddress &rawAddr)
2034 {
2035 HILOGI("rawAddr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
2036
2037 AvrcTgStateMachineManager::GetInstance()->DeleteBrowseStateMachine(rawAddr);
2038 }
2039
ExpainAvctResult(uint16_t avctRet)2040 int AvrcTgProfile::ExpainAvctResult(uint16_t avctRet)
2041 {
2042 HILOGI("avctRet:%{public}d", avctRet);
2043
2044 int result = RET_BAD_STATUS;
2045
2046 switch (avctRet) {
2047 case AVCT_SUCCESS:
2048 result = BT_SUCCESS;
2049 break;
2050 case AVCT_FAILED:
2051 default:
2052 break;
2053 }
2054
2055 return result;
2056 }
2057
ExplainResultToPassCrCode(int result)2058 uint8_t AvrcTgProfile::ExplainResultToPassCrCode(int result)
2059 {
2060 HILOGI("result:%{public}d", result);
2061
2062 uint8_t crCode = AVRC_TG_RSP_CODE_STABLE;
2063
2064 switch (result) {
2065 case BT_SUCCESS:
2066 crCode = AVRC_TG_RSP_CODE_ACCEPTED;
2067 break;
2068 case RET_NO_SUPPORT:
2069 crCode = AVRC_TG_RSP_CODE_NOT_IMPLEMENTED;
2070 break;
2071 case RET_BAD_STATUS:
2072 /// FALL THROUGH
2073 default:
2074 crCode = AVRC_TG_RSP_CODE_REJECTED;
2075 break;
2076 }
2077
2078 return crCode;
2079 }
2080
ExplainResultToStatusCrCode(int result)2081 uint8_t AvrcTgProfile::ExplainResultToStatusCrCode(int result)
2082 {
2083 HILOGI("result:%{public}d", result);
2084
2085 uint8_t crCode = AVRC_TG_RSP_CODE_STABLE;
2086
2087 switch (result) {
2088 case BT_SUCCESS:
2089 crCode = AVRC_TG_RSP_CODE_STABLE;
2090 break;
2091 case RET_NO_SUPPORT:
2092 crCode = AVRC_TG_RSP_CODE_NOT_IMPLEMENTED;
2093 break;
2094 case RET_BAD_STATUS:
2095 /// FALL THROUGH
2096 default:
2097 crCode = AVRC_TG_RSP_CODE_REJECTED;
2098 break;
2099 }
2100
2101 return crCode;
2102 }
2103
ExplainResultToControlCrCode(int result)2104 uint8_t AvrcTgProfile::ExplainResultToControlCrCode(int result)
2105 {
2106 HILOGI("result:%{public}d", result);
2107
2108 uint8_t crCode = AVRC_TG_RSP_CODE_STABLE;
2109
2110 switch (result) {
2111 case BT_SUCCESS:
2112 crCode = AVRC_TG_RSP_CODE_ACCEPTED;
2113 break;
2114 case RET_NO_SUPPORT:
2115 crCode = AVRC_TG_RSP_CODE_NOT_IMPLEMENTED;
2116 break;
2117 case RET_BAD_STATUS:
2118 /// FALL THROUGH
2119 default:
2120 crCode = AVRC_TG_RSP_CODE_REJECTED;
2121 break;
2122 }
2123
2124 return crCode;
2125 }
2126
GetNotificationLabel(uint8_t event)2127 std::pair<bool, uint8_t> AvrcTgProfile::GetNotificationLabel(uint8_t event)
2128 {
2129 HILOGI("event:%{public}d", event);
2130 switch (event) {
2131 case AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED:
2132 return playStatusChanged;
2133 case AVRC_TG_EVENT_ID_TRACK_CHANGED:
2134 return trackChanged;
2135 case AVRC_TG_EVENT_ID_TRACK_REACHED_END:
2136 case AVRC_TG_EVENT_ID_TRACK_REACHED_START:
2137 case AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED:
2138 case AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED:
2139 case AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED:
2140 case AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED:
2141 case AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED:
2142 case AVRC_TG_EVENT_ID_UIDS_CHANGED:
2143 case AVRC_TG_EVENT_ID_VOLUME_CHANGED:
2144 default:
2145 return std::make_pair(false, 0);
2146 }
2147 }
2148
SetNotificationLabel(uint8_t event,uint8_t label)2149 void AvrcTgProfile::SetNotificationLabel(uint8_t event, uint8_t label)
2150 {
2151 HILOGI("event:%{public}d, label:%{public}d", event, label);
2152 switch (event) {
2153 case AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED:
2154 playStatusChanged = std::make_pair(true, label);
2155 break;
2156 case AVRC_TG_EVENT_ID_TRACK_CHANGED:
2157 trackChanged = std::make_pair(true, label);
2158 break;
2159 case AVRC_TG_EVENT_ID_TRACK_REACHED_END:
2160 case AVRC_TG_EVENT_ID_TRACK_REACHED_START:
2161 case AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED:
2162 case AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED:
2163 case AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED:
2164 case AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED:
2165 case AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED:
2166 case AVRC_TG_EVENT_ID_UIDS_CHANGED:
2167 case AVRC_TG_EVENT_ID_VOLUME_CHANGED:
2168 default:
2169 break;
2170 }
2171 }
2172 } // namespace bluetooth
2173 } // namespace OHOS
2174