[camera] Run iOS methods on UI thread by default

packages/camera/camera/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.9.4+3
+
+* Fix registerTexture and result being called on background thread on iOS.
+
 ## 0.9.4+2
 
 * Updated package description;

packages/camera/camera/example/ios/RunnerTests/CameraFocusTests.m

@@ -19,7 +19,7 @@ @interface FLTCam : NSObject <FlutterTexture,
 
 - (void)applyFocusMode;
 - (void)applyFocusMode:(FocusMode)focusMode onDevice:(AVCaptureDevice *)captureDevice;
-- (void)setFocusPointWithResult:(FlutterResult)result x:(double)x y:(double)y;
+- (void)setFocusPointWithResult:(FLTThreadSafeFlutterResult *)result x:(double)x y:(double)y;
 @end
 
 @interface CameraFocusTests : XCTestCase
@@ -128,11 +128,11 @@ - (void)testSetFocusPointWithResult_SetsFocusPointOfInterest {
   [_camera setValue:_mockDevice forKey:@"captureDevice"];
 
   // Run test
-  [_camera
-      setFocusPointWithResult:^void(id _Nullable result) {
-      }
-                            x:1
-                            y:1];
+  [_camera setFocusPointWithResult:[[FLTThreadSafeFlutterResult alloc]
+                                       initWithResult:^(id _Nullable result){
+                                       }]
+                                 x:1
+                                 y:1];
 
   // Verify the focus point of interest has been set
   OCMVerify([_mockDevice setFocusPointOfInterest:CGPointMake(1, 1)]);

packages/camera/camera/example/ios/RunnerTests/CameraMethodChannelTests.m

@@ -0,0 +1,51 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+@import camera;
+@import camera.Test;
+@import XCTest;
+@import AVFoundation;
+#import <OCMock/OCMock.h>
+#import "MockFLTThreadSafeFlutterResult.h"
+
+@interface CameraMethodChannelTests : XCTestCase
+@property(readonly, nonatomic) CameraPlugin *camera;
+@property(readonly, nonatomic) MockFLTThreadSafeFlutterResult *resultObject;
+@end
+
+@implementation CameraMethodChannelTests
+
+- (void)setUp {
+  _camera = [[CameraPlugin alloc] initWithRegistry:nil messenger:nil];
+
+  XCTestExpectation *expectation =
+      [[XCTestExpectation alloc] initWithDescription:@"Result finished"];
+
+  // Set up mocks for initWithCameraName method
+  id avCaptureDeviceInputMock = OCMClassMock([AVCaptureDeviceInput class]);
+  OCMStub([avCaptureDeviceInputMock deviceInputWithDevice:[OCMArg any] error:[OCMArg anyObjectRef]])
+      .andReturn([AVCaptureInput alloc]);
+
+  id avCaptureSessionMock = OCMClassMock([AVCaptureSession class]);
+  OCMStub([avCaptureSessionMock alloc]).andReturn(avCaptureSessionMock);
+  OCMStub([avCaptureSessionMock canSetSessionPreset:[OCMArg any]]).andReturn(YES);
+
+  _resultObject = [[MockFLTThreadSafeFlutterResult alloc] initWithExpectation:expectation];
+}
+
+- (void)testCreate_ShouldCallResultOnMainThread {
+  // Set up method call
+  FlutterMethodCall *call = [FlutterMethodCall
+      methodCallWithMethodName:@"create"
+                     arguments:@{@"resolutionPreset" : @"medium", @"enableAudio" : @(1)}];
+
+  [self->_camera handleMethodCallAsync:call result:self->_resultObject];
+
+  // Verify the result
+  NSDictionary *dictionaryResult = (NSDictionary *)_resultObject.receivedResult;
+  XCTAssertNotNil(dictionaryResult);
+  XCTAssert([[dictionaryResult allKeys] containsObject:@"cameraId"]);
+}
+
+@end

packages/camera/camera/example/ios/RunnerTests/CameraOrientationTests.m

@@ -23,6 +23,11 @@ - (void)setUp {
   self.cameraPlugin = [[CameraPlugin alloc] initWithRegistry:nil messenger:self.mockMessenger];
 }
 
+- (void)tearDown {
+  self.mockMessenger = nil;
+  self.cameraPlugin = nil;
+}
+
 - (void)testOrientationNotifications {
   id mockMessenger = self.mockMessenger;
   [mockMessenger setExpectationOrderMatters:YES];

packages/camera/camera/example/ios/RunnerTests/CameraPreviewPauseTests.m

@@ -6,44 +6,36 @@
 @import XCTest;
 @import AVFoundation;
 #import <OCMock/OCMock.h>
+#import "MockFLTThreadSafeFlutterResult.h"
 
 @interface FLTCam : NSObject <FlutterTexture,
                               AVCaptureVideoDataOutputSampleBufferDelegate,
                               AVCaptureAudioDataOutputSampleBufferDelegate>
 @property(assign, nonatomic) BOOL isPreviewPaused;
-- (void)pausePreviewWithResult:(FlutterResult)result;
-- (void)resumePreviewWithResult:(FlutterResult)result;
+- (void)pausePreviewWithResult:(FLTThreadSafeFlutterResult *)result;
+- (void)resumePreviewWithResult:(FLTThreadSafeFlutterResult *)result;
 @end
 
 @interface CameraPreviewPauseTests : XCTestCase
-@property(readonly, nonatomic) FLTCam* camera;
+@property(readonly, nonatomic) FLTCam *camera;
+@property(readonly, nonatomic) MockFLTThreadSafeFlutterResult *resultObject;
 @end
 
 @implementation CameraPreviewPauseTests
 
 - (void)setUp {
   _camera = [[FLTCam alloc] init];
+
+  _resultObject = [[MockFLTThreadSafeFlutterResult alloc] init];
 }
 
 - (void)testPausePreviewWithResult_shouldPausePreview {
-  XCTestExpectation* resultExpectation =
-      [self expectationWithDescription:@"Succeeding result with nil value"];
-  [_camera pausePreviewWithResult:^void(id _Nullable result) {
-    XCTAssertNil(result);
-    [resultExpectation fulfill];
-  }];
-  [self waitForExpectationsWithTimeout:2.0 handler:nil];
+  [_camera pausePreviewWithResult:_resultObject];
   XCTAssertTrue(_camera.isPreviewPaused);
 }
 
 - (void)testResumePreviewWithResult_shouldResumePreview {
-  XCTestExpectation* resultExpectation =
-      [self expectationWithDescription:@"Succeeding result with nil value"];
-  [_camera resumePreviewWithResult:^void(id _Nullable result) {
-    XCTAssertNil(result);
-    [resultExpectation fulfill];
-  }];
-  [self waitForExpectationsWithTimeout:2.0 handler:nil];
+  [_camera resumePreviewWithResult:_resultObject];
   XCTAssertFalse(_camera.isPreviewPaused);
 }
 

packages/camera/camera/example/ios/RunnerTests/MockFLTThreadSafeFlutterResult.h

@@ -0,0 +1,19 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MockFLTThreadSafeFlutterResult_h
+#define MockFLTThreadSafeFlutterResult_h
+
+/**
+ * Extends FLTThreadSafeFlutterResult to give tests the ability to wait on the result and
+ * read the received result.
+ */
+@interface MockFLTThreadSafeFlutterResult : FLTThreadSafeFlutterResult
+@property(readonly, nonatomic) XCTestExpectation *_Nonnull expectation;
+@property(nonatomic, nullable) id receivedResult;
+
+- (instancetype _Nonnull)initWithExpectation:(XCTestExpectation *_Nonnull)expectation;
+@end
+
+#endif /* MockFLTThreadSafeFlutterResult_h */

packages/camera/camera/example/ios/RunnerTests/MockFLTThreadSafeFlutterResult.m

@@ -0,0 +1,47 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+@import camera;
+@import XCTest;
+
+#import "MockFLTThreadSafeFlutterResult.h"
+
+@implementation MockFLTThreadSafeFlutterResult
+/**
+ * Initializes the MockFLTThreadSafeFlutterResult.
+ */
+- (instancetype)init {
+  self = [super init];
+  return self;
+}
+
+/**
+ * Initializes the MockFLTThreadSafeFlutterResult with an expectation.
+ */
+- (instancetype)initWithExpectation:(XCTestExpectation *)expectation {
+  self = [super init];
+  _expectation = expectation;
+  return self;
+}
+
+/**
+ * Called when result is successful.
+ *
+ * Stores the data in the `receivedResult` property and fulfills the expectation.
+ */
+- (void)sendSuccessWithData:(id)data {
+  _receivedResult = data;
+  [self->_expectation fulfill];
+}
+
+/**
+ * Called when result is successful.
+ *
+ * Fulfills the expectation.
+ */
+- (void)sendSuccess {
+  _receivedResult = nil;
+  [self->_expectation fulfill];
+}
+@end

packages/camera/camera/example/ios/RunnerTests/ThreadSafeFlutterResultTests.m

@@ -0,0 +1,122 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+@import camera;
+@import XCTest;
+
+@interface ThreadSafeFlutterResultTests : XCTestCase
+@end
+
+@implementation ThreadSafeFlutterResultTests
+- (void)testAsyncSendSuccess_ShouldCallResultOnMainThread {
+  XCTestExpectation* expectation =
+      [[XCTestExpectation alloc] initWithDescription:@"Result finished"];
+
+  FLTThreadSafeFlutterResult* threadSafeFlutterResult =
+      [[FLTThreadSafeFlutterResult alloc] initWithResult:^(id _Nullable result) {
+        XCTAssert(NSThread.isMainThread);
+        [expectation fulfill];
+      }];
+  dispatch_queue_t dispatchQueue = dispatch_queue_create("test dispatchqueue", NULL);
+  dispatch_async(dispatchQueue, ^{
+    [threadSafeFlutterResult sendSuccess];
+  });
+
+  [self waitForExpectations:[NSArray arrayWithObject:expectation] timeout:1];
+}
+
+- (void)testSyncSendSuccess_ShouldCallResultOnMainThread {
+  XCTestExpectation* expectation =
+      [[XCTestExpectation alloc] initWithDescription:@"Result finished"];
+
+  FLTThreadSafeFlutterResult* threadSafeFlutterResult =
+      [[FLTThreadSafeFlutterResult alloc] initWithResult:^(id _Nullable result) {
+        XCTAssert(NSThread.isMainThread);
+        [expectation fulfill];
+      }];
+  [threadSafeFlutterResult sendSuccess];
+  [self waitForExpectations:[NSArray arrayWithObject:expectation] timeout:1];
+}
+
+- (void)testSendNotImplemented_ShouldSendNotImplementedToFlutterResult {
+  XCTestExpectation* expectation =
+      [[XCTestExpectation alloc] initWithDescription:@"Result finished"];
+
+  FLTThreadSafeFlutterResult* threadSafeFlutterResult =
+      [[FLTThreadSafeFlutterResult alloc] initWithResult:^(id _Nullable result) {
+        XCTAssert([result isKindOfClass:FlutterMethodNotImplemented.class]);
+        [expectation fulfill];
+      }];
+  dispatch_queue_t dispatchQueue = dispatch_queue_create("test dispatchqueue", NULL);
+  dispatch_async(dispatchQueue, ^{
+    [threadSafeFlutterResult sendNotImplemented];
+  });
+
+  [self waitForExpectations:[NSArray arrayWithObject:expectation] timeout:1];
+}
+
+- (void)testSendErrorDetails_ShouldSendErrorToFlutterResult {
+  NSString* errorCode = @"errorCode";
+  NSString* errorMessage = @"message";
+  NSString* errorDetails = @"error details";
+  XCTestExpectation* expectation =
+      [[XCTestExpectation alloc] initWithDescription:@"Result finished"];
+
+  FLTThreadSafeFlutterResult* threadSafeFlutterResult =
+      [[FLTThreadSafeFlutterResult alloc] initWithResult:^(id _Nullable result) {
+        XCTAssert([result isKindOfClass:FlutterError.class]);
+        FlutterError* error = (FlutterError*)result;
+        XCTAssertEqualObjects(error.code, errorCode);
+        XCTAssertEqualObjects(error.message, errorMessage);
+        XCTAssertEqualObjects(error.details, errorDetails);
+        [expectation fulfill];
+      }];
+  dispatch_queue_t dispatchQueue = dispatch_queue_create("test dispatchqueue", NULL);
+  dispatch_async(dispatchQueue, ^{
+    [threadSafeFlutterResult sendErrorWithCode:errorCode message:errorMessage details:errorDetails];
+  });
+
+  [self waitForExpectations:[NSArray arrayWithObject:expectation] timeout:1];
+}
+
+- (void)testSendNSError_ShouldSendErrorToFlutterResult {
+  NSError* originalError = [[NSError alloc] initWithDomain:NSURLErrorDomain code:404 userInfo:nil];
+  XCTestExpectation* expectation =
+      [[XCTestExpectation alloc] initWithDescription:@"Result finished"];
+
+  FLTThreadSafeFlutterResult* threadSafeFlutterResult =
+      [[FLTThreadSafeFlutterResult alloc] initWithResult:^(id _Nullable result) {
+        XCTAssert([result isKindOfClass:FlutterError.class]);
+        FlutterError* error = (FlutterError*)result;
+        NSString* constructedErrorCode =
+            [NSString stringWithFormat:@"Error %d", (int)originalError.code];
+        XCTAssertEqualObjects(error.code, constructedErrorCode);
+        [expectation fulfill];
+      }];
+  dispatch_queue_t dispatchQueue = dispatch_queue_create("test dispatchqueue", NULL);
+  dispatch_async(dispatchQueue, ^{
+    [threadSafeFlutterResult sendError:originalError];
+  });
+
+  [self waitForExpectations:[NSArray arrayWithObject:expectation] timeout:1];
+}
+
+- (void)testSendResult_ShouldSendResultToFlutterResult {
+  NSString* resultData = @"resultData";
+  XCTestExpectation* expectation =
+      [[XCTestExpectation alloc] initWithDescription:@"Result finished"];
+
+  FLTThreadSafeFlutterResult* threadSafeFlutterResult =
+      [[FLTThreadSafeFlutterResult alloc] initWithResult:^(id _Nullable result) {
+        XCTAssertEqualObjects(result, resultData);
+        [expectation fulfill];
+      }];
+  dispatch_queue_t dispatchQueue = dispatch_queue_create("test dispatchqueue", NULL);
+  dispatch_async(dispatchQueue, ^{
+    [threadSafeFlutterResult sendSuccessWithData:resultData];
+  });
+
+  [self waitForExpectations:[NSArray arrayWithObject:expectation] timeout:1];
+}
+@end