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