diff --git a/frameworks/native/distributed_file_inner/include/distributed_file_daemon_manager_impl.h b/frameworks/native/distributed_file_inner/include/distributed_file_daemon_manager_impl.h
index 686fcfe6ec24d4f91f84edcd264c69864ce30081..a073609d5d59cd684fa63a2b37fc079a7e585c49 100644
--- a/frameworks/native/distributed_file_inner/include/distributed_file_daemon_manager_impl.h
+++ b/frameworks/native/distributed_file_inner/include/distributed_file_daemon_manager_impl.h
@@ -63,6 +63,9 @@ public:
     int32_t GetDfsSwitchStatus(const std::string &networkId, int32_t &switchStatus) override;
     int32_t UpdateDfsSwitchStatus(int32_t switchStatus) override;
     int32_t GetConnectedDeviceList(std::vector<DfsDeviceInfo> &deviceList) override;
+    int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener) override;
+    int32_t UnregisterFileDfsListener(const std::string &instanceId) override;
+    int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount) override;
 private:
     DistributedFileDaemonManagerImpl() = default;
 };
diff --git a/frameworks/native/distributed_file_inner/include/distributed_file_daemon_proxy.h b/frameworks/native/distributed_file_inner/include/distributed_file_daemon_proxy.h
index 8dbe49c759c20c4bd2074e733aa625b9bd6a0aa6..755e8d11dca9c6af215f29e47757021c631c7990 100644
--- a/frameworks/native/distributed_file_inner/include/distributed_file_daemon_proxy.h
+++ b/frameworks/native/distributed_file_inner/include/distributed_file_daemon_proxy.h
@@ -66,6 +66,9 @@ public:
     int32_t GetDfsSwitchStatus(const std::string &networkId, int32_t &switchStatus) override;
     int32_t UpdateDfsSwitchStatus(int32_t switchStatus) override;
     int32_t GetConnectedDeviceList(std::vector<DfsDeviceInfo> &deviceList) override;
+    int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener) override;
+    int32_t UnregisterFileDfsListener(const std::string &instanceId) override;
+    int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount) override;
 private:
     class DaemonDeathRecipient : public IRemoteObject::DeathRecipient {
     public:
diff --git a/frameworks/native/distributed_file_inner/src/distributed_file_daemon_manager_impl.cpp b/frameworks/native/distributed_file_inner/src/distributed_file_daemon_manager_impl.cpp
index dcb03d52c85931069cc59da0c0410afea88a73e3..68f3762e38c1cbaf24929c9d173959536842c171 100644
--- a/frameworks/native/distributed_file_inner/src/distributed_file_daemon_manager_impl.cpp
+++ b/frameworks/native/distributed_file_inner/src/distributed_file_daemon_manager_impl.cpp
@@ -180,6 +180,37 @@ int32_t DistributedFileDaemonManagerImpl::GetConnectedDeviceList(std::vector<Dfs
     return distributedFileDaemonProxy->GetConnectedDeviceList(deviceList);
 }
 
+int32_t DistributedFileDaemonManagerImpl::RegisterFileDfsListener(const std::string &instanceId,
+    const sptr<IFileDfsListener> &listener)
+{
+    auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
+    if (distributedFileDaemonProxy == nullptr) {
+        LOGE("proxy is null");
+        return OHOS::FileManagement::E_SA_LOAD_FAILED;
+    }
+    return distributedFileDaemonProxy->RegisterFileDfsListener(instanceId, listener);
+}
+
+int32_t DistributedFileDaemonManagerImpl::UnregisterFileDfsListener(const std::string &instanceId)
+{
+    auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
+    if (distributedFileDaemonProxy == nullptr) {
+        LOGE("proxy is null");
+        return OHOS::FileManagement::E_SA_LOAD_FAILED;
+    }
+    return distributedFileDaemonProxy->UnregisterFileDfsListener(instanceId);
+}
+
+int32_t DistributedFileDaemonManagerImpl::IsSameAccountDevice(const std::string &networkId, bool &isSameAccount)
+{
+    auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
+    if (distributedFileDaemonProxy == nullptr) {
+        LOGE("proxy is null");
+        return OHOS::FileManagement::E_SA_LOAD_FAILED;
+    }
+    return distributedFileDaemonProxy->IsSameAccountDevice(networkId, isSameAccount);
+}
+
 int32_t DistributedFileDaemonManagerImpl::RegisterAssetCallback(const sptr<IAssetRecvCallback> &recvCallback)
 {
     LOGI("DistributedFileDaemonManagerImpl registerAssetCallback enter.");
diff --git a/frameworks/native/distributed_file_inner/src/distributed_file_daemon_proxy.cpp b/frameworks/native/distributed_file_inner/src/distributed_file_daemon_proxy.cpp
index c8be941489ab06a292a65afd52b32791d51ac624..69db3508565573c930f13ab1519fd3662a1660b6 100644
--- a/frameworks/native/distributed_file_inner/src/distributed_file_daemon_proxy.cpp
+++ b/frameworks/native/distributed_file_inner/src/distributed_file_daemon_proxy.cpp
@@ -777,6 +777,119 @@ int32_t DistributedFileDaemonProxy::GetConnectedDeviceList(std::vector<DfsDevice
     }
     return ret;
 }
+
+int32_t DistributedFileDaemonProxy::RegisterFileDfsListener(const std::string &instanceId,
+    const sptr<IFileDfsListener> &listener)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        LOGE("Failed to write interface token");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (!data.WriteString(instanceId)) {
+        LOGE("Failed to write instance id.");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (listener == nullptr) {
+        LOGE("Listener is nullptr.");
+        return OHOS::FileManagement::E_INVAL_ARG;
+    }
+    if (!data.WriteRemoteObject(listener->AsObject())) {
+        LOGE("Fail to WriteRemoteObject");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    auto remote = Remote();
+    if (remote == nullptr) {
+        LOGE("Remote is nullptr");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    int32_t ret = remote->SendRequest(
+        static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REGISTER_FILE_DFS_LISTENER), data,
+        reply, option);
+    if (ret != FileManagement::E_OK) {
+        LOGE("RegisterFileDfsListener ipc failed, ret: %{public}d", ret);
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (!reply.ReadInt32(ret)) {
+        LOGE("Read ret failed");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    return ret;
+}
+
+int32_t DistributedFileDaemonProxy::UnregisterFileDfsListener(const std::string &instanceId)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        LOGE("Failed to write interface token");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (!data.WriteString(instanceId)) {
+        LOGE("Failed to write instance id.");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    auto remote = Remote();
+    if (remote == nullptr) {
+        LOGE("Remote is nullptr");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    int32_t ret = remote->SendRequest(
+        static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_UNREGISTER_FILE_DFS_LISTENER), data,
+        reply, option);
+    if (ret != FileManagement::E_OK) {
+        LOGE("UnregisterFileDfsListener ipc failed, ret: %{public}d", ret);
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (!reply.ReadInt32(ret)) {
+        LOGE("Read ret failed");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    return ret;
+}
+
+int32_t DistributedFileDaemonProxy::IsSameAccountDevice(const std::string &networkId, bool &isSameAccount)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        LOGE("Failed to write interface token");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (!data.WriteString(networkId)) {
+        LOGE("Failed to write network id.");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    auto remote = Remote();
+    if (remote == nullptr) {
+        LOGE("Remote is nullptr");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    int32_t ret = remote->SendRequest(
+        static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_IS_SAME_ACCOUNT_DEVICE), data,
+        reply, option);
+    if (ret != FileManagement::E_OK) {
+        LOGE("IsSameAccountDevice ipc failed, ret: %{public}d", ret);
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (!reply.ReadInt32(ret)) {
+        LOGE("Read ret failed");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    if (ret != OHOS::FileManagement::E_OK) {
+        LOGE("IsSameAccountDevice failed, ret: %{public}d", ret);
+        return ret;
+    }
+    if (!reply.ReadBool(isSameAccount)) {
+        LOGE("Read isSameAccount failed");
+        return OHOS::FileManagement::E_BROKEN_IPC;
+    }
+    return ret;
+}
 } // namespace DistributedFile
 } // namespace Storage
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/distributedfiledaemon/include/ipc/daemon.h b/services/distributedfiledaemon/include/ipc/daemon.h
index e21c348e07b6d93ce33f7fad8f6667bcba0eb32d..db1acafe321904cc6ef77e3d3089feb87fd49b0e 100644
--- a/services/distributedfiledaemon/include/ipc/daemon.h
+++ b/services/distributedfiledaemon/include/ipc/daemon.h
@@ -99,6 +99,9 @@ public:
     int32_t GetDfsSwitchStatus(const std::string &networkId, int32_t &switchStatus) override;
     int32_t UpdateDfsSwitchStatus(int32_t switchStatus) override;
     int32_t GetConnectedDeviceList(std::vector<DfsDeviceInfo> &deviceList) override;
+    int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener) override;
+    int32_t UnregisterFileDfsListener(const std::string &instanceId) override;
+    int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount) override;
 
 private:
     Daemon();
diff --git a/services/distributedfiledaemon/include/ipc/daemon_stub.h b/services/distributedfiledaemon/include/ipc/daemon_stub.h
index 22e1ffae585fafca12141abb98fc5a46d690ac58..5d67c70aabd8e599c511303af6e40d6b8be39061 100644
--- a/services/distributedfiledaemon/include/ipc/daemon_stub.h
+++ b/services/distributedfiledaemon/include/ipc/daemon_stub.h
@@ -54,6 +54,10 @@ private:
     int32_t HandleGetDfsSwitchStatus(MessageParcel &data, MessageParcel &reply);
     int32_t HandleUpdateDfsSwitchStatus(MessageParcel &data, MessageParcel &reply);
     int32_t HandleGetConnectedDeviceList(MessageParcel &data, MessageParcel &reply);
+    int32_t HandleRegisterFileDfsListener(MessageParcel &data, MessageParcel &reply);
+    int32_t HandleUnregisterFileDfsListener(MessageParcel &data, MessageParcel &reply);
+    int32_t HandleIsSameAccountDevice(MessageParcel &data, MessageParcel &reply);
+    void InitDFileFunction();
 };
 } // namespace DistributedFile
 } // namespace Storage
diff --git a/services/distributedfiledaemon/include/ipc/distributed_file_daemon_ipc_interface_code.h b/services/distributedfiledaemon/include/ipc/distributed_file_daemon_ipc_interface_code.h
index 7ecd93d32645c7427a3c8e6704fcdfa2cbc80451..4a14a2e71fe2d4abce7158cfb805df84115758ae 100644
--- a/services/distributedfiledaemon/include/ipc/distributed_file_daemon_ipc_interface_code.h
+++ b/services/distributedfiledaemon/include/ipc/distributed_file_daemon_ipc_interface_code.h
@@ -35,7 +35,10 @@ namespace DistributedFile {
         GET_DFS_URI_IS_DIR_FROM_LOCAL,
         DISTRIBUTED_FILE_GET_DFS_SWITCH_STATUS,
         DISTRIBUTED_FILE_UPDATE_DFS_SWITCH_STATUS,
-        DISTRIBUTED_FILE_GET_CONNECTED_DEVICE_LIST
+        DISTRIBUTED_FILE_GET_CONNECTED_DEVICE_LIST,
+        DISTRIBUTED_FILE_REGISTER_FILE_DFS_LISTENER,
+        DISTRIBUTED_FILE_UNREGISTER_FILE_DFS_LISTENER,
+        DISTRIBUTED_FILE_IS_SAME_ACCOUNT_DEVICE
     };
 } // namespace DistributedFile
 } // namespace Storage
diff --git a/services/distributedfiledaemon/include/ipc/distributed_file_daemon_manager.h b/services/distributedfiledaemon/include/ipc/distributed_file_daemon_manager.h
index 13aadf6b53f3b631f616d3ec309d42683b2defe1..c53a6a86be2dcda87427922da0038d2772abfe30 100644
--- a/services/distributedfiledaemon/include/ipc/distributed_file_daemon_manager.h
+++ b/services/distributedfiledaemon/include/ipc/distributed_file_daemon_manager.h
@@ -60,9 +60,14 @@ public:
     virtual int32_t Copy(const std::string &srcUri, const std::string &destUri, ProcessCallback processCallback) = 0;
     virtual int32_t Cancel(const std::string &srcUri, const std::string &destUri) = 0;
     virtual int32_t Cancel() = 0;
+
+    // distributed filemanager&picker
     virtual int32_t GetDfsSwitchStatus(const std::string &networkId, int32_t &switchStatus) = 0;
     virtual int32_t UpdateDfsSwitchStatus(int32_t switchStatus) = 0;
     virtual int32_t GetConnectedDeviceList(std::vector<DfsDeviceInfo> &deviceList) = 0;
+    virtual int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener) = 0;
+    virtual int32_t UnregisterFileDfsListener(const std::string &instanceId) = 0;
+    virtual int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount) = 0;
 };
 } // namespace DistributedFile
 } // namespace Storage
diff --git a/services/distributedfiledaemon/include/ipc/i_daemon.h b/services/distributedfiledaemon/include/ipc/i_daemon.h
index 67ef3ad08d8f7e8a5f89a58e5b52296f5d4bb5bd..b902a2be5bca27c90f69607288d52cdb95de5ef1 100644
--- a/services/distributedfiledaemon/include/ipc/i_daemon.h
+++ b/services/distributedfiledaemon/include/ipc/i_daemon.h
@@ -66,6 +66,9 @@ public:
     virtual int32_t GetDfsSwitchStatus(const std::string &networkId, int32_t &switchStatus) = 0;
     virtual int32_t UpdateDfsSwitchStatus(int32_t switchStatus) = 0;
     virtual int32_t GetConnectedDeviceList(std::vector<DfsDeviceInfo> &deviceList) = 0;
+    virtual int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener) = 0;
+    virtual int32_t UnregisterFileDfsListener(const std::string &instanceId) = 0;
+    virtual int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount) = 0;
     DECLARE_INTERFACE_DESCRIPTOR(u"ohos.storage.distributedfile.daemon")
 };
 } // namespace DistributedFile
diff --git a/services/distributedfiledaemon/src/ipc/daemon.cpp b/services/distributedfiledaemon/src/ipc/daemon.cpp
index 6dc310f055b6fea9d2f628b064cef7bd72dbdc1a..d1443ae4476f11b5225c729f810552d68d66c7da 100644
--- a/services/distributedfiledaemon/src/ipc/daemon.cpp
+++ b/services/distributedfiledaemon/src/ipc/daemon.cpp
@@ -995,6 +995,24 @@ int32_t Daemon::GetConnectedDeviceList(std::vector<DfsDeviceInfo> &deviceList)
     return E_OK;
 }
 
+int32_t Daemon::RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener)
+{
+    LOGI("RegisterFileDfsListener enter, instanceId: %{public}s", instanceId.c_str());
+    return E_OK;
+}
+
+int32_t Daemon::UnregisterFileDfsListener(const std::string &instanceId)
+{
+    LOGI("UnregisterFileDfsListener enter, instanceId: %{public}s", instanceId.c_str());
+    return E_OK;
+}
+
+int32_t Daemon::IsSameAccountDevice(const std::string &networkId, bool &isSameAccount)
+{
+    LOGI("IsSameAccountDevice enter, instanceId: %{public}s", Utils::GetAnonyString(networkId).c_str());
+    return E_OK;
+}
+
 void Daemon::DisconnectByRemote(const string &networkId)
 {
     LOGI("start DisconnectByRemote");
diff --git a/services/distributedfiledaemon/src/ipc/daemon_stub.cpp b/services/distributedfiledaemon/src/ipc/daemon_stub.cpp
index acf73d0a595a1a468ad12acdc113aa5b53e9c6d8..df6ac89af9af9aae46297712614f4702bee611c7 100644
--- a/services/distributedfiledaemon/src/ipc/daemon_stub.cpp
+++ b/services/distributedfiledaemon/src/ipc/daemon_stub.cpp
@@ -21,8 +21,9 @@
 #include "dm_device_info.h"
 #include "ipc/distributed_file_daemon_ipc_interface_code.h"
 #include "ipc_skeleton.h"
-#include "utils_log.h"
 #include "securec.h"
+#include "utils_log.h"
+
 
 namespace OHOS {
 namespace Storage {
@@ -65,6 +66,11 @@ DaemonStub::DaemonStub()
         &DaemonStub::HandlePushAsset;
     opToInterfaceMap_[static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::GET_DFS_URI_IS_DIR_FROM_LOCAL)] =
         &DaemonStub::HandleGetDfsUrisDirFromLocal;
+    InitDFileFunction();
+}
+
+void DaemonStub::InitDFileFunction()
+{
     opToInterfaceMap_[static_cast<uint32_t>(
         DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_GET_DFS_SWITCH_STATUS)] =
         &DaemonStub::HandleGetDfsSwitchStatus;
@@ -74,6 +80,15 @@ DaemonStub::DaemonStub()
     opToInterfaceMap_[static_cast<uint32_t>(
         DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_GET_CONNECTED_DEVICE_LIST)] =
         &DaemonStub::HandleGetConnectedDeviceList;
+    opToInterfaceMap_[static_cast<uint32_t>(
+        DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REGISTER_FILE_DFS_LISTENER)] =
+        &DaemonStub::HandleRegisterFileDfsListener;
+    opToInterfaceMap_[static_cast<uint32_t>(
+        DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_UNREGISTER_FILE_DFS_LISTENER)] =
+        &DaemonStub::HandleUnregisterFileDfsListener;
+    opToInterfaceMap_[static_cast<uint32_t>(
+        DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_IS_SAME_ACCOUNT_DEVICE)] =
+        &DaemonStub::HandleIsSameAccountDevice;
 }
 
 int32_t DaemonStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
@@ -555,6 +570,82 @@ int32_t DaemonStub::HandleGetConnectedDeviceList(MessageParcel &data, MessagePar
     }
     return E_OK;
 }
-}  // namespace DistributedFile
-}  // namespace Storage
-}  // namespace OHOS
\ No newline at end of file
+
+int32_t DaemonStub::HandleRegisterFileDfsListener(MessageParcel &data, MessageParcel &reply)
+{
+    if (!DfsuAccessTokenHelper::CheckCallerPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
+        LOGE("Permission denied: FILE_ACCESS_MANAGER_PERMISSION");
+        return E_PERMISSION_DENIED;
+    }
+    std::string instanceId;
+    if (!data.ReadString(instanceId)) {
+        LOGE("Read instanceId failed");
+        return E_IPC_READ_FAILED;
+    }
+    auto remote = data.ReadRemoteObject();
+    if (remote == nullptr) {
+        LOGE("Read remoteObject failed");
+        return E_IPC_READ_FAILED;
+    }
+    auto remoteReverseObj = iface_cast<IFileDfsListener>(remote);
+    if (remoteReverseObj == nullptr) {
+        LOGE("RemoteReverseObj is null");
+        return E_INVAL_ARG;
+    }
+    int32_t res = RegisterFileDfsListener(instanceId, remoteReverseObj);
+    if (!reply.WriteInt32(res)) {
+        LOGE("HandleRegisterFileDfsListener write res failed, res is %{public}d", res);
+        return E_IPC_WRITE_FAILED;
+    }
+    return E_OK;
+}
+
+int32_t DaemonStub::HandleUnregisterFileDfsListener(MessageParcel &data, MessageParcel &reply)
+{
+    if (!DfsuAccessTokenHelper::CheckCallerPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
+        LOGE("Permission denied: FILE_ACCESS_MANAGER_PERMISSION");
+        return E_PERMISSION_DENIED;
+    }
+    std::string instanceId;
+    if (!data.ReadString(instanceId)) {
+        LOGE("Read instanceId failed");
+        return E_IPC_READ_FAILED;
+    }
+    int32_t res = UnregisterFileDfsListener(instanceId);
+    if (!reply.WriteInt32(res)) {
+        LOGE("HandleUnregisterFileDfsListener write res failed, res is %{public}d", res);
+        return E_IPC_WRITE_FAILED;
+    }
+    return E_OK;
+}
+
+int32_t DaemonStub::HandleIsSameAccountDevice(MessageParcel &data, MessageParcel &reply)
+{
+    if (!DfsuAccessTokenHelper::CheckCallerPermission(FILE_ACCESS_MANAGER_PERMISSION)) {
+        LOGE("Permission denied: FILE_ACCESS_MANAGER_PERMISSION");
+        return E_PERMISSION_DENIED;
+    }
+    std::string networkId;
+    if (!data.ReadString(networkId)) {
+        LOGE("Read networkId failed");
+        return E_IPC_READ_FAILED;
+    }
+    bool isSameAccount = false;
+    int32_t res = IsSameAccountDevice(networkId, isSameAccount);
+    if (!reply.WriteInt32(res)) {
+        LOGE("HandleIsSameAccountDevice write res failed, res is %{public}d", res);
+        return E_IPC_WRITE_FAILED;
+    }
+    if (res != E_OK) {
+        LOGE("IsSameAccountDevice failed, res is %{public}d", res);
+        return E_OK;
+    }
+    if (!reply.WriteBool(isSameAccount)) {
+        LOGE("HandleIsSameAccountDevice write isSameAccount:%{public}d failed", isSameAccount);
+        return E_IPC_WRITE_FAILED;
+    }
+    return E_OK;
+}
+} // namespace DistributedFile
+} // namespace Storage
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/distributedfiledaemon/test/mock/include/daemon_mock.h b/services/distributedfiledaemon/test/mock/include/daemon_mock.h
index 282afdd968a9976ae0decd5607c1fd82c86f8a0a..b9f167cab1592a382b45027032ed03f858e1c4d7 100644
--- a/services/distributedfiledaemon/test/mock/include/daemon_mock.h
+++ b/services/distributedfiledaemon/test/mock/include/daemon_mock.h
@@ -57,6 +57,10 @@ public:
     MOCK_METHOD2(GetDfsSwitchStatus, int32_t(const std::string &networkId, int32_t &switchStatus));
     MOCK_METHOD1(UpdateDfsSwitchStatus, int32_t(int32_t switchStatus));
     MOCK_METHOD1(GetConnectedDeviceList, int32_t(std::vector<DfsDeviceInfo> &deviceList));
+    MOCK_METHOD2(RegisterFileDfsListener,
+                 int32_t(const std::string &instanceId, const sptr<IFileDfsListener> &listener));
+    MOCK_METHOD1(UnregisterFileDfsListener, int32_t(const std::string &instanceId));
+    MOCK_METHOD2(IsSameAccountDevice, int32_t(const std::string &networkId, bool &isSameAccount));
 };
 } // namespace DistributedFile
 } // namespace Storage
diff --git a/test/fuzztest/daemonstub_fuzzer/daemonstub_fuzzer.cpp b/test/fuzztest/daemonstub_fuzzer/daemonstub_fuzzer.cpp
index 717f38bb2cb140ba547df75d955d216fe73631a1..d1650facdd8f8e920b27b08f78de960204b1b70c 100644
--- a/test/fuzztest/daemonstub_fuzzer/daemonstub_fuzzer.cpp
+++ b/test/fuzztest/daemonstub_fuzzer/daemonstub_fuzzer.cpp
@@ -143,6 +143,21 @@ public:
     {
         return 0;
     }
+
+    int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener) override
+    {
+        return 0;
+    }
+
+    int32_t UnregisterFileDfsListener(const std::string &instanceId) override
+    {
+        return 0;
+    }
+
+    int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount) override
+    {
+        return 0;
+    }
 };
 
 void HandleOpenP2PConnectionFuzzTest(std::shared_ptr<DaemonStub> daemonStubPtr,
@@ -389,6 +404,94 @@ void ReadBatchUrisFuzzTest(const uint8_t *data, size_t size)
     IpcWrapper::ReadBatchUris(datas, uriVec);
 }
 
+void HandleGetDfsSwitchStatus(std::shared_ptr<DaemonStub> daemonStubPtr, const uint8_t *data, size_t size)
+{
+    uint32_t code = static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_GET_DFS_SWITCH_STATUS);
+    MessageParcel datas;
+    MessageParcel reply;
+    MessageOption option;
+
+    datas.WriteInterfaceToken(DaemonStub::GetDescriptor());
+    datas.WriteBuffer(data, size);
+    datas.RewindRead(0);
+
+    daemonStubPtr->OnRemoteRequest(code, datas, reply, option);
+}
+
+void HandleUpdateDfsSwitchStatus(std::shared_ptr<DaemonStub> daemonStubPtr, const uint8_t *data, size_t size)
+{
+    uint32_t code =
+        static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_UPDATE_DFS_SWITCH_STATUS);
+    MessageParcel datas;
+    MessageParcel reply;
+    MessageOption option;
+
+    datas.WriteInterfaceToken(DaemonStub::GetDescriptor());
+    datas.WriteBuffer(data, size);
+    datas.RewindRead(0);
+
+    daemonStubPtr->OnRemoteRequest(code, datas, reply, option);
+}
+
+void HandleGetConnectedDeviceList(std::shared_ptr<DaemonStub> daemonStubPtr, const uint8_t *data, size_t size)
+{
+    uint32_t code =
+        static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_GET_CONNECTED_DEVICE_LIST);
+    MessageParcel datas;
+    MessageParcel reply;
+    MessageOption option;
+
+    datas.WriteInterfaceToken(DaemonStub::GetDescriptor());
+    datas.WriteBuffer(data, size);
+    datas.RewindRead(0);
+
+    daemonStubPtr->OnRemoteRequest(code, datas, reply, option);
+}
+
+void HandleRegisterFileDfsListener(std::shared_ptr<DaemonStub> daemonStubPtr, const uint8_t *data, size_t size)
+{
+    uint32_t code =
+        static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REGISTER_FILE_DFS_LISTENER);
+    MessageParcel datas;
+    MessageParcel reply;
+    MessageOption option;
+
+    datas.WriteInterfaceToken(DaemonStub::GetDescriptor());
+    datas.WriteBuffer(data, size);
+    datas.RewindRead(0);
+
+    daemonStubPtr->OnRemoteRequest(code, datas, reply, option);
+}
+
+void HandleUnregisterFileDfsListener(std::shared_ptr<DaemonStub> daemonStubPtr, const uint8_t *data, size_t size)
+{
+    uint32_t code =
+        static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_UNREGISTER_FILE_DFS_LISTENER);
+    MessageParcel datas;
+    MessageParcel reply;
+    MessageOption option;
+
+    datas.WriteInterfaceToken(DaemonStub::GetDescriptor());
+    datas.WriteBuffer(data, size);
+    datas.RewindRead(0);
+
+    daemonStubPtr->OnRemoteRequest(code, datas, reply, option);
+}
+
+void HandleIsSameAccountDevice(std::shared_ptr<DaemonStub> daemonStubPtr, const uint8_t *data, size_t size)
+{
+    uint32_t code = static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_IS_SAME_ACCOUNT_DEVICE);
+    MessageParcel datas;
+    MessageParcel reply;
+    MessageOption option;
+
+    datas.WriteInterfaceToken(DaemonStub::GetDescriptor());
+    datas.WriteBuffer(data, size);
+    datas.RewindRead(0);
+
+    daemonStubPtr->OnRemoteRequest(code, datas, reply, option);
+}
+
 void SetAccessTokenPermission()
 {
     uint64_t tokenId;
@@ -443,6 +546,13 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
     OHOS::HandleGetDfsUrisDirFromLocalFuzzTest(daemonStubPtr, data, size);
     OHOS::HandleInnerCancelCopyTaskFuzzTest(daemonStubPtr, data, size);
 
+    OHOS::HandleGetDfsSwitchStatus(daemonStubPtr, data, size);
+    OHOS::HandleUpdateDfsSwitchStatus(daemonStubPtr, data, size);
+    OHOS::HandleGetConnectedDeviceList(daemonStubPtr, data, size);
+    OHOS::HandleRegisterFileDfsListener(daemonStubPtr, data, size);
+    OHOS::HandleUnregisterFileDfsListener(daemonStubPtr, data, size);
+    OHOS::HandleIsSameAccountDevice(daemonStubPtr, data, size);
+
     OHOS::WriteUriByRawDataFuzzTest(data, size);
     OHOS::ReadBatchUriByRawDataFuzzTest(data, size);
     OHOS::ReadBatchUrisFuzzTest(data, size);
diff --git a/test/unittests/distributed_file_daemon/daemon_manager_impl_test.cpp b/test/unittests/distributed_file_daemon/daemon_manager_impl_test.cpp
index f9cb401632d007f76f189a04fd682a2aab7bf9e9..9f9ac99e41d6975751cdb2ccf2014a06b07cbae3 100644
--- a/test/unittests/distributed_file_daemon/daemon_manager_impl_test.cpp
+++ b/test/unittests/distributed_file_daemon/daemon_manager_impl_test.cpp
@@ -545,5 +545,85 @@ HWTEST_F(DistributedDaemonManagerImplTest, GetConnectedDeviceListTest, TestSize.
     }
     GTEST_LOG_(INFO) << "GetConnectedDeviceListTest End";
 }
+
+/**
+ * @tc.name: RegisterFileDfsListenerTest
+ * @tc.desc: Verify the RegisterFileDfsListener function
+ * @tc.type: FUNC
+ * @tc.require: I7M6L1
+ */
+HWTEST_F(DistributedDaemonManagerImplTest, RegisterFileDfsListenerTest, TestSize.Level1)
+{
+    auto remoteReverseObj = sptr(new FileDfsListenerMock());
+    GTEST_LOG_(INFO) << "RegisterFileDfsListenerTest Start";
+    try {
+        g_isNullptr = false;
+        auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
+        EXPECT_NE(distributedFileDaemonProxy, nullptr);
+        auto res = distributedDaemonManagerImpl_->RegisterFileDfsListener("test", remoteReverseObj);
+        EXPECT_NE(res, E_SA_LOAD_FAILED);
+
+        g_isNullptr = true;
+        res = distributedDaemonManagerImpl_->RegisterFileDfsListener("test", remoteReverseObj);
+        EXPECT_EQ(res, E_SA_LOAD_FAILED);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "RegisterFileDfsListenerTest ERROR";
+    }
+    GTEST_LOG_(INFO) << "RegisterFileDfsListenerTest End";
+}
+
+/**
+ * @tc.name: UnregisterFileDfsListenerTest
+ * @tc.desc: Verify the UnregisterFileDfsListener function
+ * @tc.type: FUNC
+ * @tc.require: I7M6L1
+ */
+HWTEST_F(DistributedDaemonManagerImplTest, UnregisterFileDfsListenerTest, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UnregisterFileDfsListenerTest Start";
+    try {
+        g_isNullptr = false;
+        auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
+        EXPECT_NE(distributedFileDaemonProxy, nullptr);
+        auto res = distributedDaemonManagerImpl_->UnregisterFileDfsListener("test");
+        EXPECT_NE(res, E_SA_LOAD_FAILED);
+
+        g_isNullptr = true;
+        res = distributedDaemonManagerImpl_->UnregisterFileDfsListener("test");
+        EXPECT_EQ(res, E_SA_LOAD_FAILED);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UnregisterFileDfsListenerTest ERROR";
+    }
+    GTEST_LOG_(INFO) << "UnregisterFileDfsListenerTest End";
+}
+
+/**
+ * @tc.name: IsSameAccountDeviceTest
+ * @tc.desc: Verify the IsSameAccountDevice function
+ * @tc.type: FUNC
+ * @tc.require: I7M6L1
+ */
+HWTEST_F(DistributedDaemonManagerImplTest, IsSameAccountDeviceTest, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "IsSameAccountDeviceTest Start";
+    try {
+        g_isNullptr = false;
+        bool isSameAccount = false;
+        auto distributedFileDaemonProxy = DistributedFileDaemonProxy::GetInstance();
+        EXPECT_NE(distributedFileDaemonProxy, nullptr);
+        auto res = distributedDaemonManagerImpl_->IsSameAccountDevice("test", isSameAccount);
+        EXPECT_NE(res, E_SA_LOAD_FAILED);
+
+        g_isNullptr = true;
+        res = distributedDaemonManagerImpl_->IsSameAccountDevice("test", isSameAccount);
+        EXPECT_EQ(res, E_SA_LOAD_FAILED);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "IsSameAccountDeviceTest ERROR";
+    }
+    GTEST_LOG_(INFO) << "IsSameAccountDeviceTest End";
+}
 } // namespace Test
 } // namespace OHOS::Storage::DistributedFile
diff --git a/test/unittests/distributed_file_daemon/daemon_stub_sup_test.cpp b/test/unittests/distributed_file_daemon/daemon_stub_sup_test.cpp
index bc11759f130c9e568c11bba1f6c77acbdb40b474..2894994fded0faa0f06cd8913465e555afe787b7 100644
--- a/test/unittests/distributed_file_daemon/daemon_stub_sup_test.cpp
+++ b/test/unittests/distributed_file_daemon/daemon_stub_sup_test.cpp
@@ -152,6 +152,10 @@ public:
     MOCK_METHOD2(GetDfsSwitchStatus, int32_t(const std::string &networkId, int32_t &switchStatus));
     MOCK_METHOD1(UpdateDfsSwitchStatus, int32_t(int32_t switchStatus));
     MOCK_METHOD1(GetConnectedDeviceList, int32_t(std::vector<DfsDeviceInfo> &deviceList));
+    MOCK_METHOD2(RegisterFileDfsListener,
+                 int32_t(const std::string &instanceId, const sptr<IFileDfsListener> &listener));
+    MOCK_METHOD1(UnregisterFileDfsListener, int32_t(const std::string &instanceId));
+    MOCK_METHOD2(IsSameAccountDevice, int32_t(const std::string &networkId, bool &isSameAccount));
 };
 
 class DaemonStubSupPTest : public testing::Test {
@@ -774,4 +778,128 @@ HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetConnectedDeviceList, TestSize
     EXPECT_EQ(ret, E_OK);
     GTEST_LOG_(INFO) << "DaemonStubSupHandleGetConnectedDeviceList End";
 }
+
+/**
+ * @tc.name: DaemonStubSupHandleRegisterFileDfsListener
+ * @tc.desc: Verify the HandleRegisterFileDfsListener function
+ * @tc.type: FUNC
+ * @tc.require: I7M6L1
+ */
+HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleRegisterFileDfsListener, TestSize.Level0)
+{
+    GTEST_LOG_(INFO) << "DaemonStubSupHandleRegisterFileDfsListener Start";
+    MessageParcel data;
+    MessageParcel reply;
+    g_checkCallerPermissionTrue = false;
+    auto ret = daemonStub_->HandleRegisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_PERMISSION_DENIED);
+
+    g_checkCallerPermissionTrue = true;
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
+    ret = daemonStub_->HandleRegisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_IPC_READ_FAILED);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
+    ret = daemonStub_->HandleRegisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_IPC_READ_FAILED);
+
+    auto listener = sptr(new FileDfsListenerMock());
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return("instanceId"));
+    EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listener));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+    EXPECT_CALL(*daemonStub_, RegisterFileDfsListener(_, _)).WillOnce(Return(E_OK));
+    ret = daemonStub_->HandleRegisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return("instanceId"));
+    EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listener));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
+    EXPECT_CALL(*daemonStub_, RegisterFileDfsListener(_, _)).WillOnce(Return(E_OK));
+    ret = daemonStub_->HandleRegisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_OK);
+    GTEST_LOG_(INFO) << "DaemonStubSupHandleRegisterFileDfsListener End";
+}
+
+/**
+ * @tc.name: DaemonStubSupHandleUnregisterFileDfsListener
+ * @tc.desc: Verify the HandleUnregisterFileDfsListener function
+ * @tc.type: FUNC
+ * @tc.require: I7M6L1
+ */
+HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleUnregisterFileDfsListener, TestSize.Level0)
+{
+    GTEST_LOG_(INFO) << "DaemonStubSupHandleUnregisterFileDfsListener Start";
+    MessageParcel data;
+    MessageParcel reply;
+    g_checkCallerPermissionTrue = false;
+    auto ret = daemonStub_->HandleUnregisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_PERMISSION_DENIED);
+
+    g_checkCallerPermissionTrue = true;
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
+    ret = daemonStub_->HandleUnregisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_IPC_READ_FAILED);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+    EXPECT_CALL(*daemonStub_, UnregisterFileDfsListener(_)).WillOnce(Return(E_OK));
+    ret = daemonStub_->HandleUnregisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
+    EXPECT_CALL(*daemonStub_, UnregisterFileDfsListener(_)).WillOnce(Return(E_OK));
+    ret = daemonStub_->HandleUnregisterFileDfsListener(data, reply);
+    EXPECT_EQ(ret, E_OK);
+    GTEST_LOG_(INFO) << "DaemonStubSupHandleUnregisterFileDfsListener End";
+}
+
+/**
+ * @tc.name: DaemonStubSupHandleIsSameAccountDevice
+ * @tc.desc: Verify the HandleIsSameAccountDevice function
+ * @tc.type: FUNC
+ * @tc.require: I7M6L1
+ */
+HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleIsSameAccountDevice, TestSize.Level0)
+{
+    GTEST_LOG_(INFO) << "DaemonStubSupHandleIsSameAccountDevice Start";
+    MessageParcel data;
+    MessageParcel reply;
+    g_checkCallerPermissionTrue = false;
+    auto ret = daemonStub_->HandleIsSameAccountDevice(data, reply);
+    EXPECT_EQ(ret, E_PERMISSION_DENIED);
+
+    g_checkCallerPermissionTrue = true;
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
+    ret = daemonStub_->HandleIsSameAccountDevice(data, reply);
+    EXPECT_EQ(ret, E_IPC_READ_FAILED);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
+    EXPECT_CALL(*daemonStub_, IsSameAccountDevice(_, _)).WillOnce(Return(E_OK));
+    ret = daemonStub_->HandleIsSameAccountDevice(data, reply);
+    EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
+    EXPECT_CALL(*daemonStub_, IsSameAccountDevice(_, _)).WillOnce(Return(E_INVAL_ARG));
+    ret = daemonStub_->HandleIsSameAccountDevice(data, reply);
+    EXPECT_EQ(ret, E_OK);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
+    EXPECT_CALL(*daemonStub_, IsSameAccountDevice(_, _)).WillOnce(Return(E_OK));
+    ret = daemonStub_->HandleIsSameAccountDevice(data, reply);
+    EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
+
+    EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
+    EXPECT_CALL(*daemonStub_, IsSameAccountDevice(_, _)).WillOnce(DoAll(SetArgReferee<1>(true), Return(E_OK)));
+    ret = daemonStub_->HandleIsSameAccountDevice(data, reply);
+    EXPECT_EQ(ret, E_OK);
+    GTEST_LOG_(INFO) << "DaemonStubSupHandleIsSameAccountDevice End";
+}
 } // namespace OHOS::Storage::DistributedFile::Test
\ No newline at end of file
diff --git a/test/unittests/distributed_file_daemon/daemon_stub_test.cpp b/test/unittests/distributed_file_daemon/daemon_stub_test.cpp
index 5c1f83db124de5ff8eaf78a7a52b94eba3b2c7b2..5fb980d7cde50252d5cfa727ca33b11b8743834e 100644
--- a/test/unittests/distributed_file_daemon/daemon_stub_test.cpp
+++ b/test/unittests/distributed_file_daemon/daemon_stub_test.cpp
@@ -99,6 +99,10 @@ public:
     MOCK_METHOD2(GetDfsSwitchStatus, int32_t(const std::string &networkId, int32_t &switchStatus));
     MOCK_METHOD1(UpdateDfsSwitchStatus, int32_t(int32_t switchStatus));
     MOCK_METHOD1(GetConnectedDeviceList, int32_t(std::vector<DfsDeviceInfo> &deviceList));
+    MOCK_METHOD2(RegisterFileDfsListener,
+                 int32_t(const std::string &instanceId, const sptr<IFileDfsListener> &listener));
+    MOCK_METHOD1(UnregisterFileDfsListener, int32_t(const std::string &instanceId));
+    MOCK_METHOD2(IsSameAccountDevice, int32_t(const std::string &networkId, bool &isSameAccount));
 };
 
 class DaemonStubTest : public testing::Test {
diff --git a/test/unittests/distributed_file_daemon/include/i_daemon_mock.h b/test/unittests/distributed_file_daemon/include/i_daemon_mock.h
index d69d040cdd4eaeb979d0a3177620e3b7cb11ef60..35ff96d255f410315b99b9df647a38f944ac46be 100644
--- a/test/unittests/distributed_file_daemon/include/i_daemon_mock.h
+++ b/test/unittests/distributed_file_daemon/include/i_daemon_mock.h
@@ -131,6 +131,22 @@ public:
     {
         return FileManagement::E_OK;
     }
+
+    int32_t RegisterFileDfsListener(const std::string &instanceId, const sptr<IFileDfsListener> &listener)
+    {
+        return FileManagement::E_OK;
+    }
+
+    int32_t UnregisterFileDfsListener(const std::string &instanceId)
+    {
+        return FileManagement::E_OK;
+    }
+
+    int32_t IsSameAccountDevice(const std::string &networkId, bool &isSameAccount)
+    {
+        isSameAccount = true;
+        return FileManagement::E_OK;
+    }
 };
 } // namespace OHOS::Storage::DistributedFile
 
diff --git a/test/unittests/distributed_file_inner/distributed_file_daemon_proxy_test.cpp b/test/unittests/distributed_file_inner/distributed_file_daemon_proxy_test.cpp
index ea9b1eb689be177b469e98090b67a5c6596fbc78..6923e767c597935c43159e8213b365840cbbcfde 100644
--- a/test/unittests/distributed_file_inner/distributed_file_daemon_proxy_test.cpp
+++ b/test/unittests/distributed_file_inner/distributed_file_daemon_proxy_test.cpp
@@ -1118,4 +1118,172 @@ HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetConnectedDevic
     EXPECT_EQ(ret, E_OK);
     GTEST_LOG_(INFO) << "DistributedFileDaemon_GetConnectedDeviceList End";
 }
+
+/**
+ * @tc.name: DistributedFileDaemon_RegisterFileDfsListener
+ * @tc.desc: Verify RegisterFileDfsListener function
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_RegisterFileDfsListener, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DistributedFileDaemon_RegisterFileDfsListener Start";
+    auto listener = sptr(new FileDfsListenerMock());
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+    auto ret = proxy_->RegisterFileDfsListener("instance", listener);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+    ret = proxy_->RegisterFileDfsListener("instance", listener);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    ret = proxy_->RegisterFileDfsListener("instance", nullptr);
+    EXPECT_EQ(ret, E_INVAL_ARG);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
+        .WillOnce(Return(false));
+    ret = proxy_->RegisterFileDfsListener("instance", listener);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
+    ret = proxy_->RegisterFileDfsListener("instance", listener);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
+    ret = proxy_->RegisterFileDfsListener("instance", listener);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
+    ret = proxy_->RegisterFileDfsListener("instance", listener);
+    EXPECT_EQ(ret, E_OK);
+    GTEST_LOG_(INFO) << "DistributedFileDaemon_RegisterFileDfsListener End";
+}
+
+/**
+ * @tc.name: DistributedFileDaemon_UnregisterFileDfsListener
+ * @tc.desc: Verify UnregisterFileDfsListener function
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_UnregisterFileDfsListener, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DistributedFileDaemon_UnregisterFileDfsListener Start";
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+    auto ret = proxy_->UnregisterFileDfsListener("instance");
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+    ret = proxy_->UnregisterFileDfsListener("instance");
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    auto tmpProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
+    ret = tmpProxy->UnregisterFileDfsListener("instance");
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
+    ret = proxy_->UnregisterFileDfsListener("instance");
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
+    ret = proxy_->UnregisterFileDfsListener("instance");
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
+    ret = proxy_->UnregisterFileDfsListener("instance");
+    EXPECT_EQ(ret, E_OK);
+    GTEST_LOG_(INFO) << "DistributedFileDaemon_UnregisterFileDfsListener End";
+}
+
+/**
+ * @tc.name: DistributedFileDaemon_IsSameAccountDevice
+ * @tc.desc: Verify IsSameAccountDevice function
+ * @tc.type: FUNC
+ * @tc.require: I7TDJK
+ */
+HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_IsSameAccountDevice, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "DistributedFileDaemon_IsSameAccountDevice Start";
+    bool isSameAccount = false;
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
+    auto ret = proxy_->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
+    ret = proxy_->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    auto tmpProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
+    ret = tmpProxy->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
+    ret = proxy_->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
+    ret = proxy_->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_INVAL_ARG), Return(true)));
+    ret = proxy_->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_INVAL_ARG);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
+    EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(false));
+    ret = proxy_->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_BROKEN_IPC);
+
+    EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
+    EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
+    EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
+    EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true));
+    ret = proxy_->IsSameAccountDevice("networkId", isSameAccount);
+    EXPECT_EQ(ret, E_OK);
+    GTEST_LOG_(INFO) << "DistributedFileDaemon_IsSameAccountDevice End";
 }
+} // namespace OHOS::Storage::DistributedFile::Test
diff --git a/test/unittests/distributed_file_inner/include/i_daemon_mock.h b/test/unittests/distributed_file_inner/include/i_daemon_mock.h
index 051db7bb364b04630fa5bbe7b9f8b68ce0807c34..3a51098c3b96f2b72dec612714bf17575ad0f76f 100644
--- a/test/unittests/distributed_file_inner/include/i_daemon_mock.h
+++ b/test/unittests/distributed_file_inner/include/i_daemon_mock.h
@@ -56,6 +56,10 @@ public:
     MOCK_METHOD2(GetDfsSwitchStatus, int32_t(const std::string &networkId, int32_t &switchStatus));
     MOCK_METHOD1(UpdateDfsSwitchStatus, int32_t(int32_t switchStatus));
     MOCK_METHOD1(GetConnectedDeviceList, int32_t(std::vector<DfsDeviceInfo> &deviceList));
+    MOCK_METHOD2(RegisterFileDfsListener,
+                 int32_t(const std::string &instanceId, const sptr<IFileDfsListener> &listener));
+    MOCK_METHOD1(UnregisterFileDfsListener, int32_t(const std::string &instanceId));
+    MOCK_METHOD2(IsSameAccountDevice, int32_t(const std::string &networkId, bool &isSameAccount));
 };
 } // namespace OHOS::Storage::DistributedFile