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 "device_icon_info_dao.h"
17
18 #include "distributed_device_profile_constants.h"
19 #include "distributed_device_profile_errors.h"
20 #include "distributed_device_profile_log.h"
21 #include "dp_services_constants.h"
22 #include "profile_data_rdb_adapter.h"
23
24 namespace OHOS {
25 namespace DistributedDeviceProfile {
26 IMPLEMENT_SINGLE_INSTANCE(DeviceIconInfoDao);
27 namespace {
28 const std::string TAG = "DeviceIconInfoDao";
29 }
30
Init()31 int32_t DeviceIconInfoDao::Init()
32 {
33 std::lock_guard<std::mutex> lock(rdbMutex_);
34 int32_t ret = RET_INIT;
35 if (!ProfileDataRdbAdapter::GetInstance().IsInit()) {
36 ret = ProfileDataRdbAdapter::GetInstance().Init();
37 if (ret != DP_SUCCESS) {
38 HILOGE("ProfileDataRdbAdapter Init failed");
39 return DP_INIT_DB_FAILED;
40 }
41 }
42 CreateTable();
43 CreateIndex();
44 HILOGI("end!");
45 return DP_SUCCESS;
46 }
47
UnInit()48 int32_t DeviceIconInfoDao::UnInit()
49 {
50 std::lock_guard<std::mutex> lock(rdbMutex_);
51 if (!ProfileDataRdbAdapter::GetInstance().IsInit()) {
52 HILOGE("ProfileDataRdbAdapter is UnInit");
53 return DP_SUCCESS;
54 }
55 int32_t ret = ProfileDataRdbAdapter::GetInstance().UnInit();
56 if (ret != DP_SUCCESS) {
57 HILOGE("ProfileDataRdbAdapter UnInit failed");
58 return DP_UNINIT_FAIL;
59 }
60 HILOGI("end!");
61 return DP_SUCCESS;
62 }
63
PutDeviceIconInfo(const DeviceIconInfo & deviceIconInfo)64 int32_t DeviceIconInfoDao::PutDeviceIconInfo(const DeviceIconInfo& deviceIconInfo)
65 {
66 HILOGI("deviceIconInfo:%{public}s", deviceIconInfo.dump().c_str());
67 ValuesBucket values;
68 DeviceIconInfoToEntries(deviceIconInfo, values);
69 int64_t rowId = ROWID_INIT;
70 int32_t ret = RET_INIT;
71 {
72 std::lock_guard<std::mutex> lock(rdbMutex_);
73 ret = ProfileDataRdbAdapter::GetInstance().Put(rowId, DEVICE_ICON_INFO_TABLE, values);
74 if (ret != DP_SUCCESS) {
75 HILOGE("%{public}s insert failed", DEVICE_ICON_INFO_TABLE.c_str());
76 return DP_PUT_DEVICE_ICON_INFO_FAIL;
77 }
78 }
79 HILOGI("end!");
80 return DP_SUCCESS;
81 }
82
GetDeviceIconInfos(const DeviceIconInfoFilterOptions & filterOptions,std::vector<DeviceIconInfo> & deviceIconInfos)83 int32_t DeviceIconInfoDao::GetDeviceIconInfos(const DeviceIconInfoFilterOptions& filterOptions,
84 std::vector<DeviceIconInfo>& deviceIconInfos)
85 {
86 std::string sql;
87 std::vector<ValueObject> condition;
88 if (!CreateQuerySqlAndCondition(filterOptions, sql, condition)) {
89 HILOGE("invalid params:%{public}s", filterOptions.dump().c_str());
90 return DP_INVALID_PARAMS;
91 }
92 std::shared_ptr<ResultSet> resultSet = ProfileDataRdbAdapter::GetInstance().Get(sql, condition);
93 if (resultSet == nullptr) {
94 HILOGE("resultSet is nullptr");
95 return DP_GET_RESULTSET_FAIL;
96 }
97 int32_t rowCount = ROWCOUNT_INIT;
98 resultSet->GetRowCount(rowCount);
99 if (rowCount == 0) {
100 HILOGE("by condition not find data");
101 resultSet->Close();
102 return DP_NOT_FIND_DATA;
103 }
104 while (resultSet->GoToNextRow() == DP_SUCCESS) {
105 DeviceIconInfo deviceIconInfo;
106 ConvertToDeviceIconInfo(resultSet, deviceIconInfo);
107 deviceIconInfos.emplace_back(deviceIconInfo);
108 }
109 resultSet->Close();
110 if (deviceIconInfos.empty()) {
111 return DP_NOT_FIND_DATA;
112 }
113 HILOGI("end!");
114 return DP_SUCCESS;
115 }
116
DeleteDeviceIconInfo(const DeviceIconInfo & deviceIconInfo)117 int32_t DeviceIconInfoDao::DeleteDeviceIconInfo(const DeviceIconInfo& deviceIconInfo)
118 {
119 {
120 std::lock_guard<std::mutex> lock(rdbMutex_);
121 int32_t deleteRows = DELETEROWS_INIT;
122 int32_t ret = ProfileDataRdbAdapter::GetInstance().Delete(deleteRows, DEVICE_ICON_INFO_TABLE,
123 ID_EQUAL_CONDITION, std::vector<ValueObject>{ ValueObject(deviceIconInfo.GetId()) });
124 if (ret != DP_SUCCESS) {
125 HILOGE("delete %{public}s data failed", DEVICE_ICON_INFO_TABLE.c_str());
126 return DP_DEL_DEVICE_ICON_INFO_FAIL;
127 }
128 }
129 HILOGI("end!");
130 return DP_SUCCESS;
131 }
132
UpdateDeviceIconInfo(const DeviceIconInfo & deviceIconInfo)133 int32_t DeviceIconInfoDao::UpdateDeviceIconInfo(const DeviceIconInfo& deviceIconInfo)
134 {
135 HILOGI("deviceIconInfo:%{public}s", deviceIconInfo.dump().c_str());
136 ValuesBucket values;
137 DeviceIconInfoToEntries(deviceIconInfo, values);
138 int32_t changeRowCnt = CHANGEROWCNT_INIT;
139 {
140 std::lock_guard<std::mutex> lock(rdbMutex_);
141 int32_t ret = ProfileDataRdbAdapter::GetInstance().Update(changeRowCnt, DEVICE_ICON_INFO_TABLE, values,
142 ID_EQUAL_CONDITION, std::vector<ValueObject>{ ValueObject(deviceIconInfo.GetId()) });
143 if (ret != DP_SUCCESS) {
144 HILOGE("Update %{public}s table failed", DEVICE_ICON_INFO_TABLE.c_str());
145 return DP_UPDATE_DEVICE_ICON_INFO_FAIL;
146 }
147 }
148 HILOGI("end!");
149 return DP_SUCCESS;
150 }
151
CreateTable()152 int32_t DeviceIconInfoDao::CreateTable()
153 {
154 int32_t ret = ProfileDataRdbAdapter::GetInstance().CreateTable(CREATE_DEVICE_ICON_INFO_TABLE_SQL);
155 if (ret != DP_SUCCESS) {
156 HILOGE("%{public}s create failed", DEVICE_ICON_INFO_TABLE.c_str());
157 return DP_CREATE_TABLE_FAIL;
158 }
159 return DP_SUCCESS;
160 }
161
CreateIndex()162 int32_t DeviceIconInfoDao::CreateIndex()
163 {
164 int32_t ret = ProfileDataRdbAdapter::GetInstance().CreateTable(CREATE_DEVICE_ICON_INFO_TABLE_UNIQUE_INDEX_SQL);
165 if (ret != DP_SUCCESS) {
166 HILOGE("%{public}s unique index create failed", DEVICE_ICON_INFO_TABLE.c_str());
167 return DP_CREATE_UNIQUE_INDEX_FAIL;
168 }
169 return DP_SUCCESS;
170 }
171
CreateQuerySqlAndCondition(const DeviceIconInfoFilterOptions & filterOptions,std::string & sql,std::vector<ValueObject> & condition)172 bool DeviceIconInfoDao::CreateQuerySqlAndCondition(const DeviceIconInfoFilterOptions& filterOptions,
173 std::string& sql, std::vector<ValueObject>& condition)
174 {
175 sql = SELECT_DEVICE_ICON_INFO_TABLE;
176 bool flag = false;
177 if (!filterOptions.GetProductIds().empty()) {
178 sql += "a." + PRODUCT_ID + " IN(";
179 for (const auto& prodId : filterOptions.GetProductIds()) {
180 sql += "?,";
181 condition.emplace_back(ValueObject(prodId));
182 }
183 sql.erase(sql.end() - 1, sql.end());
184 sql += ") AND ";
185 flag = true;
186 }
187 if (!filterOptions.GetSubProductId().empty()) {
188 sql += "a." + SUB_PRODUCT_ID + " = ? AND ";
189 condition.emplace_back(ValueObject(filterOptions.GetSubProductId()));
190 flag = true;
191 }
192 if (!filterOptions.GetInternalModel().empty()) {
193 sql += "a." + INTERNAL_MODEL + " = ? AND ";
194 condition.emplace_back(ValueObject(filterOptions.GetInternalModel()));
195 flag = true;
196 }
197 if (!filterOptions.GetImageType().empty()) {
198 sql += "a." + IMAGE_TYPE + " = ? AND ";
199 condition.emplace_back(ValueObject(filterOptions.GetImageType()));
200 flag = true;
201 }
202 if (!filterOptions.GetSpecName().empty()) {
203 sql += "a." + SPEC_NAME + " = ? AND ";
204 condition.emplace_back(ValueObject(filterOptions.GetSpecName()));
205 flag = true;
206 }
207 if (flag) {
208 sql.erase(sql.end() - NUM_4, sql.end());
209 return flag;
210 }
211 return flag;
212 }
213
DeviceIconInfoToEntries(const DeviceIconInfo & deviceIconInfo,ValuesBucket & values)214 int32_t DeviceIconInfoDao::DeviceIconInfoToEntries(const DeviceIconInfo& deviceIconInfo, ValuesBucket& values)
215 {
216 values.PutString(PRODUCT_ID, deviceIconInfo.GetProductId());
217 values.PutString(INTERNAL_MODEL, deviceIconInfo.GetInternalModel());
218 values.PutString(SUB_PRODUCT_ID, deviceIconInfo.GetSubProductId());
219 values.PutString(IMAGE_TYPE, deviceIconInfo.GetImageType());
220 values.PutString(SPEC_NAME, deviceIconInfo.GetSpecName());
221 values.PutString(DEVICE_ICON_VERSION, deviceIconInfo.GetVersion());
222 values.PutString(DEVICE_ICON_URL, deviceIconInfo.GetUrl());
223 if (!deviceIconInfo.GetIcon().empty()) {
224 values.PutBlob(DEVICE_ICON, deviceIconInfo.GetIcon());
225 }
226 return DP_SUCCESS;
227 }
228
ConvertToDeviceIconInfo(std::shared_ptr<ResultSet> resultSet,DeviceIconInfo & deviceIconInfo)229 int32_t DeviceIconInfoDao::ConvertToDeviceIconInfo(std::shared_ptr<ResultSet> resultSet, DeviceIconInfo& deviceIconInfo)
230 {
231 if (resultSet == nullptr) {
232 HILOGE("resultSet is nullptr.");
233 return DP_GET_RESULTSET_FAIL;
234 }
235 RowEntity rowEntity;
236 if (resultSet->GetRow(rowEntity) != DP_SUCCESS) {
237 HILOGE("get resultSet failed");
238 return DP_GET_RESULTSET_FAIL;
239 }
240 deviceIconInfo.SetId(rowEntity.Get(ID));
241 deviceIconInfo.SetProductId(rowEntity.Get(PRODUCT_ID));
242 deviceIconInfo.SetInternalModel(rowEntity.Get(INTERNAL_MODEL));
243 deviceIconInfo.SetSubProductId(rowEntity.Get(SUB_PRODUCT_ID));
244 deviceIconInfo.SetImageType(rowEntity.Get(IMAGE_TYPE));
245 deviceIconInfo.SetSpecName(rowEntity.Get(SPEC_NAME));
246 deviceIconInfo.SetVersion(rowEntity.Get(DEVICE_ICON_VERSION));
247 deviceIconInfo.SetWiseVersion(rowEntity.Get(IMAGE_VERSION));
248 deviceIconInfo.SetUrl(rowEntity.Get(DEVICE_ICON_URL));
249 deviceIconInfo.SetIcon(rowEntity.Get(DEVICE_ICON));
250 return DP_SUCCESS;
251 }
252 } // namespace DistributedDeviceProfile
253 } // namespace OHOS
254