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;
359 int status;
360 int mediaType;
361 status = resultSet->GetColumnIndex(MEDIA_DATA_DB_MEDIA_TYPE, index);
362 if (status != NativeRdb::E_OK) {
363 MEDIA_ERR_LOG("GetColumnIndex failed");
364 return E_FAIL;
365 }
366 resultSet->GetInt(index, mediaType);
367 if (mediaType == MEDIA_TYPE_ALBUM) {
368 outFormat = MTP_FORMAT_ASSOCIATION_CODE;
369 return E_SUCCESS;
370 }
371 status = resultSet->GetColumnIndex(MEDIA_DATA_DB_FILE_PATH, index);
372 if (status != NativeRdb::E_OK) {
373 MEDIA_ERR_LOG("GetColumnIndex failed");
374 return E_FAIL;
375 }
376 std::string pathVal;
377 status = resultSet->GetString(index, pathVal);
378 if (status != NativeRdb::E_OK) {
379 MEDIA_ERR_LOG("GetString failed");
380 return E_FAIL;
381 }
382 if (pathVal.empty()) {
383 MEDIA_ERR_LOG("path is empty");
384 return E_FAIL;
385 }
386 GetFormatByPath(pathVal, outFormat);
387 return E_SUCCESS;
388 }
389
LocalTime(struct tm & t,time_t curTime)390 void LocalTime(struct tm &t, time_t curTime)
391 {
392 time_t curTimeTemp = curTime;
393 if (curTimeTemp == 0) {
394 curTimeTemp = time(nullptr);
395 }
396 auto tm = localtime(&curTimeTemp);
397 if (tm) {
398 t = *tm;
399 }
400 }
401
Strftime(const std::string & format,time_t curTime)402 std::string Strftime(const std::string &format, time_t curTime)
403 {
404 if (format.empty()) {
405 return format;
406 }
407 struct tm t = {};
408 LocalTime(t, curTime);
409 char szDTime[32] = "";
410 (void)strftime(szDTime, sizeof(szDTime), format.c_str(), &t);
411 return szDTime;
412 }
413
SetProperty(const std::string & column,const shared_ptr<DataShare::DataShareResultSet> & resultSet,ResultSetDataType & type,Property & prop)414 void MtpDataUtils::SetProperty(const std::string &column, const shared_ptr<DataShare::DataShareResultSet> &resultSet,
415 ResultSetDataType &type, Property &prop)
416 {
417 variant<int32_t, std::string, int64_t, double> columnValue =
418 ResultSetUtils::GetValFromColumn(column, resultSet, type);
419 switch (type) {
420 case TYPE_STRING:
421 prop.currentValue->str_ = make_shared<std::string>(get<std::string>(columnValue));
422 break;
423 case TYPE_INT32:
424 prop.currentValue->bin_.i32 = get<int32_t>(columnValue);
425 break;
426 case TYPE_INT64:
427 if (column.compare(MEDIA_DATA_DB_DATE_MODIFIED) == 0) {
428 prop.currentValue->str_ =
429 make_shared<std::string>(MtpPacketTool::FormatDateTime(get<int64_t>(columnValue)));
430 } else {
431 prop.currentValue->bin_.i64 = get<int64_t>(columnValue);
432 }
433 break;
434 default:
435 break;
436 }
437 }
438
GetOneRowPropList(uint32_t handle,const shared_ptr<DataShare::DataShareResultSet> & resultSet,const shared_ptr<UInt16List> & properties,shared_ptr<vector<Property>> & outProps)439 void MtpDataUtils::GetOneRowPropList(uint32_t handle, const shared_ptr<DataShare::DataShareResultSet> &resultSet,
440 const shared_ptr<UInt16List> &properties, shared_ptr<vector<Property>> &outProps)
441 {
442 std::string column;
443 ResultSetDataType type;
444 for (uint16_t property : *properties) {
445 if (PropColumnMap.find(property) != PropColumnMap.end()) {
446 auto properType = MtpPacketTool::GetObjectPropTypeByPropCode(property);
447 Property prop(property, properType);
448 prop.handle_ = handle;
449 column = PropColumnMap.at(property);
450 type = ColumnTypeMap.at(column);
451 if (column.compare(MEDIA_DATA_DB_FORMAT) == 0) {
452 uint16_t format = MTP_FORMAT_UNDEFINED_CODE;
453 GetFormat(resultSet, format);
454 prop.currentValue->bin_.ui16 = format;
455 MEDIA_INFO_LOG("prop.currentValue->bin_.ui16 %{public}u", format);
456 } else {
457 SetProperty(column, resultSet, type, prop);
458 }
459 outProps->push_back(prop);
460 } else if (PropDefaultMap.find(property) != PropDefaultMap.end()) {
461 SetOneDefaultlPropList(handle, property, outProps);
462 }
463 }
464 }
465
GetPropValueBySet(const uint32_t property,const shared_ptr<DataShare::DataShareResultSet> & resultSet,PropertyValue & outPropValue)466 int32_t MtpDataUtils::GetPropValueBySet(const uint32_t property,
467 const shared_ptr<DataShare::DataShareResultSet> &resultSet, PropertyValue &outPropValue)
468 {
469 if (resultSet->GoToFirstRow() != 0) {
470 return MTP_ERROR_INVALID_OBJECTHANDLE;
471 }
472 if (PropColumnMap.find(property) != PropColumnMap.end()) {
473 std::string column = PropColumnMap.at(property);
474 ResultSetDataType type = ColumnTypeMap.at(column);
475 variant<int32_t, std::string, int64_t, double> columnValue =
476 ResultSetUtils::GetValFromColumn(column, resultSet, type);
477 switch (type) {
478 case TYPE_STRING:
479 outPropValue.outStrVal = get<std::string>(columnValue);
480 break;
481 case TYPE_INT32:
482 outPropValue.outIntVal = static_cast<uint64_t>(get<int32_t>(columnValue));
483 break;
484 case TYPE_INT64:
485 if (column.compare(MEDIA_DATA_DB_DATE_MODIFIED) == 0) {
486 std::string timeFormat = "%Y-%m-%d %H:%M:%S";
487 outPropValue.outStrVal = Strftime(timeFormat, get<int64_t>(columnValue));
488 } else {
489 outPropValue.outIntVal = static_cast<uint64_t>(get<int64_t>(columnValue));
490 }
491 break;
492 default:
493 break;
494 }
495 }
496 return MTP_SUCCESS;
497 }
498
SetOneDefaultlPropList(uint32_t handle,uint16_t property,shared_ptr<vector<Property>> & outProps)499 void MtpDataUtils::SetOneDefaultlPropList(uint32_t handle, uint16_t property, shared_ptr<vector<Property>> &outProps)
500 {
501 auto propType = PropDefaultMap.at(property);
502 auto properType = MtpPacketTool::GetObjectPropTypeByPropCode(property);
503 Property prop(property, properType);
504 prop.handle_ = handle;
505 switch (propType) {
506 case INTTYPE16:
507 prop.currentValue->bin_.i16 = 0;
508 break;
509 case INTTYPE128:
510 prop.currentValue->bin_.i128[OFFSET_0] = static_cast<int32_t>(handle);
511 prop.currentValue->bin_.i128[OFFSET_1] = 0;
512 prop.currentValue->bin_.i128[OFFSET_2] = 0;
513 prop.currentValue->bin_.i128[OFFSET_3] = 0;
514 break;
515 case STRINGTYPE:
516 prop.currentValue->str_ = make_shared<string>("");
517 break;
518 default:
519 prop.currentValue->bin_.i32 = DEFAULT_STORAGE_ID;
520 break;
521 }
522 outProps->push_back(prop);
523 }
524
GetMediaTypeByName(std::string & displayName,MediaType & outMediaType)525 int32_t MtpDataUtils::GetMediaTypeByName(std::string &displayName, MediaType &outMediaType)
526 {
527 size_t displayNameIndex = displayName.find(".");
528 std::string extension;
529 if (displayNameIndex != std::string::npos) {
530 extension = displayName.substr(displayNameIndex);
531 } else {
532 MEDIA_ERR_LOG("is dir displayName");
533 outMediaType = MEDIA_TYPE_ALBUM;
534 return E_SUCCESS;
535 }
536 uint16_t format;
537 for (auto pair : FormatMap) {
538 if ((pair.second).find(extension) != std::string::npos) {
539 format = pair.first;
540 break;
541 } else {
542 format = MTP_FORMAT_UNDEFINED_CODE;
543 }
544 }
545 GetMediaTypeByformat(format, outMediaType);
546 return E_SUCCESS;
547 }
548
549 } // namespace Media
550 } // namespace OHOS
551