From de14dcfc80b2da5de5cdfeb0250ad4e5f229e02d Mon Sep 17 00:00:00 2001 From: guoyi Date: Tue, 2 Sep 2025 19:45:38 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E4=BC=98=E5=8C=96bind?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: guoyi --- .../include/ability/dm_dialog_manager.h | 102 ++--- .../include/device_manager_service_impl.h | 25 +- .../ability/standard/dm_dialog_manager.cpp | 223 ++++++----- .../authentication/auth_ui_state_manager.cpp | 12 +- .../auth_stages/auth_confirm.cpp | 2 +- .../src/device_manager_service_impl.cpp | 347 +++++++++++------- .../UTTest_device_manager_service_impl.cpp | 78 +++- 7 files changed, 480 insertions(+), 309 deletions(-) diff --git a/services/implementation/include/ability/dm_dialog_manager.h b/services/implementation/include/ability/dm_dialog_manager.h index 73c92997c..22f002b95 100644 --- a/services/implementation/include/ability/dm_dialog_manager.h +++ b/services/implementation/include/ability/dm_dialog_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -27,96 +27,44 @@ namespace OHOS { namespace DistributedHardware { class DmDialogManager { + DM_DECLARE_SINGLE_INSTANCE_BASE(DmDialogManager); public: - static DmDialogManager &GetInstance(); - static void ConnectExtension(); + void ConnectExtension(); void ShowConfirmDialog(const std::string param); void ShowPinDialog(const std::string param); void ShowInputDialog(const std::string param); - static std::string GetBundleName() - { - return bundleName_; - } - - static std::string GetAbilityName() - { - return abilityName_; - } - - static std::string GetPinCode() - { - return pinCode_; - } - - static std::string GetDeviceName() - { - return deviceName_; - } - - static std::string GetAppOperationStr() - { - return appOperationStr_; - } - - static std::string GetCustomDescriptionStr() - { - return customDescriptionStr_; - } - - static int32_t GetDeviceType() - { - return deviceType_; - } - - static std::string GetTargetDeviceName() - { - return targetDeviceName_; - } - - static std::string GetHostPkgLabel() - { - return hostPkgLabel_; - } - static bool GetIsProxyBind() - { - return isProxyBind_; - } - static std::string GetAppUserData() - { - return appUserData_; - } - static std::string GetTitle() - { - return title_; - } + void CloseDialog(); + void OnAbilityConnectDone( + const AppExecFwk::ElementName& element, const sptr& remoteObject, int resultCode); + void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode); private: DmDialogManager(); ~DmDialogManager(); + void SendMsgRequest(const sptr& remoteObject); class DialogAbilityConnection : public OHOS::AAFwk::AbilityConnectionStub { public: void OnAbilityConnectDone( const AppExecFwk::ElementName& element, const sptr& remoteObject, int resultCode) override; void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) override; - - private: - std::mutex mutex_; }; - static std::string bundleName_; - static std::string abilityName_; - static std::string deviceName_; - static std::string targetDeviceName_; - static std::string appOperationStr_; - static std::string customDescriptionStr_; - static std::string pinCode_; - static std::string hostPkgLabel_; - static int32_t deviceType_; - static std::atomic isConnectSystemUI_; - static sptr dialogConnectionCallback_; - static DmDialogManager dialogMgr_; - static bool isProxyBind_; - static std::string appUserData_; - static std::string title_; + std::string bundleName_; + std::string abilityName_; + std::string deviceName_; + std::string targetDeviceName_; + std::string appOperationStr_; + std::string customDescriptionStr_; + std::string pinCode_; + std::string hostPkgLabel_; + int32_t deviceType_ = -1; + bool isProxyBind_ = false; + std::string appUserData_; + std::string title_; + std::mutex mutex_; + sptr dialogConnectionCallback_ = nullptr; + sptr g_remoteObject = nullptr; + std::atomic isConnectSystemUI_{false}; + std::atomic isCloseDialog_{false}; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/implementation/include/device_manager_service_impl.h b/services/implementation/include/device_manager_service_impl.h index 75b46dbad..60726df8f 100644 --- a/services/implementation/include/device_manager_service_impl.h +++ b/services/implementation/include/device_manager_service_impl.h @@ -227,12 +227,14 @@ private: void HandleRemoteUserRemoved(int32_t preUserId, const std::string &remoteUdid); DmAuthForm ConvertBindTypeToAuthForm(int32_t bindType); std::shared_ptr GetAuthMgr(); + int32_t AddAuthMgr(uint64_t tokenId, int sessionId, std::shared_ptr authMgr); + void EraseAuthMgr(uint64_t tokenId); std::shared_ptr GetAuthMgrByTokenId(uint64_t tokenId); std::shared_ptr GetCurrentAuthMgr(); void CreateGlobalClassicalAuthMgr(); std::shared_ptr GetCurSession(int sessionId); std::shared_ptr GetOrCreateSession(const std::string& deviceId, - const std::map &bindParam); + const std::map &bindParam, uint64_t tokenId); int32_t ParseConnectAddr(const PeerTargetId &targetId, std::string &deviceId, const std::map &bindParam); std::shared_ptr GetConfigByTokenId(); @@ -256,7 +258,8 @@ private: void ImportAuthCodeToConfig(std::shared_ptr authMgr, uint64_t tokenId); void CleanAuthMgrByLogicalSessionId(uint64_t logicalSessionId); - void CleanSessionMap(int sessionId, std::shared_ptr session); + void CleanSessionMap(std::shared_ptr session); + void CleanSessionMap(int sessionId); void CleanSessionMapByLogicalSessionId(uint64_t logicalSessionId); int32_t DeleteAclForProcV2(const std::string &localUdid, uint32_t localTokenId, const std::string &remoteUdid, int32_t bindLevel, const std::string &extra, int32_t userId); @@ -291,16 +294,17 @@ private: void SaveTokenIdAndSessionId(uint64_t &tokenId, int32_t &sessionId, uint64_t &logicalSessionId); void ReleaseMaps(); int32_t InitNewProtocolAuthMgr(bool isSrcSide, uint64_t tokenId, uint64_t logicalSessionId, - const std::string &pkgName); - int32_t InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName); - bool ParseConnectAddrAndSetProcessInfo(const PeerTargetId &targetId, - PeerTargetId &targetIdTmp, const std::map &bindParam, ProcessInfo &processInfo, - const std::string &pkgName); + const std::string &pkgName, int sessionId); + int32_t InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName, int sessionId); + bool ParseConnectAddrAndSetProcessInfo(PeerTargetId &targetIdTmp, + const std::map &bindParam, ProcessInfo &processInfo, + const std::string &pkgName, uint64_t tokenId); void OnAuthResultAndOnBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, - const std::string &deviceId, int32_t reason); + const std::string &deviceId, int32_t reason, uint64_t tokenId); void GetBundleName(const DMAclQuadInfo &info, std::set &pkgNameSet); void DeleteSessionKey(int32_t userId, const DistributedDeviceProfile::AccessControlProfile &profile); private: + std::mutex authMgrMtx_; std::shared_ptr authMgr_; // Old protocol only bool isNeedJoinLnn_ = true; std::mutex isNeedJoinLnnMtx_; @@ -320,11 +324,12 @@ private: // The session ID corresponding to the device ID, used only on the src side std::map deviceId2SessionIdMap_; std::map> sessionsMap_; // sessionId corresponds to the session object - std::map deviceIdMutexMap_; // Lock corresponding to the device ID std::mutex mapMutex_; // sessionsMap_ lock std::map sessionEnableCvMap_; // Condition variable corresponding to the session std::map sessionEnableMutexMap_; // Lock corresponding to the session std::map sessionEnableCvReadyMap_; // Condition variable ready flag + std::map sessionStopMap_; // stop flag + std::map sessionEnableMap_; // enable flag std::mutex logicalSessionId2TokenIdMapMtx_; std::map logicalSessionId2TokenIdMap_; // The relationship between logicalSessionId and tokenId std::mutex logicalSessionId2SessionIdMapMtx_; @@ -333,6 +338,8 @@ private: std::map> configsMap_; // Import when authMgr is not initialized std::mutex authMgrMapMtx_; std::map> authMgrMap_; // New protocol sharing + std::mutex tokenIdSessionIdMapMtx_; + std::map tokenIdSessionIdMap_; // New protocol sharing }; using CreateDMServiceFuncPtr = IDeviceManagerServiceImpl *(*)(void); diff --git a/services/implementation/src/ability/standard/dm_dialog_manager.cpp b/services/implementation/src/ability/standard/dm_dialog_manager.cpp index 71ae90d94..1f8d7d094 100644 --- a/services/implementation/src/ability/standard/dm_dialog_manager.cpp +++ b/services/implementation/src/ability/standard/dm_dialog_manager.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -32,34 +32,20 @@ namespace OHOS { namespace DistributedHardware { -static constexpr int32_t INVALID_USERID = -1; -static constexpr int32_t MESSAGE_PARCEL_KEY_SIZE = 3; -static constexpr int32_t WINDOW_LEVEL_UPPER = 2; -static constexpr int32_t WINDOW_LEVEL_DEFAULT = 1; +namespace { +constexpr int32_t INVALID_USERID = -1; +constexpr int32_t MESSAGE_PARCEL_KEY_SIZE = 3; +constexpr int32_t WINDOW_LEVEL_UPPER = 2; +constexpr int32_t WINDOW_LEVEL_DEFAULT = 1; constexpr const char* CONNECT_PIN_DIALOG = "pinDialog"; constexpr const char* DM_UI_BUNDLE_NAME = "com.ohos.devicemanagerui"; constexpr const char* CONFIRM_ABILITY_NAME = "com.ohos.devicemanagerui.ConfirmUIExtAbility"; constexpr const char* PIN_ABILITY_NAME = "com.ohos.devicemanagerui.PincodeUIExtAbility"; constexpr const char* INPUT_ABILITY_NAME = "com.ohos.devicemanagerui.InputUIExtAbility"; - -std::string DmDialogManager::bundleName_ = ""; -std::string DmDialogManager::abilityName_ = ""; -std::string DmDialogManager::deviceName_ = ""; -std::string DmDialogManager::appOperationStr_ = ""; -std::string DmDialogManager::customDescriptionStr_ = ""; -std::string DmDialogManager::targetDeviceName_ = ""; -std::string DmDialogManager::pinCode_ = ""; -std::string DmDialogManager::hostPkgLabel_ = ""; -int32_t DmDialogManager::deviceType_ = -1; -bool DmDialogManager::isProxyBind_ = false; -std::string DmDialogManager::appUserData_ = ""; -std::string DmDialogManager::title_ = ""; -DmDialogManager DmDialogManager::dialogMgr_; -sptr DmDialogManager::dialogConnectionCallback_( - new (std::nothrow) DialogAbilityConnection()); - -std::atomic DmDialogManager::isConnectSystemUI_(false); -sptr g_remoteObject = nullptr; +constexpr uint32_t CLOSE_DIALOG_CMD_CODE = 3; +constexpr uint32_t SHOW_DIALOG_CMD_CODE = 1; +} +DM_IMPLEMENT_SINGLE_INSTANCE(DmDialogManager); DmDialogManager::DmDialogManager() { @@ -71,11 +57,6 @@ DmDialogManager::~DmDialogManager() LOGI("DmDialogManager destructor"); } -DmDialogManager &DmDialogManager::GetInstance() -{ - return dialogMgr_; -} - void DmDialogManager::ShowConfirmDialog(const std::string param) { std::string deviceName = ""; @@ -83,54 +64,60 @@ void DmDialogManager::ShowConfirmDialog(const std::string param) std::string customDescriptionStr = ""; std::string hostPkgLabel = ""; int32_t deviceType = -1; - JsonObject jsonObject(param); - if (!jsonObject.IsDiscarded()) { - if (IsString(jsonObject, TAG_REQUESTER)) { - deviceName = jsonObject[TAG_REQUESTER].Get(); - } - if (IsString(jsonObject, TAG_APP_OPERATION)) { - appOperationStr = jsonObject[TAG_APP_OPERATION].Get(); - } - if (IsString(jsonObject, TAG_CUSTOM_DESCRIPTION)) { - customDescriptionStr = jsonObject[TAG_CUSTOM_DESCRIPTION].Get(); + { + std::unique_lock lock(mutex_); + JsonObject jsonObject(param); + if (!jsonObject.IsDiscarded()) { + if (IsString(jsonObject, TAG_REQUESTER)) { + deviceName = jsonObject[TAG_REQUESTER].Get(); + } + if (IsString(jsonObject, TAG_APP_OPERATION)) { + appOperationStr = jsonObject[TAG_APP_OPERATION].Get(); + } + if (IsString(jsonObject, TAG_CUSTOM_DESCRIPTION)) { + customDescriptionStr = jsonObject[TAG_CUSTOM_DESCRIPTION].Get(); + } + if (IsInt32(jsonObject, TAG_LOCAL_DEVICE_TYPE)) { + deviceType = jsonObject[TAG_LOCAL_DEVICE_TYPE].Get(); + } + if (IsString(jsonObject, TAG_HOST_PKGLABEL)) { + hostPkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get(); + } + if (IsBool(jsonObject, PARAM_KEY_IS_PROXY_BIND)) { + isProxyBind_ = jsonObject[PARAM_KEY_IS_PROXY_BIND].Get(); + } + if (IsString(jsonObject, APP_USER_DATA)) { + appUserData_ = jsonObject[APP_USER_DATA].Get(); + } + if (IsString(jsonObject, TITLE)) { + title_ = jsonObject[TITLE].Get(); + } } - if (IsInt32(jsonObject, TAG_LOCAL_DEVICE_TYPE)) { - deviceType = jsonObject[TAG_LOCAL_DEVICE_TYPE].Get(); - } - if (IsString(jsonObject, TAG_HOST_PKGLABEL)) { - hostPkgLabel = jsonObject[TAG_HOST_PKGLABEL].Get(); - } - if (IsBool(jsonObject, PARAM_KEY_IS_PROXY_BIND)) { - isProxyBind_ = jsonObject[PARAM_KEY_IS_PROXY_BIND].Get(); - } - if (IsString(jsonObject, APP_USER_DATA)) { - appUserData_ = jsonObject[APP_USER_DATA].Get(); - } - if (IsString(jsonObject, TITLE)) { - title_ = jsonObject[TITLE].Get(); - } - } - bundleName_ = DM_UI_BUNDLE_NAME; - abilityName_ = CONFIRM_ABILITY_NAME; - deviceName_ = deviceName; - appOperationStr_ = appOperationStr; - customDescriptionStr_ = customDescriptionStr; - deviceType_ = deviceType; - hostPkgLabel_ = hostPkgLabel; + bundleName_ = DM_UI_BUNDLE_NAME; + abilityName_ = CONFIRM_ABILITY_NAME; + deviceName_ = deviceName; + appOperationStr_ = appOperationStr; + customDescriptionStr_ = customDescriptionStr; + deviceType_ = deviceType; + hostPkgLabel_ = hostPkgLabel; + } ConnectExtension(); } void DmDialogManager::ShowPinDialog(const std::string param) { LOGI("pinCode: %{public}s", GetAnonyString(param).c_str()); - bundleName_ = DM_UI_BUNDLE_NAME; - abilityName_ = PIN_ABILITY_NAME; - pinCode_ = param; + { + std::lock_guard lock(mutex_); + bundleName_ = DM_UI_BUNDLE_NAME; + abilityName_ = PIN_ABILITY_NAME; + pinCode_ = param; + } #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) - ffrt::submit([]() { ConnectExtension(); }); + ffrt::submit([]() { DmDialogManager::GetInstance().ConnectExtension(); }); #else - std::thread pinDilog([]() { ConnectExtension(); }); + std::thread pinDilog([]() { DmDialogManager::GetInstance().ConnectExtension(); }); int32_t ret = pthread_setname_np(pinDilog.native_handle(), CONNECT_PIN_DIALOG.c_str()); if (ret != DM_OK) { LOGE("pinDilog setname failed."); @@ -141,18 +128,41 @@ void DmDialogManager::ShowPinDialog(const std::string param) void DmDialogManager::ShowInputDialog(const std::string param) { - targetDeviceName_ = param; - bundleName_ = DM_UI_BUNDLE_NAME; - abilityName_ = INPUT_ABILITY_NAME; + { + std::lock_guard lock(mutex_); + targetDeviceName_ = param; + bundleName_ = DM_UI_BUNDLE_NAME; + abilityName_ = INPUT_ABILITY_NAME; + } ConnectExtension(); } +void DmDialogManager::CloseDialog() +{ + LOGI("In"); + std::unique_lock lock(mutex_); + if (g_remoteObject == nullptr) { + LOGW("g_remoteObject is nullptr"); + isCloseDialog_.store(true); + return; + } + MessageParcel data; + MessageParcel reply; + MessageOption option; + int32_t ret = g_remoteObject->SendRequest(CLOSE_DIALOG_CMD_CODE, data, reply, option); + if (ret != ERR_OK) { + LOGE("close dm dialog is failed: %{public}d", ret); + return; + } +} + void DmDialogManager::ConnectExtension() { LOGI("DmDialogManager::ConnectExtension start."); + isCloseDialog_.store(false); if (isConnectSystemUI_.load() && dialogConnectionCallback_ != nullptr && g_remoteObject != nullptr) { AppExecFwk::ElementName element; - dialogConnectionCallback_->OnAbilityConnectDone(element, g_remoteObject, INVALID_USERID); + OnAbilityConnectDone(element, g_remoteObject, INVALID_USERID); LOGI("DmDialogManager::ConnectExtension dialog has been show."); return; } @@ -166,6 +176,14 @@ void DmDialogManager::ConnectExtension() return; } + std::lock_guard lock(mutex_); + if (dialogConnectionCallback_ == nullptr) { + dialogConnectionCallback_ = new (std::nothrow) DialogAbilityConnection(); + } + if (dialogConnectionCallback_ == nullptr) { + LOGE("create dialogConnectionCallback_ failed."); + return; + } LOGI("DmDialogManager::ConnectExtension abilityManager ConnectAbility begin."); auto ret = abilityManager->ConnectAbility(want, dialogConnectionCallback_, INVALID_USERID); if (ret != ERR_OK) { @@ -175,12 +193,12 @@ void DmDialogManager::ConnectExtension() want.SetElementName(bundleName, abilityName); ret = abilityManager->ConnectAbility(want, dialogConnectionCallback_, INVALID_USERID); if (ret != ERR_OK) { - LOGE("ConnectExtensionAbility systemui failed."); + LOGE("ConnectExtensionAbility systemui failed again."); } } } -void DmDialogManager::DialogAbilityConnection::OnAbilityConnectDone( +void DmDialogManager::OnAbilityConnectDone( const AppExecFwk::ElementName& element, const sptr& remoteObject, int resultCode) { LOGI("OnAbilityConnectDone"); @@ -192,54 +210,75 @@ void DmDialogManager::DialogAbilityConnection::OnAbilityConnectDone( if (g_remoteObject == nullptr) { g_remoteObject = remoteObject; } + isConnectSystemUI_.store(true); + if (isCloseDialog_.load()) { + LOGW("isCloseDialog_ is true"); + isCloseDialog_.store(false); + return; + } + SendMsgRequest(remoteObject); +} + +void DmDialogManager::SendMsgRequest(const sptr& remoteObject) +{ MessageParcel data; MessageParcel reply; MessageOption option; data.WriteInt32(MESSAGE_PARCEL_KEY_SIZE); data.WriteString16(u"bundleName"); - data.WriteString16(Str8ToStr16(DmDialogManager::GetBundleName())); + data.WriteString16(Str8ToStr16(bundleName_)); data.WriteString16(u"abilityName"); - data.WriteString16(Str8ToStr16(DmDialogManager::GetAbilityName())); + data.WriteString16(Str8ToStr16(abilityName_)); data.WriteString16(u"parameters"); JsonObject param; param["ability.want.params.uiExtensionType"] = "sysDialog/common"; param["sysDialogZOrder"] = WINDOW_LEVEL_DEFAULT; - if (DmDialogManager::GetAbilityName() == INPUT_ABILITY_NAME) { + if (abilityName_ == INPUT_ABILITY_NAME) { param["sysDialogZOrder"] = WINDOW_LEVEL_UPPER; } - std::string pinCodeHash = GetAnonyString(Crypto::Sha256(DmDialogManager::GetPinCode())); + std::string pinCodeHash = GetAnonyString(Crypto::Sha256(pinCode_)); LOGI("OnAbilityConnectDone pinCodeHash: %{public}s", pinCodeHash.c_str()); - param["isProxyBind"] = DmDialogManager::GetIsProxyBind(); - param["appUserData"] = DmDialogManager::GetAppUserData(); - param["title"] = DmDialogManager::GetTitle(); - param["pinCode"] = DmDialogManager::GetPinCode(); - param["deviceName"] = DmDialogManager::GetDeviceName(); - param["appOperationStr"] = DmDialogManager::GetAppOperationStr(); - param["customDescriptionStr"] = DmDialogManager::GetCustomDescriptionStr(); - param["deviceType"] = DmDialogManager::GetDeviceType(); - param[TAG_TARGET_DEVICE_NAME] = DmDialogManager::GetTargetDeviceName(); - param[TAG_HOST_PKGLABEL] = DmDialogManager::GetHostPkgLabel(); + param["isProxyBind"] = isProxyBind_; + param["appUserData"] = appUserData_; + param["title"] = title_; + param["pinCode"] = pinCode_; + param["deviceName"] = deviceName_; + param["appOperationStr"] = appOperationStr_; + param["customDescriptionStr"] = customDescriptionStr_; + param["deviceType"] = deviceType_; + param[TAG_TARGET_DEVICE_NAME] = targetDeviceName_; + param[TAG_HOST_PKGLABEL] = hostPkgLabel_; param["disableUpGesture"] = 1; std::string paramStr = param.Dump(); data.WriteString16(Str8ToStr16(paramStr)); LOGI("show dm dialog is begin"); - const uint32_t cmdCode = 1; - int32_t ret = remoteObject->SendRequest(cmdCode, data, reply, option); + int32_t ret = remoteObject->SendRequest(SHOW_DIALOG_CMD_CODE, data, reply, option); if (ret != ERR_OK) { LOGE("show dm dialog is failed: %{public}d", ret); return; } - isConnectSystemUI_.store(true); LOGI("show dm dialog is success"); } -void DmDialogManager::DialogAbilityConnection::OnAbilityDisconnectDone( - const AppExecFwk::ElementName& element, int resultCode) +void DmDialogManager::OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) { LOGI("OnAbilityDisconnectDone"); std::lock_guard lock(mutex_); g_remoteObject = nullptr; isConnectSystemUI_.store(false); + isCloseDialog_.store(false); +} + +void DmDialogManager::DialogAbilityConnection::OnAbilityConnectDone( + const AppExecFwk::ElementName& element, const sptr& remoteObject, int resultCode) +{ + DmDialogManager::GetInstance().OnAbilityConnectDone(element, remoteObject, resultCode); +} + +void DmDialogManager::DialogAbilityConnection::OnAbilityDisconnectDone( + const AppExecFwk::ElementName& element, int resultCode) +{ + DmDialogManager::GetInstance().OnAbilityDisconnectDone(element, resultCode); } } } \ No newline at end of file diff --git a/services/implementation/src/authentication/auth_ui_state_manager.cpp b/services/implementation/src/authentication/auth_ui_state_manager.cpp index df081c5a3..f23423794 100644 --- a/services/implementation/src/authentication/auth_ui_state_manager.cpp +++ b/services/implementation/src/authentication/auth_ui_state_manager.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -15,6 +15,7 @@ #include "auth_ui_state_manager.h" #include "dm_anonymous.h" +#include "dm_dialog_manager.h" #include "dm_log.h" #include "json_object.h" #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) @@ -64,6 +65,15 @@ void AuthUiStateManager::UpdateUiState(const DmUiStateMsg msg) jsonObj[UI_STATE_MSG] = msg; std::string paramJson = jsonObj.Dump(); std::lock_guard lock(pkgSetMutex_); + if (pkgSet_.empty()) { + LOGW("pkgSet_ is empty"); + if (msg == MSG_CANCEL_CONFIRM_SHOW) { + LOGW("cancel confirm dialog"); + DmDialogManager::GetInstance().CloseDialog(); + return; + } + return; + } for (auto item : pkgSet_) { listener_->OnUiCall(item, paramJson); } diff --git a/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp b/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp index 28ed7e71f..c5fe661fd 100644 --- a/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp +++ b/services/implementation/src/authentication_v2/auth_stages/auth_confirm.cpp @@ -650,7 +650,7 @@ void AuthSrcConfirmState::GenerateCertificate(std::shared_ptr con int32_t AuthSrcConfirmState::Action(std::shared_ptr context) { - LOGI("start."); + LOGI("AuthSrcConfirmState start."); CHECK_NULL_RETURN(context, ERR_DM_POINT_NULL); context->timer->DeleteTimer(std::string(NEGOTIATE_TIMEOUT_TASK)); ResetBindLevel(context); diff --git a/services/implementation/src/device_manager_service_impl.cpp b/services/implementation/src/device_manager_service_impl.cpp index ec8fc1518..51a976963 100644 --- a/services/implementation/src/device_manager_service_impl.cpp +++ b/services/implementation/src/device_manager_service_impl.cpp @@ -74,7 +74,11 @@ constexpr const char* NO_NEED_JOIN_LNN = "1"; // currently, we just support one bind session in one device at same time constexpr size_t MAX_NEW_PROC_SESSION_COUNT_TEMP = 1; const int32_t USLEEP_TIME_US_500000 = 500000; // 500ms +const int32_t USLEEP_TIME_US_550000 = 550000; // 550ms +const int32_t USLEEP_TIME_US_20000 = 20000; // 20ms const int32_t OPEN_AUTH_SESSION_TIMEOUT = 15000; // 15000ms +const int32_t MAX_TRY_STOP_CNT = 5; +const int32_t DEFAULT_SESSION_ID = -1; const std::map BUNDLENAME_MAPPING = { { "wear_link_service", "watch_system_service" } @@ -160,7 +164,7 @@ static uint64_t GetTokenId(bool isSrcSide, int32_t displayId, std::string &bundl } else { // sink end int64_t tmpTokenId; - // get userId + // get userId int32_t targetUserId = AuthManagerBase::DmGetUserId(displayId); if (targetUserId == -1) { return tokenId; @@ -234,7 +238,7 @@ void DeviceManagerServiceImpl::ImportAuthCodeToConfig(std::shared_ptrRegisterHiChainAuthCallbackById(logicalSessionId, authMgr); LOGI("Initialize authMgr token: %{public}" PRId64 ".", tokenId); ImportConfig(authMgr, tokenId, pkgName); - { - std::lock_guard lock(authMgrMapMtx_); - authMgrMap_[tokenId] = authMgr; - } - return DM_OK; + return AddAuthMgr(tokenId, sessionId, authMgr); } -int32_t DeviceManagerServiceImpl::InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName) +int32_t DeviceManagerServiceImpl::InitOldProtocolAuthMgr(uint64_t tokenId, const std::string &pkgName, int sessionId) { LOGI("tokenId: %{public}" PRIu64 ", pkgname:%{public}s", tokenId, pkgName.c_str()); - if (authMgr_ == nullptr) { - CreateGlobalClassicalAuthMgr(); - } - authMgr_->PrepareSoftbusSessionCallback(); { - std::lock_guard lock(authMgrMapMtx_); - authMgrMap_[tokenId] = authMgr_; + std::lock_guard lock(authMgrMtx_); + if (authMgr_ == nullptr) { + CreateGlobalClassicalAuthMgr(); + } + authMgr_->PrepareSoftbusSessionCallback(); + ImportConfig(authMgr_, tokenId, pkgName); + int32_t ret = AddAuthMgr(tokenId, sessionId, authMgr_); + if (ret != DM_OK) { + return ret; + } } - ImportConfig(authMgr_, tokenId, pkgName); { // The value of logicalSessionId in the old protocol is always 0. std::lock_guard tokenIdLock(logicalSessionId2TokenIdMapMtx_); @@ -304,30 +307,20 @@ int32_t DeviceManagerServiceImpl::InitAndRegisterAuthMgr(bool isSrcSide, uint64_ return ERR_DM_AUTH_BUSINESS_BUSY; } } - { - std::lock_guard lock(authMgrMapMtx_); - if (authMgrMap_.find(tokenId) != authMgrMap_.end()) { - // authMgr_ has been created, indicating that a binding event already exists. - // Other requests are rejected, and an error code is returned. - LOGE("BindTarget failed, this device is being bound. Please try again later."); - return ERR_DM_AUTH_BUSINESS_BUSY; - } - if (authMgrMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) { - LOGE("Other bind session exist, can not start new one."); - return ERR_DM_AUTH_BUSINESS_BUSY; - } - } if (session->version_ == "" || CompareVersion(session->version_, DM_VERSION_5_0_OLD_MAX)) { - return InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName); + return InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, session->sessionId_); } LOGI("InitAndRegisterAuthMgr old authMgr."); - return InitOldProtocolAuthMgr(tokenId, pkgName); + return InitOldProtocolAuthMgr(tokenId, pkgName, session->sessionId_); } -void DeviceManagerServiceImpl::CleanSessionMap(int sessionId, std::shared_ptr session) +void DeviceManagerServiceImpl::CleanSessionMap(std::shared_ptr session) { + if (session == nullptr) { + return; + } session->logicalSessionCnt_.fetch_sub(1); - if (session->logicalSessionCnt_.load(std::memory_order_relaxed) == 0) { + if (session->logicalSessionCnt_.load(std::memory_order_relaxed) <= 0) { { std::lock_guard lock(isNeedJoinLnnMtx_); if (isNeedJoinLnn_) { @@ -335,18 +328,33 @@ void DeviceManagerServiceImpl::CleanSessionMap(int sessionId, std::shared_ptrsessionId_); + } +} + +void DeviceManagerServiceImpl::CleanSessionMap(int sessionId) +{ + LOGI("In sessionId:%{public}d.", sessionId); + if (softbusConnector_ != nullptr) { softbusConnector_->GetSoftbusSession()->CloseAuthSession(sessionId); + } + { std::lock_guard lock(mapMutex_); + std::shared_ptr session = nullptr; if (sessionsMap_.find(sessionId) != sessionsMap_.end()) { - sessionsMap_[sessionId] = nullptr; + session = sessionsMap_[sessionId]; sessionsMap_.erase(sessionId); } - if (deviceId2SessionIdMap_.find(session->deviceId_) != deviceId2SessionIdMap_.end()) { + if (session != nullptr && deviceId2SessionIdMap_.find(session->deviceId_) != deviceId2SessionIdMap_.end()) { deviceId2SessionIdMap_.erase(session->deviceId_); } + if (sessionEnableMutexMap_.find(sessionId) != sessionEnableMutexMap_.end()) { + sessionStopMap_.erase(sessionId); + sessionEnableMap_.erase(sessionId); + sessionEnableCvReadyMap_.erase(sessionId); + sessionEnableMutexMap_.erase(sessionId); + } } - return; } void DeviceManagerServiceImpl::CleanSessionMapByLogicalSessionId(uint64_t logicalSessionId) @@ -366,7 +374,7 @@ void DeviceManagerServiceImpl::CleanSessionMapByLogicalSessionId(uint64_t logica } auto session = GetCurSession(sessionId); if (session != nullptr) { - CleanSessionMap(sessionId, session); + CleanSessionMap(session); } return; } @@ -390,28 +398,60 @@ void DeviceManagerServiceImpl::CleanAuthMgrByLogicalSessionId(uint64_t logicalSe authMgr_->ClearSoftbusSessionCallback(); } hiChainAuthConnector_->UnRegisterHiChainAuthCallbackById(logicalSessionId); + EraseAuthMgr(tokenId); + return; +} + +std::shared_ptr DeviceManagerServiceImpl::GetAuthMgr() +{ + uint64_t tokenId = IPCSkeleton::GetCallingTokenID(); + return GetAuthMgrByTokenId(tokenId); +} + +int32_t DeviceManagerServiceImpl::AddAuthMgr(uint64_t tokenId, int sessionId, std::shared_ptr authMgr) +{ + if (authMgr == nullptr) { + LOGE("authMgr is nullptr."); + return ERR_DM_POINT_NULL; + } + { + std::lock_guard mapLock(mapMutex_); + if (sessionEnableMap_.find(sessionId) != sessionEnableMap_.end() && !sessionEnableMap_[sessionId]) { + LOGE("session is not open, no need add authMgr."); + return ERR_DM_AUTH_OPEN_SESSION_FAILED; + } + } { std::lock_guard lock(authMgrMapMtx_); - if (authMgrMap_.find(tokenId) != authMgrMap_.end()) { - authMgrMap_[tokenId] = nullptr; - authMgrMap_.erase(tokenId); + if (authMgrMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) { + LOGE("Other bind session exist, can not start new one. authMgrMap_.size:%{public}zu", authMgrMap_.size()); + return ERR_DM_AUTH_BUSINESS_BUSY; } + authMgrMap_[tokenId] = authMgr; } - return; + { + std::lock_guard mapLock(tokenIdSessionIdMapMtx_); + if (tokenIdSessionIdMap_.find(tokenId) == tokenIdSessionIdMap_.end()) { + tokenIdSessionIdMap_[tokenId] = sessionId; + } + } + return DM_OK; } -std::shared_ptr DeviceManagerServiceImpl::GetAuthMgr() +void DeviceManagerServiceImpl::EraseAuthMgr(uint64_t tokenId) { - uint64_t tokenId = IPCSkeleton::GetCallingTokenID(); { std::lock_guard lock(authMgrMapMtx_); if (authMgrMap_.find(tokenId) != authMgrMap_.end()) { - LOGI("authMgrMap_ token: %{public}" PRId64 ".", tokenId); - return authMgrMap_[tokenId]; + LOGI("authMgrMap_ erase token: %{public}" PRIu64 ".", tokenId); + authMgrMap_.erase(tokenId); } } - LOGE("authMgrMap_ not found, token: %{public}" PRId64 ".", tokenId); - return nullptr; + { + std::lock_guard lock(tokenIdSessionIdMapMtx_); + LOGI("tokenIdSessionIdMap_ erase token: %{public}" PRIu64 ".", tokenId); + tokenIdSessionIdMap_.erase(tokenId); + } } // Needed in the callback function @@ -420,11 +460,11 @@ std::shared_ptr DeviceManagerServiceImpl::GetAuthMgrByTokenId(u { std::lock_guard lock(authMgrMapMtx_); if (authMgrMap_.find(tokenId) != authMgrMap_.end()) { - LOGI("authMgrMap_ token: %{public}" PRId64 ".", tokenId); + LOGI("authMgrMap_ token: %{public}" PRIu64 ".", tokenId); return authMgrMap_[tokenId]; } } - LOGE("authMgrMap_ not found, token: %{public}" PRId64 ".", tokenId); + LOGE("authMgrMap_ not found, token: %{public}" PRIu64 ".", tokenId); return nullptr; } @@ -525,9 +565,11 @@ void DeviceManagerServiceImpl::ReleaseMaps() configsMap_.clear(); } deviceId2SessionIdMap_.clear(); - deviceIdMutexMap_.clear(); sessionEnableMutexMap_.clear(); sessionEnableCvMap_.clear(); + sessionStopMap_.clear(); + sessionEnableMap_.clear(); + sessionEnableCvReadyMap_.clear(); { std::lock_guard tokenIdLock(logicalSessionId2TokenIdMapMtx_); logicalSessionId2TokenIdMap_.clear(); @@ -593,12 +635,50 @@ int32_t DeviceManagerServiceImpl::StopAuthenticateDevice(const std::string &pkgN LOGE("DeviceManagerServiceImpl::StopAuthenticateDevice failed"); return ERR_DM_INPUT_PARA_INVALID; } - auto authMgr = GetAuthMgr(); - if (authMgr == nullptr) { - LOGE("authMgr is nullptr"); - return ERR_DM_POINT_NULL; + uint64_t tokenId = IPCSkeleton::GetCallingTokenID(); + int32_t sessionId = DEFAULT_SESSION_ID; + int32_t tryCnt = 0; + while (tryCnt < MAX_TRY_STOP_CNT) { + { + std::lock_guard lock(tokenIdSessionIdMapMtx_); + if (tokenIdSessionIdMap_.find(tokenId) == tokenIdSessionIdMap_.end()) { + LOGI("sessionId not create, pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId); + return DM_OK; + } + sessionId = tokenIdSessionIdMap_[tokenId]; + } + if (sessionId > 0) { + break; + } + usleep(USLEEP_TIME_US_20000); + tryCnt++; + } + if (sessionId == DEFAULT_SESSION_ID) { + LOGE("sessionId is creating, pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId); + return ERR_DM_AUTH_BUSINESS_BUSY; + } + LOGI("pkgName:%{public}s, sessionId:%{public}d, tokenId:%{public}" PRIu64, pkgName.c_str(), sessionId, tokenId); + if (sessionEnableCvMap_.find(sessionId) != sessionEnableCvMap_.end()) { + std::unique_lock cvLock(sessionEnableMutexMap_[sessionId]); + if (sessionEnableMap_.find(sessionId) != sessionEnableMap_.end() && !sessionEnableMap_[sessionId]) { + sessionStopMap_[sessionId] = true; + } + sessionEnableCvReadyMap_[sessionId] = true; + sessionEnableCvMap_[sessionId].notify_all(); + LOGI("notify_all by stop, sessionId:%{public}d, tokenId:%{public}" PRIu64, sessionId, tokenId); + } + auto authMgr = GetAuthMgrByTokenId(tokenId); + int32_t ret = DM_OK; + if (authMgr != nullptr) { + ret = authMgr->StopAuthenticateDevice(pkgName); + if (ret == DM_OK) { + usleep(USLEEP_TIME_US_550000); + } + } else { + CleanSessionMap(sessionId); } - return authMgr->StopAuthenticateDevice(pkgName); + EraseAuthMgr(tokenId); + return ret; } int32_t DeviceManagerServiceImpl::UnBindDevice(const std::string &pkgName, const std::string &udid, @@ -839,10 +919,16 @@ std::string DeviceManagerServiceImpl::GetUdidHashByNetworkId(const std::string & int DeviceManagerServiceImpl::OnSessionOpened(int sessionId, int result) { - { + bool isNeedCloseSession = false; + if (sessionEnableCvMap_.find(sessionId) != sessionEnableCvMap_.end()) { std::lock_guard lock(sessionEnableMutexMap_[sessionId]); if (result == 0) { - LOGE("OnSessionOpened successful, sessionId: %{public}d", sessionId); + LOGI("OnSessionOpened successful, sessionId: %{public}d", sessionId); + if (sessionStopMap_.find(sessionId) != sessionStopMap_.end() && sessionStopMap_[sessionId]) { + isNeedCloseSession = true; + } else { + sessionEnableMap_[sessionId] = true; + } } else { LOGE("OnSessionOpened failed, sessionId: %{public}d, res: %{public}d", sessionId, result); } @@ -861,7 +947,10 @@ int DeviceManagerServiceImpl::OnSessionOpened(int sessionId, int result) if (!DmRadarHelper::GetInstance().ReportAuthSessionOpenCb(info)) { LOGE("ReportAuthSessionOpenCb failed"); } - + if (isNeedCloseSession) { + CleanSessionMap(sessionId); + return DM_OK; + } // Get the remote deviceId, sink end gives sessionsMap[deviceId] = session; { std::lock_guard lock(mapMutex_); @@ -991,10 +1080,7 @@ int32_t DeviceManagerServiceImpl::TransferSrcOldAuthMgr(std::shared_ptr int32_t authType = -1; authMgr->ParseAuthType(bindParam, authType); ImportAuthCodeToConfig(authMgr, tokenId); - { - std::lock_guard lock(authMgrMapMtx_); - authMgrMap_.erase(tokenId); - } + EraseAuthMgr(tokenId); if (InitAndRegisterAuthMgr(true, tokenId, curSession, logicalSessionId, "") != DM_OK) { return ERR_DM_AUTH_FAILED; } @@ -1544,56 +1630,54 @@ int DeviceManagerServiceImpl::OpenAuthSession(const std::string& deviceId, } std::shared_ptr DeviceManagerServiceImpl::GetOrCreateSession(const std::string& deviceId, - const std::map &bindParam) + const std::map &bindParam, uint64_t tokenId) { std::shared_ptr instance; int sessionId = -1; - // Acquire global lock to ensure thread safety for maps - { - std::lock_guard lock(mapMutex_); - if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) { - sessionId = deviceId2SessionIdMap_[deviceId]; - } - if (sessionsMap_.find(sessionId) != sessionsMap_.end()) { - return sessionsMap_[sessionId]; - } - } - - // Get the lock corresponding to deviceId - std::mutex& device_mutex = deviceIdMutexMap_[deviceId]; - std::lock_guard lock(device_mutex); // Check again whether the corresponding object already exists (because other threads may have created it during // the lock acquisition in the previous step) - { - std::lock_guard lock(mapMutex_); - if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) { - sessionId = deviceId2SessionIdMap_[deviceId]; - } - if (sessionsMap_.find(sessionId) != sessionsMap_.end()) { - return sessionsMap_[sessionId]; - } - sessionId = OpenAuthSession(deviceId, bindParam); - if (sessionId < 0) { - LOGE("OpenAuthSession failed, stop the authentication"); - return nullptr; - } + std::lock_guard lock(mapMutex_); + if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) { + sessionId = deviceId2SessionIdMap_[deviceId]; + } + if (sessionsMap_.find(sessionId) != sessionsMap_.end()) { + return sessionsMap_[sessionId]; + } - std::unique_lock cvLock(sessionEnableMutexMap_[sessionId]); - sessionEnableCvReadyMap_[sessionId] = false; - if (sessionEnableCvMap_[sessionId].wait_for(cvLock, std::chrono::milliseconds(OPEN_AUTH_SESSION_TIMEOUT), - [&] { return sessionEnableCvReadyMap_[sessionId]; })) { - LOGI("session enable, sessionId: %{public}d.", sessionId); - } else { - LOGE("wait session enable timeout or enable fail, sessionId: %{public}d.", sessionId); - return nullptr; - } - sessionEnableCvReadyMap_.erase(sessionId); - instance = std::make_shared(sessionId, deviceId); - deviceId2SessionIdMap_[deviceId] = sessionId; - sessionsMap_[sessionId] = instance; + sessionId = OpenAuthSession(deviceId, bindParam); + if (sessionId < 0) { + LOGE("OpenAuthSession failed, stop the authentication"); + return nullptr; } + + { + std::lock_guard lock(tokenIdSessionIdMapMtx_); + tokenIdSessionIdMap_[tokenId] = sessionId; + } + + std::unique_lock cvLock(sessionEnableMutexMap_[sessionId]); + sessionEnableCvReadyMap_[sessionId] = false; + sessionStopMap_[sessionId] = false; + sessionEnableMap_[sessionId] = false; + if (!sessionEnableCvMap_[sessionId].wait_for(cvLock, std::chrono::milliseconds(OPEN_AUTH_SESSION_TIMEOUT), + [&] { return sessionEnableCvReadyMap_[sessionId]; })) { + LOGE("wait session enable timeout or enable fail, sessionId: %{public}d.", sessionId); + return nullptr; + } + if (sessionStopMap_.find(sessionId) != sessionStopMap_.end() && sessionStopMap_[sessionId]) { + LOGW("stop by caller, sessionId: %{public}d.", sessionId); + return nullptr; + } + if (sessionEnableMap_.find(sessionId) != sessionEnableMap_.end() && !sessionEnableMap_[sessionId]) { + LOGW("Open session failed, sessionId: %{public}d.", sessionId); + return nullptr; + } + instance = std::make_shared(sessionId, deviceId); + deviceId2SessionIdMap_[deviceId] = sessionId; + sessionsMap_[sessionId] = instance; + return instance; } @@ -1714,9 +1798,9 @@ void DeviceManagerServiceImpl::SaveTokenIdAndSessionId(uint64_t &tokenId, } } -bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(const PeerTargetId &targetId, - PeerTargetId &targetIdTmp, const std::map &bindParam, ProcessInfo &processInfo, - const std::string &pkgName) +bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(PeerTargetId &targetId, + const std::map &bindParam, ProcessInfo &processInfo, + const std::string &pkgName, uint64_t tokenId) { processInfo.pkgName = pkgName; if (bindParam.count(BIND_CALLER_USERID) != 0) { @@ -1724,11 +1808,11 @@ bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(const PeerTarge } std::string deviceId = ""; if (ParseConnectAddr(targetId, deviceId, bindParam) == DM_OK) { - targetIdTmp.deviceId = deviceId; + targetId.deviceId = deviceId; } else { if (targetId.deviceId.empty()) { LOGE("DeviceManagerServiceImpl::BindTarget failed, ParseConnectAddr failed."); - OnAuthResultAndOnBindResult(processInfo, targetId, targetId.deviceId, ERR_DM_INPUT_PARA_INVALID); + OnAuthResultAndOnBindResult(processInfo, targetId, "", ERR_DM_INPUT_PARA_INVALID, tokenId); return false; } } @@ -1736,8 +1820,15 @@ bool DeviceManagerServiceImpl::ParseConnectAddrAndSetProcessInfo(const PeerTarge } void DeviceManagerServiceImpl::OnAuthResultAndOnBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, - const std::string &deviceId, int32_t reason) + const std::string &deviceId, int32_t reason, uint64_t tokenId) { + { + std::lock_guard lock(tokenIdSessionIdMapMtx_); + auto iter = tokenIdSessionIdMap_.find(tokenId); + if (iter != tokenIdSessionIdMap_.end()) { + tokenIdSessionIdMap_.erase(iter); + } + } CHECK_NULL_VOID(listener_); listener_->OnAuthResult(processInfo, deviceId, "", DmAuthStatus::STATUS_DM_AUTH_DEFAULT, reason); listener_->OnBindResult(processInfo, targetId, reason, DmAuthStatus::STATUS_DM_AUTH_DEFAULT, ""); @@ -1748,15 +1839,14 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin { PeerTargetId targetIdTmp = const_cast(targetId); ProcessInfo processInfo; - if (!ParseConnectAddrAndSetProcessInfo(targetId, targetIdTmp, bindParam, processInfo, pkgName)) { + if (!ParseConnectAddrAndSetProcessInfo(targetIdTmp, bindParam, processInfo, pkgName, tokenId)) { return; } // Created only at the source end. The same target device will not be created repeatedly with the new protocol. - std::shared_ptr curSession = GetOrCreateSession(targetIdTmp.deviceId, bindParam); + std::shared_ptr curSession = GetOrCreateSession(targetIdTmp.deviceId, bindParam, tokenId); if (curSession == nullptr) { - LOGE("Failed to create the session. Target deviceId: %{public}s.", - GetAnonyString(targetIdTmp.deviceId).c_str()); - OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_TIME_OUT); + LOGE("create session failed. Target deviceId: %{public}s.", GetAnonyString(targetIdTmp.deviceId).c_str()); + OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_TIME_OUT, tokenId); return; } @@ -1767,8 +1857,9 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin logicalSessionId = GenerateRandNum(sessionId); if (curSession->logicalSessionSet_.find(logicalSessionId) != curSession->logicalSessionSet_.end()) { LOGE("Failed to create the logical session."); - softbusConnector_->GetSoftbusSession()->CloseAuthSession(sessionId); - OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_INPUT_PARA_INVALID); + CleanSessionMap(sessionId); + OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, + ERR_DM_INPUT_PARA_INVALID, tokenId); return; } } @@ -1777,8 +1868,8 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin int32_t ret = InitAndRegisterAuthMgr(true, tokenId, curSession, logicalSessionId, ""); if (ret != DM_OK) { LOGE("InitAndRegisterAuthMgr failed, ret %{public}d.", ret); - softbusConnector_->GetSoftbusSession()->CloseAuthSession(sessionId); - OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret); + CleanSessionMap(sessionId); + OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret, tokenId); return; } curSession->logicalSessionSet_.insert(logicalSessionId); @@ -1787,16 +1878,16 @@ void DeviceManagerServiceImpl::BindTargetImpl(uint64_t tokenId, const std::strin auto authMgr = GetAuthMgrByTokenId(tokenId); if (authMgr == nullptr) { CleanAuthMgrByLogicalSessionId(logicalSessionId); - OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_POINT_NULL); + OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ERR_DM_POINT_NULL, tokenId); return; } authMgr->SetBindTargetParams(targetId); if ((ret = authMgr->BindTarget(pkgName, targetIdTmp, bindParam, sessionId, logicalSessionId)) != DM_OK) { LOGE("authMgr BindTarget failed, ret %{public}d.", ret); CleanAuthMgrByLogicalSessionId(logicalSessionId); - OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret); + OnAuthResultAndOnBindResult(processInfo, targetId, targetIdTmp.deviceId, ret, tokenId); } - LOGI("end, tokenId %{public}" PRId64".", tokenId); + LOGI("end, tokenId %{public}" PRIu64".", tokenId); return; } @@ -1812,12 +1903,19 @@ int32_t DeviceManagerServiceImpl::BindTarget(const std::string &pkgName, const P std::map bindParamTmp; SetBindCallerInfoToBindParam(bindParam, bindParamTmp, bindCallerInfo); uint64_t tokenId = IPCSkeleton::GetCallingTokenID(); + LOGI("DeviceManagerServiceImpl In, pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId); { - std::lock_guard lock(authMgrMapMtx_); - if (authMgrMap_.find(tokenId) != authMgrMap_.end()) { - LOGE("BindTarget failed, this device is being bound. please try again later."); + std::lock_guard lock(tokenIdSessionIdMapMtx_); + if (tokenIdSessionIdMap_.find(tokenId) != tokenIdSessionIdMap_.end()) { + LOGE("BindTarget failed, this device is being bound. please try again later," + "pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId); + return ERR_DM_AUTH_BUSINESS_BUSY; + } + if (tokenIdSessionIdMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) { + LOGE("Other bind exist, can not start new one. size:%{public}zu", tokenIdSessionIdMap_.size()); return ERR_DM_AUTH_BUSINESS_BUSY; } + tokenIdSessionIdMap_[tokenId] = DEFAULT_SESSION_ID; } std::thread newThread(&DeviceManagerServiceImpl::BindTargetImpl, this, tokenId, pkgName, targetId, bindParamTmp); newThread.detach(); @@ -2986,6 +3084,7 @@ void DeviceManagerServiceImpl::GetBindCallerInfo(DmBindCallerInfo &bindCallerInf bindLevel = static_cast(DmRole::DM_ROLE_FA); } if (AppManager::GetInstance().IsSystemSA()) { + isSystemSA = true; bindLevel = static_cast(DmRole::DM_ROLE_SA); } if (AuthManagerBase::CheckProcessNameInWhiteList(bundleName)) { diff --git a/test/unittest/UTTest_device_manager_service_impl.cpp b/test/unittest/UTTest_device_manager_service_impl.cpp index 992779122..3c1e0aed2 100644 --- a/test/unittest/UTTest_device_manager_service_impl.cpp +++ b/test/unittest/UTTest_device_manager_service_impl.cpp @@ -1636,8 +1636,9 @@ HWTEST_F(DeviceManagerServiceImplTest, StopAuthenticateDevice_102, testing::ext: if (deviceManagerServiceImpl_->authMgr_ == nullptr) { deviceManagerServiceImpl_->Initialize(listener_); } + deviceManagerServiceImpl_->tokenIdSessionIdMap_.clear(); int ret = deviceManagerServiceImpl_->StopAuthenticateDevice(pkgName); - EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_EQ(ret, DM_OK); } HWTEST_F(DeviceManagerServiceImplTest, CheckIsSameAccount_001, testing::ext::TestSize.Level1) @@ -2106,26 +2107,93 @@ HWTEST_F(DeviceManagerServiceImplTest, InitNewProtocolAuthMgr_001, testing::ext: bool isSrcSide = true; uint64_t tokenId = 1000023; uint64_t logicalSessionId = 456789; + int sessionId = 1; const std::string pkgName = "InitNewProtocolAuthMgr"; - int32_t ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName); + int32_t ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, + sessionId); EXPECT_EQ(ret, DM_OK); isSrcSide = false; - ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName); + ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, sessionId); EXPECT_EQ(ret, DM_OK); } HWTEST_F(DeviceManagerServiceImplTest, InitOldProtocolAuthMgr_001, testing::ext::TestSize.Level1) { uint64_t tokenId = 100002311; + int sessionId = 1; const std::string pkgName = "InitOldProtocolAuthMgr"; - int32_t ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName); + int32_t ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId); EXPECT_EQ(ret, DM_OK); deviceManagerServiceImpl_->authMgr_ = nullptr; - ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName); + ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId); EXPECT_EQ(ret, DM_OK); } + +HWTEST_F(DeviceManagerServiceImplTest, CleanSessionMap_001, testing::ext::TestSize.Level1) +{ + int sessionId = 0; + std::string deviceId = "deviceId"; + deviceManagerServiceImpl_->CleanSessionMap(nullptr); + std::shared_ptr session = std::make_shared(sessionId, deviceId); + session->logicalSessionCnt_.fetch_add(1); + deviceManagerServiceImpl_->CleanSessionMap(session); + EXPECT_EQ(session->logicalSessionCnt_.load(), 0); +} + +HWTEST_F(DeviceManagerServiceImplTest, CleanSessionMap_002, testing::ext::TestSize.Level1) +{ + int sessionId = 0; + deviceManagerServiceImpl_->softbusConnector_ = nullptr; + deviceManagerServiceImpl_->CleanSessionMap(sessionId); + if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) { + deviceManagerServiceImpl_->Initialize(listener_); + } + deviceManagerServiceImpl_->sessionsMap_.clear(); + deviceManagerServiceImpl_->CleanSessionMap(sessionId); + std::string deviceId = "deviceId"; + std::shared_ptr session = std::make_shared(sessionId, deviceId); + deviceManagerServiceImpl_->sessionsMap_[sessionId] = session; + deviceManagerServiceImpl_->CleanSessionMap(sessionId); + EXPECT_TRUE(deviceManagerServiceImpl_->sessionsMap_.empty()); +} + +HWTEST_F(DeviceManagerServiceImplTest, AddAuthMgr_001, testing::ext::TestSize.Level1) +{ + uint64_t tokenId = 0; + int sessionId = 1; + deviceManagerServiceImpl_->authMgrMap_.clear(); + deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, nullptr); + EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.empty()); + + if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) { + deviceManagerServiceImpl_->Initialize(listener_); + } + std::shared_ptr authMgr = std::make_shared( + deviceManagerServiceImpl_->softbusConnector_, deviceManagerServiceImpl_->hiChainConnector_, + deviceManagerServiceImpl_->listener_, deviceManagerServiceImpl_->hiChainAuthConnector_); + deviceManagerServiceImpl_->sessionEnableMap_[sessionId] = false; + deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, authMgr); + EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.empty()); + + deviceManagerServiceImpl_->sessionEnableMap_.clear(); + deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, authMgr); + EXPECT_FALSE(deviceManagerServiceImpl_->authMgrMap_.empty()); + deviceManagerServiceImpl_->sessionEnableMap_.clear(); + deviceManagerServiceImpl_->authMgrMap_.clear(); +} + +HWTEST_F(DeviceManagerServiceImplTest, EraseAuthMgr_001, testing::ext::TestSize.Level1) +{ + uint64_t tokenId = 0; + std::shared_ptr authMgr = std::make_shared( + deviceManagerServiceImpl_->softbusConnector_, deviceManagerServiceImpl_->hiChainConnector_, + deviceManagerServiceImpl_->listener_, deviceManagerServiceImpl_->hiChainAuthConnector_); + deviceManagerServiceImpl_->authMgrMap_[tokenId] = authMgr; + deviceManagerServiceImpl_->EraseAuthMgr(tokenId); + EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.find(tokenId) == deviceManagerServiceImpl_->authMgrMap_.end()); +} } // namespace } // namespace DistributedHardware } // namespace OHOS -- Gitee From dd4c9e8c6da0d67d8120e9d4c51391b1aa7d5f75 Mon Sep 17 00:00:00 2001 From: guoyi Date: Tue, 2 Sep 2025 19:49:40 +0800 Subject: [PATCH 2/2] =?UTF-8?q?ndk=E6=B7=BB=E5=8A=A0=E6=9D=83=E9=99=90?= =?UTF-8?q?=E6=A0=A1=E9=AA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: guoyi --- .../include/i_dm_service_impl_ext_resident.h | 1 + .../ability/standard/dm_dialog_manager.cpp | 4 +- .../src/device_manager_service_impl.cpp | 5 +- .../service/include/device_manager_service.h | 23 -- .../devicenamemgr/device_name_manager.h | 2 +- .../permission/lite/permission_manager.h | 3 +- .../permission/standard/permission_manager.h | 3 +- .../service/src/device_manager_service.cpp | 282 +----------------- .../src/devicenamemgr/device_name_manager.cpp | 1 - .../permission/lite/permission_manager.cpp | 7 +- .../standard/permission_manager.cpp | 21 +- .../UTTest_permission_manager.cpp | 20 ++ .../UTTest_permission_manager.h | 6 +- test/unittest/BUILD.gn | 4 +- .../UTTest_device_manager_service.cpp | 4 + test/unittest/UTTest_device_manager_service.h | 42 +-- .../UTTest_device_manager_service_impl.cpp | 6 + .../UTTest_device_manager_service_three.cpp | 4 - .../UTTest_device_manager_service_two.cpp | 222 ++------------ .../mock/device_name_manager_mock.cpp | 33 ++ test/unittest/mock/device_name_manager_mock.h | 40 +++ .../mock/dm_service_impl_ext_resident_mock.h | 59 ++++ .../unittest/mock/permission_manager_mock.cpp | 7 +- test/unittest/mock/permission_manager_mock.h | 4 +- 24 files changed, 269 insertions(+), 534 deletions(-) create mode 100644 test/unittest/mock/device_name_manager_mock.cpp create mode 100644 test/unittest/mock/device_name_manager_mock.h create mode 100644 test/unittest/mock/dm_service_impl_ext_resident_mock.h diff --git a/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h b/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h index 39a0eec92..4f738fc7c 100644 --- a/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h +++ b/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h @@ -112,6 +112,7 @@ public: virtual void ClearCacheWhenLogout(int32_t userId, const std::string &oldAccountId) = 0; virtual void HandleScreenLockEvent(bool isLock) = 0; virtual int32_t OpenAuthSessionWithPara(const std::string &deviceId, int32_t actionId, bool isEnable160m) = 0; + virtual void HandleUserSwitchEvent(int32_t currentUserId, int32_t beforeUserId) = 0; }; using CreateDMServiceExtResidentFuncPtr = IDMServiceImplExtResident *(*)(void); diff --git a/services/implementation/src/ability/standard/dm_dialog_manager.cpp b/services/implementation/src/ability/standard/dm_dialog_manager.cpp index 1f8d7d094..156d95b88 100644 --- a/services/implementation/src/ability/standard/dm_dialog_manager.cpp +++ b/services/implementation/src/ability/standard/dm_dialog_manager.cpp @@ -236,11 +236,11 @@ void DmDialogManager::SendMsgRequest(const sptr& remoteObject) if (abilityName_ == INPUT_ABILITY_NAME) { param["sysDialogZOrder"] = WINDOW_LEVEL_UPPER; } - std::string pinCodeHash = GetAnonyString(Crypto::Sha256(pinCode_)); - LOGI("OnAbilityConnectDone pinCodeHash: %{public}s", pinCodeHash.c_str()); param["isProxyBind"] = isProxyBind_; param["appUserData"] = appUserData_; param["title"] = title_; + std::string pinCodeHash = GetAnonyString(Crypto::Sha256(pinCode_)); + LOGI("OnAbilityConnectDone pinCodeHash: %{public}s", pinCodeHash.c_str()); param["pinCode"] = pinCode_; param["deviceName"] = deviceName_; param["appOperationStr"] = appOperationStr_; diff --git a/services/implementation/src/device_manager_service_impl.cpp b/services/implementation/src/device_manager_service_impl.cpp index 51a976963..dea0e21e5 100644 --- a/services/implementation/src/device_manager_service_impl.cpp +++ b/services/implementation/src/device_manager_service_impl.cpp @@ -277,6 +277,7 @@ int32_t DeviceManagerServiceImpl::InitOldProtocolAuthMgr(uint64_t tokenId, const ImportConfig(authMgr_, tokenId, pkgName); int32_t ret = AddAuthMgr(tokenId, sessionId, authMgr_); if (ret != DM_OK) { + authMgr_->ClearSoftbusSessionCallback(); return ret; } } @@ -423,7 +424,7 @@ int32_t DeviceManagerServiceImpl::AddAuthMgr(uint64_t tokenId, int sessionId, st } { std::lock_guard lock(authMgrMapMtx_); - if (authMgrMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) { + if (authMgrMap_.size() >= MAX_NEW_PROC_SESSION_COUNT_TEMP) { LOGE("Other bind session exist, can not start new one. authMgrMap_.size:%{public}zu", authMgrMap_.size()); return ERR_DM_AUTH_BUSINESS_BUSY; } @@ -1911,7 +1912,7 @@ int32_t DeviceManagerServiceImpl::BindTarget(const std::string &pkgName, const P "pkgName:%{public}s, tokenId:%{public}" PRIu64, pkgName.c_str(), tokenId); return ERR_DM_AUTH_BUSINESS_BUSY; } - if (tokenIdSessionIdMap_.size() > MAX_NEW_PROC_SESSION_COUNT_TEMP) { + if (tokenIdSessionIdMap_.size() >= MAX_NEW_PROC_SESSION_COUNT_TEMP) { LOGE("Other bind exist, can not start new one. size:%{public}zu", tokenIdSessionIdMap_.size()); return ERR_DM_AUTH_BUSINESS_BUSY; } diff --git a/services/service/include/device_manager_service.h b/services/service/include/device_manager_service.h index 069a2ad13..709e7301f 100644 --- a/services/service/include/device_manager_service.h +++ b/services/service/include/device_manager_service.h @@ -340,31 +340,15 @@ private: std::string &udidHash); void HandleAccountLogout(int32_t userId, const std::string &accountId, const std::string &accountName); void HandleUserRemoved(int32_t removedUserId); - /** - * @brief process the user switch - * - * @param currentUserId the user id which switched to foreground. - * @param beforeUserId the user id which switched to backend. - */ - void HandleUserSwitched(int32_t curUserId, int32_t preUserId); void HandleUserIdsBroadCast(const std::vector &remoteUserIdInfos, const std::string &remoteUdid, bool isNeedResponse); void HandleShareUnbindBroadCast(const int32_t userId, const std::string &credId); - void NotifyRemoteLocalUserSwitch(int32_t curUserId, int32_t preUserId, const std::vector &peerUdids, - const std::vector &foregroundUserIds, const std::vector &backgroundUserIds); - void NotifyRemoteLocalUserSwitchByWifi(int32_t curUserId, int32_t preUserId, - const std::map &wifiDevices, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds); - int32_t SendUserIdsByWifi(const std::string &networkId, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds); - void HandleUserSwitchTimeout(int32_t curUserId, int32_t preUserId, const std::string &udid); bool InitDPLocalServiceInfo(const DMLocalServiceInfo &serviceInfo, DistributedDeviceProfile::LocalServiceInfo &dpLocalServiceItem); void InitServiceInfo(const DistributedDeviceProfile::LocalServiceInfo &dpLocalServiceItem, DMLocalServiceInfo &serviceInfo); void InitServiceInfos(const std::vector &dpLocalServiceItems, std::vector &serviceInfos); - void HandleUserSwitched(); void NotifyRemoteUninstallApp(int32_t userId, int32_t tokenId); void NotifyRemoteUninstallAppByWifi(int32_t userId, int32_t tokenId, @@ -378,13 +362,6 @@ private: int32_t SendUnBindAppByWifi(int32_t userId, int32_t tokenId, std::string extra, const std::string &networkId, const std::string &udid); - void NotifyRemoteLocalUserSwitch(const std::string &localUdid, const std::vector &peerUdids, - const std::vector &foregroundUserIds, const std::vector &backgroundUserIds); - void NotifyRemoteLocalUserSwitchByWifi(const std::string &localUdid, - const std::map &wifiDevices, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds); - void HandleUserSwitchTimeout(const std::string &localUdid, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds, const std::string &udid); void UpdateAclAndDeleteGroup(const std::string &localUdid, const std::vector &deviceVec, const std::vector &foregroundUserIds, const std::vector &backgroundUserIds); void HandleUserSwitchedEvent(int32_t currentUserId, int32_t beforeUserId); diff --git a/services/service/include/devicenamemgr/device_name_manager.h b/services/service/include/devicenamemgr/device_name_manager.h index ed68ca896..20aa157bc 100644 --- a/services/service/include/devicenamemgr/device_name_manager.h +++ b/services/service/include/devicenamemgr/device_name_manager.h @@ -45,6 +45,7 @@ public: int32_t RestoreLocalDeviceName(); int32_t InitDeviceNameWhenLanguageOrRegionChanged(); std::string GetUserDefinedDeviceName(); + std::string GetLocalMarketName(); private: DeviceNameManager() = default; @@ -60,7 +61,6 @@ private: std::string GetSystemLanguage(); std::string GetSystemRegion(); - std::string GetLocalMarketName(); int32_t InitDisplayDeviceNameToSettingsData(const std::string &nickName, const std::string &deviceName, int32_t userId); diff --git a/services/service/include/permission/lite/permission_manager.h b/services/service/include/permission/lite/permission_manager.h index 0421f096a..ff1e02302 100644 --- a/services/service/include/permission/lite/permission_manager.h +++ b/services/service/include/permission/lite/permission_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -41,6 +41,7 @@ public: bool CheckProcessNameValidModifyRemoteDeviceName(const std::string &processName); bool CheckProcessNameValidPutDeviceProfileInfoList(const std::string &processName); bool CheckProcessValidOnGetTrustedDeviceList(); + bool CheckReadLocalDeviceName(void); }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/include/permission/standard/permission_manager.h b/services/service/include/permission/standard/permission_manager.h index d5aab748c..21d057b9a 100644 --- a/services/service/include/permission/standard/permission_manager.h +++ b/services/service/include/permission/standard/permission_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -40,6 +40,7 @@ public: bool CheckProcessNameValidModifyRemoteDeviceName(const std::string &processName); bool CheckProcessNameValidPutDeviceProfileInfoList(const std::string &processName); bool CheckProcessValidOnGetTrustedDeviceList(); + bool CheckReadLocalDeviceName(void); private: bool VerifyAccessTokenByPermissionName(const std::string& permissionName); diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp index bf85b5fca..707429bb2 100644 --- a/services/service/src/device_manager_service.cpp +++ b/services/service/src/device_manager_service.cpp @@ -2381,50 +2381,6 @@ void DeviceManagerService::HandleAccountCommonEvent(const std::string commonEven NotifyRemoteAccountCommonEvent(commonEventType, localUdid, peerUdids, foregroundUserVec, backgroundUserVec); } -void DeviceManagerService::HandleUserSwitched() -{ - LOGI("start."); - std::vector foregroundUserVec; - int32_t retFront = MultipleUserConnector::GetForegroundUserIds(foregroundUserVec); - std::vector backgroundUserVec; - int32_t retBack = MultipleUserConnector::GetBackgroundUserIds(backgroundUserVec); - if (retFront != DM_OK || retBack != DM_OK || foregroundUserVec.empty()) { - LOGE("Get userids failed, retFront: %{public}d, retBack: %{public}d, foreground user num: %{public}d", - retFront, retBack, static_cast(foregroundUserVec.size())); - return; - } - char localUdidTemp[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH); - std::string localUdid = std::string(localUdidTemp); - CHECK_NULL_VOID(discoveryMgr_); - if (!discoveryMgr_->IsCommonDependencyReady() || discoveryMgr_->GetCommonDependencyObj() == nullptr) { - LOGE("IsCommonDependencyReady failed or GetCommonDependencyObj() is nullptr."); - return; - } - if (!discoveryMgr_->GetCommonDependencyObj()->CheckAclStatusAndForegroundNotMatch(localUdid, - foregroundUserVec, backgroundUserVec)) { - LOGI("no unreasonable data."); - return; - } - std::map curUserDeviceMap = - discoveryMgr_->GetCommonDependencyObj()->GetDeviceIdAndBindLevel(foregroundUserVec, localUdid); - std::map preUserDeviceMap = - discoveryMgr_->GetCommonDependencyObj()->GetDeviceIdAndBindLevel(backgroundUserVec, localUdid); - std::vector peerUdids; - for (const auto &item : curUserDeviceMap) { - peerUdids.push_back(item.first); - } - for (const auto &item : preUserDeviceMap) { - if (find(peerUdids.begin(), peerUdids.end(), item.first) == peerUdids.end()) { - peerUdids.push_back(item.first); - } - } - if (peerUdids.empty()) { - return; - } - NotifyRemoteLocalUserSwitch(localUdid, peerUdids, foregroundUserVec, backgroundUserVec); -} - #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) void DeviceManagerService::NotifyRemoteAccountCommonEvent(const std::string commonEventType, const std::string &localUdid, const std::vector &peerUdids, @@ -2543,88 +2499,6 @@ void DeviceManagerService::UpdateAcl(const std::string &localUdid, backgroundUserIds); } -void DeviceManagerService::NotifyRemoteLocalUserSwitch(const std::string &localUdid, - const std::vector &peerUdids, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds) -{ - LOGI("onstart UserSwitch, foregroundUserIds: %{public}s, backgroundUserIds: %{public}s", - GetIntegerList(foregroundUserIds).c_str(), GetIntegerList(backgroundUserIds).c_str()); - if (peerUdids.empty()) { - return; - } - if (softbusListener_ == nullptr) { - UpdateAclAndDeleteGroup(localUdid, peerUdids, foregroundUserIds, backgroundUserIds); - LOGE("softbusListener_ is null"); - return; - } - std::vector bleUdids; - std::map wifiDevices; - for (const auto &udid : peerUdids) { - std::string netWorkId = ""; - SoftbusCache::GetInstance().GetNetworkIdFromCache(udid, netWorkId); - if (netWorkId.empty()) { - LOGI("netWorkId is empty: %{public}s", GetAnonyString(udid).c_str()); - bleUdids.push_back(udid); - continue; - } - int32_t networkType = 0; - int32_t ret = softbusListener_->GetNetworkTypeByNetworkId(netWorkId.c_str(), networkType); - if (ret != DM_OK || networkType <= 0) { - LOGI("get networkType failed: %{public}s", GetAnonyString(udid).c_str()); - bleUdids.push_back(udid); - continue; - } - uint32_t addrTypeMask = 1 << NetworkType::BIT_NETWORK_TYPE_BLE; - if ((static_cast(networkType) & addrTypeMask) != 0x0) { - bleUdids.push_back(udid); - } else { - wifiDevices.insert(std::pair(udid, netWorkId)); - } - } - if (!bleUdids.empty()) { - UpdateAclAndDeleteGroup(localUdid, peerUdids, foregroundUserIds, backgroundUserIds); - SendUserIdsBroadCast(bleUdids, foregroundUserIds, backgroundUserIds, true); - } - if (!wifiDevices.empty()) { - NotifyRemoteLocalUserSwitchByWifi(localUdid, wifiDevices, foregroundUserIds, backgroundUserIds); - } -} - -void DeviceManagerService::NotifyRemoteLocalUserSwitchByWifi(const std::string &localUdid, - const std::map &wifiDevices, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds) -{ - for (const auto &it : wifiDevices) { - int32_t result = SendUserIdsByWifi(it.second, foregroundUserIds, backgroundUserIds); - if (result != DM_OK) { - LOGE("by wifi failed: %{public}s", GetAnonyString(it.first).c_str()); - std::vector updateUdids; - updateUdids.push_back(it.first); - UpdateAclAndDeleteGroup(localUdid, updateUdids, foregroundUserIds, backgroundUserIds); - continue; - } - if (timer_ == nullptr) { - timer_ = std::make_shared(); - } - std::string udid = it.first; - timer_->StartTimer(std::string(USER_SWITCH_BY_WIFI_TIMEOUT_TASK) + Crypto::Sha256(udid), - USER_SWITCH_BY_WIFI_TIMEOUT_S, - [this, localUdid, foregroundUserIds, backgroundUserIds, udid] (std::string name) { - DeviceManagerService::HandleUserSwitchTimeout(localUdid, foregroundUserIds, backgroundUserIds, udid); - }); - } -} - -void DeviceManagerService::HandleUserSwitchTimeout(const std::string &localUdid, - const std::vector &foregroundUserIds, const std::vector &backgroundUserIds, - const std::string &udid) -{ - LOGI("start udid: %{public}s", GetAnonyString(udid).c_str()); - std::vector updateUdids; - updateUdids.push_back(udid); - UpdateAclAndDeleteGroup(localUdid, updateUdids, foregroundUserIds, backgroundUserIds); -} - void DeviceManagerService::UpdateAclAndDeleteGroup(const std::string &localUdid, const std::vector &deviceVec, const std::vector &foregroundUserIds, const std::vector &backgroundUserIds) @@ -2680,41 +2554,6 @@ void DeviceManagerService::HandleAccountLogout(int32_t userId, const std::string } } -void DeviceManagerService::HandleUserSwitched(int32_t curUserId, int32_t preUserId) -{ - LOGI("currentUserId: %{public}d. previousUserId: %{public}d", curUserId, preUserId); - if (!IsDMServiceImplReady()) { - LOGE("Init impl failed."); - return; - } - std::map curUserDeviceMap; - std::map preUserDeviceMap; - std::vector peerUdids; - curUserDeviceMap = dmServiceImpl_->GetDeviceIdAndBindLevel(curUserId); - preUserDeviceMap = dmServiceImpl_->GetDeviceIdAndBindLevel(preUserId); - for (const auto &item : curUserDeviceMap) { - peerUdids.push_back(item.first); - } - for (const auto &item : preUserDeviceMap) { - if (find(peerUdids.begin(), peerUdids.end(), item.first) == peerUdids.end()) { - peerUdids.push_back(item.first); - } - } - if (peerUdids.empty()) { - return; - } - std::vector foregroundUserVec; - int32_t retFront = MultipleUserConnector::GetForegroundUserIds(foregroundUserVec); - std::vector backgroundUserVec; - int32_t retBack = MultipleUserConnector::GetBackgroundUserIds(backgroundUserVec); - if (retFront != DM_OK || retBack != DM_OK || foregroundUserVec.empty()) { - LOGE("Get userids failed, retFront: %{public}d, retBack: %{public}d, foreground user num: %{public}d", - retFront, retBack, static_cast(foregroundUserVec.size())); - return; - } - NotifyRemoteLocalUserSwitch(curUserId, preUserId, peerUdids, foregroundUserVec, backgroundUserVec); -} - void DeviceManagerService::HandleUserRemoved(int32_t removedUserId) { LOGI("PreUserId %{public}d.", removedUserId); @@ -3658,51 +3497,6 @@ int32_t DeviceManagerService::GetAnonyLocalUdid(const std::string &pkgName, std: } #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) -void DeviceManagerService::NotifyRemoteLocalUserSwitch(int32_t curUserId, int32_t preUserId, - const std::vector &peerUdids, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds) -{ - LOGI("Send local foreground and background userids"); - if (peerUdids.empty()) { - return; - } - if (softbusListener_ == nullptr) { - dmServiceImpl_->HandleUserSwitched(peerUdids, curUserId, preUserId); - LOGE("softbusListener_ is null"); - return; - } - std::vector bleUdids; - std::map wifiDevices; - for (const auto &udid : peerUdids) { - std::string netWorkId = ""; - SoftbusCache::GetInstance().GetNetworkIdFromCache(udid, netWorkId); - if (netWorkId.empty()) { - LOGI("netWorkId is empty: %{public}s", GetAnonyString(udid).c_str()); - bleUdids.push_back(udid); - continue; - } - int32_t networkType = 0; - int32_t ret = softbusListener_->GetNetworkTypeByNetworkId(netWorkId.c_str(), networkType); - if (ret != DM_OK || networkType <= 0) { - LOGI("get networkType failed: %{public}s", GetAnonyString(udid).c_str()); - bleUdids.push_back(udid); - continue; - } - uint32_t addrTypeMask = 1 << NetworkType::BIT_NETWORK_TYPE_BLE; - if ((static_cast(networkType) & addrTypeMask) != 0x0) { - bleUdids.push_back(udid); - } else { - wifiDevices.insert(std::pair(udid, netWorkId)); - } - } - if (!bleUdids.empty()) { - dmServiceImpl_->HandleUserSwitched(bleUdids, curUserId, preUserId); - SendUserIdsBroadCast(bleUdids, foregroundUserIds, backgroundUserIds, true); - } - if (!wifiDevices.empty()) { - NotifyRemoteLocalUserSwitchByWifi(curUserId, preUserId, wifiDevices, foregroundUserIds, backgroundUserIds); - } -} void DeviceManagerService::NotifyRemoteUninstallApp(int32_t userId, int32_t tokenId) { @@ -3882,70 +3676,6 @@ void DeviceManagerService::GetNotifyRemoteUnBindAppWay(int32_t userId, int32_t t } } -void DeviceManagerService::NotifyRemoteLocalUserSwitchByWifi(int32_t curUserId, int32_t preUserId, - const std::map &wifiDevices, const std::vector &foregroundUserIds, - const std::vector &backgroundUserIds) -{ - for (const auto &it : wifiDevices) { - int32_t result = SendUserIdsByWifi(it.second, foregroundUserIds, backgroundUserIds); - if (result != DM_OK) { - LOGE("by wifi failed: %{public}s", GetAnonyString(it.first).c_str()); - std::vector updateUdids; - updateUdids.push_back(it.first); - dmServiceImpl_->HandleUserSwitched(updateUdids, curUserId, preUserId); - continue; - } - if (timer_ == nullptr) { - timer_ = std::make_shared(); - } - std::string udid = it.first; - timer_->StartTimer(std::string(USER_SWITCH_BY_WIFI_TIMEOUT_TASK) + Crypto::Sha256(udid), - USER_SWITCH_BY_WIFI_TIMEOUT_S, [this, curUserId, preUserId, udid] (std::string name) { - DeviceManagerService::HandleUserSwitchTimeout(curUserId, preUserId, udid); - }); - } -} - -int32_t DeviceManagerService::SendUserIdsByWifi(const std::string &networkId, - const std::vector &foregroundUserIds, const std::vector &backgroundUserIds) -{ - LOGI("Try open softbus session to exchange foreground/background userid"); - std::vector foregroundUserIdsUInt; - for (auto const &u : foregroundUserIds) { - foregroundUserIdsUInt.push_back(static_cast(u)); - } - std::vector backgroundUserIdsUInt; - for (auto const &u : backgroundUserIds) { - backgroundUserIdsUInt.push_back(static_cast(u)); - } - return DMCommTool::GetInstance()->SendUserIds(networkId, foregroundUserIdsUInt, backgroundUserIdsUInt); -} - -void DeviceManagerService::HandleUserSwitchTimeout(int32_t curUserId, int32_t preUserId, const std::string &udid) -{ - LOGI("start udid: %{public}s", GetAnonyString(udid).c_str()); - std::vector updateUdids; - updateUdids.push_back(udid); - dmServiceImpl_->HandleUserSwitched(updateUdids, curUserId, preUserId); -} - -void DeviceManagerService::HandleUserSwitchedEvent(int32_t currentUserId, int32_t beforeUserId) -{ - LOGI("In"); - DeviceNameManager::GetInstance().InitDeviceNameWhenUserSwitch(currentUserId, beforeUserId); - MultipleUserConnector::SetAccountInfo(currentUserId, MultipleUserConnector::GetCurrentDMAccountInfo()); - if (IsPC()) { - return; - } - if (beforeUserId == -1 || currentUserId == -1) { - HandleUserSwitched(); - return; - } - if (beforeUserId != -1 && currentUserId != -1) { - HandleUserSwitched(currentUserId, beforeUserId); - } -} - void DeviceManagerService::HandleUserStopEvent(int32_t stopUserId) { LOGI("stopUserId %{public}s.", GetAnonyInt32(stopUserId).c_str()); @@ -4473,7 +4203,12 @@ int32_t DeviceManagerService::UnRegisterPinHolderCallback(const std::string &pkg int32_t DeviceManagerService::GetLocalDeviceName(std::string &deviceName) { #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) - return DeviceNameManager::GetInstance().GetLocalDisplayDeviceName(0, deviceName); + if (PermissionManager::GetInstance().CheckReadLocalDeviceName()) { + return DeviceNameManager::GetInstance().GetLocalDisplayDeviceName(0, deviceName); + } else { + deviceName = DeviceNameManager::GetInstance().GetLocalMarketName(); + return DM_OK; + } #endif (void) deviceName; return DM_OK; @@ -4553,6 +4288,11 @@ void DeviceManagerService::HandleUserSwitchEventCallback(const std::string &comm [this, commonEventType] () { DeviceManagerService::HandleAccountCommonEvent(commonEventType); }); + if (IsDMServiceAdapterResidentLoad()) { + dmServiceImplExtResident_->HandleUserSwitchEvent(currentUserId, beforeUserId); + } else { + LOGW("HandleUserSwitchEvent fail, adapter instance not init or init failed."); + } } void DeviceManagerService::GetHoOsTypeUdids(std::vector &peerUdids) diff --git a/services/service/src/devicenamemgr/device_name_manager.cpp b/services/service/src/devicenamemgr/device_name_manager.cpp index f58602049..4e05f530f 100644 --- a/services/service/src/devicenamemgr/device_name_manager.cpp +++ b/services/service/src/devicenamemgr/device_name_manager.cpp @@ -525,7 +525,6 @@ std::string DeviceNameManager::GetLocalMarketName() return ""; } localMarketName_ = marketName; - free((char *)marketName); } std::vector prefixs = DeviceManagerService::GetInstance().GetDeviceNamePrefixs(); for (const auto &item : prefixs) { diff --git a/services/service/src/permission/lite/permission_manager.cpp b/services/service/src/permission/lite/permission_manager.cpp index dbfa6d7f3..bf6e40742 100644 --- a/services/service/src/permission/lite/permission_manager.cpp +++ b/services/service/src/permission/lite/permission_manager.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -105,5 +105,10 @@ bool PermissionManager::CheckProcessValidOnGetTrustedDeviceList() { return true; } + +bool PermissionManager::CheckReadLocalDeviceName(void) +{ + return true; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/src/permission/standard/permission_manager.cpp b/services/service/src/permission/standard/permission_manager.cpp index fbcd70775..d7036d738 100644 --- a/services/service/src/permission/standard/permission_manager.cpp +++ b/services/service/src/permission/standard/permission_manager.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -98,6 +98,8 @@ constexpr const static char* GET_TRUSTED_DEVICE_LIST_WHITE_LIST[] = { "distributedsched", }; constexpr uint32_t GET_TRUSTED_DEVICE_LIST_WHITE_LIST_NUM = std::size(GET_TRUSTED_DEVICE_LIST_WHITE_LIST); + +constexpr const char* READ_LOCAL_DEVICE_NAME_PERMISSION = "ohos.permission.READ_LOCAL_DEVICE_NAME"; } bool PermissionManager::CheckPermission(void) @@ -366,5 +368,22 @@ bool PermissionManager::CheckProcessValidOnGetTrustedDeviceList() } return false; } + +bool PermissionManager::CheckReadLocalDeviceName(void) +{ + AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID(); + if (tokenCaller == 0) { + LOGE("CheckReadLocalDeviceName GetCallingTokenID error."); + return false; + } + ATokenTypeEnum tokenTypeFlag = AccessTokenKit::GetTokenTypeFlag(tokenCaller); + if ((tokenTypeFlag == ATokenTypeEnum::TOKEN_HAP) && + (AccessTokenKit::VerifyAccessToken(tokenCaller, READ_LOCAL_DEVICE_NAME_PERMISSION) == + PermissionState::PERMISSION_GRANTED)) { + return true; + } + LOGE("Read local device name permission is denied, please apply for corresponding permissions."); + return false; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/test/commonunittest/UTTest_permission_manager.cpp b/test/commonunittest/UTTest_permission_manager.cpp index 2ece3cf82..6e953b2ea 100644 --- a/test/commonunittest/UTTest_permission_manager.cpp +++ b/test/commonunittest/UTTest_permission_manager.cpp @@ -14,6 +14,7 @@ */ #include "UTTest_permission_manager.h" +#include "access_token.h" #include "accesstoken_kit.h" #include "nativetoken_kit.h" #include "token_setproc.h" @@ -271,6 +272,25 @@ HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnGetDeviceInfo_001, testin ret = PermissionManager::GetInstance().CheckProcessNameValidOnGetDeviceInfo(processName); ASSERT_TRUE(ret); } + +HWTEST_F(PermissionManagerTest, CheckReadLocalDeviceName_001, testing::ext::TestSize.Level1) +{ + EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(0)); + bool ret = PermissionManager::GetInstance().CheckReadLocalDeviceName(); + ASSERT_FALSE(ret); + + EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(10)); + EXPECT_CALL(*accessTokenKitMock_, VerifyAccessToken(_, _)) + .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED)); + ret = PermissionManager::GetInstance().CheckPermission(); + ASSERT_FALSE(ret); + + EXPECT_CALL(*ipcSkeletonMock_, GetCallingTokenID()).WillOnce(Return(10)); + EXPECT_CALL(*accessTokenKitMock_, VerifyAccessToken(_, _)) + .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED)); + ret = PermissionManager::GetInstance().CheckPermission(); + ASSERT_TRUE(ret); +} } } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/commonunittest/UTTest_permission_manager.h b/test/commonunittest/UTTest_permission_manager.h index 20b409c34..459496bd3 100644 --- a/test/commonunittest/UTTest_permission_manager.h +++ b/test/commonunittest/UTTest_permission_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -21,10 +21,10 @@ #include #include +#include "dm_accesstoken_kit_mock.h" #include "dm_constants.h" -#include "permission_manager.h" #include "dm_ipc_skeleton_mock.h" -#include "dm_accesstoken_kit_mock.h" +#include "permission_manager.h" namespace OHOS { namespace DistributedHardware { diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 53280a13e..02d5243d7 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022-2024 Huawei Device Co., Ltd. +# Copyright (c) 2022-2025 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -482,6 +482,7 @@ ohos_unittest("UTTest_device_manager_service") { "UTTest_device_manager_service_two.cpp", "mock/app_manager_mock.cpp", "mock/device_manager_service_impl_mock.cpp", + "mock/device_name_manager_mock.cpp", "mock/deviceprofile_connector_mock.cpp", "mock/dm_comm_tool_mock.cpp", "mock/dm_crypto_mock.cpp", @@ -499,6 +500,7 @@ ohos_unittest("UTTest_device_manager_service") { "access_token:libnativetoken", "access_token:libtoken_setproc", "cJSON:cjson", + "data_share:datashare_consumer", "device_auth:deviceauth_sdk", "device_info_manager:distributed_device_profile_common", "device_info_manager:distributed_device_profile_sdk", diff --git a/test/unittest/UTTest_device_manager_service.cpp b/test/unittest/UTTest_device_manager_service.cpp index bf2d124ea..3496f2e2b 100644 --- a/test/unittest/UTTest_device_manager_service.cpp +++ b/test/unittest/UTTest_device_manager_service.cpp @@ -71,6 +71,7 @@ void DeviceManagerServiceTest::TearDown() Mock::VerifyAndClearExpectations(multipleUserConnectorMock_.get()); Mock::VerifyAndClearExpectations(dMCommToolMock_.get()); Mock::VerifyAndClearExpectations(deviceProfileConnectorMock_.get()); + Mock::VerifyAndClearExpectations(deviceNameManagerMock_.get()); } void DeviceManagerServiceTest::SetUpTestCase() @@ -85,6 +86,7 @@ void DeviceManagerServiceTest::SetUpTestCase() DmMultipleUserConnector::dmMultipleUserConnector = multipleUserConnectorMock_; DmDMCommTool::dmDMCommTool = dMCommToolMock_; DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock_; + DmDeviceNameManager::dmDeviceNameManager_ = deviceNameManagerMock_; } void DeviceManagerServiceTest::TearDownTestCase() @@ -109,6 +111,8 @@ void DeviceManagerServiceTest::TearDownTestCase() dMCommToolMock_ = nullptr; DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr; deviceProfileConnectorMock_ = nullptr; + DmDeviceNameManager::dmDeviceNameManager_ = nullptr; + deviceNameManagerMock_ = nullptr; } namespace { diff --git a/test/unittest/UTTest_device_manager_service.h b/test/unittest/UTTest_device_manager_service.h index 4b7b8e87e..317c1dd2d 100644 --- a/test/unittest/UTTest_device_manager_service.h +++ b/test/unittest/UTTest_device_manager_service.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -22,21 +22,21 @@ #include #include +#include "app_manager_mock.h" +#include "common_event_support.h" #include "device_manager_service.h" #include "device_manager_service_listener.h" -#include "device_manager_service_impl.h" -#include "dm_single_instance.h" -#include "common_event_support.h" -#include "permission_manager_mock.h" -#include "softbus_listener_mock.h" -#include "app_manager_mock.h" -#include "kv_adapter_manager_mock.h" #include "device_manager_service_impl_mock.h" -#include "dm_softbus_cache_mock.h" +#include "device_name_manager_mock.h" +#include "deviceprofile_connector_mock.h" +#include "dm_comm_tool_mock.h" #include "dm_crypto_mock.h" +#include "dm_single_instance.h" +#include "dm_softbus_cache_mock.h" +#include "kv_adapter_manager_mock.h" #include "multiple_user_connector_mock.h" -#include "dm_comm_tool_mock.h" -#include "deviceprofile_connector_mock.h" +#include "permission_manager_mock.h" +#include "softbus_listener_mock.h" namespace OHOS { namespace DistributedHardware { @@ -49,22 +49,24 @@ public: static inline std::shared_ptr permissionManagerMock_ = std::make_shared(); - static inline std::shared_ptr softbusListenerMock_ = + static inline std::shared_ptr softbusListenerMock_ = std::make_shared(); - static inline std::shared_ptr appManagerMock_ = + static inline std::shared_ptr appManagerMock_ = std::make_shared(); - static inline std::shared_ptr kVAdapterManagerMock_ = + static inline std::shared_ptr kVAdapterManagerMock_ = std::make_shared(); - static inline std::shared_ptr deviceManagerServiceImplMock_ = + static inline std::shared_ptr deviceManagerServiceImplMock_ = std::make_shared(); - static inline std::shared_ptr softbusCacheMock_ = + static inline std::shared_ptr softbusCacheMock_ = std::make_shared(); - static inline std::shared_ptr cryptoMock_ = std::make_shared(); - static inline std::shared_ptr multipleUserConnectorMock_ = + static inline std::shared_ptr cryptoMock_ = std::make_shared(); + static inline std::shared_ptr multipleUserConnectorMock_ = std::make_shared(); - static inline std::shared_ptr dMCommToolMock_ = std::make_shared(); - static inline std::shared_ptr deviceProfileConnectorMock_ = + static inline std::shared_ptr dMCommToolMock_ = std::make_shared(); + static inline std::shared_ptr deviceProfileConnectorMock_ = std::make_shared(); + static inline std::shared_ptr deviceNameManagerMock_ = + std::make_shared(); }; } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_service_impl.cpp b/test/unittest/UTTest_device_manager_service_impl.cpp index 3c1e0aed2..e44d72c59 100644 --- a/test/unittest/UTTest_device_manager_service_impl.cpp +++ b/test/unittest/UTTest_device_manager_service_impl.cpp @@ -2109,13 +2109,16 @@ HWTEST_F(DeviceManagerServiceImplTest, InitNewProtocolAuthMgr_001, testing::ext: uint64_t logicalSessionId = 456789; int sessionId = 1; const std::string pkgName = "InitNewProtocolAuthMgr"; + deviceManagerServiceImpl_->authMgrMap_.clear(); int32_t ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, sessionId); EXPECT_EQ(ret, DM_OK); + deviceManagerServiceImpl_->authMgrMap_.clear(); isSrcSide = false; ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, sessionId); EXPECT_EQ(ret, DM_OK); + deviceManagerServiceImpl_->authMgrMap_.clear(); } HWTEST_F(DeviceManagerServiceImplTest, InitOldProtocolAuthMgr_001, testing::ext::TestSize.Level1) @@ -2123,12 +2126,15 @@ HWTEST_F(DeviceManagerServiceImplTest, InitOldProtocolAuthMgr_001, testing::ext: uint64_t tokenId = 100002311; int sessionId = 1; const std::string pkgName = "InitOldProtocolAuthMgr"; + deviceManagerServiceImpl_->authMgrMap_.clear(); int32_t ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId); EXPECT_EQ(ret, DM_OK); + deviceManagerServiceImpl_->authMgrMap_.clear(); deviceManagerServiceImpl_->authMgr_ = nullptr; ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId); EXPECT_EQ(ret, DM_OK); + deviceManagerServiceImpl_->authMgrMap_.clear(); } HWTEST_F(DeviceManagerServiceImplTest, CleanSessionMap_001, testing::ext::TestSize.Level1) diff --git a/test/unittest/UTTest_device_manager_service_three.cpp b/test/unittest/UTTest_device_manager_service_three.cpp index 5ca56ab14..2b27ca0d7 100644 --- a/test/unittest/UTTest_device_manager_service_three.cpp +++ b/test/unittest/UTTest_device_manager_service_three.cpp @@ -411,11 +411,7 @@ HWTEST_F(DeviceManagerServiceThreeTest, ExportAuthCode_301, testing::ext::TestSi EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false)); DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, accountName); - int32_t curUserId = 0; int32_t preUserId = 1; - EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false)); - DeviceManagerService::GetInstance().HandleUserSwitched(curUserId, preUserId); - EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false)); DeviceManagerService::GetInstance().HandleUserRemoved(preUserId); } diff --git a/test/unittest/UTTest_device_manager_service_two.cpp b/test/unittest/UTTest_device_manager_service_two.cpp index 7c658a6ab..9f4011c5c 100644 --- a/test/unittest/UTTest_device_manager_service_two.cpp +++ b/test/unittest/UTTest_device_manager_service_two.cpp @@ -656,20 +656,6 @@ HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_201, testing::ext::TestS EXPECT_CALL(*cryptoMock_, GetAccountIdHash(_, _)).WillOnce(Return(ERR_DM_FAILED)); DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, accountName); - int32_t curUserId = 0; - int32_t preUserId = 1; - std::map curUserDeviceMap; - curUserDeviceMap["curUserId"] = userId; - curUserDeviceMap["preUserId"] = userId; - std::map preUserDeviceMap; - preUserDeviceMap["accountId"] = userId; - preUserDeviceMap["accountName"] = 1; - EXPECT_CALL(*deviceManagerServiceImplMock_, - GetDeviceIdAndBindLevel(_)).WillOnce(Return(curUserDeviceMap)).WillOnce(Return(preUserDeviceMap)); - EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)).WillOnce(Return(ERR_DM_FAILED)); - EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_)).WillOnce(Return(ERR_DM_FAILED)); - DeviceManagerService::GetInstance().HandleUserSwitched(curUserId, preUserId); - int32_t removeId = 123; deviceMap.insert(std::make_pair("removeId", removeId)); EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_)).WillOnce(Return(deviceMap)); @@ -1052,31 +1038,13 @@ HWTEST_F(DeviceManagerServiceTest, UnBindDevice_205, testing::ext::TestSize.Leve int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra); EXPECT_NE(ret, DM_OK); - int32_t userId = 123456; - int32_t curUserId = 0; - int32_t preUserId = 1; - std::map curUserDeviceMap; - curUserDeviceMap["curUserId"] = userId; - curUserDeviceMap["preUserId"] = userId; - std::map preUserDeviceMap; - preUserDeviceMap["accountId"] = userId; - preUserDeviceMap["accountName"] = 1; - std::vector foregroundUserVec; - foregroundUserVec.push_back(101); - EXPECT_CALL(*deviceManagerServiceImplMock_, - GetDeviceIdAndBindLevel(_)).WillOnce(Return(curUserDeviceMap)).WillOnce(Return(preUserDeviceMap)); - EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)) - .Times(::testing::AtLeast(1)).WillRepeatedly(DoAll(SetArgReferee<0>(foregroundUserVec), Return(DM_OK))); - EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_)).WillRepeatedly(Return(DM_OK)); - DeviceManagerService::GetInstance().HandleUserSwitched(curUserId, preUserId); - std::vector remoteUserIdInfos; std::string remoteUdid; bool isNeedResponse = false; DeviceManagerService::GetInstance().HandleUserIdsBroadCast(remoteUserIdInfos, remoteUdid, isNeedResponse); std::vector peerUdids; - userId = 123; + int32_t userId = 123; uint64_t tokenId = 1; int32_t bindLevel = 1; uint64_t peerTokenId = 1; @@ -1122,90 +1090,6 @@ HWTEST_F(DeviceManagerServiceTest, GetAnonyLocalUdid_202, testing::ext::TestSize EXPECT_EQ(ret, DM_OK); } -HWTEST_F(DeviceManagerServiceTest, NotifyRemoteLocalUserSwitch_201, testing::ext::TestSize.Level1) -{ - int32_t curUserId = 1; - int32_t preUserId = 1; - std::vector peerUdids; - std::vector foregroundUserIds; - std::vector backgroundUserIds; - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(curUserId, preUserId, peerUdids, foregroundUserIds, - backgroundUserIds); - - peerUdids.push_back("peerUdid001"); - peerUdids.push_back("peerUdid002"); - DeviceManagerService::GetInstance().softbusListener_ = nullptr; - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(curUserId, preUserId, peerUdids, foregroundUserIds, - backgroundUserIds); - EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr); - - DeviceManagerService::GetInstance().softbusListener_ = std::make_shared(); - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).Times(::testing::AtLeast(2)) - .WillOnce(DoAll(SetArgReferee<1>(""), Return(DM_OK))); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(curUserId, preUserId, peerUdids, foregroundUserIds, - backgroundUserIds); - EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr); - - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).Times(::testing::AtLeast(2)) - .WillOnce(DoAll(SetArgReferee<1>("networkId"), Return(DM_OK))); - EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _)) - .WillOnce(DoAll(SetArgReferee<1>(0), Return(ERR_DM_FAILED))); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(curUserId, preUserId, peerUdids, foregroundUserIds, - backgroundUserIds); - EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr); - - DeviceManagerService::GetInstance().timer_ = std::make_shared(); - EXPECT_CALL(*dMCommToolMock_, SendUserIds(_, _, _)).WillOnce(Return(ERR_DM_FAILED)); - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).Times(::testing::AtLeast(2)) - .WillOnce(DoAll(SetArgReferee<1>("networkId"), Return(DM_OK))); - EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _)) - .WillOnce(DoAll(SetArgReferee<1>(1), Return(DM_OK))); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(curUserId, preUserId, peerUdids, foregroundUserIds, - backgroundUserIds); - EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr); - - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).Times(::testing::AtLeast(2)) - .WillOnce(DoAll(SetArgReferee<1>("networkId"), Return(DM_OK))); - EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _)) - .WillOnce(DoAll(SetArgReferee<1>(4), Return(DM_OK))); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(curUserId, preUserId, peerUdids, foregroundUserIds, - backgroundUserIds); - EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr); -} - -HWTEST_F(DeviceManagerServiceTest, NotifyRemoteLocalUserSwitchByWifi_201, testing::ext::TestSize.Level1) -{ - DeviceManagerService::GetInstance().timer_ = std::make_shared(); - int32_t curUserId = 1; - int32_t preUserId = 1; - std::map wifiDevices; - std::vector foregroundUserIds; - std::vector backgroundUserIds; - wifiDevices.insert(std::make_pair("kdmalsalskalw002", "networkId008")); - EXPECT_CALL(*dMCommToolMock_, SendUserIds(_, _, _)).WillOnce(Return(ERR_DM_FAILED)); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitchByWifi(curUserId, preUserId, wifiDevices, - foregroundUserIds, backgroundUserIds); - EXPECT_NE(DeviceManagerService::GetInstance().timer_, nullptr); - - std::string udid = "udid"; - DeviceManagerService::GetInstance().HandleUserSwitchTimeout(curUserId, preUserId, udid); -} - -HWTEST_F(DeviceManagerServiceTest, SendUserIdsByWifi_201, testing::ext::TestSize.Level1) -{ - std::string networkId = "networkId001"; - std::vector foregroundUserIds; - std::vector backgroundUserIds; - foregroundUserIds.push_back(101); - foregroundUserIds.push_back(102); - backgroundUserIds.push_back(103); - backgroundUserIds.push_back(104); - EXPECT_CALL(*dMCommToolMock_, SendUserIds(_, _, _)).WillOnce(Return(ERR_DM_FAILED)); - int32_t ret = DeviceManagerService::GetInstance().SendUserIdsByWifi(networkId, foregroundUserIds, - backgroundUserIds); - EXPECT_EQ(ret, ERR_DM_FAILED); -} - HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_004, testing::ext::TestSize.Level1) { std::string pkgName = "pkgName_004"; @@ -1421,10 +1305,14 @@ HWTEST_F(DeviceManagerServiceTest, GetLocalDisplayDeviceName_202, testing::ext:: { std::string pkgName = "packName"; int32_t maxNameLength = 1; - std::string displayName = "displayName"; + std::string displayName = ""; + std::string deviceName = "displayName"; + EXPECT_CALL(*deviceNameManagerMock_, GetLocalDisplayDeviceName(_, _)) + .WillOnce(DoAll(SetArgReferee<1>(deviceName), Return(0))); EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); int32_t ret = DeviceManagerService::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); - EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(displayName, deviceName); } HWTEST_F(DeviceManagerServiceTest, GetDeviceNamePrefixs_201, testing::ext::TestSize.Level1) @@ -1562,51 +1450,6 @@ HWTEST_F(DeviceManagerServiceTest, UpdateLocalServiceInfo_201, testing::ext::Tes EXPECT_CALL(*deviceProfileConnectorMock_, UpdateLocalServiceInfo(_)).WillOnce(Return(DM_OK)); int32_t ret = DeviceManagerService::GetInstance().UpdateLocalServiceInfo(serviceInfo); EXPECT_EQ(ret, DM_OK); - - std::string localUdid = "localUdid"; - std::vector peerUdids{"kxjasdkaj"}; - std::vector foregroundUserIds{1, 2}; - std::vector backgroundUserIds{1, 2}; - DeviceManagerService::GetInstance().softbusListener_ = std::make_shared(); - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>(""), Return(DM_OK))); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(localUdid, peerUdids, - foregroundUserIds, backgroundUserIds); - - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)) - .WillOnce(DoAll(SetArgReferee<1>("net*****7"), Return(DM_OK))); - EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _)) - .WillOnce(DoAll(SetArgReferee<1>(1), Return(ERR_DM_FAILED))); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(localUdid, peerUdids, - foregroundUserIds, backgroundUserIds); - - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)) - .WillOnce(DoAll(SetArgReferee<1>("net*****7"), Return(DM_OK))); - EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _)) - .WillOnce(DoAll(SetArgReferee<1>(1), Return(DM_OK))); - EXPECT_CALL(*dMCommToolMock_, SendUserIds(_, _, _)).WillOnce(Return(ERR_DM_FAILED)); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(localUdid, peerUdids, - foregroundUserIds, backgroundUserIds); - - EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)) - .WillOnce(DoAll(SetArgReferee<1>("net*****7"), Return(DM_OK))); - EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _)) - .WillOnce(DoAll(SetArgReferee<1>(4), Return(DM_OK))); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(localUdid, peerUdids, - foregroundUserIds, backgroundUserIds); - - std::map wifiDevices; - wifiDevices.insert(std::make_pair("deviceName", "networkwifi")); - EXPECT_CALL(*dMCommToolMock_, SendUserIds(_, _, _)).WillOnce(Return(ERR_DM_FAILED)); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitchByWifi(localUdid, wifiDevices, - foregroundUserIds, backgroundUserIds); - - GTEST_LOG_(INFO) << "NotifyRemoteLocalUserSwitchByWifi SendUserIds is ok" ; - EXPECT_CALL(*dMCommToolMock_, SendUserIds(_, _, _)).WillOnce(Return(DM_OK)); - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitchByWifi(localUdid, wifiDevices, - foregroundUserIds, backgroundUserIds); - GTEST_LOG_(INFO) << "NotifyRemoteLocalUserSwitchByWifi end" ; - sleep(3); - DeviceManagerService::GetInstance().softbusListener_ = nullptr; } HWTEST_F(DeviceManagerServiceTest, GetLocalServiceInfoByBundleNameAndPinExchangeType_201, @@ -1621,40 +1464,6 @@ HWTEST_F(DeviceManagerServiceTest, GetLocalServiceInfoByBundleNameAndPinExchange int32_t ret = DeviceManagerService::GetInstance().GetLocalServiceInfoByBundleNameAndPinExchangeType(bundleName, pinExchangeType, serviceInfo); EXPECT_EQ(ret, DM_OK); - - std::vector foregroundUserVec{1, 2, 3}; - DeviceManagerService::GetInstance().InitDMServiceListener(); - EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)) - .WillOnce(DoAll(SetArgReferee<0>(foregroundUserVec), Return(DM_OK))); - EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*deviceProfileConnectorMock_, CheckAclStatusAndForegroundNotMatch(_, _, _)).WillOnce(Return(false)); - DeviceManagerService::GetInstance().HandleUserSwitched(); - - EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_)) - .WillOnce(DoAll(SetArgReferee<0>(foregroundUserVec), Return(DM_OK))); - EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_)).WillOnce(Return(DM_OK)); - EXPECT_CALL(*deviceProfileConnectorMock_, CheckAclStatusAndForegroundNotMatch(_, _, _)).WillOnce(Return(true)); - std::map curUserDeviceMap; - std::map preUserDeviceMap; - curUserDeviceMap.insert(std::make_pair("curdevice***ww", 10)); - preUserDeviceMap.insert(std::make_pair("preUser******info", 11)); - EXPECT_CALL(*deviceProfileConnectorMock_, - GetDeviceIdAndBindLevel(_, _)).WillOnce(Return(curUserDeviceMap)).WillOnce(Return(preUserDeviceMap)); - DeviceManagerService::GetInstance().HandleUserSwitched(); - - std::string localUdid = "localUdid"; - std::string udid = "u*********90"; - std::vector backgroundUserIds{1, 2, 3}; - DeviceManagerService::GetInstance().HandleUserSwitchTimeout(localUdid, foregroundUserVec, backgroundUserIds, udid); - - std::vector peerUdids; - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(localUdid, peerUdids, foregroundUserVec, - backgroundUserIds); - - DeviceManagerService::GetInstance().softbusListener_ = nullptr; - DeviceManagerService::GetInstance().NotifyRemoteLocalUserSwitch(localUdid, peerUdids, foregroundUserVec, - backgroundUserIds); - DeviceManagerService::GetInstance().UninitDMServiceListener(); } HWTEST_F(DeviceManagerServiceTest, InitDPLocalServiceInfo_001, testing::ext::TestSize.Level0) @@ -1952,9 +1761,22 @@ HWTEST_F(DeviceManagerServiceTest, HandleShareUnbindBroadCast_003, testing::ext: HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceName_201, testing::ext::TestSize.Level1) { - std::string deviceName = ""; - int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceName(deviceName); + std::string deviceName = "123"; + std::string displayName = ""; + EXPECT_CALL(*permissionManagerMock_, CheckReadLocalDeviceName()).WillOnce(Return(true)); + EXPECT_CALL(*deviceNameManagerMock_, GetLocalDisplayDeviceName(_, _)) + .WillOnce(DoAll(SetArgReferee<1>(deviceName), Return(0))); + int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceName(displayName); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(displayName, deviceName); + + displayName = ""; + std::string marketName = "456"; + EXPECT_CALL(*permissionManagerMock_, CheckReadLocalDeviceName()).WillOnce(Return(false)); + EXPECT_CALL(*deviceNameManagerMock_, GetLocalMarketName()).WillOnce(Return(marketName)); + ret = DeviceManagerService::GetInstance().GetLocalDeviceName(displayName); EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(displayName, marketName); } HWTEST_F(DeviceManagerServiceTest, ValidateUnBindDeviceParams_201, testing::ext::TestSize.Level1) diff --git a/test/unittest/mock/device_name_manager_mock.cpp b/test/unittest/mock/device_name_manager_mock.cpp new file mode 100644 index 000000000..21c7ca6c8 --- /dev/null +++ b/test/unittest/mock/device_name_manager_mock.cpp @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "device_name_manager_mock.h" + +#include "gtest/gtest.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(DeviceNameManager); +std::string DeviceNameManager::GetLocalMarketName() +{ + return DmDeviceNameManager::dmDeviceNameManager_->GetLocalMarketName(); +} + +int32_t DeviceNameManager::GetLocalDisplayDeviceName(int32_t maxNamelength, std::string &displayName) +{ + return DmDeviceNameManager::dmDeviceNameManager_->GetLocalDisplayDeviceName(maxNamelength, displayName); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/device_name_manager_mock.h b/test/unittest/mock/device_name_manager_mock.h new file mode 100644 index 000000000..3b34329ce --- /dev/null +++ b/test/unittest/mock/device_name_manager_mock.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef OHOS_DM_DEVICE_NAME_MANAGER_MOCK_H +#define OHOS_DM_DEVICE_NAME_MANAGER_MOCK_H + +#include +#include + +#include "device_name_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class DmDeviceNameManager { +public: + virtual ~DmDeviceNameManager() = default; + virtual std::string GetLocalMarketName() = 0; + virtual int32_t GetLocalDisplayDeviceName(int32_t maxNamelength, std::string &displayName) = 0; + static inline std::shared_ptr dmDeviceNameManager_ = nullptr; +}; + +class DeviceNameManagerMock : public DmDeviceNameManager { +public: + MOCK_METHOD(std::string, GetLocalMarketName, ()); + MOCK_METHOD(int32_t, GetLocalDisplayDeviceName, (int32_t, std::string &)); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_DEVICE_NAME_MANAGER_MOCK_H diff --git a/test/unittest/mock/dm_service_impl_ext_resident_mock.h b/test/unittest/mock/dm_service_impl_ext_resident_mock.h new file mode 100644 index 000000000..b1b7291fe --- /dev/null +++ b/test/unittest/mock/dm_service_impl_ext_resident_mock.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef OHOS_DM_SERVICE_IMPL_EXT_RESIDENT_MOCK_H +#define OHOS_DM_SERVICE_IMPL_EXT_RESIDENT_MOCK_H + +#include +#include + +#include "i_dm_service_impl_ext_resident.h" + +namespace OHOS { +namespace DistributedHardware { +class DMServiceImplExtResidentMock : public IDMServiceImplExtResident { +public: + MOCK_METHOD(int32_t, Initialize, (const std::shared_ptr &)); + MOCK_METHOD(int32_t, Release, ()); + MOCK_METHOD(bool, IsDMServiceAdapterLoad, ()); + MOCK_METHOD(bool, IsDMServiceAdapterSoLoaded, ()); + MOCK_METHOD(int32_t, BindTargetExt, (const std::string &, const PeerTargetId &, + (const std::map &))); + MOCK_METHOD(int32_t, UnbindTargetExt, (const std::string &, const PeerTargetId &, + (const std::map &))); + MOCK_METHOD(int32_t, HandleDeviceStatusChange, (DmDeviceState, const DmDeviceInfo &)); + MOCK_METHOD(int32_t, ReplyUiAction, (const std::string &, int32_t, const std::string &)); + MOCK_METHOD(int32_t, AccountIdLogout, (int32_t, const std::string &, (const std::vector &))); + MOCK_METHOD(void, HandleDeviceNotTrust, (const std::string &)); + MOCK_METHOD(int32_t, SetDnPolicy, (int32_t, int32_t)); + MOCK_METHOD(int32_t, AccountUserSwitched, (int32_t, const std::string &)); + MOCK_METHOD(int32_t, GetDeviceProfileInfoList, (const std::string &, const DmDeviceProfileInfoFilterOptions &)); + MOCK_METHOD(int32_t, GetDeviceIconInfo, (const std::string &, const DmDeviceIconInfoFilterOptions &)); + MOCK_METHOD(int32_t, PutDeviceProfileInfoList, (const std::string &, + (const std::vector &))); + MOCK_METHOD((std::vector), GetDeviceNamePrefixs, ()); + MOCK_METHOD(void, HandleNetworkConnected, (int32_t)); + MOCK_METHOD(int32_t, SetLocalDeviceName, (const std::string &, const std::string &)); + MOCK_METHOD(int32_t, SetRemoteDeviceName, (const std::string &, const std::string &, const std::string &)); + MOCK_METHOD(int32_t, GetDeviceProfileInfosFromLocalCache, (const NetworkIdQueryFilter &, + (std::vector &))); + MOCK_METHOD(int32_t, RestoreLocalDeviceName, ()); + MOCK_METHOD(void, ClearCacheWhenLogout, (int32_t, const std::string &)); + MOCK_METHOD(void, HandleScreenLockEvent, (bool)); + MOCK_METHOD(int32_t, OpenAuthSessionWithPara, (const std::string &, int32_t, bool)); + MOCK_METHOD(void, HandleUserSwitchEvent, (int32_t, int32_t)); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_SERVICE_IMPL_EXT_RESIDENT_MOCK_H diff --git a/test/unittest/mock/permission_manager_mock.cpp b/test/unittest/mock/permission_manager_mock.cpp index becbab5e6..675b86e1b 100644 --- a/test/unittest/mock/permission_manager_mock.cpp +++ b/test/unittest/mock/permission_manager_mock.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -69,5 +69,10 @@ bool PermissionManager::CheckProcessNameValidPutDeviceProfileInfoList(const std: { return DmPermissionManager::dmPermissionManager->CheckProcessNameValidPutDeviceProfileInfoList(processName); } + +bool PermissionManager::CheckReadLocalDeviceName() +{ + return DmPermissionManager::dmPermissionManager->CheckReadLocalDeviceName(); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/permission_manager_mock.h b/test/unittest/mock/permission_manager_mock.h index 29bb5ba51..7cef7f02b 100644 --- a/test/unittest/mock/permission_manager_mock.h +++ b/test/unittest/mock/permission_manager_mock.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Huawei Device Co., Ltd. + * Copyright (C) 2024-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -36,6 +36,7 @@ public: virtual bool CheckProcessNameValidModifyLocalDeviceName(const std::string &processName) = 0; virtual bool CheckProcessNameValidModifyRemoteDeviceName(const std::string &processName) = 0; virtual bool CheckProcessNameValidPutDeviceProfileInfoList(const std::string &processName) = 0; + virtual bool CheckReadLocalDeviceName() = 0; public: static inline std::shared_ptr dmPermissionManager = nullptr; }; @@ -52,6 +53,7 @@ public: MOCK_METHOD(bool, CheckProcessNameValidModifyLocalDeviceName, (const std::string &)); MOCK_METHOD(bool, CheckProcessNameValidModifyRemoteDeviceName, (const std::string &)); MOCK_METHOD(bool, CheckProcessNameValidPutDeviceProfileInfoList, (const std::string &)); + MOCK_METHOD(bool, CheckReadLocalDeviceName, ()); }; } } -- Gitee