@icedevml/react-native-host-card-emulation 0.9.2 → 1.0.0

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

@@ -1,274 +1,340 @@
 package com.itsecrnd.rtnhceandroid;
 
+import android.app.Activity;
+import android.content.ComponentName;
 import android.content.pm.PackageManager;
-import android.os.Build;
+import android.nfc.NfcAdapter;
+import android.nfc.cardemulation.CardEmulation;
 import android.util.Log;
 
 import androidx.annotation.NonNull;
-import androidx.annotation.RequiresApi;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.LifecycleState;
+import com.facebook.react.jstasks.HeadlessJsTaskContext;
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
 
 public class RTNHCEAndroidModule extends NativeHCEModuleSpec {
     public static final String TAG = "RTNHCEAndroidModule";
     public static final String NAME = "NativeHCEModule";
 
-    private volatile boolean sessionRunning;
-    private volatile boolean hceRunning;
-    private volatile boolean hceDeselected;
-    private volatile boolean hceBrokenConnection;
+    static final class BackgroundHandlerDeclaration {
+        final boolean registered;
+        final boolean allowWhenLocked;
 
-    private volatile boolean hceBackgroundReady;
+        BackgroundHandlerDeclaration(boolean registered, boolean allowWhenLocked) {
+            this.registered = registered;
+            this.allowWhenLocked = allowWhenLocked;
+        }
+    }
 
-    private HCEServiceCallback serviceCb;
+    // null until the JS side declares whether it has a background handler
+    private volatile BackgroundHandlerDeclaration backgroundHandlerDeclaration;
 
-    RTNHCEAndroidModule(ReactApplicationContext context) {
-        super(context);
+    // the activity for which HCEService is the preferred service, main thread only
+    @Nullable
+    private Activity preferredServiceActivity;
+
+    private final HeadlessJsTaskEventListener headlessJsTaskEventListener = new HeadlessJsTaskEventListener() {
+        @Override
+        public void onHeadlessJsTaskStart(int taskId) {
+            // nothing to do
+        }
+
+        @Override
+        public void onHeadlessJsTaskFinish(int taskId) {
+            HCEManager.getInstance().onHeadlessTaskFinished(RTNHCEAndroidModule.this, taskId);
+        }
+    };
+
+    /*
+     Android only allows setting the preferred service for a resumed activity
+     and the preference has to be removed once the activity is paused.
+     */
+    private final LifecycleEventListener lifecycleEventListener = new LifecycleEventListener() {
+        @Override
+        public void onHostResume() {
+            updatePreferredService(true);
+        }
 
-        this.serviceCb = null;
+        @Override
+        public void onHostPause() {
+            updatePreferredService(false);
+        }
 
-        this.sessionRunning = false;
-        this.hceRunning = false;
-        this.hceDeselected = true;
-        this.hceBrokenConnection = false;
-        this.hceBackgroundReady = false;
+        @Override
+        public void onHostDestroy() {
+            updatePreferredService(false);
+        }
+    };
+
+    RTNHCEAndroidModule(ReactApplicationContext context) {
+        super(context);
+        HeadlessJsTaskContext.getInstance(context).addTaskEventListener(headlessJsTaskEventListener);
+        context.addLifecycleEventListener(lifecycleEventListener);
     }
 
     @Override
     public void invalidate() {
-        Log.d(TAG, "RTNHCEAndroidModule:invalidate");
+        Log.d(TAG, "invalidate");
+        ReactApplicationContext context = getReactApplicationContext();
+        HeadlessJsTaskContext.getInstance(context).removeTaskEventListener(headlessJsTaskEventListener);
+        context.removeLifecycleEventListener(lifecycleEventListener);
+        HCEManager.getInstance().onModuleInvalidated(this);
+        UiThreadUtil.runOnUiThread(() -> updatePreferredService(false));
+        super.invalidate();
     }
 
     @Override
     @NonNull
     public String getName() {
-        Log.d(TAG, "RTNHCEAndroidModule:getName");
-        return RTNHCEAndroidModule.NAME;
+        return NAME;
     }
 
-    void sendEvent(final String type, final String arg) {
-        Log.d(TAG, "RTNHCEAndroidModule:sendEvent");
+    ReactApplicationContext getContext() {
+        return getReactApplicationContext();
+    }
 
-        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");
-        }
+    @Nullable
+    BackgroundHandlerDeclaration getBackgroundHandlerDeclaration() {
+        return backgroundHandlerDeclaration;
     }
 
-    void sendBackgroundEvent(final String audience, final String type, final String arg) {
-        Log.d(TAG, "RTNHCEAndroidModule:sendBackgroundEvent");
-
-        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");
+    @Nullable
+    private CardEmulation getCardEmulation() {
+        try {
+            NfcAdapter adapter = NfcAdapter.getDefaultAdapter(getReactApplicationContext());
+            return adapter != null ? CardEmulation.getInstance(adapter) : null;
+        } catch (RuntimeException e) {
+            // UnsupportedOperationException if the device doesn't support HCE
+            Log.w(TAG, "getCardEmulation: CardEmulation is not available", e);
+            return null;
         }
     }
 
-    boolean _isHCERunning() {
-        return this.hceRunning;
-    }
+    /**
+     * Make HCEService the preferred service while the app's activity is resumed and the foreground session
+     * has running emulation, so that it wins the routing of AIDs that other apps also have registered.
+     */
+    // main thread
+    private void updatePreferredService(boolean hostResumed) {
+        Activity activity = hostResumed ? getReactApplicationContext().getCurrentActivity() : null;
+        boolean wanted = activity != null && HCEManager.getInstance().hasRunningEmulation(this);
 
-    void setHCEBrokenConnection() {
-        this.hceBrokenConnection = true;
-    }
+        if (wanted && activity == preferredServiceActivity) {
+            return;
+        }
 
-    boolean isHCEBackgroundHandlerReady() {
-        return this.hceBackgroundReady;
-    }
+        CardEmulation cardEmulation = null;
+
+        if (preferredServiceActivity != null) {
+            cardEmulation = getCardEmulation();
+
+            try {
+                if (cardEmulation != null) {
+                    cardEmulation.unsetPreferredService(preferredServiceActivity);
+                }
+            } catch (RuntimeException e) {
+                // IllegalArgumentException if the activity isn't resumed anymore, the preference is gone anyway
+                Log.w(TAG, "updatePreferredService: unsetPreferredService() failed", e);
+            }
+
+            preferredServiceActivity = null;
+        }
 
-    boolean isHCEActiveConnection() {
-        return !this.hceBrokenConnection;
+        if (!wanted) {
+            return;
+        }
+
+        if (cardEmulation == null) {
+            cardEmulation = getCardEmulation();
+        }
+
+        if (cardEmulation == null) {
+            return;
+        }
+
+        try {
+            ComponentName service = new ComponentName(getReactApplicationContext(), HCEService.class);
+
+            if (cardEmulation.setPreferredService(activity, service)) {
+                preferredServiceActivity = activity;
+            } else {
+                Log.w(TAG, "updatePreferredService: setPreferredService() refused, is HCEService declared in the manifest?");
+            }
+        } catch (RuntimeException e) {
+            Log.w(TAG, "updatePreferredService: setPreferredService() failed", e);
+        }
     }
 
-    void setHCEService(HCEServiceCallback serviceCallback) {
-        Log.d(TAG, "RTNHCEAndroidModule:setHCEService");
+    private void refreshPreferredService() {
+        UiThreadUtil.runOnUiThread(() -> updatePreferredService(
+                getReactApplicationContext().getLifecycleState() == LifecycleState.RESUMED));
+    }
 
-        this.serviceCb = serviceCallback;
-        this.hceDeselected = true;
-        this.hceBackgroundReady = false;
-        this.hceBrokenConnection = false;
+    void emitEvent(String sessionId, String type) {
+        emitEvent(sessionId, type, 0, "", false, "");
     }
 
-    @Override
-    public boolean isPlatformSupported() {
-        Log.d(TAG, "RTNHCEAndroidModule:isPlatformSupported");
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
-            return false;
+    void emitEvent(String sessionId, String type, long apduId, String command, boolean deviceLocked, String reason) {
+        if (this.mEventEmitterCallback == null) {
+            Log.w(TAG, "emitEvent: missing event emitter, dropping " + type);
+            return;
         }
 
+        WritableMap map = Arguments.createMap();
+        map.putString("sessionId", sessionId);
+        map.putString("type", type);
+        map.putDouble("apduId", (double) apduId);
+        map.putString("command", command);
+        map.putBoolean("deviceLocked", deviceLocked);
+        map.putString("reason", reason);
+        emitOnEvent(map);
+    }
+
+    private boolean isHCESupported() {
         PackageManager pm = getReactApplicationContext().getPackageManager();
         return pm.hasSystemFeature(PackageManager.FEATURE_NFC)
                 && pm.hasSystemFeature(PackageManager.FEATURE_NFC_HOST_CARD_EMULATION);
     }
 
     @Override
-    public void acquireExclusiveNFC(Promise promise) {
-        Log.d(TAG, "RTNHCEAndroidModule:acquireExclusiveNFC");
-        promise.reject("err_platform_unsupported", "acquireExclusiveNFC() is not supported on Android.");
-    }
+    public void getCapabilities(Promise promise) {
+        boolean hceSupported = isHCESupported();
+        boolean nfcEnabled = false;
 
-    @Override
-    public void releaseExclusiveNFC() {
-        Log.d(TAG, "RTNHCEAndroidModule:releaseExclusiveNFC");
-        // unsupported on Android, no-op
-    }
+        try {
+            NfcAdapter adapter = NfcAdapter.getDefaultAdapter(getReactApplicationContext());
+            nfcEnabled = adapter != null && adapter.isEnabled();
+        } catch (RuntimeException e) {
+            Log.w(TAG, "getCapabilities: unable to check NFC adapter state", e);
+        }
 
-    @Override
-    public boolean isExclusiveNFC() {
-        Log.d(TAG, "RTNHCEAndroidModule:isExclusiveNFC");
-        // unsupported on Android, always false
-        return false;
+        WritableMap map = Arguments.createMap();
+        map.putString("platform", "android");
+        map.putBoolean("hceSupported", hceSupported);
+        map.putBoolean("nfcEnabled", nfcEnabled);
+        map.putBoolean("eligible", hceSupported);
+        map.putBoolean("backgroundSupported", hceSupported);
+        map.putBoolean("presentmentSupported", false);
+        promise.resolve(map);
     }
 
     @Override
-    public void beginSession(Promise promise) {
-        Log.d(TAG, "RTNHCEAndroidModule:beginSession");
-
-        if (!isPlatformSupported()) {
-            promise.reject("err_platform_unsupported", "Unsupported Android version or missing NFC/HCE feature.");
+    public void beginSession(String sessionId, boolean allowWhenLocked, Promise promise) {
+        if (!isHCESupported()) {
+            promise.reject("err_platform_unsupported", "The device doesn't support NFC host card emulation.");
             return;
         }
 
-        if (!this.sessionRunning) {
-            this.sessionRunning = true;
-            sendEvent("sessionStarted", "");
-            promise.resolve(null);
-        } else {
-            promise.reject("err_card_session_exists", "Session already exists.");
+        try {
+            HCEManager.getInstance().beginSession(this, sessionId, allowWhenLocked);
+        } catch (IllegalStateException e) {
+            promise.reject("err_session_exists", "A session already exists.");
+            return;
         }
-    }
 
-    @Override
-    public void setSessionAlertMessage(String message) {
-        Log.d(TAG, "RTNHCEAndroidModule:setSessionAlertMessage");
-        // unsupported on Android, no-op
+        promise.resolve(null);
     }
 
     @Override
-    public void invalidateSession() {
-        Log.d(TAG, "RTNHCEAndroidModule:invalidateSession");
-        if (this.sessionRunning) {
-            this.hceRunning = false;
-            this.sessionRunning = false;
-            this.hceBrokenConnection = true;
-            sendEvent("sessionInvalidated", "userInvalidated");
-        }
+    public void invalidateSession(String sessionId) {
+        HCEManager.getInstance().invalidateSession(this, sessionId);
+        refreshPreferredService();
     }
 
     @Override
-    public boolean isSessionRunning() {
-        Log.d(TAG, "RTNHCEAndroidModule:isSessionRunning");
-        return this.sessionRunning;
+    public void setSessionAlertMessage(String sessionId, String message) {
+        // unsupported on Android, no-op
     }
 
     @Override
-    public boolean beginBackgroundHCE(String handle) {
-        Log.d(TAG, "RTNHCEAndroidModule:beginBackgroundHCE");
-
+    public void startEmulation(String sessionId, Promise promise) {
         try {
-            this.serviceCb.onBackgroundHCEInit(handle);
+            HCEManager.getInstance().startEmulation(this, sessionId);
         } catch (IllegalStateException e) {
-            return false;
+            promise.reject("err_no_session", "The session is not active.");
+            return;
         }
 
-        this.hceBackgroundReady = true;
-        return true;
+        refreshPreferredService();
+        promise.resolve(null);
     }
 
     @Override
-    public boolean finishBackgroundHCE(String handle) {
-        Log.d(TAG, "RTNHCEAndroidModule:finishBackgroundHCE");
-
+    public void stopEmulation(String sessionId, String status, Promise promise) {
         try {
-            this.serviceCb.onBackgroundHCEFinish(handle);
+            HCEManager.getInstance().stopEmulation(this, sessionId);
         } catch (IllegalStateException e) {
-            return false;
+            promise.reject("err_no_session", "The session is not active.");
+            return;
         }
 
-        return true;
+        refreshPreferredService();
+        promise.resolve(null);
     }
 
     @Override
-    public void startHCE(Promise promise) {
-        Log.d(TAG, "RTNHCEAndroidModule:startHCE");
-        if (!this.sessionRunning) {
-            promise.reject("err_no_session", "No session is active.");
-            return;
-        }
-
-        if (this.hceRunning) {
-            promise.reject("err_start_emulation", "Error trying to start emulation. Emulation already started.");
-            return;
-        }
-
-        this.hceRunning = true;
-        this.hceBrokenConnection = false;
-        promise.resolve(null);
+    public void isEmulationRunning(String sessionId, Promise promise) {
+        promise.resolve(HCEManager.getInstance().isEmulationRunning(this, sessionId));
     }
 
     @Override
-    public void stopHCE(String status, Promise promise) {
-        Log.d(TAG, "RTNHCEAndroidModule:stopHCE");
-        if (!this.sessionRunning) {
-            promise.reject("err_no_session", "No session is active.");
+    public void respondApdu(String sessionId, double apduId, String rapdu, Promise promise) {
+        byte[] response;
+
+        try {
+            response = BinaryUtils.HexStringToByteArray(rapdu);
+        } catch (IllegalArgumentException e) {
+            promise.reject("err_invalid_rapdu", "The R-APDU is not a valid hex-encoded string.");
             return;
         }
 
-        if (this.hceRunning) {
-            this.hceRunning = false;
+        if (response.length < 2) {
+            promise.reject("err_invalid_rapdu", "The R-APDU must contain at least the status word.");
+            return;
+        }
 
-            if (!this.hceDeselected) {
-                this.hceDeselected = true;
-                this.hceBrokenConnection = true;
-                sendEvent("readerDeselected", "");
-            }
+        try {
+            HCEManager.getInstance().respondApdu(this, sessionId, (long) apduId, response);
+        } catch (IllegalStateException e) {
+            promise.reject("err_stale_apdu", "The C-APDU is not awaiting a response (reader lost or session closed).");
+            return;
         }
 
         promise.resolve(null);
     }
 
-    @RequiresApi(api = Build.VERSION_CODES.N)
     @Override
-    public void respondAPDU(String handle, String rapdu, Promise promise) {
-        Log.d(TAG, "RTNHCEAndroidModule:respondAPDU");
-
-        if (!this.hceBackgroundReady) {
-            if (!this.sessionRunning) {
-                promise.reject("err_no_session", "No session is active.");
-                return;
-            } else if (!this.hceRunning) {
-                promise.reject("err_no_hce", "HCE is not running.");
-                return;
-            }
-        }
+    public void acquireExclusiveNFC(Promise promise) {
+        promise.reject("err_platform_unsupported", "acquireExclusiveNFC() is not supported on Android.");
+    }
 
-        Log.d(TAG, "respondAPDU(): Send to service");
+    @Override
+    public void releaseExclusiveNFC() {
+        // unsupported on Android, no-op
+    }
 
-        try {
-            serviceCb.onRespondAPDU(handle, rapdu);
-        } catch (IllegalStateException e) {
-            promise.reject("err_illegal_state", "There is no C-APDU to respond to at the time or the provided handle is invalid.");
-            return;
-        }
+    @Override
+    public boolean isExclusiveNFC() {
+        // unsupported on Android, always false
+        return false;
+    }
 
-        promise.resolve(null);
+    @Override
+    public void setBackgroundHandlerRegistered(boolean registered, boolean allowWhenLocked) {
+        this.backgroundHandlerDeclaration = new BackgroundHandlerDeclaration(registered, allowWhenLocked);
+        UiThreadUtil.runOnUiThread(() -> HCEManager.getInstance().onBackgroundHandlerDeclared(this));
     }
 
     @Override
-    public void isHCERunning(Promise promise) {
-        Log.d(TAG, "RTNHCEAndroidModule:isHCERunning");
-        promise.resolve(this.hceRunning);
+    public boolean backgroundSessionReady(String sessionId) {
+        return HCEManager.getInstance().backgroundSessionReady(this, sessionId);
     }
 }

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

@@ -1,8 +1,9 @@
 package com.itsecrnd.rtnhceandroid;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
-import com.facebook.react.TurboReactPackage;
+import com.facebook.react.BaseReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.module.model.ReactModuleInfo;
@@ -11,10 +12,10 @@ import com.facebook.react.module.model.ReactModuleInfoProvider;
 import java.util.HashMap;
 import java.util.Map;
 
-public class RTNHCEAndroidPackage extends TurboReactPackage {
+public class RTNHCEAndroidPackage extends BaseReactPackage {
     @Nullable
     @Override
-    public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    public NativeModule getModule(@NonNull String name, @NonNull ReactApplicationContext reactContext) {
         if (name.equals(RTNHCEAndroidModule.NAME)) {
             return new RTNHCEAndroidModule(reactContext);
         } else {
@@ -22,6 +23,7 @@ public class RTNHCEAndroidPackage extends TurboReactPackage {
         }
     }
 
+    @NonNull
     @Override
     public ReactModuleInfoProvider getReactModuleInfoProvider() {
         return () -> {
@@ -33,7 +35,6 @@ public class RTNHCEAndroidPackage extends TurboReactPackage {
                             RTNHCEAndroidModule.NAME,
                             false, // canOverrideExistingModule
                             false, // needsEagerInit
-                            true, // hasConstants
                             false, // isCxxModule
                             true // isTurboModule
                     ));