1 /*
2 * Copyright (c) 2022 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 "form_info_rdb_storage_mgr.h"
17
18 #include <cinttypes>
19 #include <thread>
20 #include <unistd.h>
21 #include "fms_log_wrapper.h"
22 #include "form_constants.h"
23 #include "form_event_report.h"
24
25 namespace OHOS {
26 namespace AppExecFwk {
27 namespace {
28 constexpr int32_t MAX_TIMES = 600; // 600 * 100ms = 1min
29 constexpr int32_t SLEEP_INTERVAL = 100 * 1000; // 100ms
30 const std::string FORM_INFO_PREFIX = "formInfo_";
31 const std::string FORM_ID_PREFIX = "formId_";
32 const std::string STATUS_DATA_PREFIX = "statusData_";
33 const std::string FORM_VERSION_KEY = "versionCode_form";
34 } // namespace
35
FormInfoRdbStorageMgr()36 FormInfoRdbStorageMgr::FormInfoRdbStorageMgr()
37 {
38 HILOG_DEBUG("FormInfoRdbStorageMgr is created");
39 FormRdbTableConfig formRdbTableConfig;
40 if (FormRdbDataMgr::GetInstance().InitFormRdbTable(formRdbTableConfig) != ERR_OK) {
41 HILOG_ERROR("Form info rdb storage mgr init form rdb table fail");
42 FormEventReport::SendFormFailedEvent(FormEventName::INIT_FMS_FAILED, HiSysEventType::FAULT,
43 static_cast<int64_t>(InitFmsFiledErrorType::LOAD_FORM_DB_FAILED));
44 }
45 }
46
~FormInfoRdbStorageMgr()47 FormInfoRdbStorageMgr::~FormInfoRdbStorageMgr()
48 {
49 HILOG_DEBUG("FormInfoRdbStorageMgr is deleted");
50 }
51
LoadFormInfos(std::vector<std::pair<std::string,std::string>> & formInfoStorages)52 ErrCode FormInfoRdbStorageMgr::LoadFormInfos(std::vector<std::pair<std::string, std::string>> &formInfoStorages)
53 {
54 HILOG_DEBUG("FormInfoAllRdbStorageMgr load all form infos");
55 std::unordered_map<std::string, std::string> value;
56 ErrCode result = FormRdbDataMgr::GetInstance().QueryData(Constants::FORM_RDB_TABLE_NAME,
57 FORM_INFO_PREFIX, value);
58 if (result != ERR_OK) {
59 HILOG_ERROR("get entries error");
60 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
61 static_cast<int64_t>(CallDbFiledErrorType::LOAD_DATABASE_FAILED));
62 return ERR_APPEXECFWK_FORM_COMMON_CODE;
63 }
64
65 for (const auto &item: value) {
66 formInfoStorages.emplace_back(item.first.substr(FORM_INFO_PREFIX.length()), item.second);
67 }
68
69 return ERR_OK;
70 }
71
RemoveBundleFormInfos(const std::string & bundleName)72 ErrCode FormInfoRdbStorageMgr::RemoveBundleFormInfos(const std::string &bundleName)
73 {
74 if (bundleName.empty()) {
75 HILOG_ERROR("empty bundleName");
76 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
77 }
78
79 HILOG_DEBUG("FormInfoRdbStorageMgr remove form info, bundleName=%{public}s", bundleName.c_str());
80
81 std::string key = std::string().append(FORM_INFO_PREFIX).append(bundleName);
82 ErrCode result;
83 {
84 std::lock_guard<std::mutex> lock(rdbStorePtrMutex_);
85 result = FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, key);
86 }
87
88 if (result != ERR_OK) {
89 HILOG_ERROR("remove formInfoStorages from rdbStore error");
90 return ERR_APPEXECFWK_FORM_COMMON_CODE;
91 }
92 return ERR_OK;
93 }
94
UpdateBundleFormInfos(const std::string & bundleName,const std::string & formInfoStorages)95 ErrCode FormInfoRdbStorageMgr::UpdateBundleFormInfos(const std::string &bundleName, const std::string &formInfoStorages)
96 {
97 if (bundleName.empty()) {
98 HILOG_ERROR("empty bundleName");
99 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
100 }
101
102 HILOG_DEBUG("FormInfoRdbStorageMgr update form info, bundleName=%{public}s", bundleName.c_str());
103 std::string key = std::string().append(FORM_INFO_PREFIX).append(bundleName);
104 std::lock_guard<std::mutex> lock(rdbStorePtrMutex_);
105 std::string value = formInfoStorages;
106 ErrCode result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, key, value);
107 if (result != ERR_OK) {
108 HILOG_ERROR("update formInfoStorages to rdbStore error");
109 return ERR_APPEXECFWK_FORM_COMMON_CODE;
110 }
111 return ERR_OK;
112 }
113
SaveEntries(const std::unordered_map<std::string,std::string> & value,std::vector<InnerFormInfo> & innerFormInfos)114 void FormInfoRdbStorageMgr::SaveEntries(
115 const std::unordered_map<std::string, std::string> &value, std::vector<InnerFormInfo> &innerFormInfos)
116 {
117 for (const auto &item : value) {
118 InnerFormInfo innerFormInfo;
119 nlohmann::json jsonObject = nlohmann::json::parse(item.second, nullptr, false);
120 if (jsonObject.is_discarded() || innerFormInfo.FromJson(jsonObject) != true) {
121 HILOG_ERROR("error key: %{private}s", item.first.c_str());
122 FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, item.first);
123 continue;
124 }
125
126 if (std::find(innerFormInfos.begin(), innerFormInfos.end(), innerFormInfo) == innerFormInfos.end()) {
127 innerFormInfos.emplace_back(innerFormInfo);
128 }
129 }
130 HILOG_DEBUG("SaveEntries end");
131 }
132
LoadFormData(std::vector<InnerFormInfo> & innerFormInfos)133 ErrCode FormInfoRdbStorageMgr::LoadFormData(std::vector<InnerFormInfo> &innerFormInfos)
134 {
135 HILOG_DEBUG("call");
136 ErrCode result;
137 std::unordered_map<std::string, std::string> value;
138 {
139 std::lock_guard<std::mutex> lock(rdbStorePtrMutex_);
140 result = FormRdbDataMgr::GetInstance().QueryData(Constants::FORM_RDB_TABLE_NAME, FORM_ID_PREFIX, value);
141 }
142 if (result != ERR_OK) {
143 HILOG_ERROR("get entries error");
144 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
145 static_cast<int64_t>(CallDbFiledErrorType::LOAD_DATABASE_FAILED));
146 return ERR_APPEXECFWK_FORM_COMMON_CODE;
147 }
148 SaveEntries(value, innerFormInfos);
149
150 HILOG_DEBUG("end");
151 return ERR_OK;
152 }
153
SaveStorageFormData(const InnerFormInfo & innerFormInfo)154 ErrCode FormInfoRdbStorageMgr::SaveStorageFormData(const InnerFormInfo &innerFormInfo)
155 {
156 HILOG_DEBUG("formId[%{public}" PRId64 "]", innerFormInfo.GetFormId());
157 std::string formId = std::to_string(innerFormInfo.GetFormId());
158 std::string key = std::string().append(FORM_ID_PREFIX).append(formId);
159 std::string value = innerFormInfo.ToString();
160 ErrCode result;
161 {
162 std::lock_guard<std::mutex> lock(rdbStorePtrMutex_);
163 result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, key, value);
164 }
165 if (result != ERR_OK) {
166 HILOG_ERROR("put innerFormInfo to RdbStore error");
167 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
168 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_SAVE_FORMID_FAILED));
169 return ERR_APPEXECFWK_FORM_COMMON_CODE;
170 }
171 return ERR_OK;
172 }
173
ModifyStorageFormData(const InnerFormInfo & innerFormInfo)174 ErrCode FormInfoRdbStorageMgr::ModifyStorageFormData(const InnerFormInfo &innerFormInfo)
175 {
176 HILOG_DEBUG("formId[%{public}" PRId64 "]", innerFormInfo.GetFormId());
177 std::string formId = std::to_string(innerFormInfo.GetFormId());
178 ErrCode ret = DeleteStorageFormData(formId);
179 if (ret == ERR_OK) {
180 SaveStorageFormData(innerFormInfo);
181 }
182
183 return ret;
184 }
185
DeleteStorageFormData(const std::string & formId)186 ErrCode FormInfoRdbStorageMgr::DeleteStorageFormData(const std::string &formId)
187 {
188 HILOG_DEBUG("formId[%{public}s]", formId.c_str());
189 std::string key = std::string().append(FORM_ID_PREFIX).append(formId);
190 ErrCode result;
191 {
192 std::lock_guard<std::mutex> lock(rdbStorePtrMutex_);
193 result = FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, key);
194 }
195
196 if (result != ERR_OK) {
197 HILOG_ERROR("delete key error");
198 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
199 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_DELETE_FORMID_FAILED));
200 return ERR_APPEXECFWK_FORM_COMMON_CODE;
201 }
202
203 key = std::string().append(STATUS_DATA_PREFIX).append(formId);
204 {
205 std::lock_guard<std::mutex> lock(rdbStorePtrMutex_);
206 result = FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, key);
207 }
208 if (result != ERR_OK) {
209 HILOG_ERROR("delete status data of %{public}s failed", formId.c_str());
210 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
211 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_DELETE_FORMID_FAILED));
212 return ERR_APPEXECFWK_FORM_COMMON_CODE;
213 }
214
215 HILOG_DEBUG("delete value to RdbStore success");
216 return ERR_OK;
217 }
218
LoadStatusData(const std::string & formId,std::string & statusData)219 ErrCode FormInfoRdbStorageMgr::LoadStatusData(const std::string &formId, std::string &statusData)
220 {
221 HILOG_DEBUG("formId is %{public}s", formId.c_str());
222 if (formId.empty()) {
223 HILOG_ERROR("empty formId");
224 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
225 }
226
227 ErrCode result;
228 std::string key = std::string().append(STATUS_DATA_PREFIX).append(formId);
229 result = FormRdbDataMgr::GetInstance().QueryData(Constants::FORM_RDB_TABLE_NAME, key, statusData);
230 if (result != ERR_OK) {
231 HILOG_ERROR("load status data of %{public}s failed, code is %{public}d", formId.c_str(), result);
232 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
233 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_QUERY_FORMID_FAILED));
234 return ERR_APPEXECFWK_FORM_COMMON_CODE;
235 }
236
237 return ERR_OK;
238 }
239
UpdateStatusData(const std::string & formId,const std::string & statusData)240 ErrCode FormInfoRdbStorageMgr::UpdateStatusData(const std::string &formId, const std::string &statusData)
241 {
242 HILOG_DEBUG("formId is %{public}s", formId.c_str());
243 if (formId.empty() || statusData.empty()) {
244 HILOG_ERROR("empty formId or statusData");
245 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
246 }
247
248 ErrCode result;
249 std::string key = std::string().append(STATUS_DATA_PREFIX).append(formId);
250 result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, key, statusData);
251 if (result != ERR_OK) {
252 HILOG_ERROR("update status data of %{public}s to rdbstore failed, code is %{public}d", formId.c_str(), result);
253 return ERR_APPEXECFWK_FORM_COMMON_CODE;
254 }
255
256 return ERR_OK;
257 }
258
GetFormVersionCode(std::string & versionCode)259 ErrCode FormInfoRdbStorageMgr::GetFormVersionCode(std::string &versionCode)
260 {
261 HILOG_INFO("call");
262 ErrCode result = FormRdbDataMgr::GetInstance().QueryData(
263 Constants::FORM_RDB_TABLE_NAME, FORM_VERSION_KEY, versionCode);
264 if (result != ERR_OK) {
265 HILOG_ERROR("get form version code failed, code is %{public}d", result);
266 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
267 static_cast<int64_t>(CallDbFiledErrorType::LOAD_DATABASE_FAILED));
268 return ERR_APPEXECFWK_FORM_COMMON_CODE;
269 }
270 HILOG_INFO("get form version code success. versionCode:%{public}s", versionCode.c_str());
271 return ERR_OK;
272 }
273
UpdateFormVersionCode()274 ErrCode FormInfoRdbStorageMgr::UpdateFormVersionCode()
275 {
276 HILOG_INFO("call. versioncode:%{public}d", Constants::FORM_VERSION_CODE);
277 ErrCode result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, FORM_VERSION_KEY,
278 std::to_string(Constants::FORM_VERSION_CODE));
279 if (result != ERR_OK) {
280 HILOG_ERROR("update form version code to rdbstore failed, code is %{public}d", result);
281 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
282 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_SAVE_FORMID_FAILED));
283 return ERR_APPEXECFWK_FORM_COMMON_CODE;
284 }
285 return ERR_OK;
286 }
287 } // namespace AppExecFwk
288 } // namespace OHOS
289