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 "default_app_rdb.h"
17
18 #include "app_log_wrapper.h"
19 #include "bundle_data_mgr.h"
20 #include "bundle_mgr_service.h"
21 #include "bundle_parser.h"
22
23 namespace OHOS {
24 namespace AppExecFwk {
25 namespace {
26 constexpr int32_t INITIAL_USER_ID = -1;
27 const std::string DEFAULT_APP_JSON_PATH = "/etc/app/default_app.json";
28 const std::string BACK_UP_DEFAULT_APP_JSON_PATH = "/etc/app/backup_default_app.json";
29 }
DefaultAppRdb()30 DefaultAppRdb::DefaultAppRdb()
31 {
32 APP_LOGD("create DefaultAppRdb.");
33 BmsRdbConfig bmsRdbConfig;
34 bmsRdbConfig.dbName = Constants::BUNDLE_RDB_NAME;
35 bmsRdbConfig.tableName = Constants::DEFAULT_APP_RDB_TABLE_NAME;
36 rdbDataManager_ = std::make_shared<RdbDataManager>(bmsRdbConfig);
37 rdbDataManager_->CreateTable();
38 LoadDefaultApplicationConfig();
39 LoadBackUpDefaultApplicationConfig();
40 }
41
~DefaultAppRdb()42 DefaultAppRdb::~DefaultAppRdb()
43 {
44 APP_LOGD("destroy DefaultAppRdb.");
45 }
46
GetDefaultApplicationInfos(int32_t userId,std::map<std::string,Element> & infos)47 bool DefaultAppRdb::GetDefaultApplicationInfos(int32_t userId, std::map<std::string, Element>& infos)
48 {
49 APP_LOGD("begin to GetDefaultApplicationInfos, userId : %{public}d.", userId);
50 bool ret = GetDataFromDb(userId, infos);
51 if (!ret) {
52 APP_LOGE("GetDataFromDb failed.");
53 return false;
54 }
55
56 APP_LOGD("GetDefaultApplicationInfos success.");
57 return true;
58 }
59
GetDefaultApplicationInfo(int32_t userId,const std::string & type,Element & element)60 bool DefaultAppRdb::GetDefaultApplicationInfo(int32_t userId, const std::string& type, Element& element)
61 {
62 APP_LOGD("begin to GetDefaultApplicationInfo, userId : %{public}d, type : %{public}s.",
63 userId, type.c_str());
64 std::map<std::string, Element> infos;
65 bool ret = GetDefaultApplicationInfos(userId, infos);
66 if (!ret) {
67 APP_LOGE("GetDefaultApplicationInfos failed.");
68 return false;
69 }
70
71 if (infos.find(type) == infos.end()) {
72 APP_LOGD("type is not saved in db.");
73 return false;
74 }
75
76 element = infos.find(type)->second;
77 APP_LOGD("GetDefaultApplicationInfo success.");
78 return true;
79 }
80
SetDefaultApplicationInfos(int32_t userId,const std::map<std::string,Element> & infos)81 bool DefaultAppRdb::SetDefaultApplicationInfos(int32_t userId, const std::map<std::string, Element>& infos)
82 {
83 APP_LOGD("begin to SetDefaultApplicationInfos, userId : %{public}d.", userId);
84 bool ret = SaveDataToDb(userId, infos);
85 if (!ret) {
86 APP_LOGE("SaveDataToDb failed.");
87 return false;
88 }
89
90 APP_LOGD("SetDefaultApplicationInfos success.");
91 return true;
92 }
93
SetDefaultApplicationInfo(int32_t userId,const std::string & type,const Element & element)94 bool DefaultAppRdb::SetDefaultApplicationInfo(int32_t userId, const std::string& type, const Element& element)
95 {
96 APP_LOGD("begin to SetDefaultApplicationInfo, userId : %{public}d, type : %{public}s.", userId, type.c_str());
97 std::map<std::string, Element> infos;
98 GetDefaultApplicationInfos(userId, infos);
99 if (infos.find(type) == infos.end()) {
100 APP_LOGD("add default app info.");
101 infos.emplace(type, element);
102 } else {
103 APP_LOGD("modify default app info.");
104 infos[type] = element;
105 }
106
107 bool ret = SaveDataToDb(userId, infos);
108 if (!ret) {
109 APP_LOGE("SaveDataToDb failed.");
110 return false;
111 }
112
113 APP_LOGD("SetDefaultApplicationInfo success.");
114 return true;
115 }
116
DeleteDefaultApplicationInfos(int32_t userId)117 bool DefaultAppRdb::DeleteDefaultApplicationInfos(int32_t userId)
118 {
119 APP_LOGD("begin to DeleteDefaultApplicationInfos, userId : %{public}d.", userId);
120 bool ret = DeleteDataFromDb(userId);
121 if (!ret) {
122 APP_LOGE("DeleteDataFromDb failed.");
123 return false;
124 }
125
126 APP_LOGD("DeleteDefaultApplicationInfos success.");
127 return true;
128 }
129
DeleteDefaultApplicationInfo(int32_t userId,const std::string & type)130 bool DefaultAppRdb::DeleteDefaultApplicationInfo(int32_t userId, const std::string& type)
131 {
132 APP_LOGD("begin to DeleteDefaultApplicationInfo, userId : %{public}d, type : %{public}s.", userId, type.c_str());
133 std::map<std::string, Element> infos;
134 bool ret = GetDataFromDb(userId, infos);
135 if (!ret) {
136 APP_LOGE("GetDataFromDb failed.");
137 return true;
138 }
139
140 if (infos.find(type) == infos.end()) {
141 APP_LOGD("type doesn't exists in db.");
142 return true;
143 }
144
145 infos.erase(type);
146 ret = SaveDataToDb(userId, infos);
147 if (!ret) {
148 APP_LOGE("SaveDataToDb failed.");
149 return false;
150 }
151
152 APP_LOGD("DeleteDefaultApplicationInfo success.");
153 return true;
154 }
155
ParseConfig(const std::string & relativePath,DefaultAppData & defaultAppData)156 bool DefaultAppRdb::ParseConfig(const std::string& relativePath, DefaultAppData& defaultAppData)
157 {
158 // load default app config from json file
159 std::vector<std::string> rootDirs;
160 BMSEventHandler::GetPreInstallRootDirList(rootDirs);
161 if (rootDirs.empty()) {
162 APP_LOGW("rootDirs empty");
163 return false;
164 }
165 std::for_each(rootDirs.cbegin(), rootDirs.cend(), [&relativePath, &defaultAppData](const auto& rootDir) {
166 std::string path = rootDir + relativePath;
167 APP_LOGD("default app json path : %{public}s", path.c_str());
168 nlohmann::json jsonObject;
169 if (!BundleParser::ReadFileIntoJson(path, jsonObject)) {
170 APP_LOGW("read default app json failed");
171 return;
172 }
173 defaultAppData.ParseDefaultApplicationConfig(jsonObject);
174 });
175 return !defaultAppData.infos.empty();
176 }
177
LoadDefaultApplicationConfig()178 void DefaultAppRdb::LoadDefaultApplicationConfig()
179 {
180 APP_LOGD("begin to LoadDefaultApplicationConfig.");
181 DefaultAppData defaultAppData;
182 if (!ParseConfig(DEFAULT_APP_JSON_PATH, defaultAppData)) {
183 APP_LOGD("default app config empty");
184 return;
185 }
186 // get pre default app config
187 std::map<std::string, Element> preInfos;
188 GetDefaultApplicationInfos(INITIAL_USER_ID, preInfos);
189 // save to each user
190 std::shared_ptr<BundleDataMgr> dataMgr = DelayedSingleton<BundleMgrService>::GetInstance()->GetDataMgr();
191 if (dataMgr == nullptr) {
192 APP_LOGW("get BundleDataMgr failed.");
193 return;
194 }
195
196 std::set<int32_t> allUsers = dataMgr->GetAllUser();
197 for (int32_t userId : allUsers) {
198 std::map<std::string, Element> infos;
199 GetDefaultApplicationInfos(userId, infos);
200 for (const auto& item : defaultAppData.infos) {
201 const std::string& type = item.first;
202 const Element& element = item.second;
203 if (infos.find(type) != infos.end() && preInfos.find(type) != preInfos.end()
204 && infos.find(type)->second == preInfos.find(type)->second) {
205 infos[type] = element;
206 } else {
207 infos.try_emplace(type, element);
208 }
209 }
210
211 SetDefaultApplicationInfos(userId, infos);
212 }
213
214 // save default app config to db
215 SetDefaultApplicationInfos(INITIAL_USER_ID, defaultAppData.infos);
216 APP_LOGD("LoadDefaultApplicationConfig done.");
217 }
218
LoadBackUpDefaultApplicationConfig()219 void DefaultAppRdb::LoadBackUpDefaultApplicationConfig()
220 {
221 APP_LOGD("begin");
222 DefaultAppData defaultAppData;
223 if (!ParseConfig(BACK_UP_DEFAULT_APP_JSON_PATH, defaultAppData)) {
224 APP_LOGD("backup default app config empty");
225 return;
226 }
227 // save default app config to db
228 SetDefaultApplicationInfos(Constants::BACKUP_DEFAULT_APP_KEY, defaultAppData.infos);
229 APP_LOGD("end");
230 }
231
GetDataFromDb(int32_t userId,std::map<std::string,Element> & infos)232 bool DefaultAppRdb::GetDataFromDb(int32_t userId, std::map<std::string, Element>& infos)
233 {
234 if (rdbDataManager_ == nullptr) {
235 APP_LOGE("rdbDataManager is null");
236 return false;
237 }
238
239 std::string key = std::to_string(userId);
240 std::string value;
241 bool result = rdbDataManager_->QueryData(key, value);
242 if (!result) {
243 APP_LOGE("QueryData failed by key %{public}d", userId);
244 return false;
245 }
246
247 DefaultAppData defaultAppData;
248 nlohmann::json jsonObject = nlohmann::json::parse(value, nullptr, false);
249 if (jsonObject.is_discarded() || defaultAppData.FromJson(jsonObject) != ERR_OK) {
250 APP_LOGE("error key : %{public}s", key.c_str());
251 rdbDataManager_->DeleteData(key);
252 return false;
253 }
254
255 infos = defaultAppData.infos;
256 return true;
257 }
258
SaveDataToDb(int32_t userId,const std::map<std::string,Element> & infos)259 bool DefaultAppRdb::SaveDataToDb(int32_t userId, const std::map<std::string, Element>& infos)
260 {
261 if (rdbDataManager_ == nullptr) {
262 APP_LOGE("rdbDataManager is null");
263 return false;
264 }
265
266 DefaultAppData defaultAppData;
267 defaultAppData.infos = infos;
268 return rdbDataManager_->InsertData(std::to_string(userId), defaultAppData.ToString());
269 }
270
DeleteDataFromDb(int32_t userId)271 bool DefaultAppRdb::DeleteDataFromDb(int32_t userId)
272 {
273 if (rdbDataManager_ == nullptr) {
274 APP_LOGE("rdbDataManager is null");
275 return false;
276 }
277
278 return rdbDataManager_->DeleteData(std::to_string(userId));
279 }
280
RegisterDeathListener()281 void DefaultAppRdb::RegisterDeathListener()
282 {
283 APP_LOGD("RegisterDeathListener.");
284 }
285
UnRegisterDeathListener()286 void DefaultAppRdb::UnRegisterDeathListener()
287 {
288 APP_LOGD("UnRegisterDeathListener.");
289 }
290 }
291 }
292