1 /*
2 * Copyright (c) 2021-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 "res_desc.h"
16
17 #include <cstdlib>
18
19 #include "hilog_wrapper.h"
20 #if defined(__WINNT__)
21 #include <cstring>
22 #else
23 #include "securec.h"
24 #endif
25 #include "utils/errors.h"
26 #include "utils/string_utils.h"
27
28 namespace OHOS {
29 namespace Global {
30 namespace Resource {
GetScreenDensityStr() const31 std::string KeyParam::GetScreenDensityStr() const
32 {
33 std::string ret("not_screen_density");
34 if (type_ == KeyType::SCREEN_DENSITY) {
35 switch (value_) {
36 case ScreenDensity::SCREEN_DENSITY_SDPI:
37 ret = std::string(RE_120_STR);
38 break;
39 case ScreenDensity::SCREEN_DENSITY_MDPI:
40 ret = std::string(RE_160_STR);
41 break;
42 case ScreenDensity::SCREEN_DENSITY_LDPI:
43 ret = std::string(RE_240_STR);
44 break;
45 case ScreenDensity::SCREEN_DENSITY_XLDPI:
46 ret = std::string(RE_320_STR);
47 break;
48 case ScreenDensity::SCREEN_DENSITY_XXLDPI:
49 ret = std::string(RE_480_STR);
50 break;
51 case ScreenDensity::SCREEN_DENSITY_XXXLDPI:
52 ret = std::string(RE_640_STR);
53 break;
54 default:
55 break;
56 }
57 }
58 return ret;
59 }
GetDeviceTypeStr() const60 std::string KeyParam::GetDeviceTypeStr() const
61 {
62 std::string ret("not_device_type");
63 if (type_ == KeyType::DEVICETYPE) {
64 switch (value_) {
65 case DeviceType::DEVICE_PHONE:
66 ret = std::string(PHONE_STR);
67 break;
68 case DeviceType::DEVICE_TABLET:
69 ret = std::string(TABLET_STR);
70 break;
71 case DeviceType::DEVICE_CAR:
72 ret = std::string(CAR_STR);
73 break;
74 case DeviceType::DEVICE_PAD:
75 ret = std::string(PAD_STR);
76 break;
77 case DeviceType::DEVICE_TV:
78 ret = std::string(TV_STR);
79 break;
80 case DeviceType::DEVICE_WEARABLE:
81 ret = std::string(WEARABLE_STR);
82 break;
83 default:
84 break;
85 }
86 }
87 return ret;
88 }
89
GetColorModeStr() const90 std::string KeyParam::GetColorModeStr() const
91 {
92 std::string ret("not_color_mode");
93 if (type_ == KeyType::COLORMODE) {
94 switch (value_) {
95 case ColorMode::DARK:
96 ret = std::string(DARK_STR);
97 break;
98 case ColorMode::LIGHT:
99 ret = std::string(LIGHT_STR);
100 break;
101 default:
102 break;
103 }
104 }
105 return ret;
106 }
107
GetInputDeviceStr() const108 std::string KeyParam::GetInputDeviceStr() const
109 {
110 std::string ret("not_input_device");
111 if (type_ == KeyType::INPUTDEVICE) {
112 if (value_ == InputDevice::INPUTDEVICE_POINTINGDEVICE) {
113 ret = std::string(POINTING_DEVICE_STR);
114 }
115 }
116 return ret;
117 }
118
GetMccStr() const119 std::string KeyParam::GetMccStr() const
120 {
121 std::string ret("not_mcc");
122 if (type_ == KeyType::MCC) {
123 ret = std::string("mcc");
124 }
125 return ret;
126 }
127
GetMncStr() const128 std::string KeyParam::GetMncStr() const
129 {
130 std::string ret("not_mnc");
131 if (type_ == KeyType::MNC) {
132 ret = std::string("mnc");
133 }
134 return ret;
135 }
136
ConvertToStr() const137 const std::string KeyParam::ConvertToStr() const
138 {
139 if ((type_ == KeyType::LANGUAGES) || (type_ == KeyType::REGION) || (type_ == KeyType::SCRIPT)) {
140 char tmp[4];
141 char tmp2[5];
142 errno_t eret = memcpy_s(tmp, sizeof(tmp), &value_, 4);
143 if (eret != OK) {
144 HILOG_ERROR("memcpy_s error : %d", eret);
145 }
146 int j = 0;
147 // 4 means langauges/region/script key value max length
148 for (int i = 0; i < 4; ++i) {
149 // 3 means reverse temp value to temp2
150 if (tmp[3 - i]) {
151 tmp2[j++] = tmp[3 - i];
152 }
153 }
154 tmp2[j] = '\0';
155 return std::string(tmp2);
156 }
157 if (type_ == KeyType::DIRECTION) {
158 return std::string((value_ == 0) ? VERTICAL : HORIZONTAL);
159 }
160 if (type_ == KeyType::DEVICETYPE) {
161 return GetDeviceTypeStr();
162 }
163 if (type_ == KeyType::COLORMODE) {
164 return GetColorModeStr();
165 }
166 if (type_ == KeyType::INPUTDEVICE) {
167 return GetInputDeviceStr();
168 }
169 if (type_ == KeyType::MCC) {
170 return GetMccStr();
171 }
172 if (type_ == KeyType::MNC) {
173 return GetMncStr();
174 }
175 if (type_ == KeyType::SCREEN_DENSITY) {
176 return GetScreenDensityStr();
177 }
178 return std::string();
179 }
180
ToString() const181 std::string KeyParam::ToString() const
182 {
183 std::string ret = FormatString("[type:%d, value:%u", type_, value_);
184 if (str_.length() > 0) {
185 ret.append(FormatString(", str:%s", str_.c_str()));
186 }
187 ret.append("]");
188 return ret;
189 }
190
191 // IdItem
192
193 std::map<ResType, std::string> IdItem::resTypeStrList;
194
195 bool IdItem::sInit = IdItem::Init();
196
Init()197 bool IdItem::Init()
198 {
199 resTypeStrList.insert(make_pair(ResType::STRING, std::string("string")));
200 resTypeStrList.insert(make_pair(ResType::BOOLEAN, std::string("boolean")));
201 resTypeStrList.insert(make_pair(ResType::COLOR, std::string("color")));
202 resTypeStrList.insert(make_pair(ResType::FLOAT, std::string("float")));
203 resTypeStrList.insert(make_pair(ResType::INTEGER, std::string("integer")));
204 resTypeStrList.insert(make_pair(ResType::PATTERN, std::string("pattern")));
205 resTypeStrList.insert(make_pair(ResType::THEME, std::string("theme")));
206 resTypeStrList.insert(make_pair(ResType::MEDIA, std::string("media")));
207 return true;
208 }
209
HaveParent() const210 bool IdItem::HaveParent() const
211 {
212 if (!(resType_ == THEME || resType_ == PATTERN)) {
213 return false;
214 }
215 return (values_.size() % 2 == 1);
216 }
217
IsRef(const std::string & value,ResType & resType,int & id)218 bool IdItem::IsRef(const std::string &value, ResType &resType, int &id)
219 {
220 const char *it = value.c_str();
221 const char *st = it;
222 if (*st != '$') {
223 return false;
224 }
225 auto index = value.find(":");
226 if (index == std::string::npos || index < 2) {
227 return false;
228 }
229 std::string typeStr;
230 std::string idStr;
231 typeStr.assign(it + 1, index - 1);
232 idStr.assign(it + index + 1, value.size() - index);
233
234 int idd = atoi(idStr.c_str());
235 if (idd <= 0) {
236 return false;
237 }
238
239 for (auto iit = resTypeStrList.begin(); iit != resTypeStrList.end(); ++iit) {
240 auto tValue = iit->second;
241 auto type = iit->first;
242 if (typeStr == tValue) {
243 id = idd;
244 resType = type;
245 return true;
246 }
247 }
248
249 return false;
250 }
251
ToString() const252 std::string IdItem::ToString() const
253 {
254 std::string ret = FormatString(
255 "[size:%u, resType:%d, id:%u, valueLen:%u, isArray:%d, name:'%s', value:",
256 size_, resType_, id_, valueLen_, isArray_, name_.c_str());
257 if (isArray_) {
258 ret.append("[");
259 for (size_t i = 0; i < values_.size(); ++i) {
260 ret.append(FormatString("'%s',", values_[i].c_str()));
261 }
262 ret.append("]");
263 } else {
264 ret.append(FormatString("'%s'", value_.c_str()));
265 }
266 ret.append("]");
267 return ret;
268 }
269
~IdParam()270 IdParam::~IdParam()
271 {
272 if (idItem_ != nullptr) {
273 delete (idItem_);
274 idItem_ = nullptr;
275 }
276 }
277
ToString() const278 std::string IdParam::ToString() const
279 {
280 return FormatString("[id:%u, offset:%u, data:%s]", id_, offset_,
281 idItem_->ToString().c_str());
282 }
283
~ResId()284 ResId::~ResId()
285 {
286 for (size_t i = 0; i < idParams_.size(); ++i) {
287 if (idParams_[i] != nullptr) {
288 delete idParams_[i];
289 idParams_[i] = nullptr;
290 }
291 }
292 }
293
ToString() const294 std::string ResId::ToString() const
295 {
296 std::string ret = FormatString("idcount:%u, ", count_);
297 for (size_t i = 0; i < idParams_.size(); ++i) {
298 ret.append(idParams_[i]->ToString());
299 }
300 return ret;
301 }
302
~ResKey()303 ResKey::~ResKey()
304 {
305 HILOG_DEBUG("~ResKey()");
306 for (size_t i = 0; i < keyParams_.size(); ++i) {
307 if (keyParams_[i] != nullptr) {
308 delete keyParams_[i];
309 keyParams_[i] = nullptr;
310 }
311 }
312 if (resId_ != nullptr) {
313 delete (resId_);
314 resId_ = nullptr;
315 }
316 }
317
ToString() const318 std::string ResKey::ToString() const
319 {
320 std::string ret = FormatString("offset:%u, keyParamsCount:%u, keyParams:", offset_, keyParamsCount_);
321 for (uint32_t i = 0; i < keyParamsCount_; ++i) {
322 ret.append(keyParams_[i]->ToString());
323 }
324 ret.append("\nid: ");
325 ret.append(resId_->ToString());
326 return ret;
327 }
328
ResDesc()329 ResDesc::ResDesc() : resHeader_(nullptr)
330 {}
331
~ResDesc()332 ResDesc::~ResDesc()
333 {
334 HILOG_DEBUG("~ResDesc()");
335 if (resHeader_ != nullptr) {
336 delete (resHeader_);
337 resHeader_ = nullptr;
338 }
339
340 for (size_t i = 0; i < keys_.size(); ++i) {
341 if (keys_[i] != nullptr) {
342 delete keys_[i];
343 keys_[i] = nullptr;
344 }
345 }
346 }
347
ToString() const348 std::string ResDesc::ToString() const
349 {
350 if (resHeader_ == nullptr) {
351 return "empty";
352 }
353 std::string ret = FormatString("version:%s, length:%u, keyCount:%u\n",
354 resHeader_->version_, resHeader_->length_, resHeader_->keyCount_);
355 for (size_t i = 0; i < keys_.size(); ++i) {
356 ret.append(keys_[i]->ToString());
357 ret.append("\n");
358 }
359 return ret;
360 }
361 } // namespace Resource
362 } // namespace Global
363 } // namespace OHOS
364