@icedevml/react-native-host-card-emulation 0.6.0 → 0.6.1

package/README.md

@@ -233,6 +233,7 @@ for instance - your app may emulate an NDEF tag even when it's not launched on t
    ```
 3. Cleanup your event listener in `readerDeselected` -- this is obligatory because lack of proper cleanup will result in bugs and unexpected behavior.
    ```typescript
+   // inside processBackgroundHCE handler's switch
    case 'readerDeselected':
        // our application was deselected or the reader field was lost
        // perform a cleanup of any resources here
@@ -240,6 +241,7 @@ for instance - your app may emulate an NDEF tag even when it's not launched on t
    ```
 4. Implement the actual APDU handler that will process the C-APDU and generate a response.
    ```typescript
+   // inside processBackgroundHCE handler's switch
    case 'received':
        // decode incoming C-APDU to bytes
        const capdu = Buffer.from(event.arg!, 'hex');

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

@@ -20,7 +20,6 @@ import androidx.annotation.RequiresApi;
 
 import com.facebook.react.ReactApplication;
 import com.facebook.react.ReactHost;
-import com.facebook.react.ReactInstanceEventListener;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.UiThreadUtil;
@@ -28,12 +27,13 @@ import com.facebook.react.jstasks.HeadlessJsTaskConfig;
 import com.facebook.react.jstasks.HeadlessJsTaskContext;
 import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.UUID;
 
 @RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
-public class HCEService extends HostApduService implements ReactInstanceEventListener, HCEServiceCallback {
+public class HCEService extends HostApduService implements HCEServiceCallback {
     private static final String TAG = "HCEService";
 
     private boolean isForeground;
@@ -41,6 +41,13 @@ public class HCEService extends HostApduService implements ReactInstanceEventLis
     private RTNHCEAndroidModule hceModule;
     private byte[] pendingCAPDU;
     private volatile boolean needsResponse;
+    private final HashMap<String, Integer> taskSessionIdMap;
+
+    public HCEService() {
+        super();
+
+        taskSessionIdMap = new HashMap<>();
+    }
 
     private boolean isAppOnForeground(Context context) {
         /*
@@ -67,6 +74,7 @@ public class HCEService extends HostApduService implements ReactInstanceEventLis
     @Override
     public void onBackgroundHCEInit(String handle) {
         Log.d(TAG, "HCEService:onBackgroundHCEInit");
+        Log.d(TAG, "HCEService:onBackgroundHCEInit:" + handle + ":" + backgroundSessionUUID);
 
         if (handle == null && backgroundSessionUUID != null) {
             Log.d(TAG, "HCEService:onBackgroundHCEInit foreground call to background session");
@@ -83,6 +91,35 @@ public class HCEService extends HostApduService implements ReactInstanceEventLis
         }
     }
 
+    @Override
+    public void onBackgroundHCEFinish(String handle) {
+        Log.d(TAG, "HCEService:onBackgroundHCEFinish");
+        Integer taskId = taskSessionIdMap.get(handle);
+
+        if (taskId == null) {
+            Log.d(TAG, "HCEService:onBackgroundHCEFinish unable to resolve taskId");
+            throw new IllegalArgumentException();
+        }
+
+        ReactHost reactHost = ((ReactApplication) getApplication()).getReactHost();
+
+        if (reactHost == null) {
+            Log.d(TAG, "HCEService:onBackgroundHCEFinish getReactHost() returned null");
+            throw new IllegalArgumentException();
+        }
+
+        ReactContext reactContext = reactHost.getCurrentReactContext();
+
+        if (reactContext == null) {
+            Log.d(TAG, "HCEService:onBackgroundHCEFinish getCurrentReactContext() returned null");
+            throw new IllegalArgumentException();
+        }
+
+        HeadlessJsTaskContext headlessJsTaskContext = Companion.getInstance(reactContext);
+        headlessJsTaskContext.finishTask(taskId);
+        taskSessionIdMap.remove(handle);
+    }
+
     @Override
     public void onRespondAPDU(String handle, String rapdu) {
         Log.d(TAG, "HCEService:onRespondAPDU");
@@ -110,13 +147,13 @@ public class HCEService extends HostApduService implements ReactInstanceEventLis
         String capdu = BinaryUtils.ByteArrayToHexString(command).toUpperCase(Locale.ROOT);
 
         if (isForeground) {
-            if (hceModule._isHCERunning() && !hceModule.isHCEBrokenConnection()) {
+            if (hceModule._isHCERunning() && hceModule.isHCEActiveConnection()) {
                 Log.d(TAG, "HCEService:processCommandApdu foreground sendEvent received");
                 needsResponse = true;
                 hceModule.sendEvent("received", capdu);
             } else {
                 Log.d(TAG, "HCEService:processCommandApdu foreground respond 6999");
-                return new byte[] { (byte) 0x69, (byte) 0x99 };
+                return new byte[]{(byte) 0x69, (byte) 0x99};
             }
         } else {
             if (hceModule != null && hceModule.isHCEBackgroundHandlerReady()) {
@@ -174,13 +211,29 @@ public class HCEService extends HostApduService implements ReactInstanceEventLis
         } else {
             ReactContext reactContext = reactHost.getCurrentReactContext();
             Log.d(TAG, "HCEService:onCreate background");
-            this.backgroundSessionUUID = UUID.randomUUID().toString();
+            final String useSessID = UUID.randomUUID().toString();
+            backgroundSessionUUID = useSessID;
 
             if (reactContext == null) {
-                reactHost.addReactInstanceEventListener(this);
+                reactHost.addReactInstanceEventListener(evReactContext -> {
+                    HeadlessJsTaskContext headlessJsTaskContext = Companion.getInstance(evReactContext);
+                    headlessJsTaskContext.addTaskEventListener(new HeadlessJsTaskEventListener() {
+                        @Override
+                        public void onHeadlessJsTaskStart(int i) {
+                            Log.d(TAG, "HCEService:HeadlessJsTaskEventListener:onHeadlessJsTaskStart: " + i);
+                        }
+
+                        @Override
+                        public void onHeadlessJsTaskFinish(int i) {
+                            Log.d(TAG, "HCEService:HeadlessJsTaskEventListener:onHeadlessJsTaskFinish: " + i);
+                        }
+                    });
+
+                    setupRunJSTask(evReactContext, useSessID);
+                });
                 reactHost.start();
             } else {
-                setupRunJSTask(reactContext);
+                setupRunJSTask(reactContext, useSessID);
             }
         }
     }
@@ -191,37 +244,20 @@ public class HCEService extends HostApduService implements ReactInstanceEventLis
         needsResponse = false;
 
         if (isForeground) {
-            if (this.hceModule != null && !this.hceModule.isHCEBrokenConnection()) {
+            if (this.hceModule != null && this.hceModule.isHCEActiveConnection()) {
                 this.hceModule.sendEvent("readerDeselected", "");
             }
-        } else {
-            this.hceModule.sendBackgroundEvent(backgroundSessionUUID, "readerDeselected", "");
-        }
+        } else if (backgroundSessionUUID != null) {
+            String prevBackgroundSessionUUID = backgroundSessionUUID;
+            backgroundSessionUUID = null;
 
-        if (this.hceModule != null) {
-            this.hceModule.setHCEService(null);
-        }
-    }
-
-    @Override
-    public void onReactContextInitialized(@NonNull ReactContext reactContext) {
-        HeadlessJsTaskContext headlessJsTaskContext = Companion.getInstance(reactContext);
-        headlessJsTaskContext.addTaskEventListener(new HeadlessJsTaskEventListener() {
-            @Override
-            public void onHeadlessJsTaskStart(int i) {
-                Log.d(TAG, "HCEService:HeadlessJsTaskEventListener:onHeadlessJsTaskStart: " + i);
-            }
-
-            @Override
-            public void onHeadlessJsTaskFinish(int i) {
-                Log.d(TAG, "HCEService:HeadlessJsTaskEventListener:onHeadlessJsTaskFinish: " + i);
+            if (this.hceModule != null) {
+                this.hceModule.sendBackgroundEvent(prevBackgroundSessionUUID, "readerDeselected", "");
             }
-        });
-
-        setupRunJSTask(reactContext);
+        }
     }
 
-    public void setupRunJSTask(@NonNull ReactContext reactContext) {
+    public void setupRunJSTask(final @NonNull ReactContext reactContext, final String useSessUUID) {
         hceModule = (RTNHCEAndroidModule) reactContext.getNativeModule("NativeHCEModule");
 
         if (hceModule == null) {
@@ -230,21 +266,19 @@ public class HCEService extends HostApduService implements ReactInstanceEventLis
 
         hceModule.setHCEService(this);
 
-        UiThreadUtil.runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                Log.d(TAG, "HCEService:setupRunJSTask:runOnUiThread startTask");
-                Bundle argBundle = new Bundle();
-                argBundle.putString("handle", backgroundSessionUUID);
-                HeadlessJsTaskContext headlessJsTaskContext = Companion.getInstance(reactContext);
-                headlessJsTaskContext.startTask(
-                        new HeadlessJsTaskConfig(
-                                "handleBackgroundHCECall",
-                                Arguments.fromBundle(argBundle),
-                                15000,
-                                false // not allowed in foreground
-                        ));
-            }
+        UiThreadUtil.runOnUiThread(() -> {
+            Log.d(TAG, "HCEService:setupRunJSTask:runOnUiThread startTask");
+            Bundle argBundle = new Bundle();
+            argBundle.putString("handle", useSessUUID);
+            HeadlessJsTaskContext headlessJsTaskContext = Companion.getInstance(reactContext);
+            int taskId = headlessJsTaskContext.startTask(
+                    new HeadlessJsTaskConfig(
+                            "handleBackgroundHCECall",
+                            Arguments.fromBundle(argBundle),
+                            15000,
+                            false // not allowed in foreground
+                    ));
+            taskSessionIdMap.put(useSessUUID, taskId);
         });
     }
 

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

@@ -2,5 +2,6 @@ package com.itsecrnd.rtnhceandroid;
 
 public interface HCEServiceCallback {
     void onBackgroundHCEInit(String handle);
+    void onBackgroundHCEFinish(String handle);
     void onRespondAPDU(String handle, String rapdu);
 }

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

@@ -51,19 +51,29 @@ public class RTNHCEAndroidModule extends NativeHCEModuleSpec {
 
     void sendEvent(final String type, final String arg) {
         Log.d(TAG, "RTNHCEAndroidModule:sendEvent");
-        WritableMap map = Arguments.createMap();
-        map.putString("type", type);
-        map.putString("arg", arg);
-        emitOnEvent(map);
+
+        if (this.mEventEmitterCallback != null) {
+            WritableMap map = Arguments.createMap();
+            map.putString("type", type);
+            map.putString("arg", arg);
+            emitOnEvent(map);
+        } else {
+            Log.d(TAG, "RTNHCEAndroidModule:sendEvent missing event emitter, ignore");
+        }
     }
 
     void sendBackgroundEvent(final String audience, final String type, final String arg) {
         Log.d(TAG, "RTNHCEAndroidModule:sendBackgroundEvent");
-        WritableMap map = Arguments.createMap();
-        map.putString("audience", audience);
-        map.putString("type", type);
-        map.putString("arg", arg);
-        emitOnBackgroundEvent(map);
+
+        if (this.mEventEmitterCallback != null) {
+            WritableMap map = Arguments.createMap();
+            map.putString("audience", audience);
+            map.putString("type", type);
+            map.putString("arg", arg);
+            emitOnBackgroundEvent(map);
+        } else {
+            Log.d(TAG, "RTNHCEAndroidModule:sendBackgroundEvent missing event emitter, ignore");
+        }
     }
 
     boolean _isHCERunning() {
@@ -78,8 +88,8 @@ public class RTNHCEAndroidModule extends NativeHCEModuleSpec {
         return this.hceBackgroundReady;
     }
 
-    boolean isHCEBrokenConnection() {
-        return this.hceBrokenConnection;
+    boolean isHCEActiveConnection() {
+        return !this.hceBrokenConnection;
     }
 
     void setHCEService(HCEServiceCallback serviceCallback) {
@@ -171,6 +181,19 @@ public class RTNHCEAndroidModule extends NativeHCEModuleSpec {
         return true;
     }
 
+    @Override
+    public boolean finishBackgroundHCE(String handle) {
+        Log.d(TAG, "RTNHCEAndroidModule:finishBackgroundHCE");
+
+        try {
+            this.serviceCb.onBackgroundHCEFinish(handle);
+        } catch (IllegalStateException e) {
+            return false;
+        }
+
+        return true;
+    }
+
     @Override
     public void startHCE(Promise promise) {
         Log.d(TAG, "RTNHCEAndroidModule:startHCE");

package/js/NativeHCEModule.ts

@@ -75,6 +75,7 @@ export interface Spec extends TurboModule {
   isSessionRunning(): boolean;
 
   beginBackgroundHCE(handle: string): boolean;
+  finishBackgroundHCE(handle: string): boolean;
 
   /**
    * iOS: Start the card emulation.

package/js/hceBackground.ts

@@ -32,12 +32,14 @@ export const createBackgroundHCE = (handle: string) => {
             } finally {
                 if (event.type === "readerDeselected") {
                     subscription.remove();
+                    NativeHCEModule.finishBackgroundHCE(handle);
                 }
             }
         });
 
         if (!NativeHCEModule.beginBackgroundHCE(handle)) {
             subscription.remove();
+            NativeHCEModule.finishBackgroundHCE(handle);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icedevml/react-native-host-card-emulation",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Host Card Emulation (HCE) React Native Turbo Module for iOS and Android platforms.",
   "react-native": "js/index",
   "source": "js/index",