react-native-vision-camera-spoof-detector 1.0.5 → 1.0.7

package/android/src/main/java/com/faceantispoof/ImageFormatEncoder.kt

@@ -8,9 +8,11 @@ import java.io.ByteArrayOutputStream
 
 /**
  * Multi-format image encoder supporting JPEG, PNG, and BMP.
- * Handles RGB data conversion to various image formats for compatibility
+ * Handles BGR data conversion (OpenCV compatible) to various image formats for compatibility
  * with face recognition systems (OpenCV cv2.imdecode compatible).
  *
+ * NOTE: Converts RGB input to BGR format as required by OpenCV and FastAPI server
+ *
  * Supported formats:
  * - JPEG: Compressed, good for network transmission (~80-100 KB at quality 85)
  * - PNG: Lossless, larger file size (~200-300 KB)
@@ -36,15 +38,17 @@ object ImageFormatEncoder {
         }
 
         /**
-         * Convert RGB data to specified image format and return as Base64 string.
-         * Compatible with OpenCV cv2.imdecode() for face recognition systems.
+         * Convert RGB data to BGR format (OpenCV compatible) and encode to specified image format.
+         * Returns Base64 string compatible with FastAPI server.
+         *
+         * IMPORTANT: This method performs RGB→BGR conversion required by OpenCV cv2.imdecode()
          *
          * @param rgbData RGB data as byte array (format: RGBRGBRGB..., 3 channels)
          * @param width Image width (pixels)
          * @param height Image height (pixels)
          * @param format Target image format (JPEG, PNG, BMP)
          * @param quality Compression quality for JPEG (0-100), ignored for PNG/BMP
-         * @return Base64 encoded image string, or null if encoding fails
+         * @return Base64 encoded image string in BGR color space, or null if encoding fails
          */
         fun rgbToBase64(
             rgbData: ByteArray,
@@ -57,18 +61,22 @@ object ImageFormatEncoder {
                 validateImageDimensions(width, height)
                 validateRgbData(rgbData, width, height)
 
-                val imageBytes = rgbToImageBytes(rgbData, width, height, format, quality)
+                // CRITICAL: Convert RGB to BGR for OpenCV compatibility
+                val bgrData = rgbToBgr(rgbData)
+
+                val imageBytes = bgrToImageBytes(bgrData, width, height, format, quality)
                     ?: return null
 
                 Base64.encodeToString(imageBytes, Base64.NO_WRAP)
             } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB to ${format.name} Base64: ${e.message}", e)
+                Log.e(TAG, "Failed to convert RGB to BGR ${format.name} Base64: ${e.message}", e)
                 null
             }
         }
 
         /**
          * Convert RGB float array (normalized 0-1) to image format and return as Base64.
+         * Performs RGB→BGR conversion for OpenCV compatibility.
          * Each pixel is stored as 3 floats (R, G, B).
          *
          * @param rgbFloats RGB data as float array (normalized to 0-1)
@@ -76,7 +84,7 @@ object ImageFormatEncoder {
          * @param height Image height
          * @param format Target image format
          * @param quality Compression quality for JPEG
-         * @return Base64 encoded image string
+         * @return Base64 encoded image string in BGR format
          */
         fun rgbFloatToBase64(
             rgbFloats: FloatArray,
@@ -88,29 +96,46 @@ object ImageFormatEncoder {
             return try {
                 validateImageDimensions(width, height)
 
+                if (rgbFloats.isEmpty()) {
+                    Log.e(TAG, "RGB float array is empty")
+                    return null
+                }
+
+                val expectedSize = width * height * 3
+                if (rgbFloats.size < expectedSize) {
+                    Log.e(TAG, "RGB float array too small: expected $expectedSize, got ${rgbFloats.size}")
+                    return null
+                }
+
                 // Convert float array (normalized 0-1) to byte array (0-255)
-                val rgbBytes = ByteArray(width * height * 3)
+                val rgbBytes = ByteArray(expectedSize)
                 var idx = 0
-                for (i in rgbFloats.indices) {
-                    rgbBytes[idx++] = (rgbFloats[i] * 255f).toInt().coerceIn(0, 255).toByte()
+                for (i in 0 until expectedSize) {
+                    if (idx >= rgbFloats.size) {
+                        Log.e(TAG, "Float array index out of bounds at $idx")
+                        return null
+                    }
+                    val floatVal = rgbFloats[idx++].coerceIn(0f, 1f)
+                    rgbBytes[i] = (floatVal * 255f).toInt().coerceIn(0, 255).toByte()
                 }
 
                 rgbToBase64(rgbBytes, width, height, format, quality)
             } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB float to ${format.name} Base64: ${e.message}", e)
+                Log.e(TAG, "Failed to convert RGB float to BGR ${format.name} Base64: ${e.message}", e)
                 null
             }
         }
 
         /**
          * Convert RGB data to raw image bytes (not Base64).
+         * Performs RGB→BGR conversion for OpenCV compatibility.
          *
          * @param rgbData RGB data as byte array
          * @param width Image width
          * @param height Image height
          * @param format Target image format
          * @param quality Compression quality for JPEG
-         * @return Raw image bytes, or null if encoding fails
+         * @return Raw image bytes in BGR format, or null if encoding fails
          */
         fun rgbToImageBytes(
             rgbData: ByteArray,
@@ -123,16 +148,12 @@ object ImageFormatEncoder {
                 validateImageDimensions(width, height)
                 validateRgbData(rgbData, width, height)
 
-                val bitmap = createBitmapFromRgb(rgbData, width, height)
-                val imageBytes = when (format) {
-                    ImageFormat.JPEG -> compressBitmapToBytes(bitmap, format, quality)
-                    ImageFormat.PNG -> compressBitmapToBytes(bitmap, format, 100)
-                    ImageFormat.BMP -> compressBitmapToBytes(bitmap, format, 100)
-                }
-                bitmap.recycle()
-                imageBytes
+                // CRITICAL: Convert RGB to BGR for OpenCV compatibility
+                val bgrData = rgbToBgr(rgbData)
+
+                bgrToImageBytes(bgrData, width, height, format, quality)
             } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB to ${format.name} bytes: ${e.message}", e)
+                Log.e(TAG, "Failed to convert RGB to BGR ${format.name} bytes: ${e.message}", e)
                 null
             }
         }
@@ -196,21 +217,164 @@ object ImageFormatEncoder {
 
         // ============ Private Helper Methods ============
 
+        /**
+         * Convert RGB byte array to BGR for OpenCV compatibility.
+         * CRITICAL: OpenCV expects BGR format, not RGB.
+         * 
+         * @param rgbData RGB data in format RGBRGBRGB...
+         * @return BGR data in format BGRBGRBGR...
+         */
+        private fun rgbToBgr(rgbData: ByteArray): ByteArray {
+            val bgrData = ByteArray(rgbData.size)
+            var rgbIdx = 0
+            var bgrIdx = 0
+            
+            while (rgbIdx < rgbData.size && rgbIdx + 2 < rgbData.size) {
+                val r = rgbData[rgbIdx++]
+                val g = rgbData[rgbIdx++]
+                val b = rgbData[rgbIdx++]
+                
+                // Swap: BGR order
+                bgrData[bgrIdx++] = b
+                bgrData[bgrIdx++] = g
+                bgrData[bgrIdx++] = r
+            }
+            
+            Log.d(TAG, "Converted RGB to BGR: ${rgbData.size} bytes")
+            return bgrData
+        }
+
+        /**
+         * Convert BGR data to raw image bytes (not Base64).
+         * BGR data is already in OpenCV format.
+         *
+         * @param bgrData BGR data as byte array (already in OpenCV format)
+         * @param width Image width
+         * @param height Image height
+         * @param format Target image format
+         * @param quality Compression quality for JPEG
+         * @return Raw image bytes, or null if encoding fails
+         */
+        private fun bgrToImageBytes(
+            bgrData: ByteArray,
+            width: Int,
+            height: Int,
+            format: ImageFormat = ImageFormat.JPEG,
+            quality: Int = 85
+        ): ByteArray? {
+            return try {
+                validateImageDimensions(width, height)
+                
+                if (bgrData.size < width * height * 3) {
+                    Log.e(TAG, "BGR data too small: expected ${width * height * 3}, got ${bgrData.size}")
+                    return null
+                }
+
+                val bitmap = createBitmapFromBgr(bgrData, width, height)
+                    ?: return null
+                    
+                val imageBytes = try {
+                    when (format) {
+                        ImageFormat.JPEG -> compressBitmapToBytes(bitmap, format, quality)
+                        ImageFormat.PNG -> compressBitmapToBytes(bitmap, format, 100)
+                        ImageFormat.BMP -> compressBitmapToBytes(bitmap, format, 100)
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error compressing bitmap: ${e.message}", e)
+                    null
+                } finally {
+                    try {
+                        bitmap.recycle()
+                    } catch (e: Exception) {
+                        Log.w(TAG, "Error recycling bitmap: ${e.message}")
+                    }
+                }
+                
+                imageBytes
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to convert BGR to ${format.name} bytes: ${e.message}", e)
+                null
+            }
+        }
+
+        /**
+         * Create Bitmap from BGR byte array (OpenCV format).
+         * BGR format: BGRBGRBGR... (3 bytes per pixel, no alpha)
+         */
+        private fun createBitmapFromBgr(bgrData: ByteArray, width: Int, height: Int): Bitmap? {
+            return try {
+                if (bgrData.isEmpty()) {
+                    Log.e(TAG, "BGR data is empty")
+                    return null
+                }
+                if (width <= 0 || height <= 0) {
+                    Log.e(TAG, "Invalid dimensions: width=$width, height=$height")
+                    return null
+                }
+                
+                val expectedSize = width * height * 3
+                if (bgrData.size < expectedSize) {
+                    Log.e(TAG, "BGR data too small: expected at least $expectedSize, got ${bgrData.size}")
+                    return null
+                }
+                
+                // Convert BGR to ARGB for Bitmap (Android uses ARGB_8888)
+                // BGR order: B, G, R
+                val pixels = IntArray(width * height)
+                var bgrIdx = 0
+                for (i in pixels.indices) {
+                    if (bgrIdx + 2 >= bgrData.size) {
+                        Log.e(TAG, "BGR buffer index out of bounds at pixel $i")
+                        return null
+                    }
+                    val b = bgrData[bgrIdx++].toInt() and 0xFF
+                    val g = bgrData[bgrIdx++].toInt() and 0xFF
+                    val r = bgrData[bgrIdx++].toInt() and 0xFF
+                    pixels[i] = 0xFF000000.toInt() or (r shl 16) or (g shl 8) or b  // ARGB
+                }
+                
+                val bitmap = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
+                if (bitmap == null) {
+                    Log.e(TAG, "Failed to create bitmap from BGR")
+                    return null
+                }
+                bitmap
+            } catch (e: Exception) {
+                Log.e(TAG, "Error creating bitmap from BGR: ${e.message}", e)
+                null
+            }
+        }
+
         /**
          * Create Bitmap from RGB byte array.
          * RGB format: RGBRGBRGB... (3 bytes per pixel, no alpha)
+         * DEPRECATED: Use createBitmapFromBgr instead for OpenCV compatibility
          */
-        private fun createBitmapFromRgb(rgbData: ByteArray, width: Int, height: Int): Bitmap {
-            // Convert RGB to ARGB for Bitmap (Android uses ARGB_8888)
-            val pixels = IntArray(width * height)
-            var rgbIdx = 0
-            for (i in pixels.indices) {
-                val r = rgbData[rgbIdx++].toInt() and 0xFF
-                val g = rgbData[rgbIdx++].toInt() and 0xFF
-                val b = rgbData[rgbIdx++].toInt() and 0xFF
-                pixels[i] = 0xFF000000.toInt() or (r shl 16) or (g shl 8) or b  // ARGB
+        @Deprecated("Use createBitmapFromBgr for OpenCV compatibility")
+        private fun createBitmapFromRgb(rgbData: ByteArray, width: Int, height: Int): Bitmap? {
+            return try {
+                if (rgbData.isEmpty()) {
+                    Log.e(TAG, "RGB data is empty")
+                    return null
+                }
+                if (width <= 0 || height <= 0) {
+                    Log.e(TAG, "Invalid dimensions: width=$width, height=$height")
+                    return null
+                }
+                
+                val expectedSize = width * height * 3
+                if (rgbData.size < expectedSize) {
+                    Log.e(TAG, "RGB data too small: expected at least $expectedSize, got ${rgbData.size}")
+                    return null
+                }
+                
+                // Convert RGB to BGR first, then to ARGB for Bitmap
+                val bgrData = rgbToBgr(rgbData)
+                createBitmapFromBgr(bgrData, width, height)
+            } catch (e: Exception) {
+                Log.e(TAG, "Error creating bitmap from RGB: ${e.message}", e)
+                null
             }
-            return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
         }
 
         /**
@@ -221,9 +385,28 @@ object ImageFormatEncoder {
             format: ImageFormat,
             quality: Int
         ): ByteArray {
-            val outputStream = ByteArrayOutputStream()
-            bitmap.compress(format.compressFormat, quality, outputStream)
-            return outputStream.toByteArray()
+            return try {
+                if (bitmap.width <= 0 || bitmap.height <= 0) {
+                    throw IllegalArgumentException("Invalid bitmap dimensions: ${bitmap.width}×${bitmap.height}")
+                }
+                
+                val outputStream = ByteArrayOutputStream()
+                val compressed = bitmap.compress(format.compressFormat, quality, outputStream)
+                
+                if (!compressed) {
+                    Log.w(TAG, "Bitmap compression returned false for ${format.name}")
+                }
+                
+                val bytes = outputStream.toByteArray()
+                if (bytes.isEmpty()) {
+                    Log.w(TAG, "Compressed image bytes are empty")
+                }
+                
+                bytes
+            } catch (e: Exception) {
+                Log.e(TAG, "Error compressing bitmap: ${e.message}", e)
+                ByteArray(0)
+            }
         }
 
         /**

package/android/src/main/java/com/faceantispoof/YuvToFloatArrayConverter.kt

@@ -27,28 +27,55 @@ class YuvToFloatArrayConverter {
         targetHeight: Int = height,
         outputRgbFloat: FloatArray? = null
     ): FloatArray {
+        if (nv21.isEmpty()) {
+            throw IllegalArgumentException("NV21 array is empty")
+        }
+        if (width <= 0 || height <= 0) {
+            throw IllegalArgumentException("Invalid frame dimensions: width=$width, height=$height")
+        }
+        if (targetWidth <= 0 || targetHeight <= 0) {
+            throw IllegalArgumentException("Invalid target dimensions: targetWidth=$targetWidth, targetHeight=$targetHeight")
+        }
+        
         val outputSize = targetWidth * targetHeight * 3
         val output = outputRgbFloat?.takeIf { it.size >= outputSize } ?: FloatArray(outputSize)
 
         val ySize = width * height
         val uvPixelStride = 2
+        
+        // Validate NV21 buffer size
+        val minExpectedSize = width * height + (width * height) / 2
+        if (nv21.size < minExpectedSize) {
+            throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
+        }
 
         var outIdx = 0
 
         for (targetY in 0 until targetHeight) {
-            // Map target Y to original frame Y (nearest-neighbor)
             val srcY = (targetY * height) / targetHeight
+            if (srcY >= height) {
+                throw IndexOutOfBoundsException("Source Y index out of bounds: srcY=$srcY, height=$height")
+            }
             val srcRowOffset = srcY * width
 
             for (targetX in 0 until targetWidth) {
-                // Map target X to original frame X (nearest-neighbor)
                 val srcX = (targetX * width) / targetWidth
+                if (srcX >= width) {
+                    throw IndexOutOfBoundsException("Source X index out of bounds: srcX=$srcX, width=$width")
+                }
 
                 // Get Y component
-                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+                val yIdx = srcRowOffset + srcX
+                if (yIdx >= nv21.size) {
+                    throw IndexOutOfBoundsException("Y index out of bounds: yIdx=$yIdx, nv21.size=${nv21.size}")
+                }
+                val yVal = nv21[yIdx].toInt() and 0xFF
 
                 // Get U and V components (NV21 layout: UV interleaved in second half)
                 val uvIndex = ySize + (srcY / 2) * width + (srcX / 2) * uvPixelStride
+                if (uvIndex + 1 >= nv21.size) {
+                    throw IndexOutOfBoundsException("UV index out of bounds: uvIndex=$uvIndex, nv21.size=${nv21.size}")
+                }
                 val vVal = nv21[uvIndex].toInt() and 0xFF
                 val uVal = nv21[uvIndex + 1].toInt() and 0xFF
 
@@ -62,9 +89,13 @@ class YuvToFloatArrayConverter {
                 val b = (yf + 1.772f * uf).coerceIn(0f, 255f)
 
                 // Normalize to [0, 1]
-                output[outIdx++] = r / 255f
-                output[outIdx++] = g / 255f
-                output[outIdx++] = b / 255f
+                if (outIdx + 2 < output.size) {
+                    output[outIdx++] = r / 255f
+                    output[outIdx++] = g / 255f
+                    output[outIdx++] = b / 255f
+                } else {
+                    throw IndexOutOfBoundsException("Output array index out of bounds: outIdx=$outIdx, output.size=${output.size}")
+                }
             }
         }
 
@@ -176,20 +207,48 @@ class YuvToFloatArrayConverter {
         targetHeight: Int = height,
         outputGrayscale: IntArray? = null
     ): IntArray {
+        if (nv21.isEmpty()) {
+            throw IllegalArgumentException("NV21 array is empty")
+        }
+        if (width <= 0 || height <= 0) {
+            throw IllegalArgumentException("Invalid frame dimensions: width=$width, height=$height")
+        }
+        if (targetWidth <= 0 || targetHeight <= 0) {
+            throw IllegalArgumentException("Invalid target dimensions: targetWidth=$targetWidth, targetHeight=$targetHeight")
+        }
+        
         val outputSize = targetWidth * targetHeight
         val output = outputGrayscale?.takeIf { it.size >= outputSize } ?: IntArray(outputSize)
 
         val ySize = width * height
+        val minExpectedSize = width * height + (width * height) / 2
+        if (nv21.size < minExpectedSize) {
+            throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
+        }
 
         var outIdx = 0
         for (targetY in 0 until targetHeight) {
             val srcY = (targetY * height) / targetHeight
+            if (srcY >= height) {
+                throw IndexOutOfBoundsException("Source Y out of bounds: srcY=$srcY, height=$height")
+            }
             val srcRowOffset = srcY * width
 
             for (targetX in 0 until targetWidth) {
                 val srcX = (targetX * width) / targetWidth
-                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
-                output[outIdx++] = yVal
+                if (srcX >= width) {
+                    throw IndexOutOfBoundsException("Source X out of bounds: srcX=$srcX, width=$width")
+                }
+                val yIdx = srcRowOffset + srcX
+                if (yIdx >= nv21.size) {
+                    throw IndexOutOfBoundsException("Y index out of bounds: yIdx=$yIdx, nv21.size=${nv21.size}")
+                }
+                val yVal = nv21[yIdx].toInt() and 0xFF
+                if (outIdx < output.size) {
+                    output[outIdx++] = yVal
+                } else {
+                    throw IndexOutOfBoundsException("Output index out of bounds: outIdx=$outIdx, output.size=${output.size}")
+                }
             }
         }
 
@@ -217,26 +276,54 @@ class YuvToFloatArrayConverter {
         targetHeight: Int = height,
         outputRgbBytes: ByteArray? = null
     ): ByteArray {
+        if (nv21.isEmpty()) {
+            throw IllegalArgumentException("NV21 array is empty")
+        }
+        if (width <= 0 || height <= 0) {
+            throw IllegalArgumentException("Invalid frame dimensions: width=$width, height=$height")
+        }
+        if (targetWidth <= 0 || targetHeight <= 0) {
+            throw IllegalArgumentException("Invalid target dimensions: targetWidth=$targetWidth, targetHeight=$targetHeight")
+        }
+        
         val outputSize = targetWidth * targetHeight * 3
         val output = outputRgbBytes?.takeIf { it.size >= outputSize } ?: ByteArray(outputSize)
 
         val ySize = width * height
         val uvPixelStride = 2
+        
+        val minExpectedSize = width * height + (width * height) / 2
+        if (nv21.size < minExpectedSize) {
+            throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
+        }
 
         var outIdx = 0
 
         for (targetY in 0 until targetHeight) {
             val srcY = (targetY * height) / targetHeight
+            if (srcY >= height) {
+                throw IndexOutOfBoundsException("Source Y out of bounds: srcY=$srcY, height=$height")
+            }
             val srcRowOffset = srcY * width
 
             for (targetX in 0 until targetWidth) {
                 val srcX = (targetX * width) / targetWidth
+                if (srcX >= width) {
+                    throw IndexOutOfBoundsException("Source X out of bounds: srcX=$srcX, width=$width")
+                }
 
                 // Get Y component
-                val yVal = nv21[srcRowOffset + srcX].toInt() and 0xFF
+                val yIdx = srcRowOffset + srcX
+                if (yIdx >= nv21.size) {
+                    throw IndexOutOfBoundsException("Y index out of bounds: yIdx=$yIdx, nv21.size=${nv21.size}")
+                }
+                val yVal = nv21[yIdx].toInt() and 0xFF
 
                 // Get U and V components (NV21 layout: UV interleaved in second half)
                 val uvIndex = ySize + (srcY / 2) * width + (srcX / 2) * uvPixelStride
+                if (uvIndex + 1 >= nv21.size) {
+                    throw IndexOutOfBoundsException("UV index out of bounds: uvIndex=$uvIndex, nv21.size=${nv21.size}")
+                }
                 val vVal = nv21[uvIndex].toInt() and 0xFF
                 val uVal = nv21[uvIndex + 1].toInt() and 0xFF
 
@@ -249,9 +336,13 @@ class YuvToFloatArrayConverter {
                 val g = (yf - 0.34414f * uf - 0.71414f * vf).coerceIn(0f, 255f).toInt().toByte()
                 val b = (yf + 1.772f * uf).coerceIn(0f, 255f).toInt().toByte()
 
-                output[outIdx++] = r
-                output[outIdx++] = g
-                output[outIdx++] = b
+                if (outIdx + 2 < output.size) {
+                    output[outIdx++] = r
+                    output[outIdx++] = g
+                    output[outIdx++] = b
+                } else {
+                    throw IndexOutOfBoundsException("Output index out of bounds: outIdx=$outIdx, output.size=${output.size}")
+                }
             }
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "High-performance face anti-spoofing and liveness detection module for React Native Vision Camera. Uses TensorFlow Lite with GPU acceleration and optimized YUV processing.",
   "homepage": "https://github.com/jescon-tech/react-native-vision-camera-spoof-detector",
   "repository": {

package/android/build/intermediates/cxx/Debug/2a1it684/logs/arm64-v8a/generate_cxx_metadata_1740_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 616ms
-    [gap of 22ms]
-  execute-generate-process completed in 638ms
-  [gap of 16ms]
-generate_cxx_metadata completed in 661ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/arm64-v8a/generate_cxx_metadata_546_timing.txt

@@ -1,10 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    [gap of 56ms]
-    exec-configure 1633ms
-    [gap of 33ms]
-  execute-generate-process completed in 1722ms
-  [gap of 24ms]
-generate_cxx_metadata completed in 1868ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86/generate_cxx_metadata_1740_timing.txt

@@ -1,3 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata 13ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86/generate_cxx_metadata_548_timing.txt

@@ -1,3 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata 41ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86_64/generate_cxx_metadata_1740_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 531ms
-    [gap of 19ms]
-  execute-generate-process completed in 552ms
-  [gap of 16ms]
-generate_cxx_metadata completed in 575ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86_64/generate_cxx_metadata_548_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 610ms
-    [gap of 37ms]
-  execute-generate-process completed in 648ms
-  [gap of 16ms]
-generate_cxx_metadata completed in 674ms
-