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 "vibrate_type.h"
28 #include "os_account_manager.h"
29 #include "system_tone_player_impl.h"
30 #include "parameter.h"
31
32 using namespace std;
33 using namespace nlohmann;
34 using namespace OHOS::AbilityRuntime;
35 using namespace OHOS::DataShare;
36
37 namespace {
38 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO_NAPI, "SystemSoundManagerImpl"};
39 }
40
41 namespace OHOS {
42 namespace Media {
43 const std::string RING_TONE = "ring_tone";
44 const std::string SYSTEM_TONE = "system_tone";
45 const std::string DEFAULT_SYSTEM_SOUND_PATH = "resource/media/audio/";
46 const std::string DEFAULT_RINGTONE_URI_JSON = "ringtone_incall.json";
47 const std::string DEFAULT_RINGTONE_PATH = "ringtones/";
48 const std::string DEFAULT_SYSTEM_TONE_URI_JSON = "ringtone_sms-notification.json";
49 const std::string DEFAULT_SYSTEM_TONE_PATH = "notifications/";
50 const int STORAGE_MANAGER_MANAGER_ID = 5003;
51 const int UNSUPPORTED_ERROR = -5;
52 #ifdef SUPPORT_VIBRATOR
53 const int OPERATION_ERROR = -4;
54 #endif
55 const int IO_ERROR = -3;
56 const int TYPEERROR = -2;
57 const int ERROR = -1;
58 const int SUCCESS = 0;
59
60 // tone haptics default setting
61 static const char PARAM_HAPTICS_SETTING_RINGTONE_CARD_ONE[] = "const.multimedia.haptics_ringtone_sim_card_0_haptics";
62 static const char PARAM_HAPTICS_SETTING_RINGTONE_CARD_TWO[] = "const.multimedia.haptics_ringtone_sim_card_1_haptics";
63 static const char PARAM_HAPTICS_SETTING_SHOT_CARD_ONE[] = "const.multimedia.haptics_system_tone_sim_card_0_haptics";
64 static const char PARAM_HAPTICS_SETTING_SHOT_CARD_TWO[] = "const.multimedia.haptics_system_tone_sim_card_1_haptics";
65 static const char PARAM_HAPTICS_SETTING_NOTIFICATIONTONE[] = "const.multimedia.notification_tone_haptics";
66 static const int32_t SYSPARA_SIZE = 128;
67
68 std::shared_ptr<SystemSoundManager> SystemSoundManagerFactory::systemSoundManager_ = nullptr;
69 std::mutex SystemSoundManagerFactory::systemSoundManagerMutex_;
70 std::unordered_map<RingtoneType, RingToneType> ringtoneTypeMap_;
71 std::unordered_map<int32_t, ToneCustomizedType> sourceTypeMap_;
72 std::unordered_map<SystemToneType, int32_t> systemTypeMap_;
73 std::unordered_map<SystemToneType, ShotToneType> shotToneTypeMap_;
74 std::unordered_map<ToneHapticsMode, VibratePlayMode> hapticsModeMap_;
75 std::unordered_map<ToneHapticsType, std::pair<int32_t, int32_t>> hapticsTypeWhereArgsMap_;
76 std::unordered_map<int32_t, std::unordered_map<HapticsStyle, int32_t>> hapticsStyleMap_;
77 std::unordered_map<RingtoneType, DefaultSystemToneType> defaultoneTypeMap_;
78 std::unordered_map<SystemToneType, int32_t> defaultsystemTypeMap_;
79 Uri RINGTONEURI(RINGTONE_PATH_URI);
80 Uri VIBRATEURI(VIBRATE_PATH_URI);
81 Uri SIMCARDSETTINGURI(SIMCARD_SETTING_PATH_URI);
82 vector<string> COLUMNS = {{RINGTONE_COLUMN_TONE_ID}, {RINGTONE_COLUMN_DATA}, {RINGTONE_COLUMN_DISPLAY_NAME},
83 {RINGTONE_COLUMN_TITLE}, {RINGTONE_COLUMN_TONE_TYPE}, {RINGTONE_COLUMN_SOURCE_TYPE},
84 {RINGTONE_COLUMN_SHOT_TONE_TYPE}, {RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE},
85 {RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_RING_TONE_TYPE},
86 {RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_ALARM_TONE_TYPE},
87 {RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE}};
88 vector<string> JOIN_COLUMNS = {{RINGTONE_TABLE + "." + RINGTONE_COLUMN_TONE_ID}, {RINGTONE_COLUMN_DATA},
89 {RINGTONE_TABLE + "." + RINGTONE_COLUMN_DISPLAY_NAME}, {RINGTONE_COLUMN_TITLE},
90 {RINGTONE_COLUMN_TONE_TYPE}, {RINGTONE_COLUMN_SOURCE_TYPE}, {RINGTONE_COLUMN_SHOT_TONE_TYPE},
91 {RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE},
92 {RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE}, {RINGTONE_TABLE + "." + RINGTONE_COLUMN_RING_TONE_TYPE},
93 {RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE}, {RINGTONE_COLUMN_ALARM_TONE_TYPE},
94 {RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE}};
95 vector<string> SETTING_TABLE_COLUMNS = {{SIMCARD_SETTING_COLUMN_MODE}, {SIMCARD_SETTING_COLUMN_TONE_FILE},
96 {SIMCARD_SETTING_COLUMN_RINGTONE_TYPE}, {SIMCARD_SETTING_COLUMN_VIBRATE_FILE},
97 {SIMCARD_SETTING_COLUMN_VIBRATE_MODE}, {SIMCARD_SETTING_COLUMN_RING_MODE}};
98 vector<string> VIBRATE_TABLE_COLUMNS = {{VIBRATE_COLUMN_VIBRATE_ID}, {VIBRATE_COLUMN_DATA}, {VIBRATE_COLUMN_SIZE},
99 {VIBRATE_COLUMN_DISPLAY_NAME}, {VIBRATE_COLUMN_TITLE}, {VIBRATE_COLUMN_DISPLAY_LANGUAGE},
100 {VIBRATE_COLUMN_VIBRATE_TYPE}, {VIBRATE_COLUMN_SOURCE_TYPE}, {VIBRATE_COLUMN_DATE_ADDED},
101 {VIBRATE_COLUMN_DATE_MODIFIED}, {VIBRATE_COLUMN_DATE_TAKEN}, {VIBRATE_COLUMN_PLAY_MODE}};
102 std::vector<std::string> RINGTONETYPE = {{RINGTONE_CONTAINER_TYPE_MP3}, {RINGTONE_CONTAINER_TYPE_OGG},
103 {RINGTONE_CONTAINER_TYPE_AC3}, {RINGTONE_CONTAINER_TYPE_AAC}, {RINGTONE_CONTAINER_TYPE_FLAC},
104 {RINGTONE_CONTAINER_TYPE_WAV}};
105
CreateSystemSoundManager()106 std::shared_ptr<SystemSoundManager> SystemSoundManagerFactory::CreateSystemSoundManager()
107 {
108 std::lock_guard<std::mutex> lock(systemSoundManagerMutex_);
109 if (systemSoundManager_ == nullptr) {
110 systemSoundManager_ = std::make_shared<SystemSoundManagerImpl>();
111 }
112 CHECK_AND_RETURN_RET_LOG(systemSoundManager_ != nullptr, nullptr, "Failed to create sound manager object");
113 return systemSoundManager_;
114 }
115
CreateDataShareHelper(int32_t systemAbilityId)116 static shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int32_t systemAbilityId)
117 {
118 MEDIA_LOGI("CreateDataShareHelper : Enter CreateDataShareHelper()");
119 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
120 if (saManager == nullptr) {
121 MEDIA_LOGE("Get system ability manager failed.");
122 return nullptr;
123 }
124 auto remoteObj = saManager->GetSystemAbility(systemAbilityId);
125 if (remoteObj == nullptr) {
126 MEDIA_LOGE("Get system ability:[%{public}d] failed.", systemAbilityId);
127 return nullptr;
128 }
129 return DataShare::DataShareHelper::Creator(remoteObj, RINGTONE_URI);
130 }
131
SystemSoundManagerImpl()132 SystemSoundManagerImpl::SystemSoundManagerImpl()
133 {
134 InitDefaultUriMap();
135 InitRingerMode();
136 InitMap();
137 InitDefaultToneHapticsMap();
138 }
139
~SystemSoundManagerImpl()140 SystemSoundManagerImpl::~SystemSoundManagerImpl()
141 {
142 if (audioGroupManager_ != nullptr) {
143 (void)audioGroupManager_->UnsetRingerModeCallback(getpid(), ringerModeCallback_);
144 ringerModeCallback_ = nullptr;
145 audioGroupManager_ = nullptr;
146 }
147 }
148
InitMap(void)149 void SystemSoundManagerImpl::InitMap(void)
150 {
151 ringtoneTypeMap_[RINGTONE_TYPE_SIM_CARD_0] = RING_TONE_TYPE_SIM_CARD_1;
152 ringtoneTypeMap_[RINGTONE_TYPE_SIM_CARD_1] = RING_TONE_TYPE_SIM_CARD_2;
153 sourceTypeMap_[SOURCE_TYPE_PRESET] = PRE_INSTALLED;
154 sourceTypeMap_[SOURCE_TYPE_CUSTOMISED] = CUSTOMISED;
155 systemTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] = SHOT_TONE_TYPE_SIM_CARD_1;
156 systemTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] = SHOT_TONE_TYPE_SIM_CARD_2;
157 systemTypeMap_[SYSTEM_TONE_TYPE_NOTIFICATION] = NOTIFICATION_TONE_TYPE;
158 shotToneTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] = SHOT_TONE_TYPE_SIM_CARD_1;
159 shotToneTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] = SHOT_TONE_TYPE_SIM_CARD_2;
160 defaultoneTypeMap_[RINGTONE_TYPE_SIM_CARD_0] = DEFAULT_RING_TYPE_SIM_CARD_1;
161 defaultoneTypeMap_[RINGTONE_TYPE_SIM_CARD_1] = DEFAULT_RING_TYPE_SIM_CARD_2;
162 defaultsystemTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] = DEFAULT_SHOT_TYPE_SIM_CARD_1;
163 defaultsystemTypeMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] = DEFAULT_SHOT_TYPE_SIM_CARD_2;
164 defaultsystemTypeMap_[SYSTEM_TONE_TYPE_NOTIFICATION] = DEFAULT_NOTIFICATION_TYPE;
165 hapticsModeMap_[NONE] = VIBRATE_PLAYMODE_NONE;
166 hapticsModeMap_[SYNC] = VIBRATE_PLAYMODE_SYNC;
167 hapticsModeMap_[NON_SYNC] = VIBRATE_PLAYMODE_CLASSIC;
168 hapticsTypeWhereArgsMap_ = {
169 {ToneHapticsType::CALL_SIM_CARD_0, {RING_TONE_TYPE_SIM_CARD_1, TONE_SETTING_TYPE_RINGTONE}},
170 {ToneHapticsType::CALL_SIM_CARD_1, {RING_TONE_TYPE_SIM_CARD_2, TONE_SETTING_TYPE_RINGTONE}},
171 {ToneHapticsType::TEXT_MESSAGE_SIM_CARD_0, {RING_TONE_TYPE_SIM_CARD_1, TONE_SETTING_TYPE_SHOT}},
172 {ToneHapticsType::TEXT_MESSAGE_SIM_CARD_1, {RING_TONE_TYPE_SIM_CARD_2, TONE_SETTING_TYPE_SHOT}},
173 {ToneHapticsType::NOTIFICATION, {RING_TONE_TYPE_SIM_CARD_BOTH, TONE_SETTING_TYPE_NOTIFICATION}},
174 };
175 hapticsStyleMap_[VIBRATE_TYPE_STANDARD] = {
176 {HAPTICS_STYLE_GENTLE, VIBRATE_TYPE_GENTLE},
177 };
178 hapticsStyleMap_[VIBRATE_TYPE_SALARM] = {
179 {HAPTICS_STYLE_GENTLE, VIBRATE_TYPE_GALARM},
180 };
181 hapticsStyleMap_[VIBRATE_TYPE_SRINGTONE] = {
182 {HAPTICS_STYLE_GENTLE, VIBRATE_TYPE_GRINGTONE},
183 };
184 hapticsStyleMap_[VIBRATE_TYPE_SNOTIFICATION] = {
185 {HAPTICS_STYLE_GENTLE, VIBRATE_TYPE_GNOTIFICATION},
186 };
187 }
188
InitRingerMode(void)189 void SystemSoundManagerImpl::InitRingerMode(void)
190 {
191 audioGroupManager_ = AudioStandard::AudioSystemManager::GetInstance()->
192 GetGroupManager(AudioStandard::DEFAULT_VOLUME_GROUP_ID);
193 if (audioGroupManager_ == nullptr) {
194 MEDIA_LOGE("InitRingerMode: audioGroupManager_ is nullptr");
195 return;
196 }
197 ringerMode_ = audioGroupManager_->GetRingerMode();
198
199 ringerModeCallback_ = std::make_shared<RingerModeCallbackImpl>(*this);
200 audioGroupManager_->SetRingerModeCallback(getpid(), ringerModeCallback_);
201 }
202
IsRingtoneTypeValid(RingtoneType ringtongType)203 bool SystemSoundManagerImpl::IsRingtoneTypeValid(RingtoneType ringtongType)
204 {
205 switch (ringtongType) {
206 case RINGTONE_TYPE_SIM_CARD_0:
207 case RINGTONE_TYPE_SIM_CARD_1:
208 return true;
209 default:
210 MEDIA_LOGE("IsRingtoneTypeValid: ringtongType %{public}d is unavailable", ringtongType);
211 return false;
212 }
213 }
214
IsSystemToneTypeValid(SystemToneType systemToneType)215 bool SystemSoundManagerImpl::IsSystemToneTypeValid(SystemToneType systemToneType)
216 {
217 switch (systemToneType) {
218 case SYSTEM_TONE_TYPE_SIM_CARD_0:
219 case SYSTEM_TONE_TYPE_SIM_CARD_1:
220 case SYSTEM_TONE_TYPE_NOTIFICATION:
221 return true;
222 default:
223 MEDIA_LOGE("IsSystemToneTypeValid: systemToneType %{public}d is unavailable", systemToneType);
224 return false;
225 }
226 }
227
IsSystemToneType(const unique_ptr<RingtoneAsset> & ringtoneAsset,const SystemToneType & systemToneType)228 bool SystemSoundManagerImpl::IsSystemToneType(const unique_ptr<RingtoneAsset> &ringtoneAsset,
229 const SystemToneType &systemToneType)
230 {
231 CHECK_AND_RETURN_RET_LOG(ringtoneAsset != nullptr, false, "Invalid ringtone asset.");
232 return (systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
233 TONE_TYPE_NOTIFICATION != ringtoneAsset->GetToneType() :
234 TONE_TYPE_SHOT != ringtoneAsset->GetToneType());
235 }
236
IsToneHapticsTypeValid(ToneHapticsType toneHapticsType)237 bool SystemSoundManagerImpl::IsToneHapticsTypeValid(ToneHapticsType toneHapticsType)
238 {
239 switch (toneHapticsType) {
240 case ToneHapticsType::CALL_SIM_CARD_0 :
241 case ToneHapticsType::CALL_SIM_CARD_1 :
242 case ToneHapticsType::TEXT_MESSAGE_SIM_CARD_0 :
243 case ToneHapticsType::TEXT_MESSAGE_SIM_CARD_1 :
244 case ToneHapticsType::NOTIFICATION :
245 return true;
246 default:
247 MEDIA_LOGE("IsToneHapticsTypeValid: toneHapticsType %{public}d is unavailable", toneHapticsType);
248 return false;
249 }
250 }
251
InitDefaultUriMap()252 void SystemSoundManagerImpl::InitDefaultUriMap()
253 {
254 systemSoundPath_ = GetFullPath(DEFAULT_SYSTEM_SOUND_PATH);
255
256 std::string ringtoneJsonPath = systemSoundPath_ + DEFAULT_RINGTONE_URI_JSON;
257 InitDefaultRingtoneUriMap(ringtoneJsonPath);
258
259 std::string systemToneJsonPath = systemSoundPath_ + DEFAULT_SYSTEM_TONE_URI_JSON;
260 InitDefaultSystemToneUriMap(systemToneJsonPath);
261 }
262
InitDefaultRingtoneUriMap(const std::string & ringtoneJsonPath)263 void SystemSoundManagerImpl::InitDefaultRingtoneUriMap(const std::string &ringtoneJsonPath)
264 {
265 std::lock_guard<std::mutex> lock(uriMutex_);
266
267 std::string jsonValue = GetJsonValue(ringtoneJsonPath);
268 nlohmann::json ringtoneJson = json::parse(jsonValue, nullptr, false);
269 if (ringtoneJson.is_discarded()) {
270 MEDIA_LOGE("ringtoneJson parsing is false !");
271 return;
272 }
273 if (ringtoneJson.contains("preset_ringtone_sim1") && ringtoneJson["preset_ringtone_sim1"].is_string()) {
274 std::string defaultRingtoneName = ringtoneJson["preset_ringtone_sim1"];
275 defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_0] =
276 systemSoundPath_ + DEFAULT_RINGTONE_PATH + defaultRingtoneName + ".ogg";
277 MEDIA_LOGI("preset_ringtone_sim1 is [%{public}s]", defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_0].c_str());
278 } else {
279 defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_0] = "";
280 MEDIA_LOGW("InitDefaultRingtoneUriMap: failed to load uri of preset_ringtone_sim1");
281 }
282 if (ringtoneJson.contains("preset_ringtone_sim2") && ringtoneJson["preset_ringtone_sim2"].is_string()) {
283 std::string defaultRingtoneName = ringtoneJson["preset_ringtone_sim2"];
284 defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_1] =
285 systemSoundPath_ + DEFAULT_RINGTONE_PATH + defaultRingtoneName + ".ogg";
286 MEDIA_LOGI("preset_ringtone_sim1 is [%{public}s]", defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_1].c_str());
287 } else {
288 defaultRingtoneUriMap_[RINGTONE_TYPE_SIM_CARD_1] = "";
289 MEDIA_LOGW("InitDefaultRingtoneUriMap: failed to load uri of preset_ringtone_sim2");
290 }
291 }
292
GetDefaultRingtoneUri(RingtoneType ringtoneType)293 std::string SystemSoundManagerImpl::GetDefaultRingtoneUri(RingtoneType ringtoneType)
294 {
295 std::lock_guard<std::mutex> lock(uriMutex_);
296 if (defaultRingtoneUriMap_.count(ringtoneType) == 0) {
297 MEDIA_LOGE("Failed to GetDefaultRingtoneUri: invalid ringtone type %{public}d", ringtoneType);
298 return "";
299 }
300 return defaultRingtoneUriMap_[ringtoneType];
301 }
302
GetDefaultSystemToneUri(SystemToneType systemToneType)303 std::string SystemSoundManagerImpl::GetDefaultSystemToneUri(SystemToneType systemToneType)
304 {
305 std::lock_guard<std::mutex> lock(uriMutex_);
306 if (defaultSystemToneUriMap_.count(systemToneType) == 0) {
307 MEDIA_LOGE("Failed to GetDefaultRingtoneUri: invalid system tone type %{public}d", systemToneType);
308 return "";
309 }
310 return defaultSystemToneUriMap_[systemToneType];
311 }
312
InitDefaultSystemToneUriMap(const std::string & systemToneJsonPath)313 void SystemSoundManagerImpl::InitDefaultSystemToneUriMap(const std::string &systemToneJsonPath)
314 {
315 std::lock_guard<std::mutex> lock(uriMutex_);
316
317 std::string jsonValue = GetJsonValue(systemToneJsonPath);
318 nlohmann::json systemToneJson = json::parse(jsonValue, nullptr, false);
319 if (systemToneJson.is_discarded()) {
320 MEDIA_LOGE("systemToneJson parsing is false !");
321 return;
322 }
323 if (systemToneJson.contains("preset_ringtone_sms") && systemToneJson["preset_ringtone_sms"].is_string()) {
324 std::string defaultSystemToneName = systemToneJson["preset_ringtone_sms"];
325 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] =
326 systemSoundPath_ + DEFAULT_SYSTEM_TONE_PATH + defaultSystemToneName + ".ogg";
327 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] =
328 systemSoundPath_ + DEFAULT_SYSTEM_TONE_PATH + defaultSystemToneName + ".ogg";
329 MEDIA_LOGI("preset_ringtone_sms is [%{public}s]",
330 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_0].c_str());
331 } else {
332 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_0] = "";
333 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_SIM_CARD_1] = "";
334 MEDIA_LOGW("InitDefaultSystemToneUriMap: failed to load uri of preset_ringtone_sms");
335 }
336 if (systemToneJson.contains("preset_ringtone_notification") &&
337 systemToneJson["preset_ringtone_notification"].is_string()) {
338 std::string defaultSystemToneName = systemToneJson["preset_ringtone_notification"];
339 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_NOTIFICATION] =
340 systemSoundPath_ + DEFAULT_SYSTEM_TONE_PATH + defaultSystemToneName + ".ogg";
341 MEDIA_LOGI("preset_ringtone_notification is [%{public}s]",
342 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_NOTIFICATION].c_str());
343 } else {
344 defaultSystemToneUriMap_[SYSTEM_TONE_TYPE_NOTIFICATION] = "";
345 MEDIA_LOGW("InitDefaultSystemToneUriMap: failed to load uri of preset_ringtone_notification");
346 }
347 }
348
ReadDefaultToneHaptics(const char * paramName,ToneHapticsType toneHapticsType)349 void SystemSoundManagerImpl::ReadDefaultToneHaptics(const char *paramName, ToneHapticsType toneHapticsType)
350 {
351 char paramValue[SYSPARA_SIZE] = {0};
352 GetParameter(paramName, "", paramValue, SYSPARA_SIZE);
353 if (strcmp(paramValue, "")) {
354 defaultToneHapticsUriMap_.insert(make_pair(toneHapticsType, string(paramValue)));
355 MEDIA_LOGI("ReadDefaultToneHaptics: tone [%{public}d] haptics is [%{public}s]", toneHapticsType, paramValue);
356 } else {
357 MEDIA_LOGW("ReadDefaultToneHaptics: failed to load uri of [%{public}s]", paramName);
358 }
359 }
360
InitDefaultToneHapticsMap()361 void SystemSoundManagerImpl::InitDefaultToneHapticsMap()
362 {
363 ReadDefaultToneHaptics(PARAM_HAPTICS_SETTING_RINGTONE_CARD_ONE, ToneHapticsType::CALL_SIM_CARD_0);
364 ReadDefaultToneHaptics(PARAM_HAPTICS_SETTING_RINGTONE_CARD_TWO, ToneHapticsType::CALL_SIM_CARD_1);
365 ReadDefaultToneHaptics(PARAM_HAPTICS_SETTING_SHOT_CARD_ONE, ToneHapticsType::TEXT_MESSAGE_SIM_CARD_0);
366 ReadDefaultToneHaptics(PARAM_HAPTICS_SETTING_SHOT_CARD_TWO, ToneHapticsType::TEXT_MESSAGE_SIM_CARD_1);
367 ReadDefaultToneHaptics(PARAM_HAPTICS_SETTING_NOTIFICATIONTONE, ToneHapticsType::NOTIFICATION);
368 }
369
GetFullPath(const std::string & originalUri)370 std::string SystemSoundManagerImpl::GetFullPath(const std::string &originalUri)
371 {
372 char buf[MAX_PATH_LEN];
373 char *path = GetOneCfgFile(originalUri.c_str(), buf, MAX_PATH_LEN);
374 if (path == nullptr || *path == '\0') {
375 MEDIA_LOGE("GetOneCfgFile for %{public}s failed.", originalUri.c_str());
376 return "";
377 }
378 std::string filePath = path;
379 MEDIA_LOGI("GetFullPath for [%{public}s], result: [%{public}s]", originalUri.c_str(), filePath.c_str());
380 return filePath;
381 }
382
GetJsonValue(const std::string & jsonPath)383 std::string SystemSoundManagerImpl::GetJsonValue(const std::string &jsonPath)
384 {
385 std::string jsonValue = "";
386 ifstream file(jsonPath.c_str());
387 if (!file.is_open()) {
388 MEDIA_LOGI("file not open! try open first ! ");
389 file.open(jsonPath.c_str(), ios::app);
390 if (!file.is_open()) {
391 MEDIA_LOGE("open file again fail !");
392 return "";
393 }
394 }
395 file.seekg(0, ios::end);
396
397 const long maxFileLength = 32 * 1024 * 1024; // max size of the json file
398 const long fileLength = file.tellg();
399 if (fileLength > maxFileLength) {
400 MEDIA_LOGE("invalid file length(%{public}ld)!", fileLength);
401 return "";
402 }
403
404 jsonValue.clear();
405 file.seekg(0, ios::beg);
406 copy(istreambuf_iterator<char>(file), istreambuf_iterator<char>(), back_inserter(jsonValue));
407 return jsonValue;
408 }
409
WriteUriToDatabase(const std::string & key,const std::string & uri)410 int32_t SystemSoundManagerImpl::WriteUriToDatabase(const std::string &key, const std::string &uri)
411 {
412 int32_t result = AudioStandard::AudioSystemManager::GetInstance()->SetSystemSoundUri(key, uri);
413 MEDIA_LOGI("WriteUriToDatabase: key: %{public}s, uri: %{public}s, result: %{public}d",
414 key.c_str(), uri.c_str(), result);
415 return result;
416 }
417
GetUriFromDatabase(const std::string & key)418 std::string SystemSoundManagerImpl::GetUriFromDatabase(const std::string &key)
419 {
420 std::string uri = AudioStandard::AudioSystemManager::GetInstance()->GetSystemSoundUri(key);
421
422 MEDIA_LOGI("GetUriFromDatabase: key [%{public}s], uri [%{public}s]", key.c_str(), uri.c_str());
423 return uri;
424 }
425
GetKeyForDatabase(const std::string & systemSoundType,int32_t type)426 std::string SystemSoundManagerImpl::GetKeyForDatabase(const std::string &systemSoundType, int32_t type)
427 {
428 if (systemSoundType == RING_TONE) {
429 switch (static_cast<RingtoneType>(type)) {
430 case RINGTONE_TYPE_SIM_CARD_0:
431 return "ringtone_for_sim_card_0";
432 case RINGTONE_TYPE_SIM_CARD_1:
433 return "ringtone_for_sim_card_1";
434 default:
435 MEDIA_LOGE("GetKeyForDatabase: ringtoneType %{public}d is unavailable", type);
436 return "";
437 }
438 } else if (systemSoundType == SYSTEM_TONE) {
439 switch (static_cast<SystemToneType>(type)) {
440 case SYSTEM_TONE_TYPE_SIM_CARD_0:
441 return "system_tone_for_sim_card_0";
442 case SYSTEM_TONE_TYPE_SIM_CARD_1:
443 return "system_tone_for_sim_card_1";
444 case SYSTEM_TONE_TYPE_NOTIFICATION:
445 return "system_tone_for_notification";
446 default:
447 MEDIA_LOGE("GetKeyForDatabase: systemToneType %{public}d is unavailable", type);
448 return "";
449 }
450 } else {
451 MEDIA_LOGE("GetKeyForDatabase: systemSoundType %{public}s is unavailable", systemSoundType.c_str());
452 return "";
453 }
454 }
455
UpdateRingtoneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const int32_t & toneId,RingtoneType ringtoneType,const int32_t & num)456 int32_t SystemSoundManagerImpl::UpdateRingtoneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
457 const int32_t &toneId, RingtoneType ringtoneType, const int32_t &num)
458 {
459 RingToneType type = RING_TONE_TYPE_SIM_CARD_1;
460 DataSharePredicates updateOnlyPredicates;
461 DataShareValuesBucket updateOnlyValuesBucket;
462 updateOnlyPredicates.SetWhereClause(RINGTONE_COLUMN_RING_TONE_TYPE + " = ? AND " +
463 RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = ? ");
464 updateOnlyPredicates.SetWhereArgs({to_string(ringtoneTypeMap_[ringtoneType]),
465 to_string(SOURCE_TYPE_CUSTOMISED)});
466 updateOnlyValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_TYPE, RING_TONE_TYPE_NOT);
467 updateOnlyValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
468 dataShareHelper->Update(RINGTONEURI, updateOnlyPredicates, updateOnlyValuesBucket);
469
470 DataSharePredicates updateBothPredicates;
471 DataShareValuesBucket updateBothValuesBucket;
472 if (ringtoneTypeMap_[ringtoneType] == RING_TONE_TYPE_SIM_CARD_1) {
473 type = RING_TONE_TYPE_SIM_CARD_2;
474 }
475 updateBothPredicates.SetWhereClause(RINGTONE_COLUMN_RING_TONE_TYPE + " = ? AND " +
476 RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = ? ");
477 updateBothPredicates.SetWhereArgs({to_string(RING_TONE_TYPE_SIM_CARD_BOTH),
478 to_string(SOURCE_TYPE_CUSTOMISED)});
479 updateBothValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_TYPE, type);
480 dataShareHelper->Update(RINGTONEURI, updateBothPredicates, updateBothValuesBucket);
481
482 DataSharePredicates updatePredicates;
483 DataShareValuesBucket updateValuesBucket;
484 if (((num == RING_TONE_TYPE_SIM_CARD_1 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
485 (ringtoneTypeMap_[ringtoneType] == RING_TONE_TYPE_SIM_CARD_2)) ||
486 ((num == RING_TONE_TYPE_SIM_CARD_2 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
487 (ringtoneTypeMap_[ringtoneType] == RING_TONE_TYPE_SIM_CARD_1))) {
488 type = RING_TONE_TYPE_SIM_CARD_BOTH;
489 } else {
490 type = ringtoneTypeMap_[ringtoneType];
491 }
492 updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
493 updatePredicates.SetWhereArgs({to_string(toneId)});
494 updateValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_TYPE, type);
495 updateValuesBucket.Put(RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
496 return dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
497 }
498
SetRingtoneUri(const shared_ptr<Context> & context,const string & uri,RingtoneType ringtoneType)499 int32_t SystemSoundManagerImpl::SetRingtoneUri(const shared_ptr<Context> &context, const string &uri,
500 RingtoneType ringtoneType)
501 {
502 std::lock_guard<std::mutex> lock(uriMutex_);
503 CHECK_AND_RETURN_RET_LOG(IsRingtoneTypeValid(ringtoneType), MSERR_INVALID_VAL, "Invalid ringtone type");
504
505 MEDIA_LOGI("SetRingtoneUri: ringtoneType %{public}d, uri %{public}s", ringtoneType, uri.c_str());
506 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
507 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
508 "Create dataShare failed, datashare or ringtone library error.");
509 DataShare::DatashareBusinessError businessError;
510 DataShare::DataSharePredicates queryPredicates;
511 DataShare::DataSharePredicates queryPredicatesByUri;
512 queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
513 auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
514 auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
515 unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
516 if (ringtoneAssetByUri == nullptr) {
517 resultSetByUri == nullptr ? : resultSetByUri->Close();
518 dataShareHelper->Release();
519 return ERROR;
520 }
521 resultSetByUri == nullptr ? : resultSetByUri->Close();
522 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_RINGTONE);
523 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
524 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
525 CHECK_AND_RETURN_RET_LOG(results != nullptr, ERROR, "query failed, ringtone library error.");
526 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
527 while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
528 ringtoneAsset = results->GetNextObject();
529 }
530 if (ringtoneAsset != nullptr) {
531 int32_t changedRows = UpdateRingtoneUri(dataShareHelper, ringtoneAsset->GetId(),
532 ringtoneType, ringtoneAsset->GetRingtoneType());
533 resultSet == nullptr ? : resultSet->Close();
534 return changedRows > 0 ? SUCCESS : ERROR;
535 }
536 resultSet == nullptr ? : resultSet->Close();
537 dataShareHelper->Release();
538 return TYPEERROR;
539 }
540
GetRingtoneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & type)541 std::string SystemSoundManagerImpl::GetRingtoneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
542 const std::string &type)
543 {
544 std::string uri = "";
545 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, uri,
546 "Invalid dataShare, datashare or ringtone library error.");
547 DataShare::DatashareBusinessError businessError;
548 DataShare::DataSharePredicates queryPredicates;
549 queryPredicates.SetWhereClause(RINGTONE_COLUMN_RING_TONE_TYPE + " = ? AND " +
550 RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " = ? ");
551 queryPredicates.SetWhereArgs({type, to_string(SOURCE_TYPE_CUSTOMISED)});
552 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
553 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
554 CHECK_AND_RETURN_RET_LOG(results != nullptr, uri, "query failed, ringtone library error.");
555 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
556 if (ringtoneAsset != nullptr) {
557 uri = ringtoneAsset->GetPath();
558 }
559 resultSet == nullptr ? : resultSet->Close();
560 return uri;
561 }
562
GetRingtoneUri(const shared_ptr<Context> & context,RingtoneType ringtoneType)563 std::string SystemSoundManagerImpl::GetRingtoneUri(const shared_ptr<Context> &context, RingtoneType ringtoneType)
564 {
565 CHECK_AND_RETURN_RET_LOG(IsRingtoneTypeValid(ringtoneType), "", "Invalid ringtone type");
566 std::string ringtoneUri = "";
567 MEDIA_LOGI("GetRingtoneUri: ringtoneType %{public}d", ringtoneType);
568 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
569 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, "",
570 "Create dataShare failed, datashare or ringtone library error.");
571 ringtoneUri = GetRingtoneUriByType(dataShareHelper, to_string(ringtoneTypeMap_[ringtoneType]));
572 if (ringtoneUri.empty()) {
573 ringtoneUri = GetRingtoneUriByType(dataShareHelper, to_string(RING_TONE_TYPE_SIM_CARD_BOTH));
574 }
575 if (ringtoneUri.empty()) {
576 std::shared_ptr<ToneAttrs> ringtoneAttrs = GetDefaultRingtoneAttrs(context, ringtoneType);
577 if (ringtoneAttrs != nullptr) {
578 ringtoneUri = ringtoneAttrs ->GetUri();
579 } else {
580 MEDIA_LOGE("GetRingtoneUri: no ringtone in the ringtone library!");
581 }
582 }
583 dataShareHelper->Release();
584 if (!ringtoneUri.empty()) {
585 MEDIA_LOGI("GetRingtoneUri: ringtoneUri %{public}s", ringtoneUri.c_str());
586 }
587 return ringtoneUri;
588 }
589
GetRingtoneTitle(const std::string & ringtoneUri)590 std::string SystemSoundManagerImpl::GetRingtoneTitle(const std::string &ringtoneUri)
591 {
592 std::lock_guard<std::mutex> lock(uriMutex_);
593 std::string ringtoneTitle = "";
594 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
595 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ringtoneUri,
596 "Create dataShare failed, datashare or ringtone library error.");
597 DataShare::DatashareBusinessError businessError;
598 DataShare::DataSharePredicates queryPredicatesByUri;
599 queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, ringtoneUri);
600 auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
601 auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
602 unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
603 if (ringtoneAssetByUri != nullptr) {
604 ringtoneTitle = ringtoneAssetByUri->GetTitle();
605 }
606 resultSetByUri == nullptr ? : resultSetByUri->Close();
607 dataShareHelper->Release();
608 return ringtoneTitle;
609 }
610
GetRingtonePlayer(const shared_ptr<Context> & context,RingtoneType ringtoneType)611 std::shared_ptr<RingtonePlayer> SystemSoundManagerImpl::GetRingtonePlayer(const shared_ptr<Context> &context,
612 RingtoneType ringtoneType)
613 {
614 std::lock_guard<std::mutex> lock(playerMutex_);
615 CHECK_AND_RETURN_RET_LOG(IsRingtoneTypeValid(ringtoneType), nullptr, "invalid ringtone type");
616 MEDIA_LOGI("GetRingtonePlayer: for ringtoneType %{public}d", ringtoneType);
617
618 std::shared_ptr<RingtonePlayer> ringtonePlayer = std::make_shared<RingtonePlayerImpl>(context, *this, ringtoneType);
619 CHECK_AND_RETURN_RET_LOG(ringtonePlayer != nullptr, nullptr,
620 "Failed to create ringtone player object");
621 return ringtonePlayer;
622 }
623
GetSystemTonePlayer(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)624 std::shared_ptr<SystemTonePlayer> SystemSoundManagerImpl::GetSystemTonePlayer(
625 const std::shared_ptr<AbilityRuntime::Context> &context, SystemToneType systemToneType)
626 {
627 std::lock_guard<std::mutex> lock(playerMutex_);
628 CHECK_AND_RETURN_RET_LOG(IsSystemToneTypeValid(systemToneType), nullptr, "invalid system tone type");
629 MEDIA_LOGI("GetSystemTonePlayer: for systemToneType %{public}d", systemToneType);
630
631 std::shared_ptr<SystemTonePlayer> systemTonePlayer =
632 std::make_shared<SystemTonePlayerImpl>(context, *this, systemToneType);
633 CHECK_AND_RETURN_RET_LOG(systemTonePlayer != nullptr, nullptr,
634 "Failed to create system tone player object");
635 return systemTonePlayer;
636 }
637
UpdateShotToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const int32_t & toneId,SystemToneType systemToneType,const int32_t & num)638 int32_t SystemSoundManagerImpl::UpdateShotToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
639 const int32_t &toneId, SystemToneType systemToneType, const int32_t &num)
640 {
641 ShotToneType type = SHOT_TONE_TYPE_SIM_CARD_1;
642 DataSharePredicates updateOnlyPredicates;
643 DataShareValuesBucket updateOnlyValuesBucket;
644 updateOnlyPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
645 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
646 updateOnlyPredicates.SetWhereArgs({to_string(systemTypeMap_[systemToneType]),
647 to_string(SOURCE_TYPE_CUSTOMISED)});
648 updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, RING_TONE_TYPE_NOT);
649 updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
650 dataShareHelper->Update(RINGTONEURI, updateOnlyPredicates, updateOnlyValuesBucket);
651
652 DataSharePredicates updateBothPredicates;
653 DataShareValuesBucket updateBothValuesBucket;
654 if (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_1) {
655 type = SHOT_TONE_TYPE_SIM_CARD_2;
656 }
657 updateBothPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
658 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
659 updateBothPredicates.SetWhereArgs({to_string(SHOT_TONE_TYPE_SIM_CARD_BOTH),
660 to_string(SOURCE_TYPE_CUSTOMISED)});
661 updateBothValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, type);
662 dataShareHelper->Update(RINGTONEURI, updateBothPredicates, updateBothValuesBucket);
663
664 DataSharePredicates updatePredicates;
665 DataShareValuesBucket updateValuesBucket;
666 if (((num == SHOT_TONE_TYPE_SIM_CARD_1 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
667 (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_2)) ||
668 ((num == SHOT_TONE_TYPE_SIM_CARD_2 || num == RING_TONE_TYPE_SIM_CARD_BOTH) &&
669 (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_1))) {
670 type = SHOT_TONE_TYPE_SIM_CARD_BOTH;
671 } else {
672 type = shotToneTypeMap_[systemToneType];
673 }
674 updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
675 updatePredicates.SetWhereArgs({to_string(toneId)});
676 updateValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, type);
677 updateValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
678 return dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
679 }
680
UpdateNotificatioToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const int32_t & toneId)681 int32_t SystemSoundManagerImpl::UpdateNotificatioToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
682 const int32_t &toneId)
683 {
684 DataSharePredicates updateOldPredicates;
685 DataShareValuesBucket updateOldValuesBucket;
686 updateOldPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
687 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
688 updateOldPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(SOURCE_TYPE_CUSTOMISED)});
689 updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE, NOTIFICATION_TONE_TYPE_NOT);
690 updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
691 dataShareHelper->Update(RINGTONEURI, updateOldPredicates, updateOldValuesBucket);
692
693 DataSharePredicates updatePredicates;
694 DataShareValuesBucket updateValuesBucket;
695 updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
696 updatePredicates.SetWhereArgs({to_string(toneId)});
697 updateValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE, NOTIFICATION_TONE_TYPE);
698 updateValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
699 return dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
700 }
701
SetNoSystemToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,SystemToneType systemToneType)702 int32_t SystemSoundManagerImpl::SetNoSystemToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
703 SystemToneType systemToneType)
704 {
705 MEDIA_LOGI("Set no audio uri for system tone type %{public}d", systemToneType);
706 int32_t result = 0;
707 // Removes the flag for the current system tone uri.
708 result += RemoveSourceTypeForSystemTone(dataShareHelper, systemToneType, SOURCE_TYPE_CUSTOMISED);
709 // Removes the flag for the preset system tone uri.
710 result += RemoveSourceTypeForSystemTone(dataShareHelper, systemToneType, SOURCE_TYPE_PRESET);
711 return result;
712 }
713
RemoveSourceTypeForSystemTone(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,SystemToneType systemToneType,SourceType sourceType)714 int32_t SystemSoundManagerImpl::RemoveSourceTypeForSystemTone(
715 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, SystemToneType systemToneType, SourceType sourceType)
716 {
717 int32_t result = 0;
718 switch (systemToneType) {
719 case SYSTEM_TONE_TYPE_SIM_CARD_0:
720 case SYSTEM_TONE_TYPE_SIM_CARD_1: {
721 // SIM_CARD_0 or SIM_CARD_1
722 DataSharePredicates updateOnlyPredicates;
723 DataShareValuesBucket updateOnlyValuesBucket;
724 updateOnlyPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
725 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
726 updateOnlyPredicates.SetWhereArgs({to_string(systemTypeMap_[systemToneType]), to_string(sourceType)});
727 updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, RING_TONE_TYPE_NOT);
728 updateOnlyValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
729 result += dataShareHelper->Update(RINGTONEURI, updateOnlyPredicates, updateOnlyValuesBucket);
730 // both SIM_CARD_0 and SIM_CARD_1
731 DataSharePredicates updateBothPredicates;
732 DataShareValuesBucket updateBothValuesBucket;
733 ShotToneType type = SHOT_TONE_TYPE_SIM_CARD_1;
734 if (systemTypeMap_[systemToneType] == SHOT_TONE_TYPE_SIM_CARD_1) {
735 type = SHOT_TONE_TYPE_SIM_CARD_2;
736 }
737 updateBothPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
738 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
739 updateBothPredicates.SetWhereArgs({to_string(SHOT_TONE_TYPE_SIM_CARD_BOTH), to_string(sourceType)});
740 updateBothValuesBucket.Put(RINGTONE_COLUMN_SHOT_TONE_TYPE, type);
741 result += dataShareHelper->Update(RINGTONEURI, updateBothPredicates, updateBothValuesBucket);
742 break;
743 }
744 case SYSTEM_TONE_TYPE_NOTIFICATION: {
745 DataSharePredicates updateOldPredicates;
746 DataShareValuesBucket updateOldValuesBucket;
747 updateOldPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
748 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
749 updateOldPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(sourceType)});
750 updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE, NOTIFICATION_TONE_TYPE_NOT);
751 updateOldValuesBucket.Put(RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
752 result += dataShareHelper->Update(RINGTONEURI, updateOldPredicates, updateOldValuesBucket);
753 break;
754 }
755 default:
756 MEDIA_LOGE("The system tone type [%{public}d] is invalid!", systemToneType);
757 break;
758 }
759 return result;
760 }
761
SetSystemToneUri(const shared_ptr<Context> & context,const string & uri,SystemToneType systemToneType)762 int32_t SystemSoundManagerImpl::SetSystemToneUri(const shared_ptr<Context> &context, const string &uri,
763 SystemToneType systemToneType)
764 {
765 std::lock_guard<std::mutex> lock(uriMutex_);
766 CHECK_AND_RETURN_RET_LOG(IsSystemToneTypeValid(systemToneType), MSERR_INVALID_VAL, "Invalid system tone type");
767
768 MEDIA_LOGI("SetSystemToneUri: systemToneType %{public}d, uri %{public}s", systemToneType, uri.c_str());
769 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
770 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
771 "Create dataShare failed, datashare or ringtone library error.");
772
773 if (uri == NO_SYSTEM_SOUND) {
774 int32_t changedRows = SetNoSystemToneUri(dataShareHelper, systemToneType);
775 MEDIA_LOGI("SetNoSystemToneUri result: changedRows %{public}d", changedRows);
776 dataShareHelper->Release();
777 return SUCCESS;
778 }
779
780 DataShare::DatashareBusinessError businessError;
781 DataShare::DataSharePredicates queryPredicates;
782 DataShare::DataSharePredicates queryPredicatesByUri;
783 queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
784 auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
785 auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
786 unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
787 if (ringtoneAssetByUri == nullptr) {
788 resultSetByUri == nullptr ? : resultSetByUri->Close();
789 dataShareHelper->Release();
790 MEDIA_LOGE("Failed to find the uri in ringtone library!");
791 return ERROR;
792 }
793 resultSetByUri == nullptr ? : resultSetByUri->Close();
794 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_NOTIFICATION);
795 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
796 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
797 CHECK_AND_RETURN_RET_LOG(results != nullptr, ERROR, "query failed, ringtone library error.");
798 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
799 while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
800 ringtoneAsset = results->GetNextObject();
801 }
802 if (ringtoneAsset != nullptr) {
803 int32_t changedRows = 0;
804 if (systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION) {
805 changedRows = UpdateNotificatioToneUri(dataShareHelper, ringtoneAsset->GetId());
806 } else {
807 changedRows = UpdateShotToneUri(dataShareHelper, ringtoneAsset->GetId(),
808 systemToneType, ringtoneAsset->GetShottoneType());
809 }
810 resultSet == nullptr ? : resultSet->Close();
811 return changedRows > 0 ? SUCCESS : ERROR;
812 }
813 resultSet == nullptr ? : resultSet->Close();
814 dataShareHelper->Release();
815 return TYPEERROR;
816 }
817
GetShotToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & type)818 std::string SystemSoundManagerImpl::GetShotToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
819 const std::string &type)
820 {
821 std::string uri = "";
822 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, uri,
823 "Invalid dataShare, datashare or ringtone library error.");
824 DataShare::DatashareBusinessError businessError;
825 DataShare::DataSharePredicates queryPredicates;
826 queryPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
827 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
828 queryPredicates.SetWhereArgs({type, to_string(SOURCE_TYPE_CUSTOMISED)});
829 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
830 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
831 CHECK_AND_RETURN_RET_LOG(results != nullptr, uri, "query failed, ringtone library error.");
832 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
833 if (ringtoneAsset != nullptr) {
834 uri = ringtoneAsset->GetPath();
835 }
836 resultSet == nullptr ? : resultSet->Close();
837 return uri;
838 }
839
GetPresetShotToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & type)840 std::string SystemSoundManagerImpl::GetPresetShotToneUriByType(
841 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, const std::string &type)
842 {
843 std::string uri = "";
844 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, uri,
845 "Invalid dataShare, datashare or ringtone library error.");
846 DataShare::DatashareBusinessError businessError;
847 DataShare::DataSharePredicates queryPredicates;
848 queryPredicates.SetWhereClause(RINGTONE_COLUMN_SHOT_TONE_TYPE + " = ? AND " +
849 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " = ? ");
850 queryPredicates.SetWhereArgs({type, to_string(SOURCE_TYPE_PRESET)});
851 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
852 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
853 CHECK_AND_RETURN_RET_LOG(results != nullptr, uri, "query failed, ringtone library error.");
854 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
855 if (ringtoneAsset != nullptr) {
856 uri = ringtoneAsset->GetPath();
857 }
858 resultSet == nullptr ? : resultSet->Close();
859 return uri;
860 }
861
GetNotificationToneUriByType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)862 std::string SystemSoundManagerImpl::GetNotificationToneUriByType(
863 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)
864 {
865 std::string uri = "";
866 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, uri,
867 "Invalid dataShare, datashare or ringtone library error.");
868 DataShare::DatashareBusinessError businessError;
869 DataShare::DataSharePredicates queryPredicates;
870 queryPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
871 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
872 queryPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(SOURCE_TYPE_CUSTOMISED)});
873 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
874 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
875 CHECK_AND_RETURN_RET_LOG(results != nullptr, uri, "query failed, ringtone library error.");
876 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
877 if (ringtoneAsset != nullptr) {
878 uri = ringtoneAsset->GetPath();
879 }
880 resultSet == nullptr ? : resultSet->Close();
881 return uri;
882 }
883
GetPresetNotificationToneUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)884 std::string SystemSoundManagerImpl::GetPresetNotificationToneUri(
885 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper)
886 {
887 std::string uri = "";
888 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, uri,
889 "Invalid dataShare, datashare or ringtone library error.");
890 DataShare::DatashareBusinessError businessError;
891 DataShare::DataSharePredicates queryPredicates;
892 queryPredicates.SetWhereClause(RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " = ? AND " +
893 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " = ? ");
894 queryPredicates.SetWhereArgs({to_string(NOTIFICATION_TONE_TYPE), to_string(SOURCE_TYPE_PRESET)});
895 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
896 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
897 CHECK_AND_RETURN_RET_LOG(results != nullptr, uri, "query failed, ringtone library error.");
898 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
899 if (ringtoneAsset != nullptr) {
900 uri = ringtoneAsset->GetPath();
901 }
902 resultSet == nullptr ? : resultSet->Close();
903 return uri;
904 }
905
GetSystemToneUri(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)906 std::string SystemSoundManagerImpl::GetSystemToneUri(const std::shared_ptr<AbilityRuntime::Context> &context,
907 SystemToneType systemToneType)
908 {
909 CHECK_AND_RETURN_RET_LOG(IsSystemToneTypeValid(systemToneType), "", "Invalid system tone type");
910 std::string systemToneUri = "";
911 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
912 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, "",
913 "Create dataShare failed, datashare or ringtone library error.");
914 switch (systemToneType) {
915 case SYSTEM_TONE_TYPE_SIM_CARD_0:
916 case SYSTEM_TONE_TYPE_SIM_CARD_1:
917 systemToneUri = GetShotToneUriByType(dataShareHelper, to_string(systemTypeMap_[systemToneType]));
918 if (systemToneUri.empty()) {
919 systemToneUri = GetShotToneUriByType(dataShareHelper, to_string(RING_TONE_TYPE_SIM_CARD_BOTH));
920 }
921 if (systemToneUri.empty()) {
922 systemToneUri = GetPresetShotToneUriByType(dataShareHelper, to_string(systemTypeMap_[systemToneType]));
923 }
924 if (systemToneUri.empty()) {
925 systemToneUri = GetPresetShotToneUriByType(dataShareHelper, to_string(RING_TONE_TYPE_SIM_CARD_BOTH));
926 }
927 break;
928 case SYSTEM_TONE_TYPE_NOTIFICATION:
929 systemToneUri = GetNotificationToneUriByType(dataShareHelper);
930 if (systemToneUri.empty()) {
931 systemToneUri = GetPresetNotificationToneUri(dataShareHelper);
932 }
933 break;
934 default:
935 break;
936 }
937 if (systemToneUri.empty()) {
938 MEDIA_LOGI("No system tone uri for type %{public}d. Return NO_SYSTEM_SOUND", systemToneType);
939 return NO_SYSTEM_SOUND;
940 }
941 dataShareHelper->Release();
942 MEDIA_LOGI("Finish to get system tone uri: type %{public}d, uri %{public}s", systemToneType, systemToneUri.c_str());
943 return systemToneUri;
944 }
945
GetDefaultRingtoneAttrs(const shared_ptr<Context> & context,RingtoneType ringtoneType)946 std::shared_ptr<ToneAttrs> SystemSoundManagerImpl::GetDefaultRingtoneAttrs(
947 const shared_ptr<Context> &context, RingtoneType ringtoneType)
948 {
949 MEDIA_LOGI("GetDefaultRingtoneAttrs : Enter the getDefaultRingtoneAttrs interface");
950 std::lock_guard<std::mutex> lock(uriMutex_);
951 CHECK_AND_RETURN_RET_LOG(IsRingtoneTypeValid(ringtoneType), nullptr, "Invalid ringtone type");
952 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
953 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, nullptr,
954 "Create dataShare failed, datashare or ringtone library error.");
955 DataShare::DatashareBusinessError businessError;
956 DataShare::DataSharePredicates queryPredicates;
957 std::vector<std::string> onClause;
958 onClause.push_back("ToneFiles.tone_id = PreloadConfig.tone_id");
959 queryPredicates.InnerJoin("PreloadConfig")->On(onClause)->EqualTo("PreloadConfig.ring_tone_type",
960 defaultoneTypeMap_[ringtoneType]);
961 ringtoneAttrs_ = nullptr;
962 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, JOIN_COLUMNS, &businessError);
963 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
964 CHECK_AND_RETURN_RET_LOG(results != nullptr, nullptr, "single sim card failed, ringtone library error.");
965 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
966 while ((ringtoneAsset != nullptr) && (TONE_TYPE_RINGTONE != ringtoneAsset->GetToneType())) {
967 ringtoneAsset = results->GetNextObject();
968 }
969 if (ringtoneAsset != nullptr) {
970 ringtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
971 ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
972 sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_RINGTONE);
973 MEDIA_LOGI("RingtoneAttrs_ : DisplayName = %{public}s, Path = %{public}s , Title = %{public}s",
974 ringtoneAsset->GetDisplayName().c_str(), ringtoneAsset->GetPath().c_str(),
975 ringtoneAsset->GetTitle().c_str());
976 } else {
977 MEDIA_LOGE("GetDefaultRingtoneAttrs: no single card default ringtone in the ringtone library!");
978 }
979 resultSet == nullptr ? : resultSet->Close();
980 dataShareHelper->Release();
981 return ringtoneAttrs_;
982 }
983
GetRingtoneAttrList(const std::shared_ptr<AbilityRuntime::Context> & context,RingtoneType ringtoneType)984 std::vector<std::shared_ptr<ToneAttrs>> SystemSoundManagerImpl::GetRingtoneAttrList(
985 const std::shared_ptr<AbilityRuntime::Context> &context, RingtoneType ringtoneType)
986 {
987 MEDIA_LOGI("GetRingtoneAttrList : Enter the getRingtoneAttrList interface");
988 std::lock_guard<std::mutex> lock(uriMutex_);
989 ringtoneAttrsArray_.clear();
990 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
991 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ringtoneAttrsArray_,
992 "Create dataShare failed, datashare or ringtone library error.");
993 DataShare::DatashareBusinessError businessError;
994 DataShare::DataSharePredicates queryPredicates;
995 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TONE_TYPE_RINGTONE));
996 queryPredicates.GreaterThan(RINGTONE_COLUMN_MEDIA_TYPE, to_string(RINGTONE_MEDIA_TYPE_INVALID));
997 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
998 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
999 CHECK_AND_RETURN_RET_LOG(results != nullptr, ringtoneAttrsArray_, "query failed, ringtone library error.");
1000 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1001 while (ringtoneAsset != nullptr) {
1002 ringtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
1003 ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
1004 sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_RINGTONE);
1005 ringtoneAttrsArray_.push_back(ringtoneAttrs_);
1006 ringtoneAsset = results->GetNextObject();
1007 }
1008 if (ringtoneAsset != nullptr) {
1009 MEDIA_LOGI("RingtoneAttrsArray_ : DisplayName = %{public}s, Path = %{public}s",
1010 ringtoneAsset->GetDisplayName().c_str(), ringtoneAsset->GetPath().c_str());
1011 }
1012 if (ringtoneAttrsArray_.empty()) {
1013 MEDIA_LOGE("GetRingtoneAttrList: no ringtone in the ringtone library!");
1014 }
1015 resultSet == nullptr ? : resultSet->Close();
1016 dataShareHelper->Release();
1017 return ringtoneAttrsArray_;
1018 }
1019
GetDefaultSystemToneAttrs(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)1020 std::shared_ptr<ToneAttrs> SystemSoundManagerImpl::GetDefaultSystemToneAttrs(
1021 const std::shared_ptr<AbilityRuntime::Context> &context, SystemToneType systemToneType)
1022 {
1023 MEDIA_LOGI("GetDefaultSystemToneAttrs : Enter the getDefaultSystemToneAttrs interface");
1024 std::lock_guard<std::mutex> lock(uriMutex_);
1025 CHECK_AND_RETURN_RET_LOG(IsSystemToneTypeValid(systemToneType), nullptr, "Invalid systemtone type");
1026 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1027 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, nullptr,
1028 "Create dataShare failed, datashare or ringtone library error.");
1029 std::string ringToneType = systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
1030 RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE : RINGTONE_COLUMN_SHOT_TONE_TYPE;
1031 int32_t category = systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
1032 TONE_CATEGORY_NOTIFICATION : TONE_CATEGORY_TEXT_MESSAGE;
1033 DataShare::DatashareBusinessError businessError;
1034 DataShare::DataSharePredicates queryPredicates;
1035 systemtoneAttrs_ = nullptr;
1036 std::vector<std::string> onClause;
1037 onClause.push_back("ToneFiles.tone_id = PreloadConfig.tone_id");
1038 queryPredicates.InnerJoin("PreloadConfig")->On(onClause)->EqualTo("PreloadConfig.ring_tone_type",
1039 defaultsystemTypeMap_[systemToneType]);
1040 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, JOIN_COLUMNS, &businessError);
1041 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1042 CHECK_AND_RETURN_RET_LOG(results != nullptr, nullptr, "query single systemtone failed, ringtone library error.");
1043 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1044 while ((ringtoneAsset != nullptr) && IsSystemToneType(ringtoneAsset, systemToneType)) {
1045 ringtoneAsset = results->GetNextObject();
1046 }
1047 if (ringtoneAsset != nullptr) {
1048 systemtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
1049 ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
1050 sourceTypeMap_[ringtoneAsset->GetSourceType()], category);
1051 MEDIA_LOGI("SystemtoneAttrs_ : DisplayName = %{public}s, Path = %{public}s , Title = %{public}s",
1052 ringtoneAsset->GetDisplayName().c_str(), ringtoneAsset->GetPath().c_str(),
1053 ringtoneAsset->GetTitle().c_str());
1054 } else {
1055 MEDIA_LOGE("GetDefaultSystemToneAttrs: no single default systemtone in the ringtone library!");
1056 }
1057 resultSet == nullptr ? : resultSet->Close();
1058 dataShareHelper->Release();
1059 return systemtoneAttrs_;
1060 }
1061
GetSystemToneAttrList(const std::shared_ptr<AbilityRuntime::Context> & context,SystemToneType systemToneType)1062 std::vector<std::shared_ptr<ToneAttrs>> SystemSoundManagerImpl::GetSystemToneAttrList(
1063 const std::shared_ptr<AbilityRuntime::Context> &context, SystemToneType systemToneType)
1064 {
1065 std::lock_guard<std::mutex> lock(uriMutex_);
1066 systemtoneAttrsArray_.clear();
1067 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1068 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, systemtoneAttrsArray_,
1069 "Create dataShare failed, datashare or ringtone library error.");
1070 int32_t category = systemToneType == SYSTEM_TONE_TYPE_NOTIFICATION ?
1071 TONE_CATEGORY_NOTIFICATION : TONE_CATEGORY_TEXT_MESSAGE;
1072 DataShare::DatashareBusinessError businessError;
1073 DataShare::DataSharePredicates queryPredicates;
1074 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TONE_TYPE_NOTIFICATION));
1075 queryPredicates.GreaterThan(RINGTONE_COLUMN_MEDIA_TYPE, to_string(RINGTONE_MEDIA_TYPE_INVALID));
1076 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1077 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1078 CHECK_AND_RETURN_RET_LOG(results != nullptr, systemtoneAttrsArray_, "query failed, ringtone library error.");
1079 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1080 while (ringtoneAsset != nullptr) {
1081 systemtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
1082 ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
1083 sourceTypeMap_[ringtoneAsset->GetSourceType()], category);
1084 systemtoneAttrsArray_.push_back(systemtoneAttrs_);
1085 ringtoneAsset = results->GetNextObject();
1086 }
1087 if (systemtoneAttrsArray_.empty()) {
1088 MEDIA_LOGE("GetSystemToneAttrList: no systemtone in the ringtone library!");
1089 }
1090 resultSet == nullptr ? : resultSet->Close();
1091 dataShareHelper->Release();
1092 return systemtoneAttrsArray_;
1093 }
1094
SetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & uri)1095 int32_t SystemSoundManagerImpl::SetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> &context,
1096 const std::string &uri)
1097 {
1098 std::lock_guard<std::mutex> lock(uriMutex_);
1099 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1100 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
1101 "Create dataShare failed, datashare or ringtone library error.");
1102 DataShare::DatashareBusinessError businessError;
1103 DataShare::DataSharePredicates queryPredicates;
1104 DataShare::DataSharePredicates queryPredicatesByUri;
1105 queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
1106 auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
1107 auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
1108 unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
1109 if (ringtoneAssetByUri == nullptr) {
1110 resultSetByUri == nullptr ? : resultSetByUri->Close();
1111 dataShareHelper->Release();
1112 return ERROR;
1113 }
1114 resultSetByUri == nullptr ? : resultSetByUri->Close();
1115 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_ALARM);
1116 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1117 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1118 CHECK_AND_RETURN_RET_LOG(results != nullptr, ERROR, "query failed, ringtone library error.");
1119 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1120 while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
1121 ringtoneAsset = results->GetNextObject();
1122 }
1123 if (ringtoneAsset != nullptr) {
1124 DataSharePredicates updateOldPredicates;
1125 DataShareValuesBucket updateOldValuesBucket;
1126 updateOldPredicates.SetWhereClause(RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " = ? ");
1127 updateOldPredicates.SetWhereArgs({to_string(SOURCE_TYPE_CUSTOMISED)});
1128 updateOldValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_TYPE, ALARM_TONE_TYPE_NOT);
1129 updateOldValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE, SOURCE_TYPE_INVALID);
1130 dataShareHelper->Update(RINGTONEURI, updateOldPredicates, updateOldValuesBucket);
1131 DataSharePredicates updatePredicates;
1132 DataShareValuesBucket updateValuesBucket;
1133 updatePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
1134 updatePredicates.SetWhereArgs({to_string(ringtoneAsset->GetId())});
1135 updateValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_TYPE, ALARM_TONE_TYPE);
1136 updateValuesBucket.Put(RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE, SOURCE_TYPE_CUSTOMISED);
1137 int32_t changedRows = dataShareHelper->Update(RINGTONEURI, updatePredicates, updateValuesBucket);
1138 resultSet == nullptr ? : resultSet->Close();
1139 dataShareHelper->Release();
1140 return changedRows > 0 ? SUCCESS : ERROR;
1141 }
1142 resultSet == nullptr ? : resultSet->Close();
1143 dataShareHelper->Release();
1144 return TYPEERROR;
1145 }
1146
GetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> & context)1147 std::string SystemSoundManagerImpl::GetAlarmToneUri(const std::shared_ptr<AbilityRuntime::Context> &context)
1148 {
1149 int32_t count = 2;
1150 std::string alarmToneUri = "";
1151 std::lock_guard<std::mutex> lock(uriMutex_);
1152 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1153 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, alarmToneUri,
1154 "Create dataShare failed, datashare or ringtone library error.");
1155 DataShare::DatashareBusinessError businessError;
1156 DataShare::DataSharePredicates queryPredicates;
1157 queryPredicates.EqualTo(RINGTONE_COLUMN_ALARM_TONE_TYPE, to_string(ALARM_TONE_TYPE));
1158 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1159 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1160 CHECK_AND_RETURN_RET_LOG(results != nullptr, alarmToneUri, "query failed, ringtone library error.");
1161 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1162 while ((ringtoneAsset != nullptr) && (SOURCE_TYPE_CUSTOMISED !=
1163 ringtoneAsset->GetAlarmtoneSourceType()) && (results->GetCount() == count)) {
1164 ringtoneAsset = results->GetNextObject();
1165 }
1166 if (ringtoneAsset != nullptr) {
1167 alarmToneUri = ringtoneAsset->GetPath();
1168 } else {
1169 MEDIA_LOGE("GetAlarmToneUri: no alarmtone in the ringtone library!");
1170 }
1171 resultSet == nullptr ? : resultSet->Close();
1172 dataShareHelper->Release();
1173 return alarmToneUri;
1174 }
1175
GetDefaultAlarmToneAttrs(const std::shared_ptr<AbilityRuntime::Context> & context)1176 std::shared_ptr<ToneAttrs> SystemSoundManagerImpl::GetDefaultAlarmToneAttrs(
1177 const std::shared_ptr<AbilityRuntime::Context> &context)
1178 {
1179 MEDIA_LOGI("GetDefaultAlarmToneAttrs : Enter the getDefaultAlarmToneAttrs interface");
1180 std::lock_guard<std::mutex> lock(uriMutex_);
1181 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1182 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, nullptr,
1183 "Create dataShare failed, datashare or ringtone library error.");
1184 DataShare::DatashareBusinessError businessError;
1185 DataShare::DataSharePredicates queryPredicates;
1186 alarmtoneAttrs_ = nullptr;
1187 std::vector<std::string> onClause;
1188 onClause.push_back(RINGTONE_TABLE + "." + RINGTONE_COLUMN_TONE_ID + "=" +
1189 PRELOAD_CONFIG_TABLE + "." + PRELOAD_CONFIG_COLUMN_TONE_ID);
1190 queryPredicates.InnerJoin(PRELOAD_CONFIG_TABLE)->On(onClause)->EqualTo(
1191 PRELOAD_CONFIG_TABLE + "." + PRELOAD_CONFIG_COLUMN_RING_TONE_TYPE, DEFAULT_ALARM_TYPE);
1192 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, JOIN_COLUMNS, &businessError);
1193 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1194 CHECK_AND_RETURN_RET_LOG(results != nullptr, nullptr, "query failed, ringtone library error.");
1195 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1196 while ((ringtoneAsset != nullptr) && (TONE_TYPE_ALARM != ringtoneAsset->GetToneType())) {
1197 ringtoneAsset = results->GetNextObject();
1198 }
1199 if (ringtoneAsset != nullptr) {
1200 alarmtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
1201 ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
1202 sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_ALARM);
1203 MEDIA_LOGI("AlarmtoneAttrs_ : DisplayName = %{public}s, Path = %{public}s , Title = %{public}s",
1204 ringtoneAsset->GetDisplayName().c_str(), ringtoneAsset->GetPath().c_str(),
1205 ringtoneAsset->GetTitle().c_str());
1206 } else {
1207 MEDIA_LOGE("GetDefaultAlarmToneAttrs: no default alarmtone in the ringtone library!");
1208 }
1209 resultSet == nullptr ? : resultSet->Close();
1210 dataShareHelper->Release();
1211 return alarmtoneAttrs_;
1212 }
1213
GetAlarmToneAttrList(const std::shared_ptr<AbilityRuntime::Context> & context)1214 std::vector<std::shared_ptr<ToneAttrs>> SystemSoundManagerImpl::GetAlarmToneAttrList
1215 (const std::shared_ptr<AbilityRuntime::Context> &context)
1216 {
1217 std::lock_guard<std::mutex> lock(uriMutex_);
1218 alarmtoneAttrsArray_.clear();
1219 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1220 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, alarmtoneAttrsArray_,
1221 "Create dataShare failed, datashare or ringtone library error.");
1222 DataShare::DatashareBusinessError businessError;
1223 DataShare::DataSharePredicates queryPredicates;
1224 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, to_string(TONE_TYPE_ALARM));
1225 queryPredicates.GreaterThan(RINGTONE_COLUMN_MEDIA_TYPE, to_string(RINGTONE_MEDIA_TYPE_INVALID));
1226 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1227 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1228 CHECK_AND_RETURN_RET_LOG(results != nullptr, alarmtoneAttrsArray_, "query failed, ringtone library error.");
1229 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1230 while (ringtoneAsset != nullptr) {
1231 alarmtoneAttrs_ = std::make_shared<ToneAttrs>(ringtoneAsset->GetTitle(),
1232 ringtoneAsset->GetDisplayName(), ringtoneAsset->GetPath(),
1233 sourceTypeMap_[ringtoneAsset->GetSourceType()], TONE_CATEGORY_ALARM);
1234 alarmtoneAttrsArray_.push_back(alarmtoneAttrs_);
1235 ringtoneAsset = results->GetNextObject();
1236 }
1237 if (alarmtoneAttrsArray_.empty()) {
1238 MEDIA_LOGE("GetAlarmToneAttrList: no alarmtone in the ringtone library!");
1239 }
1240 resultSet == nullptr ? : resultSet->Close();
1241 dataShareHelper->Release();
1242 return alarmtoneAttrsArray_;
1243 }
1244
OpenAlarmTone(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & uri)1245 int32_t SystemSoundManagerImpl::OpenAlarmTone(const std::shared_ptr<AbilityRuntime::Context> &context,
1246 const std::string &uri)
1247 {
1248 std::lock_guard<std::mutex> lock(uriMutex_);
1249 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1250 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
1251 "Create dataShare failed, datashare or ringtone library error.");
1252 DataShare::DatashareBusinessError businessError;
1253 DataShare::DataSharePredicates queryPredicates;
1254 DataShare::DataSharePredicates queryPredicatesByUri;
1255 queryPredicatesByUri.EqualTo(RINGTONE_COLUMN_DATA, uri);
1256 auto resultSetByUri = dataShareHelper->Query(RINGTONEURI, queryPredicatesByUri, COLUMNS, &businessError);
1257 auto resultsByUri = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSetByUri));
1258 unique_ptr<RingtoneAsset> ringtoneAssetByUri = resultsByUri->GetFirstObject();
1259 if (ringtoneAssetByUri == nullptr) {
1260 MEDIA_LOGE("OpenAlarmTone: tone of uri is not in the ringtone library!");
1261 resultSetByUri == nullptr ? : resultSetByUri->Close();
1262 dataShareHelper->Release();
1263 return ERROR;
1264 }
1265 resultSetByUri == nullptr ? : resultSetByUri->Close();
1266 queryPredicates.EqualTo(RINGTONE_COLUMN_TONE_TYPE, TONE_TYPE_ALARM);
1267 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1268 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1269 CHECK_AND_RETURN_RET_LOG(results != nullptr, ERROR, "query failed, ringtone library error.");
1270 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1271 while ((ringtoneAsset != nullptr) && (uri != ringtoneAsset->GetPath())) {
1272 ringtoneAsset = results->GetNextObject();
1273 }
1274 if (ringtoneAsset != nullptr) {
1275 string uriStr = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(ringtoneAsset->GetId());
1276 Uri ofUri(uriStr);
1277 int32_t fd = dataShareHelper->OpenFile(ofUri, "r");
1278 resultSet == nullptr ? : resultSet->Close();
1279 dataShareHelper->Release();
1280 return fd > 0 ? fd : ERROR;
1281 }
1282 MEDIA_LOGE("OpenAlarmTone: tone of uri is not alarm!");
1283 resultSet == nullptr ? : resultSet->Close();
1284 dataShareHelper->Release();
1285 return TYPEERROR;
1286 }
1287
Close(const int32_t & fd)1288 int32_t SystemSoundManagerImpl::Close(const int32_t &fd)
1289 {
1290 std::lock_guard<std::mutex> lock(uriMutex_);
1291 return close(fd);
1292 }
1293
AddCustomizedToneByExternalUri(const std::shared_ptr<AbilityRuntime::Context> & context,const std::shared_ptr<ToneAttrs> & toneAttrs,const std::string & externalUri)1294 std::string SystemSoundManagerImpl::AddCustomizedToneByExternalUri(
1295 const std::shared_ptr<AbilityRuntime::Context> &context, const std::shared_ptr<ToneAttrs> &toneAttrs,
1296 const std::string &externalUri)
1297 {
1298 std::string fdHead = "fd://";
1299 std::string srcPath = externalUri;
1300 int32_t srcFd;
1301 if (srcPath.find(fdHead) != std::string::npos) {
1302 StrToInt(srcPath.substr(fdHead.size()), srcFd);
1303 } else {
1304 srcFd = open(srcPath.c_str(), O_RDONLY);
1305 }
1306 if (srcFd < 0) {
1307 MEDIA_LOGE("AddCustomizedTone: fd open error is %{public}s", strerror(errno));
1308 fdHead.clear();
1309 return fdHead;
1310 }
1311 return AddCustomizedToneByFd(context, toneAttrs, srcFd);
1312 }
1313
AddCustomizedToneByFd(const std::shared_ptr<AbilityRuntime::Context> & context,const std::shared_ptr<ToneAttrs> & toneAttrs,const int32_t & fd)1314 std::string SystemSoundManagerImpl::AddCustomizedToneByFd(const std::shared_ptr<AbilityRuntime::Context> &context,
1315 const std::shared_ptr<ToneAttrs> &toneAttrs, const int32_t &fd)
1316 {
1317 return AddCustomizedToneByFdAndOffset(context, toneAttrs, fd, 0, INT_MAX);
1318 }
1319
GetCustomizedTone(const std::shared_ptr<ToneAttrs> & toneAttrs)1320 void SystemSoundManagerImpl::GetCustomizedTone(const std::shared_ptr<ToneAttrs> &toneAttrs)
1321 {
1322 displayName_ = toneAttrs->GetFileName();
1323 mimeType_ = "";
1324 for (const auto& type : RINGTONETYPE) {
1325 size_t found = displayName_.find("." + type);
1326 if (found != std::string::npos) {
1327 mimeType_ = type;
1328 }
1329 }
1330 if (mimeType_.empty()) {
1331 mimeType_ = RINGTONE_CONTAINER_TYPE_OGG;
1332 displayName_ = displayName_ + ".ogg";
1333 }
1334 }
1335
AddCustomizedTone(const std::shared_ptr<DataShare::DataShareHelper> & dataShareHelper,const std::shared_ptr<ToneAttrs> & toneAttrs)1336 int32_t SystemSoundManagerImpl::AddCustomizedTone(const std::shared_ptr<DataShare::DataShareHelper> &dataShareHelper,
1337 const std::shared_ptr<ToneAttrs> &toneAttrs)
1338 {
1339 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR, "Invalid dataShareHelper.");
1340 int32_t category = -1;
1341 category = toneAttrs->GetCategory();
1342 GetCustomizedTone(toneAttrs);
1343 DataShareValuesBucket valuesBucket;
1344 valuesBucket.Put(RINGTONE_COLUMN_DISPLAY_NAME, static_cast<string>(displayName_));
1345 valuesBucket.Put(RINGTONE_COLUMN_TITLE, static_cast<string>(toneAttrs->GetTitle()));
1346 valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, static_cast<string>(mimeType_));
1347 valuesBucket.Put(RINGTONE_COLUMN_SOURCE_TYPE, static_cast<int>(SOURCE_TYPE_CUSTOMISED));
1348 switch (category) {
1349 case TONE_CATEGORY_RINGTONE:
1350 toneAttrs->SetUri(RINGTONE_CUSTOMIZED_RINGTONE_PATH + RINGTONE_SLASH_CHAR + displayName_);
1351 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_RINGTONE));
1352 break;
1353 case TONE_CATEGORY_TEXT_MESSAGE:
1354 toneAttrs->SetUri(RINGTONE_CUSTOMIZED_NOTIFICATIONS_PATH + RINGTONE_SLASH_CHAR + displayName_);
1355 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_NOTIFICATION));
1356 break;
1357 case TONE_CATEGORY_NOTIFICATION:
1358 toneAttrs->SetUri(RINGTONE_CUSTOMIZED_NOTIFICATIONS_PATH + RINGTONE_SLASH_CHAR + displayName_);
1359 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_NOTIFICATION));
1360 break;
1361 case TONE_CATEGORY_ALARM:
1362 toneAttrs->SetUri(RINGTONE_CUSTOMIZED_ALARM_PATH + RINGTONE_SLASH_CHAR + displayName_);
1363 valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TONE_TYPE_ALARM));
1364 break;
1365 default:
1366 break;
1367 }
1368 valuesBucket.Put(RINGTONE_COLUMN_DATA, static_cast<string>(toneAttrs->GetUri()));
1369 return dataShareHelper->Insert(RINGTONEURI, valuesBucket);
1370 }
1371
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)1372 std::string SystemSoundManagerImpl::AddCustomizedToneByFdAndOffset(
1373 const std::shared_ptr<AbilityRuntime::Context> &context, const std::shared_ptr<ToneAttrs> &toneAttrs,
1374 const int32_t &fd, const int32_t &offset, const int32_t &length)
1375 {
1376 std::string result = "TYPEERROR";
1377 if (toneAttrs->GetCustomizedType() != CUSTOMISED) {
1378 MEDIA_LOGE("AddCustomizedTone: the ringtone is not customized!");
1379 return result;
1380 }
1381 std::lock_guard<std::mutex> lock(uriMutex_);
1382 int32_t srcFd = fd;
1383 off_t lseekResult = lseek(srcFd, offset, SEEK_SET);
1384 if (srcFd < 0 || lseekResult == -1) {
1385 MEDIA_LOGE("fd is error");
1386 result.clear();
1387 return result;
1388 }
1389 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1390 if (dataShareHelper == nullptr) {
1391 MEDIA_LOGE("Create dataShare failed, datashare or ringtone library error.");
1392 result.clear();
1393 return result;
1394 }
1395 int32_t sert = AddCustomizedTone(dataShareHelper, toneAttrs);
1396 std::string dstPath = RINGTONE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(sert);
1397 Uri ofUri(dstPath);
1398 int32_t dstFd = dataShareHelper->OpenFile(ofUri, "rw");
1399 if (dstFd < 0) {
1400 MEDIA_LOGE("AddCustomizedTone: open error is %{public}s", strerror(errno));
1401 result.clear();
1402 dataShareHelper->Release();
1403 return result;
1404 }
1405 char buffer[4096];
1406 int32_t len = length;
1407 memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
1408 int32_t bytesRead = 0;
1409 while ((bytesRead = read(srcFd, buffer, sizeof(buffer))) > 0 && len > 0) {
1410 int32_t bytesWritten = write(dstFd, buffer, (bytesRead < len) ? bytesRead : len);
1411 memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
1412 len -= bytesWritten;
1413 if (bytesWritten == -1) {
1414 break;
1415 }
1416 }
1417 close(srcFd);
1418 close(dstFd);
1419 dataShareHelper->Release();
1420 return toneAttrs->GetUri();
1421 }
1422
RemoveCustomizedTone(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & uri)1423 int32_t SystemSoundManagerImpl::RemoveCustomizedTone(
1424 const std::shared_ptr<AbilityRuntime::Context> &context, const std::string &uri)
1425 {
1426 std::lock_guard<std::mutex> lock(uriMutex_);
1427 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1428 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, ERROR,
1429 "Create dataShare failed, datashare or ringtone library error.");
1430 int32_t changedRows = TYPEERROR;
1431 DataShare::DatashareBusinessError businessError;
1432 DataShare::DataSharePredicates queryPredicates;
1433 queryPredicates.EqualTo(RINGTONE_COLUMN_DATA, uri);
1434 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1435 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1436 CHECK_AND_RETURN_RET_LOG(results != nullptr, ERROR, "query failed, ringtone library error.");
1437 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1438 if (ringtoneAsset == nullptr) {
1439 MEDIA_LOGE("RemoveCustomizedTone: tone of uri is not in the ringtone library!");
1440 resultSet == nullptr ? : resultSet->Close();
1441 dataShareHelper->Release();
1442 return ERROR;
1443 }
1444 while ((ringtoneAsset != nullptr) &&
1445 (SOURCE_TYPE_CUSTOMISED != ringtoneAsset->GetSourceType())) {
1446 ringtoneAsset = results->GetNextObject();
1447 }
1448 if (ringtoneAsset != nullptr) {
1449 DataShare::DataSharePredicates deletePredicates;
1450 deletePredicates.SetWhereClause(RINGTONE_COLUMN_TONE_ID + " = ? ");
1451 deletePredicates.SetWhereArgs({to_string(ringtoneAsset->GetId())});
1452 changedRows = dataShareHelper->Delete(RINGTONEURI, deletePredicates);
1453 } else {
1454 MEDIA_LOGE("RemoveCustomizedTone: the ringtone is not customized!");
1455 }
1456 resultSet == nullptr ? : resultSet->Close();
1457 dataShareHelper->Release();
1458 return changedRows;
1459 }
1460
SetRingerMode(const AudioStandard::AudioRingerMode & ringerMode)1461 int32_t SystemSoundManagerImpl::SetRingerMode(const AudioStandard::AudioRingerMode &ringerMode)
1462 {
1463 ringerMode_.store(ringerMode);
1464 return MSERR_OK;
1465 }
1466
GetRingerMode() const1467 AudioStandard::AudioRingerMode SystemSoundManagerImpl::GetRingerMode() const
1468 {
1469 return ringerMode_.load();
1470 }
1471
ConvertToRingtoneType(ToneHapticsType toneHapticsType,RingtoneType & ringtoneType)1472 bool SystemSoundManagerImpl::ConvertToRingtoneType(ToneHapticsType toneHapticsType, RingtoneType &ringtoneType)
1473 {
1474 switch (toneHapticsType) {
1475 case ToneHapticsType::CALL_SIM_CARD_0 :
1476 ringtoneType = RINGTONE_TYPE_SIM_CARD_0;
1477 return true;
1478 case ToneHapticsType::CALL_SIM_CARD_1 :
1479 ringtoneType = RINGTONE_TYPE_SIM_CARD_1;
1480 return true;
1481 default:
1482 return false;
1483 }
1484 }
1485
ConvertToSystemToneType(ToneHapticsType toneHapticsType,SystemToneType & systemToneType)1486 bool SystemSoundManagerImpl::ConvertToSystemToneType(ToneHapticsType toneHapticsType, SystemToneType &systemToneType)
1487 {
1488 switch (toneHapticsType) {
1489 case ToneHapticsType::TEXT_MESSAGE_SIM_CARD_0 :
1490 systemToneType = SYSTEM_TONE_TYPE_SIM_CARD_0;
1491 return true;
1492 case ToneHapticsType::TEXT_MESSAGE_SIM_CARD_1 :
1493 systemToneType = SYSTEM_TONE_TYPE_SIM_CARD_1;
1494 return true;
1495 case ToneHapticsType::NOTIFICATION :
1496 systemToneType = SYSTEM_TONE_TYPE_NOTIFICATION;
1497 return true;
1498 default:
1499 return false;
1500 }
1501 }
1502
IntToToneHapticsMode(int32_t value)1503 ToneHapticsMode SystemSoundManagerImpl::IntToToneHapticsMode(int32_t value)
1504 {
1505 switch (value) {
1506 case NONE:
1507 return NONE;
1508 case SYNC:
1509 return SYNC;
1510 case NON_SYNC:
1511 return NON_SYNC;
1512 default:
1513 return NONE;
1514 }
1515 }
1516
GetCurrentToneUri(const std::shared_ptr<AbilityRuntime::Context> & context,ToneHapticsType toneHapticsType)1517 std::string SystemSoundManagerImpl::GetCurrentToneUri(const std::shared_ptr<AbilityRuntime::Context> &context,
1518 ToneHapticsType toneHapticsType)
1519 {
1520 string currentToneUri = "";
1521 RingtoneType ringtoneType;
1522 SystemToneType systemToneType;
1523 if (ConvertToRingtoneType(toneHapticsType, ringtoneType)) {
1524 currentToneUri = GetRingtoneUri(context, ringtoneType);
1525 } else if (ConvertToSystemToneType(toneHapticsType, systemToneType)) {
1526 currentToneUri = GetSystemToneUri(context, systemToneType);
1527 } else {
1528 MEDIA_LOGE("Invalid tone haptics type");
1529 }
1530 return currentToneUri;
1531 }
1532
1533
UpdateToneHapticsSettings(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & toneUri,ToneHapticsType toneHapticsType,const ToneHapticsSettings & settings)1534 int32_t SystemSoundManagerImpl::UpdateToneHapticsSettings(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
1535 const std::string &toneUri, ToneHapticsType toneHapticsType, const ToneHapticsSettings &settings)
1536 {
1537 MEDIA_LOGI("UpdateToneHapticsSettings: update haptics settings, toneUri[%{public}s] type[%{public}d],"
1538 "mode[%{public}d] hapticsUri[%{public}s]", toneUri.c_str(), toneHapticsType, settings.mode,
1539 settings.hapticsUri.c_str());
1540 DataShare::DataSharePredicates queryPredicates;
1541 queryPredicates.EqualTo(SIMCARD_SETTING_COLUMN_MODE, hapticsTypeWhereArgsMap_[toneHapticsType].first);
1542 queryPredicates.And();
1543 queryPredicates.EqualTo(SIMCARD_SETTING_COLUMN_RINGTONE_TYPE, hapticsTypeWhereArgsMap_[toneHapticsType].second);
1544
1545 DataShareValuesBucket valuesBucket;
1546 valuesBucket.Put(SIMCARD_SETTING_COLUMN_TONE_FILE, toneUri);
1547 valuesBucket.Put(SIMCARD_SETTING_COLUMN_VIBRATE_FILE, settings.hapticsUri);
1548 valuesBucket.Put(SIMCARD_SETTING_COLUMN_RING_MODE, to_string(hapticsModeMap_[settings.mode]));
1549 valuesBucket.Put(SIMCARD_SETTING_COLUMN_VIBRATE_MODE, to_string(VIBRATE_TYPE_STANDARD));
1550
1551 int32_t result = dataShareHelper->Update(SIMCARDSETTINGURI, queryPredicates, valuesBucket);
1552 if (result > 0) {
1553 return SUCCESS;
1554 } else {
1555 MEDIA_LOGE("UpdateToneHapticsSettings: update haptics settings fail");
1556 }
1557
1558 valuesBucket.Put(SIMCARD_SETTING_COLUMN_MODE, to_string(hapticsTypeWhereArgsMap_[toneHapticsType].first));
1559 valuesBucket.Put(SIMCARD_SETTING_COLUMN_RINGTONE_TYPE,
1560 to_string(hapticsTypeWhereArgsMap_[toneHapticsType].second));
1561 result = dataShareHelper->Insert(SIMCARDSETTINGURI, valuesBucket);
1562 if (result <= 0) {
1563 MEDIA_LOGE("UpdateToneHapticsSettings: insert haptics settings fail");
1564 }
1565 return result > 0 ? SUCCESS : IO_ERROR;
1566 }
1567
GetSimcardSettingAssetByToneHapticsType(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,ToneHapticsType toneHapticsType)1568 std::unique_ptr<SimcardSettingAsset> SystemSoundManagerImpl::GetSimcardSettingAssetByToneHapticsType(
1569 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, ToneHapticsType toneHapticsType)
1570 {
1571 DataShare::DatashareBusinessError businessError;
1572 DataShare::DataSharePredicates queryPredicates;
1573 queryPredicates.EqualTo(SIMCARD_SETTING_COLUMN_MODE, hapticsTypeWhereArgsMap_[toneHapticsType].first);
1574 queryPredicates.And();
1575 queryPredicates.EqualTo(SIMCARD_SETTING_COLUMN_RINGTONE_TYPE, hapticsTypeWhereArgsMap_[toneHapticsType].second);
1576 auto resultSet = dataShareHelper->Query(SIMCARDSETTINGURI, queryPredicates, SETTING_TABLE_COLUMNS,
1577 &businessError);
1578 auto results = make_unique<RingtoneFetchResult<SimcardSettingAsset>>(move(resultSet));
1579 unique_ptr<SimcardSettingAsset> simcardSettingAsset = results->GetFirstObject();
1580 return simcardSettingAsset;
1581 }
1582
GetToneSyncedHapticsUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & toneUri)1583 std::string SystemSoundManagerImpl::GetToneSyncedHapticsUri(
1584 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, const std::string &toneUri)
1585 {
1586 std::shared_ptr<ToneHapticsAttrs> toneHapticsAttrs;
1587 int32_t result = GetHapticsAttrsSyncedWithTone(toneUri, dataShareHelper, toneHapticsAttrs);
1588 if (result == SUCCESS && toneHapticsAttrs) {
1589 return toneHapticsAttrs->GetUri();
1590 }
1591 return "";
1592 }
1593
GetDefaultNonSyncedHapticsUri(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,ToneHapticsType toneHapticsType)1594 std::string SystemSoundManagerImpl::GetDefaultNonSyncedHapticsUri(
1595 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, ToneHapticsType toneHapticsType)
1596 {
1597 MEDIA_LOGD("GetDefaultNonSyncedHapticsUri: toneHapticsType %{public}d", toneHapticsType);
1598 auto toneHapticsItem = defaultToneHapticsUriMap_.find(toneHapticsType);
1599 if (toneHapticsItem == defaultToneHapticsUriMap_.end()) {
1600 MEDIA_LOGE("GetDefaultNonSyncedHapticsUri: get type %{public}d defaultTone haptics fail", toneHapticsType);
1601 return "";
1602 }
1603
1604 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, "",
1605 "Create dataShare failed, datashare or ringtone library error.");
1606
1607 DataShare::DatashareBusinessError businessError;
1608 DataShare::DataSharePredicates queryPredicatesByUri;
1609 queryPredicatesByUri.EqualTo(VIBRATE_COLUMN_DISPLAY_NAME, toneHapticsItem->second);
1610 queryPredicatesByUri.And();
1611 queryPredicatesByUri.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, VIBRATE_TYPE_STANDARD);
1612 auto resultSetByUri = dataShareHelper->Query(VIBRATEURI, queryPredicatesByUri, VIBRATE_TABLE_COLUMNS,
1613 &businessError);
1614 auto resultsByUri = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSetByUri));
1615 unique_ptr<VibrateAsset> vibrateAssetByUri = resultsByUri->GetFirstObject();
1616 if (vibrateAssetByUri == nullptr) {
1617 MEDIA_LOGE("GetDefaultNonSyncedHapticsUri: no non_sync vibration called %{public}s",
1618 toneHapticsItem->second.c_str());
1619 return "";
1620 }
1621
1622 string hapticsUri = vibrateAssetByUri->GetPath();
1623 MEDIA_LOGI("GetDefaultNonSyncedHapticsUri: toneHapticsType %{public}d default haptics %{public}s",
1624 toneHapticsType, hapticsUri.c_str());
1625 return hapticsUri;
1626 }
1627
GetFirstNonSyncedHapticsUri()1628 std::string SystemSoundManagerImpl::GetFirstNonSyncedHapticsUri()
1629 {
1630 std::vector<std::shared_ptr<ToneHapticsAttrs>> toneHapticsAttrsArray;
1631 int32_t result = GetToneHapticsList(nullptr, false, toneHapticsAttrsArray);
1632 if (result == SUCCESS && !toneHapticsAttrsArray.empty()) {
1633 return toneHapticsAttrsArray[0]->GetUri();
1634 }
1635 return "";
1636 }
1637
GetDefaultToneHapticsSettings(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & currentToneUri,ToneHapticsType toneHapticsType,ToneHapticsSettings & settings)1638 int32_t SystemSoundManagerImpl::GetDefaultToneHapticsSettings(
1639 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, const std::string ¤tToneUri,
1640 ToneHapticsType toneHapticsType, ToneHapticsSettings &settings)
1641 {
1642 settings.hapticsUri = GetToneSyncedHapticsUri(dataShareHelper, currentToneUri);
1643 if (!settings.hapticsUri.empty()) {
1644 settings.mode = ToneHapticsMode::SYNC;
1645 return SUCCESS;
1646 }
1647 settings.hapticsUri = GetDefaultNonSyncedHapticsUri(dataShareHelper, toneHapticsType);
1648 if (!settings.hapticsUri.empty()) {
1649 settings.mode = ToneHapticsMode::NON_SYNC;
1650 return SUCCESS;
1651 }
1652 settings.hapticsUri = GetFirstNonSyncedHapticsUri();
1653 if (!settings.hapticsUri.empty()) {
1654 settings.mode = ToneHapticsMode::NON_SYNC;
1655 return SUCCESS;
1656 }
1657 return IO_ERROR;
1658 }
1659
GetToneHapticsSettings(const std::shared_ptr<AbilityRuntime::Context> & context,ToneHapticsType toneHapticsType,ToneHapticsSettings & settings)1660 int32_t SystemSoundManagerImpl::GetToneHapticsSettings(const std::shared_ptr<AbilityRuntime::Context> &context,
1661 ToneHapticsType toneHapticsType, ToneHapticsSettings &settings)
1662 {
1663 #ifdef SUPPORT_VIBRATOR
1664 CHECK_AND_RETURN_RET_LOG(IsToneHapticsTypeValid(toneHapticsType), IO_ERROR, "Invalid tone haptics type");
1665 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1666 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, IO_ERROR,
1667 "Create dataShare failed, datashare or ringtone library error.");
1668 string currentToneUri = GetCurrentToneUri(context, toneHapticsType);
1669
1670 int32_t result = GetToneHapticsSettings(dataShareHelper, currentToneUri, toneHapticsType, settings);
1671 dataShareHelper->Release();
1672 return result;
1673 #endif
1674 return UNSUPPORTED_ERROR;
1675 }
1676
GetToneHapticsSettings(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & toneUri,ToneHapticsType toneHapticsType,ToneHapticsSettings & settings)1677 int32_t SystemSoundManagerImpl::GetToneHapticsSettings(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
1678 const std::string &toneUri, ToneHapticsType toneHapticsType, ToneHapticsSettings &settings)
1679 {
1680 #ifdef SUPPORT_VIBRATOR
1681 std::lock_guard<std::mutex> lock(toneHapticsMutex_);
1682 MEDIA_LOGI("GetToneHapticsSettings: toneUri %{public}s toneHapticsType %{public}d", toneUri.c_str(),
1683 toneHapticsType);
1684 if (dataShareHelper == nullptr || toneUri.empty() || !IsToneHapticsTypeValid(toneHapticsType)) {
1685 MEDIA_LOGE("GetToneHapticsSettings: param fail");
1686 return IO_ERROR;
1687 }
1688
1689 int32_t result = SUCCESS;
1690 auto simcardSettingAsset = GetSimcardSettingAssetByToneHapticsType(dataShareHelper, toneHapticsType);
1691 if (simcardSettingAsset == nullptr || simcardSettingAsset->GetToneFile().empty()) {
1692 result = GetDefaultToneHapticsSettings(dataShareHelper, toneUri, toneHapticsType, settings);
1693 if (result != SUCCESS) {
1694 MEDIA_LOGE("GetToneHapticsSettings: get defaultTone haptics settings fail");
1695 }
1696 return result;
1697 }
1698
1699 if (toneUri == simcardSettingAsset->GetToneFile()) {
1700 settings.hapticsUri = simcardSettingAsset->GetVibrateFile();
1701 settings.mode = IntToToneHapticsMode(simcardSettingAsset->GetRingMode());
1702 return SUCCESS;
1703 }
1704
1705 if (simcardSettingAsset->GetRingMode() != VIBRATE_PLAYMODE_SYNC) {
1706 settings.hapticsUri = simcardSettingAsset->GetVibrateFile();
1707 settings.mode = IntToToneHapticsMode(simcardSettingAsset->GetRingMode());
1708 } else {
1709 result = GetDefaultToneHapticsSettings(dataShareHelper, toneUri, toneHapticsType, settings);
1710 }
1711 if (result == SUCCESS) {
1712 result = UpdateToneHapticsSettings(dataShareHelper, toneUri, toneHapticsType, settings);
1713 } else {
1714 MEDIA_LOGE("GetToneHapticsSettings: get defaultTone haptics settings fail");
1715 }
1716 return result;
1717 #endif
1718 return UNSUPPORTED_ERROR;
1719 }
1720
SetToneHapticsSettings(const std::shared_ptr<AbilityRuntime::Context> & context,ToneHapticsType toneHapticsType,const ToneHapticsSettings & settings)1721 int32_t SystemSoundManagerImpl::SetToneHapticsSettings(const std::shared_ptr<AbilityRuntime::Context> &context,
1722 ToneHapticsType toneHapticsType, const ToneHapticsSettings &settings)
1723 {
1724 #ifdef SUPPORT_VIBRATOR
1725 CHECK_AND_RETURN_RET_LOG(IsToneHapticsTypeValid(toneHapticsType), OPERATION_ERROR, "Invalid tone haptics type");
1726 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1727 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, IO_ERROR,
1728 "Create dataShare failed, datashare or ringtone library error.");
1729 string currentToneUri = GetCurrentToneUri(context, toneHapticsType);
1730
1731 int32_t res = SetToneHapticsSettings(dataShareHelper, currentToneUri, toneHapticsType, settings);
1732 dataShareHelper->Release();
1733 return res;
1734 #endif
1735 return UNSUPPORTED_ERROR;
1736 }
1737
SetToneHapticsSettings(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & toneUri,ToneHapticsType toneHapticsType,const ToneHapticsSettings & settings)1738 int32_t SystemSoundManagerImpl::SetToneHapticsSettings(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
1739 const std::string &toneUri, ToneHapticsType toneHapticsType, const ToneHapticsSettings &settings)
1740 {
1741 #ifdef SUPPORT_VIBRATOR
1742 std::lock_guard<std::mutex> lock(toneHapticsMutex_);
1743 MEDIA_LOGI("SetToneHapticsSettings: toneUri %{public}s type %{public}d hapticsUri %{public}s mode %{public}d",
1744 toneUri.c_str(), toneHapticsType, settings.hapticsUri.c_str(), settings.mode);
1745 if (dataShareHelper == nullptr || toneUri.empty() || !IsToneHapticsTypeValid(toneHapticsType)) {
1746 MEDIA_LOGE("SetToneHapticsSettings: param fail");
1747 return IO_ERROR;
1748 }
1749
1750 ToneHapticsSettings updateSettings = settings;
1751 if (updateSettings.mode == ToneHapticsMode::NON_SYNC) {
1752 DataShare::DatashareBusinessError businessError;
1753 DataShare::DataSharePredicates queryPredicatesByUri;
1754 queryPredicatesByUri.EqualTo(VIBRATE_COLUMN_DATA, updateSettings.hapticsUri);
1755 queryPredicatesByUri.And();
1756 queryPredicatesByUri.EqualTo(VIBRATE_COLUMN_PLAY_MODE, hapticsModeMap_[updateSettings.mode]);
1757 auto resultSetByUri = dataShareHelper->Query(VIBRATEURI, queryPredicatesByUri, VIBRATE_TABLE_COLUMNS,
1758 &businessError);
1759 auto resultsByUri = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSetByUri));
1760 unique_ptr<VibrateAsset> vibrateAssetByUri = resultsByUri->GetFirstObject();
1761 if (vibrateAssetByUri == nullptr) {
1762 MEDIA_LOGE("SetToneHapticsSettings: vibration of uri is not in the ringtone library!");
1763 return OPERATION_ERROR;
1764 }
1765 } else if (settings.mode == ToneHapticsMode::SYNC) {
1766 std::shared_ptr<ToneHapticsAttrs> toneHapticsAttrs;
1767 int32_t result = GetHapticsAttrsSyncedWithTone(toneUri, dataShareHelper, toneHapticsAttrs);
1768 if (result != SUCCESS) {
1769 MEDIA_LOGE("SetToneHapticsSettings: current tone does not support sync vibration!");
1770 return result;
1771 }
1772 updateSettings.hapticsUri = toneHapticsAttrs->GetUri();
1773 }
1774
1775 int32_t res = UpdateToneHapticsSettings(dataShareHelper, toneUri, toneHapticsType, updateSettings);
1776 if (res != SUCCESS) {
1777 MEDIA_LOGE("SetToneHapticsSettings: set tone haptics settings fail!");
1778 }
1779 return res;
1780 #endif
1781 return UNSUPPORTED_ERROR;
1782 }
1783
GetToneHapticsList(const std::shared_ptr<AbilityRuntime::Context> & context,bool isSynced,std::vector<std::shared_ptr<ToneHapticsAttrs>> & toneHapticsAttrsArray)1784 int32_t SystemSoundManagerImpl::GetToneHapticsList(const std::shared_ptr<AbilityRuntime::Context> &context,
1785 bool isSynced, std::vector<std::shared_ptr<ToneHapticsAttrs>> &toneHapticsAttrsArray)
1786 {
1787 #ifdef SUPPORT_VIBRATOR
1788 MEDIA_LOGI("GetToneHapticsList: get vibration list, type : %{public}s.", isSynced ? "sync" : "non sync");
1789 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1790 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, IO_ERROR,
1791 "Create dataShare failed, datashare or ringtone library error.");
1792
1793 DataShare::DatashareBusinessError businessError;
1794 DataShare::DataSharePredicates queryPredicates;
1795 queryPredicates.BeginWrap();
1796 queryPredicates.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, VIBRATE_TYPE_STANDARD);
1797 queryPredicates.Or();
1798 queryPredicates.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, VIBRATE_TYPE_SALARM);
1799 queryPredicates.Or();
1800 queryPredicates.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, VIBRATE_TYPE_SRINGTONE);
1801 queryPredicates.Or();
1802 queryPredicates.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, VIBRATE_TYPE_SNOTIFICATION);
1803 queryPredicates.EndWrap();
1804 queryPredicates.And();
1805 queryPredicates.EqualTo(VIBRATE_COLUMN_PLAY_MODE,
1806 std::to_string(isSynced ? VIBRATE_PLAYMODE_SYNC : VIBRATE_PLAYMODE_CLASSIC));
1807 auto resultSet = dataShareHelper->Query(VIBRATEURI, queryPredicates, VIBRATE_TABLE_COLUMNS, &businessError);
1808 auto results = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSet));
1809
1810 toneHapticsAttrsArray.clear();
1811 unique_ptr<VibrateAsset> vibrateAsset = results->GetFirstObject();
1812 if (vibrateAsset == nullptr) {
1813 MEDIA_LOGE("GetToneHapticsList: get %{public}s vibration list fail!", isSynced ? "sync" : "non sync");
1814 } else {
1815 while (vibrateAsset != nullptr) {
1816 auto toneHapticsAttrs = std::make_shared<ToneHapticsAttrs>(vibrateAsset->GetTitle(),
1817 vibrateAsset->GetDisplayName(), vibrateAsset->GetPath());
1818 toneHapticsAttrsArray.push_back(toneHapticsAttrs);
1819 vibrateAsset = results->GetNextObject();
1820 }
1821 }
1822
1823 dataShareHelper->Release();
1824 return toneHapticsAttrsArray.empty() ? IO_ERROR : SUCCESS;
1825 #endif
1826 return UNSUPPORTED_ERROR;
1827 }
1828
ConvertToHapticsFileName(const std::string & fileName)1829 std::string SystemSoundManagerImpl::ConvertToHapticsFileName(const std::string &fileName)
1830 {
1831 size_t dotPos = fileName.find_last_of('.');
1832 if (dotPos != std::string::npos) {
1833 std::string baseName = fileName.substr(0, dotPos);
1834 return baseName + ".json";
1835 } else {
1836 return fileName + ".json";
1837 }
1838 }
1839
IsPresetRingtone(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & toneUri)1840 std::unique_ptr<RingtoneAsset> SystemSoundManagerImpl::IsPresetRingtone(
1841 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, const std::string &toneUri)
1842 {
1843 DataShare::DatashareBusinessError businessError;
1844 DataShare::DataSharePredicates queryPredicates;
1845 queryPredicates.EqualTo(RINGTONE_COLUMN_DATA, toneUri);
1846 auto resultSet = dataShareHelper->Query(RINGTONEURI, queryPredicates, COLUMNS, &businessError);
1847 auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
1848 unique_ptr<RingtoneAsset> ringtoneAsset = results->GetFirstObject();
1849 if (ringtoneAsset == nullptr) {
1850 MEDIA_LOGE("IsPresetRingtone: toneUri[%{public}s] inexistence in the ringtone library!", toneUri.c_str());
1851 return nullptr;
1852 }
1853 if (ringtoneAsset->GetSourceType() != SOURCE_TYPE_PRESET) {
1854 MEDIA_LOGE("IsPresetRingtone: toneUri[%{public}s] is not system prefabrication!", toneUri.c_str());
1855 return nullptr;
1856 }
1857 return ringtoneAsset;
1858 }
1859
GetStandardVibrateType(int toneType)1860 int SystemSoundManagerImpl::GetStandardVibrateType(int toneType)
1861 {
1862 switch (toneType) {
1863 case TONE_TYPE_ALARM:
1864 return VIBRATE_TYPE_SALARM;
1865 case TONE_TYPE_RINGTONE:
1866 return VIBRATE_TYPE_SRINGTONE;
1867 case TONE_TYPE_NOTIFICATION:
1868 return VIBRATE_TYPE_SNOTIFICATION;
1869 default:
1870 return VIBRATE_TYPE_STANDARD;
1871 }
1872 }
1873
GetHapticsAttrsSyncedWithTone(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & toneUri,std::shared_ptr<ToneHapticsAttrs> & toneHapticsAttrs)1874 int32_t SystemSoundManagerImpl::GetHapticsAttrsSyncedWithTone(const std::shared_ptr<AbilityRuntime::Context> &context,
1875 const std::string &toneUri, std::shared_ptr<ToneHapticsAttrs> &toneHapticsAttrs)
1876 {
1877 #ifdef SUPPORT_VIBRATOR
1878 CHECK_AND_RETURN_RET_LOG(!toneUri.empty(), OPERATION_ERROR, "Invalid toneUri");
1879 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1880 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, IO_ERROR,
1881 "Create dataShare failed, datashare or ringtone library error.");
1882
1883 int32_t result = GetHapticsAttrsSyncedWithTone(toneUri, dataShareHelper, toneHapticsAttrs);
1884 dataShareHelper->Release();
1885 return result;
1886 #endif
1887 return UNSUPPORTED_ERROR;
1888 }
1889
GetHapticsAttrsSyncedWithTone(const std::string & toneUri,std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,std::shared_ptr<ToneHapticsAttrs> & toneHapticsAttrs)1890 int32_t SystemSoundManagerImpl::GetHapticsAttrsSyncedWithTone(const std::string &toneUri,
1891 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, std::shared_ptr<ToneHapticsAttrs> &toneHapticsAttrs)
1892 {
1893 #ifdef SUPPORT_VIBRATOR
1894 MEDIA_LOGI("GetHapticsAttrsSyncedWithTone: get %{public}s sync vibration.", toneUri.c_str());
1895 if (dataShareHelper == nullptr || toneUri.empty()) {
1896 MEDIA_LOGE("GetHapticsAttrsSyncedWithTone: param fail");
1897 return IO_ERROR;
1898 }
1899
1900 unique_ptr<RingtoneAsset> ringtoneAsset = IsPresetRingtone(dataShareHelper, toneUri);
1901 if (ringtoneAsset == nullptr) {
1902 MEDIA_LOGE("GetHapticsAttrsSyncedWithTone: toneUri[%{public}s] is not presetRingtone!", toneUri.c_str());
1903 return OPERATION_ERROR;
1904 }
1905
1906 DataShare::DatashareBusinessError businessError;
1907 DataShare::DataSharePredicates vibrateQueryPredicates;
1908 vibrateQueryPredicates.EqualTo(VIBRATE_COLUMN_DISPLAY_NAME,
1909 ConvertToHapticsFileName(ringtoneAsset->GetDisplayName()));
1910 vibrateQueryPredicates.And();
1911 vibrateQueryPredicates.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE,
1912 GetStandardVibrateType(ringtoneAsset->GetToneType()));
1913 vibrateQueryPredicates.And();
1914 vibrateQueryPredicates.EqualTo(VIBRATE_COLUMN_PLAY_MODE, VIBRATE_PLAYMODE_SYNC);
1915 auto vibrateResultSet = dataShareHelper->Query(VIBRATEURI, vibrateQueryPredicates, VIBRATE_TABLE_COLUMNS,
1916 &businessError);
1917 auto vibrateResults = make_unique<RingtoneFetchResult<VibrateAsset>>(move(vibrateResultSet));
1918
1919 unique_ptr<VibrateAsset> vibrateAsset = vibrateResults->GetFirstObject();
1920 if (vibrateAsset == nullptr) {
1921 MEDIA_LOGE("GetHapticsAttrsSyncedWithTone: toneUri[%{public}s] is not sync vibration!", toneUri.c_str());
1922 return IO_ERROR;
1923 }
1924
1925 toneHapticsAttrs = std::make_shared<ToneHapticsAttrs>(vibrateAsset->GetTitle(), vibrateAsset->GetDisplayName(),
1926 vibrateAsset->GetPath());
1927 return SUCCESS;
1928 #endif
1929 return UNSUPPORTED_ERROR;
1930 }
1931
OpenToneHaptics(const std::shared_ptr<AbilityRuntime::Context> & context,const std::string & hapticsUri)1932 int32_t SystemSoundManagerImpl::OpenToneHaptics(const std::shared_ptr<AbilityRuntime::Context> &context,
1933 const std::string &hapticsUri)
1934 {
1935 #ifdef SUPPORT_VIBRATOR
1936 CHECK_AND_RETURN_RET_LOG(!hapticsUri.empty(), OPERATION_ERROR, "Invalid hapticsUri");
1937 MEDIA_LOGI("OpenToneHaptics: open %{public}s vibration.", hapticsUri.c_str());
1938 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper(STORAGE_MANAGER_MANAGER_ID);
1939 CHECK_AND_RETURN_RET_LOG(dataShareHelper != nullptr, IO_ERROR,
1940 "Create dataShare failed, datashare or ringtone library error.");
1941
1942 DataShare::DatashareBusinessError businessError;
1943 DataShare::DataSharePredicates queryPredicatesByUri;
1944 queryPredicatesByUri.EqualTo(VIBRATE_COLUMN_DATA, hapticsUri);
1945 auto resultSetByUri = dataShareHelper->Query(VIBRATEURI, queryPredicatesByUri, VIBRATE_TABLE_COLUMNS,
1946 &businessError);
1947 auto resultsByUri = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSetByUri));
1948 unique_ptr<VibrateAsset> vibrateAssetByUri = resultsByUri->GetFirstObject();
1949 if (vibrateAssetByUri == nullptr) {
1950 MEDIA_LOGE("OpenToneHaptics: vibration of uri is not in the ringtone library!");
1951 dataShareHelper->Release();
1952 return OPERATION_ERROR;
1953 }
1954
1955 string uriStr = VIBRATE_PATH_URI + RINGTONE_SLASH_CHAR + to_string(vibrateAssetByUri->GetId());
1956 Uri ofUri(uriStr);
1957 int32_t fd = dataShareHelper->OpenFile(ofUri, "r");
1958 dataShareHelper->Release();
1959 return fd > 0 ? fd : IO_ERROR;
1960 #endif
1961 return UNSUPPORTED_ERROR;
1962 }
1963
GetVibrateTypeByStyle(int standardVibrateType,HapticsStyle hapticsStyle,int & vibrateType)1964 bool SystemSoundManagerImpl::GetVibrateTypeByStyle(int standardVibrateType, HapticsStyle hapticsStyle,
1965 int &vibrateType)
1966 {
1967 auto standardVibrateTypeEntry = hapticsStyleMap_.find(standardVibrateType);
1968 if (standardVibrateTypeEntry == hapticsStyleMap_.end()) {
1969 MEDIA_LOGE("GetVibrateType: input type [%{public}d] is not standardVibrateType!", standardVibrateType);
1970 return false;
1971 }
1972 auto hapticsStyleEntry = standardVibrateTypeEntry->second.find(hapticsStyle);
1973 if (hapticsStyleEntry == standardVibrateTypeEntry->second.end()) {
1974 MEDIA_LOGE("GetVibrateType: not have %{public}d haptics Style", hapticsStyle);
1975 return false;
1976 }
1977 vibrateType = hapticsStyleEntry->second;
1978 MEDIA_LOGI("GetVibrateType: standard %{public}d, style %{public}d, vibrateType %{public}d",
1979 hapticsStyle, hapticsStyle, vibrateType);
1980 return true;
1981 }
1982
GetHapticsUriByStyle(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const std::string & standardHapticsUri,HapticsStyle hapticsStyle)1983 std::string SystemSoundManagerImpl::GetHapticsUriByStyle(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
1984 const std::string &standardHapticsUri, HapticsStyle hapticsStyle)
1985 {
1986 if (dataShareHelper == nullptr || standardHapticsUri.empty()) {
1987 MEDIA_LOGE("GetHapticsUriByStyle: param fail, uri [%{public}s]", standardHapticsUri.c_str());
1988 return "";
1989 }
1990 MEDIA_LOGI("GetHapticsUriByStyle: standardHapticsUri %{public}s, style %{public}d", standardHapticsUri.c_str(),
1991 hapticsStyle);
1992
1993 DataShare::DatashareBusinessError businessError;
1994 DataShare::DataSharePredicates queryPredicatesByUri;
1995 queryPredicatesByUri.EqualTo(VIBRATE_COLUMN_DATA, standardHapticsUri);
1996 auto resultSetByUri = dataShareHelper->Query(VIBRATEURI, queryPredicatesByUri, VIBRATE_TABLE_COLUMNS,
1997 &businessError);
1998 auto resultsByUri = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSetByUri));
1999 unique_ptr<VibrateAsset> vibrateAssetByUri = resultsByUri->GetFirstObject();
2000 if (vibrateAssetByUri == nullptr) {
2001 MEDIA_LOGE("GetHapticsUriByStyle: vibration of uri is not in the ringtone library!");
2002 return "";
2003 }
2004 int vibrateType = 0;
2005 if (!GetVibrateTypeByStyle(vibrateAssetByUri->GetVibrateType(), hapticsStyle, vibrateType)) {
2006 MEDIA_LOGE("GetHapticsUriByStyle: vibration of uri is not standard vibrate!");
2007 return "";
2008 }
2009
2010 DataShare::DataSharePredicates queryPredicatesByDisplayName;
2011 queryPredicatesByDisplayName.EqualTo(VIBRATE_COLUMN_DISPLAY_NAME, vibrateAssetByUri->GetDisplayName());
2012 queryPredicatesByDisplayName.And();
2013 queryPredicatesByDisplayName.EqualTo(VIBRATE_COLUMN_PLAY_MODE, vibrateAssetByUri->GetPlayMode());
2014 queryPredicatesByDisplayName.And();
2015 queryPredicatesByDisplayName.EqualTo(VIBRATE_COLUMN_VIBRATE_TYPE, vibrateType);
2016 auto resultSetByDisplayName = dataShareHelper->Query(VIBRATEURI, queryPredicatesByDisplayName,
2017 VIBRATE_TABLE_COLUMNS, &businessError);
2018 auto resultsByDisplayName = make_unique<RingtoneFetchResult<VibrateAsset>>(move(resultSetByDisplayName));
2019 unique_ptr<VibrateAsset> vibrateAssetByDisplayName = resultsByDisplayName->GetFirstObject();
2020 if (vibrateAssetByDisplayName == nullptr) {
2021 MEDIA_LOGE("GetHapticsUriByStyle: style %{public}d vibration is not in the ringtone library!", hapticsStyle);
2022 return "";
2023 }
2024 MEDIA_LOGI("GetHapticsUriByStyle: get style %{public}d vibration %{public}s!", hapticsStyle,
2025 vibrateAssetByDisplayName->GetPath().c_str());
2026 return vibrateAssetByDisplayName->GetPath();
2027 }
2028 } // namesapce AudioStandard
2029 } // namespace OHOS
2030