1 /*
2 * Copyright (c) 2025-2025 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 "camera_datashare_helper.h"
17
18 #include "camera_log.h"
19 #include "camera_util.h"
20 #include "iservice_registry.h"
21 #include "system_ability_definition.h"
22
23 namespace OHOS {
24 namespace CameraStandard {
25
CreateCameraDataShareHelper()26 std::shared_ptr<DataShare::DataShareHelper> CameraDataShareHelper::CreateCameraDataShareHelper()
27 {
28 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
29 CHECK_RETURN_RET_ELOG(samgr == nullptr, nullptr, "CameraDataShareHelper GetSystemAbilityManager failed.");
30 sptr<IRemoteObject> remoteObj = samgr->GetSystemAbility(CAMERA_SERVICE_ID);
31 CHECK_RETURN_RET_ELOG(remoteObj == nullptr, nullptr, "CameraDataShareHelper GetSystemAbility Service Failed.");
32 return DataShare::DataShareHelper::Creator(remoteObj, SETTINGS_DATA_BASE_URI, SETTINGS_DATA_EXT_URI);
33 }
34
QueryOnce(const std::string key,std::string & value)35 int32_t CameraDataShareHelper::QueryOnce(const std::string key, std::string &value)
36 {
37 auto dataShareHelper = CreateCameraDataShareHelper();
38 CHECK_RETURN_RET_ELOG(dataShareHelper == nullptr, CAMERA_INVALID_ARG, "dataShareHelper_ is nullptr");
39 Uri uri(SETTINGS_DATA_BASE_URI);
40 DataShare::DataSharePredicates predicates;
41 predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, key);
42 std::vector<std::string> columns;
43 columns.emplace_back(SETTINGS_DATA_FIELD_VALUE);
44
45 auto resultSet = dataShareHelper->Query(uri, predicates, columns);
46 CHECK_RETURN_RET_ELOG(resultSet == nullptr, CAMERA_INVALID_ARG, "CameraDataShareHelper query fail");
47
48 int32_t numRows = 0;
49 resultSet->GetRowCount(numRows);
50 CHECK_RETURN_RET_ELOG(numRows == 0, CAMERA_INVALID_ARG, "CameraDataShareHelper query failed, row is zero.");
51
52 if (resultSet->GoToFirstRow() != DataShare::E_OK) {
53 MEDIA_INFO_LOG("CameraDataShareHelper Query failed,go to first row error");
54 resultSet->Close();
55 dataShareHelper->Release();
56 return CAMERA_INVALID_ARG;
57 }
58
59 int columnIndex;
60 resultSet->GetColumnIndex(SETTINGS_DATA_FIELD_VALUE, columnIndex);
61 resultSet->GetString(columnIndex, value);
62 resultSet->Close();
63 dataShareHelper->Release();
64 MEDIA_INFO_LOG("CameraDataShareHelper query success,value=%{public}s", value.c_str());
65 return CAMERA_OK;
66 }
67
UpdateOnce(const std::string key,std::string value)68 int32_t CameraDataShareHelper::UpdateOnce(const std::string key, std::string value)
69 {
70 auto dataShareHelper = CreateCameraDataShareHelper();
71 CHECK_RETURN_RET_ELOG(dataShareHelper == nullptr, CAMERA_INVALID_ARG, "dataShareHelper_ is nullptr");
72 Uri uri(SETTINGS_DATA_BASE_URI);
73 DataShare::DataSharePredicates predicates;
74 predicates.EqualTo(SETTINGS_DATA_FIELD_KEYWORD, key);
75
76 DataShare::DataShareValuesBucket bucket;
77 DataShare::DataShareValueObject keywordObj(key);
78 DataShare::DataShareValueObject valueObj(value);
79 bucket.Put(SETTINGS_DATA_FIELD_KEYWORD, keywordObj);
80 bucket.Put(SETTINGS_DATA_FIELD_VALUE, valueObj);
81
82 if (dataShareHelper->Update(uri, predicates, bucket) <= 0) {
83 dataShareHelper->Insert(uri, bucket);
84 dataShareHelper->Release();
85 MEDIA_ERR_LOG("CameraDataShareHelper Update:%{public}s failed", key.c_str());
86 return CAMERA_INVALID_ARG;
87 }
88 MEDIA_INFO_LOG("CameraDataShareHelper Update:%{public}s success", key.c_str());
89 dataShareHelper->Release();
90 return CAMERA_OK;
91 }
92
IsDataShareReady()93 bool CameraDataShareHelper::IsDataShareReady()
94 {
95 if (isDataShareReady_) {
96 return true;
97 }
98 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
99 CHECK_RETURN_RET_ELOG(samgr == nullptr, false, "CameraDataShareHelper GetSystemAbilityManager failed.");
100 sptr<IRemoteObject> remoteObj = samgr->GetSystemAbility(CAMERA_SERVICE_ID);
101 CHECK_RETURN_RET_ELOG(remoteObj == nullptr, false, "CameraDataShareHelper GetSystemAbility Service Failed.");
102 std::pair<int, std::shared_ptr<DataShare::DataShareHelper>> ret =
103 DataShare::DataShareHelper::Create(remoteObj, SETTINGS_DATA_BASE_URI, SETTINGS_DATA_EXT_URI);
104 MEDIA_INFO_LOG("create dataShareHelper ret=%{public}d", ret.first);
105 if (ret.first == DataShare::E_OK) {
106 auto dataShareHelper = ret.second;
107 if (dataShareHelper != nullptr) {
108 bool releaseRet = dataShareHelper->Release();
109 MEDIA_INFO_LOG("release dataShareHelper, ret=%{public}d", releaseRet);
110 }
111 isDataShareReady_ = true;
112 return true;
113 } else if (ret.first == DataShare::E_DATA_SHARE_NOT_READY) {
114 isDataShareReady_ = false;
115 return false;
116 }
117 return true;
118 }
119 } // namespace CameraStandard
120 } // namespace OHOS
121
122