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 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
234 if (rdbRet < 0) {
235 RINGTONE_ERR_LOG("execute update failed");
236 return E_DB_FAIL;
237 }
238
239 return E_OK;
240 }
241
UpdateRingtoneSetting(shared_ptr<RingtoneMetadata> & meta,int32_t toneType,int32_t sourceType)242 int32_t RingtoneSettingManager::UpdateRingtoneSetting(shared_ptr<RingtoneMetadata> &meta, int32_t toneType,
243 int32_t sourceType)
244 {
245 int32_t val = meta->GetRingToneType();
246 if (val != RING_TONE_TYPE_NOT && val != toneType) {
247 val = RING_TONE_TYPE_SIM_CARD_BOTH;
248 } else {
249 val = toneType;
250 }
251 string updateSql = "UPDATE ToneFiles SET " +
252 RINGTONE_COLUMN_RING_TONE_TYPE + " = " + to_string(val) + ", " +
253 RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " + to_string(sourceType) +
254 " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(meta->GetToneId());
255 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
256 if (rdbRet < 0) {
257 RINGTONE_ERR_LOG("execute update failed");
258 return E_DB_FAIL;
259 }
260
261 return E_OK;
262 }
263
UpdateNotificationSetting(shared_ptr<RingtoneMetadata> & meta,int32_t toneType,int32_t sourceType)264 int32_t RingtoneSettingManager::UpdateNotificationSetting(shared_ptr<RingtoneMetadata> &meta, int32_t toneType,
265 int32_t sourceType)
266 {
267 string updateSql = "UPDATE ToneFiles SET " +
268 RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = " + to_string(toneType) + ", " +
269 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " + to_string(sourceType) +
270 " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(meta->GetToneId());
271 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
272 if (rdbRet < 0) {
273 RINGTONE_ERR_LOG("execute update failed");
274 return E_DB_FAIL;
275 }
276
277 return E_OK;
278 }
279
UpdateAlarmSetting(shared_ptr<RingtoneMetadata> & meta,int32_t toneType,int32_t sourceType)280 int32_t RingtoneSettingManager::UpdateAlarmSetting(shared_ptr<RingtoneMetadata> &meta, int32_t toneType,
281 int32_t sourceType)
282 {
283 string updateSql = "UPDATE ToneFiles SET " +
284 RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " + to_string(toneType) + ", " +
285 RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " + to_string(sourceType) +
286 " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(meta->GetToneId());
287 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
288 if (rdbRet < 0) {
289 RINGTONE_ERR_LOG("execute update failed");
290 return E_DB_FAIL;
291 }
292
293 return E_OK;
294 }
295
UpdateSettingsByPath(string & tonePath,int32_t settingType,int32_t toneType,int32_t sourceType)296 int32_t RingtoneSettingManager::UpdateSettingsByPath(string &tonePath, int32_t settingType, int32_t toneType,
297 int32_t sourceType)
298 {
299 string querySql = QUERY_SETTINGS_BY_PATH + "\"" + tonePath + "\"";
300 auto ret = TravelQueryResultSet(querySql, [&](shared_ptr<RingtoneMetadata> &meta) -> bool {
301 string updateSql = {};
302 if (settingType == TONE_SETTING_TYPE_SHOT) {
303 // update shot-tone settings
304 if (UpdateShotSetting(meta, toneType, sourceType) != E_OK) {
305 return false;
306 }
307 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
308 // update ring-tone settings
309 if (UpdateRingtoneSetting(meta, toneType, sourceType) != E_OK) {
310 return false;
311 }
312 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
313 // update notification-tone settings
314 if (UpdateNotificationSetting(meta, toneType, sourceType) != E_OK) {
315 return false;
316 }
317 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
318 // update alarm-tone settings
319 if (UpdateAlarmSetting(meta, toneType, sourceType) != E_OK) {
320 return false;
321 }
322 } else {
323 RINGTONE_INFO_LOG("invalid tone-setting-type");
324 return false;
325 }
326 return true;
327 });
328
329 return ret;
330 }
331
UpdateSettingsWithToneId(int32_t settingType,int32_t toneId,int32_t toneType)332 int32_t RingtoneSettingManager::UpdateSettingsWithToneId(int32_t settingType, int32_t toneId, int32_t toneType)
333 {
334 int32_t ret = E_OK;
335
336 string updateSql = {};
337 if (settingType == TONE_SETTING_TYPE_SHOT) {
338 // update shot-tone settings
339 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " = " +
340 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
341 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
342 // update ring-tone settings
343 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_RING_TONE_TYPE + " = " +
344 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
345 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
346 // update notification-tone settings
347 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = " +
348 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
349 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
350 // update alarm-tone settings
351 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " +
352 to_string(toneType) + " WHERE " + RINGTONE_COLUMN_TONE_ID + " = " + to_string(toneId);
353 } else {
354 RINGTONE_INFO_LOG("invalid tone-setting-type");
355 return E_INVALID_ARGUMENTS;
356 }
357 if (!updateSql.empty()) {
358 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
359 if (rdbRet < 0) {
360 RINGTONE_ERR_LOG("execute update failed");
361 ret = E_DB_FAIL;
362 }
363 }
364 return ret;
365 }
366
367 static const string SHOT_SETTING_CLEANUP_CLAUSE = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " = " +
368 to_string(SHOT_TONE_TYPE_DEFAULT) + ", " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " +
369 to_string(SHOT_TONE_SOURCE_TYPE_DEFAULT);
370
371 static const string RINGTONE_SETTING_CLEANUP_CLAUSE = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_RING_TONE_TYPE + " = " +
372 to_string(RING_TONE_TYPE_DEFAULT) + ", " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + "=" +
373 to_string(RING_TONE_SOURCE_TYPE_DEFAULT);
374
CleanupSettingFromRdb(int32_t settingType,int32_t toneType,int32_t sourceType)375 int32_t RingtoneSettingManager::CleanupSettingFromRdb(int32_t settingType, int32_t toneType, int32_t sourceType)
376 {
377 int32_t ret = E_OK;
378 string updateSql = {};
379 if (settingType == TONE_SETTING_TYPE_SHOT) {
380 if (toneType == SHOT_TONE_TYPE_SIM_CARD_BOTH) {
381 updateSql = SHOT_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " <> " +
382 to_string(SHOT_TONE_TYPE_DEFAULT) + " AND " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " +
383 to_string(sourceType);
384 } else {
385 updateSql = SHOT_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_SHOT_TONE_TYPE + " = " +
386 to_string(toneType) + " AND " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " + to_string(sourceType);
387 }
388 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
389 if (toneType == RING_TONE_TYPE_SIM_CARD_BOTH) {
390 updateSql = RINGTONE_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_RING_TONE_TYPE + " <> " +
391 to_string(RING_TONE_TYPE_DEFAULT) + " AND " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " +
392 to_string(sourceType);
393 } else {
394 updateSql = RINGTONE_SETTING_CLEANUP_CLAUSE + " WHERE " + RINGTONE_COLUMN_RING_TONE_TYPE + " = " +
395 to_string(toneType) + " AND " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " +
396 to_string(sourceType);
397 }
398 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
399 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = " +
400 to_string(NOTIFICATION_TONE_TYPE_NOT) + ", " + RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " +
401 to_string(NOTIFICATION_TONE_SOURCE_TYPE_DEFAULT) + " WHERE " + RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE +
402 " = " + to_string(toneType) + " AND " + RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " +
403 to_string(sourceType);
404 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
405 updateSql = "UPDATE ToneFiles SET " + RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " +
406 to_string(ALARM_TONE_TYPE_NOT) + ", " + RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " +
407 to_string(ALARM_TONE_SOURCE_TYPE_DEFAULT) + " WHERE " + RINGTONE_COLUMN_ALARM_TONE_TYPE + " = " +
408 to_string(toneType) + " AND " + RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " +
409 to_string(sourceType);
410 } else {
411 return E_INVALID_ARGUMENTS;
412 }
413 if (!updateSql.empty()) {
414 int32_t rdbRet = ringtoneRdb_->ExecuteSql(updateSql);
415 if (rdbRet < 0) {
416 RINGTONE_ERR_LOG("execute update failed");
417 ret = E_DB_FAIL;
418 }
419 }
420 return ret;
421 }
422
CleanupSetting(int32_t settingType,int32_t toneType,int32_t sourceType)423 int32_t RingtoneSettingManager::CleanupSetting(int32_t settingType, int32_t toneType, int32_t sourceType)
424 {
425 if (ringtoneRdb_ == nullptr) {
426 RINGTONE_ERR_LOG("ringtone rdb_ is nullptr");
427 return E_DB_FAIL;
428 }
429
430 string querySql = {};
431 if (settingType == TONE_SETTING_TYPE_SHOT) {
432 querySql = QUERY_SHOTTONE_SETTINGS_SQL + " AND " + RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = " +
433 to_string(sourceType);
434 } else if (settingType == TONE_SETTING_TYPE_ALARM) {
435 querySql = QUERY_ALARMTONE_SETTINGS_SQL + " AND " + RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = " +
436 to_string(sourceType);
437 } else if (settingType == TONE_SETTING_TYPE_NOTIFICATION) {
438 querySql = QUERY_NOTIFICATIONTONE_SETTINGS_SQL + " AND " +
439 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = " + to_string(sourceType);
440 } else if (settingType == TONE_SETTING_TYPE_RINGTONE) {
441 querySql = QUERY_RINGTONE_SETTINGS_SQL + " AND " + RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = " +
442 to_string(sourceType);
443 } else {
444 RINGTONE_ERR_LOG("setting type is not existing");
445 return E_INVALID_ARGUMENTS;
446 }
447
448 TravelQueryResultSet(querySql, [&](shared_ptr<RingtoneMetadata> &meta) -> bool {
449 int32_t ret = true;
450 if ((settingType == TONE_SETTING_TYPE_SHOT) && (toneType != SHOT_TONE_TYPE_SIM_CARD_BOTH) &&
451 (meta->GetShotToneType() == SHOT_TONE_TYPE_SIM_CARD_BOTH)) {
452 int32_t cleanType = (toneType == SHOT_TONE_TYPE_SIM_CARD_1 ? SHOT_TONE_TYPE_SIM_CARD_2 :
453 SHOT_TONE_TYPE_SIM_CARD_1);
454 UpdateSettingsWithToneId(settingType, meta->GetToneId(), cleanType);
455 } else if ((settingType == TONE_SETTING_TYPE_RINGTONE) && (toneType != RING_TONE_TYPE_SIM_CARD_BOTH) &&
456 (meta->GetRingToneType() == RING_TONE_TYPE_SIM_CARD_BOTH)) {
457 int32_t cleanType = (toneType == RING_TONE_TYPE_SIM_CARD_1 ? RING_TONE_TYPE_SIM_CARD_2 :
458 RING_TONE_TYPE_SIM_CARD_1);
459 UpdateSettingsWithToneId(settingType, meta->GetToneId(), cleanType);
460 } else {
461 ret = false;
462 }
463
464 return ret;
465 });
466
467 return CleanupSettingFromRdb(settingType, toneType, sourceType);
468 }
469
TravelQueryResultSet(string querySql,function<bool (shared_ptr<RingtoneMetadata> &)> func)470 int32_t RingtoneSettingManager::TravelQueryResultSet(string querySql,
471 function<bool (shared_ptr<RingtoneMetadata> &)> func)
472 {
473 auto resultSet = ringtoneRdb_->QuerySql(querySql);
474 if (resultSet == nullptr) {
475 RINGTONE_INFO_LOG("result is null");
476 return E_OK;
477 }
478 vector<shared_ptr<RingtoneMetadata>> metaDatas = {};
479 int32_t ret = GetMetaDataFromResultSet(resultSet, metaDatas);
480 if (ret != E_OK) {
481 RINGTONE_INFO_LOG("read resultSet error");
482 resultSet->Close();
483 return E_DB_FAIL;
484 }
485 for (auto meta : metaDatas) {
486 if (func(meta) == true) {
487 break;
488 }
489 }
490
491 resultSet->Close();
492 return E_OK;
493 }
494
Update(int & changedRows,const NativeRdb::ValuesBucket & values,const NativeRdb::AbsRdbPredicates & predicates)495 int32_t RingtoneSettingManager::Update(int &changedRows, const NativeRdb::ValuesBucket &values,
496 const NativeRdb::AbsRdbPredicates &predicates)
497 {
498 if (ringtoneRdb_ == nullptr) {
499 RINGTONE_ERR_LOG("ringtone rdb_ is nullptr");
500 return E_DB_FAIL;
501 }
502 return ringtoneRdb_->Update(changedRows, values, predicates);
503 }
504
505 } // namespace Media
506 } // namespace OHOS
507