From f8d023f52dd83f18a146edfbcd714199ae94b4ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E9=9B=B7?= Date: Tue, 26 Aug 2025 09:46:14 +0800 Subject: [PATCH 1/2] add service discovery MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张雷 --- .../device_manager_ipc_interface_code.h | 4 + .../ipc_notify_service_discover_result_req.h | 53 ++++++++++++ .../ipc/model/ipc_notify_service_found_req.h | 53 ++++++++++++ .../model/ipc_start_service_discovery_req.h | 42 +++++++++ common/include/ipc/standard/ipc_model_codec.h | 4 + common/src/ipc/standard/ipc_model_codec.cpp | 50 +++++++++++ .../native_cpp/include/device_manager.h | 4 + .../include/device_manager_callback.h | 9 ++ .../native_cpp/include/device_manager_impl.h | 4 + .../native_cpp/include/dm_device_info.h | 15 ++++ .../include/i_dm_service_impl_ext.h | 2 + .../include/i_dm_service_impl_ext_resident.h | 2 + .../idevice_manager_service_listener.h | 3 + .../include/notify/device_manager_notify.h | 6 ++ .../native_cpp/src/device_manager_impl.cpp | 56 ++++++++++++ .../src/ipc/standard/ipc_cmd_parser.cpp | 85 +++++++++++++++++++ .../src/notify/device_manager_notify.cpp | 57 +++++++++++++ .../service/include/device_manager_service.h | 2 + .../include/device_manager_service_listener.h | 3 + .../service/src/device_manager_service.cpp | 39 +++++++++ .../src/device_manager_service_listener.cpp | 24 ++++++ .../src/ipc/standard/ipc_cmd_parser.cpp | 80 +++++++++++++++++ 22 files changed, 597 insertions(+) create mode 100644 common/include/ipc/model/ipc_notify_service_discover_result_req.h create mode 100644 common/include/ipc/model/ipc_notify_service_found_req.h create mode 100644 common/include/ipc/model/ipc_start_service_discovery_req.h diff --git a/common/include/device_manager_ipc_interface_code.h b/common/include/device_manager_ipc_interface_code.h index 418684851..8a8a4c9a9 100644 --- a/common/include/device_manager_ipc_interface_code.h +++ b/common/include/device_manager_ipc_interface_code.h @@ -122,6 +122,10 @@ enum DMIpcCmdInterfaceCode { CHECK_SINK_ACCESS_CONTROL, CHECK_SRC_SAME_ACCOUNT, CHECK_SINK_SAME_ACCOUNT, + START_SERVICE_DISCOVERING, + STOP_SERVICE_DISCOVERING, + NOTIFY_SERVICE_FOUND, + NOTIFY_SERVICE_DISCOVERY_RESULT, // Add ipc msg here IPC_MSG_BUTT }; diff --git a/common/include/ipc/model/ipc_notify_service_discover_result_req.h b/common/include/ipc/model/ipc_notify_service_discover_result_req.h new file mode 100644 index 000000000..c7d70355f --- /dev/null +++ b/common/include/ipc/model/ipc_notify_service_discover_result_req.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DM_IPC_NOTIFY_SERVICE_DISCOVER_RESULT_REQ_H +#define OHOS_DM_IPC_NOTIFY_SERVICE_DISCOVER_RESULT_REQ_H + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyServiceDiscoverResultReq : public IpcReq { + DECLARE_IPC_MODEL(IpcNotifyServiceDiscoverResultReq); + +public: + int32_t GetDiscServiceId() const + { + return discServiceId_; + } + + void SetDiscServiceId(int32_t discServiceId) + { + discServiceId_ = discServiceId; + } + + int32_t GetResult() const + { + return result_; + } + + void SetResult(int32_t result) + { + result_ = result; + } + +private: + int32_t discServiceId_ { 0 }; + int32_t result_ { 0 }; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_IPC_NOTIFY_SERVICE_DISCOVER_RESULT_REQ_H diff --git a/common/include/ipc/model/ipc_notify_service_found_req.h b/common/include/ipc/model/ipc_notify_service_found_req.h new file mode 100644 index 000000000..527ad1aec --- /dev/null +++ b/common/include/ipc/model/ipc_notify_service_found_req.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DM_IPC_NOTIFY_SERVICE_FOUND_REQ_H +#define OHOS_DM_IPC_NOTIFY_SERVICE_FOUND_REQ_H + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyServiceFoundReq : public IpcReq { + DECLARE_IPC_MODEL(IpcNotifyServiceFoundReq); + +public: + int32_t GetDiscServiceId() const + { + return discServiceId_; + } + + void SetDiscServiceId(int32_t discServiceId) + { + discServiceId_ = discServiceId; + } + + const DiscoveryServiceInfo &GetDiscServiceInfo() const + { + return discServiceInfo_; + } + + void SetDiscServiceInfo(const DiscoveryServiceInfo &discServiceInfo) + { + discServiceInfo_ = discServiceInfo; + } + +private: + int32_t discServiceId_ { 0 }; + DiscoveryServiceInfo discServiceInfo_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_IPC_NOTIFY_SERVICE_FOUND_REQ_H diff --git a/common/include/ipc/model/ipc_start_service_discovery_req.h b/common/include/ipc/model/ipc_start_service_discovery_req.h new file mode 100644 index 000000000..3ebb89310 --- /dev/null +++ b/common/include/ipc/model/ipc_start_service_discovery_req.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DM_IPC_START_SERVICE_DISCOVERY_REQ_H +#define OHOS_DM_IPC_START_SERVICE_DISCOVERY_REQ_H + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcStartServiceDiscoveryReq : public IpcReq { + DECLARE_IPC_MODEL(IpcStartServiceDiscoveryReq); + +public: + DiscoveryServiceParam GetDiscParam() const + { + return discParam_; + } + + void SetDiscParam(const DiscoveryServiceParam &discParam) + { + discParam_ = discParam; + } + +private: + DiscoveryServiceParam discParam_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_IPC_START_SERVICE_DISCOVERY_REQ_H \ No newline at end of file diff --git a/common/include/ipc/standard/ipc_model_codec.h b/common/include/ipc/standard/ipc_model_codec.h index e06af83a9..37f9159fc 100644 --- a/common/include/ipc/standard/ipc_model_codec.h +++ b/common/include/ipc/standard/ipc_model_codec.h @@ -56,6 +56,10 @@ public: static bool DecodeNetworkIdQueryFilter(MessageParcel &parcel, NetworkIdQueryFilter &queryFilter); static bool EncodeStringVector(const std::vector &vec, MessageParcel &parcel); static bool DecodeStringVector(MessageParcel &parcel, std::vector &vec); + static bool EncodeSrvDiscParam(const DiscoveryServiceParam ¶m, MessageParcel &parcel); + static bool DecodeSrvDiscParam(MessageParcel &parcel, DiscoveryServiceParam ¶m); + static bool EncodeSrvDiscServiceInfo(const DiscoveryServiceInfo &serviceInfo, MessageParcel &parcel); + static bool DecodeSrvDiscServiceInfo(MessageParcel &parcel, DiscoveryServiceInfo &serviceInfo); }; } // namespace DistributedHardware } // namespace OHOS diff --git a/common/src/ipc/standard/ipc_model_codec.cpp b/common/src/ipc/standard/ipc_model_codec.cpp index 2e336c5fd..46894a9ce 100644 --- a/common/src/ipc/standard/ipc_model_codec.cpp +++ b/common/src/ipc/standard/ipc_model_codec.cpp @@ -493,6 +493,56 @@ bool IpcModelCodec::DecodeStringVector(MessageParcel &parcel, std::vector callback) = 0; + virtual int32_t StopServiceDiscovery(const std::string &pkgName, int32_t discoveryServiceId) = 0; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h b/interfaces/inner_kits/native_cpp/include/device_manager_callback.h index e40343680..5ed96ac73 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h +++ b/interfaces/inner_kits/native_cpp/include/device_manager_callback.h @@ -179,6 +179,15 @@ public: } virtual void OnCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId, int32_t errcode) = 0; }; + +class ServiceDiscoveryCallback { +public: + virtual ~ServiceDiscoveryCallback() + { + } + virtual void OnServiceFound(const DiscoveryServiceInfo &service) = 0; + virtual void OnServiceDiscoveryResult(int32_t resReason) = 0; +}; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DM_CALLBACK_H diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h index 863626aef..ce3ae6484 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h +++ b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h @@ -440,6 +440,10 @@ public: virtual bool CheckSrcIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee) override; virtual bool CheckSinkIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee) override; + virtual int32_t StartServiceDiscovery(const std::string &pkgName, const DiscoveryServiceParam &discParam, + std::shared_ptr callback) override; + virtual int32_t StopServiceDiscovery(const std::string &pkgName, int32_t discoveryServiceId) override; + private: DeviceManagerImpl() = default; ~DeviceManagerImpl() = default; diff --git a/interfaces/inner_kits/native_cpp/include/dm_device_info.h b/interfaces/inner_kits/native_cpp/include/dm_device_info.h index b7704d94d..c7aecdbc3 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_device_info.h +++ b/interfaces/inner_kits/native_cpp/include/dm_device_info.h @@ -20,6 +20,7 @@ #include #include "dm_app_image_info.h" +#include "dm_subscribe_info.h" #define DM_MAX_DEVICE_ID_LEN (97) #define DM_MAX_DEVICE_NAME_LEN (129) @@ -470,6 +471,20 @@ typedef struct DMAclQuadInfo { std::string peerUdid; int32_t peerUserId; } DMAclQuadInfo; + +typedef struct DiscoveryServiceParam { + std::string serviceName; + std::string serviceType; + int32_t discoveryServiceId; + DmExchangeFreq freq; + DMSrvMediumType medium; + DMSrvDiscoveryMode mode; +} DiscoveryServiceParam; + +typedef struct DiscoveryServiceInfo { + ServiceInfo serviceInfo; + std::string pkgName; +} DiscoveryServiceInfo; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DM_DEVICE_INFO_H \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext.h b/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext.h index cb4bb85bc..9de1bff15 100644 --- a/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext.h +++ b/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext.h @@ -107,6 +107,8 @@ public: virtual void OnSessionClosed(const int32_t sessionId) = 0; virtual void OnBytesReceived(const int32_t sessionId, const std::string message) = 0; virtual int32_t OpenAuthSessionWithPara(const std::string &deviceId, int32_t actionId, bool isEnable160m) = 0; + virtual int32_t StartServiceDiscovery(const ProcessInfo &processInfo, const DiscoveryServiceParam &discParam) = 0; + virtual int32_t StopServiceDiscovery(int32_t discServiceId) = 0; }; using CreateDMServiceImplExtFuncPtr = IDMServiceImplExt *(*)(void); diff --git a/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h b/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h index 4f738fc7c..d4683c745 100644 --- a/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h +++ b/interfaces/inner_kits/native_cpp/include/i_dm_service_impl_ext_resident.h @@ -113,6 +113,8 @@ public: virtual void HandleScreenLockEvent(bool isLock) = 0; virtual int32_t OpenAuthSessionWithPara(const std::string &deviceId, int32_t actionId, bool isEnable160m) = 0; virtual void HandleUserSwitchEvent(int32_t currentUserId, int32_t beforeUserId) = 0; + virtual int32_t StartServiceDiscovery(const ProcessInfo &processInfo, const DiscoveryServiceParam &discParam) = 0; + virtual int32_t StopServiceDiscovery(int32_t discServiceId) = 0; }; using CreateDMServiceExtResidentFuncPtr = IDMServiceImplExtResident *(*)(void); diff --git a/interfaces/inner_kits/native_cpp/include/idevice_manager_service_listener.h b/interfaces/inner_kits/native_cpp/include/idevice_manager_service_listener.h index 336c5b631..0a65c48ab 100644 --- a/interfaces/inner_kits/native_cpp/include/idevice_manager_service_listener.h +++ b/interfaces/inner_kits/native_cpp/include/idevice_manager_service_listener.h @@ -174,6 +174,9 @@ public: virtual void OnSetRemoteDeviceNameResult(const ProcessInfo &processInfo, const std::string &deviceId, const std::string &deviceName, int32_t code) = 0; virtual void SetExistPkgName(const std::set &pkgNameSet) = 0; + virtual void OnServiceFound(const ProcessInfo &processInfo, int32_t discServiceId, + const DiscoveryServiceInfo &discServiceInfo) = 0; + virtual void OnServiceDiscoveryResult(const ProcessInfo &processInfo, int32_t discServiceId, int32_t reason) = 0; virtual std::string GetLocalDisplayDeviceName() = 0; virtual int32_t OpenAuthSessionWithPara(const std::string &deviceId, int32_t actionId, bool isEnable160m) = 0; diff --git a/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h b/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h index 39a229cc8..5473dcfff 100644 --- a/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h +++ b/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h @@ -87,6 +87,9 @@ public: std::shared_ptr callback); void OnSetRemoteDeviceNameResult(const std::string &pkgName, const std::string &deviceId, int32_t code); void UnRegisterPinHolderCallback(const std::string &pkgName); + void RegisterServiceDiscoveryCallback(int32_t discoveryServiceId, + std::shared_ptr callback); + void UnRegisterServiceDiscoveryCallback(int32_t discoveryServiceId); public: static void DeviceInfoOnline(const DmDeviceInfo &deviceInfo, std::shared_ptr tempCbk); @@ -139,6 +142,8 @@ public: std::string content); std::shared_ptr GetDiscoveryCallback(const std::string &pkgName, uint16_t subscribeId); void GetCallBack(std::map> &callbackMap); + void OnServiceFound(int32_t discoveryServiceId, const DiscoveryServiceInfo &service); + void OnServiceDiscoveryResult(int32_t discoveryServiceId, int32_t resReason); private: #if !defined(__LITEOS_M__) @@ -166,6 +171,7 @@ private: std::map> setLocalDeviceNameCallback_; std::map>> setRemoteDeviceNameCallback_; + std::map> serviceDiscoveryCallbacks_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp index d07c6ff68..8d38f04a7 100644 --- a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp +++ b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp @@ -63,6 +63,7 @@ #include "ipc_set_remote_device_name_req.h" #include "ipc_set_useroperation_req.h" #include "ipc_skeleton.h" +#include "ipc_start_service_discovery_req.h" #include "ipc_sync_callback_req.h" #include "ipc_unauthenticate_device_req.h" #include "ipc_unbind_device_req.h" @@ -2998,5 +2999,60 @@ bool DeviceManagerImpl::CheckAclByIpcCode(const DmAccessCaller &caller, const Dm anonyLocalUdid_); return result; } + +int32_t DeviceManagerImpl::StartServiceDiscovery(const std::string &pkgName, const DiscoveryServiceParam &discParam, + std::shared_ptr callback) +{ + LOGI("StartServiceDiscovery start."); + if (pkgName.empty() || callback == nullptr || discParam.serviceType.empty() || discParam.discoveryServiceId == 0) { + LOGE("error: Invalid para"); + return ERR_DM_INPUT_PARA_INVALID; + } + DeviceManagerNotify::GetInstance().RegisterServiceDiscoveryCallback(discParam.discoveryServiceId, callback); + + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + req->SetDiscParam(discParam); + int32_t ret = ipcClientProxy_->SendRequest(START_SERVICE_DISCOVERING, req, rsp); + if (ret != DM_OK) { + LOGE("StartServiceDiscovery error: Send Request failed ret: %{public}d", ret); + return ERR_DM_IPC_SEND_REQUEST_FAILED; + } + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("StartServiceDiscovery error: Failed with ret %{public}d", ret); + return ret; + } + + LOGI("Completed"); + return DM_OK; +} + +int32_t DeviceManagerImpl::StopServiceDiscovery(const std::string &pkgName, int32_t discoveryServiceId) +{ + LOGI("StopServiceDiscovery Start"); + if (pkgName.empty() || discoveryServiceId == 0) { + LOGE("error: Invalid para"); + return ERR_DM_INPUT_PARA_INVALID; + } + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + req->SetInt32Param(discoveryServiceId); + int32_t ret = ipcClientProxy_->SendRequest(STOP_SERVICE_DISCOVERING, req, rsp); + if (ret != DM_OK) { + LOGE("StopServiceDiscovery error: Send Request failed ret: %{public}d", ret); + return ERR_DM_IPC_SEND_REQUEST_FAILED; + } + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("StopServiceDiscovery error: Failed with ret %{public}d :", ret); + return ret; + } + DeviceManagerNotify::GetInstance().UnRegisterServiceDiscoveryCallback(discoveryServiceId); + LOGI("StopServiceDiscovery completed"); + return DM_OK; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp index a30e5493b..3d61897d8 100644 --- a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp +++ b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp @@ -63,6 +63,7 @@ #include "ipc_set_local_device_name_req.h" #include "ipc_set_remote_device_name_req.h" #include "ipc_set_useroperation_req.h" +#include "ipc_start_service_discovery_req.h" #include "ipc_sync_callback_req.h" #include "ipc_permission_req.h" #include "ipc_publish_req.h" @@ -2217,5 +2218,89 @@ ON_IPC_READ_RESPONSE(CHECK_SINK_SAME_ACCOUNT, MessageParcel &reply, std::shared_ { return ReadResponse(CHECK_SINK_SAME_ACCOUNT, reply, pBaseRsp); } + +ON_IPC_SET_REQUEST(START_SERVICE_DISCOVERING, std::shared_ptr pBaseReq, MessageParcel &data) +{ + if (pBaseReq == nullptr) { + LOGE("pBaseReq is null"); + return ERR_DM_FAILED; + } + std::shared_ptr pReq = + std::static_pointer_cast(pBaseReq); + if (!data.WriteString(pReq->GetPkgName())) { + LOGE("write pkgName failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + DiscoveryServiceParam discParam = pReq->GetDiscParam(); + if (!IpcModelCodec::EncodeSrvDiscParam(discParam, data)) { + LOGE("write GetServiceId failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(START_SERVICE_DISCOVERING, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + if (pBaseRsp == nullptr) { + LOGE("pBaseRsp is null"); + return ERR_DM_FAILED; + } + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + pRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; +} + +ON_IPC_SET_REQUEST(STOP_SERVICE_DISCOVERING, std::shared_ptr pBaseReq, MessageParcel &data) +{ + if (pBaseReq == nullptr) { + LOGE("pBaseReq is null"); + return ERR_DM_FAILED; + } + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + if (!data.WriteString(pReq->GetPkgName())) { + LOGE("write pkgName failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + int32_t discServiceId = pReq->GetInt32Param(); + if (!data.WriteInt32(discServiceId)) { + LOGE("write discServiceId failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(STOP_SERVICE_DISCOVERING, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + if (pBaseRsp == nullptr) { + LOGE("pBaseRspis null"); + return ERR_DM_FAILED; + } + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + pRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; +} + +ON_IPC_CMD(NOTIFY_SERVICE_FOUND, MessageParcel &data, MessageParcel &reply) +{ + int32_t discoveryServiceId = data.ReadInt32(); + DiscoveryServiceInfo discServiceInfo; + if (!IpcModelCodec::DecodeSrvDiscServiceInfo(data, discServiceInfo)) { + LOGE("DecodeSrvDiscServiceInfo failed"); + return ERR_DM_FAILED; + } + DeviceManagerNotify::GetInstance().OnServiceFound(discoveryServiceId, discServiceInfo); + + reply.WriteInt32(DM_OK); + return DM_OK; +} + +ON_IPC_CMD(NOTIFY_SERVICE_DISCOVERY_RESULT, MessageParcel &data, MessageParcel &reply) +{ + int32_t reason = data.ReadInt32(); + int32_t discoveryServiceId = data.ReadInt32(); + DeviceManagerNotify::GetInstance().OnServiceDiscoveryResult(discoveryServiceId, reason); + reply.WriteInt32(DM_OK); + return DM_OK; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp b/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp index 907efd298..a6c577909 100644 --- a/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp +++ b/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp @@ -1450,5 +1450,62 @@ void DeviceManagerNotify::UnRegisterPinHolderCallback(const std::string &pkgName std::lock_guard autoLock(lock_); pinHolderCallback_.erase(pkgName); } + +void DeviceManagerNotify::RegisterServiceDiscoveryCallback(int32_t discoveryServiceId, + std::shared_ptr callback) +{ + if (callback == nullptr) { + LOGE("Invalid parameter, pkgName is empty."); + return; + } + std::lock_guard autolock(lock_); + serviceDiscoveryCallbacks_[discoveryServiceId] = callback; +} + +void DeviceManagerNotify::UnRegisterServiceDiscoveryCallback(int32_t discoveryServiceId) +{ + std::lock_guard autolock(lock_); + if (serviceDiscoveryCallbacks_.count(discoveryServiceId) == 0) { + LOGE("error,Service Discovery not register."); + return; + } + serviceDiscoveryCallbacks_.erase(discoveryServiceId); +} + +void DeviceManagerNotify::OnServiceFound(int32_t discoveryServiceId, const DiscoveryServiceInfo &service) +{ + std::shared_ptr tempCbk; + std::lock_guard autolock(lock_); + auto iter = serviceDiscoveryCallbacks_.find(discoveryServiceId); + if (iter == serviceDiscoveryCallbacks_.end()) { + LOGE("error, callback not register for discoveryServiceId %{public}d", discoveryServiceId); + return; + } + tempCbk = iter->second; + if (tempCbk == nullptr) { + LOGE("OnServiceFound error, registered service discovery callback is nullptr."); + return; + } + LOGD("Complete with serviceInfo"); + tempCbk->OnServiceFound(service); +} + +void DeviceManagerNotify::OnServiceDiscoveryResult(int32_t discoveryServiceId, int32_t resReason) +{ + std::shared_ptr tempCbk; + std::lock_guard autolock(lock_); + auto iter = serviceDiscoveryCallbacks_.find(discoveryServiceId); + if (iter == serviceDiscoveryCallbacks_.end()) { + LOGE("error, callback not register for discoveryServiceId %{public}d", discoveryServiceId); + return; + } + tempCbk = iter->second; + if (tempCbk == nullptr) { + LOGE("OnServiceDiscoveryResult error, registered service discovery callback is nullptr."); + return; + } + LOGD("Complete with result"); + tempCbk->OnServiceDiscoveryResult(resReason); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/include/device_manager_service.h b/services/service/include/device_manager_service.h index 709e7301f..538a17ef6 100644 --- a/services/service/include/device_manager_service.h +++ b/services/service/include/device_manager_service.h @@ -275,6 +275,8 @@ public: bool CheckSinkAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee); bool CheckSrcIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee); bool CheckSinkIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee); + int32_t StartServiceDiscovery(const std::string &pkgName, const DiscoveryServiceParam &discParam); + int32_t StopServiceDiscovery(const std::string &pkgName, int32_t discServiceId); private: bool IsDMServiceImplReady(); bool IsDMImplSoLoaded(); diff --git a/services/service/include/device_manager_service_listener.h b/services/service/include/device_manager_service_listener.h index 216835016..a34c9cb2f 100644 --- a/services/service/include/device_manager_service_listener.h +++ b/services/service/include/device_manager_service_listener.h @@ -90,6 +90,9 @@ public: void OnSetRemoteDeviceNameResult(const ProcessInfo &processInfo, const std::string &deviceId, const std::string &deviceName, int32_t code) override; void SetExistPkgName(const std::set &pkgNameSet) override; + void OnServiceFound(const ProcessInfo &processInfo, int32_t discServiceId, + const DiscoveryServiceInfo &discServiceInfo) override; + void OnServiceDiscoveryResult(const ProcessInfo &processInfo, int32_t discServiceId, int32_t reason) override; std::string GetLocalDisplayDeviceName() override; int32_t OpenAuthSessionWithPara(const std::string &deviceId, int32_t actionId, bool isEnable160m) override; diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp index 707429bb2..9dd8aa43e 100644 --- a/services/service/src/device_manager_service.cpp +++ b/services/service/src/device_manager_service.cpp @@ -4363,5 +4363,44 @@ void DeviceManagerService::HandleAccountLogoutEventCallback(const std::string &c MultipleUserConnector::GetCurrentDMAccountInfo()); } #endif + +int32_t DeviceManagerService::StartServiceDiscovery(const std::string &pkgName, const DiscoveryServiceParam &discParam) +{ + LOGI("In"); + if (!PermissionManager::GetInstance().CheckPermission()) { + LOGE("The caller does not have permission to call"); + return ERR_DM_NO_PERMISSION; + } + if (pkgName.empty() || discParam.serviceType.empty() || discParam.discoveryServiceId == 0) { + LOGE("error: Invalid para"); + return ERR_DM_INPUT_PARA_INVALID; + } + if (!IsDMServiceAdapterResidentLoad()) { + LOGE("failed, adapter instance not init or init failed."); + return ERR_DM_UNSUPPORTED_METHOD; + } + ProcessInfo processInfo; + processInfo.pkgName = pkgName; + MultipleUserConnector::GetCallerUserId(processInfo.userId); + return dmServiceImplExtResident_->StartServiceDiscovery(processInfo, discParam); +} + +int32_t DeviceManagerService::StopServiceDiscovery(const std::string &pkgName, int32_t discServiceId) +{ + LOGI("In"); + if (!PermissionManager::GetInstance().CheckPermission()) { + LOGE("The caller does not have permission to call"); + return ERR_DM_NO_PERMISSION; + } + if (pkgName.empty() || discServiceId == 0) { + LOGE("error: Invalid para"); + return ERR_DM_INPUT_PARA_INVALID; + } + if (!IsDMServiceAdapterResidentLoad()) { + LOGE("failed, adapter instance not init or init failed."); + return ERR_DM_UNSUPPORTED_METHOD; + } + return dmServiceImplExtResident_->StopServiceDiscovery(discServiceId); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/src/device_manager_service_listener.cpp b/services/service/src/device_manager_service_listener.cpp index bc47a6a81..9c0f61258 100644 --- a/services/service/src/device_manager_service_listener.cpp +++ b/services/service/src/device_manager_service_listener.cpp @@ -39,6 +39,8 @@ #include "ipc_notify_get_device_profile_info_list_req.h" #include "ipc_notify_pin_holder_event_req.h" #include "ipc_notify_publish_result_req.h" +#include "ipc_notify_service_discover_result_req.h" +#include "ipc_notify_service_found_req.h" #include "ipc_notify_set_local_device_name_req.h" #include "ipc_notify_set_remote_device_name_req.h" #include "ipc_server_stub.h" @@ -1052,5 +1054,27 @@ int32_t DeviceManagerServiceListener::OpenAuthSessionWithPara(const std::string return ERR_DM_UNSUPPORTED_METHOD; #endif } + +void DeviceManagerServiceListener::OnServiceFound(const ProcessInfo &processInfo, int32_t discServiceId, + const DiscoveryServiceInfo &discServiceInfo) +{ + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + pReq->SetProcessInfo(processInfo); + pReq->SetDiscServiceId(discServiceId); + pReq->SetDiscServiceInfo(discServiceInfo); + ipcServerListener_.SendRequest(NOTIFY_SERVICE_FOUND, pReq, pRsp); +} + +void DeviceManagerServiceListener::OnServiceDiscoveryResult(const ProcessInfo &processInfo, int32_t discServiceId, + int32_t reason) +{ + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + pReq->SetProcessInfo(processInfo); + pReq->SetDiscServiceId(discServiceId); + pReq->SetResult(reason); + ipcServerListener_.SendRequest(NOTIFY_SERVICE_DISCOVERY_RESULT, pReq, pRsp); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/service/src/ipc/standard/ipc_cmd_parser.cpp b/services/service/src/ipc/standard/ipc_cmd_parser.cpp index e8f908bca..dc2f1be90 100644 --- a/services/service/src/ipc/standard/ipc_cmd_parser.cpp +++ b/services/service/src/ipc/standard/ipc_cmd_parser.cpp @@ -40,6 +40,8 @@ #include "ipc_notify_get_device_profile_info_list_req.h" #include "ipc_notify_publish_result_req.h" #include "ipc_notify_pin_holder_event_req.h" +#include "ipc_notify_service_discover_result_req.h" +#include "ipc_notify_service_found_req.h" #include "ipc_notify_set_local_device_name_req.h" #include "ipc_notify_set_remote_device_name_req.h" #include "ipc_server_client_proxy.h" @@ -2007,5 +2009,83 @@ ON_IPC_CMD(CHECK_SINK_SAME_ACCOUNT, MessageParcel &data, MessageParcel &reply) { return OnIpcCmd(CHECK_SINK_SAME_ACCOUNT, data, reply); } + +ON_IPC_CMD(START_SERVICE_DISCOVERING, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + DiscoveryServiceParam discParam; + if (!IpcModelCodec::DecodeSrvDiscParam(data, discParam)) { + LOGE("DecodeSrvDiscParam failed"); + return ERR_DM_FAILED; + } + int32_t result = DeviceManagerService::GetInstance().StartServiceDiscovery(pkgName, discParam); + + if (!reply.WriteInt32(result)) { + LOGE("Write result failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_CMD(STOP_SERVICE_DISCOVERING, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + int32_t discServiceId = data.ReadInt32(); + int32_t result = DeviceManagerService::GetInstance().StopServiceDiscovery(pkgName, discServiceId); + if (!reply.WriteInt32(result)) { + LOGE("write result failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_SET_REQUEST(NOTIFY_SERVICE_FOUND, std::shared_ptr pBaseReq, MessageParcel &data) +{ + CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED); + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + int32_t discServiceId = pReq->GetDiscServiceId(); + DiscoveryServiceInfo discServiceInfo = pReq->GetDiscServiceInfo(); + if (!data.WriteInt32(discServiceId)) { + LOGE("write errCode failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + if (!IpcModelCodec::EncodeSrvDiscServiceInfo(discServiceInfo, data)) { + LOGE("write discServiceInfo failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(NOTIFY_SERVICE_FOUND, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED); + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; +} + +ON_IPC_SET_REQUEST(NOTIFY_SERVICE_DISCOVERY_RESULT, std::shared_ptr pBaseReq, MessageParcel &data) +{ + CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED); + std::shared_ptr pReq = + std::static_pointer_cast(pBaseReq); + int32_t discServiceId = pReq->GetDiscServiceId(); + int32_t result = pReq->GetResult(); + if (!data.WriteInt32(result)) { + LOGE("write result failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + if (!data.WriteInt32(discServiceId)) { + LOGE("write discServiceId failed"); + return ERR_DM_IPC_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(NOTIFY_SERVICE_DISCOVERY_RESULT, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED); + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; +} } // namespace DistributedHardware } // namespace OHOS -- Gitee From 883f5aadd1d312b4776cffcdaa97fc5d2ae2d57a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E9=9B=B7?= Date: Tue, 26 Aug 2025 17:42:08 +0800 Subject: [PATCH 2/2] add service discovery MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张雷 --- common/src/ipc/standard/ipc_model_codec.cpp | 6 +++--- .../inner_kits/native_cpp/src/device_manager_impl.cpp | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/common/src/ipc/standard/ipc_model_codec.cpp b/common/src/ipc/standard/ipc_model_codec.cpp index 46894a9ce..aa2804a2d 100644 --- a/common/src/ipc/standard/ipc_model_codec.cpp +++ b/common/src/ipc/standard/ipc_model_codec.cpp @@ -513,13 +513,13 @@ bool IpcModelCodec::DecodeSrvDiscParam(MessageParcel &parcel, DiscoveryServicePa READ_HELPER_RET(parcel, Int32, param.discoveryServiceId, false); int32_t freq = 0; READ_HELPER_RET(parcel, Int32, freq, false); - param.freq = freq; + param.freq = static_cast(freq); int32_t medium = 0; READ_HELPER_RET(parcel, Int32, medium, false); - param.medium = medium; + param.medium = static_cast(medium); int32_t mode = 0; READ_HELPER_RET(parcel, Int32, mode, false); - param.mode = mode; + param.mode = static_cast(mode); return true; } diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp index 8d38f04a7..22bcc9a74 100644 --- a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp +++ b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp @@ -3001,7 +3001,7 @@ bool DeviceManagerImpl::CheckAclByIpcCode(const DmAccessCaller &caller, const Dm } int32_t DeviceManagerImpl::StartServiceDiscovery(const std::string &pkgName, const DiscoveryServiceParam &discParam, - std::shared_ptr callback) + std::shared_ptr callback) { LOGI("StartServiceDiscovery start."); if (pkgName.empty() || callback == nullptr || discParam.serviceType.empty() || discParam.discoveryServiceId == 0) { -- Gitee