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