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