1 /*
2 * Copyright (c) 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 "avmeta_data.h"
17 #include "avsession_log.h"
18
19 namespace OHOS::AVSession {
Marshalling(Parcel & parcel) const20 bool AVMetaData::Marshalling(Parcel& parcel) const
21 {
22 return parcel.WriteString(metaMask_.to_string()) &&
23 parcel.WriteString(assetId_) &&
24 parcel.WriteString(title_) &&
25 parcel.WriteString(artist_) &&
26 parcel.WriteString(author_) &&
27 parcel.WriteString(avQueueName_) &&
28 parcel.WriteString(avQueueId_) &&
29 parcel.WriteString(avQueueImageUri_) &&
30 parcel.WriteString(album_) &&
31 parcel.WriteString(writer_) &&
32 parcel.WriteString(composer_) &&
33 parcel.WriteInt64(duration_) &&
34 parcel.WriteString(mediaImageUri_) &&
35 parcel.WriteDouble(publishDate_) &&
36 parcel.WriteString(subTitle_) &&
37 parcel.WriteString(description_) &&
38 parcel.WriteString(lyric_) &&
39 parcel.WriteString(singleLyricText_) &&
40 parcel.WriteString(previousAssetId_) &&
41 parcel.WriteString(nextAssetId_) &&
42 parcel.WriteInt32(skipIntervals_) &&
43 parcel.WriteInt32(filter_) &&
44 parcel.WriteInt32(displayTags_) &&
45 WriteDrmSchemes(parcel) &&
46 parcel.WriteParcelable(mediaImage_.get()) &&
47 parcel.WriteParcelable(avQueueImage_.get()) &&
48 parcel.WriteParcelable(bundleIcon_.get());
49 }
50
Unmarshalling(Parcel & data)51 AVMetaData *AVMetaData::Unmarshalling(Parcel& data)
52 {
53 std::string mask;
54 CHECK_AND_RETURN_RET_LOG(data.ReadString(mask) && mask.length() == META_KEY_MAX, nullptr, "mask not valid");
55 CHECK_AND_RETURN_RET_LOG(mask.find_first_not_of("01") == std::string::npos, nullptr, "mask string not 0 or 1");
56 auto *result = new (std::nothrow) AVMetaData();
57 CHECK_AND_RETURN_RET_LOG(result != nullptr, nullptr, "new AVMetaData failed");
58 result->metaMask_ = MetaMaskType(mask);
59
60 if (!UnmarshallingCheckParamTask(data, result)) {
61 delete result;
62 result = nullptr;
63 return nullptr;
64 }
65 if (!UnmarshallingCheckImageTask(data, result)) {
66 delete result;
67 result = nullptr;
68 return nullptr;
69 }
70 return result;
71 }
72
UnmarshallingCheckParamTask(Parcel & data,AVMetaData * result)73 bool AVMetaData::UnmarshallingCheckParamTask(Parcel& data, AVMetaData *result)
74 {
75 bool isParamUnsupport = (!data.ReadString(result->assetId_) ||
76 !data.ReadString(result->title_) ||
77 !data.ReadString(result->artist_) ||
78 !data.ReadString(result->author_) ||
79 !data.ReadString(result->avQueueName_) ||
80 !data.ReadString(result->avQueueId_) ||
81 !data.ReadString(result->avQueueImageUri_) ||
82 !data.ReadString(result->album_) ||
83 !data.ReadString(result->writer_) ||
84 !data.ReadString(result->composer_) ||
85 !data.ReadInt64(result->duration_) ||
86 !data.ReadString(result->mediaImageUri_) ||
87 !data.ReadDouble(result->publishDate_) ||
88 !data.ReadString(result->subTitle_) ||
89 !data.ReadString(result->description_) ||
90 !data.ReadString(result->lyric_) ||
91 !data.ReadString(result->singleLyricText_) ||
92 !data.ReadString(result->previousAssetId_) ||
93 !data.ReadString(result->nextAssetId_) ||
94 !data.ReadInt32(result->skipIntervals_) ||
95 !data.ReadInt32(result->filter_) ||
96 !data.ReadInt32(result->displayTags_) ||
97 !ReadDrmSchemes(data, result));
98 if (isParamUnsupport) {
99 SLOGE("read AVMetaData failed");
100 return false;
101 }
102 return true;
103 }
104
UnmarshallingCheckImageTask(Parcel & data,AVMetaData * result)105 bool AVMetaData::UnmarshallingCheckImageTask(Parcel& data, AVMetaData *result)
106 {
107 result->mediaImage_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
108 if (result->metaMask_.test(META_KEY_MEDIA_IMAGE) && result->mediaImage_ == nullptr) {
109 SLOGE("read PixelMap failed");
110 return false;
111 }
112 result->avQueueImage_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
113 if (result->metaMask_.test(META_KEY_AVQUEUE_IMAGE) && result->avQueueImage_ == nullptr) {
114 SLOGE("read avqueue PixelMap failed");
115 return false;
116 }
117 result->bundleIcon_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
118 if (result->metaMask_.test(META_KEY_BUNDLE_ICON) && result->bundleIcon_ == nullptr) {
119 SLOGE("read bundle icon failed");
120 return false;
121 }
122 return true;
123 }
124
MarshallingExceptImg(MessageParcel & data,const AVMetaData metaIn)125 bool AVMetaData::MarshallingExceptImg(MessageParcel& data, const AVMetaData metaIn)
126 {
127 bool ret = data.WriteString(metaIn.metaMask_.to_string()) &&
128 data.WriteString(metaIn.assetId_) &&
129 data.WriteString(metaIn.title_) &&
130 data.WriteString(metaIn.artist_) &&
131 data.WriteString(metaIn.author_) &&
132 data.WriteString(metaIn.avQueueName_) &&
133 data.WriteString(metaIn.avQueueId_) &&
134 data.WriteString(metaIn.avQueueImageUri_) &&
135 data.WriteString(metaIn.album_) &&
136 data.WriteString(metaIn.writer_) &&
137 data.WriteString(metaIn.composer_) &&
138 data.WriteInt64(metaIn.duration_) &&
139 data.WriteString(metaIn.mediaImageUri_) &&
140 data.WriteDouble(metaIn.publishDate_) &&
141 data.WriteString(metaIn.subTitle_) &&
142 data.WriteString(metaIn.description_) &&
143 data.WriteString(metaIn.lyric_) &&
144 data.WriteString(metaIn.singleLyricText_) &&
145 data.WriteString(metaIn.previousAssetId_) &&
146 data.WriteString(metaIn.nextAssetId_) &&
147 data.WriteInt32(metaIn.skipIntervals_) &&
148 data.WriteInt32(metaIn.filter_) &&
149 data.WriteInt32(metaIn.mediaLength_) &&
150 data.WriteInt32(metaIn.avQueueLength_) &&
151 data.WriteInt32(metaIn.displayTags_) &&
152 data.WriteParcelable(metaIn.bundleIcon_.get());
153 WriteDrmSchemes(data, metaIn);
154 SLOGD("MarshallingExceptImg without small img ret %{public}d", static_cast<int>(ret));
155 return ret;
156 }
157
UnmarshallingExceptImg(MessageParcel & data,AVMetaData & metaOut)158 bool AVMetaData::UnmarshallingExceptImg(MessageParcel& data, AVMetaData& metaOut)
159 {
160 std::string mask;
161 data.ReadString(mask);
162 int32_t maskSize = static_cast<int32_t>(mask.size());
163 if (maskSize <= 0 || maskSize > META_KEY_MAX) {
164 SLOGE("get err mask, return");
165 return false;
166 }
167 SLOGD("get mask with %{public}s", mask.c_str());
168 for (int32_t i = 0; i < maskSize; ++i) {
169 if (mask[i] == '1') {
170 metaOut.metaMask_.flip(maskSize - i - 1);
171 }
172 }
173
174 bool ret = !data.ReadString(metaOut.assetId_) ||
175 !data.ReadString(metaOut.title_) ||
176 !data.ReadString(metaOut.artist_) ||
177 !data.ReadString(metaOut.author_) ||
178 !data.ReadString(metaOut.avQueueName_) ||
179 !data.ReadString(metaOut.avQueueId_) ||
180 !data.ReadString(metaOut.avQueueImageUri_) ||
181 !data.ReadString(metaOut.album_) ||
182 !data.ReadString(metaOut.writer_) ||
183 !data.ReadString(metaOut.composer_) ||
184 !data.ReadInt64(metaOut.duration_) ||
185 !data.ReadString(metaOut.mediaImageUri_) ||
186 !data.ReadDouble(metaOut.publishDate_) ||
187 !data.ReadString(metaOut.subTitle_) ||
188 !data.ReadString(metaOut.description_) ||
189 !data.ReadString(metaOut.lyric_) ||
190 !data.ReadString(metaOut.singleLyricText_) ||
191 !data.ReadString(metaOut.previousAssetId_) ||
192 !data.ReadString(metaOut.nextAssetId_) ||
193 !data.ReadInt32(metaOut.skipIntervals_) ||
194 !data.ReadInt32(metaOut.filter_) ||
195 !data.ReadInt32(metaOut.mediaLength_) ||
196 !data.ReadInt32(metaOut.avQueueLength_) ||
197 !data.ReadInt32(metaOut.displayTags_);
198 metaOut.bundleIcon_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
199 if (metaOut.metaMask_.test(META_KEY_BUNDLE_ICON) && metaOut.bundleIcon_ == nullptr) {
200 SLOGE("read bundle icon failed");
201 return false;
202 }
203 ret = ret || !ReadDrmSchemes(data, metaOut);
204 SLOGD("UnmarshallingExceptImg with drm but no small img ret %{public}d", static_cast<int>(ret));
205 return ret;
206 }
207
WriteDrmSchemes(Parcel & parcel) const208 bool AVMetaData::WriteDrmSchemes(Parcel& parcel) const
209 {
210 CHECK_AND_RETURN_RET_LOG(parcel.WriteInt32(drmSchemes_.size()), false,
211 "write drmSchemes size failed");
212 for (auto drmScheme : drmSchemes_) {
213 CHECK_AND_RETURN_RET_LOG(parcel.WriteString(drmScheme), false, "write drmScheme failed");
214 }
215 return true;
216 }
217
WriteDrmSchemes(MessageParcel & parcel,const AVMetaData metaData)218 bool AVMetaData::WriteDrmSchemes(MessageParcel& parcel, const AVMetaData metaData)
219 {
220 CHECK_AND_RETURN_RET_LOG(parcel.WriteInt32(metaData.drmSchemes_.size()), false,
221 "write drmSchemes size failed");
222 for (auto drmScheme : metaData.drmSchemes_) {
223 CHECK_AND_RETURN_RET_LOG(parcel.WriteString(drmScheme), false, "write drmScheme failed");
224 }
225 return true;
226 }
227
ReadDrmSchemes(Parcel & parcel,AVMetaData * metaData)228 bool AVMetaData::ReadDrmSchemes(Parcel& parcel, AVMetaData *metaData)
229 {
230 int32_t drmSchemesLen = 0;
231 CHECK_AND_RETURN_RET_LOG(parcel.ReadInt32(drmSchemesLen), false, "read drmSchemesLen failed");
232 std::vector<std::string> drmSchemes;
233 int32_t maxDrmSchemesLen = 10;
234 CHECK_AND_RETURN_RET_LOG((drmSchemesLen >= 0) &&
235 (drmSchemesLen <= maxDrmSchemesLen), false, "drmSchemesLen is illegal");
236 for (int i = 0; i < drmSchemesLen; i++) {
237 std::string drmScheme;
238 CHECK_AND_RETURN_RET_LOG(parcel.ReadString(drmScheme), false, "read drmScheme failed");
239 drmSchemes.emplace_back(drmScheme);
240 }
241 metaData->drmSchemes_ = drmSchemes;
242 return true;
243 }
244
ReadDrmSchemes(MessageParcel & parcel,AVMetaData & metaData)245 bool AVMetaData::ReadDrmSchemes(MessageParcel& parcel, AVMetaData& metaData)
246 {
247 int32_t drmSchemesLen = 0;
248 CHECK_AND_RETURN_RET_LOG(parcel.ReadInt32(drmSchemesLen), false, "read drmSchemesLen failed");
249 std::vector<std::string> drmSchemes;
250 int32_t maxDrmSchemesLen = 10;
251 CHECK_AND_RETURN_RET_LOG((drmSchemesLen >= 0) &&
252 (drmSchemesLen <= maxDrmSchemesLen), false, "drmSchemesLen is illegal");
253 for (int i = 0; i < drmSchemesLen; i++) {
254 std::string drmScheme;
255 CHECK_AND_RETURN_RET_LOG(parcel.ReadString(drmScheme), false, "read drmScheme failed");
256 drmSchemes.emplace_back(drmScheme);
257 }
258 metaData.drmSchemes_ = drmSchemes;
259 return true;
260 }
261
SetAssetId(const std::string & assetId)262 void AVMetaData::SetAssetId(const std::string& assetId)
263 {
264 assetId_ = assetId;
265 metaMask_.set(META_KEY_ASSET_ID);
266 }
267
GetAssetId() const268 std::string AVMetaData::GetAssetId() const
269 {
270 return assetId_;
271 }
272
SetTitle(const std::string & title)273 void AVMetaData::SetTitle(const std::string& title)
274 {
275 title_ = title;
276 metaMask_.set(META_KEY_TITLE);
277 }
278
GetTitle() const279 std::string AVMetaData::GetTitle() const
280 {
281 return title_;
282 }
283
SetArtist(const std::string & artist)284 void AVMetaData::SetArtist(const std::string& artist)
285 {
286 artist_ = artist;
287 metaMask_.set(META_KEY_ARTIST);
288 }
289
GetArtist() const290 std::string AVMetaData::GetArtist() const
291 {
292 return artist_;
293 }
294
SetAuthor(const std::string & author)295 void AVMetaData::SetAuthor(const std::string& author)
296 {
297 author_ = author;
298 metaMask_.set(META_KEY_AUTHOR);
299 }
300
GetAuthor() const301 std::string AVMetaData::GetAuthor() const
302 {
303 return author_;
304 }
305
SetAVQueueName(const std::string & avQueueName)306 void AVMetaData::SetAVQueueName(const std::string& avQueueName)
307 {
308 avQueueName_ = avQueueName;
309 metaMask_.set(META_KEY_AVQUEUE_NAME);
310 }
311
GetAVQueueName() const312 std::string AVMetaData::GetAVQueueName() const
313 {
314 return avQueueName_;
315 }
316
SetAVQueueId(const std::string & avQueueId)317 void AVMetaData::SetAVQueueId(const std::string& avQueueId)
318 {
319 avQueueId_ = avQueueId;
320 metaMask_.set(META_KEY_AVQUEUE_ID);
321 }
322
GetAVQueueId() const323 std::string AVMetaData::GetAVQueueId() const
324 {
325 return avQueueId_;
326 }
327
SetAVQueueImage(const std::shared_ptr<AVSessionPixelMap> & avQueueImage)328 void AVMetaData::SetAVQueueImage(const std::shared_ptr<AVSessionPixelMap>& avQueueImage)
329 {
330 avQueueImage_ = avQueueImage;
331 metaMask_.set(META_KEY_AVQUEUE_IMAGE);
332 }
333
GetAVQueueImage() const334 std::shared_ptr<AVSessionPixelMap> AVMetaData::GetAVQueueImage() const
335 {
336 return avQueueImage_;
337 }
338
SetBundleIcon(const std::shared_ptr<AVSessionPixelMap> & bundleIcon)339 void AVMetaData::SetBundleIcon(const std::shared_ptr<AVSessionPixelMap>& bundleIcon)
340 {
341 bundleIcon_ = bundleIcon;
342 metaMask_.set(META_KEY_BUNDLE_ICON);
343 }
344
GetBundleIcon() const345 std::shared_ptr<AVSessionPixelMap> AVMetaData::GetBundleIcon() const
346 {
347 return bundleIcon_;
348 }
349
SetAVQueueImageUri(const std::string & avQueueImageUri)350 void AVMetaData::SetAVQueueImageUri(const std::string& avQueueImageUri)
351 {
352 avQueueImageUri_ = avQueueImageUri;
353 metaMask_.set(META_KEY_AVQUEUE_IMAGE_URI);
354 }
355
GetAVQueueImageUri() const356 std::string AVMetaData::GetAVQueueImageUri() const
357 {
358 return avQueueImageUri_;
359 }
360
SetAlbum(const std::string & album)361 void AVMetaData::SetAlbum(const std::string& album)
362 {
363 album_ = album;
364 metaMask_.set(META_KEY_ALBUM);
365 }
366
GetAlbum() const367 std::string AVMetaData::GetAlbum() const
368 {
369 return album_;
370 }
371
SetWriter(const std::string & writer)372 void AVMetaData::SetWriter(const std::string& writer)
373 {
374 writer_ = writer;
375 metaMask_.set(META_KEY_WRITER);
376 }
377
GetWriter() const378 std::string AVMetaData::GetWriter() const
379 {
380 return writer_;
381 }
382
SetComposer(const std::string & composer)383 void AVMetaData::SetComposer(const std::string& composer)
384 {
385 composer_ = composer;
386 metaMask_.set(META_KEY_COMPOSER);
387 }
388
GetComposer() const389 std::string AVMetaData::GetComposer() const
390 {
391 return composer_;
392 }
393
SetDuration(int64_t duration)394 void AVMetaData::SetDuration(int64_t duration)
395 {
396 if (duration < AVMetaData::DURATION_ALWAYS_PLAY) {
397 SLOGW("invalid duration");
398 }
399 duration_ = duration;
400 metaMask_.set(META_KEY_DURATION);
401 }
402
GetDuration() const403 int64_t AVMetaData::GetDuration() const
404 {
405 return duration_;
406 }
407
SetMediaImage(const std::shared_ptr<AVSessionPixelMap> & mediaImage)408 void AVMetaData::SetMediaImage(const std::shared_ptr<AVSessionPixelMap>& mediaImage)
409 {
410 mediaImage_ = mediaImage;
411 metaMask_.set(META_KEY_MEDIA_IMAGE);
412 }
413
GetMediaImage() const414 std::shared_ptr<AVSessionPixelMap> AVMetaData::GetMediaImage() const
415 {
416 return mediaImage_;
417 }
418
SetMediaImageUri(const std::string & mediaImageUri)419 void AVMetaData::SetMediaImageUri(const std::string& mediaImageUri)
420 {
421 mediaImageUri_ = mediaImageUri;
422 metaMask_.set(META_KEY_MEDIA_IMAGE_URI);
423 }
424
GetMediaImageUri() const425 std::string AVMetaData::GetMediaImageUri() const
426 {
427 return mediaImageUri_;
428 }
429
SetPublishDate(double date)430 void AVMetaData::SetPublishDate(double date)
431 {
432 if (date < 0) {
433 SLOGW("invalid publish date");
434 }
435 publishDate_ = date;
436 metaMask_.set(META_KEY_PUBLISH_DATE);
437 }
438
GetPublishDate() const439 double AVMetaData::GetPublishDate() const
440 {
441 return publishDate_;
442 }
443
SetSubTitle(const std::string & subTitle)444 void AVMetaData::SetSubTitle(const std::string& subTitle)
445 {
446 subTitle_ = subTitle;
447 metaMask_.set(META_KEY_SUBTITLE);
448 }
449
GetSubTitle() const450 std::string AVMetaData::GetSubTitle() const
451 {
452 return subTitle_;
453 }
454
SetDescription(const std::string & description)455 void AVMetaData::SetDescription(const std::string& description)
456 {
457 description_ = description;
458 metaMask_.set(META_KEY_DESCRIPTION);
459 }
460
GetDescription() const461 std::string AVMetaData::GetDescription() const
462 {
463 return description_;
464 }
465
SetLyric(const std::string & lyric)466 void AVMetaData::SetLyric(const std::string& lyric)
467 {
468 lyric_ = lyric;
469 metaMask_.set(META_KEY_LYRIC);
470 }
471
GetLyric() const472 std::string AVMetaData::GetLyric() const
473 {
474 return lyric_;
475 }
476
SetSingleLyricText(const std::string & singleLyricText)477 void AVMetaData::SetSingleLyricText(const std::string& singleLyricText)
478 {
479 singleLyricText_ = singleLyricText;
480 metaMask_.set(META_KEY_SINGLE_LYRIC_TEXT);
481 }
482
GetSingleLyricText() const483 std::string AVMetaData::GetSingleLyricText() const
484 {
485 return singleLyricText_;
486 }
487
SetPreviousAssetId(const std::string & assetId)488 void AVMetaData::SetPreviousAssetId(const std::string& assetId)
489 {
490 previousAssetId_ = assetId;
491 metaMask_.set(META_KEY_PREVIOUS_ASSET_ID);
492 }
493
GetPreviousAssetId() const494 std::string AVMetaData::GetPreviousAssetId() const
495 {
496 return previousAssetId_;
497 }
498
SetNextAssetId(const std::string & assetId)499 void AVMetaData::SetNextAssetId(const std::string& assetId)
500 {
501 nextAssetId_ = assetId;
502 metaMask_.set(META_KEY_NEXT_ASSET_ID);
503 }
504
GetNextAssetId() const505 std::string AVMetaData::GetNextAssetId() const
506 {
507 return nextAssetId_;
508 }
509
SetSkipIntervals(int32_t skipIntervals)510 void AVMetaData::SetSkipIntervals(int32_t skipIntervals)
511 {
512 SLOGD("SetSkipIntervals %{public}d", static_cast<int32_t>(skipIntervals));
513 skipIntervals_ = skipIntervals;
514 metaMask_.set(META_KEY_SKIP_INTERVALS);
515 }
516
GetSkipIntervals() const517 int32_t AVMetaData::GetSkipIntervals() const
518 {
519 SLOGD("GetSkipIntervals %{public}d", static_cast<int32_t>(skipIntervals_));
520 return skipIntervals_;
521 }
522
SetFilter(int32_t filter)523 void AVMetaData::SetFilter(int32_t filter)
524 {
525 SLOGD("SetFilter %{public}d", static_cast<int32_t>(filter));
526 filter_ = filter;
527 metaMask_.set(META_KEY_FILTER);
528 }
529
GetFilter() const530 int32_t AVMetaData::GetFilter() const
531 {
532 SLOGD("GetFilter %{public}d", static_cast<int32_t>(filter_));
533 return filter_;
534 }
535
SetMediaLength(int32_t mediaLength)536 void AVMetaData::SetMediaLength(int32_t mediaLength)
537 {
538 mediaLength_ = mediaLength;
539 }
540
GetMediaLength() const541 int32_t AVMetaData::GetMediaLength() const
542 {
543 return mediaLength_;
544 }
545
SetAVQueueLength(int32_t avQueueLength)546 void AVMetaData::SetAVQueueLength(int32_t avQueueLength)
547 {
548 avQueueLength_ = avQueueLength;
549 }
550
GetAVQueueLength() const551 int32_t AVMetaData::GetAVQueueLength() const
552 {
553 return avQueueLength_;
554 }
555
SetDisplayTags(int32_t displayTags)556 void AVMetaData::SetDisplayTags(int32_t displayTags)
557 {
558 SLOGD("SetDisplayTags %{public}d", static_cast<int32_t>(displayTags));
559 displayTags_ = displayTags;
560 metaMask_.set(META_KEY_DISPLAY_TAGS);
561 }
562
GetDisplayTags() const563 int32_t AVMetaData::GetDisplayTags() const
564 {
565 SLOGD("GetDisplayTags %{public}d", static_cast<int32_t>(displayTags_));
566 return displayTags_;
567 }
568
SetDrmSchemes(std::vector<std::string> drmSchemes)569 void AVMetaData::SetDrmSchemes(std::vector<std::string> drmSchemes)
570 {
571 drmSchemes_ = drmSchemes;
572 metaMask_.set(META_KEY_DRM_SCHEMES);
573 }
574
GetDrmSchemes() const575 std::vector<std::string> AVMetaData::GetDrmSchemes() const
576 {
577 return drmSchemes_;
578 }
579
GetMetaMask() const580 AVMetaData::MetaMaskType AVMetaData::GetMetaMask() const
581 {
582 return metaMask_;
583 }
584
Reset()585 void AVMetaData::Reset()
586 {
587 metaMask_.reset();
588 assetId_ = "";
589 title_ = "";
590 artist_ = "";
591 author_ = "";
592 avQueueName_ = "";
593 avQueueId_ = "";
594 avQueueImage_ = nullptr;
595 avQueueImageUri_ = "";
596 bundleIcon_ = nullptr;
597 album_ = "";
598 writer_ = "";
599 composer_ = "";
600 duration_ = 0;
601 mediaImage_ = nullptr;
602 mediaImageUri_ = "";
603 publishDate_ = 0;
604 subTitle_ = "";
605 description_ = "";
606 lyric_ = "";
607 singleLyricText_ = "";
608 previousAssetId_ = "";
609 nextAssetId_ = "";
610 skipIntervals_ = SECONDS_15;
611 displayTags_ = 0;
612 drmSchemes_.clear();
613 }
614
ResetExtAssetId()615 void AVMetaData::ResetExtAssetId()
616 {
617 metaMask_.reset();
618 metaMask_.set(META_KEY_ASSET_ID);
619 title_ = "";
620 artist_ = "";
621 author_ = "";
622 avQueueName_ = "";
623 avQueueId_ = "";
624 avQueueImage_ = nullptr;
625 avQueueImageUri_ = "";
626 album_ = "";
627 writer_ = "";
628 composer_ = "";
629 duration_ = 0;
630 mediaImage_ = nullptr;
631 mediaImageUri_ = "";
632 publishDate_ = 0;
633 subTitle_ = "";
634 description_ = "";
635 lyric_ = "";
636 singleLyricText_ = "";
637 previousAssetId_ = "";
638 nextAssetId_ = "";
639 skipIntervals_ = SECONDS_15;
640 displayTags_ = 0;
641 drmSchemes_.clear();
642 }
643
CopyToByMask(MetaMaskType & mask,AVMetaData & metaOut) const644 bool AVMetaData::CopyToByMask(MetaMaskType& mask, AVMetaData& metaOut) const
645 {
646 bool result = false;
647 auto intersection = metaMask_ & mask;
648 for (int i = 0; i < META_KEY_MAX; i++) {
649 if (intersection.test(i)) {
650 cloneActions[i](*this, metaOut);
651 metaOut.metaMask_.set(i);
652 result = true;
653 }
654 }
655
656 return result;
657 }
658
CopyFrom(const AVMetaData & metaIn)659 bool AVMetaData::CopyFrom(const AVMetaData& metaIn)
660 {
661 if (metaIn.assetId_.empty()) {
662 SLOGE("assetId is empty");
663 return false;
664 }
665
666 if (metaIn.assetId_ != assetId_) {
667 SLOGD("assetId not equal here");
668 *this = metaIn;
669 return true;
670 }
671
672 bool result = false;
673 for (int i = 0; i < META_KEY_MAX; i++) {
674 if (metaIn.metaMask_.test(i)) {
675 cloneActions[i](metaIn, *this);
676 metaMask_.set(i);
677 result = true;
678 }
679 }
680
681 return result;
682 }
683
EqualWithUri(const AVMetaData & metaData)684 bool AVMetaData::EqualWithUri(const AVMetaData& metaData)
685 {
686 if (metaData.mediaImage_ != nullptr) {
687 SLOGI("Current fun cannot determine whether mediaImage_ is equal,\
688 not perform subsequent judgments when mediaImage_ is not null.");
689 return false;
690 }
691
692 return (assetId_ == metaData.assetId_)
693 && (title_ == metaData.title_)
694 && (artist_ == metaData.artist_)
695 && (author_ == metaData.author_)
696 && (avQueueName_ == metaData.avQueueName_)
697 && (avQueueId_ == metaData.avQueueId_)
698 && (avQueueImageUri_ == metaData.avQueueImageUri_)
699 && (album_ == metaData.album_)
700 && (writer_ == metaData.writer_)
701 && (composer_ == metaData.composer_)
702 && (duration_ == metaData.duration_)
703 && (mediaImageUri_ == metaData.mediaImageUri_)
704 && (publishDate_ == metaData.publishDate_)
705 && (subTitle_ == metaData.subTitle_)
706 && (description_ == metaData.description_)
707 && (lyric_ == metaData.lyric_)
708 && (singleLyricText_ == metaData.singleLyricText_)
709 && (previousAssetId_ == metaData.previousAssetId_)
710 && (nextAssetId_ == metaData.nextAssetId_)
711 && (skipIntervals_ == metaData.skipIntervals_)
712 && (filter_ == metaData.filter_)
713 && (displayTags_ == metaData.displayTags_)
714 && (drmSchemes_ == metaData.drmSchemes_);
715 }
716
IsValid() const717 bool AVMetaData::IsValid() const
718 {
719 return duration_ >= AVMetaData::DURATION_ALWAYS_PLAY && publishDate_ >= 0
720 && displayTags_ <= AVMetaData::DISPLAY_TAG_ALL;
721 }
722
CloneAssetId(const AVMetaData & from,AVMetaData & to)723 void AVMetaData::CloneAssetId(const AVMetaData& from, AVMetaData& to)
724 {
725 to.assetId_ = from.assetId_;
726 }
727
CloneTitle(const AVMetaData & from,AVMetaData & to)728 void AVMetaData::CloneTitle(const AVMetaData& from, AVMetaData& to)
729 {
730 to.title_ = from.title_;
731 }
732
CloneArtist(const AVMetaData & from,AVMetaData & to)733 void AVMetaData::CloneArtist(const AVMetaData& from, AVMetaData& to)
734 {
735 to.artist_ = from.artist_;
736 }
737
CloneAuthor(const AVMetaData & from,AVMetaData & to)738 void AVMetaData::CloneAuthor(const AVMetaData& from, AVMetaData& to)
739 {
740 to.author_ = from.author_;
741 }
742
CloneAVQueueName(const AVMetaData & from,AVMetaData & to)743 void AVMetaData::CloneAVQueueName(const AVMetaData& from, AVMetaData& to)
744 {
745 to.avQueueName_ = from.avQueueName_;
746 }
747
CloneAVQueueId(const AVMetaData & from,AVMetaData & to)748 void AVMetaData::CloneAVQueueId(const AVMetaData& from, AVMetaData& to)
749 {
750 to.avQueueId_ = from.avQueueId_;
751 }
752
CloneAVQueueImage(const AVMetaData & from,AVMetaData & to)753 void AVMetaData::CloneAVQueueImage(const AVMetaData& from, AVMetaData& to)
754 {
755 to.avQueueImage_ = from.avQueueImage_;
756 }
757
CloneAVQueueImageUri(const AVMetaData & from,AVMetaData & to)758 void AVMetaData::CloneAVQueueImageUri(const AVMetaData& from, AVMetaData& to)
759 {
760 to.avQueueImageUri_ = from.avQueueImageUri_;
761 }
762
CloneBundleIcon(const AVMetaData & from,AVMetaData & to)763 void AVMetaData::CloneBundleIcon(const AVMetaData& from, AVMetaData& to)
764 {
765 to.bundleIcon_ = from.bundleIcon_;
766 }
767
CloneAlbum(const AVMetaData & from,AVMetaData & to)768 void AVMetaData::CloneAlbum(const AVMetaData& from, AVMetaData& to)
769 {
770 to.album_ = from.album_;
771 }
772
CloneWriter(const AVMetaData & from,AVMetaData & to)773 void AVMetaData::CloneWriter(const AVMetaData& from, AVMetaData& to)
774 {
775 to.writer_ = from.writer_;
776 }
777
CloneComposer(const AVMetaData & from,AVMetaData & to)778 void AVMetaData::CloneComposer(const AVMetaData& from, AVMetaData& to)
779 {
780 to.composer_ = from.composer_;
781 }
782
CloneDuration(const AVMetaData & from,AVMetaData & to)783 void AVMetaData::CloneDuration(const AVMetaData& from, AVMetaData& to)
784 {
785 to.duration_ = from.duration_;
786 }
787
CloneMediaImage(const AVMetaData & from,AVMetaData & to)788 void AVMetaData::CloneMediaImage(const AVMetaData& from, AVMetaData& to)
789 {
790 to.mediaImage_ = from.mediaImage_;
791 }
792
CloneMediaImageUri(const AVMetaData & from,AVMetaData & to)793 void AVMetaData::CloneMediaImageUri(const AVMetaData& from, AVMetaData& to)
794 {
795 to.mediaImageUri_ = from.mediaImageUri_;
796 }
797
ClonePublishData(const AVMetaData & from,AVMetaData & to)798 void AVMetaData::ClonePublishData(const AVMetaData& from, AVMetaData& to)
799 {
800 to.publishDate_ = from.publishDate_;
801 }
802
CloneSubTitle(const AVMetaData & from,AVMetaData & to)803 void AVMetaData::CloneSubTitle(const AVMetaData& from, AVMetaData& to)
804 {
805 to.subTitle_ = from.subTitle_;
806 }
807
CloneDescription(const AVMetaData & from,AVMetaData & to)808 void AVMetaData::CloneDescription(const AVMetaData& from, AVMetaData& to)
809 {
810 to.description_ = from.description_;
811 }
812
CloneLyric(const AVMetaData & from,AVMetaData & to)813 void AVMetaData::CloneLyric(const AVMetaData& from, AVMetaData& to)
814 {
815 to.lyric_ = from.lyric_;
816 }
817
CloneSingleLyricText(const AVMetaData & from,AVMetaData & to)818 void AVMetaData::CloneSingleLyricText(const AVMetaData& from, AVMetaData& to)
819 {
820 to.singleLyricText_ = from.singleLyricText_;
821 }
822
ClonePreviousAssetId(const AVMetaData & from,AVMetaData & to)823 void AVMetaData::ClonePreviousAssetId(const AVMetaData& from, AVMetaData& to)
824 {
825 to.previousAssetId_ = from.previousAssetId_;
826 }
827
CloneNextAssetId(const AVMetaData & from,AVMetaData & to)828 void AVMetaData::CloneNextAssetId(const AVMetaData& from, AVMetaData& to)
829 {
830 to.nextAssetId_ = from.nextAssetId_;
831 }
832
CloneSkipIntervals(const AVMetaData & from,AVMetaData & to)833 void AVMetaData::CloneSkipIntervals(const AVMetaData& from, AVMetaData& to)
834 {
835 to.skipIntervals_ = from.skipIntervals_;
836 }
837
CloneFilter(const AVMetaData & from,AVMetaData & to)838 void AVMetaData::CloneFilter(const AVMetaData& from, AVMetaData& to)
839 {
840 to.filter_ = from.filter_;
841 }
842
CloneDisplayTags(const AVMetaData & from,AVMetaData & to)843 void AVMetaData::CloneDisplayTags(const AVMetaData& from, AVMetaData& to)
844 {
845 to.displayTags_ = from.displayTags_;
846 }
847
CloneDrmSchemes(const AVMetaData & from,AVMetaData & to)848 void AVMetaData::CloneDrmSchemes(const AVMetaData& from, AVMetaData& to)
849 {
850 to.drmSchemes_ = from.drmSchemes_;
851 }
852 } // namespace OHOS::AVSession
853