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 
LnnTrySyncDeviceName(void)299 void LnnTrySyncDeviceName(void)
300 {
301     char localDevName[DEVICE_NAME_BUF_LEN] = {0};
302     int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, localDevName, sizeof(localDevName));
303     if (ret != SOFTBUS_OK) {
304         LNN_LOGE(LNN_BUILDER, "get local devicename fail");
305         return;
306     }
307     char name[DEVICE_NAME_BUF_LEN] = {0};
308     if (LnnGetSettingDeviceName(name, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
309         LNN_LOGE(LNN_BUILDER, "set device name fail");
310         return;
311     }
312     if (strcmp(localDevName, name) == 0) {
313         LNN_LOGI(LNN_BUILDER, "devicename not change no need sync");
314         return;
315     }
316     HandlerGetDeviceName(name);
317 }
318 
IsDeviceNeedSyncNickName(const char * networkId)319 static bool IsDeviceNeedSyncNickName(const char *networkId)
320 {
321     NodeInfo nodeInfo;
322     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
323     if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
324         LNN_LOGE(LNN_BUILDER, "get node info fail");
325         return false;
326     }
327     return IsFeatureSupport(nodeInfo.feature, BIT_SUPPORT_UNIFORM_NAME_CAPABILITY);
328 }
329 
NotifyNickNameChange(void)330 static void NotifyNickNameChange(void)
331 {
332     NodeBasicInfo *info = NULL;
333     int32_t infoNum = 0;
334     if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
335         LNN_LOGE(LNN_BUILDER, "get online node fail");
336         return;
337     }
338     for (int32_t i = 0; i < infoNum; i++) {
339         if (!IsDeviceNeedSyncNickName(info[i].networkId)) {
340             continue;
341         }
342         if (LnnSyncDeviceNickName(info[i].networkId) != SOFTBUS_OK) {
343             LNN_LOGE(LNN_BUILDER, "LnnSyncDeviceNickName fail");
344         }
345     }
346     SoftBusFree(info);
347 }
348 
HandlerGetDeviceNickName(const char * displayName)349 static void HandlerGetDeviceNickName(const char *displayName)
350 {
351     (void)displayName;
352     char nickName[DEVICE_NAME_BUF_LEN] = {0};
353     NodeInfo *localNodeInfo = (NodeInfo *)LnnGetLocalNodeInfo();
354     if (localNodeInfo == NULL) {
355         LNN_LOGE(LNN_BUILDER, "local devinfo nullptr");
356         return;
357     }
358     char unifiedName[DEVICE_NAME_BUF_LEN] = {0};
359     if (LnnGetUnifiedDeviceName(unifiedName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
360         LNN_LOGE(LNN_BUILDER, "get device unified name fail");
361         return;
362     }
363     if (strlen(localNodeInfo->deviceInfo.unifiedName) != 0) {
364         if (LnnSetLocalUnifiedName(unifiedName) != SOFTBUS_OK) {
365             LNN_LOGE(LNN_BUILDER, "set device unifiedName fail");
366         }
367     }
368     char unifiedDefault[DEVICE_NAME_BUF_LEN] = {0};
369     if (LnnGetUnifiedDefaultDeviceName(unifiedDefault, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
370         LNN_LOGE(LNN_BUILDER, "get defaultDeviceName fail");
371         return;
372     }
373     if (strlen(unifiedDefault) != 0) {
374         if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_DEFAULT_NAME, unifiedDefault) != SOFTBUS_OK) {
375             LNN_LOGE(LNN_BUILDER, "set device unifiedDefaultName fail");
376         }
377     }
378     if (LnnGetSettingNickName(unifiedDefault, unifiedName,
379         nickName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
380         LNN_LOGE(LNN_BUILDER, "get nickName fail");
381         return;
382     }
383     if (strlen(nickName) == 0) {
384         if (strcpy_s(localNodeInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, "") != EOK) {
385             LNN_LOGE(LNN_BUILDER, "strcpy fail");
386         }
387     } else {
388         if (LnnSetLocalStrInfo(STRING_KEY_DEV_NICK_NAME, nickName) != SOFTBUS_OK) {
389             LNN_LOGE(LNN_BUILDER, "set device nickName fail");
390         }
391     }
392     NotifyNickNameChange();
393 }
394 
LnnHandlerGetDeviceName(DeviceNameType type,const char * name)395 static void LnnHandlerGetDeviceName(DeviceNameType type, const char *name)
396 {
397     if (type == DEVICE_NAME_TYPE_DEV_NAME) {
398         HandlerGetDeviceName(name);
399     } else if (type == DEVICE_NAME_TYPE_NICK_NAME) {
400         HandlerGetDeviceNickName(name);
401     } else {
402         LNN_LOGW(LNN_BUILDER, "invalid type=%{public}d", type);
403     }
404     LnnNotifyLocalNetworkIdChanged();
405 }
406 
UpdateLocalExtendDeviceName(const char * deviceName,char * unifiedName,char * unifiedDefaultName,char * nickName)407 static void UpdateLocalExtendDeviceName(const char *deviceName, char *unifiedName, char *unifiedDefaultName,
408     char *nickName)
409 {
410     if (LnnGetUnifiedDeviceName(unifiedName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK && strlen(unifiedName) != 0) {
411         if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_NAME, unifiedName) != SOFTBUS_OK) {
412             LNN_LOGE(LNN_BUILDER, "UpdateLocalFromSetting set unified name fail");
413         }
414     }
415     if (LnnGetUnifiedDefaultDeviceName(unifiedDefaultName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK &&
416         strlen(unifiedDefaultName) != 0) {
417         if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_DEFAULT_NAME, unifiedDefaultName) != SOFTBUS_OK) {
418             LNN_LOGE(LNN_BUILDER, "UpdateLocalFromSetting set default unified name fail");
419         }
420     }
421     if (LnnGetSettingNickName(deviceName, unifiedName, nickName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK &&
422         strlen(nickName) != 0) {
423         if (LnnSetLocalStrInfo(STRING_KEY_DEV_NICK_NAME, nickName) != SOFTBUS_OK) {
424             LNN_LOGE(LNN_BUILDER, "UpdateLocalFromSetting set nick name fail");
425         }
426     }
427 }
428 
AccountBootEventHandle(const char * key,const char * value,void * context)429 static void AccountBootEventHandle(const char *key, const char *value, void *context)
430 {
431     (void)context;
432     LNN_LOGI(LNN_EVENT, "account is ready, key=%{public}s, value=%{public}s", key, value);
433     if (strcmp(key, BOOTEVENT_ACCOUNT_READY) != 0 || strcmp(value, "true") != 0) {
434         return;
435     }
436     g_tryGetDevnameNums = 0;
437     g_needSubscribeAccount = false;
438     int32_t ret = LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), UpdataLocalFromSetting, NULL, 0);
439     if (ret != SOFTBUS_OK) {
440         LNN_LOGE(LNN_EVENT, "async call boot event fail");
441     }
442 }
PrintLocalExtendDeviceName(const char * deviceName,const char * unifiedName,const char * unifiedDefaultName,const char * nickName)443 static void PrintLocalExtendDeviceName(const char *deviceName, const char *unifiedName,
444     const char *unifiedDefaultName, const char *nickName)
445 {
446     char *anonyDeviceName = NULL;
447     Anonymize(deviceName, &anonyDeviceName);
448     char *anonyUnifiedName = NULL;
449     Anonymize(unifiedName, &anonyUnifiedName);
450     char *anonyUnifiedDefaultName = NULL;
451     Anonymize(unifiedDefaultName, &anonyUnifiedDefaultName);
452     char *anonyNickName = NULL;
453     Anonymize(nickName, &anonyNickName);
454     LNN_LOGI(LNN_BUILDER, "UpdateLocalFromSetting done, deviceName=%{public}s, unifiedName=%{public}s, "
455         "unifiedDefaultName=%{public}s, nickName=%{public}s",
456         anonyDeviceName, anonyUnifiedName, anonyUnifiedDefaultName, anonyNickName);
457     AnonymizeFree(anonyDeviceName);
458     AnonymizeFree(anonyUnifiedName);
459     AnonymizeFree(anonyUnifiedDefaultName);
460     AnonymizeFree(anonyNickName);
461 }
462 
463 
UpdataLocalFromSetting(void * p)464 static void UpdataLocalFromSetting(void *p)
465 {
466     (void)p;
467     char deviceName[DEVICE_NAME_BUF_LEN] = {0};
468     char unifiedName[DEVICE_NAME_BUF_LEN] = {0};
469     char unifiedDefaultName[DEVICE_NAME_BUF_LEN] = {0};
470     char nickName[DEVICE_NAME_BUF_LEN] = {0};
471     if (LnnGetSettingDeviceName(deviceName, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
472         g_tryGetDevnameNums++;
473         LNN_LOGI(LNN_BUILDER, "g_tryGetDevnameNums=%{public}d, needSubscribe=%{public}d",
474             g_tryGetDevnameNums, g_needSubscribeAccount);
475         if (g_tryGetDevnameNums < MAX_TRY) {
476             SoftBusLooper *looper = GetLooper(LOOP_TYPE_DEFAULT);
477             if (looper == NULL) {
478                 LNN_LOGE(LNN_BUILDER, "looper is null");
479                 return;
480             }
481             int ret = LnnAsyncCallbackDelayHelper(looper, UpdataLocalFromSetting, NULL, DELAY_LEN);
482             if (ret != SOFTBUS_OK) {
483                 LNN_LOGE(LNN_BUILDER, "init UpdataLocalFromSetting fail");
484             }
485             return;
486         }
487         if (!g_needSubscribeAccount) {
488             LNN_LOGE(LNN_BUILDER, "update device name fail");
489             RegisterNameMonitor();
490             return;
491         }
492         LNN_LOGI(LNN_BUILDER, "account or database not ready, retry after account ready");
493         if (LnnSubscribeAccountBootEvent(AccountBootEventHandle) != SOFTBUS_OK) {
494             LNN_LOGE(LNN_BUILDER, "watch account server fail");
495             RegisterNameMonitor();
496         }
497         return;
498     }
499     if (LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, deviceName) != SOFTBUS_OK) {
500         LNN_LOGE(LNN_BUILDER, "UpdataLocalFromSetting set device name fail");
501     }
502     UpdateLocalExtendDeviceName(deviceName, unifiedName, unifiedDefaultName, nickName);
503     RegisterNameMonitor();
504     DiscDeviceInfoChanged(TYPE_LOCAL_DEVICE_NAME);
505     LnnNotifyLocalNetworkIdChanged();
506     PrintLocalExtendDeviceName(deviceName, unifiedName, unifiedDefaultName, nickName);
507 }
508 
RegisterDeviceNameHandle(void)509 static void RegisterDeviceNameHandle(void)
510 {
511     LnnInitGetDeviceName(LnnHandlerGetDeviceName);
512 }
513 
UpdateDeviceName(void * p)514 void UpdateDeviceName(void *p)
515 {
516     g_needSubscribeAccount = true;
517     RegisterDeviceNameHandle();
518     UpdataLocalFromSetting(p);
519 }
520 
LnnAccountStateChangeHandler(const LnnEventBasicInfo * info)521 static void LnnAccountStateChangeHandler(const LnnEventBasicInfo *info)
522 {
523     if (info == NULL || info->event != LNN_EVENT_ACCOUNT_CHANGED) {
524         LNN_LOGE(LNN_BUILDER, "invalid param");
525         return;
526     }
527     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
528     SoftBusAccountState accountState = (SoftBusAccountState)event->status;
529     LNN_LOGD(LNN_BUILDER, "account state=%{public}d", accountState);
530     HandlerGetDeviceNickName(NULL);
531     return;
532 }
533 
LnnInitDevicename(void)534 int32_t LnnInitDevicename(void)
535 {
536     int32_t ret = LnnRegSyncInfoHandler(LNN_INFO_TYPE_DEVICE_NAME, OnReceiveDeviceName);
537     if (ret != SOFTBUS_OK) {
538         return ret;
539     }
540     if (LnnRegisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, LnnAccountStateChangeHandler) != SOFTBUS_OK) {
541         LNN_LOGE(LNN_BUILDER, "regist account change evt handler fail");
542         return SOFTBUS_ERR;
543     }
544     return LnnRegSyncInfoHandler(LNN_INFO_TYPE_NICK_NAME, OnReceiveDeviceNickName);
545 }
546 
LnnDeinitDevicename(void)547 void LnnDeinitDevicename(void)
548 {
549     (void)LnnUnregSyncInfoHandler(LNN_INFO_TYPE_DEVICE_NAME, OnReceiveDeviceName);
550     LnnUnregisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, LnnAccountStateChangeHandler);
551     (void)LnnUnregSyncInfoHandler(LNN_INFO_TYPE_NICK_NAME, OnReceiveDeviceNickName);
552 }
553