1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "avrcp_tg_notification.h"
17 #include "avrcp_tg_vendor_player_application_settings.h"
18
19 namespace OHOS {
20 namespace bluetooth {
AvrcTgNotifyPacket(uint8_t eventId,uint8_t crCode,uint8_t label)21 AvrcTgNotifyPacket::AvrcTgNotifyPacket(uint8_t eventId, uint8_t crCode, uint8_t label)
22 : interval_(AVRC_PLAYBACK_INTERVAL_1_SEC), playStatus_(AVRC_PLAY_STATUS_ERROR),
23 volume_(AVRC_ABSOLUTE_VOLUME_INVALID)
24 {
25 HILOGI("eventId: %{public}d, crCode: %{public}d, label: %{public}d", eventId, crCode, label);
26
27 crCode_ = crCode;
28 pduId_ = AVRC_TG_PDU_ID_REGISTER_NOTIFICATION;
29 parameterLength_ = AVRC_TG_NOTIFY_PARAMETER_LENGTH;
30 eventId_ = eventId;
31 label_ = label;
32 }
33
AvrcTgNotifyPacket(Packet * pkt,uint8_t label)34 AvrcTgNotifyPacket::AvrcTgNotifyPacket(Packet *pkt, uint8_t label)
35 : AvrcTgVendorPacket(),
36 interval_(AVRC_PLAYBACK_INTERVAL_1_SEC),
37 playStatus_(AVRC_PLAY_STATUS_ERROR),
38 volume_(AVRC_ABSOLUTE_VOLUME_INVALID)
39 {
40 HILOGI("label: %{public}d", label);
41
42 crCode_ = AVRC_TG_RSP_CODE_CHANGED;
43 pduId_ = AVRC_TG_PDU_ID_REGISTER_NOTIFICATION;
44 label_ = label;
45
46 DisassemblePacket(pkt);
47 }
48
~AvrcTgNotifyPacket()49 AvrcTgNotifyPacket::~AvrcTgNotifyPacket()
50 {
51 HILOGI("enter");
52
53 attributes_.clear();
54 values_.clear();
55 }
56
AssembleParameters(Packet * pkt)57 Packet *AvrcTgNotifyPacket::AssembleParameters(Packet *pkt)
58 {
59 HILOGI("enter");
60
61 switch (eventId_) {
62 case AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED:
63 AssemblePlaybackStatusChanged(pkt);
64 break;
65 case AVRC_TG_EVENT_ID_TRACK_CHANGED:
66 AssembleTrackChanged(pkt);
67 break;
68 case AVRC_TG_EVENT_ID_PLAYBACK_POS_CHANGED:
69 AssemblePlaybackPosChanged(pkt);
70 break;
71 case AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED:
72 AssemblePlayerApplicationSettingChanged(pkt);
73 break;
74 case AVRC_TG_EVENT_ID_ADDRESSED_PLAYER_CHANGED:
75 AssembleAddressedPlayerChanged(pkt);
76 break;
77 case AVRC_TG_EVENT_ID_UIDS_CHANGED:
78 AssembleUidsChanged(pkt);
79 break;
80 case AVRC_TG_EVENT_ID_VOLUME_CHANGED:
81 AssembleVolumeChanged(pkt);
82 break;
83 case AVRC_TG_EVENT_ID_TRACK_REACHED_END:
84 case AVRC_TG_EVENT_ID_TRACK_REACHED_START:
85 case AVRC_TG_EVENT_ID_NOW_PLAYING_CONTENT_CHANGED:
86 case AVRC_TG_EVENT_ID_AVAILABLE_PLAYERS_CHANGED: {
87 AssembleCommonChanged(pkt);
88 break;
89 }
90 default: {
91 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
92 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
93 AssembleRejectPacket();
94 break;
95 }
96 }
97
98 return pkt;
99 }
100
AssemblePlaybackStatusChanged(Packet * pkt)101 void AvrcTgNotifyPacket::AssemblePlaybackStatusChanged(Packet *pkt)
102 {
103 HILOGI("enter");
104
105 auto buffer = BufferMalloc(AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
106 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_ID_PLAYBACK_STATUS_SIZE);
107 if (buffer == nullptr) {
108 HILOGE("BufferMalloc fail");
109 return;
110 }
111 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
112 HILOGI("BufferMalloc: %{public}ju",
113 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_NOTIFY_EVENT_ID_SIZE +
114 AVRC_TG_NOTIFY_EVENT_ID_PLAYBACK_STATUS_SIZE));
115
116 uint16_t offset = 0x0000;
117 offset += PushOctets1((bufferPtr + offset), packetType_);
118 HILOGI("packetType_: %{public}x", packetType_);
119
120 parameterLength_ = AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_ID_PLAYBACK_STATUS_SIZE;
121 offset += PushOctets2((bufferPtr + offset), parameterLength_);
122 HILOGI("parameterLength_: %{public}hu", parameterLength_);
123
124 offset += PushOctets1((bufferPtr + offset), eventId_);
125 HILOGI("eventId_: %{public}hhx", eventId_);
126
127 PushOctets1((bufferPtr + offset), playStatus_);
128 HILOGI("playStatus_: %{public}hhx", playStatus_);
129
130 PacketPayloadAddLast(pkt, buffer);
131
132 BufferFree(buffer);
133 }
134
AssembleTrackChanged(Packet * pkt)135 void AvrcTgNotifyPacket::AssembleTrackChanged(Packet *pkt)
136 {
137 HILOGI("enter");
138
139 auto buffer = BufferMalloc(AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
140 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_UID_SIZE);
141 if (buffer == nullptr) {
142 HILOGE("BufferMalloc fail");
143 return;
144 }
145 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
146 HILOGI("BufferMalloc: %{public}ju",
147 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_NOTIFY_EVENT_ID_SIZE +
148 AVRC_TG_NOTIFY_EVENT_UID_SIZE));
149
150 uint16_t offset = 0x0000;
151 offset += PushOctets1((bufferPtr + offset), packetType_);
152 HILOGI("packetType_: %{public}x", packetType_);
153
154 parameterLength_ = AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_UID_SIZE;
155 offset += PushOctets2((bufferPtr + offset), parameterLength_);
156 HILOGI("parameterLength_: %{public}d", parameterLength_);
157
158 offset += PushOctets1((bufferPtr + offset), eventId_);
159 HILOGI("eventId_: %{public}x", eventId_);
160
161 PushOctets8((bufferPtr + offset), uid_);
162 HILOGI("uid_: %{public}jx", uid_);
163
164 PacketPayloadAddLast(pkt, buffer);
165
166 BufferFree(buffer);
167 }
168
AssemblePlaybackPosChanged(Packet * pkt)169 void AvrcTgNotifyPacket::AssemblePlaybackPosChanged(Packet *pkt)
170 {
171 HILOGI("enter");
172
173 auto buffer = BufferMalloc(AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
174 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_PLAYBACK_POSITION_SIZE);
175 if (buffer == nullptr) {
176 HILOGE("BufferMalloc fail");
177 return;
178 }
179 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
180 HILOGI("BufferMalloc: %{public}ju",
181 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_NOTIFY_EVENT_ID_SIZE +
182 AVRC_TG_NOTIFY_EVENT_PLAYBACK_POSITION_SIZE));
183
184 uint16_t offset = 0x0000;
185 offset += PushOctets1((bufferPtr + offset), packetType_);
186 HILOGI("packetType_: %{public}x", packetType_);
187
188 parameterLength_ = AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_PLAYBACK_POSITION_SIZE;
189 offset += PushOctets2((bufferPtr + offset), parameterLength_);
190 HILOGI("parameterLength_: %{public}d", parameterLength_);
191
192 offset += PushOctets1((bufferPtr + offset), eventId_);
193 HILOGI("eventId_: %{public}x", eventId_);
194
195 PushOctets4((bufferPtr + offset), playbackPos_);
196 HILOGI("playbackPos_: %{public}x", playbackPos_);
197
198 PacketPayloadAddLast(pkt, buffer);
199
200 BufferFree(buffer);
201 }
202
AssemblePlayerApplicationSettingChanged(Packet * pkt)203 void AvrcTgNotifyPacket::AssemblePlayerApplicationSettingChanged(Packet *pkt)
204 {
205 HILOGI("enter");
206
207 uint16_t numOfAttributes = GetAvailableParameterSize() / AVRC_TG_OFFSET_TWO_BITS;
208 if (numOfAttributes > values_.size()) {
209 numOfAttributes = values_.size();
210 }
211
212 size_t bufferSize = AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
213 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_GCPASV_NUM_OF_VALUES_SIZE + numOfAttributes +
214 numOfAttributes;
215 HILOGI("BufferMalloc: %{public}zu", bufferSize);
216
217 auto buffer = BufferMalloc(bufferSize);
218 if (buffer == nullptr) {
219 HILOGE("BufferMalloc fail");
220 return;
221 }
222 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
223
224 uint16_t offset = 0x0000;
225 offset += PushOctets1((bufferPtr + offset), packetType_);
226 HILOGI("packetType_: %{public}x", packetType_);
227
228 parameterLength_ =
229 numOfAttributes + numOfAttributes + AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_GCPASV_NUM_OF_VALUES_SIZE;
230 offset += PushOctets2((bufferPtr + offset), parameterLength_);
231 HILOGI("parameterLength_: %{public}u", parameterLength_);
232
233 offset += PushOctets1((bufferPtr + offset), eventId_);
234 HILOGI("eventId_: %{public}u", eventId_);
235
236 offset += PushOctets1((bufferPtr + offset), numOfAttributes);
237 HILOGI("numOfAttributes: %{public}u", numOfAttributes);
238
239 for (int i = 0; i < numOfAttributes; i++) {
240 offset += PushOctets1((bufferPtr + offset), attributes_.at(i));
241 HILOGI("attribute: %{public}u", attributes_.at(i));
242 offset += PushOctets1((bufferPtr + offset), values_.at(i));
243 HILOGI("value: %{public}x", values_.at(i));
244 }
245 attributes_.erase(attributes_.begin(), attributes_.begin() + numOfAttributes);
246 values_.erase(values_.begin(), values_.begin() + numOfAttributes);
247
248 HILOGI("attributes_.size: %{public}zu", attributes_.size());
249 HILOGI("values_.size: %{public}zu", values_.size());
250
251 PacketPayloadAddLast(pkt, buffer);
252
253 BufferFree(buffer);
254 }
255
AssembleAddressedPlayerChanged(Packet * pkt)256 void AvrcTgNotifyPacket::AssembleAddressedPlayerChanged(Packet *pkt)
257 {
258 HILOGI("enter");
259
260 size_t bufferSize = AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
261 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_PLAYER_ID_SIZE +
262 AVRC_TG_NOTIFY_EVENT_UID_COUNTER_SIZE;
263 HILOGI("BufferMalloc: %{public}zu", bufferSize);
264
265 auto buffer = BufferMalloc(bufferSize);
266 if (buffer == nullptr) {
267 HILOGE("BufferMalloc fail");
268 return;
269 }
270 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
271
272 uint16_t offset = 0x0000;
273 offset += PushOctets1((bufferPtr + offset), packetType_);
274 HILOGI("packetType_: %{public}x", packetType_);
275
276 parameterLength_ =
277 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_PLAYER_ID_SIZE + AVRC_TG_NOTIFY_EVENT_UID_COUNTER_SIZE;
278 offset += PushOctets2((bufferPtr + offset), parameterLength_);
279 HILOGI("parameterLength_: %{public}d", parameterLength_);
280
281 offset += PushOctets1((bufferPtr + offset), eventId_);
282 HILOGI("eventId_: %{public}x", eventId_);
283
284 offset += PushOctets2((bufferPtr + offset), playerId_);
285 HILOGI("playerId_: %{public}x", playerId_);
286
287 PushOctets2((bufferPtr + offset), uidCounter_);
288 HILOGI("uidCounter_: %{public}x", uidCounter_);
289
290 PacketPayloadAddLast(pkt, buffer);
291
292 BufferFree(buffer);
293 }
294
AssembleUidsChanged(Packet * pkt)295 void AvrcTgNotifyPacket::AssembleUidsChanged(Packet *pkt)
296 {
297 HILOGI("enter");
298
299 auto buffer = BufferMalloc(AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
300 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_UID_COUNTER_SIZE);
301 if (buffer == nullptr) {
302 HILOGE("BufferMalloc fail");
303 return;
304 }
305 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
306 HILOGI("BufferMalloc: %{public}ju",
307 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_NOTIFY_EVENT_ID_SIZE +
308 AVRC_TG_NOTIFY_EVENT_UID_COUNTER_SIZE));
309
310 uint16_t offset = 0x0000;
311 offset += PushOctets1((bufferPtr + offset), packetType_);
312 HILOGI("packetType_: %{public}x", packetType_);
313
314 parameterLength_ = AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_UID_COUNTER_SIZE;
315 offset += PushOctets2((bufferPtr + offset), parameterLength_);
316 HILOGI("parameterLength_: %{public}d", parameterLength_);
317
318 offset += PushOctets1((bufferPtr + offset), eventId_);
319 HILOGI("eventId_: %{public}x", eventId_);
320
321 PushOctets2((bufferPtr + offset), uidCounter_);
322 HILOGI("uidCounter_: %{public}d", uidCounter_);
323
324 PacketPayloadAddLast(pkt, buffer);
325
326 BufferFree(buffer);
327 }
328
AssembleVolumeChanged(Packet * pkt)329 void AvrcTgNotifyPacket::AssembleVolumeChanged(Packet *pkt)
330 {
331 HILOGI("enter");
332
333 auto buffer = BufferMalloc(AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
334 AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_ID_VOLUME_SIZE);
335 if (buffer == nullptr) {
336 HILOGE("BufferMalloc fail");
337 return;
338 }
339 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
340 HILOGI("BufferMalloc: %{public}ju",
341 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_NOTIFY_EVENT_ID_SIZE +
342 AVRC_TG_NOTIFY_EVENT_ID_VOLUME_SIZE));
343
344 uint16_t offset = 0x0000;
345 offset += PushOctets1((bufferPtr + offset), packetType_);
346 HILOGI("packetType_: %{public}x", packetType_);
347
348 parameterLength_ = AVRC_TG_NOTIFY_EVENT_ID_SIZE + AVRC_TG_NOTIFY_EVENT_ID_VOLUME_SIZE;
349 offset += PushOctets2((bufferPtr + offset), parameterLength_);
350 HILOGI("parameterLength_: %{public}d", parameterLength_);
351
352 offset += PushOctets1((bufferPtr + offset), eventId_);
353 HILOGI("eventId_: %{public}x", eventId_);
354
355 PushOctets1((bufferPtr + offset), volume_);
356 HILOGI("volume_: %{public}x", volume_);
357
358 PacketPayloadAddLast(pkt, buffer);
359
360 BufferFree(buffer);
361 }
362
AssembleCommonChanged(Packet * pkt)363 void AvrcTgNotifyPacket::AssembleCommonChanged(Packet *pkt)
364 {
365 HILOGI("enter");
366
367 auto buffer = BufferMalloc(AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE +
368 AVRC_TG_NOTIFY_PARAMETER_LENGTH + AVRC_TG_NOTIFY_EVENT_ID_SIZE);
369 auto bufferPtr = static_cast<uint8_t *>(BufferPtr(buffer));
370 HILOGI("BufferMalloc: %{public}ju",
371 (AVRC_TG_VENDOR_PACKET_TYPE_SIZE + AVRC_TG_VENDOR_PARAMETER_LENGTH_SIZE + AVRC_TG_NOTIFY_PARAMETER_LENGTH +
372 AVRC_TG_NOTIFY_EVENT_ID_SIZE));
373
374 uint16_t offset = 0x0000;
375 offset += PushOctets1((bufferPtr + offset), packetType_);
376 HILOGI("packetType_: %{public}x", packetType_);
377
378 parameterLength_ = AVRC_TG_NOTIFY_EVENT_ID_SIZE;
379 offset += PushOctets2((bufferPtr + offset), parameterLength_);
380 HILOGI("parameterLength_: %{public}d", parameterLength_);
381
382 PushOctets1((bufferPtr + offset), eventId_);
383 HILOGI("eventId_: %{public}x", eventId_);
384
385 PacketPayloadAddLast(pkt, buffer);
386
387 BufferFree(buffer);
388 }
389
DisassembleParameters(uint8_t * buffer)390 bool AvrcTgNotifyPacket::DisassembleParameters(uint8_t *buffer)
391 {
392 HILOGI("enter");
393
394 isValid_ = false;
395
396 do {
397 uint16_t offset = AVRC_TG_VENDOR_PARAMETER_LENGTH_OFFSET;
398 uint64_t payload = 0x00;
399 offset += PopOctets2((buffer + offset), payload);
400 parameterLength_ = static_cast<uint16_t>(payload);
401 HILOGI("parameterLength_: %{public}d", parameterLength_);
402
403 payload = 0x00;
404 offset += PopOctets1((buffer + offset), payload);
405 eventId_ = static_cast<uint8_t>(payload);
406 HILOGI("eventId_: %{public}x", eventId_);
407 if (!IsValidEventId()) {
408 crCode_ = AVRC_TG_RSP_CODE_REJECTED;
409 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
410 AssembleRejectPacket();
411 break;
412 }
413 if (!IsSupportedEventId()) {
414 crCode_ = AVRC_TG_RSP_CODE_NOT_IMPLEMENTED;
415 status_ = AVRC_ES_CODE_INVALID_PARAMETER;
416 AssembleRejectPacket();
417 break;
418 }
419
420 payload = 0x00;
421 PopOctets4((buffer + offset), payload);
422 interval_ = static_cast<uint32_t>(payload);
423 HILOGI("interval_: %{public}u", interval_);
424
425 crCode_ = AVRC_TG_RSP_CODE_INTERIM;
426
427 isValid_ = true;
428
429 HILOGI("isValid_: %{public}d", isValid_);
430 } while (false);
431
432 return isValid_;
433 }
434
GetNumberOfPackets(void)435 uint16_t AvrcTgNotifyPacket::GetNumberOfPackets(void)
436 {
437 HILOGI("enter");
438
439 uint16_t numOfPkts = AVRC_TG_NOTIFY_NUM_OF_PACKETS;
440
441 if (eventId_ == AVRC_TG_EVENT_ID_PLAYER_APPLICATION_SETTING_CHANGED) {
442 double paramSize = attributes_.size() + values_.size();
443 if (GetAvailableParameterSize() != 0) {
444 numOfPkts = ceil(paramSize / GetAvailableParameterSize());
445 }
446 }
447 HILOGI("numOfPkts: %{public}u", numOfPkts);
448
449 return numOfPkts;
450 }
451
GetAvailableParameterSize(void) const452 uint16_t AvrcTgNotifyPacket::GetAvailableParameterSize(void) const
453 {
454 HILOGI("enter");
455
456 uint16_t remain = mtu_ - (AVRC_TG_VENDOR_FIXED_OPERAND_SIZE + AVRC_TG_GCPASV_NUM_OF_VALUES_SIZE);
457 if (remain > (AVRC_TG_GCPASV_MAX_NUM_OF_ATTRIBUTES + AVRC_TG_GCPASV_MAX_NUM_OF_VALUES)) {
458 remain = (AVRC_TG_GCPASV_MAX_NUM_OF_ATTRIBUTES + AVRC_TG_GCPASV_MAX_NUM_OF_VALUES);
459 }
460 uint16_t unitsOfParam = AVRC_TG_GCPASV_ATTRIBUTE_SIZE + AVRC_TG_GCPASV_VALUE_SIZE;
461
462 return (remain / unitsOfParam) * unitsOfParam;
463 }
464
IsValidEventId(void) const465 bool AvrcTgNotifyPacket::IsValidEventId(void) const
466 {
467 HILOGI("enter");
468
469 return ((eventId_ >= AVRC_TG_EVENT_ID_PLAYBACK_STATUS_CHANGED) && (eventId_ <= AVRC_TG_EVENT_ID_VOLUME_CHANGED));
470 }
471
IsSupportedEventId(void) const472 bool AvrcTgNotifyPacket::IsSupportedEventId(void) const
473 {
474 HILOGI("enter");
475
476 return !(eventId_ == AVRC_TG_EVENT_ID_BATT_STATUS_CHANGED || eventId_ == AVRC_TG_EVENT_ID_SYSTEM_STATUS_CHANGED);
477 }
478 } // namespace bluetooth
479 } // namespace OHOS