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 "data_center/form_info/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 "common/event/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 constexpr char MULTI_APP_FORM_VERSION_PREFIX[] = "versionCode_multiAppForm_";
35 } // namespace
36
FormInfoRdbStorageMgr()37 FormInfoRdbStorageMgr::FormInfoRdbStorageMgr()
38 {
39 HILOG_DEBUG("FormInfoRdbStorageMgr is created");
40 FormRdbTableConfig formRdbTableConfig;
41 if (FormRdbDataMgr::GetInstance().InitFormRdbTable(formRdbTableConfig) != ERR_OK) {
42 HILOG_ERROR("Form info rdb storage mgr init form rdb table fail");
43 FormEventReport::SendFormFailedEvent(FormEventName::INIT_FMS_FAILED, HiSysEventType::FAULT,
44 static_cast<int64_t>(InitFmsFiledErrorType::LOAD_FORM_DB_FAILED));
45 }
46 }
47
~FormInfoRdbStorageMgr()48 FormInfoRdbStorageMgr::~FormInfoRdbStorageMgr()
49 {
50 HILOG_DEBUG("FormInfoRdbStorageMgr is deleted");
51 }
52
LoadFormInfos(std::vector<std::pair<std::string,std::string>> & formInfoStorages)53 ErrCode FormInfoRdbStorageMgr::LoadFormInfos(std::vector<std::pair<std::string, std::string>> &formInfoStorages)
54 {
55 HILOG_DEBUG("FormInfoAllRdbStorageMgr load all form infos");
56 std::unordered_map<std::string, std::string> value;
57 ErrCode result = FormRdbDataMgr::GetInstance().QueryData(Constants::FORM_RDB_TABLE_NAME, 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 = FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, key);
83 if (result != ERR_OK) {
84 HILOG_ERROR("remove formInfoStorages from rdbStore error");
85 return ERR_APPEXECFWK_FORM_COMMON_CODE;
86 }
87 return ERR_OK;
88 }
89
UpdateBundleFormInfos(const std::string & bundleName,const std::string & formInfoStorages)90 ErrCode FormInfoRdbStorageMgr::UpdateBundleFormInfos(const std::string &bundleName, const std::string &formInfoStorages)
91 {
92 if (bundleName.empty()) {
93 HILOG_ERROR("empty bundleName");
94 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
95 }
96
97 HILOG_DEBUG("FormInfoRdbStorageMgr update form info, bundleName=%{public}s", bundleName.c_str());
98 std::string key = std::string().append(FORM_INFO_PREFIX).append(bundleName);
99 std::string value = formInfoStorages;
100 ErrCode result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, key, value);
101 if (result != ERR_OK) {
102 HILOG_ERROR("update formInfoStorages to rdbStore error");
103 return ERR_APPEXECFWK_FORM_COMMON_CODE;
104 }
105 return ERR_OK;
106 }
107
SaveEntries(const std::unordered_map<std::string,std::string> & value,std::vector<InnerFormInfo> & innerFormInfos)108 void FormInfoRdbStorageMgr::SaveEntries(
109 const std::unordered_map<std::string, std::string> &value, std::vector<InnerFormInfo> &innerFormInfos)
110 {
111 for (const auto &item : value) {
112 InnerFormInfo innerFormInfo;
113 nlohmann::json jsonObject = nlohmann::json::parse(item.second, nullptr, false);
114 if (jsonObject.is_discarded() || innerFormInfo.FromJson(jsonObject) != true) {
115 HILOG_ERROR("error key: %{private}s", item.first.c_str());
116 FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, item.first);
117 continue;
118 }
119
120 if (std::find(innerFormInfos.begin(), innerFormInfos.end(), innerFormInfo) == innerFormInfos.end()) {
121 innerFormInfos.emplace_back(innerFormInfo);
122 }
123 }
124 HILOG_DEBUG("SaveEntries end");
125 }
126
LoadFormData(std::vector<InnerFormInfo> & innerFormInfos)127 ErrCode FormInfoRdbStorageMgr::LoadFormData(std::vector<InnerFormInfo> &innerFormInfos)
128 {
129 HILOG_DEBUG("call");
130 ErrCode result;
131 std::unordered_map<std::string, std::string> value;
132 result = FormRdbDataMgr::GetInstance().QueryData(Constants::FORM_RDB_TABLE_NAME, FORM_ID_PREFIX, value);
133 if (result != ERR_OK) {
134 HILOG_ERROR("get entries error");
135 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
136 static_cast<int64_t>(CallDbFiledErrorType::LOAD_DATABASE_FAILED));
137 return ERR_APPEXECFWK_FORM_COMMON_CODE;
138 }
139 SaveEntries(value, innerFormInfos);
140
141 HILOG_DEBUG("end");
142 return ERR_OK;
143 }
144
SaveStorageFormData(const InnerFormInfo & innerFormInfo)145 ErrCode FormInfoRdbStorageMgr::SaveStorageFormData(const InnerFormInfo &innerFormInfo)
146 {
147 HILOG_DEBUG("formId[%{public}" PRId64 "]", innerFormInfo.GetFormId());
148 std::string formId = std::to_string(innerFormInfo.GetFormId());
149 std::string key = std::string().append(FORM_ID_PREFIX).append(formId);
150 std::string value = innerFormInfo.ToString();
151 ErrCode result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, key, value);
152 if (result != ERR_OK) {
153 HILOG_ERROR("put innerFormInfo to RdbStore error");
154 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
155 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_SAVE_FORMID_FAILED));
156 return ERR_APPEXECFWK_FORM_COMMON_CODE;
157 }
158 return ERR_OK;
159 }
160
ModifyStorageFormData(const InnerFormInfo & innerFormInfo)161 ErrCode FormInfoRdbStorageMgr::ModifyStorageFormData(const InnerFormInfo &innerFormInfo)
162 {
163 HILOG_DEBUG("formId[%{public}" PRId64 "]", innerFormInfo.GetFormId());
164 std::string formId = std::to_string(innerFormInfo.GetFormId());
165 ErrCode ret = DeleteStorageFormData(formId);
166 if (ret == ERR_OK) {
167 SaveStorageFormData(innerFormInfo);
168 }
169
170 return ret;
171 }
172
DeleteStorageFormData(const std::string & formId)173 ErrCode FormInfoRdbStorageMgr::DeleteStorageFormData(const std::string &formId)
174 {
175 HILOG_DEBUG("formId[%{public}s]", formId.c_str());
176 std::string key = std::string().append(FORM_ID_PREFIX).append(formId);
177 ErrCode result = FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, key);
178 if (result != ERR_OK) {
179 HILOG_ERROR("delete key error");
180 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
181 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_DELETE_FORMID_FAILED));
182 return ERR_APPEXECFWK_FORM_COMMON_CODE;
183 }
184
185 key = std::string().append(STATUS_DATA_PREFIX).append(formId);
186 result = FormRdbDataMgr::GetInstance().DeleteData(Constants::FORM_RDB_TABLE_NAME, key);
187 if (result != ERR_OK) {
188 HILOG_ERROR("delete status data of %{public}s failed", formId.c_str());
189 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
190 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_DELETE_FORMID_FAILED));
191 return ERR_APPEXECFWK_FORM_COMMON_CODE;
192 }
193
194 HILOG_DEBUG("delete value to RdbStore success");
195 return ERR_OK;
196 }
197
LoadStatusData(const std::string & formId,std::string & statusData)198 ErrCode FormInfoRdbStorageMgr::LoadStatusData(const std::string &formId, std::string &statusData)
199 {
200 HILOG_DEBUG("formId is %{public}s", formId.c_str());
201 if (formId.empty()) {
202 HILOG_ERROR("empty formId");
203 return ERR_APPEXECFWK_FORM_INVALID_PARAM;
204 }
205
206 ErrCode result;
207 std::string key = std::string().append(STATUS_DATA_PREFIX).append(formId);
208 result = FormRdbDataMgr::GetInstance().QueryData(Constants::FORM_RDB_TABLE_NAME, key, statusData);
209 if (result != ERR_OK) {
210 HILOG_ERROR("load status data of %{public}s failed, code is %{public}d", formId.c_str(), result);
211 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
212 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_QUERY_FORMID_FAILED));
213 return ERR_APPEXECFWK_FORM_COMMON_CODE;
214 }
215
216 return ERR_OK;
217 }
218
UpdateStatusData(const std::string & formId,const std::string & statusData)219 ErrCode FormInfoRdbStorageMgr::UpdateStatusData(const std::string &formId, const std::string &statusData)
220 {
221 HILOG_DEBUG("formId is %{public}s", formId.c_str());
222 if (formId.empty() || statusData.empty()) {
223 HILOG_ERROR("empty formId or statusData");
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().InsertData(Constants::FORM_RDB_TABLE_NAME, key, statusData);
230 if (result != ERR_OK) {
231 HILOG_ERROR("update status data of %{public}s to rdbstore failed, code is %{public}d", formId.c_str(), result);
232 return ERR_APPEXECFWK_FORM_COMMON_CODE;
233 }
234
235 return ERR_OK;
236 }
237
GetFormVersionCode(std::string & versionCode)238 ErrCode FormInfoRdbStorageMgr::GetFormVersionCode(std::string &versionCode)
239 {
240 HILOG_INFO("call");
241 ErrCode result = FormRdbDataMgr::GetInstance().QueryData(
242 Constants::FORM_RDB_TABLE_NAME, FORM_VERSION_KEY, versionCode);
243 if (result != ERR_OK) {
244 HILOG_ERROR("get form version code failed, code is %{public}d", result);
245 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
246 static_cast<int64_t>(CallDbFiledErrorType::LOAD_DATABASE_FAILED));
247 return ERR_APPEXECFWK_FORM_COMMON_CODE;
248 }
249 HILOG_INFO("get form version code success. versionCode:%{public}s", versionCode.c_str());
250 return ERR_OK;
251 }
252
UpdateFormVersionCode()253 ErrCode FormInfoRdbStorageMgr::UpdateFormVersionCode()
254 {
255 HILOG_INFO("call. versioncode:%{public}d", Constants::FORM_VERSION_CODE);
256 ErrCode result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, FORM_VERSION_KEY,
257 std::to_string(Constants::FORM_VERSION_CODE));
258 if (result != ERR_OK) {
259 HILOG_ERROR("update form version code to rdbstore failed, code is %{public}d", result);
260 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
261 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_SAVE_FORMID_FAILED));
262 return ERR_APPEXECFWK_FORM_COMMON_CODE;
263 }
264 return ERR_OK;
265 }
266
GetMultiAppFormVersionCode(const std::string & bundleName,std::string & versionCode)267 ErrCode FormInfoRdbStorageMgr::GetMultiAppFormVersionCode(const std::string &bundleName, std::string &versionCode)
268 {
269 HILOG_INFO("call");
270 std::string key = MULTI_APP_FORM_VERSION_PREFIX + bundleName;
271 ErrCode result = FormRdbDataMgr::GetInstance().QueryData(Constants::FORM_RDB_TABLE_NAME, key, versionCode);
272 if (result != ERR_OK) {
273 HILOG_ERROR("get multi app form version code failed, code is %{public}d", result);
274 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
275 static_cast<int64_t>(CallDbFiledErrorType::LOAD_DATABASE_FAILED));
276 return ERR_APPEXECFWK_FORM_COMMON_CODE;
277 }
278 HILOG_INFO("get multi app form version code success.");
279 return ERR_OK;
280 }
281
UpdateMultiAppFormVersionCode(const std::string & bundleName,const std::string & versionCode)282 ErrCode FormInfoRdbStorageMgr::UpdateMultiAppFormVersionCode(const std::string &bundleName,
283 const std::string &versionCode)
284 {
285 HILOG_INFO("call. bundleName: %{public}s", bundleName.c_str());
286 std::string key = MULTI_APP_FORM_VERSION_PREFIX + bundleName;
287 ErrCode result = FormRdbDataMgr::GetInstance().InsertData(Constants::FORM_RDB_TABLE_NAME, key, versionCode);
288 if (result != ERR_OK) {
289 HILOG_ERROR("update multi app form version code to rdbstore failed, code is %{public}d", result);
290 FormEventReport::SendFormFailedEvent(FormEventName::CALLEN_DB_FAILED, HiSysEventType::FAULT,
291 static_cast<int64_t>(CallDbFiledErrorType::DATABASE_SAVE_FORMID_FAILED));
292 return ERR_APPEXECFWK_FORM_COMMON_CODE;
293 }
294 return ERR_OK;
295 }
296 } // namespace AppExecFwk
297 } // namespace OHOS
298