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