1 /*
2 * Copyright (C) 2021 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 "media_lib_proxy.h"
17 #include "media_file_utils.h"
18 #include "media_log.h"
19
20 using namespace std;
21 namespace OHOS {
22 namespace Media {
MediaLibProxy(const sptr<IRemoteObject> & impl)23 MediaLibProxy::MediaLibProxy(const sptr<IRemoteObject> &impl)
24 : IRemoteProxy<IMediaLibService>(impl) { }
25
GetMediaLibraryClientInstance()26 IMediaLibraryClient *IMediaLibraryClient::GetMediaLibraryClientInstance()
27 {
28 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
29 if (samgr == nullptr) {
30 MEDIA_ERR_LOG("samgr object is NULL.");
31 return nullptr;
32 }
33
34 sptr<IRemoteObject> object = samgr->GetSystemAbility(MEDIA_LIBRARY_SERVICE_ID);
35 if (object == nullptr) {
36 MEDIA_ERR_LOG("Media Service object is NULL.");
37 return nullptr;
38 }
39
40 static MediaLibProxy msProxy(object);
41
42 return &msProxy;
43 }
44
CopyUriToDstMediaAsset(const MediaAsset & assetData)45 bool CopyUriToDstMediaAsset(const MediaAsset &assetData)
46 {
47 bool errCode = false;
48 MediaAsset *dstAsset = (MediaAsset *)&assetData;
49
50 // If albumname is empty, napi returns false
51 if (!(dstAsset->albumName_.empty())) {
52 dstAsset->uri_ = ROOT_MEDIA_DIR + dstAsset->albumName_;
53 errCode = true;
54 }
55
56 return errCode;
57 }
58
ModifyDstMediaAssetUri(const MediaAsset & assetData)59 void ModifyDstMediaAssetUri(const MediaAsset &assetData)
60 {
61 MediaAsset *dstAsset = (MediaAsset *)&assetData;
62
63 size_t slashIndex = dstAsset->uri_.rfind("/");
64 if (slashIndex != string::npos) {
65 string dirPath = dstAsset->uri_.substr(0, slashIndex);
66 dstAsset->uri_ = dirPath + "/" + dstAsset->name_;
67 }
68 }
69
WriteCommonData(const MediaAsset & assetData,const MessageParcel & dataMsg)70 int32_t WriteCommonData(const MediaAsset &assetData, const MessageParcel &dataMsg)
71 {
72 MessageParcel *data = (MessageParcel *)&dataMsg;
73 MediaAsset *asset = (MediaAsset *)&assetData;
74
75 if (data->WriteInt32(asset->id_) &&
76 data->WriteUint64(asset->size_) &&
77 data->WriteInt32(asset->albumId_) &&
78 data->WriteString(asset->albumName_) &&
79 data->WriteString(asset->uri_) &&
80 data->WriteInt32(asset->mediaType_) &&
81 data->WriteString(asset->name_) &&
82 data->WriteUint64(asset->dateAdded_) &&
83 data->WriteUint64(asset->dateModified_)) {
84 return SUCCESS;
85 }
86
87 return COMMON_DATA_WRITE_FAIL;
88 }
89
ReadCommonData(const MediaAsset & assetData,const MessageParcel & replyMsg)90 void ReadCommonData(const MediaAsset &assetData, const MessageParcel &replyMsg)
91 {
92 MessageParcel *reply = (MessageParcel *)&replyMsg;
93 MediaAsset *asset = (MediaAsset *)&assetData;
94
95 asset->id_ = reply->ReadInt32();
96 asset->size_ = reply->ReadUint64();
97 asset->albumId_ = reply->ReadInt32();
98 asset->albumName_ = reply->ReadString();
99 asset->uri_ = reply->ReadString();
100 asset->mediaType_ = (MediaType)reply->ReadInt32();
101 asset->name_ = reply->ReadString();
102 asset->dateAdded_ = reply->ReadUint64();
103 asset->dateModified_ = reply->ReadUint64();
104 }
105
WriteAlbumdata(const AlbumAsset & assetData,const MessageParcel & dataMsg)106 int32_t WriteAlbumdata(const AlbumAsset& assetData, const MessageParcel& dataMsg)
107 {
108 MessageParcel *data = (MessageParcel *)&dataMsg;
109 AlbumAsset *albumAsset = (AlbumAsset *)&assetData;
110
111 if (data->WriteInt32(albumAsset->GetAlbumId()) &&
112 data->WriteString(albumAsset->GetAlbumName())) {
113 return SUCCESS;
114 }
115
116 return ALBUM_ASSET_WRITE_FAIL;
117 }
118
ReadMediaAlbumdata(const AlbumAsset & assetData,const MessageParcel & replyMsg)119 void ReadMediaAlbumdata(const AlbumAsset& assetData, const MessageParcel& replyMsg)
120 {
121 MessageParcel *reply = (MessageParcel *)&replyMsg;
122 AlbumAsset *albumAsset = (AlbumAsset *)&assetData;
123
124 albumAsset->SetAlbumId(reply->ReadInt32());
125 albumAsset->SetAlbumName(reply->ReadString());
126 }
127
ReadMediaList(vector<unique_ptr<MediaAsset>> & mediaAssetList,MessageParcel & reply)128 int32_t ReadMediaList(vector<unique_ptr<MediaAsset>> &mediaAssetList, MessageParcel &reply)
129 {
130 int32_t errCode = SUCCESS;
131 int32_t count = reply.ReadInt32();
132
133 for (int32_t i = 0; i < count; i++) {
134 unique_ptr<MediaAsset> mediaAsset = make_unique<MediaAsset>();
135 if (mediaAsset) {
136 ReadCommonData(*mediaAsset, reply);
137 mediaAssetList.push_back(move(mediaAsset));
138 } else {
139 MEDIA_ERR_LOG("MediaLibProxy::MediaAsset allocation failed");
140 errCode = MEDIA_ASSET_READ_FAIL;
141 break;
142 }
143 }
144
145 return errCode;
146 }
147
ReadImageList(vector<unique_ptr<ImageAsset>> & imageAssetList,MessageParcel & reply)148 int32_t ReadImageList(vector<unique_ptr<ImageAsset>> &imageAssetList, MessageParcel &reply)
149 {
150 int32_t errCode = SUCCESS;
151 int32_t count = reply.ReadInt32();
152
153 for (int32_t i = 0; i < count; i++) {
154 unique_ptr<ImageAsset> imageAsset = make_unique<ImageAsset>();
155 if (imageAsset) {
156 ReadCommonData(*imageAsset, reply);
157 imageAsset->width_ = reply.ReadInt32();
158 imageAsset->height_ = reply.ReadInt32();
159 imageAsset->mimeType_ = reply.ReadString();
160
161 imageAssetList.push_back(move(imageAsset));
162 } else {
163 MEDIA_ERR_LOG("MediaLibProxy::ImageAsset allocation failed");
164 errCode = IMAGE_ASSET_READ_FAIL;
165 break;
166 }
167 }
168
169 return errCode;
170 }
171
ReadVideoList(vector<unique_ptr<VideoAsset>> & videoAssetList,MessageParcel & reply)172 int32_t ReadVideoList(vector<unique_ptr<VideoAsset>> &videoAssetList, MessageParcel &reply)
173 {
174 int32_t errCode = SUCCESS;
175 int32_t count = reply.ReadInt32();
176
177 for (int32_t i = 0; i < count; i++) {
178 unique_ptr<VideoAsset> videoAsset = make_unique<VideoAsset>();
179 if (videoAsset) {
180 ReadCommonData(*videoAsset, reply);
181 videoAsset->width_ = reply.ReadInt32();
182 videoAsset->height_ = reply.ReadInt32();
183 videoAsset->duration_ = reply.ReadInt32();
184 videoAsset->mimeType_ = reply.ReadString();
185
186 videoAssetList.push_back(move(videoAsset));
187 } else {
188 MEDIA_ERR_LOG("MediaLibProxy::VideoAsset allocation failed");
189 errCode = VIDEO_ASSET_READ_FAIL;
190 break;
191 }
192 }
193
194 return errCode;
195 }
196
ReadAudioList(vector<unique_ptr<AudioAsset>> & audioAssetList,MessageParcel & reply)197 int32_t ReadAudioList(vector<unique_ptr<AudioAsset>> &audioAssetList, MessageParcel &reply)
198 {
199 int32_t errCode = SUCCESS;
200 int32_t count = reply.ReadInt32();
201
202 for (int32_t i = 0; i < count; i++) {
203 unique_ptr<AudioAsset> audioAsset = make_unique<AudioAsset>();
204 if (audioAsset) {
205 ReadCommonData(*audioAsset, reply);
206
207 audioAsset->title_ = reply.ReadString();
208 audioAsset->artist_ = reply.ReadString();
209 audioAsset->duration_ = reply.ReadInt32();
210 audioAsset->mimeType_ = reply.ReadString();
211
212 audioAssetList.push_back(move(audioAsset));
213 } else {
214 MEDIA_ERR_LOG("MediaLibProxy::AudioAsset allocation failed");
215 errCode = AUDIO_ASSET_READ_FAIL;
216 break;
217 }
218 }
219
220 return errCode;
221 }
222
ReadImageAlbumList(vector<unique_ptr<AlbumAsset>> & imageAlbumList,MessageParcel & reply)223 int32_t ReadImageAlbumList(vector<unique_ptr<AlbumAsset>> &imageAlbumList, MessageParcel &reply)
224 {
225 int32_t errCode = SUCCESS;
226 int32_t count = reply.ReadInt32();
227
228 for (int32_t i = 0; i < count; i++) {
229 unique_ptr<AlbumAsset> imageAlbum = make_unique<AlbumAsset>();
230 if (imageAlbum) {
231 imageAlbum->SetAlbumId(reply.ReadInt32());
232 imageAlbum->SetAlbumName(reply.ReadString());
233
234 if (ReadImageList(imageAlbum->imageAssetList_, reply) == IMAGE_ASSET_READ_FAIL) {
235 MEDIA_ERR_LOG("MediaLibProxy::AlbumAsset read image list failed");
236 errCode = IMAGEALBUM_ASSET_READ_FAIL;
237 break;
238 }
239 imageAlbumList.push_back(move(imageAlbum));
240 } else {
241 MEDIA_ERR_LOG("MediaLibProxy::AlbumAsset allocation failed");
242 errCode = IMAGEALBUM_ASSET_READ_FAIL;
243 break;
244 }
245 }
246
247 return errCode;
248 }
249
ReadVideoAlbumList(vector<unique_ptr<AlbumAsset>> & videoAlbumList,MessageParcel & reply)250 int32_t ReadVideoAlbumList(vector<unique_ptr<AlbumAsset>> &videoAlbumList, MessageParcel &reply)
251 {
252 int32_t errCode = SUCCESS;
253 int32_t count = reply.ReadInt32();
254
255 for (int32_t i = 0; i < count; i++) {
256 unique_ptr<AlbumAsset> videoAlbum = make_unique<AlbumAsset>();
257 if (videoAlbum) {
258 videoAlbum->SetAlbumId(reply.ReadInt32());
259 videoAlbum->SetAlbumName(reply.ReadString());
260
261 if (ReadVideoList(videoAlbum->videoAssetList_, reply) == VIDEO_ASSET_READ_FAIL) {
262 MEDIA_ERR_LOG("MediaLibProxy::AlbumAsset read video list failed");
263 errCode = VIDEOALBUM_ASSET_READ_FAIL;
264 break;
265 }
266 videoAlbumList.push_back(move(videoAlbum));
267 } else {
268 MEDIA_ERR_LOG("MediaLibProxy::AlbumAsset allocation failed");
269 errCode = VIDEOALBUM_ASSET_READ_FAIL;
270 break;
271 }
272 }
273
274 return errCode;
275 }
276
GetImageAssets(string selection,vector<string> selArgs)277 vector<unique_ptr<ImageAsset>> MediaLibProxy::GetImageAssets(string selection,
278 vector<string> selArgs)
279 {
280 MessageParcel data;
281 MessageParcel reply;
282 MessageOption option;
283 vector<unique_ptr<ImageAsset>> imageAssetList;
284
285 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
286 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
287 return imageAssetList;
288 }
289
290 if ((data.WriteString(selection)) && (data.WriteStringVector(selArgs))) {
291 int32_t error = Remote()->SendRequest(MEDIA_GET_IMAGE_ASSETS, data, reply, option);
292 if (error != ERR_NONE) {
293 MEDIA_ERR_LOG("GetImageAssets failed, error: %{public}d", error);
294 return imageAssetList;
295 }
296 (void)ReadImageList(imageAssetList, reply);
297 } else {
298 MEDIA_ERR_LOG("data.WriteStringFailed");
299 }
300
301 return imageAssetList;
302 }
303
GetAudioAssets(string selection,vector<string> selArgs)304 vector<unique_ptr<AudioAsset>> MediaLibProxy::GetAudioAssets(string selection,
305 vector<string> selArgs)
306 {
307 MessageParcel data;
308 MessageParcel reply;
309 MessageOption option;
310 vector<unique_ptr<AudioAsset>> audioAssetList;
311
312 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
313 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
314 return audioAssetList;
315 }
316
317 if ((data.WriteString(selection)) && (data.WriteStringVector(selArgs))) {
318 int32_t error = Remote()->SendRequest(MEDIA_GET_AUDIO_ASSETS, data, reply, option);
319 if (error != ERR_NONE) {
320 MEDIA_ERR_LOG("GetAudioAssets failed, error: %{public}d", error);
321 return audioAssetList;
322 }
323 (void)ReadAudioList(audioAssetList, reply);
324 } else {
325 MEDIA_ERR_LOG("data.WriteStringFailed");
326 }
327
328 return audioAssetList;
329 }
330
GetVideoAssets(string selection,vector<string> selArgs)331 vector<unique_ptr<VideoAsset>> MediaLibProxy::GetVideoAssets(string selection, vector<string> selArgs)
332 {
333 MessageParcel data;
334 MessageParcel reply;
335 MessageOption option;
336 vector<unique_ptr<VideoAsset>> videoAssetList;
337
338 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
339 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
340 return videoAssetList;
341 }
342
343 if ((data.WriteString(selection)) && (data.WriteStringVector(selArgs))) {
344 int32_t error = Remote()->SendRequest(MEDIA_GET_VIDEO_ASSETS, data, reply, option);
345 if (error != ERR_NONE) {
346 MEDIA_ERR_LOG("GetVideoAssets failed, error: %{public}d", error);
347 return videoAssetList;
348 }
349 (void)ReadVideoList(videoAssetList, reply);
350 } else {
351 MEDIA_ERR_LOG("data.WriteStringFailed");
352 }
353
354 return videoAssetList;
355 }
356
GetMediaAssets(string selection,vector<string> selArgs)357 vector<unique_ptr<MediaAsset>> MediaLibProxy::GetMediaAssets(string selection, vector<string> selArgs)
358 {
359 MessageParcel data;
360 MessageParcel reply;
361 MessageOption option;
362 vector<unique_ptr<MediaAsset>> mediaAssetList;
363
364 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
365 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
366 return mediaAssetList;
367 }
368
369 if ((data.WriteString(selection)) && (data.WriteStringVector(selArgs))) {
370 int32_t error = Remote()->SendRequest(MEDIA_GET_MEDIA_ASSETS, data, reply, option);
371 if (error != ERR_NONE) {
372 MEDIA_ERR_LOG("GetMediaAssets failed, error: %{public}d", error);
373 return mediaAssetList;
374 }
375 (void)ReadMediaList(mediaAssetList, reply);
376 } else {
377 MEDIA_ERR_LOG("data.WriteStringFailed");
378 }
379
380 return mediaAssetList;
381 }
382
GetImageAlbumAssets(string selection,vector<string> selArgs)383 vector<unique_ptr<AlbumAsset>> MediaLibProxy::GetImageAlbumAssets(string selection, vector<string> selArgs)
384 {
385 MessageParcel data;
386 MessageParcel reply;
387 MessageOption option;
388 vector<unique_ptr<AlbumAsset>> albumAssetList;
389
390 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
391 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
392 return albumAssetList;
393 }
394
395 if ((data.WriteString(selection)) && (data.WriteStringVector(selArgs))) {
396 int32_t error = Remote()->SendRequest(MEDIA_GET_IMAGEALBUM_ASSETS, data, reply, option);
397 if (error != ERR_NONE) {
398 MEDIA_ERR_LOG("GetImageAlbumAssets failed, error: %{public}d", error);
399 return albumAssetList;
400 }
401 (void)ReadImageAlbumList(albumAssetList, reply);
402 } else {
403 MEDIA_ERR_LOG("data.WriteStringFailed");
404 }
405
406 return albumAssetList;
407 }
408
GetVideoAlbumAssets(string selection,vector<string> selArgs)409 vector<unique_ptr<AlbumAsset>> MediaLibProxy::GetVideoAlbumAssets(string selection, vector<string> selArgs)
410 {
411 MessageParcel data;
412 MessageParcel reply;
413 MessageOption option;
414 vector<unique_ptr<AlbumAsset>> albumAssetList;
415
416 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
417 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
418 return albumAssetList;
419 }
420
421 if ((data.WriteString(selection)) && (data.WriteStringVector(selArgs))) {
422 int32_t error = Remote()->SendRequest(MEDIA_GET_VIDEOALBUM_ASSETS, data, reply, option);
423 if (error != ERR_NONE) {
424 MEDIA_ERR_LOG("GetVideoAlbumAssets failed, error: %{public}d", error);
425 return albumAssetList;
426 }
427 (void)ReadVideoAlbumList(albumAssetList, reply);
428 } else {
429 MEDIA_ERR_LOG("data.WriteStringFailed");
430 }
431
432 return albumAssetList;
433 }
434
CreateMediaAsset(AssetType assetType,const MediaAsset & mediaAsset)435 bool MediaLibProxy::CreateMediaAsset(AssetType assetType, const MediaAsset& mediaAsset)
436 {
437 bool errRet = true;
438 MessageParcel data;
439 MessageParcel reply;
440 MessageOption option;
441
442 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
443 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
444 return false;
445 }
446
447 if ((data.WriteInt32(assetType) && (WriteCommonData(mediaAsset, data) == SUCCESS))) {
448 int32_t error = Remote()->SendRequest(MEDIA_CREATE_MEDIA_ASSET, data, reply, option);
449 if (error != ERR_NONE) {
450 MEDIA_ERR_LOG("CreateMedia failed, error: %{public}d", error);
451 errRet = false;
452 }
453 } else {
454 errRet = false;
455 MEDIA_ERR_LOG("CreateMediaAsset wrtie data failed !!");
456 }
457
458 return errRet;
459 }
460
DeleteMediaAsset(AssetType assetType,const MediaAsset & mediaAsset)461 bool MediaLibProxy::DeleteMediaAsset(AssetType assetType, const MediaAsset& mediaAsset)
462 {
463 bool errRet = true;
464 MessageParcel data;
465 MessageParcel reply;
466 MessageOption option;
467
468 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
469 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
470 return false;
471 }
472
473 if ((data.WriteInt32(assetType) && (WriteCommonData(mediaAsset, data) == SUCCESS))) {
474 int32_t error = Remote()->SendRequest(MEDIA_DELETE_MEDIA_ASSET, data, reply, option);
475 if (error != ERR_NONE) {
476 MEDIA_ERR_LOG("DeleteMediaAsset SendRequest failed, error: %{public}d", error);
477 errRet = false;
478 }
479 } else {
480 errRet = false;
481 }
482
483 return errRet;
484 }
485
ModifyMediaAsset(AssetType assetType,const MediaAsset & srcMediaAsset,const MediaAsset & dstMediaAsset)486 bool MediaLibProxy::ModifyMediaAsset(AssetType assetType, const MediaAsset &srcMediaAsset,
487 const MediaAsset &dstMediaAsset)
488 {
489 bool errRet = true;
490 MessageParcel data;
491 MessageParcel reply;
492 MessageOption option;
493
494 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
495 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
496 return false;
497 }
498
499 ModifyDstMediaAssetUri(dstMediaAsset);
500
501 if ((data.WriteInt32(assetType)) && (WriteCommonData(srcMediaAsset, data) == SUCCESS) &&
502 (WriteCommonData(dstMediaAsset, data) == SUCCESS)) {
503 int32_t error = Remote()->SendRequest(MEDIA_MODIFY_MEDIA_ASSET, data, reply, option);
504 if (error != ERR_NONE) {
505 MEDIA_ERR_LOG("ModifyMediaAsset SendRequest failed, error: %{public}d", error);
506 errRet = false;
507 }
508 } else {
509 errRet = false;
510 MEDIA_ERR_LOG("ModifyMediaAsset write data failed !!");
511 }
512
513 return errRet;
514 }
515
CopyMediaAsset(AssetType assetType,const MediaAsset & srcMediaAsset,const MediaAsset & dstMediaAsset)516 bool MediaLibProxy::CopyMediaAsset(AssetType assetType, const MediaAsset &srcMediaAsset,
517 const MediaAsset &dstMediaAsset)
518 {
519 bool errRet = true;
520 MessageParcel data;
521 MessageParcel reply;
522 MessageOption option;
523
524 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
525 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
526 return false;
527 }
528
529 if ((CopyUriToDstMediaAsset(dstMediaAsset) == true) && (data.WriteInt32(assetType)) &&
530 (WriteCommonData(srcMediaAsset, data) == SUCCESS) &&
531 (WriteCommonData(dstMediaAsset, data) == SUCCESS)) {
532 int32_t error = Remote()->SendRequest(MEDIA_COPY_MEDIA_ASSET, data, reply, option);
533 if (error != ERR_NONE) {
534 MEDIA_ERR_LOG("CopyMediaAsset SendRequest failed, error: %{public}d", error);
535 errRet = false;
536 }
537 } else {
538 errRet = false;
539 MEDIA_ERR_LOG("CopyMediaAsset: write data failed !!");
540 }
541
542 return errRet;
543 }
544
CreateMediaAlbumAsset(AssetType assetType,const AlbumAsset & albumAsset)545 bool MediaLibProxy::CreateMediaAlbumAsset(AssetType assetType, const AlbumAsset& albumAsset)
546 {
547 bool errRet = true;
548 MessageParcel data;
549 MessageParcel reply;
550 MessageOption option;
551
552 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
553 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
554 return false;
555 }
556
557 if ((data.WriteInt32(assetType)) && (WriteAlbumdata(albumAsset, data) == SUCCESS)) {
558 int32_t error = Remote()->SendRequest(MEDIA_CREATE_MEDIA_ALBUM_ASSET, data, reply, option);
559 if (error != ERR_NONE) {
560 MEDIA_ERR_LOG("CreateMediaAlbumAsset SendRequest failed, error: %{public}d", error);
561 errRet = false;
562 }
563 } else {
564 MEDIA_ERR_LOG("CreateMediaAlbumAsset WriteAlbumdata failed");
565 errRet = false;
566 }
567
568 return errRet;
569 }
570
DeleteMediaAlbumAsset(AssetType assetType,const AlbumAsset & albumAsset,const string & albumUri)571 bool MediaLibProxy::DeleteMediaAlbumAsset(AssetType assetType, const AlbumAsset& albumAsset,
572 const string &albumUri)
573 {
574 bool errRet = false;
575 MessageParcel data;
576 MessageParcel reply;
577 MessageOption option;
578
579 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
580 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
581 return false;
582 }
583
584 if ((assetType == ASSET_IMAGEALBUM) && (data.WriteInt32(assetType)) &&
585 (WriteAlbumdata(albumAsset, data) == SUCCESS) && data.WriteString(albumUri)) {
586 MEDIA_ERR_LOG("DeleteMediaAlbumAsset-WriteAlbumdata done");
587 errRet = true;
588 } else if ((assetType == ASSET_VIDEOALBUM) && (data.WriteInt32(assetType)) &&
589 (WriteAlbumdata(albumAsset, data) == SUCCESS) && data.WriteString(albumUri)) {
590 MEDIA_ERR_LOG("DeleteMediaAlbumAsset-WriteAlbumdata done");
591 errRet = true;
592 }
593
594 if (errRet == true) {
595 int32_t error = Remote()->SendRequest(MEDIA_DELETE_MEDIA_ALBUM_ASSET, data, reply, option);
596 if (error != ERR_NONE) {
597 MEDIA_ERR_LOG("DeleteMediaAlbumAsset SendRequest failed, error: %{public}d", error);
598 errRet = false;
599 }
600 } else {
601 MEDIA_ERR_LOG("DeleteMediaAlbumAsset-WriteAlbumdata Failed");
602 }
603
604 return errRet;
605 }
606
ModifyMediaAlbumAsset(AssetType assetType,const AlbumAsset & srcAlbumAsset,const AlbumAsset & dstAlbumAsset,const string & albumUri)607 bool MediaLibProxy::ModifyMediaAlbumAsset(AssetType assetType, const AlbumAsset& srcAlbumAsset,
608 const AlbumAsset &dstAlbumAsset, const string &albumUri)
609 {
610 bool errRet = false;
611 MessageParcel data;
612 MessageParcel reply;
613 MessageOption option;
614 AlbumAsset *dstAsset = (AlbumAsset *)&dstAlbumAsset;
615
616 if (!data.WriteInterfaceToken(MediaLibProxy::GetDescriptor())) {
617 MEDIA_ERR_LOG("MediaLibProxy interface token write error");
618 return false;
619 }
620
621 if (data.WriteInt32(assetType)) {
622 if ((assetType == ASSET_IMAGEALBUM) &&
623 (WriteAlbumdata(srcAlbumAsset, data) == SUCCESS) &&
624 (WriteAlbumdata(dstAlbumAsset, data) == SUCCESS) &&
625 data.WriteString(albumUri)) {
626 errRet = true;
627 } else if ((assetType == ASSET_VIDEOALBUM) &&
628 (WriteAlbumdata(srcAlbumAsset, data) == SUCCESS) &&
629 (WriteAlbumdata(dstAlbumAsset, data) == SUCCESS) &&
630 data.WriteString(albumUri)) {
631 errRet = true;
632 }
633
634 if (errRet == true) {
635 int32_t error = Remote()->SendRequest(MEDIA_MODIFY_MEDIA_ALBUM_ASSET, data, reply, option);
636 if (error != ERR_NONE) {
637 MEDIA_ERR_LOG("ModifyMediaAlbumAsset SendRequest failed, error: %{public}d", error);
638 return false;
639 }
640 dstAsset->SetAlbumName(ROOT_MEDIA_DIR + dstAsset->GetAlbumName());
641 } else {
642 MEDIA_ERR_LOG("ModifyMediaAlbumAsset: WriteAlbumdata failed");
643 }
644 } else {
645 MEDIA_ERR_LOG("ModifyMediaAlbumAsset assetype write failed");
646 }
647
648 return errRet;
649 }
650 } // namespace Media
651 } // namespace OHOS
652