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