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 #define MLOG_TAG "Extension"
16
17 #include "media_datashare_ext_ability.h"
18
19 #include <cstdlib>
20
21 #include "ability_info.h"
22 #include "app_mgr_client.h"
23 #include "dataobs_mgr_client.h"
24 #include "datashare_ext_ability_context.h"
25 #include "hilog_wrapper.h"
26 #include "ipc_skeleton.h"
27 #include "medialibrary_command.h"
28 #include "media_datashare_stub_impl.h"
29 #include "media_file_utils.h"
30 #include "media_log.h"
31 #include "media_scanner_manager.h"
32 #include "medialibrary_appstate_observer.h"
33 #include "medialibrary_data_manager.h"
34 #include "medialibrary_bundle_manager.h"
35 #include "dfx_manager.h"
36 #include "dfx_timer.h"
37 #include "dfx_const.h"
38 #include "dfx_reporter.h"
39 #include "medialibrary_errno.h"
40 #include "medialibrary_object_utils.h"
41 #include "medialibrary_subscriber.h"
42 #include "medialibrary_uripermission_operations.h"
43 #include "multistages_capture_manager.h"
44 #include "enhancement_manager.h"
45 #include "napi/native_api.h"
46 #include "napi/native_node_api.h"
47 #include "os_account_manager.h"
48 #include "permission_utils.h"
49 #include "photo_album_column.h"
50 #include "runtime.h"
51 #include "singleton.h"
52 #include "system_ability_definition.h"
53 #include "uri_permission_manager_client.h"
54 #include "userfilemgr_uri.h"
55 #include "want.h"
56 #ifdef MEDIALIBRARY_SECURITY_OPEN
57 #include "sec_comp_kit.h"
58 #endif
59 #include "userfilemgr_uri.h"
60 #include "parameters.h"
61 #include "media_tool_permission_handler.h"
62 #include "grant_permission_handler.h"
63 #include "read_write_permission_handler.h"
64 #include "db_permission_handler.h"
65
66 using namespace std;
67 using namespace OHOS::AppExecFwk;
68 using namespace OHOS::NativeRdb;
69 using namespace OHOS::DistributedKv;
70 using namespace OHOS::Media;
71 using namespace OHOS::DataShare;
72 using namespace OHOS::Security::AccessToken;
73
74 namespace OHOS {
75 namespace AbilityRuntime {
76 using namespace OHOS::AppExecFwk;
77 using DataObsMgrClient = OHOS::AAFwk::DataObsMgrClient;
78
Create(const unique_ptr<Runtime> & runtime)79 MediaDataShareExtAbility* MediaDataShareExtAbility::Create(const unique_ptr<Runtime>& runtime)
80 {
81 return new MediaDataShareExtAbility(static_cast<Runtime&>(*runtime));
82 }
83
MediaDataShareExtAbility(Runtime & runtime)84 MediaDataShareExtAbility::MediaDataShareExtAbility(Runtime& runtime) : DataShareExtAbility(), runtime_(runtime) {}
85
~MediaDataShareExtAbility()86 MediaDataShareExtAbility::~MediaDataShareExtAbility()
87 {
88 }
89
Init(const shared_ptr<AbilityLocalRecord> & record,const shared_ptr<OHOSApplication> & application,shared_ptr<AbilityHandler> & handler,const sptr<IRemoteObject> & token)90 void MediaDataShareExtAbility::Init(const shared_ptr<AbilityLocalRecord> &record,
91 const shared_ptr<OHOSApplication> &application, shared_ptr<AbilityHandler> &handler,
92 const sptr<IRemoteObject> &token)
93 {
94 if ((record == nullptr) || (application == nullptr) || (handler == nullptr) || (token == nullptr)) {
95 MEDIA_ERR_LOG("MediaDataShareExtAbility::init failed, some object is nullptr");
96 DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->KillApplicationSelf();
97 return;
98 }
99 DataShareExtAbility::Init(record, application, handler, token);
100 }
101
IsStartBeforeUserUnlock()102 static bool IsStartBeforeUserUnlock()
103 {
104 int32_t activeUserId = 0;
105 ErrCode ret = OHOS::AccountSA::OsAccountManager::GetForegroundOsAccountLocalId(activeUserId);
106 if (ret != ERR_OK) {
107 MEDIA_ERR_LOG("GetForegroundOsAccountLocalId fail, ret code %{public}d, result is not credible", ret);
108 return false;
109 }
110 MEDIA_INFO_LOG("Current active account is %{public}d ", activeUserId);
111 bool isAccountVerified = true; // Assume verified to avoid unknown killing
112 ErrCode err = AccountSA::OsAccountManager::IsOsAccountVerified(activeUserId, isAccountVerified);
113 if (err != ERR_OK) {
114 MEDIA_ERR_LOG("Check activeUserId fail caused by %{public}d, check result is not credible", err);
115 return false;
116 }
117 MEDIA_INFO_LOG("Current user verification result: %{public}d", isAccountVerified);
118 return !isAccountVerified;
119 }
120
InitPermissionHandler()121 void MediaDataShareExtAbility::InitPermissionHandler()
122 {
123 MEDIA_DEBUG_LOG("InitPermissionHandler begin");
124 // 构造鉴权处理器责任链
125 auto mediaToolPermissionHandler = std::make_shared<MediaToolPermissionHandler>();
126 auto grantPermissionHandler = std::make_shared<GrantPermissionHandler>();
127 grantPermissionHandler->SetNextHandler(mediaToolPermissionHandler);
128 auto dbPermissionHandler = std::make_shared<DbPermissionHandler>();
129 dbPermissionHandler->SetNextHandler(grantPermissionHandler);
130 permissionHandler_ = std::make_shared<ReadWritePermissionHandler>();
131 permissionHandler_->SetNextHandler(dbPermissionHandler);
132 MEDIA_DEBUG_LOG("InitPermissionHandler end:permissionHandler_=%{public}d", permissionHandler_ != nullptr);
133 }
134
CheckUnlockScene(int64_t startTime)135 static bool CheckUnlockScene(int64_t startTime)
136 {
137 if (IsStartBeforeUserUnlock()) {
138 DfxReporter::ReportStartResult(DfxType::CHECK_USER_UNLOCK_FAIL, 0, startTime);
139 MEDIA_INFO_LOG("%{public}s Killing self caused by booting before unlocking", __func__);
140 DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->KillApplicationSelf();
141 return false;
142 }
143
144 bool isMediaPathExists = MediaFileUtils::IsDirectory(ROOT_MEDIA_DIR);
145 if (!isMediaPathExists) {
146 DfxReporter::ReportStartResult(DfxType::CHECK_MEDIA_PATH_UNLOCK_FAIL, 0, startTime);
147 MEDIA_INFO_LOG("%{public}s Killing self caused by media path unmounted", __func__);
148 DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->KillApplicationSelf();
149 return false;
150 }
151
152 return true;
153 }
154
OnStart(const AAFwk::Want & want)155 void MediaDataShareExtAbility::OnStart(const AAFwk::Want &want)
156 {
157 int64_t startTime = MediaFileUtils::UTCTimeMilliSeconds();
158 MEDIA_INFO_LOG("%{public}s begin.", __func__);
159 Extension::OnStart(want);
160 auto context = AbilityRuntime::Context::GetApplicationContext();
161 if (context == nullptr) {
162 DfxReporter::ReportStartResult(DfxType::START_CONTEXT_FAIL, 0, startTime);
163 DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->KillApplicationSelf();
164 return;
165 }
166 MEDIA_INFO_LOG("%{public}s runtime language %{public}d", __func__, runtime_.GetLanguage());
167 InitPermissionHandler();
168 auto dataManager = MediaLibraryDataManager::GetInstance();
169 if (dataManager == nullptr) {
170 DfxReporter::ReportStartResult(DfxType::START_DATAMANAGER_FAIL, 0, startTime);
171 DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->KillApplicationSelf();
172 return;
173 }
174 if (!CheckUnlockScene(startTime)) {
175 return;
176 }
177 auto extensionContext = GetContext();
178 int32_t sceneCode = DfxType::START_SUCCESS;
179 int32_t ret = dataManager->InitMediaLibraryMgr(context, extensionContext, sceneCode);
180 if (ret != E_OK) {
181 MEDIA_ERR_LOG("Failed to init MediaLibraryMgr");
182 if (sceneCode == DfxType::START_RDB_STORE_FAIL) {
183 DfxReporter::ReportStartResult(sceneCode, ret, startTime);
184 }
185 DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->KillApplicationSelf();
186 return;
187 }
188 dataManager->SetOwner(static_pointer_cast<MediaDataShareExtAbility>(shared_from_this()));
189
190 DfxManager::GetInstance();
191 auto scannerManager = MediaScannerManager::GetInstance();
192 if (scannerManager == nullptr) {
193 DfxReporter::ReportStartResult(DfxType::START_SCANNER_FAIL, 0, startTime);
194 DelayedSingleton<AppExecFwk::AppMgrClient>::GetInstance()->KillApplicationSelf();
195 return;
196 }
197
198 MultiStagesPhotoCaptureManager::GetInstance().Init();
199 MultiStagesVideoCaptureManager::GetInstance().Init();
200
201 EnhancementManager::GetInstance().InitAsync();
202
203 Media::MedialibrarySubscriber::Subscribe();
204 dataManager->SetStartupParameter();
205 DfxReporter::ReportStartResult(DfxType::START_SUCCESS, 0, startTime);
206 }
207
OnStop()208 void MediaDataShareExtAbility::OnStop()
209 {
210 MEDIA_INFO_LOG("%{public}s begin.", __func__);
211 auto scannerManager = MediaScannerManager::GetInstance();
212 if (scannerManager != nullptr) {
213 scannerManager->Stop();
214 }
215 MediaLibraryDataManager::GetInstance()->ClearMediaLibraryMgr();
216 MedialibraryAppStateObserverManager::GetInstance().UnSubscribeAppState();
217 MEDIA_INFO_LOG("%{public}s end.", __func__);
218 }
219
OnConnect(const AAFwk::Want & want)220 sptr<IRemoteObject> MediaDataShareExtAbility::OnConnect(const AAFwk::Want &want)
221 {
222 MEDIA_INFO_LOG("%{public}s begin. ", __func__);
223 Extension::OnConnect(want);
224 sptr<MediaDataShareStubImpl> remoteObject = new (nothrow) MediaDataShareStubImpl(
225 static_pointer_cast<MediaDataShareExtAbility>(shared_from_this()),
226 nullptr);
227 if (remoteObject == nullptr) {
228 MEDIA_ERR_LOG("%{public}s No memory allocated for DataShareStubImpl", __func__);
229 return nullptr;
230 }
231 MEDIA_INFO_LOG("%{public}s end.", __func__);
232 return remoteObject->AsObject();
233 }
234
GetFileTypes(const Uri & uri,const string & mimeTypeFilter)235 vector<string> MediaDataShareExtAbility::GetFileTypes(const Uri &uri, const string &mimeTypeFilter)
236 {
237 vector<string> ret;
238 return ret;
239 }
240
FillV10Perms(const MediaType mediaType,const bool containsRead,const bool containsWrite,vector<string> & perm)241 static void FillV10Perms(const MediaType mediaType, const bool containsRead, const bool containsWrite,
242 vector<string> &perm)
243 {
244 if (containsRead) {
245 if (mediaType == MEDIA_TYPE_IMAGE || mediaType == MEDIA_TYPE_VIDEO ||
246 mediaType == Media::MEDIA_TYPE_PHOTO || mediaType == Media::MEDIA_TYPE_ALBUM) {
247 perm.push_back(PERM_READ_IMAGEVIDEO);
248 } else if (mediaType == MEDIA_TYPE_AUDIO) {
249 perm.push_back(PERM_READ_AUDIO);
250 } else if (mediaType == MEDIA_TYPE_FILE) {
251 perm.push_back(PERM_READ_IMAGEVIDEO);
252 perm.push_back(PERM_READ_AUDIO);
253 perm.push_back(PERM_READ_DOCUMENT);
254 }
255 }
256 if (containsWrite) {
257 if (mediaType == MEDIA_TYPE_IMAGE || mediaType == MEDIA_TYPE_VIDEO ||
258 mediaType == Media::MEDIA_TYPE_PHOTO || mediaType == Media::MEDIA_TYPE_ALBUM) {
259 perm.push_back(PERM_WRITE_IMAGEVIDEO);
260 } else if (mediaType == MEDIA_TYPE_AUDIO) {
261 perm.push_back(PERM_WRITE_AUDIO);
262 } else if (mediaType == MEDIA_TYPE_FILE) {
263 perm.push_back(PERM_WRITE_IMAGEVIDEO);
264 perm.push_back(PERM_WRITE_AUDIO);
265 perm.push_back(PERM_WRITE_DOCUMENT);
266 }
267 }
268 }
269
FillDeprecatedPerms(const bool containsRead,const bool containsWrite,vector<string> & perm)270 static void FillDeprecatedPerms(const bool containsRead, const bool containsWrite, vector<string> &perm)
271 {
272 if (containsRead) {
273 perm.push_back(PERMISSION_NAME_READ_MEDIA);
274 }
275 if (containsWrite) {
276 perm.push_back(PERMISSION_NAME_WRITE_MEDIA);
277 }
278 }
279
ContainsFlag(const string & mode,const char flag)280 static inline bool ContainsFlag(const string &mode, const char flag)
281 {
282 return mode.find(flag) != string::npos;
283 }
284
CollectPermissionInfo(MediaLibraryCommand & cmd,const string & mode,const bool permGranted,PermissionUsedType type)285 static void CollectPermissionInfo(MediaLibraryCommand &cmd, const string &mode,
286 const bool permGranted, PermissionUsedType type)
287 {
288 if ((cmd.GetOprnObject() == OperationObject::FILESYSTEM_PHOTO) ||
289 (cmd.GetOprnObject() == OperationObject::THUMBNAIL) ||
290 (cmd.GetOprnObject() == OperationObject::THUMBNAIL_ASTC)) {
291 if (mode.find("r") != string::npos) {
292 PermissionUtils::CollectPermissionInfo(PERM_READ_IMAGEVIDEO, permGranted, type);
293 }
294 if (mode.find("w") != string::npos) {
295 PermissionUtils::CollectPermissionInfo(PERM_WRITE_IMAGEVIDEO, permGranted, type);
296 }
297 }
298 }
299
CheckOpenFilePermission(MediaLibraryCommand & cmd,string & mode)300 static int32_t CheckOpenFilePermission(MediaLibraryCommand &cmd, string &mode)
301 {
302 MEDIA_DEBUG_LOG("uri: %{private}s mode: %{private}s", cmd.GetUri().ToString().c_str(), mode.c_str());
303 MediaType mediaType = MediaFileUri::GetMediaTypeFromUri(cmd.GetUri().ToString());
304 const bool containsRead = ContainsFlag(mode, 'r');
305 const bool containsWrite = ContainsFlag(mode, 'w');
306
307 if (cmd.GetQuerySetParam(IS_TOOL_OPEN) == TOOL_OPEN_TRUE) {
308 return IsDeveloperMediaTool(cmd)? E_SUCCESS : E_PERMISSION_DENIED;
309 }
310 vector<string> perms;
311 FillV10Perms(mediaType, containsRead, containsWrite, perms);
312 if ((cmd.GetOprnObject() == OperationObject::FILESYSTEM_PHOTO) ||
313 (cmd.GetOprnObject() == OperationObject::THUMBNAIL) ||
314 (cmd.GetOprnObject() == OperationObject::THUMBNAIL_ASTC)) {
315 return PermissionUtils::CheckPhotoCallerPermission(perms)? E_SUCCESS : E_PERMISSION_DENIED;
316 }
317 int32_t err = (mediaType == MEDIA_TYPE_FILE) ?
318 (PermissionUtils::CheckHasPermission(perms) ? E_SUCCESS : E_PERMISSION_DENIED) :
319 (PermissionUtils::CheckCallerPermission(perms) ? E_SUCCESS : E_PERMISSION_DENIED);
320 if (err == E_SUCCESS) {
321 return E_SUCCESS;
322 }
323 // Try to check deprecated permissions
324 perms.clear();
325 FillDeprecatedPerms(containsRead, containsWrite, perms);
326 return PermissionUtils::CheckCallerPermission(perms) ? E_SUCCESS : E_PERMISSION_DENIED;
327 }
328
AddHiddenAlbumPermission(MediaLibraryCommand & cmd,vector<string> & outPerms)329 static inline void AddHiddenAlbumPermission(MediaLibraryCommand &cmd, vector<string> &outPerms)
330 {
331 Media::OperationType type = cmd.GetOprnType();
332 if (type == Media::OperationType::QUERY_HIDDEN) {
333 outPerms.push_back(PERM_MANAGE_PRIVATE_PHOTOS);
334 }
335 }
336
SystemApiCheck(MediaLibraryCommand & cmd)337 static int32_t SystemApiCheck(MediaLibraryCommand &cmd)
338 {
339 static const set<OperationObject> SYSTEM_API_OBJECTS = {
340 OperationObject::UFM_PHOTO,
341 OperationObject::UFM_AUDIO,
342 OperationObject::UFM_ALBUM,
343 OperationObject::UFM_MAP,
344 OperationObject::SMART_ALBUM,
345
346 OperationObject::ALL_DEVICE,
347 OperationObject::ACTIVE_DEVICE,
348 OperationObject::PAH_FORM_MAP,
349 };
350
351 static const set<string> SYSTEM_API_URIS = {
352 // Deleting asset permanently from system is only allowed for system apps.
353 URI_DELETE_PHOTOS,
354 // Deleting asset to trash album directly without a pop-up box is only allowed for system apps.
355 UFM_DELETE_PHOTOS,
356 PAH_DELETE_PHOTOS,
357 };
358
359 OperationObject obj = cmd.GetOprnObject();
360 string uri = cmd.GetUriStringWithoutSegment();
361 if (SYSTEM_API_OBJECTS.find(obj) != SYSTEM_API_OBJECTS.end() ||
362 (SYSTEM_API_URIS.find(uri) != SYSTEM_API_URIS.end())) {
363 if (!PermissionUtils::IsSystemApp()) {
364 MEDIA_ERR_LOG("Systemapi should only be called by system applications!");
365 return E_CHECK_SYSTEMAPP_FAIL;
366 }
367 }
368 return E_SUCCESS;
369 }
370
HandleMediaVolumePerm()371 static inline int32_t HandleMediaVolumePerm()
372 {
373 return PermissionUtils::CheckCallerPermission(PERMISSION_NAME_READ_MEDIA) ? E_SUCCESS : E_PERMISSION_DENIED;
374 }
375
HandleBundlePermCheck()376 static inline int32_t HandleBundlePermCheck()
377 {
378 bool ret = PermissionUtils::CheckCallerPermission(PERMISSION_NAME_WRITE_MEDIA);
379 if (ret) {
380 return E_SUCCESS;
381 }
382
383 return PermissionUtils::CheckHasPermission(WRITE_PERMS_V10) ? E_SUCCESS : E_PERMISSION_DENIED;
384 }
385
HandleNoPermCheck(MediaLibraryCommand & cmd)386 static int32_t HandleNoPermCheck(MediaLibraryCommand &cmd)
387 {
388 static const set<string> NO_NEED_PERM_CHECK_URI = {
389 URI_CLOSE_FILE,
390 MEDIALIBRARY_DIRECTORY_URI,
391 };
392
393 static const set<OperationObject> NO_NEED_PERM_CHECK_OBJ = {
394 OperationObject::ALL_DEVICE,
395 OperationObject::ACTIVE_DEVICE,
396 OperationObject::MISCELLANEOUS,
397 };
398
399 string uri = cmd.GetUri().ToString();
400 OperationObject obj = cmd.GetOprnObject();
401 if (NO_NEED_PERM_CHECK_URI.find(uri) != NO_NEED_PERM_CHECK_URI.end() ||
402 NO_NEED_PERM_CHECK_OBJ.find(obj) != NO_NEED_PERM_CHECK_OBJ.end()) {
403 return E_SUCCESS;
404 }
405 return E_NEED_FURTHER_CHECK;
406 }
407
HandleSecurityComponentPermission(MediaLibraryCommand & cmd)408 static int32_t HandleSecurityComponentPermission(MediaLibraryCommand &cmd)
409 {
410 if (cmd.GetUri().ToString().find(OPRN_CREATE_COMPONENT) != string::npos ||
411 cmd.GetUri().ToString().find(OPRN_SAVE_CAMERA_PHOTO_COMPONENT) != string::npos) {
412 #ifdef MEDIALIBRARY_SECURITY_OPEN
413 auto tokenId = PermissionUtils::GetTokenId();
414 if (!Security::SecurityComponent::SecCompKit::VerifySavePermission(tokenId)) {
415 MEDIA_ERR_LOG("Failed to verify save permission of security component");
416 return E_NEED_FURTHER_CHECK;
417 }
418 return E_SUCCESS;
419 #else
420 MEDIA_ERR_LOG("Security component is not existed");
421 return E_NEED_FURTHER_CHECK;
422 #endif
423 }
424 return E_NEED_FURTHER_CHECK;
425 }
426
HandleShortPermission(bool & need)427 static int32_t HandleShortPermission(bool &need)
428 {
429 int32_t err = PermissionUtils::CheckPhotoCallerPermission(PERM_SHORT_TERM_WRITE_IMAGEVIDEO) ? E_SUCCESS :
430 E_PERMISSION_DENIED;
431 if (!err) {
432 need = true;
433 } else {
434 need = false;
435 }
436 return err;
437 }
438
HandleRestorePermission(MediaLibraryCommand & cmd)439 static int32_t HandleRestorePermission(MediaLibraryCommand &cmd)
440 {
441 if (cmd.GetUriStringWithoutSegment() == PAH_GENERATE_THUMBNAILS_RESTORE) {
442 return PermissionUtils::CheckCallerPermission(PERM_READ_IMAGEVIDEO) ? E_SUCCESS : E_PERMISSION_DENIED;
443 }
444 return E_PERMISSION_DENIED;
445 }
446
UserFileMgrPermissionCheck(MediaLibraryCommand & cmd,const bool isWrite)447 static int32_t UserFileMgrPermissionCheck(MediaLibraryCommand &cmd, const bool isWrite)
448 {
449 static const set<OperationObject> USER_FILE_MGR_OBJECTS = {
450 OperationObject::UFM_PHOTO,
451 OperationObject::UFM_AUDIO,
452 OperationObject::UFM_ALBUM,
453 OperationObject::UFM_MAP,
454 };
455
456 OperationObject obj = cmd.GetOprnObject();
457 if (USER_FILE_MGR_OBJECTS.find(obj) == USER_FILE_MGR_OBJECTS.end()) {
458 return E_NEED_FURTHER_CHECK;
459 }
460
461 int32_t err = HandleSecurityComponentPermission(cmd);
462 if (err == E_SUCCESS || (err != E_SUCCESS && err != E_NEED_FURTHER_CHECK)) {
463 return err;
464 }
465
466 vector<string> perms;
467 if (obj == OperationObject::UFM_AUDIO) {
468 perms.push_back(isWrite ? PERM_WRITE_AUDIO : PERM_READ_AUDIO);
469 } else {
470 perms.push_back(isWrite ? PERM_WRITE_IMAGEVIDEO : PERM_READ_IMAGEVIDEO);
471 }
472 AddHiddenAlbumPermission(cmd, perms);
473 return PermissionUtils::CheckCallerPermission(perms) ? E_SUCCESS : E_PERMISSION_DENIED;
474 }
475
PhotoAccessHelperPermCheck(MediaLibraryCommand & cmd,const bool isWrite)476 static int32_t PhotoAccessHelperPermCheck(MediaLibraryCommand &cmd, const bool isWrite)
477 {
478 static const set<OperationObject> PHOTO_ACCESS_HELPER_OBJECTS = {
479 OperationObject::PAH_PHOTO,
480 OperationObject::PAH_ALBUM,
481 OperationObject::PAH_MAP,
482 OperationObject::PAH_FORM_MAP,
483 OperationObject::ANALYSIS_PHOTO_ALBUM,
484 OperationObject::ANALYSIS_PHOTO_MAP,
485 OperationObject::VISION_OCR,
486 OperationObject::VISION_AESTHETICS,
487 OperationObject::VISION_LABEL,
488 OperationObject::VISION_VIDEO_LABEL,
489 OperationObject::VISION_IMAGE_FACE,
490 OperationObject::VISION_VIDEO_FACE,
491 OperationObject::VISION_FACE_TAG,
492 OperationObject::VISION_OBJECT,
493 OperationObject::VISION_RECOMMENDATION,
494 OperationObject::VISION_SEGMENTATION,
495 OperationObject::VISION_COMPOSITION,
496 OperationObject::VISION_SALIENCY,
497 OperationObject::VISION_HEAD,
498 OperationObject::VISION_POSE,
499 OperationObject::VISION_TOTAL,
500 OperationObject::GEO_DICTIONARY,
501 OperationObject::GEO_KNOWLEDGE,
502 OperationObject::GEO_PHOTO,
503 OperationObject::PAH_MULTISTAGES_CAPTURE,
504 OperationObject::STORY_ALBUM,
505 OperationObject::STORY_COVER,
506 OperationObject::STORY_PLAY,
507 OperationObject::USER_PHOTOGRAPHY,
508 OperationObject::PAH_BATCH_THUMBNAIL_OPERATE,
509 OperationObject::INDEX_CONSTRUCTION_STATUS,
510 OperationObject::MEDIA_APP_URI_PERMISSION,
511 OperationObject::PAH_CLOUD_ENHANCEMENT_OPERATE,
512 OperationObject::ANALYSIS_ASSET_SD_MAP,
513 OperationObject::ANALYSIS_ALBUM_ASSET_MAP,
514 };
515
516 int32_t err = HandleSecurityComponentPermission(cmd);
517 if (err == E_SUCCESS || (err != E_SUCCESS && err != E_NEED_FURTHER_CHECK)) {
518 return err;
519 }
520
521 OperationObject obj = cmd.GetOprnObject();
522 if (PHOTO_ACCESS_HELPER_OBJECTS.find(obj) == PHOTO_ACCESS_HELPER_OBJECTS.end()) {
523 return E_NEED_FURTHER_CHECK;
524 }
525 vector<string> perms;
526 AddHiddenAlbumPermission(cmd, perms);
527 perms.push_back(isWrite ? PERM_WRITE_IMAGEVIDEO : PERM_READ_IMAGEVIDEO);
528 return PermissionUtils::CheckCallerPermission(perms) ? E_SUCCESS : E_PERMISSION_DENIED;
529 }
530
HandleSpecialObjectPermission(MediaLibraryCommand & cmd,bool isWrite)531 static int32_t HandleSpecialObjectPermission(MediaLibraryCommand &cmd, bool isWrite)
532 {
533 int err = HandleNoPermCheck(cmd);
534 if (err == E_SUCCESS || (err != E_SUCCESS && err != E_NEED_FURTHER_CHECK)) {
535 return err;
536 }
537
538 OperationObject obj = cmd.GetOprnObject();
539 if (obj == OperationObject::MEDIA_VOLUME) {
540 return HandleMediaVolumePerm();
541 } else if (obj == OperationObject::BUNDLE_PERMISSION) {
542 return HandleBundlePermCheck();
543 }
544
545 return E_NEED_FURTHER_CHECK;
546 }
547
UnifyOprnObject(MediaLibraryCommand & cmd)548 static void UnifyOprnObject(MediaLibraryCommand &cmd)
549 {
550 static const unordered_map<OperationObject, OperationObject> UNIFY_OP_OBJECT_MAP = {
551 { OperationObject::UFM_PHOTO, OperationObject::FILESYSTEM_PHOTO },
552 { OperationObject::UFM_AUDIO, OperationObject::FILESYSTEM_AUDIO },
553 { OperationObject::UFM_ALBUM, OperationObject::PHOTO_ALBUM },
554 { OperationObject::UFM_MAP, OperationObject::PHOTO_MAP },
555 { OperationObject::PAH_PHOTO, OperationObject::FILESYSTEM_PHOTO },
556 { OperationObject::PAH_ALBUM, OperationObject::PHOTO_ALBUM },
557 { OperationObject::PAH_MAP, OperationObject::PHOTO_MAP },
558 { OperationObject::TOOL_PHOTO, OperationObject::FILESYSTEM_PHOTO },
559 { OperationObject::TOOL_AUDIO, OperationObject::FILESYSTEM_AUDIO },
560 { OperationObject::TOOL_ALBUM, OperationObject::PHOTO_ALBUM },
561 };
562
563 OperationObject obj = cmd.GetOprnObject();
564 if (UNIFY_OP_OBJECT_MAP.find(obj) != UNIFY_OP_OBJECT_MAP.end()) {
565 cmd.SetOprnObject(UNIFY_OP_OBJECT_MAP.at(obj));
566 }
567 }
568
MediatoolPermCheck(MediaLibraryCommand & cmd)569 static int32_t MediatoolPermCheck(MediaLibraryCommand &cmd)
570 {
571 if (IsMediatoolOperation(cmd)) {
572 if (!IsDeveloperMediaTool(cmd)) {
573 return E_PERMISSION_DENIED;
574 }
575 return E_SUCCESS;
576 } else {
577 return E_NEED_FURTHER_CHECK;
578 }
579 }
580
CheckPermFromUri(MediaLibraryCommand & cmd,bool isWrite)581 static int32_t CheckPermFromUri(MediaLibraryCommand &cmd, bool isWrite)
582 {
583 MEDIA_DEBUG_LOG("uri: %{private}s object: %{public}d, opType: %{public}d isWrite: %{public}d",
584 cmd.GetUri().ToString().c_str(), cmd.GetOprnObject(), cmd.GetOprnType(), isWrite);
585
586 int err = SystemApiCheck(cmd);
587 if (err != E_SUCCESS) {
588 return err;
589 }
590 err = MediatoolPermCheck(cmd);
591 if (err == E_SUCCESS || (err != E_SUCCESS && err != E_NEED_FURTHER_CHECK)) {
592 UnifyOprnObject(cmd);
593 return err;
594 }
595 err = PhotoAccessHelperPermCheck(cmd, isWrite);
596 if (err == E_SUCCESS || (err != E_SUCCESS && err != E_NEED_FURTHER_CHECK)) {
597 UnifyOprnObject(cmd);
598 return err;
599 }
600 err = UserFileMgrPermissionCheck(cmd, isWrite);
601 if (err == E_SUCCESS || (err != E_SUCCESS && err != E_NEED_FURTHER_CHECK)) {
602 UnifyOprnObject(cmd);
603 return err;
604 }
605 err = HandleSpecialObjectPermission(cmd, isWrite);
606 if (err == E_SUCCESS || (err != E_SUCCESS && err != E_NEED_FURTHER_CHECK)) {
607 UnifyOprnObject(cmd);
608 return err;
609 }
610
611 // Finally, we should check the permission of medialibrary interfaces.
612 string perm = isWrite ? PERMISSION_NAME_WRITE_MEDIA : PERMISSION_NAME_READ_MEDIA;
613 err = PermissionUtils::CheckCallerPermission(perm) ? E_SUCCESS : E_PERMISSION_DENIED;
614 if (err < 0) {
615 return err;
616 }
617 UnifyOprnObject(cmd);
618 return E_SUCCESS;
619 }
620
CheckIsOwner(const Uri & uri,MediaLibraryCommand & cmd,const string & mode)621 static bool CheckIsOwner(const Uri &uri, MediaLibraryCommand &cmd, const string &mode)
622 {
623 auto ret = false;
624 string unifyMode = mode;
625 if (cmd.GetTableName() == PhotoColumn::PHOTOS_TABLE || cmd.GetTableName() == AudioColumn::AUDIOS_TABLE ||
626 cmd.GetTableName() == MEDIALIBRARY_TABLE) {
627 std::vector<std::string> columns;
628 DatashareBusinessError businessError;
629 int errCode = businessError.GetCode();
630 string clientAppId = GetClientAppId();
631 string fileId = MediaFileUtils::GetIdFromUri(uri.ToString());
632 DataSharePredicates predicates;
633 predicates.And()->EqualTo("file_id", fileId);
634 predicates.And()->EqualTo("owner_appid", clientAppId);
635 if (clientAppId.empty() || fileId.empty()) {
636 return false;
637 }
638 auto queryResultSet = MediaLibraryDataManager::GetInstance()->Query(cmd, columns, predicates, errCode);
639 auto count = 0;
640 if (queryResultSet != nullptr) {
641 queryResultSet->GetRowCount(count);
642 if (count != 0) {
643 ret = true;
644 CollectPermissionInfo(cmd, unifyMode, true,
645 PermissionUsedTypeValue::SECURITY_COMPONENT_TYPE);
646 }
647 }
648 }
649 return ret;
650 }
651
AddOwnerCheck(MediaLibraryCommand & cmd,DataSharePredicates & appidPredicates)652 static bool AddOwnerCheck(MediaLibraryCommand &cmd, DataSharePredicates &appidPredicates)
653 {
654 if (cmd.GetTableName() != PhotoColumn::PHOTOS_TABLE && cmd.GetTableName() != AudioColumn::AUDIOS_TABLE &&
655 cmd.GetTableName() != MEDIALIBRARY_TABLE) {
656 return false;
657 }
658 string clientAppId = GetClientAppId();
659 if (clientAppId.empty()) {
660 return false;
661 }
662 appidPredicates.And()->EqualTo("owner_appid", clientAppId);
663 return true;
664 }
665
GetFlagFromMode(const string & mode)666 static uint32_t GetFlagFromMode(const string &mode)
667 {
668 if (mode.find("w") != string::npos) {
669 return AAFwk::Want::FLAG_AUTH_WRITE_URI_PERMISSION;
670 }
671 return AAFwk::Want::FLAG_AUTH_READ_URI_PERMISSION;
672 }
673
CheckPermissionForOpenFile(const Uri & uri,MediaLibraryCommand & command,string & unifyMode)674 int MediaDataShareExtAbility::CheckPermissionForOpenFile(const Uri &uri,
675 MediaLibraryCommand &command, string &unifyMode)
676 {
677 PermParam permParam = {
678 .isWrite = false,
679 .isOpenFile = true,
680 .openFileNode = unifyMode
681 };
682 CHECK_AND_RETURN_RET_LOG(permissionHandler_ != nullptr, E_PERMISSION_DENIED, "permissionHandler_ is nullptr");
683 int err = permissionHandler_->CheckPermission(command, permParam);
684 MEDIA_DEBUG_LOG("permissionHandler_ err=%{public}d", err);
685 if (err != E_SUCCESS) {
686 err = CheckOpenFilePermission(command, unifyMode);
687 }
688 if (err == E_PERMISSION_DENIED) {
689 err = UriPermissionOperations::CheckUriPermission(command.GetUriStringWithoutSegment(), unifyMode);
690 if (err != E_OK) {
691 auto& uriPermissionClient = AAFwk::UriPermissionManagerClient::GetInstance();
692 if (uriPermissionClient.VerifyUriPermission(Uri(command.GetUriStringWithoutSegment()),
693 GetFlagFromMode(unifyMode), IPCSkeleton::GetCallingTokenID())) {
694 CollectPermissionInfo(command, unifyMode, true, PermissionUsedTypeValue::PICKER_TYPE);
695 err = E_OK;
696 }
697 }
698 if (err != E_OK) {
699 CollectPermissionInfo(command, unifyMode, false, PermissionUsedTypeValue::PICKER_TYPE);
700 if (!CheckIsOwner(uri, command, unifyMode)) {
701 MEDIA_ERR_LOG("Permission Denied! err = %{public}d", err);
702 CollectPermissionInfo(command, unifyMode, false,
703 PermissionUsedTypeValue::SECURITY_COMPONENT_TYPE);
704 return err;
705 } else {
706 return E_OK;
707 }
708 }
709 }
710 return err;
711 }
712
OpenFile(const Uri & uri,const string & mode)713 int MediaDataShareExtAbility::OpenFile(const Uri &uri, const string &mode)
714 {
715 #ifdef MEDIALIBRARY_COMPATIBILITY
716 string realUriStr = MediaFileUtils::GetRealUriFromVirtualUri(uri.ToString());
717 Uri realUri(realUriStr);
718 MediaLibraryCommand command(realUri, Media::OperationType::OPEN);
719
720 #else
721 MediaLibraryCommand command(uri, Media::OperationType::OPEN);
722 #endif
723
724 string unifyMode = mode;
725 transform(unifyMode.begin(), unifyMode.end(), unifyMode.begin(), ::tolower);
726 int err = CheckPermissionForOpenFile(uri, command, unifyMode);
727 if (err < 0) {
728 return err;
729 }
730 int32_t object = static_cast<int32_t>(command.GetOprnObject());
731 int32_t type = static_cast<int32_t>(command.GetOprnType());
732 DfxTimer dfxTimer(type, object, OPEN_FILE_TIME_OUT, true);
733 if (command.GetUri().ToString().find(MEDIA_DATA_DB_THUMBNAIL) != string::npos) {
734 command.SetOprnObject(OperationObject::THUMBNAIL);
735 }
736 if (command.GetUri().ToString().find(MEDIA_DATA_DB_THUMB_ASTC) != string::npos) {
737 command.SetOprnObject(OperationObject::THUMBNAIL_ASTC);
738 }
739 if (command.GetUri().ToString().find(PhotoColumn::PHOTO_CACHE_URI_PREFIX) != string::npos) {
740 command.SetOprnObject(OperationObject::FILESYSTEM_PHOTO);
741 }
742 if (command.GetUri().ToString().find(PhotoColumn::HIGHTLIGHT_URI) != string::npos) {
743 command.SetOprnObject(OperationObject::HIGHLIGHT_URI);
744 } else if (command.GetUri().ToString().find(MEDIA_DATA_DB_HIGHLIGHT) != string::npos) {
745 command.SetOprnObject(OperationObject::HIGHLIGHT_COVER);
746 }
747 if (command.GetUri().ToString().find(PhotoColumn::PHOTO_REQUEST_PICTURE) != string::npos) {
748 command.SetOprnObject(OperationObject::REQUEST_PICTURE);
749 }
750 if (command.GetUri().ToString().find(PhotoColumn::PHOTO_REQUEST_PICTURE_BUFFER) != string::npos) {
751 command.SetOprnObject(OperationObject::PHOTO_REQUEST_PICTURE_BUFFER);
752 }
753 return MediaLibraryDataManager::GetInstance()->OpenFile(command, unifyMode);
754 }
755
OpenRawFile(const Uri & uri,const string & mode)756 int MediaDataShareExtAbility::OpenRawFile(const Uri &uri, const string &mode)
757 {
758 return 0;
759 }
760
Insert(const Uri & uri,const DataShareValuesBucket & value)761 int MediaDataShareExtAbility::Insert(const Uri &uri, const DataShareValuesBucket &value)
762 {
763 MediaLibraryCommand cmd(uri);
764 PermParam permParam = {
765 .isWrite = true,
766 };
767 CHECK_AND_RETURN_RET_LOG(permissionHandler_ != nullptr, E_PERMISSION_DENIED, "permissionHandler_ is nullptr");
768 int err = permissionHandler_->CheckPermission(cmd, permParam);
769 MEDIA_DEBUG_LOG("permissionHandler_ err=%{public}d", err);
770 if (err != E_SUCCESS) {
771 err = CheckPermFromUri(cmd, true);
772 }
773 if (err != E_SUCCESS) {
774 return err;
775 }
776 int32_t object = static_cast<int32_t>(cmd.GetOprnObject());
777 int32_t type = static_cast<int32_t>(cmd.GetOprnType());
778 DfxTimer dfxTimer(type, object, COMMON_TIME_OUT, true);
779 return MediaLibraryDataManager::GetInstance()->Insert(cmd, value);
780 }
781
InsertExt(const Uri & uri,const DataShareValuesBucket & value,string & result)782 int MediaDataShareExtAbility::InsertExt(const Uri &uri, const DataShareValuesBucket &value, string &result)
783 {
784 MediaLibraryCommand cmd(uri);
785 PermParam permParam = {
786 .isWrite = true,
787 };
788 bool needToResetTime = false;
789 CHECK_AND_RETURN_RET_LOG(permissionHandler_ != nullptr, E_PERMISSION_DENIED, "permissionHandler_ is nullptr");
790 int err = permissionHandler_->CheckPermission(cmd, permParam);
791 MEDIA_DEBUG_LOG("permissionHandler_ err=%{public}d", err);
792 if (err != E_SUCCESS) {
793 err = CheckPermFromUri(cmd, true);
794 }
795 if ((err != E_SUCCESS) && cmd.GetUriStringWithoutSegment() == PAH_CREATE_PHOTO)
796 err = HandleShortPermission(needToResetTime);
797 int32_t type = static_cast<int32_t>(cmd.GetOprnType());
798 int32_t object = static_cast<int32_t>(cmd.GetOprnObject());
799 if (err < 0) {
800 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
801 return err;
802 }
803
804 DfxTimer dfxTimer(type, object, COMMON_TIME_OUT, true);
805 int32_t ret = MediaLibraryDataManager::GetInstance()->InsertExt(cmd, value, result);
806 if (needToResetTime) {
807 AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
808 Security::AccessToken::AccessTokenKit::GrantPermissionForSpecifiedTime(tokenCaller,
809 PERM_SHORT_TERM_WRITE_IMAGEVIDEO, THREE_HUNDERD_S);
810 }
811 return ret;
812 }
813
Update(const Uri & uri,const DataSharePredicates & predicates,const DataShareValuesBucket & value)814 int MediaDataShareExtAbility::Update(const Uri &uri, const DataSharePredicates &predicates,
815 const DataShareValuesBucket &value)
816 {
817 MediaLibraryCommand cmd(uri);
818 PermParam permParam = {
819 .isWrite = true,
820 };
821 CHECK_AND_RETURN_RET_LOG(permissionHandler_ != nullptr, E_PERMISSION_DENIED, "permissionHandler_ is nullptr");
822 cmd.SetDataSharePred(predicates);
823 int err = permissionHandler_->CheckPermission(cmd, permParam);
824 MEDIA_DEBUG_LOG("permissionHandler_ err=%{public}d", err);
825 if (err != E_SUCCESS) {
826 err = CheckPermFromUri(cmd, true);
827 }
828 if (err != E_SUCCESS) {
829 err = HandleRestorePermission(cmd);
830 }
831 bool isMediatoolOperation = IsMediatoolOperation(cmd);
832 int32_t type = static_cast<int32_t>(cmd.GetOprnType());
833 int32_t object = static_cast<int32_t>(cmd.GetOprnObject());
834 DataSharePredicates appidPredicates = predicates;
835
836 if (err != E_SUCCESS) {
837 if (isMediatoolOperation) {
838 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
839 return err;
840 }
841 if (!AddOwnerCheck(cmd, appidPredicates)) {
842 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
843 return err;
844 }
845 }
846
847 DfxTimer dfxTimer(type, object, COMMON_TIME_OUT, true);
848 auto updateRet = MediaLibraryDataManager::GetInstance()->Update(cmd, value, appidPredicates);
849 if (err < 0 && updateRet <= 0) {
850 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
851 return err;
852 }
853 return updateRet;
854 }
855
Delete(const Uri & uri,const DataSharePredicates & predicates)856 int MediaDataShareExtAbility::Delete(const Uri &uri, const DataSharePredicates &predicates)
857 {
858 MediaLibraryCommand cmd(uri, Media::OperationType::DELETE);
859 PermParam permParam = {
860 .isWrite = true,
861 };
862 CHECK_AND_RETURN_RET_LOG(permissionHandler_ != nullptr, E_PERMISSION_DENIED, "permissionHandler_ is nullptr");
863 cmd.SetDataSharePred(predicates);
864 int err = permissionHandler_->CheckPermission(cmd, permParam);
865 MEDIA_DEBUG_LOG("permissionHandler_ err=%{public}d", err);
866 if (err != E_SUCCESS) {
867 err = CheckPermFromUri(cmd, true);
868 }
869 int32_t type = static_cast<int32_t>(cmd.GetOprnType());
870 int32_t object = static_cast<int32_t>(cmd.GetOprnObject());
871 if (err != E_SUCCESS) {
872 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
873 return err;
874 }
875
876 DfxTimer dfxTimer(type, object, COMMON_TIME_OUT, true);
877 return MediaLibraryDataManager::GetInstance()->Delete(cmd, predicates);
878 }
879
Query(const Uri & uri,const DataSharePredicates & predicates,vector<string> & columns,DatashareBusinessError & businessError)880 shared_ptr<DataShareResultSet> MediaDataShareExtAbility::Query(const Uri &uri,
881 const DataSharePredicates &predicates, vector<string> &columns, DatashareBusinessError &businessError)
882 {
883 MediaLibraryCommand cmd(uri);
884 PermParam permParam = {.isWrite = false};
885 CHECK_AND_RETURN_RET_LOG(permissionHandler_ != nullptr, nullptr, "permissionHandler_ is nullptr");
886 cmd.SetDataSharePred(predicates);
887 int err = permissionHandler_->CheckPermission(cmd, permParam);
888 MEDIA_DEBUG_LOG("permissionHandler_ err=%{public}d", err);
889 if (err != E_SUCCESS) {
890 err = CheckPermFromUri(cmd, false);
891 }
892 int32_t object = static_cast<int32_t>(cmd.GetOprnObject());
893 int32_t type = static_cast<int32_t>(cmd.GetOprnType());
894 DfxTimer dfxTimer(type, object, COMMON_TIME_OUT, true);
895 bool isMediatoolOperation = IsMediatoolOperation(cmd);
896 int errCode = businessError.GetCode();
897 DataSharePredicates appidPredicates = predicates;
898
899 if (err != E_SUCCESS) {
900 if (isMediatoolOperation) {
901 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
902 businessError.SetCode(err);
903 return nullptr;
904 }
905 auto& uriPermissionClient = AAFwk::UriPermissionManagerClient::GetInstance();
906 if (uriPermissionClient.VerifyUriPermission(uri, AAFwk::Want::FLAG_AUTH_READ_URI_PERMISSION,
907 IPCSkeleton::GetCallingTokenID())) {
908 MEDIA_DEBUG_LOG("Permission check pass , uri = %{private}s", uri.ToString().c_str());
909 } else {
910 if (!AddOwnerCheck(cmd, appidPredicates)) {
911 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
912 businessError.SetCode(err);
913 return nullptr;
914 }
915 }
916 }
917 auto queryResultSet = MediaLibraryDataManager::GetInstance()->Query(cmd, columns, appidPredicates, errCode);
918 businessError.SetCode(to_string(errCode));
919 if (queryResultSet == nullptr) {
920 MEDIA_ERR_LOG("queryResultSet is nullptr! errCode: %{public}d", errCode);
921 businessError.SetCode(errCode);
922 return nullptr;
923 }
924 auto count = 0;
925 queryResultSet->GetRowCount(count);
926 if (err < 0 && count == 0) {
927 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
928 businessError.SetCode(err);
929 return nullptr;
930 }
931 return make_shared<DataShareResultSet>(queryResultSet);
932 }
933
GetType(const Uri & uri)934 string MediaDataShareExtAbility::GetType(const Uri &uri)
935 {
936 MEDIA_INFO_LOG("%{public}s begin.", __func__);
937 auto ret = MediaLibraryDataManager::GetInstance()->GetType(uri);
938 MEDIA_INFO_LOG("%{public}s end.", __func__);
939 return ret;
940 }
941
BatchInsert(const Uri & uri,const vector<DataShareValuesBucket> & values)942 int MediaDataShareExtAbility::BatchInsert(const Uri &uri, const vector<DataShareValuesBucket> &values)
943 {
944 MediaLibraryCommand cmd(uri);
945 int32_t err = CheckPermFromUri(cmd, true);
946 int32_t type = static_cast<int32_t>(cmd.GetOprnType());
947 int32_t object = static_cast<int32_t>(cmd.GetOprnObject());
948 if (err != E_SUCCESS) {
949 MEDIA_INFO_LOG("permission deny: {%{public}d, %{public}d, %{public}d}", type, object, err);
950 return err;
951 }
952 DfxTimer dfxTimer(type, object, COMMON_TIME_OUT, true);
953 return MediaLibraryDataManager::GetInstance()->BatchInsert(cmd, values);
954 }
955
RegisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)956 bool MediaDataShareExtAbility::RegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
957 {
958 MEDIA_INFO_LOG("%{public}s begin.", __func__);
959 auto obsMgrClient = DataObsMgrClient::GetInstance();
960 if (obsMgrClient == nullptr) {
961 MEDIA_ERR_LOG("%{public}s obsMgrClient is nullptr", __func__);
962 return false;
963 }
964
965 ErrCode ret = obsMgrClient->RegisterObserver(uri, dataObserver);
966 if (ret != ERR_OK) {
967 MEDIA_ERR_LOG("%{public}s obsMgrClient->RegisterObserver error return %{public}d", __func__, ret);
968 return false;
969 }
970 MEDIA_INFO_LOG("%{public}s end.", __func__);
971 return true;
972 }
973
UnregisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)974 bool MediaDataShareExtAbility::UnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
975 {
976 MEDIA_INFO_LOG("%{public}s begin.", __func__);
977 auto obsMgrClient = DataObsMgrClient::GetInstance();
978 if (obsMgrClient == nullptr) {
979 MEDIA_ERR_LOG("%{public}s obsMgrClient is nullptr", __func__);
980 return false;
981 }
982
983 ErrCode ret = obsMgrClient->UnregisterObserver(uri, dataObserver);
984 if (ret != ERR_OK) {
985 MEDIA_ERR_LOG("%{public}s obsMgrClient->UnregisterObserver error return %{public}d", __func__, ret);
986 return false;
987 }
988 MEDIA_INFO_LOG("%{public}s end.", __func__);
989 return true;
990 }
991
NotifyChange(const Uri & uri)992 bool MediaDataShareExtAbility::NotifyChange(const Uri &uri)
993 {
994 auto obsMgrClient = DataObsMgrClient::GetInstance();
995 if (obsMgrClient == nullptr) {
996 MEDIA_ERR_LOG("%{public}s obsMgrClient is nullptr", __func__);
997 return false;
998 }
999
1000 ErrCode ret = obsMgrClient->NotifyChange(uri);
1001 if (ret != ERR_OK) {
1002 MEDIA_ERR_LOG("%{public}s obsMgrClient->NotifyChange error return %{public}d", __func__, ret);
1003 return false;
1004 }
1005 return true;
1006 }
1007
NormalizeUri(const Uri & uri)1008 Uri MediaDataShareExtAbility::NormalizeUri(const Uri &uri)
1009 {
1010 MEDIA_INFO_LOG("%{public}s begin.", __func__);
1011 auto ret = uri;
1012 MEDIA_INFO_LOG("%{public}s end.", __func__);
1013 return ret;
1014 }
1015
DenormalizeUri(const Uri & uri)1016 Uri MediaDataShareExtAbility::DenormalizeUri(const Uri &uri)
1017 {
1018 MEDIA_INFO_LOG("%{public}s begin.", __func__);
1019 auto ret = uri;
1020 MEDIA_INFO_LOG("%{public}s end.", __func__);
1021 return ret;
1022 }
1023 } // namespace AbilityRuntime
1024 } // namespace OHOS
1025