fix init failed when host not start

Signed-off-by: lizhifeng <lizhifeng23@huawei.com>

bundle.json

@@ -72,8 +72,7 @@
                 ],
                 "service_group": [
                     "//foundation/communication/connected_nfc_tag/sa_profile:nfc_tag_profile",
-                    "//foundation/communication/connected_nfc_tag/services:nfc_tag_service",
-                    "//foundation/communication/connected_nfc_tag/services:nfc_tag_service_static"
+                    "//foundation/communication/connected_nfc_tag/services:nfc_tag_service"
                 ]
             },
             "inner_kits": [

connected_nfc_tag.gni

@@ -18,4 +18,30 @@ declare_args() {
   if (defined(global_parts_info.connected_nfc_tag_only_system_app_access_api)) {
     connected_nfc_tag_only_system_app_access_api = true
   }
-}
+}
+
+common_cflags = [
+  "-fstack-protector-strong",
+  "-D_FORTIFY_SOURCE=2",
+  "-fdata-sections",
+  "-ffunction-sections",
+  "-Os",
+  "-O2",
+]
+
+global_defines = ["NFC_TAG_HILOG"]
+
+global_sanitize = {
+  boundary_sanitize = true
+  cfi = true
+  cfi_cross_dso = true
+  integer_overflow = true
+  ubsan = true
+  debug = false
+}
+
+unittest_defines = [
+  "NFC_TAG_HILOG",
+  "private = public",
+  "protected = public",
+]

interfaces/inner_api/BUILD.gn

@@ -26,26 +26,10 @@ config("nfc_tag_public_config") {
 }
 
 ohos_shared_library("nfc_tag_inner_kits") {
-  cflags_cc = [
-    "-fPIC",
-    "-fdata-sections",
-    "-fno-exceptions",
-    "-ffunction-sections",
-    "-Oz",
-    "-flto",
-    "-Wno-unused-parameter",
-    "-Wunused-private-field",
-  ]
-  defines = [ "NFC_TAG_HILOG" ]
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = false
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
+  cflags = common_cflags
+  cflags_cc = common_cflags
+  sanitize = global_sanitize
+  defines = global_defines
   branch_protector_ret = "pac_ret"
   configs = [ ":nfc_tag_config" ]
   public_configs = [ ":nfc_tag_public_config" ]
@@ -62,7 +46,32 @@ ohos_shared_library("nfc_tag_inner_kits") {
     "hilog:libhilog",
     "ipc:ipc_core",
     "samgr:samgr_proxy",
-    "drivers_interface_connected_nfc_tag:libconnected_nfc_tag_proxy_1.1",
+  ]
+
+  subsystem_name = "communication"
+  part_name = "connected_nfc_tag"
+}
+
+ohos_static_library("nfc_tag_inner_kits_test") {
+  defines = global_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
+  configs = [ ":nfc_tag_config" ]
+  public_configs = [ ":nfc_tag_public_config" ]
+  sources = [
+    "src/nfc_tag_callback_stub.cpp",
+    "src/nfc_tag_client.cpp",
+    "src/nfc_tag_proxy.cpp",
+  ]
+
+  deps = []
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+    "samgr:samgr_proxy",
   ]
 
   subsystem_name = "communication"

services/BUILD.gn

@@ -15,17 +15,6 @@ import("//build/ohos.gni")
 import("//build/ohos_var.gni")
 import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
-nfc_tag_service_cflags_cc = [
-  "-fPIC",
-  "-fdata-sections",
-  "-fno-exceptions",
-  "-ffunction-sections",
-  "-Oz",
-  "-flto",
-  "-Wno-unused-parameter",
-  "-Wunused-private-field",
-]
-
 nfc_tag_service_source = [
     "src/nfc_tag_callback_proxy.cpp",
     "src/nfc_tag_service.cpp",
@@ -56,17 +45,10 @@ nfc_tag_service_external_deps = [
 ]
 
 ohos_shared_library("nfc_tag_service") {
-  cflags_cc = nfc_tag_service_cflags_cc
-  defines = [ "NFC_TAG_HILOG" ]
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = false
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
+  cflags = common_cflags
+  cflags_cc = common_cflags
+  sanitize = global_sanitize
+  defines = global_defines
   branch_protector_ret = "pac_ret"
 
   # Used to control the export of dynamic library symbols.
@@ -87,26 +69,15 @@ ohos_shared_library("nfc_tag_service") {
   subsystem_name = "communication"
 }
 
-ohos_static_library("nfc_tag_service_static") {
-  cflags_cc = nfc_tag_service_cflags_cc
-  defines = [ "NFC_TAG_HILOG" ]
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = false
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
-  branch_protector_ret = "pac_ret"
+ohos_static_library("nfc_tag_service_test") {
+  defines = global_defines
 
   include_dirs = nfc_tag_service_include_dirs
 
   sources = nfc_tag_service_source
 
   deps = [
-    "$NFC_TAG_DIR/services/src/hdi:nfc_tag_hdi_adapter",
+    "$NFC_TAG_DIR/services/src/hdi:nfc_tag_hdi_adapter_test",
   ]
 
   external_deps = nfc_tag_service_external_deps

services/include/nfc_tag_service.h

@@ -22,6 +22,7 @@
 #include "nfc_tag_stub.h"
 #include "iremote_object.h"
 #include "nfc_tag_errcode.h"
+#include "nfc_tag_hdi_adapter.h"
 
 namespace OHOS {
 namespace NFC {
@@ -76,6 +77,7 @@ private:
     bool ServiceInit();
     ErrCode VerifyPermissionsBeforeEntry();
 private:
+    NfcTagHdiAdapter hdiAdapter_;
     bool published_;
     ServiceRunningState state_;
     sptr<NfcTagCallBackManager> callbackManager_;

services/src/hdi/BUILD.gn

@@ -13,38 +13,63 @@
 
 import("//build/ohos.gni")
 import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni")
+import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_static_library("nfc_tag_hdi_adapter") {
-  cflags_cc = [
-    "-fPIC",
-    "-fdata-sections",
-    "-fno-exceptions",
-    "-ffunction-sections",
-    "-Oz",
-    "-flto",
-    "-Wno-unused-parameter",
-    "-Wunused-private-field",
-  ]
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = false
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
+  cflags = common_cflags
+  cflags_cc = common_cflags
+  sanitize = global_sanitize
+  defines = global_defines
   branch_protector_ret = "pac_ret"
 
   include_dirs = [
     "include",
-    "//foundation/communication/connected_nfc_tag/interfaces/inner_api/include",
+    "$NFC_TAG_DIR/interfaces/inner_api/include",
+    "$NFC_TAG_DIR/utils/sa_listener",
     "//third_party/bounds_checking_function/include",
   ]
 
-  sources = [ "src/nfc_tag_hdi_adapter.cpp" ]
+  sources = [
+    "src/nfc_tag_hdi_adapter.cpp",
+    "src/nfc_tag_hdi_impl.cpp",
+  ]
 
-  deps = []
+  deps = [
+    "$NFC_TAG_DIR/utils/sa_listener:nfc_tag_sa_listener",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "drivers_interface_connected_nfc_tag:libconnected_nfc_tag_proxy_1.1",
+    "hdf_core:libhdi",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+  ]
+
+  subsystem_name = "communication"
+  part_name = "connected_nfc_tag"
+}
+
+ohos_static_library("nfc_tag_hdi_adapter_test") {
+  defines = global_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
+  include_dirs = [
+    "include",
+    "$NFC_TAG_DIR/interfaces/inner_api/include",
+    "$NFC_TAG_DIR/utils/sa_listener",
+    "//third_party/bounds_checking_function/include",
+  ]
+
+  sources = [
+    "src/nfc_tag_hdi_adapter.cpp",
+    "src/nfc_tag_hdi_impl.cpp",
+  ]
+
+  deps = [
+    "$NFC_TAG_DIR/utils/sa_listener:nfc_tag_sa_listener",
+  ]
 
   external_deps = [
     "c_utils:utils",

services/src/hdi/include/nfc_tag_hdi_adapter.h

@@ -18,7 +18,6 @@
 #include <string>
 #include <vector>
 #include <cstdint>
-#include <mutex>
 
 #include "infc_tag_callback.h"
 #include "nfc_tag_errcode.h"
@@ -27,10 +26,6 @@ namespace OHOS {
 namespace NFC {
 class NfcTagHdiAdapter {
 public:
-    NfcTagHdiAdapter();
-    ~NfcTagHdiAdapter();
-    static NfcTagHdiAdapter &GetInstance();
-
     ErrCode Init();
 
     ErrCode Uninit();
@@ -46,12 +41,8 @@ public:
     ErrCode RegisterCallBack(sptr<INfcTagCallback> listener);
 
     ErrCode UnRegisterCallBack(sptr<INfcTagCallback> listener);
-
-private:
-    class Impl;
-    sptr<Impl> pimpl_;
-    sptr<Impl> GetImpl();
-    std::mutex implMutex_;
+public:
+    ErrCode InitDriver();
 };
 }  // namespace NFC
 }  // namespace OHOS

services/src/hdi/include/nfc_tag_hdi_impl.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef OHOS_NFC_TAG_HDI_IMPL_H
+#define OHOS_NFC_TAG_HDI_IMPL_H
+
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <mutex>
+
+#include "infc_tag_callback.h"
+#include "v1_1/iconnected_nfc_tag.h"
+#include "iservstat_listener_hdi.h"
+#include "nfc_tag_errcode.h"
+#include "system_ability_listener.h"
+
+namespace OHOS {
+namespace NFC {
+
+class NfcTagDriverStatusListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
+public:
+    NfcTagDriverStatusListener() = default;
+    ~NfcTagDriverStatusListener() = default;
+    void OnReceive(const OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) override;
+};
+
+class NfcTagHdiCallBack : public HDI::ConnectedNfcTag::V1_1::IConnectedNfcTagCallback {
+public:
+    NfcTagHdiCallBack() = default;
+    ~NfcTagHdiCallBack();
+    ErrCode RegisterUpperCallBack(sptr<INfcTagCallback> listener);
+    ErrCode UnRegisterUpperCallBack(sptr<INfcTagCallback> listener);
+    int32_t OnChipEvent(HDI::ConnectedNfcTag::V1_1::ConnectedNfcTagEvent event,
+        const std::vector<uint8_t>& message) override;
+private:
+    std::mutex callbackMutex_;
+    sptr<INfcTagCallback> upperCallBack_{nullptr};
+};
+
+class NfcTagHdiImpl {
+public:
+    static NfcTagHdiImpl &GetInstance();
+    NfcTagHdiImpl();
+    ~NfcTagHdiImpl();
+    ErrCode Init();
+    ErrCode Uninit();
+    ErrCode ReadNdefTag(std::string &data);
+    ErrCode WriteNdefTag(const std::string &data);
+    ErrCode ReadNdefData(std::vector<uint8_t> &data);
+    ErrCode WriteNdefData(const std::vector<uint8_t> &data);
+    ErrCode RegisterCallBack(sptr<INfcTagCallback> listener);
+    ErrCode UnRegisterCallBack(sptr<INfcTagCallback> listener);
+    ErrCode InitDriver();
+    void OnNfcTagDriverStart();
+    void OnNfcTagDriverStop();
+private:
+    sptr<OHOS::HDI::ConnectedNfcTag::V1_1::IConnectedNfcTag> GetProxy();
+    sptr<OHOS::HDI::ConnectedNfcTag::V1_1::IConnectedNfcTag> nfcTagProxy_;
+    std::mutex driverMutex_;
+private:
+    void OnDriverManagerAdd();
+    void OnDriverManagerRemove();
+    sptr<SystemAbilityListener> driverManagerStatusListener_ = nullptr;
+    sptr<OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub> nfcTagDriverStatusListener_ = nullptr;
+};
+}  // namespace NFC
+}  // namespace OHOS
+#endif

services/src/hdi/src/nfc_tag_hdi_adapter.cpp

@@ -12,275 +12,56 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#define LOG_TAG "NFCTAG_SVC_HDI"
+#define LOG_TAG "NFCTAG_SVC_ADAPTER"
 #include "nfc_tag_hdi_adapter.h"
 #include <mutex>
 #include "nfc_tag_log.h"
 #include "nfc_tag_errcode.h"
-#include "v1_1/iconnected_nfc_tag.h"
-
-using namespace OHOS::HDI::ConnectedNfcTag;
-using IConnectedNfcTagV1_1 = OHOS::HDI::ConnectedNfcTag::V1_1::IConnectedNfcTag;
+#include "nfc_tag_hdi_impl.h"
 
 namespace OHOS {
 namespace NFC {
 
-class NfcTagHdiAdapter::Impl : public HDI::ConnectedNfcTag::V1_1::IConnectedNfcTagCallback {
-public:
-    Impl();
-    ~Impl();
-    ErrCode Init();
-    ErrCode Uninit();
-    ErrCode ReadNdefTag(std::string &data);
-    ErrCode WriteNdefTag(const std::string &data);
-    ErrCode ReadNdefData(std::vector<uint8_t> &data);
-    ErrCode WriteNdefData(const std::vector<uint8_t> &data);
-    ErrCode RegisterCallBack(sptr<INfcTagCallback> listener, sptr<Impl> impl);
-    ErrCode UnRegisterCallBack(sptr<INfcTagCallback> listener, sptr<Impl> impl);
-    int32_t OnChipEvent(HDI::ConnectedNfcTag::V1_1::ConnectedNfcTagEvent event,
-        const std::vector<uint8_t>& message) override;
-private:
-    sptr<IConnectedNfcTagV1_1> GetProxy();
-    std::mutex proxyMutex_;
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy_;
-    sptr<INfcTagCallback> upperCallBack_;
-    std::mutex callbackMutex_;
-    bool inited;
-};
-
-NfcTagHdiAdapter::Impl::Impl(): inited(false)
-{
-    HILOGI("enter");
-}
-
-NfcTagHdiAdapter::Impl::~Impl()
-{
-    HILOGI("destroy called.");
-    {
-        std::lock_guard<std::mutex> lock(callbackMutex_);
-        upperCallBack_ = nullptr;
-    }
-    if (inited) {
-        Uninit();
-    }
-    std::lock_guard<std::mutex> lock(proxyMutex_);
-    nfcTagProxy_ = nullptr;
-}
-
-sptr<IConnectedNfcTagV1_1> NfcTagHdiAdapter::Impl::GetProxy()
-{
-    std::lock_guard<std::mutex> lock(proxyMutex_);
-    if (nfcTagProxy_ == nullptr) {
-        nfcTagProxy_ = IConnectedNfcTagV1_1::Get();
-    }
-    return nfcTagProxy_;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::Init()
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    int32_t ret = nfcTagProxy->Init();
-    if (ret != 0) {
-        HILOGE("nfcTagProxy->Init %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    inited = true;
-    return NFC_SUCCESS;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::Uninit()
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    int32_t ret = nfcTagProxy->Uninit();
-    inited = false;
-    if (ret != 0) {
-        HILOGE("nfcTagProxy->Uninit %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    return NFC_SUCCESS;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::ReadNdefTag(std::string &data)
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    int32_t ret = nfcTagProxy->ReadNdefTag(data);
-    if (ret != 0) {
-        HILOGE("nfcTagProxy->ReadNdefTag %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    return NFC_SUCCESS;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::WriteNdefTag(const std::string &data)
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    int32_t ret = nfcTagProxy->WriteNdefTag(data);
-    if (ret != 0) {
-        HILOGE("nfcTagProxy->WriteNdefTag %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    return NFC_SUCCESS;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::ReadNdefData(std::vector<uint8_t> &data)
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    int32_t ret = nfcTagProxy->ReadNdefData(data);
-    if (ret != 0) {
-        HILOGE("nfcTagProxy->ReadNdefData %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    return NFC_SUCCESS;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::WriteNdefData(const std::vector<uint8_t> &data)
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    int32_t ret = nfcTagProxy->WriteNdefData(data);
-    if (ret != 0) {
-        HILOGE("nfcTagProxy->WriteNdefData %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    return NFC_SUCCESS;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::RegisterCallBack(sptr<INfcTagCallback> listener, sptr<Impl> impl)
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    {
-        std::lock_guard<std::mutex> lock(callbackMutex_);
-        upperCallBack_ = listener;
-    }
-    int32_t ret = nfcTagProxy->RegisterCallBack(impl);
-    if (ret != 0) {
-        HILOGE("nfcTagProxy->RegisterCallBack %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    return NFC_SUCCESS;
-}
-
-ErrCode NfcTagHdiAdapter::Impl::UnRegisterCallBack(sptr<INfcTagCallback> listener, sptr<Impl> impl)
-{
-    HILOGI("enter");
-    sptr<IConnectedNfcTagV1_1> nfcTagProxy = GetProxy();
-    if (nfcTagProxy == nullptr) {
-        HILOGE("nfcTagProxy == nullptr");
-        return NFC_NO_HDI_PROXY;
-    }
-    {
-        std::lock_guard<std::mutex> lock(callbackMutex_);
-        if (upperCallBack_ == listener) {
-            upperCallBack_ = nullptr;
-        } else {
-            HILOGE("listener not equal the regisetered");
-            return NFC_NO_CALLBACK;
-        }
-    }
-    int32_t ret = nfcTagProxy->RegisterCallBack(nullptr);
-    if (ret != 0) {
-        HILOGE("UnRegisterCallBack %{public}d", ret);
-        return NFC_HDI_REMOTE_FAILED;
-    }
-    return NFC_SUCCESS;
-}
-
-int32_t NfcTagHdiAdapter::Impl::OnChipEvent(HDI::ConnectedNfcTag::V1_1::ConnectedNfcTagEvent event,
-    const std::vector<uint8_t>& message)
-{
-    HILOGI("event: %d", static_cast<int>(event));
-    std::lock_guard<std::mutex> lock(callbackMutex_);
-    if (upperCallBack_ != nullptr) {
-        upperCallBack_->OnNotify(static_cast<int>(event));
-    }
-    return 0;
-}
-
-NfcTagHdiAdapter::NfcTagHdiAdapter(): pimpl_(sptr<Impl>::MakeSptr())
-{
-    HILOGI("enter");
-}
-
-NfcTagHdiAdapter::~NfcTagHdiAdapter()
-{
-    HILOGI("enter");
-}
-
-NfcTagHdiAdapter &NfcTagHdiAdapter::GetInstance()
-{
-    static NfcTagHdiAdapter sNfcTagHdiAdapter;
-    return sNfcTagHdiAdapter;
-}
-
 ErrCode NfcTagHdiAdapter::Init()
 {
-    return pimpl_->Init();
+    return NfcTagHdiImpl::GetInstance().Init();
 }
 ErrCode NfcTagHdiAdapter::Uninit()
 {
-    return pimpl_->Uninit();
+    return NfcTagHdiImpl::GetInstance().Uninit();
 }
 ErrCode NfcTagHdiAdapter::ReadNdefTag(std::string &data)
 {
-    return pimpl_->ReadNdefTag(data);
+    return NfcTagHdiImpl::GetInstance().ReadNdefTag(data);
 }
 ErrCode NfcTagHdiAdapter::WriteNdefTag(const std::string &data)
 {
-    return pimpl_->WriteNdefTag(data);
+    return NfcTagHdiImpl::GetInstance().WriteNdefTag(data);
 }
 
 ErrCode NfcTagHdiAdapter::ReadNdefData(std::vector<uint8_t> &data)
 {
-    return pimpl_->ReadNdefData(data);
+    return NfcTagHdiImpl::GetInstance().ReadNdefData(data);
 }
 
 ErrCode NfcTagHdiAdapter::WriteNdefData(const std::vector<uint8_t> &data)
 {
-    return pimpl_->WriteNdefData(data);
+    return NfcTagHdiImpl::GetInstance().WriteNdefData(data);
 }
 
 ErrCode NfcTagHdiAdapter::RegisterCallBack(sptr<INfcTagCallback> listener)
 {
-    return pimpl_->RegisterCallBack(listener, pimpl_);
+    return NfcTagHdiImpl::GetInstance().RegisterCallBack(listener);
 }
 
 ErrCode NfcTagHdiAdapter::UnRegisterCallBack(sptr<INfcTagCallback> listener)
 {
-    return pimpl_->UnRegisterCallBack(listener, pimpl_);
+    return NfcTagHdiImpl::GetInstance().UnRegisterCallBack(listener);
+}
+
+ErrCode NfcTagHdiAdapter::InitDriver()
+{
+    return NfcTagHdiImpl::GetInstance().InitDriver();
 }
 
 }  // namespace NFC

services/src/hdi/src/nfc_tag_hdi_impl.cpp

@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2022-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "NFCTAG_SVC_HDI"
+#include "nfc_tag_hdi_impl.h"
+#include "nfc_tag_log.h"
+#include "nfc_tag_errcode.h"
+#include "system_ability_definition.h"
+#include "iservice_registry.h"
+#include "iservmgr_hdi.h"
+
+namespace OHOS {
+namespace NFC {
+
+namespace {
+constexpr const char *SERVICE_NAME = "connected_nfc_tag_service";
+};
+
+void NfcTagDriverStatusListener::OnReceive(const OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status)
+{
+    if (status.serviceName != SERVICE_NAME) {
+        return;
+    }
+
+    HILOGI("receive service %{public}s status %{public}d", status.serviceName.c_str(), status.status);
+    if (status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
+        NfcTagHdiImpl::GetInstance().OnNfcTagDriverStart();
+    } else if (status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP) {
+        NfcTagHdiImpl::GetInstance().OnNfcTagDriverStop();
+    }
+}
+
+NfcTagHdiCallBack::~NfcTagHdiCallBack()
+{
+    std::lock_guard<std::mutex> lock(callbackMutex_);
+    upperCallBack_ = nullptr;
+}
+
+ErrCode NfcTagHdiCallBack::RegisterUpperCallBack(sptr<INfcTagCallback> listener)
+{
+    std::lock_guard<std::mutex> lock(callbackMutex_);
+    if (listener == nullptr) {
+        HILOGE("listener == nullptr");
+        return NFC_NO_CALLBACK;
+    }
+    if (upperCallBack_ != nullptr) {
+        HILOGE("listener been registered");
+        return NFC_CALLBACK_REGISTERED;
+    }
+    upperCallBack_ = listener;
+    return NFC_SUCCESS;
+}
+ErrCode NfcTagHdiCallBack::UnRegisterUpperCallBack(sptr<INfcTagCallback> listener)
+{
+    std::lock_guard<std::mutex> lock(callbackMutex_);
+    if (upperCallBack_ != listener || listener == nullptr) {
+        HILOGE("listener not equal the registered");
+        return NFC_INVALID_CALLBACK;
+    }
+    upperCallBack_ = nullptr;
+    return NFC_SUCCESS;
+}
+int32_t NfcTagHdiCallBack::OnChipEvent(HDI::ConnectedNfcTag::V1_1::ConnectedNfcTagEvent event,
+    const std::vector<uint8_t>& message)
+{
+    HILOGI("event: %d", static_cast<int>(event));
+    std::lock_guard<std::mutex> lock(callbackMutex_);
+    if (upperCallBack_ != nullptr) {
+        upperCallBack_->OnNotify(static_cast<int>(event));
+    }
+    return 0;
+}
+
+sptr<NfcTagHdiCallBack> g_nfcTagHdiCallBack = sptr<NfcTagHdiCallBack>::MakeSptr();
+
+NfcTagHdiImpl &NfcTagHdiImpl::GetInstance()
+{
+    static NfcTagHdiImpl sNfcTagHdiImpl;
+    return sNfcTagHdiImpl;
+}
+
+NfcTagHdiImpl::NfcTagHdiImpl()
+{
+    HILOGI("enter");
+    nfcTagDriverStatusListener_ = sptr<NfcTagDriverStatusListener>::MakeSptr();
+}
+
+NfcTagHdiImpl::~NfcTagHdiImpl()
+{
+    HILOGI("destroy called.");
+    Uninit();
+
+    if (driverManagerStatusListener_) {
+        SystemAbilityListener::UnSubscribe(DEVICE_SERVICE_MANAGER_SA_ID, driverManagerStatusListener_);
+    }
+
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    nfcTagProxy_ = nullptr;
+}
+
+sptr<OHOS::HDI::ConnectedNfcTag::V1_1::IConnectedNfcTag> NfcTagHdiImpl::GetProxy()
+{
+    if (nfcTagProxy_ == nullptr) {
+        nfcTagProxy_ = OHOS::HDI::ConnectedNfcTag::V1_1::IConnectedNfcTag::Get();
+    }
+    return nfcTagProxy_;
+}
+
+ErrCode NfcTagHdiImpl::Init()
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    int32_t ret = nfcTagProxy->Init();
+    if (ret != 0) {
+        HILOGE("nfcTagProxy->Init %{public}d", ret);
+        return NFC_HDI_REMOTE_FAILED;
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::Uninit()
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    int32_t ret = nfcTagProxy->Uninit();
+    if (ret != 0) {
+        HILOGE("nfcTagProxy->Uninit %{public}d", ret);
+        return NFC_HDI_REMOTE_FAILED;
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::ReadNdefTag(std::string &data)
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    int32_t ret = nfcTagProxy->ReadNdefTag(data);
+    if (ret != 0) {
+        HILOGE("nfcTagProxy->ReadNdefTag %{public}d", ret);
+        return NFC_HDI_REMOTE_FAILED;
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::WriteNdefTag(const std::string &data)
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    int32_t ret = nfcTagProxy->WriteNdefTag(data);
+    if (ret != 0) {
+        HILOGE("nfcTagProxy->WriteNdefTag %{public}d", ret);
+        return NFC_HDI_REMOTE_FAILED;
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::ReadNdefData(std::vector<uint8_t> &data)
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    int32_t ret = nfcTagProxy->ReadNdefData(data);
+    if (ret != 0) {
+        HILOGE("nfcTagProxy->ReadNdefData %{public}d", ret);
+        return NFC_HDI_REMOTE_FAILED;
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::WriteNdefData(const std::vector<uint8_t> &data)
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    int32_t ret = nfcTagProxy->WriteNdefData(data);
+    if (ret != 0) {
+        HILOGE("nfcTagProxy->WriteNdefData %{public}d", ret);
+        return NFC_HDI_REMOTE_FAILED;
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::RegisterCallBack(sptr<INfcTagCallback> listener)
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    ErrCode errCode = g_nfcTagHdiCallBack->RegisterUpperCallBack(listener);
+    if (errCode != NFC_SUCCESS) {
+        return errCode;
+    }
+    int32_t ret = nfcTagProxy->RegisterCallBack(g_nfcTagHdiCallBack);
+    if (ret != 0) {
+        g_nfcTagHdiCallBack->UnRegisterUpperCallBack(listener);
+        HILOGE("nfcTagProxy->RegisterCallBack %{public}d", ret);
+        return NFC_HDI_REMOTE_FAILED;
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::UnRegisterCallBack(sptr<INfcTagCallback> listener)
+{
+    HILOGI("enter");
+    std::lock_guard<std::mutex> lock(driverMutex_);
+    auto nfcTagProxy = GetProxy();
+    if (nfcTagProxy == nullptr) {
+        HILOGE("nfcTagProxy == nullptr");
+        return NFC_NO_HDI_PROXY;
+    }
+    ErrCode errCode = g_nfcTagHdiCallBack->UnRegisterUpperCallBack(listener);
+    if (errCode != NFC_SUCCESS) {
+        return errCode;
+    }
+    int32_t ret = nfcTagProxy->RegisterCallBack(nullptr);
+    if (ret != 0) {
+        HILOGE("UnRegisterCallBack %{public}d", ret);
+    }
+    return NFC_SUCCESS;
+}
+
+ErrCode NfcTagHdiImpl::InitDriver()
+{
+    if (driverManagerStatusListener_ != nullptr) {
+        HILOGE("driverManagerStatusListener_ != nullptr");
+        return NFC_SUCCESS;
+    }
+    driverManagerStatusListener_ = SystemAbilityListener::Subscribe(
+        "DriverManager", DEVICE_SERVICE_MANAGER_SA_ID,
+        [this]() { OnDriverManagerAdd(); },
+        [this]() { OnDriverManagerRemove(); });
+    return NFC_SUCCESS;
+}
+
+void NfcTagHdiImpl::OnDriverManagerAdd()
+{
+    HILOGI("enter");
+    auto servMgr = OHOS::HDI::ServiceManager::V1_0::IServiceManager::Get();
+    if (servMgr == nullptr) {
+        HILOGE("servMgr == nullptr");
+        return;
+    }
+    if (servMgr->RegisterServiceStatusListener(nfcTagDriverStatusListener_, DEVICE_CLASS_DEFAULT) != 0) {
+        HILOGE("RegisterServiceStatusListener failed");
+        return;
+    }
+    auto service = servMgr->GetService(SERVICE_NAME);
+    if (service != nullptr) {
+        OnNfcTagDriverStart();
+    } else {
+        OnNfcTagDriverStop();
+    }
+}
+
+void NfcTagHdiImpl::OnDriverManagerRemove()
+{
+    HILOGI("enter");
+    OnNfcTagDriverStop();
+}
+
+void NfcTagHdiImpl::OnNfcTagDriverStart()
+{
+    HILOGI("enter");
+    Init();
+}
+
+void NfcTagHdiImpl::OnNfcTagDriverStop()
+{
+    HILOGI("enter");
+    Uninit();
+}
+
+}  // namespace NFC
+}  // namespace OHOS

services/src/nfc_tag_service.cpp

@@ -112,6 +112,8 @@ void NfcTagService::OnStart()
         HILOGI("Service has already started.");
         return;
     }
+    ErrCode errCode = hdiAdapter_.InitDriver();
+    HILOGI("hdiAdapter_.InitDriver: %{public}d", errCode);
     if (!ServiceInit()) {
         HILOGE("Failed to init service");
         OnStop();
@@ -166,7 +168,7 @@ ErrCode NfcTagService::Init()
     if (ret != NFC_SUCCESS) {
         return ret;
     }
-    return NfcTagHdiAdapter::GetInstance().Init();
+    return hdiAdapter_.Init();
 }
 
 ErrCode NfcTagService::Uninit()
@@ -175,7 +177,7 @@ ErrCode NfcTagService::Uninit()
     if (ret != NFC_SUCCESS) {
         return ret;
     }
-    return NfcTagHdiAdapter::GetInstance().Uninit();
+    return hdiAdapter_.Uninit();
 }
 
 ErrCode NfcTagService::ReadNdefTag(std::string &response)
@@ -184,7 +186,7 @@ ErrCode NfcTagService::ReadNdefTag(std::string &response)
     if (ret != NFC_SUCCESS) {
         return ret;
     }
-    return NfcTagHdiAdapter::GetInstance().ReadNdefTag(response);
+    return hdiAdapter_.ReadNdefTag(response);
 }
 
 ErrCode NfcTagService::WriteNdefTag(const std::string &data)
@@ -193,7 +195,7 @@ ErrCode NfcTagService::WriteNdefTag(const std::string &data)
     if (ret != NFC_SUCCESS) {
         return ret;
     }
-    return NfcTagHdiAdapter::GetInstance().WriteNdefTag(data);
+    return hdiAdapter_.WriteNdefTag(data);
 }
 
 ErrCode NfcTagService::ReadNdefData(std::vector<uint8_t> &data)
@@ -202,7 +204,7 @@ ErrCode NfcTagService::ReadNdefData(std::vector<uint8_t> &data)
     if (ret != NFC_SUCCESS) {
         return ret;
     }
-    return NfcTagHdiAdapter::GetInstance().ReadNdefData(data);
+    return hdiAdapter_.ReadNdefData(data);
 }
 
 ErrCode NfcTagService::WriteNdefData(const std::vector<uint8_t> &data)
@@ -211,7 +213,7 @@ ErrCode NfcTagService::WriteNdefData(const std::vector<uint8_t> &data)
     if (ret != NFC_SUCCESS) {
         return ret;
     }
-    return NfcTagHdiAdapter::GetInstance().WriteNdefData(data);
+    return hdiAdapter_.WriteNdefData(data);
 }
 
 ErrCode NfcTagService::RegListener(const sptr<INfcTagCallback> &callback)
@@ -230,7 +232,7 @@ ErrCode NfcTagService::RegListener(const sptr<INfcTagCallback> &callback)
     }
     ErrCode errCode = callbackManager_->RegisterListener(callback);
     if (errCode == NFC_SUCCESS) {
-        ErrCode hdiCode = NfcTagHdiAdapter::GetInstance().RegisterCallBack(callbackManager_);
+        ErrCode hdiCode = hdiAdapter_.RegisterCallBack(callbackManager_);
         if (hdiCode != NFC_SUCCESS) {
             callbackManager_->UnRegisterListener(callback);
         }
@@ -255,7 +257,7 @@ ErrCode NfcTagService::UnregListener(const sptr<INfcTagCallback> &callback)
     }
     ErrCode errCode = callbackManager_->UnRegisterListener(callback);
     if (errCode == NFC_SUCCESS) {
-        return NfcTagHdiAdapter::GetInstance().UnRegisterCallBack(callbackManager_);
+        return hdiAdapter_.UnRegisterCallBack(callbackManager_);
     }
     return errCode;
 }

test/fuzztest/framework_fuzzer/BUILD.gn

@@ -19,19 +19,19 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 ohos_fuzztest("FrameworkFuzzTest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
   fuzz_config_file = "$NFC_TAG_DIR/test/fuzztest/framework_fuzzer"
-
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = global_defines
   sources = [
     "nfc_tag_proxy_fuzzer.cpp",
   ]
   include_dirs = [
     "$NFC_TAG_DIR/interfaces/inner_api/include",
+    "$NFC_TAG_DIR/services/src/hdi/include",
     "$NFC_TAG_DIR/services/include",
     "$NFC_TAG_DIR/test/utils",
   ]
   deps = [
-    "$NFC_TAG_DIR/interfaces/inner_api:nfc_tag_inner_kits",
-    "$NFC_TAG_DIR/services:nfc_tag_service_static",
+    "$NFC_TAG_DIR/interfaces/inner_api:nfc_tag_inner_kits_test",
+    "$NFC_TAG_DIR/services:nfc_tag_service_test",
     "$NFC_TAG_DIR/test/utils:test_utils_static",
   ]
 
@@ -41,24 +41,6 @@ ohos_fuzztest("FrameworkFuzzTest") {
     "ipc:ipc_core",
   ]
 
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
-  cflags += [
-    "-g",
-    "-O0",
-    "-Wno-unused-variable",
-    "-fno-omit-frame-pointer",
-  ]
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = true
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
   part_name = "connected_nfc_tag"
   subsystem_name = "communication"
 }

test/fuzztest/service_fuzzer/BUILD.gn

@@ -19,19 +19,19 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 ohos_fuzztest("ServiceFuzzTest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
   fuzz_config_file = "$NFC_TAG_DIR/test/fuzztest/service_fuzzer"
-
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = global_defines
   sources = [
     "nfc_tag_service_fuzzer.cpp",
   ]
   include_dirs = [
     "$NFC_TAG_DIR/interfaces/inner_api/include",
+    "$NFC_TAG_DIR/services/src/hdi/include",
     "$NFC_TAG_DIR/services/include",
     "$NFC_TAG_DIR/test/utils",
   ]
   deps = [
-    "$NFC_TAG_DIR/interfaces/inner_api:nfc_tag_inner_kits",
-    "$NFC_TAG_DIR/services:nfc_tag_service_static",
+    "$NFC_TAG_DIR/interfaces/inner_api:nfc_tag_inner_kits_test",
+    "$NFC_TAG_DIR/services:nfc_tag_service_test",
     "$NFC_TAG_DIR/test/utils:test_utils_static",
   ]
 
@@ -41,24 +41,6 @@ ohos_fuzztest("ServiceFuzzTest") {
     "ipc:ipc_core",
   ]
 
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
-  cflags += [
-    "-g",
-    "-O0",
-    "-Wno-unused-variable",
-    "-fno-omit-frame-pointer",
-  ]
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = true
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
   part_name = "connected_nfc_tag"
   subsystem_name = "communication"
 }

test/unittest/common_mock/BUILD.gn

@@ -21,7 +21,10 @@ config("common_mock_config") {
 }
 
 ohos_static_library("nfc_tag_common_mock") {
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "common_mock.cpp",
   ]

test/unittest/common_mock/iservstat_listener_hdi.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ISERVSTAT_LISTENER_HDI_H
+#define ISERVSTAT_LISTENER_HDI_H
+
+namespace OHOS::HDI::ServiceManager::V1_0 {
+struct ServiceStatus {
+    /** Service name */
+    std::string serviceName;
+    /** Device type */
+    uint16_t deviceClass;
+    /** Service status */
+    uint16_t status;
+    /** Service information */
+    std::string info;
+};
+
+class ServStatListenerStub : public OHOS::RefBase {
+public:
+    ServStatListenerStub() = default;
+    ~ServStatListenerStub() = default;
+    virtual void OnReceive(const OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) = 0;
+};
+
+}
+
+#endif

test/unittest/common_mock/system_ability_listener.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SYSTEM_ABILITY_LISTENER_H
+#define SYSTEM_ABILITY_LISTENER_H
+
+namespace OHOS::NFC {
+class SystemAbilityListener : public OHOS::RefBase {
+public:
+    SystemAbilityListener() = default;
+    ~SystemAbilityListener() = default;
+};
+}
+
+#endif

test/unittest/framework_test/nfc_tag_callback_stub_test/BUILD.gn

@@ -18,14 +18,14 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_callback_stub_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_callback_stub_test.cpp",
     "$NFC_TAG_DIR/interfaces/inner_api/src/nfc_tag_callback_stub.cpp",
   ]
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
 
   include_dirs = [
     "$NFC_TAG_DIR/interfaces/inner_api/include",

test/unittest/framework_test/nfc_tag_callback_stub_test/nfc_tag_callback_stub_test.cpp

@@ -15,9 +15,7 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#define private public
 #include "nfc_tag_callback_stub.h"
-#undef private
 #include "common_mock.h"
 using namespace testing;
 using namespace testing::ext;

test/unittest/framework_test/nfc_tag_proxy_test/BUILD.gn

@@ -18,25 +18,16 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_proxy_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_proxy_test.cpp",
     "$NFC_TAG_DIR/test/unittest/source_mock/nfc_tag_callback_stub_mock.cpp",
     "$NFC_TAG_DIR/interfaces/inner_api/src/nfc_tag_proxy.cpp",
   ]
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
 
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = false
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
   include_dirs = [
     "$NFC_TAG_DIR/services/include",
     "$NFC_TAG_DIR/services/src/hdi/include",

test/unittest/framework_test/nfc_tag_proxy_test/nfc_tag_proxy_test.cpp

@@ -14,9 +14,7 @@
  */
 
 #include "gtest/gtest.h"
-#define private public
 #include "nfc_tag_proxy.h"
-#undef private
 #include "nfc_tag_stub.h"
 #include "system_ability.h"
 #include "accesstoken_kit.h"

test/unittest/service_test/nfc_tag_callback_proxy_test/BUILD.gn

@@ -18,25 +18,16 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_callback_proxy_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_callback_proxy_test.cpp",
     "$NFC_TAG_DIR/test/unittest/source_mock/nfc_tag_callback_stub_mock.cpp",
     "$NFC_TAG_DIR/services/src/nfc_tag_callback_proxy.cpp",
   ]
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
 
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = false
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
   include_dirs = [
     "$NFC_TAG_DIR/services/include",
     "$NFC_TAG_DIR/services/src/hdi/include",

test/unittest/service_test/nfc_tag_callback_proxy_test/nfc_tag_callback_proxy_test.cpp

@@ -14,9 +14,7 @@
  */
 
 #include "gtest/gtest.h"
-#define private public
 #include "nfc_tag_callback_proxy.h"
-#undef private
 #include "nfc_tag_callback_stub.h"
 #include "nfc_tag_hdi_adapter.h"
 #include "accesstoken_kit.h"

test/unittest/service_test/nfc_tag_hdi_adapter_test/BUILD.gn

@@ -18,21 +18,21 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_hdi_adapter_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
-  sources = [
-    "nfc_tag_hdi_adapter_test.cpp",
-    "$NFC_TAG_DIR/services/src/hdi/src/nfc_tag_hdi_adapter.cpp",
-  ]
+  defines = unittest_defines
   cflags_cc = [ "--coverage" ]
   cflags = [ "--coverage" ]
   ldflags = [ "--coverage" ]
+  sources = [
+    "nfc_tag_hdi_adapter_test.cpp",
+    "nfc_tag_hdi_impl_mock.cpp",
+    "$NFC_TAG_DIR/services/src/hdi/src/nfc_tag_hdi_adapter.cpp",
+  ]
 
   include_dirs = [
     "$NFC_TAG_DIR/services/include",
     "$NFC_TAG_DIR/services/src/hdi/include",
     "$NFC_TAG_DIR/interfaces/inner_api/include",
     "./../../common_mock/",
-    "./v1_1/",
     "./",
   ]
 

test/unittest/service_test/nfc_tag_hdi_adapter_test/nfc_tag_hdi_adapter_test.cpp

@@ -13,12 +13,9 @@
  * limitations under the License.
  */
 
-
 #include "gtest/gtest.h"
-#define private public
 #include "nfc_tag_hdi_adapter.h"
 #include "v1_1/iconnected_nfc_tag.h"
-#undef private
 
 using namespace testing;
 using namespace testing::ext;
@@ -27,10 +24,6 @@ using namespace OHOS;
 using namespace OHOS::HDI::ConnectedNfcTag;
 using namespace OHOS::HDI::ConnectedNfcTag::V1_1;
 
-int32_t IConnectedNfcTag::resultMock_ = -1;
-bool IConnectedNfcTag::noProxy_ = true;
-sptr<IConnectedNfcTag> IConnectedNfcTag::iconnectedNfcTag_ = nullptr;
-
 namespace OHOS {
 namespace NFC {
 
@@ -54,438 +47,124 @@ public:
 };
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_GetInstance_001
- * @tc.name: NfcTagHdiAdapterTest_GetInstance_001
- * @tc.desc: return NFC_SUCCESS
+ * @tc.number: NfcTagHdiAdapterTest_Init
+ * @tc.name: NfcTagHdiAdapterTest_Init
+ * @tc.desc: Init call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_GetInstance_001, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Init, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_GetInstance_001 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    EXPECT_EQ(NfcTagHdiAdapter::GetInstance().Init(), NFC_SUCCESS);
-    EXPECT_EQ(NfcTagHdiAdapter::GetInstance().Uninit(), NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_GetInstance_001 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_Init_001
- * @tc.name: NfcTagHdiAdapterTest_Init_001
- * @tc.desc: return NFC_NO_HDI_PROXY
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Init_001, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init_001 start";
-    IConnectedNfcTag::noProxy_ = true;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init start";
     NfcTagHdiAdapter adapter;
-    ErrCode ret = adapter.Init();
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init_001 end";
+    EXPECT_EQ(adapter.Init(), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_Init_002
- * @tc.name: NfcTagHdiAdapterTest_Init_002
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
+ * @tc.number: NfcTagHdiAdapterTest_Uninit
+ * @tc.name: NfcTagHdiAdapterTest_Uninit
+ * @tc.desc: Uninit call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Init_002, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Uninit, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init_002 start";
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit start";
     NfcTagHdiAdapter adapter;
-    ErrCode ret = adapter.Init();
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init_002 end";
+    EXPECT_EQ(adapter.Uninit(), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_Init_003
- * @tc.name: NfcTagHdiAdapterTest_Init_003
- * @tc.desc: return NFC_SUCCESS
+ * @tc.number: NfcTagHdiAdapterTest_ReadNdefTag
+ * @tc.name: NfcTagHdiAdapterTest_ReadNdefTag
+ * @tc.desc: ReadNdefTag call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Init_003, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefTag, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    ErrCode ret = adapter.Init();
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    ret = adapter.Uninit();
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Init_003 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_Uninit_001
- * @tc.name: NfcTagHdiAdapterTest_Uninit_001
- * @tc.desc: return NFC_NO_HDI_PROXY
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Uninit_001, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit_001 start";
-    NfcTagHdiAdapter adapter;
-    IConnectedNfcTag::noProxy_ = true;
-    ErrCode ret = adapter.Uninit();
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit_001 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_Uninit_002
- * @tc.name: NfcTagHdiAdapterTest_Uninit_002
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Uninit_002, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit_002 start";
-    NfcTagHdiAdapter adapter;
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
-    ErrCode ret = adapter.Uninit();
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit_002 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_Uninit_003
- * @tc.name: NfcTagHdiAdapterTest_Uninit_003
- * @tc.desc: return NFC_SUCCESS
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_Uninit_003, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    ErrCode ret = adapter.Uninit();
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_Uninit_003 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_ReadNdefTag_001
- * @tc.name: NfcTagHdiAdapterTest_ReadNdefTag_001
- * @tc.desc: return NFC_NO_HDI_PROXY
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefTag_001, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag_001 start";
-    IConnectedNfcTag::noProxy_ = true;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag start";
     NfcTagHdiAdapter adapter;
     std::string tag;
-    ErrCode ret = adapter.ReadNdefTag(tag);
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag_001 end";
+    EXPECT_EQ(adapter.ReadNdefTag(tag), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_ReadNdefTag_002
- * @tc.name: NfcTagHdiAdapterTest_ReadNdefTag_002
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
+ * @tc.number: NfcTagHdiAdapterTest_WriteNdefTag
+ * @tc.name: NfcTagHdiAdapterTest_WriteNdefTag
+ * @tc.desc: WriteNdefTag call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefTag_002, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefTag, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag_002 start";
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag start";
     NfcTagHdiAdapter adapter;
     std::string tag;
-    ErrCode ret = adapter.ReadNdefTag(tag);
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag_002 end";
+    EXPECT_EQ(adapter.WriteNdefTag(tag), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_ReadNdefTag_003
- * @tc.name: NfcTagHdiAdapterTest_ReadNdefTag_003
- * @tc.desc: return NFC_SUCCESS
+ * @tc.number: NfcTagHdiAdapterTest_ReadNdefData
+ * @tc.name: NfcTagHdiAdapterTest_ReadNdefData
+ * @tc.desc: ReadNdefData call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefTag_003, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefData, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData start";
     NfcTagHdiAdapter adapter;
-    std::string tag;
-    ErrCode ret = adapter.ReadNdefTag(tag);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefTag_003 end";
+    std::vector<uint8_t> data;
+    EXPECT_EQ(adapter.ReadNdefData(data), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_WriteNdefTag_001
- * @tc.name: NfcTagHdiAdapterTest_WriteNdefTag_001
- * @tc.desc: return NFC_NO_HDI_PROXY
+ * @tc.number: NfcTagHdiAdapterTest_WriteNdefData
+ * @tc.name: NfcTagHdiAdapterTest_WriteNdefData
+ * @tc.desc: WriteNdefData call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefTag_001, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefData, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag_001 start";
-    IConnectedNfcTag::noProxy_ = true;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData start";
     NfcTagHdiAdapter adapter;
-    std::string tag = "test";
-    ErrCode ret = adapter.WriteNdefTag(tag);
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag_001 end";
+    std::vector<uint8_t> data;
+    EXPECT_EQ(adapter.WriteNdefData(data), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_WriteNdefTag_002
- * @tc.name: NfcTagHdiAdapterTest_WriteNdefTag_002
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
+ * @tc.number: NfcTagHdiAdapterTest_RegisterCallBack
+ * @tc.name: NfcTagHdiAdapterTest_RegisterCallBack
+ * @tc.desc: RegisterCallBack call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefTag_002, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_RegisterCallBack, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag_002 start";
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack start";
     NfcTagHdiAdapter adapter;
-    std::string tag = "test";
-    ErrCode ret = adapter.WriteNdefTag(tag);
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag_002 end";
+    EXPECT_EQ(adapter.RegisterCallBack(nullptr), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_WriteNdefTag_003
- * @tc.name: NfcTagHdiAdapterTest_WriteNdefTag_003
- * @tc.desc: return NFC_SUCCESS
+ * @tc.number: NfcTagHdiAdapterTest_UnRegisterCallBack
+ * @tc.name: NfcTagHdiAdapterTest_UnRegisterCallBack
+ * @tc.desc: UnRegisterCallBack call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefTag_003, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_UnRegisterCallBack, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack start";
     NfcTagHdiAdapter adapter;
-    std::string tag = "test";
-    ErrCode ret = adapter.WriteNdefTag(tag);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefTag_003 end";
+    EXPECT_EQ(adapter.UnRegisterCallBack(nullptr), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack end";
 }
 
 /*
- * @tc.number: NfcTagHdiAdapterTest_ReadNdefData_001
- * @tc.name: NfcTagHdiAdapterTest_ReadNdefData_001
- * @tc.desc: return NFC_NO_HDI_PROXY
+ * @tc.number: NfcTagHdiAdapterTest_InitDriver
+ * @tc.name: NfcTagHdiAdapterTest_InitDriver
+ * @tc.desc: InitDriver call
 */
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefData_001, TestSize.Level0)
+HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_InitDriver, TestSize.Level0)
 {
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData_001 start";
-    IConnectedNfcTag::noProxy_ = true;
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_InitDriver start";
     NfcTagHdiAdapter adapter;
-    std::vector<uint8_t> tag;
-    ErrCode ret = adapter.ReadNdefData(tag);
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData_001 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_ReadNdefData_002
- * @tc.name: NfcTagHdiAdapterTest_ReadNdefData_002
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefData_002, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData_002 start";
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    std::vector<uint8_t> tag;
-    ErrCode ret = adapter.ReadNdefData(tag);
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData_002 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_ReadNdefData_003
- * @tc.name: NfcTagHdiAdapterTest_ReadNdefData_003
- * @tc.desc: return NFC_SUCCESS
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_ReadNdefData_003, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    std::vector<uint8_t> tag;
-    ErrCode ret = adapter.ReadNdefData(tag);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_ReadNdefData_003 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_WriteNdefData_001
- * @tc.name: NfcTagHdiAdapterTest_WriteNdefData_001
- * @tc.desc: return NFC_NO_HDI_PROXY
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefData_001, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData_001 start";
-    IConnectedNfcTag::noProxy_ = true;
-    NfcTagHdiAdapter adapter;
-    std::vector<uint8_t> tag = {3, 1, 0};
-    ErrCode ret = adapter.WriteNdefData(tag);
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData_001 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_WriteNdefData_002
- * @tc.name: NfcTagHdiAdapterTest_WriteNdefData_002
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefData_002, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData_002 start";
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    std::vector<uint8_t> tag = {3, 1, 0};
-    ErrCode ret = adapter.WriteNdefData(tag);
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData_002 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_WriteNdefData_003
- * @tc.name: NfcTagHdiAdapterTest_WriteNdefData_003
- * @tc.desc: return NFC_SUCCESS
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_WriteNdefData_003, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    std::vector<uint8_t> tag = {3, 1, 0};
-    ErrCode ret = adapter.WriteNdefData(tag);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_WriteNdefData_003 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_RegisterCallBack_001
- * @tc.name: NfcTagHdiAdapterTest_RegisterCallBack_001
- * @tc.desc: return NFC_NO_HDI_PROXY
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_RegisterCallBack_001, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack_001 start";
-    IConnectedNfcTag::noProxy_ = true;
-    NfcTagHdiAdapter adapter;
-    sptr<INfcTagCallbackTest> callbackTest = sptr<INfcTagCallbackTest>::MakeSptr();
-    ErrCode ret = adapter.RegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack_001 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_RegisterCallBack_002
- * @tc.name: NfcTagHdiAdapterTest_RegisterCallBack_002
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_RegisterCallBack_002, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack_002 start";
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    sptr<INfcTagCallbackTest> callbackTest = sptr<INfcTagCallbackTest>::MakeSptr();
-    ErrCode ret = adapter.RegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack_002 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_RegisterCallBack_003
- * @tc.name: NfcTagHdiAdapterTest_RegisterCallBack_003
- * @tc.desc: return NFC_SUCCESS
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_RegisterCallBack_003, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    sptr<INfcTagCallbackTest> callbackTest = sptr<INfcTagCallbackTest>::MakeSptr();
-    ErrCode ret = adapter.RegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_RegisterCallBack_003 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_UnRegisterCallBack_001
- * @tc.name: NfcTagHdiAdapterTest_UnRegisterCallBack_001
- * @tc.desc: return NFC_NO_HDI_PROXY
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_UnRegisterCallBack_001, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_001 start";
-    IConnectedNfcTag::noProxy_ = true;
-    NfcTagHdiAdapter adapter;
-    sptr<INfcTagCallbackTest> callbackTest = sptr<INfcTagCallbackTest>::MakeSptr();
-    ErrCode ret = adapter.UnRegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_NO_HDI_PROXY);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_001 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_UnRegisterCallBack_002
- * @tc.name: NfcTagHdiAdapterTest_UnRegisterCallBack_002
- * @tc.desc: return NFC_NO_CALLBACK
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_UnRegisterCallBack_002, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_002 start";
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    sptr<INfcTagCallbackTest> callbackTest = sptr<INfcTagCallbackTest>::MakeSptr();
-    ErrCode ret = adapter.UnRegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_NO_CALLBACK);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_002 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_UnRegisterCallBack_003
- * @tc.name: NfcTagHdiAdapterTest_UnRegisterCallBack_003
- * @tc.desc: return NFC_SUCCESS
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_UnRegisterCallBack_003, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_003 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    std::string tag = "test";
-    sptr<INfcTagCallbackTest> callbackTest = sptr<INfcTagCallbackTest>::MakeSptr();
-    ErrCode ret = adapter.RegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    ret = adapter.UnRegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_003 end";
-}
-
-/*
- * @tc.number: NfcTagHdiAdapterTest_UnRegisterCallBack_004
- * @tc.name: NfcTagHdiAdapterTest_UnRegisterCallBack_004
- * @tc.desc: return NFC_HDI_REMOTE_FAILED
-*/
-HWTEST_F(NfcTagHdiAdapterTest, NfcTagHdiAdapterTest_UnRegisterCallBack_004, TestSize.Level0)
-{
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_004 start";
-    IConnectedNfcTag::resultMock_ = 0;
-    IConnectedNfcTag::noProxy_ = false;
-    NfcTagHdiAdapter adapter;
-    sptr<INfcTagCallbackTest> callbackTest = sptr<INfcTagCallbackTest>::MakeSptr();
-    ErrCode ret = adapter.RegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_SUCCESS);
-    IConnectedNfcTag::resultMock_ = -1;
-    IConnectedNfcTag::noProxy_ = false;
-    ret = adapter.UnRegisterCallBack(callbackTest);
-    EXPECT_EQ(ret, NFC_HDI_REMOTE_FAILED);
-    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_UnRegisterCallBack_004 end";
+    EXPECT_EQ(adapter.InitDriver(), NFC_SUCCESS);
+    GTEST_LOG_(INFO) << "NfcTagHdiAdapterTest_InitDriver end";
 }
 
 } // namespace NFC

test/unittest/service_test/nfc_tag_hdi_adapter_test/nfc_tag_hdi_impl_mock.cpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "nfc_tag_hdi_impl.h"
+
+namespace OHOS {
+namespace NFC {
+
+static ErrCode g_errCodeMock = NFC_SUCCESS;
+
+void HdiImplReturnMock(ErrCode errCode)
+{
+    g_errCodeMock = errCode;
+}
+
+void NfcTagDriverStatusListener::OnReceive(const OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status)
+{}
+
+NfcTagHdiCallBack::~NfcTagHdiCallBack()
+{}
+
+ErrCode NfcTagHdiCallBack::RegisterUpperCallBack(sptr<INfcTagCallback> listener)
+{
+    return g_errCodeMock;
+}
+ErrCode NfcTagHdiCallBack::UnRegisterUpperCallBack(sptr<INfcTagCallback> listener)
+{
+    return g_errCodeMock;
+}
+int32_t NfcTagHdiCallBack::OnChipEvent(HDI::ConnectedNfcTag::V1_1::ConnectedNfcTagEvent event,
+    const std::vector<uint8_t>& message)
+{
+    return 0;
+}
+
+NfcTagHdiImpl& NfcTagHdiImpl::GetInstance()
+{
+    static NfcTagHdiImpl sNfcTagHdiImpl;
+    return sNfcTagHdiImpl;
+}
+
+NfcTagHdiImpl::NfcTagHdiImpl()
+{}
+
+NfcTagHdiImpl::~NfcTagHdiImpl()
+{}
+
+ErrCode NfcTagHdiImpl::Init()
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::Uninit()
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::ReadNdefTag(std::string &data)
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::WriteNdefTag(const std::string &data)
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::ReadNdefData(std::vector<uint8_t> &data)
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::WriteNdefData(const std::vector<uint8_t> &data)
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::RegisterCallBack(sptr<INfcTagCallback> listener)
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::UnRegisterCallBack(sptr<INfcTagCallback> listener)
+{
+    return g_errCodeMock;
+}
+
+ErrCode NfcTagHdiImpl::InitDriver()
+{
+    return g_errCodeMock;
+}
+
+void NfcTagHdiImpl::OnNfcTagDriverStart()
+{}
+
+void NfcTagHdiImpl::OnNfcTagDriverStop()
+{}
+
+sptr<OHOS::HDI::ConnectedNfcTag::V1_1::IConnectedNfcTag> NfcTagHdiImpl::GetProxy()
+{
+    return nfcTagProxy_;
+}
+
+}  // namespace NFC
+}  // namespace OHOS

test/unittest/service_test/nfc_tag_service_test/BUILD.gn

@@ -18,23 +18,15 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_service_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_service_test.cpp",
     "$NFC_TAG_DIR/services/src/nfc_tag_service.cpp",
   ]
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
-  sanitize = {
-    cfi = true
-    boundary_sanitize = true
-    integer_overflow = true
-    cfi_cross_dso = true
-    debug = false
-    ubsan = true
-    cfi_vcall_icall_only = true
-  }
+
   include_dirs = [
     "$NFC_TAG_DIR/services/include",
     "$NFC_TAG_DIR/services/src/hdi/include",

test/unittest/service_test/nfc_tag_service_test/nfc_tag_service_test.cpp

@@ -15,10 +15,8 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#define private public
 #include "nfc_tag_service.h"
 #include "nfc_tag_utils.h"
-#undef private
 #include "nfc_tag_hdi_adapter.h"
 #include "accesstoken_kit.h"
 #include "ipc_skeleton.h"
@@ -60,23 +58,6 @@ void SetUp() override
 void TearDown() override {}
 };
 
-class NfcTagHdiAdapter::Impl : public OHOS::RefBase {
-};
-
-NfcTagHdiAdapter::NfcTagHdiAdapter()
-{
-}
-
-NfcTagHdiAdapter::~NfcTagHdiAdapter()
-{
-}
-
-NfcTagHdiAdapter &NfcTagHdiAdapter::GetInstance()
-{
-    static NfcTagHdiAdapter sNfcTagHdiAdapter;
-    return sNfcTagHdiAdapter;
-}
-
 ErrCode NfcTagHdiAdapter::Init()
 {
     return g_hdiCodeMock;
@@ -117,6 +98,11 @@ ErrCode NfcTagHdiAdapter::UnRegisterCallBack(sptr<INfcTagCallback> listener)
     return g_hdiCodeMock;
 }
 
+ErrCode NfcTagHdiAdapter::InitDriver()
+{
+    return g_hdiCodeMock;
+}
+
 NfcTagStub::NfcTagStub()
 {}
 

test/unittest/service_test/nfc_tag_stub_test/BUILD.gn

@@ -18,15 +18,15 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_stub_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_stub_test.cpp",
     "$NFC_TAG_DIR/test/unittest/source_mock/nfc_tag_callback_stub_mock.cpp",
     "$NFC_TAG_DIR/services/src/nfc_tag_stub.cpp",
   ]
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
 
   include_dirs = [
     "$NFC_TAG_DIR/services/include",

test/unittest/service_test/nfc_tag_stub_test/nfc_tag_stub_test.cpp

@@ -14,9 +14,7 @@
  */
 
 #include "gtest/gtest.h"
-#define private public
 #include "nfc_tag_stub.h"
-#undef private
 #include "nfc_tag_callback_stub.h"
 #include "iremote_broker.h"
 

test/unittest/service_test/nfc_tag_sys_perm_test/BUILD.gn

@@ -18,14 +18,14 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_sys_perm_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_sys_perm_test.cpp",
     "$NFC_TAG_DIR/services/src/nfc_tag_sys_perm.cpp",
   ]
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
 
   include_dirs = [
     "$NFC_TAG_DIR/services/include",

test/unittest/service_test/nfc_tag_utils_test/BUILD.gn

@@ -18,14 +18,14 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 ohos_unittest("nfc_tag_utils_unittest") {
   module_out_path = "connected_nfc_tag/nfc_tag_service/"
-  defines = [ "NFC_TAG_HILOG" ]
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_utils_test.cpp",
     "$NFC_TAG_DIR/services/src/nfc_tag_utils.cpp",
   ]
-  cflags_cc = [ "--coverage" ]
-  cflags = [ "--coverage" ]
-  ldflags = [ "--coverage" ]
 
   include_dirs = [
     "$NFC_TAG_DIR/services/include",

test/utils/BUILD.gn

@@ -18,6 +18,10 @@ import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
 
 # Only used for test
 ohos_static_library("test_utils_static") {
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
   sources = [
     "nfc_tag_access_token_mock.cpp",
   ]

utils/sa_listener/BUILD.gn

@@ -0,0 +1,68 @@
+# Copyright (C) 2025 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos.gni")
+import("//foundation/communication/connected_nfc_tag/connected_nfc_tag.gni")
+
+ohos_static_library("nfc_tag_sa_listener") {
+  cflags = common_cflags
+  cflags_cc = common_cflags
+  sanitize = global_sanitize
+  defines = global_defines
+  branch_protector_ret = "pac_ret"
+
+  include_dirs = [
+    "include",
+    "$NFC_TAG_DIR/interfaces/inner_api/include",
+    "//third_party/bounds_checking_function/include",
+  ]
+
+  sources = [ "system_ability_listener.cpp" ]
+
+  deps = []
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "samgr:samgr_proxy",
+  ]
+
+  subsystem_name = "communication"
+  part_name = "connected_nfc_tag"
+}
+
+ohos_static_library("nfc_tag_sa_listener_test") {
+  defines = unittest_defines
+  cflags_cc = [ "--coverage" ]
+  cflags = [ "--coverage" ]
+  ldflags = [ "--coverage" ]
+
+  include_dirs = [
+    "include",
+    "$NFC_TAG_DIR/interfaces/inner_api/include",
+    "//third_party/bounds_checking_function/include",
+  ]
+
+  sources = [ "system_ability_listener.cpp" ]
+
+  deps = []
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "samgr:samgr_proxy",
+  ]
+
+  subsystem_name = "communication"
+  part_name = "connected_nfc_tag"
+}

utils/sa_listener/system_ability_listener.cpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "NFCTAG_SA"
+#include "system_ability_listener.h"
+#include "nfc_tag_log.h"
+#include "nfc_tag_errcode.h"
+#include "iservice_registry.h"
+#include "if_system_ability_manager.h"
+
+namespace OHOS {
+namespace NFC {
+SystemAbilityListener::SystemAbilityListener(const std::string &name, int32_t systemAbilityId,
+    ListenerFunc addFunc, ListenerFunc removeFunc)
+    : name_(name),
+      systemAbilityId_(systemAbilityId),
+      addFunc_(addFunc),
+      removeFunc_(removeFunc)
+{
+    HILOGI("enter.");
+}
+
+void SystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
+{
+    HILOGI("enter");
+    if (systemAbilityId != systemAbilityId_) {
+        HILOGI("systemAbilityId is not same.");
+        return;
+    }
+
+    if (addFunc_ != nullptr) {
+        HILOGI("addFunc_ called");
+        addFunc_();
+    }
+}
+
+void SystemAbilityListener::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
+{
+    HILOGI("enter");
+    if (systemAbilityId != systemAbilityId_) {
+        HILOGI("systemAbilityId is not same.");
+        return;
+    }
+
+    if (removeFunc_ != nullptr) {
+        HILOGI("removeFunc_ called");
+        removeFunc_();
+    }
+}
+
+sptr<SystemAbilityListener> SystemAbilityListener::Subscribe(const std::string &name, int32_t systemAbilityId,
+    ListenerFunc addFunc, ListenerFunc removeFunc)
+{
+    HILOGI("name:%{public}s, systemAbilityId:%{public}d", name.c_str(), systemAbilityId);
+    auto sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (sam == nullptr) {
+        return nullptr;
+    }
+    auto listener = sptr<SystemAbilityListener>::MakeSptr(name, systemAbilityId, addFunc, removeFunc);
+    int32_t ret = sam->SubscribeSystemAbility(systemAbilityId, listener);
+    if (ret != ERR_OK) {
+        HILOGE("SubscribeSystemAbility fail, name:%{public}s, "
+            "systemAbilityId:%{public}d",
+            name.c_str(), systemAbilityId);
+        return nullptr;
+    }
+
+    HILOGI("Subscribe service name:%{public}s success", name.c_str());
+    return listener;
+}
+
+void SystemAbilityListener::UnSubscribe(int32_t systemAbilityId, sptr<SystemAbilityListener> &listener)
+{
+    HILOGI("start systemAbilityId:%{public}d", systemAbilityId);
+    auto sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (sam == nullptr) {
+        return;
+    }
+
+    int32_t ret = sam->UnSubscribeSystemAbility(systemAbilityId, listener);
+    if (ret != ERR_OK) {
+        HILOGE("UnSubscribeSystemAbility fail.");
+        return;
+    }
+
+    HILOGI("UnSubscribe service success");
+}
+}  // namespace NFC
+}  // namespace OHOS

utils/sa_listener/system_ability_listener.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SYSTEM_ABILITY_LISTENER_H
+#define SYSTEM_ABILITY_LISTENER_H
+
+#include "system_ability_status_change_stub.h"
+
+namespace OHOS {
+namespace NFC {
+class SystemAbilityListener : public OHOS::SystemAbilityStatusChangeStub, public NoCopyable {
+public:
+    using ListenerFunc = std::function<void(void)>;
+    SystemAbilityListener(const std::string &name, int32_t systemAbilityId,
+        ListenerFunc addFunc, ListenerFunc removeFunc);
+    ~SystemAbilityListener() override {};
+
+    void OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
+    void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) override;
+    static sptr<SystemAbilityListener> Subscribe(const std::string &name, int32_t systemAbilityId,
+        ListenerFunc addFunc, ListenerFunc removeFunc);
+    static void UnSubscribe(int32_t systemAbilityId, sptr<SystemAbilityListener> &listener);
+
+private:
+    std::string name_;
+    int32_t systemAbilityId_ = -1;
+    ListenerFunc addFunc_;
+    ListenerFunc removeFunc_;
+};
+}  // namespace NFC
+}  // namespace OHOS
+#endif