vision-camera-face-detection 1.2.0

package/android/src/main/java/com/visioncamerafacedetection/VisionCameraFaceDetectionPlugin.kt

@@ -0,0 +1,359 @@
+package com.visioncamerafacedetection
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Matrix
+import android.graphics.Rect
+import android.graphics.RectF
+import android.util.Log
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.common.internal.ImageConvertUtils
+import com.google.mlkit.vision.face.Face
+import com.google.mlkit.vision.face.FaceContour
+import com.google.mlkit.vision.face.FaceDetection
+import com.google.mlkit.vision.face.FaceDetector
+import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.google.mlkit.vision.face.FaceLandmark
+import com.mrousavy.camera.core.FrameInvalidError
+import com.mrousavy.camera.core.types.Orientation
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+import java.nio.ByteBuffer
+import java.nio.FloatBuffer
+
+private const val TAG = "FaceDetector"
+
+class VisionCameraFaceDetectionPlugin(
+  proxy: VisionCameraProxy,
+  options: Map<String, Any>?
+) : FrameProcessorPlugin() {
+  // device display data
+  private val displayMetrics = proxy.context.resources.displayMetrics
+  private val density = displayMetrics.density
+  private val windowWidth = (displayMetrics.widthPixels).toDouble() / density
+  private val windowHeight = (displayMetrics.heightPixels).toDouble() / density
+
+  // detection props
+  private var autoScale = false
+  private var faceDetector: FaceDetector? = null
+  private var runLandmarks = false
+  private var runClassifications = false
+  private var runContours = false
+  private var trackingEnabled = false
+
+  init {
+    // handle auto scaling
+    autoScale = options?.get("autoScale").toString() == "true"
+
+    // initializes faceDetector on creation
+    var performanceModeValue = FaceDetectorOptions.PERFORMANCE_MODE_FAST
+    var landmarkModeValue = FaceDetectorOptions.LANDMARK_MODE_NONE
+    var classificationModeValue = FaceDetectorOptions.CLASSIFICATION_MODE_NONE
+    var contourModeValue = FaceDetectorOptions.CONTOUR_MODE_NONE
+    var minFaceSize = 0.15f
+
+    if (options?.get("performanceMode").toString() == "accurate") {
+      performanceModeValue = FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE
+    }
+
+    if (options?.get("landmarkMode").toString() == "all") {
+      runLandmarks = true
+      landmarkModeValue = FaceDetectorOptions.LANDMARK_MODE_ALL
+    }
+
+    if (options?.get("classificationMode").toString() == "all") {
+      runClassifications = true
+      classificationModeValue = FaceDetectorOptions.CLASSIFICATION_MODE_ALL
+    }
+
+    if (options?.get("contourMode").toString() == "all") {
+      runContours = true
+      contourModeValue = FaceDetectorOptions.CONTOUR_MODE_ALL
+    }
+
+    val minFaceSizeParam = options?.get("minFaceSize").toString()
+    if (
+      minFaceSizeParam != "null" &&
+      minFaceSizeParam != minFaceSize.toString()
+    ) {
+      minFaceSize = minFaceSizeParam.toFloat()
+    }
+
+    val optionsBuilder = FaceDetectorOptions.Builder()
+      .setPerformanceMode(performanceModeValue)
+      .setLandmarkMode(landmarkModeValue)
+      .setContourMode(contourModeValue)
+      .setClassificationMode(classificationModeValue)
+      .setMinFaceSize(minFaceSize)
+
+    if (options?.get("trackingEnabled").toString() == "true") {
+      trackingEnabled = true
+      optionsBuilder.enableTracking()
+    }
+    faceDetector = FaceDetection.getClient(
+      optionsBuilder.build()
+    )
+  }
+
+  private fun processBoundingBox(
+    boundingBox: Rect,
+    sourceWidth: Double,
+    sourceHeight: Double,
+    orientation: Orientation,
+    scaleX: Double,
+    scaleY: Double
+  ): Map<String, Any> {
+    val bounds: MutableMap<String, Any> = HashMap()
+    val width = boundingBox.width().toDouble() * scaleX
+    val height = boundingBox.height().toDouble() * scaleY
+    val x = boundingBox.left.toDouble() * scaleX
+    val y = boundingBox.top.toDouble() * scaleY
+
+    when (orientation) {
+      Orientation.PORTRAIT -> {
+        // device is landscape left
+        bounds["x"] = (-y + sourceWidth * scaleX) - width
+        bounds["y"] = (-x + sourceHeight * scaleY) - height
+      }
+      Orientation.LANDSCAPE_LEFT -> {
+        // device is portrait
+        bounds["x"] = (-x + sourceWidth * scaleX) - width
+        bounds["y"] = y
+      }
+      Orientation.PORTRAIT_UPSIDE_DOWN -> {
+        // device is landscape right
+        bounds["x"] = y
+        bounds["y"] = x
+      }
+      Orientation.LANDSCAPE_RIGHT -> {
+        // device is upside down
+        bounds["x"] = x
+        bounds["y"] = (-y + sourceHeight * scaleY) - height
+      }
+    }
+    bounds["width"] = width
+    bounds["height"] = height
+    return bounds
+  }
+
+  private fun processLandmarks(
+    face: Face,
+    scaleX: Double,
+    scaleY: Double
+  ): Map<String, Any> {
+    val faceLandmarksTypes = intArrayOf(
+      FaceLandmark.LEFT_CHEEK,
+      FaceLandmark.LEFT_EAR,
+      FaceLandmark.LEFT_EYE,
+      FaceLandmark.MOUTH_BOTTOM,
+      FaceLandmark.MOUTH_LEFT,
+      FaceLandmark.MOUTH_RIGHT,
+      FaceLandmark.NOSE_BASE,
+      FaceLandmark.RIGHT_CHEEK,
+      FaceLandmark.RIGHT_EAR,
+      FaceLandmark.RIGHT_EYE
+    )
+    val faceLandmarksTypesStrings = arrayOf(
+      "LEFT_CHEEK",
+      "LEFT_EAR",
+      "LEFT_EYE",
+      "MOUTH_BOTTOM",
+      "MOUTH_LEFT",
+      "MOUTH_RIGHT",
+      "NOSE_BASE",
+      "RIGHT_CHEEK",
+      "RIGHT_EAR",
+      "RIGHT_EYE"
+    )
+    val faceLandmarksTypesMap: MutableMap<String, Any> = HashMap()
+    for (i in faceLandmarksTypesStrings.indices) {
+      val landmark = face.getLandmark(faceLandmarksTypes[i])
+      val landmarkName = faceLandmarksTypesStrings[i]
+      Log.d(
+        TAG,
+        "Getting '$landmarkName' landmark"
+      )
+      if (landmark == null) {
+        Log.d(
+          TAG,
+          "Landmark '$landmarkName' is null - going next"
+        )
+        continue
+      }
+      val point = landmark.position
+      val currentPointsMap: MutableMap<String, Double> = HashMap()
+      currentPointsMap["x"] = point.x.toDouble() * scaleX
+      currentPointsMap["y"] = point.y.toDouble() * scaleY
+      faceLandmarksTypesMap[landmarkName] = currentPointsMap
+    }
+    return faceLandmarksTypesMap
+  }
+
+  private fun processFaceContours(
+    face: Face,
+    scaleX: Double,
+    scaleY: Double
+  ): Map<String, Any> {
+    val faceContoursTypes = intArrayOf(
+      FaceContour.FACE,
+      FaceContour.LEFT_CHEEK,
+      FaceContour.LEFT_EYE,
+      FaceContour.LEFT_EYEBROW_BOTTOM,
+      FaceContour.LEFT_EYEBROW_TOP,
+      FaceContour.LOWER_LIP_BOTTOM,
+      FaceContour.LOWER_LIP_TOP,
+      FaceContour.NOSE_BOTTOM,
+      FaceContour.NOSE_BRIDGE,
+      FaceContour.RIGHT_CHEEK,
+      FaceContour.RIGHT_EYE,
+      FaceContour.RIGHT_EYEBROW_BOTTOM,
+      FaceContour.RIGHT_EYEBROW_TOP,
+      FaceContour.UPPER_LIP_BOTTOM,
+      FaceContour.UPPER_LIP_TOP
+    )
+    val faceContoursTypesStrings = arrayOf(
+      "FACE",
+      "LEFT_CHEEK",
+      "LEFT_EYE",
+      "LEFT_EYEBROW_BOTTOM",
+      "LEFT_EYEBROW_TOP",
+      "LOWER_LIP_BOTTOM",
+      "LOWER_LIP_TOP",
+      "NOSE_BOTTOM",
+      "NOSE_BRIDGE",
+      "RIGHT_CHEEK",
+      "RIGHT_EYE",
+      "RIGHT_EYEBROW_BOTTOM",
+      "RIGHT_EYEBROW_TOP",
+      "UPPER_LIP_BOTTOM",
+      "UPPER_LIP_TOP"
+    )
+    val faceContoursTypesMap: MutableMap<String, Any> = HashMap()
+    for (i in faceContoursTypesStrings.indices) {
+      val contour = face.getContour(faceContoursTypes[i])
+      val contourName = faceContoursTypesStrings[i]
+      Log.d(
+        TAG,
+        "Getting '$contourName' contour"
+      )
+      if (contour == null) {
+        Log.d(
+          TAG,
+          "Face contour '$contourName' is null - going next"
+        )
+        continue
+      }
+      val points = contour.points
+      val pointsMap: MutableMap<String, Map<String, Double>> = HashMap()
+      for (j in points.indices) {
+        val currentPointsMap: MutableMap<String, Double> = HashMap()
+        currentPointsMap["x"] = points[j].x.toDouble() * scaleX
+        currentPointsMap["y"] = points[j].y.toDouble() * scaleY
+        pointsMap[j.toString()] = currentPointsMap
+      }
+      faceContoursTypesMap[contourName] = pointsMap
+    }
+    return faceContoursTypesMap
+  }
+
+  private fun getOrientation(
+    orientation: Orientation
+  ): Int {
+    return when (orientation) {
+      // device is landscape left
+      Orientation.PORTRAIT -> 0
+      // device is portrait
+      Orientation.LANDSCAPE_LEFT -> 270
+      // device is landscape right
+      Orientation.PORTRAIT_UPSIDE_DOWN -> 180
+      // device is upside-down
+      Orientation.LANDSCAPE_RIGHT -> 90
+    }
+  }
+
+  override fun callback(
+    frame: Frame,
+    params: Map<String, Any>?
+  ): Any {
+    val result = ArrayList<Map<String, Any>>()
+    try {
+      val orientation = getOrientation(frame.orientation)
+      val image = InputImage.fromMediaImage(frame.image, orientation)
+      // we need to invert sizes as frame is always -90deg rotated
+      val width = image.height.toDouble()
+      val height = image.width.toDouble()
+      val scaleX = if (autoScale) windowWidth / width else 1.0
+      val scaleY = if (autoScale) windowHeight / height else 1.0
+      val task = faceDetector!!.process(image)
+      val faces = Tasks.await(task)
+      faces.forEach { face ->
+        val bmpFrameResult = ImageConvertUtils.getInstance().getUpRightBitmap(image)
+        val bmpFaceResult =
+          Bitmap.createBitmap(
+            TF_OD_API_INPUT_SIZE,
+            TF_OD_API_INPUT_SIZE,
+            Bitmap.Config.ARGB_8888
+          )
+        val faceBB = RectF(face.boundingBox)
+        val cvFace = Canvas(bmpFaceResult)
+        val sx = TF_OD_API_INPUT_SIZE.toFloat() / faceBB.width()
+        val sy = TF_OD_API_INPUT_SIZE.toFloat() / faceBB.height()
+        val matrix = Matrix()
+        matrix.postTranslate(-faceBB.left, -faceBB.top)
+        matrix.postScale(sx, sy)
+        cvFace.drawBitmap(bmpFrameResult, matrix, null)
+        val input: ByteBuffer = FaceHelper().bitmap2ByteBuffer(bmpFaceResult)
+        val output: FloatBuffer = FloatBuffer.allocate(192)
+        interpreter?.run(input, output)
+
+        val arrayData: MutableList<Any> = ArrayList()
+        for (i: Float in output.array()) {
+          arrayData.add(i.toDouble())
+        }
+        val map: MutableMap<String, Any> = HashMap()
+        if (runLandmarks) {
+          map["landmarks"] = processLandmarks(
+            face,
+            scaleX,
+            scaleY
+          )
+        }
+        if (runClassifications) {
+          map["leftEyeOpenProbability"] = face.leftEyeOpenProbability?.toDouble() ?: -1
+          map["rightEyeOpenProbability"] = face.rightEyeOpenProbability?.toDouble() ?: -1
+          map["smilingProbability"] = face.smilingProbability?.toDouble() ?: -1
+        }
+        if (runContours) {
+          map["contours"] = processFaceContours(
+            face,
+            scaleX,
+            scaleY
+          )
+        }
+        if (trackingEnabled) {
+          map["trackingId"] = face.trackingId ?: -1
+        }
+        map["rollAngle"] = face.headEulerAngleZ.toDouble()
+        map["pitchAngle"] = face.headEulerAngleX.toDouble()
+        map["yawAngle"] = face.headEulerAngleY.toDouble()
+        map["bounds"] = processBoundingBox(
+          face.boundingBox,
+          width,
+          height,
+          frame.orientation,
+          scaleX,
+          scaleY
+        )
+        map["data"] = arrayData
+        result.add(map)
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error processing face detection: ", e)
+    } catch (e: FrameInvalidError) {
+      Log.e(TAG, "Frame invalid error: ", e)
+    }
+    return result
+  }
+}

package/ios/FaceHelper.swift

@@ -0,0 +1,238 @@
+import VisionCamera
+import MLKitFaceDetection
+import MLKitVision
+import CoreML
+import UIKit
+import AVFoundation
+import Accelerate
+import TensorFlowLite
+
+let batchSize = 1
+let inputChannels = 1
+let inputWidth = 112
+let inputHeight = 112
+
+// TensorFlow Lite `Interpreter` object for performing inference on a given model.
+var interpreter: Interpreter? = nil
+
+class FaceHelper {
+    static func processContours(from face: Face) -> [String:[[String:CGFloat]]] {
+        let faceContoursTypes = [
+            FaceContourType.face,
+            FaceContourType.leftEyebrowTop,
+            FaceContourType.leftEyebrowBottom,
+            FaceContourType.rightEyebrowTop,
+            FaceContourType.rightEyebrowBottom,
+            FaceContourType.leftEye,
+            FaceContourType.rightEye,
+            FaceContourType.upperLipTop,
+            FaceContourType.upperLipBottom,
+            FaceContourType.lowerLipTop,
+            FaceContourType.lowerLipBottom,
+            FaceContourType.noseBridge,
+            FaceContourType.noseBottom,
+            FaceContourType.leftCheek,
+            FaceContourType.rightCheek,
+        ]
+        
+        let faceContoursTypesStrings = [
+            "FACE",
+            "LEFT_EYEBROW_TOP",
+            "LEFT_EYEBROW_BOTTOM",
+            "RIGHT_EYEBROW_TOP",
+            "RIGHT_EYEBROW_BOTTOM",
+            "LEFT_EYE",
+            "RIGHT_EYE",
+            "UPPER_LIP_TOP",
+            "UPPER_LIP_BOTTOM",
+            "LOWER_LIP_TOP",
+            "LOWER_LIP_BOTTOM",
+            "NOSE_BRIDGE",
+            "NOSE_BOTTOM",
+            "LEFT_CHEEK",
+            "RIGHT_CHEEK",
+        ];
+        
+        var faceContoursTypesMap: [String:[[String:CGFloat]]] = [:]
+        
+        for i in 0..<faceContoursTypes.count {
+            let contour = face.contour(ofType: faceContoursTypes[i]);
+            
+            var pointsArray: [[String:CGFloat]] = []
+            
+            if let points = contour?.points {
+                for point in points {
+                    let currentPointsMap = [
+                        "x": point.x,
+                        "y": point.y,
+                    ]
+                    
+                    pointsArray.append(currentPointsMap)
+                }
+                
+                faceContoursTypesMap[faceContoursTypesStrings[i]] = pointsArray
+            }
+        }
+        
+        return faceContoursTypesMap
+    }
+    
+    static func processBoundingBox(from face: Face) -> [String:Any] {
+        let frameRect = face.frame
+        
+        let offsetX = (frameRect.midX - ceil(frameRect.width)) / 2.0
+        let offsetY = (frameRect.midY - ceil(frameRect.height)) / 2.0
+        
+        let x = frameRect.maxX + offsetX
+        let y = frameRect.minY + offsetY
+        
+        return [
+            "x": frameRect.midX + (frameRect.midX - x),
+            "y": frameRect.midY + (y - frameRect.midY),
+            "width": frameRect.width,
+            "height": frameRect.height,
+            "boundingCenterX": frameRect.midX,
+            "boundingCenterY": frameRect.midY
+        ]
+    }
+    
+    static func getImageFaceFromUIImage(from image: UIImage, rectImage: CGRect) -> UIImage? {
+        let imageRef: CGImage = (image.cgImage?.cropping(to: rectImage)!)!
+        let imageCrop: UIImage = UIImage(cgImage: imageRef, scale: 0.5, orientation: image.imageOrientation)
+        return imageCrop
+    }
+    
+    static func convertImageToBase64(image: UIImage) -> String {
+        let imageData = image.pngData()!
+        return imageData.base64EncodedString()
+    }
+    
+    static func rgbDataFromBuffer(
+        _ buffer: CVPixelBuffer,
+        byteCount: Int,
+        isModelQuantized: Bool
+    ) -> Data? {
+        CVPixelBufferLockBaseAddress(buffer, .readOnly)
+        defer {
+            CVPixelBufferUnlockBaseAddress(buffer, .readOnly)
+        }
+        guard let sourceData = CVPixelBufferGetBaseAddress(buffer) else {
+            return nil
+        }
+        
+        let width = CVPixelBufferGetWidth(buffer)
+        let height = CVPixelBufferGetHeight(buffer)
+        let sourceBytesPerRow = CVPixelBufferGetBytesPerRow(buffer)
+        let destinationChannelCount = 3
+        let destinationBytesPerRow = destinationChannelCount * width
+        
+        var sourceBuffer = vImage_Buffer(data: sourceData,
+                                         height: vImagePixelCount(height),
+                                         width: vImagePixelCount(width),
+                                         rowBytes: sourceBytesPerRow)
+        
+        guard let destinationData = malloc(height * destinationBytesPerRow) else {
+            print("Error: out of memory")
+            return nil
+        }
+        
+        defer {
+            free(destinationData)
+        }
+        
+        var destinationBuffer = vImage_Buffer(data: destinationData,
+                                              height: vImagePixelCount(height),
+                                              width: vImagePixelCount(width),
+                                              rowBytes: destinationBytesPerRow)
+        
+        let pixelBufferFormat = CVPixelBufferGetPixelFormatType(buffer)
+        
+        switch (pixelBufferFormat) {
+        case kCVPixelFormatType_32BGRA:
+            vImageConvert_BGRA8888toRGB888(&sourceBuffer, &destinationBuffer, UInt32(kvImageNoFlags))
+        case kCVPixelFormatType_32ARGB:
+            vImageConvert_ARGB8888toRGB888(&sourceBuffer, &destinationBuffer, UInt32(kvImageNoFlags))
+        case kCVPixelFormatType_32RGBA:
+            vImageConvert_RGBA8888toRGB888(&sourceBuffer, &destinationBuffer, UInt32(kvImageNoFlags))
+        default:
+            // Unknown pixel format.
+            return nil
+        }
+        
+        let byteData = Data(bytes: destinationBuffer.data, count: destinationBuffer.rowBytes * height)
+        if isModelQuantized {
+            return byteData
+        }
+        
+        // Not quantized, convert to floats
+        let bytes = Array<UInt8>(unsafeData: byteData)!
+        var floats = [Float]()
+        for i in 0..<bytes.count {
+            floats.append(Float(bytes[i]) / 255.0)
+        }
+        return Data(copyingBufferOf: floats)
+    }
+    
+    static func uiImageToPixelBuffer(image: UIImage, size: Int) -> CVPixelBuffer? {
+        let attrs = [kCVPixelBufferCGImageCompatibilityKey: kCFBooleanTrue, kCVPixelBufferCGBitmapContextCompatibilityKey: kCFBooleanTrue] as CFDictionary
+        var pixelBuffer : CVPixelBuffer?
+        let status = CVPixelBufferCreate(kCFAllocatorDefault, size, size, kCVPixelFormatType_32ARGB, attrs, &pixelBuffer)
+        guard (status == kCVReturnSuccess) else {
+            return nil
+        }
+        
+        CVPixelBufferLockBaseAddress(pixelBuffer!, CVPixelBufferLockFlags(rawValue: 0))
+        let pixelData = CVPixelBufferGetBaseAddress(pixelBuffer!)
+        
+        let rgbColorSpace = CGColorSpaceCreateDeviceRGB()
+        let context = CGContext(data: pixelData, width: size, height: size, bitsPerComponent: 8, bytesPerRow: CVPixelBufferGetBytesPerRow(pixelBuffer!), space: rgbColorSpace, bitmapInfo: CGImageAlphaInfo.noneSkipFirst.rawValue)
+        
+        context?.translateBy(x: 0, y: CGFloat(size))
+        context?.scaleBy(x: 1.0, y: -1.0)
+        
+        UIGraphicsPushContext(context!)
+        image.draw(in: CGRect(x: 0, y: 0, width: size, height: size))
+        UIGraphicsPopContext()
+        CVPixelBufferUnlockBaseAddress(pixelBuffer!, CVPixelBufferLockFlags(rawValue: 0))
+        return pixelBuffer
+    }
+    
+    static func getImageFaceFromBuffer(from sampleBuffer: CMSampleBuffer?, rectImage: CGRect) -> UIImage? {
+        guard let sampleBuffer = sampleBuffer else {
+            print("Sample buffer is NULL.")
+            return nil
+        }
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            print("Invalid sample buffer.")
+            return nil
+        }
+        let ciimage = CIImage(cvPixelBuffer: imageBuffer)
+        let context = CIContext(options: nil)
+        let cgImage = context.createCGImage(ciimage, from: ciimage.extent)!
+        
+        if (!rectImage.isNull) {
+            let imageRef: CGImage = cgImage.cropping(to: rectImage)!
+            let imageCrop: UIImage = UIImage(cgImage: imageRef, scale: 0.5, orientation: .up)
+            return imageCrop
+        } else {
+            return nil
+        }
+    }
+}
+
+// MARK: - Extensions
+extension Data {
+    // Creates a new buffer by copying the buffer pointer of the given array.
+    init<T>(copyingBufferOf array: [T]) {
+        self = array.withUnsafeBufferPointer(Data.init)
+    }
+}
+
+extension Array {
+    // Creates a new array from the bytes of the given unsafe data.
+    init?(unsafeData: Data) {
+        guard unsafeData.count % MemoryLayout<Element>.stride == 0 else { return nil }
+        self = unsafeData.withUnsafeBytes { .init($0.bindMemory(to: Element.self)) }
+    }
+}
+

package/ios/VisionCameraFaceDetection-Bridging-Header.h

@@ -0,0 +1,6 @@
+#if VISION_CAMERA_ENABLE_FRAME_PROCESSORS
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/Frame.h>
+#endif
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/VisionCameraFaceDetectionModule.mm

@@ -0,0 +1,19 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(VisionCameraFaceDetectionModule, NSObject)
+
+RCT_EXTERN_METHOD(detectFromBase64:(NSString)imageString
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(initTensor:(NSString)modelName
+                  withCount:(NSNumber)count
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+@end