1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ringtone_rdb_callbacks.h"
17
18 #include <sys/stat.h>
19
20 #include "rdb_sql_utils.h"
21 #include "ringtone_errno.h"
22 #include "ringtone_log.h"
23 #include "ringtone_db_const.h"
24 #include "ringtone_file_utils.h"
25 #include "ringtone_mimetype_utils.h"
26 #include "ringtone_utils.h"
27 #include "result_set_utils.h"
28 #include "preferences_helper.h"
29 #include "dfx_const.h"
30
31 namespace OHOS {
32 namespace Media {
33 using namespace std;
34
35 const string DEFAULT_MIME_TYPE = "application/octet-stream";
36 static const char RINGTONE_PARAMETER_SCANNER_COMPLETED_KEY[] = "ringtone.scanner.completed";
37 static const int RINGTONE_PARAMETER_SCANNER_COMPLETED_FALSE = 0;
38
39 const std::string CREATE_RINGTONE_TABLE = "CREATE TABLE IF NOT EXISTS " + RINGTONE_TABLE + "(" +
40 RINGTONE_COLUMN_TONE_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
41 RINGTONE_COLUMN_DATA + " TEXT , " +
42 RINGTONE_COLUMN_SIZE + " BIGINT DEFAULT 0, " +
43 RINGTONE_COLUMN_DISPLAY_NAME + " TEXT , " +
44 RINGTONE_COLUMN_TITLE + " TEXT , " +
45 RINGTONE_COLUMN_MEDIA_TYPE + " INT DEFAULT 0, " +
46 RINGTONE_COLUMN_TONE_TYPE + " INT DEFAULT 0, " +
47 RINGTONE_COLUMN_MIME_TYPE + " TEXT , " +
48 RINGTONE_COLUMN_SOURCE_TYPE + " INT DEFAULT 0, " +
49 RINGTONE_COLUMN_DATE_ADDED + " BIGINT DEFAULT 0, " +
50 RINGTONE_COLUMN_DATE_MODIFIED + " BIGINT DEFAULT 0, " +
51 RINGTONE_COLUMN_DATE_TAKEN + " BIGINT DEFAULT 0, " +
52 RINGTONE_COLUMN_DURATION + " INT DEFAULT 0, " +
53 RINGTONE_COLUMN_SHOT_TONE_TYPE + " INT DEFAULT 0, " +
54 RINGTONE_COLUMN_SHOT_TONE_SOURCE_TYPE + " INT DEFAULT 0, " +
55 RINGTONE_COLUMN_NOTIFICATION_TONE_TYPE + " INT DEFAULT 0, " +
56 RINGTONE_COLUMN_NOTIFICATION_TONE_SOURCE_TYPE + " INT DEFAULT 0, " +
57 RINGTONE_COLUMN_RING_TONE_TYPE + " INT DEFAULT 0, " +
58 RINGTONE_COLUMN_RING_TONE_SOURCE_TYPE + " INT DEFAULT 0, " +
59 RINGTONE_COLUMN_ALARM_TONE_TYPE + " INT DEFAULT 0, " +
60 RINGTONE_COLUMN_ALARM_TONE_SOURCE_TYPE + " INT DEFAULT 0, " +
61 RINGTONE_COLUMN_DISPLAY_LANGUAGE_TYPE + " TEXT , " +
62 RINGTONE_COLUMN_SCANNER_FLAG + " INT DEFAULT 0 " + ")";
63
64 const std::string CREATE_PRELOAD_CONF_TABLE = "CREATE TABLE IF NOT EXISTS " + PRELOAD_CONFIG_TABLE + "(" +
65 PRELOAD_CONFIG_COLUMN_RING_TONE_TYPE + " INTEGER PRIMARY KEY," +
66 PRELOAD_CONFIG_COLUMN_TONE_ID + " INTEGER ," +
67 PRELOAD_CONFIG_COLUMN_DISPLAY_NAME + " TEXT " + ")";
68
69 const std::string INIT_PRELOAD_CONF_TABLE = "INSERT OR IGNORE INTO " + PRELOAD_CONFIG_TABLE + " (" +
70 PRELOAD_CONFIG_COLUMN_RING_TONE_TYPE + ") VALUES (1), (2), (3), (4), (5), (6);";
71
72 const std::string CREATE_SIMCARD_SETTING_TABLE = "CREATE TABLE IF NOT EXISTS " + SIMCARD_SETTING_TABLE + "(" +
73 SIMCARD_SETTING_COLUMN_MODE + " INTEGER ," +
74 SIMCARD_SETTING_COLUMN_RINGTONE_TYPE + " INTEGER ," +
75 SIMCARD_SETTING_COLUMN_TONE_FILE + " TEXT ," +
76 SIMCARD_SETTING_COLUMN_VIBRATE_FILE + " TEXT ," +
77 SIMCARD_SETTING_COLUMN_VIBRATE_MODE + " INTEGER ," +
78 SIMCARD_SETTING_COLUMN_RING_MODE + " INTEGER ," +
79 " PRIMARY KEY (" + SIMCARD_SETTING_COLUMN_MODE + ", " + SIMCARD_SETTING_COLUMN_RINGTONE_TYPE + "))";
80
81 const std::string INIT_SIMCARD_SETTING_TABLE = "INSERT OR IGNORE INTO " + SIMCARD_SETTING_TABLE + " (" +
82 SIMCARD_SETTING_COLUMN_MODE + ", " +
83 SIMCARD_SETTING_COLUMN_RINGTONE_TYPE + ") VALUES (1, 0), (1, 1), (1, 2), (1, 3), \
84 (2, 0), (2, 1), (2, 2), (2, 3), \
85 (3, 0), (3, 1), (3, 2), (3, 3);";
86
87 const std::string CREATE_VIBRATE_TABLE = "CREATE TABLE IF NOT EXISTS " + VIBRATE_TABLE + "(" +
88 VIBRATE_COLUMN_VIBRATE_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
89 VIBRATE_COLUMN_DATA + " TEXT , " +
90 VIBRATE_COLUMN_SIZE + " BIGINT DEFAULT 0, " +
91 VIBRATE_COLUMN_DISPLAY_NAME + " TEXT , " +
92 VIBRATE_COLUMN_TITLE + " TEXT , " +
93 VIBRATE_COLUMN_DISPLAY_LANGUAGE + " TEXT , " +
94 VIBRATE_COLUMN_VIBRATE_TYPE + " INT DEFAULT 0, " +
95 VIBRATE_COLUMN_SOURCE_TYPE + " INT DEFAULT 0, " +
96 VIBRATE_COLUMN_DATE_ADDED + " BIGINT DEFAULT 0, " +
97 VIBRATE_COLUMN_DATE_MODIFIED + " BIGINT DEFAULT 0, " +
98 VIBRATE_COLUMN_DATE_TAKEN + " BIGINT DEFAULT 0, " +
99 VIBRATE_COLUMN_PLAY_MODE + " INT DEFAULT 0, " +
100 VIBRATE_COLUMN_SCANNER_FLAG + " INT DEFAULT 0 " + ")";
101
102
103 static const vector<string> g_initSqls = {
104 CREATE_RINGTONE_TABLE,
105 CREATE_VIBRATE_TABLE,
106 CREATE_SIMCARD_SETTING_TABLE,
107 INIT_SIMCARD_SETTING_TABLE,
108 CREATE_PRELOAD_CONF_TABLE,
109 INIT_PRELOAD_CONF_TABLE
110 };
111
RingtoneDataCallBack(void)112 RingtoneDataCallBack::RingtoneDataCallBack(void)
113 {
114 }
115
~RingtoneDataCallBack(void)116 RingtoneDataCallBack::~RingtoneDataCallBack(void)
117 {
118 }
119
InitSql(NativeRdb::RdbStore & store)120 int32_t RingtoneDataCallBack::InitSql(NativeRdb::RdbStore &store)
121 {
122 for (const string &sqlStr : g_initSqls) {
123 if (store.ExecuteSql(sqlStr) != NativeRdb::E_OK) {
124 RINGTONE_ERR_LOG("Failed to execute sql");
125 return NativeRdb::E_ERROR;
126 }
127 }
128 return NativeRdb::E_OK;
129 }
130
OnCreate(NativeRdb::RdbStore & store)131 int32_t RingtoneDataCallBack::OnCreate(NativeRdb::RdbStore &store)
132 {
133 if (InitSql(store) != NativeRdb::E_OK) {
134 RINGTONE_DEBUG_LOG("Failed to init sql");
135 return NativeRdb::E_ERROR;
136 }
137
138 RingtoneFileUtils::CreateRingtoneDir();
139 return NativeRdb::E_OK;
140 }
141
ExecSqls(const vector<string> & sqls,NativeRdb::RdbStore & store)142 static void ExecSqls(const vector<string> &sqls, NativeRdb::RdbStore &store)
143 {
144 int32_t err = NativeRdb::E_OK;
145 for (const auto &sql : sqls) {
146 err = store.ExecuteSql(sql);
147 if (err != NativeRdb::E_OK) {
148 RINGTONE_ERR_LOG("Failed to exec: %{private}s", sql.c_str());
149 continue;
150 }
151 }
152 }
153
AddDisplayLanguageColumn(NativeRdb::RdbStore & store)154 static void AddDisplayLanguageColumn(NativeRdb::RdbStore &store)
155 {
156 const vector<string> sqls = {
157 "ALTER TABLE " + RINGTONE_TABLE + " ADD COLUMN " + RINGTONE_COLUMN_DISPLAY_LANGUAGE_TYPE + " TEXT",
158 };
159 RINGTONE_INFO_LOG("Add display language column");
160 ExecSqls(sqls, store);
161 }
162
AddScannerFlagColumn(NativeRdb::RdbStore & store)163 static void AddScannerFlagColumn(NativeRdb::RdbStore &store)
164 {
165 const vector<string> sqls = {
166 "ALTER TABLE " + RINGTONE_TABLE + " ADD COLUMN " + RINGTONE_COLUMN_SCANNER_FLAG + " INT DEFAULT 0",
167 "ALTER TABLE " + VIBRATE_TABLE + " ADD COLUMN " + VIBRATE_COLUMN_SCANNER_FLAG + " INT DEFAULT 0",
168 };
169 RINGTONE_INFO_LOG("Add scanner flag column");
170 ExecSqls(sqls, store);
171 }
172
UpdateMimeType(NativeRdb::RdbStore & store)173 static void UpdateMimeType(NativeRdb::RdbStore &store)
174 {
175 RINGTONE_INFO_LOG("Update MimeType Begin");
176 RingtoneMimeTypeUtils::InitMimeTypeMap();
177 const string sql = "SELECT * FROM " + RINGTONE_TABLE;
178 auto resultSet = store.QuerySql(sql);
179 if (resultSet == nullptr) {
180 RINGTONE_ERR_LOG("error query sql %{public}s", sql.c_str());
181 return;
182 }
183 while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
184 std::string mimeType = GetStringVal(RINGTONE_COLUMN_MIME_TYPE, resultSet);
185 if (mimeType != DEFAULT_MIME_TYPE) {
186 continue;
187 }
188 string displayName = GetStringVal(RINGTONE_COLUMN_DISPLAY_NAME, resultSet);
189 int32_t toneid = GetInt32Val(RINGTONE_COLUMN_TONE_ID, resultSet);
190 std::string extension = RingtoneFileUtils::GetFileExtension(displayName);
191 mimeType = RingtoneMimeTypeUtils::GetMimeTypeFromExtension(extension);
192 int32_t mime = RingtoneMimeTypeUtils::GetMediaTypeFromMimeType(mimeType);
193 RINGTONE_INFO_LOG("extension: %{public}s, mimeType: %{public}s, toneid: %{public}d mime: %{public}d",
194 extension.c_str(), mimeType.c_str(), toneid, mime);
195
196 NativeRdb::ValuesBucket values;
197 values.PutString(RINGTONE_COLUMN_MIME_TYPE, mimeType);
198 values.PutInt(RINGTONE_COLUMN_MEDIA_TYPE, mime);
199 NativeRdb::AbsRdbPredicates absRdbPredicates(RINGTONE_TABLE);
200 absRdbPredicates.EqualTo(RINGTONE_COLUMN_TONE_ID, toneid);
201 int32_t changedRows;
202 int32_t result = store.Update(changedRows, values, absRdbPredicates);
203 if (result != E_OK || changedRows <= 0) {
204 RINGTONE_ERR_LOG("Update operation failed. Result %{public}d. Updated %{public}d", result, changedRows);
205 }
206 }
207 resultSet->Close();
208 }
209
AddPreloadConfTable(NativeRdb::RdbStore & store)210 static void AddPreloadConfTable(NativeRdb::RdbStore &store)
211 {
212 const vector<string> sqls = {
213 CREATE_PRELOAD_CONF_TABLE,
214 INIT_PRELOAD_CONF_TABLE
215 };
216 RINGTONE_INFO_LOG("Add preload config table");
217 ExecSqls(sqls, store);
218 }
219
UpdateDefaultSystemTone(NativeRdb::RdbStore & store)220 static void UpdateDefaultSystemTone(NativeRdb::RdbStore &store)
221 {
222 RINGTONE_INFO_LOG("setting system tone begin");
223 auto infos = RingtoneUtils::GetDefaultSystemtoneInfo();
224 for (auto info : infos) {
225 const string querySql = "SELECT tone_id FROM ToneFiles WHERE display_name = "s + "\"" + info.second + "\"";
226 auto resultSet = store.QuerySql(querySql);
227 if (resultSet == nullptr || resultSet->GoToFirstRow() != NativeRdb::E_OK) {
228 RINGTONE_ERR_LOG("Update operation failed. no resultSet");
229 continue;
230 }
231
232 int32_t tone_id = GetInt32Val("tone_id", resultSet);
233 NativeRdb::ValuesBucket values;
234 values.PutString(PRELOAD_CONFIG_COLUMN_DISPLAY_NAME, info.second);
235 values.PutInt(PRELOAD_CONFIG_COLUMN_TONE_ID, tone_id);
236 NativeRdb::AbsRdbPredicates absRdbPredicates(PRELOAD_CONFIG_TABLE);
237 absRdbPredicates.EqualTo(PRELOAD_CONFIG_COLUMN_RING_TONE_TYPE, std::to_string(info.first));
238 int32_t changedRows = 0;
239 int32_t result = store.Update(changedRows, values, absRdbPredicates);
240 if (result != E_OK || changedRows <= 0) {
241 RINGTONE_ERR_LOG("Update operation failed. Result %{public}d. Updated %{public}d", result, changedRows);
242 }
243 }
244 }
245
AddVibrateTable(NativeRdb::RdbStore & store)246 static void AddVibrateTable(NativeRdb::RdbStore &store)
247 {
248 const vector<string> sqls = {
249 CREATE_VIBRATE_TABLE,
250 CREATE_SIMCARD_SETTING_TABLE,
251 INIT_SIMCARD_SETTING_TABLE,
252 };
253 int32_t errCode;
254 shared_ptr<NativePreferences::Preferences> prefs =
255 NativePreferences::PreferencesHelper::GetPreferences(COMMON_XML_EL1, errCode);
256 if (!prefs) {
257 RINGTONE_ERR_LOG("AddVibrateTable: update faild errCode=%{public}d", errCode);
258 } else {
259 prefs->PutInt(RINGTONE_PARAMETER_SCANNER_COMPLETED_KEY, RINGTONE_PARAMETER_SCANNER_COMPLETED_FALSE);
260 prefs->FlushSync();
261 }
262
263 RINGTONE_INFO_LOG("Add vibrate table");
264 ExecSqls(sqls, store);
265 }
266
UpgradeExtension(NativeRdb::RdbStore & store,int32_t oldVersion)267 static void UpgradeExtension(NativeRdb::RdbStore &store, int32_t oldVersion)
268 {
269 if (oldVersion < VERSION_ADD_DISPLAY_LANGUAGE_COLUMN) {
270 AddDisplayLanguageColumn(store);
271 }
272 if (oldVersion < VERSION_UPDATE_MIME_TYPE) {
273 UpdateMimeType(store);
274 }
275 if (oldVersion < VERSION_ADD_PRELOAD_CONF_TABLE) {
276 AddPreloadConfTable(store);
277 UpdateDefaultSystemTone(store);
278 }
279 if (oldVersion < VERSION_ADD_VIBRATE_TABLE) {
280 AddVibrateTable(store);
281 }
282 if (oldVersion < VERSION_UPDATE_WATCH_MIME_TYPE) {
283 UpdateMimeType(store);
284 }
285 if (oldVersion < VERSION_ADD_SCANNER_FLAG) {
286 AddScannerFlagColumn(store);
287 }
288 }
289
OnUpgrade(NativeRdb::RdbStore & store,int32_t oldVersion,int32_t newVersion)290 int32_t RingtoneDataCallBack::OnUpgrade(NativeRdb::RdbStore &store, int32_t oldVersion, int32_t newVersion)
291 {
292 RINGTONE_INFO_LOG("OnUpgrade old:%d, new:%d", oldVersion, newVersion);
293 UpgradeExtension(store, oldVersion);
294 return NativeRdb::E_OK;
295 }
296 } // namespace Media
297 } // namespace OHOS
298