回退 'Pull Request !7135 : 【OpenHarmony5.0】删除发现模块冗余代码'

CODEOWNERS

@@ -45,9 +45,11 @@ tests/core/connection/wifi_direct_cpp/        wuchunbo1@huawei.com
 [Disc]
 adapter/common/range/   fanjingya1@huawei.com
 core/discovery/         fanjingya1@huawei.com
+sdk/discovery/          fanjingya1@huawei.com
 tests/adapter/fuzztest/softbusadapterrange_fuzzer/      fanjingya1@huawei.com
 tests/adapter/unittest/softbus_adapter_range_test.cpp   fanjingya1@huawei.com
 tests/core/discovery/   fanjingya1@huawei.com
+tests/sdk/discovery/    fanjingya1@huawei.com
 
 [DiscInterface]
 interfaces/kits/discovery/  fanjingya1@huawei.com

bundle.json

@@ -114,6 +114,7 @@
               "bus_center/softbus_bus_center.h",
               "common/softbus_common.h",
               "common/softbus_error_code.h",
+              "discovery/discovery_service.h",
               "transport/session.h"
             ],
             "header_base": "//foundation/communication/dsoftbus/interfaces/kits"

core/bus_center/ipc/standard/include/bus_center_client_proxy_standard.h

@@ -25,6 +25,11 @@ public:
         : IRemoteProxy<ISoftBusClient>(impl) {}
     virtual ~BusCenterClientProxy() = default;
 
+    void OnDeviceFound(const DeviceInfo *device) override;
+    void OnDiscoverFailed(int subscribeId, int failReason) override;
+    void OnDiscoverySuccess(int subscribeId) override;
+    void OnPublishSuccess(int publishId) override;
+    void OnPublishFail(int publishId, int reason) override;
     int32_t OnChannelOpened(const char *sessionName, const ChannelInfo *channel) override;
     int32_t OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode) override;
     int32_t OnChannelLinkDown(const char *NetworkId, int32_t routeType) override;

core/bus_center/ipc/standard/src/bus_center_client_proxy_standard.cpp

@@ -53,6 +53,26 @@ int32_t BusCenterClientProxy::OnChannelQosEvent(int32_t channelId, int32_t chann
     return SOFTBUS_OK;
 }
 
+void BusCenterClientProxy::OnDeviceFound(const DeviceInfo *deviceInfo)
+{
+}
+
+void BusCenterClientProxy::OnDiscoverFailed(int subscribeId, int failReason)
+{
+}
+
+void BusCenterClientProxy::OnDiscoverySuccess(int subscribeId)
+{
+}
+
+void BusCenterClientProxy::OnPublishSuccess(int publishId)
+{
+}
+
+void BusCenterClientProxy::OnPublishFail(int publishId, int reason)
+{
+}
+
 int32_t BusCenterClientProxy::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
 {
     sptr<IRemoteObject> remote = Remote();

core/bus_center/lnn/disc_mgr/src/lnn_discovery_manager.c

@@ -17,6 +17,7 @@
 
 #include <string.h>
 
+#include "discovery_service.h"
 #include "lnn_coap_discovery_impl.h"
 #include "lnn_log.h"
 #include "lnn_net_builder.h"

core/common/dfx/hisysevent_adapter/softbus_hisysevt_transreporter.c

@@ -82,6 +82,10 @@ typedef struct {
     char *apiName;
 }ApiNameIdMap;
 static ApiNameIdMap g_apiNameIdMapTbl[] = {
+    {SERVER_START_DISCOVERY, "StartDiscovery"},
+    {SERVER_STOP_DISCOVERY, "StopDiscovery"},
+    {SERVER_PUBLISH_SERVICE, "PublishService"},
+    {SERVER_UNPUBLISH_SERVICE, "UnPublishService"},
     {MANAGE_REGISTER_SERVICE, "SoftbusRegisterService"},
     {SERVER_CREATE_SESSION_SERVER, "CreateSessionServer"},
     {SERVER_REMOVE_SESSION_SERVER, "RemoveSessionServer"},

core/common/include/softbus_server_ipc_interface_code.h

@@ -40,7 +40,10 @@ struct CommonScvId {
 enum SoftBusFuncId {
     MANAGE_REGISTER_SERVICE = 0,
 
-    SERVER_CREATE_SESSION_SERVER = 128,
+    SERVER_PUBLISH_SERVICE = 128,
+    SERVER_UNPUBLISH_SERVICE,
+
+    SERVER_CREATE_SESSION_SERVER,
     SERVER_REMOVE_SESSION_SERVER,
     SERVER_OPEN_SESSION,
     SERVER_OPEN_AUTH_SESSION,
@@ -54,6 +57,9 @@ enum SoftBusFuncId {
     SERVER_STREAM_STATS,
     SERVER_GET_SOFTBUS_SPEC_OBJECT,
 
+    SERVER_START_DISCOVERY,
+    SERVER_STOP_DISCOVERY,
+
     SERVER_JOIN_LNN,
     SERVER_JOIN_METANODE,
     SERVER_LEAVE_LNN,
@@ -87,6 +93,12 @@ enum SoftBusFuncId {
     CLIENT_ON_CHANNEL_MSGRECEIVED,
     CLIENT_ON_CHANNEL_QOSEVENT,
 
+    CLIENT_DISCOVERY_SUCC,
+    CLIENT_DISCOVERY_FAIL,
+    CLIENT_DISCOVERY_DEVICE_FOUND,
+    CLIENT_PUBLISH_SUCC,
+    CLIENT_PUBLISH_FAIL,
+
     CLIENT_ON_JOIN_RESULT,
     CLIENT_ON_JOIN_METANODE_RESULT,
     CLIENT_ON_LEAVE_RESULT,

core/discovery/ble/softbus_ble/include/disc_ble_utils.h

@@ -19,7 +19,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include "softbus_common.h"
+#include "discovery_service.h"
 
 #ifdef __cplusplus
 #if __cplusplus

core/discovery/ble/softbus_ble/src/disc_ble.c

@@ -26,6 +26,7 @@
 #include "disc_event.h"
 #include "disc_log.h"
 #include "disc_manager.h"
+#include "discovery_service.h"
 #include "lnn_device_info.h"
 #include "lnn_ohos_account.h"
 #include "message_handler.h"

core/discovery/disc.gni

@@ -26,6 +26,8 @@ disc_server_src += [
   "$dsoftbus_root_path/core/discovery/manager/src/softbus_disc_server.c",
 ]
 disc_server_inc += [
+  "$dsoftbus_root_path/core/discovery/ipc/include",
+  "$dsoftbus_root_path/core/discovery/ipc/include",
   "$dsoftbus_root_path/core/discovery/manager/include",
   "$dsoftbus_root_path/core/discovery/interface",
   "$dsoftbus_root_path/core/common/dfx/hisysevent_adapter/include",
@@ -35,11 +37,22 @@ if (!dsoftbus_feature_ex_kits) {
 }
 if (defined(ohos_lite)) {
   if (ohos_kernel_type == "liteos_m") {
+    disc_server_src +=
+        [ "$dsoftbus_root_path/core/discovery/ipc/mini/disc_client_proxy.c" ]
+    disc_server_inc += [ "$dsoftbus_root_path/sdk/discovery/manager/include" ]
   } else {
+    disc_server_src +=
+        [ "$dsoftbus_root_path/core/discovery/ipc/small/disc_client_proxy.c" ]
     disc_server_deps += [
       "//foundation/communication/ipc/interfaces/innerkits/c/ipc:ipc_single",
     ]
   }
 } else {
+  disc_server_src += [
+    "$dsoftbus_root_path/core/discovery/ipc/$os_type/src/disc_client_proxy.cpp",
+    "$dsoftbus_root_path/core/discovery/ipc/$os_type/src/disc_client_proxy_standard.cpp",
+  ]
+  disc_server_inc +=
+      [ "$dsoftbus_root_path/core/discovery/ipc/$os_type/include" ]
   disc_server_external_deps += [ "c_utils:utils" ]
 }

core/discovery/interface/disc_interface.h

@@ -16,7 +16,7 @@
 #ifndef DISC_MANAGER_INTERFACE_H
 #define DISC_MANAGER_INTERFACE_H
 
-#include "softbus_common.h"
+#include "discovery_service.h"
 #include "stdint.h"
 
 #ifdef __cplusplus

core/discovery/interface/disc_serializer.h

@@ -16,6 +16,8 @@
 #ifndef DISC_SERIALIZER_H
 #define DISC_SERIALIZER_H
 
+#include "discovery_service.h"
+
 #ifdef __cplusplus
 #if __cplusplus
 extern "C" {

core/discovery/ipc/include/disc_client_proxy.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2021 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 DISC_CLIENT_PROXY_H
+
+#include <stdint.h>
+#include "softbus_common.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
+
+/**
+ * @brief Discovery device callback function.
+ * @see {@link ClientIpcOnDiscoverFailed} or {@link ClientIpcDiscoverySuccess}
+ * @param[in] pkgName Indicates the pointer to package name, which can contain a maximum of 64 bytes.
+ * @param[in] device Indicates a pointer to device information. For details, see {@link DeviceInfo}.
+ * @param[in] addtions Indicates a pointer to device additional information.
+ * @return <b>SOFTBUS_OK</b> Client IPC found on device.
+ */
+int32_t ClientIpcOnDeviceFound(const char *pkgName, const DeviceInfo *device, const InnerDeviceInfoAddtions *addtions);
+
+/**
+ * @brief The discovery failure callback notifies the local end of failure to discover other devices.
+ * This callback is only called when discovering other devices fails.
+ * @see {@link ClientIpcOnDeviceFound} or {@link ClientIpcDiscoverySuccess}
+ * @param[in] pkgName Indicates the pointer to package name, which can contain a maximum of 64 bytes.
+ * @param[in] subscribeId Indicates the service ID.
+ * @param[in] failReason Fail reason.
+ * @return <b>SOFTBUS_OK</b> Failed to find Client IPC found on device.
+ */
+int32_t ClientIpcOnDiscoverFailed(const char *pkgName, int subscribeId, int failReason);
+
+/**
+ * @brief The discovery success callback notifies the local end of successfully discovering other devices.
+ * This callback is only called when other devices are successfully discovered.
+ * @see {@link ClientIpcOnDeviceFound} or {@link ClientIpcOnDiscoverFailed}
+ * @param[in] pkgName Indicates the pointer to package name, which can contain a maximum of 64 bytes.
+ * @param[in] subscribeId Indicates the service ID.
+ * @return <b>SOFTBUS_OK</b> Client IPC found on device successfully.
+ */
+int32_t ClientIpcDiscoverySuccess(const char *pkgName, int subscribeId);
+
+/**
+ * @brief Publishing success callback, notifying the local end of publishing its own information successfully.
+ * This callback is only called when the ability to publish itself is successful.
+ * @see {@link ClientIpcOnPublishFail}
+ * @param[in] pkgName Indicates the pointer to package name, which can contain a maximum of 64 bytes.
+ * @param[in] publishId Publish ID.
+ * @return <b>SOFTBUS_OK</b> Client IPC published successfully.
+ */
+int32_t ClientIpcOnPublishSuccess(const char *pkgName, int publishId);
+
+/**
+ * @brief Publishing failure callback, notifying the local end of the failure to publish its own information.
+ * This callback is only called when the ability to publish itself fails.
+ * @see {@link ClientIpcOnPublishSuccess}
+ * @param[in] pkgName Indicates the pointer to package name, which can contain a maximum of 64 bytes.
+ * @param[in] publishId Publish ID.
+ * @param[in] reason Fail reason.
+ * @return <b>SOFTBUS_OK</b> Client IPC published failed.
+ */
+int32_t ClientIpcOnPublishFail(const char *pkgName, int publishId, int reason);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif // !DISC_CLIENT_PROXY_H

core/discovery/ipc/mini/disc_client_proxy.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2021 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 "disc_client_proxy.h"
+
+#include "client_disc_manager.h"
+#include "disc_log.h"
+#include "softbus_def.h"
+#include "softbus_errcode.h"
+
+int32_t ClientIpcOnDeviceFound(const char *pkgName, const DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
+{
+    (void)pkgName;
+    (void)additions;
+    DISC_LOGI(DISC_CONTROL, "ondevice found ipc server push.");
+    DiscClientOnDeviceFound(device);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnDiscoverFailed(const char *pkgName, int subscribeId, int failReason)
+{
+    (void)pkgName;
+    DISC_LOGI(DISC_CONTROL, "on discovery failed callback ipc server push.");
+    DiscClientOnDiscoverFailed(subscribeId, (DiscoveryFailReason)failReason);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcDiscoverySuccess(const char *pkgName, int subscribeId)
+{
+    (void)pkgName;
+    DISC_LOGI(DISC_CONTROL, "on discovery success callback ipc server push.");
+    DiscClientOnDiscoverySuccess(subscribeId);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnPublishSuccess(const char *pkgName, int publishId)
+{
+    (void)pkgName;
+    DISC_LOGI(DISC_CONTROL, "on publish success callback ipc server push.");
+    DiscClientOnPublishSuccess(publishId);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnPublishFail(const char *pkgName, int publishId, int reason)
+{
+    (void)pkgName;
+    DISC_LOGI(DISC_CONTROL, "on publish failed ipc server push.");
+    DiscClientOnPublishFail(publishId, (PublishFailReason)reason);
+    return SOFTBUS_OK;
+}

core/discovery/ipc/small/disc_client_proxy.c

@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2021 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 "disc_client_proxy.h"
+
+#include "disc_log.h"
+#include "ipc_skeleton.h"
+#include "serializer.h"
+#include "softbus_client_info_manager.h"
+#include "softbus_def.h"
+#include "softbus_errcode.h"
+#include "softbus_server_ipc_interface_code.h"
+
+static int32_t GetSvcIdentityByPkgName(const char *pkgName, SvcIdentity *svc)
+{
+    struct CommonScvId svcId = {0};
+    int ret = SERVER_GetIdentityByPkgName(pkgName, &svcId);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "ondevice found callback failed.");
+        return ret;
+    }
+    svc->handle = svcId.handle;
+    svc->token = svcId.token;
+    svc->cookie = svcId.cookie;
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnDeviceFound(const char *pkgName, const DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
+{
+    (void)additions;
+    DISC_LOGI(DISC_CONTROL, "ondevice found ipc server push.");
+    IpcIo io;
+    uint8_t tmpData[MAX_SOFT_BUS_IPC_LEN_EX] = {0};
+    IpcIoInit(&io, tmpData, MAX_SOFT_BUS_IPC_LEN_EX, 0);
+    bool ret = WriteRawData(&io, (const void*)device, sizeof(DeviceInfo));
+    if (!ret) {
+        DISC_LOGE(DISC_CONTROL, "Write DeviceInfo failed.");
+        return SOFTBUS_IPC_ERR;
+    }
+    SvcIdentity svc = {0};
+    int status = GetSvcIdentityByPkgName(pkgName, &svc);
+    if (status != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "ondevice found callback get svc failed.");
+        return status;
+    }
+    MessageOption option;
+    MessageOptionInit(&option);
+    option.flags = TF_OP_ASYNC;
+    int32_t ans = SendRequest(svc, CLIENT_DISCOVERY_DEVICE_FOUND, &io, NULL, option, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "ondevice found callback SendRequest failed.");
+        return ans;
+    }
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnDiscoverFailed(const char *pkgName, int subscribeId, int failReason)
+{
+    DISC_LOGI(DISC_CONTROL, "on discovery failed callback ipc server push.");
+    IpcIo io;
+    uint8_t tmpData[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIoInit(&io, tmpData, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteInt32(&io, subscribeId);
+    if (!ret) {
+        DISC_LOGE(DISC_CONTROL, "Write subscribeId failed.");
+        return SOFTBUS_IPC_ERR;
+    }
+    ret = WriteInt32(&io, failReason);
+    if (!ret) {
+        DISC_LOGE(DISC_CONTROL, "Write failReason failed.");
+        return SOFTBUS_IPC_ERR;
+    }
+    SvcIdentity svc = {0};
+    int status = GetSvcIdentityByPkgName(pkgName, &svc);
+    if (status != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on discovery failed callback get svc failed.");
+        return status;
+    }
+    MessageOption option;
+    MessageOptionInit(&option);
+    option.flags = TF_OP_ASYNC;
+    int32_t ans = SendRequest(svc, CLIENT_DISCOVERY_FAIL, &io, NULL, option, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on discovery failed callback SendRequest failed.");
+        return ans;
+    }
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcDiscoverySuccess(const char *pkgName, int subscribeId)
+{
+    DISC_LOGI(DISC_CONTROL, "on discovery success callback ipc server push.");
+    IpcIo io;
+    uint8_t tmpData[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIoInit(&io, tmpData, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteInt32(&io, subscribeId);
+    if (!ret) {
+        DISC_LOGE(DISC_CONTROL, "Write subscribeId failed.");
+        return SOFTBUS_IPC_ERR;
+    }
+    SvcIdentity svc = {0};
+    int status = GetSvcIdentityByPkgName(pkgName, &svc);
+    if (status != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on discovery success callback get svc failed.");
+        return status;
+    }
+    MessageOption option;
+    MessageOptionInit(&option);
+    option.flags = TF_OP_ASYNC;
+    int32_t ans = SendRequest(svc, CLIENT_DISCOVERY_SUCC, &io, NULL, option, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on discovery success callback SendRequest failed.");
+        return ans;
+    }
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnPublishSuccess(const char *pkgName, int publishId)
+{
+    DISC_LOGI(DISC_CONTROL, "on publish success callback ipc server push.");
+    IpcIo io;
+    uint8_t tmpData[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIoInit(&io, tmpData, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteInt32(&io, publishId);
+    if (!ret) {
+        DISC_LOGE(DISC_CONTROL, "Write publishId failed.");
+        return SOFTBUS_IPC_ERR;
+    }
+    SvcIdentity svc = {0};
+    int status = GetSvcIdentityByPkgName(pkgName, &svc);
+    if (status != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on publish success callback get svc failed.");
+        return status;
+    }
+    MessageOption option;
+    MessageOptionInit(&option);
+    option.flags = TF_OP_ASYNC;
+    int32_t ans = SendRequest(svc, CLIENT_PUBLISH_SUCC, &io, NULL, option, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on publish success callback SendRequest failed.");
+        return ans;
+    }
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnPublishFail(const char *pkgName, int publishId, int reason)
+{
+    DISC_LOGI(DISC_CONTROL, "on publish failed ipc server push.");
+    IpcIo io;
+    uint8_t tmpData[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIoInit(&io, tmpData, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteInt32(&io, publishId);
+    if (!ret) {
+        DISC_LOGE(DISC_CONTROL, "Write publishId failed.");
+        return SOFTBUS_IPC_ERR;
+    }
+    ret = WriteInt32(&io, reason);
+    if (!ret) {
+        DISC_LOGE(DISC_CONTROL, "Write reason failed.");
+        return SOFTBUS_IPC_ERR;
+    }
+    SvcIdentity svc = {0};
+    int status = GetSvcIdentityByPkgName(pkgName, &svc);
+    if (status != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on publish failed callback get svc failed.");
+        return status;
+    }
+    MessageOption option;
+    MessageOptionInit(&option);
+    option.flags = TF_OP_ASYNC;
+    int32_t ans = SendRequest(svc, CLIENT_PUBLISH_FAIL, &io, NULL, option, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "on publish failed callback SendRequest failed.");
+        return ans;
+    }
+    return SOFTBUS_OK;
+}

core/discovery/ipc/standard/include/disc_client_proxy_standard.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2021 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 INTERFACES_INNERKITS_DISC_CLIENT_PROXY_STANDARD_H_
+#define INTERFACES_INNERKITS_DISC_CLIENT_PROXY_STANDARD_H_
+
+#include "if_softbus_client.h"
+#include "softbus_error_code.h"
+
+namespace OHOS {
+class DiscClientProxy : public IRemoteProxy<ISoftBusClient> {
+public:
+    explicit DiscClientProxy(const sptr<IRemoteObject> &impl);
+    ~DiscClientProxy() override;
+
+    void OnDeviceFound(const DeviceInfo *device) override;
+    void OnDiscoverFailed(int subscribeId, int failReason) override;
+    void OnDiscoverySuccess(int subscribeId) override;
+    void OnPublishSuccess(int publishId) override;
+    void OnPublishFail(int publishId, int reason) override;
+
+private:
+    static inline BrokerDelegator<DiscClientProxy> delegator_;
+};
+}
+#endif

core/discovery/ipc/standard/src/disc_client_proxy.cpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2021 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 "disc_client_proxy.h"
+
+#include "disc_client_proxy_standard.h"
+#include "disc_log.h"
+#include "softbus_client_info_manager.h"
+#include "softbus_def.h"
+#include "softbus_error_code.h"
+
+using namespace OHOS;
+
+static sptr<DiscClientProxy> GetClientProxy(const char *pkgName)
+{
+    sptr<IRemoteObject> clientObject = SoftbusClientInfoManager::GetInstance().GetSoftbusClientProxy(pkgName);
+    sptr<DiscClientProxy> clientProxy = new (std::nothrow) DiscClientProxy(clientObject);
+    return clientProxy;
+}
+
+int32_t ClientIpcOnDeviceFound(const char *pkgName, const DeviceInfo *device,
+    const InnerDeviceInfoAddtions *additions)
+{
+    sptr<DiscClientProxy> clientProxy = GetClientProxy(pkgName);
+    DISC_CHECK_AND_RETURN_RET_LOGE(clientProxy != nullptr, SOFTBUS_DISCOVER_GET_CLIENT_PROXY_FAILED,
+        DISC_CONTROL, "client proxy is nullptr");
+
+    clientProxy->OnDeviceFound(device);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnDiscoverFailed(const char *pkgName, int subscribeId, int failReason)
+{
+    sptr<DiscClientProxy> clientProxy = GetClientProxy(pkgName);
+    DISC_CHECK_AND_RETURN_RET_LOGE(clientProxy != nullptr, SOFTBUS_DISCOVER_GET_CLIENT_PROXY_FAILED,
+        DISC_CONTROL, "client proxy is nullptr");
+
+    clientProxy->OnDiscoverFailed(subscribeId, failReason);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcDiscoverySuccess(const char *pkgName, int subscribeId)
+{
+    sptr<DiscClientProxy> clientProxy = GetClientProxy(pkgName);
+    DISC_CHECK_AND_RETURN_RET_LOGE(clientProxy != nullptr, SOFTBUS_DISCOVER_GET_CLIENT_PROXY_FAILED,
+        DISC_CONTROL, "client proxy is nullptr");
+
+    clientProxy->OnDiscoverySuccess(subscribeId);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnPublishSuccess(const char *pkgName, int publishId)
+{
+    sptr<DiscClientProxy> clientProxy = GetClientProxy(pkgName);
+    DISC_CHECK_AND_RETURN_RET_LOGE(clientProxy != nullptr, SOFTBUS_DISCOVER_GET_CLIENT_PROXY_FAILED,
+        DISC_CONTROL, "client proxy is nullptr");
+
+    clientProxy->OnPublishSuccess(publishId);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientIpcOnPublishFail(const char *pkgName, int publishId, int reason)
+{
+    sptr<DiscClientProxy> clientProxy = GetClientProxy(pkgName);
+    DISC_CHECK_AND_RETURN_RET_LOGE(clientProxy != nullptr, SOFTBUS_DISCOVER_GET_CLIENT_PROXY_FAILED,
+        DISC_CONTROL, "client proxy is nullptr");
+
+    clientProxy->OnPublishFail(publishId, reason);
+    return SOFTBUS_OK;
+}

core/discovery/ipc/standard/src/disc_client_proxy_standard.cpp

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2021 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 "disc_client_proxy_standard.h"
+#include "disc_log.h"
+#include "softbus_server_ipc_interface_code.h"
+
+namespace OHOS {
+DiscClientProxy::DiscClientProxy(const sptr<IRemoteObject> &impl)
+    : IRemoteProxy<ISoftBusClient>(impl)
+{
+    DISC_LOGI(DISC_CONTROL, "construct");
+}
+
+DiscClientProxy::~DiscClientProxy()
+{
+    DISC_LOGI(DISC_CONTROL, "destroy");
+}
+
+void DiscClientProxy::OnDeviceFound(const DeviceInfo *deviceInfo)
+{
+    MessageParcel data;
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInterfaceToken(GetDescriptor()), DISC_CONTROL, "write InterfaceToken failed");
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteBuffer(deviceInfo, sizeof(DeviceInfo)), DISC_CONTROL,
+        "write device info failed");
+    
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_CONTROL, "remote is nullptr");
+        return;
+    }
+    MessageParcel reply;
+    MessageOption option { MessageOption::TF_ASYNC };
+    DISC_CHECK_AND_RETURN_LOGE(remote->SendRequest(CLIENT_DISCOVERY_DEVICE_FOUND, data, reply, option) == SOFTBUS_OK,
+        DISC_CONTROL, "send request failed");
+}
+
+void DiscClientProxy::OnDiscoverFailed(int subscribeId, int reason)
+{
+    MessageParcel data;
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInterfaceToken(GetDescriptor()), DISC_CONTROL, "write InterfaceToken failed");
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInt32(subscribeId), DISC_CONTROL, "write subscribe id failed");
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInt32(reason), DISC_CONTROL, "write reason failed");
+
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_LNN, "remote is nullptr");
+        return;
+    }
+    MessageParcel reply;
+    MessageOption option { MessageOption::TF_ASYNC };
+    DISC_CHECK_AND_RETURN_LOGE(remote->SendRequest(CLIENT_DISCOVERY_FAIL, data, reply, option) == SOFTBUS_OK,
+        DISC_CONTROL, "send request failed");
+}
+
+void DiscClientProxy::OnDiscoverySuccess(int subscribeId)
+{
+    MessageParcel data;
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInterfaceToken(GetDescriptor()), DISC_CONTROL, "write InterfaceToken failed");
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInt32(subscribeId), DISC_CONTROL, "write subscribe id failed");
+
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_LNN, "remote is nullptr");
+        return;
+    }
+    MessageParcel reply;
+    MessageOption option { MessageOption::TF_ASYNC };
+    DISC_CHECK_AND_RETURN_LOGE(remote->SendRequest(CLIENT_DISCOVERY_SUCC, data, reply, option) == SOFTBUS_OK,
+        DISC_CONTROL, "send request failed");
+}
+
+void DiscClientProxy::OnPublishSuccess(int publishId)
+{
+    MessageParcel data;
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInterfaceToken(GetDescriptor()), DISC_CONTROL, "write InterfaceToken failed");
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInt32(publishId), DISC_CONTROL, "write publish id failed");
+
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_LNN, "remote is nullptr");
+        return;
+    }
+    MessageParcel reply;
+    MessageOption option { MessageOption::TF_ASYNC };
+    DISC_CHECK_AND_RETURN_LOGE(remote->SendRequest(CLIENT_PUBLISH_SUCC, data, reply, option) == 0,
+        DISC_CONTROL, "send request failed");
+}
+
+void DiscClientProxy::OnPublishFail(int publishId, int reason)
+{
+    MessageParcel data;
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInterfaceToken(GetDescriptor()), DISC_CONTROL, "write InterfaceToken failed");
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInt32(publishId), DISC_CONTROL, "write publish id failed");
+    DISC_CHECK_AND_RETURN_LOGE(data.WriteInt32(reason), DISC_CONTROL, "write reason failed");
+
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_LNN, "remote is nullptr");
+        return;
+    }
+    MessageParcel reply;
+    MessageOption option{MessageOption::TF_ASYNC};
+    DISC_CHECK_AND_RETURN_LOGE(remote->SendRequest(CLIENT_PUBLISH_FAIL, data, reply, option) == SOFTBUS_OK,
+        DISC_CONTROL, "send request failed");
+}
+}

core/discovery/manager/include/softbus_disc_server.h

@@ -26,6 +26,11 @@ int32_t DiscServerInit(void);
 void DiscServerDeinit(void);
 void DiscServerDeathCallback(const char *pkgName);
 
+int32_t DiscIpcPublishService(const char *packageName, const PublishInfo *info);
+int32_t DiscIpcUnPublishService(const char *packageName, int32_t publishId);
+int32_t DiscIpcStartDiscovery(const char *packageName, const SubscribeInfo *info);
+int32_t DiscIpcStopDiscovery(const char *packageName, int32_t subscribeId);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

core/discovery/manager/src/softbus_disc_server.c

@@ -15,10 +15,15 @@
 
 #include "softbus_disc_server.h"
 
+#include "disc_client_proxy.h"
 #include "disc_log.h"
 #include "softbus_error_code.h"
 #include "softbus_hisysevt_discreporter.h"
 
+static IServerDiscInnerCallback g_discInnerCb = {
+    .OnServerDeviceFound = ClientIpcOnDeviceFound,
+};
+
 int32_t DiscServerInit(void)
 {
     int32_t ret = DiscMgrInit();
@@ -38,3 +43,85 @@ void DiscServerDeathCallback(const char *pkgName)
 {
     DiscMgrDeathCallback(pkgName);
 }
+
+static SoftBusDiscMedium ConvertDiscType(const ExchangeMedium *discType)
+{
+    switch (*discType) {
+        case BLE:
+            return SOFTBUS_HISYSEVT_DISC_MEDIUM_BLE;
+        case COAP:
+            return SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP;
+        default:
+            return SOFTBUS_HISYSEVT_DISC_MEDIUM_BUTT;
+    }
+}
+
+static int32_t PublishErroCodeProcess(int32_t erroCode)
+{
+    if (erroCode == SOFTBUS_DISCOVER_MANAGER_INVALID_MEDIUM) {
+        return PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM;
+    }
+    return PUBLISH_FAIL_REASON_INTERNAL;
+}
+
+static int32_t DiscoveryErroCodeProcess(int32_t erroCode)
+{
+    if (erroCode == SOFTBUS_DISCOVER_MANAGER_INVALID_MEDIUM) {
+        return DISCOVERY_FAIL_REASON_NOT_SUPPORT_MEDIUM;
+    }
+    return DISCOVERY_FAIL_REASON_INTERNAL;
+}
+
+int32_t DiscIpcPublishService(const char *packageName, const PublishInfo *info)
+{
+    DISC_CHECK_AND_RETURN_RET_LOGW(packageName != NULL && info != NULL, SOFTBUS_INVALID_PARAM, DISC_CONTROL,
+        "invalid parameters");
+    int32_t ret = DiscPublishService(packageName, info);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "ServerPublishService failed");
+        SoftbusReportDiscFault(ConvertDiscType(&info->medium), ret);
+        (void)ClientIpcOnPublishFail(packageName, info->publishId, PublishErroCodeProcess(ret));
+        return ret;
+    }
+    DISC_LOGI(DISC_CONTROL, "ServerPublishService success!");
+    (void)ClientIpcOnPublishSuccess(packageName, info->publishId);
+    return SOFTBUS_OK;
+}
+
+int32_t DiscIpcUnPublishService(const char *packageName, int32_t publishId)
+{
+    int32_t ret = DiscUnPublishService(packageName, publishId);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "ServerUnPublishService failed");
+        return ret;
+    }
+    DISC_LOGI(DISC_CONTROL, "ServerUnPublishService success!");
+    return SOFTBUS_OK;
+}
+
+int32_t DiscIpcStartDiscovery(const char *packageName, const SubscribeInfo *info)
+{
+    DISC_CHECK_AND_RETURN_RET_LOGW(packageName != NULL && info != NULL, SOFTBUS_INVALID_PARAM, DISC_CONTROL,
+        "invalid parameters");
+    int32_t ret = DiscStartDiscovery(packageName, info, &g_discInnerCb);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "ServerStartDiscovery failed");
+        SoftbusReportDiscFault(ConvertDiscType(&info->medium), ret);
+        (void)ClientIpcOnDiscoverFailed(packageName, info->subscribeId, DiscoveryErroCodeProcess(ret));
+        return ret;
+    }
+    DISC_LOGI(DISC_CONTROL, "ServerStartDiscovery success!");
+    (void)ClientIpcDiscoverySuccess(packageName, info->subscribeId);
+    return SOFTBUS_OK;
+}
+
+int32_t DiscIpcStopDiscovery(const char *packageName, int32_t subscribeId)
+{
+    int32_t ret = DiscStopDiscovery(packageName, subscribeId);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "ServerStopDiscovery failed");
+        return ret;
+    }
+    DISC_LOGI(DISC_CONTROL, "ServerStopDiscovery success!");
+    return SOFTBUS_OK;
+}

core/frame/BUILD.gn

@@ -144,6 +144,7 @@ if (defined(ohos_lite)) {
         "common/src/softbus_server_frame.c",
         "small/client_manager/src/softbus_client_info_manager.c",
         "small/init/src/bus_center_server_stub.c",
+        "small/init/src/disc_server_stub.c",
         "small/init/src/softbus_server_stub.c",
         "small/init/src/trans_server_stub.c",
       ]

core/frame/small/init/include/disc_server_stub.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2021 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 DISC_SERVER_STUB_H
+
+#include <stdint.h>
+#include "serializer.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
+
+int32_t ServerPublishService(IpcIo *req, IpcIo *reply);
+int32_t ServerUnPublishService(IpcIo *req, IpcIo *reply);
+int32_t ServerStartDiscovery(IpcIo *req, IpcIo *reply);
+int32_t ServerStopDiscovery(IpcIo *req, IpcIo *reply);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif // !DISC_SERVER_STUB_H

core/frame/small/init/src/disc_server_stub.c

@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2021-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.
+ */
+
+#include "disc_server_stub.h"
+
+#include "comm_log.h"
+#include "disc_serializer.h"
+#include "discovery_service.h"
+#include "ipc_skeleton.h"
+#include "softbus_def.h"
+#include "softbus_disc_server.h"
+#include "softbus_errcode.h"
+#include "softbus_permission.h"
+
+int32_t ServerPublishService(IpcIo *req, IpcIo *reply)
+{
+    COMM_LOGI(COMM_SVC, "publish service ipc server pop.");
+    if (req == NULL || reply == NULL) {
+        COMM_LOGE(COMM_SVC, "invalid param.");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    size_t len;
+    unsigned char *capabilityData = NULL;
+    const char *pkgName = (const char*)ReadString(req, &len);
+    if (pkgName == NULL) {
+        COMM_LOGE(COMM_SVC, "ServerPublishService pkgName is null");
+        return SOFTBUS_ERR;
+    }
+    PublishSerializer *info = (PublishSerializer*)ReadRawData(req, sizeof(PublishSerializer));
+    if (info == NULL) {
+        COMM_LOGE(COMM_SVC, "ipc pop is null.");
+        return SOFTBUS_ERR;
+    }
+    char *capability = (char*)ReadString(req, &len);
+    if (info->commonSerializer.dataLen != 0) {
+        capabilityData = (unsigned char*)ReadString(req, &len);
+    }
+    PublishInfo publishInfo = {
+        .capability = capability,
+        .capabilityData = capabilityData,
+        .dataLen = info->commonSerializer.dataLen,
+        .freq = info->commonSerializer.freq,
+        .medium = info->commonSerializer.medium,
+        .mode = info->commonSerializer.mode,
+        .publishId = info->commonSerializer.id.publishId,
+    };
+    int32_t callingUid = GetCallingUid();
+    if (!CheckDiscPermission(callingUid, pkgName)) {
+        COMM_LOGE(COMM_SVC, "publish service no permission.");
+        return SOFTBUS_PERMISSION_DENIED;
+    }
+    int32_t ret = DiscIpcPublishService(pkgName, &publishInfo);
+    if (ret != SOFTBUS_OK) {
+        COMM_LOGE(COMM_SVC, "publish service failed.");
+        return SOFTBUS_ERR;
+    }
+    return SOFTBUS_OK;
+}
+
+int32_t ServerUnPublishService(IpcIo *req, IpcIo *reply)
+{
+    COMM_LOGI(COMM_SVC, "unpublish service ipc server pop.");
+    size_t len;
+    const char *pkgName = (const char*)ReadString(req, &len);
+    if (pkgName == NULL) {
+        COMM_LOGE(COMM_SVC, "ServerUnPublishService read pkgName failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    int32_t publishId;
+    ReadInt32(req, &publishId);
+    int32_t callingUid = GetCallingUid();
+    if (!CheckDiscPermission(callingUid, pkgName)) {
+        COMM_LOGE(COMM_SVC, "unpublish service no permission.");
+        return SOFTBUS_PERMISSION_DENIED;
+    }
+    int32_t ret = DiscIpcUnPublishService(pkgName, publishId);
+    if (ret != SOFTBUS_OK) {
+        COMM_LOGE(COMM_SVC, "unpublish service failed.");
+        return SOFTBUS_ERR;
+    }
+    return SOFTBUS_OK;
+}
+
+int32_t ServerStartDiscovery(IpcIo *req, IpcIo *reply)
+{
+    COMM_LOGD(COMM_SVC, "start discovery ipc server pop.");
+    size_t len;
+    unsigned char *capabilityData = NULL;
+    const char *pkgName = (const char *)ReadString(req, &len);
+    SubscribeSerializer *info = (SubscribeSerializer *)ReadRawData(req, sizeof(SubscribeSerializer));
+    if (info == NULL) {
+        COMM_LOGE(COMM_SVC, "ipc pop is null.");
+        return SOFTBUS_ERR;
+    }
+    char *capability = (char *)ReadString(req, &len);
+    if (info->commonSerializer.dataLen != 0) {
+        capabilityData = (unsigned char *)ReadString(req, &len);
+    }
+    SubscribeInfo subscribeInfo = {
+        .capability = capability,
+        .capabilityData = capabilityData,
+        .dataLen = info->commonSerializer.dataLen,
+        .freq = info->commonSerializer.freq,
+        .medium = info->commonSerializer.medium,
+        .mode = info->commonSerializer.mode,
+        .subscribeId = info->commonSerializer.id.subscribeId,
+        .isSameAccount = info->isSameAccount,
+        .isWakeRemote = info->isWakeRemote,
+    };
+    int32_t callingUid = GetCallingUid();
+    if (!CheckDiscPermission(callingUid, pkgName)) {
+        COMM_LOGE(COMM_SVC, "start discovery no permission.");
+        return SOFTBUS_PERMISSION_DENIED;
+    }
+    int32_t ret = DiscIpcStartDiscovery(pkgName, &subscribeInfo);
+    if (ret != SOFTBUS_OK) {
+        COMM_LOGE(COMM_SVC, "start discovery failed.");
+        return SOFTBUS_ERR;
+    }
+    return SOFTBUS_OK;
+}
+
+int32_t ServerStopDiscovery(IpcIo *req, IpcIo *reply)
+{
+    COMM_LOGI(COMM_SVC, "stop discovery ipc server pop.");
+    size_t len;
+    const char *pkgName = (const char *)ReadString(req, &len);
+    int32_t subscribeId;
+    ReadInt32(req, &subscribeId);
+    int32_t callingUid = GetCallingUid();
+    if (!CheckDiscPermission(callingUid, pkgName)) {
+        COMM_LOGE(COMM_SVC, "stop discovery no permission.");
+        return SOFTBUS_PERMISSION_DENIED;
+    }
+    int32_t ret = DiscIpcStopDiscovery(pkgName, subscribeId);
+    if (ret != SOFTBUS_OK) {
+        COMM_LOGE(COMM_SVC, "stop discovery failed.");
+        return SOFTBUS_ERR;
+    }
+    return SOFTBUS_OK;
+}

core/frame/small/init/src/softbus_server_stub.c

@@ -17,6 +17,7 @@
 
 #include "bus_center_server_stub.h"
 #include "comm_log.h"
+#include "disc_server_stub.h"
 #include "ipc_skeleton.h"
 #include "iproxy_server.h"
 #include "lnn_bus_center_ipc.h"
@@ -177,6 +178,10 @@ typedef struct {
 
 const ServerInvokeCmd g_serverInvokeCmdTbl[] = {
     { MANAGE_REGISTER_SERVICE, ServerRegisterService },
+    { SERVER_PUBLISH_SERVICE, ServerPublishService },
+    { SERVER_UNPUBLISH_SERVICE, ServerUnPublishService },
+    { SERVER_START_DISCOVERY, ServerStartDiscovery },
+    { SERVER_STOP_DISCOVERY, ServerStopDiscovery },
     { SERVER_JOIN_LNN, ServerJoinLNN },
     { SERVER_JOIN_METANODE, ServerJoinMetaNode },
     { SERVER_LEAVE_LNN, ServerLeaveLNN },

core/frame/standard/init/include/if_softbus_server.h

@@ -17,6 +17,7 @@
 #define INTERFACES_INNERKITS_SOFTBUS_SERVER_H_
 
 #include "data_level.h"
+#include "discovery_service.h"
 #include "iremote_broker.h"
 #include "iremote_object.h"
 #include "iremote_proxy.h"
@@ -29,6 +30,10 @@ class ISoftBusServer : public IRemoteBroker {
 public:
     virtual ~ISoftBusServer() = default;
 
+    virtual int32_t StartDiscovery(const char *pkgName, const SubscribeInfo *info) = 0;
+    virtual int32_t StopDiscovery(const char *pkgName, int subscribeId) = 0;
+    virtual int32_t PublishService(const char *pkgName, const PublishInfo *info) = 0;
+    virtual int32_t UnPublishService(const char *pkgName, int publishId) = 0;
     virtual int32_t SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object) = 0;
 
     virtual int32_t CreateSessionServer(const char *pkgName, const char *sessionName) = 0;

core/frame/standard/init/include/softbus_server.h

@@ -28,6 +28,10 @@ public:
     SoftBusServer(int32_t saId, bool runOnCreate);
     ~SoftBusServer() = default;
 
+    int32_t StartDiscovery(const char *pkgName, const SubscribeInfo *info) override;
+    int32_t StopDiscovery(const char *pkgName, int subscribeId) override;
+    int32_t PublishService(const char *pkgName, const PublishInfo *info) override;
+    int32_t UnPublishService(const char *pkgName, int publishId) override;
     int32_t SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object) override;
 
     int32_t CreateSessionServer(const char *pkgName, const char *sessionName) override;

core/frame/standard/init/include/softbus_server_stub.h

@@ -31,6 +31,10 @@ public:
 
 private:
     int32_t GetNodeKeyInfoLen(int32_t key);
+    int32_t StartDiscoveryInner(MessageParcel &data, MessageParcel &reply);
+    int32_t StopDiscoveryInner(MessageParcel &data, MessageParcel &reply);
+    int32_t PublishServiceInner(MessageParcel &data, MessageParcel &reply);
+    int32_t UnpublishServiceInner(MessageParcel &data, MessageParcel &reply);
     int32_t SoftbusRegisterServiceInner(MessageParcel &data, MessageParcel &reply);
 
     int32_t CreateSessionServerInner(MessageParcel &data, MessageParcel &reply);

core/frame/standard/init/src/softbus_server.cpp

@@ -57,6 +57,26 @@ SoftBusServer::SoftBusServer(int32_t saId, bool runOnCreate) : SystemAbility(saI
 {
 }
 
+int32_t SoftBusServer::StartDiscovery(const char *pkgName, const SubscribeInfo *info)
+{
+    return DiscIpcStartDiscovery(pkgName, info);
+}
+
+int32_t SoftBusServer::StopDiscovery(const char *pkgName, int subscribeId)
+{
+    return DiscIpcStopDiscovery(pkgName, subscribeId);
+}
+
+int32_t SoftBusServer::PublishService(const char *pkgName, const PublishInfo *info)
+{
+    return DiscIpcPublishService(pkgName, (PublishInfo *)(info));
+}
+
+int32_t SoftBusServer::UnPublishService(const char *pkgName, int publishId)
+{
+    return DiscIpcUnPublishService(pkgName, publishId);
+}
+
 int32_t SoftBusServer::SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object)
 {
     if (clientPkgName == nullptr || object == nullptr) {

core/frame/standard/init/src/softbus_server_stub.cpp

@@ -147,6 +147,10 @@ SoftBusServerStub::SoftBusServerStub()
 
 void SoftBusServerStub::InitMemberFuncMap()
 {
+    memberFuncMap_[SERVER_START_DISCOVERY] = &SoftBusServerStub::StartDiscoveryInner;
+    memberFuncMap_[SERVER_STOP_DISCOVERY] = &SoftBusServerStub::StopDiscoveryInner;
+    memberFuncMap_[SERVER_PUBLISH_SERVICE] = &SoftBusServerStub::PublishServiceInner;
+    memberFuncMap_[SERVER_UNPUBLISH_SERVICE] = &SoftBusServerStub::UnpublishServiceInner;
     memberFuncMap_[MANAGE_REGISTER_SERVICE] = &SoftBusServerStub::SoftbusRegisterServiceInner;
     memberFuncMap_[SERVER_CREATE_SESSION_SERVER] = &SoftBusServerStub::CreateSessionServerInner;
     memberFuncMap_[SERVER_REMOVE_SESSION_SERVER] = &SoftBusServerStub::RemoveSessionServerInner;
@@ -188,6 +192,10 @@ void SoftBusServerStub::InitMemberFuncMap()
 
 void SoftBusServerStub::InitMemberPermissionMap()
 {
+    memberPermissionMap_[SERVER_START_DISCOVERY] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
+    memberPermissionMap_[SERVER_STOP_DISCOVERY] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
+    memberPermissionMap_[SERVER_PUBLISH_SERVICE] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
+    memberPermissionMap_[SERVER_UNPUBLISH_SERVICE] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
     memberPermissionMap_[MANAGE_REGISTER_SERVICE] = nullptr;
     memberPermissionMap_[SERVER_CREATE_SESSION_SERVER] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
     memberPermissionMap_[SERVER_REMOVE_SESSION_SERVER] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
@@ -276,6 +284,128 @@ int32_t SoftBusServerStub::OnRemoteRequest(
     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
 }
 
+int32_t SoftBusServerStub::StartDiscoveryInner(MessageParcel &data, MessageParcel &reply)
+{
+    const char *pkgName = data.ReadCString();
+    COMM_CHECK_AND_RETURN_RET_LOGE(pkgName != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read pkgName failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(strnlen(pkgName, PKG_NAME_SIZE_MAX) < PKG_NAME_SIZE_MAX, SOFTBUS_INVALID_PKGNAME,
+        COMM_SVC, "pkgName invalid");
+    SoftbusRecordCalledApiInfo(pkgName, SERVER_START_DISCOVERY);
+
+    SubscribeInfo info = {0};
+    int32_t value = 0;
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(info.subscribeId), SOFTBUS_IPC_ERR, COMM_SVC,
+        "read subscribeId failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(value), SOFTBUS_IPC_ERR, COMM_SVC, "read mode failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(value == DISCOVER_MODE_PASSIVE || value == DISCOVER_MODE_ACTIVE,
+        SOFTBUS_INVALID_PARAM, COMM_SVC, "mode invalid");
+    info.mode = static_cast<DiscoverMode>(value);
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(value), SOFTBUS_IPC_ERR, COMM_SVC, "read medium failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(0 <= value && value < MEDIUM_BUTT, SOFTBUS_INVALID_PARAM, COMM_SVC,
+        "medium invalid");
+    info.medium = static_cast<ExchangeMedium>(value);
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(value), SOFTBUS_IPC_ERR, COMM_SVC, "read freq failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(0 <= value && value < FREQ_BUTT, SOFTBUS_INVALID_PARAM, COMM_SVC, "freq invalid");
+    info.freq = static_cast<ExchangeFreq>(value);
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadBool(info.isSameAccount), SOFTBUS_IPC_ERR, COMM_SVC,
+        "read isSameAccount failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadBool(info.isWakeRemote), SOFTBUS_IPC_ERR, COMM_SVC,
+        "read isWakeRemote failed");
+
+    info.capability = data.ReadCString();
+    COMM_CHECK_AND_RETURN_RET_LOGE(info.capability != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read capability failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadUint32(info.dataLen), SOFTBUS_IPC_ERR, COMM_SVC, "read dataLen failed");
+    if (info.dataLen > 0 && info.dataLen < MAX_CAPABILITYDATA_LEN) {
+        const char *capabilityData = data.ReadCString();
+        COMM_CHECK_AND_RETURN_RET_LOGE(capabilityData != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read capaData failed");
+        COMM_CHECK_AND_RETURN_RET_LOGE(strlen(capabilityData) == info.dataLen, SOFTBUS_INVALID_PARAM, COMM_SVC,
+            "capabilityData invalid");
+        info.capabilityData = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(capabilityData));
+    } else {
+        info.capabilityData = nullptr;
+        info.dataLen = 0;
+    }
+
+    int32_t retReply = StartDiscovery(pkgName, &info);
+    COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(retReply), SOFTBUS_IPC_ERR, COMM_SVC, "write reply failed");
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusServerStub::StopDiscoveryInner(MessageParcel &data, MessageParcel &reply)
+{
+    const char *pkgName = data.ReadCString();
+    COMM_CHECK_AND_RETURN_RET_LOGE(pkgName != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read pkgName failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(strnlen(pkgName, PKG_NAME_SIZE_MAX) < PKG_NAME_SIZE_MAX, SOFTBUS_INVALID_PKGNAME,
+        COMM_SVC, "pkgName invalid");
+    SoftbusRecordCalledApiInfo(pkgName, SERVER_STOP_DISCOVERY);
+
+    int32_t subscribeId = 0;
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(subscribeId), SOFTBUS_IPC_ERR, COMM_SVC, "read subscribeId failed");
+
+    int32_t retReply = StopDiscovery(pkgName, subscribeId);
+    COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(retReply), SOFTBUS_IPC_ERR, COMM_SVC, "write reply failed");
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusServerStub::PublishServiceInner(MessageParcel &data, MessageParcel &reply)
+{
+    const char *pkgName = data.ReadCString();
+    COMM_CHECK_AND_RETURN_RET_LOGE(pkgName != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read pkgName failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(strnlen(pkgName, PKG_NAME_SIZE_MAX) < PKG_NAME_SIZE_MAX, SOFTBUS_INVALID_PKGNAME,
+        COMM_SVC, "pkgName invalid");
+    SoftbusRecordCalledApiInfo(pkgName, SERVER_PUBLISH_SERVICE);
+
+    PublishInfo info = {0};
+    int32_t value = 0;
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(info.publishId), SOFTBUS_IPC_ERR, COMM_SVC,
+        "read publishId failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(value), SOFTBUS_IPC_ERR, COMM_SVC, "read mode failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(value == DISCOVER_MODE_PASSIVE || value == DISCOVER_MODE_ACTIVE,
+        SOFTBUS_INVALID_PARAM, COMM_SVC, "mode invalid");
+    info.mode = static_cast<DiscoverMode>(value);
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(value), SOFTBUS_IPC_ERR, COMM_SVC, "read medium failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(0 <= value && value < MEDIUM_BUTT, SOFTBUS_INVALID_PARAM, COMM_SVC,
+        "medium invalid");
+    info.medium = static_cast<ExchangeMedium>(value);
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(value), SOFTBUS_IPC_ERR, COMM_SVC, "read freq failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(0 <= value && value < FREQ_BUTT, SOFTBUS_INVALID_PARAM, COMM_SVC, "freq invalid");
+    info.freq = static_cast<ExchangeFreq>(value);
+
+    info.capability = data.ReadCString();
+    COMM_CHECK_AND_RETURN_RET_LOGE(info.capability != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read capability failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadUint32(info.dataLen), SOFTBUS_IPC_ERR, COMM_SVC, "read dataLen failed");
+    if (info.dataLen > 0 && info.dataLen < MAX_CAPABILITYDATA_LEN) {
+        const char *capabilityData = data.ReadCString();
+        COMM_CHECK_AND_RETURN_RET_LOGE(capabilityData != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read capaData failed");
+        COMM_CHECK_AND_RETURN_RET_LOGE(strlen(capabilityData) == info.dataLen, SOFTBUS_INVALID_PARAM, COMM_SVC,
+            "capabilityData invalid");
+        info.capabilityData = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(capabilityData));
+    } else {
+        info.capabilityData = nullptr;
+        info.dataLen = 0;
+    }
+
+    int32_t retReply = PublishService(pkgName, &info);
+    COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(retReply), SOFTBUS_IPC_ERR, COMM_SVC, "write reply failed");
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusServerStub::UnpublishServiceInner(MessageParcel &data, MessageParcel &reply)
+{
+    const char *pkgName = data.ReadCString();
+    COMM_CHECK_AND_RETURN_RET_LOGE(pkgName != nullptr, SOFTBUS_IPC_ERR, COMM_SVC, "read pkgName failed");
+    COMM_CHECK_AND_RETURN_RET_LOGE(strnlen(pkgName, PKG_NAME_SIZE_MAX) < PKG_NAME_SIZE_MAX, SOFTBUS_INVALID_PKGNAME,
+        COMM_SVC, "pkgName invalid");
+    SoftbusRecordCalledApiInfo(pkgName, SERVER_UNPUBLISH_SERVICE);
+
+    int32_t publishId = 0;
+    COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(publishId), SOFTBUS_IPC_ERR, COMM_SVC, "read publishId failed");
+
+    int32_t retReply = UnPublishService(pkgName, publishId);
+    COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(retReply), SOFTBUS_IPC_ERR, COMM_SVC, "write reply failed");
+    return SOFTBUS_OK;
+}
+
 int32_t SoftBusServerStub::SoftbusRegisterServiceInner(MessageParcel &data, MessageParcel &reply)
 {
     COMM_LOGD(COMM_SVC, "enter");

core/transmission/ipc/standard/include/trans_client_proxy_standard.h

@@ -25,6 +25,11 @@ public:
         : IRemoteProxy<ISoftBusClient>(impl) {}
     virtual ~TransClientProxy() = default;
 
+    void OnDeviceFound(const DeviceInfo *device) override;
+    void OnDiscoverFailed(int subscribeId, int failReason) override;
+    void OnDiscoverySuccess(int subscribeId) override;
+    void OnPublishSuccess(int publishId) override;
+    void OnPublishFail(int publishId, int reason) override;
     int32_t OnChannelOpened(const char *sessionName, const ChannelInfo *channel) override;
     int32_t OnChannelBind(int32_t channelId, int32_t channelType) override;
     int32_t OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode) override;

core/transmission/ipc/standard/src/trans_client_proxy_standard.cpp

@@ -376,6 +376,33 @@ int32_t TransClientProxy::SetChannelInfo(
     return serverRet;
 }
 
+void TransClientProxy::OnDeviceFound(const DeviceInfo *device)
+{
+    (void)device;
+}
+
+void TransClientProxy::OnDiscoverFailed(int subscribeId, int failReason)
+{
+    (void)subscribeId;
+    (void)failReason;
+}
+
+void TransClientProxy::OnDiscoverySuccess(int subscribeId)
+{
+    (void)subscribeId;
+}
+
+void TransClientProxy::OnPublishSuccess(int publishId)
+{
+    (void)publishId;
+}
+
+void TransClientProxy::OnPublishFail(int publishId, int reason)
+{
+    (void)publishId;
+    (void)reason;
+}
+
 int32_t TransClientProxy::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
 {
     (void)addr;

interfaces/kits/discovery/discovery_service.h

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2021-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.
+ */
+
+/**
+ * @addtogroup SoftBus
+ * @{
+ *
+ * @brief Provides high-speed, secure communication between devices.
+ *
+ * This module implements unified distributed communication capability management between nearby devices, and provides
+ * link-independent device discovery and transmission interfaces to support service publishing and data transmission.
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+/** @} */
+
+/**
+ * @file discovery_service.h
+ *
+ * @brief Declares functions and constants for the discovery service of the Intelligent Soft Bus.
+ *
+ * The functions are used to perform
+ * the following operations: \n
+ * <ul>
+ * <li>Publishing service and stop publishing service functions</li>
+ * <li>Start the discovery function and stop the discover function</li>
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+
+#ifndef DISCOVERY_SERVICE_H
+#define DISCOVERY_SERVICE_H
+
+#include "softbus_common.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
+
+/**
+ * @brief Indicates the maximum length of the device address in <b>IDiscoveryCallback</b>.
+ *
+ */
+#define CONNECT_ADDR_LEN 46
+
+/**
+ * @brief Enumerates error codes for service publishing failures.
+ *
+ * The error codes are returned to the caller through <b>IPublishCallback</b>.
+ *
+ */
+typedef enum {
+    /* Unsupported medium */
+    PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM = 1,
+    /* internal error */
+    PUBLISH_FAIL_REASON_INTERNAL = 2,
+    /* Unknown reason */
+    PUBLISH_FAIL_REASON_UNKNOWN = 0xFF
+} PublishFailReason;
+
+/**
+ * @brief Defines the callbacks for successful and failed service publishing.
+ *
+ */
+typedef struct {
+    /** Callback for successful publishing */
+    void (*OnPublishSuccess)(int publishId);
+    /** Callback for failed publishing */
+    void (*OnPublishFail)(int publishId, PublishFailReason reason);
+} IPublishCallback;
+
+/**
+ * @brief Enumerates error codes for service subscription failures.
+ *
+ * The error codes are returned to the caller through <b>IDiscoveryCallback</b>.
+ *
+ */
+typedef enum {
+    /* Unsupported medium */
+    DISCOVERY_FAIL_REASON_NOT_SUPPORT_MEDIUM = 1,
+    /* internal error */
+    DISCOVERY_FAIL_REASON_INTERNAL = 2,
+    /* Unknown error */
+    DISCOVERY_FAIL_REASON_UNKNOWN = 0xFF
+} DiscoveryFailReason;
+
+/**
+ * @brief Defines a callback for service subscription.
+ *
+ * Three types of callbacks are available.
+ *
+ */
+typedef struct {
+    /** Callback that is invoked when a device is found */
+    void (*OnDeviceFound)(const DeviceInfo *device);
+    /** Callback for a subscription failure */
+    void (*OnDiscoverFailed)(int subscribeId, DiscoveryFailReason failReason);
+    /** Callback for a subscription success */
+    void (*OnDiscoverySuccess)(int subscribeId);
+} IDiscoveryCallback;
+
+/**
+ * @brief Publishing service, the discovered end publishes its own information,
+ * which can be discovered by other devices.
+ * Peer devices in the same LAN as the device that publishes this service can discover this service as needed.
+ * The service is identified by <b>publicId</b> and <b>pkgName</b>.
+ * @see {@link UnPublishService}
+ * @param[in] pkgName Indicates the pointer to the service package name, which can contain a maximum of 64 bytes.
+ * @param[in] info Indicates the pointer to the service publishing information.
+ * For details, see {@link PublishInfo}.
+ * @param[in] cb Indicates the pointer to the service publishing callback.
+ * For details, see {@link IPublishCallback}.
+ * @return <b>SOFTBUS_INVALID_PARAM</b> if any parameter is null or invalid.
+ * @return <b>SOFTBUS_DISCOVER_NOT_INIT</b> if the Intelligent SoftBus client fails to be initialized.
+ * @return <b>SOFTBUS_LOCK_ERR</b> if the mutex fails to be locked.
+ * @return <b>SOFTBUS_OK</b> if the service is successfully published.
+ * @deprecated Please use PublishLNN instead, for details, see {@link PublishLNN}.
+ */
+int PublishService(const char *pkgName, const PublishInfo *info, const IPublishCallback *cb);
+
+/**
+ * @brief Stop publishing service functions, stop publishing its own capability information,
+ * and other devices cannot find it.
+ * @see {@link PublishService}
+ * @param[in] pkgName Indicates the pointer to the service package name, which can contain a maximum of 64 bytes.
+ * @param[in] publishId Indicates the service ID.
+ * @return <b>SOFTBUS_INVALID_PARAM</b> if <b>pkgName</b> is invalid.
+ * @return <b>SOFTBUS_DISCOVER_NOT_INIT</b> if the Intelligent SoftBus client fails to be initialized.
+ * @return <b>SOFTBUS_OK</b> if the service is successfully unpublished.
+ * @deprecated Please use StopPublishLNN instead, for details, see {@link StopPublishLNN}.
+ */
+int UnPublishService(const char *pkgName, int publishId);
+
+/**
+ * @brief Start the discovery function, the discovered end begins to discover other devices
+ * and obtains the information of the remote device.
+ * Information about the device that publishes the service will be reported to the device that subscribes to
+ * the service. The service is identified by <b>subscribeId</b> and <b>pkgName</b>.
+ * @see {@link StopDiscovery}
+ * @param[in] pkgName Indicates the pointer to the service package name, which can contain a maximum of 64 bytes.
+ * @param[in] info Indicates the pointer to the service subscription information.
+ * For details, see {@link SubscribeInfo}.
+ * @param[in] cb Indicates the service subscription callback. For details, see {@link IDiscoveryCallback}.
+ * @return <b>SOFTBUS_INVALID_PARAM</b> if any parameter is null or invalid.
+ * @return <b>SOFTBUS_DISCOVER_NOT_INIT</b> if the Intelligent SoftBus client fails to be initialized.
+ * @return <b>SOFTBUS_LOCK_ERR</b> if the mutex fails to be locked.
+ * @return <b>SOFTBUS_OK</b> if the service subscription is successful.
+ * @deprecated Please use RefreshLNN instead, for details, see {@link RefreshLNN}.
+ */
+int StartDiscovery(const char *pkgName, const SubscribeInfo *info, const IDiscoveryCallback *cb);
+
+/**
+ * @brief Stop the discovery function, at this time no longer capture device information of other devices at this time.
+ * @see {@link StartDiscovery}
+ * @param[in] pkgName Indicates the pointer to the service package name, which can contain a maximum of 64 bytes.
+ * @param[in] subscribeId Indicates the service ID.
+ * @return <b>SOFTBUS_INVALID_PARAM</b> if <b>pkgName</b> is invalid.
+ * @return <b>SOFTBUS_DISCOVER_NOT_INIT</b> if the Intelligent SoftBus client fails to be initialized.
+ * @return <b>SOFTBUS_OK</b> if the service unsubscription is successful.
+ * @deprecated Please use StopRefreshLNN instead, for details, see {@link StopRefreshLNN}.
+ */
+int StopDiscovery(const char *pkgName, int subscribeId);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif /* DISCOVERY_SERVICE_H */

sdk/BUILD.gn

@@ -14,15 +14,16 @@
 import("../core/common/dfx/dsoftbus_dfx.gni")
 import("../dsoftbus.gni")
 import("bus_center/bus_center_sdk.gni")
+import("discovery/disc_sdk.gni")
 import("frame/frame_sdk.gni")
 import("transmission/trans_sdk.gni")
 
 dsoftbus_root_path = ".."
 
-common_client_src = bus_center_sdk_src + softbus_client_frame_src +
-                    trans_session_manager_sdk_src
-common_client_inc = bus_center_sdk_inc + softbus_client_frame_inc +
-                    trans_session_manager_sdk_inc
+common_client_src = bus_center_sdk_src + disc_sdk_src +
+                    softbus_client_frame_src + trans_session_manager_sdk_src
+common_client_inc = bus_center_sdk_inc + disc_sdk_inc +
+                    softbus_client_frame_inc + trans_session_manager_sdk_inc
 common_client_deps = bus_center_sdk_deps + trans_session_manager_sdk_deps
 
 common_client_ext_deps = []

sdk/bus_center/ipc/include/bus_center_server_proxy.h

@@ -58,4 +58,4 @@ int32_t ServerIpcShiftLNNGear(const char *pkgName, const char *callerId, const c
 #endif /* __cplusplus */
 #endif /* __cplusplus */
 
-#endif // BUS_CENTER_SERVER_PROXY_H
+#endif // !DISC_SERVER_PROXY_H

sdk/bus_center/ipc/standard/include/bus_center_server_proxy_standard.h

@@ -26,6 +26,10 @@ public:
         : IRemoteProxy<ISoftBusServer>(impl) {}
     virtual ~BusCenterServerProxy() = default;
 
+    int32_t StartDiscovery(const char *pkgName, const SubscribeInfo *info) override;
+    int32_t StopDiscovery(const char *pkgName, int subscribeId) override;
+    int32_t PublishService(const char *pkgName, const PublishInfo *info) override;
+    int32_t UnPublishService(const char *pkgName, int publishId) override;
     int32_t SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object) override;
 
     int32_t CreateSessionServer(const char *pkgName, const char *sessionName) override;

sdk/bus_center/ipc/standard/src/bus_center_server_proxy_standard.cpp

@@ -17,6 +17,7 @@
 
 #include <securec.h>
 #include "bus_center_server_proxy.h"
+#include "discovery_service.h"
 #include "ipc_skeleton.h"
 #include "iremote_broker.h"
 #include "iremote_object.h"
@@ -81,6 +82,34 @@ void BusCenterServerProxy::BusCenterServerProxyStandardDeInit(void)
     g_remoteProxy.clear();
 }
 
+int32_t BusCenterServerProxy::StartDiscovery(const char *pkgName, const SubscribeInfo *subInfo)
+{
+    (void)pkgName;
+    (void)subInfo;
+    return SOFTBUS_OK;
+}
+
+int32_t BusCenterServerProxy::StopDiscovery(const char *pkgName, int32_t subscribeId)
+{
+    (void)pkgName;
+    (void)subscribeId;
+    return SOFTBUS_OK;
+}
+
+int32_t BusCenterServerProxy::PublishService(const char *pkgName, const PublishInfo *pubInfo)
+{
+    (void)pkgName;
+    (void)pubInfo;
+    return SOFTBUS_OK;
+}
+
+int32_t BusCenterServerProxy::UnPublishService(const char *pkgName, int32_t publishId)
+{
+    (void)pkgName;
+    (void)publishId;
+    return SOFTBUS_OK;
+}
+
 int32_t BusCenterServerProxy::SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject>& object)
 {
     (void)clientPkgName;

sdk/discovery/disc_sdk.gni

@@ -0,0 +1,51 @@
+# Copyright (c) 2021 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.
+
+import("../../dsoftbus.gni")
+
+disc_sdk_src =
+    [ "$dsoftbus_root_path/sdk/discovery/service/src/client_disc_service.c" ]
+disc_sdk_inc = [
+  "$dsoftbus_root_path/sdk/discovery/ipc/include",
+  "$dsoftbus_root_path/sdk/discovery/manager/include",
+  "$dsoftbus_root_path/sdk/discovery/service/include",
+]
+if (defined(ohos_lite)) {
+  disc_sdk_inc += [ "$dsoftbus_root_path/core/discovery/interface" ]
+  if (ohos_kernel_type == "liteos_m") {
+    import("../../core/discovery/disc.gni")
+    disc_sdk_src += [
+      "$dsoftbus_root_path/sdk/discovery/ipc/mini/disc_server_proxy.c",
+      "$dsoftbus_root_path/sdk/discovery/manager/src/client_disc_manager.c",
+    ]
+    disc_sdk_inc += disc_server_inc
+  } else {
+    disc_sdk_src += [
+      "$dsoftbus_root_path/sdk/discovery/ipc/small/disc_server_proxy.c",
+      "$dsoftbus_root_path/sdk/discovery/manager/src/client_disc_manager.c",
+    ]
+  }
+} else {
+  disc_sdk_inc += [
+    "$dsoftbus_root_path/sdk/discovery/ipc/$os_type/include",
+    "$dsoftbus_root_path/core/frame/$os_type/init/include",
+    "$dsoftbus_root_path/core/transmission/common/include",
+    "$dsoftbus_root_path/interfaces/inner_kits/lnn",
+    "$dsoftbus_root_path/interfaces/kits/transport",
+  ]
+  disc_sdk_src += [
+    "$dsoftbus_root_path/sdk/discovery/ipc/$os_type/src/disc_server_proxy.cpp",
+    "$dsoftbus_root_path/sdk/discovery/ipc/$os_type/src/disc_server_proxy_standard.cpp",
+    "$dsoftbus_root_path/sdk/discovery/manager/src/client_disc_manager.c",
+  ]
+}

sdk/discovery/ipc/include/disc_server_proxy.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2021 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 DISC_SERVER_PROXY_H
+
+#include <stdint.h>
+#include "discovery_service.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
+
+int32_t DiscServerProxyInit(void);
+void DiscServerProxyDeInit(void);
+
+/**
+ * @brief The publishing service is started in the IPC communication,
+ * and the agent is called to start the publishing service.
+ * @see {@link ServerIpcUnPublishService}
+ * @param[in] pkgName Indicates the pointer to the service package name, which can contain a maximum of 64 bytes.
+ * @param[in] info Indicates the pointer to the service publishing information.
+ * For details, see {@link PublishInfo}.
+ * @return <b>SOFTBUS_OK</b> if the service ipc is successfully published.
+ */
+int32_t ServerIpcPublishService(const char *pkgName, const PublishInfo *info);
+
+/**
+ * @brief Unpublish the service in the IPC communication, call the proxy to stop publishing the service.
+ * @see {@link ServerIpcPublishService}
+ * @param[in] pkgName Indicates the pointer to the service package name, which can contain a maximum of 64 bytes.
+ * @param[in] publishId Indicates the service ID.
+ * @return <b>SOFTBUS_OK</b> if the service ipc is successfully unpublished.
+ */
+int32_t ServerIpcUnPublishService(const char *pkgName, int32_t publishId);
+
+/**
+ * @brief The active discovery service is started in the IPC communication,
+ * and the agent is called to start the active discovery service.
+ * @see {@link ServerIpcStopDiscovery}
+ * @param[in] pkgName Indicates the pointer to the subscribe package name,
+ * which can contain a maximum of 64 bytes.
+ * @param[in] info Indicates the pointer to the service publishing information.
+ * For details, see {@link SubscribeInfo}.
+ * @return <b>SOFTBUS_OK</b> if the service ipc is successfully start discovery.
+ */
+int32_t ServerIpcStartDiscovery(const char *pkgName, const SubscribeInfo *info);
+
+/**
+ * @brief Stop the discovery service in IPC communication and call the agent to stop the discovery service.
+ * @see {@link ServerIpcStartDiscovery}
+ * @param[in] pkgName Indicates the pointer to the subscribe package name,
+ * which can contain a maximum of 64 bytes.
+ * @param[in] subscribeId Indicates the subscribe ID.
+ * @return <b>SOFTBUS_OK</b> if the service ipc is successfully stop discovery.
+ */
+int32_t ServerIpcStopDiscovery(const char *pkgName, int32_t subscribeId);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif // !DISC_SERVER_PROXY_H

sdk/discovery/ipc/mini/disc_server_proxy.c

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2021 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 "disc_server_proxy.h"
+
+#include "softbus_disc_server.h"
+#include "softbus_errcode.h"
+
+int32_t DiscServerProxyInit(void)
+{
+    return SOFTBUS_OK;
+}
+
+void DiscServerProxyDeInit(void)
+{
+    return;
+}
+
+int32_t ServerIpcPublishService(const char *pkgName, const PublishInfo *info)
+{
+    return DiscIpcPublishService(pkgName, info);
+}
+
+int32_t ServerIpcUnPublishService(const char *pkgName, int32_t publishId)
+{
+    return DiscIpcUnPublishService(pkgName, publishId);
+}
+
+int32_t ServerIpcStartDiscovery(const char *pkgName, const SubscribeInfo *info)
+{
+    return DiscIpcStartDiscovery(pkgName, info);
+}
+
+int32_t ServerIpcStopDiscovery(const char *pkgName, int32_t subscribeId)
+{
+    return DiscIpcStopDiscovery(pkgName, subscribeId);
+}
+

sdk/discovery/ipc/small/disc_server_proxy.c

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2021 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 "disc_server_proxy.h"
+
+#include "disc_log.h"
+#include "disc_serializer.h"
+#include "iproxy_client.h"
+#include "samgr_lite.h"
+#include "serializer.h"
+#include "softbus_adapter_file.h"
+#include "softbus_adapter_timer.h"
+#include "softbus_def.h"
+#include "softbus_errcode.h"
+#include "softbus_server_ipc_interface_code.h"
+
+#define WAIT_SERVER_READY_INTERVAL_COUNT 50
+
+static IClientProxy *g_serverProxy = NULL;
+
+int32_t DiscServerProxyInit(void)
+{
+    if (g_serverProxy != NULL) {
+        DISC_LOGI(DISC_INIT, "server proxy has initialized.");
+        return SOFTBUS_OK;
+    }
+
+    DISC_LOGI(DISC_INIT, "disc start get server proxy");
+    int32_t proxyInitCount = 0;
+    while (g_serverProxy == NULL) {
+        proxyInitCount++;
+        if (proxyInitCount == WAIT_SERVER_READY_INTERVAL_COUNT) {
+            DISC_LOGE(DISC_INIT, "disc get server proxy error");
+            return SOFTBUS_DISC_SERVER_INIT_FAILED;
+        }
+        IUnknown *iUnknown = SAMGR_GetInstance()->GetDefaultFeatureApi(SOFTBUS_SERVICE);
+        if (iUnknown == NULL) {
+            SoftBusSleepMs(WAIT_SERVER_READY_INTERVAL);
+            continue;
+        }
+
+        int32_t ret = iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, (void **)&g_serverProxy);
+        if (ret != EC_SUCCESS || g_serverProxy == NULL) {
+            DISC_LOGE(DISC_INIT, "QueryInterface failed. ret=%{public}d", ret);
+            SoftBusSleepMs(WAIT_SERVER_READY_INTERVAL);
+            continue;
+        }
+    }
+    DISC_LOGI(DISC_INIT, "disc get server proxy ok");
+    return SOFTBUS_OK;
+}
+
+void DiscServerProxyDeInit(void)
+{
+    g_serverProxy = NULL;
+}
+
+int ServerIpcPublishService(const char *pkgName, const PublishInfo *info)
+{
+    DISC_LOGI(DISC_CONTROL, "publish service ipc client push.");
+    if (pkgName == NULL || info == NULL) {
+        DISC_LOGE(DISC_SDK, "Invalid param:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (g_serverProxy == NULL) {
+        return SOFTBUS_NO_INIT;
+    }
+
+    uint8_t data[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIo request = {0};
+    IpcIoInit(&request, data, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteString(&request, pkgName);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write pkgName failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    DiscSerializer serializer = {
+        .dataLen = info->dataLen,
+        .freq = info->freq,
+        .medium = info->medium,
+        .mode = info->mode,
+        .id.publishId = info->publishId
+    };
+    PublishSerializer publishSerializer = {
+        .commonSerializer = serializer
+    };
+    ret = WriteRawData(&request, (void*)&publishSerializer, sizeof(PublishSerializer));
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write publish serializer failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    
+    ret = WriteString(&request, info->capability);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write capability failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (info->dataLen != 0) {
+        ret = WriteString(&request, (const char *)(info->capabilityData));
+        if (!ret) {
+            DISC_LOGE(DISC_SDK, "Write capability Data failed");
+            return SOFTBUS_IPC_ERR;
+        }
+    }
+    /* asynchronous invocation */
+    int32_t ans = g_serverProxy->Invoke(g_serverProxy, SERVER_PUBLISH_SERVICE, &request, NULL, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "publish service invoke failed. ans=%{public}d", ans);
+        return ans;
+    }
+    return SOFTBUS_OK;
+}
+
+int ServerIpcUnPublishService(const char *pkgName, int publishId)
+{
+    DISC_LOGI(DISC_CONTROL, "unpublish service ipc client push.");
+    if (pkgName == NULL) {
+        DISC_LOGE(DISC_SDK, "Invalid param:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (g_serverProxy == NULL) {
+        return SOFTBUS_NO_INIT;
+    }
+
+    uint8_t data[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIo request = {0};
+    IpcIoInit(&request, data, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteString(&request, pkgName);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write pkgName failed");
+        return SOFTBUS_IPC_ERR;
+    }
+
+    ret = WriteInt32(&request, publishId);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write publishId failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    /* asynchronous invocation */
+    int32_t ans = g_serverProxy->Invoke(g_serverProxy, SERVER_UNPUBLISH_SERVICE, &request, NULL, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "unpublish service invoke failed. ans=%{public}d", ans);
+        return ans;
+    }
+    return SOFTBUS_OK;
+}
+
+int ServerIpcStartDiscovery(const char *pkgName, const SubscribeInfo *info)
+{
+    DISC_LOGI(DISC_CONTROL, "start discovery ipc client push.");
+    if (pkgName == NULL || info == NULL) {
+        DISC_LOGE(DISC_SDK, "Invalid param:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (g_serverProxy == NULL) {
+        return SOFTBUS_NO_INIT;
+    }
+
+    uint8_t data[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIo request = {0};
+    IpcIoInit(&request, data, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteString(&request, pkgName);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write pkgName failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    DiscSerializer serializer = {
+        .dataLen = info->dataLen,
+        .freq = info->freq,
+        .medium = info->medium,
+        .mode = info->mode,
+        .id.subscribeId = info->subscribeId
+    };
+    SubscribeSerializer subscribeSerializer = {
+        .commonSerializer = serializer,
+        .isSameAccount = info->isSameAccount,
+        .isWakeRemote = info->isWakeRemote
+    };
+    ret = WriteRawData(&request, (void*)&subscribeSerializer, sizeof(SubscribeSerializer));
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write SubscribeSerializer failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    ret = WriteString(&request, info->capability);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write capability failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (info->dataLen != 0) {
+        ret = WriteString(&request, (const char *)(info->capabilityData));
+        if (!ret) {
+            DISC_LOGE(DISC_SDK, "Write capabilityData failed");
+            return SOFTBUS_IPC_ERR;
+        }
+    }
+    /* asynchronous invocation */
+    int32_t ans = g_serverProxy->Invoke(g_serverProxy, SERVER_START_DISCOVERY, &request, NULL, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "start discovery invoke failed. ans=%{public}d", ans);
+        return ans;
+    }
+    return SOFTBUS_OK;
+}
+
+int ServerIpcStopDiscovery(const char *pkgName, int subscribeId)
+{
+    DISC_LOGI(DISC_SDK, "stop discovery ipc client push.");
+    if (pkgName == NULL) {
+        DISC_LOGE(DISC_SDK, "Invalid param:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (g_serverProxy == NULL) {
+        return SOFTBUS_NO_INIT;
+    }
+
+    uint8_t data[MAX_SOFT_BUS_IPC_LEN] = {0};
+    IpcIo request = {0};
+    IpcIoInit(&request, data, MAX_SOFT_BUS_IPC_LEN, 0);
+    bool ret = WriteString(&request, pkgName);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write pkgName failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    ret = WriteInt32(&request, subscribeId);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "Write subscribeId failed");
+        return SOFTBUS_IPC_ERR;
+    }
+    /* asynchronous invocation */
+    int32_t ans = g_serverProxy->Invoke(g_serverProxy, SERVER_STOP_DISCOVERY, &request, NULL, NULL);
+    if (ans != SOFTBUS_OK) {
+        DISC_LOGE(DISC_CONTROL, "stop discovery invoke failed. ans=%{public}d", ans);
+        return ans;
+    }
+    return SOFTBUS_OK;
+}

sdk/discovery/ipc/standard/include/disc_server_proxy_standard.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021-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 INTERFACES_INNERKITS_DISC_SERVER_PROXY_STANDARD_H_
+#define INTERFACES_INNERKITS_DISC_SERVER_PROXY_STANDARD_H_
+
+#include "if_softbus_server.h"
+#include "softbus_common.h"
+
+namespace OHOS {
+class DiscServerProxy : public IRemoteProxy<ISoftBusServer> {
+public:
+    explicit DiscServerProxy(const sptr<IRemoteObject> &impl)
+        : IRemoteProxy<ISoftBusServer>(impl) {}
+    virtual ~DiscServerProxy() = default;
+
+    int32_t StartDiscovery(const char *pkgName, const SubscribeInfo *info) override;
+    int32_t StopDiscovery(const char *pkgName, int subscribeId) override;
+    int32_t PublishService(const char *pkgName, const PublishInfo *info) override;
+    int32_t UnPublishService(const char *pkgName, int publishId) override;
+    int32_t SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object) override;
+
+    int32_t CreateSessionServer(const char *pkgName, const char *sessionName) override;
+    int32_t RemoveSessionServer(const char *pkgName, const char *sessionName) override;
+    int32_t OpenSession(const SessionParam *param, TransInfo *info) override;
+    int32_t NotifyAuthSuccess(int32_t channelId, int32_t channelType) override;
+    int32_t OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo) override;
+    int32_t ReleaseResources(int32_t channelId) override;
+    int32_t CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) override;
+    int32_t CloseChannelWithStatistics(int32_t channelId, uint64_t laneId, const void *dataInfo,
+        uint32_t len) override;
+    int32_t SendMessage(int32_t channelId, int32_t channelType, const void *data,
+        uint32_t len, int32_t msgType) override;
+
+    int32_t JoinLNN(const char *pkgName, void *addr, uint32_t addrTypeLen) override;
+    int32_t LeaveLNN(const char *pkgName, const char *networkId) override;
+    int32_t GetAllOnlineNodeInfo(const char *pkgName, void **info, uint32_t infoTypeLen, int *infoNum) override;
+    int32_t GetLocalDeviceInfo(const char *pkgName, void *info, uint32_t infoTypeLen) override;
+    int32_t GetNodeKeyInfo(const char *pkgName, const char *networkId, int key, unsigned char *buf,
+        uint32_t len) override;
+    int32_t SetNodeDataChangeFlag(const char *pkgName, const char *networkId, uint16_t dataChangeFlag) override;
+    int32_t RegDataLevelChangeCb(const char *pkgName) override;
+    int32_t UnregDataLevelChangeCb(const char *pkgName) override;
+    int32_t SetDataLevel(const DataLevel *dataLevel) override;
+    int32_t StartTimeSync(const char *pkgName, const char *targetNetworkId, int32_t accuracy,
+        int32_t period) override;
+    int32_t StopTimeSync(const char *pkgName, const char *targetNetworkId) override;
+    int32_t QosReport(int32_t channelId, int32_t chanType, int32_t appType, int32_t quality) override;
+    int32_t StreamStats(int32_t channelId, int32_t channelType, const StreamSendStats *data) override;
+    int32_t RippleStats(int32_t channelId, int32_t channelType, const TrafficStats *data) override;
+    int32_t EvaluateQos(const char *peerNetworkId, TransDataType dataType, const QosTV *qos,
+        uint32_t qosCount) override;
+private:
+    static inline BrokerDelegator<DiscServerProxy> delegator_;
+};
+} // namespace OHOS
+
+#endif // !defined(INTERFACES_INNERKITS_DISC_SERVER_PROXY_STANDARD_H_)

sdk/discovery/ipc/standard/src/disc_server_proxy.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2021-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.
+ */
+
+#include "disc_server_proxy.h"
+#include "disc_server_proxy_standard.h"
+
+#include <mutex>
+#include "disc_log.h"
+#include "ipc_skeleton.h"
+#include "iremote_broker.h"
+#include "iremote_object.h"
+#include "iremote_proxy.h"
+#include "softbus_errcode.h"
+#include "softbus_server_ipc_interface_code.h"
+
+using namespace OHOS;
+
+namespace {
+sptr<DiscServerProxy> g_serverProxy = nullptr;
+const std::u16string SAMANAGER_INTERFACE_TOKEN = u"ohos.samgr.accessToken";
+uint32_t g_getSystemAbilityId = 2;
+std::mutex g_mutex;
+}
+
+static sptr<IRemoteObject> GetSystemAbility()
+{
+    MessageParcel data;
+
+    if (!data.WriteInterfaceToken(SAMANAGER_INTERFACE_TOKEN)) {
+        DISC_LOGE(DISC_SDK, "Write INTERFACE_TOKEN failed!");
+        return nullptr;
+    }
+    
+    if (!data.WriteInt32(SOFTBUS_SERVER_SA_ID_INNER)) {
+        DISC_LOGE(DISC_SDK, "Write SERVER_SA_ID_INNER failed!");
+        return nullptr;
+    }
+    MessageParcel reply;
+    MessageOption option;
+    sptr<IRemoteObject> samgr = IPCSkeleton::GetContextObject();
+    if (samgr == nullptr) {
+        DISC_LOGE(DISC_SDK, "Get samgr failed!");
+        return nullptr;
+    }
+    int32_t err = samgr->SendRequest(g_getSystemAbilityId, data, reply, option);
+    if (err != 0) {
+        DISC_LOGE(DISC_SDK, "Get GetSystemAbility failed!");
+        return nullptr;
+    }
+    return reply.ReadRemoteObject();
+}
+
+int32_t DiscServerProxyInit(void)
+{
+    std::lock_guard<std::mutex> lock(g_mutex);
+    if (g_serverProxy != nullptr) {
+        DISC_LOGI(DISC_INIT, "Init success");
+        return SOFTBUS_OK;
+    }
+    sptr<IRemoteObject> object = GetSystemAbility();
+    if (object == nullptr) {
+        DISC_LOGE(DISC_INIT, "Get remote softbus object failed!");
+        return SOFTBUS_DISCOVER_GET_REMOTE_FAILED;
+    }
+    g_serverProxy = new (std::nothrow) DiscServerProxy(object);
+    if (g_serverProxy == nullptr) {
+        DISC_LOGE(DISC_INIT, "Create disc server proxy failed!");
+        return SOFTBUS_NO_INIT;
+    }
+    return SOFTBUS_OK;
+}
+
+void DiscServerProxyDeInit(void)
+{
+    g_serverProxy.clear();
+}
+
+int32_t ServerIpcPublishService(const char *pkgName, const PublishInfo *info)
+{
+    if (g_serverProxy == nullptr) {
+        DISC_LOGE(DISC_SDK, "softbus server g_serverProxy is nullptr!");
+        return SOFTBUS_NO_INIT;
+    }
+    return g_serverProxy->PublishService(pkgName, info);
+}
+
+int32_t ServerIpcUnPublishService(const char *pkgName, int32_t publishId)
+{
+    if (g_serverProxy == nullptr) {
+        DISC_LOGE(DISC_SDK, "softbus server g_serverProxy is nullptr!");
+        return SOFTBUS_NO_INIT;
+    }
+    int ret = g_serverProxy->UnPublishService(pkgName, publishId);
+    return ret;
+}
+
+int32_t ServerIpcStartDiscovery(const char *pkgName, const SubscribeInfo *info)
+{
+    if (g_serverProxy == nullptr) {
+        DISC_LOGE(DISC_SDK, "softbus server g_serverProxy is nullptr!");
+        return SOFTBUS_NO_INIT;
+    }
+    return g_serverProxy->StartDiscovery(pkgName, info);
+}
+
+int32_t ServerIpcStopDiscovery(const char *pkgName, int32_t subscribeId)
+{
+    if (g_serverProxy == nullptr) {
+        DISC_LOGE(DISC_SDK, "softbus server g_serverProxy is nullptr!");
+        return SOFTBUS_NO_INIT;
+    }
+    return g_serverProxy->StopDiscovery(pkgName, subscribeId);
+}

sdk/discovery/ipc/standard/src/disc_server_proxy_standard.cpp

@@ -0,0 +1,459 @@
+/*
+ * Copyright (c) 2021-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 "disc_server_proxy_standard.h"
+
+#include "ipc_skeleton.h"
+#include "disc_log.h"
+#include "discovery_service.h"
+#include "message_parcel.h"
+#include "softbus_errcode.h"
+#include "softbus_server_ipc_interface_code.h"
+
+namespace OHOS {
+static uint32_t g_getSystemAbilityId = 2;
+const std::u16string SAMANAGER_INTERFACE_TOKEN = u"ohos.samgr.accessToken";
+static sptr<IRemoteObject> GetSystemAbility()
+{
+    MessageParcel data;
+
+    if (!data.WriteInterfaceToken(SAMANAGER_INTERFACE_TOKEN)) {
+        DISC_LOGE(DISC_SDK, "Write Interface token failed!");
+        return nullptr;
+    }
+    if (!data.WriteInt32(SOFTBUS_SERVER_SA_ID_INNER)) {
+        DISC_LOGE(DISC_SDK, "Write inner failed!");
+        return nullptr;
+    }
+    MessageParcel reply;
+    MessageOption option;
+    sptr<IRemoteObject> samgr = IPCSkeleton::GetContextObject();
+    if (samgr == nullptr) {
+        DISC_LOGE(DISC_SDK, "samgr failed!");
+        return nullptr;
+    }
+    int32_t err = samgr->SendRequest(g_getSystemAbilityId, data, reply, option);
+    if (err != 0) {
+        DISC_LOGE(DISC_SDK, "GetSystemAbility failed!");
+        return nullptr;
+    }
+    return reply.ReadRemoteObject();
+}
+
+int32_t DiscServerProxy::StartDiscovery(const char *pkgName, const SubscribeInfo *subInfo)
+{
+    sptr<IRemoteObject> remote = GetSystemAbility();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_ABILITY, "remote is nullptr!");
+        return SOFTBUS_DISCOVER_GET_REMOTE_FAILED;
+    }
+
+    MessageParcel data;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery faceToken failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteCString(pkgName)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery pkgName failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(subInfo->subscribeId)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo subscribeId failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(subInfo->mode)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo mode failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(subInfo->medium)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo medium failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(subInfo->freq)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo freq failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteBool(subInfo->isSameAccount)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo isSameAccount failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteBool(subInfo->isWakeRemote)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo isWakeRemote failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteCString(subInfo->capability)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo capability failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteUint32(subInfo->dataLen)) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery subInfo dataLen failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (subInfo->dataLen != 0) {
+        data.WriteCString((char *)subInfo->capabilityData);
+    }
+    MessageParcel reply;
+    MessageOption option;
+    int32_t err = remote->SendRequest(SERVER_START_DISCOVERY, data, reply, option);
+    if (err != 0) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery send request failed!");
+        return err;
+    }
+    int32_t serverRet = 0;
+    int32_t ret = reply.ReadInt32(serverRet);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "StartDiscovery read serverRet failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    return serverRet;
+}
+
+int32_t DiscServerProxy::StopDiscovery(const char *pkgName, int subscribeId)
+{
+    sptr<IRemoteObject> remote = GetSystemAbility();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_ABILITY, "remote is nullptr!");
+        return SOFTBUS_DISCOVER_GET_REMOTE_FAILED;
+    }
+
+    MessageParcel data;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        DISC_LOGE(DISC_SDK, "StopDiscovery failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteCString(pkgName)) {
+        DISC_LOGE(DISC_SDK, "StopDiscovery pkgName failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(subscribeId)) {
+        DISC_LOGE(DISC_SDK, "StopDiscovery subscribeId failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+
+    MessageParcel reply;
+    MessageOption option;
+    int32_t err = remote->SendRequest(SERVER_STOP_DISCOVERY, data, reply, option);
+    DISC_LOGI(DISC_ABILITY, "StopDiscovery send request ret=%{public}d!", err);
+    if (err != 0) {
+        DISC_LOGE(DISC_SDK, "StopDiscovery send request failed!");
+        return err;
+    }
+    int32_t serverRet = 0;
+    int32_t ret = reply.ReadInt32(serverRet);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "StopDiscovery read serverRet failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    return serverRet;
+}
+
+int32_t DiscServerProxy::PublishService(const char *pkgName, const PublishInfo *pubInfo)
+{
+    sptr<IRemoteObject> remote = GetSystemAbility();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_ABILITY, "remote is nullptr!");
+        return SOFTBUS_DISCOVER_GET_REMOTE_FAILED;
+    }
+
+    MessageParcel data;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        DISC_LOGE(DISC_SDK, "PublishService write InterfaceToken failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteCString(pkgName)) {
+        DISC_LOGE(DISC_SDK, "PublishService write pkgName failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(pubInfo->publishId)) {
+        DISC_LOGE(DISC_SDK, "PublishService write publishId failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(pubInfo->mode)) {
+        DISC_LOGE(DISC_SDK, "PublishService write mode failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(pubInfo->medium)) {
+        DISC_LOGE(DISC_SDK, "PublishService write medium failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(pubInfo->freq)) {
+        DISC_LOGE(DISC_SDK, "PublishService write freq failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteCString(pubInfo->capability)) {
+        DISC_LOGE(DISC_SDK, "PublishService write capability failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteUint32(pubInfo->dataLen)) {
+        DISC_LOGE(DISC_SDK, "PublishService write dataLen failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (pubInfo->dataLen != 0) {
+        data.WriteCString((char *)pubInfo->capabilityData);
+    }
+    MessageParcel reply;
+    MessageOption option;
+    int32_t err = remote->SendRequest(SERVER_PUBLISH_SERVICE, data, reply, option);
+    DISC_LOGI(DISC_ABILITY, "PublishService send request ret=%{public}d!", err);
+    if (err != 0) {
+        DISC_LOGE(DISC_SDK, "PublishService send request failed!");
+        return err;
+    }
+    int32_t serverRet = 0;
+    int32_t ret = reply.ReadInt32(serverRet);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "PublishService read serverRet failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    return serverRet;
+}
+
+int32_t DiscServerProxy::UnPublishService(const char *pkgName, int publishId)
+{
+    sptr<IRemoteObject> remote = GetSystemAbility();
+    if (remote == nullptr) {
+        DISC_LOGE(DISC_ABILITY, "remote is nullptr!");
+        return SOFTBUS_DISCOVER_GET_REMOTE_FAILED;
+    }
+
+    MessageParcel data;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        DISC_LOGE(DISC_SDK, "UnPublishService failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteCString(pkgName)) {
+        DISC_LOGE(DISC_SDK, "UnPublishService pkgName failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    if (!data.WriteInt32(publishId)) {
+        DISC_LOGE(DISC_SDK, "UnPublishService publishId failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+
+    MessageParcel reply;
+    MessageOption option;
+    int32_t err = remote->SendRequest(SERVER_UNPUBLISH_SERVICE, data, reply, option);
+    DISC_LOGI(DISC_SDK, "UnPublishService send request ret=%{public}d!", err);
+    if (err != 0) {
+        DISC_LOGE(DISC_SDK, "UnPublishService send request failed!");
+        return err;
+    }
+    int32_t serverRet = 0;
+    int32_t ret = reply.ReadInt32(serverRet);
+    if (!ret) {
+        DISC_LOGE(DISC_SDK, "UnPublishService read serverRet failed!");
+        return SOFTBUS_IPC_ERR;
+    }
+    return serverRet;
+}
+
+int32_t DiscServerProxy::SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject>& object)
+{
+    (void)clientPkgName;
+    (void)object;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::CreateSessionServer(const char *pkgName, const char *sessionName)
+{
+    (void)pkgName;
+    (void)sessionName;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::RemoveSessionServer(const char *pkgName, const char *sessionName)
+{
+    (void)pkgName;
+    (void)sessionName;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::OpenSession(const SessionParam *param, TransInfo *info)
+{
+    (void)param;
+    (void)info;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo)
+{
+    (void)sessionName;
+    (void)addrInfo;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::NotifyAuthSuccess(int32_t channelId, int32_t channelType)
+{
+    (void)channelId;
+    (void)channelType;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::ReleaseResources(int32_t channelId)
+{
+    (void)channelId;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType)
+{
+    (void)sessionName;
+    (void)channelId;
+    (void)channelType;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::CloseChannelWithStatistics(int32_t channelId, uint64_t laneId, const void *dataInfo,
+    uint32_t len)
+{
+    (void)channelId;
+    (void)laneId;
+    (void)dataInfo;
+    (void)len;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::SendMessage(int32_t channelId, int32_t channelType, const void *data,
+    uint32_t len, int32_t msgType)
+{
+    (void)channelId;
+    (void)channelType;
+    (void)data;
+    (void)len;
+    (void)msgType;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::JoinLNN(const char *pkgName, void *addr, uint32_t addrTypeLen)
+{
+    (void)pkgName;
+    (void)addr;
+    (void)addrTypeLen;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::LeaveLNN(const char *pkgName, const char *networkId)
+{
+    (void)pkgName;
+    (void)networkId;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::GetAllOnlineNodeInfo(const char *pkgName, void **info, uint32_t infoTypeLen, int *infoNum)
+{
+    (void)pkgName;
+    (void)info;
+    (void)infoTypeLen;
+    (void)infoNum;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::GetLocalDeviceInfo(const char *pkgName, void *info, uint32_t infoTypeLen)
+{
+    (void)pkgName;
+    (void)info;
+    (void)infoTypeLen;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::GetNodeKeyInfo(const char *pkgName, const char *networkId, int key, unsigned char *buf,
+    uint32_t len)
+{
+    (void)pkgName;
+    (void)networkId;
+    (void)key;
+    (void)buf;
+    (void)len;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::SetNodeDataChangeFlag(const char *pkgName, const char *networkId, uint16_t dataChangeFlag)
+{
+    (void)pkgName;
+    (void)networkId;
+    (void)dataChangeFlag;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::RegDataLevelChangeCb(const char *pkgName)
+{
+    (void)pkgName;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::UnregDataLevelChangeCb(const char *pkgName)
+{
+    (void)pkgName;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::SetDataLevel(const DataLevel *dataLevel)
+{
+    (void)dataLevel;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::StartTimeSync(const char *pkgName, const char *targetNetworkId, int32_t accuracy,
+    int32_t period)
+{
+    (void)pkgName;
+    (void)targetNetworkId;
+    (void)accuracy;
+    (void)period;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::StopTimeSync(const char *pkgName, const char *targetNetworkId)
+{
+    (void)pkgName;
+    (void)targetNetworkId;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::QosReport(int32_t channelId, int32_t chanType, int32_t appType, int32_t quality)
+{
+    (void)channelId;
+    (void)chanType;
+    (void)appType;
+    (void)quality;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::StreamStats(int32_t channelId, int32_t channelType, const StreamSendStats *data)
+{
+    (void)channelId;
+    (void)channelType;
+    (void)data;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::RippleStats(int32_t channelId, int32_t channelType, const TrafficStats *data)
+{
+    (void)channelId;
+    (void)channelType;
+    (void)data;
+    return SOFTBUS_OK;
+}
+
+int32_t DiscServerProxy::EvaluateQos(const char *peerNetworkId, TransDataType dataType, const QosTV *qos,
+    uint32_t qosCount)
+{
+    (void)peerNetworkId;
+    (void)dataType;
+    (void)qos;
+    (void)qosCount;
+    return SOFTBUS_OK;
+}
+} // namespace OHOS

sdk/discovery/manager/include/client_disc_manager.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2021-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 SOFTBUS_CLIENT_DISC_MANAGER_H
+#define SOFTBUS_CLIENT_DISC_MANAGER_H
+
+#include "discovery_service.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Client initialization. Configure the storage information environment,
+ * this interface is only called once when the softbus service is created.
+ * @see {@link DiscClientDeinit}
+ * @return <b>SOFTBUS_MALLOC_ERR</b> Failed to allocate space for global variable of discovery information.
+ * @return <b>SOFTBUS_DISC_SERVER_INIT_FAILED</b> Failed to initialize the server agent on the discovery side.
+ * @return <b>SOFTBUS_OK</b> The discoverer client was initialized successfully.
+ */
+int32_t DiscClientInit(void);
+
+/**
+ * @brief The client deinitializes, releasing the stored information.
+ * This interface is only called once when the softbus service is destroyed.
+ * @see {@link DiscClientInit}
+ */
+void DiscClientDeinit(void);
+
+/**
+ * @brief Internal publishing service. Publish its own capability information to other devices,
+ * and other devices can capture this information to establish connections.
+ * @see {@link UnPublishServiceInner}
+ * @param[in] packageName Indicates the pointer to the package name,
+ * and the name of the relevant package carrying its own capabilities.
+ * @param[in] info Indicates the pointer to the published information,
+ * which is used to publish the information body of its own information. For details, see {@link PublishInfo}.
+ * @param[in] cb Indicates the pointer to the callback of the publishing function,
+ * which is used to notify itself whether the publishing of its
+ * own information is successful after the publishing function is triggered. For details, see {@link IPublishCallback}.
+ * @return <b>SOFTBUS_NO_INIT</b> Failed to publish internal information function.
+ * @return <b>SOFTBUS_OK</b> The function of internal publishing self information was published successfully.
+ */
+int32_t PublishServiceInner(const char *packageName, const PublishInfo *info, const IPublishCallback *cb);
+
+/**
+ * @brief Internal unpublish service. Stop publishing its own information,
+ * and external devices cannot capture this device's capability information.
+ * @see {@link PublishServiceInner}
+ * @param[in] packageName Indicates the pointer to the package name,
+ * and the name of the relevant package carrying its own capabilities.
+ * @param[in] publishId ID of the internal release information to be cancelled this time.
+ * @return <b>SOFTBUS_NO_INIT</b> Internal unpublishing function failed. Other devices can still find the device.
+ * @return <b>SOFTBUS_OK</b> The internal unpublishing function is successful,
+ * and the party cannot publish its own information.
+ */
+int32_t UnpublishServiceInner(const char *packageName, int32_t publishId);
+
+/**
+ * @brief Internal discovery service. Other devices can be discovered.
+ * @see {@link StopDiscoveryInner}
+ * @param[in] packageName Indicates the pointer to the package name,
+ * and the name of the relevant package carrying its own capabilities.
+ * @param[in] info Indicates a pointer to published information used
+ * to discover the body of information for a specific capability. For more information, see {@link SubscribeInfo}.
+ * @param[in] cb Indicates the pointer to the discovery callback, It is used to inform yourself,
+ * Whether the discovery capability is successfully started after the discovery function is triggered.
+ * For more information, see {@link IDiscoveryCallback}.
+ * @return <b>SOFTBUS_NO_INIT</b> The internal start Discovery Function failed to start. No other devices can be found.
+ * @return <b>SOFTBUS_OK</b> The internal start discovery function is started successfully.
+ * You can discover specific capability devices.
+ */
+int32_t StartDiscoveryInner(const char *packageName, const SubscribeInfo *info, const IDiscoveryCallback *cb);
+
+/**
+ * @brief Stop discovery service internally. Stop discovering other devices,
+ * after which other devices cannot be discovered.
+ * @see {@link StartDiscoveryInner}
+ * @param[in] packageName Indicates the pointer to the package name,
+ * and the name of the relevant package carrying its own capabilities.
+ * @param[in] subscribeId ID to stop discovery this time.
+ * @return <b>SOFTBUS_NO_INIT</b> The internal stop discovery function cannot be started.
+ * Other devices can still be found.
+ * @return <b>SOFTBUS_OK</b> Internal stop discovery function started successfully.
+ * You cannot discover devices with specific functions.
+ */
+int32_t StopDiscoveryInner(const char *packageName, int32_t subscribeId);
+
+/**
+ * @brief The server discovers the local device and calls this callback.
+ * @see {@link DiscClientOnDiscoverySuccess} or {@link DiscClientOnDiscoverFailed}.
+ * @param[in] device Indicates a pointer to device information to record the devices on
+ * which the discovery client was discovered. For more information, see {@link DeviceInfo}.
+ */
+void DiscClientOnDeviceFound(const DeviceInfo *device);
+
+/**
+ * @brief When the server subscribes to the local device successfully,
+ * this callback is called to notify the local device.
+ * @see {@link DiscClientOnDeviceFound} or {@link DiscClientOnDiscoverFailed}.
+ * @param[in] subscribeId The id of the subscription information used to record
+ * the successful discovery of the discovered peer.
+ */
+void DiscClientOnDiscoverySuccess(int32_t subscribeId);
+
+/**
+ * @brief When the server fails to subscribe to the local device, this callback is called to notify the local device.
+ * @see {@link DiscClientOnDiscoverySuccess} or {@link DiscClientOnDeviceFound}.
+ * @param[in] subscribeId The id of the subscription information used to record the discovered peer discovery failure.
+ * @param[in] failReason reason of failure. For more information, see {@link DiscoveryFailReason}.
+ */
+void DiscClientOnDiscoverFailed(int32_t subscribeId, DiscoveryFailReason failReason);
+
+/**
+ * @brief The local end publishes the service successfully, and the callback is called to notify the local end.
+ * @see {@link DiscClientOnPublishFail}.
+ * @param[in] publishId The information id used for the client to publish successfully.
+ */
+void DiscClientOnPublishSuccess(int32_t publishId);
+
+/**
+ * @brief The local end fails to publish the service, and this callback is called to notify the local end.
+ * @see {@link DiscClientOnPublishSuccess}.
+ * @param[in] publishId The information id used for the client to publish failed.
+ * @param[in] reason reason of failure. For more information, see {@link PublishFailReason}.
+ */
+void DiscClientOnPublishFail(int32_t publishId, PublishFailReason reason);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SOFTBUS_CLIENT_DISC_MANAGER_H

sdk/discovery/manager/src/client_disc_manager.c

@@ -0,0 +1,166 @@
+/*
+ * 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.
+ */
+
+#include "client_disc_manager.h"
+
+#include "disc_log.h"
+#include "disc_server_proxy.h"
+#include "softbus_adapter_mem.h"
+#include "softbus_errcode.h"
+
+typedef struct {
+    IPublishCallback publishCb;
+    IDiscoveryCallback subscribeCb;
+} DiscInfo;
+
+static DiscInfo *g_discInfo = NULL;
+
+int32_t PublishServiceInner(const char *packageName, const PublishInfo *info, const IPublishCallback *cb)
+{
+    g_discInfo->publishCb = *cb;
+
+    int32_t ret = ServerIpcPublishService(packageName, info);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_SDK, "Server PublishService failed, ret=%{public}d", ret);
+        return ret;
+    }
+
+    return SOFTBUS_OK;
+}
+
+int32_t UnpublishServiceInner(const char *packageName, int32_t publishId)
+{
+    int32_t ret = ServerIpcUnPublishService(packageName, publishId);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_SDK, "Server UnPublishService failed, ret=%{public}d", ret);
+        return ret;
+    }
+
+    return SOFTBUS_OK;
+}
+
+int32_t StartDiscoveryInner(const char *packageName, const SubscribeInfo *info, const IDiscoveryCallback *cb)
+{
+    if (packageName == NULL || info == NULL || cb == NULL) {
+        DISC_LOGE(DISC_SDK, "invalid parameter:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    g_discInfo->subscribeCb = *cb;
+    int32_t ret = ServerIpcStartDiscovery(packageName, info);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_SDK, "Server StartDiscovery failed, ret=%{public}d", ret);
+        return ret;
+    }
+
+    return SOFTBUS_OK;
+}
+
+int32_t StopDiscoveryInner(const char *packageName, int32_t subscribeId)
+{
+    int32_t ret = ServerIpcStopDiscovery(packageName, subscribeId);
+    if (ret != SOFTBUS_OK) {
+        DISC_LOGE(DISC_SDK, "Server StopDiscovery failed, ret=%{public}d", ret);
+        return ret;
+    }
+
+    return SOFTBUS_OK;
+}
+
+int32_t DiscClientInit(void)
+{
+    if (g_discInfo != NULL) {
+        SoftBusFree(g_discInfo);
+        g_discInfo = NULL;
+    }
+    g_discInfo = (DiscInfo *)SoftBusCalloc(sizeof(DiscInfo));
+    if (g_discInfo == NULL) {
+        DISC_LOGE(DISC_INIT, "Calloc failed");
+        return SOFTBUS_MALLOC_ERR;
+    }
+    if (DiscServerProxyInit() != SOFTBUS_OK) {
+        DISC_LOGE(DISC_INIT, "disc server proxy init failed.");
+        SoftBusFree(g_discInfo);
+        g_discInfo = NULL;
+        return SOFTBUS_DISC_SERVER_INIT_FAILED;
+    }
+    DISC_LOGI(DISC_INIT, "Init success as client side");
+    return SOFTBUS_OK;
+}
+
+void DiscClientDeinit(void)
+{
+    if (g_discInfo == NULL) {
+        return;
+    }
+    SoftBusFree(g_discInfo);
+    g_discInfo = NULL;
+    DiscServerProxyDeInit();
+    DISC_LOGI(DISC_CONTROL, "DeInit success");
+}
+
+void DiscClientOnDeviceFound(const DeviceInfo *device)
+{
+    if (device == NULL) {
+        DISC_LOGE(DISC_SDK, "invalid parameter:null");
+        return;
+    }   
+    DISC_LOGI(DISC_SDK, "Sdk OnDeviceFound, capabilityBitmap=%{public}d",
+        device->capabilityBitmap[0]);
+    if (g_discInfo == NULL) {
+        DISC_LOGE(DISC_SDK, "OnDeviceFound callback failed!");
+        return;
+    }
+    g_discInfo->subscribeCb.OnDeviceFound(device);
+}
+
+void DiscClientOnDiscoverySuccess(int32_t subscribeId)
+{
+    DISC_LOGI(DISC_SDK, "Sdk OnDiscoverySuccess, subscribeId=%{public}d", subscribeId);
+    if (g_discInfo == NULL) {
+        DISC_LOGE(DISC_SDK, "OnDiscoverySuccess callback failed!");
+        return;
+    }
+    g_discInfo->subscribeCb.OnDiscoverySuccess(subscribeId);
+}
+
+void DiscClientOnDiscoverFailed(int32_t subscribeId, DiscoveryFailReason failReason)
+{
+    DISC_LOGI(DISC_SDK, "Sdk OnDiscoverFailed, subscribeId=%{public}d", subscribeId);
+    if (g_discInfo == NULL) {
+        DISC_LOGE(DISC_SDK, "OnDiscoverFailed callback failed!");
+        return;
+    }
+    g_discInfo->subscribeCb.OnDiscoverFailed(subscribeId, failReason);
+}
+
+void DiscClientOnPublishSuccess(int32_t publishId)
+{
+    DISC_LOGI(DISC_SDK, "Sdk OnPublishSuccess, publishId=%{public}d", publishId);
+    if (g_discInfo == NULL) {
+        DISC_LOGE(DISC_SDK, "OnPublishSuccess callback failed!");
+        return;
+    }
+    g_discInfo->publishCb.OnPublishSuccess(publishId);
+}
+
+void DiscClientOnPublishFail(int32_t publishId, PublishFailReason reason)
+{
+    DISC_LOGI(DISC_SDK, "Sdk OnPublishFail, publishId=%{public}d", publishId);
+    if (g_discInfo == NULL) {
+        DISC_LOGE(DISC_SDK, "OnPublishFail callback failed!");
+        return;
+    }
+    g_discInfo->publishCb.OnPublishFail(publishId, reason);
+}

sdk/discovery/service/include/client_disc_service.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2021 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 CLIENT_DISC_SERVICE_H
+#define CLIENT_DISC_SERVICE_H
+
+#include "discovery_service.h"
+#ifdef __cplusplus
+#endif
+#endif // CLIENT_DISC_SERVICE_H

sdk/discovery/service/src/client_disc_service.c

@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2021-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.
+ */
+
+#include "client_disc_service.h"
+
+#include <securec.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "client_disc_manager.h"
+#include "disc_event.h"
+#include "disc_log.h"
+#include "softbus_adapter_mem.h"
+#include "softbus_client_frame_manager.h"
+#include "softbus_def.h"
+#include "softbus_errcode.h"
+#include "softbus_utils.h"
+
+static int32_t PublishInfoCheck(const PublishInfo *info)
+{
+    if ((info->mode != DISCOVER_MODE_PASSIVE) && (info->mode != DISCOVER_MODE_ACTIVE)) {
+        DISC_LOGE(DISC_SDK, "mode is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if ((info->medium < AUTO) || (info->medium > COAP)) {
+        DISC_LOGE(DISC_SDK, "medium is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if ((info->freq < LOW) || (info->freq >= FREQ_BUTT)) {
+        DISC_LOGE(DISC_SDK, "freq is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if ((info->capabilityData == NULL) && (info->dataLen != 0)) {
+        DISC_LOGE(DISC_SDK, "data is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if (info->dataLen == 0) {
+        return SOFTBUS_OK;
+    }
+
+    if ((info->dataLen > MAX_CAPABILITYDATA_LEN) ||
+        (strlen((char *)(info->capabilityData)) >= MAX_CAPABILITYDATA_LEN)) {
+        DISC_LOGE(DISC_SDK, "data exceeds the maximum length");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    return SOFTBUS_OK;
+}
+
+static int32_t SubscribeInfoCheck(const SubscribeInfo *info)
+{
+    if ((info->mode != DISCOVER_MODE_PASSIVE) && (info->mode != DISCOVER_MODE_ACTIVE)) {
+        DISC_LOGE(DISC_SDK, "mode is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if ((info->medium < AUTO) || (info->medium > COAP)) {
+        DISC_LOGE(DISC_SDK, "medium is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if ((info->freq < LOW) || (info->freq >= FREQ_BUTT)) {
+        DISC_LOGE(DISC_SDK, "freq is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if ((info->capabilityData == NULL) && (info->dataLen != 0)) {
+        DISC_LOGE(DISC_SDK, "data is invalid");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if (info->dataLen == 0) {
+        return SOFTBUS_OK;
+    }
+
+    if ((info->dataLen > MAX_CAPABILITYDATA_LEN) ||
+        (strlen((char *)(info->capabilityData)) >= MAX_CAPABILITYDATA_LEN)) {
+        DISC_LOGE(DISC_SDK, "data exceeds the maximum length");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    return SOFTBUS_OK;
+}
+
+static void DfxRecordDiscServerEnd(int32_t serverType, int32_t reason, const char *packageName)
+{
+    if (reason == SOFTBUS_OK) {
+        return;
+    }
+    DiscEventExtra extra = { 0 };
+    DiscEventExtraInit(&extra);
+    extra.serverType = serverType;
+    extra.errcode = reason;
+    extra.result = EVENT_STAGE_RESULT_FAILED;
+
+    char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
+    if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
+        PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
+        extra.callerPkg = pkgName;
+    }
+    DISC_EVENT(EVENT_SCENE_DISC, EVENT_STAGE_DISC_SDK, extra);
+}
+
+int PublishService(const char *packageName, const PublishInfo *info, const IPublishCallback *cb)
+{
+    if ((packageName == NULL) || (strlen(packageName) >= PKG_NAME_SIZE_MAX) || (info == NULL) || (cb == NULL)) {
+        DfxRecordDiscServerEnd(SERVER_PUBLISH, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "invalid parameter:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if (InitSoftBus(packageName) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_PUBLISH, SOFTBUS_DISCOVER_NOT_INIT, packageName);
+        DISC_LOGE(DISC_SDK, "init softbus err");
+        return SOFTBUS_DISCOVER_NOT_INIT;
+    }
+
+    if (CheckPackageName(packageName) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_PUBLISH, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "check packageName failed");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if (PublishInfoCheck(info) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_PUBLISH, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "publish infoCheck failed");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t ret = PublishServiceInner(packageName, info, cb);
+    DfxRecordDiscServerEnd(SERVER_PUBLISH, ret, packageName);
+    return ret;
+}
+
+int UnPublishService(const char *packageName, int publishId)
+{
+    if ((packageName == NULL) || (strlen(packageName) >= PKG_NAME_SIZE_MAX)) {
+        DfxRecordDiscServerEnd(SERVER_STOP_PUBLISH, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "invalid packageName");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if (CheckPackageName(packageName) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_STOP_PUBLISH, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "check packageName failed");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t ret = UnpublishServiceInner(packageName, publishId);
+    DfxRecordDiscServerEnd(SERVER_STOP_PUBLISH, ret, packageName);
+    return ret;
+}
+
+int StartDiscovery(const char *packageName, const SubscribeInfo *info, const IDiscoveryCallback *cb)
+{
+    if ((packageName == NULL) || (strlen(packageName) >= PKG_NAME_SIZE_MAX) || (info == NULL) || (cb == NULL)) {
+        DfxRecordDiscServerEnd(SERVER_DISCOVERY, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, " invalid parameter:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (InitSoftBus(packageName) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_DISCOVERY, SOFTBUS_DISCOVER_NOT_INIT, packageName);
+        DISC_LOGE(DISC_SDK, "init softbus err");
+        return SOFTBUS_DISCOVER_NOT_INIT;
+    }
+    if (CheckPackageName(packageName) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_DISCOVERY, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "check packageName failed");
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (SubscribeInfoCheck(info) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_DISCOVERY, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "subscribe infoCheck failed");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t ret = StartDiscoveryInner(packageName, info, cb);
+    DfxRecordDiscServerEnd(SERVER_DISCOVERY, ret, packageName);
+    return ret;
+}
+
+int StopDiscovery(const char *packageName, int subscribeId)
+{
+    if ((packageName == NULL) || (strlen(packageName) >= PKG_NAME_SIZE_MAX)) {
+        DfxRecordDiscServerEnd(SERVER_STOP_DISCOVERY, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "invalid packageName:null");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    if (CheckPackageName(packageName) != SOFTBUS_OK) {
+        DfxRecordDiscServerEnd(SERVER_STOP_DISCOVERY, SOFTBUS_INVALID_PARAM, packageName);
+        DISC_LOGE(DISC_SDK, "check packageName failed");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t ret = StopDiscoveryInner(packageName, subscribeId);
+    DfxRecordDiscServerEnd(SERVER_STOP_DISCOVERY, ret, packageName);
+    return ret;
+}

sdk/frame/common/src/softbus_client_frame_manager.c

@@ -19,6 +19,7 @@
 #include <string.h>
 
 #include "client_bus_center_manager.h"
+#include "client_disc_manager.h"
 #include "client_trans_session_manager.h"
 #include "client_trans_socket_manager.h"
 #include "comm_log.h"
@@ -156,6 +157,7 @@ static void ClientModuleDeinit(void)
     BusCenterClientDeinit();
     TransClientDeinit();
     ConnClientDeinit();
+    DiscClientDeinit();
 }
 
 static int32_t ConnClientInit(void)
@@ -188,6 +190,11 @@ static int32_t ClientModuleInit(void)
         goto ERR_EXIT;
     }
 
+    if (DiscClientInit() != SOFTBUS_OK) {
+        COMM_LOGE(COMM_SDK, "init service manager failed");
+        goto ERR_EXIT;
+    }
+
     if (ConnClientInit() != SOFTBUS_OK) {
         COMM_LOGE(COMM_SDK, "init connect manager failed");
         goto ERR_EXIT;

sdk/frame/frame_sdk.gni

@@ -34,6 +34,7 @@ if (defined(ohos_lite)) {
       "$dsoftbus_root_path/sdk/frame/common/src/softbus_client_event_manager.c",
       "$dsoftbus_root_path/sdk/frame/common/src/softbus_client_frame_manager.c",
       "$dsoftbus_root_path/sdk/frame/small/src/bus_center_client_stub.c",
+      "$dsoftbus_root_path/sdk/frame/small/src/disc_client_stub.c",
       "$dsoftbus_root_path/sdk/frame/small/src/softbus_client_context_manager.c",
       "$dsoftbus_root_path/sdk/frame/small/src/softbus_client_stub.c",
       "$dsoftbus_root_path/sdk/frame/small/src/softbus_server_proxy.c",

sdk/frame/small/include/disc_client_stub.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2021 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 DISC_CLIENT_STUB_H
+#define DISC_CLIENT_STUB_H
+
+#include "serializer.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+extern "C" {
+#endif
+#endif
+
+int32_t ClientOnDiscoverySuccess(IpcIo *data, IpcIo *reply);
+int32_t ClientOnDiscoverFailed(IpcIo *data, IpcIo *reply);
+int32_t ClientOnDeviceFound(IpcIo *data, IpcIo *reply);
+int32_t ClientOnPublishSuccess(IpcIo *data, IpcIo *reply);
+int32_t ClientOnPublishFail(IpcIo *data, IpcIo *reply);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif // !DISC_CLIENT_STUB_H

sdk/frame/small/src/disc_client_stub.c

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2021 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 "disc_client_stub.h"
+
+#include "client_disc_manager.h"
+#include "disc_log.h"
+#include "ipc_skeleton.h"
+#include "softbus_errcode.h"
+
+int32_t ClientOnDiscoverySuccess(IpcIo *data, IpcIo *reply)
+{
+    if (data == NULL) {
+        DISC_LOGW(DISC_CONTROL, "invalid param.");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t subscribeId = 0;
+    ReadInt32(data, &subscribeId);
+    DiscClientOnDiscoverySuccess(subscribeId);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientOnDiscoverFailed(IpcIo *data, IpcIo *reply)
+{
+    if (data == NULL) {
+        DISC_LOGW(DISC_CONTROL, "invalid param.");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t subscribeId = 0;
+    int32_t failReason = 0;
+    ReadInt32(data, &subscribeId);
+    ReadInt32(data, &failReason);
+    DiscClientOnDiscoverFailed(subscribeId, failReason);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientOnDeviceFound(IpcIo *data, IpcIo *reply)
+{
+    if (data == NULL) {
+        DISC_LOGW(DISC_CONTROL, "invalid param.");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    const DeviceInfo *deviceInfo = (const DeviceInfo*)ReadRawData(reply, sizeof(DeviceInfo));
+    if (deviceInfo == NULL) {
+        return SOFTBUS_ERR;
+    }
+    DiscClientOnDeviceFound(deviceInfo);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientOnPublishSuccess(IpcIo *data, IpcIo *reply)
+{
+    if (data == NULL) {
+        DISC_LOGW(DISC_CONTROL, "invalid param.");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t publishId = 0;
+    ReadInt32(data, &publishId);
+    DiscClientOnPublishSuccess(publishId);
+    return SOFTBUS_OK;
+}
+
+int32_t ClientOnPublishFail(IpcIo *data, IpcIo *reply)
+{
+    if (data == NULL) {
+        DISC_LOGW(DISC_CONTROL, "invalid param.");
+        return SOFTBUS_INVALID_PARAM;
+    }
+
+    int32_t publishId = 0;
+    int32_t failReason = 0;
+    ReadInt32(data, &publishId);
+    ReadInt32(data, &failReason);
+    DiscClientOnPublishFail(publishId, failReason);
+    return SOFTBUS_OK;
+}

sdk/frame/small/src/softbus_client_stub.c

@@ -15,6 +15,7 @@
 
 #include "bus_center_client_stub.h"
 #include "comm_log.h"
+#include "disc_client_stub.h"
 #include "iproxy_client.h"
 #include "ipc_skeleton.h"
 #include "softbus_adapter_mem.h"
@@ -41,6 +42,11 @@ struct SoftBusIpcClientCmd {
 };
 
 static struct SoftBusIpcClientCmd g_softBusIpcClientCmdTbl[] = {
+    { CLIENT_DISCOVERY_SUCC, ClientOnDiscoverySuccess },
+    { CLIENT_DISCOVERY_FAIL, ClientOnDiscoverFailed },
+    { CLIENT_DISCOVERY_DEVICE_FOUND, ClientOnDeviceFound },
+    { CLIENT_PUBLISH_SUCC, ClientOnPublishSuccess },
+    { CLIENT_PUBLISH_FAIL, ClientOnPublishFail },
     { CLIENT_ON_JOIN_RESULT, ClientOnJoinLNNResult },
     { CLIENT_ON_JOIN_METANODE_RESULT, ClientOnJoinMetaNodeResult },
     { CLIENT_ON_LEAVE_RESULT, ClientOnLeaveLNNResult },

sdk/frame/standard/include/if_softbus_client.h

@@ -17,11 +17,11 @@
 #define INTERFACES_INNERKITS_SOFTBUS_CLIENT_H_
 
 #include "data_level_inner.h"
+#include "discovery_service.h"
 #include "iremote_broker.h"
 #include "iremote_object.h"
 #include "iremote_proxy.h"
 #include "session.h"
-#include "softbus_common.h"
 #include "softbus_def.h"
 
 namespace OHOS {
@@ -29,6 +29,16 @@ class ISoftBusClient : public IRemoteBroker {
 public:
     ~ISoftBusClient() override = default;
 
+    virtual void OnDeviceFound(const DeviceInfo *device);
+
+    virtual void OnDiscoverFailed(int subscribeId, int failReason);
+
+    virtual void OnDiscoverySuccess(int subscribeId);
+
+    virtual void OnPublishSuccess(int publishId);
+
+    virtual void OnPublishFail(int publishId, int reason);
+
     virtual int32_t OnChannelOpened(const char *sessionName, const ChannelInfo *channel);
 
     virtual int32_t OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode);

sdk/frame/standard/include/softbus_client_stub.h

@@ -35,6 +35,11 @@ public:
     SoftBusClientStub();
     virtual ~SoftBusClientStub() = default;
     int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
+    void OnDeviceFound(const DeviceInfo *device) override;
+    void OnDiscoverFailed(int subscribeId, int failReason) override;
+    void OnDiscoverySuccess(int subscribeId) override;
+    void OnPublishSuccess(int publishId) override;
+    void OnPublishFail(int publishId, int reason) override;
     int32_t OnChannelOpened(const char *sessionName, const ChannelInfo *info) override;
     int32_t OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode) override;
     int32_t OnChannelLinkDown(const char *networkId, int32_t routeType) override;
@@ -59,6 +64,11 @@ public:
     int32_t OnChannelBind(int32_t channelId, int32_t channelType) override;
 
 private:
+    int32_t OnDeviceFoundInner(MessageParcel &data, MessageParcel &reply);
+    int32_t OnDiscoverFailedInner(MessageParcel &data, MessageParcel &reply);
+    int32_t OnDiscoverySuccessInner(MessageParcel &data, MessageParcel &reply);
+    int32_t OnPublishSuccessInner(MessageParcel &data, MessageParcel &reply);
+    int32_t OnPublishFailInner(MessageParcel &data, MessageParcel &reply);
     int32_t OnChannelOpenedInner(MessageParcel &data, MessageParcel &reply);
     int32_t OnChannelOpenFailedInner(MessageParcel &data, MessageParcel &reply);
     int32_t OnChannelLinkDownInner(MessageParcel &data, MessageParcel &reply);

sdk/frame/standard/include/softbus_server_proxy_standard.h

@@ -29,6 +29,10 @@ public:
         : IRemoteProxy<ISoftBusServer>(impl) {}
     virtual ~SoftBusServerProxyFrame() = default;
 
+    int32_t StartDiscovery(const char *pkgName, const SubscribeInfo *info) override;
+    int32_t StopDiscovery(const char *pkgName, int subscribeId) override;
+    int32_t PublishService(const char *pkgName, const PublishInfo *info) override;
+    int32_t UnPublishService(const char *pkgName, int publishId) override;
     int32_t SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object) override;
 
     int32_t CreateSessionServer(const char *pkgName, const char *sessionName) override;

sdk/frame/standard/src/if_softbus_client.cpp

@@ -18,6 +18,30 @@
 #include "softbus_error_code.h"
 
 namespace OHOS {
+void ISoftBusClient::OnDeviceFound(const DeviceInfo *device)
+{
+    COMM_LOGI(COMM_EVENT, "ipc default impl");
+}
+
+void ISoftBusClient::OnDiscoverFailed(int subscribeId, int failReason)
+{
+    COMM_LOGI(COMM_EVENT, "ipc default impl");
+}
+
+void ISoftBusClient::OnDiscoverySuccess(int subscribeId)
+{
+    COMM_LOGI(COMM_EVENT, "ipc default impl");
+}
+void ISoftBusClient::OnPublishSuccess(int publishId)
+{
+    COMM_LOGI(COMM_EVENT, "ipc default impl");
+}
+
+void ISoftBusClient::OnPublishFail(int publishId, int reason)
+{
+    COMM_LOGI(COMM_EVENT, "ipc default impl");
+}
+
 int32_t ISoftBusClient::OnChannelOpened(const char *sessionName, const ChannelInfo *channel)
 {
     COMM_LOGI(COMM_EVENT, "ipc default impl");

sdk/frame/standard/src/softbus_client_stub.cpp

@@ -18,6 +18,7 @@
 #include <string>
 
 #include "client_bus_center_manager.h"
+#include "client_disc_manager.h"
 #include "client_trans_channel_callback.h"
 #include "client_trans_session_manager.h"
 #include "client_trans_socket_manager.h"
@@ -35,6 +36,11 @@
 namespace OHOS {
 SoftBusClientStub::SoftBusClientStub()
 {
+    memberFuncMap_[CLIENT_DISCOVERY_DEVICE_FOUND] = &SoftBusClientStub::OnDeviceFoundInner;
+    memberFuncMap_[CLIENT_DISCOVERY_SUCC] = &SoftBusClientStub::OnDiscoverySuccessInner;
+    memberFuncMap_[CLIENT_DISCOVERY_FAIL] = &SoftBusClientStub::OnDiscoverFailedInner;
+    memberFuncMap_[CLIENT_PUBLISH_SUCC] = &SoftBusClientStub::OnPublishSuccessInner;
+    memberFuncMap_[CLIENT_PUBLISH_FAIL] = &SoftBusClientStub::OnPublishFailInner;
     memberFuncMap_[CLIENT_ON_CHANNEL_OPENED] = &SoftBusClientStub::OnChannelOpenedInner;
     memberFuncMap_[CLIENT_ON_CHANNEL_OPENFAILED] = &SoftBusClientStub::OnChannelOpenFailedInner;
     memberFuncMap_[CLIENT_ON_CHANNEL_LINKDOWN] = &SoftBusClientStub::OnChannelLinkDownInner;
@@ -91,6 +97,50 @@ int32_t SoftBusClientStub::OnClientPermissonChangeInner(MessageParcel &data, Mes
     return SOFTBUS_OK;
 }
 
+int32_t SoftBusClientStub::OnDeviceFoundInner(MessageParcel &data, MessageParcel &reply)
+{
+    const unsigned char *info = data.ReadBuffer(sizeof(DeviceInfo));
+    if (info == nullptr) {
+        return SOFTBUS_TRANS_PROXY_READBUFFER_FAILED;
+    }
+    DeviceInfo deviceInfo;
+    if (memcpy_s(&deviceInfo, sizeof(DeviceInfo), info, sizeof(DeviceInfo)) != EOK) {
+        return SOFTBUS_MEM_ERR;
+    }
+    OnDeviceFound(&deviceInfo);
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusClientStub::OnDiscoverFailedInner(MessageParcel &data, MessageParcel &reply)
+{
+    int subscribeId = data.ReadInt32();
+    int failReason = data.ReadInt32();
+    OnDiscoverFailed(subscribeId, failReason);
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusClientStub::OnDiscoverySuccessInner(MessageParcel &data, MessageParcel &reply)
+{
+    int subscribeId = data.ReadInt32();
+    OnDiscoverySuccess(subscribeId);
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusClientStub::OnPublishSuccessInner(MessageParcel &data, MessageParcel &reply)
+{
+    int publishId = data.ReadInt32();
+    OnPublishSuccess(publishId);
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusClientStub::OnPublishFailInner(MessageParcel &data, MessageParcel &reply)
+{
+    int publishId = data.ReadInt32();
+    int failReason = data.ReadInt32();
+    OnPublishFail(publishId, failReason);
+    return SOFTBUS_OK;
+}
+
 int32_t SoftBusClientStub::OnClientTransLimitChangeInner(MessageParcel &data, MessageParcel &reply)
 {
     int32_t channelId;
@@ -113,6 +163,31 @@ int32_t SoftBusClientStub::OnClientTransLimitChange(int32_t channelId, uint8_t t
     return TransLimitChange(channelId, tos);
 }
 
+void SoftBusClientStub::OnDeviceFound(const DeviceInfo *device)
+{
+    DiscClientOnDeviceFound(device);
+}
+
+void SoftBusClientStub::OnDiscoverFailed(int subscribeId, int failReason)
+{
+    DiscClientOnDiscoverFailed(subscribeId, (DiscoveryFailReason)failReason);
+}
+
+void SoftBusClientStub::OnDiscoverySuccess(int subscribeId)
+{
+    DiscClientOnDiscoverySuccess(subscribeId);
+}
+
+void SoftBusClientStub::OnPublishSuccess(int publishId)
+{
+    DiscClientOnPublishSuccess(publishId);
+}
+
+void SoftBusClientStub::OnPublishFail(int publishId, int reason)
+{
+    DiscClientOnPublishFail(publishId, (PublishFailReason)reason);
+}
+
 int32_t SoftBusClientStub::OnChannelOpened(const char *sessionName, const ChannelInfo *info)
 {
     return TransOnChannelOpened(sessionName, info);

sdk/frame/standard/src/softbus_server_proxy_frame.cpp

@@ -25,6 +25,7 @@
 #include "client_trans_socket_manager.h"
 #include "bus_center_server_proxy.h"
 #include "comm_log.h"
+#include "disc_server_proxy.h"
 #include "ipc_skeleton.h"
 #include "iremote_broker.h"
 #include "iremote_object.h"
@@ -175,6 +176,7 @@ void ClientDeathProcTask(void)
         }
         g_serverProxy.clear();
     }
+    DiscServerProxyDeInit();
     TransServerProxyDeInit();
     BusCenterServerProxyDeInit();
 
@@ -193,6 +195,7 @@ void ClientDeathProcTask(void)
         COMM_LOGE(COMM_SDK, "server proxy init reached the maximum count=%{public}d", cnt);
         return;
     }
+    DiscServerProxyInit();
     TransServerProxyInit();
     BusCenterServerProxyInit();
     InnerRegisterService(&sessionServerInfoList);

sdk/frame/standard/src/softbus_server_proxy_standard.cpp

@@ -36,6 +36,34 @@ sptr<IRemoteObject> SoftBusServerProxyFrame::GetRemoteInstance()
     return clientCallbackStub_;
 }
 
+int32_t SoftBusServerProxyFrame::StartDiscovery(const char *pkgName, const SubscribeInfo *info)
+{
+    (void)pkgName;
+    (void)info;
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusServerProxyFrame::StopDiscovery(const char *pkgName, int subscribeId)
+{
+    (void)pkgName;
+    (void)subscribeId;
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusServerProxyFrame::PublishService(const char *pkgName, const PublishInfo *info)
+{
+    (void)pkgName;
+    (void)info;
+    return SOFTBUS_OK;
+}
+
+int32_t SoftBusServerProxyFrame::UnPublishService(const char *pkgName, int publishId)
+{
+    (void)pkgName;
+    (void)publishId;
+    return SOFTBUS_OK;
+}
+
 int32_t SoftBusServerProxyFrame::SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject>& object)
 {
     sptr<IRemoteObject> remote = Remote();

sdk/libsoftbus_client_map

@@ -29,6 +29,7 @@
         "TransOnUdpChannelQosEvent";
         "ServerIpcPublishLNN";
         "ClientDeleteSession";
+        "UnpublishServiceInner";
         "ClientTransUdpMgrDeinit";
         "ServerIpcNotifyAuthSuccess";
         "ServerIpcLeaveLNN";
@@ -39,6 +40,7 @@
         "FreeNodeInfo";
         "ServerIpcStreamStats";
         "TransTdcSendMessage";
+        "DiscClientDeinit";
         "FindConfigType";
         "TransClientDeinit";
         "ClientRegisterService";
@@ -48,6 +50,8 @@
         "BusCenterServerProxyInit";
         "ServerIpcStopRefreshLNN";
         "TransGetUdpChannel";
+        "ServerIpcPublishService";
+        "DiscClientOnPublishSuccess";
         "ClientTransProxyDeinit";
         "JoinMetaNode";
         "ClientTransProxyInit";
@@ -55,8 +59,10 @@
         "FrameIndexToType";
         "ServerIpcStopTimeSync";
         "GetMySessionNameInner";
+        "StartDiscovery";
         "RefreshLNNInner";
         "LnnOnLeaveResult";
+        "ServerIpcStopDiscovery";
         "GetSessionSide";
         "TransOnChannelClosed";
         "TransProxyChannelSendBytes";
@@ -67,12 +73,14 @@
         "ServerIpcCreateSessionServer";
         "TransOnUdpChannelOpenFailed";
         "CheckSendLen";
+        "DiscServerProxyInit";
         "ClientTransRegLnnOffline";
         "ServerIpcStartTimeSync";
         "TransCloseStreamChannel";
         ".init_proc";
         "ClientTransChannelSendBytes";
         "TransTdcGetHandle";
+        "ServerIpcUnPublishService";
         "GetNodeKeyInfoInner";
         "InitPendingPacket";
         "DeactiveMetaNode";
@@ -111,6 +119,7 @@
         "IsServerSideInner";
         "TransProxyChannelSendMessage";
         "TransDataListInit";
+        "DiscClientOnDiscoverySuccess";
         "TransOnSessionClosed";
         "TransGetFileName";
         "GetEncryptByChannelId";
@@ -131,11 +140,13 @@
         "ServerIpcOpenAuthSession";
         "CreatePendingPacket";
         "CreateSessionServerInner";
+        "PublishServiceInner";
         "RefreshLNN";
         "GetPkgNameInner";
         "CloseSession";
         "CLIENT_NotifyObserver";
         "ServerIpcGetLocalDeviceInfo";
+        "DiscClientInit";
         "ClientAddAuthSession";
         "TransTdcGetInfoByIdWithIncSeq";
         "PublishLNNInner";
@@ -159,6 +170,7 @@
         "RegisterFileCb";
         "InnerOnBytesReceived";
         "RemoveSessionServer";
+        "StopDiscovery";
         "ClientGetSessionCallbackById";
         "ClientGetDataConfigByChannelId";
         "ClientTransUdpMgrInit";
@@ -169,11 +181,13 @@
         "LnnOnRefreshDeviceFound";
         "ServerIpcActiveMetaNode";
         "ServerIpcLeaveMetaNode";
+        "DiscClientOnDeviceFound";
         "EventClientInit";
         "ServerIpcGetNodeKeyInfo";
         "CheckPackageName";
         "PublishLNN";
         "ClientTransAuthOnDataReceived";
+        "StopDiscoveryInner";
         "SendStream";
         "TransSetFileSendListener";
         "ClientTransProxyOnChannelOpened";
@@ -201,6 +215,7 @@
         "TransAuthChannelSendMessage";
         "TransGetFileListener";
         "ShiftLNNGearInner";
+        "ServerIpcStartDiscovery";
         "ServerIpcJoinMetaNode";
         "FileUnLock";
         "TransOnUdpChannelOpened";
@@ -212,6 +227,7 @@
         "GetPeerPidInner";
         "StartNStackXDFileClient";
         "MetaNodeOnLeaveResult";
+        "DiscClientOnPublishFail";
         "ProcessFileFrameData";
         "SendVtpStream";
         "TransClientInit";
@@ -257,6 +273,7 @@
         "IsPathValid";
         "TransTdcGetInfoById";
         "UnregisterStreamCb";
+        "PublishService";
         "ClientTransChannelSendStream";
         "TransTdcSendBytes";
         "GetAllNodeDeviceInfo";
@@ -267,6 +284,7 @@
         "EventClientDeinit";
         "FileListToBuffer";
         "RTU_CRC";
+        "UnPublishService";
         "SetFileReceiveListener";
         "ClientGetSessionDataById";
         "ClientTransChannelSendMessage";
@@ -282,6 +300,7 @@
         "TransTdcStopRead";
         "ServerIpcReleaseResources";
         "ServerIpcCloseChannel";
+        "DiscClientOnDiscoverFailed";
         "SendBytesInner";
         "GetPeerSessionNameInner";
         "TransTdcManagerDeinit";
@@ -299,6 +318,7 @@
         "CloseSessionInner";
         "ClientTransTdcOnDataReceived";
         "ClientAddSessionServer";
+        "StartDiscoveryInner";
         "InnerOnSessionOpened";
         "GrantPermissionInner";
         "LeaveMetaNode";
@@ -317,6 +337,7 @@
         "ClientSetChannelBySessionId";
         "StopPublishLNN";
         "GetPeerSessionName";
+        "DiscServerProxyDeInit";
         "ServerIpcGetAllMetaNodeInfo";
         "TransOnChannelQosEvent";
         "ClientGetSessionIntegerDataById";
@@ -512,6 +533,7 @@
             Communication::SoftBus*;
             OHOS::ISoftBusServer*;
             "VTT for OHOS::BusCenterServerProxy";
+            "VTT for OHOS::DiscServerProxy";
             "VTT for OHOS::IRemoteStub<OHOS::ISoftBusClient>";
             "VTT for OHOS::ISoftBusClient";
             "VTT for OHOS::ISoftBusServer";
@@ -522,6 +544,7 @@
             "construction vtable for OHOS::IPCObjectStub-in-OHOS::IRemoteStub<OHOS::ISoftBusClient>";
             "construction vtable for OHOS::IPCObjectStub-in-OHOS::SoftBusClientStub";
             "construction vtable for OHOS::IRemoteBroker-in-OHOS::BusCenterServerProxy";
+            "construction vtable for OHOS::IRemoteBroker-in-OHOS::DiscServerProxy";
             "construction vtable for OHOS::IRemoteBroker-in-OHOS::IRemoteStub<OHOS::ISoftBusClient>";
             "construction vtable for OHOS::IRemoteBroker-in-OHOS::ISoftBusClient";
             "construction vtable for OHOS::IRemoteBroker-in-OHOS::ISoftBusServer";
@@ -531,17 +554,20 @@
             "construction vtable for OHOS::IRemoteObject-in-OHOS::IRemoteStub<OHOS::ISoftBusClient>";
             "construction vtable for OHOS::IRemoteObject-in-OHOS::SoftBusClientStub";
             "construction vtable for OHOS::IRemoteProxy<OHOS::ISoftBusServer>-in-OHOS::BusCenterServerProxy";
+            "construction vtable for OHOS::IRemoteProxy<OHOS::ISoftBusServer>-in-OHOS::DiscServerProxy";
             "construction vtable for OHOS::IRemoteProxy<OHOS::ISoftBusServer>-in-OHOS::SoftBusServerProxyFrame";
             "construction vtable for OHOS::IRemoteProxy<OHOS::ISoftBusServer>-in-OHOS::TransServerProxy";
             "construction vtable for OHOS::IRemoteStub<OHOS::ISoftBusClient>-in-OHOS::SoftBusClientStub";
             "construction vtable for OHOS::ISoftBusClient-in-OHOS::IRemoteStub<OHOS::ISoftBusClient>";
             "construction vtable for OHOS::ISoftBusClient-in-OHOS::SoftBusClientStub";
             "construction vtable for OHOS::ISoftBusServer-in-OHOS::BusCenterServerProxy";
+            "construction vtable for OHOS::ISoftBusServer-in-OHOS::DiscServerProxy";
             "construction vtable for OHOS::ISoftBusServer-in-OHOS::SoftBusServerProxyFrame";
             "construction vtable for OHOS::ISoftBusServer-in-OHOS::TransServerProxy";
             "construction vtable for OHOS::Parcelable-in-OHOS::IRemoteStub<OHOS::ISoftBusClient>";
             "construction vtable for OHOS::Parcelable-in-OHOS::SoftBusClientStub";
             "guard variable for OHOS::BusCenterServerProxy::delegator_";
+            "guard variable for OHOS::DiscServerProxy::delegator_";
             "guard variable for OHOS::SoftBusServerProxyFrame::delegator_";
             "guard variable for OHOS::TransServerProxy::delegator_";
             "non-virtual thunk to OHOS::IRemoteStub<OHOS::ISoftBusClient>::AsObject(void)";
@@ -552,13 +578,18 @@
             "non-virtual thunk to OHOS::SoftBusClientStub::OnChannelOpened(char const*, ChannelInfo const*)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnChannelQosEvent(int, int, int, int, QosTv const*)";
             "non-virtual thunk to OHOS::SoftBusClientStub::SetChannelInfo(char const*, int, int, int)";
+            "non-virtual thunk to OHOS::SoftBusClientStub::OnDeviceFound(DeviceInfo const*)";
+            "non-virtual thunk to OHOS::SoftBusClientStub::OnDiscoverFailed(int, int)";
+            "non-virtual thunk to OHOS::SoftBusClientStub::OnDiscoverySuccess(int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnJoinLNNResult(void *, unsigned int,char const*, int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnJoinMetaNodeResult(void *, unsigned int, char const*, int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnLeaveLNNResult(char const*, int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnLeaveMetaNodeResult(char const*, int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnNodeBasicInfoChanged(void *, unsigned int, int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnNodeOnlineStateChanged(bool, void *, unsigned int)";
+            "non-virtual thunk to OHOS::SoftBusClientStub::OnPublishFail(int, int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnPublishLNNResult(int, int)";
+            "non-virtual thunk to OHOS::SoftBusClientStub::OnPublishSuccess(int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnRefreshDeviceFound(void const*, unsigned int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnRefreshLNNResult(int, int)";
             "non-virtual thunk to OHOS::SoftBusClientStub::OnTimeSyncResult(void const*, unsigned int, int)";
@@ -577,10 +608,12 @@
             "vtable for Communication::SoftBus::TwoLevelsTlv";
             "vtable for Communication::SoftBus::VtpStreamSocket";
             "vtable for OHOS::BrokerDelegator<OHOS::BusCenterServerProxy>";
+            "vtable for OHOS::BrokerDelegator<OHOS::DiscServerProxy>";
             "vtable for OHOS::BrokerDelegator<OHOS::SoftBusServerProxyFrame>";
             "vtable for OHOS::BrokerDelegator<OHOS::TransServerProxy>";
             "vtable for OHOS::BrokerDelegatorBase";
             "vtable for OHOS::BusCenterServerProxy";
+            "vtable for OHOS::DiscServerProxy";
             "vtable for OHOS::IRemoteStub<OHOS::ISoftBusClient>";
             "vtable for OHOS::ISoftBusClient";
             "vtable for OHOS::ISoftBusServer";

sdk/transmission/ipc/standard/include/trans_server_proxy_standard.h

@@ -26,6 +26,10 @@ public:
         : IRemoteProxy<ISoftBusServer>(impl) {}
     virtual ~TransServerProxy() = default;
 
+    int32_t StartDiscovery(const char *pkgName, const SubscribeInfo *subInfo) override;
+    int32_t StopDiscovery(const char *pkgName, int32_t subscribeId) override;
+    int32_t PublishService(const char *pkgName, const PublishInfo *pubInfo) override;
+    int32_t UnPublishService(const char *pkgName, int32_t publishId) override;
     int32_t SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object) override;
 
     int32_t CreateSessionServer(const char *pkgName, const char *sessionName) override;

sdk/transmission/ipc/standard/src/trans_server_proxy_standard.cpp

@@ -60,6 +60,34 @@ static sptr<IRemoteObject> GetSystemAbility()
     return reply.ReadRemoteObject();
 }
 
+int32_t TransServerProxy::StartDiscovery(const char *pkgName, const SubscribeInfo *subInfo)
+{
+    (void)pkgName;
+    (void)subInfo;
+    return SOFTBUS_OK;
+}
+
+int32_t TransServerProxy::StopDiscovery(const char *pkgName, int32_t subscribeId)
+{
+    (void)pkgName;
+    (void)subscribeId;
+    return SOFTBUS_OK;
+}
+
+int32_t TransServerProxy::PublishService(const char *pkgName, const PublishInfo *pubInfo)
+{
+    (void)pkgName;
+    (void)pubInfo;
+    return SOFTBUS_OK;
+}
+
+int32_t TransServerProxy::UnPublishService(const char *pkgName, int32_t publishId)
+{
+    (void)pkgName;
+    (void)publishId;
+    return SOFTBUS_OK;
+}
+
 int32_t TransServerProxy::SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object)
 {
     (void)clientPkgName;

tests/BUILD.gn

@@ -23,6 +23,7 @@ if (defined(ohos_lite)) {
         features += [
           "adapter/unittest:AdapterTest",
           "sdk/bus_center/unittest:BusCenterSdkRefreshSmall",
+          "sdk/discovery/unittest:DiscSdkTest",
           "sdk/transmission/trans_channel:TransSdkStreamTest",
         ]
       }
@@ -48,6 +49,7 @@ if (defined(ohos_lite)) {
         "core/frame:unittest",
         "core/transmission:unittest",
         "sdk/bus_center:unittest",
+        "sdk/discovery:unittest",
         "sdk/frame/common:unittest",
         "sdk/frame/standard:unittest",
         "sdk/transmission:unittest",
@@ -69,6 +71,7 @@ if (defined(ohos_lite)) {
       "core/frame:fuzztest",
       "core/transmission:fuzztest",
       "sdk/bus_center:fuzztest",
+      "sdk/discovery:fuzztest",
       "sdk/frame:fuzztest",
       "sdk/transmission:fuzztest",
     ]

tests/core/discovery/ble/bt_state/disc_bt_state_mock_test.cpp

@@ -22,6 +22,7 @@
 #include <cstdlib>
 
 #include "bluetooth_mock.h"
+#include "discovery_service.h"
 #include "disc_ble.h"
 #include "disc_log.h"
 #include "lnn_local_net_ledger.h"

tests/core/discovery/ipc/BUILD.gn

@@ -20,6 +20,42 @@ import("../../../utils/utils.gni")
 
 module_output_path = "dsoftbus/discovery"
 
+ohos_unittest("DiscClientProxyTest") {
+  module_out_path = module_output_path
+  sources = [
+    "$dsoftbus_core_path/discovery/ipc/standard/src/disc_client_proxy.cpp",
+    "$dsoftbus_core_path/discovery/ipc/standard/src/disc_client_proxy_standard.cpp",
+    "$dsoftbus_root_path/sdk/frame/standard/src/if_softbus_client.cpp",
+    "client_info_manager_mock.cpp",
+    "disc_client_proxy_test.cpp",
+    "remote_object_mock.cpp",
+  ]
+  sources += test_utils_src
+
+  include_dirs = [
+    "$dsoftbus_core_path/discovery/ipc/include",
+    "$dsoftbus_core_path/discovery/ipc/standard/include",
+    "$dsoftbus_root_path/interfaces/kits/common",
+    "$dsoftbus_root_path/interfaces/kits/discovery",
+    "$dsoftbus_root_path/sdk/frame/standard/include/",
+    "$dsoftbus_core_path/common/include",
+    "$dsoftbus_root_path/core/common/dfx/interface/include",
+    "$dsoftbus_core_path/frame/standard/client_manager/include",
+    "$softbus_adapter_common/include",
+  ]
+  include_dirs += test_utils_inc
+
+  deps = [
+    "//third_party/googletest:gmock",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "ipc:ipc_core",
+  ]
+}
+
 ohos_unittest("DiscClientOnDeviceFoundTest") {
   module_out_path = module_output_path
   sources = [
@@ -66,5 +102,8 @@ ohos_unittest("DiscClientOnDeviceFoundTest") {
 
 group("unittest") {
   testonly = true
-  deps = [ ":DiscClientOnDeviceFoundTest" ]
+  deps = [
+    ":DiscClientOnDeviceFoundTest",
+    ":DiscClientProxyTest",
+  ]
 }

tests/core/discovery/ipc/client_info_manager_mock.cpp

@@ -14,6 +14,7 @@
  */
 
 #include "client_info_manager_mock.h"
+#include "disc_client_proxy_standard.h"
 #include "remote_object_mock.h"
 
 namespace OHOS {

tests/core/discovery/ipc/disc_client_proxy_test.cpp

@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2022 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 <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "discovery_service.h"
+#include "disc_client_proxy.h"
+#include "disc_log.h"
+#include "softbus_error_code.h"
+#include "softbus_server_ipc_interface_code.h"
+#include "remote_object_mock.h"
+#include "client_info_manager_mock.h"
+#include "exception_branch_checker.h"
+
+using namespace testing::ext;
+using testing::Return;
+
+namespace OHOS {
+class DiscClientProxyTest : public testing::Test {
+public:
+    static void SetUpTestCase() {}
+    static void TearDownTestCase() {}
+    void SetUp() override {}
+    void TearDown() override {}
+
+    static inline std::string pkgName = "TestPackage";
+    static constexpr int SUBSCRIBE_ID = 8;
+    static constexpr int PUBLISH_ID = 16;
+};
+
+/*
+* @tc.name: OnDeviceFound001
+* @tc.desc: both fail and success case
+* @tc.type: FUNC
+* @tc.require:
+*/
+HWTEST_F(DiscClientProxyTest, OnDeviceFound001, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "OnDeviceFound001 begin ----");
+    const DeviceInfo device {};
+    const InnerDeviceInfoAddtions addition{};
+
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        EXPECT_CALL(*objectMock, SendRequest).WillRepeatedly(Return(SOFTBUS_DISCOVER_TEST_CASE_ERRCODE));
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+        ExceptionBranchChecker checker("send request failed");
+
+        EXPECT_EQ(ClientIpcOnDeviceFound(pkgName.c_str(), &device, &addition), SOFTBUS_OK);
+        EXPECT_EQ(checker.GetResult(), true);
+    }
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+
+        EXPECT_EQ(ClientIpcOnDeviceFound(pkgName.c_str(), &device, &addition), SOFTBUS_OK);
+        EXPECT_EQ(objectMock->GetResult(CLIENT_DISCOVERY_DEVICE_FOUND, &device), true);
+    }
+
+    RemoteObjectMock::Destroy();
+    DISC_LOGI(DISC_TEST, "OnDeviceFound001 end ----");
+}
+
+/*
+* @tc.name: OnDiscoverFailed001
+* @tc.desc: both fail and success case
+* @tc.type: FUNC
+* @tc.require:
+*/
+HWTEST_F(DiscClientProxyTest, OnDiscoverFailed001, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "OnDiscoverFailed001 begin ----");
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        EXPECT_CALL(*objectMock, SendRequest).WillRepeatedly(Return(SOFTBUS_DISCOVER_TEST_CASE_ERRCODE));
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+        ExceptionBranchChecker checker("send request failed");
+
+        EXPECT_EQ(ClientIpcOnDiscoverFailed(pkgName.c_str(), SUBSCRIBE_ID, DISCOVERY_FAIL_REASON_NOT_SUPPORT_MEDIUM),
+                  SOFTBUS_OK);
+        EXPECT_EQ(checker.GetResult(), true);
+    }
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+
+        EXPECT_EQ(ClientIpcOnDiscoverFailed(pkgName.c_str(), SUBSCRIBE_ID, DISCOVERY_FAIL_REASON_NOT_SUPPORT_MEDIUM),
+                  SOFTBUS_OK);
+        EXPECT_EQ(objectMock->GetResult(CLIENT_DISCOVERY_FAIL, nullptr, 0, SUBSCRIBE_ID,
+                                        DISCOVERY_FAIL_REASON_NOT_SUPPORT_MEDIUM), true);
+    }
+
+    RemoteObjectMock::Destroy();
+    DISC_LOGI(DISC_TEST, "OnDiscoverFailed001 end ----");
+}
+
+/*
+* @tc.name: DiscoverySuccess001
+* @tc.desc: both fail and success case
+* @tc.type: FUNC
+* @tc.require:
+*/
+HWTEST_F(DiscClientProxyTest, DiscoverySuccess001, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "DiscoverySuccess001 begin ----");
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        EXPECT_CALL(*objectMock, SendRequest).WillRepeatedly(Return(SOFTBUS_DISCOVER_TEST_CASE_ERRCODE));
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+        ExceptionBranchChecker checker("send request failed");
+
+        EXPECT_EQ(ClientIpcDiscoverySuccess(pkgName.c_str(), SUBSCRIBE_ID), SOFTBUS_OK);
+        EXPECT_EQ(checker.GetResult(), true);
+    }
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+
+        EXPECT_EQ(ClientIpcDiscoverySuccess(pkgName.c_str(), SUBSCRIBE_ID), SOFTBUS_OK);
+        EXPECT_EQ(objectMock->GetResult(CLIENT_DISCOVERY_SUCC, nullptr, 0, SUBSCRIBE_ID), true);
+    }
+
+    RemoteObjectMock::Destroy();
+    DISC_LOGI(DISC_TEST, "DiscoverySuccess001 end ----");
+}
+
+/*
+* @tc.name: OnPublishSuccess001
+* @tc.desc: both fail and success case
+* @tc.type: FUNC
+* @tc.require:
+*/
+HWTEST_F(DiscClientProxyTest, OnPublishSuccess001, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "DiscoverySuccess001 begin ----");
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        EXPECT_CALL(*objectMock, SendRequest).WillRepeatedly(Return(SOFTBUS_DISCOVER_TEST_CASE_ERRCODE));
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+        ExceptionBranchChecker checker("send request failed");
+
+        EXPECT_EQ(ClientIpcOnPublishSuccess(pkgName.c_str(), PUBLISH_ID), SOFTBUS_OK);
+        EXPECT_EQ(checker.GetResult(), true);
+    }
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+
+        EXPECT_EQ(ClientIpcOnPublishSuccess(pkgName.c_str(), PUBLISH_ID), SOFTBUS_OK);
+        EXPECT_EQ(objectMock->GetResult(CLIENT_PUBLISH_SUCC, nullptr, PUBLISH_ID), true);
+    }
+
+    RemoteObjectMock::Destroy();
+    DISC_LOGI(DISC_TEST, "OnPublishSuccess001 end ----");
+}
+
+/*
+* @tc.name: OnPublishFail001
+* @tc.desc: both fail and success case
+* @tc.type: FUNC
+* @tc.require:
+*/
+HWTEST_F(DiscClientProxyTest, OnPublishFail001, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "OnPublishFail001 begin ----");
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        EXPECT_CALL(*objectMock, SendRequest).WillRepeatedly(Return(SOFTBUS_DISCOVER_TEST_CASE_ERRCODE));
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+        ExceptionBranchChecker checker("send request failed");
+
+        EXPECT_EQ(ClientIpcOnPublishFail(pkgName.c_str(), PUBLISH_ID, PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM),
+                  SOFTBUS_OK);
+        EXPECT_EQ(checker.GetResult(), true);
+    }
+    {
+        sptr<RemoteObjectMock> objectMock = new (std::nothrow) RemoteObjectMock();
+        RemoteObjectMock::SetupStub(objectMock);
+        ClientInfoManagerMock managerMock;
+        managerMock.SetupStub();
+
+        EXPECT_EQ(ClientIpcOnPublishFail(pkgName.c_str(), PUBLISH_ID, PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM),
+                  SOFTBUS_OK);
+        EXPECT_EQ(objectMock->GetResult(CLIENT_PUBLISH_FAIL, nullptr, PUBLISH_ID, 0,
+                                        PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM), true);
+    }
+
+    RemoteObjectMock::Destroy();
+    DISC_LOGI(DISC_TEST, "OnPublishFail001 end ----");
+}
+}

tests/core/discovery/ipc/remote_object_mock.cpp

@@ -47,6 +47,16 @@ void RemoteObjectMock::Destroy()
 void RemoteObjectMock::SetupStub(const sptr<RemoteObjectMock> &self)
 {
     SetSelf(self);
+    EXPECT_CALL(*self, SendRequest(CLIENT_DISCOVERY_DEVICE_FOUND, _, _, _))
+        .WillRepeatedly(ActionOfSendRequestForOnDeviceFound);
+    EXPECT_CALL(*self, SendRequest(CLIENT_DISCOVERY_SUCC, _, _, _))
+        .WillRepeatedly(ActionOfSendRequestForOnDiscoverySuccess);
+    EXPECT_CALL(*self, SendRequest(CLIENT_DISCOVERY_FAIL, _, _, _))
+        .WillRepeatedly(ActionOfSendRequestForOnDiscoveryFailed);
+    EXPECT_CALL(*self, SendRequest(CLIENT_PUBLISH_SUCC, _, _, _))
+        .WillRepeatedly(ActionOfSendRequestForOnPublishSuccess);
+    EXPECT_CALL(*self, SendRequest(CLIENT_PUBLISH_FAIL, _, _, _))
+        .WillRepeatedly(ActionOfSendRequestForOnPublishFail);
 }
 
 sptr<RemoteObjectMock> RemoteObjectMock::Get()
@@ -84,4 +94,56 @@ bool RemoteObjectMock::GetResult(uint32_t code, const DeviceInfo *deviceInfo, in
         return false;
     }
     return true;
+}
+
+int RemoteObjectMock::ActionOfSendRequestForOnDeviceFound(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                          MessageOption &option)
+{
+    DISC_LOGI(DISC_TEST, "code=%{public}u", code);
+    Get()->code_ = code;
+    Get()->descriptor_ = data.ReadInterfaceToken();
+    return memcpy_s(&Get()->deviceInfo_, sizeof(DeviceInfo), data.ReadBuffer(sizeof(DeviceInfo)), sizeof(DeviceInfo));
+}
+
+int RemoteObjectMock::ActionOfSendRequestForOnDiscoveryFailed(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                              MessageOption &option)
+{
+    DISC_LOGI(DISC_TEST, "code=%{public}u", code);
+    Get()->code_ = code;
+    Get()->descriptor_ = data.ReadInterfaceToken();
+    Get()->subscribeId_ = data.ReadInt32();
+    Get()->reason_ = data.ReadInt32();
+    return 0;
+}
+
+int RemoteObjectMock::ActionOfSendRequestForOnDiscoverySuccess(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                               MessageOption &option)
+{
+    DISC_LOGI(DISC_TEST, "code=%{public}u", code);
+    Get()->code_ = code;
+    Get()->descriptor_ = data.ReadInterfaceToken();
+    Get()->subscribeId_ = data.ReadInt32();
+    return 0;
+}
+
+int RemoteObjectMock::ActionOfSendRequestForOnPublishSuccess(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                             MessageOption &option)
+{
+    DISC_LOGI(DISC_TEST, "code=%{public}u", code);
+    Get()->code_ = code;
+    Get()->descriptor_ = data.ReadInterfaceToken();
+    Get()->publishId_ = data.ReadInt32();
+    return 0;
+}
+
+int RemoteObjectMock::ActionOfSendRequestForOnPublishFail(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                          MessageOption &option)
+{
+    DISC_LOGI(DISC_TEST, "code=%{public}u", code);
+    Get()->code_ = code;
+    Get()->descriptor_ = data.ReadInterfaceToken();
+    Get()->publishId_ = data.ReadInt32();
+    Get()->reason_ = data.ReadInt32();
+    return 0;
+}
 }

tests/core/discovery/ipc/remote_object_mock.h

@@ -56,6 +56,17 @@ public:
     bool GetResult(uint32_t code, const DeviceInfo *deviceInfo = nullptr, int publishId = 0, int subscribeId = 0,
                    int reason = 0);
 
+    static int ActionOfSendRequestForOnDeviceFound(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                   MessageOption &option);
+    static int ActionOfSendRequestForOnDiscoveryFailed(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                       MessageOption &option);
+    static int ActionOfSendRequestForOnDiscoverySuccess(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                        MessageOption &option);
+    static int ActionOfSendRequestForOnPublishSuccess(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                      MessageOption &option);
+    static int ActionOfSendRequestForOnPublishFail(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                                   MessageOption &option);
+
 private:
     std::u16string descriptor_;
     uint32_t code_ {};

tests/core/discovery/manager/unittest/BUILD.gn

@@ -84,10 +84,46 @@ ohos_unittest("DiscManagerMockTest") {
   ]
 }
 
+ohos_unittest("DiscManagerServerTest") {
+  module_out_path = module_output_path
+  sources = [
+    "$dsoftbus_core_path/discovery/manager/src/softbus_disc_server.c",
+    "softbus_disc_server_mock.cpp",
+    "softbus_disc_server_test.cpp",
+  ]
+
+  include_dirs = [
+    "$dsoftbus_core_path/common/dfx/hisysevent_adapter/include",
+    "$dsoftbus_core_path/common/dfx/hidumper_adapter/include",
+    "$dsoftbus_core_path/common/include",
+    "$dsoftbus_core_path/discovery/ble/dispatcher/include",
+    "$dsoftbus_core_path/discovery/coap/interface",
+    "$dsoftbus_core_path/discovery/interface",
+    "$dsoftbus_core_path/discovery/ipc/include",
+    "$dsoftbus_core_path/discovery/manager/include",
+    "$dsoftbus_root_path/interfaces/kits/common",
+    "$dsoftbus_root_path/interfaces/kits/discovery",
+    "$softbus_adapter_common/include",
+  ]
+
+  deps = [
+    "$dsoftbus_root_path/adapter:softbus_adapter",
+    "$dsoftbus_root_path/core/common:softbus_utils",
+    "//third_party/googletest:gmock",
+    "//third_party/googletest:gtest_main",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+  ]
+}
+
 group("unittest") {
   testonly = true
   deps = [
     ":DiscManagerMockTest",
+    ":DiscManagerServerTest",
     ":DiscManagerTest",
   ]
 }

tests/core/discovery/manager/unittest/softbus_disc_server_mock.cpp

@@ -0,0 +1,83 @@
+/*
+ * 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 "softbus_disc_server_mock.h"
+
+using namespace testing;
+using namespace testing::ext;
+
+namespace OHOS {
+DiscMock::DiscMock()
+{
+    mock.store(this);
+}
+
+DiscMock::~DiscMock()
+{
+    mock.store(nullptr);
+}
+
+extern "C" {
+int32_t DiscPublishService(const char *packageName, const PublishInfo *info)
+{
+    return DiscMock::GetDiscMockInterface()->DiscPublishService(packageName, info);
+}
+
+int32_t DiscUnPublishService(const char *packageName, int32_t publishId)
+{
+    return DiscMock::GetDiscMockInterface()->DiscUnPublishService(packageName, publishId);
+}
+
+int32_t DiscStartDiscovery(const char *packageName, const SubscribeInfo *info, const IServerDiscInnerCallback *cb)
+{
+    return DiscMock::GetDiscMockInterface()->DiscStartDiscovery(packageName, info, cb);
+}
+
+int32_t DiscStopDiscovery(const char *packageName, int32_t subscribeId)
+{
+    return DiscMock::GetDiscMockInterface()->DiscStopDiscovery(packageName, subscribeId);
+}
+
+int32_t ClientIpcOnPublishFail(const char *pkgName, int32_t publishId, int32_t reason)
+{
+    return DiscMock::GetDiscMockInterface()->ClientIpcOnPublishFail(pkgName, publishId, reason);
+}
+
+int32_t ClientIpcOnPublishSuccess(const char *pkgName, int32_t publishId)
+{
+    return DiscMock::GetDiscMockInterface()->ClientIpcOnPublishSuccess(pkgName, publishId);
+}
+
+int32_t ClientIpcOnDiscoverFailed(const char *pkgName, int32_t subscribeId, int32_t failReason)
+{
+    return DiscMock::GetDiscMockInterface()->ClientIpcOnDiscoverFailed(pkgName, subscribeId, failReason);
+}
+
+int32_t ClientIpcDiscoverySuccess(const char *pkgName, int32_t subscribeId)
+{
+    return DiscMock::GetDiscMockInterface()->ClientIpcDiscoverySuccess(pkgName, subscribeId);
+}
+
+int32_t SoftbusReportDiscFault(SoftBusDiscMedium medium, int32_t errCode)
+{
+    return DiscMock::GetDiscMockInterface()->SoftbusReportDiscFault(medium, errCode);
+}
+
+int32_t ClientIpcOnDeviceFound(const char *pkgName, const DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
+{
+    return DiscMock::GetDiscMockInterface()->ClientIpcOnDeviceFound(pkgName, device, additions);
+}
+}
+} // namespace OHOS

tests/core/discovery/manager/unittest/softbus_disc_server_mock.h

@@ -0,0 +1,73 @@
+/*
+ * 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 SOFTBUS_DISC_SERVER_MOCK_H
+#define SOFTBUS_DISC_SERVER_MOCK_H
+
+#include <atomic>
+
+#include "disc_manager.h"
+#include "gmock/gmock.h"
+#include "softbus_common.h"
+#include "softbus_hisysevt_discreporter.h"
+
+namespace OHOS {
+class DiscMockInterface {
+public:
+    DiscMockInterface() {}
+    virtual ~DiscMockInterface() {}
+
+    virtual int32_t DiscPublishService(const char *packageName, const PublishInfo *info) = 0;
+    virtual int32_t DiscUnPublishService(const char *packageName, int32_t publishId) = 0;
+    virtual int32_t DiscStartDiscovery(const char *packageName, const SubscribeInfo *info,
+                                       const IServerDiscInnerCallback *cb) = 0;
+    virtual int32_t DiscStopDiscovery(const char *packageName, int32_t subscribeId) = 0;
+    virtual int32_t ClientIpcOnPublishFail(const char *pkgName, int32_t publishId, int32_t reason) = 0;
+    virtual int32_t ClientIpcOnPublishSuccess(const char *pkgName, int32_t publishId) = 0;
+    virtual int32_t ClientIpcOnDiscoverFailed(const char *pkgName, int32_t subscribeId, int32_t failReason) = 0;
+    virtual int32_t ClientIpcDiscoverySuccess(const char *pkgName, int32_t subscribeId) = 0;
+    virtual int32_t SoftbusReportDiscFault(SoftBusDiscMedium medium, int32_t errCode) = 0;
+    virtual int32_t ClientIpcOnDeviceFound(const char *pkgName, const DeviceInfo *device,
+                                           const InnerDeviceInfoAddtions *additions) = 0;
+};
+
+class DiscMock : public DiscMockInterface {
+public:
+    static DiscMock* GetDiscMockInterface()
+    {
+        return mock.load();
+    }
+    DiscMock();
+    ~DiscMock() override;
+
+    MOCK_METHOD(int32_t, DiscPublishService, (const char *packageName, const PublishInfo *info), (override));
+    MOCK_METHOD(int32_t, DiscUnPublishService, (const char *packageName, int32_t publishId), (override));
+    MOCK_METHOD(int32_t, DiscStartDiscovery,
+               (const char *packageName, const SubscribeInfo *info, const IServerDiscInnerCallback *cb), (override));
+    MOCK_METHOD(int32_t, DiscStopDiscovery, (const char *packageName, int32_t subscribeId), (override));
+    MOCK_METHOD(int32_t, ClientIpcOnPublishFail, (const char *pkgName, int32_t publishId, int32_t reason), (override));
+    MOCK_METHOD(int32_t, ClientIpcOnPublishSuccess, (const char *pkgName, int32_t publishId), (override));
+    MOCK_METHOD(int32_t, ClientIpcOnDiscoverFailed,
+               (const char *pkgName, int32_t subscribeId, int32_t failReason), (override));
+    MOCK_METHOD(int32_t, ClientIpcDiscoverySuccess, (const char *pkgName, int32_t subscribeId), (override));
+    MOCK_METHOD(int32_t, SoftbusReportDiscFault, (SoftBusDiscMedium medium, int32_t errCode), (override));
+    MOCK_METHOD(int32_t, ClientIpcOnDeviceFound,
+               (const char *pkgName, const DeviceInfo *device, const InnerDeviceInfoAddtions *additions), (override));
+
+private:
+    static inline std::atomic<DiscMock*> mock = nullptr;
+};
+} // namespace OHOS
+#endif // SOFTBUS_DISC_SERVER_MOCK_H

tests/core/discovery/manager/unittest/softbus_disc_server_test.cpp

@@ -0,0 +1,209 @@
+/*
+ * 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 <securec.h>
+
+#include "disc_log.h"
+#include "softbus_common.h"
+#include "softbus_disc_server.h"
+#include "softbus_disc_server_mock.h"
+#include "softbus_errcode.h"
+
+using namespace testing;
+using namespace testing::ext;
+using testing::Return;
+
+namespace OHOS {
+class DiscManagerServerTest : public testing::Test {
+public:
+    static void SetUpTestCase()
+    {}
+    static void TearDownTestCase()
+    {}
+
+    void SetUp()
+    {}
+    void TearDown()
+    {}
+};
+
+
+/*
+ * @tc.name: DiscIpcPublishServiceTest
+ * @tc.desc: Test the invalid parameter input and normal flow of the DiscIpcPublishService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscManagerServerTest, DiscIpcPublishServiceTest, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "DiscIpcPublishServiceTest start");
+    PublishInfo publishInfo;
+    (void)memset_s(&publishInfo, sizeof(PublishInfo), 0, sizeof(PublishInfo));
+    const char *packageName = "packageName";
+    EXPECT_EQ(DiscIpcPublishService(nullptr, &publishInfo), SOFTBUS_INVALID_PARAM);
+    EXPECT_EQ(DiscIpcPublishService(packageName, nullptr), SOFTBUS_INVALID_PARAM);
+    DiscMock discMock;
+    EXPECT_CALL(discMock, ClientIpcOnPublishFail).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, ClientIpcOnPublishSuccess).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, SoftbusReportDiscFault).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, DiscPublishService).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
+    EXPECT_EQ(DiscIpcPublishService(packageName, &publishInfo), SOFTBUS_INVALID_PARAM);
+    EXPECT_CALL(discMock, DiscPublishService).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_EQ(DiscIpcPublishService(packageName, &publishInfo), SOFTBUS_OK);
+    DISC_LOGI(DISC_TEST, "DiscIpcPublishServiceTest end");
+}
+
+/*
+ * @tc.name: DiscIpcUnPublishServiceTest
+ * @tc.desc: Test the invalid parameter input and normal flow of the DiscIpcUnPublishService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscManagerServerTest, DiscIpcUnPublishServiceTest, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "DiscIpcUnPublishServiceTest start");
+    DiscMock discMock;
+    EXPECT_CALL(discMock, DiscUnPublishService).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
+    EXPECT_EQ(DiscIpcUnPublishService(nullptr, 0), SOFTBUS_INVALID_PARAM);
+    EXPECT_CALL(discMock, DiscUnPublishService).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_EQ(DiscIpcUnPublishService(nullptr, 0), SOFTBUS_OK);
+    DISC_LOGI(DISC_TEST, "DiscIpcUnPublishServiceTest end");
+}
+
+/*
+ * @tc.name: DiscIpcStartDiscoveryTest
+ * @tc.desc: Test the invalid parameter input and normal flow of the DiscIpcStartDiscovery function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscManagerServerTest, DiscIpcStartDiscoveryTest, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "DiscIpcStartDiscoveryTest start");
+    SubscribeInfo subscribeInfo;
+    (void)memset_s(&subscribeInfo, sizeof(subscribeInfo), 0, sizeof(subscribeInfo));
+    const char *packageName = "packageName";
+    DiscMock discMock;
+    EXPECT_EQ(DiscIpcStartDiscovery(nullptr, &subscribeInfo), SOFTBUS_INVALID_PARAM);
+    EXPECT_EQ(DiscIpcStartDiscovery(packageName, nullptr), SOFTBUS_INVALID_PARAM);
+    EXPECT_CALL(discMock, ClientIpcOnDiscoverFailed).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, ClientIpcDiscoverySuccess).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, SoftbusReportDiscFault).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, ClientIpcOnDeviceFound).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, DiscStartDiscovery).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_EQ(DiscIpcStartDiscovery(packageName, &subscribeInfo), SOFTBUS_OK);
+    EXPECT_CALL(discMock, DiscStartDiscovery).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_EQ(DiscIpcStartDiscovery(packageName, &subscribeInfo), SOFTBUS_OK);
+    DISC_LOGI(DISC_TEST, "DiscIpcStartDiscoveryTest end");
+}
+
+/*
+ * @tc.name: DiscIpcStopDiscoveryTest
+ * @tc.desc: Test the invalid parameter input and normal flow of the DiscIpcStopDiscovery function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscManagerServerTest, DiscIpcStopDiscoveryTest, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "DiscIpcStopDiscoveryTest start");
+    DiscMock discMock;
+    EXPECT_CALL(discMock, DiscStopDiscovery).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
+    EXPECT_EQ(DiscIpcStopDiscovery(nullptr, 0), SOFTBUS_INVALID_PARAM);
+    EXPECT_CALL(discMock, DiscStopDiscovery).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_EQ(DiscIpcStopDiscovery(nullptr, 0), SOFTBUS_OK);
+    DISC_LOGI(DISC_TEST, "DiscIpcStopDiscoveryTest end");
+}
+
+/*
+ * @tc.name: PublishErroCodeProcessTest
+ * @tc.desc: Test the PublishErroCodeProcess function by run DiscIpcPublishService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscManagerServerTest, PublishErroCodeProcessTest, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "PublishErroCodeProcessTest start");
+    PublishInfo publishInfo;
+    (void)memset_s(&publishInfo, sizeof(PublishInfo), 0, sizeof(PublishInfo));
+    const char *packageName = "packageName";
+    DiscMock discMock;
+    EXPECT_CALL(discMock, ClientIpcOnPublishFail).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, ClientIpcOnPublishSuccess).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, SoftbusReportDiscFault).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, DiscPublishService).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
+    EXPECT_EQ(DiscIpcPublishService(packageName, &publishInfo), SOFTBUS_INVALID_PARAM);
+    EXPECT_CALL(discMock,
+                DiscPublishService).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_INVALID_MEDIUM));
+    EXPECT_EQ(DiscIpcPublishService(packageName, &publishInfo), SOFTBUS_DISCOVER_MANAGER_INVALID_MEDIUM);
+    DISC_LOGI(DISC_TEST, "PublishErroCodeProcessTest end");
+}
+
+/*
+ * @tc.name: DiscoveryErroCodeProcessTest
+ * @tc.desc: Test the DiscoveryErroCodeProcess function by run DiscIpcStartDiscovery function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscManagerServerTest, DiscoveryErroCodeProcessTest, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "DiscoveryErroCodeProcessTest start");
+    SubscribeInfo subscribeInfo;
+    (void)memset_s(&subscribeInfo, sizeof(subscribeInfo), 0, sizeof(subscribeInfo));
+    const char *packageName = "packageName";
+    DiscMock discMock;
+    EXPECT_CALL(discMock, ClientIpcOnDiscoverFailed).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, ClientIpcDiscoverySuccess).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, SoftbusReportDiscFault).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, ClientIpcOnDeviceFound).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, DiscStartDiscovery).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
+    EXPECT_EQ(DiscIpcStartDiscovery(packageName, &subscribeInfo), SOFTBUS_INVALID_PARAM);
+    EXPECT_CALL(discMock,
+                DiscStartDiscovery).WillRepeatedly(Return(SOFTBUS_DISCOVER_MANAGER_INVALID_MEDIUM));
+    EXPECT_EQ(DiscIpcStartDiscovery(packageName, &subscribeInfo), SOFTBUS_DISCOVER_MANAGER_INVALID_MEDIUM);
+    DISC_LOGI(DISC_TEST, "DiscoveryErroCodeProcessTest end");
+}
+
+/*
+ * @tc.name: ConvertDiscTypeTest
+ * @tc.desc: Test the ConvertDiscTypeTest function by run DiscIpcPublishService function
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscManagerServerTest, ConvertDiscTypeTest, TestSize.Level1)
+{
+    DISC_LOGI(DISC_TEST, "ConvertDiscTypeTest start");
+    PublishInfo deviceinfo1 {
+        .medium = COAP,
+        .publishId = 0,
+    };
+    PublishInfo deviceinfo2 {
+        .medium = BLE,
+        .publishId = 0,
+    };
+    PublishInfo deviceinfo3 {
+        .medium = USB,
+        .publishId = 0,
+    };
+    const char *packageName = "packageName";
+    DiscMock discMock;
+    EXPECT_CALL(discMock, ClientIpcOnPublishFail).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, ClientIpcOnPublishSuccess).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, SoftbusReportDiscFault).WillRepeatedly(Return(SOFTBUS_OK));
+    EXPECT_CALL(discMock, DiscPublishService).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
+    EXPECT_EQ(DiscIpcPublishService(packageName, &deviceinfo1), SOFTBUS_INVALID_PARAM);
+    EXPECT_EQ(DiscIpcPublishService(packageName, &deviceinfo2), SOFTBUS_INVALID_PARAM);
+    EXPECT_EQ(DiscIpcPublishService(packageName, &deviceinfo3), SOFTBUS_INVALID_PARAM);
+    DISC_LOGI(DISC_TEST, "ConvertDiscTypeTest end");
+}
+} // namespace OHOS

tests/core/frame/fuzztest/softbusserverstub2_fuzzer/softbusserverstub2_fuzzer.cpp

@@ -30,6 +30,8 @@ constexpr int32_t SOFTBUS_SERVER_SA_ID = 4700;
 const std::u16string SOFTBUS_SERVER_STUB_INTERFACE_TOKEN = u"OHOS.ISoftBusServer";
 const std::vector<SoftBusFuncId> CODE_LIST = {
     MANAGE_REGISTER_SERVICE,
+    SERVER_PUBLISH_SERVICE,
+    SERVER_UNPUBLISH_SERVICE,
     SERVER_CREATE_SESSION_SERVER,
     SERVER_REMOVE_SESSION_SERVER,
     SERVER_OPEN_SESSION,
@@ -43,6 +45,8 @@ const std::vector<SoftBusFuncId> CODE_LIST = {
     SERVER_REMOVE_PERMISSION,
     SERVER_STREAM_STATS,
     SERVER_GET_SOFTBUS_SPEC_OBJECT,
+    SERVER_START_DISCOVERY,
+    SERVER_STOP_DISCOVERY,
     SERVER_JOIN_LNN,
     SERVER_JOIN_METANODE,
     SERVER_LEAVE_LNN,

tests/core/frame/fuzztest/softbusserverstub_fuzzer/softbusserverstub_fuzzer.cpp

@@ -42,6 +42,10 @@
 #define SIZE_NUM_FIVE 5
 
 namespace OHOS {
+constexpr int32_t SOFTBUS_FUZZ_TEST_START_DISCOVERY_SUB_SCRIBE_ID = 5;
+constexpr int32_t SOFTBUS_FUZZ_TEST_START_DISCOVERY_MODE = 6;
+constexpr int32_t SOFTBUS_FUZZ_TEST_START_DISCOVERY_MEDIUM = 7;
+constexpr int32_t SOFTBUS_FUZZ_TEST_START_DISCOVERY_FREQ = 8;
 constexpr int32_t SOFTBUS_FUZZ_TEST_ADDR_TYPE_LEN = 160;
 
 const std::u16string SOFTBUS_SERVER_STUB_INTERFACE_TOKEN = u"OHOS.ISoftBusServer";
@@ -49,7 +53,9 @@ const std::u16string SAMANAGER_INTERFACE_TOKEN = u"ohos.samgr.accessToken";
 
 enum SoftBusFuncId {
     MANAGE_REGISTER_SERVICE = 0,
-    SERVER_CREATE_SESSION_SERVER = 128,
+    SERVER_PUBLISH_SERVICE = 128,
+    SERVER_UNPUBLISH_SERVICE,
+    SERVER_CREATE_SESSION_SERVER,
     SERVER_REMOVE_SESSION_SERVER,
     SERVER_OPEN_SESSION,
     SERVER_OPEN_AUTH_SESSION,
@@ -61,6 +67,8 @@ enum SoftBusFuncId {
     SERVER_REMOVE_PERMISSION,
     SERVER_STREAM_STATS,
     SERVER_GET_SOFTBUS_SPEC_OBJECT,
+    SERVER_START_DISCOVERY,
+    SERVER_STOP_DISCOVERY,
     SERVER_JOIN_LNN,
     SERVER_JOIN_METANODE,
     SERVER_LEAVE_LNN,
@@ -108,6 +116,94 @@ static bool SendRequestByCommand(const uint8_t *data, size_t size, uint32_t comm
     return object->SendRequest(command, datas, reply, option) == ERR_NONE;
 }
 
+static void PublishInfoProc(const uint8_t *data, MessageParcel &datas)
+{
+    uint32_t offset = 0;
+    char pkgName[INPUT_NAME_SIZE_MAX] = "distribdata_test";
+    if (memcpy_s(pkgName, INPUT_NAME_SIZE_MAX, reinterpret_cast<const char *>(data), INPUT_NAME_SIZE_MAX - 1) != EOK) {
+        return;
+    }
+    pkgName[INPUT_NAME_SIZE_MAX - 1] = '\0';
+    offset = INPUT_NAME_SIZE_MAX;
+    int32_t publishId = *reinterpret_cast<const int32_t *>(data + offset);
+    offset += sizeof(int32_t);
+    int32_t mode = *reinterpret_cast<const int32_t *>(data + offset);
+    offset += sizeof(int32_t);
+    int32_t medium = *reinterpret_cast<const int32_t *>(data + offset);
+    offset += sizeof(int32_t);
+    int32_t freq = *reinterpret_cast<const int32_t *>(data + offset);
+    offset += sizeof(int32_t);
+
+    char capability[INPUT_NAME_SIZE_MAX] = "";
+    if (memcpy_s(capability, INPUT_NAME_SIZE_MAX, reinterpret_cast<const char *>(data),
+        INPUT_NAME_SIZE_MAX - 1) != EOK) {
+        return;
+    }
+    capability[INPUT_NAME_SIZE_MAX - 1] = '\0';
+    uint32_t dataLen = *reinterpret_cast<const uint32_t *>(data + offset);
+    offset += sizeof(uint32_t);
+    char capabilityData[INPUT_NAME_SIZE_MAX] = "";
+    if (memcpy_s(capabilityData, INPUT_NAME_SIZE_MAX, reinterpret_cast<const char *>(data),
+        INPUT_NAME_SIZE_MAX) != EOK) {
+        return;
+    }
+    capabilityData[INPUT_NAME_SIZE_MAX - 1] = '\0';
+    datas.WriteCString(pkgName);
+    datas.WriteInt32(publishId);
+    datas.WriteInt32(mode);
+    datas.WriteInt32(medium);
+    datas.WriteInt32(freq);
+    datas.WriteCString(capability);
+    datas.WriteUint32(dataLen);
+    datas.WriteCString(capabilityData);
+}
+
+bool PublishServiceFuzzTest(const uint8_t *data, size_t size)
+{
+    sptr<IRemoteObject> object = GetRemoteObject();
+    if (object == nullptr || data == nullptr || size < INPUT_NAME_SIZE_MAX * SIZE_NUM_THREE +
+        sizeof(int32_t) * SIZE_NUM_FOUR + sizeof(uint32_t)) {
+        return false;
+    }
+
+    MessageParcel datas;
+    PublishInfoProc(data, datas);
+    MessageParcel reply;
+    sptr<OHOS::SoftBusServerStub> SoftBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
+    if (SoftBusServer == nullptr) {
+        return false;
+    }
+    SoftBusServer->PublishServiceInner(datas, reply);
+    return true;
+}
+
+bool UnPublishServiceFuzzTest(const uint8_t *data, size_t size)
+{
+    sptr<IRemoteObject> object = GetRemoteObject();
+    if (object == nullptr || data == nullptr || size < INPUT_NAME_SIZE_MAX + sizeof(int32_t)) {
+        return false;
+    }
+    uint32_t offset = 0;
+    char pkgName[INPUT_NAME_SIZE_MAX] = "distribdata_test";
+    if (memcpy_s(pkgName, INPUT_NAME_SIZE_MAX, reinterpret_cast<const char *>(data), INPUT_NAME_SIZE_MAX - 1) != EOK) {
+        return false;
+    }
+    pkgName[INPUT_NAME_SIZE_MAX - 1] = '\0';
+    offset = INPUT_NAME_SIZE_MAX;
+    int32_t publishId = *reinterpret_cast<const int32_t *>(data + offset);
+
+    MessageParcel datas;
+    datas.WriteCString(pkgName);
+    datas.WriteInt32(publishId);
+    MessageParcel reply;
+    sptr<OHOS::SoftBusServerStub> SoftBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
+    if (SoftBusServer == nullptr) {
+        return false;
+    }
+    SoftBusServer->UnpublishServiceInner(datas, reply);
+    return true;
+}
+
 bool CreateSessionServerFuzzTest(const uint8_t *data, size_t size)
 {
     sptr<IRemoteObject> object = GetRemoteObject();
@@ -471,6 +567,62 @@ bool GetSoftbusSpecObjectFuzzTest(const uint8_t *data, size_t size)
     return SendRequestByCommand(data, size, SERVER_GET_SOFTBUS_SPEC_OBJECT);
 }
 
+bool StartDiscoveryFuzzTest(const uint8_t *data, size_t size)
+{
+    sptr<IRemoteObject> object = GetRemoteObject();
+    if (object == nullptr) {
+        return false;
+    }
+    int32_t subscribeId = SOFTBUS_FUZZ_TEST_START_DISCOVERY_SUB_SCRIBE_ID;
+    int32_t mode = SOFTBUS_FUZZ_TEST_START_DISCOVERY_MODE;
+    int32_t medium = SOFTBUS_FUZZ_TEST_START_DISCOVERY_MEDIUM;
+    int32_t freq = SOFTBUS_FUZZ_TEST_START_DISCOVERY_FREQ;
+    bool boolNum = true;
+    MessageParcel datas;
+    datas.WriteBuffer(data, size);
+    datas.WriteInt32(subscribeId);
+    datas.WriteInt32(mode);
+    datas.WriteInt32(medium);
+    datas.WriteInt32(freq);
+    datas.WriteBool(boolNum);
+    datas.WriteInt32(freq);
+    datas.RewindRead(0);
+    MessageParcel reply;
+    sptr<OHOS::SoftBusServerStub> SoftBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
+    if (SoftBusServer == nullptr) {
+        return false;
+    }
+    SoftBusServer->StartDiscoveryInner(datas, reply);
+    return true;
+}
+
+bool StopDiscoveryFuzzTest(const uint8_t *data, size_t size)
+{
+    sptr<IRemoteObject> object = GetRemoteObject();
+    if (object == nullptr) {
+        return false;
+    }
+    char pkgName[INPUT_NAME_SIZE_MAX] = "";
+    uint32_t offset = 0;
+    if (memcpy_s(pkgName, INPUT_NAME_SIZE_MAX, reinterpret_cast<const char *>(data),
+        INPUT_NAME_SIZE_MAX - 1) != EOK) {
+        return false;
+    }
+    pkgName[INPUT_NAME_SIZE_MAX - 1] = '\0';
+    offset += INPUT_NAME_SIZE_MAX;
+    int32_t publishId = *reinterpret_cast<const int32_t *>(data + offset);
+    MessageParcel datas;
+    datas.WriteCString(pkgName);
+    datas.WriteInt32(publishId);
+    MessageParcel reply;
+    sptr<OHOS::SoftBusServerStub> SoftBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
+    if (SoftBusServer == nullptr) {
+        return false;
+    }
+    SoftBusServer->StopDiscoveryInner(datas, reply);
+    return true;
+}
+
 bool JoinLNNFuzzTest(const uint8_t *data, size_t size)
 {
     sptr<IRemoteObject> object = GetRemoteObject();
@@ -1308,6 +1460,8 @@ bool RunFuzzTestCase(const uint8_t *data, size_t size)
     OHOS::RemovePermissionFuzzTest(data, size);
     OHOS::StreamStatsFuzzTest(data, size);
     OHOS::GetSoftbusSpecObjectFuzzTest(data, size);
+    OHOS::StartDiscoveryFuzzTest(data, size);
+    OHOS::StopDiscoveryFuzzTest(data, size);
     OHOS::JoinLNNFuzzTest(data, size);
     OHOS::JoinMetaNodeFuzzTest(data, size);
     OHOS::LeaveLNNFuzzTest(data, size);
@@ -1327,6 +1481,8 @@ bool RunFuzzTestCase(const uint8_t *data, size_t size)
     OHOS::GetAllMetaNodeInfoFuzzTest(data, size);
     OHOS::ShiftLNNGearFuzzTest(data, size);
     OHOS::RippleStatsFuzzTest(data, size);
+    OHOS::PublishServiceFuzzTest(data, size);
+    OHOS::UnPublishServiceFuzzTest(data, size);
     OHOS::SoftbusRegisterServiceFuzzTest(data, size);
     OHOS::CheckOpenSessionPermissionFuzzTest(data, size);
     OHOS::EvaLuateQosInnerFuzzTest(data, size);

tests/core/transmission/ipc/trans_client_proxy_standard_test.cpp

@@ -60,6 +60,7 @@ HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest001, TestSize
 {
     #define TEST_INVALID 0
     int32_t ret;
+    DeviceInfo device;
 
     static const uint32_t SOFTBUS_SA_ID = 4700;
     sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
@@ -68,7 +69,16 @@ HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest001, TestSize
     sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
     ASSERT_TRUE(clientProxy != nullptr);
 
+    clientProxy->OnDeviceFound(&device);
+
     int tmp = TEST_INVALID;
+    clientProxy->OnDiscoverFailed(tmp, tmp);
+
+    clientProxy->OnDiscoverySuccess(tmp);
+
+    clientProxy->OnPublishSuccess(tmp);
+
+    clientProxy->OnPublishFail(tmp, tmp);
 
     void *addr = nullptr;
     uint32_t addrTypeLen = TEST_INVALID;

tests/sdk/bus_center/demo/bus_center/publish_refresh_lnn_demo.c

@@ -24,6 +24,7 @@
  */
 
 #include <stdint.h>
+#include "discovery_service.h"
 #include "softbus_bus_center.h"
 #include "softbus_common.h"
 

tests/sdk/bus_center/unittest/bus_center_sdk_publish_test.cpp

@@ -20,6 +20,7 @@
 #include <sys/time.h>
 #include <unistd.h>
 
+#include "discovery_service.h"
 #include "softbus_access_token_test.h"
 #include "softbus_adapter_mem.h"
 #include "softbus_bus_center.h"

tests/sdk/bus_center/unittest/bus_center_sdk_refresh_small_test.cpp

@@ -19,6 +19,7 @@
 #include <sys/time.h>
 #include <unistd.h>
 
+#include "discovery_service.h"
 #include "softbus_access_token_test.h"
 #include "softbus_bus_center.h"
 #include "softbus_server_frame.h"

tests/sdk/bus_center/unittest/bus_center_sdk_refresh_test.cpp

@@ -19,6 +19,7 @@
 #include <sys/time.h>
 #include <unistd.h>
 
+#include "discovery_service.h"
 #include "softbus_access_token_test.h"
 #include "softbus_bus_center.h"
 

tests/sdk/discovery/BUILD.gn

@@ -18,3 +18,13 @@ group("benchmarktest") {
   testonly = true
   deps = [ "benchmarktest:benchmarktest" ]
 }
+
+group("fuzztest") {
+  testonly = true
+  deps = [ "fuzztest:fuzztest" ]
+}
+
+group("unittest") {
+  testonly = true
+  deps = [ "unittest:unittest" ]
+}

tests/sdk/discovery/account/BUILD.gn

@@ -0,0 +1,57 @@
+# Copyright (c) 2021 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.
+
+import("//build/test.gni")
+import("../../../../dsoftbus.gni")
+module_output_path = "dsoftbus/discovery"
+dsoftbus_root_path = "../../../.."
+
+ohos_unittest("disc_account_test") {
+  module_out_path = module_output_path
+  sources = [ "disc_account_test.cpp" ]
+  include_dirs = [
+    "$dsoftbus_root_path/core/common/inner_communication",
+    "$dsoftbus_root_path/adapter/common/include",
+    "$dsoftbus_root_path/core/common/include",
+    "$dsoftbus_root_path/interfaces/kits/discovery",
+    "$dsoftbus_root_path/interfaces/kits/common",
+    "$dsoftbus_root_path/interfaces/inner_kits/transport",
+    "$dsoftbus_root_path/sdk/discovery/include",
+    "//commonlibrary/c_utils/base/include",
+    "//third_party/bounds_checking_function/include",
+    "unittest/common/",
+    "$dsoftbus_root_path/sdk/discovery/manager/include",
+  ]
+  deps = [
+    "$dsoftbus_root_path/core/common:softbus_utils",
+    "$dsoftbus_root_path/sdk:softbus_client",
+    "//third_party/bounds_checking_function:libsec_shared",
+    "//third_party/bounds_checking_function:libsec_static",
+    "//third_party/googletest:gtest_main",
+  ]
+  if (is_standard_system) {
+    external_deps = [
+      "c_utils:utils",
+      "hilog:libhilog",
+    ]
+  } else {
+    external_deps = [
+      "c_utils:utils",
+      "hilog:libhilog",
+    ]
+  }
+}
+group("unittest") {
+  testonly = true
+  deps = [ ":disc_account_test" ]
+}

tests/sdk/discovery/account/disc_account_test.cpp

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2021-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.
+ */
+
+#include <cstdio>
+#include <ctime>
+#include <gtest/gtest.h>
+#include <securec.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "discovery_service.h"
+#include "inner_session.h"
+#include "session.h"
+#include "softbus_utils.h"
+
+using namespace testing::ext;
+
+namespace OHOS {
+int32_t g_testWay = -1;
+int32_t g_accountWay = -1;
+int32_t g_publishId = 1;
+int32_t g_subscribeId = 1;
+enum TEST_WAY {
+    STARTDISCOVERY_WAY = 0,
+    PUBLISHSERVICE_WAY
+};
+
+enum ACCOUNT_MODE {
+    SAMEACCOUNT_TRUE = 0,
+    SAMEACCOUNT_FALSE
+};
+
+const char *g_pkgName = "com.objectstore.foundation";
+bool g_state = false;
+static void Wait(void);
+
+ConnectionAddr g_addr;
+ConnectionAddr g_addr1;
+
+static SubscribeInfo g_sInfo = {
+    .subscribeId = g_subscribeId,
+    .medium = BLE,
+    .mode = DISCOVER_MODE_ACTIVE,
+    .freq = MID,
+    .capability = "dvKit",
+    .capabilityData = (unsigned char *)"capdata3",
+    .dataLen = sizeof("capdata3"),
+    .isSameAccount = false,
+    .isWakeRemote = false
+};
+
+static PublishInfo g_pInfo = {
+    .publishId = g_publishId,
+    .medium = BLE,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .freq = MID,
+    .capability = "dvKit",
+    .capabilityData = (unsigned char *)"capdata4",
+    .dataLen = sizeof("capdata4")
+};
+
+static void TestDeviceFound(const DeviceInfo *device)
+{
+    if (ConvertBtMacToStr(g_addr.info.ble.bleMac, 18, (const uint8_t *)&(device->addr[0].info.ble.bleMac[0]), 6) != 0) {
+        return;
+    }
+    if (strcmp(g_addr1.info.ble.bleMac, g_addr.info.ble.bleMac) != 0) {
+        strcpy_s(g_addr1.info.ble.bleMac, BT_MAC_LEN, g_addr.info.ble.bleMac);
+        printf("[client]TestDeviceFound\r\n");
+        g_state = true;
+    }
+}
+
+static void TestDiscoverFailed(int subscribeId, DiscoveryFailReason failReason)
+{
+    printf("[test]TestDiscoverFailed\r\n");
+}
+
+static void TestDiscoverySuccess(int subscribeId)
+{
+    printf("[test]TestDiscoverySuccess\r\n");
+}
+
+static void TestPublishSuccess(int publishId)
+{
+    printf("[test]TestPublishSuccess\r\n");
+}
+
+static void TestPublishFail(int publishId, PublishFailReason reason)
+{
+    printf("[test]TestPublishFail\r\n");
+}
+
+static IDiscoveryCallback g_subscribeCb = {
+    .OnDeviceFound = TestDeviceFound,
+    .OnDiscoverFailed = TestDiscoverFailed,
+    .OnDiscoverySuccess = TestDiscoverySuccess
+};
+
+static IPublishCallback g_publishCb = {
+    .OnPublishSuccess = TestPublishSuccess,
+    .OnPublishFail = TestPublishFail
+};
+
+class DiscAccountTest : public testing::Test {
+public:
+    DiscAccountTest()
+    {}
+    ~DiscAccountTest()
+    {}
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp() override
+    {}
+    void TearDown() override
+    {}
+};
+
+void DiscAccountTest::SetUpTestCase(void)
+{
+    printf("********Ble Test Begin*********\r\n");
+    printf("*       0.discovery           *\r\n");
+    printf("*       1.publish             *\r\n");
+    printf("*******************************\r\n");
+    printf("input the num:");
+    if (scanf_s("%d", &g_testWay, sizeof(g_testWay)) < 0) {
+        printf("input error!\n");
+    }
+    getchar();
+    if (g_testWay == PUBLISHSERVICE_WAY) {
+        return;
+    }
+    printf("***********Account*************\r\n");
+    printf("*          0.true             *\r\n");
+    printf("*          1.false            *\r\n");
+    printf("*******************************\r\n");
+    printf("input the num:");
+    if (scanf_s("%d", &g_accountWay, sizeof(g_accountWay)) < 0) {
+        printf("input error!\n");
+    }
+    getchar();
+    if (g_accountWay == SAMEACCOUNT_TRUE) {
+        g_sInfo.isSameAccount = true;
+        return;
+    }
+    g_sInfo.isSameAccount = false;
+}
+
+void DiscAccountTest::TearDownTestCase(void)
+{
+    if (g_testWay == STARTDISCOVERY_WAY) {
+        StopDiscovery(g_pkgName, g_subscribeId);
+        return;
+    }
+    UnPublishService(g_pkgName, g_publishId);
+}
+
+static void Wait(void)
+{
+    printf("[test]wait enter...\r\n");
+    do {
+        sleep(1);
+    } while (!g_state);
+    printf("[test]wait end!\r\n");
+    g_state = false;
+}
+
+static int32_t TestPublishServer()
+{
+    printf("[test]TestPublishServer enter\r\n");
+    g_pInfo.mode = DISCOVER_MODE_ACTIVE;
+    int32_t ret = PublishService(g_pkgName, &g_pInfo, &g_publishCb);
+    EXPECT_TRUE(ret == 0);
+    printf("[test]TestPublishServer end\r\n");
+    return ret;
+}
+
+static int32_t TestStartDiscovery()
+{
+    printf("[test]TestStartDiscovery enter\r\n");
+    g_sInfo.mode = DISCOVER_MODE_ACTIVE;
+    int32_t ret = StartDiscovery(g_pkgName, &g_sInfo, &g_subscribeCb);
+    EXPECT_TRUE(ret == 0);
+    printf("[test]TestStartDiscovery end\r\n");
+    return ret;
+}
+
+/**
+ * @tc.name: StartDiscovery001
+ * @tc.desc: Verify wrong parameter
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscAccountTest, StartDiscovery001, TestSize.Level0)
+{
+    if (g_testWay != STARTDISCOVERY_WAY) {
+        printf("[test]start dsicovery test skip...\r\n");
+        EXPECT_TRUE(0 == 0);
+        return;
+    }
+    int32_t ret = TestStartDiscovery();
+    EXPECT_TRUE(ret == 0);
+    Wait();
+};
+
+
+/**
+ * @tc.name: PublishServiceTest001
+ * @tc.desc: Verify wrong parameter
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(DiscAccountTest, PublishServiceTest001, TestSize.Level0)
+{
+    if (g_testWay != PUBLISHSERVICE_WAY) {
+        printf("[test]passive test skip...\r\n");
+        EXPECT_TRUE(0 == 0);
+        return;
+    }
+    int32_t ret = TestPublishServer();
+    EXPECT_TRUE(ret == 0);
+    Wait();
+};
+}

tests/sdk/discovery/benchmarktest/BUILD.gn

@@ -23,6 +23,8 @@ ohos_benchmarktest("DiscoveryTest") {
     "$dsoftbus_root_path/core/common/include",
     "$dsoftbus_root_path/interfaces/kits/discovery",
     "$dsoftbus_root_path/interfaces/kits/common",
+    "$dsoftbus_root_path/sdk/discovery/include",
+    "$dsoftbus_root_path/sdk/discovery/manager/include",
     "//base/security/access_token/interfaces/innerkits/token_setproc/include",
     "//base/security/access_token/interfaces/innerkits/nativetoken/include",
     "//base/security/access_token/interfaces/innerkits/accesstoken/include",

tests/sdk/discovery/benchmarktest/discovery_test.cpp

@@ -15,6 +15,7 @@
 
 #include <benchmark/benchmark.h>
 #include "accesstoken_kit.h"
+#include "discovery_service.h"
 #include "nativetoken_kit.h"
 #include "softbus_bus_center.h"
 #include "token_setproc.h"

tests/sdk/discovery/fuzztest/BUILD.gn

@@ -0,0 +1,17 @@
+# Copyright (c) 2022 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.
+
+group("fuzztest") {
+  testonly = true
+  deps = [ "discoveryservice_fuzzer:DiscoveryServiceFuzzTest" ]
+}

tests/sdk/discovery/fuzztest/discoveryservice_fuzzer/BUILD.gn

@@ -0,0 +1,51 @@
+# Copyright (c) 2022 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.
+
+#####################hydra-fuzz###################
+import("//build/config/features.gni")
+import("//build/ohos.gni")
+import("//build/test.gni")
+import("../../../../../dsoftbus.gni")
+
+##############################fuzztest##########################################
+
+dsoftbus_root_path = "../../../../.."
+
+ohos_fuzztest("DiscoveryServiceFuzzTest") {
+  module_out_path = dsoftbus_fuzz_out_path
+  fuzz_config_file =
+      "$dsoftbus_root_path/tests/sdk/discovery/fuzztest/discoveryservice_fuzzer"
+  include_dirs = [
+    "../../../../../adapter/common/include",
+    "../../../../../core/common/include",
+    "../../../../../core/common/inner_communication",
+    "../../../../../interfaces/kits/common",
+    "../../../../../interfaces/kits/discovery",
+    "../../../../../sdk/discovery/include",
+    "../../../../../sdk/discovery/manager/include",
+    "//commonlibrary/c_utils/base/include",
+  ]
+  cflags = [
+    "-g",
+    "-O0",
+    "-Wno-unused-variable",
+    "-fno-omit-frame-pointer",
+    "-fstack-protector-strong",
+  ]
+  sources = [ "discoveryservice_fuzzer.cpp" ]
+
+  deps = [
+    "$dsoftbus_root_path/adapter:softbus_adapter",
+    "$dsoftbus_root_path/sdk:softbus_client",
+  ]
+}

tests/sdk/discovery/fuzztest/discoveryservice_fuzzer/corpus/init

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+FUZZ

tests/sdk/discovery/fuzztest/discoveryservice_fuzzer/discoveryservice_fuzzer.cpp

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2022-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.
+ */
+
+#include "discoveryservice_fuzzer.h"
+
+#include <cstddef>
+#include <string>
+#include "discovery_service.h"
+
+#define MID_THRESHOLD (UINT8_MAX / FREQ_BUTT * 2)
+#define HIGH_THRESHOLD (UINT8_MAX / FREQ_BUTT * 3)
+#define SUPER_HIGH_THRESHOLD (UINT8_MAX / FREQ_BUTT * 4)
+
+namespace OHOS {
+static std::string TEST_PACKAGE_NAME = "TestPackageName";
+
+static void TestPublishSuccess(int publicId) {}
+static void TestPublishFail(int publishId, PublishFailReason reason) {}
+static IPublishCallback g_publishCallback = {
+    .OnPublishSuccess = TestPublishSuccess,
+    .OnPublishFail = TestPublishFail,
+};
+
+static void TestDeviceFound(const DeviceInfo *device) {}
+static void TestDiscoverFailed(int subscribeId, DiscoveryFailReason failReason) {}
+static void TestDiscoverySuccess(int subscribeId) {}
+static IDiscoveryCallback g_discoveryCallback = {
+    .OnDeviceFound = TestDeviceFound,
+    .OnDiscoverFailed = TestDiscoverFailed,
+    .OnDiscoverySuccess = TestDiscoverySuccess,
+};
+
+static PublishInfo g_publishInfo;
+static DiscoverMode GenerateMode(uint8_t data)
+{
+    if (data < UINT8_MAX / 2) {
+        return DISCOVER_MODE_ACTIVE;
+    }
+    return DISCOVER_MODE_PASSIVE;
+}
+
+static ExchangeMedium GenerateMedium(uint8_t data)
+{
+    if (data < UINT8_MAX / MEDIUM_BUTT) {
+        return AUTO;
+    }
+    if (data < UINT8_MAX / MEDIUM_BUTT * 2) {
+        return BLE;
+    }
+    if (data < UINT8_MAX / MEDIUM_BUTT * 3) {
+        return COAP;
+    }
+    if (data < UINT8_MAX / MEDIUM_BUTT * 4) {
+        return USB;
+    }
+    return COAP1;
+}
+
+static ExchangeFreq GenerateFreq(uint8_t data)
+{
+    if (data < UINT8_MAX / FREQ_BUTT) {
+        return LOW;
+    }
+    if (data < MID_THRESHOLD) {
+        return MID;
+    }
+    if (data < HIGH_THRESHOLD) {
+        return HIGH;
+    }
+    if (data < SUPER_HIGH_THRESHOLD) {
+        return SUPER_HIGH;
+    }
+    return EXTREME_HIGH;
+}
+
+static PublishInfo *GeneratePublishInfo(const uint8_t *data, size_t size)
+{
+    if (size < sizeof(PublishInfo)) {
+        return &g_publishInfo;
+    }
+
+    g_publishInfo.publishId = *data++;
+    g_publishInfo.mode = GenerateMode(*data++);
+    g_publishInfo.medium = GenerateMedium(*data++);
+    g_publishInfo.freq = GenerateFreq(*data);
+
+    return &g_publishInfo;
+}
+
+static SubscribeInfo g_subscribeInfo;
+static SubscribeInfo *GenerateSubscribeInfo(const uint8_t *data, size_t size)
+{
+    if (size < sizeof(SubscribeInfo)) {
+        return &g_subscribeInfo;
+    }
+
+    g_subscribeInfo.subscribeId = *data++;
+    g_subscribeInfo.mode = GenerateMode(*data++);
+    g_subscribeInfo.medium = GenerateMedium(*data++);
+    g_subscribeInfo.freq = GenerateFreq(*data++);
+    g_subscribeInfo.isSameAccount = *data++;
+    g_subscribeInfo.isWakeRemote = *data;
+
+    return &g_subscribeInfo;
+}
+
+void DiscoveryServiceTest(const uint8_t* data, size_t size)
+{
+    PublishService(TEST_PACKAGE_NAME.c_str(), GeneratePublishInfo(data, size), &g_publishCallback);
+    UnPublishService(TEST_PACKAGE_NAME.c_str(), *data);
+    StartDiscovery(TEST_PACKAGE_NAME.c_str(), GenerateSubscribeInfo(data, size), &g_discoveryCallback);
+    StopDiscovery(TEST_PACKAGE_NAME.c_str(), *data);
+}
+} // namespace OHOS
+
+/* Fuzzer entry point */
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int32_t)) {
+        return 0;
+    }
+    OHOS::DiscoveryServiceTest(data, size);
+    return 0;
+}

tests/sdk/discovery/fuzztest/discoveryservice_fuzzer/discoveryservice_fuzzer.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 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 DISCOVERYSERVICE_FUZZER_H
+#define DISCOVERYSERVICE_FUZZER_H
+
+#define FUZZ_PROJECT_NAME "discoveryservice_fuzzer"
+
+#endif // DISCOVERYSERVICE_FUZZER_H

tests/sdk/discovery/fuzztest/discoveryservice_fuzzer/project.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) 2022 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.
+-->
+<fuzz_config>
+  <fuzztest>
+    <!-- maximum length of a test input -->
+    <max_len>1000</max_len>
+    <!-- maximum total time in seconds to run the fuzzer -->
+    <max_total_time>300</max_total_time>
+    <!-- memory usage limit in Mb -->
+    <rss_limit_mb>4096</rss_limit_mb>
+  </fuzztest>
+</fuzz_config>

tests/sdk/discovery/mini_test/BUILD.gn

@@ -0,0 +1,33 @@
+# Copyright (c) 2021 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.
+
+import("//build/lite/config/component/lite_component.gni")
+import("../../../../dsoftbus.gni")
+
+dsoftbus_root_path = "../../../.."
+
+static_library("disc_test") {
+  sources = [ "discover_test.c" ]
+  include_dirs = [
+    "$dsoftbus_root_path/core/common/include",
+    "$dsoftbus_root_path/core/frame/common/include",
+  ]
+  deps =
+      [ "$dsoftbus_root_path/sdk/discovery/service:dsoftbus_disc_service_sdk" ]
+  cflags = [
+    "-Wall",
+    "-fPIC",
+    "-std=c99",
+  ]
+  ldflags = [ "-fPIC" ]
+}

tests/sdk/discovery/mini_test/discover_test.c

@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) 2021-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.
+ */
+
+#include <securec.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "discovery_service.h"
+#include "lwip/netif.h"
+#include "lwip/netifapi.h"
+#include "ohos_init.h"
+#include "softbus_common.h"
+#include "softbus_errcode.h"
+#include "softbus_server_frame.h"
+
+#define NET_WORK_NAME "wlan0"
+#define TEST_CASE_NUM 10
+#define MAXT_WAIT_COUNT 6
+#define WIFI_CONFIG_INTERVAL 10
+#define TEST_COUNT_INTREVAL 5
+#define WAIT_SERVER_READY 5
+#define MAX_TEST_COUNT 20
+#define NSTACKX_MAX_IP_STRING_LEN 20
+#define DISC_TEST_PKG_NAME "DISC_TEST"
+
+static int32_t g_testSuccessCnt = 0;
+
+static int GetSubscribeId(void)
+{
+    static int32_t subscribeId = 0;
+    subscribeId++;
+    return subscribeId;
+}
+
+static int GetPublishId(void)
+{
+    static int32_t publishId = 0;
+    publishId++;
+    return publishId;
+}
+
+static SubscribeInfo g_sInfo1 = {
+    .subscribeId = 1,
+    .medium = COAP,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .freq = MID,
+    .capability = "ddmpCapability",
+    .capabilityData = (unsigned char *)"capdata3",
+    .dataLen = sizeof("capdata3"),
+    .isSameAccount = true,
+    .isWakeRemote = false
+};
+
+static SubscribeInfo g_sInfo2 = {
+    .subscribeId = 1,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .medium = COAP,
+    .freq = MID,
+    .capability = "hicall",
+    .capabilityData = NULL,
+    .dataLen = 0,
+    .isSameAccount = true,
+    .isWakeRemote = false
+};
+
+static SubscribeInfo g_sInfo3 = {
+    .subscribeId = 1,
+    .mode = DISCOVER_MODE_ACTIVE,
+    .medium = COAP,
+    .freq = MID,
+    .capability = "ddmpCapability",
+    .capabilityData = NULL,
+    .dataLen = 0,
+    .isSameAccount = true,
+    .isWakeRemote = false
+};
+
+static PublishInfo g_pInfo1 = {
+    .publishId = 1,
+    .medium = COAP,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .freq = MID,
+    .capability = "dvKit",
+    .capabilityData = (unsigned char *)"capdata4",
+    .dataLen = sizeof("capdata4")
+};
+
+static PublishInfo g_pInfo2 = {
+    .publishId = 1,
+    .mode = DISCOVER_MODE_ACTIVE,
+    .medium = COAP,
+    .freq = MID,
+    .capability = "dvKit",
+    .capabilityData = NULL,
+    .dataLen = 0
+};
+
+static void OnDeviceFound(const DeviceInfo *device)
+{
+    if (device == NULL) {
+        printf("ondevice found device is null\n");
+        return;
+    }
+    printf("***********OnDeviceFound!!!!!******************************************\n");
+    printf("id : %s.\n", device->devId);
+    printf("name : %s.\n", device->devName);
+    printf("device type : %u.\n", device->devType);
+    printf("capNum : %u.\n", device->capabilityBitmapNum);
+    for (uint32_t i = 0; i < device->capabilityBitmapNum; i++) {
+        printf("capBitmap[%u] : %u.\n", i, device->capabilityBitmap[i]);
+    }
+    printf("addr num : %u.\n", device->addrNum);
+    printf("ip : %s.\n", device->addr[0].info.ip.ip);
+    printf("port : %d.\n", device->addr[0].info.ip.port);
+    printf("connect type : %d.\n", device->addr[0].type);
+    printf("peerUid : %s.\n", device->addr[0].peerUid);
+    printf("hw account hash : %s.\n", device->hwAccountHash);
+    printf("**********************************************************************\n");
+    return;
+}
+
+static void TestDeviceFound(const DeviceInfo *device)
+{
+    printf("[client]TestDeviceFound\n");
+    OnDeviceFound(device);
+}
+
+static void TestDiscoverFailed(int subscribeId, DiscoveryFailReason failReason)
+{
+    printf("[client]TestDiscoverFailed, subscribeId = %d, failReason = %d\n", subscribeId, failReason);
+}
+
+static void TestDiscoverySuccess(int subscribeId)
+{
+    printf("[client]TestDiscoverySuccess, subscribeId = %d\n", subscribeId);
+}
+
+static void TestPublishSuccess(int publishId)
+{
+    printf("[client]TestPublishSuccess, publishId = %d\n", publishId);
+}
+
+static void TestPublishFail(int publishId, PublishFailReason reason)
+{
+    printf("[client]TestPublishFail, publishId = %d, PublishFailReason = %d\n", publishId, reason);
+}
+
+static IDiscoveryCallback g_subscribeCb = {
+    .OnDeviceFound = TestDeviceFound,
+    .OnDiscoverFailed = TestDiscoverFailed,
+    .OnDiscoverySuccess = TestDiscoverySuccess
+};
+
+static IPublishCallback g_publishCb = {
+    .OnPublishSuccess = TestPublishSuccess,
+    .OnPublishFail = TestPublishFail
+};
+
+static void GetLocalWifiIp(char *ip, int32_t len)
+{
+    struct netif *wifiNetIf = NULL;
+    ip4_addr_t ipaddr;
+    int32_t ret;
+    int32_t cnt = 0;
+    while (cnt < MAXT_WAIT_COUNT) {
+        cnt++;
+        sleep(WIFI_CONFIG_INTERVAL);
+        wifiNetIf = netifapi_netif_find(NET_WORK_NAME);
+        if (wifiNetIf == NULL) {
+            printf("netif find device failed.\n");
+            continue;
+        }
+        ret = netifapi_netif_get_addr(wifiNetIf, &ipaddr, NULL, NULL);
+        if (ret != 0) {
+            printf("netif get ip addr failed, ret = %d.\n", ret);
+            continue;
+        }
+        if (ipaddr.addr == 0) {
+            printf("wifi is not connected.\n");
+            continue;
+        }
+        break;
+    }
+    inet_ntop(AF_INET, &ipaddr, ip, len);
+    printf("wifi connected, device ip = %s.\n", ip);
+}
+
+static void TestPassivePubSrv1(void)
+{
+    g_pInfo1.publishId = GetPublishId();
+    if (PublishService(DISC_TEST_PKG_NAME, &g_pInfo1, &g_publishCb) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestActivePubSrv2(void)
+{
+    g_pInfo2.publishId = GetPublishId();
+    if (PublishService(DISC_TEST_PKG_NAME, &g_pInfo2, &g_publishCb) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestUnPubSrv1(void)
+{
+    if (UnPublishService(DISC_TEST_PKG_NAME, g_pInfo1.publishId) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestUnPubSrv2(void)
+{
+    if (UnPublishService(DISC_TEST_PKG_NAME, g_pInfo2.publishId) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestPassiveStartDisc1(void)
+{
+    g_sInfo1.subscribeId = GetSubscribeId();
+    if (StartDiscovery(DISC_TEST_PKG_NAME, &g_sInfo1, &g_subscribeCb) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestPassiveStartDisc2(void)
+{
+    g_sInfo2.subscribeId = GetSubscribeId();
+    if (StartDiscovery(DISC_TEST_PKG_NAME, &g_sInfo2, &g_subscribeCb) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestActiveStartDisc3(void)
+{
+    g_sInfo3.subscribeId = GetSubscribeId();
+    if (StartDiscovery(DISC_TEST_PKG_NAME, &g_sInfo3, &g_subscribeCb) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestStopDisc1(void)
+{
+    if (StopDiscovery(DISC_TEST_PKG_NAME, g_sInfo1.subscribeId) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestStopDisc2(void)
+{
+    if (StopDiscovery(DISC_TEST_PKG_NAME, g_sInfo2.subscribeId) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void TestStopDisc3(void)
+{
+    if (StopDiscovery(DISC_TEST_PKG_NAME, g_sInfo3.subscribeId) != SOFTBUS_OK) {
+        printf("test failed, [%s].\n", __FUNCTION__);
+        return;
+    }
+    g_testSuccessCnt++;
+}
+
+static void DiscoveryTestEntry(void)
+{
+    InitSoftBusServer();
+    sleep(WAIT_SERVER_READY);
+
+    char ip[NSTACKX_MAX_IP_STRING_LEN] = {0};
+    int32_t testCnt = 0;
+    GetLocalWifiIp(ip, NSTACKX_MAX_IP_STRING_LEN);
+    while (testCnt < MAX_TEST_COUNT) {
+        TestPassivePubSrv1();
+        TestActivePubSrv2();
+        TestPassiveStartDisc1();
+        TestPassiveStartDisc2();
+        TestActiveStartDisc3();
+        sleep(TEST_COUNT_INTREVAL);
+        TestUnPubSrv1();
+        TestUnPubSrv2();
+        TestStopDisc1();
+        TestStopDisc2();
+        TestStopDisc3();
+        testCnt++;
+        printf("*****test index: %d / %d *******\n", testCnt, MAX_TEST_COUNT);
+        printf("*****success: %d / %d *****\n", g_testSuccessCnt, TEST_CASE_NUM * MAX_TEST_COUNT);
+    }
+}
+
+SYS_SERVICE_INIT_PRI(DiscoveryTestEntry, 4); // 4 : priority

tests/sdk/discovery/unittest/BUILD.gn

@@ -0,0 +1,169 @@
+# Copyright (c) 2021-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.
+
+import("../../../../dsoftbus.gni")
+
+dsoftbus_root_path = "../../../.."
+
+if (defined(ohos_lite)) {
+  import("//build/lite/config/component/lite_component.gni")
+  import("//build/lite/config/test.gni")
+
+  if (ohos_build_type == "debug") {
+    unittest("DiscSdkTest") {
+      output_extension = "bin"
+      output_dir = "$root_out_dir/test/unittest/dsoftbus"
+      sources = [
+        "disc_sdk_test.cpp",
+        "disc_sdk_test_bt_status_virtual.c",
+      ]
+      include_dirs = [
+        "$dsoftbus_root_path/core/common/include",
+        "$dsoftbus_root_path/sdk/bus_center/manager/include",
+        "$dsoftbus_root_path/interfaces/kits/discovery",
+        "$dsoftbus_root_path/interfaces/kits/common",
+        "$dsoftbus_root_path/tests/sdk/common/include",
+      ]
+      deps = [
+        "$dsoftbus_root_path/sdk:softbus_client",
+        "$dsoftbus_root_path/tests/sdk/common:softbus_access_token_test",
+      ]
+    }
+  }
+} else {
+  import("//build/test.gni")
+  module_output_path = "dsoftbus/discovery"
+  ohos_unittest("DiscSdkOnlyL2Test") {
+    module_out_path = module_output_path
+    sources = [ "disc_sdk_only_l2_test.cpp" ]
+    include_dirs = [
+      "$dsoftbus_root_path/core/common/inner_communication",
+      "$dsoftbus_root_path/core/common/include",
+      "$dsoftbus_root_path/interfaces/kits/discovery",
+      "$dsoftbus_root_path/interfaces/kits/common",
+      "$dsoftbus_root_path/sdk/discovery/include",
+      "$dsoftbus_root_path/sdk/discovery/manager/include",
+      "$dsoftbus_root_path/tests/sdk/common/include",
+      "unittest/common/",
+    ]
+    deps = [
+      "$dsoftbus_root_path/sdk:softbus_client",
+      "$dsoftbus_root_path/tests/sdk/common:softbus_access_token_test",
+    ]
+    external_deps = [
+      "bounds_checking_function:libsec_static",
+      "c_utils:utils",
+      "googletest:gtest_main",
+      "hilog:libhilog",
+    ]
+  }
+
+  ohos_unittest("DiscSdkTest") {
+    module_out_path = module_output_path
+    sources = [ "disc_sdk_test.cpp" ]
+    include_dirs = [
+      "$dsoftbus_root_path/sdk/bus_center/manager/include",
+      "$dsoftbus_root_path/core/common/inner_communication",
+      "$dsoftbus_root_path/core/common/include",
+      "$dsoftbus_root_path/interfaces/kits/discovery",
+      "$dsoftbus_root_path/interfaces/kits/common",
+      "$dsoftbus_root_path/sdk/discovery/include",
+      "unittest/common/",
+      "$dsoftbus_root_path/sdk/discovery/manager/include",
+      "$dsoftbus_root_path/tests/sdk/common/include",
+    ]
+    deps = [
+      "$dsoftbus_root_path/sdk:softbus_client",
+      "$dsoftbus_root_path/tests/sdk/common:softbus_access_token_test",
+    ]
+    external_deps = [
+      "bounds_checking_function:libsec_static",
+      "c_utils:utils",
+      "googletest:gtest_main",
+      "hilog:libhilog",
+    ]
+    if (support_bluetooth &&
+        (dsoftbus_feature_conn_br || dsoftbus_feature_conn_ble)) {
+      sources += [ "disc_sdk_test_bt_status.c" ]
+      external_deps += [ "bluetooth:btframework" ]
+    } else {
+      sources += [ "disc_sdk_test_bt_status_virtual.c" ]
+    }
+  }
+
+  ohos_unittest("DiscSdkAutoTest") {
+    sanitize = {
+      cfi = true
+      cfi_cross_dso = true
+      debug = false
+    }
+    module_out_path = module_output_path
+    sources = [ "disc_sdk_auto_test.cpp" ]
+    include_dirs = [
+      "$dsoftbus_root_path/core/common/include",
+      "$dsoftbus_root_path/tests/sdk/common/include",
+      "$dsoftbus_root_path/interfaces/kits/common",
+      "$dsoftbus_root_path/interfaces/kits/discovery",
+    ]
+    deps = [
+      "$dsoftbus_root_path/sdk:softbus_client",
+      "$dsoftbus_root_path/tests/sdk/common:softbus_access_token_test",
+    ]
+    external_deps = [
+      "bounds_checking_function:libsec_static",
+      "c_utils:utils",
+      "googletest:gtest_main",
+      "hilog:libhilog",
+    ]
+    if (support_bluetooth &&
+        (dsoftbus_feature_conn_br || dsoftbus_feature_conn_ble)) {
+      sources += [ "disc_sdk_test_bt_status.c" ]
+      external_deps += [ "bluetooth:btframework" ]
+    } else {
+      sources += [ "disc_sdk_test_bt_status_virtual.c" ]
+    }
+  }
+
+  ohos_unittest("DiscSdkManagerTest") {
+    module_out_path = module_output_path
+    sources = [ "disc_sdk_manager_test.cpp" ]
+    include_dirs = [
+      "$dsoftbus_root_path/core/common/include",
+      "$dsoftbus_root_path/interfaces/kits/common",
+      "$dsoftbus_root_path/interfaces/kits/discovery",
+      "$dsoftbus_root_path/sdk/discovery/ipc/include",
+      "$dsoftbus_root_path/sdk/discovery/ipc/standard/include",
+      "$dsoftbus_root_path/sdk/discovery/manager/include",
+      "$dsoftbus_root_path/tests/sdk/common/include",
+    ]
+    deps = [
+      "$dsoftbus_root_path/sdk:softbus_client",
+      "$dsoftbus_root_path/tests/sdk/common:softbus_access_token_test",
+    ]
+    external_deps = [
+      "c_utils:utils",
+      "googletest:gtest_main",
+      "hilog:libhilog",
+    ]
+  }
+
+  group("unittest") {
+    testonly = true
+    deps = [
+      ":DiscSdkAutoTest",
+      ":DiscSdkManagerTest",
+      ":DiscSdkOnlyL2Test",
+      ":DiscSdkTest",
+    ]
+  }
+}

tests/sdk/discovery/unittest/disc_sdk_manager_test.cpp

@@ -0,0 +1,366 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include "client_disc_manager.h"
+#include "disc_server_proxy.h"
+#include "softbus_errcode.h"
+
+using namespace testing::ext;
+
+namespace OHOS {
+static int32_t g_subscribeId = 0;
+static int32_t g_publishId = 0;
+static char g_pkgName[] = "Softbus_Kits";
+static bool g_isFound = false;
+static bool g_discSuccessFlag = false;
+static bool g_discFailedFlag = false;
+static bool g_pubSuccessFlag = false;
+static bool g_pubFailedFlag = false;
+
+class DiscSdkManagerTest : public testing::Test {
+public:
+    DiscSdkManagerTest()
+    {}
+    ~DiscSdkManagerTest()
+    {}
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp() override
+    {}
+    void TearDown() override
+    {}
+};
+
+void DiscSdkManagerTest::SetUpTestCase(void)
+{}
+
+void DiscSdkManagerTest::TearDownTestCase(void)
+{}
+
+static SubscribeInfo g_subscribeInfo = {
+    .subscribeId = 1,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .medium = COAP,
+    .freq = MID,
+    .isSameAccount = true,
+    .isWakeRemote = false,
+    .capability = "dvKit",
+    .capabilityData = (unsigned char *)"capdata",
+    .dataLen = strlen("capdata")
+};
+
+static PublishInfo g_publishInfo = {
+    .publishId = 1,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .medium = COAP,
+    .freq = MID,
+    .capability = "dvKit",
+    .capabilityData = (unsigned char *)"capdata",
+    .dataLen = strlen("capdata")
+};
+
+static void TestDeviceFound(const DeviceInfo *device)
+{
+    printf("[client]TestDeviceFound\n");
+    g_isFound = true;
+}
+
+static void TestDiscoverFailed(int32_t subscribeId, DiscoveryFailReason failReason)
+{
+    printf("[client]TestDiscoverFailed\n");
+    g_discFailedFlag = true;
+}
+
+static void TestDiscoverySuccess(int32_t subscribeId)
+{
+    printf("[client]TestDiscoverySuccess\n");
+    g_discSuccessFlag = true;
+}
+
+static void TestPublishSuccess(int32_t publishId)
+{
+    printf("[client]TestPublishSuccess\n");
+    g_pubSuccessFlag = true;
+}
+
+static void TestPublishFail(int32_t publishId, PublishFailReason reason)
+{
+    printf("[client]TestPublishFail\n");
+    g_pubFailedFlag = true;
+}
+
+static IDiscoveryCallback g_subscribeCb = {
+    .OnDeviceFound = TestDeviceFound,
+    .OnDiscoverFailed = TestDiscoverFailed,
+    .OnDiscoverySuccess = TestDiscoverySuccess
+};
+
+static IPublishCallback g_publishCb = {
+    .OnPublishSuccess = TestPublishSuccess,
+    .OnPublishFail = TestPublishFail
+};
+
+/**
+ * @tc.name: PublishServiceInnerTest001
+ * @tc.desc: Test PublishServiceInner when ServerIpcPublishService failed.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, PublishServiceInnerTest001, TestSize.Level1)
+{
+    int32_t ret = DiscClientInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+    ret = PublishServiceInner(g_pkgName, &g_publishInfo, &g_publishCb);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+    DiscClientDeinit();
+}
+
+/**
+ * @tc.name: UnpublishServiceInnerTest001
+ * @tc.desc: Test UnpublishServiceInner when ServerIpcUnPublishService failed.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, UnpublishServiceInnerTest001, TestSize.Level1)
+{
+    int32_t ret = UnpublishServiceInner(g_pkgName, g_publishId);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+}
+
+/**
+ * @tc.name: StartDiscoveryInnerTest001
+ * @tc.desc: Test StartDiscoveryInner when ServerIpcStartDiscovery failed.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, StartDiscoveryInnerTest001, TestSize.Level1)
+{
+    int32_t ret = DiscClientInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+    ret = StartDiscoveryInner(g_pkgName, &g_subscribeInfo, &g_subscribeCb);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+    DiscClientDeinit();
+}
+
+/**
+ * @tc.name: StopDiscoveryInnerTest001
+ * @tc.desc: Test StopDiscoveryInner when ServerIpcStopDiscovery failed.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, StopDiscoveryInnerTest001, TestSize.Level1)
+{
+    int32_t ret = StopDiscoveryInner(g_pkgName, g_subscribeId);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+}
+
+/**
+ * @tc.name: DiscClientOnDeviceFoundTest001
+ * @tc.desc: The first call to DiscClientOnDeviceFound parameter is null, the second call g_discInfo is not
+ *           initialized, and the third call is normal.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: Test DiscClientOnDeviceFound when g_discInfo is null and normal.
+ */
+HWTEST_F(DiscSdkManagerTest, DiscClientOnDeviceFoundTest001, TestSize.Level1)
+{
+    DeviceInfo device;
+    DiscClientOnDeviceFound(nullptr);
+    EXPECT_FALSE(g_isFound);
+    DiscClientOnDeviceFound(&device);
+    EXPECT_FALSE(g_isFound);
+    int32_t ret = DiscClientInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+    ret = StartDiscoveryInner(g_pkgName, &g_subscribeInfo, &g_subscribeCb);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+    DiscClientOnDeviceFound(&device);
+    EXPECT_TRUE(g_isFound);
+    DiscClientDeinit();
+}
+
+/**
+ * @tc.name: DiscClientOnDiscoverySuccessTest001
+ * @tc.desc: The first call to DiscClientOnDiscoverySuccess g_discInfo is null, the second call is normal.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: Test DiscClientOnDiscoverySuccess when g_discInfo is null and normal.
+ */
+HWTEST_F(DiscSdkManagerTest, DiscClientOnDiscoverySuccessTest001, TestSize.Level1)
+{
+    DiscClientOnDiscoverySuccess(g_subscribeId);
+    EXPECT_FALSE(g_discSuccessFlag);
+    int32_t ret = DiscClientInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+    ret = StartDiscoveryInner(g_pkgName, &g_subscribeInfo, &g_subscribeCb);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+    DiscClientOnDiscoverySuccess(g_subscribeId);
+    EXPECT_TRUE(g_discSuccessFlag);
+    DiscClientDeinit();
+}
+
+/**
+ * @tc.name: DiscClientOnDiscoverFailedTest001
+ * @tc.desc: The first call to DiscClientOnDiscoverFailed g_discInfo is null, the second call is normal.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: Test DiscClientOnDiscoverFailed when g_discInfo is null and normal.
+ */
+HWTEST_F(DiscSdkManagerTest, DiscClientOnDiscoverFailedTest001, TestSize.Level1)
+{
+    DiscClientOnDiscoverFailed(g_subscribeId, DISCOVERY_FAIL_REASON_NOT_SUPPORT_MEDIUM);
+    EXPECT_FALSE(g_discFailedFlag);
+    int32_t ret = DiscClientInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+    ret = StartDiscoveryInner(g_pkgName, &g_subscribeInfo, &g_subscribeCb);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+    DiscClientOnDiscoverFailed(g_subscribeId, DISCOVERY_FAIL_REASON_NOT_SUPPORT_MEDIUM);
+    EXPECT_TRUE(g_discFailedFlag);
+    DiscClientDeinit();
+}
+
+/**
+ * @tc.name: DiscClientOnPublishSuccessTest001
+ * @tc.desc: The first call to DiscClientOnPublishSuccess g_discInfo is null, the second call is normal.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: Test DiscClientOnPublishSuccess when g_discInfo is null and normal.
+ */
+HWTEST_F(DiscSdkManagerTest, DiscClientOnPublishSuccessTest001, TestSize.Level1)
+{
+    DiscClientOnPublishSuccess(g_publishId);
+    EXPECT_FALSE(g_pubSuccessFlag);
+    int32_t ret = DiscClientInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+    ret = PublishServiceInner(g_pkgName, &g_publishInfo, &g_publishCb);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+    DiscClientOnPublishSuccess(g_publishId);
+    EXPECT_TRUE(g_pubSuccessFlag);
+    DiscClientDeinit();
+}
+
+/**
+ * @tc.name: DiscClientOnPublishFailTest001
+ * @tc.desc: The first call to DiscClientOnPublishFail g_discInfo is null, the second call is normal.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: Test DiscClientOnPublishFail when g_discInfo is null and normal.
+ */
+HWTEST_F(DiscSdkManagerTest, DiscClientOnPublishFailTest001, TestSize.Level1)
+{
+    DiscClientOnPublishFail(g_publishId, PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM);
+    EXPECT_FALSE(g_pubFailedFlag);
+    int32_t ret = DiscClientInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+    ret = PublishServiceInner(g_pkgName, &g_publishInfo, &g_publishCb);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+    DiscClientOnPublishFail(g_publishId, PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM);
+    EXPECT_TRUE(g_pubFailedFlag);
+    DiscClientDeinit();
+}
+
+/**
+ * @tc.name: DiscServerProxyInitTest001
+ * @tc.desc: Test DiscServerProxyInit again.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is initialized and return SOFTBUS_OK.
+ */
+HWTEST_F(DiscSdkManagerTest, DiscServerProxyInitTest001, TestSize.Level1)
+{
+    int32_t ret = DiscServerProxyInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    ret = DiscServerProxyInit();
+    EXPECT_EQ(ret, SOFTBUS_OK);
+    DiscServerProxyDeInit();
+}
+
+/**
+ * @tc.name: ServerIpcPublishServiceTest001
+ * @tc.desc: Test the first call to ServerIpcPublishService.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, ServerIpcPublishServiceTest001, TestSize.Level1)
+{
+    int32_t ret = ServerIpcPublishService(g_pkgName, &g_publishInfo);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+}
+
+/**
+ * @tc.name: ServerIpcUnPublishServiceTest001
+ * @tc.desc: Test the first call to ServerIpcUnPublishService.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, ServerIpcUnPublishServiceTest001, TestSize.Level1)
+{
+    int32_t ret = ServerIpcUnPublishService(g_pkgName, g_publishId);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+}
+
+/**
+ * @tc.name: ServerIpcStartDiscoveryTest001
+ * @tc.desc: Test the first call to ServerIpcStartDiscovery.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, ServerIpcStartDiscoveryTest001, TestSize.Level1)
+{
+    int32_t ret = ServerIpcStartDiscovery(g_pkgName, &g_subscribeInfo);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+}
+
+/**
+ * @tc.name: ServerIpcStopDiscoveryTest001
+ * @tc.desc: Test the first call to ServerIpcStopDiscovery.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The g_serverProxy is not initialized and return SOFTBUS_NO_INIT.
+ */
+HWTEST_F(DiscSdkManagerTest, ServerIpcStopDiscoveryTest001, TestSize.Level1)
+{
+    int32_t ret = ServerIpcStopDiscovery(g_pkgName, g_subscribeId);
+    EXPECT_EQ(ret, SOFTBUS_NO_INIT);
+}
+} // namespace OHOS

tests/sdk/discovery/unittest/disc_sdk_only_l2_test.cpp

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2022-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 <cstdio>
+#include <ctime>
+#include <gtest/gtest.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "softbus_access_token_test.h"
+#include "softbus_bus_center.h"
+
+using namespace testing::ext;
+
+namespace OHOS {
+static int g_subscribeId = 0;
+static int g_publishId = 0;
+static const char *g_pkgName = "Softbus_Kits";
+
+class DiscSdkOnlyL2Test : public testing::Test {
+public:
+    DiscSdkOnlyL2Test()
+    {}
+    ~DiscSdkOnlyL2Test()
+    {}
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp() override
+    {}
+    void TearDown() override
+    {}
+};
+
+void DiscSdkOnlyL2Test::SetUpTestCase(void)
+{
+    SetAceessTokenPermission("discSdkOnlyL2Test");
+}
+
+void DiscSdkOnlyL2Test::TearDownTestCase(void)
+{}
+
+static int GetSubscribeId(void)
+{
+    g_subscribeId++;
+    return g_subscribeId;
+}
+
+static int GetPublishId(void)
+{
+    g_publishId++;
+    return g_publishId;
+}
+
+static SubscribeInfo g_sInfo = {
+    .subscribeId = 1,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .medium = COAP,
+    .freq = MID,
+    .isSameAccount = true,
+    .isWakeRemote = false,
+    .capability = "dvKit",
+    .capabilityData = (unsigned char *)"capdata3",
+    .dataLen = strlen("capdata3")
+};
+
+static PublishInfo g_pInfo = {
+    .publishId = 1,
+    .mode = DISCOVER_MODE_PASSIVE,
+    .medium = COAP,
+    .freq = MID,
+    .capability = "dvKit",
+    .capabilityData = (unsigned char *)"capdata4",
+    .dataLen = strlen("capdata4")
+};
+
+static void TestDeviceFound(const DeviceInfo *device)
+{
+    printf("[client]TestDeviceFound\n");
+}
+
+static void TestOnDiscoverResult(int32_t refreshId, RefreshResult reason)
+{
+    (void)refreshId;
+    (void)reason;
+    printf("[client]TestDiscoverResult\n");
+}
+
+static void TestOnPublishResult(int publishId, PublishResult reason)
+{
+    (void)publishId;
+    (void)reason;
+    printf("[client]TestPublishResult\n");
+}
+
+static IRefreshCallback g_refreshCb = {
+    .OnDeviceFound = TestDeviceFound,
+    .OnDiscoverResult = TestOnDiscoverResult
+};
+
+static IPublishCb g_publishCb = {
+    .OnPublishResult = TestOnPublishResult,
+};
+
+/**
+ * @tc.name: StopPublishLNNTest004
+ * @tc.desc: not start publish.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The StopPublishLNN operates normally.
+ */
+HWTEST_F(DiscSdkOnlyL2Test, StopPublishLNNTest001, TestSize.Level2)
+{
+    int ret;
+    int tmpId = GetPublishId();
+
+    ret = StopPublishLNN(g_pkgName, tmpId);
+    EXPECT_TRUE(ret != 0);
+}
+
+/**
+ * @tc.name: StopPublishLNNTest005
+ * @tc.desc: Verify StopPublishLNN again.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The StopPublishLNN operates normally.
+ */
+HWTEST_F(DiscSdkOnlyL2Test, StopPublishLNNTest002, TestSize.Level2)
+{
+    int ret;
+    int tmpId = GetPublishId();
+
+    g_pInfo.publishId = tmpId;
+    PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
+    ret = StopPublishLNN(g_pkgName, tmpId);
+    EXPECT_TRUE(ret == 0);
+    ret = StopPublishLNN(g_pkgName, tmpId);
+    EXPECT_TRUE(ret != 0);
+}
+
+/**
+ * @tc.name: StopRefreshLNNTest004
+ * @tc.desc: not start discover.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The StopRefreshLNN operates normally.
+ */
+HWTEST_F(DiscSdkOnlyL2Test, StopRefreshLNNTest001, TestSize.Level2)
+{
+    int ret;
+    int tmpId = GetSubscribeId();
+
+    ret = StopRefreshLNN(g_pkgName, tmpId);
+    EXPECT_TRUE(ret != 0);
+}
+
+/**
+ * @tc.name: StopRefreshLNNTest005
+ * @tc.desc: Verify StopRefreshLNN again.
+ * @tc.in: Test Moudle, Test Number, Test Levels.
+ * @tc.out: NonZero
+ * @tc.type: FUNC
+ * @tc.require: The StopRefreshLNN operates normally.
+ */
+HWTEST_F(DiscSdkOnlyL2Test, StopRefreshLNNTest002, TestSize.Level2)
+{
+    int ret;
+    int tmpId = GetSubscribeId();
+
+    g_sInfo.subscribeId = tmpId;
+    RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
+    ret = StopRefreshLNN(g_pkgName, tmpId);
+    EXPECT_TRUE(ret == 0);
+    ret = StopRefreshLNN(g_pkgName, tmpId);
+    EXPECT_TRUE(ret != 0);
+}
+} // namespace OHOS

tests/sdk/discovery/unittest/disc_sdk_test_bt_status.c

@@ -0,0 +1,23 @@
+/*
+ * 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 "disc_sdk_test_bt_status.h"
+
+#include "c_header/ohos_bt_gap.h"
+
+bool SoftbusTestGetBtStatus(void)
+{
+    return IsBleEnabled();
+}

tests/sdk/discovery/unittest/disc_sdk_test_bt_status.h

@@ -0,0 +1,30 @@
+/*
+ * 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 DISC_SDK_TEST_BT_STATUS_H
+#define DISC_SDK_TEST_BT_STATUS_H
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool SoftbusTestGetBtStatus(void);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // DISC_SDK_TEST_BT_STATUS_H