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 "i_locator.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 auto remote = sptr<ILocator>(new (std::nothrow) IRemoteStub<ILocator>());
54 if (remote == nullptr) {
55 LBSLOGE(LOCATOR_STANDARD, "%{public}s: remoteObject is nullptr", __func__);
56 return;
57 }
58 remoteObj_ = remote->AsObject();
59 }
60
CreateDataShareHelper()61 std::shared_ptr<DataShare::DataShareHelper> LocationDataRdbHelper::CreateDataShareHelper()
62 {
63 if (remoteObj_ == nullptr) {
64 LBSLOGE(LOCATOR_STANDARD, "%{public}s: remoteObject is nullptr, reInitialize", __func__);
65 Initialize();
66 }
67 return DataShare::DataShareHelper::Creator(remoteObj_,
68 LocationDataRdbManager::GetLocationDataUriByCurrentUserId("location_enable"));
69 }
70
ReleaseDataShareHelper(std::shared_ptr<DataShare::DataShareHelper> & dataShareHelper)71 void LocationDataRdbHelper::ReleaseDataShareHelper(std::shared_ptr<DataShare::DataShareHelper>& dataShareHelper)
72 {
73 if (dataShareHelper == nullptr) {
74 return;
75 }
76 dataShareHelper->Release();
77 }
78
RegisterDataObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)79 LocationErrCode LocationDataRdbHelper::RegisterDataObserver(
80 const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
81 {
82 auto dataShareHelper = CreateDataShareHelper();
83 if (dataShareHelper == nullptr) {
84 return ERRCODE_SERVICE_UNAVAILABLE;
85 }
86 dataShareHelper->RegisterObserver(uri, dataObserver);
87 ReleaseDataShareHelper(dataShareHelper);
88 return ERRCODE_SUCCESS;
89 }
90
UnregisterDataObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)91 LocationErrCode LocationDataRdbHelper::UnregisterDataObserver(
92 const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
93 {
94 auto dataShareHelper = CreateDataShareHelper();
95 if (dataShareHelper == nullptr) {
96 return ERRCODE_SERVICE_UNAVAILABLE;
97 }
98 dataShareHelper->UnregisterObserver(uri, dataObserver);
99 ReleaseDataShareHelper(dataShareHelper);
100 return ERRCODE_SUCCESS;
101 }
102
GetValue(Uri & uri,const std::string & column,int32_t & value)103 LocationErrCode LocationDataRdbHelper::GetValue(Uri &uri, const std::string &column, int32_t &value)
104 {
105 std::string valueStr;
106 LocationErrCode errCode = GetStringValue(uri, column, valueStr);
107 value = atoi(valueStr.c_str());
108 LBSLOGD(LOCATOR_STANDARD, "LocationDataRdbHelper:%{public}s success, value = %{public}d", __func__, value);
109 return errCode;
110 }
111
GetStringValue(Uri & uri,const std::string & column,std::string & value)112 LocationErrCode LocationDataRdbHelper::GetStringValue(Uri &uri, const std::string &column, std::string &value)
113 {
114 auto dataShareHelper = CreateDataShareHelper();
115 if (dataShareHelper == nullptr) {
116 return ERRCODE_SERVICE_UNAVAILABLE;
117 }
118 DataShare::DataSharePredicates predicates;
119 std::vector<std::string> columns;
120 predicates.EqualTo(LOCATION_DATA_COLUMN_KEYWORD, column);
121 auto rows = dataShareHelper->Query(uri, predicates, columns);
122 if (rows == nullptr) {
123 LBSLOGE(LOCATOR_STANDARD, "%{public}s can not get rows", __func__);
124 ReleaseDataShareHelper(dataShareHelper);
125 return ERRCODE_SERVICE_UNAVAILABLE;
126 }
127 rows->GoToFirstRow();
128 int32_t columnIndex;
129 rows->GetColumnIndex(LOCATION_DATA_COLUMN_VALUE, columnIndex);
130 std::string valueStr;
131 int32_t ret = rows->GetString(columnIndex, valueStr);
132 if (ret != 0) {
133 LBSLOGE(LOCATOR_STANDARD, "%{public}s can not get value", __func__);
134 rows->Close();
135 ReleaseDataShareHelper(dataShareHelper);
136 return ERRCODE_SERVICE_UNAVAILABLE;
137 }
138 rows->Close();
139 ReleaseDataShareHelper(dataShareHelper);
140 value = valueStr;
141 return ERRCODE_SUCCESS;
142 }
143
SetValue(Uri & uri,const std::string & column,int & value)144 LocationErrCode LocationDataRdbHelper::SetValue(Uri &uri, const std::string &column, int &value)
145 {
146 auto dataShareHelper = CreateDataShareHelper();
147 if (dataShareHelper == nullptr) {
148 return ERRCODE_SERVICE_UNAVAILABLE;
149 }
150 int32_t oldVal = 0;
151 LocationErrCode errorCode = GetValue(uri, column, oldVal);
152 DataShare::DataShareValueObject keyObj(column);
153 DataShare::DataShareValueObject valueObj(std::to_string(value));
154 DataShare::DataShareValuesBucket bucket;
155 bucket.Put(LOCATION_DATA_COLUMN_VALUE, valueObj);
156 bucket.Put(LOCATION_DATA_COLUMN_KEYWORD, keyObj);
157 int32_t err;
158 if (errorCode != ERRCODE_SUCCESS) {
159 err = dataShareHelper->Insert(uri, bucket);
160 } else {
161 DataShare::DataSharePredicates predicates;
162 predicates.EqualTo(LOCATION_DATA_COLUMN_KEYWORD, column);
163 err = dataShareHelper->Update(uri, predicates, bucket);
164 }
165 if (err < 0) {
166 LBSLOGE(LOCATOR_STANDARD, "%{public}s: can not set value", __func__);
167 ReleaseDataShareHelper(dataShareHelper);
168 return ERRCODE_SERVICE_UNAVAILABLE;
169 }
170 dataShareHelper->NotifyChange(uri);
171 ReleaseDataShareHelper(dataShareHelper);
172 return ERRCODE_SUCCESS;
173 }
174 } // namespace Location
175 } // namespace OHOS