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 (!TelephonyPermission::CheckPermission(Permission::READ_MESSAGES)) {
69 DATA_STORAGE_LOGE("Permission denied!");
70 return DATA_STORAGE_ERR_PERMISSION_ERR;
71 }
72 if (!IsInitOk()) {
73 return DATA_STORAGE_ERROR;
74 }
75 std::lock_guard<std::mutex> guard(lock_);
76 Uri tempUri = uri;
77 MessageUriType messageUriType = ParseUriType(tempUri);
78 int64_t id = DATA_STORAGE_ERROR;
79 switch (messageUriType) {
80 case MessageUriType::SMS_MMS: {
81 helper_.Insert(id, value, TABLE_SMS_MMS_INFO);
82 break;
83 }
84 case MessageUriType::MMS_PROTOCOL: {
85 helper_.Insert(id, value, TABLE_MMS_PROTOCOL);
86 break;
87 }
88 case MessageUriType::SMS_SUBSECTION: {
89 helper_.Insert(id, value, TABLE_SMS_SUBSECTION);
90 break;
91 }
92 case MessageUriType::MMS_PART: {
93 helper_.Insert(id, value, TABLE_MMS_PART);
94 break;
95 }
96 default:
97 DATA_STORAGE_LOGI("SmsMmsAbility::Insert##uri = %{public}s\n", uri.ToString().c_str());
98 break;
99 }
100 return id;
101 }
102
Query(const Uri & uri,const std::vector<std::string> & columns,const NativeRdb::DataAbilityPredicates & predicates)103 std::shared_ptr<NativeRdb::AbsSharedResultSet> SmsMmsAbility::Query(
104 const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
105 {
106 if (!TelephonyPermission::CheckPermission(Permission::READ_MESSAGES)) {
107 DATA_STORAGE_LOGE("Permission denied!");
108 return nullptr;
109 }
110 std::shared_ptr<NativeRdb::AbsSharedResultSet> resultSet = nullptr;
111 if (!IsInitOk()) {
112 return resultSet;
113 }
114 Uri tempUri = uri;
115 MessageUriType messageUriType = ParseUriType(tempUri);
116 NativeRdb::AbsRdbPredicates *absRdbPredicates = nullptr;
117 switch (messageUriType) {
118 case MessageUriType::SMS_MMS: {
119 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_MMS_INFO);
120 break;
121 }
122 case MessageUriType::MMS_PROTOCOL: {
123 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PROTOCOL);
124 break;
125 }
126 case MessageUriType::SMS_SUBSECTION: {
127 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_SUBSECTION);
128 break;
129 }
130 case MessageUriType::MMS_PART: {
131 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PART);
132 break;
133 }
134 case MessageUriType::MAX_GROUP: {
135 resultSet = helper_.QueryMaxGroupId();
136 break;
137 }
138 case MessageUriType::UNREAD_TOTAL: {
139 resultSet = helper_.StatisticsUnRead();
140 break;
141 }
142 default:
143 DATA_STORAGE_LOGI("SmsMmsAbility::Query##uri = %{public}s\n", uri.ToString().c_str());
144 break;
145 }
146 if (absRdbPredicates != nullptr) {
147 ConvertPredicates(predicates, absRdbPredicates);
148 resultSet = helper_.Query(*absRdbPredicates, columns);
149 delete absRdbPredicates;
150 absRdbPredicates = nullptr;
151 } else {
152 DATA_STORAGE_LOGE("SmsMmsAbility::Query NativeRdb::AbsRdbPredicates is null!");
153 }
154 return resultSet;
155 }
156
Update(const Uri & uri,const NativeRdb::ValuesBucket & value,const NativeRdb::DataAbilityPredicates & predicates)157 int SmsMmsAbility::Update(
158 const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
159 {
160 if (!TelephonyPermission::CheckPermission(Permission::READ_MESSAGES)) {
161 DATA_STORAGE_LOGE("Permission denied!");
162 return DATA_STORAGE_ERR_PERMISSION_ERR;
163 }
164 int result = DATA_STORAGE_ERROR;
165 if (!IsInitOk()) {
166 return result;
167 }
168 std::lock_guard<std::mutex> guard(lock_);
169 Uri tempUri = uri;
170 MessageUriType messageUriType = ParseUriType(tempUri);
171 NativeRdb::AbsRdbPredicates *absRdbPredicates = nullptr;
172 switch (messageUriType) {
173 case MessageUriType::SMS_MMS: {
174 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_MMS_INFO);
175 break;
176 }
177 case MessageUriType::MMS_PROTOCOL: {
178 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PROTOCOL);
179 break;
180 }
181 case MessageUriType::SMS_SUBSECTION: {
182 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_SUBSECTION);
183 break;
184 }
185 case MessageUriType::MMS_PART: {
186 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PART);
187 break;
188 }
189 default:
190 DATA_STORAGE_LOGI("SmsMmsAbility::Update##uri = %{public}s\n", uri.ToString().c_str());
191 break;
192 }
193 if (absRdbPredicates != nullptr) {
194 int changedRows = 0;
195 ConvertPredicates(predicates, absRdbPredicates);
196 result = helper_.Update(changedRows, value, *absRdbPredicates);
197 delete absRdbPredicates;
198 absRdbPredicates = nullptr;
199 } else {
200 DATA_STORAGE_LOGE("SmsMmsAbility::Update NativeRdb::AbsRdbPredicates is null!");
201 }
202 return result;
203 }
204
Delete(const Uri & uri,const NativeRdb::DataAbilityPredicates & predicates)205 int SmsMmsAbility::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
206 {
207 if (!TelephonyPermission::CheckPermission(Permission::READ_MESSAGES)) {
208 DATA_STORAGE_LOGE("Permission denied!");
209 return DATA_STORAGE_ERR_PERMISSION_ERR;
210 }
211 int result = DATA_STORAGE_ERROR;
212 if (!IsInitOk()) {
213 return result;
214 }
215 std::lock_guard<std::mutex> guard(lock_);
216 Uri tempUri = uri;
217 MessageUriType messageUriType = ParseUriType(tempUri);
218 NativeRdb::AbsRdbPredicates *absRdbPredicates = nullptr;
219 switch (messageUriType) {
220 case MessageUriType::SMS_MMS: {
221 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_MMS_INFO);
222 break;
223 }
224 case MessageUriType::THIRTY: {
225 result = helper_.DeleteDataByThirty();
226 if (result != NativeRdb::E_OK) {
227 DATA_STORAGE_LOGE("SmsMmsAbility::Delete DeleteDataByThirty fail!");
228 result = static_cast<int>(LoadProFileErrorType::DELETE_THIRTY_DATA_FAIL);
229 }
230 break;
231 }
232 case MessageUriType::MMS_PROTOCOL: {
233 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PROTOCOL);
234 break;
235 }
236 case MessageUriType::SMS_SUBSECTION: {
237 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_SMS_SUBSECTION);
238 break;
239 }
240 case MessageUriType::MMS_PART: {
241 absRdbPredicates = new NativeRdb::AbsRdbPredicates(TABLE_MMS_PART);
242 break;
243 }
244 default:
245 DATA_STORAGE_LOGI("SmsMmsAbility::Delete##uri = %{public}s\n", uri.ToString().c_str());
246 break;
247 }
248 if (absRdbPredicates != nullptr) {
249 ConvertPredicates(predicates, absRdbPredicates);
250 int deletedRows = 0;
251 result = helper_.Delete(deletedRows, *absRdbPredicates);
252 delete absRdbPredicates;
253 absRdbPredicates = nullptr;
254 } else if (result == DATA_STORAGE_ERROR) {
255 DATA_STORAGE_LOGE("SmsMmsAbility::Delete NativeRdb::AbsRdbPredicates is null!");
256 }
257 return result;
258 }
259
IsInitOk()260 bool SmsMmsAbility::IsInitOk()
261 {
262 if (!initDatabaseDir) {
263 DATA_STORAGE_LOGE("SmsMmsAbility::IsInitOk initDatabaseDir failed!");
264 } else if (!initRdbStore) {
265 DATA_STORAGE_LOGE("SmsMmsAbility::IsInitOk initRdbStore failed!");
266 }
267 return initDatabaseDir && initRdbStore;
268 }
269
InitUriMap()270 void SmsMmsAbility::InitUriMap()
271 {
272 smsMmsUriMap = {
273 {"/sms_mms/sms_mms_info", MessageUriType::SMS_MMS},
274 {"/sms_mms/sms_mms_info/thirty", MessageUriType::THIRTY},
275 {"/sms_mms/sms_mms_info/max_group", MessageUriType::MAX_GROUP},
276 {"/sms_mms/sms_mms_info/unread_total", MessageUriType::UNREAD_TOTAL},
277 {"/sms_mms/mms_protocol", MessageUriType::MMS_PROTOCOL},
278 {"/sms_mms/sms_subsection", MessageUriType::SMS_SUBSECTION},
279 {"/sms_mms/mms_part", MessageUriType::MMS_PART}
280 };
281 }
282
GetType(const Uri & uri)283 std::string SmsMmsAbility::GetType(const Uri &uri)
284 {
285 DATA_STORAGE_LOGI("SmsMmsAbility::GetType##uri = %{public}s\n", uri.ToString().c_str());
286 std::string retval(uri.ToString());
287 return retval;
288 }
289
OpenFile(const Uri & uri,const std::string & mode)290 int SmsMmsAbility::OpenFile(const Uri &uri, const std::string &mode)
291 {
292 DATA_STORAGE_LOGI("SmsMmsAbility::OpenFile##uri = %{public}s\n", uri.ToString().c_str());
293 Uri tempUri = uri;
294 MessageUriType messageUriType = ParseUriType(tempUri);
295 return static_cast<int>(messageUriType);
296 }
297
BatchInsert(const Uri & uri,const std::vector<NativeRdb::ValuesBucket> & values)298 int SmsMmsAbility::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
299 {
300 if (!TelephonyPermission::CheckPermission(Permission::READ_MESSAGES)) {
301 DATA_STORAGE_LOGE("Permission denied!");
302 return DATA_STORAGE_ERR_PERMISSION_ERR;
303 }
304 int result = DATA_STORAGE_ERROR;
305 if (!IsInitOk()) {
306 return result;
307 }
308 std::lock_guard<std::mutex> guard(lock_);
309 Uri tempUri = uri;
310 MessageUriType messageUriType = ParseUriType(tempUri);
311 int64_t id = DATA_STORAGE_ERROR;
312 if (messageUriType == MessageUriType::SMS_MMS) {
313 result = helper_.BatchInsertSmsMmsInfo(id, values);
314 } else {
315 DATA_STORAGE_LOGI("SmsMmsAbility::BatchInsert##uri = %{public}s\n", uri.ToString().c_str());
316 }
317 return result;
318 }
319
ParseUriType(Uri & uri)320 MessageUriType SmsMmsAbility::ParseUriType(Uri &uri)
321 {
322 DATA_STORAGE_LOGI("SmsMmsAbility::ParseUriType start\n");
323 MessageUriType messageUriType = MessageUriType::UNKNOW;
324 std::string uriPath = uri.ToString();
325 if (!uriPath.empty()) {
326 helper_.ReplaceAllStr(uriPath, ":///", "://");
327 Uri tempUri(uriPath);
328 std::string path = tempUri.GetPath();
329 if (!path.empty()) {
330 DATA_STORAGE_LOGI("SmsMmsAbility::ParseUriType##path = %{public}s\n", path.c_str());
331 std::map<std::string, MessageUriType>::iterator it = smsMmsUriMap.find(path);
332 if (it != smsMmsUriMap.end()) {
333 messageUriType = it->second;
334 DATA_STORAGE_LOGI("SmsMmsAbility::ParseUriType##messageUriType = %{public}d\n", messageUriType);
335 }
336 }
337 }
338 return messageUriType;
339 }
340
ConvertPredicates(const NativeRdb::DataAbilityPredicates & dataPredicates,NativeRdb::AbsRdbPredicates * absRdbPredicates)341 void SmsMmsAbility::ConvertPredicates(
342 const NativeRdb::DataAbilityPredicates &dataPredicates, NativeRdb::AbsRdbPredicates *absRdbPredicates)
343 {
344 NativeRdb::PredicatesUtils::SetWhereClauseAndArgs(
345 absRdbPredicates, dataPredicates.GetWhereClause(), dataPredicates.GetWhereArgs());
346 NativeRdb::PredicatesUtils::SetAttributes(absRdbPredicates, dataPredicates.IsDistinct(),
347 dataPredicates.GetIndex(), dataPredicates.GetGroup(), dataPredicates.GetOrder(), dataPredicates.GetLimit(),
348 dataPredicates.GetOffset());
349 }
350
351 REGISTER_AA(SmsMmsAbility);
352 } // namespace Telephony
353 } // namespace OHOS
354