1 /*
2 * Copyright (c) 2023 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 "location_data_rdb_helper.h"
17
18 #include "if_system_ability_manager.h"
19 #include "iservice_registry.h"
20 #include "location_sa_load_manager.h"
21 #include "system_ability_definition.h"
22
23 #include "datashare_predicates.h"
24 #include "datashare_values_bucket.h"
25 #include "common_utils.h"
26 #include "ilocator_service.h"
27 #include "location_log.h"
28 #include "location_data_rdb_manager.h"
29
30 namespace OHOS {
31 namespace Location {
32 constexpr const char* LOCATION_DATA_COLUMN_KEYWORD = "KEYWORD";
33 constexpr const char* LOCATION_DATA_COLUMN_VALUE = "VALUE";
34
GetInstance()35 LocationDataRdbHelper* LocationDataRdbHelper::GetInstance()
36 {
37 static LocationDataRdbHelper data;
38 return &data;
39 }
40
LocationDataRdbHelper()41 LocationDataRdbHelper::LocationDataRdbHelper()
42 {
43 Initialize();
44 }
45
~LocationDataRdbHelper()46 LocationDataRdbHelper::~LocationDataRdbHelper()
47 {
48 remoteObj_ = nullptr;
49 }
50
Initialize()51 void LocationDataRdbHelper::Initialize()
52 {
53 sptr<IRemoteObject> objectLocator =
54 CommonUtils::GetRemoteObject(LOCATION_LOCATOR_SA_ID, CommonUtils::InitDeviceId());
55 if (objectLocator == nullptr) {
56 LBSLOGE(LOCATOR_STANDARD, "%{public}s get locator sa failed", __func__);
57 return;
58 }
59 sptr<ILocatorService> client = iface_cast<ILocatorService>(objectLocator);
60 if (!client || !client->AsObject()) {
61 LBSLOGE(LOCATOR_STANDARD, "%{public}s: get locator service failed.", __func__);
62 return;
63 }
64 remoteObj_ = client->AsObject();
65 }
66
CreateDataShareHelper()67 std::shared_ptr<DataShare::DataShareHelper> LocationDataRdbHelper::CreateDataShareHelper()
68 {
69 if (remoteObj_ == nullptr) {
70 LBSLOGE(LOCATOR_STANDARD, "%{public}s: remoteObject is nullptr, reInitialize", __func__);
71 Initialize();
72 }
73 return DataShare::DataShareHelper::Creator(remoteObj_,
74 LocationDataRdbManager::GetLocationDataUriByCurrentUserId("location_enable"));
75 }
76
ReleaseDataShareHelper(std::shared_ptr<DataShare::DataShareHelper> & dataShareHelper)77 void LocationDataRdbHelper::ReleaseDataShareHelper(std::shared_ptr<DataShare::DataShareHelper>& dataShareHelper)
78 {
79 if (dataShareHelper == nullptr) {
80 return;
81 }
82 dataShareHelper->Release();
83 }
84
RegisterDataObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)85 LocationErrCode LocationDataRdbHelper::RegisterDataObserver(
86 const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
87 {
88 auto dataShareHelper = CreateDataShareHelper();
89 if (dataShareHelper == nullptr) {
90 return ERRCODE_SERVICE_UNAVAILABLE;
91 }
92 dataShareHelper->RegisterObserver(uri, dataObserver);
93 ReleaseDataShareHelper(dataShareHelper);
94 return ERRCODE_SUCCESS;
95 }
96
UnregisterDataObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)97 LocationErrCode LocationDataRdbHelper::UnregisterDataObserver(
98 const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
99 {
100 auto dataShareHelper = CreateDataShareHelper();
101 if (dataShareHelper == nullptr) {
102 return ERRCODE_SERVICE_UNAVAILABLE;
103 }
104 dataShareHelper->UnregisterObserver(uri, dataObserver);
105 ReleaseDataShareHelper(dataShareHelper);
106 return ERRCODE_SUCCESS;
107 }
108
GetValue(Uri & uri,const std::string & column,int32_t & value)109 LocationErrCode LocationDataRdbHelper::GetValue(Uri &uri, const std::string &column, int32_t &value)
110 {
111 std::string valueStr;
112 LocationErrCode errCode = GetStringValue(uri, column, valueStr);
113 value = atoi(valueStr.c_str());
114 LBSLOGD(LOCATOR_STANDARD, "LocationDataRdbHelper:%{public}s success, value = %{public}d", __func__, value);
115 return errCode;
116 }
117
GetStringValue(Uri & uri,const std::string & column,std::string & value)118 LocationErrCode LocationDataRdbHelper::GetStringValue(Uri &uri, const std::string &column, std::string &value)
119 {
120 auto dataShareHelper = CreateDataShareHelper();
121 if (dataShareHelper == nullptr) {
122 return ERRCODE_SERVICE_UNAVAILABLE;
123 }
124 DataShare::DataSharePredicates predicates;
125 std::vector<std::string> columns;
126 predicates.EqualTo(LOCATION_DATA_COLUMN_KEYWORD, column);
127 auto rows = dataShareHelper->Query(uri, predicates, columns);
128 if (rows == nullptr) {
129 LBSLOGE(LOCATOR_STANDARD, "%{public}s can not get rows", __func__);
130 ReleaseDataShareHelper(dataShareHelper);
131 return ERRCODE_SERVICE_UNAVAILABLE;
132 }
133 rows->GoToFirstRow();
134 int32_t columnIndex;
135 rows->GetColumnIndex(LOCATION_DATA_COLUMN_VALUE, columnIndex);
136 std::string valueStr;
137 int32_t ret = rows->GetString(columnIndex, valueStr);
138 if (ret != 0) {
139 LBSLOGE(LOCATOR_STANDARD, "%{public}s can not get value", __func__);
140 rows->Close();
141 ReleaseDataShareHelper(dataShareHelper);
142 return ERRCODE_SERVICE_UNAVAILABLE;
143 }
144 rows->Close();
145 ReleaseDataShareHelper(dataShareHelper);
146 value = valueStr;
147 return ERRCODE_SUCCESS;
148 }
149
SetValue(Uri & uri,const std::string & column,int & value)150 LocationErrCode LocationDataRdbHelper::SetValue(Uri &uri, const std::string &column, int &value)
151 {
152 auto dataShareHelper = CreateDataShareHelper();
153 if (dataShareHelper == nullptr) {
154 return ERRCODE_SERVICE_UNAVAILABLE;
155 }
156 int32_t oldVal = 0;
157 LocationErrCode errorCode = GetValue(uri, column, oldVal);
158 DataShare::DataShareValueObject keyObj(column);
159 DataShare::DataShareValueObject valueObj(std::to_string(value));
160 DataShare::DataShareValuesBucket bucket;
161 bucket.Put(LOCATION_DATA_COLUMN_VALUE, valueObj);
162 bucket.Put(LOCATION_DATA_COLUMN_KEYWORD, keyObj);
163 int32_t err;
164 if (errorCode != ERRCODE_SUCCESS) {
165 err = dataShareHelper->Insert(uri, bucket);
166 } else {
167 DataShare::DataSharePredicates predicates;
168 predicates.EqualTo(LOCATION_DATA_COLUMN_KEYWORD, column);
169 err = dataShareHelper->Update(uri, predicates, bucket);
170 }
171 if (err < 0) {
172 LBSLOGE(LOCATOR_STANDARD, "%{public}s: can not set value", __func__);
173 ReleaseDataShareHelper(dataShareHelper);
174 return ERRCODE_SERVICE_UNAVAILABLE;
175 }
176 dataShareHelper->NotifyChange(uri);
177 ReleaseDataShareHelper(dataShareHelper);
178 return ERRCODE_SUCCESS;
179 }
180
GetIntelligentValue(Uri & uri,const std::string & createHelperUri,const std::string & column,std::string & value)181 LocationErrCode LocationDataRdbHelper::GetIntelligentValue(
182 Uri &uri, const std::string &createHelperUri, const std::string &column, std::string &value)
183 {
184 if (remoteObj_ == nullptr) {
185 LBSLOGE(LOCATOR_STANDARD, "%{public}s: remoteObject is nullptr, reInitialize", __func__);
186 Initialize();
187 }
188 auto dataShareHelper = DataShare::DataShareHelper::Creator(remoteObj_, createHelperUri);
189 if (dataShareHelper == nullptr) {
190 LBSLOGE(LOCATOR_STANDARD, "create dataShareHelper failed");
191 return ERRCODE_SERVICE_UNAVAILABLE;
192 }
193 DataShare::DataSharePredicates predicates;
194 std::vector<std::string> columns;
195 auto rows = dataShareHelper->Query(uri, predicates, columns);
196 if (rows == nullptr) {
197 LBSLOGE(LOCATOR_STANDARD, "%{public}s can not get rows", __func__);
198 ReleaseDataShareHelper(dataShareHelper);
199 return ERRCODE_SERVICE_UNAVAILABLE;
200 }
201 rows->GoToFirstRow();
202 int32_t columnIndex;
203 rows->GetColumnIndex(column, columnIndex);
204 std::string valueStr;
205 int32_t ret = rows->GetString(columnIndex, valueStr);
206 if (ret != 0) {
207 LBSLOGE(LOCATOR_STANDARD, "%{public}s can not get value", __func__);
208 rows->Close();
209 ReleaseDataShareHelper(dataShareHelper);
210 return ERRCODE_SERVICE_UNAVAILABLE;
211 }
212 rows->Close();
213 ReleaseDataShareHelper(dataShareHelper);
214 value = valueStr;
215 return ERRCODE_SUCCESS;
216 }
217 } // namespace Location
218 } // namespace OHOS