diff --git a/frameworks/native/netvpnclient/src/networkvpn_client.cpp b/frameworks/native/netvpnclient/src/networkvpn_client.cpp
index 93eba99c6f3182d16eb1db3acf61aa0474666042..6867556f105ab40ddc0d2c380d054c72fd275f3b 100644
--- a/frameworks/native/netvpnclient/src/networkvpn_client.cpp
+++ b/frameworks/native/netvpnclient/src/networkvpn_client.cpp
@@ -26,6 +26,7 @@
 #include "netmgr_ext_log_wrapper.h"
 #include "system_ability_definition.h"
 #include "network_vpn_service_proxy.h"
+#include "system_ability_status_change_stub.h"
 
 namespace OHOS {
 namespace NetManagerStandard {
@@ -33,6 +34,14 @@ namespace NetManagerStandard {
 static constexpr uint32_t WAIT_FOR_SERVICE_TIME_MS = 500;
 static constexpr uint32_t MAX_GET_SERVICE_COUNT = 10;
 
+class NetworkVpnClient::SystemAbilityListener : public SystemAbilityStatusChangeStub {
+public:
+    SystemAbilityListener() = default;
+    ~SystemAbilityListener() = default;
+    void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
+    void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
+};
+
 int32_t VpnSetUpEventCallback::OnVpnMultiUserSetUp()
 {
     NETMGR_EXT_LOG_I("vpn multiple user setup event.");
@@ -40,12 +49,137 @@ int32_t VpnSetUpEventCallback::OnVpnMultiUserSetUp()
     return NETMANAGER_EXT_SUCCESS;
 }
 
+int32_t VpnEventCallbackCollection::OnVpnStateChanged(bool isConnected)
+{
+    std::shared_lock<std::shared_mutex> lock(vpnEventCbMutex_);
+    std::list<sptr<IVpnEventCallback>> tmpList = vpnEventCbList_;
+    lock.unlock();
+    for (auto iter = tmpList.begin(); iter != tmpList.end(); iter++) {
+        (*iter)->OnVpnStateChanged(isConnected);
+    }
+    return NETMANAGER_EXT_SUCCESS;
+}
+
+int32_t VpnEventCallbackCollection::OnMultiVpnStateChanged(
+    bool isConnected, const std::string &bundleName, const std::string &vpnId)
+{
+    std::shared_lock<std::shared_mutex> lock(vpnEventCbMutex_);
+    std::list<sptr<IVpnEventCallback>> tmpList = vpnEventCbList_;
+    lock.unlock();
+    for (auto iter = tmpList.begin(); iter != tmpList.end(); iter++) {
+        (*iter)->OnMultiVpnStateChanged(isConnected, bundleName, vpnId);
+    }
+    return NETMANAGER_EXT_SUCCESS;
+}
+
+int32_t VpnEventCallbackCollection::OnVpnMultiUserSetUp()
+{
+    std::shared_lock<std::shared_mutex> lock(vpnEventCbMutex_);
+    std::list<sptr<IVpnEventCallback>> tmpList = vpnEventCbList_;
+    lock.unlock();
+    for (auto iter = tmpList.begin(); iter != tmpList.end(); iter++) {
+        (*iter)->OnVpnMultiUserSetUp();
+    }
+    return NETMANAGER_EXT_SUCCESS;
+}
+
+int32_t VpnEventCallbackCollection::RegisterCallback(sptr<IVpnEventCallback> callback)
+{
+    std::unique_lock<std::shared_mutex> lock(vpnEventCbMutex_);
+    for (auto iter = vpnEventCbList_.begin(); iter != vpnEventCbList_.end(); iter++) {
+        if ((*iter)->AsObject().GetRefPtr() == callback->AsObject().GetRefPtr()) {
+            return NETMANAGER_EXT_ERR_OPERATION_FAILED;
+        }
+    }
+    vpnEventCbList_.push_back(callback);
+    return NETMANAGER_EXT_SUCCESS;
+}
+
+int32_t VpnEventCallbackCollection::UnregisterCallback(sptr<IVpnEventCallback> callback)
+{
+    std::unique_lock<std::shared_mutex> lock(vpnEventCbMutex_);
+    for (auto iter = vpnEventCbList_.begin(); iter != vpnEventCbList_.end(); iter++) {
+        if ((*iter)->AsObject().GetRefPtr() == callback->AsObject().GetRefPtr()) {
+            vpnEventCbList_.erase(iter);
+            break;
+        }
+    }
+    return NETMANAGER_EXT_SUCCESS;
+}
+
+int32_t VpnEventCallbackCollection::GetCallbackNum()
+{
+    std::shared_lock<std::shared_mutex> lock(vpnEventCbMutex_);
+    return vpnEventCbList_.size();
+}
+
+NetworkVpnClient::NetworkVpnClient() : saStatusChangeListener_(nullptr)
+{
+    Subscribe();
+}
+
+NetworkVpnClient::~NetworkVpnClient()
+{
+    Unsubscribe();
+    UnregisterVpnEventCbCollection();
+#ifdef SUPPORT_SYSVPN
+    UnregisterMultiVpnEventCbCollection();
+#endif
+}
+
 NetworkVpnClient &NetworkVpnClient::GetInstance()
 {
     static NetworkVpnClient instance;
     return instance;
 }
 
+void NetworkVpnClient::Subscribe()
+{
+    auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgrProxy != nullptr) {
+        saStatusChangeListener_ = sptr<SystemAbilityListener>::MakeSptr();
+        samgrProxy->SubscribeSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID, saStatusChangeListener_);
+    }
+}
+
+void NetworkVpnClient::Unsubscribe()
+{
+    if (saStatusChangeListener_ != nullptr) {
+        auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+        if (samgrProxy != nullptr) {
+            samgrProxy->UnSubscribeSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID, saStatusChangeListener_);
+        }
+    }
+}
+
+void NetworkVpnClient::SystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
+{
+    switch (systemAbilityId) {
+        case COMM_VPN_MANAGER_SYS_ABILITY_ID: {
+            NetworkVpnClient::GetInstance().SetVpnSaState(true);
+            NetworkVpnClient::GetInstance().RegisterVpnEventCbCollection();
+#ifdef SUPPORT_SYSVPN
+            NetworkVpnClient::GetInstance().RegisterMultiVpnEventCbCollection();
+#endif
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+void NetworkVpnClient::SystemAbilityListener::OnRemoveSystemAbility(
+    int32_t systemAbilityId, const std::string &deviceId)
+{
+    switch (systemAbilityId) {
+        case COMM_VPN_MANAGER_SYS_ABILITY_ID:
+            NetworkVpnClient::GetInstance().SetVpnSaState(false);
+            break;
+        default:
+            break;
+    }
+}
+
 int32_t NetworkVpnClient::Prepare(bool &isExistVpn, bool &isRun, std::string &pkg)
 {
     sptr<INetworkVpnService> proxy = GetProxy();
@@ -280,12 +414,14 @@ int32_t NetworkVpnClient::RegisterMultiVpnEvent(sptr<IVpnEventCallback> callback
         NETMGR_EXT_LOG_E("RegisterMultiVpnEvent callback is null.");
         return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
     }
-    sptr<INetworkVpnService> proxy = GetProxy();
-    if (proxy == nullptr) {
-        NETMGR_EXT_LOG_E("RegisterMultiVpnEvent proxy is nullptr");
-        return NETMANAGER_EXT_ERR_GET_PROXY_FAIL;
+    if (multiVpnEventCbCollection_ == nullptr) {
+        multiVpnEventCbCollection_ = sptr<VpnEventCallbackCollection>::MakeSptr();
+    }
+    int ret = multiVpnEventCbCollection_->RegisterCallback(callback);
+    if (ret == NETMANAGER_EXT_SUCCESS && multiVpnEventCbCollection_->GetCallbackNum() == 1) {
+        RegisterMultiVpnEventCbCollection();
     }
-    return proxy->RegisterMultiVpnEvent(callback);
+    return ret;
 }
 
 int32_t NetworkVpnClient::UnregisterMultiVpnEvent(sptr<IVpnEventCallback> callback)
@@ -294,12 +430,41 @@ int32_t NetworkVpnClient::UnregisterMultiVpnEvent(sptr<IVpnEventCallback> callba
         NETMGR_EXT_LOG_E("UnregisterMultiVpnEvent callback is null.");
         return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
     }
+    if (multiVpnEventCbCollection_ != nullptr) {
+        int ret = multiVpnEventCbCollection_->UnregisterCallback(callback);
+        if (ret == NETMANAGER_EXT_SUCCESS && multiVpnEventCbCollection_->GetCallbackNum() == 0) {
+            UnregisterMultiVpnEventCbCollection();
+        }
+    }
+    return NETMANAGER_EXT_SUCCESS;
+}
+
+void NetworkVpnClient::RegisterMultiVpnEventCbCollection()
+{
+    if (multiVpnEventCbCollection_ == nullptr) {
+        multiVpnEventCbCollection_ = sptr<VpnEventCallbackCollection>::MakeSptr();
+    }
+    if (multiVpnEventCbCollection_->GetCallbackNum() == 0 || !saStart_) {
+        return;
+    }
     sptr<INetworkVpnService> proxy = GetProxy();
     if (proxy == nullptr) {
-        NETMGR_EXT_LOG_E("UnregisterMultiVpnEvent proxy is nullptr");
-        return NETMANAGER_EXT_ERR_GET_PROXY_FAIL;
+        NETMGR_EXT_LOG_E("RegisterMultiVpnEventCbCollection proxy is nullptr");
+        return;
+    }
+    proxy->RegisterMultiVpnEvent(multiVpnEventCbCollection_);
+}
+
+void NetworkVpnClient::UnregisterMultiVpnEventCbCollection()
+{
+    if (multiVpnEventCbCollection_ != nullptr) {
+        sptr<INetworkVpnService> proxy = GetProxy();
+        if (proxy == nullptr) {
+            NETMGR_EXT_LOG_E("UnregisterMultiVpnEventCbCollection proxy is nullptr");
+            return;
+        }
+        proxy->UnregisterMultiVpnEvent(multiVpnEventCbCollection_);
     }
-    return proxy->UnregisterMultiVpnEvent(callback);
 }
 #endif // SUPPORT_SYSVPN
 
@@ -309,12 +474,14 @@ int32_t NetworkVpnClient::RegisterVpnEvent(sptr<IVpnEventCallback> callback)
         NETMGR_EXT_LOG_E("RegisterVpnEvent callback is null.");
         return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
     }
-    sptr<INetworkVpnService> proxy = GetProxy();
-    if (proxy == nullptr) {
-        NETMGR_EXT_LOG_E("RegisterVpnEvent proxy is nullptr");
-        return NETMANAGER_EXT_ERR_GET_PROXY_FAIL;
+    if (vpnEventCbCollection_ == nullptr) {
+        vpnEventCbCollection_ = sptr<VpnEventCallbackCollection>::MakeSptr();
+    }
+    int ret = vpnEventCbCollection_->RegisterCallback(callback);
+    if (ret == NETMANAGER_EXT_SUCCESS && vpnEventCbCollection_->GetCallbackNum() == 1) {
+        RegisterVpnEventCbCollection();
     }
-    return proxy->RegisterVpnEvent(callback);
+    return ret;
 }
 
 int32_t NetworkVpnClient::UnregisterVpnEvent(sptr<IVpnEventCallback> callback)
@@ -323,12 +490,41 @@ int32_t NetworkVpnClient::UnregisterVpnEvent(sptr<IVpnEventCallback> callback)
         NETMGR_EXT_LOG_E("UnregisterVpnEvent callback is null.");
         return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
     }
+    if (vpnEventCbCollection_ != nullptr) {
+        int ret = vpnEventCbCollection_->UnregisterCallback(callback);
+        if (ret == NETMANAGER_EXT_SUCCESS && vpnEventCbCollection_->GetCallbackNum() == 0) {
+            UnregisterVpnEventCbCollection();
+        }
+    }
+    return NETMANAGER_EXT_SUCCESS;
+}
+
+void NetworkVpnClient::RegisterVpnEventCbCollection()
+{
+    if (vpnEventCbCollection_ == nullptr) {
+        vpnEventCbCollection_ = sptr<VpnEventCallbackCollection>::MakeSptr();
+    }
+    if (vpnEventCbCollection_->GetCallbackNum() == 0 || !saStart_) {
+        return;
+    }
     sptr<INetworkVpnService> proxy = GetProxy();
     if (proxy == nullptr) {
-        NETMGR_EXT_LOG_E("UnregisterVpnEvent proxy is nullptr");
-        return NETMANAGER_EXT_ERR_GET_PROXY_FAIL;
+        NETMGR_EXT_LOG_E("RegisterVpnEventCbCollection proxy is nullptr");
+        return;
+    }
+    proxy->RegisterVpnEvent(vpnEventCbCollection_);
+}
+
+void NetworkVpnClient::UnregisterVpnEventCbCollection()
+{
+    if (vpnEventCbCollection_ != nullptr) {
+        sptr<INetworkVpnService> proxy = GetProxy();
+        if (proxy == nullptr) {
+            NETMGR_EXT_LOG_E("UnregisterVpnEventCbCollection proxy is nullptr");
+            return;
+        }
+        proxy->UnregisterVpnEvent(vpnEventCbCollection_);
     }
-    return proxy->UnregisterVpnEvent(callback);
 }
 
 int32_t NetworkVpnClient::CreateVpnConnection(bool isVpnExtCall)
@@ -363,7 +559,7 @@ sptr<INetworkVpnService> NetworkVpnClient::GetProxy()
         NETMGR_EXT_LOG_E("get SystemAbilityManager failed");
         return nullptr;
     }
-    sptr<IRemoteObject> remote = sam->CheckSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
+    sptr<IRemoteObject> remote = sam->GetSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
     if (remote == nullptr) {
         NETMGR_EXT_LOG_E("get Remote vpn service failed");
         return nullptr;
@@ -397,10 +593,6 @@ void NetworkVpnClient::RecoverCallback()
         proxy->SetUpVpn(*clientVpnConfig_.first, clientVpnConfig_.second);
     }
     NETMGR_EXT_LOG_D("Get proxy %{public}s, count: %{public}u", proxy == nullptr ? "failed" : "success", count);
-    if (proxy != nullptr && vpnEventCallback_ != nullptr) {
-        int32_t ret = proxy->RegisterVpnEvent(vpnEventCallback_);
-        NETMGR_EXT_LOG_D("Register result %{public}d", ret);
-    }
 }
 
 void NetworkVpnClient::OnRemoteDied(const wptr<IRemoteObject> &remote)
@@ -463,5 +655,10 @@ int32_t NetworkVpnClient::SetSelfVpnPid()
     }
     return proxy->SetSelfVpnPid();
 }
+
+void NetworkVpnClient::SetVpnSaState(bool state)
+{
+    saStart_ = state;
+}
 } // namespace NetManagerStandard
 } // namespace OHOS
diff --git a/interfaces/innerkits/netvpnclient/include/networkvpn_client.h b/interfaces/innerkits/netvpnclient/include/networkvpn_client.h
index 113457a9068866b999d20286c4a675116cef3e7b..a636288a40f158c3108c840937b6798f27978089 100644
--- a/interfaces/innerkits/netvpnclient/include/networkvpn_client.h
+++ b/interfaces/innerkits/netvpnclient/include/networkvpn_client.h
@@ -20,6 +20,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <shared_mutex>
 
 #include <parcel.h>
 #include <refbase.h>
@@ -41,12 +42,30 @@ public:
     int32_t OnVpnMultiUserSetUp() override;
 };
 
+class VpnEventCallbackCollection final : public VpnEventCallbackStub {
+public:
+    int32_t OnVpnStateChanged(bool isConnected) override;
+    int32_t OnMultiVpnStateChanged(bool isConnected, const std::string &bundleName,
+        const std::string &vpnId) override;
+    int32_t OnVpnMultiUserSetUp() override;
+
+    int32_t RegisterCallback(sptr<IVpnEventCallback> callback);
+    int32_t UnregisterCallback(sptr<IVpnEventCallback> callback);
+    int32_t GetCallbackNum();
+
+private:
+    std::shared_mutex vpnEventCbMutex_;
+    std::list<sptr<IVpnEventCallback>> vpnEventCbList_;
+};
+
 class NetworkVpnClient {
 private:
-    NetworkVpnClient() = default;
-    ~NetworkVpnClient() = default;
+    NetworkVpnClient();
+    ~NetworkVpnClient();
     NetworkVpnClient(const NetworkVpnClient &) = delete;
     NetworkVpnClient &operator=(const NetworkVpnClient &) = delete;
+    void Subscribe();
+    void Unsubscribe();
 
 public:
     static NetworkVpnClient &GetInstance();
@@ -268,6 +287,7 @@ public:
     int32_t GetSelfAppName(std::string &selfAppName, std::string &selfBundleName);
 
     int32_t SetSelfVpnPid();
+    void SetVpnSaState(bool state);
 
 private:
     class MonitorVpnServiceDead : public IRemoteObject::DeathRecipient {
@@ -283,17 +303,29 @@ private:
         NetworkVpnClient &client_;
     };
 
+    class SystemAbilityListener;
+
     sptr<INetworkVpnService> GetProxy();
     void RecoverCallback();
     void OnRemoteDied(const wptr<IRemoteObject> &remote);
+    void RegisterVpnEventCbCollection();
+    void UnregisterVpnEventCbCollection();
+#ifdef SUPPORT_SYSVPN
+    void RegisterMultiVpnEventCbCollection();
+    void UnregisterMultiVpnEventCbCollection();
+#endif
 
 private:
     std::mutex mutex_;
     VpnInterface vpnInterface_;
+    sptr<SystemAbilityListener> saStatusChangeListener_;
     sptr<IVpnEventCallback> vpnEventCallback_ = nullptr;
     sptr<INetworkVpnService> networkVpnService_ = nullptr;
     sptr<IRemoteObject::DeathRecipient> deathRecipient_ = nullptr;
+    sptr<VpnEventCallbackCollection> vpnEventCbCollection_ = nullptr;
+    sptr<VpnEventCallbackCollection> multiVpnEventCbCollection_ = nullptr;
     std::pair<sptr<VpnConfig>, bool> clientVpnConfig_;
+    bool saStart_ = false;
 };
 } // namespace NetManagerStandard
 } // namespace OHOS
diff --git a/sa_profile/1155.xml b/sa_profile/1155.xml
index b79415b0ce2a2b652d8d8e12407c8c518c66b81a..00db886338d8029b34e86b83cc78caf30fa89f47 100644
--- a/sa_profile/1155.xml
+++ b/sa_profile/1155.xml
@@ -20,7 +20,7 @@
         <libpath>libnet_vpn_manager.z.so</libpath> <!-- Declare the path of .so file which includes the system ability; Note: 1 .so file can have 1 to N system abilities. -->
         <!--<depend></depend> --> <!-- Declare the name of system abilities which the system ability depends on, using ";" as separator among names. If there are dependencies, it needs to check if all those dependencies are available in service manager before starting the system ability. -->
         <!--<depend-time-out></depend-time-out> --> <!-- Check all dependencies are available before the timeout period ended. The MAX_DEPENDENCY_TIMEOUT is 60s. -->
-        <run-on-create>true</run-on-create> <!-- "true" means the system ability would start immediately, "false" means the system ability would start on demand. -->
+        <run-on-create>false</run-on-create> <!-- "true" means the system ability would start immediately, "false" means the system ability would start on demand. -->
         <distributed>false</distributed> <!-- "true" means the system ability supports distributed scheduling while "false" is not. -->
         <dump-level>1</dump-level> <!-- Declare the dump level. 1-high; 2-media; 3-low -->
     </systemability>
diff --git a/test/vpnmanager/unittest/sys_vpn_manager_test/networkvpn_client_test.cpp b/test/vpnmanager/unittest/sys_vpn_manager_test/networkvpn_client_test.cpp
index dd1c870c40f6cdc3131c5f51da3afc9c7bd630d1..9ff62de5c3fb968e2a0e8e73086df983195310d0 100644
--- a/test/vpnmanager/unittest/sys_vpn_manager_test/networkvpn_client_test.cpp
+++ b/test/vpnmanager/unittest/sys_vpn_manager_test/networkvpn_client_test.cpp
@@ -307,7 +307,7 @@ HWTEST_F(NetworkVpnClientTest, RecoverCallback001, TestSize.Level1)
 HWTEST_F(NetworkVpnClientTest, OnRemoteDied001, TestSize.Level1)
 {
     sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    sptr<IRemoteObject> remote = sam->CheckSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
+    sptr<IRemoteObject> remote = sam->GetSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
     networkVpnClient_.networkVpnService_ = iface_cast<INetworkVpnService>(remote);
     networkVpnClient_.vpnEventCallback_ = new (std::nothrow) VpnSetUpEventCallback();
     ASSERT_NE(networkVpnClient_.vpnEventCallback_, nullptr);
diff --git a/test/vpnmanager/unittest/vpn_manager_test/networkvpn_client_test.cpp b/test/vpnmanager/unittest/vpn_manager_test/networkvpn_client_test.cpp
index 99c363fd016e97810c65734ac6d8906ac5102cac..d3398b0264631bb0485ee3f2901ab6ab7ae690bf 100644
--- a/test/vpnmanager/unittest/vpn_manager_test/networkvpn_client_test.cpp
+++ b/test/vpnmanager/unittest/vpn_manager_test/networkvpn_client_test.cpp
@@ -119,38 +119,89 @@ HWTEST_F(NetworkVpnClientTest, SetUpVpn002, TestSize.Level1)
 
 HWTEST_F(NetworkVpnClientTest, RegisterVpnEvent001, TestSize.Level1)
 {
+    networkVpnClient_.vpnEventCbCollection_ = nullptr;
     EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
-    callback_ = new (std::nothrow) IVpnEventCallbackTest();
-    EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(callback_), NETMANAGER_ERR_PERMISSION_DENIED);
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    networkVpnClient_.saStart_ = false;
+    EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
+    EXPECT_EQ(networkVpnClient_.vpnEventCbCollection_->GetCallbackNum(), 1);
 }
 
 HWTEST_F(NetworkVpnClientTest, RegisterVpnEvent002, TestSize.Level1)
 {
     NetManagerExtAccessToken access;
     EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
-    callback_ = new (std::nothrow) IVpnEventCallbackTest();
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
+}
+
+HWTEST_F(NetworkVpnClientTest, RegisterVpnEvent003, TestSize.Level1)
+{
+    networkVpnClient_.vpnEventCbCollection_ = nullptr;
+    EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    networkVpnClient_.saStart_ = true;
     EXPECT_EQ(networkVpnClient_.RegisterVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
+    EXPECT_EQ(networkVpnClient_.vpnEventCbCollection_->GetCallbackNum(), 1);
 }
 
 HWTEST_F(NetworkVpnClientTest, UnregisterVpnEvent001, TestSize.Level1)
 {
     EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
-    callback_ = new (std::nothrow) IVpnEventCallbackTest();
-    EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(callback_), NETMANAGER_ERR_PERMISSION_DENIED);
+    networkVpnClient_.vpnEventCbCollection_ = sptr<VpnEventCallbackCollection>::MakeSptr();
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    networkVpnClient_.RegisterVpnEvent(callback_);
+    EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
 }
 
 HWTEST_F(NetworkVpnClientTest, UnregisterVpnEvent002, TestSize.Level1)
 {
-    NetManagerExtAccessToken access;
+    networkVpnClient_.vpnEventCbCollection_ = nullptr;
     EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
-    callback_ = new (std::nothrow) IVpnEventCallbackTest();
-    EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(callback_), NETMANAGER_EXT_ERR_OPERATION_FAILED);
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    EXPECT_EQ(networkVpnClient_.UnregisterVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
+}
+
+#ifdef SUPPORT_SYSVPN
+HWTEST_F(NetworkVpnClientTest, RegisterMultiVpnEvent001, TestSize.Level1)
+{
+    networkVpnClient_.multiVpnEventCbCollection_ = nullptr;
+    EXPECT_EQ(networkVpnClient_.RegisterMultiVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    networkVpnClient_.saStart_ = true;
+    EXPECT_EQ(networkVpnClient_.RegisterMultiVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
+}
+
+HWTEST_F(NetworkVpnClientTest, RegisterMultiVpnEvent002, TestSize.Level1)
+{
+    networkVpnClient_.multiVpnEventCbCollection_ = nullptr;
+    networkVpnClient_.saStart_ = false;
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    EXPECT_EQ(networkVpnClient_.RegisterMultiVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
+}
+
+HWTEST_F(NetworkVpnClientTest, UnregisterMultiVpnEvent001, TestSize.Level1)
+{
+    EXPECT_EQ(networkVpnClient_.UnregisterMultiVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    networkVpnClient_.multiVpnEventCbCollection_ = sptr<VpnEventCallbackCollection>::MakeSptr();
+    networkVpnClient_.RegisterMultiVpnEvent(callback_);
+    EXPECT_EQ(networkVpnClient_.UnregisterMultiVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
+}
+
+HWTEST_F(NetworkVpnClientTest, UnregisterMultiVpnEvent002, TestSize.Level1)
+{
+    networkVpnClient_.multiVpnEventCbCollection_ = nullptr;
+    EXPECT_EQ(networkVpnClient_.UnregisterMultiVpnEvent(nullptr), NETMANAGER_EXT_ERR_PARAMETER_ERROR);
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    EXPECT_EQ(networkVpnClient_.UnregisterMultiVpnEvent(callback_), NETMANAGER_EXT_SUCCESS);
 }
+#endif
 
 HWTEST_F(NetworkVpnClientTest, GetProxy, TestSize.Level1)
 {
     sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    sptr<IRemoteObject> remote = sam->CheckSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
+    sptr<IRemoteObject> remote = sam->GetSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
     networkVpnClient_.networkVpnService_ = iface_cast<INetworkVpnService>(remote);
     EXPECT_EQ(networkVpnClient_.GetProxy(), networkVpnClient_.networkVpnService_);
     networkVpnClient_.networkVpnService_ = nullptr;
@@ -162,7 +213,7 @@ HWTEST_F(NetworkVpnClientTest, OnRemoteDied, TestSize.Level1)
     sptr<IRemoteObject> remote = nullptr;
     networkVpnClient_.OnRemoteDied(remote);
     sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    remote = sam->CheckSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
+    remote = sam->GetSystemAbility(COMM_VPN_MANAGER_SYS_ABILITY_ID);
     networkVpnClient_.networkVpnService_ = nullptr;
     networkVpnClient_.OnRemoteDied(remote);
     networkVpnClient_.networkVpnService_ = iface_cast<INetworkVpnService>(remote);
@@ -172,7 +223,7 @@ HWTEST_F(NetworkVpnClientTest, OnRemoteDied, TestSize.Level1)
 
 HWTEST_F(NetworkVpnClientTest, NetworkVpnClientBranch001, TestSize.Level1)
 {
-    callback_ = new (std::nothrow) IVpnEventCallbackTest();
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
     callback_->OnVpnMultiUserSetUp();
     networkVpnClient_.multiUserSetUpEvent();
 
@@ -216,5 +267,16 @@ HWTEST_F(NetworkVpnClientTest, GetVpnInterfaceFd, TestSize.Level1)
     int32_t fd = vpnInterface.GetVpnInterfaceFd();
     EXPECT_GT(fd, 0);
 }
+
+HWTEST_F(NetworkVpnClientTest, VpnEventCallback, TestSize.Level1)
+{
+    callback_ = sptr<IVpnEventCallbackTest>::MakeSptr();
+    auto collection = sptr<VpnEventCallbackCollection>::MakeSptr();
+    collection->vpnEventCbList_.push_back(callback_);
+
+    EXPECT_EQ(collection->OnVpnStateChanged(true), NETMANAGER_EXT_SUCCESS);
+    EXPECT_EQ(collection->OnMultiVpnStateChanged(true, "test", "0"), NETMANAGER_EXT_SUCCESS);
+    EXPECT_EQ(collection->OnVpnMultiUserSetUp(), NETMANAGER_EXT_SUCCESS);
+}
 } // namespace NetManagerStandard
 } // namespace OHOS