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_persist_helper.h"
17
18 #include "ability_manager_interface.h"
19 #include "if_system_ability_manager.h"
20 #include "iservice_registry.h"
21 #include "system_ability.h"
22 #include "system_ability_definition.h"
23 #include "resource_manager.h"
24 #include "parameter.h"
25
26 #include "telephony_log_wrapper.h"
27 #include "string_utils.h"
28
29 namespace OHOS {
30 namespace Telephony {
31 class AbsSharedResultSet;
SmsPersistHelper()32 SmsPersistHelper::SmsPersistHelper() {}
33
~SmsPersistHelper()34 SmsPersistHelper::~SmsPersistHelper() {}
35
CreateDataShareHelper(std::string uri)36 std::shared_ptr<DataShare::DataShareHelper> SmsPersistHelper::CreateDataShareHelper(std::string uri)
37 {
38 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
39 if (saManager == nullptr) {
40 TELEPHONY_LOGE(" Get system ability mgr failed.");
41 return nullptr;
42 }
43 auto remoteObj = saManager->GetSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);
44 if (remoteObj == nullptr) {
45 TELEPHONY_LOGE("GetSystemAbility Service Failed.");
46 return nullptr;
47 }
48 return DataShare::DataShareHelper::Creator(remoteObj, uri);
49 }
50
Insert(DataShare::DataShareValuesBucket & values)51 bool SmsPersistHelper::Insert(DataShare::DataShareValuesBucket &values)
52 {
53 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(SMS_URI);
54 if (helper == nullptr) {
55 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
56 return false;
57 }
58 Uri uri(SMS_SUBSECTION);
59 int ret = helper->Insert(uri, values);
60 helper->Release();
61 return ret >= 0 ? true : false;
62 }
63
Insert(std::string tableUri,DataShare::DataShareValuesBucket & values)64 bool SmsPersistHelper::Insert(std::string tableUri, DataShare::DataShareValuesBucket &values)
65 {
66 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(SMS_URI);
67 if (helper == nullptr) {
68 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
69 return false;
70 }
71 Uri uri(tableUri);
72 int ret = helper->Insert(uri, values);
73 helper->Release();
74 return ret >= 0 ? true : false;
75 }
76
QuerySession(DataShare::DataSharePredicates & predicates,uint16_t & sectionId,uint16_t & messageCount)77 bool SmsPersistHelper::QuerySession(DataShare::DataSharePredicates &predicates, uint16_t §ionId,
78 uint16_t &messageCount)
79 {
80 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(SMS_URI);
81 if (helper == nullptr) {
82 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
83 return false;
84 }
85 Uri uri(SESSION);
86 std::vector<std::string> columns;
87 auto resultSet = helper->Query(uri, predicates, columns);
88 if (resultSet == nullptr) {
89 TELEPHONY_LOGE("Query Result Set nullptr Failed.");
90 return false;
91 }
92 resultSet->GoToFirstRow();
93 int32_t columnInt;
94 int columnIndex;
95 resultSet->GetColumnIndex("id", columnIndex);
96 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
97 sectionId = columnInt;
98 }
99 resultSet->GetColumnIndex("message_count", columnIndex);
100 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
101 messageCount = columnInt;
102 return true;
103 }
104 resultSet->Close();
105 helper->Release();
106 return false;
107 }
108
Update(DataShare::DataSharePredicates & predicates,DataShare::DataShareValuesBucket & values)109 bool SmsPersistHelper::Update(DataShare::DataSharePredicates &predicates, DataShare::DataShareValuesBucket &values)
110 {
111 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(SMS_URI);
112 if (helper == nullptr) {
113 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
114 return false;
115 }
116 Uri uri(SESSION);
117 int ret = helper->Update(uri, predicates, values);
118 helper->Release();
119 return ret >= 0 ? true : false;
120 }
121
Query(DataShare::DataSharePredicates & predicates,std::vector<SmsReceiveIndexer> & indexers)122 bool SmsPersistHelper::Query(DataShare::DataSharePredicates &predicates, std::vector<SmsReceiveIndexer> &indexers)
123 {
124 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(SMS_URI);
125 if (helper == nullptr) {
126 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
127 return false;
128 }
129 Uri uri(SMS_SUBSECTION);
130 std::vector<std::string> columns;
131 auto resultSet = helper->Query(uri, predicates, columns);
132 helper->Release();
133 if (resultSet == nullptr) {
134 TELEPHONY_LOGE("Query Result Set nullptr Failed.");
135 return false;
136 }
137
138 int resultSetNum = resultSet->GoToFirstRow();
139 while (resultSetNum == 0) {
140 SmsReceiveIndexer indexer;
141 ResultSetConvertToIndexer(indexer, resultSet);
142 indexers.push_back(indexer);
143 resultSetNum = resultSet->GoToNextRow();
144 }
145 resultSet->Close();
146 return true;
147 }
148
QueryMaxGroupId(DataShare::DataSharePredicates & predicates,uint16_t & maxGroupId)149 bool SmsPersistHelper::QueryMaxGroupId(DataShare::DataSharePredicates &predicates, uint16_t &maxGroupId)
150 {
151 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(SMS_URI);
152 if (helper == nullptr) {
153 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
154 return false;
155 }
156 Uri uri(SMS_MMS_INFO);
157 std::vector<std::string> columns;
158 auto resultSet = helper->Query(uri, predicates, columns);
159 if (resultSet == nullptr) {
160 TELEPHONY_LOGE("Query Result Set nullptr Failed.");
161 return false;
162 }
163
164 int32_t columnInt;
165 int columnIndex;
166 resultSet->GoToLastRow();
167 resultSet->GetColumnIndex(SmsMmsInfo::GROUP_ID, columnIndex);
168 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
169 maxGroupId = columnInt;
170 }
171 resultSet->Close();
172 helper->Release();
173 return true;
174 }
175
Delete(DataShare::DataSharePredicates & predicates)176 bool SmsPersistHelper::Delete(DataShare::DataSharePredicates &predicates)
177 {
178 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(SMS_URI);
179 if (helper == nullptr) {
180 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
181 return false;
182 }
183 Uri uri(SMS_SUBSECTION);
184 int ret = helper->Delete(uri, predicates);
185 helper->Release();
186 return ret >= 0 ? true : false;
187 }
188
QueryBlockPhoneNumber(const std::string & phoneNum)189 bool SmsPersistHelper::QueryBlockPhoneNumber(const std::string &phoneNum)
190 {
191 bool result = false;
192 int count = 0;
193 const std::string phoneNumber = "phone_number";
194 if (phoneNum.empty()) {
195 return result;
196 }
197 std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataShareHelper(CONTACT_URI);
198 if (helper == nullptr) {
199 TELEPHONY_LOGE("Create Data Ability Helper nullptr Failed.");
200 return false;
201 }
202 Uri uri(CONTACT_BLOCK);
203 std::vector<std::string> columns;
204 DataShare::DataSharePredicates predicates;
205 predicates.EqualTo(phoneNumber, phoneNum);
206 auto resultSet = helper->Query(uri, predicates, columns);
207 helper->Release();
208 if (resultSet == nullptr) {
209 TELEPHONY_LOGE("Query Result Set nullptr Failed.");
210 return result;
211 }
212 if (resultSet->GetRowCount(count) == 0 && count != 0) {
213 result = true;
214 }
215 resultSet->Close();
216 return result;
217 }
218
QueryParamBoolean(const std::string key,bool defValue)219 bool SmsPersistHelper::QueryParamBoolean(const std::string key, bool defValue)
220 {
221 const int PARAM_SIZE = 64;
222 char paramOutBuff[PARAM_SIZE] = {0};
223 std::string defStrValue = defValue ? "1" : "0";
224 std::string paramValue(defStrValue);
225
226 int retLen = GetParameter(key.c_str(), defStrValue.c_str(), paramOutBuff, PARAM_SIZE);
227 if (retLen > 0) {
228 paramOutBuff[retLen] = '\0';
229 paramValue.assign(paramOutBuff, retLen);
230 }
231
232 TELEPHONY_LOGI("QueryParamBoolean: %{public}zu : %{public}s", paramValue.size(), paramValue.c_str());
233 if ((paramValue == std::string("1")) || (paramValue == std::string("y")) || (paramValue == std::string("yes")) ||
234 (paramValue == std::string("on")) || (paramValue == std::string("true"))) {
235 return true;
236 } else if ((paramValue == std::string("0")) || (paramValue == std::string("n")) ||
237 (paramValue == std::string("no")) || (paramValue == std::string("off")) ||
238 (paramValue == std::string("false"))) {
239 return false;
240 }
241 return defValue;
242 }
243
ConvertIntToIndexer(SmsReceiveIndexer & info,const std::shared_ptr<DataShare::DataShareResultSet> & resultSet)244 void SmsPersistHelper::ConvertIntToIndexer(
245 SmsReceiveIndexer &info, const std::shared_ptr<DataShare::DataShareResultSet> &resultSet)
246 {
247 int32_t columnInt;
248 int columnIndex;
249 resultSet->GetColumnIndex(SmsMmsData::FORMAT, columnIndex);
250 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
251 info.SetIsCdma(columnInt != 0);
252 }
253
254 resultSet->GetColumnIndex(SmsMmsData::SMS_SUBSECTION_ID, columnIndex);
255 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
256 info.SetMsgRefId(columnInt);
257 }
258
259 resultSet->GetColumnIndex(SmsMmsData::SIZE, columnIndex);
260 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
261 info.SetMsgCount(columnInt);
262 }
263
264 resultSet->GetColumnIndex(SmsMmsData::SUBSECTION_INDEX, columnIndex);
265 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
266 info.SetMsgSeqId(columnInt);
267 }
268
269 resultSet->GetColumnIndex(SmsMmsData::DEST_PORT, columnIndex);
270 if (resultSet->GetInt(columnIndex, columnInt) == 0) {
271 info.SetDestPort(columnInt);
272 }
273 }
274
ConvertStringToIndexer(SmsReceiveIndexer & info,const std::shared_ptr<DataShare::DataShareResultSet> & resultSet)275 void SmsPersistHelper::ConvertStringToIndexer(
276 SmsReceiveIndexer &info, const std::shared_ptr<DataShare::DataShareResultSet> &resultSet)
277 {
278 int columnIndex;
279 std::string columnValue;
280 resultSet->GetColumnIndex(SmsMmsData::RECEIVER_NUMBER, columnIndex);
281 if (resultSet->GetString(columnIndex, columnValue) == 0) {
282 info.SetVisibleAddress(columnValue);
283 }
284 resultSet->GetColumnIndex(SmsMmsData::SENDER_NUMBER, columnIndex);
285 if (resultSet->GetString(columnIndex, columnValue) == 0) {
286 info.SetOriginatingAddress(columnValue);
287 }
288
289 resultSet->GetColumnIndex(SmsMmsData::START_TIME, columnIndex);
290 if (resultSet->GetString(columnIndex, columnValue) == 0) {
291 info.SetTimestamp(std::stol(columnValue));
292 }
293 resultSet->GetColumnIndex(SmsMmsData::END_TIME, columnIndex);
294 if (resultSet->GetString(columnIndex, columnValue) == 0) {
295 info.SetTimestamp(std::stol(columnValue));
296 }
297
298 resultSet->GetColumnIndex(SmsMmsData::RAW_PUD, columnIndex);
299 if (resultSet->GetString(columnIndex, columnValue) == 0) {
300 info.SetPdu(StringUtils::HexToByteVector(columnValue));
301 }
302 }
303
ResultSetConvertToIndexer(SmsReceiveIndexer & info,const std::shared_ptr<DataShare::DataShareResultSet> & resultSet)304 void SmsPersistHelper::ResultSetConvertToIndexer(
305 SmsReceiveIndexer &info, const std::shared_ptr<DataShare::DataShareResultSet> &resultSet)
306 {
307 ConvertIntToIndexer(info, resultSet);
308 ConvertStringToIndexer(info, resultSet);
309 }
310 } // namespace Telephony
311 } // namespace OHOS
312