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_error_utils.h"
16 #include <map>
17
18 #include "medialibrary_errno.h"
19 #include "media_log.h"
20 #include "media_mtp_utils.h"
21 #include "mtp_constants.h"
22
23 using namespace std;
24 namespace OHOS {
25 namespace Media {
SolveGetHandlesError(const int32_t mediaError)26 int32_t MtpErrorUtils::SolveGetHandlesError(const int32_t mediaError)
27 {
28 static const std::map<int32_t, int32_t> getHandlesError = {
29 { E_SUCCESS, MTP_SUCCESS },
30 { E_HAS_DB_ERROR, MTP_ERROR_STORE_NOT_AVAILABLE },
31 { E_NO_SUCH_FILE, MTP_ERROR_INVALID_OBJECTHANDLE },
32 };
33 map<int32_t, int32_t>::const_iterator iterator = getHandlesError.find(mediaError);
34 if (iterator != getHandlesError.end()) {
35 return getHandlesError.at(mediaError);
36 } else {
37 return MTP_ERROR_INVALID_OBJECTHANDLE;
38 }
39 }
40
SolveGetObjectInfoError(const int32_t mediaError)41 int32_t MtpErrorUtils::SolveGetObjectInfoError(const int32_t mediaError)
42 {
43 static const std::map<int32_t, int32_t> getObjectInfoError = {
44 { E_SUCCESS, MTP_SUCCESS },
45 { E_HAS_DB_ERROR, MTP_ERROR_STORE_NOT_AVAILABLE },
46 { E_NO_SUCH_FILE, MTP_ERROR_INVALID_OBJECTHANDLE },
47 };
48 map<int32_t, int32_t>::const_iterator iterator = getObjectInfoError.find(mediaError);
49 if (iterator != getObjectInfoError.end()) {
50 return getObjectInfoError.at(mediaError);
51 } else {
52 return MTP_ERROR_INVALID_OBJECTHANDLE;
53 }
54 }
55
SolveGetFdError(const int32_t mediaError)56 int32_t MtpErrorUtils::SolveGetFdError(const int32_t mediaError)
57 {
58 static const std::map<int32_t, int32_t> getFdInfoError = {
59 { E_SUCCESS, MTP_SUCCESS },
60 { E_HAS_DB_ERROR, MTP_ERROR_STORE_NOT_AVAILABLE },
61 { E_HAS_FS_ERROR, MTP_ERROR_INVALID_OBJECTHANDLE },
62 };
63 map<int32_t, int32_t>::const_iterator iterator = getFdInfoError.find(mediaError);
64 if (iterator != getFdInfoError.end()) {
65 return getFdInfoError.at(mediaError);
66 } else {
67 return MTP_ERROR_INVALID_OBJECTHANDLE;
68 }
69 }
70
SolveSendObjectInfoError(const int32_t mediaError)71 int32_t MtpErrorUtils::SolveSendObjectInfoError(const int32_t mediaError)
72 {
73 static const std::map<int32_t, int32_t> sendObjectInfoError = {
74 { E_SUCCESS, MTP_SUCCESS },
75 { E_HAS_DB_ERROR, MTP_ERROR_STORE_NOT_AVAILABLE },
76 { E_NO_SUCH_FILE, MTP_ERROR_INVALID_PARENTOBJECT },
77 };
78 map<int32_t, int32_t>::const_iterator iterator = sendObjectInfoError.find(mediaError);
79 if (iterator != sendObjectInfoError.end()) {
80 return sendObjectInfoError.at(mediaError);
81 } else {
82 return MTP_ERROR_INVALID_OBJECTHANDLE;
83 }
84 }
85
SolveMoveObjectError(const int32_t mediaError)86 int32_t MtpErrorUtils::SolveMoveObjectError(const int32_t mediaError)
87 {
88 static const std::map<int32_t, int32_t> moveObjectError = {
89 { E_SUCCESS, MTP_SUCCESS },
90 { E_HAS_DB_ERROR, MTP_ERROR_STORE_NOT_AVAILABLE },
91 { E_NO_SUCH_FILE, MTP_ERROR_INVALID_OBJECTHANDLE },
92 { E_INVALID_FILEID, MTP_ERROR_INVALID_OBJECTHANDLE },
93 { E_INVALID_PATH, MTP_ERROR_INVALID_OBJECTHANDLE },
94 { E_MODIFY_DATA_FAIL, MTP_ERROR_INVALID_OBJECTHANDLE },
95 { E_FAIL, MTP_ERROR_PARAMETER_NOT_SUPPORTED },
96 { E_FILE_EXIST, MTP_ERROR_PARAMETER_NOT_SUPPORTED },
97 { E_FILE_OPER_FAIL, MTP_ERROR_STORE_NOT_AVAILABLE },
98 };
99 map<int32_t, int32_t>::const_iterator iterator = moveObjectError.find(mediaError);
100 if (iterator != moveObjectError.end()) {
101 return moveObjectError.at(mediaError);
102 } else {
103 return MTP_ERROR_INVALID_OBJECTHANDLE;
104 }
105 }
106
SolveCopyObjectError(const int32_t mediaError)107 int32_t MtpErrorUtils::SolveCopyObjectError(const int32_t mediaError)
108 {
109 static const std::map<int32_t, int32_t> copyObjectError = {
110 { E_SUCCESS, MTP_SUCCESS },
111 { E_HAS_DB_ERROR, MTP_ERROR_INVALID_OBJECTHANDLE },
112 { E_NO_SUCH_FILE, MTP_ERROR_INVALID_OBJECTHANDLE },
113 { E_INVALID_FILEID, MTP_ERROR_INVALID_OBJECTHANDLE },
114 { E_INVALID_PATH, MTP_ERROR_INVALID_OBJECTHANDLE },
115 { E_FAIL, MTP_ERROR_PARAMETER_NOT_SUPPORTED },
116 { E_FILE_EXIST, MTP_ERROR_PARAMETER_NOT_SUPPORTED },
117 { E_VIOLATION_PARAMETERS, MTP_ERROR_PARAMETER_NOT_SUPPORTED },
118 { E_DELETE_DIR_FAIL, MTP_ERROR_INVALID_OBJECTHANDLE },
119 };
120 map<int32_t, int32_t>::const_iterator iterator = copyObjectError.find(mediaError);
121 if (iterator != copyObjectError.end()) {
122 return copyObjectError.at(mediaError);
123 } else {
124 return MTP_ERROR_INVALID_OBJECTHANDLE;
125 }
126 }
127
SolveDeleteObjectError(const int32_t mediaError)128 int32_t MtpErrorUtils::SolveDeleteObjectError(const int32_t mediaError)
129 {
130 static const std::map<int32_t, int32_t> deleteObjectError = {
131 { E_SUCCESS, MTP_SUCCESS },
132 { E_HAS_DB_ERROR, MTP_ERROR_INVALID_OBJECTHANDLE },
133 { E_FAIL, MTP_ERROR_PARAMETER_NOT_SUPPORTED },
134 { E_NO_SUCH_FILE, MTP_ERROR_INVALID_OBJECTHANDLE },
135 { E_VIOLATION_PARAMETERS, MTP_ERROR_PARAMETER_NOT_SUPPORTED },
136 };
137 map<int32_t, int32_t>::const_iterator iterator = deleteObjectError.find(mediaError);
138 if (iterator != deleteObjectError.end()) {
139 return deleteObjectError.at(mediaError);
140 } else {
141 return MTP_ERROR_INVALID_OBJECTHANDLE;
142 }
143 }
144
SolveObjectPropValueError(const int32_t mediaError)145 int32_t MtpErrorUtils::SolveObjectPropValueError(const int32_t mediaError)
146 {
147 static const std::map<int32_t, int32_t> objectPropValueError = {
148 { E_SUCCESS, MTP_SUCCESS },
149 { E_HAS_DB_ERROR, MTP_ERROR_INVALID_OBJECTPROP_FORMAT },
150 { E_NO_SUCH_FILE, MTP_ERROR_INVALID_OBJECTPROPCODE },
151 { E_INVALID_FILEID, MTP_ERROR_INVALID_OBJECTPROP_VALUE },
152 { E_INVALID_PATH, MTP_ERROR_INVALID_OBJECTPROP_VALUE },
153 { E_MODIFY_DATA_FAIL, MTP_ERROR_INVALID_OBJECTPROPCODE },
154 { E_FAIL, MTP_ERROR_INVALID_OBJECTPROPCODE },
155 { E_FILE_EXIST, MTP_ERROR_INVALID_OBJECTPROPCODE },
156 { E_FILE_OPER_FAIL, MTP_ERROR_INVALID_OBJECTPROPCODE },
157 };
158 map<int32_t, int32_t>::const_iterator iterator = objectPropValueError.find(mediaError);
159 if (iterator != objectPropValueError.end()) {
160 return objectPropValueError.at(mediaError);
161 } else {
162 return MTP_ERROR_INVALID_OBJECTPROPCODE;
163 }
164 }
165
SolveCloseFdError(const int32_t mediaError)166 int32_t MtpErrorUtils::SolveCloseFdError(const int32_t mediaError)
167 {
168 static const std::map<int32_t, int32_t> CloseFdError = {
169 { E_SUCCESS, MTP_SUCCESS },
170 { E_HAS_DB_ERROR, MTP_ERROR_STORE_NOT_AVAILABLE },
171 { E_INVALID_FILEID, MTP_ERROR_INVALID_OBJECTHANDLE },
172 };
173 map<int32_t, int32_t>::const_iterator iterator = CloseFdError.find(mediaError);
174 if (iterator != CloseFdError.end()) {
175 return CloseFdError.at(mediaError);
176 } else {
177 return MTP_ERROR_INVALID_OBJECTHANDLE;
178 }
179 }
180 } // namespace Media
181 } // namespace OHOS