1 /*
2 * Copyright (C) 2021 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 "sms_mms_ability.h"
17
18 #include "ability_context.h"
19 #include "ability_loader.h"
20 #include "abs_rdb_predicates.h"
21 #include "abs_shared_result_set.h"
22 #include "data_ability_predicates.h"
23 #include "data_storage_errors.h"
24 #include "data_storage_log_wrapper.h"
25 #include "new"
26 #include "predicates_utils.h"
27 #include "rdb_errno.h"
28 #include "sms_mms_data.h"
29 #include "uri.h"
30 #include "utility"
31
32 namespace OHOS {
33 using AppExecFwk::Ability;
34 using AppExecFwk::AbilityLoader;
35 namespace Telephony {
OnStart(const AppExecFwk::Want & want)36 void SmsMmsAbility::OnStart(const AppExecFwk::Want &want)
37 {
38 DATA_STORAGE_LOGI("SmsMmsAbility::OnStart\n");
39 Ability::OnStart(want);
40 auto abilityContext = GetAbilityContext();
41 if (abilityContext == nullptr) {
42 DATA_STORAGE_LOGE("SmsMmsAbility::OnStart GetAbilityContext is null");
43 return;
44 }
45 // switch database dir to el1 for init before unlock
46 abilityContext->SwitchArea(0);
47 std::string path = abilityContext->GetDatabaseDir();
48 DATA_STORAGE_LOGI("GetDatabaseDir: %{public}s", path.c_str());
49 if (!path.empty()) {
50 initDatabaseDir = true;
51 path.append("/");
52 InitUriMap();
53 helper_.UpdateDbPath(path);
54 if (helper_.Init() == NativeRdb::E_OK) {
55 initRdbStore = true;
56 } else {
57 DATA_STORAGE_LOGE("SmsMmsAbility::OnStart rdb init fail!");
58 initRdbStore = false;
59 }
60 } else {
61 initDatabaseDir = false;
62 DATA_STORAGE_LOGE("SmsMmsAbility::OnStart##the databaseDir is empty\n");
63 }
64 }
65
Insert(const Uri & uri,const NativeRdb::ValuesBucket & value)66 int SmsMmsAbility::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
67 {
68 if (!IsInitOk()) {
69 return DATA_STORAGE_ERROR;
70 }
71 std::lock_guard<std::mutex> guard(lock_);
72 Uri tempUri = uri;
73 MessageUriType messageUriType = ParseUriType(tempUri);
74 int64_t id = DATA_STORAGE_ERROR;
75 switch (messageUriType) {
76 case MessageUriType::SMS_MMS: {
77 helper_.Insert(id, value, TABLE_SMS_MMS_INFO);
78 break;
79 }
80 case MessageUriType::MMS_PROTOCOL: {
81 helper_.Insert(id, value, TABLE_MMS_PROTOCOL);
82 break;
83 }
84 case MessageUriType::SMS_SUBSECTION: {
85 helper_.Insert(id, value, TABLE_SMS_SUBSECTION);
86 break;
87 }
88 case MessageUriType::MMS_PART: {
89 helper_.Insert(id, value, TABLE_MMS_PART);
90 break;
91 }
92 default:
93 DATA_STORAGE_LOGI("SmsMmsAbility::Insert##uri = %{public}s\n", uri.ToString().c_str());
94 break;
95 }
96 return id;
97 }
98
Query(const Uri & uri,const std::vector<std::string> & columns,const NativeRdb::DataAbilityPredicates & predicates)99 std::shared_ptr<NativeRdb::AbsSharedResultSet> SmsMmsAbility::Query(
100 const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
101 {
102 std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet = nullptr;
103 if (!IsInitOk()) {
104 return resultSet;
105 }
106 Uri tempUri = uri;
107 MessageUriType messageUriType = ParseUriType(tempUri);
108 NativeRdb::AbsRdbPredicates *absRdbPredicates = nullptr;
109 switch (messageUriType) {
110 case MessageUriType::SMS_MMS: {
111 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_MMS_INFO);
112 break;
113 }
114 case MessageUriType::MMS_PROTOCOL: {
115 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PROTOCOL);
116 break;
117 }
118 case MessageUriType::SMS_SUBSECTION: {
119 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_SUBSECTION);
120 break;
121 }
122 case MessageUriType::MMS_PART: {
123 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PART);
124 break;
125 }
126 case MessageUriType::MAX_GROUP: {
127 resultSet = helper_.QueryMaxGroupId();
128 break;
129 }
130 case MessageUriType::UNREAD_TOTAL: {
131 resultSet = helper_.StatisticsUnRead();
132 break;
133 }
134 default:
135 DATA_STORAGE_LOGI("SmsMmsAbility::Query##uri = %{public}s\n", uri.ToString().c_str());
136 break;
137 }
138 if (absRdbPredicates != nullptr) {
139 ConvertPredicates(predicates, absRdbPredicates);
140 resultSet = helper_.Query(*absRdbPredicates, columns);
141 delete absRdbPredicates;
142 absRdbPredicates = nullptr;
143 } else {
144 DATA_STORAGE_LOGE("SmsMmsAbility::Query NativeRdb::AbsRdbPredicates is null!");
145 }
146 return resultSet;
147 }
148
Update(const Uri & uri,const NativeRdb::ValuesBucket & value,const NativeRdb::DataAbilityPredicates & predicates)149 int SmsMmsAbility::Update(
150 const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
151 {
152 int result = DATA_STORAGE_ERROR;
153 if (!IsInitOk()) {
154 return result;
155 }
156 std::lock_guard<std::mutex> guard(lock_);
157 Uri tempUri = uri;
158 MessageUriType messageUriType = ParseUriType(tempUri);
159 NativeRdb::AbsRdbPredicates *absRdbPredicates = nullptr;
160 switch (messageUriType) {
161 case MessageUriType::SMS_MMS: {
162 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_MMS_INFO);
163 break;
164 }
165 case MessageUriType::MMS_PROTOCOL: {
166 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PROTOCOL);
167 break;
168 }
169 case MessageUriType::SMS_SUBSECTION: {
170 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_SUBSECTION);
171 break;
172 }
173 case MessageUriType::MMS_PART: {
174 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PART);
175 break;
176 }
177 default:
178 DATA_STORAGE_LOGI("SmsMmsAbility::Update##uri = %{public}s\n", uri.ToString().c_str());
179 break;
180 }
181 if (absRdbPredicates != nullptr) {
182 int changedRows = 0;
183 ConvertPredicates(predicates, absRdbPredicates);
184 result = helper_.Update(changedRows, value, *absRdbPredicates);
185 delete absRdbPredicates;
186 absRdbPredicates = nullptr;
187 } else {
188 DATA_STORAGE_LOGE("SmsMmsAbility::Update NativeRdb::AbsRdbPredicates is null!");
189 }
190 return result;
191 }
192
Delete(const Uri & uri,const NativeRdb::DataAbilityPredicates & predicates)193 int SmsMmsAbility::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
194 {
195 int result = DATA_STORAGE_ERROR;
196 if (!IsInitOk()) {
197 return result;
198 }
199 std::lock_guard<std::mutex> guard(lock_);
200 Uri tempUri = uri;
201 MessageUriType messageUriType = ParseUriType(tempUri);
202 NativeRdb::AbsRdbPredicates *absRdbPredicates = nullptr;
203 switch (messageUriType) {
204 case MessageUriType::SMS_MMS: {
205 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_MMS_INFO);
206 break;
207 }
208 case MessageUriType::THIRTY: {
209 result = helper_.DeleteDataByThirty();
210 if (result != NativeRdb::E_OK) {
211 DATA_STORAGE_LOGE("SmsMmsAbility::Delete DeleteDataByThirty fail!");
212 result = static_cast<int>(LoadProFileErrorType::DELETE_THIRTY_DATA_FAIL);
213 }
214 break;
215 }
216 case MessageUriType::MMS_PROTOCOL: {
217 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PROTOCOL);
218 break;
219 }
220 case MessageUriType::SMS_SUBSECTION: {
221 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_SUBSECTION);
222 break;
223 }
224 case MessageUriType::MMS_PART: {
225 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PART);
226 break;
227 }
228 default:
229 DATA_STORAGE_LOGI("SmsMmsAbility::Delete##uri = %{public}s\n", uri.ToString().c_str());
230 break;
231 }
232 if (absRdbPredicates != nullptr) {
233 ConvertPredicates(predicates, absRdbPredicates);
234 int deletedRows = 0;
235 result = helper_.Delete(deletedRows, *absRdbPredicates);
236 delete absRdbPredicates;
237 absRdbPredicates = nullptr;
238 } else if (result == DATA_STORAGE_ERROR) {
239 DATA_STORAGE_LOGE("SmsMmsAbility::Delete NativeRdb::AbsRdbPredicates is null!");
240 }
241 return result;
242 }
243
IsInitOk()244 bool SmsMmsAbility::IsInitOk()
245 {
246 if (!initDatabaseDir) {
247 DATA_STORAGE_LOGE("SmsMmsAbility::IsInitOk initDatabaseDir failed!");
248 } else if (!initRdbStore) {
249 DATA_STORAGE_LOGE("SmsMmsAbility::IsInitOk initRdbStore failed!");
250 }
251 return initDatabaseDir && initRdbStore;
252 }
253
InitUriMap()254 void SmsMmsAbility::InitUriMap()
255 {
256 smsMmsUriMap = {
257 {"/sms_mms/sms_mms_info", MessageUriType::SMS_MMS},
258 {"/sms_mms/sms_mms_info/thirty", MessageUriType::THIRTY},
259 {"/sms_mms/sms_mms_info/max_group", MessageUriType::MAX_GROUP},
260 {"/sms_mms/sms_mms_info/unread_total", MessageUriType::UNREAD_TOTAL},
261 {"/sms_mms/mms_protocol", MessageUriType::MMS_PROTOCOL},
262 {"/sms_mms/sms_subsection", MessageUriType::SMS_SUBSECTION},
263 {"/sms_mms/mms_part", MessageUriType::MMS_PART}
264 };
265 }
266
GetType(const Uri & uri)267 std::string SmsMmsAbility::GetType(const Uri &uri)
268 {
269 DATA_STORAGE_LOGI("SmsMmsAbility::GetType##uri = %{public}s\n", uri.ToString().c_str());
270 std::string retval(uri.ToString());
271 return retval;
272 }
273
OpenFile(const Uri & uri,const std::string & mode)274 int SmsMmsAbility::OpenFile(const Uri &uri, const std::string &mode)
275 {
276 DATA_STORAGE_LOGI("SmsMmsAbility::OpenFile##uri = %{public}s\n", uri.ToString().c_str());
277 Uri tempUri = uri;
278 MessageUriType messageUriType = ParseUriType(tempUri);
279 return static_cast<int>(messageUriType);
280 }
281
BatchInsert(const Uri & uri,const std::vector<NativeRdb::ValuesBucket> & values)282 int SmsMmsAbility::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
283 {
284 int result = DATA_STORAGE_ERROR;
285 if (!IsInitOk()) {
286 return result;
287 }
288 std::lock_guard<std::mutex> guard(lock_);
289 Uri tempUri = uri;
290 MessageUriType messageUriType = ParseUriType(tempUri);
291 int64_t id = DATA_STORAGE_ERROR;
292 if (messageUriType == MessageUriType::SMS_MMS) {
293 result = helper_.BatchInsertSmsMmsInfo(id, values);
294 } else {
295 DATA_STORAGE_LOGI("SmsMmsAbility::BatchInsert##uri = %{public}s\n", uri.ToString().c_str());
296 }
297 return result;
298 }
299
ParseUriType(Uri & uri)300 MessageUriType SmsMmsAbility::ParseUriType(Uri &uri)
301 {
302 DATA_STORAGE_LOGI("SmsMmsAbility::ParseUriType start\n");
303 MessageUriType messageUriType = MessageUriType::UNKNOW;
304 std::string uriPath = uri.ToString();
305 if (!uriPath.empty()) {
306 helper_.ReplaceAllStr(uriPath, ":///", "://");
307 Uri tempUri(uriPath);
308 std::string path = tempUri.GetPath();
309 if (!path.empty()) {
310 DATA_STORAGE_LOGI("SmsMmsAbility::ParseUriType##path = %{public}s\n", path.c_str());
311 std::map<std::string, MessageUriType>::iterator it = smsMmsUriMap.find(path);
312 if (it != smsMmsUriMap.end()) {
313 messageUriType = it->second;
314 DATA_STORAGE_LOGI("SmsMmsAbility::ParseUriType##messageUriType = %{public}d\n", messageUriType);
315 }
316 }
317 }
318 return messageUriType;
319 }
320
ConvertPredicates(const NativeRdb::DataAbilityPredicates & dataPredicates,NativeRdb::AbsRdbPredicates * absRdbPredicates)321 void SmsMmsAbility::ConvertPredicates(
322 const NativeRdb::DataAbilityPredicates &dataPredicates, NativeRdb::AbsRdbPredicates *absRdbPredicates)
323 {
324 NativeRdb::PredicatesUtils::SetWhereClauseAndArgs(
325 absRdbPredicates, dataPredicates.GetWhereClause(), dataPredicates.GetWhereArgs());
326 NativeRdb::PredicatesUtils::SetAttributes(absRdbPredicates, dataPredicates.IsDistinct(),
327 dataPredicates.GetIndex(), dataPredicates.GetGroup(), dataPredicates.GetOrder(), dataPredicates.GetLimit(),
328 dataPredicates.GetOffset());
329 }
330
331 REGISTER_AA(SmsMmsAbility);
332 } // namespace Telephony
333 } // namespace OHOS
334