diff --git a/common/include/device_manager_ipc_interface_code.h b/common/include/device_manager_ipc_interface_code.h
index 418684851ef4e18d1ffd2b47eeff7818525a521e..8a8a4c9a929697d7662b2768f071cb54d947bdf7 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 0000000000000000000000000000000000000000..c7d70355f224e87d017c952b79db2220ed7b47ed
--- /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 0000000000000000000000000000000000000000..527ad1aec675dae29238b5f04c881817d8382e8a
--- /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 0000000000000000000000000000000000000000..3ebb8931063f70257544f2533f13f23c7a45d7d8
--- /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 e06af83a94477da5100f2039832ccb033d070f7d..37f9159fcc536f185bbc48f02725ad0dff6e5a32 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<std::string> &vec, MessageParcel &parcel);
     static bool DecodeStringVector(MessageParcel &parcel, std::vector<std::string> &vec);
+    static bool EncodeSrvDiscParam(const DiscoveryServiceParam &param, MessageParcel &parcel);
+    static bool DecodeSrvDiscParam(MessageParcel &parcel, DiscoveryServiceParam &param);
+    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 2e336c5fd53edbeca9293ec8f9539a453c9c91c8..aa2804a2dca6615e348211d1c89ba2a564cce361 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<std::s
     }
     return true;
 }
+
+bool IpcModelCodec::EncodeSrvDiscParam(const DiscoveryServiceParam &param, MessageParcel &parcel)
+{
+    bool bRet = true;
+    bRet = (bRet && parcel.WriteString(param.serviceName));
+    bRet = (bRet && parcel.WriteString(param.serviceType));
+    bRet = (bRet && parcel.WriteInt32(param.discoveryServiceId));
+    bRet = (bRet && parcel.WriteInt32(param.freq));
+    bRet = (bRet && parcel.WriteInt32(param.medium));
+    bRet = (bRet && parcel.WriteInt32(param.mode));
+    return bRet;
+}
+
+bool IpcModelCodec::DecodeSrvDiscParam(MessageParcel &parcel, DiscoveryServiceParam &param)
+{
+    READ_HELPER_RET(parcel, String, param.serviceName, false);
+    READ_HELPER_RET(parcel, String, param.serviceType, false);
+    READ_HELPER_RET(parcel, Int32, param.discoveryServiceId, false);
+    int32_t freq = 0;
+    READ_HELPER_RET(parcel, Int32, freq, false);
+    param.freq = static_cast<DmExchangeFreq>(freq);
+    int32_t medium = 0;
+    READ_HELPER_RET(parcel, Int32, medium, false);
+    param.medium = static_cast<DMSrvMediumType>(medium);
+    int32_t mode = 0;
+    READ_HELPER_RET(parcel, Int32, mode, false);
+    param.mode = static_cast<DMSrvDiscoveryMode>(mode);
+    return true;
+}
+
+bool IpcModelCodec::EncodeSrvDiscServiceInfo(const DiscoveryServiceInfo &serviceInfo, MessageParcel &parcel)
+{
+    bool bRet = true;
+    bRet = (bRet && parcel.WriteString(serviceInfo.pkgName));
+    bRet = (bRet && parcel.WriteInt64(serviceInfo.serviceInfo.serviceId));
+    bRet = (bRet && parcel.WriteString(serviceInfo.serviceInfo.serviceType));
+    bRet = (bRet && parcel.WriteString(serviceInfo.serviceInfo.serviceName));
+    bRet = (bRet && parcel.WriteString(serviceInfo.serviceInfo.serviceDisplayName));
+    return bRet;
+}
+
+bool IpcModelCodec::DecodeSrvDiscServiceInfo(MessageParcel &parcel, DiscoveryServiceInfo &serviceInfo)
+{
+    READ_HELPER_RET(parcel, String, serviceInfo.pkgName, false);
+    READ_HELPER_RET(parcel, Int64, serviceInfo.serviceInfo.serviceId, false);
+    READ_HELPER_RET(parcel, String, serviceInfo.serviceInfo.serviceType, false);
+    READ_HELPER_RET(parcel, String, serviceInfo.serviceInfo.serviceName, false);
+    READ_HELPER_RET(parcel, String, serviceInfo.serviceInfo.serviceDisplayName, false);
+    return true;
+}
 //LCOV_EXCL_STOP
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/interfaces/inner_kits/native_cpp/include/device_manager.h b/interfaces/inner_kits/native_cpp/include/device_manager.h
index da0db3936076c2cece54906b35ba28a0a818fe77..bea0de4c4e408edbef2850e998fcdf3636007a58 100644
--- a/interfaces/inner_kits/native_cpp/include/device_manager.h
+++ b/interfaces/inner_kits/native_cpp/include/device_manager.h
@@ -653,6 +653,10 @@ public:
     virtual bool CheckSinkAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee) = 0;
     virtual bool CheckSrcIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee) = 0;
     virtual bool CheckSinkIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee) = 0;
+
+    virtual int32_t StartServiceDiscovery(const std::string &pkgName, const DiscoveryServiceParam &discParam,
+        std::shared_ptr<ServiceDiscoveryCallback> 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 e403436809b85a6d2069e2e947ba7a8559dc6e39..5ed96ac73c1d765f31803edf3c4a97c30f354078 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 863626aef135a41ee472de50ce98df36a35c596b..ce3ae6484de6acd71efa639277ecd46e11b2e509 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<ServiceDiscoveryCallback> 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 b7704d94df412168e0e12abc80305242450246e6..c7aecdbc39c9c3bf6f4814aaca626869c07577cf 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 <string>
 
 #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 cb4bb85bc260c8e3638704898fe98dfe3c505d4a..9de1bff15c121f39278c19d2cdefe86e842cda69 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 4f738fc7cac35b6dbc1356a306d56fc22437940e..d4683c745ab9f8421969bb5297783ad48a59fed3 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 336c5b631bd1e523058e86a725f72225b2997688..0a65c48abd5d7165b2937cab1d766aed389a51b8 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<std::string> &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 39a229cc8fa23bb023351d03ab785b694637c7ab..5473dcfff043a7a719eb0762b895a344a1c19ab0 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<SetRemoteDeviceNameCallback> 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<ServiceDiscoveryCallback> callback);
+    void UnRegisterServiceDiscoveryCallback(int32_t discoveryServiceId);
 
 public:
     static void DeviceInfoOnline(const DmDeviceInfo &deviceInfo, std::shared_ptr<DeviceStateCallback> tempCbk);
@@ -139,6 +142,8 @@ public:
         std::string content);
     std::shared_ptr<DiscoveryCallback> GetDiscoveryCallback(const std::string &pkgName, uint16_t subscribeId);
     void GetCallBack(std::map<DmCommonNotifyEvent, std::set<std::string>> &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<std::string, std::shared_ptr<SetLocalDeviceNameCallback>> setLocalDeviceNameCallback_;
     std::map<std::string,
         std::map<std::string, std::shared_ptr<SetRemoteDeviceNameCallback>>> setRemoteDeviceNameCallback_;
+    std::map<int32_t, std::shared_ptr<ServiceDiscoveryCallback>> 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 d07c6ff6860971db662beb87cfc9f1e12e74e489..22bcc9a749c4995ecdf57a7224b4a6c9d729cdf7 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<ServiceDiscoveryCallback> 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<IpcStartServiceDiscoveryReq> req = std::make_shared<IpcStartServiceDiscoveryReq>();
+    std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
+    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<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
+    std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
+    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 a30e5493b2b6ea81ff6113a7f7f820ed819f662a..3d61897d8e0e72a85e7c12f3084bee6da41ddd29 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<IpcReq> pBaseReq, MessageParcel &data)
+{
+    if (pBaseReq == nullptr) {
+        LOGE("pBaseReq is null");
+        return ERR_DM_FAILED;
+    }
+    std::shared_ptr<IpcStartServiceDiscoveryReq> pReq =
+        std::static_pointer_cast<IpcStartServiceDiscoveryReq>(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<IpcRsp> pBaseRsp)
+{
+    if (pBaseRsp == nullptr) {
+        LOGE("pBaseRsp is null");
+        return ERR_DM_FAILED;
+    }
+    std::shared_ptr<IpcRsp> pRsp = std::static_pointer_cast<IpcRsp>(pBaseRsp);
+    pRsp->SetErrCode(reply.ReadInt32());
+    return DM_OK;
+}
+
+ON_IPC_SET_REQUEST(STOP_SERVICE_DISCOVERING, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
+{
+    if (pBaseReq == nullptr) {
+        LOGE("pBaseReq is null");
+        return ERR_DM_FAILED;
+    }
+    std::shared_ptr<IpcCommonParamReq> pReq = std::static_pointer_cast<IpcCommonParamReq>(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<IpcRsp> pBaseRsp)
+{
+    if (pBaseRsp == nullptr) {
+        LOGE("pBaseRspis null");
+        return ERR_DM_FAILED;
+    }
+    std::shared_ptr<IpcRsp> pRsp = std::static_pointer_cast<IpcRsp>(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 907efd2984775652335f81fb84458d28406fce53..a6c577909cdd4bf39f6ab7e14fb1b3f24858f175 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<std::mutex> autoLock(lock_);
     pinHolderCallback_.erase(pkgName);
 }
+
+void DeviceManagerNotify::RegisterServiceDiscoveryCallback(int32_t discoveryServiceId,
+    std::shared_ptr<ServiceDiscoveryCallback> callback)
+{
+    if (callback == nullptr) {
+        LOGE("Invalid parameter, pkgName is empty.");
+        return;
+    }
+    std::lock_guard<std::mutex> autolock(lock_);
+    serviceDiscoveryCallbacks_[discoveryServiceId] = callback;
+}
+
+void DeviceManagerNotify::UnRegisterServiceDiscoveryCallback(int32_t discoveryServiceId)
+{
+    std::lock_guard<std::mutex> 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<ServiceDiscoveryCallback> tempCbk;
+    std::lock_guard<std::mutex> 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<ServiceDiscoveryCallback> tempCbk;
+    std::lock_guard<std::mutex> 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 709e7301f82ebded3a8b48bc725e3199ce8e06b4..538a17ef6124996c75e445c695a91a9d202a9ae4 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 216835016a96327f3e1961ba1e80cab2facb1e72..a34c9cb2feaebf22d9c7588a5ec8986311b09209 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<std::string> &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 707429bb2109385a93a67e18411d1d82fb86d426..9dd8aa43e243d6bbe5a443f2b3e381449c7f978e 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 bc47a6a81fc2c3d3908b7aa811a1d160a185c12a..9c0f61258bc5f8790bc621fcfe85b061766df23e 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<IpcNotifyServiceFoundReq> pReq = std::make_shared<IpcNotifyServiceFoundReq>();
+    std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
+    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<IpcNotifyServiceDiscoverResultReq> pReq = std::make_shared<IpcNotifyServiceDiscoverResultReq>();
+    std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
+    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 e8f908bca808e91b7bef061b7d87ed46e4c9e3c3..dc2f1be9045a639601037e2addffd04bb8bbf690 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<IpcReq> pBaseReq, MessageParcel &data)
+{
+    CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
+    std::shared_ptr<IpcNotifyServiceFoundReq> pReq = std::static_pointer_cast<IpcNotifyServiceFoundReq>(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<IpcRsp> 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<IpcReq> pBaseReq, MessageParcel &data)
+{
+    CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
+    std::shared_ptr<IpcNotifyServiceDiscoverResultReq> pReq =
+        std::static_pointer_cast<IpcNotifyServiceDiscoverResultReq>(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<IpcRsp> pBaseRsp)
+{
+    CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
+    pBaseRsp->SetErrCode(reply.ReadInt32());
+    return DM_OK;
+}
 } // namespace DistributedHardware
 } // namespace OHOS