@icedevml/react-native-host-card-emulation 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Michal Leszczynski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# Package: React Native HCE Module
+
+Host Card Emulation Module for React Native on iOS and Android platforms.
+
+> [!IMPORTANT]  
+> As per Apple's policy, **Host Card Emulation feature is only available for users based in the European
+> Economic Area (EEA)** with an iPhone running iOS 17.4 or later. Applications require a special HCE entitlement
+> in order to use this feature, which is managed by Apple. Read more in the official support article:
+> "[HCE-based contactless NFC transactions for apps in the European Economic Area (EEA)](https://developer.apple.com/support/hce-transactions-in-apps/)".
+
+> [!NOTE]  
+> Kindly please reference this project in your README if you are willing to create a derivative library.
+
+## API Specification & Demo App
+
+* [module API (declarations)](https://github.com/icedevml/react-native-host-card-emulation/blob/master/packages/react-native-hce-module/js/NativeHCEModule.ts)
+* [demo app's code (example usage)](https://github.com/icedevml/react-native-host-card-emulation/blob/master/packages/demo-hce-module-ios-app/App.tsx)

package/RTNHCEModuleIOS.podspec

@@ -0,0 +1,19 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name            = "RTNHCEModuleIOS"
+  s.version         = package["version"]
+  s.summary         = package["description"]
+  s.description     = package["description"]
+  s.homepage        = package["homepage"]
+  s.license         = package["license"]
+  s.platforms       = { :ios => "11.0" }
+  s.author          = package["author"]
+  s.source          = { :git => package["repository"], :tag => "#{s.version}" }
+
+  s.source_files    = "ios/**/*.{h,m,mm,swift}"
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,33 @@
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        gradlePluginPortal()
+    }
+    dependencies {
+        classpath("com.android.tools.build:gradle:7.3.1")
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'com.facebook.react'
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', 33)
+    namespace "com.itsecrnd.rtnhceandroid"
+}
+
+repositories {
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url "$projectDir/../node_modules/react-native/android"
+    }
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+}

package/android/src/main/AndroidMainfest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.itsecrnd.rtnhceandroid">
+</manifest>

package/android/src/main/java/com/itsecrnd/rtnhceandroid/AESGCMUtil.java

@@ -0,0 +1,89 @@
+package com.itsecrnd.rtnhceandroid;
+
+import android.annotation.SuppressLint;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.KeyGenerator;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.GCMParameterSpec;
+
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Base64;
+
+@SuppressLint("NewApi")
+public class AESGCMUtil {
+    public static SecretKey generateKey() {
+        KeyGenerator keyGen;
+        try {
+            keyGen = KeyGenerator.getInstance("AES");
+        } catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException("Failed to get AES algorithm.", e);
+        }
+        keyGen.init(256);
+        return keyGen.generateKey();
+    }
+
+    public static byte[] generateNonce(int size) {
+        byte[] nonce = new byte[size];
+        new SecureRandom().nextBytes(nonce); // Fill nonce with random bytes
+        return nonce;
+    }
+
+    public static String encryptData(SecretKey key, String plaintext) {
+        try {
+            byte[] iv = new byte[32];
+            new SecureRandom().nextBytes(iv);
+
+            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
+            GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, iv);
+            cipher.init(Cipher.ENCRYPT_MODE, key, gcmParameterSpec);
+
+            byte[] plaintextBytes = plaintext.getBytes(StandardCharsets.UTF_8);
+            byte[] ciphertextBytes = cipher.doFinal(plaintextBytes);
+
+            return Base64.getEncoder().encodeToString(iv) + ';' +
+                Base64.getEncoder().encodeToString(ciphertextBytes);
+        } catch (NoSuchPaddingException
+                 | NoSuchAlgorithmException
+                 | IllegalBlockSizeException
+                 | InvalidAlgorithmParameterException
+                 | BadPaddingException
+                 | InvalidKeyException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String decryptData(SecretKey key, String ciphertext) {
+        try {
+            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
+            String[] parts = ciphertext.split(";");
+
+            if (parts.length != 2) {
+                throw new IllegalArgumentException("Invalid ciphertext parameter.");
+            }
+
+            byte[] iv = Base64.getDecoder().decode(parts[0]);
+            byte[] ciphertextBytes = Base64.getDecoder().decode(parts[1]);
+
+            GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, iv);
+            cipher.init(Cipher.DECRYPT_MODE, key, gcmParameterSpec);
+
+            byte[] plaintextBytes = cipher.doFinal(ciphertextBytes);
+            return new String(plaintextBytes, StandardCharsets.UTF_8);
+        } catch (NoSuchPaddingException
+                 | IllegalBlockSizeException
+                 | InvalidAlgorithmParameterException
+                 | BadPaddingException
+                 | InvalidKeyException
+                 | NoSuchAlgorithmException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

package/android/src/main/java/com/itsecrnd/rtnhceandroid/BinaryUtils.java

@@ -0,0 +1,66 @@
+/*
+ * Content of "BinaryUtils" class:
+ * Original source: https://github.com/googlearchive/android-CardEmulation
+ *
+ * ---
+ *
+ * Copyright (C) 2013 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 com.itsecrnd.rtnhceandroid;
+
+public class BinaryUtils {
+    /**
+     * Utility method to convert a byte array to a hexadecimal string.
+     *
+     * @param bytes Bytes to convert
+     * @return String, containing hexadecimal representation.
+     */
+    public static String ByteArrayToHexString(byte[] bytes) {
+        final char[] hexArray = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+        char[] hexChars = new char[bytes.length * 2]; // Each byte has two hex characters (nibbles)
+        int v;
+        for (int j = 0; j < bytes.length; j++) {
+            v = bytes[j] & 0xFF; // Cast bytes[j] to int, treating as unsigned value
+            hexChars[j * 2] = hexArray[v >>> 4]; // Select hex character from upper nibble
+            hexChars[j * 2 + 1] = hexArray[v & 0x0F]; // Select hex character from lower nibble
+        }
+        return new String(hexChars);
+    }
+
+    /**
+     * Utility method to convert a hexadecimal string to a byte string.
+     *
+     * <p>Behavior with input strings containing non-hexadecimal characters is undefined.
+     *
+     * @param s String containing hexadecimal characters to convert
+     * @return Byte array generated from input
+     * @throws java.lang.IllegalArgumentException if input length is incorrect
+     */
+    public static byte[] HexStringToByteArray(String s) throws IllegalArgumentException {
+        int len = s.length();
+        if (len % 2 == 1) {
+            throw new IllegalArgumentException("Hex string must have even number of characters");
+        }
+        byte[] data = new byte[len / 2]; // Allocate 1 byte per 2 hex characters
+        for (int i = 0; i < len; i += 2) {
+            // Convert each character into a integer (base-16), then bit-shift into place
+            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+                    + Character.digit(s.charAt(i+1), 16));
+        }
+        return data;
+    }
+}

package/android/src/main/java/com/itsecrnd/rtnhceandroid/HCEService.java

@@ -0,0 +1,92 @@
+package com.itsecrnd.rtnhceandroid;
+
+import static com.itsecrnd.rtnhceandroid.IntentKeys.INTENT_RECEIVE_C_APDU;
+import static com.itsecrnd.rtnhceandroid.IntentKeys.INTENT_SEND_R_APDU;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.nfc.cardemulation.HostApduService;
+import android.nfc.cardemulation.PollingFrame;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import java.util.List;
+import java.util.Locale;
+
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+
+@RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
+public class HCEService extends HostApduService {
+    private static final String TAG = "HCEService";
+
+    private SecretKey encSecretKey;
+
+    private final BroadcastReceiver receiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+
+            if (action != null && action.equals(INTENT_SEND_R_APDU)) {
+                String rapdu = AESGCMUtil.decryptData(encSecretKey, intent.getStringExtra("rapdu"));
+                byte[] dec = BinaryUtils.HexStringToByteArray(rapdu.toUpperCase(Locale.ROOT));
+                sendResponseApdu(dec);
+            }
+        }
+    };
+
+    @Override
+    public byte[] processCommandApdu(byte[] command, Bundle extras) {
+        String capdu = AESGCMUtil.encryptData(encSecretKey, BinaryUtils.ByteArrayToHexString(command));
+
+        Intent intent = new Intent(INTENT_RECEIVE_C_APDU);
+        intent.setPackage(getApplicationContext().getPackageName());
+        intent.putExtra("capdu", capdu);
+        getApplicationContext().sendBroadcast(intent);
+
+        return null;
+    }
+
+    @Override
+    public void processPollingFrames(@NonNull List<PollingFrame> frames) {
+        super.processPollingFrames(frames);
+        Log.i(TAG, "Polling frames: " + frames.size());
+    }
+
+    @Override
+    public void onCreate() {
+        Log.d(TAG, "Starting service");
+
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(INTENT_SEND_R_APDU);
+
+        String encKey = getApplicationContext()
+                .getSharedPreferences("RTNHCEAndroidModuleBroadcastEnc", Context.MODE_PRIVATE)
+                .getString("encKey", "");
+
+        if (encKey.isEmpty()) {
+            throw new RuntimeException("Failed to load encKey.");
+        }
+
+        byte[] bArr = BinaryUtils.HexStringToByteArray(encKey);
+        encSecretKey = new SecretKeySpec(bArr, 0, bArr.length, "AES");
+
+        /*
+         * See a comment about registerReceiver() in RTNHCEAndroidModule.
+         */
+        getApplicationContext().registerReceiver(receiver, filter, RECEIVER_EXPORTED);
+    }
+
+    @Override
+    public void onDeactivated(int reason) {
+        Log.d(TAG, "Finishing service: " + reason);
+
+        getApplicationContext().unregisterReceiver(receiver);
+    }
+}

package/android/src/main/java/com/itsecrnd/rtnhceandroid/IntentKeys.java

@@ -0,0 +1,6 @@
+package com.itsecrnd.rtnhceandroid;
+
+public class IntentKeys {
+    public static final String INTENT_RECEIVE_C_APDU = "com.itsecrnd.rtnhceandroid.receivecapdu";
+    public static final String INTENT_SEND_R_APDU = "com.itsecrnd.rtnhceandroid.sendrapdu";
+}

package/android/src/main/java/com/itsecrnd/rtnhceandroid/RTNHCEAndroidModule.java

@@ -0,0 +1,148 @@
+package com.itsecrnd.rtnhceandroid;
+
+import static android.content.Context.RECEIVER_EXPORTED;
+
+import static com.itsecrnd.rtnhceandroid.IntentKeys.INTENT_RECEIVE_C_APDU;
+import static com.itsecrnd.rtnhceandroid.IntentKeys.INTENT_SEND_R_APDU;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
+
+import javax.crypto.SecretKey;
+
+@RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
+public class RTNHCEAndroidModule extends NativeHCEModuleSpec {
+    public static final String TAG = "RTNHCEAndroidModule";
+    public static final String NAME = "NativeHCEModule";
+
+    private final SecretKey encSecretKey;
+
+    private final BroadcastReceiver receiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+
+            if (action != null && action.equals(INTENT_RECEIVE_C_APDU)) {
+                String capdu = AESGCMUtil.decryptData(encSecretKey, intent.getStringExtra("capdu"));
+
+                WritableMap map = Arguments.createMap();
+                map.putString("type", "received");
+                map.putString("arg", capdu);
+                emitOnEvent(map);
+            }
+        }
+    };
+
+    RTNHCEAndroidModule(ReactApplicationContext context) {
+        super(context);
+        String encKey;
+
+        try {
+            encSecretKey = AESGCMUtil.generateKey();
+            encKey = BinaryUtils.ByteArrayToHexString(encSecretKey.getEncoded());
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to generate encryption key.", e);
+        }
+
+        getReactApplicationContext()
+                .getSharedPreferences("RTNHCEAndroidModuleBroadcastEnc", Context.MODE_PRIVATE)
+                .edit()
+                .putString("encKey", encKey)
+                .commit();
+
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(INTENT_RECEIVE_C_APDU);
+
+        /*
+         * FIXME It seems like those intents are not going through across this module and HostApduService.
+         * This happens even though those things are within the same application and package.
+         * It also seems like there is no way to bind HostApduService (or it's a skill issue).
+         *
+         * For now we will just encrypt&authenticate all messages using AES/GCM and use exported
+         * receivers. This is not a perfect solution but it is going to be secure and sufficient for now.
+         *
+         * If somebody knows a better way then any pull requests would be greatly appreciated.
+         */
+        getReactApplicationContext().getApplicationContext().registerReceiver(receiver, filter, RECEIVER_EXPORTED);
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+        return RTNHCEAndroidModule.NAME;
+    }
+
+    @Override
+    public boolean isPlatformSupported() {
+        return true;
+    }
+
+    @Override
+    public void acquireExclusiveNFC(Promise promise) {
+        promise.resolve(null);
+    }
+
+    @Override
+    public boolean isExclusiveNFC() {
+        return false;
+    }
+
+    @Override
+    public void beginSession(Promise promise) {
+        promise.resolve(null);
+    }
+
+    @Override
+    public void setSessionAlertMessage(String message) {
+
+    }
+
+    @Override
+    public void invalidateSession() {
+
+    }
+
+    @Override
+    public boolean isSessionRunning() {
+        return true;
+    }
+
+    @Override
+    public void startHCE(Promise promise) {
+        promise.resolve(null);
+    }
+
+    @Override
+    public void stopHCE(String status, Promise promise) {
+        promise.resolve(null);
+    }
+
+    @Override
+    public void respondAPDU(String rapdu, Promise promise) {
+        String encRapdu = AESGCMUtil.encryptData(encSecretKey, rapdu);
+
+        Intent intent = new Intent(INTENT_SEND_R_APDU);
+        intent.setPackage(getReactApplicationContext().getPackageName());
+        intent.putExtra("rapdu", encRapdu);
+        getReactApplicationContext().getApplicationContext().sendBroadcast(intent);
+
+        promise.resolve(null);
+    }
+
+    @Override
+    public void isHCERunning(Promise promise) {
+        promise.resolve(true);
+    }
+}

package/android/src/main/java/com/itsecrnd/rtnhceandroid/RTNHCEAndroidPackage.java

@@ -0,0 +1,47 @@
+package com.itsecrnd.rtnhceandroid;
+
+import android.os.Build;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
+public class RTNHCEAndroidPackage extends TurboReactPackage {
+    @Nullable
+    @Override
+    public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+        if (name.equals(RTNHCEAndroidModule.NAME)) {
+            return new RTNHCEAndroidModule(reactContext);
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return () -> {
+            final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+            moduleInfos.put(
+                    RTNHCEAndroidModule.NAME,
+                    new ReactModuleInfo(
+                            RTNHCEAndroidModule.NAME,
+                            RTNHCEAndroidModule.NAME,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            true // isTurboModule
+            ));
+            return moduleInfos;
+        };
+    }
+}

package/ios/RTNHCEModuleIOS-Bridging-Header.h

@@ -0,0 +1 @@
+#import <React-RCTAppDelegate/RCTDefaultReactNativeFactoryDelegate.h>

package/ios/RTNHCEModuleIOS.h

@@ -0,0 +1,12 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <Foundation/Foundation.h>
+#import <RTNHCEModuleSpec/RTNHCEModuleSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RTNHCEModuleIOS : NativeHCEModuleSpecBase <NativeHCEModuleSpec>
+
+@end
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/RTNHCEModuleIOS.mm

@@ -0,0 +1,125 @@
+#import "RTNHCEModuleIOS.h"
+#import "RCTDefaultReactNativeFactoryDelegate.h"
+#import "RTNHCEModuleIOS-Swift.h"
+
+@implementation RTNHCEModuleIOS {
+    API_AVAILABLE(ios(17.4))
+    RTNHCEModuleIOSImpl *hcemoduleios;
+}
+
+-(id) init {
+    self = [super init];
+
+    if (@available(iOS 17.4, *)) {
+        __weak RTNHCEModuleIOS *weakSelf = self;
+
+        hcemoduleios = [RTNHCEModuleIOSImpl new];
+        [hcemoduleios setEmitOnEventWithEmitOnEvent:^(NSString *type, NSString *arg){
+            [weakSelf emitOnEvent:@{@"type": type, @"arg": arg}];
+        }];
+    } else {
+        // ignore
+    }
+
+    return(self);
+}
+
+- (void)dealloc {
+    [hcemoduleios setEmitOnEventWithEmitOnEvent:^(NSString *type, NSString *arg){
+        // no-op
+    }];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+    return std::make_shared<facebook::react::NativeHCEModuleSpecJSI>(params);
+}
+
+- (nonnull NSNumber *)isPlatformSupported {
+    if (@available(iOS 17.4, *)) {
+        return @1;
+    }
+
+    return @0;
+}
+
+- (void)acquireExclusiveNFC:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios acquireExclusiveNFCWithResolve:resolve reject:reject];
+    } else {
+        reject(@"err_platform_unsupported", @"This iOS version does not support HCE.", nil);
+    }
+}
+
+- (nonnull NSNumber *)isExclusiveNFC {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios isExclusiveNFC] ? @1 : @0;
+    }
+
+    return @0;
+}
+
+- (void)beginSession:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios beginSessionWithResolve:resolve reject:reject];
+    } else {
+        reject(@"err_platform_unsupported", @"This iOS version does not support HCE.", nil);
+    }
+}
+
+- (void)setSessionAlertMessage:(nonnull NSString *)message {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios setSessionAlertMessageWithMessage:message];
+    }
+}
+
+- (void)invalidateSession {
+    if (@available(iOS 17.4, *)) {
+        [hcemoduleios invalidateSession];
+    }
+}
+
+- (nonnull NSNumber *)isSessionRunning {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios isSessionRunning] ? @1 : @0;
+    } else {
+        return @0;
+    }
+}
+
+- (void)startHCE:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios startHCEWithResolve:resolve reject:reject];
+    } else {
+        reject(@"err_platform_unsupported", @"This iOS version does not support HCE.", nil);
+    }
+}
+
+- (void)stopHCE:(nonnull NSString *)status resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios stopHCEWithStatus:status resolve:resolve reject:reject];
+    } else {
+        reject(@"err_platform_unsupported", @"This iOS version does not support HCE.", nil);
+    }
+}
+
+- (void)respondAPDU:(nonnull NSString *)rapdu resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    if (@available(iOS 17.4, *)) {
+        return [hcemoduleios respondAPDUWithRapdu:rapdu resolve:resolve reject:reject];
+    } else {
+        reject(@"err_platform_unsupported", @"This iOS version does not support HCE.", nil);
+    }
+}
+
+- (void)isHCERunning:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    if (@available(iOS 17.4, *)) {
+        [hcemoduleios isHCERunningWithResolve:resolve reject:reject];
+    } else {
+        reject(@"err_platform_unsupported", @"This iOS version does not support HCE.", nil);
+    }
+}
+
++ (NSString *)moduleName {
+    return @"NativeHCEModule";
+}
+
+@end

package/ios/RTNHCEModuleIOSImpl.swift

@@ -0,0 +1,190 @@
+import Foundation
+import CoreNFC
+
+extension StringProtocol {
+  func asHexArray() -> [UInt8] {
+    var startIndex = self.startIndex
+    return stride(from: 0, to: count, by: 2).compactMap { _ in
+      let endIndex = index(startIndex, offsetBy: 2, limitedBy: self.endIndex) ?? self.endIndex
+      defer { startIndex = endIndex }
+      return UInt8(self[startIndex..<endIndex], radix: 16)
+    }
+  }
+}
+
+extension Data {
+  struct HexEncodingOptions: OptionSet {
+    let rawValue: Int
+    static let upperCase = HexEncodingOptions(rawValue: 1 << 0)
+  }
+
+  func hexEncodedString(options: HexEncodingOptions = []) -> String {
+    let format = options.contains(.upperCase) ? "%02hhX" : "%02hhx"
+    return map { String(format: format, $0) }.joined()
+  }
+}
+
+@available(iOS 17.4, *)
+@objc public class RTNHCEModuleIOSImpl: NSObject {
+  var cardSession: CardSession? = nil
+  var cardSessionInvalidated: Bool = true
+  var presentmentIntent: NFCPresentmentIntentAssertion? = nil
+  var receivedCardAPDU: CardSession.APDU? = nil
+
+  var emitOnEvent: ((NSString, NSString?) -> ())? = nil
+
+  @objc public func setEmitOnEvent(emitOnEvent: @escaping (NSString, NSString?) -> ()) {
+    self.emitOnEvent = emitOnEvent
+  }
+
+  @objc public func acquireExclusiveNFC(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    Task.init {
+      if self.presentmentIntent != nil && self.presentmentIntent!.isValid {
+        reject("err_already_exists", "NFCPresentmentIntentAssertion already exists and is valid.", nil)
+        return
+      }
+
+      self.presentmentIntent = nil
+
+      do {
+        self.presentmentIntent = try await NFCPresentmentIntentAssertion.acquire()
+      } catch (let error) {
+        // TODO exact error details here and in other places as well
+        reject("err_create_presentment", "Failed to create NFCPresentmentIntentAssertion: \(error)", nil)
+        return
+      }
+
+      resolve(nil)
+    }
+  }
+
+  @objc public func isExclusiveNFC() -> Bool {
+    return self.presentmentIntent != nil && self.presentmentIntent!.isValid
+  }
+
+  @objc public func beginSession(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    Task.init {
+      guard NFCReaderSession.readingAvailable else {
+        reject("err_nfc_reader_not_available", "Preflight check failed: NFCReaderSession.readingAvailable is false", nil)
+        return
+      }
+
+      guard CardSession.isSupported else {
+        reject("err_card_session_unsupported", "Preflight check failed: CardSession.isSupported is false", nil)
+        return
+      }
+
+      guard await CardSession.isEligible else {
+        reject("err_card_session_not_eligible", "Preflight check failed: CardSession.isEligible is false", nil)
+        return
+      }
+
+      guard self.cardSessionInvalidated else {
+        reject("err_card_session_exists", "CardSession already exists.", nil)
+        return
+      }
+
+      do {
+        self.cardSession = try await CardSession()
+      } catch (let error) {
+        reject("err_create_card_session", "Failed to create CardSession(): \(error)", nil)
+        return
+      }
+
+      resolve(nil)
+
+      do {
+        for try await event in cardSession!.eventStream {
+          switch event {
+          case .sessionStarted:
+            cardSession!.alertMessage = String(localized: "Communicating with card reader.")
+            self.emitOnEvent!("sessionStarted", "")
+
+          case .readerDetected:
+            self.emitOnEvent!("readerDetected", "")
+
+          case .readerDeselected:
+            self.emitOnEvent!("readerDeselected", "")
+
+          case .received(let cardAPDU):
+            self.receivedCardAPDU = cardAPDU
+            self.emitOnEvent!("received", NSString(string:cardAPDU.payload.hexEncodedString()))
+
+          case .sessionInvalidated(let reason):
+            self.cardSessionInvalidated = true
+            self.emitOnEvent!("sessionInvalidated", "\(reason)" as NSString)
+            self.cardSession = nil
+
+          @unknown default:
+            fatalError("Received unknown CardSession event.")
+          }
+        }
+      } catch (let err) {
+        self.emitOnEvent!("internalError", "\(err)" as NSString)
+      }
+    }
+  }
+
+  @objc public func setSessionAlertMessage(message: NSString) {
+    self.cardSession?.alertMessage = String(message)
+  }
+
+  @objc public func invalidateSession() {
+    self.cardSession?.invalidate()
+    self.cardSession = nil
+    self.cardSessionInvalidated = true
+  }
+
+  @objc public func isSessionRunning() -> Bool {
+    return self.cardSession != nil && !self.cardSessionInvalidated
+  }
+
+  @objc public func isHCERunning(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    Task.init {
+      guard self.cardSession != nil else {
+        return resolve(false)
+      }
+
+      let isRunning = await self.cardSession!.isEmulationInProgress
+      resolve(isRunning)
+    }
+  }
+
+  @objc public func respondAPDU(rapdu: NSString, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    Task.init {
+      guard let capdu = self.receivedCardAPDU else {
+        reject("err_no_apdu_received", "There is no received APDU to respond to.", nil)
+        return
+      }
+
+      do {
+        try await capdu.respond(response: Data.init(String(rapdu).asHexArray()))
+      } catch (let error) {
+        reject("err_apdu_respond", "Error trying to respond to APDU. \(error)", nil)
+        return
+      }
+
+      resolve(nil)
+    }
+  }
+
+  @objc public func startHCE(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    Task.init {
+      try await self.cardSession?.startEmulation()
+    }
+  }
+
+  @objc public func stopHCE(status: NSString, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    Task.init {
+      let sStatus = String(status)
+
+      if (sStatus == "success") {
+        await self.cardSession?.stopEmulation(status: .success)
+      } else {
+        await self.cardSession?.stopEmulation(status: .failure)
+      }
+
+      resolve(nil)
+    }
+  }
+}

package/js/NativeHCEModule.ts

@@ -0,0 +1,33 @@
+import type {TurboModule, CodegenTypes} from 'react-native';
+import {TurboModuleRegistry} from 'react-native';
+
+export type HCEModuleIOSEventType = 'sessionStarted' | 'readerDetected' | 'readerDeselected' | 'received' | 'sessionInvalidated';
+export type HCEModuleIOSStopReason = 'success' | 'failure';
+
+export type HCEModuleIOSEvent = {
+  type: HCEModuleIOSEventType
+  arg: string | null,
+}
+
+export interface Spec extends TurboModule {
+  isPlatformSupported(): boolean;
+
+  acquireExclusiveNFC(): Promise<boolean>;
+  isExclusiveNFC(): boolean;
+
+  beginSession(): Promise<void>;
+  setSessionAlertMessage(message: string): void;
+  invalidateSession(): void;
+  isSessionRunning(): boolean;
+
+  startHCE(): Promise<void>;
+  stopHCE(status: HCEModuleIOSStopReason): Promise<void>;
+  respondAPDU(rapdu: string): Promise<void>;
+  isHCERunning(): Promise<boolean>;
+
+  readonly onEvent: CodegenTypes.EventEmitter<HCEModuleIOSEvent>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeHCEModule',
+);

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@icedevml/react-native-host-card-emulation",
+  "version": "0.2.0",
+  "description": "Host Card Emulation (HCE) React Native Turbo Module for iOS and Android platforms.",
+  "react-native": "js/index",
+  "source": "js/index",
+  "files": [
+    "js",
+    "android",
+    "ios",
+    "RTNHCEModuleIOS.podspec",
+    "!android/build",
+    "!ios/build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "keywords": [
+    "react-native",
+    "ios",
+    "nfc",
+    "hce"
+  ],
+  "repository": "https://github.com/icedevml/react-native-host-card-emulation",
+  "author": "Michal Leszczynski ml@icedev.pl (https://github.com/icedevml)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/icedevml/react-native-host-card-emulation/issues"
+  },
+  "homepage": "https://github.com/icedevml/react-native-host-card-emulation#readme",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "codegenConfig": {
+    "name": "RTNHCEModuleSpec",
+    "type": "modules",
+    "jsSrcsDir": "js",
+    "android": {
+      "javaPackageName": "com.itsecrnd.rtnhceandroid"
+    },
+    "ios": {
+      "modulesProvider": {
+        "NativeHCEModule": "RTNHCEModuleIOS"
+      }
+    }
+  }
+}