1 /*
2 * Copyright (c) 2021-2024 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
16 #include "dcamera.h"
17 #include <chrono>
18 #include "constants.h"
19 #include "distributed_hardware_log.h"
20
21 namespace OHOS {
22 namespace DistributedHardware {
23 const uint32_t OFFSET2 = 2;
24 const uint32_t OFFSET4 = 4;
25 const uint32_t OFFSET6 = 6;
26 const uint8_t PARAM_FC = 0xfc;
27 const uint8_t PARAM_03 = 0x03;
28 const uint8_t PARAM_F0 = 0xf0;
29 const uint8_t PARAM_0F = 0x0f;
30 const uint8_t PARAM_C0 = 0xc0;
31 const uint8_t PARAM_3F = 0x3f;
32 const int INDEX_FIRST = 0;
33 const int INDEX_SECOND = 1;
34 const int INDEX_THIRD = 2;
35 const int INDEX_FORTH = 3;
MapToExternalRetCode(DCamRetCode retCode)36 CamRetCode MapToExternalRetCode(DCamRetCode retCode)
37 {
38 switch (retCode) {
39 case DCamRetCode::SUCCESS:
40 return CamRetCode::NO_ERROR;
41 case DCamRetCode::CAMERA_BUSY:
42 return CamRetCode::CAMERA_BUSY;
43 case DCamRetCode::INVALID_ARGUMENT:
44 return CamRetCode::INVALID_ARGUMENT;
45 case DCamRetCode::METHOD_NOT_SUPPORTED:
46 return CamRetCode::METHOD_NOT_SUPPORTED;
47 case DCamRetCode::CAMERA_OFFLINE:
48 return CamRetCode::CAMERA_CLOSED;
49 case DCamRetCode::EXCEED_MAX_NUMBER:
50 return CamRetCode::INSUFFICIENT_RESOURCES;
51 case DCamRetCode::FAILED:
52 return CamRetCode::DEVICE_ERROR;
53 default:
54 break;
55 }
56 return CamRetCode::DEVICE_ERROR;
57 }
58
GetCurrentLocalTimeStamp()59 uint64_t GetCurrentLocalTimeStamp()
60 {
61 std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> tp =
62 std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
63 auto tmp = std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch());
64 return static_cast<uint64_t>(tmp.count());
65 }
66
SplitString(const std::string & str,std::vector<std::string> & tokens,const std::string & delimiters)67 void SplitString(const std::string &str, std::vector<std::string> &tokens, const std::string &delimiters)
68 {
69 std::string::size_type lastPos = 0;
70 std::string::size_type pos = str.find(delimiters);
71 while (std::string::npos != pos) {
72 tokens.push_back(str.substr(lastPos, pos - lastPos));
73 lastPos = pos + delimiters.size();
74 pos = str.find(delimiters, lastPos);
75 }
76 if (lastPos != str.length()) {
77 tokens.push_back(str.substr(lastPos));
78 }
79 }
80
Base64Encode(const unsigned char * toEncode,unsigned int len)81 std::string Base64Encode(const unsigned char *toEncode, unsigned int len)
82 {
83 std::string ret = "";
84 if (len == 0 || toEncode == nullptr) {
85 DHLOGE("toEncode is null or len is zero.");
86 return ret;
87 }
88 int32_t length = static_cast<int32_t>(len);
89 uint32_t i = 0;
90 unsigned char charArray3[3];
91 unsigned char charArray4[4];
92
93 while (length--) {
94 charArray3[i++] = *(toEncode++);
95 if (i == sizeof(charArray3)) {
96 charArray4[INDEX_FIRST] = (charArray3[INDEX_FIRST] & PARAM_FC) >> OFFSET2;
97 charArray4[INDEX_SECOND] = ((charArray3[INDEX_FIRST] & PARAM_03) << OFFSET4) +
98 ((charArray3[INDEX_SECOND] & PARAM_F0) >> OFFSET4);
99 charArray4[INDEX_THIRD] = ((charArray3[INDEX_SECOND] & PARAM_0F) << OFFSET2) +
100 ((charArray3[INDEX_THIRD] & PARAM_C0) >> OFFSET6);
101 charArray4[INDEX_FORTH] = charArray3[INDEX_THIRD] & PARAM_3F;
102 for (i = 0; i < sizeof(charArray4); i++) {
103 ret += BASE_64_CHARS[charArray4[i]];
104 }
105 i = 0;
106 }
107 }
108
109 if (i > 0) {
110 uint32_t j = 0;
111 for (j = i; j < sizeof(charArray3); j++) {
112 charArray3[j] = '\0';
113 }
114 charArray4[INDEX_FIRST] = (charArray3[INDEX_FIRST] & PARAM_FC) >> OFFSET2;
115 charArray4[INDEX_SECOND] = ((charArray3[INDEX_FIRST] & PARAM_03) << OFFSET4) +
116 ((charArray3[INDEX_SECOND] & PARAM_F0) >> OFFSET4);
117 charArray4[INDEX_THIRD] = ((charArray3[INDEX_SECOND] & PARAM_0F) << OFFSET2) +
118 ((charArray3[INDEX_THIRD] & PARAM_C0) >> OFFSET6);
119 charArray4[INDEX_FORTH] = charArray3[INDEX_THIRD] & PARAM_3F;
120 for (j = 0; j < i + 1; j++) {
121 ret += BASE_64_CHARS[charArray4[j]];
122 }
123 while (i++ < sizeof(charArray3)) {
124 ret += '=';
125 }
126 }
127 return ret;
128 }
129
Base64Decode(const std::string & basicString)130 std::string Base64Decode(const std::string& basicString)
131 {
132 std::string ret = "";
133 if (basicString.empty()) {
134 DHLOGE("basicString is empty.");
135 return ret;
136 }
137 uint32_t i = 0;
138 int index = 0;
139 int len = static_cast<int>(basicString.size());
140 unsigned char charArray3[3];
141 unsigned char charArray4[4];
142
143 while (len-- && (basicString[index] != '=') && IsBase64(basicString[index])) {
144 charArray4[i++] = basicString[index];
145 index++;
146 if (i == sizeof(charArray4)) {
147 for (i = 0; i < sizeof(charArray4); i++) {
148 charArray4[i] = BASE_64_CHARS.find(charArray4[i]);
149 }
150 charArray3[INDEX_FIRST] = (charArray4[INDEX_FIRST] << OFFSET2) +
151 ((charArray4[INDEX_SECOND] & 0x30) >> OFFSET4);
152 charArray3[INDEX_SECOND] = ((charArray4[INDEX_SECOND] & 0xf) << OFFSET4) +
153 ((charArray4[INDEX_THIRD] & 0x3c) >> OFFSET2);
154 charArray3[INDEX_THIRD] = ((charArray4[INDEX_THIRD] & 0x3) << OFFSET6) + charArray4[INDEX_FORTH];
155 for (i = 0; i < sizeof(charArray3); i++) {
156 ret += charArray3[i];
157 }
158 i = 0;
159 }
160 }
161
162 if (i) {
163 uint32_t j = 0;
164 for (j = i; j < sizeof(charArray4); j++) {
165 charArray4[j] = 0;
166 }
167 for (j = 0; j < sizeof(charArray4); j++) {
168 charArray4[j] = BASE_64_CHARS.find(charArray4[j]);
169 }
170 charArray3[INDEX_FIRST] = (charArray4[INDEX_FIRST] << OFFSET2) +
171 ((charArray4[INDEX_SECOND] & 0x30) >> OFFSET4);
172 charArray3[INDEX_SECOND] = ((charArray4[INDEX_SECOND] & 0xf) << OFFSET4) +
173 ((charArray4[INDEX_THIRD] & 0x3c) >> OFFSET2);
174 charArray3[INDEX_THIRD] = ((charArray4[INDEX_THIRD] & 0x3) << OFFSET6) + charArray4[INDEX_FORTH];
175 for (j = 0; j < i - 1; j++) {
176 ret += charArray3[j];
177 }
178 }
179 return ret;
180 }
181
IsBase64(unsigned char c)182 bool IsBase64(unsigned char c)
183 {
184 return (isalnum(c) || (c == '+') || (c == '/'));
185 }
186
IsDhBaseInfoInvalid(const DHBase & dhBase)187 bool IsDhBaseInfoInvalid(const DHBase& dhBase)
188 {
189 return dhBase.deviceId_.empty() || (dhBase.deviceId_.length() > DEVID_MAX_LENGTH) ||
190 dhBase.dhId_.empty() || (dhBase.dhId_.length() > DHID_MAX_LENGTH);
191 }
192 } // namespace DistributedHardware
193 } // namespace OHOS
194