From 90f1be113362904768634ef1391910a343bcebcd Mon Sep 17 00:00:00 2001 From: yangwei_814916 Date: Fri, 19 Jan 2024 16:47:16 +0800 Subject: [PATCH 1/5] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=BC=80=E6=9C=BA?= =?UTF-8?q?=E5=86=85=E5=AD=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yangwei_814916 --- services/implementation/BUILD.gn | 3 - .../include/device_manager_service_impl.h | 7 - .../src/device_manager_service_impl.cpp | 49 -- services/service/BUILD.gn | 6 + .../service/include/device_manager_service.h | 2 + .../include/idevice_manager_service_impl.h | 43 -- .../service/include/pinholder/pin_holder.h | 77 +++ .../include/pinholder/pin_holder_session.h | 81 ++++ .../softbus/pinholder_session_callback.h | 29 ++ .../service/src/device_manager_service.cpp | 43 +- services/service/src/pinholder/pin_holder.cpp | 453 ++++++++++++++++++ .../src/pinholder/pin_holder_session.cpp | 152 ++++++ .../pinholder_fuzzer/pinholder_fuzzer.cpp | 1 + test/unittest/UTTest_device_manager_service.h | 6 - test/unittest/UTTest_dm_pin_holder.cpp | 157 ++++++ test/unittest/UTTest_dm_pin_holder.h | 1 + 16 files changed, 972 insertions(+), 138 deletions(-) create mode 100644 services/service/include/pinholder/pin_holder.h create mode 100644 services/service/include/pinholder/pin_holder_session.h create mode 100644 services/service/include/softbus/pinholder_session_callback.h create mode 100644 services/service/src/pinholder/pin_holder.cpp create mode 100644 services/service/src/pinholder/pin_holder_session.cpp diff --git a/services/implementation/BUILD.gn b/services/implementation/BUILD.gn index 877a06acc..492dfa882 100644 --- a/services/implementation/BUILD.gn +++ b/services/implementation/BUILD.gn @@ -120,7 +120,6 @@ if (defined(ohos_lite)) { "include/dependency/multipleuser", "include/dependency/hichain", "include/dependency/softbus", - "include/pinholder", "${common_path}/include", "${common_path}/include/ipc", "${common_path}/include/ipc/model", @@ -173,8 +172,6 @@ if (defined(ohos_lite)) { "src/devicestate/dm_device_state_manager.cpp", "src/discovery/dm_discovery_filter.cpp", "src/discovery/dm_discovery_manager.cpp", - "src/pinholder/dm_pin_holder.cpp", - "src/pinholder/pin_holder_session.cpp", "src/publish/dm_publish_manager.cpp", ] diff --git a/services/implementation/include/device_manager_service_impl.h b/services/implementation/include/device_manager_service_impl.h index bb17cd052..ce6a35ee8 100644 --- a/services/implementation/include/device_manager_service_impl.h +++ b/services/implementation/include/device_manager_service_impl.h @@ -27,7 +27,6 @@ #include "dm_device_info.h" #include "dm_device_state_manager.h" #include "dm_discovery_manager.h" -#include "dm_pin_holder.h" #include "dm_publish_manager.h" #include "idevice_manager_service_impl.h" #include "single_instance.h" @@ -123,11 +122,6 @@ public: int32_t BindTarget(const std::string &pkgName, const PeerTargetId &targetId, const std::map &bindParam); - int32_t RegisterPinHolderCallback(const std::string &pkgName); - int32_t CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload); - int32_t DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload); std::map GetAppTrustDeviceIdList(std::string pkgname); void OnUnbindSessionOpened(int32_t sessionId, int32_t result); void OnUnbindSessionCloseed(int32_t sessionId); @@ -152,7 +146,6 @@ private: std::shared_ptr mineHiChainConnector_; std::shared_ptr credentialMgr_; std::shared_ptr commonEventManager_; - std::shared_ptr pinHolder_; std::shared_ptr hiChainAuthConnector_; }; diff --git a/services/implementation/src/device_manager_service_impl.cpp b/services/implementation/src/device_manager_service_impl.cpp index bdad391a9..11288a8bc 100644 --- a/services/implementation/src/device_manager_service_impl.cpp +++ b/services/implementation/src/device_manager_service_impl.cpp @@ -80,9 +80,6 @@ int32_t DeviceManagerServiceImpl::Initialize(const std::shared_ptr(hiChainConnector_, listener); } - if (pinHolder_ == nullptr) { - pinHolder_ = std::make_shared(listener); - } int32_t userId = MultipleUserConnector::GetCurrentAccountUserID(); if (userId > 0) { @@ -361,21 +358,6 @@ void DeviceManagerServiceImpl::OnBytesReceived(int sessionId, const void *data, SoftbusSession::OnBytesReceived(sessionId, data, dataLen); } -int DeviceManagerServiceImpl::OnPinHolderSessionOpened(int sessionId, int result) -{ - return PinHolderSession::OnSessionOpened(sessionId, result); -} - -void DeviceManagerServiceImpl::OnPinHolderSessionClosed(int sessionId) -{ - PinHolderSession::OnSessionClosed(sessionId); -} - -void DeviceManagerServiceImpl::OnPinHolderBytesReceived(int sessionId, const void *data, unsigned int dataLen) -{ - PinHolderSession::OnBytesReceived(sessionId, data, dataLen); -} - int32_t DeviceManagerServiceImpl::RequestCredential(const std::string &reqJsonStr, std::string &returnJsonStr) { if (reqJsonStr.empty()) { @@ -628,37 +610,6 @@ int32_t DeviceManagerServiceImpl::ExportAuthCode(std::string &authCode) return DM_OK; } -int32_t DeviceManagerServiceImpl::RegisterPinHolderCallback(const std::string &pkgName) -{ - if (pkgName.empty()) { - LOGE("RegisterPinHolderCallback failed, pkgName is empty"); - return ERR_DM_INPUT_PARA_INVALID; - } - return pinHolder_->RegisterPinHolderCallback(pkgName); -} - -int32_t DeviceManagerServiceImpl::CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload) -{ - if (pkgName.empty()) { - LOGE("CreatePinHolder failed, pkgName is empty"); - return ERR_DM_INPUT_PARA_INVALID; - } - - return pinHolder_->CreatePinHolder(pkgName, targetId, pinType, payload); -} - -int32_t DeviceManagerServiceImpl::DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload) -{ - if (pkgName.empty()) { - LOGE("DestroyPinHolder failed, pkgName is empty"); - return ERR_DM_INPUT_PARA_INVALID; - } - - return pinHolder_->DestroyPinHolder(pkgName, targetId, pinType, payload); -} - int32_t DeviceManagerServiceImpl::BindTarget(const std::string &pkgName, const PeerTargetId &targetId, const std::map &bindParam) { diff --git a/services/service/BUILD.gn b/services/service/BUILD.gn index c740fb0dc..3678f3851 100644 --- a/services/service/BUILD.gn +++ b/services/service/BUILD.gn @@ -29,6 +29,7 @@ if (defined(ohos_lite)) { "include/softbus", "include/ipc/lite", "include/permission/lite", + "include/pinholder", "${common_path}/include", "${common_path}/include/ipc", "${common_path}/include/ipc/lite", @@ -65,6 +66,8 @@ if (defined(ohos_lite)) { "src/ipc/lite/ipc_server_main.cpp", "src/ipc/lite/ipc_server_stub.cpp", "src/permission/lite/permission_manager.cpp", + "src/pinholder/dm_pin_holder.cpp", + "src/pinholder/pin_holder_session.cpp", "src/softbus/softbus_listener.cpp", ] @@ -112,6 +115,7 @@ if (defined(ohos_lite)) { "include/ipc", "include/ipc/standard", "include/permission/standard", + "include/pinholder", "include/softbus", "${common_path}/include", "${common_path}/include/dfx", @@ -157,6 +161,8 @@ if (defined(ohos_lite)) { "src/ipc/standard/ipc_server_listener.cpp", "src/ipc/standard/ipc_server_stub.cpp", "src/permission/standard/permission_manager.cpp", + "src/pinholder/dm_pin_holder.cpp", + "src/pinholder/pin_holder_session.cpp", "src/softbus/softbus_listener.cpp", ] diff --git a/services/service/include/device_manager_service.h b/services/service/include/device_manager_service.h index b22fefb2b..35ec0e50d 100644 --- a/services/service/include/device_manager_service.h +++ b/services/service/include/device_manager_service.h @@ -26,6 +26,7 @@ #include "advertise_manager.h" #include "discovery_manager.h" +#include "pin_holder.h" #include "device_manager_service_listener.h" #include "idevice_manager_service_impl.h" #include "i_dm_service_impl_ext.h" @@ -209,6 +210,7 @@ private: std::shared_ptr dmServiceImpl_; std::shared_ptr dmServiceImplExt_; std::string localDeviceId_; + std::shared_ptr pinHolder_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/include/idevice_manager_service_impl.h b/services/service/include/idevice_manager_service_impl.h index 21dc8d0fb..689a747da 100644 --- a/services/service/include/idevice_manager_service_impl.h +++ b/services/service/include/idevice_manager_service_impl.h @@ -145,27 +145,6 @@ public: */ virtual void OnBytesReceived(int sessionId, const void *data, unsigned int dataLen) = 0; - /** - * @tc.name: IDeviceManagerServiceImpl::OnPinHolderSessionOpened - * @tc.desc: Send Session Opened event to the device manager service impl - * @tc.type: FUNC - */ - virtual int OnPinHolderSessionOpened(int sessionId, int result) = 0; - - /** - * @tc.name: IDeviceManagerServiceImpl::OnPinHolderSessionClosed - * @tc.desc: Send Session Closed event to the device manager service impl - * @tc.type: FUNC - */ - virtual void OnPinHolderSessionClosed(int sessionId) = 0; - - /** - * @tc.name: IDeviceManagerServiceImpl::OnPinHolderBytesReceived - * @tc.desc: Send Bytes Received event to the device manager service impl - * @tc.type: FUNC - */ - virtual void OnPinHolderBytesReceived(int sessionId, const void *data, unsigned int dataLen) = 0; - /** * @tc.name: IDeviceManagerServiceImpl::RequestCredential * @tc.desc: RequestCredential of the Device Manager Service @@ -288,28 +267,6 @@ public: */ virtual int32_t UnRegisterUiStateCallback(const std::string &pkgName) = 0; - /** - * @tc.name: IDeviceManagerServiceImpl::RegisterPinHolderCallback - * @tc.desc: RegisterPinHolderCallback - * @tc.type: FUNC - */ - virtual int32_t RegisterPinHolderCallback(const std::string &pkgName) = 0; - - /** - * @tc.name: IDeviceManagerServiceImpl::CreatePinHolder - * @tc.desc: CreatePinHolder - * @tc.type: FUNC - */ - virtual int32_t CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload) = 0; - - /** - * @tc.name: IDeviceManagerServiceImpl::DestroyPinHolder - * @tc.desc: DestroyPinHolder - * @tc.type: FUNC - */ - virtual int32_t DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload) = 0; virtual std::map GetAppTrustDeviceIdList(std::string pkgname) = 0; virtual void OnUnbindSessionOpened(int32_t sessionId, int32_t result) = 0; virtual void OnUnbindSessionCloseed(int32_t sessionId) = 0; diff --git a/services/service/include/pinholder/pin_holder.h b/services/service/include/pinholder/pin_holder.h new file mode 100644 index 000000000..e85572388 --- /dev/null +++ b/services/service/include/pinholder/pin_holder.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2024 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_PIN_HOLDER_H +#define OHOS_DM_PIN_HOLDER_H + +#include "dm_timer.h" +#include "idevice_manager_service_listener.h" +#include "pin_holder_session.h" + +#include +#include + +namespace OHOS { +namespace DistributedHardware { +typedef enum PinHolderState { + SOURCE_INIT = 1, + SOURCE_CREATE, + SOURCE_DESTROY, + SINK_INIT = 20, + SINK_CREATE, + SINK_DESTROY, +} PinHolderState; + +class PinHolder final : public IPinholderSessionCallback, + public std::enable_shared_from_this { +public: + PinHolder(std::shared_ptr listener); + ~PinHolder(); + int32_t RegisterPinHolderCallback(const std::string &pkgName); + int32_t CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId, + DmPinType pinType, const std::string &payload); + int32_t DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, + DmPinType pinType, const std::string &payload); +public: + void OnSessionOpened(int32_t sessionId, int32_t sessionSide, int32_t result); + void OnSessionClosed(int32_t sessionId); + void OnDataReceived(int32_t sessionId, std::string message); + +private: + int32_t CreateGeneratePinHolderMsg(); + int32_t ParseMsgType(const std::string &message); + void ProcessCreateMsg(const std::string &message); + void ProcessCreateRespMsg(const std::string &message); + void ProcessDestroyMsg(const std::string &message); + void ProcessDestroyResMsg(const std::string &message); + void CloseSession(const std::string &name); + void GetPeerDeviceId(int32_t sessionId, std::string &udidHash); + int32_t CheckTargetIdVaild(const PeerTargetId &targetId); +private: + std::shared_ptr listener_ = nullptr; + std::shared_ptr session_ = nullptr; + std::shared_ptr timer_ = nullptr; + + std::string registerPkgName_ = ""; + std::string remoteDeviceId_ = ""; + std::string payload_ = ""; + DmPinType pinType_; + PinHolderState sinkState_; + PinHolderState sourceState_; + int32_t sessionId_ = -1; +}; +} +} +#endif // OHOS_DM_PIN_HOLDER_H \ No newline at end of file diff --git a/services/service/include/pinholder/pin_holder_session.h b/services/service/include/pinholder/pin_holder_session.h new file mode 100644 index 000000000..abcc94085 --- /dev/null +++ b/services/service/include/pinholder/pin_holder_session.h @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2024 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_PIN_HOLDER_SESSION_H +#define OHOS_PIN_HOLDER_SESSION_H + +#include "dm_device_info.h" +#include "pinholder_session_callback.h" + +#include "inner_session.h" +#include "session.h" +#include "softbus_bus_center.h" + +namespace OHOS { +namespace DistributedHardware { +class PinHolderSession { +public: + static int OnSessionOpened(int sessionId, int result); + static void OnSessionClosed(int sessionId); + static void OnBytesReceived(int sessionId, const void *data, unsigned int dataLen); + +public: + PinHolderSession(); + ~PinHolderSession(); + + /** + * @tc.name: PinHolderSession::RegisterSessionCallback + * @tc.desc: RegisterSessionCallback of the Softbus Session + * @tc.type: FUNC + */ + int32_t RegisterSessionCallback(std::shared_ptr callback); + + /** + * @tc.name: PinHolderSession::UnRegisterSessionCallback + * @tc.desc: UnRegister SessionCallback of the Softbus Session + * @tc.type: FUNC + */ + int32_t UnRegisterSessionCallback(); + + /** + * @tc.name: PinHolderSession::OpenAuthSession + * @tc.desc: Open AuthSession of the Softbus Session + * @tc.type: FUNC + */ + int32_t OpenSessionServer(const PeerTargetId &targetId); + + /** + * @tc.name: PinHolderSession::CloseAuthSession + * @tc.desc: Close AuthSession of the Softbus Session + * @tc.type: FUNC + */ + int32_t CloseSessionServer(int32_t sessionId); + + /** + * @tc.name: PinHolderSession::SendData + * @tc.desc: Send Data of the Softbus Session + * @tc.type: FUNC + */ + int32_t SendData(int32_t sessionId, const std::string &message); + +private: + int32_t GetAddrByTargetId(const PeerTargetId &targetId, ConnectionAddr &addrInfo); + +private: + static std::shared_ptr sessionCallback_; +}; +} +} +#endif // OHOS_PIN_HOLDER_SESSION_H \ No newline at end of file diff --git a/services/service/include/softbus/pinholder_session_callback.h b/services/service/include/softbus/pinholder_session_callback.h new file mode 100644 index 000000000..b7f579aba --- /dev/null +++ b/services/service/include/softbus/pinholder_session_callback.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2024 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_SOFTBUS_SESSION_CALLBACK_H +#define OHOS_DM_SOFTBUS_SESSION_CALLBACK_H + +namespace OHOS { +namespace DistributedHardware { +class IPinholderSessionCallback { +public: + virtual void OnSessionOpened(int32_t sessionId, int32_t sessionSide, int32_t result) = 0; + virtual void OnSessionClosed(int32_t sessionId) = 0; + virtual void OnDataReceived(int32_t sessionId, std::string message) = 0; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_SOFTBUS_SESSION_CALLBACK_H diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp index 5fdbbf6cf..1603ef199 100755 --- a/services/service/src/device_manager_service.cpp +++ b/services/service/src/device_manager_service.cpp @@ -80,6 +80,10 @@ int32_t DeviceManagerService::InitDMServiceListener() if (discoveryMgr_ == nullptr) { discoveryMgr_ = std::make_shared(softbusListener_, listener_); } + if (pinHolder_ == nullptr) { + pinHolder_ = std::make_shared(listener_); + } + LOGI("DeviceManagerServiceListener init success."); return DM_OK; } @@ -573,29 +577,20 @@ void DeviceManagerService::OnBytesReceived(int sessionId, const void *data, unsi int DeviceManagerService::OnPinHolderSessionOpened(int sessionId, int result) { - if (!IsDMServiceImplReady()) { - LOGE("OnPinHolderSessionOpened failed, instance not init or init failed."); - return ERR_DM_NOT_INIT; - } - return dmServiceImpl_->OnPinHolderSessionOpened(sessionId, result); + LOGI("DeviceManagerService::OnPinHolderSessionOpened"); + return PinHolderSession::OnSessionOpened(sessionId, result); } void DeviceManagerService::OnPinHolderSessionClosed(int sessionId) { - if (!IsDMServiceImplReady()) { - LOGE("OnPinHolderSessionClosed failed, instance not init or init failed."); - return; - } - dmServiceImpl_->OnPinHolderSessionClosed(sessionId); + LOGI("DeviceManagerService::OnPinHolderSessionClosed"); + PinHolderSession::OnSessionClosed(sessionId); } void DeviceManagerService::OnPinHolderBytesReceived(int sessionId, const void *data, unsigned int dataLen) { - if (!IsDMServiceImplReady()) { - LOGE("OnPinHolderBytesReceived failed, instance not init or init failed."); - return; - } - dmServiceImpl_->OnPinHolderBytesReceived(sessionId, data, dataLen); + LOGI("DeviceManagerService::OnPinHolderBytesReceived"); + PinHolderSession::OnBytesReceived(sessionId, data, dataLen); } int32_t DeviceManagerService::RequestCredential(const std::string &reqJsonStr, std::string &returnJsonStr) @@ -1228,11 +1223,7 @@ int32_t DeviceManagerService::RegisterPinHolderCallback(const std::string &pkgNa LOGE("Invalid parameter, pkgName: %s.", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } - if (!IsDMServiceImplReady()) { - LOGE("RegisterPinHolderCallback failed, instance not init or init failed."); - return ERR_DM_NOT_INIT; - } - return dmServiceImpl_->RegisterPinHolderCallback(pkgName); + return pinHolder_->RegisterPinHolderCallback(pkgName); } int32_t DeviceManagerService::CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId, @@ -1256,11 +1247,7 @@ int32_t DeviceManagerService::CreatePinHolder(const std::string &pkgName, const LOGE("Invalid parameter, pkgName: %s.", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } - if (!IsDMServiceImplReady()) { - LOGE("CreatePinHolder failed, instance not init or init failed."); - return ERR_DM_NOT_INIT; - } - return dmServiceImpl_->CreatePinHolder(pkgName, targetId, pinType, payload); + return pinHolder_->CreatePinHolder(pkgName, targetId, pinType, payload); } int32_t DeviceManagerService::DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, @@ -1284,11 +1271,7 @@ int32_t DeviceManagerService::DestroyPinHolder(const std::string &pkgName, const LOGE("Invalid parameter, pkgName: %s.", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } - if (!IsDMServiceImplReady()) { - LOGE("DestroyPinHolder failed, instance not init or init failed."); - return ERR_DM_NOT_INIT; - } - return dmServiceImpl_->DestroyPinHolder(pkgName, targetId, pinType, payload); + return pinHolder_->DestroyPinHolder(pkgName, targetId, pinType, payload); } void DeviceManagerService::OnUnbindSessionOpened(int32_t sessionId, int32_t result) diff --git a/services/service/src/pinholder/pin_holder.cpp b/services/service/src/pinholder/pin_holder.cpp new file mode 100644 index 000000000..8b8afce79 --- /dev/null +++ b/services/service/src/pinholder/pin_holder.cpp @@ -0,0 +1,453 @@ +/* + * Copyright (c) 2024 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 "pin_holder.h" + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "dm_softbus_adapter_crypto.h" +#include "nlohmann/json.hpp" +#include "parameter.h" + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t SESSION_SIDE_SERVER = 0; +constexpr int32_t SESSION_ID_INVALID = -1; +constexpr int32_t REPLY_SUCCESS = 0; +constexpr int32_t REPLY_FAILED = -1; + +constexpr int32_t MSG_TYPE_CREATE_PIN_HOLDER = 600; +constexpr int32_t MSG_TYPE_CREATE_PIN_HOLDER_RESP = 601; +constexpr int32_t MSG_TYPE_DESTROY_PIN_HOLDER = 650; +constexpr int32_t MSG_TYPE_DESTROY_PIN_HOLDER_RESP = 651; + +constexpr const char* PINHOLDER_CREATE_TIMEOUT_TASK = "deviceManagerTimer:pinholdercreate"; +constexpr int32_t PIN_HOLDER_SESSION_CREATE_TIMEOUT = 60; + +constexpr const char* TAG_PIN_TYPE = "PIN_TYPE"; +constexpr const char* TAG_PAYLOAD = "PAYLOAD"; +constexpr const char* TAG_REPLY = "REPLY"; +PinHolder::PinHolder(std::shared_ptr listener): listener_(listener) +{ + if (session_ == nullptr) { + session_ = std::make_shared(); + } + if (timer_ == nullptr) { + timer_ = std::make_shared(); + } + sinkState_ = SINK_INIT; + sourceState_ = SOURCE_INIT; +} + +PinHolder::~PinHolder() +{ + if (session_ != nullptr) { + session_->UnRegisterSessionCallback(); + session_ = nullptr; + } + if (timer_ != nullptr) { + timer_->DeleteAll(); + timer_ = nullptr; + } +} + +int32_t PinHolder::RegisterPinHolderCallback(const std::string &pkgName) +{ + if (session_ == nullptr) { + LOGE("RegisterPinHolderCallback session is nullptr."); + return ERR_DM_FAILED; + } + registerPkgName_ = pkgName; + session_->RegisterSessionCallback(shared_from_this()); + return DM_OK; +} + +int32_t PinHolder::CreatePinHolder(const std::string &pkgName, + const PeerTargetId &targetId, DmPinType pinType, const std::string &payload) +{ + LOGI("CreatePinHolder."); + if (registerPkgName_.empty() || registerPkgName_ != pkgName) { + LOGE("CreatePinHolder pkgName: %s is not register callback.", pkgName.c_str()); + return ERR_DM_FAILED; + } + int32_t ret = CheckTargetIdVaild(targetId); + if (ret != DM_OK) { + LOGE("CreatePinHolder targetId is invalid."); + return ret; + } + + if (listener_ == nullptr || session_ == nullptr) { + LOGE("CreatePinHolder listener or session is nullptr."); + return ERR_DM_FAILED; + } + + if (sourceState_ != SOURCE_INIT) { + LOGE("CreatePinHolder failed, state is %d.", sourceState_); + return ERR_DM_FAILED; + } + + if (sessionId_ != SESSION_ID_INVALID) { + LOGI("CreatePinHolder session already create, sessionId: %d.", sessionId_); + CreateGeneratePinHolderMsg(); + return DM_OK; + } + + sessionId_ = session_->OpenSessionServer(targetId); + if (sessionId_ < 0) { + LOGE("[SOFTBUS]open session error, sessionId: %d.", sessionId_); + sessionId_ = SESSION_ID_INVALID; + listener_->OnCreateResult(registerPkgName_, ERR_DM_AUTH_OPEN_SESSION_FAILED); + return ERR_DM_AUTH_OPEN_SESSION_FAILED; + } + pinType_ = pinType; + payload_ = payload; + return DM_OK; +} + +int32_t PinHolder::DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, DmPinType pinType, + const std::string &payload) +{ + LOGI("DestroyPinHolder."); + if (listener_ == nullptr || session_ == nullptr) { + LOGE("DestroyPinHolder listener or session is nullptr."); + return ERR_DM_FAILED; + } + + if (registerPkgName_.empty() || pkgName != registerPkgName_) { + LOGE("DestroyPinHolder pkgName: %s is not register callback.", pkgName.c_str()); + return ERR_DM_FAILED; + } + + int32_t ret = CheckTargetIdVaild(targetId); + if (ret != DM_OK) { + LOGE("DestroyPinHolder targetId is invalid."); + return ret; + } + + if (sessionId_ == SESSION_ID_INVALID) { + LOGI("DestroyPinHolder session already destroy."); + listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED); + return ERR_DM_FAILED; + } + if (sourceState_ != SOURCE_CREATE) { + LOGE("DestroyPinHolder failed, state is %d.", sourceState_); + return ERR_DM_FAILED; + } + + timer_->DeleteTimer(PINHOLDER_CREATE_TIMEOUT_TASK); + + nlohmann::json jsonObj; + jsonObj[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER; + jsonObj[TAG_PIN_TYPE] = pinType; + jsonObj[TAG_PAYLOAD] = payload; + pinType_ = pinType; + std::string message = jsonObj.dump(); + LOGI("DestroyPinHolder, message type is: %d, pin type is: %d.", MSG_TYPE_DESTROY_PIN_HOLDER, pinType); + ret = session_->SendData(sessionId_, message); + if (ret != DM_OK) { + LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); + listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED); + return ERR_DM_FAILED; + } + return ret; +} + +int32_t PinHolder::CreateGeneratePinHolderMsg() +{ + if (listener_ == nullptr || session_ == nullptr) { + LOGE("CreateGeneratePinHolderMsg listener or session is nullptr."); + return ERR_DM_FAILED; + } + + timer_->DeleteAll(); + timer_->StartTimer(std::string(PINHOLDER_CREATE_TIMEOUT_TASK), PIN_HOLDER_SESSION_CREATE_TIMEOUT, + [this] (std::string name) { + PinHolder::CloseSession(name); + }); + nlohmann::json jsonObj; + jsonObj[TAG_PIN_TYPE] = pinType_; + jsonObj[TAG_PAYLOAD] = payload_; + jsonObj[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER; + std::string message = jsonObj.dump(); + LOGI("CreateGeneratePinHolderMsg, message type is: %d, pin type is: %d.", MSG_TYPE_CREATE_PIN_HOLDER, pinType_); + int32_t ret = session_->SendData(sessionId_, message); + if (ret != DM_OK) { + LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); + listener_->OnCreateResult(registerPkgName_, ERR_DM_FAILED); + return ERR_DM_FAILED; + } + return ret; +} + +int32_t PinHolder::ParseMsgType(const std::string &message) +{ + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("ParseMsgType DecodeRequest jsonStr error"); + return ERR_DM_FAILED; + } + if (!IsInt32(jsonObject, TAG_MSG_TYPE)) { + LOGE("ParseMsgType err json string."); + return ERR_DM_FAILED; + } + int32_t msgType = jsonObject[TAG_MSG_TYPE].get(); + return msgType; +} + +void PinHolder::ProcessCreateMsg(const std::string &message) +{ + if (listener_ == nullptr || session_ == nullptr) { + LOGE("ProcessCreateMsg listener or session is nullptr."); + return; + } + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("ProcessCreateMsg DecodeRequest jsonStr error"); + return; + } + if (!IsInt32(jsonObject, TAG_PIN_TYPE) || !IsString(jsonObject, TAG_PAYLOAD)) { + LOGE("ProcessCreateMsg err json string."); + return; + } + DmPinType pinType = static_cast(jsonObject[TAG_PIN_TYPE].get()); + std::string payload = jsonObject[TAG_PAYLOAD].get(); + + nlohmann::json jsonObj; + jsonObj[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER_RESP; + if (sinkState_ != SINK_INIT) { + jsonObj[TAG_REPLY] = REPLY_FAILED; + } else { + jsonObj[TAG_REPLY] = REPLY_SUCCESS; + sinkState_ = SINK_CREATE; + sourceState_ = SOURCE_CREATE; + listener_->OnPinHolderCreate(registerPkgName_, remoteDeviceId_, pinType, payload); + } + + std::string msg = jsonObj.dump(); + LOGI("ProcessCreateMsg, message type is: %d.", MSG_TYPE_CREATE_PIN_HOLDER_RESP); + int32_t ret = session_->SendData(sessionId_, msg); + if (ret != DM_OK) { + LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); + return; + } +} + +void PinHolder::ProcessCreateRespMsg(const std::string &message) +{ + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("ProcessCreateRespMsg DecodeRequest jsonStr error."); + return; + } + if (!IsInt32(jsonObject, TAG_REPLY)) { + LOGE("ProcessCreateRespMsg err json string."); + return; + } + int32_t reply = jsonObject[TAG_REPLY].get(); + if (listener_ == nullptr || session_ == nullptr) { + LOGE("ProcessCreateRespMsg listener or session is nullptr."); + return; + } + if (reply == REPLY_SUCCESS) { + listener_->OnCreateResult(registerPkgName_, DM_OK); + sourceState_ = SOURCE_CREATE; + sinkState_ = SINK_CREATE; + } else { + LOGE("ProcessCreateRespMsg remote state is wrong."); + listener_->OnCreateResult(registerPkgName_, ERR_DM_FAILED); + session_->CloseSessionServer(sessionId_); + } +} + +void PinHolder::ProcessDestroyMsg(const std::string &message) +{ + if (listener_ == nullptr || session_ == nullptr) { + LOGE("ProcessDestroyMsg listener or session is nullptr."); + return; + } + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("ProcessDestroyMsg DecodeRequest jsonStr error."); + return; + } + if (!IsInt32(jsonObject, TAG_PIN_TYPE) || !IsString(jsonObject, TAG_PAYLOAD)) { + LOGE("ProcessDestroyMsg err json string."); + return; + } + DmPinType pinType = static_cast(jsonObject[TAG_PIN_TYPE].get()); + std::string payload = jsonObject[TAG_PAYLOAD].get(); + + nlohmann::json jsonObj; + jsonObj[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER_RESP; + if (sinkState_ != SINK_CREATE) { + jsonObj[TAG_REPLY] = REPLY_FAILED; + } else { + jsonObj[TAG_REPLY] = REPLY_SUCCESS; + sinkState_ = SINK_INIT; + sourceState_ = SOURCE_INIT; + listener_->OnPinHolderDestroy(registerPkgName_, pinType, payload); + } + + std::string msg = jsonObj.dump(); + LOGI("ProcessDestroyMsg, message type is: %d.", MSG_TYPE_DESTROY_PIN_HOLDER_RESP); + int32_t ret = session_->SendData(sessionId_, msg); + if (ret != DM_OK) { + LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); + return; + } +} + +void PinHolder::CloseSession(const std::string &name) +{ + LOGI("PinHolder::CloseSession start timer name %s.", name.c_str()); + if (session_ == nullptr) { + LOGE("CloseSession session is nullptr."); + return; + } + nlohmann::json jsonObj; + jsonObj[DM_CONNECTION_DISCONNECTED] = true; + std::string payload = jsonObj.dump(); + if (listener_ != nullptr) { + listener_->OnPinHolderDestroy(registerPkgName_, pinType_, payload); + } + session_->CloseSessionServer(sessionId_); + timer_->DeleteAll(); + sessionId_ = SESSION_ID_INVALID; + sinkState_ = SINK_INIT; + sourceState_ = SOURCE_INIT; + remoteDeviceId_ = ""; +} + +void PinHolder::ProcessDestroyResMsg(const std::string &message) +{ + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("ProcessDestroyResMsg DecodeRequest jsonStr error."); + return; + } + if (!IsInt32(jsonObject, TAG_REPLY)) { + LOGE("ProcessDestroyResMsg err json string."); + return; + } + int32_t reply = jsonObject[TAG_REPLY].get(); + if (listener_ == nullptr || session_ == nullptr) { + LOGE("ProcessDestroyResMsg listener or session is nullptr."); + return; + } + if (reply == REPLY_SUCCESS) { + listener_->OnDestroyResult(registerPkgName_, DM_OK); + sourceState_ = SOURCE_INIT; + sinkState_ = SINK_INIT; + CloseSession(registerPkgName_); + } else { + LOGE("ProcessDestroyResMsg remote state is wrong."); + listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED); + session_->CloseSessionServer(sessionId_); + } +} + +void PinHolder::OnDataReceived(int32_t sessionId, std::string message) +{ + int32_t msgType = ParseMsgType(message); + LOGI("OnDataReceived, msgType: %d.", msgType); + + switch (msgType) { + case MSG_TYPE_CREATE_PIN_HOLDER: + ProcessCreateMsg(message); + break; + case MSG_TYPE_CREATE_PIN_HOLDER_RESP: + ProcessCreateRespMsg(message); + break; + case MSG_TYPE_DESTROY_PIN_HOLDER: + ProcessDestroyMsg(message); + break; + case MSG_TYPE_DESTROY_PIN_HOLDER_RESP: + ProcessDestroyResMsg(message); + break; + default: + break; + } +} + +void PinHolder::GetPeerDeviceId(int32_t sessionId, std::string &udidHash) +{ + char peerDeviceId[DEVICE_UUID_LENGTH] = {0}; + int32_t ret = ::GetPeerDeviceId(sessionId, &peerDeviceId[0], DEVICE_UUID_LENGTH); + if (ret != DM_OK) { + LOGE("[SOFTBUS]GetPeerDeviceId failed for session: %d.", sessionId); + udidHash = ""; + return; + } + std::string deviceId = peerDeviceId; + char udidHashTmp[DM_MAX_DEVICE_ID_LEN] = {0}; + if (DmSoftbusAdapterCrypto::GetUdidHash(deviceId, reinterpret_cast(udidHashTmp)) != DM_OK) { + LOGE("get udidhash by udid: %s failed.", GetAnonyString(deviceId).c_str()); + udidHash = ""; + return; + } + udidHash = udidHashTmp; + LOGI("GetPeerDeviceId udid hash: %s success.", GetAnonyString(udidHash).c_str()); +} + +void PinHolder::OnSessionOpened(int32_t sessionId, int32_t sessionSide, int32_t result) +{ + sessionId_ = sessionId; + if (sessionSide == SESSION_SIDE_SERVER) { + LOGI("[SOFTBUS]onSesssionOpened success, side is sink. sessionId: %d.", sessionId); + GetPeerDeviceId(sessionId, remoteDeviceId_); + return; + } + if (result == DM_OK) { + CreateGeneratePinHolderMsg(); + return; + } + LOGE("[SOFTBUS]onSesssionOpened failed. sessionId: %d.", sessionId); + sessionId_ = SESSION_ID_INVALID; + if (listener_ != nullptr) { + listener_->OnCreateResult(registerPkgName_, ERR_DM_FAILED); + } + return; +} + +void PinHolder::OnSessionClosed(int32_t sessionId) +{ + LOGI("[SOFTBUS]OnSessionClosed sessionId: %d.", sessionId); + sessionId_ = SESSION_ID_INVALID; + sinkState_ = SINK_INIT; + sourceState_ = SOURCE_INIT; + remoteDeviceId_ = ""; + nlohmann::json jsonObj; + jsonObj[DM_CONNECTION_DISCONNECTED] = true; + std::string payload = jsonObj.dump(); + if (listener_ != nullptr) { + listener_->OnPinHolderDestroy(registerPkgName_, pinType_, payload); + } + if (timer_ != nullptr) { + timer_->DeleteAll(); + } + return; +} + +int32_t PinHolder::CheckTargetIdVaild(const PeerTargetId &targetId) +{ + if (targetId.deviceId.empty() && targetId.brMac.empty() && targetId.bleMac.empty() && targetId.wifiIp.empty()) { + LOGE("CheckTargetIdVaild failed. targetId is empty."); + return ERR_DM_INPUT_PARA_INVALID; + } + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/service/src/pinholder/pin_holder_session.cpp b/services/service/src/pinholder/pin_holder_session.cpp new file mode 100644 index 000000000..8749cf425 --- /dev/null +++ b/services/service/src/pinholder/pin_holder_session.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2024 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 "pin_holder_session.h" + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "dm_softbus_adapter_crypto.h" +#include "nlohmann/json.hpp" + +namespace OHOS { +namespace DistributedHardware { +std::shared_ptr PinHolderSession::sessionCallback_ = nullptr; +PinHolderSession::PinHolderSession() +{ + LOGD("PinHolderSession constructor."); +} + +PinHolderSession::~PinHolderSession() +{ + LOGD("PinHolderSession destructor."); +} + +int32_t PinHolderSession::RegisterSessionCallback(std::shared_ptr callback) +{ + sessionCallback_ = callback; + return DM_OK; +} + +int32_t PinHolderSession::UnRegisterSessionCallback() +{ + sessionCallback_ = nullptr; + return DM_OK; +} + +int32_t PinHolderSession::OpenSessionServer(const PeerTargetId &targetId) +{ + int32_t sessionId = -1; + ConnectionAddr addrInfo; + if (GetAddrByTargetId(targetId, addrInfo) != DM_OK) { + LOGE("[SOFTBUS]open session error, sessionId: %d.", sessionId); + } + sessionId = ::OpenAuthSession(DM_PIN_HOLDER_SESSION_NAME, &addrInfo, 1, nullptr); + if (sessionId < 0) { + LOGE("[SOFTBUS]open session error, sessionId: %d.", sessionId); + return sessionId; + } + LOGI("OpenAuthSession success. sessionId: %d.", sessionId); + return sessionId; +} + +int32_t PinHolderSession::CloseSessionServer(int32_t sessionId) +{ + LOGD("CloseSessionServer."); + ::CloseSession(sessionId); + return DM_OK; +} + +int PinHolderSession::OnSessionOpened(int sessionId, int result) +{ + if (sessionCallback_ == nullptr) { + LOGE("OnSessionOpened error, sessionCallback_ is nullptr."); + return ERR_DM_FAILED; + } + int32_t sessionSide = GetSessionSide(sessionId); + sessionCallback_->OnSessionOpened(sessionId, sessionSide, result); + LOGI("OnSessionOpened, success, sessionId: %d.", sessionId); + return DM_OK; +} + +void PinHolderSession::OnSessionClosed(int sessionId) +{ + LOGI("[SOFTBUS]OnSessionClosed sessionId: %d", sessionId); + if (sessionCallback_ == nullptr) { + LOGE("OnSessionClosed error, sessionCallback_ is nullptr."); + return; + } + sessionCallback_->OnSessionClosed(sessionId); + return; +} + +void PinHolderSession::OnBytesReceived(int sessionId, const void *data, unsigned int dataLen) +{ + if (sessionId < 0 || data == nullptr || dataLen <= 0) { + LOGE("[SOFTBUS]fail to receive data from softbus with sessionId: %d, dataLen: %d.", sessionId, dataLen); + return; + } + if (sessionCallback_ == nullptr) { + LOGE("OnBytesReceived error, sessionCallback_ is nullptr."); + return; + } + LOGI("start, sessionId: %d, dataLen: %d.", sessionId, dataLen); + std::string message = std::string(reinterpret_cast(data), dataLen); + sessionCallback_->OnDataReceived(sessionId, message); + return; +} + +int32_t PinHolderSession::SendData(int32_t sessionId, const std::string &message) +{ + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("extrasJson error, message: %s.", message.c_str()); + return ERR_DM_FAILED; + } + if (!IsInt32(jsonObject, TAG_MSG_TYPE)) { + LOGE("SoftbusSession::SendData err json string."); + return ERR_DM_FAILED; + } + int32_t msgType = jsonObject[TAG_MSG_TYPE].get(); + LOGI("start, msgType: %d.", msgType); + int32_t ret = SendBytes(sessionId, message.c_str(), strlen(message.c_str())); + if (ret != DM_OK) { + LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); + return ERR_DM_FAILED; + } + return ret; +} + +int32_t PinHolderSession::GetAddrByTargetId(const PeerTargetId &targetId, ConnectionAddr &addr) +{ + if (!targetId.wifiIp.empty() && targetId.wifiIp.length() <= IP_STR_MAX_LEN) { + addr.type = ConnectionAddrType::CONNECTION_ADDR_WLAN; + memcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, targetId.wifiIp.c_str(), targetId.wifiIp.length()); + addr.info.ip.port = targetId.wifiPort; + } else if (!targetId.brMac.empty() && targetId.brMac.length() <= BT_MAC_LEN) { + addr.type = ConnectionAddrType::CONNECTION_ADDR_BR; + memcpy_s(addr.info.br.brMac, BT_MAC_LEN, targetId.brMac.c_str(), targetId.brMac.length()); + } else if (!targetId.bleMac.empty() && targetId.bleMac.length() <= BT_MAC_LEN) { + addr.type = ConnectionAddrType::CONNECTION_ADDR_BLE; + memcpy_s(addr.info.ble.bleMac, BT_MAC_LEN, targetId.bleMac.c_str(), targetId.bleMac.length()); + if (!targetId.deviceId.empty()) { + DmSoftbusAdapterCrypto::ConvertHexStringToBytes(addr.info.ble.udidHash, UDID_HASH_LEN, + targetId.deviceId.c_str(), targetId.deviceId.length()); + } + } + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp b/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp index e8fe73a77..a95ba0bf6 100644 --- a/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp +++ b/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp @@ -15,6 +15,7 @@ #include "pinholder_fuzzer.h" +#include "device_manager.h" #include "device_manager_callback.h" #include "dm_ability_manager.h" #include "dm_constants.h" diff --git a/test/unittest/UTTest_device_manager_service.h b/test/unittest/UTTest_device_manager_service.h index fd9df250a..b21575307 100644 --- a/test/unittest/UTTest_device_manager_service.h +++ b/test/unittest/UTTest_device_manager_service.h @@ -26,13 +26,7 @@ #undef private #include "device_manager_service_listener.h" -#include "dm_auth_manager.h" -#include "dm_device_state_manager.h" -#include "dm_discovery_manager.h" -#include "dm_publish_manager.h" #include "single_instance.h" -#include "softbus_connector.h" - namespace OHOS { namespace DistributedHardware { class DeviceManagerServiceTest : public testing::Test { diff --git a/test/unittest/UTTest_dm_pin_holder.cpp b/test/unittest/UTTest_dm_pin_holder.cpp index 88ae4eec9..154ae6004 100644 --- a/test/unittest/UTTest_dm_pin_holder.cpp +++ b/test/unittest/UTTest_dm_pin_holder.cpp @@ -147,9 +147,13 @@ HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_102, testing::ext::TestSize. std::string packName = "com.ohos.dmtest"; std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); dmPinHolder->session_ = nullptr; + pinHolder->session_ = nullptr; int32_t ret = dmPinHolder->RegisterPinHolderCallback(packName); ASSERT_EQ(ret, ERR_DM_FAILED); + ret = pinHolder->RegisterPinHolderCallback(packName); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_103, testing::ext::TestSize.Level0) @@ -157,9 +161,13 @@ HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_103, testing::ext::TestSize. std::string packName = "com.ohos.dmtest"; std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); dmPinHolder->session_ = std::make_shared(); + pinHolder->session_ = std::make_shared(); int32_t ret = dmPinHolder->RegisterPinHolderCallback(packName); ASSERT_EQ(ret, DM_OK); + ret = pinHolder->RegisterPinHolderCallback(packName); + ASSERT_EQ(ret, DM_OK); } HWTEST_F(DmPinHolderTest, CreatePinholder_101, testing::ext::TestSize.Level0) @@ -186,9 +194,13 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_102, testing::ext::TestSize.Level0) std::string payload; std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); dmPinHolder->registerPkgName_ = ""; + pinHolder->registerPkgName_ = ""; int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreatePinholder_103, testing::ext::TestSize.Level0) @@ -199,9 +211,13 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_103, testing::ext::TestSize.Level0) std::string payload; std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); dmPinHolder->registerPkgName_ = "dmtest"; + pinHolder->registerPkgName_ = "dmtest"; int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreatePinholder_105, testing::ext::TestSize.Level0) @@ -218,9 +234,13 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_105, testing::ext::TestSize.Level0) std::string payload; std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); dmPinHolder->registerPkgName_ = packName; + pinHolder->registerPkgName_ = packName; int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); + ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } HWTEST_F(DmPinHolderTest, CreatePinholder_106, testing::ext::TestSize.Level0) @@ -241,6 +261,11 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_106, testing::ext::TestSize.Level0) dmPinHolder->listener_ = nullptr; int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->registerPkgName_ = packName; + pinHolder->listener_ = nullptr; + ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreatePinholder_107, testing::ext::TestSize.Level0) @@ -261,6 +286,11 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_107, testing::ext::TestSize.Level0) dmPinHolder->session_ = nullptr; int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->registerPkgName_ = packName; + pinHolder->session_ = nullptr; + ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreatePinholder_108, testing::ext::TestSize.Level0) @@ -281,6 +311,11 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_108, testing::ext::TestSize.Level0) dmPinHolder->sourceState_ = SOURCE_CREATE; int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->registerPkgName_ = packName; + pinHolder->sourceState_ = SOURCE_CREATE; + ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, DestroyPinHolder_101, testing::ext::TestSize.Level0) @@ -299,6 +334,10 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_101, testing::ext::TestSize.Level0) dmPinHolder->listener_ = nullptr; int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->listener_ = nullptr; + ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, DestroyPinHolder_102, testing::ext::TestSize.Level0) @@ -317,6 +356,10 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_102, testing::ext::TestSize.Level0) dmPinHolder->session_ = nullptr; int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->session_ = nullptr; + ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, DestroyPinHolder_103, testing::ext::TestSize.Level0) @@ -335,6 +378,10 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_103, testing::ext::TestSize.Level0) dmPinHolder->registerPkgName_ = ""; int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->registerPkgName_ = ""; + ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, DestroyPinHolder_104, testing::ext::TestSize.Level0) @@ -353,6 +400,10 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_104, testing::ext::TestSize.Level0) dmPinHolder->registerPkgName_ = "dmtest"; int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->registerPkgName_ = "dmtest"; + ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, DestroyPinHolder_105, testing::ext::TestSize.Level0) @@ -371,6 +422,10 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_105, testing::ext::TestSize.Level0) dmPinHolder->registerPkgName_ = packName; int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->registerPkgName_ = packName; + ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } HWTEST_F(DmPinHolderTest, DestroyPinHolder_106, testing::ext::TestSize.Level0) @@ -393,6 +448,13 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_106, testing::ext::TestSize.Level0) dmPinHolder->listener_ = std::make_shared(); int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->registerPkgName_ = packName; + pinHolder->sessionId_ = sessionId; + pinHolder->sourceState_ = SOURCE_DESTROY; + pinHolder->listener_ = std::make_shared(); + ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_101, testing::ext::TestSize.Level0) @@ -402,6 +464,10 @@ HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_101, testing::ext::TestSize dmPinHolder->listener_ = nullptr; int32_t ret = dmPinHolder->CreateGeneratePinHolderMsg(); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->listener_ = nullptr; + ret = pinHolder->CreateGeneratePinHolderMsg(); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_102, testing::ext::TestSize.Level0) @@ -411,231 +477,304 @@ HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_102, testing::ext::TestSize dmPinHolder->session_ = nullptr; int32_t ret = dmPinHolder->CreateGeneratePinHolderMsg(); ASSERT_EQ(ret, ERR_DM_FAILED); + std::shared_ptr pinHolder = std::make_shared(listener); + pinHolder->session_ = nullptr; + ret = pinHolder->CreateGeneratePinHolderMsg(); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, ParseMsgType_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); std::string message; int32_t ret = dmPinHolder->ParseMsgType(message); ASSERT_EQ(ret, ERR_DM_FAILED); + ret = pinHolder->ParseMsgType(message); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, ProcessCreateMsg_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); std::string message; dmPinHolder->listener_ = nullptr; dmPinHolder->ProcessCreateMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->listener_ = nullptr; + pinHolder->ProcessCreateMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateMsg_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); std::string message; dmPinHolder->session_ = nullptr; dmPinHolder->ProcessCreateMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->session_ = nullptr; + pinHolder->ProcessCreateMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateMsg_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; std::string message = jsonObject.dump(); dmPinHolder->ProcessCreateMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->ProcessCreateMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateMsg_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = "TAG_PIN_TYPE"; std::string message = jsonObject.dump(); dmPinHolder->ProcessCreateMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->ProcessCreateMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateMsg_105, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = DmPinType::SUPER_SONIC; jsonObject[TAG_PAYLOAD] = DmPinType::SUPER_SONIC; std::string message = jsonObject.dump(); dmPinHolder->ProcessCreateMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->ProcessCreateMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; std::string message = jsonObject.dump(); dmPinHolder->ProcessCreateRespMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->ProcessCreateRespMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE; std::string message = jsonObject.dump(); dmPinHolder->listener_ = nullptr; dmPinHolder->ProcessCreateRespMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->listener_ = nullptr; + pinHolder->ProcessCreateRespMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_REPLY] = DmPinType::SUPER_SONIC; std::string message = jsonObject.dump(); dmPinHolder->session_ = nullptr; dmPinHolder->ProcessCreateRespMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->session_ = nullptr; + pinHolder->ProcessCreateRespMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE; std::string message = jsonObject.dump(); dmPinHolder->session_ = nullptr; dmPinHolder->ProcessCreateRespMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->session_ = nullptr; + pinHolder->ProcessCreateRespMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); std::string message; dmPinHolder->listener_ = nullptr; dmPinHolder->ProcessDestroyMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->listener_ = nullptr; + pinHolder->ProcessDestroyMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); std::string message; dmPinHolder->session_ = nullptr; dmPinHolder->ProcessDestroyMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->session_ = nullptr; + pinHolder->ProcessDestroyMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; std::string message = jsonObject.dump(); dmPinHolder->ProcessDestroyMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->ProcessDestroyMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = "TAG_PIN_TYPE"; std::string message = jsonObject.dump(); dmPinHolder->ProcessDestroyMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->ProcessDestroyMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_105, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = DmPinType::SUPER_SONIC; jsonObject[TAG_PAYLOAD] = DmPinType::SUPER_SONIC; std::string message = jsonObject.dump(); dmPinHolder->ProcessDestroyMsg(message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->ProcessDestroyMsg(message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, CloseSession_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); std::string name; dmPinHolder->session_ = nullptr; dmPinHolder->CloseSession(name); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->session_ = nullptr; + pinHolder->CloseSession(name); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, OnDataReceived_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER; std::string message = jsonObject.dump(); dmPinHolder->OnDataReceived(sessionId, message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->OnDataReceived(sessionId, message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, OnDataReceived_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER_RESP; std::string message = jsonObject.dump(); dmPinHolder->OnDataReceived(sessionId, message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->OnDataReceived(sessionId, message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, OnDataReceived_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER; std::string message = jsonObject.dump(); dmPinHolder->OnDataReceived(sessionId, message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->OnDataReceived(sessionId, message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, OnDataReceived_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER_RESP; std::string message = jsonObject.dump(); dmPinHolder->OnDataReceived(sessionId, message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->OnDataReceived(sessionId, message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, OnDataReceived_105, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; int32_t data = 300; nlohmann::json jsonObject; @@ -643,39 +782,51 @@ HWTEST_F(DmPinHolderTest, OnDataReceived_105, testing::ext::TestSize.Level0) std::string message = jsonObject.dump(); dmPinHolder->OnDataReceived(sessionId, message); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->OnDataReceived(sessionId, message); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, GetPeerDeviceId_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; std::string udidHash; dmPinHolder->GetPeerDeviceId(sessionId, udidHash); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->GetPeerDeviceId(sessionId, udidHash); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, OnSessionOpened_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; int32_t sessionSide = 0; int32_t result = 0; dmPinHolder->OnSessionOpened(sessionId, sessionSide, result); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder->OnSessionOpened(sessionId, sessionSide, result); + ASSERT_NE(pinHolder->timer_, nullptr); } HWTEST_F(DmPinHolderTest, OnSessionOpened_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; int32_t sessionSide = 1; int32_t result = 1; dmPinHolder ->listener_ = nullptr; dmPinHolder->OnSessionOpened(sessionId, sessionSide, result); ASSERT_NE(dmPinHolder->timer_, nullptr); + pinHolder ->listener_ = nullptr; + pinHolder->OnSessionOpened(sessionId, sessionSide, result); + ASSERT_NE(pinHolder->timer_, nullptr); } @@ -683,6 +834,7 @@ HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); PeerTargetId targetId = { .deviceId = "", .brMac = "", @@ -691,12 +843,15 @@ HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_101, testing::ext::TestSize.Level0) }; int32_t ret = dmPinHolder->CheckTargetIdVaild(targetId); ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); + ret = pinHolder->CheckTargetIdVaild(targetId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); std::shared_ptr dmPinHolder = std::make_shared(listener); + std::shared_ptr pinHolder = std::make_shared(listener); PeerTargetId targetId = { .deviceId = "deviceId", .brMac = "brMac", @@ -705,6 +860,8 @@ HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_102, testing::ext::TestSize.Level0) }; int32_t ret = dmPinHolder->CheckTargetIdVaild(targetId); ASSERT_EQ(ret, DM_OK); + ret = pinHolder->CheckTargetIdVaild(targetId); + ASSERT_EQ(ret, DM_OK); } } // namespace } // namespace DistributedHardware diff --git a/test/unittest/UTTest_dm_pin_holder.h b/test/unittest/UTTest_dm_pin_holder.h index 1a002adb2..44f8716c1 100644 --- a/test/unittest/UTTest_dm_pin_holder.h +++ b/test/unittest/UTTest_dm_pin_holder.h @@ -25,6 +25,7 @@ #include "device_manager.h" #include "single_instance.h" #include "dm_pin_holder.h" +#include "pin_holder.h" namespace OHOS { namespace DistributedHardware { -- Gitee From d31ec95149819f5ea30788f781a0f055e8c2fcbc Mon Sep 17 00:00:00 2001 From: yangwei_814916 Date: Fri, 19 Jan 2024 17:10:36 +0800 Subject: [PATCH 2/5] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=BC=80=E6=9C=BA?= =?UTF-8?q?=E5=86=85=E5=AD=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yangwei_814916 --- services/service/BUILD.gn | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/service/BUILD.gn b/services/service/BUILD.gn index 3678f3851..647bfb483 100644 --- a/services/service/BUILD.gn +++ b/services/service/BUILD.gn @@ -66,7 +66,7 @@ if (defined(ohos_lite)) { "src/ipc/lite/ipc_server_main.cpp", "src/ipc/lite/ipc_server_stub.cpp", "src/permission/lite/permission_manager.cpp", - "src/pinholder/dm_pin_holder.cpp", + "src/pinholder/pin_holder.cpp", "src/pinholder/pin_holder_session.cpp", "src/softbus/softbus_listener.cpp", ] @@ -161,7 +161,7 @@ if (defined(ohos_lite)) { "src/ipc/standard/ipc_server_listener.cpp", "src/ipc/standard/ipc_server_stub.cpp", "src/permission/standard/permission_manager.cpp", - "src/pinholder/dm_pin_holder.cpp", + "src/pinholder/pin_holder.cpp", "src/pinholder/pin_holder_session.cpp", "src/softbus/softbus_listener.cpp", ] -- Gitee From 416a852b78018d9dc63a41a8bad41b6d55f08c92 Mon Sep 17 00:00:00 2001 From: yangwei_814916 Date: Fri, 19 Jan 2024 18:29:22 +0800 Subject: [PATCH 3/5] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=BC=80=E6=9C=BA?= =?UTF-8?q?=E5=86=85=E5=AD=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yangwei_814916 --- test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp | 2 +- test/unittest/BUILD.gn | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp b/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp index a95ba0bf6..2b8b6b06c 100644 --- a/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp +++ b/test/commonfuzztest/pinholder_fuzzer/pinholder_fuzzer.cpp @@ -20,7 +20,7 @@ #include "dm_ability_manager.h" #include "dm_constants.h" #include "dm_log.h" -#include "dm_pin_holder.h" +#include "pin_holder.h" #include "nlohmann/json.hpp" #include "parameter.h" #include "device_manager_service_listener.h" diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 7dc164632..b73aba86f 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -906,10 +906,12 @@ config("device_manager_test_common_public_config") { "${servicesimpl_path}/include/devicestate", "${services_path}/include", "${services_path}/include/softbus", + "${services_path}/include/pinholder", "${devicemanager_path}/test/unittest/mock", "${servicesimpl_path}/include/ability", "${servicesimpl_path}/include/config", "${servicesimpl_path}/include/dependency/multipleuser", + "${servicesimpl_path}/include/pinholder", "${devicemanager_path}/test/unittest/mock/", "//third_party/json/include", ] -- Gitee From ad83b95f793e102d41eb0ad4eb006cf8d56de6fb Mon Sep 17 00:00:00 2001 From: yangwei_814916 Date: Sat, 20 Jan 2024 14:18:44 +0800 Subject: [PATCH 4/5] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=BC=80=E6=9C=BA?= =?UTF-8?q?=E5=86=85=E5=AD=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yangwei_814916 --- .../include/pinholder/dm_pin_holder.h | 101 ---- .../include/pinholder/pin_holder_session.h | 82 ---- .../src/pinholder/dm_pin_holder.cpp | 454 ------------------ .../src/pinholder/pin_holder_session.cpp | 161 ------- .../service/include/pinholder/pin_holder.h | 9 +- .../include/pinholder/pin_holder_session.h | 2 +- .../softbus/pinholder_session_callback.h | 6 +- .../src/pinholder/pin_holder_session.cpp | 24 +- test/unittest/BUILD.gn | 6 +- test/unittest/UTTest_dm_pin_holder.cpp | 200 +------- test/unittest/UTTest_dm_pin_holder.h | 3 +- 11 files changed, 49 insertions(+), 999 deletions(-) delete mode 100644 services/implementation/include/pinholder/dm_pin_holder.h delete mode 100644 services/implementation/include/pinholder/pin_holder_session.h delete mode 100644 services/implementation/src/pinholder/dm_pin_holder.cpp delete mode 100644 services/implementation/src/pinholder/pin_holder_session.cpp diff --git a/services/implementation/include/pinholder/dm_pin_holder.h b/services/implementation/include/pinholder/dm_pin_holder.h deleted file mode 100644 index 0123e81de..000000000 --- a/services/implementation/include/pinholder/dm_pin_holder.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (c) 2023 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_PIN_HOLDER_H -#define OHOS_DM_PIN_HOLDER_H - -#include "device_manager.h" -#include "dm_adapter_crypto.h" -#include "softbus_bus_center.h" -#include "dm_device_info.h" -#include "dm_subscribe_info.h" -#include "dm_timer.h" -#include "idevice_manager_service_listener.h" -#include "inner_session.h" -#include "pin_holder_session.h" -#include "session.h" - -#include -#include - -namespace OHOS { -namespace DistributedHardware { -typedef enum PinHolderState { - SOURCE_INIT = 1, - SOURCE_CREATE, - SOURCE_DESTROY, - SINK_INIT = 20, - SINK_CREATE, - SINK_DESTROY, -} PinHolderState; - -class DmPinHolder final : public ISoftbusSessionCallback, - public std::enable_shared_from_this { -public: - DmPinHolder(std::shared_ptr listener); - ~DmPinHolder(); - int32_t RegisterPinHolderCallback(const std::string &pkgName); - int32_t CreatePinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload); - int32_t DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, - DmPinType pinType, const std::string &payload); -public: - void OnSessionOpened(int32_t sessionId, int32_t sessionSide, int32_t result); - void OnSessionClosed(int32_t sessionId); - void OnDataReceived(int32_t sessionId, std::string message); - bool GetIsCryptoSupport() - { - return false; - } - AesGcmCipherKey GetSessionKeyAndLen() - { - AesGcmCipherKey cipherKey = { 0 }; - return cipherKey; - } - void OnUnbindSessionOpened(int sessionId, int32_t sessionSide, int result) - { - return; - } - void OnAuthDeviceDataReceived(int32_t sessionId, std::string message) - { - return; - } - -private: - int32_t CreateGeneratePinHolderMsg(); - int32_t ParseMsgType(const std::string &message); - void ProcessCreateMsg(const std::string &message); - void ProcessCreateRespMsg(const std::string &message); - void ProcessDestroyMsg(const std::string &message); - void ProcessDestroyResMsg(const std::string &message); - void CloseSession(const std::string &name); - void GetPeerDeviceId(int32_t sessionId, std::string &udidHash); - int32_t CheckTargetIdVaild(const PeerTargetId &targetId); -private: - std::shared_ptr listener_ = nullptr; - std::shared_ptr session_ = nullptr; - std::shared_ptr timer_ = nullptr; - - std::string registerPkgName_ = ""; - std::string remoteDeviceId_ = ""; - std::string payload_ = ""; - DmPinType pinType_; - PinHolderState sinkState_; - PinHolderState sourceState_; - int32_t sessionId_ = -1; -}; -} -} -#endif // OHOS_DM_PIN_HOLDER_H \ No newline at end of file diff --git a/services/implementation/include/pinholder/pin_holder_session.h b/services/implementation/include/pinholder/pin_holder_session.h deleted file mode 100644 index d0c526ddd..000000000 --- a/services/implementation/include/pinholder/pin_holder_session.h +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright (c) 2023 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_PIN_HOLDER_SESSION_H -#define OHOS_PIN_HOLDER_SESSION_H - -#include "device_manager.h" - -#include "softbus_bus_center.h" -#include "dm_device_info.h" -#include "softbus_session_callback.h" -#include "inner_session.h" -#include "session.h" - -namespace OHOS { -namespace DistributedHardware { -class PinHolderSession { -public: - static int OnSessionOpened(int sessionId, int result); - static void OnSessionClosed(int sessionId); - static void OnBytesReceived(int sessionId, const void *data, unsigned int dataLen); - -public: - PinHolderSession(); - ~PinHolderSession(); - - /** - * @tc.name: PinHolderSession::RegisterSessionCallback - * @tc.desc: RegisterSessionCallback of the Softbus Session - * @tc.type: FUNC - */ - int32_t RegisterSessionCallback(std::shared_ptr callback); - - /** - * @tc.name: PinHolderSession::UnRegisterSessionCallback - * @tc.desc: UnRegister SessionCallback of the Softbus Session - * @tc.type: FUNC - */ - int32_t UnRegisterSessionCallback(); - - /** - * @tc.name: PinHolderSession::OpenAuthSession - * @tc.desc: Open AuthSession of the Softbus Session - * @tc.type: FUNC - */ - int32_t OpenSessionServer(const PeerTargetId &targetId); - - /** - * @tc.name: PinHolderSession::CloseAuthSession - * @tc.desc: Close AuthSession of the Softbus Session - * @tc.type: FUNC - */ - int32_t CloseSessionServer(int32_t sessionId); - - /** - * @tc.name: PinHolderSession::SendData - * @tc.desc: Send Data of the Softbus Session - * @tc.type: FUNC - */ - int32_t SendData(int32_t sessionId, const std::string &message); - -private: - int32_t GetAddrByTargetId(const PeerTargetId &targetId, ConnectionAddr &addrInfo); - -private: - static std::shared_ptr sessionCallback_; -}; -} -} -#endif // OHOS_PIN_HOLDER_SESSION_H \ No newline at end of file diff --git a/services/implementation/src/pinholder/dm_pin_holder.cpp b/services/implementation/src/pinholder/dm_pin_holder.cpp deleted file mode 100644 index 9a775736b..000000000 --- a/services/implementation/src/pinholder/dm_pin_holder.cpp +++ /dev/null @@ -1,454 +0,0 @@ -/* - * Copyright (c) 2023-2024 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 "dm_pin_holder.h" - -#include "dm_anonymous.h" -#include "dm_constants.h" -#include "dm_log.h" -#include "dm_softbus_adapter_crypto.h" -#include "nlohmann/json.hpp" -#include "parameter.h" -#include "softbus_connector.h" - -namespace OHOS { -namespace DistributedHardware { -constexpr int32_t SESSION_SIDE_SERVER = 0; -constexpr int32_t SESSION_ID_INVALID = -1; -constexpr int32_t REPLY_SUCCESS = 0; -constexpr int32_t REPLY_FAILED = -1; - -constexpr int32_t MSG_TYPE_CREATE_PIN_HOLDER = 600; -constexpr int32_t MSG_TYPE_CREATE_PIN_HOLDER_RESP = 601; -constexpr int32_t MSG_TYPE_DESTROY_PIN_HOLDER = 650; -constexpr int32_t MSG_TYPE_DESTROY_PIN_HOLDER_RESP = 651; - -constexpr const char* PINHOLDER_CREATE_TIMEOUT_TASK = "deviceManagerTimer:pinholdercreate"; -constexpr int32_t PIN_HOLDER_SESSION_CREATE_TIMEOUT = 60; - -constexpr const char* TAG_PIN_TYPE = "PIN_TYPE"; -constexpr const char* TAG_PAYLOAD = "PAYLOAD"; -constexpr const char* TAG_REPLY = "REPLY"; -DmPinHolder::DmPinHolder(std::shared_ptr listener): listener_(listener) -{ - if (session_ == nullptr) { - session_ = std::make_shared(); - } - if (timer_ == nullptr) { - timer_ = std::make_shared(); - } - sinkState_ = SINK_INIT; - sourceState_ = SOURCE_INIT; -} - -DmPinHolder::~DmPinHolder() -{ - if (session_ != nullptr) { - session_->UnRegisterSessionCallback(); - session_ = nullptr; - } - if (timer_ != nullptr) { - timer_->DeleteAll(); - timer_ = nullptr; - } -} - -int32_t DmPinHolder::RegisterPinHolderCallback(const std::string &pkgName) -{ - if (session_ == nullptr) { - LOGE("RegisterPinHolderCallback session is nullptr."); - return ERR_DM_FAILED; - } - registerPkgName_ = pkgName; - session_->RegisterSessionCallback(shared_from_this()); - return DM_OK; -} - -int32_t DmPinHolder::CreatePinHolder(const std::string &pkgName, - const PeerTargetId &targetId, DmPinType pinType, const std::string &payload) -{ - LOGI("CreatePinHolder."); - if (registerPkgName_.empty() || registerPkgName_ != pkgName) { - LOGE("CreatePinHolder pkgName: %s is not register callback.", pkgName.c_str()); - return ERR_DM_FAILED; - } - int32_t ret = CheckTargetIdVaild(targetId); - if (ret != DM_OK) { - LOGE("CreatePinHolder targetId is invalid."); - return ret; - } - - if (listener_ == nullptr || session_ == nullptr) { - LOGE("CreatePinHolder listener or session is nullptr."); - return ERR_DM_FAILED; - } - - if (sourceState_ != SOURCE_INIT) { - LOGE("CreatePinHolder failed, state is %d.", sourceState_); - return ERR_DM_FAILED; - } - - if (sessionId_ != SESSION_ID_INVALID) { - LOGI("CreatePinHolder session already create, sessionId: %d.", sessionId_); - CreateGeneratePinHolderMsg(); - return DM_OK; - } - - sessionId_ = session_->OpenSessionServer(targetId); - if (sessionId_ < 0) { - LOGE("[SOFTBUS]open session error, sessionId: %d.", sessionId_); - sessionId_ = SESSION_ID_INVALID; - listener_->OnCreateResult(registerPkgName_, ERR_DM_AUTH_OPEN_SESSION_FAILED); - return ERR_DM_AUTH_OPEN_SESSION_FAILED; - } - pinType_ = pinType; - payload_ = payload; - return DM_OK; -} - -int32_t DmPinHolder::DestroyPinHolder(const std::string &pkgName, const PeerTargetId &targetId, DmPinType pinType, - const std::string &payload) -{ - LOGI("DestroyPinHolder."); - if (listener_ == nullptr || session_ == nullptr) { - LOGE("DestroyPinHolder listener or session is nullptr."); - return ERR_DM_FAILED; - } - - if (registerPkgName_.empty() || pkgName != registerPkgName_) { - LOGE("DestroyPinHolder pkgName: %s is not register callback.", pkgName.c_str()); - return ERR_DM_FAILED; - } - - int32_t ret = CheckTargetIdVaild(targetId); - if (ret != DM_OK) { - LOGE("DestroyPinHolder targetId is invalid."); - return ret; - } - - if (sessionId_ == SESSION_ID_INVALID) { - LOGI("DestroyPinHolder session already destroy."); - listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED); - return ERR_DM_FAILED; - } - if (sourceState_ != SOURCE_CREATE) { - LOGE("DestroyPinHolder failed, state is %d.", sourceState_); - return ERR_DM_FAILED; - } - - timer_->DeleteTimer(PINHOLDER_CREATE_TIMEOUT_TASK); - - nlohmann::json jsonObj; - jsonObj[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER; - jsonObj[TAG_PIN_TYPE] = pinType; - jsonObj[TAG_PAYLOAD] = payload; - pinType_ = pinType; - std::string message = jsonObj.dump(); - LOGI("DestroyPinHolder, message type is: %d, pin type is: %d.", MSG_TYPE_DESTROY_PIN_HOLDER, pinType); - ret = session_->SendData(sessionId_, message); - if (ret != DM_OK) { - LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); - listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED); - return ERR_DM_FAILED; - } - return ret; -} - -int32_t DmPinHolder::CreateGeneratePinHolderMsg() -{ - if (listener_ == nullptr || session_ == nullptr) { - LOGE("CreateGeneratePinHolderMsg listener or session is nullptr."); - return ERR_DM_FAILED; - } - - timer_->DeleteAll(); - timer_->StartTimer(std::string(PINHOLDER_CREATE_TIMEOUT_TASK), PIN_HOLDER_SESSION_CREATE_TIMEOUT, - [this] (std::string name) { - DmPinHolder::CloseSession(name); - }); - nlohmann::json jsonObj; - jsonObj[TAG_PIN_TYPE] = pinType_; - jsonObj[TAG_PAYLOAD] = payload_; - jsonObj[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER; - std::string message = jsonObj.dump(); - LOGI("CreateGeneratePinHolderMsg, message type is: %d, pin type is: %d.", MSG_TYPE_CREATE_PIN_HOLDER, pinType_); - int32_t ret = session_->SendData(sessionId_, message); - if (ret != DM_OK) { - LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); - listener_->OnCreateResult(registerPkgName_, ERR_DM_FAILED); - return ERR_DM_FAILED; - } - return ret; -} - -int32_t DmPinHolder::ParseMsgType(const std::string &message) -{ - nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); - if (jsonObject.is_discarded()) { - LOGE("ParseMsgType DecodeRequest jsonStr error"); - return ERR_DM_FAILED; - } - if (!IsInt32(jsonObject, TAG_MSG_TYPE)) { - LOGE("ParseMsgType err json string."); - return ERR_DM_FAILED; - } - int32_t msgType = jsonObject[TAG_MSG_TYPE].get(); - return msgType; -} - -void DmPinHolder::ProcessCreateMsg(const std::string &message) -{ - if (listener_ == nullptr || session_ == nullptr) { - LOGE("ProcessCreateMsg listener or session is nullptr."); - return; - } - nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); - if (jsonObject.is_discarded()) { - LOGE("ProcessCreateMsg DecodeRequest jsonStr error"); - return; - } - if (!IsInt32(jsonObject, TAG_PIN_TYPE) || !IsString(jsonObject, TAG_PAYLOAD)) { - LOGE("ProcessCreateMsg err json string."); - return; - } - DmPinType pinType = static_cast(jsonObject[TAG_PIN_TYPE].get()); - std::string payload = jsonObject[TAG_PAYLOAD].get(); - - nlohmann::json jsonObj; - jsonObj[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER_RESP; - if (sinkState_ != SINK_INIT) { - jsonObj[TAG_REPLY] = REPLY_FAILED; - } else { - jsonObj[TAG_REPLY] = REPLY_SUCCESS; - sinkState_ = SINK_CREATE; - sourceState_ = SOURCE_CREATE; - listener_->OnPinHolderCreate(registerPkgName_, remoteDeviceId_, pinType, payload); - } - - std::string msg = jsonObj.dump(); - LOGI("ProcessCreateMsg, message type is: %d.", MSG_TYPE_CREATE_PIN_HOLDER_RESP); - int32_t ret = session_->SendData(sessionId_, msg); - if (ret != DM_OK) { - LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); - return; - } -} - -void DmPinHolder::ProcessCreateRespMsg(const std::string &message) -{ - nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); - if (jsonObject.is_discarded()) { - LOGE("ProcessCreateRespMsg DecodeRequest jsonStr error."); - return; - } - if (!IsInt32(jsonObject, TAG_REPLY)) { - LOGE("ProcessCreateRespMsg err json string."); - return; - } - int32_t reply = jsonObject[TAG_REPLY].get(); - if (listener_ == nullptr || session_ == nullptr) { - LOGE("ProcessCreateRespMsg listener or session is nullptr."); - return; - } - if (reply == REPLY_SUCCESS) { - listener_->OnCreateResult(registerPkgName_, DM_OK); - sourceState_ = SOURCE_CREATE; - sinkState_ = SINK_CREATE; - } else { - LOGE("ProcessCreateRespMsg remote state is wrong."); - listener_->OnCreateResult(registerPkgName_, ERR_DM_FAILED); - session_->CloseSessionServer(sessionId_); - } -} - -void DmPinHolder::ProcessDestroyMsg(const std::string &message) -{ - if (listener_ == nullptr || session_ == nullptr) { - LOGE("ProcessDestroyMsg listener or session is nullptr."); - return; - } - nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); - if (jsonObject.is_discarded()) { - LOGE("ProcessDestroyMsg DecodeRequest jsonStr error."); - return; - } - if (!IsInt32(jsonObject, TAG_PIN_TYPE) || !IsString(jsonObject, TAG_PAYLOAD)) { - LOGE("ProcessDestroyMsg err json string."); - return; - } - DmPinType pinType = static_cast(jsonObject[TAG_PIN_TYPE].get()); - std::string payload = jsonObject[TAG_PAYLOAD].get(); - - nlohmann::json jsonObj; - jsonObj[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER_RESP; - if (sinkState_ != SINK_CREATE) { - jsonObj[TAG_REPLY] = REPLY_FAILED; - } else { - jsonObj[TAG_REPLY] = REPLY_SUCCESS; - sinkState_ = SINK_INIT; - sourceState_ = SOURCE_INIT; - listener_->OnPinHolderDestroy(registerPkgName_, pinType, payload); - } - - std::string msg = jsonObj.dump(); - LOGI("ProcessDestroyMsg, message type is: %d.", MSG_TYPE_DESTROY_PIN_HOLDER_RESP); - int32_t ret = session_->SendData(sessionId_, msg); - if (ret != DM_OK) { - LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); - return; - } -} - -void DmPinHolder::CloseSession(const std::string &name) -{ - LOGI("DmPinHolder::CloseSession start timer name %s.", name.c_str()); - if (session_ == nullptr) { - LOGE("CloseSession session is nullptr."); - return; - } - nlohmann::json jsonObj; - jsonObj[DM_CONNECTION_DISCONNECTED] = true; - std::string payload = jsonObj.dump(); - if (listener_ != nullptr) { - listener_->OnPinHolderDestroy(registerPkgName_, pinType_, payload); - } - session_->CloseSessionServer(sessionId_); - timer_->DeleteAll(); - sessionId_ = SESSION_ID_INVALID; - sinkState_ = SINK_INIT; - sourceState_ = SOURCE_INIT; - remoteDeviceId_ = ""; -} - -void DmPinHolder::ProcessDestroyResMsg(const std::string &message) -{ - nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); - if (jsonObject.is_discarded()) { - LOGE("ProcessDestroyResMsg DecodeRequest jsonStr error."); - return; - } - if (!IsInt32(jsonObject, TAG_REPLY)) { - LOGE("ProcessDestroyResMsg err json string."); - return; - } - int32_t reply = jsonObject[TAG_REPLY].get(); - if (listener_ == nullptr || session_ == nullptr) { - LOGE("ProcessDestroyResMsg listener or session is nullptr."); - return; - } - if (reply == REPLY_SUCCESS) { - listener_->OnDestroyResult(registerPkgName_, DM_OK); - sourceState_ = SOURCE_INIT; - sinkState_ = SINK_INIT; - CloseSession(registerPkgName_); - } else { - LOGE("ProcessDestroyResMsg remote state is wrong."); - listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED); - session_->CloseSessionServer(sessionId_); - } -} - -void DmPinHolder::OnDataReceived(int32_t sessionId, std::string message) -{ - int32_t msgType = ParseMsgType(message); - LOGI("OnDataReceived, msgType: %d.", msgType); - - switch (msgType) { - case MSG_TYPE_CREATE_PIN_HOLDER: - ProcessCreateMsg(message); - break; - case MSG_TYPE_CREATE_PIN_HOLDER_RESP: - ProcessCreateRespMsg(message); - break; - case MSG_TYPE_DESTROY_PIN_HOLDER: - ProcessDestroyMsg(message); - break; - case MSG_TYPE_DESTROY_PIN_HOLDER_RESP: - ProcessDestroyResMsg(message); - break; - default: - break; - } -} - -void DmPinHolder::GetPeerDeviceId(int32_t sessionId, std::string &udidHash) -{ - char peerDeviceId[DEVICE_UUID_LENGTH] = {0}; - int32_t ret = ::GetPeerDeviceId(sessionId, &peerDeviceId[0], DEVICE_UUID_LENGTH); - if (ret != DM_OK) { - LOGE("[SOFTBUS]GetPeerDeviceId failed for session: %d.", sessionId); - udidHash = ""; - return; - } - std::string deviceId = peerDeviceId; - char udidHashTmp[DM_MAX_DEVICE_ID_LEN] = {0}; - if (DmSoftbusAdapterCrypto::GetUdidHash(deviceId, reinterpret_cast(udidHashTmp)) != DM_OK) { - LOGE("get udidhash by udid: %s failed.", GetAnonyString(deviceId).c_str()); - udidHash = ""; - return; - } - udidHash = udidHashTmp; - LOGI("GetPeerDeviceId udid hash: %s success.", GetAnonyString(udidHash).c_str()); -} - -void DmPinHolder::OnSessionOpened(int32_t sessionId, int32_t sessionSide, int32_t result) -{ - sessionId_ = sessionId; - if (sessionSide == SESSION_SIDE_SERVER) { - LOGI("[SOFTBUS]onSesssionOpened success, side is sink. sessionId: %d.", sessionId); - GetPeerDeviceId(sessionId, remoteDeviceId_); - return; - } - if (result == DM_OK) { - CreateGeneratePinHolderMsg(); - return; - } - LOGE("[SOFTBUS]onSesssionOpened failed. sessionId: %d.", sessionId); - sessionId_ = SESSION_ID_INVALID; - if (listener_ != nullptr) { - listener_->OnCreateResult(registerPkgName_, ERR_DM_FAILED); - } - return; -} - -void DmPinHolder::OnSessionClosed(int32_t sessionId) -{ - LOGI("[SOFTBUS]OnSessionClosed sessionId: %d.", sessionId); - sessionId_ = SESSION_ID_INVALID; - sinkState_ = SINK_INIT; - sourceState_ = SOURCE_INIT; - remoteDeviceId_ = ""; - nlohmann::json jsonObj; - jsonObj[DM_CONNECTION_DISCONNECTED] = true; - std::string payload = jsonObj.dump(); - if (listener_ != nullptr) { - listener_->OnPinHolderDestroy(registerPkgName_, pinType_, payload); - } - if (timer_ != nullptr) { - timer_->DeleteAll(); - } - return; -} - -int32_t DmPinHolder::CheckTargetIdVaild(const PeerTargetId &targetId) -{ - if (targetId.deviceId.empty() && targetId.brMac.empty() && targetId.bleMac.empty() && targetId.wifiIp.empty()) { - LOGE("CheckTargetIdVaild failed. targetId is empty."); - return ERR_DM_INPUT_PARA_INVALID; - } - return DM_OK; -} -} // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file diff --git a/services/implementation/src/pinholder/pin_holder_session.cpp b/services/implementation/src/pinholder/pin_holder_session.cpp deleted file mode 100644 index 9bc60d115..000000000 --- a/services/implementation/src/pinholder/pin_holder_session.cpp +++ /dev/null @@ -1,161 +0,0 @@ -/* - * Copyright (c) 2023-2024 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 "pin_holder_session.h" - -#include "dm_anonymous.h" -#include "dm_constants.h" -#include "dm_log.h" -#include "dm_softbus_adapter_crypto.h" -#include "nlohmann/json.hpp" -#include "softbus_connector.h" - -namespace OHOS { -namespace DistributedHardware { -std::shared_ptr PinHolderSession::sessionCallback_ = nullptr; -PinHolderSession::PinHolderSession() -{ - LOGD("PinHolderSession constructor."); -} - -PinHolderSession::~PinHolderSession() -{ - LOGD("PinHolderSession destructor."); -} - -int32_t PinHolderSession::RegisterSessionCallback(std::shared_ptr callback) -{ - sessionCallback_ = callback; - return DM_OK; -} - -int32_t PinHolderSession::UnRegisterSessionCallback() -{ - sessionCallback_ = nullptr; - return DM_OK; -} - -int32_t PinHolderSession::OpenSessionServer(const PeerTargetId &targetId) -{ - int32_t sessionId = -1; - ConnectionAddr addrInfo; - if (GetAddrByTargetId(targetId, addrInfo) != DM_OK) { - LOGE("[SOFTBUS]open session error, sessionId: %d.", sessionId); - } - sessionId = ::OpenAuthSession(DM_PIN_HOLDER_SESSION_NAME, &addrInfo, 1, nullptr); - if (sessionId < 0) { - LOGE("[SOFTBUS]open session error, sessionId: %d.", sessionId); - return sessionId; - } - LOGI("OpenAuthSession success. sessionId: %d.", sessionId); - return sessionId; -} - -int32_t PinHolderSession::CloseSessionServer(int32_t sessionId) -{ - LOGD("CloseSessionServer."); - ::CloseSession(sessionId); - return DM_OK; -} - -int PinHolderSession::OnSessionOpened(int sessionId, int result) -{ - if (sessionCallback_ == nullptr) { - LOGE("OnSessionOpened error, sessionCallback_ is nullptr."); - return ERR_DM_FAILED; - } - int32_t sessionSide = GetSessionSide(sessionId); - sessionCallback_->OnSessionOpened(sessionId, sessionSide, result); - LOGI("OnSessionOpened, success, sessionId: %d.", sessionId); - return DM_OK; -} - -void PinHolderSession::OnSessionClosed(int sessionId) -{ - LOGI("[SOFTBUS]OnSessionClosed sessionId: %d", sessionId); - if (sessionCallback_ == nullptr) { - LOGE("OnSessionClosed error, sessionCallback_ is nullptr."); - return; - } - sessionCallback_->OnSessionClosed(sessionId); - return; -} - -void PinHolderSession::OnBytesReceived(int sessionId, const void *data, unsigned int dataLen) -{ - if (sessionId < 0 || data == nullptr || dataLen <= 0) { - LOGE("[SOFTBUS]fail to receive data from softbus with sessionId: %d, dataLen: %d.", sessionId, dataLen); - return; - } - if (sessionCallback_ == nullptr) { - LOGE("OnBytesReceived error, sessionCallback_ is nullptr."); - return; - } - LOGI("start, sessionId: %d, dataLen: %d.", sessionId, dataLen); - std::string message = std::string(reinterpret_cast(data), dataLen); - sessionCallback_->OnDataReceived(sessionId, message); - return; -} - -int32_t PinHolderSession::SendData(int32_t sessionId, const std::string &message) -{ - nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); - if (jsonObject.is_discarded()) { - LOGE("extrasJson error, message: %s.", message.c_str()); - return ERR_DM_FAILED; - } - if (!IsInt32(jsonObject, TAG_MSG_TYPE)) { - LOGE("SoftbusSession::SendData err json string."); - return ERR_DM_FAILED; - } - int32_t msgType = jsonObject[TAG_MSG_TYPE].get(); - LOGI("start, msgType: %d.", msgType); - int32_t ret = SendBytes(sessionId, message.c_str(), strlen(message.c_str())); - if (ret != DM_OK) { - LOGE("[SOFTBUS]SendBytes failed, ret: %d.", ret); - return ERR_DM_FAILED; - } - return ret; -} - -int32_t PinHolderSession::GetAddrByTargetId(const PeerTargetId &targetId, ConnectionAddr &addr) -{ - if (!targetId.wifiIp.empty() && targetId.wifiIp.length() <= IP_STR_MAX_LEN) { - addr.type = ConnectionAddrType::CONNECTION_ADDR_WLAN; - memcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, targetId.wifiIp.c_str(), targetId.wifiIp.length()); - addr.info.ip.port = targetId.wifiPort; - } else if (!targetId.brMac.empty() && targetId.brMac.length() <= BT_MAC_LEN) { - addr.type = ConnectionAddrType::CONNECTION_ADDR_BR; - memcpy_s(addr.info.br.brMac, BT_MAC_LEN, targetId.brMac.c_str(), targetId.brMac.length()); - } else if (!targetId.bleMac.empty() && targetId.bleMac.length() <= BT_MAC_LEN) { - addr.type = ConnectionAddrType::CONNECTION_ADDR_BLE; - memcpy_s(addr.info.ble.bleMac, BT_MAC_LEN, targetId.bleMac.c_str(), targetId.bleMac.length()); - if (!targetId.deviceId.empty()) { - DmSoftbusAdapterCrypto::ConvertHexStringToBytes(addr.info.ble.udidHash, UDID_HASH_LEN, - targetId.deviceId.c_str(), targetId.deviceId.length()); - } - } else if (!targetId.deviceId.empty()) { - std::string connectAddr; - ConnectionAddr *addrInfo = SoftbusConnector::GetConnectAddr(targetId.deviceId, connectAddr); - if (addrInfo == nullptr) { - LOGE("GetConnectAddr failed."); - return ERR_DM_INPUT_PARA_INVALID; - } - addr = *addrInfo; - } - return DM_OK; -} -} // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file diff --git a/services/service/include/pinholder/pin_holder.h b/services/service/include/pinholder/pin_holder.h index e85572388..c9ba1b966 100644 --- a/services/service/include/pinholder/pin_holder.h +++ b/services/service/include/pinholder/pin_holder.h @@ -13,12 +13,13 @@ * limitations under the License. */ -#ifndef OHOS_DM_PIN_HOLDER_H -#define OHOS_DM_PIN_HOLDER_H +#ifndef OHOS_PIN_HOLDER_H +#define OHOS_PIN_HOLDER_H #include "dm_timer.h" #include "idevice_manager_service_listener.h" #include "pin_holder_session.h" +#include "pinholder_session_callback.h" #include #include @@ -35,7 +36,7 @@ typedef enum PinHolderState { } PinHolderState; class PinHolder final : public IPinholderSessionCallback, - public std::enable_shared_from_this { + public std::enable_shared_from_this { public: PinHolder(std::shared_ptr listener); ~PinHolder(); @@ -74,4 +75,4 @@ private: }; } } -#endif // OHOS_DM_PIN_HOLDER_H \ No newline at end of file +#endif // OHOS_PIN_HOLDER_H \ No newline at end of file diff --git a/services/service/include/pinholder/pin_holder_session.h b/services/service/include/pinholder/pin_holder_session.h index abcc94085..fbeef1db8 100644 --- a/services/service/include/pinholder/pin_holder_session.h +++ b/services/service/include/pinholder/pin_holder_session.h @@ -74,7 +74,7 @@ private: int32_t GetAddrByTargetId(const PeerTargetId &targetId, ConnectionAddr &addrInfo); private: - static std::shared_ptr sessionCallback_; + static std::shared_ptr pinholderSessionCallback_; }; } } diff --git a/services/service/include/softbus/pinholder_session_callback.h b/services/service/include/softbus/pinholder_session_callback.h index b7f579aba..13dd1fc8d 100644 --- a/services/service/include/softbus/pinholder_session_callback.h +++ b/services/service/include/softbus/pinholder_session_callback.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DM_SOFTBUS_SESSION_CALLBACK_H -#define OHOS_DM_SOFTBUS_SESSION_CALLBACK_H +#ifndef OHOS_PIN_HOLDER_SESSION_CALLBACK_H +#define OHOS_PIN_HOLDER_SESSION_CALLBACK_H namespace OHOS { namespace DistributedHardware { @@ -26,4 +26,4 @@ public: }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DM_SOFTBUS_SESSION_CALLBACK_H +#endif // OHOS_PIN_HOLDER_SESSION_CALLBACK_H diff --git a/services/service/src/pinholder/pin_holder_session.cpp b/services/service/src/pinholder/pin_holder_session.cpp index 8749cf425..5d4a668e9 100644 --- a/services/service/src/pinholder/pin_holder_session.cpp +++ b/services/service/src/pinholder/pin_holder_session.cpp @@ -23,7 +23,7 @@ namespace OHOS { namespace DistributedHardware { -std::shared_ptr PinHolderSession::sessionCallback_ = nullptr; +std::shared_ptr PinHolderSession::pinholderSessionCallback_ = nullptr; PinHolderSession::PinHolderSession() { LOGD("PinHolderSession constructor."); @@ -36,13 +36,13 @@ PinHolderSession::~PinHolderSession() int32_t PinHolderSession::RegisterSessionCallback(std::shared_ptr callback) { - sessionCallback_ = callback; + pinholderSessionCallback_ = callback; return DM_OK; } int32_t PinHolderSession::UnRegisterSessionCallback() { - sessionCallback_ = nullptr; + pinholderSessionCallback_ = nullptr; return DM_OK; } @@ -71,12 +71,12 @@ int32_t PinHolderSession::CloseSessionServer(int32_t sessionId) int PinHolderSession::OnSessionOpened(int sessionId, int result) { - if (sessionCallback_ == nullptr) { - LOGE("OnSessionOpened error, sessionCallback_ is nullptr."); + if (pinholderSessionCallback_ == nullptr) { + LOGE("OnSessionOpened error, pinholderSessionCallback_ is nullptr."); return ERR_DM_FAILED; } int32_t sessionSide = GetSessionSide(sessionId); - sessionCallback_->OnSessionOpened(sessionId, sessionSide, result); + pinholderSessionCallback_->OnSessionOpened(sessionId, sessionSide, result); LOGI("OnSessionOpened, success, sessionId: %d.", sessionId); return DM_OK; } @@ -84,11 +84,11 @@ int PinHolderSession::OnSessionOpened(int sessionId, int result) void PinHolderSession::OnSessionClosed(int sessionId) { LOGI("[SOFTBUS]OnSessionClosed sessionId: %d", sessionId); - if (sessionCallback_ == nullptr) { - LOGE("OnSessionClosed error, sessionCallback_ is nullptr."); + if (pinholderSessionCallback_ == nullptr) { + LOGE("OnSessionClosed error, pinholderSessionCallback_ is nullptr."); return; } - sessionCallback_->OnSessionClosed(sessionId); + pinholderSessionCallback_->OnSessionClosed(sessionId); return; } @@ -98,13 +98,13 @@ void PinHolderSession::OnBytesReceived(int sessionId, const void *data, unsigned LOGE("[SOFTBUS]fail to receive data from softbus with sessionId: %d, dataLen: %d.", sessionId, dataLen); return; } - if (sessionCallback_ == nullptr) { - LOGE("OnBytesReceived error, sessionCallback_ is nullptr."); + if (pinholderSessionCallback_ == nullptr) { + LOGE("OnBytesReceived error, pinholderSessionCallback_ is nullptr."); return; } LOGI("start, sessionId: %d, dataLen: %d.", sessionId, dataLen); std::string message = std::string(reinterpret_cast(data), dataLen); - sessionCallback_->OnDataReceived(sessionId, message); + pinholderSessionCallback_->OnDataReceived(sessionId, message); return; } diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index b73aba86f..cba7433ed 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -126,7 +126,11 @@ ohos_unittest("UTTest_ipc_cmd_register") { ohos_unittest("UTTest_dm_pin_holder") { module_out_path = module_out_path - sources = [ "UTTest_dm_pin_holder.cpp" ] + sources = [ + "UTTest_dm_pin_holder.cpp", + "${services_path}/src/pinholder/pin_holder.cpp", + "${services_path}/src/pinholder/pin_holder_session.cpp", + ] deps = [ ":device_manager_test_common" ] diff --git a/test/unittest/UTTest_dm_pin_holder.cpp b/test/unittest/UTTest_dm_pin_holder.cpp index 154ae6004..0c6c7c571 100644 --- a/test/unittest/UTTest_dm_pin_holder.cpp +++ b/test/unittest/UTTest_dm_pin_holder.cpp @@ -40,6 +40,8 @@ #include "nlohmann/json.hpp" #include "securec.h" #include "token_setproc.h" +#include "pin_holder.h" +#include "pinholder_session_callback.h" namespace OHOS { namespace DistributedHardware { @@ -146,13 +148,9 @@ HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_102, testing::ext::TestSize. { std::string packName = "com.ohos.dmtest"; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); - dmPinHolder->session_ = nullptr; pinHolder->session_ = nullptr; - int32_t ret = dmPinHolder->RegisterPinHolderCallback(packName); - ASSERT_EQ(ret, ERR_DM_FAILED); - ret = pinHolder->RegisterPinHolderCallback(packName); + int32_t ret = pinHolder->RegisterPinHolderCallback(packName); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -160,13 +158,9 @@ HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_103, testing::ext::TestSize. { std::string packName = "com.ohos.dmtest"; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); - dmPinHolder->session_ = std::make_shared(); pinHolder->session_ = std::make_shared(); - int32_t ret = dmPinHolder->RegisterPinHolderCallback(packName); - ASSERT_EQ(ret, DM_OK); - ret = pinHolder->RegisterPinHolderCallback(packName); + int32_t ret = pinHolder->RegisterPinHolderCallback(packName); ASSERT_EQ(ret, DM_OK); } @@ -193,13 +187,9 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_102, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = ""; pinHolder->registerPkgName_ = ""; - int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); - ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -210,13 +200,9 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_103, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = "dmtest"; pinHolder->registerPkgName_ = "dmtest"; - int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); - ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -233,13 +219,9 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_105, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = packName; pinHolder->registerPkgName_ = packName; - int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); - ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -256,15 +238,10 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_106, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = packName; - dmPinHolder->listener_ = nullptr; - int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->registerPkgName_ = packName; pinHolder->listener_ = nullptr; - ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -281,15 +258,10 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_107, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = packName; - dmPinHolder->session_ = nullptr; - int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->registerPkgName_ = packName; pinHolder->session_ = nullptr; - ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -306,15 +278,10 @@ HWTEST_F(DmPinHolderTest, CreatePinholder_108, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = packName; - dmPinHolder->sourceState_ = SOURCE_CREATE; - int32_t ret = dmPinHolder->CreatePinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->registerPkgName_ = packName; pinHolder->sourceState_ = SOURCE_CREATE; - ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->CreatePinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -330,13 +297,9 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_101, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->listener_ = nullptr; - int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->listener_ = nullptr; - ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -352,13 +315,9 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_102, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->session_ = nullptr; - int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->session_ = nullptr; - ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -374,13 +333,9 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_103, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = ""; - int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->registerPkgName_ = ""; - ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -396,13 +351,9 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_104, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = "dmtest"; - int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->registerPkgName_ = "dmtest"; - ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } @@ -418,13 +369,9 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_105, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = packName; - int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->registerPkgName_ = packName; - ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } @@ -440,70 +387,47 @@ HWTEST_F(DmPinHolderTest, DestroyPinHolder_106, testing::ext::TestSize.Level0) DmPinType pinType = DmPinType::NUMBER_PIN_CODE; std::string payload; std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->registerPkgName_ = packName; - int32_t sessionId = 0; - dmPinHolder->sessionId_ = sessionId; - dmPinHolder->sourceState_ = SOURCE_DESTROY; - dmPinHolder->listener_ = std::make_shared(); - int32_t ret = dmPinHolder->DestroyPinHolder(packName, targetId, pinType, payload); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->registerPkgName_ = packName; - pinHolder->sessionId_ = sessionId; + pinHolder->sessionId_ = 0; pinHolder->sourceState_ = SOURCE_DESTROY; pinHolder->listener_ = std::make_shared(); - ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); + int32_t ret = pinHolder->DestroyPinHolder(packName, targetId, pinType, payload); ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->listener_ = nullptr; - int32_t ret = dmPinHolder->CreateGeneratePinHolderMsg(); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->listener_ = nullptr; - ret = pinHolder->CreateGeneratePinHolderMsg(); + int32_t ret = pinHolder->CreateGeneratePinHolderMsg(); ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); - dmPinHolder->session_ = nullptr; - int32_t ret = dmPinHolder->CreateGeneratePinHolderMsg(); - ASSERT_EQ(ret, ERR_DM_FAILED); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->session_ = nullptr; - ret = pinHolder->CreateGeneratePinHolderMsg(); + int32_t ret = pinHolder->CreateGeneratePinHolderMsg(); ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, ParseMsgType_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); std::string message; - int32_t ret = dmPinHolder->ParseMsgType(message); - ASSERT_EQ(ret, ERR_DM_FAILED); - ret = pinHolder->ParseMsgType(message); + int32_t ret = pinHolder->ParseMsgType(message); ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, ProcessCreateMsg_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); std::string message; - dmPinHolder->listener_ = nullptr; - dmPinHolder->ProcessCreateMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->listener_ = nullptr; pinHolder->ProcessCreateMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); @@ -512,12 +436,8 @@ HWTEST_F(DmPinHolderTest, ProcessCreateMsg_101, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessCreateMsg_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); std::string message; - dmPinHolder->session_ = nullptr; - dmPinHolder->ProcessCreateMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->session_ = nullptr; pinHolder->ProcessCreateMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); @@ -526,12 +446,9 @@ HWTEST_F(DmPinHolderTest, ProcessCreateMsg_102, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessCreateMsg_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; std::string message = jsonObject.dump(); - dmPinHolder->ProcessCreateMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->ProcessCreateMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -539,13 +456,10 @@ HWTEST_F(DmPinHolderTest, ProcessCreateMsg_103, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessCreateMsg_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = "TAG_PIN_TYPE"; std::string message = jsonObject.dump(); - dmPinHolder->ProcessCreateMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->ProcessCreateMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -553,14 +467,11 @@ HWTEST_F(DmPinHolderTest, ProcessCreateMsg_104, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessCreateMsg_105, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = DmPinType::SUPER_SONIC; jsonObject[TAG_PAYLOAD] = DmPinType::SUPER_SONIC; std::string message = jsonObject.dump(); - dmPinHolder->ProcessCreateMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->ProcessCreateMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -568,12 +479,9 @@ HWTEST_F(DmPinHolderTest, ProcessCreateMsg_105, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; std::string message = jsonObject.dump(); - dmPinHolder->ProcessCreateRespMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->ProcessCreateRespMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -581,14 +489,10 @@ HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_101, testing::ext::TestSize.Level HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE; std::string message = jsonObject.dump(); - dmPinHolder->listener_ = nullptr; - dmPinHolder->ProcessCreateRespMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->listener_ = nullptr; pinHolder->ProcessCreateRespMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); @@ -597,14 +501,10 @@ HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_102, testing::ext::TestSize.Level HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_REPLY] = DmPinType::SUPER_SONIC; std::string message = jsonObject.dump(); - dmPinHolder->session_ = nullptr; - dmPinHolder->ProcessCreateRespMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->session_ = nullptr; pinHolder->ProcessCreateRespMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); @@ -613,14 +513,10 @@ HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_103, testing::ext::TestSize.Level HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_REPLY] = DmPinType::NUMBER_PIN_CODE; std::string message = jsonObject.dump(); - dmPinHolder->session_ = nullptr; - dmPinHolder->ProcessCreateRespMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->session_ = nullptr; pinHolder->ProcessCreateRespMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); @@ -629,12 +525,8 @@ HWTEST_F(DmPinHolderTest, ProcessCreateRespMsg_104, testing::ext::TestSize.Level HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); std::string message; - dmPinHolder->listener_ = nullptr; - dmPinHolder->ProcessDestroyMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->listener_ = nullptr; pinHolder->ProcessDestroyMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); @@ -643,12 +535,8 @@ HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_101, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); std::string message; - dmPinHolder->session_ = nullptr; - dmPinHolder->ProcessDestroyMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->session_ = nullptr; pinHolder->ProcessDestroyMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); @@ -657,12 +545,9 @@ HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_102, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; std::string message = jsonObject.dump(); - dmPinHolder->ProcessDestroyMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->ProcessDestroyMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -670,13 +555,10 @@ HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_103, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = "TAG_PIN_TYPE"; std::string message = jsonObject.dump(); - dmPinHolder->ProcessDestroyMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->ProcessDestroyMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -684,14 +566,11 @@ HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_104, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_105, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); nlohmann::json jsonObject; jsonObject[TAG_PIN_TYPE] = DmPinType::SUPER_SONIC; jsonObject[TAG_PAYLOAD] = DmPinType::SUPER_SONIC; std::string message = jsonObject.dump(); - dmPinHolder->ProcessDestroyMsg(message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->ProcessDestroyMsg(message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -699,12 +578,8 @@ HWTEST_F(DmPinHolderTest, ProcessDestroyMsg_105, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, CloseSession_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); std::string name; - dmPinHolder->session_ = nullptr; - dmPinHolder->CloseSession(name); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->session_ = nullptr; pinHolder->CloseSession(name); ASSERT_NE(pinHolder->timer_, nullptr); @@ -713,14 +588,11 @@ HWTEST_F(DmPinHolderTest, CloseSession_101, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, OnDataReceived_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER; std::string message = jsonObject.dump(); - dmPinHolder->OnDataReceived(sessionId, message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->OnDataReceived(sessionId, message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -728,14 +600,11 @@ HWTEST_F(DmPinHolderTest, OnDataReceived_101, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, OnDataReceived_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_CREATE_PIN_HOLDER_RESP; std::string message = jsonObject.dump(); - dmPinHolder->OnDataReceived(sessionId, message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->OnDataReceived(sessionId, message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -743,14 +612,11 @@ HWTEST_F(DmPinHolderTest, OnDataReceived_102, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, OnDataReceived_103, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER; std::string message = jsonObject.dump(); - dmPinHolder->OnDataReceived(sessionId, message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->OnDataReceived(sessionId, message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -758,14 +624,11 @@ HWTEST_F(DmPinHolderTest, OnDataReceived_103, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, OnDataReceived_104, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = MSG_TYPE_DESTROY_PIN_HOLDER_RESP; std::string message = jsonObject.dump(); - dmPinHolder->OnDataReceived(sessionId, message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->OnDataReceived(sessionId, message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -773,15 +636,12 @@ HWTEST_F(DmPinHolderTest, OnDataReceived_104, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, OnDataReceived_105, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; int32_t data = 300; nlohmann::json jsonObject; jsonObject[TAG_MSG_TYPE] = data; std::string message = jsonObject.dump(); - dmPinHolder->OnDataReceived(sessionId, message); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->OnDataReceived(sessionId, message); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -789,12 +649,9 @@ HWTEST_F(DmPinHolderTest, OnDataReceived_105, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, GetPeerDeviceId_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; std::string udidHash; - dmPinHolder->GetPeerDeviceId(sessionId, udidHash); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->GetPeerDeviceId(sessionId, udidHash); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -802,13 +659,10 @@ HWTEST_F(DmPinHolderTest, GetPeerDeviceId_101, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, OnSessionOpened_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; int32_t sessionSide = 0; int32_t result = 0; - dmPinHolder->OnSessionOpened(sessionId, sessionSide, result); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder->OnSessionOpened(sessionId, sessionSide, result); ASSERT_NE(pinHolder->timer_, nullptr); } @@ -816,14 +670,10 @@ HWTEST_F(DmPinHolderTest, OnSessionOpened_101, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, OnSessionOpened_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); int32_t sessionId = 1; int32_t sessionSide = 1; int32_t result = 1; - dmPinHolder ->listener_ = nullptr; - dmPinHolder->OnSessionOpened(sessionId, sessionSide, result); - ASSERT_NE(dmPinHolder->timer_, nullptr); pinHolder ->listener_ = nullptr; pinHolder->OnSessionOpened(sessionId, sessionSide, result); ASSERT_NE(pinHolder->timer_, nullptr); @@ -833,7 +683,6 @@ HWTEST_F(DmPinHolderTest, OnSessionOpened_102, testing::ext::TestSize.Level0) HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_101, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); PeerTargetId targetId = { .deviceId = "", @@ -841,16 +690,13 @@ HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_101, testing::ext::TestSize.Level0) .bleMac = "", .wifiIp = "", }; - int32_t ret = dmPinHolder->CheckTargetIdVaild(targetId); - ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); - ret = pinHolder->CheckTargetIdVaild(targetId); + int32_t ret = pinHolder->CheckTargetIdVaild(targetId); ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_102, testing::ext::TestSize.Level0) { std::shared_ptr listener = std::make_shared(); - std::shared_ptr dmPinHolder = std::make_shared(listener); std::shared_ptr pinHolder = std::make_shared(listener); PeerTargetId targetId = { .deviceId = "deviceId", @@ -858,9 +704,7 @@ HWTEST_F(DmPinHolderTest, CheckTargetIdVaild_102, testing::ext::TestSize.Level0) .bleMac = "bleMac", .wifiIp = "wifiIp", }; - int32_t ret = dmPinHolder->CheckTargetIdVaild(targetId); - ASSERT_EQ(ret, DM_OK); - ret = pinHolder->CheckTargetIdVaild(targetId); + int32_t ret = pinHolder->CheckTargetIdVaild(targetId); ASSERT_EQ(ret, DM_OK); } } // namespace diff --git a/test/unittest/UTTest_dm_pin_holder.h b/test/unittest/UTTest_dm_pin_holder.h index 44f8716c1..b18006aa3 100644 --- a/test/unittest/UTTest_dm_pin_holder.h +++ b/test/unittest/UTTest_dm_pin_holder.h @@ -24,8 +24,7 @@ #include "mock/mock_ipc_client_proxy.h" #include "device_manager.h" #include "single_instance.h" -#include "dm_pin_holder.h" -#include "pin_holder.h" +#include "idevice_manager_service_listener.h" namespace OHOS { namespace DistributedHardware { -- Gitee From 019ab1ae3790e2b9251dbf31bea83b2cccc718cd Mon Sep 17 00:00:00 2001 From: yangwei_814916 Date: Sat, 20 Jan 2024 15:05:44 +0800 Subject: [PATCH 5/5] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=BC=80=E6=9C=BA?= =?UTF-8?q?=E5=86=85=E5=AD=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: yangwei_814916 --- test/unittest/BUILD.gn | 2 +- test/unittest/UTTest_dm_pin_holder.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index cba7433ed..9f4aeabbd 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -127,9 +127,9 @@ ohos_unittest("UTTest_dm_pin_holder") { module_out_path = module_out_path sources = [ - "UTTest_dm_pin_holder.cpp", "${services_path}/src/pinholder/pin_holder.cpp", "${services_path}/src/pinholder/pin_holder_session.cpp", + "UTTest_dm_pin_holder.cpp", ] deps = [ ":device_manager_test_common" ] diff --git a/test/unittest/UTTest_dm_pin_holder.cpp b/test/unittest/UTTest_dm_pin_holder.cpp index 0c6c7c571..1723dd780 100644 --- a/test/unittest/UTTest_dm_pin_holder.cpp +++ b/test/unittest/UTTest_dm_pin_holder.cpp @@ -411,7 +411,7 @@ HWTEST_F(DmPinHolderTest, CreateGeneratePinHolderMsg_102, testing::ext::TestSize std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->session_ = nullptr; int32_t ret = pinHolder->CreateGeneratePinHolderMsg(); - ASSERT_EQ(ret, ERR_DM_FAILED); + ASSERT_EQ(ret, ERR_DM_FAILED); } HWTEST_F(DmPinHolderTest, ParseMsgType_101, testing::ext::TestSize.Level0) -- Gitee