tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Add new aidl interface for android.hardware.nfc" am: d4dcde3bc1 am: 0252bda2b0

Browse source 
Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/1878145

Change-Id: Ic9da15d1a266a6c34bdc47b5cc88ae746a546b20
This commit is contained in:
George Chang 2022-01-22 02:27:55 +00:00 committed by Automerger Merge Worker
commit ddebafd43c
30 changed files with 1842 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
compatibility_matrices/compatibility_matrix.current.xml
View file

@ -425,6 +425,13 @@
<instance>default</instance>
</interface>
</hal>
<hal format="aidl" optional="true">
<name>android.hardware.nfc</name>
<interface>
<name>INfc</name>
<instance>default</instance>
</interface>
</hal>
<hal format="hidl" optional="true">
<name>android.hardware.oemlock</name>
<version>1.0</version>

6
nfc/OWNERS Normal file
View file

@ -0,0 +1,6 @@
# Bug component: 48448
alisher@google.com
georgekgchang@google.com
jackcwyu@google.com

34
nfc/aidl/Android.bp Normal file
View file

@ -0,0 +1,34 @@
// 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.
aidl_interface {
name: "android.hardware.nfc",
vendor_available: true,
srcs: ["android/hardware/nfc/*.aidl"],
stability: "vintf",
backend: {
cpp: {
enabled: false,
},
java: {
sdk_version: "module_current",
enabled: false,
},
ndk: {
vndk: {
enabled: true,
},
},
},
}

47
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/INfc.aidl Normal file
View file

@ -0,0 +1,47 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@VintfStability
interface INfc {
void open(in android.hardware.nfc.INfcClientCallback clientCallback);
void close(in android.hardware.nfc.NfcCloseType type);
void coreInitialized();
void factoryReset();
android.hardware.nfc.NfcConfig getConfig();
void powerCycle();
void preDiscover();
int write(in byte[] data);
void setEnableVerboseLogging(in boolean enable);
boolean isVerboseLoggingEnabled();
}

39
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/INfcClientCallback.aidl Normal file
View file

@ -0,0 +1,39 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@VintfStability
interface INfcClientCallback {
void sendData(in byte[] data);
void sendEvent(in android.hardware.nfc.NfcEvent event, in android.hardware.nfc.NfcStatus status);
}

39
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/NfcCloseType.aidl Normal file
View file

@ -0,0 +1,39 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@Backing(type="int") @VintfStability
enum NfcCloseType {
DISABLE = 0,
HOST_SWITCHED_OFF = 1,
}

52
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/NfcConfig.aidl Normal file
View file

@ -0,0 +1,52 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@VintfStability
parcelable NfcConfig {
boolean nfaPollBailOutMode;
android.hardware.nfc.PresenceCheckAlgorithm presenceCheckAlgorithm;
android.hardware.nfc.ProtocolDiscoveryConfig nfaProprietaryCfg;
byte defaultOffHostRoute;
byte defaultOffHostRouteFelica;
byte defaultSystemCodeRoute;
byte defaultSystemCodePowerState;
byte defaultRoute;
byte offHostESEPipeId;
byte offHostSIMPipeId;
int maxIsoDepTransceiveLength;
byte[] hostAllowlist;
byte[] offHostRouteUicc;
byte[] offHostRouteEse;
byte defaultIsoDepRoute;
}

43
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/NfcEvent.aidl Normal file
View file

@ -0,0 +1,43 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@Backing(type="int") @VintfStability
enum NfcEvent {
OPEN_CPLT = 0,
CLOSE_CPLT = 1,
POST_INIT_CPLT = 2,
PRE_DISCOVER_CPLT = 3,
HCI_NETWORK_RESET = 4,
ERROR = 5,
}

42
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/NfcStatus.aidl Normal file
View file

@ -0,0 +1,42 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@Backing(type="int") @VintfStability
enum NfcStatus {
OK = 0,
FAILED = 1,
ERR_TRANSPORT = 2,
ERR_CMD_TIMEOUT = 3,
REFUSED = 4,
}

40
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/PresenceCheckAlgorithm.aidl Normal file
View file

@ -0,0 +1,40 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@Backing(type="byte") @VintfStability
enum PresenceCheckAlgorithm {
DEFAULT = 0,
I_BLOCK = 1,
ISO_DEP_NAK = 2,
}

46
nfc/aidl/aidl_api/android.hardware.nfc/current/android/hardware/nfc/ProtocolDiscoveryConfig.aidl Normal file
View file

@ -0,0 +1,46 @@
/*
* 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.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.nfc;
@VintfStability
parcelable ProtocolDiscoveryConfig {
byte protocol18092Active;
byte protocolBPrime;
byte protocolDual;
byte protocol15693;
byte protocolKovio;
byte protocolMifare;
byte discoveryPollKovio;
byte discoveryPollBPrime;
byte discoveryListenBPrime;
}

143
nfc/aidl/android/hardware/nfc/INfc.aidl Normal file
View file

@ -0,0 +1,143 @@
/*
* 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.
*/
package android.hardware.nfc;
import android.hardware.nfc.INfcClientCallback;
import android.hardware.nfc.NfcCloseType;
import android.hardware.nfc.NfcConfig;
import android.hardware.nfc.NfcStatus;
@VintfStability
interface INfc {
/**
* Opens the NFC controller device and performs initialization.
* This may include patch download and other vendor-specific initialization.
*
* If open completes successfully, the controller must be ready to perform NCI
* initialization - ie accept CORE_RESET and subsequent commands through the write()
* call.
*
* Returns ok() if initialization starts successfully.
* If open() returns ok(), the NCI stack must wait for a NfcEvent.OPEN_CPLT
* callback before continuing.
* If a NfcEvent.OPEN_CPLT callback received with status NfcStatus::OK, the controller
* must be ready to perform NCI initialization - ie accept CORE_RESET and subsequent
* commands through the write() call.
*/
void open(in INfcClientCallback clientCallback);
/**
* Close the NFC HAL and setup NFC controller close type.
* Associated resources such as clientCallback must be released.
* The clientCallback reference from open() must be invalid after close().
* If close() returns ok(), the NCI stack must wait for a NfcEvent.CLOSE_CPLT
* callback before continuing.
* Returns an error if close may be called more than once.
* Calls to any other method which expect a callback after this must return
* a service-specific error NfcStatus::FAILED.
* HAL close automatically if the client drops the reference to the HAL or
* crashes.
*/
void close(in NfcCloseType type);
/**
* coreInitialized() is called after the CORE_INIT_RSP is received from the
* NFCC. At this time, the HAL can do any chip-specific configuration.
*
* If coreInitialized() returns ok(), the NCI stack must wait for a
* NfcEvent.POST_INIT_CPLT before continuing.
* If coreInitialized() returns an error, the NCI stack must continue immediately.
*
* coreInitialized() must be called after open() registers the clientCallback
* or return a service-specific error NfcStatus::FAILED directly.
*
*/
void coreInitialized();
/**
* Clears the NFC chip.
*
* Must be called during factory reset and/or before the first time the HAL is
* initialized after a factory reset.
*/
void factoryReset();
/**
* Fetches vendor specific configurations.
* @return NfcConfig indicates support for certain features and
* populates the vendor specific configs.
*/
NfcConfig getConfig();
/**
* Restart controller by power cyle;
* It's similar to open but just reset the controller without initialize all the
* resources.
*
* If powerCycle() returns ok(), the NCI stack must wait for a NfcEvent.OPEN_CPLT
* before continuing.
*
* powerCycle() must be called after open() registers the clientCallback
* or return a service-specific error NfcStatus::FAILED directly.
*/
void powerCycle();
/**
* preDiscover is called every time before starting RF discovery.
* It is a good place to do vendor-specific configuration that must be
* performed every time RF discovery is about to be started.
*
* If preDiscover() returns ok(), the NCI stack must wait for a
* NfcEvent.PREDISCOVER_CPLT before continuing.
*
* preDiscover() must be called after open() registers the clientCallback
* or return a service-specific error NfcStatus::FAILED directly.
*
* If preDiscover() reports an error, the NCI stack must start RF discovery immediately.
*/
void preDiscover();
/**
* Performs an NCI write.
*
* This method may queue writes and return immediately. The only
* requirement is that the writes are executed in order.
*
* @param data
* Data packet to transmit NCI Commands and Data Messages over write.
* Detailed format is defined in NFC Controller Interface (NCI) Technical Specification.
* https://nfc-forum.org/our-work/specification-releases/
*
* @return number of bytes written to the NFCC.
*/
int write(in byte[] data);
/**
* Set the logging flag for NFC HAL to enable it's verbose logging.
* If verbose logging is not supported, the call must not have any effect on logging verbosity.
* However, isVerboseLoggingEnabled() must still return the value set by the last call to
* setEnableVerboseLogging().
* @param enable for setting the verbose logging flag to HAL
*/
void setEnableVerboseLogging(in boolean enable);
/**
* Get the verbose logging flag value from NFC HAL.
* @return true if verbose logging flag value is enabled, false if disabled.
*/
boolean isVerboseLoggingEnabled();
}

41
nfc/aidl/android/hardware/nfc/INfcClientCallback.aidl Normal file
View file

@ -0,0 +1,41 @@
/*
* 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.
*/
package android.hardware.nfc;
import android.hardware.nfc.NfcEvent;
import android.hardware.nfc.NfcStatus;
@VintfStability
interface INfcClientCallback {
/**
* The callback passed in from the NFC stack that the HAL
* can use to pass incomming response data to the stack.
*
* @param data
* Data packet to transmit NCI Responses, Notifications, and Data
* Messages over sendData.
* Detailed format is defined in NFC Controller Interface (NCI) Technical Specification.
* https://nfc-forum.org/our-work/specification-releases/
*/
void sendData(in byte[] data);
/**
* The callback passed in from the NFC stack that the HAL
* can use to pass events back to the stack.
*/
void sendEvent(in NfcEvent event, in NfcStatus status);
}

38
nfc/aidl/android/hardware/nfc/NfcCloseType.aidl Normal file
View file

@ -0,0 +1,38 @@
/*
* 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.
*/
package android.hardware.nfc;
/**
* Different closing types for NFC HAL.
*/
@VintfStability
@Backing(type="int")
enum NfcCloseType {
/**
* Close the NFC controller and free NFC HAL resources.
*/
DISABLE = 0,
/**
* Switch the NFC controller operation mode and free NFC HAL resources.
* Enable NFC functionality for off host card emulation usecases in
* device(host) power off(switched off) state, if the device
* supports power off use cases. If the device doesn't support power
* off use cases, this call should be same as DISABLE.
*/
HOST_SWITCHED_OFF = 1,
}

89
nfc/aidl/android/hardware/nfc/NfcConfig.aidl Normal file
View file

@ -0,0 +1,89 @@
/*
* 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.
*/
package android.hardware.nfc;
import android.hardware.nfc.PresenceCheckAlgorithm;
import android.hardware.nfc.ProtocolDiscoveryConfig;
/**
* Define Nfc related configurations based on:
* NFC Controller Interface (NCI) Technical Specification
* https://nfc-forum.org/our-work/specification-releases/
*/
@VintfStability
parcelable NfcConfig {
/**
* If true, NFCC is using bail out mode for either Type A or Type B poll
* based on: Nfc-Forum Activity Technical Specification
* https://nfc-forum.org/our-work/specification-releases/
*/
boolean nfaPollBailOutMode;
PresenceCheckAlgorithm presenceCheckAlgorithm;
ProtocolDiscoveryConfig nfaProprietaryCfg;
/**
* Default off-host route. 0x00 if there aren't any. Refer to NCI spec.
*/
byte defaultOffHostRoute;
/**
* Default off-host route for Felica. 0x00 if there aren't any. Refer to
* NCI spec.
*/
byte defaultOffHostRouteFelica;
/**
* Default system code route. 0x00 if there aren't any. Refer NCI spec.
*/
byte defaultSystemCodeRoute;
/**
* Default power state for system code route. 0x00 if there aren't any.
* Refer to NCI spec.
*/
byte defaultSystemCodePowerState;
/**
* Default route for all remaining protocols and technology which haven't
* been configured.
* Device Host(0x00) is the default. Refer to NCI spec.
*
*/
byte defaultRoute;
/**
* Pipe ID for eSE. 0x00 if there aren't any.
*/
byte offHostESEPipeId;
/**
* Pipe ID for UICC. 0x00 if there aren't any.
*/
byte offHostSIMPipeId;
/**
* Extended APDU length for ISO_DEP. If not supported default length is 261
*/
int maxIsoDepTransceiveLength;
/**
* list of allowed host ids, as per ETSI TS 102 622
* https://www.etsi.org/
*/
byte[] hostAllowlist;
/**
* NFCEE ID for offhost UICC & eSE secure element.
* 0x00 if there aren't any. Refer to NCI spec.
*/
byte[] offHostRouteUicc;
byte[] offHostRouteEse;
/**
* Default IsoDep route. 0x00 if there aren't any. Refer to NCI spec.
*/
byte defaultIsoDepRoute;
}

53
nfc/aidl/android/hardware/nfc/NfcEvent.aidl Normal file
View file

@ -0,0 +1,53 @@
/*
* 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.
*/
package android.hardware.nfc;
/**
* Nfc event to notify nfc status change.
*/
@VintfStability
@Backing(type="int")
enum NfcEvent {
/**
* Open complete event to notify upper layer when NFC HAL and NFCC
* initialization complete.
*/
OPEN_CPLT = 0,
/**
* Close complete event to notify upper layer when HAL close is done.
*/
CLOSE_CPLT = 1,
/**
* Post init complete event to notify upper layer when post init operations
* are done.
*/
POST_INIT_CPLT = 2,
/**
* Pre-discover complete event to notify upper layer when pre-discover
* operations are done.
*/
PRE_DISCOVER_CPLT = 3,
/**
* HCI network reset event to notify upplayer when HCI network needs to
* be re-initialized in case of an error.
*/
HCI_NETWORK_RESET = 4,
/**
* Error event to notify upper layer when there's an unknown error.
*/
ERROR = 5,
}

45
nfc/aidl/android/hardware/nfc/NfcStatus.aidl Normal file
View file

@ -0,0 +1,45 @@
/*
* 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.
*/
package android.hardware.nfc;
/**
* Used to specify the status of the NfcEvent
*/
@VintfStability
@Backing(type="int")
enum NfcStatus {
/**
* Default status when NfcEvent with status OK.
*/
OK = 0,
/**
* Generic error.
*/
FAILED = 1,
/**
* Transport error.
*/
ERR_TRANSPORT = 2,
/**
* Command timeout error.
*/
ERR_CMD_TIMEOUT = 3,
/**
* Refused error when command is rejected.
*/
REFUSED = 4,
}

39
nfc/aidl/android/hardware/nfc/PresenceCheckAlgorithm.aidl Normal file
View file

@ -0,0 +1,39 @@
/*
* 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.
*/
package android.hardware.nfc;
/*
* Presence Check Algorithm as defined in ISO/IEC 14443-4:
* https://www.iso.org/standard/73599.html
*/
@VintfStability
@Backing(type="byte")
enum PresenceCheckAlgorithm {
/**
* Let the stack select an algorithm
*/
DEFAULT = 0,
/**
* ISO-DEP protocol's empty I-block
*/
I_BLOCK = 1,
/**
* Type - 4 tag protocol iso-dep nak presence check command is sent waiting for
* response and notification.
*/
ISO_DEP_NAK = 2,
}

36
nfc/aidl/android/hardware/nfc/ProtocolDiscoveryConfig.aidl Normal file
View file

@ -0,0 +1,36 @@
/*
* 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.
*/
package android.hardware.nfc;
/**
* Vendor Specific Proprietary Protocol & Discovery Configuration.
* Set to 0xFF if not supported.
* discovery* fields map to "RF Technology and Mode" in NCI Spec
* protocol* fields map to "RF protocols" in NCI Spec
*/
@VintfStability
parcelable ProtocolDiscoveryConfig {
byte protocol18092Active;
byte protocolBPrime;
byte protocolDual;
byte protocol15693;
byte protocolKovio;
byte protocolMifare;
byte discoveryPollKovio;
byte discoveryPollBPrime;
byte discoveryListenBPrime;
}

23
nfc/aidl/default/Android.bp Normal file
View file

@ -0,0 +1,23 @@
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",
],
}

163
nfc/aidl/default/Nfc.cpp Normal file
View file

@ -0,0 +1,163 @@
/*
* 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));
} else {
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));
return ndk::ScopedAStatus::ok();
}
return ndk::ScopedAStatus::ok();
}
::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

72
nfc/aidl/default/Nfc.h Normal file
View file

@ -0,0 +1,72 @@
/*
* 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

71
nfc/aidl/default/Vendor_hal_api.cpp Normal file
View file

@ -0,0 +1,71 @@
/*
* 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;
}

51
nfc/aidl/default/Vendor_hal_api.h Normal file
View file

@ -0,0 +1,51 @@
/*
* 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();

31
nfc/aidl/default/hardware_nfc.h Normal file
View file

@ -0,0 +1,31 @@
/*
* 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
typedef uint8_t nfc_event_t;
typedef uint8_t nfc_status_t;
/*
* The callback passed in from the NFC stack that the HAL
* can use to pass events back to the stack.
*/
typedef void(nfc_stack_callback_t)(nfc_event_t event, nfc_status_t event_status);
/*
* The callback passed in from the NFC stack that the HAL
* can use to pass incomming data to the stack.
*/
typedef void(nfc_stack_data_callback_t)(uint16_t data_len, uint8_t* p_data);

38
nfc/aidl/default/main.cpp Normal file
View file

@ -0,0 +1,38 @@
/*
* 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/logging.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include "Nfc.h"
using ::aidl::android::hardware::nfc::Nfc;
int main() {
LOG(INFO) << "NFC HAL starting up";
if (!ABinderProcess_setThreadPoolMaxThreadCount(1)) {
LOG(INFO) << "failed to set thread pool max thread count";
return 1;
}
std::shared_ptr<Nfc> nfc_service = ndk::SharedRefBase::make<Nfc>();
const std::string instance = std::string() + Nfc::descriptor + "/default";
binder_status_t status =
AServiceManager_addService(nfc_service->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool();
return 0;
}

4
nfc/aidl/default/nfc-service-example.rc Normal file
View file

@ -0,0 +1,4 @@
service nfc_hal_service /vendor/bin/hw/android.hardware.nfc-service.st
class hal
user nfc
group nfc

6
nfc/aidl/default/nfc-service-example.xml Normal file
View file

@ -0,0 +1,6 @@
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.nfc</name>
<fqname>INfc/default</fqname>
</hal>
</manifest>

46
nfc/aidl/vts/functional/Android.bp Normal file
View file

@ -0,0 +1,46 @@
//
// 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.
//
package {
// 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_test {
name: "VtsAidlHalNfcTargetTest",
defaults: [
"VtsHalTargetTestDefaults",
"use_libaidlvintf_gtest_helper_static",
],
srcs: [
"VtsAidlHalNfcTargetTest.cpp",
],
shared_libs: [
"libbinder",
"libbinder_ndk",
],
static_libs: [
"android.hardware.nfc-V1-ndk",
],
test_suites: [
"general-tests",
"vts",
],
}

458
nfc/aidl/vts/functional/VtsAidlHalNfcTargetTest.cpp Normal file
View file

@ -0,0 +1,458 @@
/*
* 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;
}