1 /*
2 * Copyright (c) 2024 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 "datashare_errno.h"
17 #include "datashare_predicates.h"
18 #include "datashare_result_set.h"
19 #include "datashare_values_bucket.h"
20 #include "iservice_registry.h"
21 #include "oobe_datashare_utils.h"
22 #include "res_sched_log.h"
23 #include "system_ability_definition.h"
24 #include "uri.h"
25
26 namespace OHOS {
27 namespace ResourceSchedule {
28 sptr<IRemoteObject> DataShareUtils::remoteObj_;
29 ffrt::mutex DataShareUtils::mutex_;
30 namespace {
31 constexpr const int32_t E_OK = 0;
32 constexpr const int32_t E_DATA_SHARE_NOT_READY = 1055;
33 const std::string SETTING_COLUMN_KEYWORD = "KEYWORD";
34 const std::string SETTING_COLUMN_VALUE = "VALUE";
35 constexpr const char *SETTINGS_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
36 const std::string SETTING_URI_PROXY = "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
37 } // namespace
38
39 DataShareUtils::DataShareUtils() = default;
40 DataShareUtils::~DataShareUtils() = default;
41
GetInstance()42 DataShareUtils& DataShareUtils::GetInstance()
43 {
44 static DataShareUtils instance;
45 instance.InitSystemAbilityManager();
46 return instance;
47 }
48
GetStringValue(const std::string & key,std::string & value)49 ErrCode DataShareUtils::GetStringValue(const std::string& key, std::string& value)
50 {
51 auto helper = CreateDataShareHelper();
52 if (helper == nullptr) {
53 RESSCHED_LOGE("DataShareUtils: helper does not created!");
54 return ERR_NO_INIT;
55 }
56 std::vector<std::string> columns = {SETTING_COLUMN_VALUE};
57 DataShare::DataSharePredicates predicates;
58 predicates.EqualTo(SETTING_COLUMN_KEYWORD, key);
59 RESSCHED_LOGD("keyWord=%{public}s", key.c_str());
60 Uri uri(AssembleUri(key));
61 auto resultSet = helper->Query(uri, predicates, columns);
62 ReleaseDataShareHelper(helper);
63 if (resultSet == nullptr) {
64 RESSCHED_LOGE("helper->Query return nullptr");
65 return ERR_INVALID_OPERATION;
66 }
67 int32_t count;
68 resultSet->GetRowCount(count);
69 if (count == 0) {
70 RESSCHED_LOGW("not found value, keyWord=%{public}s, count=%{public}d", key.c_str(), count);
71 return ERR_NAME_NOT_FOUND;
72 }
73 const int32_t INDEX = 0;
74 resultSet->GoToRow(INDEX);
75 int32_t ret = resultSet->GetString(INDEX, value);
76 if (ret != DataShare::E_OK) {
77 RESSCHED_LOGW("resultSet->GetString return not ok, ret=%{public}d", ret);
78 return ERR_INVALID_VALUE;
79 }
80 return ERR_OK;
81 }
82
CreateDataShareHelper()83 std::shared_ptr<DataShare::DataShareHelper> DataShareUtils::CreateDataShareHelper()
84 {
85 if (remoteObj_ == nullptr) {
86 RESSCHED_LOGE("Get remoteObj return nullptr!");
87 return nullptr;
88 }
89 std::pair<int, std::shared_ptr<DataShare::DataShareHelper>> ret =
90 DataShare::DataShareHelper::Create(remoteObj_, SETTING_URI_PROXY, SETTINGS_DATA_EXT_URI);
91 if (ret.first == E_OK) {
92 RESSCHED_LOGI("create data_share helper success!");
93 auto helper = ret.second;
94 isConnectDataShareSucc = true;
95 return helper;
96 }
97 RESSCHED_LOGE("create data_share helper faild!");
98 isConnectDataShareSucc = false;
99 return nullptr;
100 }
101
ReleaseDataShareHelper(std::shared_ptr<DataShare::DataShareHelper> & helper)102 bool DataShareUtils::ReleaseDataShareHelper(std::shared_ptr<DataShare::DataShareHelper>& helper)
103 {
104 if (helper == nullptr) {
105 RESSCHED_LOGW("release helper fail, helper is null!");
106 return false;
107 }
108 if (!helper->Release()) {
109 RESSCHED_LOGW("release helper fail.");
110 return false;
111 }
112 return true;
113 }
114
InitSystemAbilityManager()115 void DataShareUtils::InitSystemAbilityManager()
116 {
117 auto sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
118 if (sam == nullptr) {
119 RESSCHED_LOGE("get sam return nullptr");
120 return;
121 }
122 auto remoteObj = sam->GetSystemAbility(RES_SCHED_SYS_ABILITY_ID);
123 if (remoteObj == nullptr) {
124 RESSCHED_LOGE("Get remoteObj return nullptr, systemAbilityId=%{public}d", RES_SCHED_SYS_ABILITY_ID);
125 return;
126 }
127 remoteObj_ = remoteObj;
128 }
129
AssembleUri(const std::string & key)130 Uri DataShareUtils::AssembleUri(const std::string& key)
131 {
132 Uri uri(SETTING_URI_PROXY + "&key=" + key);
133 return uri;
134 }
135
IsConnectDataShareSucc()136 bool DataShareUtils::IsConnectDataShareSucc()
137 {
138 return isConnectDataShareSucc;
139 }
140
GetDataShareReadyFlag()141 bool DataShareUtils::GetDataShareReadyFlag()
142 {
143 std::lock_guard<ffrt::mutex> lock(mutex_);
144 return isDataShareReady_;
145 }
146
SetDataShareReadyFlag(bool readyFlag)147 void DataShareUtils::SetDataShareReadyFlag(bool readyFlag)
148 {
149 std::lock_guard<ffrt::mutex> lock(mutex_);
150 isDataShareReady_ = readyFlag;
151 }
152 } // namespace ResourceSchedule
153 } // namespace OHOS