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 "mtp_operation_utils.h"
16 #include <fstream>
17 #include <cstdint>
18 #include <cinttypes>
19 #include <iremote_object.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <unistd.h>
23 #include "application_context.h"
24 #include "ability_manager_client.h"
25 #ifdef HAS_BATTERY_MANAGER_PART
26 #include "battery_srv_client.h"
27 #endif
28 #include "directory_ex.h"
29 #include "iservice_registry.h"
30 #include "media_log.h"
31 #include "media_mtp_utils.h"
32 #include "mtp_file_observer.h"
33 #include "mtp_medialibrary_manager.h"
34 #include "mtp_packet_tools.h"
35 #include "mtp_operation_context.h"
36 #include "mtp_storage_manager.h"
37 #include "payload_data.h"
38 #include "payload_data/resp_common_data.h"
39 #include "payload_data/close_session_data.h"
40 #include "payload_data/copy_object_data.h"
41 #include "payload_data/delete_object_data.h"
42 #include "payload_data/get_device_info_data.h"
43 #include "payload_data/get_device_prop_desc_data.h"
44 #include "payload_data/get_device_prop_value_data.h"
45 #include "payload_data/get_num_objects_data.h"
46 #include "payload_data/get_object_data.h"
47 #include "payload_data/get_object_handles_data.h"
48 #include "payload_data/get_object_info_data.h"
49 #include "payload_data/get_object_prop_list_data.h"
50 #include "payload_data/get_object_prop_desc_data.h"
51 #include "payload_data/get_object_prop_value_data.h"
52 #include "payload_data/get_object_props_supported_data.h"
53 #include "payload_data/get_object_references_data.h"
54 #include "payload_data/get_partial_object_data.h"
55 #include "payload_data/get_storage_info_data.h"
56 #include "payload_data/get_storage_ids_data.h"
57 #include "payload_data/get_thumb_data.h"
58 #include "payload_data/move_object_data.h"
59 #include "payload_data/object_event_data.h"
60 #include "payload_data/open_session_data.h"
61 #include "payload_data/send_object_data.h"
62 #include "payload_data/send_object_info_data.h"
63 #include "payload_data/set_device_prop_value_data.h"
64 #include "payload_data/set_object_prop_value_data.h"
65 #include "payload_data/set_object_references_data.h"
66 #include "parameters.h"
67 #include "storage.h"
68 #include "system_ability_definition.h"
69 using namespace std;
70 namespace OHOS {
71 namespace Media {
72 #ifdef HAS_BATTERY_MANAGER_PART
73 static constexpr int MAX_BATTERY = 100;
74 static constexpr int ERROR_BATTERY = -1;
75 #endif
76 static constexpr int EMPTY_BATTERY = 0;
77 static constexpr int STORAGE_MANAGER_UID = 5003;
78
79 static constexpr uint32_t HEADER_LEN = 12;
80 static constexpr uint32_t READ_LEN = 1024;
MtpOperationUtils(const shared_ptr<MtpOperationContext> & context)81 MtpOperationUtils::MtpOperationUtils(const shared_ptr<MtpOperationContext> &context) : context_(context)
82 {
83 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
84 auto token = saManager->GetSystemAbility(STORAGE_MANAGER_UID);
85 mtpMedialibraryManager_ = MtpMedialibraryManager::GetInstance();
86 mtpMedialibraryManager_->Init(token);
87 }
88
~MtpOperationUtils()89 MtpOperationUtils::~MtpOperationUtils()
90 {
91 }
92
GetDeviceInfo(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)93 uint16_t MtpOperationUtils::GetDeviceInfo(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
94 {
95 if (containerType != DATA_CONTAINER_TYPE) {
96 data = make_shared<RespCommonData>();
97 return CheckErrorCode(errorCode);
98 }
99
100 shared_ptr<GetDeviceInfoData> getDeviceInfoData = make_shared<GetDeviceInfoData>();
101 getDeviceInfoData->SetManufacturer(GetPropertyInner("const.product.manufacturer",
102 DEFAULT_PRODUCT_MANUFACTURER));
103 getDeviceInfoData->SetModel(GetPropertyInner("const.product.model", DEFAULT_PRODUCT_MODEL));
104 getDeviceInfoData->SetVersion(GetPropertyInner("const.product.software.version",
105 DEFAULT_PRODUCT_SOFTWARE_VERSION));
106 getDeviceInfoData->SetSerialNum(GetPropertyInner("ohos.boot.sn", "0"));
107 data = getDeviceInfoData;
108 errorCode = MTP_SUCCESS;
109 return MTP_OK_CODE;
110 }
111
GetNumObjects(shared_ptr<PayloadData> & data)112 uint16_t MtpOperationUtils::GetNumObjects(shared_ptr<PayloadData> &data)
113 {
114 if (context_ == nullptr) {
115 MEDIA_ERR_LOG("GetNumObjects context_ is null");
116 return CheckErrorCode(MTP_ERROR_CONTEXT_IS_NULL);
117 }
118
119 if (!MtpStorageManager::GetInstance()->HasStorage(context_->storageID)) {
120 return MTP_INVALID_STORAGEID_CODE;
121 }
122
123 shared_ptr<GetNumObjectsData> getNumObjects = make_shared<GetNumObjectsData>();
124 data = getNumObjects;
125 return CheckErrorCode(MTP_SUCCESS);
126 }
127
HasStorage(int & errorCode)128 uint16_t MtpOperationUtils::HasStorage(int &errorCode)
129 {
130 if (context_ == nullptr) {
131 MEDIA_ERR_LOG("GetObjectHandles context_ is null");
132 errorCode = MTP_ERROR_CONTEXT_IS_NULL;
133 return errorCode;
134 }
135 if (context_->sessionOpen == false) {
136 MEDIA_ERR_LOG("GetObjectHandles session not open");
137 errorCode = MTP_ERROR_SESSION_NOT_OPEN;
138 return errorCode;
139 }
140 if (!MtpStorageManager::GetInstance()->HasStorage(context_->storageID)) {
141 MEDIA_ERR_LOG("GetObjectHandles no this storage");
142 errorCode = MTP_ERROR_INVALID_STORAGE_ID;
143 return errorCode;
144 }
145 return MTP_SUCCESS;
146 }
147
GetObjectHandles(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)148 uint16_t MtpOperationUtils::GetObjectHandles(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
149 {
150 if (containerType != DATA_CONTAINER_TYPE) {
151 data = make_shared<RespCommonData>();
152 return CheckErrorCode(errorCode);
153 }
154
155 uint16_t ret = HasStorage(errorCode);
156 if (ret != MTP_SUCCESS) {
157 return CheckErrorCode(ret);
158 }
159 if (context_->parent == MTP_ALL_HANDLE_ID) {
160 context_->parent = 0;
161 }
162 shared_ptr<UInt32List> objectHandles = make_shared<UInt32List>();
163 errorCode = mtpMedialibraryManager_->GetHandles(context_, objectHandles);
164 if (errorCode != MTP_SUCCESS) {
165 MEDIA_ERR_LOG("GetObjectHandles GetHandles fail!");
166 return CheckErrorCode(errorCode);
167 }
168
169 shared_ptr<GetObjectHandlesData> getObjectHandles = make_shared<GetObjectHandlesData>();
170 getObjectHandles->SetObjectHandles(objectHandles);
171 data = getObjectHandles;
172 errorCode = MTP_SUCCESS;
173 if (context_->parent != 0) {
174 string path;
175 string realPath;
176 if (GetPathByHandle(context_->parent, path, realPath) != MTP_UNDEFINED_CODE) {
177 MtpFileObserver::GetInstance().AddFileInotify(path, realPath, context_);
178 }
179 }
180 return CheckErrorCode(errorCode);
181 }
182
GetObjectInfo(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)183 uint16_t MtpOperationUtils::GetObjectInfo(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
184 {
185 if (containerType != DATA_CONTAINER_TYPE) {
186 data = make_shared<RespCommonData>();
187 return CheckErrorCode(errorCode);
188 }
189
190 uint16_t ret = HasStorage(errorCode);
191 if (ret != MTP_SUCCESS) {
192 return CheckErrorCode(ret);
193 }
194
195 shared_ptr<ObjectInfo> objectInfo = make_shared<ObjectInfo>(context_->handle);
196 errorCode = mtpMedialibraryManager_->GetObjectInfo(context_, objectInfo);
197 if (errorCode != MTP_SUCCESS) {
198 MEDIA_ERR_LOG("GetObjectHandles GetObjectInfo fail!");
199 return CheckErrorCode(errorCode);
200 }
201 shared_ptr<GetObjectInfoData> getObjectInfo = make_shared<GetObjectInfoData>();
202 getObjectInfo->SetObjectInfo(objectInfo);
203 data = getObjectInfo;
204 errorCode = MTP_SUCCESS;
205 return CheckErrorCode(errorCode);
206 }
207
GetObjectPropDesc(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)208 uint16_t MtpOperationUtils::GetObjectPropDesc(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
209 {
210 if (containerType != DATA_CONTAINER_TYPE) {
211 data = make_shared<RespCommonData>();
212 return CheckErrorCode(errorCode);
213 }
214
215 if (context_ == nullptr) {
216 MEDIA_ERR_LOG("GetObjectPropDesc context_ is null");
217 errorCode = MTP_ERROR_CONTEXT_IS_NULL;
218 return CheckErrorCode(errorCode);
219 }
220
221 data = make_shared<GetObjectPropDescData>(context_);
222 errorCode = MTP_SUCCESS;
223 return CheckErrorCode(errorCode);
224 }
225
GetObjectPropValue(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)226 uint16_t MtpOperationUtils::GetObjectPropValue(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
227 {
228 if (containerType != DATA_CONTAINER_TYPE) {
229 data = make_shared<RespCommonData>();
230 return CheckErrorCode(errorCode);
231 }
232
233 if (context_ == nullptr) {
234 MEDIA_ERR_LOG("GetObjectPropValue context_ is null");
235 errorCode = MTP_ERROR_CONTEXT_IS_NULL;
236 return CheckErrorCode(errorCode);
237 }
238
239 int type = MTP_TYPE_UNDEFINED_CODE;
240 // GetObjectPropValue may have 3 types of return value, using params to return in one function
241 uint64_t int64Value = 0;
242 uint128_t int128Value = {0};
243 string strValue;
244 mtpMedialibraryManager_->GetObjectPropValue(context_, int64Value, int128Value, strValue);
245 shared_ptr<GetObjectPropValueData> getObjectPropValue = make_shared<GetObjectPropValueData>(context_);
246 type = MtpPacketTool::GetObjectPropTypeByPropCode(context_->property);
247 getObjectPropValue->SetPropValue(type, int64Value, int128Value, strValue);
248 data = getObjectPropValue;
249 errorCode = MTP_SUCCESS;
250 return CheckErrorCode(errorCode);
251 }
252
DoSetObjectPropValue(int & errorCode)253 void MtpOperationUtils::DoSetObjectPropValue(int &errorCode)
254 {
255 if (context_ == nullptr) {
256 MEDIA_ERR_LOG("SetObjectPropValue context_ is null");
257 errorCode = MTP_ERROR_CONTEXT_IS_NULL;
258 return;
259 }
260
261 errorCode = mtpMedialibraryManager_->SetObjectPropValue(context_);
262 SendEventPacket(context_->handle, MTP_EVENT_OBJECT_ADDED_CODE);
263 }
264
SendEventPacket(uint32_t objectHandle,uint16_t eventCode)265 void MtpOperationUtils::SendEventPacket(uint32_t objectHandle, uint16_t eventCode)
266 {
267 EventMtp event;
268 event.length = MTP_CONTAINER_HEADER_SIZE + sizeof(objectHandle);
269 vector<uint8_t> outBuffer;
270 MtpPacketTool::PutUInt32(outBuffer, event.length);
271 MtpPacketTool::PutUInt16(outBuffer, EVENT_CONTAINER_TYPE);
272 MtpPacketTool::PutUInt16(outBuffer, eventCode);
273 MtpPacketTool::PutUInt32(outBuffer, context_->transactionID);
274 MtpPacketTool::PutUInt32(outBuffer, objectHandle);
275
276 event.data = outBuffer;
277 context_->mtpDriver->WriteEvent(event);
278 }
279
GetObjectPropList(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)280 uint16_t MtpOperationUtils::GetObjectPropList(shared_ptr<PayloadData> &data,
281 uint16_t containerType, int &errorCode)
282 {
283 if (containerType != DATA_CONTAINER_TYPE) {
284 data = make_shared<RespCommonData>();
285 return CheckErrorCode(errorCode);
286 }
287
288 if (context_ == nullptr) {
289 MEDIA_ERR_LOG("GetObjectPropList context_ is null");
290 errorCode = MTP_ERROR_CONTEXT_IS_NULL;
291 return CheckErrorCode(errorCode);
292 }
293
294 shared_ptr<vector<Property>> props = make_shared<vector<Property>>();
295 mtpMedialibraryManager_->GetObjectPropList(context_, props);
296
297 shared_ptr<GetObjectPropListData> getObjectPropList = make_shared<GetObjectPropListData>(context_);
298 getObjectPropList->SetProps(props);
299 data = getObjectPropList;
300 errorCode = MTP_SUCCESS;
301 return CheckErrorCode(errorCode);
302 }
303
GetObjectReferences(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)304 uint16_t MtpOperationUtils::GetObjectReferences(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
305 {
306 if (containerType != DATA_CONTAINER_TYPE) {
307 data = make_shared<RespCommonData>();
308 return CheckErrorCode(errorCode);
309 }
310
311 uint16_t ret = HasStorage(errorCode);
312 if (ret != MTP_SUCCESS) {
313 return CheckErrorCode(ret);
314 }
315
316 shared_ptr<UInt32List> objectHandles = nullptr;
317 shared_ptr<GetObjectReferencesData> getObjectReferences = make_shared<GetObjectReferencesData>(context_);
318 getObjectReferences->SetObjectHandles(objectHandles);
319 data = getObjectReferences;
320 errorCode = MTP_SUCCESS;
321 return CheckErrorCode(errorCode);
322 }
323
SetObjectReferences(shared_ptr<PayloadData> & data)324 uint16_t MtpOperationUtils::SetObjectReferences(shared_ptr<PayloadData> &data)
325 {
326 if (context_ == nullptr) {
327 MEDIA_ERR_LOG("SetObjectReferences context_ is null");
328 return CheckErrorCode(MTP_ERROR_CONTEXT_IS_NULL);
329 }
330
331 uint16_t result = MTP_INVALID_OBJECTPROP_FORMAT_CODE;
332 shared_ptr<SetObjectReferencesData> setObjectReferences = make_shared<SetObjectReferencesData>(context_);
333 setObjectReferences->SetResult(result);
334 data = setObjectReferences;
335 return CheckErrorCode(MTP_SUCCESS);
336 }
337
GetObjectDataDeal()338 uint16_t MtpOperationUtils::GetObjectDataDeal()
339 {
340 if (context_ == nullptr) {
341 MEDIA_ERR_LOG("SetObjectReferences context_ is null");
342 return MTP_ERROR_CONTEXT_IS_NULL;
343 }
344
345 int fd = 0;
346 int errorCode = mtpMedialibraryManager_->GetFd(context_, fd);
347 if (errorCode != MTP_SUCCESS) {
348 MEDIA_ERR_LOG("GetObjectDataDeal GetFd fail!");
349 return errorCode;
350 }
351 MtpFileRange object;
352 object.fd = fd;
353 object.offset = 0;
354 struct stat sstat;
355 int result = fstat(object.fd, &sstat);
356 if (result < 0) {
357 MEDIA_ERR_LOG("GetObjectDataDeal fstat error = %{public}d", errno);
358 return MTP_ERROR_INCOMPLETE_TRANSFER;
359 }
360 object.length = sstat.st_size;
361 object.command = context_->operationCode;
362 object.transaction_id = context_->transactionID;
363 result = context_->mtpDriver->SendObj(object);
364 if (result < 0) {
365 MEDIA_ERR_LOG("GetObjectDataDeal SendObj error!");
366 return MTP_ERROR_INCOMPLETE_TRANSFER;
367 }
368 return MTP_SUCCESS;
369 }
370
GetObject(shared_ptr<PayloadData> & data,int errorCode)371 uint16_t MtpOperationUtils::GetObject(shared_ptr<PayloadData> &data, int errorCode)
372 {
373 data = make_shared<GetObjectData>();
374 return CheckErrorCode(errorCode);
375 }
376
DoRecevieSendObject()377 uint16_t MtpOperationUtils::DoRecevieSendObject()
378 {
379 if (context_ == nullptr) {
380 MEDIA_ERR_LOG("DoRecevieSendObject context_ is null");
381 return MTP_ERROR_CONTEXT_IS_NULL;
382 }
383
384 int fd = 0;
385 int errorCode = mtpMedialibraryManager_->GetFd(context_, fd);
386 if (errorCode != MTP_SUCCESS) {
387 MEDIA_ERR_LOG("DoRecevieSendObject GetFd fail!");
388 return errorCode;
389 }
390
391 vector<uint8_t> dataBuffer;
392 uint32_t temp = READ_LEN;
393 context_->mtpDriver->Read(dataBuffer, temp);
394 uint32_t initialData = dataBuffer.size() < HEADER_LEN ? 0 : dataBuffer.size() - HEADER_LEN;
395 int ret = write(fd, &dataBuffer[HEADER_LEN], initialData);
396 if (ret < 0) {
397 MEDIA_ERR_LOG("DoRecevieSendObject write error = %{public}d", errno);
398 return MTP_ERROR_INCOMPLETE_TRANSFER;
399 }
400
401 MtpFileRange object;
402 object.fd = fd;
403 object.offset = initialData;
404 object.length = static_cast<int64_t>(context_->sendObjectFileSize) - static_cast<int64_t>(initialData);
405 context_->mtpDriver->ReceiveObj(object);
406 fsync(fd);
407 struct stat sstat;
408 int result = fstat(fd, &sstat);
409 if (result < 0) {
410 MEDIA_ERR_LOG("DoRecevieSendObject fstat error = %{public}d", errno);
411 return MTP_ERROR_INCOMPLETE_TRANSFER;
412 }
413 errorCode = mtpMedialibraryManager_->CloseFd(context_, fd);
414 if (errorCode != MTP_SUCCESS) {
415 MEDIA_ERR_LOG("DoRecevieSendObject CloseFd fail!");
416 return errorCode;
417 }
418 SendEventPacket(context_->handle, MTP_EVENT_OBJECT_INFO_CHANGED_CODE);
419 return MTP_SUCCESS;
420 }
421
GetThumb(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)422 uint16_t MtpOperationUtils::GetThumb(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
423 {
424 if (containerType != DATA_CONTAINER_TYPE) {
425 data = make_shared<RespCommonData>();
426 return CheckErrorCode(errorCode);
427 }
428
429 uint16_t ret = HasStorage(errorCode);
430 if (ret != MTP_SUCCESS) {
431 return CheckErrorCode(ret);
432 }
433
434 shared_ptr<UInt8List> thumb = make_shared<UInt8List>();
435 errorCode = mtpMedialibraryManager_->GetThumb(context_, thumb);
436 if (errorCode != MTP_SUCCESS) {
437 data = make_shared<RespCommonData>();
438 return CheckErrorCode(errorCode);
439 }
440
441 shared_ptr<GetThumbData> getThumb = make_shared<GetThumbData>();
442 getThumb->SetThumb(thumb);
443 data = getThumb;
444 errorCode = MTP_SUCCESS;
445 return CheckErrorCode(errorCode);
446 }
447
SendObjectInfo(shared_ptr<PayloadData> & data,int & errorCode)448 uint16_t MtpOperationUtils::SendObjectInfo(shared_ptr<PayloadData> &data, int &errorCode)
449 {
450 if (context_ == nullptr) {
451 MEDIA_ERR_LOG("MtpOperationUtils::SendObjectInfo context_ is null");
452 data = make_shared<RespCommonData>();
453 return CheckErrorCode(MTP_ERROR_CONTEXT_IS_NULL);
454 }
455
456 uint32_t storageID = 0;
457 uint32_t parent = 0;
458 uint32_t handle = 0;
459 errorCode = mtpMedialibraryManager_->SendObjectInfo(context_, storageID, parent, handle);
460 if (errorCode != MTP_SUCCESS) {
461 MEDIA_ERR_LOG("MtpOperationUtils::SendObjectInfo fail!");
462 data = make_shared<RespCommonData>();
463 return CheckErrorCode(errorCode);
464 }
465 context_->handle = handle;
466 shared_ptr<SendObjectInfoData> sendObjectInfo = make_shared<SendObjectInfoData>();
467 sendObjectInfo->SetSetParam(storageID, parent, handle);
468 data = sendObjectInfo;
469 return CheckErrorCode(errorCode);
470 }
471
GetRespCommonData(shared_ptr<PayloadData> & data,int errorCode)472 uint16_t MtpOperationUtils::GetRespCommonData(shared_ptr<PayloadData> &data, int errorCode)
473 {
474 data = make_shared<RespCommonData>();
475 return CheckErrorCode(errorCode);
476 }
477
GetPartialObject(shared_ptr<PayloadData> & data)478 uint16_t MtpOperationUtils::GetPartialObject(shared_ptr<PayloadData> &data)
479 {
480 if (context_ == nullptr) {
481 MEDIA_ERR_LOG("context_ is null");
482 return CheckErrorCode(MTP_ERROR_CONTEXT_IS_NULL);
483 }
484
485 uint32_t length = 0;
486 shared_ptr<GetPartialObjectData> getPartialObject = make_shared<GetPartialObjectData>(context_);
487 getPartialObject->SetLength(length);
488 data = getPartialObject;
489 return MTP_SUCCESS;
490 }
491
GetObjectPropsSupported(shared_ptr<PayloadData> & data)492 uint16_t MtpOperationUtils::GetObjectPropsSupported(shared_ptr<PayloadData> &data)
493 {
494 if (context_ == nullptr) {
495 MEDIA_ERR_LOG("context_ is null");
496 return CheckErrorCode(MTP_ERROR_CONTEXT_IS_NULL);
497 }
498
499 data = make_shared<GetObjectPropsSupportedData>(context_);
500 return MTP_OK_CODE;
501 }
502
DeleteObject(shared_ptr<PayloadData> & data,int & errorCode)503 uint16_t MtpOperationUtils::DeleteObject(shared_ptr<PayloadData> &data, int &errorCode)
504 {
505 if (context_ == nullptr) {
506 errorCode = MTP_ERROR_CONTEXT_IS_NULL;
507 } else {
508 MEDIA_ERR_LOG("MtpOperationUtils::DeleteObject format=%{public}u", context_->format);
509 errorCode = mtpMedialibraryManager_->DeleteObject(context_);
510 }
511 data = make_shared<RespCommonData>();
512 return CheckErrorCode(errorCode);
513 }
514
MoveObject(shared_ptr<PayloadData> & data,int & errorCode)515 uint16_t MtpOperationUtils::MoveObject(shared_ptr<PayloadData> &data, int &errorCode)
516 {
517 if (context_ == nullptr) {
518 errorCode = MTP_ERROR_CONTEXT_IS_NULL;
519 } else {
520 errorCode = mtpMedialibraryManager_->MoveObject(context_);
521 }
522
523 data = make_shared<RespCommonData>();
524 return CheckErrorCode(errorCode);
525 }
526
CopyObject(shared_ptr<PayloadData> & data,int & errorCode)527 uint16_t MtpOperationUtils::CopyObject(shared_ptr<PayloadData> &data, int &errorCode)
528 {
529 if (context_ == nullptr) {
530 MEDIA_ERR_LOG("context_ is null");
531 data = make_shared<RespCommonData>();
532 return CheckErrorCode(MTP_ERROR_CONTEXT_IS_NULL);
533 }
534
535 uint32_t objectHandle = 0;
536 errorCode = mtpMedialibraryManager_->CopyObject(context_, objectHandle);
537 SendEventPacket(objectHandle, MTP_EVENT_OBJECT_ADDED_CODE);
538 shared_ptr<CopyObjectData> copyObject = make_shared<CopyObjectData>();
539 copyObject->SetObjectHandle(objectHandle);
540 data = copyObject;
541 return CheckErrorCode(errorCode);
542 }
543
GetStorageIDs(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)544 uint16_t MtpOperationUtils::GetStorageIDs(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
545 {
546 if (containerType != DATA_CONTAINER_TYPE) {
547 data = make_shared<RespCommonData>();
548 return CheckErrorCode(errorCode);
549 }
550
551 if (context_->sessionOpen == false) {
552 MEDIA_ERR_LOG("session isn't open");
553 errorCode = MTP_ERROR_SESSION_NOT_OPEN;
554 return CheckErrorCode(errorCode);
555 }
556 auto storage = make_shared<Storage>();
557 storage->SetStorageID(DEFAULT_STORAGE_ID);
558 storage->SetStorageType(MTP_STORAGE_FIXEDRAM);
559 storage->SetFilesystemType(MTP_FILESYSTEM_GENERICHIERARCHICAL);
560 storage->SetAccessCapability(MTP_ACCESS_READ_WRITE);
561 storage->SetMaxCapacity(MtpStorageManager::GetInstance()->GetTotalSize());
562 storage->SetFreeSpaceInBytes(MtpStorageManager::GetInstance()->GetFreeSize());
563 storage->SetFreeSpaceInObjects(0);
564 storage->SetStorageDescription("Inner Storage");
565 MtpStorageManager::GetInstance()->AddStorage(storage);
566
567 shared_ptr<GetStorageIdsData> getStorageIdsData = make_shared<GetStorageIdsData>();
568 getStorageIdsData->SetStorages(MtpStorageManager::GetInstance()->GetStorages());
569 data = getStorageIdsData;
570 errorCode = MTP_SUCCESS;
571 return CheckErrorCode(errorCode);
572 }
573
GetStorageInfo(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)574 uint16_t MtpOperationUtils::GetStorageInfo(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
575 {
576 if (containerType != DATA_CONTAINER_TYPE) {
577 data = make_shared<RespCommonData>();
578 return CheckErrorCode(errorCode);
579 }
580
581 if (context_->sessionOpen == false) {
582 MEDIA_ERR_LOG("session isn't open error");
583 errorCode = MTP_ERROR_SESSION_NOT_OPEN;
584 return CheckErrorCode(errorCode);
585 }
586
587 shared_ptr<Storage> storage = MtpStorageManager::GetInstance()->GetStorage(context_->storageInfoID);
588 if (storage == nullptr) {
589 MEDIA_ERR_LOG("invalid storage id error");
590 errorCode = MTP_ERROR_INVALID_STORAGE_ID;
591 return CheckErrorCode(errorCode);
592 }
593 shared_ptr<GetStorageInfoData> getStorageInfoData = make_shared<GetStorageInfoData>();
594 getStorageInfoData->SetStorage(storage);
595 data = getStorageInfoData;
596 errorCode = MTP_SUCCESS;
597 return MTP_OK_CODE;
598 }
599
GetOpenSession(shared_ptr<PayloadData> & data,int errorCode)600 uint16_t MtpOperationUtils::GetOpenSession(shared_ptr<PayloadData> &data, int errorCode)
601 {
602 shared_ptr<OpenSessionData> openSessionData = make_shared<OpenSessionData>(context_);
603 uint16_t respCode = CheckErrorCode(errorCode);
604 if (respCode == MTP_SESSION_ALREADY_OPEN_CODE) {
605 openSessionData->SetSessionId(context_->sessionID);
606 }
607 if (respCode == MTP_OK_CODE) {
608 context_->sessionOpen = true;
609 }
610 data = openSessionData;
611 return respCode;
612 }
613
CheckErrorCode(int errorCode)614 uint16_t MtpOperationUtils::CheckErrorCode(int errorCode)
615 {
616 switch (errorCode) {
617 case MTP_ERROR_PACKET_INCORRECT:
618 return MTP_INVALID_PARAMETER_CODE;
619 case MTP_ERROR_SESSION_ALREADY_OPEN:
620 return MTP_SESSION_ALREADY_OPEN_CODE;
621 case MTP_ERROR_NO_THIS_FILE:
622 return MTP_INVALID_OBJECTHANDLE_CODE;
623 case MTP_ERROR_INCOMPLETE_TRANSFER:
624 return MTP_INCOMPLETE_TRANSFER_CODE;
625 case MTP_ERROR_SESSION_NOT_OPEN:
626 return MTP_SESSION_NOT_OPEN_CODE;
627 case MTP_ERROR_INVALID_STORAGE_ID:
628 return MTP_INVALID_STORAGEID_CODE;
629 case MTP_ERROR_INVALID_OBJECTHANDLE:
630 return MTP_INVALID_OBJECTHANDLE_CODE;
631 case MTP_ERROR_DEVICEPROP_NOT_SUPPORTED:
632 return MTP_DEVICEPROP_NOT_SUPPORTED_CODE;
633 case MTP_ERROR_STORE_NOT_AVAILABLE:
634 return MTP_STORE_NOT_AVAILABLE_CODE;
635 case MTP_ERROR_INVALID_PARENTOBJECT:
636 return MTP_INVALID_PARENTOBJECT_CODE;
637 case MTP_ERROR_PARAMETER_NOT_SUPPORTED:
638 return MTP_PARAMETER_NOT_SUPPORTED_CODE;
639 case MTP_ERROR_INVALID_OBJECTPROP_VALUE:
640 return MTP_INVALID_OBJECTPROP_VALUE_CODE;
641 case MTP_ERROR_INVALID_OBJECTPROP_FORMAT:
642 return MTP_INVALID_OBJECTPROP_FORMAT_CODE;
643 case MTP_ERROR_INVALID_OBJECTPROPCODE:
644 return MTP_INVALID_OBJECTPROPCODE_CODE;
645 case MTP_ERROR_ACCESS_DENIED:
646 return MTP_ACCESS_DENIED_CODE;
647 case MTP_ERROR_SPECIFICATION_BY_GROUP_UNSUPPORTED:
648 return MTP_SPECIFICATION_BY_GROUP_UNSUPPORTED_CODE;
649 case MTP_ERROR_SPECIFICATION_BY_DEPTH_UNSUPPORTED:
650 return MTP_SPECIFICATION_BY_DEPTH_UNSUPPORTED_CODE;
651 default:
652 return MTP_OK_CODE;
653 }
654 }
655
GetCloseSession(shared_ptr<PayloadData> & data)656 uint16_t MtpOperationUtils::GetCloseSession(shared_ptr<PayloadData> &data)
657 {
658 data = make_shared<CloseSessionData>(context_);
659 return MTP_OK_CODE;
660 }
661
GetPropDesc(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)662 uint16_t MtpOperationUtils::GetPropDesc(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
663 {
664 if (containerType != DATA_CONTAINER_TYPE) {
665 data = make_shared<RespCommonData>();
666 return CheckErrorCode(errorCode);
667 }
668
669 shared_ptr<GetDevicePropDescData> devicePropDescData = make_shared<GetDevicePropDescData>();
670 shared_ptr<Property> property = nullptr;
671 switch (context_->property) {
672 case MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER_CODE:
673 property = make_shared<Property>(context_->property, MTP_DEVICE_PROP_DESC_TYPE_STR, true);
674 break;
675 case MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME_CODE:
676 property = make_shared<Property>(context_->property, MTP_DEVICE_PROP_DESC_TYPE_STR, true);
677 property->currentValue->str_ = make_shared<string>(GetPropertyInner("persist.device.name",
678 DEFAULT_PRODUCT_NAME));
679 break;
680 case MTP_DEVICE_PROPERTY_SESSION_INITIATOR_VERSION_INFO_CODE:
681 property = make_shared<Property>(context_->property, MTP_DEVICE_PROP_DESC_TYPE_STR, true);
682 break;
683 case MTP_DEVICE_PROPERTY_IMAGE_SIZE_CODE:
684 property = make_shared<Property>(context_->property, MTP_DEVICE_PROP_DESC_TYPE_STR, true);
685 break;
686 case MTP_DEVICE_PROPERTY_BATTERY_LEVEL_CODE:
687 property = make_shared<Property>(context_->property, MTP_DEVICE_PROP_DESC_TYPE_UINT8);
688 property->currentValue->bin_.ui8 = (uint8_t)MtpOperationUtils::GetBatteryLevel();
689 property->SetFormRange(BATTERY_LEVEL_MIN, BATTERY_LEVEL_MAX, BATTERY_LEVEL_STEP);
690 break;
691 case MTP_DEVICE_PROPERTY_PERCEIVED_DEVICE_TYPE_CODE:
692 property = make_shared<Property>(context_->property, MTP_DEVICE_PROP_DESC_TYPE_UINT32);
693 break;
694 default:
695 MEDIA_INFO_LOG("property do not find");
696 break;
697 }
698
699 devicePropDescData->SetProperty(property);
700 data = devicePropDescData;
701 errorCode = MTP_SUCCESS;
702 return MTP_OK_CODE;
703 }
704
GetPropValue(shared_ptr<PayloadData> & data,uint16_t containerType,int & errorCode)705 uint16_t MtpOperationUtils::GetPropValue(shared_ptr<PayloadData> &data, uint16_t containerType, int &errorCode)
706 {
707 if (containerType != DATA_CONTAINER_TYPE) {
708 data = make_shared<RespCommonData>();
709 return CheckErrorCode(errorCode);
710 }
711
712 shared_ptr<GetDevicePropValueData> devicePropValueData = make_shared<GetDevicePropValueData>();
713 shared_ptr<Property::Value> value = make_shared<Property::Value>();
714 uint16_t valueType = MTP_DEVICE_PROP_DESC_TYPE_UNDEFINED;
715 switch (context_->property) {
716 case MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER_CODE:
717 valueType = MTP_DEVICE_PROP_DESC_TYPE_STR;
718 value->str_ = make_shared<string>("");
719 break;
720 case MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME_CODE:
721 valueType = MTP_DEVICE_PROP_DESC_TYPE_STR;
722 value->str_ = make_shared<string>(GetPropertyInner("persist.device.name", DEFAULT_PRODUCT_NAME));
723 break;
724 case MTP_DEVICE_PROPERTY_SESSION_INITIATOR_VERSION_INFO_CODE:
725 valueType = MTP_DEVICE_PROP_DESC_TYPE_STR;
726 value->str_ = make_shared<string>("");
727 break;
728 case MTP_DEVICE_PROPERTY_IMAGE_SIZE_CODE:
729 valueType = MTP_DEVICE_PROP_DESC_TYPE_STR;
730 value->str_ = make_shared<string>("");
731 break;
732 case MTP_DEVICE_PROPERTY_BATTERY_LEVEL_CODE:
733 valueType = MTP_DEVICE_PROP_DESC_TYPE_UINT8;
734 value->bin_.ui8 = (uint8_t)MtpOperationUtils::GetBatteryLevel();
735 break;
736 case MTP_DEVICE_PROPERTY_PERCEIVED_DEVICE_TYPE_CODE:
737 valueType = MTP_DEVICE_PROP_DESC_TYPE_UINT32;
738 value->bin_.ui32 = MTP_PERCEIVED_DEVICE_TYPE_GENERIC;
739 break;
740 default:
741 MEDIA_INFO_LOG("property do not find");
742 break;
743 }
744
745 devicePropValueData->SetValue(valueType, value);
746 data = devicePropValueData;
747 errorCode = MTP_SUCCESS;
748 return MTP_OK_CODE;
749 }
750
SetDevicePropValueResp(shared_ptr<PayloadData> & data)751 uint16_t MtpOperationUtils::SetDevicePropValueResp(shared_ptr<PayloadData> &data)
752 {
753 data = make_shared<RespCommonData>();
754 return MTP_OK_CODE;
755 }
756
ResetDevicePropResp(shared_ptr<PayloadData> & data)757 uint16_t MtpOperationUtils::ResetDevicePropResp(shared_ptr<PayloadData> &data)
758 {
759 if (!SetPropertyInner("persist.device.name", DEFAULT_PRODUCT_NAME)) {
760 MEDIA_ERR_LOG("SetPropertyInner fail");
761 }
762 data = make_shared<RespCommonData>();
763 return MTP_OK_CODE;
764 }
765
ObjectEvent(shared_ptr<PayloadData> & data,const int32_t payload)766 uint16_t MtpOperationUtils::ObjectEvent(shared_ptr<PayloadData> &data, const int32_t payload)
767 {
768 std::shared_ptr<ObjectEventData> eventData = make_shared<ObjectEventData>();
769 eventData->SetPayload(payload);
770 data = eventData;
771 return MTP_OK_CODE;
772 }
773
GetPathByHandle(const uint32_t & handle,string & path,string & realPath)774 uint16_t MtpOperationUtils::GetPathByHandle(const uint32_t &handle, string &path, string &realPath)
775 {
776 if (handle == 0) {
777 return MTP_UNDEFINED_CODE;
778 }
779 mtpMedialibraryManager_->GetPathById(handle, path);
780
781 size_t position = path.find("/local");
782 string real = "100";
783 if (position != string::npos) {
784 realPath = path.substr(0, position + 1) + real + path.substr(position, path.size());
785 }
786 MEDIA_DEBUG_LOG("MtpOperationUtils GetPathByHandle new %{private}s", realPath.c_str());
787 return MTP_OK_CODE;
788 }
789
GetHandleByPaths(string path,uint32_t & handle)790 int32_t MtpOperationUtils::GetHandleByPaths(string path, uint32_t &handle)
791 {
792 if (path.empty()) {
793 return MTP_UNDEFINED_CODE;
794 }
795 if (path.back() == '/') {
796 path.pop_back();
797 }
798
799 int32_t result = mtpMedialibraryManager_->GetIdByPath(path, handle);
800 return result;
801 }
802
GetBatteryLevel()803 int32_t MtpOperationUtils::GetBatteryLevel()
804 {
805 #ifdef HAS_BATTERY_MANAGER_PART
806 auto &batterySrvClient = PowerMgr::BatterySrvClient::GetInstance();
807 int32_t capacity = batterySrvClient.GetCapacity();
808 if (capacity > MAX_BATTERY || capacity < EMPTY_BATTERY) {
809 return ERROR_BATTERY;
810 }
811 return capacity;
812 #else
813 return EMPTY_BATTERY;
814 #endif
815 }
816
GetPropertyInner(const std::string & property,const std::string & defValue)817 std::string MtpOperationUtils::GetPropertyInner(const std::string &property, const std::string &defValue)
818 {
819 return OHOS::system::GetParameter(property, defValue);
820 }
821
SetPropertyInner(const std::string & property,const std::string & defValue)822 bool MtpOperationUtils::SetPropertyInner(const std::string &property, const std::string &defValue)
823 {
824 return OHOS::system::SetParameter(property, defValue);
825 }
826 } // namespace Media
827 } // namespace OHOS
828