capacitor-plugin-faceantispoofing 0.0.1

package/CapacitorPluginFaceantispoofing.podspec

@@ -0,0 +1,20 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorPluginFaceantispoofing'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.resource_bundles = {'CapacitorPluginFaceantispoofing' => ['ios/Sources/**/*.tflite']}
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.dependency 'TensorFlowLiteSwift', '~> 2.17.0'
+  s.dependency 'TensorFlowLiteC', '~> 2.17.0'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapacitorPluginFaceantispoofing",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CapacitorPluginFaceantispoofing",
+            targets: ["FaceAntiSpoofingPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
+    ],
+    targets: [
+        .target(
+            name: "FaceAntiSpoofingPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/FaceAntiSpoofingPlugin"),
+        .testTarget(
+            name: "FaceAntiSpoofingPluginTests",
+            dependencies: ["FaceAntiSpoofingPlugin"],
+            path: "ios/Tests/FaceAntiSpoofingPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,175 @@
+# capacitor-plugin-faceantispoofing
+
+Capacitor plugin for Passive Liveness Detection and Face Anti-Spoofing using TensorFlow Lite models.
+
+This plugin has been migrated from [cordova-plugin-facespoofing](https://github.com/rakaraka029/cordova-plugin-facespoofing).
+
+## Features
+
+- **Face Detection**: Uses MTCNN (Multi-task Cascaded Convolutional Networks) for accurate face detection
+- **Anti-Spoofing Detection**: Passive liveness detection using TensorFlow Lite models
+- **Blur Detection**: Laplacian variance-based image quality assessment
+- **Cross-Platform**: Support for both Android and iOS
+
+## Install
+
+### Using npm
+
+```bash
+npm install capacitor-plugin-faceantispoofing
+npx cap sync
+```
+
+### Using yarn
+
+```bash
+yarn add capacitor-plugin-faceantispoofing
+npx cap sync
+```
+
+## Usage
+
+```typescript
+import { FaceAntiSpoofing } from 'capacitor-plugin-faceantispoofing';
+
+// Detect face liveness from base64 image
+const detectLiveness = async (base64Image: string) => {
+  try {
+    const result = await FaceAntiSpoofing.detect({
+      image: base64Image  // Base64 encoded image (without data:image/...;base64, prefix)
+    });
+
+    console.log('Error:', result.error);
+    console.log('Liveness:', result.liveness);
+    console.log('Score:', result.score);
+    console.log('Threshold:', result.threshold);
+    console.log('Message:', result.message);
+
+    if (result.liveness) {
+      console.log('Real face detected!');
+    } else {
+      console.log('Spoof detected or no face found!');
+    }
+  } catch (error) {
+    console.error('Detection failed:', error);
+  }
+};
+```
+
+## API
+
+### `detect(options)`
+
+Detects face liveness and performs anti-spoofing detection on the provided image.
+
+| Param        | Type                          | Description                                        |
+| ------------ | ----------------------------- | -------------------------------------------------- |
+| **options**  | `<DetectOptions>`             | Options for the detection                          |
+| **image**    | `<string>`                    | Base64 encoded image data or file URI              |
+
+**Returns:** `Promise<DetectionResult>`
+
+### DetectOptions
+
+| Prop    | Type                | Description                              |
+| ------- | ------------------- | ---------------------------------------- |
+| image   | `string`            | Base64 encoded image (without `data:image/...;base64,` prefix) or file URI starting with `file://` |
+
+### DetectionResult
+
+| Prop      | Type                | Description                              |
+| --------- | ------------------- | ---------------------------------------- |
+| error     | `boolean`           | Whether an error occurred                |
+| liveness  | `boolean`           | Whether the face is detected as real     |
+| score     | `string`            | The liveness score                       |
+| threshold | `string`            | The threshold used for classification    |
+| message   | `string`            | Additional information message           |
+
+## Detection Flow
+
+1. **Face Detection**: Uses MTCNN (P-Net → R-Net → O-Net) to detect faces in the image
+2. **Face Alignment**: Aligns the detected face based on facial landmarks
+3. **Blur Detection**: Checks image clarity using Laplacian variance
+4. **Anti-Spoofing**: If image is clear enough, runs the anti-spoofing model to classify as real or fake
+
+## Response Values
+
+- **No faces detected**: `error: true`, `message: "No faces detected"`
+- **Image too blurry**: `error: false`, `liveness: false`, score contains Laplacian value
+- **Real face detected**: `error: false`, `liveness: true`, score < threshold
+- **Spoof detected**: `error: false`, `liveness: false`, score >= threshold
+
+## Platform Support
+
+| Platform | Supported |
+| -------- | --------- |
+| Android  | ✅ Yes     |
+| iOS      | ✅ Yes     |
+| Web      | ❌ No*     |
+
+*Web is not supported as native TensorFlow Lite is required.
+
+## Dependencies
+
+### Android
+- Google AI Edge LITErt (TensorFlow Lite) 1.4.0
+- minSdkVersion: 24
+- compileSdkVersion: 36
+
+### iOS
+- TensorFlowLiteSwift ~ 2.17.0
+- TensorFlowLiteC ~ 2.17.0
+- iOS Deployment Target: 15.0
+
+## Model Files
+
+This plugin includes the following TensorFlow Lite models:
+
+- `FaceAntiSpoofing.tflite` - Anti-spoofing classification model
+- `pnet.tflite` - MTCNN Proposal Network
+- `rnet.tflite` - MTCNN Refine Network
+- `onet.tflite` - MTCNN Output Network
+
+## Threshold Values
+
+- **Android**: THRESHOLD = 0.5, LAPLACIAN_THRESHOLD = 0
+- **iOS**: threshold = 0.5, laplacianThreshold = 0
+
+Note: These values have been normalized from the original Cordova plugin.
+
+## Example Image Format
+
+The plugin accepts images in the following formats:
+
+1. **Base64 without prefix**: `iVBORw0KGgoAAAANSUhEUgAA...`
+2. **Base64 with data URI**: `data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...`
+3. **File URI**: `file:///path/to/image.png`
+
+## Error Handling
+
+```typescript
+try {
+  const result = await FaceAntiSpoofing.detect({ image: base64Data });
+
+  if (result.error) {
+    console.error('Detection error:', result.message);
+    return;
+  }
+
+  if (result.liveness) {
+    // Real face detected
+  } else {
+    // Spoof or no face detected
+  }
+} catch (e) {
+  console.error('Plugin error:', e);
+}
+```
+
+## License
+
+MIT
+
+## Credits
+
+Originally based on [cordova-plugin-facespoofing](https://github.com/rakaraka029/cordova-plugin-facespoofing) by rakaraka029.

package/android/build.gradle

@@ -0,0 +1,64 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "io.github.asephermann.plugins.faceantispoofing"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+    aaptOptions {
+        noCompress "tflite"
+        noCompress "lite"
+    }
+}
+
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+    implementation 'com.google.ai.edge.litert:litert:1.4.0'
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/io/github/asephermann/plugins/faceantispoofing/FaceAntiSpoofing.java

@@ -0,0 +1,112 @@
+package io.github.asephermann.plugins.faceantispoofing;
+
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.util.Log;
+
+import com.google.ai.edge.litert.Interpreter;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class FaceAntiSpoofing {
+    private static final String MODEL_FILE = "FaceAntiSpoofing.tflite";
+
+    public static final int INPUT_IMAGE_SIZE = 256;
+    public static final float THRESHOLD = 0.5f;
+    public static final int ROUTE_INDEX = 6;
+    public static final int LAPLACE_THRESHOLD = 50;
+    public static final int LAPLACIAN_THRESHOLD = 0;
+
+    private Interpreter interpreter;
+
+    public FaceAntiSpoofing(AssetManager assetManager) throws IOException {
+        Interpreter.Options options = new Interpreter.Options();
+        options.setNumThreads(4);
+        interpreter = new Interpreter(MyUtil.loadModelFile(assetManager, MODEL_FILE), options);
+    }
+
+    public float antiSpoofing(Bitmap bitmap) {
+        Bitmap bitmapScale = Bitmap.createScaledBitmap(bitmap, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE, true);
+
+        float[][][] img = normalizeImage(bitmapScale);
+        float[][][][] input = new float[1][][][];
+        input[0] = img;
+        float[][] clss_pred = new float[1][8];
+        float[][] leaf_node_mask = new float[1][8];
+        Map<Integer, Object> outputs = new HashMap<>();
+        outputs.put(interpreter.getOutputIndex("Identity"), clss_pred);
+        outputs.put(interpreter.getOutputIndex("Identity_1"), leaf_node_mask);
+        interpreter.runForMultipleInputsOutputs(new Object[]{input}, outputs);
+
+        Log.i("FaceAntiSpoofing", "[" + clss_pred[0][0] + ", " + clss_pred[0][1] + ", "
+                + clss_pred[0][2] + ", " + clss_pred[0][3] + ", " + clss_pred[0][4] + ", "
+                + clss_pred[0][5] + ", " + clss_pred[0][6] + ", " + clss_pred[0][7] + "]");
+        Log.i("FaceAntiSpoofing", "[" + leaf_node_mask[0][0] + ", " + leaf_node_mask[0][1] + ", "
+                + leaf_node_mask[0][2] + ", " + leaf_node_mask[0][3] + ", " + leaf_node_mask[0][4] + ", "
+                + leaf_node_mask[0][5] + ", " + leaf_node_mask[0][6] + ", " + leaf_node_mask[0][7] + "]");
+
+        return leaf_score1(clss_pred, leaf_node_mask);
+    }
+
+    private float leaf_score1(float[][] clss_pred, float[][] leaf_node_mask) {
+        float score = 0;
+        for (int i = 0; i < 8; i++) {
+            score += Math.abs(clss_pred[0][i]) * leaf_node_mask[0][i];
+        }
+        return score;
+    }
+
+    private float leaf_score2(float[][] clss_pred) {
+        return clss_pred[0][ROUTE_INDEX];
+    }
+
+    public static float[][][] normalizeImage(Bitmap bitmap) {
+        int h = bitmap.getHeight();
+        int w = bitmap.getWidth();
+        float[][][] floatValues = new float[h][w][3];
+
+        float imageStd = 255;
+        int[] pixels = new int[h * w];
+        bitmap.getPixels(pixels, 0, bitmap.getWidth(), 0, 0, w, h);
+        for (int i = 0; i < h; i++) {
+            for (int j = 0; j < w; j++) {
+                final int val = pixels[i * w + j];
+                float r = ((val >> 16) & 0xFF) / imageStd;
+                float g = ((val >> 8) & 0xFF) / imageStd;
+                float b = (val & 0xFF) / imageStd;
+
+                float[] arr = {r, g, b};
+                floatValues[i][j] = arr;
+            }
+        }
+        return floatValues;
+    }
+
+    public int laplacian(Bitmap bitmap) {
+        Bitmap bitmapScale = Bitmap.createScaledBitmap(bitmap, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE, true);
+
+        int[][] laplace = {{0, 1, 0}, {1, -4, 1}, {0, 1, 0}};
+        int size = laplace.length;
+        int[][] img = MyUtil.convertGreyImg(bitmapScale);
+        int height = img.length;
+        int width = img[0].length;
+
+        int score = 0;
+        for (int x = 0; x < height - size + 1; x++){
+            for (int y = 0; y < width - size + 1; y++){
+                int result = 0;
+                for (int i = 0; i < size; i++){
+                    for (int j = 0; j < size; j++){
+                        result += (img[x + i][y + j] & 0xFF) * laplace[i][j];
+                    }
+                }
+                if (result > LAPLACE_THRESHOLD) {
+                    score++;
+                }
+            }
+        }
+        return score;
+    }
+}

package/android/src/main/java/io/github/asephermann/plugins/faceantispoofing/FaceAntiSpoofingPlugin.java

@@ -0,0 +1,178 @@
+package io.github.asephermann.plugins.faceantispoofing;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.util.Base64;
+import android.util.Log;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Vector;
+
+import io.github.asephermann.plugins.faceantispoofing.mtcnn.Align;
+import io.github.asephermann.plugins.faceantispoofing.mtcnn.Box;
+import io.github.asephermann.plugins.faceantispoofing.mtcnn.MTCNN;
+
+@CapacitorPlugin(name = "FaceAntiSpoofing")
+public class FaceAntiSpoofingPlugin extends Plugin {
+
+    private static final String TAG = "FaceAntiSpoofing";
+
+    private FaceAntiSpoofing faceAntiSpoofing;
+    private MTCNN mtcnn;
+
+    @Override
+    public void load() {
+        super.load();
+        try {
+            faceAntiSpoofing = new FaceAntiSpoofing(getContext().getAssets());
+            mtcnn = new MTCNN(getContext().getAssets());
+            Log.d(TAG, "Models loaded successfully");
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to load models", e);
+        }
+    }
+
+    @PluginMethod
+    public void detect(PluginCall call) {
+        String image = call.getString("image");
+
+        if (image == null || image.isEmpty()) {
+            call.reject("Image data is required");
+            return;
+        }
+
+        if (faceAntiSpoofing == null || mtcnn == null) {
+            call.reject("Models not loaded. Please ensure the plugin is properly initialized.");
+            return;
+        }
+
+        try {
+            Bitmap bitmap = decodeImage(image);
+            if (bitmap == null) {
+                call.reject("Failed to decode image");
+                return;
+            }
+
+            DetectionResult result = performAntiSpoofing(bitmap);
+            call.resolve(resultToJSObject(result));
+        } catch (Exception e) {
+            Log.e(TAG, "Error during detection", e);
+            call.reject("Error during detection: " + e.getMessage());
+        }
+    }
+
+    private Bitmap decodeImage(String imageData) throws IOException {
+        // Check if it's a base64 string or file path
+        if (imageData.startsWith("data:image/")) {
+            // Remove data URI prefix if present
+            int commaIndex = imageData.indexOf(',');
+            if (commaIndex != -1) {
+                imageData = imageData.substring(commaIndex + 1);
+            }
+            byte[] decodedString = Base64.decode(imageData, Base64.DEFAULT);
+            return BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
+        } else if (imageData.startsWith("file://")) {
+            String filePath = imageData.substring(7);
+            File file = new File(filePath);
+            if (file.exists()) {
+                FileInputStream fis = new FileInputStream(file);
+                Bitmap bitmap = BitmapFactory.decodeStream(fis);
+                fis.close();
+                return bitmap;
+            }
+        } else {
+            // Try as base64
+            byte[] decodedString = Base64.decode(imageData, Base64.DEFAULT);
+            return BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
+        }
+        return null;
+    }
+
+    private DetectionResult performAntiSpoofing(Bitmap bitmap) {
+        DetectionResult result = new DetectionResult();
+
+        if (bitmap == null) {
+            result.error = true;
+            result.message = "Please detect face first";
+            return result;
+        }
+
+        Bitmap bitmapTemp1 = bitmap.copy(bitmap.getConfig(), false);
+        Vector<Box> boxes1 = mtcnn.detectFaces(bitmapTemp1, bitmapTemp1.getWidth() / 8);
+
+        if (boxes1.size() == 0) {
+            result.error = true;
+            result.message = "No faces detected";
+            return result;
+        }
+
+        Box box1 = boxes1.get(0);
+        bitmapTemp1 = Align.face_align(bitmapTemp1, box1.landmark);
+        boxes1 = mtcnn.detectFaces(bitmapTemp1, bitmapTemp1.getWidth() / 8);
+
+        if (boxes1.size() == 0) {
+            result.error = true;
+            result.message = "No faces detected";
+            return result;
+        }
+
+        box1 = boxes1.get(0);
+        box1.toSquareShape();
+        box1.limitSquare(bitmapTemp1.getWidth(), bitmapTemp1.getHeight());
+        android.graphics.Rect rect1 = box1.transform2Rect();
+        Bitmap bitmapCrop1 = MyUtil.crop(bitmapTemp1, rect1);
+
+        int laplace2 = faceAntiSpoofing.laplacian(bitmapCrop1);
+
+        if (laplace2 < FaceAntiSpoofing.LAPLACIAN_THRESHOLD) {
+            result.error = false;
+            result.score = String.valueOf(laplace2);
+            result.threshold = String.valueOf(FaceAntiSpoofing.LAPLACIAN_THRESHOLD);
+            result.liveness = false;
+            result.message = "";
+        } else {
+            float score2 = faceAntiSpoofing.antiSpoofing(bitmapCrop1);
+            if (score2 < FaceAntiSpoofing.THRESHOLD) {
+                result.error = false;
+                result.score = String.valueOf(score2);
+                result.threshold = String.valueOf(FaceAntiSpoofing.THRESHOLD);
+                result.liveness = true;
+                result.message = "";
+            } else {
+                result.error = false;
+                result.score = String.valueOf(score2);
+                result.threshold = String.valueOf(FaceAntiSpoofing.THRESHOLD);
+                result.liveness = false;
+                result.message = "Sorry, we can't find a face or indicate that the photo is real.";
+            }
+        }
+
+        return result;
+    }
+
+    private JSObject resultToJSObject(DetectionResult result) {
+        JSObject jsObject = new JSObject();
+        jsObject.put("error", result.error);
+        jsObject.put("liveness", result.liveness);
+        jsObject.put("score", result.score);
+        jsObject.put("threshold", result.threshold);
+        jsObject.put("message", result.message);
+        return jsObject;
+    }
+
+    private static class DetectionResult {
+        boolean error = false;
+        boolean liveness = false;
+        String score = "0";
+        String threshold = "0";
+        String message = "";
+    }
+}