nfc/aidl/vts/functional/VtsAidlHalNfcTargetTest.cpp - LeafOS-Project/android_hardware_interfaces - Gitiles

 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
  * 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 "nfc_aidl_hal_test"

 #include <aidl/Gtest.h>
 #include <aidl/Vintf.h>
 #include <aidl/android/hardware/nfc/BnNfc.h>
 #include <aidl/android/hardware/nfc/BnNfcClientCallback.h>
 #include <aidl/android/hardware/nfc/INfc.h>
 #include <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <android/binder_auto_utils.h>
 #include <android/binder_enums.h>
 #include <android/binder_interface_utils.h>
 #include <android/binder_manager.h>
 #include <android/binder_process.h>

 #include <chrono>
 #include <future>

 using aidl::android::hardware::nfc::INfc;
 using aidl::android::hardware::nfc::INfcClientCallback;
 using aidl::android::hardware::nfc::NfcCloseType;
 using aidl::android::hardware::nfc::NfcConfig;
 using aidl::android::hardware::nfc::NfcEvent;
 using aidl::android::hardware::nfc::NfcStatus;
 using aidl::android::hardware::nfc::PresenceCheckAlgorithm;

 using android::getAidlHalInstanceNames;
 using android::PrintInstanceNameToString;
 using android::base::StringPrintf;
 using ndk::enum_range;
 using ndk::ScopedAStatus;
 using ndk::SharedRefBase;
 using ndk::SpAIBinder;

 constexpr static int kCallbackTimeoutMs = 10000;

 // 261 bytes is the default and minimum transceive length
 constexpr unsigned int MIN_ISO_DEP_TRANSCEIVE_LENGTH = 261;

 // Range of valid off host route ids
 constexpr uint8_t MIN_OFFHOST_ROUTE_ID = 0x01;
 constexpr uint8_t MAX_OFFHOST_ROUTE_ID = 0xFE;

 class NfcClientCallback : public aidl::android::hardware::nfc::BnNfcClientCallback {
   public:
     NfcClientCallback(const std::function<void(NfcEvent, NfcStatus)>& on_hal_event_cb,
                       const std::function<void(const std::vector<uint8_t>&)>& on_nci_data_cb)
         : on_nci_data_cb_(on_nci_data_cb), on_hal_event_cb_(on_hal_event_cb) {}
     virtual ~NfcClientCallback() = default;

     ::ndk::ScopedAStatus sendEvent(NfcEvent event, NfcStatus event_status) override {
         on_hal_event_cb_(event, event_status);
         return ::ndk::ScopedAStatus::ok();
     };
     ::ndk::ScopedAStatus sendData(const std::vector<uint8_t>& data) override {
         on_nci_data_cb_(data);
         return ::ndk::ScopedAStatus::ok();
     };

   private:
     std::function<void(const std::vector<uint8_t>&)> on_nci_data_cb_;
     std::function<void(NfcEvent, NfcStatus)> on_hal_event_cb_;
 };

 class NfcAidl : public testing::TestWithParam<std::string> {
   public:
     void SetUp() override {
         SpAIBinder binder(AServiceManager_waitForService(GetParam().c_str()));
         infc_ = INfc::fromBinder(binder);
         ASSERT_NE(infc_, nullptr);
     }
     std::shared_ptr<INfc> infc_;
 };

 /*
  * OpenAndCloseForDisable:
  * Makes an open call, waits for NfcEvent::OPEN_CPLT
  * Immediately calls close(NfcCloseType::DISABLE) and
  * waits for NfcEvent::CLOSE_CPLT
  *
  */
 TEST_P(NfcAidl, OpenAndCloseForDisable) {
     std::promise<void> open_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 LOG(INFO) << StringPrintf("%s,%d ", __func__, event);
                 if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);
     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close DISABLE";
     EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
     LOG(INFO) << "wait for close";
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
 }

 /*
  * OpenAndCloseForHostSwitchedOff:
  * Makes an open call, waits for NfcEvent::OPEN_CPLT
  * Immediately calls close(NfcCloseType::HOST_SWITCHED_OFF) and
  * waits for NfcEvent::CLOSE_CPLT
  *
  */
 TEST_P(NfcAidl, OpenAndCloseForHostSwitchedOff) {
     std::promise<void> open_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close HOST_SWITCHED_OFF";
     EXPECT_TRUE(infc_->close(NfcCloseType::HOST_SWITCHED_OFF).isOk());
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
 }

 /*
  * OpenAfterOpen:
  * Calls open() multiple times
  * Checks status
  */
 TEST_P(NfcAidl, OpenAfterOpen) {
     int open_count = 0;
     std::promise<void> open_cb_promise;
     std::promise<void> open2_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto open2_cb_future = open2_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &open2_cb_promise, &open_count](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) {
                     open_count == 0 ? open_cb_promise.set_value() : open2_cb_promise.set_value();
                     open_count++;
                 }
             },
             [](auto) {});

     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // Open again and wait for OPEN_CPLT
     LOG(INFO) << "open again";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open2_cb_future.wait_for(timeout), std::future_status::ready);
 }

 /*
  * CloseAfterClose:
  * Calls close() multiple times
  * Checks status
  */
 TEST_P(NfcAidl, CloseAfterClose) {
     std::promise<void> open_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close";
     EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
     // Close again should fail.
     LOG(INFO) << "close again";
     EXPECT_TRUE(!(infc_->close(NfcCloseType::DISABLE).isOk()));
 }

 /*
  * PowerCycleAfterOpen:
  * Calls powerCycle() after open
  * Waits for NfcEvent.OPEN_CPLT
  * Checks status
  */
 TEST_P(NfcAidl, PowerCycleAfterOpen) {
     int open_cplt_count = 0;
     std::promise<void> open_cb_promise;
     std::promise<void> power_cycle_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto power_cycle_cb_future = power_cycle_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise, &power_cycle_cb_promise, &open_cplt_count](
                     auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) {
                     if (open_cplt_count == 0) {
                         open_cplt_count++;
                         open_cb_promise.set_value();
                     } else {
                         power_cycle_cb_promise.set_value();
                     }
                 }
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // PowerCycle and wait for OPEN_CPLT
     LOG(INFO) << "PowerCycle";
     EXPECT_TRUE(infc_->powerCycle().isOk());
     EXPECT_EQ(power_cycle_cb_future.wait_for(timeout), std::future_status::ready);

     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close";
     EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
 }

 /*
  * PowerCycleAfterClose:
  * Calls powerCycle() after close
  * PowerCycle should fail immediately
  */
 TEST_P(NfcAidl, PowerCycleAfterClose) {
     std::promise<void> open_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close";
     EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);

     // PowerCycle should fail
     LOG(INFO) << "PowerCycle";
     EXPECT_TRUE(!(infc_->powerCycle().isOk()));
 }

 /*
  * CoreInitializedAfterOpen:
  * Calls coreInitialized() after open
  * Waits for NfcEvent.POST_INIT_CPLT
  */
 TEST_P(NfcAidl, CoreInitializedAfterOpen) {
     std::promise<void> open_cb_promise;
     std::promise<void> core_init_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto core_init_cb_future = core_init_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise, &core_init_cb_promise](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
                 if (event == NfcEvent::POST_INIT_CPLT) core_init_cb_promise.set_value();
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // CoreInitialized and wait for POST_INIT_CPLT
     LOG(INFO) << "coreInitialized";
     EXPECT_TRUE(infc_->coreInitialized().isOk());
     EXPECT_EQ(core_init_cb_future.wait_for(timeout), std::future_status::ready);

     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close";
     EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
 }

 /*
  * CoreInitializedAfterClose:
  * Calls coreInitialized() after close
  * coreInitialized() should fail immediately
  */
 TEST_P(NfcAidl, CoreInitializedAfterClose) {
     std::promise<void> open_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close";
     EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);

     // coreInitialized should fail
     LOG(INFO) << "CoreInitialized";
     EXPECT_TRUE(!(infc_->coreInitialized().isOk()));
 }

 /*
  * PreDiscoverAfterClose:
  * Call preDiscover() after close
  * preDiscover() should fail immediately
  */
 TEST_P(NfcAidl, PreDiscoverAfterClose) {
     std::promise<void> open_cb_promise;
     std::promise<void> close_cb_promise;
     auto open_cb_future = open_cb_promise.get_future();
     auto close_cb_future = close_cb_promise.get_future();
     std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
             [&open_cb_promise, &close_cb_promise](auto event, auto status) {
                 EXPECT_EQ(status, NfcStatus::OK);
                 if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
                 if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
             },
             [](auto) {});
     std::chrono::milliseconds timeout{kCallbackTimeoutMs};
     // Open and wait for OPEN_CPLT
     LOG(INFO) << "open";
     EXPECT_TRUE(infc_->open(mCallback).isOk());
     EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

     // Close and wait for CLOSE_CPLT
     LOG(INFO) << "close";
     EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
     EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);

     // preDiscover should fail
     LOG(INFO) << "preDiscover";
     EXPECT_TRUE(!(infc_->preDiscover().isOk()));
 }

 /*
  * checkGetConfigValues:
  * Calls getConfig()
  * checks if fields in NfcConfig are populated correctly
  */
 TEST_P(NfcAidl, CheckGetConfigValues) {
     NfcConfig configValue;
     EXPECT_TRUE(infc_->getConfig(&configValue).isOk());
     EXPECT_GE(configValue.maxIsoDepTransceiveLength, MIN_ISO_DEP_TRANSCEIVE_LENGTH);
     LOG(INFO) << StringPrintf("configValue.maxIsoDepTransceiveLength = %x",
                               configValue.maxIsoDepTransceiveLength);
     for (auto uicc : configValue.offHostRouteUicc) {
         LOG(INFO) << StringPrintf("offHostRouteUicc = %x", uicc);
         EXPECT_GE(uicc, MIN_OFFHOST_ROUTE_ID);
         EXPECT_LE(uicc, MAX_OFFHOST_ROUTE_ID);
     }
     for (auto ese : configValue.offHostRouteEse) {
         LOG(INFO) << StringPrintf("offHostRouteEse = %x", ese);
         EXPECT_GE(ese, MIN_OFFHOST_ROUTE_ID);
         EXPECT_LE(ese, MAX_OFFHOST_ROUTE_ID);
     }
     if (configValue.defaultIsoDepRoute != 0) {
         EXPECT_GE((uint8_t)configValue.defaultIsoDepRoute, MIN_OFFHOST_ROUTE_ID);
         EXPECT_LE((uint8_t)configValue.defaultIsoDepRoute, MAX_OFFHOST_ROUTE_ID);
     }
 }

 /*
  * CheckisVerboseLoggingEnabledAfterSetEnableVerboseLogging:
  * Calls setEnableVerboseLogging()
  * checks the return value of isVerboseLoggingEnabled
  */
 TEST_P(NfcAidl, CheckisVerboseLoggingEnabledAfterSetEnableVerboseLogging) {
     bool enabled = false;
     EXPECT_TRUE(infc_->setEnableVerboseLogging(true).isOk());
     EXPECT_TRUE(infc_->isVerboseLoggingEnabled(&enabled).isOk());
     EXPECT_TRUE(enabled);
     EXPECT_TRUE(infc_->setEnableVerboseLogging(false).isOk());
     EXPECT_TRUE(infc_->isVerboseLoggingEnabled(&enabled).isOk());
     EXPECT_TRUE(!enabled);
 }

 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NfcAidl);
 INSTANTIATE_TEST_SUITE_P(Nfc, NfcAidl,
                          testing::ValuesIn(::android::getAidlHalInstanceNames(INfc::descriptor)),
                          ::android::PrintInstanceNameToString);

 int main(int argc, char** argv) {
     ::testing::InitGoogleTest(&argc, argv);
     ABinderProcess_startThreadPool();
     std::system("/system/bin/svc nfc disable"); /* Turn off NFC */
     sleep(5);
     int status = RUN_ALL_TESTS();
     LOG(INFO) << "Test result = " << status;
     std::system("/system/bin/svc nfc enable"); /* Turn on NFC */
     sleep(5);
     return status;
 }
	/*
	* Copyright (C) 2021 The Android Open Source Project
	*
	* 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 "nfc_aidl_hal_test"

	#include <aidl/Gtest.h>
	#include <aidl/Vintf.h>
	#include <aidl/android/hardware/nfc/BnNfc.h>
	#include <aidl/android/hardware/nfc/BnNfcClientCallback.h>
	#include <aidl/android/hardware/nfc/INfc.h>
	#include <android-base/logging.h>
	#include <android-base/stringprintf.h>
	#include <android/binder_auto_utils.h>
	#include <android/binder_enums.h>
	#include <android/binder_interface_utils.h>
	#include <android/binder_manager.h>
	#include <android/binder_process.h>

	#include <chrono>
	#include <future>

	using aidl::android::hardware::nfc::INfc;
	using aidl::android::hardware::nfc::INfcClientCallback;
	using aidl::android::hardware::nfc::NfcCloseType;
	using aidl::android::hardware::nfc::NfcConfig;
	using aidl::android::hardware::nfc::NfcEvent;
	using aidl::android::hardware::nfc::NfcStatus;
	using aidl::android::hardware::nfc::PresenceCheckAlgorithm;

	using android::getAidlHalInstanceNames;
	using android::PrintInstanceNameToString;
	using android::base::StringPrintf;
	using ndk::enum_range;
	using ndk::ScopedAStatus;
	using ndk::SharedRefBase;
	using ndk::SpAIBinder;

	constexpr static int kCallbackTimeoutMs = 10000;

	// 261 bytes is the default and minimum transceive length
	constexpr unsigned int MIN_ISO_DEP_TRANSCEIVE_LENGTH = 261;

	// Range of valid off host route ids
	constexpr uint8_t MIN_OFFHOST_ROUTE_ID = 0x01;
	constexpr uint8_t MAX_OFFHOST_ROUTE_ID = 0xFE;

	class NfcClientCallback : public aidl::android::hardware::nfc::BnNfcClientCallback {
	public:
	NfcClientCallback(const std::function<void(NfcEvent, NfcStatus)>& on_hal_event_cb,
	const std::function<void(const std::vector<uint8_t>&)>& on_nci_data_cb)
	: on_nci_data_cb_(on_nci_data_cb), on_hal_event_cb_(on_hal_event_cb) {}
	virtual ~NfcClientCallback() = default;

	::ndk::ScopedAStatus sendEvent(NfcEvent event, NfcStatus event_status) override {
	on_hal_event_cb_(event, event_status);
	return ::ndk::ScopedAStatus::ok();
	};
	::ndk::ScopedAStatus sendData(const std::vector<uint8_t>& data) override {
	on_nci_data_cb_(data);
	return ::ndk::ScopedAStatus::ok();
	};

	private:
	std::function<void(const std::vector<uint8_t>&)> on_nci_data_cb_;
	std::function<void(NfcEvent, NfcStatus)> on_hal_event_cb_;
	};

	class NfcAidl : public testing::TestWithParam<std::string> {
	public:
	void SetUp() override {
	SpAIBinder binder(AServiceManager_waitForService(GetParam().c_str()));
	infc_ = INfc::fromBinder(binder);
	ASSERT_NE(infc_, nullptr);
	}
	std::shared_ptr<INfc> infc_;
	};

	/*
	* OpenAndCloseForDisable:
	* Makes an open call, waits for NfcEvent::OPEN_CPLT
	* Immediately calls close(NfcCloseType::DISABLE) and
	* waits for NfcEvent::CLOSE_CPLT
	*
	*/
	TEST_P(NfcAidl, OpenAndCloseForDisable) {
	std::promise<void> open_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	LOG(INFO) << StringPrintf("%s,%d ", __func__, event);
	if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);
	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close DISABLE";
	EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
	LOG(INFO) << "wait for close";
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
	}

	/*
	* OpenAndCloseForHostSwitchedOff:
	* Makes an open call, waits for NfcEvent::OPEN_CPLT
	* Immediately calls close(NfcCloseType::HOST_SWITCHED_OFF) and
	* waits for NfcEvent::CLOSE_CPLT
	*
	*/
	TEST_P(NfcAidl, OpenAndCloseForHostSwitchedOff) {
	std::promise<void> open_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close HOST_SWITCHED_OFF";
	EXPECT_TRUE(infc_->close(NfcCloseType::HOST_SWITCHED_OFF).isOk());
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
	}

	/*
	* OpenAfterOpen:
	* Calls open() multiple times
	* Checks status
	*/
	TEST_P(NfcAidl, OpenAfterOpen) {
	int open_count = 0;
	std::promise<void> open_cb_promise;
	std::promise<void> open2_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto open2_cb_future = open2_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &open2_cb_promise, &open_count](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) {
	open_count == 0 ? open_cb_promise.set_value() : open2_cb_promise.set_value();
	open_count++;
	}
	},
	[](auto) {});

	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// Open again and wait for OPEN_CPLT
	LOG(INFO) << "open again";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open2_cb_future.wait_for(timeout), std::future_status::ready);
	}

	/*
	* CloseAfterClose:
	* Calls close() multiple times
	* Checks status
	*/
	TEST_P(NfcAidl, CloseAfterClose) {
	std::promise<void> open_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close";
	EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
	// Close again should fail.
	LOG(INFO) << "close again";
	EXPECT_TRUE(!(infc_->close(NfcCloseType::DISABLE).isOk()));
	}

	/*
	* PowerCycleAfterOpen:
	* Calls powerCycle() after open
	* Waits for NfcEvent.OPEN_CPLT
	* Checks status
	*/
	TEST_P(NfcAidl, PowerCycleAfterOpen) {
	int open_cplt_count = 0;
	std::promise<void> open_cb_promise;
	std::promise<void> power_cycle_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto power_cycle_cb_future = power_cycle_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise, &power_cycle_cb_promise, &open_cplt_count](
	auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) {
	if (open_cplt_count == 0) {
	open_cplt_count++;
	open_cb_promise.set_value();
	} else {
	power_cycle_cb_promise.set_value();
	}
	}
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// PowerCycle and wait for OPEN_CPLT
	LOG(INFO) << "PowerCycle";
	EXPECT_TRUE(infc_->powerCycle().isOk());
	EXPECT_EQ(power_cycle_cb_future.wait_for(timeout), std::future_status::ready);

	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close";
	EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
	}

	/*
	* PowerCycleAfterClose:
	* Calls powerCycle() after close
	* PowerCycle should fail immediately
	*/
	TEST_P(NfcAidl, PowerCycleAfterClose) {
	std::promise<void> open_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close";
	EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);

	// PowerCycle should fail
	LOG(INFO) << "PowerCycle";
	EXPECT_TRUE(!(infc_->powerCycle().isOk()));
	}

	/*
	* CoreInitializedAfterOpen:
	* Calls coreInitialized() after open
	* Waits for NfcEvent.POST_INIT_CPLT
	*/
	TEST_P(NfcAidl, CoreInitializedAfterOpen) {
	std::promise<void> open_cb_promise;
	std::promise<void> core_init_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto core_init_cb_future = core_init_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise, &core_init_cb_promise](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
	if (event == NfcEvent::POST_INIT_CPLT) core_init_cb_promise.set_value();
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// CoreInitialized and wait for POST_INIT_CPLT
	LOG(INFO) << "coreInitialized";
	EXPECT_TRUE(infc_->coreInitialized().isOk());
	EXPECT_EQ(core_init_cb_future.wait_for(timeout), std::future_status::ready);

	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close";
	EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);
	}

	/*
	* CoreInitializedAfterClose:
	* Calls coreInitialized() after close
	* coreInitialized() should fail immediately
	*/
	TEST_P(NfcAidl, CoreInitializedAfterClose) {
	std::promise<void> open_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close";
	EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);

	// coreInitialized should fail
	LOG(INFO) << "CoreInitialized";
	EXPECT_TRUE(!(infc_->coreInitialized().isOk()));
	}

	/*
	* PreDiscoverAfterClose:
	* Call preDiscover() after close
	* preDiscover() should fail immediately
	*/
	TEST_P(NfcAidl, PreDiscoverAfterClose) {
	std::promise<void> open_cb_promise;
	std::promise<void> close_cb_promise;
	auto open_cb_future = open_cb_promise.get_future();
	auto close_cb_future = close_cb_promise.get_future();
	std::shared_ptr<INfcClientCallback> mCallback = ::ndk::SharedRefBase::make<NfcClientCallback>(
	[&open_cb_promise, &close_cb_promise](auto event, auto status) {
	EXPECT_EQ(status, NfcStatus::OK);
	if (event == NfcEvent::OPEN_CPLT) open_cb_promise.set_value();
	if (event == NfcEvent::CLOSE_CPLT) close_cb_promise.set_value();
	},
	[](auto) {});
	std::chrono::milliseconds timeout{kCallbackTimeoutMs};
	// Open and wait for OPEN_CPLT
	LOG(INFO) << "open";
	EXPECT_TRUE(infc_->open(mCallback).isOk());
	EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);

	// Close and wait for CLOSE_CPLT
	LOG(INFO) << "close";
	EXPECT_TRUE(infc_->close(NfcCloseType::DISABLE).isOk());
	EXPECT_EQ(close_cb_future.wait_for(timeout), std::future_status::ready);

	// preDiscover should fail
	LOG(INFO) << "preDiscover";
	EXPECT_TRUE(!(infc_->preDiscover().isOk()));
	}

	/*
	* checkGetConfigValues:
	* Calls getConfig()
	* checks if fields in NfcConfig are populated correctly
	*/
	TEST_P(NfcAidl, CheckGetConfigValues) {
	NfcConfig configValue;
	EXPECT_TRUE(infc_->getConfig(&configValue).isOk());
	EXPECT_GE(configValue.maxIsoDepTransceiveLength, MIN_ISO_DEP_TRANSCEIVE_LENGTH);
	LOG(INFO) << StringPrintf("configValue.maxIsoDepTransceiveLength = %x",
	configValue.maxIsoDepTransceiveLength);
	for (auto uicc : configValue.offHostRouteUicc) {
	LOG(INFO) << StringPrintf("offHostRouteUicc = %x", uicc);
	EXPECT_GE(uicc, MIN_OFFHOST_ROUTE_ID);
	EXPECT_LE(uicc, MAX_OFFHOST_ROUTE_ID);
	}
	for (auto ese : configValue.offHostRouteEse) {
	LOG(INFO) << StringPrintf("offHostRouteEse = %x", ese);
	EXPECT_GE(ese, MIN_OFFHOST_ROUTE_ID);
	EXPECT_LE(ese, MAX_OFFHOST_ROUTE_ID);
	}
	if (configValue.defaultIsoDepRoute != 0) {
	EXPECT_GE((uint8_t)configValue.defaultIsoDepRoute, MIN_OFFHOST_ROUTE_ID);
	EXPECT_LE((uint8_t)configValue.defaultIsoDepRoute, MAX_OFFHOST_ROUTE_ID);
	}
	}

	/*
	* CheckisVerboseLoggingEnabledAfterSetEnableVerboseLogging:
	* Calls setEnableVerboseLogging()
	* checks the return value of isVerboseLoggingEnabled
	*/
	TEST_P(NfcAidl, CheckisVerboseLoggingEnabledAfterSetEnableVerboseLogging) {
	bool enabled = false;
	EXPECT_TRUE(infc_->setEnableVerboseLogging(true).isOk());
	EXPECT_TRUE(infc_->isVerboseLoggingEnabled(&enabled).isOk());
	EXPECT_TRUE(enabled);
	EXPECT_TRUE(infc_->setEnableVerboseLogging(false).isOk());
	EXPECT_TRUE(infc_->isVerboseLoggingEnabled(&enabled).isOk());
	EXPECT_TRUE(!enabled);
	}

	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NfcAidl);
	INSTANTIATE_TEST_SUITE_P(Nfc, NfcAidl,
	testing::ValuesIn(::android::getAidlHalInstanceNames(INfc::descriptor)),
	::android::PrintInstanceNameToString);

	int main(int argc, char** argv) {
	::testing::InitGoogleTest(&argc, argv);
	ABinderProcess_startThreadPool();
	std::system("/system/bin/svc nfc disable"); /* Turn off NFC */
	sleep(5);
	int status = RUN_ALL_TESTS();
	LOG(INFO) << "Test result = " << status;
	std::system("/system/bin/svc nfc enable"); /* Turn on NFC */
	sleep(5);
	return status;
	}