1 /*
2 * Copyright (C) 2024 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 #define MLOG_TAG "RingtoneSettingManager"
16
17 #include "ringtone_setting_manager.h"
18
19 #include "rdb_errno.h"
20 #include "result_set_utils.h"
21 #include "ringtone_errno.h"
22 #include "ringtone_log.h"
23 #include "ringtone_metadata.h"
24 #include "ringtone_type.h"
25
26 namespace OHOS {
27 namespace Media {
28 using namespace std;
29 static const string RINGTONE_SETTINGS_SELECT_COLUMNS =
30 RINGTONE_COLUMN_TONE_ID + ", " + RINGTONE_COLUMN_DATA + ", " + RINGTONE_COLUMN_SHOT_TONE_TYPE + ", " +
31 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + ", " + RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + ", " +
32 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + ", " + RINGTONE_COLUMN_RING_TONE_TYPE + ", " +
33 RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + ", " + RINGTONE_COLUMN_ALARM_TONE_TYPE + ", " +
34 RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE;
35
36 static const string RINGTONE_SETTINGS_WHERECLAUSE_SHOT = RINGTONE_COLUMN_SHOT_TONE_TYPE + " <> " +
37 to_string(SHOT_TONE_TYPE_NOT);
38
39 static const string RINGTONE_SETTINGS_WHERECLAUSE_ALARM = RINGTONE_COLUMN_ALARM_TONE_TYPE + " <> " +
40 to_string(ALARM_TONE_TYPE_NOT);
41
42 static const string RINGTONE_SETTINGS_WHERECLAUSE_NOTIFICATION = RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " <> " +
43 to_string(NOTIFICATION_TONE_TYPE_NOT);
44
45 static const string RINGTONE_SETTINGS_WHERECLAUSE_RINGTONE = RINGTONE_COLUMN_RING_TONE_TYPE + " <> " +
46 to_string(RING_TONE_TYPE_NOT);
47
48 static const string QUERY_SHOTTONE_SETTINGS_SQL = "SELECT " + RINGTONE_SETTINGS_SELECT_COLUMNS + " FROM "
49 + RINGTONE_TABLE + " WHERE " + RINGTONE_SETTINGS_WHERECLAUSE_SHOT;
50
51 static const string QUERY_ALARMTONE_SETTINGS_SQL = "SELECT " + RINGTONE_SETTINGS_SELECT_COLUMNS + " FROM "
52 + RINGTONE_TABLE + " WHERE " + RINGTONE_SETTINGS_WHERECLAUSE_ALARM;
53
54 static const string QUERY_NOTIFICATIONTONE_SETTINGS_SQL = "SELECT " + RINGTONE_SETTINGS_SELECT_COLUMNS +
55 " FROM " + RINGTONE_TABLE + " WHERE " + RINGTONE_SETTINGS_WHERECLAUSE_NOTIFICATION;
56
57 static const string QUERY_RINGTONE_SETTINGS_SQL = "SELECT " + RINGTONE_SETTINGS_SELECT_COLUMNS + " FROM " +
58 RINGTONE_TABLE + " WHERE " + RINGTONE_SETTINGS_WHERECLAUSE_RINGTONE;
59
60 static const string QUERY_SETTINGS_BY_PATH = "SELECT " + RINGTONE_SETTINGS_SELECT_COLUMNS + " FROM "
61 + RINGTONE_TABLE + " WHERE " + RINGTONE_COLUMN_DATA + " = ";
62
RingtoneSettingManager(std::shared_ptr<NativeRdb::RdbStore> rdb)63 RingtoneSettingManager::RingtoneSettingManager(std::shared_ptr<NativeRdb::RdbStore> rdb) : ringtoneRdb_(rdb)
64 {
65 }
66
CommitSettingCompare(int32_t settingType,int32_t toneType,int32_t sourceType)67 int32_t RingtoneSettingManager::CommitSettingCompare(int32_t settingType, int32_t toneType, int32_t sourceType)
68 {
69 if ((sourceType != SOURCE_TYPE_PRESET) && (sourceType != SOURCE_TYPE_CUSTOMISED)) {
70 return E_INVALID_ARGUMENTS;
71 }
72 if ((settingType < TONE_SETTING_TYPE_ALARM) || (settingType >= TONE_SETTING_TYPE_MAX)) {
73 return E_INVALID_ARGUMENTS;
74 }
75 if (((settingType == TONE_SETTING_TYPE_NOTIFICATION) && (toneType != NOTIFICATION_TONE_TYPE)) ||
76 ((settingType == TONE_SETTING_TYPE_ALARM) && (toneType != ALARM_TONE_TYPE))) {
77 return E_INVALID_ARGUMENTS;
78 }
79 if ((settingType == TONE_SETTING_TYPE_SHOT) && ((toneType <= SHOT_TONE_TYPE_NOT) ||
80 (toneType >= TONE_SETTING_TYPE_MAX))) {
81 return E_INVALID_ARGUMENTS;
82 }
83 if ((settingType == TONE_SETTING_TYPE_RINGTONE) && ((toneType <= RING_TONE_TYPE_NOT) ||
84 (toneType >= TONE_SETTING_TYPE_MAX))) {
85 return E_INVALID_ARGUMENTS;
86 }
87 return E_OK;
88 }
89
CommitSetting(int32_t toneId,string & tonePath,int32_t settingType,int32_t toneType,int32_t sourceType)90 int32_t RingtoneSettingManager::CommitSetting(int32_t toneId, string &tonePath, int32_t settingType, int32_t toneType,
91 int32_t sourceType)
92 {
93 RINGTONE_DEBUG_LOG("toneId=%{public}d, tonePath=%{public}s, settingType=%{public}d, toneType=%{public}d,"
94 "sourceType=%{public}d", toneId, tonePath.c_str(), settingType, toneType, sourceType);
95 auto ret = CommitSettingCompare(settingType, toneType, sourceType);
96 if (ret != E_OK) {
97 return ret;
98 }
99 SettingItem item = {toneId, settingType, toneType, sourceType};
100 for (auto it = settings_.find(tonePath); it != settings_.end(); it++) {
101 if ((settingType == it->second.settingType) && (toneType == it->second.toneType) &&
102 (sourceType == it->second.sourceType)) {
103 RINGTONE_INFO_LOG("warning: this setting is existing, tone file:%{public}s", tonePath.c_str());
104 return E_FAIL;
105 } else if ((settingType == it->second.settingType) && (sourceType == it->second.sourceType)) {
106 if (((settingType == TONE_SETTING_TYPE_SHOT) && (it->second.toneType == SHOT_TONE_TYPE_SIM_CARD_BOTH)) ||
107 ((settingType == TONE_SETTING_TYPE_RINGTONE) &&
108 (it->second.toneType == SHOT_TONE_TYPE_SIM_CARD_BOTH))) {
109 RINGTONE_INFO_LOG("warning: this setting is existing, tone file:%{public}s", tonePath.c_str());
110 return E_FAIL;
111 }
112 if ((settingType == TONE_SETTING_TYPE_SHOT) && (toneType != it->second.toneType)) {
113 it->second.toneType = SHOT_TONE_TYPE_SIM_CARD_BOTH;
114 return E_OK;
115 }
116 if ((settingType == TONE_SETTING_TYPE_RINGTONE) && (toneType != it->second.toneType)) {
117 it->second.toneType = RING_TONE_TYPE_SIM_CARD_BOTH;
118 return E_OK;
119 }
120 } else {
121 continue;
122 }
123 }
124 settings_.emplace(tonePath, item);
125 return E_OK;
126 }
127
TravelSettings(function<int32_t (string &,SettingItem &)> func)128 void RingtoneSettingManager::TravelSettings(function<int32_t (string &, SettingItem &)> func)
129 {
130 for (auto it = settings_.cbegin(); it != settings_.cend(); ++it) {
131 string first = it->first;
132 SettingItem item = it->second;
133 func(first, item);
134 }
135 }
136
FlushSettings()137 void RingtoneSettingManager::FlushSettings()
138 {
139 TravelSettings([this](string &tonePath, SettingItem &item) -> int32_t {
140 int32_t ret = CleanupSetting(item.settingType, item.toneType, item.sourceType);
141 if (ret != E_OK) {
142 RINGTONE_ERR_LOG("error: cleanup settings failed, tonePath=%{public}s", tonePath.c_str());
143 }
144 return ret;
145 });
146
147 TravelSettings([this](string &tonePath, SettingItem &item) -> int32_t {
148 int32_t ret = this->UpdateSettingsByPath(tonePath, item.settingType, item.toneType, item.sourceType);
149 if (ret != E_OK) {
150 RINGTONE_ERR_LOG("error: update settings failed, tonePath=%{public}s", tonePath.c_str());
151 }
152 return ret;
153 });
154
155 settings_.clear();
156 }
157
PopulateMetadata(const shared_ptr<NativeRdb::ResultSet> & resultSet,unique_ptr<RingtoneMetadata> & metaData)158 int32_t RingtoneSettingManager::PopulateMetadata(const shared_ptr<NativeRdb::ResultSet> &resultSet,
159 unique_ptr<RingtoneMetadata> &metaData)
160 {
161 std::vector<std::string> columnNames;
162 int32_t err = resultSet->GetAllColumnNames(columnNames);
163 if (err != NativeRdb::E_OK) {
164 RINGTONE_ERR_LOG("failed to get all column names");
165 return E_RDB;
166 }
167
168 for (const auto &col : columnNames) {
169 ExtractMetaFromColumn(resultSet, metaData, col);
170 }
171
172 return E_OK;
173 }
174
ExtractMetaFromColumn(const shared_ptr<NativeRdb::ResultSet> & resultSet,unique_ptr<RingtoneMetadata> & metadata,const std::string & col)175 void RingtoneSettingManager::ExtractMetaFromColumn(const shared_ptr<NativeRdb::ResultSet> &resultSet,
176 unique_ptr<RingtoneMetadata> &metadata, const std::string &col)
177 {
178 RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_NULL;
179 RingtoneMetadata::RingtoneMetadataFnPtr requestFunc = nullptr;
180 auto itr = metadata->memberFuncMap_.find(col);
181 if (itr != metadata->memberFuncMap_.end()) {
182 dataType = itr->second.first;
183 requestFunc = itr->second.second;
184 } else {
185 RINGTONE_ERR_LOG("column name invalid %{private}s", col.c_str());
186 return;
187 }
188
189 std::variant<int32_t, std::string, int64_t, double> data =
190 ResultSetUtils::GetValFromColumn<const shared_ptr<NativeRdb::ResultSet>>(col, resultSet, dataType);
191
192 // Use the function pointer from map and pass data to fn ptr
193 if (requestFunc != nullptr) {
194 (metadata.get()->*requestFunc)(data);
195 }
196 }
197
GetMetaDataFromResultSet(shared_ptr<NativeRdb::ResultSet> resultSet,vector<shared_ptr<RingtoneMetadata>> & metaDatas)198 int32_t RingtoneSettingManager::GetMetaDataFromResultSet(shared_ptr<NativeRdb::ResultSet> resultSet,
199 vector<shared_ptr<RingtoneMetadata>> &metaDatas)
200 {
201 if (resultSet == nullptr) {
202 RINGTONE_INFO_LOG("invalid argument");
203 return E_INVALID_ARGUMENTS;
204 }
205 auto ret = resultSet->GoToFirstRow();
206 while (ret == NativeRdb::E_OK) {
207 auto metaData = make_unique<RingtoneMetadata>();
208 if (PopulateMetadata(resultSet, metaData) != E_OK) {
209 resultSet->Close();
210 RINGTONE_INFO_LOG("read resultset error");
211 return E_DB_FAIL;
212 }
213 metaDatas.push_back(std::move(metaData));
214 ret = resultSet->GoToNextRow();
215 };
216
217 return E_OK;
218 }
219
UpdateShotSetting(shared_ptr<RingtoneMetadata> & meta,int32_t toneType,int32_t sourceType)220 int32_t RingtoneSettingManager::UpdateShotSetting(shared_ptr<RingtoneMetadata> &meta, int32_t toneType,
221 int32_t sourceType)
222 {
223 int32_t val = meta->GetShotToneType();
224 if (val != SHOT_TONE_TYPE_NOT && val != toneType) {
225 val = SHOT_TONE_TYPE_SIM_CARD_BOTH;
226 } else {
227 val = toneType;
228 }
229 string updateSql = "UPDATE ToneFiles SET " +
230 RINGTONE_COLUMN_SHOT_TONE_TYPE + " = " + to_string(val) + ", " +
231 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " + to_string(sourceType) +
232 " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(meta->GetToneId()) +
233 " AND " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " NOT IN (1, 2)";
234 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
235 if (rdbRet < 0) {
236 RINGTONE_ERR_LOG("execute update failed");
237 return E_DB_FAIL;
238 }
239
240 return E_OK;
241 }
242
UpdateRingtoneSetting(shared_ptr<RingtoneMetadata> & meta,int32_t toneType,int32_t sourceType)243 int32_t RingtoneSettingManager::UpdateRingtoneSetting(shared_ptr<RingtoneMetadata> &meta, int32_t toneType,
244 int32_t sourceType)
245 {
246 int32_t val = meta->GetRingToneType();
247 if (val != RING_TONE_TYPE_NOT && val != toneType) {
248 val = RING_TONE_TYPE_SIM_CARD_BOTH;
249 } else {
250 val = toneType;
251 }
252 string updateSql = "UPDATE ToneFiles SET " +
253 RINGTONE_COLUMN_RING_TONE_TYPE + " = " + to_string(val) + ", " +
254 RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " + to_string(sourceType) +
255 " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(meta->GetToneId()) +
256 " AND " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " NOT IN (1, 2)";
257 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
258 if (rdbRet < 0) {
259 RINGTONE_ERR_LOG("execute update failed");
260 return E_DB_FAIL;
261 }
262
263 return E_OK;
264 }
265
UpdateNotificationSetting(shared_ptr<RingtoneMetadata> & meta,int32_t toneType,int32_t sourceType)266 int32_t RingtoneSettingManager::UpdateNotificationSetting(shared_ptr<RingtoneMetadata> &meta, int32_t toneType,
267 int32_t sourceType)
268 {
269 string updateSql = "UPDATE ToneFiles SET " +
270 RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = " + to_string(toneType) + ", " +
271 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " + to_string(sourceType) +
272 " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(meta->GetToneId()) +
273 " AND " + RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " NOT IN (1, 2)";
274 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
275 if (rdbRet < 0) {
276 RINGTONE_ERR_LOG("execute update failed");
277 return E_DB_FAIL;
278 }
279
280 return E_OK;
281 }
282
UpdateAlarmSetting(shared_ptr<RingtoneMetadata> & meta,int32_t toneType,int32_t sourceType)283 int32_t RingtoneSettingManager::UpdateAlarmSetting(shared_ptr<RingtoneMetadata> &meta, int32_t toneType,
284 int32_t sourceType)
285 {
286 string updateSql = "UPDATE ToneFiles SET " +
287 RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " + to_string(toneType) + ", " +
288 RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " + to_string(sourceType) +
289 " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(meta->GetToneId()) +
290 " AND " + RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " NOT IN (1, 2)";
291 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
292 if (rdbRet < 0) {
293 RINGTONE_ERR_LOG("execute update failed");
294 return E_DB_FAIL;
295 }
296
297 return E_OK;
298 }
299
UpdateSettingsByPath(string & tonePath,int32_t settingType,int32_t toneType,int32_t sourceType)300 int32_t RingtoneSettingManager::UpdateSettingsByPath(string &tonePath, int32_t settingType, int32_t toneType,
301 int32_t sourceType)
302 {
303 string querySql = QUERY_SETTINGS_BY_PATH + "\"" + tonePath + "\"";
304 auto ret = TravelQueryResultSet(querySql, [&](shared_ptr<RingtoneMetadata> &meta) -> bool {
305 string updateSql = {};
306 if (settingType == TONE_SETTING_TYPE_SHOT) {
307 // update shot-tone settings
308 if (UpdateShotSetting(meta, toneType, sourceType) != E_OK) {
309 return false;
310 }
311 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
312 // update ring-tone settings
313 if (UpdateRingtoneSetting(meta, toneType, sourceType) != E_OK) {
314 return false;
315 }
316 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
317 // update notification-tone settings
318 if (UpdateNotificationSetting(meta, toneType, sourceType) != E_OK) {
319 return false;
320 }
321 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
322 // update alarm-tone settings
323 if (UpdateAlarmSetting(meta, toneType, sourceType) != E_OK) {
324 return false;
325 }
326 } else {
327 RINGTONE_INFO_LOG("invalid tone-setting-type");
328 return false;
329 }
330 return true;
331 });
332
333 return ret;
334 }
335
UpdateSettingsWithToneId(int32_t settingType,int32_t toneId,int32_t toneType)336 int32_t RingtoneSettingManager::UpdateSettingsWithToneId(int32_t settingType, int32_t toneId, int32_t toneType)
337 {
338 int32_t ret = E_OK;
339
340 string updateSql = {};
341 if (settingType == TONE_SETTING_TYPE_SHOT) {
342 // update shot-tone settings
343 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " = " +
344 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
345 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
346 // update ring-tone settings
347 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_RING_TONE_TYPE + " = " +
348 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
349 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
350 // update notification-tone settings
351 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = " +
352 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
353 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
354 // update alarm-tone settings
355 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " +
356 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
357 } else {
358 RINGTONE_INFO_LOG("invalid tone-setting-type");
359 return E_INVALID_ARGUMENTS;
360 }
361 if (!updateSql.empty()) {
362 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
363 if (rdbRet < 0) {
364 RINGTONE_ERR_LOG("execute update failed");
365 ret = E_DB_FAIL;
366 }
367 }
368 return ret;
369 }
370
371 static const string SHOT_SETTING_CLEANUP_CLAUSE = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " = " +
372 to_string(SHOT_TONE_TYPE_DEFAULT) + ", " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " +
373 to_string(SHOT_TONE_SOURCE_TYPE_DEFAULT);
374
375 static const string RINGTONE_SETTING_CLEANUP_CLAUSE = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_RING_TONE_TYPE + " = " +
376 to_string(RING_TONE_TYPE_DEFAULT) + ", " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + "=" +
377 to_string(RING_TONE_SOURCE_TYPE_DEFAULT);
378
CleanupSettingFromRdb(int32_t settingType,int32_t toneType,int32_t sourceType)379 int32_t RingtoneSettingManager::CleanupSettingFromRdb(int32_t settingType, int32_t toneType, int32_t sourceType)
380 {
381 int32_t ret = E_OK;
382 string updateSql = {};
383 if (settingType == TONE_SETTING_TYPE_SHOT) {
384 if (toneType == SHOT_TONE_TYPE_SIM_CARD_BOTH) {
385 updateSql = SHOT_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " <> " +
386 to_string(SHOT_TONE_TYPE_DEFAULT) + " AND " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " +
387 to_string(sourceType);
388 } else {
389 updateSql = SHOT_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " = " +
390 to_string(toneType) + " AND " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " + to_string(sourceType);
391 }
392 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
393 if (toneType == RING_TONE_TYPE_SIM_CARD_BOTH) {
394 updateSql = RINGTONE_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_RING_TONE_TYPE + " <> " +
395 to_string(RING_TONE_TYPE_DEFAULT) + " AND " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " +
396 to_string(sourceType);
397 } else {
398 updateSql = RINGTONE_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_RING_TONE_TYPE + " = " +
399 to_string(toneType) + " AND " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " +
400 to_string(sourceType);
401 }
402 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
403 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = " +
404 to_string(NOTIFICATION_TONE_TYPE_NOT) + ", " + RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " +
405 to_string(NOTIFICATION_TONE_SOURCE_TYPE_DEFAULT) + " WHERE " + RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE +
406 " = " + to_string(toneType) + " AND " + RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " +
407 to_string(sourceType);
408 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
409 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " +
410 to_string(ALARM_TONE_TYPE_NOT) + ", " + RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " +
411 to_string(ALARM_TONE_SOURCE_TYPE_DEFAULT) + " WHERE " + RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " +
412 to_string(toneType) + " AND " + RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " +
413 to_string(sourceType);
414 } else {
415 return E_INVALID_ARGUMENTS;
416 }
417 if (!updateSql.empty()) {
418 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
419 if (rdbRet < 0) {
420 RINGTONE_ERR_LOG("execute update failed");
421 ret = E_DB_FAIL;
422 }
423 }
424 return ret;
425 }
426
CleanupSetting(int32_t settingType,int32_t toneType,int32_t sourceType)427 int32_t RingtoneSettingManager::CleanupSetting(int32_t settingType, int32_t toneType, int32_t sourceType)
428 {
429 if (ringtoneRdb_ == nullptr) {
430 RINGTONE_ERR_LOG("ringtone rdb_ is nullptr");
431 return E_DB_FAIL;
432 }
433
434 string querySql = {};
435 if (settingType == TONE_SETTING_TYPE_SHOT) {
436 querySql = QUERY_SHOTTONE_SETTINGS_SQL + " AND " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " +
437 to_string(sourceType);
438 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
439 querySql = QUERY_ALARMTONE_SETTINGS_SQL + " AND " + RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " +
440 to_string(sourceType);
441 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
442 querySql = QUERY_NOTIFICATIONTONE_SETTINGS_SQL + " AND " +
443 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " + to_string(sourceType);
444 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
445 querySql = QUERY_RINGTONE_SETTINGS_SQL + " AND " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " +
446 to_string(sourceType);
447 } else {
448 RINGTONE_ERR_LOG("setting type is not existing");
449 return E_INVALID_ARGUMENTS;
450 }
451
452 TravelQueryResultSet(querySql, [&](shared_ptr<RingtoneMetadata> &meta) -> bool {
453 int32_t ret = true;
454 if ((settingType == TONE_SETTING_TYPE_SHOT) && (toneType != SHOT_TONE_TYPE_SIM_CARD_BOTH) &&
455 (meta->GetShotToneType() == SHOT_TONE_TYPE_SIM_CARD_BOTH)) {
456 int32_t cleanType = (toneType == SHOT_TONE_TYPE_SIM_CARD_1 ? SHOT_TONE_TYPE_SIM_CARD_2 :
457 SHOT_TONE_TYPE_SIM_CARD_1);
458 UpdateSettingsWithToneId(settingType, meta->GetToneId(), cleanType);
459 } else if ((settingType == TONE_SETTING_TYPE_RINGTONE) && (toneType != RING_TONE_TYPE_SIM_CARD_BOTH) &&
460 (meta->GetRingToneType() == RING_TONE_TYPE_SIM_CARD_BOTH)) {
461 int32_t cleanType = (toneType == RING_TONE_TYPE_SIM_CARD_1 ? RING_TONE_TYPE_SIM_CARD_2 :
462 RING_TONE_TYPE_SIM_CARD_1);
463 UpdateSettingsWithToneId(settingType, meta->GetToneId(), cleanType);
464 } else {
465 ret = false;
466 }
467
468 return ret;
469 });
470
471 return CleanupSettingFromRdb(settingType, toneType, sourceType);
472 }
473
TravelQueryResultSet(string querySql,function<bool (shared_ptr<RingtoneMetadata> &)> func)474 int32_t RingtoneSettingManager::TravelQueryResultSet(string querySql,
475 function<bool (shared_ptr<RingtoneMetadata> &)> func)
476 {
477 auto resultSet = ringtoneRdb_->QuerySql(querySql);
478 if (resultSet == nullptr) {
479 RINGTONE_INFO_LOG("result is null");
480 return E_OK;
481 }
482 vector<shared_ptr<RingtoneMetadata>> metaDatas = {};
483 int32_t ret = GetMetaDataFromResultSet(resultSet, metaDatas);
484 if (ret != E_OK) {
485 RINGTONE_INFO_LOG("read resultSet error");
486 resultSet->Close();
487 return E_DB_FAIL;
488 }
489 for (auto meta : metaDatas) {
490 if (func(meta) == true) {
491 break;
492 }
493 }
494
495 resultSet->Close();
496 return E_OK;
497 }
498
Update(int & changedRows,const NativeRdb::ValuesBucket & values,const NativeRdb::AbsRdbPredicates & predicates)499 int32_t RingtoneSettingManager::Update(int &changedRows, const NativeRdb::ValuesBucket &values,
500 const NativeRdb::AbsRdbPredicates &predicates)
501 {
502 if (ringtoneRdb_ == nullptr) {
503 RINGTONE_ERR_LOG("ringtone rdb_ is nullptr");
504 return E_DB_FAIL;
505 }
506 return ringtoneRdb_->Update(changedRows, values, predicates);
507 }
508
509 } // namespace Media
510 } // namespace OHOS
511