• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023 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 "system_sound_manager_impl.h"
17 
18 #include <fstream>
19 
20 #include "config_policy_utils.h"
21 #include "file_ex.h"
22 #include "nlohmann/json.hpp"
23 
24 #include "media_log.h"
25 #include "media_errors.h"
26 #include "ringtone_player_impl.h"
27 #include "system_tone_player_impl.h"
28 
29 using namespace std;
30 using namespace nlohmann;
31 using namespace OHOS::AbilityRuntime;
32 using namespace OHOS::DataShare;
33 
34 namespace {
35 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO_NAPI, "SystemSoundManagerImpl"};
36 }
37 
38 namespace OHOS {
39 namespace Media {
40 const std::string RING_TONE = "ring_tone";
41 const std::string SYSTEM_TONE = "system_tone";
42 const std::string DEFAULT_SYSTEM_SOUND_PATH = "resource/media/audio/";
43 const std::string DEFAULT_RINGTONE_URI_JSON = "ringtone_incall.json";
44 const std::string DEFAULT_RINGTONE_PATH = "ringtones/";
45 const std::string DEFAULT_SYSTEM_TONE_URI_JSON = "ringtone_sms-notification.json";
46 const std::string DEFAULT_SYSTEM_TONE_PATH = "notifications/";
47 const int STORAGE_MANAGER_MANAGER_ID = 5003;
48 const int TYPEERROR = -2;
49 const int ERROR = -1;
50 const int SUCCESS = 0;
51 
52 std::shared_ptr<SystemSoundManager> SystemSoundManagerFactory::systemSoundManager_ = nullptr;
53 std::mutex SystemSoundManagerFactory::systemSoundManagerMutex_;
54 std::unordered_map<RingtoneType, RingToneType> ringtoneTypeMap_;
55 std::unordered_map<int32_t, ToneCustomizedType> sourceTypeMap_;
56 std::unordered_map<SystemToneType, int32_t> systemTypeMap_;
57 std::unordered_map<SystemToneType, ShotToneType> shotToneTypeMap_;
58 Uri RINGTONEURI(RINGTONE_PATH_URI);
59 vector<string> COLUMNS = {{RINGTONE_COLUMN_TONE_ID}, {RINGTONE_COLUMN_DATA}, {RINGTONE_COLUMN_DISPLAY_NAME},
60     {RINGTONE_COLUMN_TITLE}, {RINGTONE_COLUMN_TONE_TYPE}, {RINGTONE_COLUMN_SOURCE_TYPE},
61     {RINGTONE_COLUMN_SHOT_TONE_TYPE}, {RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE},
62     {RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_RING_TONE_TYPE},
63     {RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_ALARM_TONE_TYPE},
64     {RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE}};
65 std::vector<std::string> RINGTONETYPE = {{RINGTONE_CONTAINER_TYPE_MP3}, {RINGTONE_CONTAINER_TYPE_OGG},
66     {RINGTONE_CONTAINER_TYPE_AC3}, {RINGTONE_CONTAINER_TYPE_AAC}, {RINGTONE_CONTAINER_TYPE_FLAC},
67     {RINGTONE_CONTAINER_TYPE_WAV}};
68 
CreateSystemSoundManager()69 std::shared_ptr<SystemSoundManager> SystemSoundManagerFactory::CreateSystemSoundManager()
70 {
71     std::lock_guard<std::mutex> lock(systemSoundManagerMutex_);
72     if (systemSoundManager_ == nullptr) {
73         systemSoundManager_ = std::make_shared<SystemSoundManagerImpl>();
74     }
75     CHECK_AND_RETURN_RET_LOG(systemSoundManager_ != nullptr, nullptr, "Failed to create sound manager object");
76     return systemSoundManager_;
77 }
78 
CreateDataShareHelper(int32_t systemAbilityId)79 static shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId)
80 {
81     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
82     if (saManager == nullptr) {
83         MEDIA_LOGE("Get system ability manager failed.");
84         return nullptr;
85     }
86     auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
87     if (remoteObj == nullptr) {
88         MEDIA_LOGE("Get system ability:[%{public}d] failed.", systemAbilityId);
89         return nullptr;
90     }
91     return DataShare::DataShareHelper::Creator(remoteObj, RINGTONE_URI);
92 }
93 
SystemSoundManagerImpl()94 SystemSoundManagerImpl::SystemSoundManagerImpl()
95 {
96     InitDefaultUriMap();
97     InitRingerMode();
98     InitMap();
99 }
100 
~SystemSoundManagerImpl()101 SystemSoundManagerImpl::~SystemSoundManagerImpl()
102 {
103     if (audioGroupManager_ != nullptr) {
104         (void)audioGroupManager_->UnsetRingerModeCallback(getpid(), ringerModeCallback_);
105         ringerModeCallback_ = nullptr;
106         audioGroupManager_ = nullptr;
107     }
108 }
109 
InitMap(void)110 void SystemSoundManagerImpl::InitMap(void)
111 {
112     ringtoneTypeMap_[RINGTONE_TYPE_SIM_CARD_0] = RING_TONE_TYPE_SIM_CARD_1;
113     ringtoneTypeMap_[RINGTONE_TYPE_SIM_CARD_1] = RING_TONE_TYPE_SIM_CARD_2;
114     sourceTypeMap_[SOURCE_TYPE_PRESET] = PRE_INSTALLED;
115     sourceTypeMap_[SOURCE_TYPE_CUSTOMISED] = CUSTOMISED;
116     systemTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] = SHOT_TONE_TYPE_SIM_CARD_1;
117     systemTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] = SHOT_TONE_TYPE_SIM_CARD_2;
118     systemTypeMap_[SYSTEM_TONE_TYPE_NOTIFICATION] = NOTIFICATION_TONE_TYPE;
119     shotToneTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] = SHOT_TONE_TYPE_SIM_CARD_1;
120     shotToneTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] = SHOT_TONE_TYPE_SIM_CARD_2;
121 }
122 
InitRingerMode(void)123 void SystemSoundManagerImpl::InitRingerMode(void)
124 {
125     audioGroupManager_ = AudioStandard::AudioSystemManager::GetInstance()->
126         GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
127     if (audioGroupManager_ == nullptr) {
128         MEDIA_LOGE("InitRingerMode: audioGroupManager_ is nullptr");
129         return;
130     }
131     ringerMode_ = audioGroupManager_->GetRingerMode();
132 
133     ringerModeCallback_ = std::make_shared<RingerModeCallbackImpl>(*this);
134     audioGroupManager_->SetRingerModeCallback(getpid(), ringerModeCallback_);
135 }
136 
isRingtoneTypeValid(RingtoneType ringtongType)137 bool SystemSoundManagerImpl::isRingtoneTypeValid(RingtoneType ringtongType)
138 {
139     switch (ringtongType) {
140         case RINGTONE_TYPE_SIM_CARD_0:
141         case RINGTONE_TYPE_SIM_CARD_1:
142             return true;
143         default:
144             MEDIA_LOGE("isRingtoneTypeValid: ringtongType %{public}d is unavailable", ringtongType);
145             return false;
146     }
147 }
148 
isSystemToneTypeValid(SystemToneType systemToneType)149 bool SystemSoundManagerImpl::isSystemToneTypeValid(SystemToneType systemToneType)
150 {
151     switch (systemToneType) {
152         case SYSTEM_TONE_TYPE_SIM_CARD_0:
153         case SYSTEM_TONE_TYPE_SIM_CARD_1:
154         case SYSTEM_TONE_TYPE_NOTIFICATION:
155             return true;
156         default:
157             MEDIA_LOGE("isSystemToneTypeValid: systemToneType %{public}d is unavailable", systemToneType);
158             return false;
159     }
160 }
161 
InitDefaultUriMap()162 void SystemSoundManagerImpl::InitDefaultUriMap()
163 {
164     systemSoundPath_ = GetFullPath(DEFAULT_SYSTEM_SOUND_PATH);
165 
166     std::string ringtoneJsonPath = systemSoundPath_ + DEFAULT_RINGTONE_URI_JSON;
167     InitDefaultRingtoneUriMap(ringtoneJsonPath);
168 
169     std::string systemToneJsonPath = systemSoundPath_ + DEFAULT_SYSTEM_TONE_URI_JSON;
170     InitDefaultSystemToneUriMap(systemToneJsonPath);
171 }
172 
InitDefaultRingtoneUriMap(const std::string & ringtoneJsonPath)173 void SystemSoundManagerImpl::InitDefaultRingtoneUriMap(const std::string &ringtoneJsonPath)
174 {
175     std::lock_guard<std::mutex> lock(uriMutex_);
176 
177     std::string jsonValue = GetJsonValue(ringtoneJsonPath);
178     nlohmann::json ringtoneJson = json::parse(jsonValue, nullptr, false);
179     if (ringtoneJson.is_discarded()) {
180         MEDIA_LOGE("ringtoneJson parsing is false !");
181         return;
182     }
183     if (ringtoneJson.contains("preset_ringtone_sim1") && ringtoneJson["preset_ringtone_sim1"].is_string()) {
184         std::string defaultRingtoneName = ringtoneJson["preset_ringtone_sim1"];
185         defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_0] =
186             systemSoundPath_ + DEFAULT_RINGTONE_PATH + defaultRingtoneName + ".ogg";
187         MEDIA_LOGI("preset_ringtone_sim1 is [%{public}s]", defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_0].c_str());
188     } else {
189         defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_0] = "";
190         MEDIA_LOGW("InitDefaultRingtoneUriMap: failed to load uri of preset_ringtone_sim1");
191     }
192     if (ringtoneJson.contains("preset_ringtone_sim2") && ringtoneJson["preset_ringtone_sim2"].is_string()) {
193         std::string defaultRingtoneName = ringtoneJson["preset_ringtone_sim2"];
194         defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_1] =
195             systemSoundPath_ + DEFAULT_RINGTONE_PATH + defaultRingtoneName + ".ogg";
196         MEDIA_LOGI("preset_ringtone_sim1 is [%{public}s]", defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_1].c_str());
197     } else {
198         defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_1] = "";
199         MEDIA_LOGW("InitDefaultRingtoneUriMap: failed to load uri of preset_ringtone_sim2");
200     }
201 }
202 
GetDefaultRingtoneUri(RingtoneType ringtoneType)203 std::string SystemSoundManagerImpl::GetDefaultRingtoneUri(RingtoneType ringtoneType)
204 {
205     std::lock_guard<std::mutex> lock(uriMutex_);
206     if (defaultRingtoneUriMap_.count(ringtoneType) == 0) {
207         MEDIA_LOGE("Failed to GetDefaultRingtoneUri: invalid ringtone type %{public}d", ringtoneType);
208         return "";
209     }
210     return defaultRingtoneUriMap_[ringtoneType];
211 }
212 
GetDefaultSystemToneUri(SystemToneType systemToneType)213 std::string SystemSoundManagerImpl::GetDefaultSystemToneUri(SystemToneType systemToneType)
214 {
215     std::lock_guard<std::mutex> lock(uriMutex_);
216     if (defaultSystemToneUriMap_.count(systemToneType) == 0) {
217         MEDIA_LOGE("Failed to GetDefaultRingtoneUri: invalid system tone type %{public}d", systemToneType);
218         return "";
219     }
220     return defaultSystemToneUriMap_[systemToneType];
221 }
222 
InitDefaultSystemToneUriMap(const std::string & systemToneJsonPath)223 void SystemSoundManagerImpl::InitDefaultSystemToneUriMap(const std::string &systemToneJsonPath)
224 {
225     std::lock_guard<std::mutex> lock(uriMutex_);
226 
227     std::string jsonValue = GetJsonValue(systemToneJsonPath);
228     nlohmann::json systemToneJson = json::parse(jsonValue, nullptr, false);
229     if (systemToneJson.is_discarded()) {
230         MEDIA_LOGE("systemToneJson parsing is false !");
231         return;
232     }
233     if (systemToneJson.contains("preset_ringtone_sms") && systemToneJson["preset_ringtone_sms"].is_string()) {
234         std::string defaultSystemToneName = systemToneJson["preset_ringtone_sms"];
235         defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] =
236             systemSoundPath_ + DEFAULT_SYSTEM_TONE_PATH + defaultSystemToneName + ".ogg";
237         defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] =
238             systemSoundPath_ + DEFAULT_SYSTEM_TONE_PATH + defaultSystemToneName + ".ogg";
239         MEDIA_LOGI("preset_ringtone_sms is [%{public}s]",
240             defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_0].c_str());
241     } else {
242         defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] = "";
243         defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] = "";
244         MEDIA_LOGW("InitDefaultSystemToneUriMap: failed to load uri of preset_ringtone_sms");
245     }
246     if (systemToneJson.contains("preset_ringtone_notification") &&
247         systemToneJson["preset_ringtone_notification"].is_string()) {
248         std::string defaultSystemToneName = systemToneJson["preset_ringtone_notification"];
249         defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_NOTIFICATION] =
250             systemSoundPath_ + DEFAULT_SYSTEM_TONE_PATH + defaultSystemToneName + ".ogg";
251         MEDIA_LOGI("preset_ringtone_notification is [%{public}s]",
252             defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_NOTIFICATION].c_str());
253     } else {
254         defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_NOTIFICATION] = "";
255         MEDIA_LOGW("InitDefaultSystemToneUriMap: failed to load uri of preset_ringtone_notification");
256     }
257 }
258 
GetFullPath(const std::string & originalUri)259 std::string SystemSoundManagerImpl::GetFullPath(const std::string &originalUri)
260 {
261     char buf[MAX_PATH_LEN];
262     char *path = GetOneCfgFile(originalUri.c_str(), buf, MAX_PATH_LEN);
263     if (path == nullptr || *path == '\0') {
264         MEDIA_LOGE("GetOneCfgFile for %{public}s failed.", originalUri.c_str());
265         return "";
266     }
267     std::string filePath = path;
268     MEDIA_LOGI("GetFullPath for [%{public}s], result: [%{public}s]", originalUri.c_str(), filePath.c_str());
269     return filePath;
270 }
271 
GetJsonValue(const std::string & jsonPath)272 std::string SystemSoundManagerImpl::GetJsonValue(const std::string &jsonPath)
273 {
274     std::string jsonValue = "";
275     ifstream file(jsonPath.c_str());
276     if (!file.is_open()) {
277         MEDIA_LOGI("file not open! try open first ! ");
278         file.open(jsonPath.c_str(), ios::app);
279         if (!file.is_open()) {
280             MEDIA_LOGE("open file again fail !");
281             return "";
282         }
283     }
284     file.seekg(0, ios::end);
285 
286     const long maxFileLength = 32 * 1024 * 1024; // max size of the json file
287     const long fileLength = file.tellg();
288     if (fileLength > maxFileLength) {
289         MEDIA_LOGE("invalid file length(%{public}ld)!", fileLength);
290         return "";
291     }
292 
293     jsonValue.clear();
294     file.seekg(0, ios::beg);
295     copy(istreambuf_iterator<char>(file), istreambuf_iterator<char>(), back_inserter(jsonValue));
296     return jsonValue;
297 }
298 
WriteUriToDatabase(const std::string & key,const std::string & uri)299 int32_t SystemSoundManagerImpl::WriteUriToDatabase(const std::string &key, const std::string &uri)
300 {
301     int32_t result = AudioStandard::AudioSystemManager::GetInstance()->SetSystemSoundUri(key, uri);
302     MEDIA_LOGI("WriteUriToDatabase: key: %{public}s, uri: %{public}s, result: %{public}d",
303         key.c_str(), uri.c_str(), result);
304     return result;
305 }
306 
GetUriFromDatabase(const std::string & key)307 std::string SystemSoundManagerImpl::GetUriFromDatabase(const std::string &key)
308 {
309     std::string uri = AudioStandard::AudioSystemManager::GetInstance()->GetSystemSoundUri(key);
310 
311     MEDIA_LOGI("GetUriFromDatabase: key [%{public}s], uri [%{public}s]", key.c_str(), uri.c_str());
312     return uri;
313 }
314 
GetKeyForDatabase(const std::string & systemSoundType,int32_t type)315 std::string SystemSoundManagerImpl::GetKeyForDatabase(const std::string &systemSoundType, int32_t type)
316 {
317     if (systemSoundType == RING_TONE) {
318         switch (static_cast<RingtoneType>(type)) {
319             case RINGTONE_TYPE_SIM_CARD_0:
320                 return "ringtone_for_sim_card_0";
321             case RINGTONE_TYPE_SIM_CARD_1:
322                 return "ringtone_for_sim_card_1";
323             default:
324                 MEDIA_LOGE("GetKeyForDatabase: ringtoneType %{public}d is unavailable", type);
325                 return "";
326         }
327     } else if (systemSoundType == SYSTEM_TONE) {
328         switch (static_cast<SystemToneType>(type)) {
329             case SYSTEM_TONE_TYPE_SIM_CARD_0:
330                 return "system_tone_for_sim_card_0";
331             case SYSTEM_TONE_TYPE_SIM_CARD_1:
332                 return "system_tone_for_sim_card_1";
333             case SYSTEM_TONE_TYPE_NOTIFICATION:
334                 return "system_tone_for_notification";
335             default:
336                 MEDIA_LOGE("GetKeyForDatabase: systemToneType %{public}d is unavailable", type);
337                 return "";
338         }
339     } else {
340         MEDIA_LOGE("GetKeyForDatabase: systemSoundType %{public}s is unavailable", systemSoundType.c_str());
341         return "";
342     }
343 }
344 
UpdateRingtoneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const int32_t & toneId,RingtoneType ringtoneType,const int32_t & num)345 int32_t SystemSoundManagerImpl::UpdateRingtoneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
346     const int32_t &toneId, RingtoneType ringtoneType, const int32_t &num)
347 {
348     RingToneType type = RING_TONE_TYPE_SIM_CARD_1;
349     DataSharePredicates updateOnlyPredicates;
350     DataShareValuesBucket updateOnlyValuesBucket;
351     updateOnlyPredicates.SetWhereClause(RINGTONE_COLUMN_RING_TONE_TYPE + " = ? AND " +
352         RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = ? ");
353     updateOnlyPredicates.SetWhereArgs({to_string(ringtoneTypeMap_[ringtoneType]),
354         to_string(SOURCE_TYPE_CUSTOMISED)});
355     updateOnlyValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_TYPE, RING_TONE_TYPE_NOT);
356     updateOnlyValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
357     dataShareHelper->Update(RINGTONEURI, updateOnlyPredicates, updateOnlyValuesBucket);
358 
359     DataSharePredicates updateBothPredicates;
360     DataShareValuesBucket updateBothValuesBucket;
361     if (ringtoneTypeMap_[ringtoneType] == RING_TONE_TYPE_SIM_CARD_1) {
362         type = RING_TONE_TYPE_SIM_CARD_2;
363     }
364     updateBothPredicates.SetWhereClause(RINGTONE_COLUMN_RING_TONE_TYPE + " = ? AND " +
365         RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = ? ");
366     updateBothPredicates.SetWhereArgs({to_string(RING_TONE_TYPE_SIM_CARD_BOTH),
367         to_string(SOURCE_TYPE_CUSTOMISED)});
368     updateBothValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_TYPE, type);
369     dataShareHelper->Update(RINGTONEURI, updateBothPredicates, updateBothValuesBucket);
370 
371     DataSharePredicates updatePredicates;
372     DataShareValuesBucket updateValuesBucket;
373     if (((num == RING_TONE_TYPE_SIM_CARD_1 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
374         (ringtoneTypeMap_[ringtoneType] == RING_TONE_TYPE_SIM_CARD_2)) ||
375         ((num == RING_TONE_TYPE_SIM_CARD_2 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
376         (ringtoneTypeMap_[ringtoneType] == RING_TONE_TYPE_SIM_CARD_1))) {
377         type = RING_TONE_TYPE_SIM_CARD_BOTH;
378     } else {
379         type = ringtoneTypeMap_[ringtoneType];
380     }
381     updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
382     updatePredicates.SetWhereArgs({to_string(toneId)});
383     updateValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_TYPE, type);
384     updateValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
385     return dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
386 }
387 
SetRingtoneUri(const shared_ptr<Context> & context,const string & uri,RingtoneType ringtoneType)388 int32_t SystemSoundManagerImpl::SetRingtoneUri(const shared_ptr<Context> &context, const string &uri,
389     RingtoneType ringtoneType)
390 {
391     std::lock_guard<std::mutex> lock(uriMutex_);
392     CHECK_AND_RETURN_RET_LOG(isRingtoneTypeValid(ringtoneType), MSERR_INVALID_VAL, "Invalid ringtone type");
393 
394     MEDIA_LOGI("SetRingtoneUri: ringtoneType %{public}d, uri %{public}s", ringtoneType, uri.c_str());
395     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
396     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
397         "Create dataShare failed, datashare or ringtone library error.");
398     DataShare::DatashareBusinessError businessError;
399     DataShare::DataSharePredicates queryPredicates;
400     DataShare::DataSharePredicates queryPredicatesByUri;
401     queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
402     auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
403     auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
404     unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
405     if (ringtoneAssetByUri == nullptr) {
406         resultSetByUri == nullptr ? : resultSetByUri->Close();
407         dataShareHelper->Release();
408         return ERROR;
409     }
410     resultSetByUri == nullptr ? : resultSetByUri->Close();
411     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_RINGTONE);
412     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
413     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
414     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
415     while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
416         ringtoneAsset = results->GetNextObject();
417     }
418     if (ringtoneAsset != nullptr) {
419         int32_t changedRows = UpdateRingtoneUri(dataShareHelper, ringtoneAsset->GetId(),
420             ringtoneType, ringtoneAsset->GetRingtoneType());
421         resultSet == nullptr ? : resultSet->Close();
422         return changedRows > 0 ? SUCCESS : ERROR;
423     }
424     resultSet == nullptr ? : resultSet->Close();
425     dataShareHelper->Release();
426     return TYPEERROR;
427 }
428 
GetRingtoneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & type)429 std::string SystemSoundManagerImpl::GetRingtoneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
430     const std::string &type)
431 {
432     std::string uri = "";
433     DataShare::DatashareBusinessError businessError;
434     DataShare::DataSharePredicates queryPredicates;
435     queryPredicates.SetWhereClause(RINGTONE_COLUMN_RING_TONE_TYPE + " = ? AND " +
436         RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = ? ");
437     queryPredicates.SetWhereArgs({type, to_string(SOURCE_TYPE_CUSTOMISED)});
438     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
439     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
440     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
441     if (ringtoneAsset != nullptr) {
442         uri = ringtoneAsset->GetPath();
443     }
444     resultSet == nullptr ? : resultSet->Close();
445     return uri;
446 }
447 
GetRingtoneUri(const shared_ptr<Context> & context,RingtoneType ringtoneType)448 std::string SystemSoundManagerImpl::GetRingtoneUri(const shared_ptr<Context> &context, RingtoneType ringtoneType)
449 {
450     CHECK_AND_RETURN_RET_LOG(isRingtoneTypeValid(ringtoneType), "", "Invalid ringtone type");
451     std::string ringtoneUri = "";
452     MEDIA_LOGI("GetRingtoneUri: ringtoneType %{public}d", ringtoneType);
453     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
454     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, "",
455         "Create dataShare failed, datashare or ringtone library error.");
456     ringtoneUri = GetRingtoneUriByType(dataShareHelper, to_string(ringtoneTypeMap_[ringtoneType]));
457     if (ringtoneUri.empty()) {
458         ringtoneUri = GetRingtoneUriByType(dataShareHelper, to_string(RING_TONE_TYPE_SIM_CARD_BOTH));
459     }
460     if (ringtoneUri.empty()) {
461         std::shared_ptr<ToneAttrs> ringtoneAttrs = GetDefaultRingtoneAttrs(context, ringtoneType);
462         if (ringtoneAttrs != nullptr) {
463             ringtoneUri = ringtoneAttrs ->GetUri();
464         } else {
465             MEDIA_LOGE("GetRingtoneUri: no ringtone in the ringtone library!");
466         }
467     }
468     dataShareHelper->Release();
469     if (!ringtoneUri.empty()) {
470         MEDIA_LOGI("GetRingtoneUri: ringtoneUri %{public}s", ringtoneUri.c_str());
471     }
472     return ringtoneUri;
473 }
474 
GetRingtoneTitle(const std::string & ringtoneUri)475 std::string SystemSoundManagerImpl::GetRingtoneTitle(const std::string &ringtoneUri)
476 {
477     std::lock_guard<std::mutex> lock(uriMutex_);
478     std::string ringtoneTitle = "";
479     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
480     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ringtoneUri,
481         "Create dataShare failed, datashare or ringtone library error.");
482     DataShare::DatashareBusinessError businessError;
483     DataShare::DataSharePredicates queryPredicatesByUri;
484     queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, ringtoneUri);
485     auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
486     auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
487     unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
488     if (ringtoneAssetByUri != nullptr) {
489         ringtoneTitle = ringtoneAssetByUri->GetTitle();
490     }
491     resultSetByUri == nullptr ? : resultSetByUri->Close();
492     dataShareHelper->Release();
493     return ringtoneTitle;
494 }
495 
GetRingtonePlayer(const shared_ptr<Context> & context,RingtoneType ringtoneType)496 std::shared_ptr<RingtonePlayer> SystemSoundManagerImpl::GetRingtonePlayer(const shared_ptr<Context> &context,
497     RingtoneType ringtoneType)
498 {
499     std::lock_guard<std::mutex> lock(playerMutex_);
500     CHECK_AND_RETURN_RET_LOG(isRingtoneTypeValid(ringtoneType), nullptr, "invalid ringtone type");
501     MEDIA_LOGI("GetRingtonePlayer: for ringtoneType %{public}d", ringtoneType);
502 
503     std::shared_ptr<RingtonePlayer> ringtonePlayer = std::make_shared<RingtonePlayerImpl>(context, *this, ringtoneType);
504     CHECK_AND_RETURN_RET_LOG(ringtonePlayer != nullptr, nullptr,
505         "Failed to create ringtone player object");
506     return ringtonePlayer;
507 }
508 
GetSystemTonePlayer(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)509 std::shared_ptr<SystemTonePlayer> SystemSoundManagerImpl::GetSystemTonePlayer(
510     const std::shared_ptr<AbilityRuntime::Context> &context, SystemToneType systemToneType)
511 {
512     std::lock_guard<std::mutex> lock(playerMutex_);
513     CHECK_AND_RETURN_RET_LOG(isSystemToneTypeValid(systemToneType), nullptr, "invalid system tone type");
514     MEDIA_LOGI("GetSystemTonePlayer: for systemToneType %{public}d", systemToneType);
515 
516     std::shared_ptr<SystemTonePlayer> systemTonePlayer =
517         std::make_shared<SystemTonePlayerImpl>(context, *this, systemToneType);
518     CHECK_AND_RETURN_RET_LOG(systemTonePlayer != nullptr, nullptr,
519         "Failed to create system tone player object");
520     return systemTonePlayer;
521 }
522 
UpdateShotToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const int32_t & toneId,SystemToneType systemToneType,const int32_t & num)523 int32_t SystemSoundManagerImpl::UpdateShotToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
524     const int32_t &toneId, SystemToneType systemToneType, const int32_t &num)
525 {
526     ShotToneType type = SHOT_TONE_TYPE_SIM_CARD_1;
527     DataSharePredicates updateOnlyPredicates;
528     DataShareValuesBucket updateOnlyValuesBucket;
529     updateOnlyPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
530         RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
531     updateOnlyPredicates.SetWhereArgs({to_string(systemTypeMap_[systemToneType]),
532         to_string(SOURCE_TYPE_CUSTOMISED)});
533     updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, RING_TONE_TYPE_NOT);
534     updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
535     dataShareHelper->Update(RINGTONEURI, updateOnlyPredicates, updateOnlyValuesBucket);
536 
537     DataSharePredicates updateBothPredicates;
538     DataShareValuesBucket updateBothValuesBucket;
539     if (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_1) {
540         type = SHOT_TONE_TYPE_SIM_CARD_2;
541     }
542     updateBothPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
543         RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
544     updateBothPredicates.SetWhereArgs({to_string(SHOT_TONE_TYPE_SIM_CARD_BOTH),
545         to_string(SOURCE_TYPE_CUSTOMISED)});
546     updateBothValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, type);
547     dataShareHelper->Update(RINGTONEURI, updateBothPredicates, updateBothValuesBucket);
548 
549     DataSharePredicates updatePredicates;
550     DataShareValuesBucket updateValuesBucket;
551     if (((num == SHOT_TONE_TYPE_SIM_CARD_1 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
552         (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_2)) ||
553         ((num == SHOT_TONE_TYPE_SIM_CARD_2 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
554         (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_1))) {
555         type = SHOT_TONE_TYPE_SIM_CARD_BOTH;
556     } else {
557         type = shotToneTypeMap_[systemToneType];
558     }
559     updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
560     updatePredicates.SetWhereArgs({to_string(toneId)});
561     updateValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, type);
562     updateValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
563     return dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
564 }
565 
UpdateNotificatioToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const int32_t & toneId)566 int32_t SystemSoundManagerImpl::UpdateNotificatioToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
567     const int32_t &toneId)
568 {
569     DataSharePredicates updateOldPredicates;
570     DataShareValuesBucket updateOldValuesBucket;
571     updateOldPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
572         RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
573     updateOldPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(SOURCE_TYPE_CUSTOMISED)});
574     updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE, NOTIFICATION_TONE_TYPE_NOT);
575     updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
576     dataShareHelper->Update(RINGTONEURI, updateOldPredicates, updateOldValuesBucket);
577 
578     DataSharePredicates updatePredicates;
579     DataShareValuesBucket updateValuesBucket;
580     updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
581     updatePredicates.SetWhereArgs({to_string(toneId)});
582     updateValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE, NOTIFICATION_TONE_TYPE);
583     updateValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
584     return dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
585 }
586 
SetNoSystemToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,SystemToneType systemToneType)587 int32_t SystemSoundManagerImpl::SetNoSystemToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
588     SystemToneType systemToneType)
589 {
590     MEDIA_LOGI("Set no audio uri for system tone type %{public}d", systemToneType);
591     int32_t result = 0;
592     // Removes the flag for the current system tone uri.
593     result += RemoveSourceTypeForSystemTone(dataShareHelper, systemToneType, SOURCE_TYPE_CUSTOMISED);
594     // Removes the flag for the preset system tone uri.
595     result += RemoveSourceTypeForSystemTone(dataShareHelper, systemToneType, SOURCE_TYPE_PRESET);
596     return result;
597 }
598 
RemoveSourceTypeForSystemTone(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,SystemToneType systemToneType,SourceType sourceType)599 int32_t SystemSoundManagerImpl::RemoveSourceTypeForSystemTone(
600     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, SystemToneType systemToneType, SourceType sourceType)
601 {
602     int32_t result = 0;
603     switch (systemToneType) {
604         case SYSTEM_TONE_TYPE_SIM_CARD_0:
605         case SYSTEM_TONE_TYPE_SIM_CARD_1: {
606             // SIM_CARD_0 or SIM_CARD_1
607             DataSharePredicates updateOnlyPredicates;
608             DataShareValuesBucket updateOnlyValuesBucket;
609             updateOnlyPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
610                 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
611             updateOnlyPredicates.SetWhereArgs({to_string(systemTypeMap_[systemToneType]), to_string(sourceType)});
612             updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, RING_TONE_TYPE_NOT);
613             updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
614             result += dataShareHelper->Update(RINGTONEURI, updateOnlyPredicates, updateOnlyValuesBucket);
615             // both SIM_CARD_0 and SIM_CARD_1
616             DataSharePredicates updateBothPredicates;
617             DataShareValuesBucket updateBothValuesBucket;
618             ShotToneType type = SHOT_TONE_TYPE_SIM_CARD_1;
619             if (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_1) {
620                 type = SHOT_TONE_TYPE_SIM_CARD_2;
621             }
622             updateBothPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
623                 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
624             updateBothPredicates.SetWhereArgs({to_string(SHOT_TONE_TYPE_SIM_CARD_BOTH), to_string(sourceType)});
625             updateBothValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, type);
626             result += dataShareHelper->Update(RINGTONEURI, updateBothPredicates, updateBothValuesBucket);
627             break;
628         }
629         case SYSTEM_TONE_TYPE_NOTIFICATION: {
630             DataSharePredicates updateOldPredicates;
631             DataShareValuesBucket updateOldValuesBucket;
632             updateOldPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
633                 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
634             updateOldPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(sourceType)});
635             updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE, NOTIFICATION_TONE_TYPE_NOT);
636             updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
637             result += dataShareHelper->Update(RINGTONEURI, updateOldPredicates, updateOldValuesBucket);
638             break;
639         }
640         default:
641             MEDIA_LOGE("The system tone type [%{public}d] is invalid!", systemToneType);
642             break;
643     }
644     return result;
645 }
646 
SetSystemToneUri(const shared_ptr<Context> & context,const string & uri,SystemToneType systemToneType)647 int32_t SystemSoundManagerImpl::SetSystemToneUri(const shared_ptr<Context> &context, const string &uri,
648     SystemToneType systemToneType)
649 {
650     std::lock_guard<std::mutex> lock(uriMutex_);
651     CHECK_AND_RETURN_RET_LOG(isSystemToneTypeValid(systemToneType), MSERR_INVALID_VAL, "Invalid system tone type");
652 
653     MEDIA_LOGI("SetSystemToneUri: systemToneType %{public}d, uri %{public}s", systemToneType, uri.c_str());
654     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
655     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
656         "Create dataShare failed, datashare or ringtone library error.");
657 
658     if (uri == NO_SYSTEM_SOUND) {
659         int32_t changedRows = SetNoSystemToneUri(dataShareHelper, systemToneType);
660         dataShareHelper->Release();
661         return changedRows > 0 ? SUCCESS : ERROR;
662     }
663 
664     DataShare::DatashareBusinessError businessError;
665     DataShare::DataSharePredicates queryPredicates;
666     DataShare::DataSharePredicates queryPredicatesByUri;
667     queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
668     auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
669     auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
670     unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
671     if (ringtoneAssetByUri == nullptr) {
672         resultSetByUri == nullptr ? : resultSetByUri->Close();
673         dataShareHelper->Release();
674         MEDIA_LOGE("Failed to find the uri in ringtone library!");
675         return ERROR;
676     }
677     resultSetByUri == nullptr ? : resultSetByUri->Close();
678     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_NOTIFICATION);
679     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
680     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
681     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
682     while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
683         ringtoneAsset = results->GetNextObject();
684     }
685     if (ringtoneAsset != nullptr) {
686         int32_t changedRows = 0;
687         if (systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION) {
688             changedRows = UpdateNotificatioToneUri(dataShareHelper, ringtoneAsset->GetId());
689         } else {
690             changedRows = UpdateShotToneUri(dataShareHelper, ringtoneAsset->GetId(),
691                 systemToneType, ringtoneAsset->GetShottoneType());
692         }
693         resultSet == nullptr ? : resultSet->Close();
694         return changedRows > 0 ? SUCCESS : ERROR;
695     }
696     resultSet == nullptr ? : resultSet->Close();
697     dataShareHelper->Release();
698     return TYPEERROR;
699 }
700 
GetShotToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & type)701 std::string SystemSoundManagerImpl::GetShotToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
702     const std::string &type)
703 {
704     std::string uri = "";
705     DataShare::DatashareBusinessError businessError;
706     DataShare::DataSharePredicates queryPredicates;
707     queryPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
708         RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
709     queryPredicates.SetWhereArgs({type, to_string(SOURCE_TYPE_CUSTOMISED)});
710     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
711     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
712     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
713     if (ringtoneAsset != nullptr) {
714         uri = ringtoneAsset->GetPath();
715     }
716     resultSet == nullptr ? : resultSet->Close();
717     return uri;
718 }
719 
GetPresetShotToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & type)720 std::string SystemSoundManagerImpl::GetPresetShotToneUriByType(
721     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, const std::string &type)
722 {
723     std::string uri = "";
724     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, uri,
725         "Invalid dataShare, datashare or ringtone library error.");
726     DataShare::DatashareBusinessError businessError;
727     DataShare::DataSharePredicates queryPredicates;
728     queryPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
729         RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
730     queryPredicates.SetWhereArgs({type, to_string(SOURCE_TYPE_PRESET)});
731     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
732     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
733     CHECK_AND_RETURN_RET_LOG(results != nullptr, uri, "query failed, ringtone library error.");
734     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
735     if (ringtoneAsset != nullptr) {
736         uri = ringtoneAsset->GetPath();
737     }
738     resultSet == nullptr ? : resultSet->Close();
739     return uri;
740 }
741 
GetNotificationToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)742 std::string SystemSoundManagerImpl::GetNotificationToneUriByType(
743     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)
744 {
745     std::string uri = "";
746     DataShare::DatashareBusinessError businessError;
747     DataShare::DataSharePredicates queryPredicates;
748     queryPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
749         RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
750     queryPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(SOURCE_TYPE_CUSTOMISED)});
751     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
752     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
753     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
754     if (ringtoneAsset != nullptr) {
755         uri = ringtoneAsset->GetPath();
756     }
757     resultSet == nullptr ? : resultSet->Close();
758     return uri;
759 }
760 
GetPresetNotificationToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)761 std::string SystemSoundManagerImpl::GetPresetNotificationToneUri(
762     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)
763 {
764     std::string uri = "";
765     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, uri,
766         "Invalid dataShare, datashare or ringtone library error.");
767     DataShare::DatashareBusinessError businessError;
768     DataShare::DataSharePredicates queryPredicates;
769     queryPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
770         RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
771     queryPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(SOURCE_TYPE_PRESET)});
772     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
773     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
774     CHECK_AND_RETURN_RET_LOG(results != nullptr, uri, "query failed, ringtone library error.");
775     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
776     if (ringtoneAsset != nullptr) {
777         uri = ringtoneAsset->GetPath();
778     }
779     resultSet == nullptr ? : resultSet->Close();
780     return uri;
781 }
782 
GetSystemToneUri(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)783 std::string SystemSoundManagerImpl::GetSystemToneUri(const std::shared_ptr<AbilityRuntime::Context> &context,
784     SystemToneType systemToneType)
785 {
786     CHECK_AND_RETURN_RET_LOG(isSystemToneTypeValid(systemToneType), "", "Invalid system tone type");
787     std::string systemToneUri = "";
788     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
789     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, "",
790         "Create dataShare failed, datashare or ringtone library error.");
791     switch (systemToneType) {
792         case SYSTEM_TONE_TYPE_SIM_CARD_0:
793         case SYSTEM_TONE_TYPE_SIM_CARD_1:
794             systemToneUri = GetShotToneUriByType(dataShareHelper, to_string(systemTypeMap_[systemToneType]));
795             if (systemToneUri.empty()) {
796                 systemToneUri = GetShotToneUriByType(dataShareHelper, to_string(RING_TONE_TYPE_SIM_CARD_BOTH));
797             }
798             if (systemToneUri.empty()) {
799                 systemToneUri = GetPresetShotToneUriByType(dataShareHelper, to_string(systemTypeMap_[systemToneType]));
800             }
801             if (systemToneUri.empty()) {
802                 systemToneUri = GetPresetShotToneUriByType(dataShareHelper, to_string(RING_TONE_TYPE_SIM_CARD_BOTH));
803             }
804             break;
805         case SYSTEM_TONE_TYPE_NOTIFICATION:
806             systemToneUri = GetNotificationToneUriByType(dataShareHelper);
807             if (systemToneUri.empty()) {
808                 systemToneUri = GetPresetNotificationToneUri(dataShareHelper);
809             }
810             break;
811         default:
812             break;
813     }
814     if (systemToneUri.empty()) {
815         MEDIA_LOGI("No system tone uri for type %{public}d. Return NO_SYSTEM_SOUND", systemToneType);
816         return NO_SYSTEM_SOUND;
817     }
818     dataShareHelper->Release();
819     MEDIA_LOGI("Finish to get system tone uri: type %{public}d, uri %{public}s", systemToneType, systemToneUri.c_str());
820     return systemToneUri;
821 }
822 
GetDefaultRingtoneAttrs(const shared_ptr<Context> & context,RingtoneType ringtoneType)823 std::shared_ptr<ToneAttrs> SystemSoundManagerImpl::GetDefaultRingtoneAttrs(
824     const shared_ptr<Context> &context, RingtoneType ringtoneType)
825 {
826     std::lock_guard<std::mutex> lock(uriMutex_);
827     CHECK_AND_RETURN_RET_LOG(isRingtoneTypeValid(ringtoneType),  nullptr, "Invalid ringtone type");
828     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
829     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, nullptr,
830         "Create dataShare failed, datashare or ringtone library error.");
831     DataShare::DatashareBusinessError businessError;
832     DataShare::DataSharePredicates queryPredicates;
833     ringtoneAttrs_ = nullptr;
834     queryPredicates.EqualTo(RINGTONE_COLUMN_RING_TONE_TYPE, to_string(ringtoneTypeMap_[ringtoneType]));
835     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
836     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
837     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
838     while ((ringtoneAsset != nullptr) && (SOURCE_TYPE_PRESET != ringtoneAsset->GetSourceType())) {
839         ringtoneAsset = results->GetNextObject();
840     }
841     if (ringtoneAsset != nullptr) {
842         ringtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
843             ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
844             sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_RINGTONE);
845     } else {
846         MEDIA_LOGE("GetDefaultRingtoneAttrs: no single card default ringtone in the ringtone library!");
847     }
848     DataShare::DataSharePredicates queryPredicatesBothCard;
849     queryPredicatesBothCard.EqualTo(RINGTONE_COLUMN_RING_TONE_TYPE, to_string(RING_TONE_TYPE_SIM_CARD_BOTH));
850     resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicatesBothCard, COLUMNS, &businessError);
851     results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
852     unique_ptr<RingtoneAsset> ringtoneAssetBothCard = results->GetFirstObject();
853     while ((ringtoneAssetBothCard != nullptr) &&
854         (SOURCE_TYPE_PRESET != ringtoneAssetBothCard->GetSourceType())) {
855         ringtoneAssetBothCard = results->GetNextObject();
856     }
857     if (ringtoneAssetBothCard != nullptr) {
858         ringtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAssetBothCard->GetTitle(),
859             ringtoneAssetBothCard->GetDisplayName(), ringtoneAssetBothCard->GetPath(),
860             sourceTypeMap_[ringtoneAssetBothCard->GetSourceType()], TONE_CATEGORY_RINGTONE);
861     } else {
862         MEDIA_LOGE("GetDefaultRingtoneAttrs: no both card default ringtone in the ringtone library!");
863     }
864     resultSet == nullptr ? : resultSet->Close();
865     dataShareHelper->Release();
866     return ringtoneAttrs_;
867 }
868 
GetRingtoneAttrList(const std::shared_ptr<AbilityRuntime::Context> & context,RingtoneType ringtoneType)869 std::vector<std::shared_ptr<ToneAttrs>> SystemSoundManagerImpl::GetRingtoneAttrList(
870     const std::shared_ptr<AbilityRuntime::Context> &context, RingtoneType ringtoneType)
871 {
872     std::lock_guard<std::mutex> lock(uriMutex_);
873     ringtoneAttrsArray_.clear();
874     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
875     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ringtoneAttrsArray_,
876         "Create dataShare failed, datashare or ringtone library error.");
877     DataShare::DatashareBusinessError businessError;
878     DataShare::DataSharePredicates queryPredicates;
879     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TONE_TYPE_RINGTONE));
880     queryPredicates.GreaterThan(RINGTONE_COLUMN_MEDIA_TYPE, to_string(RINGTONE_MEDIA_TYPE_INVALID));
881     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
882     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
883     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
884     while (ringtoneAsset != nullptr) {
885         ringtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
886             ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
887             sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_RINGTONE);
888         ringtoneAttrsArray_.push_back(ringtoneAttrs_);
889         ringtoneAsset = results->GetNextObject();
890     }
891     if (ringtoneAttrsArray_.empty()) {
892         MEDIA_LOGE("GetRingtoneAttrList: no ringtone in the ringtone library!");
893     }
894     resultSet == nullptr ? : resultSet->Close();
895     dataShareHelper->Release();
896     return ringtoneAttrsArray_;
897 }
898 
GetDefaultSystemToneAttrs(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)899 std::shared_ptr<ToneAttrs> SystemSoundManagerImpl::GetDefaultSystemToneAttrs(
900     const std::shared_ptr<AbilityRuntime::Context> &context, SystemToneType systemToneType)
901 {
902     std::lock_guard<std::mutex> lock(uriMutex_);
903     CHECK_AND_RETURN_RET_LOG(isSystemToneTypeValid(systemToneType),  nullptr, "Invalid systemtone type");
904     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
905     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, nullptr,
906         "Create dataShare failed, datashare or ringtone library error.");
907     std::string ringToneType = systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
908         RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE : RINGTONE_COLUMN_SHOT_TONE_TYPE;
909     int32_t category = systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
910         TONE_CATEGORY_NOTIFICATION : TONE_CATEGORY_TEXT_MESSAGE;
911     int32_t valueOfRingToneType = systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
912         NOTIFICATION_TONE_TYPE : SHOT_TONE_TYPE_SIM_CARD_BOTH;
913     DataShare::DatashareBusinessError businessError;
914     DataShare::DataSharePredicates queryPredicates;
915     systemtoneAttrs_ = nullptr;
916     queryPredicates.EqualTo(ringToneType, to_string(systemTypeMap_[systemToneType]));
917     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
918     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
919     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
920     while ((ringtoneAsset != nullptr) && (SOURCE_TYPE_PRESET != ringtoneAsset->GetSourceType())) {
921         ringtoneAsset = results->GetNextObject();
922     }
923     if (ringtoneAsset != nullptr) {
924         systemtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
925             ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
926             sourceTypeMap_[ringtoneAsset->GetSourceType()], category);
927     } else {
928         MEDIA_LOGE("GetDefaultSystemToneAttrs: no single default systemtone in the ringtone library!");
929     }
930     DataShare::DataSharePredicates queryPredicatesBothCard;
931     queryPredicatesBothCard.EqualTo(ringToneType, to_string(valueOfRingToneType));
932     resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicatesBothCard, COLUMNS, &businessError);
933     results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
934     unique_ptr<RingtoneAsset> ringtoneAssetBothCard = results->GetFirstObject();
935     while ((ringtoneAssetBothCard != nullptr) &&
936         (SOURCE_TYPE_PRESET != ringtoneAssetBothCard->GetSourceType())) {
937         ringtoneAssetBothCard = results->GetNextObject();
938     }
939     if (ringtoneAssetBothCard != nullptr) {
940         systemtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAssetBothCard->GetTitle(),
941             ringtoneAssetBothCard->GetDisplayName(), ringtoneAssetBothCard->GetPath(),
942             sourceTypeMap_[ringtoneAssetBothCard->GetSourceType()], category);
943     }
944     resultSet == nullptr ? : resultSet->Close();
945     dataShareHelper->Release();
946     return systemtoneAttrs_;
947 }
948 
GetSystemToneAttrList(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)949 std::vector<std::shared_ptr<ToneAttrs>> SystemSoundManagerImpl::GetSystemToneAttrList(
950     const std::shared_ptr<AbilityRuntime::Context> &context, SystemToneType systemToneType)
951 {
952     std::lock_guard<std::mutex> lock(uriMutex_);
953     systemtoneAttrsArray_.clear();
954     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
955     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, systemtoneAttrsArray_,
956         "Create dataShare failed, datashare or ringtone library error.");
957     int32_t category = systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
958         TONE_CATEGORY_NOTIFICATION : TONE_CATEGORY_TEXT_MESSAGE;
959     DataShare::DatashareBusinessError businessError;
960     DataShare::DataSharePredicates queryPredicates;
961     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TONE_TYPE_NOTIFICATION));
962     queryPredicates.GreaterThan(RINGTONE_COLUMN_MEDIA_TYPE, to_string(RINGTONE_MEDIA_TYPE_INVALID));
963     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
964     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
965     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
966     while (ringtoneAsset != nullptr) {
967         systemtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
968             ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
969             sourceTypeMap_[ringtoneAsset->GetSourceType()], category);
970         systemtoneAttrsArray_.push_back(systemtoneAttrs_);
971         ringtoneAsset = results->GetNextObject();
972     }
973     if (systemtoneAttrsArray_.empty()) {
974         MEDIA_LOGE("GetSystemToneAttrList: no systemtone in the ringtone library!");
975     }
976     resultSet == nullptr ? : resultSet->Close();
977     dataShareHelper->Release();
978     return systemtoneAttrsArray_;
979 }
980 
SetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & uri)981 int32_t SystemSoundManagerImpl::SetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> &context,
982     const std::string &uri)
983 {
984     std::lock_guard<std::mutex> lock(uriMutex_);
985     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
986     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
987         "Create dataShare failed, datashare or ringtone library error.");
988     DataShare::DatashareBusinessError businessError;
989     DataShare::DataSharePredicates queryPredicates;
990     DataShare::DataSharePredicates queryPredicatesByUri;
991     queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
992     auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
993     auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
994     unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
995     if (ringtoneAssetByUri == nullptr) {
996         resultSetByUri == nullptr ? : resultSetByUri->Close();
997         dataShareHelper->Release();
998         return ERROR;
999     }
1000     resultSetByUri == nullptr ? : resultSetByUri->Close();
1001     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_ALARM);
1002     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1003     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1004     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1005     while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
1006         ringtoneAsset = results->GetNextObject();
1007     }
1008     if (ringtoneAsset != nullptr) {
1009         DataSharePredicates updateOldPredicates;
1010         DataShareValuesBucket updateOldValuesBucket;
1011         updateOldPredicates.SetWhereClause(RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = ? ");
1012         updateOldPredicates.SetWhereArgs({to_string(SOURCE_TYPE_CUSTOMISED)});
1013         updateOldValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_TYPE, ALARM_TONE_TYPE_NOT);
1014         updateOldValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
1015         dataShareHelper->Update(RINGTONEURI, updateOldPredicates, updateOldValuesBucket);
1016         DataSharePredicates updatePredicates;
1017         DataShareValuesBucket updateValuesBucket;
1018         updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
1019         updatePredicates.SetWhereArgs({to_string(ringtoneAsset->GetId())});
1020         updateValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_TYPE, ALARM_TONE_TYPE);
1021         updateValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
1022         int32_t changedRows = dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
1023         resultSet == nullptr ? : resultSet->Close();
1024         dataShareHelper->Release();
1025         return changedRows > 0 ? SUCCESS : ERROR;
1026     }
1027     resultSet == nullptr ? : resultSet->Close();
1028     dataShareHelper->Release();
1029     return TYPEERROR;
1030 }
1031 
GetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> & context)1032 std::string SystemSoundManagerImpl::GetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> &context)
1033 {
1034     int32_t count = 2;
1035     std::string alarmToneUri = "";
1036     std::lock_guard<std::mutex> lock(uriMutex_);
1037     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1038     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, alarmToneUri,
1039         "Create dataShare failed, datashare or ringtone library error.");
1040     DataShare::DatashareBusinessError businessError;
1041     DataShare::DataSharePredicates queryPredicates;
1042     queryPredicates.EqualTo(RINGTONE_COLUMN_ALARM_TONE_TYPE, to_string(ALARM_TONE_TYPE));
1043     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1044     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1045     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1046     while ((ringtoneAsset != nullptr) && (SOURCE_TYPE_CUSTOMISED !=
1047         ringtoneAsset->GetAlarmtoneSourceType()) && (results->GetCount() == count)) {
1048         ringtoneAsset = results->GetNextObject();
1049     }
1050     if (ringtoneAsset != nullptr) {
1051         alarmToneUri = ringtoneAsset->GetPath();
1052     } else {
1053         MEDIA_LOGE("GetAlarmToneUri: no alarmtone in the ringtone library!");
1054     }
1055     resultSet == nullptr ? : resultSet->Close();
1056     dataShareHelper->Release();
1057     return alarmToneUri;
1058 }
1059 
GetDefaultAlarmToneAttrs(const std::shared_ptr<AbilityRuntime::Context> & context)1060 std::shared_ptr<ToneAttrs> SystemSoundManagerImpl::GetDefaultAlarmToneAttrs(
1061     const std::shared_ptr<AbilityRuntime::Context> &context)
1062 {
1063     std::lock_guard<std::mutex> lock(uriMutex_);
1064     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1065     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, nullptr,
1066         "Create dataShare failed, datashare or ringtone library error.");
1067     DataShare::DatashareBusinessError businessError;
1068     DataShare::DataSharePredicates queryPredicates;
1069     alarmtoneAttrs_ = nullptr;
1070     queryPredicates.EqualTo(RINGTONE_COLUMN_ALARM_TONE_TYPE, to_string(ALARM_TONE_TYPE));
1071     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1072     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1073     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1074     while ((ringtoneAsset != nullptr) && (SOURCE_TYPE_PRESET != ringtoneAsset->GetSourceType())) {
1075         ringtoneAsset = results->GetNextObject();
1076     }
1077     if (ringtoneAsset != nullptr) {
1078         alarmtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
1079             ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
1080             sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_ALARM);
1081     } else {
1082         MEDIA_LOGE("GetDefaultAlarmToneAttrs: no default alarmtone in the ringtone library!");
1083     }
1084     resultSet == nullptr ? : resultSet->Close();
1085     dataShareHelper->Release();
1086     return alarmtoneAttrs_;
1087 }
1088 
GetAlarmToneAttrList(const std::shared_ptr<AbilityRuntime::Context> & context)1089 std::vector<std::shared_ptr<ToneAttrs>> SystemSoundManagerImpl::GetAlarmToneAttrList
1090     (const std::shared_ptr<AbilityRuntime::Context> &context)
1091 {
1092     std::lock_guard<std::mutex> lock(uriMutex_);
1093     alarmtoneAttrsArray_.clear();
1094     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1095     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, alarmtoneAttrsArray_,
1096         "Create dataShare failed, datashare or ringtone library error.");
1097     DataShare::DatashareBusinessError businessError;
1098     DataShare::DataSharePredicates queryPredicates;
1099     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TONE_TYPE_ALARM));
1100     queryPredicates.GreaterThan(RINGTONE_COLUMN_MEDIA_TYPE, to_string(RINGTONE_MEDIA_TYPE_INVALID));
1101     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1102     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1103     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1104     while (ringtoneAsset != nullptr) {
1105         alarmtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
1106             ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
1107             sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_ALARM);
1108         alarmtoneAttrsArray_.push_back(alarmtoneAttrs_);
1109         ringtoneAsset = results->GetNextObject();
1110     }
1111     if (alarmtoneAttrsArray_.empty()) {
1112         MEDIA_LOGE("GetAlarmToneAttrList: no alarmtone in the ringtone library!");
1113     }
1114     resultSet == nullptr ? : resultSet->Close();
1115     dataShareHelper->Release();
1116     return alarmtoneAttrsArray_;
1117 }
1118 
OpenAlarmTone(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & uri)1119 int32_t SystemSoundManagerImpl::OpenAlarmTone(const std::shared_ptr<AbilityRuntime::Context> &context,
1120     const std::string &uri)
1121 {
1122     std::lock_guard<std::mutex> lock(uriMutex_);
1123     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1124     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
1125         "Create dataShare failed, datashare or ringtone library error.");
1126     DataShare::DatashareBusinessError businessError;
1127     DataShare::DataSharePredicates queryPredicates;
1128     DataShare::DataSharePredicates queryPredicatesByUri;
1129     queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
1130     auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
1131     auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
1132     unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
1133     if (ringtoneAssetByUri == nullptr) {
1134         MEDIA_LOGE("OpenAlarmTone: tone of uri is not in the ringtone library!");
1135         resultSetByUri == nullptr ? : resultSetByUri->Close();
1136         dataShareHelper->Release();
1137         return ERROR;
1138     }
1139     resultSetByUri == nullptr ? : resultSetByUri->Close();
1140     queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_ALARM);
1141     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1142     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1143     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1144     while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
1145         ringtoneAsset = results->GetNextObject();
1146     }
1147     if (ringtoneAsset != nullptr) {
1148         string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(ringtoneAsset->GetId());
1149         Uri ofUri(uriStr);
1150         int32_t fd = dataShareHelper->OpenFile(ofUri, "r");
1151         resultSet == nullptr ? : resultSet->Close();
1152         dataShareHelper->Release();
1153         return fd > 0 ? fd : ERROR;
1154     }
1155     MEDIA_LOGE("OpenAlarmTone: tone of uri is not alarm!");
1156     resultSet == nullptr ? : resultSet->Close();
1157     dataShareHelper->Release();
1158     return TYPEERROR;
1159 }
1160 
Close(const int32_t & fd)1161 int32_t SystemSoundManagerImpl::Close(const int32_t &fd)
1162 {
1163     std::lock_guard<std::mutex> lock(uriMutex_);
1164     return close(fd);
1165 }
1166 
AddCustomizedToneByExternalUri(const std::shared_ptr<AbilityRuntime::Context> & context,const std::shared_ptr<ToneAttrs> & toneAttrs,const std::string & externalUri)1167 std::string SystemSoundManagerImpl::AddCustomizedToneByExternalUri(
1168     const std::shared_ptr<AbilityRuntime::Context> &context, const std::shared_ptr<ToneAttrs> &toneAttrs,
1169     const std::string &externalUri)
1170 {
1171     std::string fdHead = "fd://";
1172     std::string srcPath = externalUri;
1173     int32_t srcFd;
1174     if (srcPath.find(fdHead) != std::string::npos) {
1175         StrToInt(srcPath.substr(fdHead.size()), srcFd);
1176     } else {
1177         srcFd = open(srcPath.c_str(), O_RDONLY);
1178     }
1179     if (srcFd < 0) {
1180         MEDIA_LOGE("AddCustomizedTone: fd open error is %{public}s", strerror(errno));
1181         fdHead.clear();
1182         return fdHead;
1183     }
1184     return AddCustomizedToneByFd(context, toneAttrs, srcFd);
1185 }
1186 
AddCustomizedToneByFd(const std::shared_ptr<AbilityRuntime::Context> & context,const std::shared_ptr<ToneAttrs> & toneAttrs,const int32_t & fd)1187 std::string SystemSoundManagerImpl::AddCustomizedToneByFd(const std::shared_ptr<AbilityRuntime::Context> &context,
1188     const std::shared_ptr<ToneAttrs> &toneAttrs, const int32_t &fd)
1189 {
1190     return AddCustomizedToneByFdAndOffset(context, toneAttrs, fd, 0, INT_MAX);
1191 }
1192 
GetCustomizedTone(const std::shared_ptr<ToneAttrs> & toneAttrs)1193 void SystemSoundManagerImpl::GetCustomizedTone(const std::shared_ptr<ToneAttrs> &toneAttrs)
1194 {
1195     displayName_ = toneAttrs->GetFileName();
1196     mimeType_ = "";
1197     for (const auto& type : RINGTONETYPE) {
1198         size_t found = displayName_.find("." + type);
1199         if (found != std::string::npos) {
1200             mimeType_ = type;
1201         }
1202     }
1203     if (mimeType_.empty()) {
1204         mimeType_ = RINGTONE_CONTAINER_TYPE_OGG;
1205         displayName_ = displayName_ + ".ogg";
1206     }
1207 }
1208 
AddCustomizedTone(const std::shared_ptr<DataShare::DataShareHelper> & dataShareHelper,const std::shared_ptr<ToneAttrs> & toneAttrs)1209 int32_t SystemSoundManagerImpl::AddCustomizedTone(const std::shared_ptr<DataShare::DataShareHelper> &dataShareHelper,
1210     const std::shared_ptr<ToneAttrs> &toneAttrs)
1211 {
1212     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR, "Invalid dataShareHelper.");
1213     int32_t category = -1;
1214     category = toneAttrs->GetCategory();
1215     GetCustomizedTone(toneAttrs);
1216     DataShareValuesBucket valuesBucket;
1217     valuesBucket.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(displayName_));
1218     valuesBucket.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(toneAttrs->GetTitle()));
1219     valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, static_cast<string>(mimeType_));
1220     valuesBucket.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(SOURCE_TYPE_CUSTOMISED));
1221     switch (category) {
1222         case TONE_CATEGORY_RINGTONE:
1223             toneAttrs->SetUri(RINGTONE_CUSTOMIZED_RINGTONE_PATH + RINGTONE_SLASH_CHAR + displayName_);
1224             valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_RINGTONE));
1225             break;
1226         case TONE_CATEGORY_TEXT_MESSAGE:
1227             toneAttrs->SetUri(RINGTONE_CUSTOMIZED_NOTIFICATIONS_PATH + RINGTONE_SLASH_CHAR + displayName_);
1228             valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_NOTIFICATION));
1229             break;
1230         case TONE_CATEGORY_NOTIFICATION:
1231             toneAttrs->SetUri(RINGTONE_CUSTOMIZED_NOTIFICATIONS_PATH + RINGTONE_SLASH_CHAR + displayName_);
1232             valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_NOTIFICATION));
1233             break;
1234         case TONE_CATEGORY_ALARM:
1235             toneAttrs->SetUri(RINGTONE_CUSTOMIZED_ALARM_PATH + RINGTONE_SLASH_CHAR + displayName_);
1236             valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_ALARM));
1237             break;
1238         default:
1239             break;
1240     }
1241     valuesBucket.Put(RINGTONE_COLUMN_DATA, static_cast<string>(toneAttrs->GetUri()));
1242     return dataShareHelper->Insert(RINGTONEURI, valuesBucket);
1243 }
1244 
AddCustomizedToneByFdAndOffset(const std::shared_ptr<AbilityRuntime::Context> & context,const std::shared_ptr<ToneAttrs> & toneAttrs,const int32_t & fd,const int32_t & offset,const int32_t & length)1245 std::string SystemSoundManagerImpl::AddCustomizedToneByFdAndOffset(
1246     const std::shared_ptr<AbilityRuntime::Context> &context, const std::shared_ptr<ToneAttrs> &toneAttrs,
1247     const int32_t &fd, const int32_t &offset, const int32_t &length)
1248 {
1249     std::string result = "TYPEERROR";
1250     if (toneAttrs->GetCustomizedType() != CUSTOMISED) {
1251         MEDIA_LOGE("AddCustomizedTone: the ringtone is not customized!");
1252         return result;
1253     }
1254     std::lock_guard<std::mutex> lock(uriMutex_);
1255     int32_t srcFd = fd;
1256     off_t lseekResult = lseek(srcFd, offset, SEEK_SET);
1257     if (srcFd < 0 || lseekResult == -1) {
1258         MEDIA_LOGE("fd is error");
1259         result.clear();
1260         return result;
1261     }
1262     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1263     if (dataShareHelper == nullptr) {
1264         MEDIA_LOGE("Create dataShare failed, datashare or ringtone library error.");
1265         result.clear();
1266         return result;
1267     }
1268     int32_t sert = AddCustomizedTone(dataShareHelper, toneAttrs);
1269     std::string dstPath = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(sert);
1270     Uri ofUri(dstPath);
1271     int32_t dstFd = dataShareHelper->OpenFile(ofUri, "rw");
1272     if (dstFd < 0) {
1273         MEDIA_LOGE("AddCustomizedTone: open error is %{public}s", strerror(errno));
1274         result.clear();
1275         dataShareHelper->Release();
1276         return result;
1277     }
1278     char buffer[4096];
1279     int32_t len = length;
1280     memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
1281     int32_t bytesRead = 0;
1282     while ((bytesRead = read(srcFd, buffer, sizeof(buffer))) > 0 && len > 0) {
1283         int32_t bytesWritten = write(dstFd, buffer, (bytesRead < len) ? bytesRead : len);
1284         memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
1285         len -= bytesWritten;
1286         if (bytesWritten == -1) {
1287             break;
1288         }
1289     }
1290     close(srcFd);
1291     close(dstFd);
1292     dataShareHelper->Release();
1293     return toneAttrs->GetUri();
1294 }
1295 
RemoveCustomizedTone(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & uri)1296 int32_t SystemSoundManagerImpl::RemoveCustomizedTone(
1297     const std::shared_ptr<AbilityRuntime::Context> &context, const std::string &uri)
1298 {
1299     std::lock_guard<std::mutex> lock(uriMutex_);
1300     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1301     CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
1302         "Create dataShare failed, datashare or ringtone library error.");
1303     int32_t changedRows = TYPEERROR;
1304     DataShare::DatashareBusinessError businessError;
1305     DataShare::DataSharePredicates queryPredicates;
1306     queryPredicates.EqualTo(RINGTONE_COLUMN_DATA, uri);
1307     auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1308     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1309     unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1310     if (ringtoneAsset == nullptr) {
1311         MEDIA_LOGE("RemoveCustomizedTone: tone of uri is not in the ringtone library!");
1312         resultSet == nullptr ? : resultSet->Close();
1313         dataShareHelper->Release();
1314         return ERROR;
1315     }
1316     while ((ringtoneAsset != nullptr) &&
1317         (SOURCE_TYPE_CUSTOMISED != ringtoneAsset->GetSourceType())) {
1318         ringtoneAsset = results->GetNextObject();
1319     }
1320     if (ringtoneAsset != nullptr) {
1321         DataShare::DataSharePredicates deletePredicates;
1322         deletePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
1323         deletePredicates.SetWhereArgs({to_string(ringtoneAsset->GetId())});
1324         changedRows = dataShareHelper->Delete(RINGTONEURI, deletePredicates);
1325     } else {
1326         MEDIA_LOGE("RemoveCustomizedTone: the ringtone is not customized!");
1327     }
1328     resultSet == nullptr ? : resultSet->Close();
1329     dataShareHelper->Release();
1330     return changedRows;
1331 }
1332 
SetRingerMode(const AudioStandard::AudioRingerMode & ringerMode)1333 int32_t SystemSoundManagerImpl::SetRingerMode(const AudioStandard::AudioRingerMode &ringerMode)
1334 {
1335     ringerMode_.store(ringerMode);
1336     return MSERR_OK;
1337 }
1338 
GetRingerMode() const1339 AudioStandard::AudioRingerMode SystemSoundManagerImpl::GetRingerMode() const
1340 {
1341     return ringerMode_.load();
1342 }
1343 
1344 // Ringer mode callback class symbols
RingerModeCallbackImpl(SystemSoundManagerImpl & systemSoundManagerImpl)1345 RingerModeCallbackImpl::RingerModeCallbackImpl(SystemSoundManagerImpl &systemSoundManagerImpl)
1346     : sysSoundMgr_(systemSoundManagerImpl) {}
1347 
OnRingerModeUpdated(const AudioStandard::AudioRingerMode & ringerMode)1348 void RingerModeCallbackImpl::OnRingerModeUpdated(const AudioStandard::AudioRingerMode &ringerMode)
1349 {
1350     ringerMode_ = ringerMode;
1351     int32_t result = sysSoundMgr_.SetRingerMode(ringerMode_);
1352     if (result == MSERR_OK && ringerMode_ == AudioStandard::AudioRingerMode::RINGER_MODE_SILENT) {
1353         SystemSoundVibrator::StopVibrator();
1354     }
1355 }
1356 } // namesapce AudioStandard
1357 } // namespace OHOS
1358