1 /*
2 * Copyright (c) 2023-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 "content_sensor_manager_utils.h"
17
18 #include <cstring>
19 #include <iomanip>
20 #include <sstream>
21
22 #include "cJSON.h"
23 #include "parameter.h"
24 #include "parameters.h"
25 #include "softbus_bus_center.h"
26 #include "softbus_error_code.h"
27
28 #include "distributed_device_profile_constants.h"
29 #include "distributed_device_profile_log.h"
30
31 namespace OHOS {
32 namespace DistributedDeviceProfile {
33 namespace {
34 const std::string TAG = "ContentSensorManagerUtils";
35 const char* SYS_SETTINGS_DATA_SYNC = "persist.distributed_scene.sys_settings_data_sync";
36 const char* PRODUCT_ID_KEY = "const.distributed_collaboration.productId";
37 const char* UNDEFINED_VALUE = "undefined";
38 const char* SYNC_TYPE_E2E = "1";
39 const char* MANUFACTURER_KEY = "const.product.manufacturer";
40 constexpr int32_t DEVICE_UUID_LENGTH = 65;
41 constexpr int32_t SYS_SETTINGS_DATA_SYNC_PARAM_LEN = 128;
42 constexpr int32_t PROT_TYPE_WIFI_ONLY = 1;
43 constexpr int32_t PROT_TYPE_MOBILIE_NETWORK_AND_WIFI = 18;
44 constexpr const char* WIFI_ONLY_DEVICE_TREE_PROC_NODE_NAME = "/proc/device-tree/singleap_wifionly/is_wifionly";
45 constexpr const char* WIFI_ONLY_FLAG_VALUE = "1";
46 constexpr int32_t WIFI_ONLY_FLAG_VALUE_MAX_LEN = 8;
47 const char* OHOS_BOOT_BACKCOLOR = "ohos.boot.backcolor";
48 const char* SUB_PROD_ID_MAP = "const.distributed_collaboration.subProdIdMap";
49 }
50 IMPLEMENT_SINGLE_INSTANCE(ContentSensorManagerUtils);
ObtainProductModel()51 std::string ContentSensorManagerUtils::ObtainProductModel()
52 {
53 HILOGI("called!");
54 std::lock_guard<std::mutex> lock(csMutex_);
55 if (!deviceModel_.empty()) {
56 return deviceModel_;
57 }
58 const char* productModelTemp = GetProductModel();
59 if (productModelTemp == nullptr) {
60 HILOGE("get productModel failed!");
61 return "";
62 }
63 deviceModel_ = productModelTemp;
64 free((char*)productModelTemp);
65 return deviceModel_;
66 }
67
ObtainDeviceType()68 std::string ContentSensorManagerUtils::ObtainDeviceType()
69 {
70 HILOGI("called!");
71 std::lock_guard<std::mutex> lock(csMutex_);
72 if (!deviceType_.empty()) {
73 return deviceType_;
74 }
75 const char* deviceTypeTemp = GetDeviceType();
76 if (deviceTypeTemp == nullptr) {
77 HILOGE("get deviceType failed!");
78 return "";
79 }
80 deviceType_ = deviceTypeTemp;
81 free((char*)deviceTypeTemp);
82 return deviceType_;
83 }
84
ObtainDeviceTypeId()85 std::string ContentSensorManagerUtils::ObtainDeviceTypeId()
86 {
87 {
88 std::lock_guard<std::mutex> lock(csMutex_);
89 if (!deviceTypeId_.empty()) {
90 return deviceTypeId_;
91 }
92 }
93 NodeBasicInfo nodeBasicInfo;
94 int32_t ret = GetLocalNodeDeviceInfo(DP_PKG_NAME.c_str(), &nodeBasicInfo);
95 if (ret != SOFTBUS_OK) {
96 HILOGE("GetLocalNodeDeviceInfo from dsofbus fail, ret=%{public}d", ret);
97 return "";
98 }
99 uint16_t deviceTypeId = nodeBasicInfo.deviceTypeId;
100 std::stringstream strDeviceTypeId;
101 strDeviceTypeId << std::uppercase << std::setw(NUM_3) << std::setfill('0') << std::hex << deviceTypeId;
102 std::lock_guard<std::mutex> lock(csMutex_);
103 deviceTypeId_ = strDeviceTypeId.str();
104 return deviceTypeId_;
105 }
106
ObtainManufacture()107 std::string ContentSensorManagerUtils::ObtainManufacture()
108 {
109 HILOGI("called!");
110 std::lock_guard<std::mutex> lock(csMutex_);
111 if (!manufacture_.empty()) {
112 return manufacture_;
113 }
114 std::string manufactureTemp = system::GetParameter(MANUFACTURER_KEY, "");
115 if (manufactureTemp.empty()) {
116 HILOGE("get manufacture failed!");
117 return "";
118 }
119 manufacture_ = manufactureTemp;
120 return manufacture_;
121 }
122
ObtainSerial()123 std::string ContentSensorManagerUtils::ObtainSerial()
124 {
125 HILOGI("called!");
126 std::lock_guard<std::mutex> lock(csMutex_);
127 if (!serial_.empty()) {
128 return serial_;
129 }
130 const char* serialTemp = GetSerial();
131 if (serialTemp == nullptr) {
132 HILOGE("get serial failed!");
133 return "";
134 }
135 serial_ = serialTemp;
136 free((char*)serialTemp);
137 return serial_;
138 }
139
ObtainMarketName()140 std::string ContentSensorManagerUtils::ObtainMarketName()
141 {
142 HILOGI("called!");
143 std::lock_guard<std::mutex> lock(csMutex_);
144 if (!marketName_.empty()) {
145 return marketName_;
146 }
147 const char* marketNameTemp = GetMarketName();
148 if (marketNameTemp == nullptr) {
149 HILOGE("get marketName failed!");
150 return "";
151 }
152 marketName_ = marketNameTemp;
153 free((char*)marketNameTemp);
154 return marketName_;
155 }
156
ObtainOsFullName()157 std::string ContentSensorManagerUtils::ObtainOsFullName()
158 {
159 HILOGI("called!");
160 std::lock_guard<std::mutex> lock(csMutex_);
161 if (!osFullName_.empty()) {
162 return osFullName_;
163 }
164 const char* osFullNameTemp = GetOSFullName();
165 if (osFullNameTemp == nullptr) {
166 HILOGE("get osFullName failed!");
167 return "";
168 }
169 osFullName_ = osFullNameTemp;
170 free((char*)osFullNameTemp);
171 return osFullName_;
172 }
173
ObtainDisplayVersion()174 std::string ContentSensorManagerUtils::ObtainDisplayVersion()
175 {
176 HILOGI("called!");
177 std::lock_guard<std::mutex> lock(csMutex_);
178 if (!displayVersion_.empty()) {
179 return displayVersion_;
180 }
181 const char* displayVersionTemp = GetDisplayVersion();
182 if (displayVersionTemp == nullptr) {
183 HILOGE("get displayVersion failed!");
184 return "";
185 }
186 displayVersion_ = displayVersionTemp;
187 free((char*)displayVersionTemp);
188 return displayVersion_;
189 }
190
ObtainLocalUdid()191 std::string ContentSensorManagerUtils::ObtainLocalUdid()
192 {
193 std::lock_guard<std::mutex> lock(csMutex_);
194 if (!localUdid_.empty()) {
195 return localUdid_;
196 }
197 HILOGD("GetDevUdid");
198 char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
199 GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
200 localUdid_ = localUdidTemp;
201 return localUdid_;
202 }
203
ObtainProductId()204 std::string ContentSensorManagerUtils::ObtainProductId()
205 {
206 HILOGI("called!");
207 std::lock_guard<std::mutex> lock(csMutex_);
208 if (!productId_.empty()) {
209 return productId_;
210 }
211 std::string productIdTemp = system::GetParameter(PRODUCT_ID_KEY, "");
212 if (productIdTemp.empty()) {
213 HILOGE("get productId failed!");
214 return "";
215 }
216 productId_ = productIdTemp;
217 if (productId_.size() > NUM_1) {
218 productId_.pop_back();
219 }
220 return productId_;
221 }
222
ObtainDeviceDataSyncMode()223 void ContentSensorManagerUtils::ObtainDeviceDataSyncMode()
224 {
225 char isE2EDeviceParam[SYS_SETTINGS_DATA_SYNC_PARAM_LEN + 1] = {0};
226 int ret = GetParameter(SYS_SETTINGS_DATA_SYNC, UNDEFINED_VALUE, isE2EDeviceParam,
227 SYS_SETTINGS_DATA_SYNC_PARAM_LEN);
228 if (ret > 0 && strncmp(isE2EDeviceParam, SYNC_TYPE_E2E, strlen(SYNC_TYPE_E2E)) == 0) {
229 isDeviceE2ESync_.store(true);
230 HILOGI("Determining the e2e device succeeded.");
231 return;
232 }
233 HILOGW("Determining is not e2e device");
234 }
235
IsDeviceE2ESync()236 bool ContentSensorManagerUtils::IsDeviceE2ESync()
237 {
238 return isDeviceE2ESync_.load();
239 }
240
GetProtType()241 int32_t ContentSensorManagerUtils::GetProtType()
242 {
243 std::lock_guard<std::mutex> lock(csMutex_);
244 if (protType_ > 0) {
245 return protType_;
246 }
247 if (IsWifiOnly()) {
248 protType_ = PROT_TYPE_WIFI_ONLY;
249 } else {
250 protType_ = PROT_TYPE_MOBILIE_NETWORK_AND_WIFI;
251 }
252 HILOGI("protType:%{public}d", protType_);
253 return protType_;
254 }
255
IsWifiOnly()256 bool ContentSensorManagerUtils::IsWifiOnly()
257 {
258 char buf[WIFI_ONLY_FLAG_VALUE_MAX_LEN] = {0};
259 FILE *fp = nullptr;
260 if ((fp = fopen(WIFI_ONLY_DEVICE_TREE_PROC_NODE_NAME, "r")) == nullptr) {
261 HILOGE("open wifi only device tree proc node fail");
262 return false;
263 }
264 if (fgets(buf, WIFI_ONLY_FLAG_VALUE_MAX_LEN, fp) == nullptr) {
265 HILOGE("fgets return nullptr");
266 if (fclose(fp) != 0) {
267 HILOGE("Close file failed");
268 }
269 return false;
270 }
271 if (strcmp(buf, WIFI_ONLY_FLAG_VALUE)) {
272 HILOGE("buf not equal WIFI_ONLY_FLAG_VALUE");
273 if (fclose(fp) != 0) {
274 HILOGE("Close file failed");
275 }
276 return false;
277 }
278 if (fclose(fp) != 0) {
279 HILOGE("Close file failed");
280 }
281 return true;
282 }
283
GetSubProductId()284 std::string ContentSensorManagerUtils::GetSubProductId()
285 {
286 std::string backcolor = GetBackcolor();
287 std::map<std::string, std::string> subProdIdMap = GetSubProdIdMap();
288 if (backcolor.empty() || subProdIdMap.empty() || subProdIdMap.find(backcolor) == subProdIdMap.end()) {
289 return EMPTY_STRING;
290 }
291 return subProdIdMap[backcolor];
292 }
293
GetBackcolor()294 std::string ContentSensorManagerUtils::GetBackcolor()
295 {
296 std::lock_guard<std::mutex> lock(csMutex_);
297 if (!backcolor_.empty()) {
298 return backcolor_;
299 }
300 std::string temp = system::GetParameter(OHOS_BOOT_BACKCOLOR, "");
301 if (temp.empty()) {
302 HILOGE("get backcolor failed!");
303 return "";
304 }
305 backcolor_ = temp;
306 return backcolor_;
307 }
308
GetSubProdIdMap()309 std::map<std::string, std::string> ContentSensorManagerUtils::GetSubProdIdMap()
310 {
311 std::lock_guard<std::mutex> lock(csMutex_);
312 if (!subProdIdMap_.empty()) {
313 return subProdIdMap_;
314 }
315 std::string temp = system::GetParameter(SUB_PROD_ID_MAP, "");
316 if (temp.empty()) {
317 HILOGE("get subProdIdMap failed!");
318 return {};
319 }
320 cJSON* json = cJSON_Parse(temp.c_str());
321 if (!cJSON_IsObject(json)) {
322 HILOGW("cJSON_Parse productName fail!");
323 cJSON_Delete(json);
324 return {};
325 }
326 cJSON* item = json->child;
327 while (item != NULL) {
328 if (cJSON_IsString(item)) {
329 subProdIdMap_[item->string] = item->valuestring;
330 }
331 item = item->next;
332 }
333 cJSON_Delete(json);
334 return subProdIdMap_;
335 }
336 } // namespace DistributedDeviceProfile
337 } // namespace OHOS
338