Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 60cd14a5 authored by Henri Chataing's avatar Henri Chataing
Browse files

Remove the default implementation for NFC aidl HAL 

The HAL android.hardware.nfc-service.example
is not used anywhere; cuttlefish is using the implementation
in /device/google/cuttlefish/guest/hals/nfc instead
(android.hardware.nfc-service.cuttlefish)

Test: NA
Change-Id: I76dd12624e0e3eb4bb4c7ebf33c33a7781bf9836
parent 1d9bf983

nfc/aidl/default/Android.bp

deleted100644 → 0
+0 −33
Original line number Diff line number Diff line 
package {

    default_team: "trendy_team_fwk_nfc",

    // See: http://go/android-license-faq

    // A large-scale-change added 'default_applicable_licenses' to import

    // all of the 'license_kinds' from "hardware_interfaces_license"

    // to get the below license kinds:

    //   SPDX-license-identifier-Apache-2.0

    default_applicable_licenses: ["hardware_interfaces_license"],

}



cc_binary {

    name: "android.hardware.nfc-service.example",

    relative_install_path: "hw",

    init_rc: ["nfc-service-example.rc"],

    vintf_fragments: ["nfc-service-example.xml"],

    vendor: true,

    cflags: [

        "-Wall",

        "-Wextra",

    ],

    shared_libs: [

        "libbase",

        "liblog",

        "libutils",

        "libbinder_ndk",

        "android.hardware.nfc-V1-ndk",

    ],

    srcs: [

        "main.cpp",

        "Nfc.cpp",

        "Vendor_hal_api.cpp",

    ],

}

nfc/aidl/default/Nfc.cpp

deleted100644 → 0
+0 −160
Original line number Diff line number Diff line 
/*

 * 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.

 */



#include "Nfc.h"



#include <android-base/logging.h>



#include "Vendor_hal_api.h"



namespace aidl {

namespace android {

namespace hardware {

namespace nfc {



std::shared_ptr<INfcClientCallback> Nfc::mCallback = nullptr;

AIBinder_DeathRecipient* clientDeathRecipient = nullptr;



void OnDeath(void* cookie) {

    if (Nfc::mCallback != nullptr && !AIBinder_isAlive(Nfc::mCallback->asBinder().get())) {

        LOG(INFO) << __func__ << " Nfc service has died";

        Nfc* nfc = static_cast<Nfc*>(cookie);

        nfc->close(NfcCloseType::DISABLE);

    }

}



::ndk::ScopedAStatus Nfc::open(const std::shared_ptr<INfcClientCallback>& clientCallback) {

    LOG(INFO) << "open";

    if (clientCallback == nullptr) {

        LOG(INFO) << "Nfc::open null callback";

        return ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(NfcStatus::FAILED));

    }

    Nfc::mCallback = clientCallback;



    clientDeathRecipient = AIBinder_DeathRecipient_new(OnDeath);

    auto linkRet = AIBinder_linkToDeath(clientCallback->asBinder().get(), clientDeathRecipient,

                                        this /* cookie */);

    if (linkRet != STATUS_OK) {

        LOG(ERROR) << __func__ << ": linkToDeath failed: " << linkRet;

        // Just ignore the error.

    }



    int ret = Vendor_hal_open(eventCallback, dataCallback);

    return ret == 0 ? ndk::ScopedAStatus::ok()

                    : ndk::ScopedAStatus::fromServiceSpecificError(

                              static_cast<int32_t>(NfcStatus::FAILED));

}



::ndk::ScopedAStatus Nfc::close(NfcCloseType type) {

    LOG(INFO) << "close";

    if (Nfc::mCallback == nullptr) {

        LOG(ERROR) << __func__ << "mCallback null";

        return ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(NfcStatus::FAILED));

    }

    int ret = 0;

    if (type == NfcCloseType::HOST_SWITCHED_OFF) {

        ret = Vendor_hal_close_off();

    } else {

        ret = Vendor_hal_close();

    }

    Nfc::mCallback = nullptr;

    AIBinder_DeathRecipient_delete(clientDeathRecipient);

    clientDeathRecipient = nullptr;

    return ret == 0 ? ndk::ScopedAStatus::ok()

                    : ndk::ScopedAStatus::fromServiceSpecificError(

                              static_cast<int32_t>(NfcStatus::FAILED));

}



::ndk::ScopedAStatus Nfc::coreInitialized() {

    LOG(INFO) << "coreInitialized";

    if (Nfc::mCallback == nullptr) {

        LOG(ERROR) << __func__ << "mCallback null";

        return ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(NfcStatus::FAILED));

    }

    int ret = Vendor_hal_core_initialized();



    return ret == 0 ? ndk::ScopedAStatus::ok()

                    : ndk::ScopedAStatus::fromServiceSpecificError(

                              static_cast<int32_t>(NfcStatus::FAILED));

}



::ndk::ScopedAStatus Nfc::factoryReset() {

    LOG(INFO) << "factoryReset";

    Vendor_hal_factoryReset();

    return ndk::ScopedAStatus::ok();

}



::ndk::ScopedAStatus Nfc::getConfig(NfcConfig* _aidl_return) {

    LOG(INFO) << "getConfig";

    NfcConfig nfcVendorConfig;

    Vendor_hal_getConfig(nfcVendorConfig);



    *_aidl_return = nfcVendorConfig;

    return ndk::ScopedAStatus::ok();

}



::ndk::ScopedAStatus Nfc::powerCycle() {

    LOG(INFO) << "powerCycle";

    if (Nfc::mCallback == nullptr) {

        LOG(ERROR) << __func__ << "mCallback null";

        return ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(NfcStatus::FAILED));

    }

    return Vendor_hal_power_cycle() ? ndk::ScopedAStatus::fromServiceSpecificError(

                                              static_cast<int32_t>(NfcStatus::FAILED))

                                    : ndk::ScopedAStatus::ok();

}



::ndk::ScopedAStatus Nfc::preDiscover() {

    LOG(INFO) << "preDiscover";

    if (Nfc::mCallback == nullptr) {

        LOG(ERROR) << __func__ << "mCallback null";

        return ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(NfcStatus::FAILED));

    }

    return Vendor_hal_pre_discover() ? ndk::ScopedAStatus::fromServiceSpecificError(

                                               static_cast<int32_t>(NfcStatus::FAILED))

                                     : ndk::ScopedAStatus::ok();

}



::ndk::ScopedAStatus Nfc::write(const std::vector<uint8_t>& data, int32_t* _aidl_return) {

    LOG(INFO) << "write";

    if (Nfc::mCallback == nullptr) {

        LOG(ERROR) << __func__ << "mCallback null";

        return ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(NfcStatus::FAILED));

    }

    *_aidl_return = Vendor_hal_write(data.size(), &data[0]);

    return ndk::ScopedAStatus::ok();

}

::ndk::ScopedAStatus Nfc::setEnableVerboseLogging(bool enable) {

    LOG(INFO) << "setVerboseLogging";

    Vendor_hal_setVerboseLogging(enable);

    return ndk::ScopedAStatus::ok();

}



::ndk::ScopedAStatus Nfc::isVerboseLoggingEnabled(bool* _aidl_return) {

    *_aidl_return = Vendor_hal_getVerboseLogging();

    return ndk::ScopedAStatus::ok();

}



}  // namespace nfc

}  // namespace hardware

}  // namespace android

}  // namespace aidl

nfc/aidl/default/Nfc.h

deleted100644 → 0
+0 −72
Original line number Diff line number Diff line 
/*

 * 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.

 */



#pragma once



#include <aidl/android/hardware/nfc/BnNfc.h>

#include <aidl/android/hardware/nfc/INfcClientCallback.h>

#include <android-base/logging.h>

namespace aidl {

namespace android {

namespace hardware {

namespace nfc {



using ::aidl::android::hardware::nfc::NfcCloseType;

using ::aidl::android::hardware::nfc::NfcConfig;

using ::aidl::android::hardware::nfc::NfcStatus;



// Default implementation that reports no support NFC.

struct Nfc : public BnNfc {

  public:

    Nfc() = default;



    ::ndk::ScopedAStatus open(const std::shared_ptr<INfcClientCallback>& clientCallback) override;

    ::ndk::ScopedAStatus close(NfcCloseType type) override;

    ::ndk::ScopedAStatus coreInitialized() override;

    ::ndk::ScopedAStatus factoryReset() override;

    ::ndk::ScopedAStatus getConfig(NfcConfig* _aidl_return) override;

    ::ndk::ScopedAStatus powerCycle() override;

    ::ndk::ScopedAStatus preDiscover() override;

    ::ndk::ScopedAStatus write(const std::vector<uint8_t>& data, int32_t* _aidl_return) override;

    ::ndk::ScopedAStatus setEnableVerboseLogging(bool enable) override;

    ::ndk::ScopedAStatus isVerboseLoggingEnabled(bool* _aidl_return) override;



    static void eventCallback(uint8_t event, uint8_t status) {

        if (mCallback != nullptr) {

            auto ret = mCallback->sendEvent((NfcEvent)event, (NfcStatus)status);

            if (!ret.isOk()) {

                LOG(ERROR) << "Failed to send event!";

            }

        }

    }



    static void dataCallback(uint16_t data_len, uint8_t* p_data) {

        std::vector<uint8_t> data(p_data, p_data + data_len);

        if (mCallback != nullptr) {

            auto ret = mCallback->sendData(data);

            if (!ret.isOk()) {

                LOG(ERROR) << "Failed to send data!";

            }

        }

    }



    static std::shared_ptr<INfcClientCallback> mCallback;

};



}  // namespace nfc

}  // namespace hardware

}  // namespace android

}  // namespace aidl

nfc/aidl/default/Vendor_hal_api.cpp

deleted100644 → 0
+0 −71
Original line number Diff line number Diff line 
/*

 * 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.

 */



#include <android-base/properties.h>

#include <dlfcn.h>

#include <errno.h>

#include <string.h>



#include "Vendor_hal_api.h"



bool logging = false;



int Vendor_hal_open(nfc_stack_callback_t* p_cback, nfc_stack_data_callback_t* p_data_cback) {

    (void)p_cback;

    (void)p_data_cback;

    // nothing to open in this example

    return -1;

}



int Vendor_hal_write(uint16_t data_len, const uint8_t* p_data) {

    (void)data_len;

    (void)p_data;

    return -1;

}



int Vendor_hal_core_initialized() {

    return -1;

}



int Vendor_hal_pre_discover() {

    return -1;

}



int Vendor_hal_close() {

    return -1;

}



int Vendor_hal_close_off() {

    return -1;

}



int Vendor_hal_power_cycle() {

    return -1;

}



void Vendor_hal_factoryReset() {}



void Vendor_hal_getConfig(NfcConfig& config) {

    (void)config;

}



void Vendor_hal_setVerboseLogging(bool enable) {

    logging = enable;

}



bool Vendor_hal_getVerboseLogging() {

    return logging;

}

nfc/aidl/default/Vendor_hal_api.h

deleted100644 → 0
+0 −51
Original line number Diff line number Diff line 
/*

 * 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.

 */

#pragma once



#include <aidl/android/hardware/nfc/INfc.h>

#include <aidl/android/hardware/nfc/NfcConfig.h>

#include <aidl/android/hardware/nfc/NfcEvent.h>

#include <aidl/android/hardware/nfc/NfcStatus.h>

#include <aidl/android/hardware/nfc/PresenceCheckAlgorithm.h>

#include <aidl/android/hardware/nfc/ProtocolDiscoveryConfig.h>

#include "hardware_nfc.h"



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 aidl::android::hardware::nfc::ProtocolDiscoveryConfig;



int Vendor_hal_open(nfc_stack_callback_t* p_cback, nfc_stack_data_callback_t* p_data_cback);

int Vendor_hal_write(uint16_t data_len, const uint8_t* p_data);



int Vendor_hal_core_initialized();



int Vendor_hal_pre_discover();



int Vendor_hal_close();



int Vendor_hal_close_off();



int Vendor_hal_power_cycle();



void Vendor_hal_factoryReset();



void Vendor_hal_getConfig(NfcConfig& config);



void Vendor_hal_setVerboseLogging(bool enable);



bool Vendor_hal_getVerboseLogging();