1 /*
2 * Copyright (C) 2022 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 #include <map>
16 #include "medialibrary_errno.h"
17 #include "medialibrary_db_const.h"
18 #include "media_file_utils.h"
19 #include "media_log.h"
20 #include "media_mtp_utils.h"
21 #include "mtp_data_utils.h"
22 #include "mtp_constants.h"
23 #include "mtp_packet_tools.h"
24 #include "payload_data/get_object_props_supported_data.h"
25 #include "payload_data.h"
26 #include "rdb_errno.h"
27
28 using namespace std;
29 namespace OHOS {
30 namespace Media {
31 struct NormalProperty {
32 int32_t intValue;
33 string strValue;
34 };
35 static constexpr int32_t INTTYPE16 = 16;
36 static constexpr int32_t INTTYPE128 = 128;
37 static constexpr int32_t STRINGTYPE = -1;
38 static const string MEDIA_DATA_DB_FORMAT = "format";
39
40 static const map<uint16_t, string> FormatMap = {
41 { 0, MTP_FORMAT_ALL},
42 { MTP_FORMAT_UNDEFINED_CODE, MTP_FORMAT_UNDEFINED },
43 { MTP_FORMAT_ASSOCIATION_CODE, MTP_FORMAT_ASSOCIATION },
44 { MTP_FORMAT_SCRIPT_CODE, MTP_FORMAT_SCRIPT },
45 { MTP_FORMAT_EXECUTABLE_CODE, MTP_FORMAT_EXECUTABLE },
46 { MTP_FORMAT_TEXT_CODE, MTP_FORMAT_TEXT },
47 { MTP_FORMAT_DPOF_CODE, MTP_FORMAT_DPOF },
48 { MTP_FORMAT_AIFF_CODE, MTP_FORMAT_AIFF },
49 { MTP_FORMAT_WAV_CODE, MTP_FORMAT_WAV },
50 { MTP_FORMAT_HTML_CODE, MTP_FORMAT_HTML },
51 { MTP_FORMAT_MP3_CODE, MTP_FORMAT_MP3 },
52 { MTP_FORMAT_AVI_CODE, MTP_FORMAT_AVI },
53 { MTP_FORMAT_MPEG_CODE, MTP_FORMAT_ASF },
54 // image files...
55 { MTP_FORMAT_DEFINED_CODE, MTP_FORMAT_DEFINED },
56 { MTP_FORMAT_EXIF_JPEG_CODE, MTP_FORMAT_EXIF_JPEG },
57 { MTP_FORMAT_FLASHPIX_CODE, MTP_FORMAT_FLASHPIX },
58 { MTP_FORMAT_BMP_CODE, MTP_FORMAT_BMP },
59 { MTP_FORMAT_CIFF_CODE, MTP_FORMAT_CIFF },
60 { MTP_FORMAT_GIF_CODE, MTP_FORMAT_GIF },
61 { MTP_FORMAT_JFIF_CODE, MTP_FORMAT_JFIF },
62 { MTP_FORMAT_CD_CODE, MTP_FORMAT_CD },
63 { MTP_FORMAT_PICT_CODE, MTP_FORMAT_PICT },
64 { MTP_FORMAT_PNG_CODE, MTP_FORMAT_PNG },
65 { MTP_FORMAT_TIFF_CODE, MTP_FORMAT_TIFF },
66 { MTP_FORMAT_JP2_CODE, MTP_FORMAT_JP2 },
67 { MTP_FORMAT_JPX_CODE, MTP_FORMAT_JPX },
68 // firmware files
69 { MTP_FORMAT_UNDEFINED_FIRMWARE_CODE, MTP_FORMAT_UNDEFINED_FIRMWARE },
70 // Windows image files
71 { MTP_FORMAT_WINDOWS_IMAGE_FORMAT_CODE, MTP_FORMAT_WINDOWS_IMAGE_FORMAT },
72 // audio files
73 { MTP_FORMAT_UNDEFINED_AUDIO_CODE, MTP_FORMAT_UNDEFINED_AUDIO },
74 { MTP_FORMAT_WMA_CODE, MTP_FORMAT_WMA },
75 { MTP_FORMAT_OGG_CODE, MTP_FORMAT_OGG },
76 { MTP_FORMAT_AAC_CODE, MTP_FORMAT_AAC },
77 { MTP_FORMAT_AUDIBLE_CODE, MTP_FORMAT_AUDIBLE },
78 { MTP_FORMAT_FLAC_CODE, MTP_FORMAT_FLAC },
79 // video files
80 { MTP_FORMAT_UNDEFINED_VIDEO_CODE, MTP_FORMAT_UNDEFINED_VIDEO },
81 { MTP_FORMAT_WMV_CODE, MTP_FORMAT_WMV },
82 { MTP_FORMAT_MP4_CONTAINER_CODE, MTP_FORMAT_MP4_CONTAINER },
83 { MTP_FORMAT_MP2_CODE, MTP_FORMAT_MP2 },
84 { MTP_FORMAT_3GP_CONTAINER_CODE, MTP_FORMAT_3GP_CONTAINER },
85 // unknown
86 { MTP_FORMAT_UNDEFINED_COLLECTION_CODE, MTP_FORMAT_UNDEFINED_COLLECTION },
87 { MTP_FORMAT_ABSTRACT_MULTIMEDIA_ALBUM_CODE, MTP_FORMAT_ABSTRACT_MULTIMEDIA_ALBUM },
88 { MTP_FORMAT_ABSTRACT_IMAGE_ALBUM_CODE, MTP_FORMAT_ABSTRACT_IMAGE_ALBUM },
89 { MTP_FORMAT_ABSTRACT_AUDIO_ALBUM_CODE, MTP_FORMAT_ABSTRACT_AUDIO_ALBUM },
90 { MTP_FORMAT_ABSTRACT_VIDEO_ALBUM_CODE, MTP_FORMAT_ABSTRACT_VIDEO_ALBUM },
91 { MTP_FORMAT_ABSTRACT_AUDIO_VIDEO_PLAYLIST_CODE, MTP_FORMAT_ABSTRACT_AUDIO_VIDEO_PLAYLIST },
92 { MTP_FORMAT_ABSTRACT_CONTACT_GROUP_CODE, MTP_FORMAT_ABSTRACT_CONTACT_GROUP },
93 { MTP_FORMAT_ABSTRACT_MESSAGE_FOLDER_CODE, MTP_FORMAT_ABSTRACT_MESSAGE_FOLDER },
94 { MTP_FORMAT_ABSTRACT_CHAPTERED_PRODUCTION_CODE, MTP_FORMAT_ABSTRACT_CHAPTERED_PRODUCTION },
95 { MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST_CODE, MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST },
96 { MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST_CODE, MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST },
97 { MTP_FORMAT_ABSTRACT_MEDIACAST_CODE, MTP_FORMAT_ABSTRACT_MEDIACAST },
98 { MTP_FORMAT_WPL_PLAYLIST_CODE, MTP_FORMAT_WPL_PLAYLIST },
99 { MTP_FORMAT_M3U_PLAYLIST_CODE, MTP_FORMAT_M3U_PLAYLIST },
100 { MTP_FORMAT_MPL_PLAYLIST_CODE, MTP_FORMAT_MPL_PLAYLIST },
101 { MTP_FORMAT_ASX_PLAYLIST_CODE, MTP_FORMAT_ASX_PLAYLIST },
102 { MTP_FORMAT_PLS_PLAYLIST_CODE, MTP_FORMAT_PLS_PLAYLIST },
103 { MTP_FORMAT_UNDEFINED_DOCUMENT_CODE, MTP_FORMAT_UNDEFINED_DOCUMENT },
104 { MTP_FORMAT_XML_DOCUMENT_CODE, MTP_FORMAT_XML_DOCUMENT },
105 { MTP_FORMAT_ABSTRACT_DOCUMENT_CODE, MTP_FORMAT_ABSTRACT_DOCUMENT },
106 { MTP_FORMAT_MICROSOFT_WORD_DOCUMENT_CODE, MTP_FORMAT_MICROSOFT_WORD_DOCUMENT },
107 { MTP_FORMAT_MHT_COMPILED_HTML_DOCUMENT_CODE, MTP_FORMAT_MHT_COMPILED_HTML_DOCUMENT },
108 { MTP_FORMAT_MICROSOFT_EXCEL_SPREADSHEET_CODE, MTP_FORMAT_MICROSOFT_EXCEL_SPREADSHEET },
109 { MTP_FORMAT_UNDEFINED_MESSAGE_CODE, MTP_FORMAT_UNDEFINED_MESSAGE },
110 { MTP_FORMAT_ABSTRACT_MESSAGE_CODE, MTP_FORMAT_ABSTRACT_MESSAGE },
111 { MTP_FORMAT_UNDEFINED_CONTACT_CODE, MTP_FORMAT_UNDEFINED_CONTACT },
112 { MTP_FORMAT_ABSTRACT_CONTACT_CODE, MTP_FORMAT_ABSTRACT_CONTACT },
113 { MTP_FORMAT_MICROSOFT_POWERPOINT_PRESENTATION_CODE, MTP_FORMAT_MICROSOFT_POWERPOINT_PRESENTATION },
114 { MTP_FORMAT_VCARD_2_CODE, MTP_FORMAT_VCARD_2 }
115 };
116
117 static const map<std::string, MediaType> FormatAllMap = {
118 { MTP_FORMAT_ALL, MEDIA_TYPE_ALL },
119 { MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST, MEDIA_TYPE_AUDIO },
120 { MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST, MEDIA_TYPE_VIDEO },
121 { MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST, MEDIA_TYPE_VIDEO },
122 { MTP_FORMAT_ASSOCIATION, MEDIA_TYPE_ALBUM }
123 };
124
125 static const map<uint16_t, MediaType> FormatMediaTypeMap = {
126 { 0, MEDIA_TYPE_ALL },
127 { MTP_FORMAT_UNDEFINED_CODE, MEDIA_TYPE_FILE },
128 { MTP_FORMAT_DEFINED_CODE, MEDIA_TYPE_IMAGE },
129 { MTP_FORMAT_EXIF_JPEG_CODE, MEDIA_TYPE_IMAGE },
130 { MTP_FORMAT_FLASHPIX_CODE, MEDIA_TYPE_IMAGE },
131 { MTP_FORMAT_BMP_CODE, MEDIA_TYPE_IMAGE },
132 { MTP_FORMAT_CIFF_CODE, MEDIA_TYPE_IMAGE },
133 { MTP_FORMAT_GIF_CODE, MEDIA_TYPE_IMAGE },
134 { MTP_FORMAT_JFIF_CODE, MEDIA_TYPE_IMAGE },
135 { MTP_FORMAT_CD_CODE, MEDIA_TYPE_IMAGE },
136 { MTP_FORMAT_PICT_CODE, MEDIA_TYPE_IMAGE },
137 { MTP_FORMAT_PNG_CODE, MEDIA_TYPE_IMAGE },
138 { MTP_FORMAT_TIFF_CODE, MEDIA_TYPE_IMAGE },
139 { MTP_FORMAT_JP2_CODE, MEDIA_TYPE_IMAGE },
140 { MTP_FORMAT_JPX_CODE, MEDIA_TYPE_IMAGE },
141 { MTP_FORMAT_UNDEFINED_AUDIO_CODE, MEDIA_TYPE_AUDIO },
142 { MTP_FORMAT_WMA_CODE, MEDIA_TYPE_AUDIO },
143 { MTP_FORMAT_OGG_CODE, MEDIA_TYPE_AUDIO },
144 { MTP_FORMAT_AAC_CODE, MEDIA_TYPE_AUDIO },
145 { MTP_FORMAT_AUDIBLE_CODE, MEDIA_TYPE_AUDIO },
146 { MTP_FORMAT_FLAC_CODE, MEDIA_TYPE_AUDIO },
147 { MTP_FORMAT_UNDEFINED_VIDEO_CODE, MEDIA_TYPE_VIDEO },
148 { MTP_FORMAT_WMV_CODE, MEDIA_TYPE_VIDEO },
149 { MTP_FORMAT_MP4_CONTAINER_CODE, MEDIA_TYPE_VIDEO },
150 { MTP_FORMAT_MP3_CODE, MEDIA_TYPE_AUDIO },
151 { MTP_FORMAT_MP2_CODE, MEDIA_TYPE_VIDEO },
152 { MTP_FORMAT_3GP_CONTAINER_CODE, MEDIA_TYPE_VIDEO },
153 { MTP_FORMAT_ASSOCIATION_CODE, MEDIA_TYPE_ALBUM}
154 };
155
156 static const map<uint32_t, std::string> ObjMediaPropMap = {
157 { MTP_PROPERTY_OBJECT_FILE_NAME_CODE, MEDIA_DATA_DB_NAME },
158 { MTP_PROPERTY_PARENT_OBJECT_CODE, MEDIA_DATA_DB_PARENT_ID }
159 };
160
161 static const map<uint16_t, int> ObjMediaPropTypeMap = {
162 { MTP_PROPERTY_OBJECT_FILE_NAME_CODE, MTP_TYPE_STRING_CODE },
163 { MTP_PROPERTY_PARENT_OBJECT_CODE, MTP_TYPE_UINT32_CODE }
164 };
165
166 static const map<std::string, uint16_t> ColumnToPropTypeMap = {
167 { MEDIA_DATA_DB_SIZE, MTP_PROPERTY_OBJECT_SIZE_CODE },
168 { MEDIA_DATA_DB_NAME, MTP_PROPERTY_OBJECT_FILE_NAME_CODE },
169 { MEDIA_DATA_DB_DATE_MODIFIED, MTP_PROPERTY_DATE_MODIFIED_CODE },
170 { MEDIA_DATA_DB_PARENT_ID, MTP_PROPERTY_PARENT_OBJECT_CODE },
171 { MEDIA_DATA_DB_NAME, MTP_PROPERTY_NAME_CODE },
172 { MEDIA_DATA_DB_NAME, MTP_PROPERTY_DISPLAY_NAME_CODE },
173 { MEDIA_DATA_DB_DATE_ADDED, MTP_PROPERTY_DATE_ADDED_CODE },
174 { MEDIA_DATA_DB_ARTIST, MTP_PROPERTY_ARTIST_CODE },
175 { MEDIA_DATA_DB_DURATION, MTP_PROPERTY_DURATION_CODE },
176 { MEDIA_DATA_DB_DESCRIPTION, MTP_PROPERTY_DESCRIPTION_CODE },
177 };
178
179 static const map<std::string, ResultSetDataType> ColumnTypeMap = {
180 { MEDIA_DATA_DB_ID, TYPE_INT32 },
181 { MEDIA_DATA_DB_SIZE, TYPE_INT64 },
182 { MEDIA_DATA_DB_PARENT_ID, TYPE_INT32 },
183 { MEDIA_DATA_DB_DATE_MODIFIED, TYPE_INT64 },
184 { MEDIA_DATA_DB_DATE_ADDED, TYPE_INT64 },
185 { MEDIA_DATA_DB_NAME, TYPE_STRING },
186 { MEDIA_DATA_DB_DESCRIPTION, TYPE_STRING },
187 { MEDIA_DATA_DB_DURATION, TYPE_INT32 },
188 { MEDIA_DATA_DB_ARTIST, TYPE_STRING },
189 { MEDIA_DATA_DB_AUDIO_ALBUM, TYPE_STRING },
190 { MEDIA_DATA_DB_FORMAT, TYPE_INT32 },
191 };
192
193 static const map<uint16_t, std::string> PropColumnMap = {
194 { MTP_PROPERTY_OBJECT_FORMAT_CODE, MEDIA_DATA_DB_FORMAT },
195 { MTP_PROPERTY_OBJECT_SIZE_CODE, MEDIA_DATA_DB_SIZE },
196 { MTP_PROPERTY_OBJECT_FILE_NAME_CODE, MEDIA_DATA_DB_NAME },
197 { MTP_PROPERTY_DATE_MODIFIED_CODE, MEDIA_DATA_DB_DATE_MODIFIED },
198 { MTP_PROPERTY_PARENT_OBJECT_CODE, MEDIA_DATA_DB_PARENT_ID },
199 { MTP_PROPERTY_NAME_CODE, MEDIA_DATA_DB_NAME },
200 { MTP_PROPERTY_DISPLAY_NAME_CODE, MEDIA_DATA_DB_NAME },
201 { MTP_PROPERTY_DATE_ADDED_CODE, MEDIA_DATA_DB_DATE_ADDED },
202 { MTP_PROPERTY_ARTIST_CODE, MEDIA_DATA_DB_ARTIST },
203 { MTP_PROPERTY_DURATION_CODE, MEDIA_DATA_DB_DURATION },
204 };
205
206 static const map<uint16_t, int32_t> PropDefaultMap = {
207 { MTP_PROPERTY_STORAGE_ID_CODE, DEFAULT_STORAGE_ID },
208 { MTP_PROPERTY_PROTECTION_STATUS_CODE, INTTYPE16 },
209 { MTP_PROPERTY_PERSISTENT_UID_CODE, INTTYPE128 },
210 { MTP_PROPERTY_ALBUM_NAME_CODE, STRINGTYPE },
211 { MTP_PROPERTY_ALBUM_ARTIST_CODE, STRINGTYPE },
212 { MTP_PROPERTY_TRACK_CODE, INTTYPE16 },
213 { MTP_PROPERTY_ORIGINAL_RELEASE_DATE_CODE, STRINGTYPE },
214 { MTP_PROPERTY_GENRE_CODE, STRINGTYPE },
215 };
216
SolveHandlesFormatData(const uint16_t format,std::string & outExtension,MediaType & outMediaType)217 int32_t MtpDataUtils::SolveHandlesFormatData(const uint16_t format, std::string &outExtension, MediaType &outMediaType)
218 {
219 if (FormatMap.find(format) == FormatMap.end()) {
220 MEDIA_ERR_LOG("Can not find format");
221 return MTP_ERROR_INVALID_OBJECTHANDLE;
222 }
223 outExtension = FormatMap.at(format);
224 if (FormatAllMap.find(outExtension) != FormatAllMap.end()) {
225 outMediaType = FormatAllMap.at(outExtension);
226 return MTP_SUCCESS;
227 }
228 outMediaType = MEDIA_TYPE_DEFAULT;
229 return MTP_SUCCESS;
230 }
231
SolveSendObjectFormatData(const uint16_t format,MediaType & outMediaType)232 int32_t MtpDataUtils::SolveSendObjectFormatData(const uint16_t format, MediaType &outMediaType)
233 {
234 if (FormatMediaTypeMap.find(format) == FormatMediaTypeMap.end()) {
235 MEDIA_ERR_LOG("Can not find format");
236 outMediaType = MEDIA_TYPE_FILE;
237 } else {
238 outMediaType = FormatMediaTypeMap.at(format);
239 }
240 return MTP_SUCCESS;
241 }
242
SolveSetObjectPropValueData(const shared_ptr<MtpOperationContext> & context,std::string & outColName,variant<int64_t,std::string> & outColVal)243 int32_t MtpDataUtils::SolveSetObjectPropValueData(const shared_ptr<MtpOperationContext> &context,
244 std::string &outColName, variant<int64_t, std::string> &outColVal)
245 {
246 if (ObjMediaPropTypeMap.find(context->property) == ObjMediaPropTypeMap.end()) {
247 MEDIA_ERR_LOG("Can not support propertyType");
248 return MTP_ERROR_INVALID_OBJECTPROP_VALUE;
249 }
250 if (ObjMediaPropMap.find(context->property) == ObjMediaPropMap.end()) {
251 MEDIA_ERR_LOG("Can not support this property");
252 return MTP_ERROR_INVALID_OBJECTPROP_VALUE;
253 } else {
254 outColName = ObjMediaPropMap.at(context->property);
255 }
256 if (context->properType == MTP_TYPE_STRING_CODE) {
257 outColVal = context->properStrValue;
258 MEDIA_INFO_LOG("context->properStrValue = %{public}s", context->properStrValue.c_str());
259 } else {
260 outColVal = context->properIntValue;
261 }
262 return MTP_SUCCESS;
263 }
264
GetMediaTypeByformat(const uint16_t format,MediaType & outMediaType)265 void MtpDataUtils::GetMediaTypeByformat(const uint16_t format, MediaType &outMediaType)
266 {
267 if (FormatMediaTypeMap.find(format) == FormatMediaTypeMap.end()) {
268 MEDIA_ERR_LOG("Can not find format");
269 outMediaType = MEDIA_TYPE_DEFAULT;
270 }
271 if (FormatMediaTypeMap.find(format) != FormatMediaTypeMap.end()) {
272 outMediaType = FormatMediaTypeMap.at(format);
273 }
274 }
275
GetPropListBySet(const uint32_t property,const uint16_t format,const shared_ptr<DataShare::DataShareResultSet> & resultSet,shared_ptr<vector<Property>> & outProps)276 int32_t MtpDataUtils::GetPropListBySet(const uint32_t property, const uint16_t format,
277 const shared_ptr<DataShare::DataShareResultSet> &resultSet, shared_ptr<vector<Property>> &outProps)
278 {
279 shared_ptr<UInt16List> properties = make_shared<UInt16List>();
280 if (property == MTP_PROPERTY_ALL_CODE) {
281 shared_ptr<MtpOperationContext> context = make_shared<MtpOperationContext>();
282 context->format = format;
283 shared_ptr<GetObjectPropsSupportedData> payLoadData = make_shared<GetObjectPropsSupportedData>(context);
284 payLoadData->GetObjectProps(*properties);
285 } else {
286 properties->push_back(property);
287 }
288 return GetPropList(resultSet, properties, outProps);
289 }
290
GetPropList(const shared_ptr<DataShare::DataShareResultSet> & resultSet,const shared_ptr<UInt16List> & properties,shared_ptr<vector<Property>> & outProps)291 int32_t MtpDataUtils::GetPropList(const shared_ptr<DataShare::DataShareResultSet> &resultSet,
292 const shared_ptr<UInt16List> &properties, shared_ptr<vector<Property>> &outProps)
293 {
294 int count = 0;
295 resultSet->GetRowCount(count);
296 if (properties->size() == 0) {
297 return MTP_INVALID_OBJECTPROPCODE_CODE;
298 }
299 ResultSetDataType idType = TYPE_INT32;
300 int32_t handle = 0;
301 for (int32_t row = 0; row < count; row++) {
302 resultSet->GoToRow(row);
303 handle = get<int32_t>(ResultSetUtils::GetValFromColumn(MEDIA_DATA_DB_ID, resultSet, idType));
304 MEDIA_INFO_LOG("GetPropList %{public}d",
305 get<int32_t>(ResultSetUtils::GetValFromColumn(MEDIA_DATA_DB_ID, resultSet, idType)));
306 GetOneRowPropList(static_cast<uint32_t>(handle), resultSet, properties, outProps);
307 }
308 return MTP_SUCCESS;
309 }
310
ReturnError(const std::string & errMsg,const ResultSetDataType & type)311 variant<int32_t, int64_t, std::string> MtpDataUtils::ReturnError(const std::string &errMsg,
312 const ResultSetDataType &type)
313 {
314 MEDIA_ERR_LOG("%{public}s", errMsg.c_str());
315 if ((type) == TYPE_STRING) {
316 return "";
317 } else {
318 return 0;
319 }
320 }
321
GetFormatByPath(const std::string & path,uint16_t & outFormat)322 void MtpDataUtils::GetFormatByPath(const std::string &path, uint16_t &outFormat)
323 {
324 if (path.empty()) {
325 MEDIA_ERR_LOG("path is nullptr");
326 return;
327 }
328 if (MediaFileUtils::IsDirectory(path)) {
329 MEDIA_ERR_LOG("path is dir");
330 outFormat = MTP_FORMAT_ASSOCIATION_CODE;
331 return;
332 }
333 size_t slashIndex = path.rfind('/');
334 std::string displayName;
335 if (slashIndex != std::string::npos) {
336 displayName = path.substr(slashIndex + 1);
337 }
338 size_t extensionIndex = displayName.find(".");
339 std::string extension;
340 if (extensionIndex != std::string::npos) {
341 extension = displayName.substr(extensionIndex);
342 } else {
343 MEDIA_ERR_LOG("get extensionIndex failed");
344 outFormat = MTP_FORMAT_UNDEFINED_CODE;
345 return;
346 }
347 for (auto pair : FormatMap) {
348 if ((pair.second).find(extension) != std::string::npos) {
349 outFormat = pair.first;
350 break;
351 }
352 }
353 }
354
GetFormat(const shared_ptr<DataShare::DataShareResultSet> & resultSet,uint16_t & outFormat)355 int32_t MtpDataUtils::GetFormat(const shared_ptr<DataShare::DataShareResultSet> &resultSet,
356 uint16_t &outFormat)
357 {
358 int index, status, mediaType;
359 status = resultSet->GetColumnIndex(MEDIA_DATA_DB_MEDIA_TYPE, index);
360 if (status != NativeRdb::E_OK) {
361 MEDIA_ERR_LOG("GetColumnIndex failed");
362 return E_FAIL;
363 }
364 resultSet->GetInt(index, mediaType);
365 if (mediaType == MEDIA_TYPE_ALBUM) {
366 outFormat = MTP_FORMAT_ASSOCIATION_CODE;
367 return E_SUCCESS;
368 }
369 status = resultSet->GetColumnIndex(MEDIA_DATA_DB_FILE_PATH, index);
370 if (status != NativeRdb::E_OK) {
371 MEDIA_ERR_LOG("GetColumnIndex failed");
372 return E_FAIL;
373 }
374 std::string pathVal;
375 status = resultSet->GetString(index, pathVal);
376 if (status != NativeRdb::E_OK) {
377 MEDIA_ERR_LOG("GetString failed");
378 return E_FAIL;
379 }
380 if (pathVal.empty()) {
381 MEDIA_ERR_LOG("path is empty");
382 return E_FAIL;
383 }
384 GetFormatByPath(pathVal, outFormat);
385 return E_SUCCESS;
386 }
387
LocalTime(struct tm & t,time_t curTime)388 void LocalTime(struct tm &t, time_t curTime)
389 {
390 time_t curTimeTemp = curTime;
391 if (curTimeTemp == 0) {
392 curTimeTemp = time(nullptr);
393 }
394 auto tm = localtime(&curTimeTemp);
395 if (tm) {
396 t = *tm;
397 }
398 }
399
Strftime(const std::string & format,time_t curTime)400 std::string Strftime(const std::string &format, time_t curTime)
401 {
402 if (format.empty()) {
403 return format;
404 }
405 struct tm t = {};
406 LocalTime(t, curTime);
407 char szDTime[32] = "";
408 (void)strftime(szDTime, sizeof(szDTime), format.c_str(), &t);
409 return szDTime;
410 }
411
SetProperty(const std::string & column,const shared_ptr<DataShare::DataShareResultSet> & resultSet,ResultSetDataType & type,Property & prop)412 void MtpDataUtils::SetProperty(const std::string &column, const shared_ptr<DataShare::DataShareResultSet> &resultSet,
413 ResultSetDataType &type, Property &prop)
414 {
415 variant<int32_t, std::string, int64_t, double> columnValue =
416 ResultSetUtils::GetValFromColumn(column, resultSet, type);
417 switch (type) {
418 case TYPE_STRING:
419 prop.currentValue->str_ = make_shared<std::string>(get<std::string>(columnValue));
420 break;
421 case TYPE_INT32:
422 prop.currentValue->bin_.i32 = get<int32_t>(columnValue);
423 break;
424 case TYPE_INT64:
425 if (column.compare(MEDIA_DATA_DB_DATE_MODIFIED) == 0) {
426 prop.currentValue->str_ =
427 make_shared<std::string>(MtpPacketTool::FormatDateTime(get<int64_t>(columnValue)));
428 } else {
429 prop.currentValue->bin_.i64 = get<int64_t>(columnValue);
430 }
431 break;
432 default:
433 break;
434 }
435 }
436
GetOneRowPropList(uint32_t handle,const shared_ptr<DataShare::DataShareResultSet> & resultSet,const shared_ptr<UInt16List> & properties,shared_ptr<vector<Property>> & outProps)437 void MtpDataUtils::GetOneRowPropList(uint32_t handle, const shared_ptr<DataShare::DataShareResultSet> &resultSet,
438 const shared_ptr<UInt16List> &properties, shared_ptr<vector<Property>> &outProps)
439 {
440 std::string column;
441 ResultSetDataType type;
442 for (uint16_t property : *properties) {
443 if (PropColumnMap.find(property) != PropColumnMap.end()) {
444 auto properType = MtpPacketTool::GetObjectPropTypeByPropCode(property);
445 Property prop(property, properType);
446 prop.handle_ = handle;
447 column = PropColumnMap.at(property);
448 type = ColumnTypeMap.at(column);
449 if (column.compare(MEDIA_DATA_DB_FORMAT) == 0) {
450 uint16_t format = MTP_FORMAT_UNDEFINED_CODE;
451 GetFormat(resultSet, format);
452 prop.currentValue->bin_.ui16 = format;
453 MEDIA_INFO_LOG("prop.currentValue->bin_.ui16 %{public}u", format);
454 } else {
455 SetProperty(column, resultSet, type, prop);
456 }
457 outProps->push_back(prop);
458 } else if (PropDefaultMap.find(property) != PropDefaultMap.end()) {
459 SetOneDefaultlPropList(handle, property, outProps);
460 }
461 }
462 }
463
GetPropValueBySet(const uint32_t property,const shared_ptr<DataShare::DataShareResultSet> & resultSet,PropertyValue & outPropValue)464 int32_t MtpDataUtils::GetPropValueBySet(const uint32_t property,
465 const shared_ptr<DataShare::DataShareResultSet> &resultSet, PropertyValue &outPropValue)
466 {
467 if (resultSet->GoToFirstRow() != 0) {
468 return MTP_ERROR_INVALID_OBJECTHANDLE;
469 }
470 if (PropColumnMap.find(property) != PropColumnMap.end()) {
471 std::string column = PropColumnMap.at(property);
472 ResultSetDataType type = ColumnTypeMap.at(column);
473 variant<int32_t, std::string, int64_t, double> columnValue =
474 ResultSetUtils::GetValFromColumn(column, resultSet, type);
475 switch (type) {
476 case TYPE_STRING:
477 outPropValue.outStrVal = get<std::string>(columnValue);
478 break;
479 case TYPE_INT32:
480 outPropValue.outIntVal = static_cast<uint64_t>(get<int32_t>(columnValue));
481 break;
482 case TYPE_INT64:
483 if (column.compare(MEDIA_DATA_DB_DATE_MODIFIED) == 0) {
484 std::string timeFormat = "%Y-%m-%d %H:%M:%S";
485 outPropValue.outStrVal = Strftime(timeFormat, get<int64_t>(columnValue));
486 } else {
487 outPropValue.outIntVal = static_cast<uint64_t>(get<int64_t>(columnValue));
488 }
489 break;
490 default:
491 break;
492 }
493 }
494 return MTP_SUCCESS;
495 }
496
SetOneDefaultlPropList(uint32_t handle,uint16_t property,shared_ptr<vector<Property>> & outProps)497 void MtpDataUtils::SetOneDefaultlPropList(uint32_t handle, uint16_t property, shared_ptr<vector<Property>> &outProps)
498 {
499 auto propType = PropDefaultMap.at(property);
500 auto properType = MtpPacketTool::GetObjectPropTypeByPropCode(property);
501 Property prop(property, properType);
502 prop.handle_ = handle;
503 switch (propType) {
504 case INTTYPE16:
505 prop.currentValue->bin_.i16 = 0;
506 break;
507 case INTTYPE128:
508 prop.currentValue->bin_.i128[OFFSET_0] = static_cast<int32_t>(handle);
509 prop.currentValue->bin_.i128[OFFSET_1] = 0;
510 prop.currentValue->bin_.i128[OFFSET_2] = 0;
511 prop.currentValue->bin_.i128[OFFSET_3] = 0;
512 break;
513 case STRINGTYPE:
514 prop.currentValue->str_ = make_shared<string>("");
515 break;
516 default:
517 prop.currentValue->bin_.i32 = DEFAULT_STORAGE_ID;
518 break;
519 }
520 outProps->push_back(prop);
521 }
522
GetMediaTypeByName(std::string & displayName,MediaType & outMediaType)523 int32_t MtpDataUtils::GetMediaTypeByName(std::string &displayName, MediaType &outMediaType)
524 {
525 size_t displayNameIndex = displayName.find(".");
526 std::string extension;
527 if (displayNameIndex != std::string::npos) {
528 extension = displayName.substr(displayNameIndex);
529 } else {
530 MEDIA_ERR_LOG("is dir displayName");
531 outMediaType = MEDIA_TYPE_ALBUM;
532 return E_SUCCESS;
533 }
534 uint16_t format;
535 for (auto pair : FormatMap) {
536 if ((pair.second).find(extension) != std::string::npos) {
537 format = pair.first;
538 break;
539 } else {
540 format = MTP_FORMAT_UNDEFINED_CODE;
541 }
542 }
543 GetMediaTypeByformat(format, outMediaType);
544 return E_SUCCESS;
545 }
546
547 } // namespace Media
548 } // namespace OHOS
549