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
16 #include "lnn_devicename_info.h"
17
18 #include <securec.h>
19 #include <string.h>
20
21 #include "anonymizer.h"
22 #include "bus_center_event.h"
23 #include "bus_center_manager.h"
24 #include "disc_interface.h"
25 #include "lnn_async_callback_utils.h"
26 #include "lnn_distributed_net_ledger.h"
27 #include "lnn_event_monitor_impl.h"
28 #include "lnn_feature_capability.h"
29 #include "lnn_local_net_ledger.h"
30 #include "lnn_log.h"
31 #include "lnn_net_capability.h"
32 #include "lnn_network_info.h"
33 #include "lnn_sync_info_manager.h"
34 #include "lnn_sync_item_info.h"
35 #include "lnn_settingdata_event_monitor.h"
36 #include "lnn_deviceinfo_to_profile.h"
37 #include "lnn_ohos_account_adapter.h"
38 #include "softbus_adapter_mem.h"
39 #include "softbus_def.h"
40 #include "softbus_errcode.h"
41 #include "softbus_wifi_api_adapter.h"
42 #include "softbus_adapter_json.h"
43 #include "message_handler.h"
44
45 #define DELAY_LEN 1000
46 #define MAX_TRY 10
47 #define KEY_NICK_NAME "KEY_NICK_NAME"
48 #define KEY_ACCOUNT "KEY_ACCOUNT"
49
50 static int32_t g_tryGetDevnameNums = 0;
51 static bool g_needSubscribeAccount = false;
52 static void UpdataLocalFromSetting(void *p);
53
LnnSyncDeviceName(const char * networkId)54 static int32_t LnnSyncDeviceName(const char *networkId)
55 {
56 const char *deviceName = NULL;
57 const NodeInfo *info = LnnGetLocalNodeInfo();
58 if (info == NULL) {
59 LNN_LOGE(LNN_BUILDER, "get local node info fail");
60 return SOFTBUS_ERR;
61 }
62 deviceName = LnnGetDeviceName(&info->deviceInfo);
63 if (deviceName == NULL) {
64 LNN_LOGE(LNN_BUILDER, "get device name fail");
65 return SOFTBUS_ERR;
66 }
67 if (LnnSendSyncInfoMsg(LNN_INFO_TYPE_DEVICE_NAME, networkId, (const uint8_t *)deviceName,
68 strlen(deviceName) + 1, NULL) != SOFTBUS_OK) {
69 LNN_LOGE(LNN_BUILDER, "send sync device name fail");
70 return SOFTBUS_ERR;
71 }
72 return SOFTBUS_OK;
73 }
74
LnnSyncDeviceNickName(const char * networkId)75 static int32_t LnnSyncDeviceNickName(const char *networkId)
76 {
77 int64_t accountId = 0;
78 const NodeInfo *info = LnnGetLocalNodeInfo();
79 if (info == NULL) {
80 LNN_LOGE(LNN_BUILDER, "get local nodeInfo fail");
81 return SOFTBUS_ERR;
82 }
83 (void)GetCurrentAccount(&accountId);
84 JsonObj *json = JSON_CreateObject();
85 if (json == NULL) {
86 return SOFTBUS_ERR;
87 }
88 if (!JSON_AddStringToObject(json, KEY_NICK_NAME, info->deviceInfo.nickName) ||
89 !JSON_AddInt64ToObject(json, KEY_ACCOUNT, accountId)) {
90 LNN_LOGE(LNN_BUILDER, "sync device name fail");
91 JSON_Delete(json);
92 return SOFTBUS_ERR;
93 }
94 char *msg = JSON_PrintUnformatted(json);
95 JSON_Delete(json);
96 if (msg == NULL) {
97 return SOFTBUS_ERR;
98 }
99 if (LnnSendSyncInfoMsg(LNN_INFO_TYPE_NICK_NAME, networkId, (const uint8_t *)msg,
100 strlen(msg) + 1, NULL) != SOFTBUS_OK) {
101 LNN_LOGE(LNN_BUILDER, "send sync nickName fail");
102 JSON_Free(msg);
103 return SOFTBUS_ERR;
104 }
105 JSON_Free(msg);
106 return SOFTBUS_OK;
107 }
108
OnReceiveDeviceName(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)109 static void OnReceiveDeviceName(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
110 {
111 char udid[UDID_BUF_LEN];
112 NodeBasicInfo basic;
113 if (type != LNN_INFO_TYPE_DEVICE_NAME || len == 0 || networkId == NULL || msg == NULL) {
114 LNN_LOGE(LNN_BUILDER, "invalid param, SyncInfoType=%{public}d", type);
115 return;
116 }
117 char deviceName[DEVICE_NAME_BUF_LEN + 1] = {0};
118 if (memcpy_s(deviceName, DEVICE_NAME_BUF_LEN, msg, len) != EOK) {
119 LNN_LOGE(LNN_BUILDER, "memcpy fail");
120 return;
121 }
122 char *anonyNetworkId = NULL;
123 Anonymize(networkId, &anonyNetworkId);
124 char *anonyDeviceName = NULL;
125 Anonymize(deviceName, &anonyDeviceName);
126 LNN_LOGI(LNN_BUILDER, "recv device name changed. deviceName=%{public}s, networkId=%{public}s",
127 anonyDeviceName, anonyNetworkId);
128 AnonymizeFree(anonyNetworkId);
129 AnonymizeFree(anonyDeviceName);
130 if (LnnConvertDlId(networkId, CATEGORY_NETWORK_ID, CATEGORY_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
131 LNN_LOGE(LNN_BUILDER, "convert networkId to udid fail");
132 return;
133 }
134 if (!LnnSetDLDeviceInfoName(udid, deviceName)) {
135 LNN_LOGE(LNN_BUILDER, "set peer device name fail");
136 }
137 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
138 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
139 LNN_LOGE(LNN_BUILDER, "GetBasicInfoByUdid fail!");
140 return;
141 }
142 LnnNotifyBasicInfoChanged(&basic, TYPE_DEVICE_NAME);
143 NodeInfo nodeInfo;
144 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
145 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
146 LNN_LOGE(LNN_BUILDER, "get node info fail");
147 return;
148 }
149 UpdateProfile(&nodeInfo);
150 }
151
NotifyDeviceDisplayNameChange(const char * networkId,const char * udid)152 static void NotifyDeviceDisplayNameChange(const char *networkId, const char *udid)
153 {
154 NodeBasicInfo basic;
155 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
156 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
157 LNN_LOGE(LNN_BUILDER, "GetBasicInfoByUdid fail");
158 return;
159 }
160 LnnNotifyBasicInfoChanged(&basic, TYPE_DEVICE_NAME);
161 NodeInfo nodeInfo;
162 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
163 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
164 LNN_LOGE(LNN_BUILDER, "get node info fail");
165 return;
166 }
167 UpdateProfile(&nodeInfo);
168 }
169
SetDisplayName(char * displayName,const char * nickName,const NodeInfo * peerNodeInfo,const NodeInfo * localNodeInfo,int64_t accountId)170 static void SetDisplayName(char *displayName, const char *nickName, const NodeInfo *peerNodeInfo,
171 const NodeInfo *localNodeInfo, int64_t accountId)
172 {
173 int32_t ret = EOK;
174 if (strlen(peerNodeInfo->deviceInfo.unifiedName) != 0 &&
175 strcmp(peerNodeInfo->deviceInfo.unifiedName, peerNodeInfo->deviceInfo.unifiedDefaultName) != 0) {
176 ret = strcpy_s(displayName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedName);
177 } else if (strlen(nickName) == 0 || localNodeInfo->accountId == accountId) {
178 ret = strcpy_s(displayName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedDefaultName);
179 } else {
180 LnnGetDeviceDisplayName(nickName, peerNodeInfo->deviceInfo.unifiedDefaultName,
181 displayName, DEVICE_NAME_BUF_LEN);
182 }
183 if (ret != EOK) {
184 LNN_LOGW(LNN_BUILDER, "strcpy_s fail, use default name");
185 }
186 char *anonyDeviceName = NULL;
187 Anonymize(displayName, &anonyDeviceName);
188 LNN_LOGI(LNN_BUILDER, "peer deviceName=%{public}s", anonyDeviceName);
189 AnonymizeFree(anonyDeviceName);
190 }
191
NickNameMsgProc(const char * networkId,int64_t accountId,const char * nickName)192 static void NickNameMsgProc(const char *networkId, int64_t accountId, const char *nickName)
193 {
194 const NodeInfo *localNodeInfo = LnnGetLocalNodeInfo();
195 LNN_CHECK_AND_RETURN_LOGE(localNodeInfo != NULL, LNN_BUILDER, "local devinfo nullptr");
196 char *anonyNickName = NULL;
197 Anonymize(nickName, &anonyNickName);
198 LNN_LOGI(LNN_BUILDER, "nickName is=%{public}s", anonyNickName);
199 AnonymizeFree(anonyNickName);
200 char displayName[DEVICE_NAME_BUF_LEN] = {0};
201 NodeInfo peerNodeInfo;
202 (void)memset_s(&peerNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
203 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &peerNodeInfo) != SOFTBUS_OK) {
204 LNN_LOGE(LNN_BUILDER, "get remote nodeInfo fail");
205 return;
206 }
207 if (strcmp(peerNodeInfo.deviceInfo.nickName, nickName) == 0) {
208 LNN_LOGE(LNN_BUILDER, "nickName not change, ignore this msg");
209 return;
210 }
211 if (!LnnSetDLDeviceNickName(networkId, nickName)) {
212 LNN_LOGE(LNN_BUILDER, "set remote device nick name fail");
213 return;
214 }
215 char *anonyUnifiedDefaultName = NULL;
216 Anonymize(peerNodeInfo.deviceInfo.unifiedDefaultName, &anonyUnifiedDefaultName);
217 anonyNickName = NULL;
218 Anonymize(peerNodeInfo.deviceInfo.nickName, &anonyNickName);
219 char *anonyUnifiedName = NULL;
220 Anonymize(peerNodeInfo.deviceInfo.unifiedName, &anonyUnifiedName);
221 char *anonyDeviceName = NULL;
222 Anonymize(peerNodeInfo.deviceInfo.deviceName, &anonyDeviceName);
223 LNN_LOGI(LNN_BUILDER, "peer unifiedDefaultName=%{public}s, nickName=%{public}s, "
224 "unifiedName=%{public}s, deviceName=%{public}s",
225 anonyUnifiedDefaultName, anonyNickName, anonyUnifiedName, anonyDeviceName);
226 AnonymizeFree(anonyUnifiedDefaultName);
227 AnonymizeFree(anonyNickName);
228 AnonymizeFree(anonyUnifiedName);
229 AnonymizeFree(anonyDeviceName);
230 SetDisplayName(displayName, nickName, &peerNodeInfo, localNodeInfo, accountId);
231 if (strcmp(peerNodeInfo.deviceInfo.deviceName, displayName) == 0 || strlen(displayName) == 0) {
232 LNN_LOGI(LNN_BUILDER, "device name not change, ignore this msg");
233 return;
234 }
235 (void)LnnSetDLDeviceInfoName(peerNodeInfo.deviceInfo.deviceUdid, displayName);
236 NotifyDeviceDisplayNameChange(networkId, peerNodeInfo.deviceInfo.deviceUdid);
237 }
238
OnReceiveDeviceNickName(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)239 static void OnReceiveDeviceNickName(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
240 {
241 if (msg == NULL) {
242 LNN_LOGE(LNN_BUILDER, "msg is nullptr");
243 return;
244 }
245 if (type != LNN_INFO_TYPE_NICK_NAME) {
246 return;
247 }
248 JsonObj *json = JSON_Parse((const char *)msg, len);
249 if (json == NULL) {
250 LNN_LOGE(LNN_BUILDER, "parse json fail");
251 return;
252 }
253 int64_t accountId = 0;
254 char nickName[DEVICE_NAME_BUF_LEN] = {0};
255 if (!JSON_GetInt64FromOject(json, KEY_ACCOUNT, &accountId) ||
256 !JSON_GetStringFromOject(json, KEY_NICK_NAME, nickName, DEVICE_NAME_BUF_LEN)) {
257 LNN_LOGE(LNN_BUILDER, "nickName json parse fail");
258 JSON_Delete(json);
259 return;
260 }
261 JSON_Delete(json);
262 NickNameMsgProc(networkId, accountId, nickName);
263 }
264
HandlerGetDeviceName(const char * deviceName)265 static void HandlerGetDeviceName(const char *deviceName)
266 {
267 int32_t infoNum = 0;
268 NodeBasicInfo *info = NULL;
269 char name[DEVICE_NAME_BUF_LEN] = {0};
270 if (LnnGetSettingDeviceName(name, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
271 LNN_LOGE(LNN_BUILDER, "set device name fail");
272 return;
273 }
274 if (LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, name) != SOFTBUS_OK) {
275 LNN_LOGE(LNN_BUILDER, "set device name fail");
276 }
277 char unifiedName[DEVICE_NAME_BUF_LEN] = {0};
278 if (LnnGetUnifiedDeviceName(unifiedName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK) {
279 if (LnnSetLocalUnifiedName(unifiedName) != SOFTBUS_OK) {
280 LNN_LOGE(LNN_BUILDER, "set device unifiedName fail");
281 }
282 }
283 DiscDeviceInfoChanged(TYPE_LOCAL_DEVICE_NAME);
284 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
285 LNN_LOGI(LNN_BUILDER, "get online node fail");
286 return;
287 }
288 for (int32_t i = 0; i < infoNum; i++) {
289 if (LnnIsLSANode(&info[i])) {
290 continue;
291 }
292 if (LnnSyncDeviceName(info[i].networkId) != SOFTBUS_OK) {
293 LNN_LOGE(LNN_BUILDER, "LnnSyncDeviceName fail");
294 }
295 }
296 SoftBusFree(info);
297 }
298
IsDeviceNeedSyncNickName(const char * networkId)299 static bool IsDeviceNeedSyncNickName(const char *networkId)
300 {
301 NodeInfo nodeInfo;
302 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
303 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
304 LNN_LOGE(LNN_BUILDER, "get node info fail");
305 return false;
306 }
307 return IsFeatureSupport(nodeInfo.feature, BIT_SUPPORT_UNIFORM_NAME_CAPABILITY);
308 }
309
NotifyNickNameChange(void)310 static void NotifyNickNameChange(void)
311 {
312 NodeBasicInfo *info = NULL;
313 int32_t infoNum = 0;
314 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
315 LNN_LOGE(LNN_BUILDER, "get online node fail");
316 return;
317 }
318 for (int32_t i = 0; i < infoNum; i++) {
319 if (!IsDeviceNeedSyncNickName(info[i].networkId)) {
320 continue;
321 }
322 if (LnnSyncDeviceNickName(info[i].networkId) != SOFTBUS_OK) {
323 LNN_LOGE(LNN_BUILDER, "LnnSyncDeviceNickName fail");
324 }
325 }
326 SoftBusFree(info);
327 }
328
HandlerGetDeviceNickName(const char * displayName)329 static void HandlerGetDeviceNickName(const char *displayName)
330 {
331 (void)displayName;
332 char nickName[DEVICE_NAME_BUF_LEN] = {0};
333 NodeInfo *localNodeInfo = (NodeInfo *)LnnGetLocalNodeInfo();
334 if (localNodeInfo == NULL) {
335 LNN_LOGE(LNN_BUILDER, "local devinfo nullptr");
336 return;
337 }
338 char unifiedName[DEVICE_NAME_BUF_LEN] = {0};
339 if (LnnGetUnifiedDeviceName(unifiedName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
340 LNN_LOGE(LNN_BUILDER, "get device unified name fail");
341 return;
342 }
343 if (strlen(localNodeInfo->deviceInfo.unifiedName) != 0) {
344 if (LnnSetLocalUnifiedName(unifiedName) != SOFTBUS_OK) {
345 LNN_LOGE(LNN_BUILDER, "set device unifiedName fail");
346 }
347 }
348 char unifiedDefault[DEVICE_NAME_BUF_LEN] = {0};
349 if (LnnGetUnifiedDefaultDeviceName(unifiedDefault, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
350 LNN_LOGE(LNN_BUILDER, "get defaultDeviceName fail");
351 return;
352 }
353 if (strlen(unifiedDefault) != 0) {
354 if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_DEFAULT_NAME, unifiedDefault) != SOFTBUS_OK) {
355 LNN_LOGE(LNN_BUILDER, "set device unifiedDefaultName fail");
356 }
357 }
358 if (LnnGetSettingNickName(unifiedDefault, unifiedName,
359 nickName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
360 LNN_LOGE(LNN_BUILDER, "get nickName fail");
361 return;
362 }
363 if (strlen(nickName) == 0) {
364 if (strcpy_s(localNodeInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, "") != EOK) {
365 LNN_LOGE(LNN_BUILDER, "strcpy fail");
366 }
367 } else {
368 if (LnnSetLocalStrInfo(STRING_KEY_DEV_NICK_NAME, nickName) != SOFTBUS_OK) {
369 LNN_LOGE(LNN_BUILDER, "set device nickName fail");
370 }
371 }
372 NotifyNickNameChange();
373 }
374
LnnHandlerGetDeviceName(DeviceNameType type,const char * name)375 static void LnnHandlerGetDeviceName(DeviceNameType type, const char *name)
376 {
377 if (type == DEVICE_NAME_TYPE_DEV_NAME) {
378 HandlerGetDeviceName(name);
379 } else if (type == DEVICE_NAME_TYPE_NICK_NAME) {
380 HandlerGetDeviceNickName(name);
381 } else {
382 LNN_LOGW(LNN_BUILDER, "invalid type=%{public}d", type);
383 }
384 LnnNotifyLocalNetworkIdChanged();
385 }
386
UpdateLocalExtendDeviceName(const char * deviceName,char * unifiedName,char * unifiedDefaultName,char * nickName)387 static void UpdateLocalExtendDeviceName(const char *deviceName, char *unifiedName, char *unifiedDefaultName,
388 char *nickName)
389 {
390 if (LnnGetUnifiedDeviceName(unifiedName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK && strlen(unifiedName) != 0) {
391 if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_NAME, unifiedName) != SOFTBUS_OK) {
392 LNN_LOGE(LNN_BUILDER, "UpdateLocalFromSetting set unified name fail");
393 }
394 }
395 if (LnnGetUnifiedDefaultDeviceName(unifiedDefaultName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK &&
396 strlen(unifiedDefaultName) != 0) {
397 if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_DEFAULT_NAME, unifiedDefaultName) != SOFTBUS_OK) {
398 LNN_LOGE(LNN_BUILDER, "UpdateLocalFromSetting set default unified name fail");
399 }
400 }
401 if (LnnGetSettingNickName(deviceName, unifiedName, nickName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK &&
402 strlen(nickName) != 0) {
403 if (LnnSetLocalStrInfo(STRING_KEY_DEV_NICK_NAME, nickName) != SOFTBUS_OK) {
404 LNN_LOGE(LNN_BUILDER, "UpdateLocalFromSetting set nick name fail");
405 }
406 }
407 }
408
AccountBootEventHandle(const char * key,const char * value,void * context)409 static void AccountBootEventHandle(const char *key, const char *value, void *context)
410 {
411 (void)context;
412 LNN_LOGI(LNN_EVENT, "account is ready, key=%{public}s, value=%{public}s", key, value);
413 if (strcmp(key, BOOTEVENT_ACCOUNT_READY) != 0 || strcmp(value, "true") != 0) {
414 return;
415 }
416 g_tryGetDevnameNums = 0;
417 g_needSubscribeAccount = false;
418 int32_t ret = LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), UpdataLocalFromSetting, NULL, 0);
419 if (ret != SOFTBUS_OK) {
420 LNN_LOGE(LNN_EVENT, "async call boot event fail");
421 }
422 }
PrintLocalExtendDeviceName(const char * deviceName,const char * unifiedName,const char * unifiedDefaultName,const char * nickName)423 static void PrintLocalExtendDeviceName(const char *deviceName, const char *unifiedName,
424 const char *unifiedDefaultName, const char *nickName)
425 {
426 char *anonyDeviceName = NULL;
427 Anonymize(deviceName, &anonyDeviceName);
428 char *anonyUnifiedName = NULL;
429 Anonymize(unifiedName, &anonyUnifiedName);
430 char *anonyUnifiedDefaultName = NULL;
431 Anonymize(unifiedDefaultName, &anonyUnifiedDefaultName);
432 char *anonyNickName = NULL;
433 Anonymize(nickName, &anonyNickName);
434 LNN_LOGI(LNN_BUILDER, "UpdateLocalFromSetting done, deviceName=%{public}s, unifiedName=%{public}s, "
435 "unifiedDefaultName=%{public}s, nickName=%{public}s",
436 anonyDeviceName, anonyUnifiedName, anonyUnifiedDefaultName, anonyNickName);
437 AnonymizeFree(anonyDeviceName);
438 AnonymizeFree(anonyUnifiedName);
439 AnonymizeFree(anonyUnifiedDefaultName);
440 AnonymizeFree(anonyNickName);
441 }
442
443
UpdataLocalFromSetting(void * p)444 static void UpdataLocalFromSetting(void *p)
445 {
446 (void)p;
447 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
448 char unifiedName[DEVICE_NAME_BUF_LEN] = {0};
449 char unifiedDefaultName[DEVICE_NAME_BUF_LEN] = {0};
450 char nickName[DEVICE_NAME_BUF_LEN] = {0};
451 if (LnnGetSettingDeviceName(deviceName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
452 g_tryGetDevnameNums++;
453 LNN_LOGI(LNN_BUILDER, "g_tryGetDevnameNums=%{public}d, needSubscribe=%{public}d",
454 g_tryGetDevnameNums, g_needSubscribeAccount);
455 if (g_tryGetDevnameNums < MAX_TRY) {
456 SoftBusLooper *looper = GetLooper(LOOP_TYPE_DEFAULT);
457 if (looper == NULL) {
458 LNN_LOGE(LNN_BUILDER, "looper is null");
459 return;
460 }
461 int ret = LnnAsyncCallbackDelayHelper(looper, UpdataLocalFromSetting, NULL, DELAY_LEN);
462 if (ret != SOFTBUS_OK) {
463 LNN_LOGE(LNN_BUILDER, "init UpdataLocalFromSetting fail");
464 }
465 return;
466 }
467 if (!g_needSubscribeAccount) {
468 LNN_LOGE(LNN_BUILDER, "update device name fail");
469 RegisterNameMonitor();
470 return;
471 }
472 LNN_LOGI(LNN_BUILDER, "account or database not ready, retry after account ready");
473 if (LnnSubscribeAccountBootEvent(AccountBootEventHandle) != SOFTBUS_OK) {
474 LNN_LOGE(LNN_BUILDER, "watch account server fail");
475 RegisterNameMonitor();
476 }
477 return;
478 }
479 if (LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, deviceName) != SOFTBUS_OK) {
480 LNN_LOGE(LNN_BUILDER, "UpdataLocalFromSetting set device name fail");
481 }
482 UpdateLocalExtendDeviceName(deviceName, unifiedName, unifiedDefaultName, nickName);
483 RegisterNameMonitor();
484 DiscDeviceInfoChanged(TYPE_LOCAL_DEVICE_NAME);
485 LnnNotifyLocalNetworkIdChanged();
486 PrintLocalExtendDeviceName(deviceName, unifiedName, unifiedDefaultName, nickName);
487 }
488
RegisterDeviceNameHandle(void)489 static void RegisterDeviceNameHandle(void)
490 {
491 LnnInitGetDeviceName(LnnHandlerGetDeviceName);
492 }
493
UpdateDeviceName(void * p)494 void UpdateDeviceName(void *p)
495 {
496 g_needSubscribeAccount = true;
497 RegisterDeviceNameHandle();
498 UpdataLocalFromSetting(p);
499 }
500
LnnAccountStateChangeHandler(const LnnEventBasicInfo * info)501 static void LnnAccountStateChangeHandler(const LnnEventBasicInfo *info)
502 {
503 if (info == NULL || info->event != LNN_EVENT_ACCOUNT_CHANGED) {
504 LNN_LOGE(LNN_BUILDER, "invalid param");
505 return;
506 }
507 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
508 SoftBusAccountState accountState = (SoftBusAccountState)event->status;
509 LNN_LOGD(LNN_BUILDER, "account state=%{public}d", accountState);
510 HandlerGetDeviceNickName(NULL);
511 return;
512 }
513
LnnInitDevicename(void)514 int32_t LnnInitDevicename(void)
515 {
516 int32_t ret = LnnRegSyncInfoHandler(LNN_INFO_TYPE_DEVICE_NAME, OnReceiveDeviceName);
517 if (ret != SOFTBUS_OK) {
518 return ret;
519 }
520 if (LnnRegisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, LnnAccountStateChangeHandler) != SOFTBUS_OK) {
521 LNN_LOGE(LNN_BUILDER, "regist account change evt handler fail");
522 return SOFTBUS_ERR;
523 }
524 return LnnRegSyncInfoHandler(LNN_INFO_TYPE_NICK_NAME, OnReceiveDeviceNickName);
525 }
526
LnnDeinitDevicename(void)527 void LnnDeinitDevicename(void)
528 {
529 (void)LnnUnregSyncInfoHandler(LNN_INFO_TYPE_DEVICE_NAME, OnReceiveDeviceName);
530 LnnUnregisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, LnnAccountStateChangeHandler);
531 (void)LnnUnregSyncInfoHandler(LNN_INFO_TYPE_NICK_NAME, OnReceiveDeviceNickName);
532 }
533