5 #include "display_list/geometry/dl_geometry_types.h"
8 #import <OCMock/OCMock.h>
9 #import <UIKit/UIKit.h>
10 #import <WebKit/WebKit.h>
11 #import <XCTest/XCTest.h>
15 #include "flutter/display_list/effects/dl_image_filters.h"
16 #include "flutter/fml/synchronization/count_down_latch.h"
17 #include "flutter/fml/thread.h"
44 NSObject<FlutterTexture>* texture)
override {
58 - (instancetype)init {
78 @property(nonatomic, strong) NSMutableArray<NSNumber*>* toggleHistory;
82 - (instancetype)init {
85 _toggleHistory = [NSMutableArray array];
89 - (void)setEnabled:(BOOL)enabled {
90 [
super setEnabled:enabled];
91 [
self.toggleHistory addObject:@(enabled)];
103 @property(nonatomic, strong) UIView* view;
104 @property(nonatomic, assign) BOOL viewCreated;
109 - (instancetype)init {
110 if (
self = [super init]) {
118 [
self checkViewCreatedOnce];
122 - (void)checkViewCreatedOnce {
126 self.viewCreated = YES;
135 : NSObject <FlutterPlatformViewFactory>
140 viewIdentifier:(int64_t)viewId
141 arguments:(
id _Nullable)args {
148 @property(nonatomic, strong) UIView* view;
149 @property(nonatomic, assign) BOOL viewCreated;
153 - (instancetype)init {
154 if (
self = [super init]) {
155 _view = [[WKWebView alloc] init];
163 [
self checkViewCreatedOnce];
167 - (void)checkViewCreatedOnce {
171 self.viewCreated = YES;
183 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
184 viewIdentifier:(int64_t)viewId
185 arguments:(
id _Nullable)args {
194 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
195 viewIdentifier:(int64_t)viewId
196 arguments:(
id _Nullable)args {
203 @property(nonatomic, strong) UIView* view;
204 @property(nonatomic, assign) BOOL viewCreated;
208 - (instancetype)init {
209 if (
self = [super init]) {
210 _view = [[UIView alloc] init];
211 [_view addSubview:[[WKWebView alloc] init]];
219 [
self checkViewCreatedOnce];
223 - (void)checkViewCreatedOnce {
227 self.viewCreated = YES;
239 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
240 viewIdentifier:(int64_t)viewId
241 arguments:(
id _Nullable)args {
247 @property(nonatomic, strong) UIView* view;
248 @property(nonatomic, assign) BOOL viewCreated;
252 - (instancetype)init {
253 if (
self = [super init]) {
254 _view = [[UIView alloc] init];
255 UIView* childView = [[UIView alloc] init];
256 [_view addSubview:childView];
257 [childView addSubview:[[WKWebView alloc] init]];
265 [
self checkViewCreatedOnce];
269 - (void)checkViewCreatedOnce {
273 self.viewCreated = YES;
278 : NSObject <FlutterPlatformViewFactory>
283 viewIdentifier:(int64_t)viewId
284 arguments:(
id _Nullable)args {
291 class FlutterPlatformViewsTestMockPlatformViewDelegate :
public PlatformView::Delegate {
293 void OnPlatformViewCreated(std::unique_ptr<Surface> surface)
override {}
294 void OnPlatformViewDestroyed()
override {}
295 void OnPlatformViewScheduleFrame()
override {}
296 void OnPlatformViewAddView(int64_t view_id,
297 const ViewportMetrics& viewport_metrics,
298 AddViewCallback callback)
override {}
299 void OnPlatformViewRemoveView(int64_t view_id, RemoveViewCallback callback)
override {}
300 void OnPlatformViewSendViewFocusEvent(
const ViewFocusEvent& event)
override {};
301 void OnPlatformViewSetNextFrameCallback(
const fml::closure& closure)
override {}
302 void OnPlatformViewSetViewportMetrics(int64_t view_id,
const ViewportMetrics& metrics)
override {}
303 const flutter::Settings& OnPlatformViewGetSettings()
const override {
return settings_; }
304 void OnPlatformViewDispatchPlatformMessage(std::unique_ptr<PlatformMessage> message)
override {}
305 void OnPlatformViewDispatchPointerDataPacket(std::unique_ptr<PointerDataPacket> packet)
override {
307 HitTestResponse OnPlatformViewHitTest(int64_t view_id,
const flutter::PointData offset)
override {
308 return {.has_platform_view =
false};
310 void OnPlatformViewDispatchSemanticsAction(int64_t view_id,
312 SemanticsAction action,
313 fml::MallocMapping args)
override {}
314 void OnPlatformViewSetSemanticsEnabled(
bool enabled)
override {}
315 void OnPlatformViewSetAccessibilityFeatures(int32_t flags)
override {}
316 void OnPlatformViewRegisterTexture(std::shared_ptr<Texture> texture)
override {}
317 void OnPlatformViewUnregisterTexture(int64_t
texture_id)
override {}
318 void OnPlatformViewMarkTextureFrameAvailable(int64_t
texture_id)
override {}
320 void LoadDartDeferredLibrary(intptr_t loading_unit_id,
321 std::unique_ptr<const fml::Mapping> snapshot_data,
322 std::unique_ptr<const fml::Mapping> snapshot_instructions)
override {
324 void LoadDartDeferredLibraryError(intptr_t loading_unit_id,
325 const std::string error_message,
326 bool transient)
override {}
327 void UpdateAssetResolverByType(std::unique_ptr<flutter::AssetResolver> updated_asset_resolver,
328 flutter::AssetResolver::AssetResolverType type)
override {}
329 std::shared_ptr<fml::BasicTaskRunner> OnPlatformViewGetShutdownSafeIOTaskRunner()
const override {
336 BOOL BlurRadiusEqualToBlurRadius(CGFloat radius1, CGFloat radius2) {
337 const CGFloat epsilon = 0.01;
338 return std::abs(radius1 - radius2) < epsilon;
357 view = view.superview;
364 static UIGestureRecognizer* FindForwardingGestureRecognizer(UIView* view) {
365 for (UIGestureRecognizer* gestureRecognizer in view.gestureRecognizers) {
367 return gestureRecognizer;
376 - (void)testCreateWithInvalidViewTypeReturnsError {
380 NSArray<NSDictionary*>* invalidArguments = @[
382 @{@"id" : @2, @"viewType" : [NSNull null]},
383 @{@"id" : @2, @"viewType" : @7},
386 for (NSDictionary* arguments in invalidArguments) {
387 __block BOOL errored = NO;
393 [flutterPlatformViewsController
396 XCTAssertTrue(errored,
@"arguments: %@", arguments);
400 - (void)testFlutterViewOnlyCreateOnceInOneFrame {
401 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
406 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
408 flutterPlatformViewsController,
410 std::make_shared<fml::SyncSwitch>());
414 [flutterPlatformViewsController
416 withId:@"MockFlutterPlatformView"
420 [flutterPlatformViewsController
424 @"viewType" : @"MockFlutterPlatformView",
425 @"gestureBlockingPolicy" : @"eager"
428 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
429 flutterPlatformViewsController.
flutterView = flutterView;
431 flutter::MutatorsStack stack;
433 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
434 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
435 stack.PushTransform(screenScaleMatrix);
437 flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
438 stack.PushTransform(translateMatrix);
439 flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
441 auto embeddedViewParams =
442 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
444 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
445 withParams:std::move(embeddedViewParams)];
449 [flutterPlatformViewsController
reset];
452 - (void)testCanCreatePlatformViewWithoutFlutterView {
453 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
458 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
460 flutterPlatformViewsController,
462 std::make_shared<fml::SyncSwitch>());
466 [flutterPlatformViewsController
468 withId:@"MockFlutterPlatformView"
472 [flutterPlatformViewsController
476 @"viewType" : @"MockFlutterPlatformView",
477 @"gestureBlockingPolicy" : @"eager"
484 - (void)testChildClippingViewHitTests {
487 UIView* childView = [[UIView alloc] initWithFrame:CGRectMake(100, 100, 100, 100)];
488 [childClippingView addSubview:childView];
490 XCTAssertFalse([childClippingView pointInside:CGPointMake(50, 50) withEvent:nil]);
491 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 100) withEvent:nil]);
492 XCTAssertFalse([childClippingView pointInside:CGPointMake(100, 99) withEvent:nil]);
493 XCTAssertFalse([childClippingView pointInside:CGPointMake(201, 200) withEvent:nil]);
494 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 201) withEvent:nil]);
495 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 200) withEvent:nil]);
496 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 299) withEvent:nil]);
498 XCTAssertTrue([childClippingView pointInside:CGPointMake(150, 150) withEvent:nil]);
499 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 100) withEvent:nil]);
500 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 100) withEvent:nil]);
501 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 199) withEvent:nil]);
502 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 199) withEvent:nil]);
505 - (void)testReleasesBackdropFilterSubviewsOnChildClippingViewDealloc {
506 __weak NSMutableArray<UIVisualEffectView*>* weakBackdropFilterSubviews = nil;
507 __weak UIVisualEffectView* weakVisualEffectView1 = nil;
508 __weak UIVisualEffectView* weakVisualEffectView2 = nil;
512 UIVisualEffectView* visualEffectView1 = [[UIVisualEffectView alloc]
513 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
514 weakVisualEffectView1 = visualEffectView1;
519 isRoundedSuperellipse:NO
520 visualEffectView:visualEffectView1];
525 UIVisualEffectView* visualEffectView2 = [[UIVisualEffectView alloc]
526 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleDark]];
527 weakVisualEffectView2 = visualEffectView2;
532 isRoundedSuperellipse:NO
533 visualEffectView:visualEffectView2];
537 XCTAssertNotNil(weakBackdropFilterSubviews);
540 XCTAssertNil(weakBackdropFilterSubviews);
541 XCTAssertNil(weakVisualEffectView1);
542 XCTAssertNil(weakVisualEffectView2);
545 - (void)testApplyBackdropFilter {
546 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
551 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
553 flutterPlatformViewsController,
555 std::make_shared<fml::SyncSwitch>());
559 [flutterPlatformViewsController
561 withId:@"MockFlutterPlatformView"
565 [flutterPlatformViewsController
569 @"viewType" : @"MockFlutterPlatformView",
570 @"gestureBlockingPolicy" : @"eager"
576 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
577 flutterPlatformViewsController.
flutterView = flutterView;
579 flutter::MutatorsStack stack;
581 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
582 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
583 stack.PushTransform(screenScaleMatrix);
585 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
586 stack.PushBackdropFilter(filter,
587 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
589 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
590 screenScaleMatrix, flutter::DlSize(10, 10), stack);
592 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
593 withParams:std::move(embeddedViewParams)];
594 [flutterPlatformViewsController
600 [flutterView addSubview:childClippingView];
602 [flutterView setNeedsLayout];
603 [flutterView layoutIfNeeded];
606 NSUInteger numberOfExpectedVisualEffectView = 0;
607 for (UIView* subview in childClippingView.subviews) {
608 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
611 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
612 if ([
self validateOneVisualEffectView:subview
613 expectedFrame:CGRectMake(0, 0, 10, 10)
615 numberOfExpectedVisualEffectView++;
618 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
621 - (void)testApplyBackdropFilterWithCorrectFrame {
622 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
627 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
629 flutterPlatformViewsController,
631 std::make_shared<fml::SyncSwitch>());
635 [flutterPlatformViewsController
637 withId:@"MockFlutterPlatformView"
641 [flutterPlatformViewsController
645 @"viewType" : @"MockFlutterPlatformView",
646 @"gestureBlockingPolicy" : @"eager"
652 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
653 flutterPlatformViewsController.
flutterView = flutterView;
655 flutter::MutatorsStack stack;
657 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
658 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
659 stack.PushTransform(screenScaleMatrix);
661 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
662 stack.PushBackdropFilter(filter,
663 flutter::DlRect::MakeXYWH(0, 0, screenScale * 8, screenScale * 8));
665 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
666 screenScaleMatrix, flutter::DlSize(5, 10), stack);
668 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
669 withParams:std::move(embeddedViewParams)];
670 [flutterPlatformViewsController
676 [flutterView addSubview:childClippingView];
678 [flutterView setNeedsLayout];
679 [flutterView layoutIfNeeded];
682 NSUInteger numberOfExpectedVisualEffectView = 0;
683 for (UIView* subview in childClippingView.subviews) {
684 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
687 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
688 if ([
self validateOneVisualEffectView:subview
689 expectedFrame:CGRectMake(0, 0, 5, 8)
691 numberOfExpectedVisualEffectView++;
694 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
697 - (void)testApplyMultipleBackdropFilters {
698 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
703 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
705 flutterPlatformViewsController,
707 std::make_shared<fml::SyncSwitch>());
711 [flutterPlatformViewsController
713 withId:@"MockFlutterPlatformView"
717 [flutterPlatformViewsController
721 @"viewType" : @"MockFlutterPlatformView",
722 @"gestureBlockingPolicy" : @"eager"
728 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
729 flutterPlatformViewsController.
flutterView = flutterView;
731 flutter::MutatorsStack stack;
733 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
734 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
735 stack.PushTransform(screenScaleMatrix);
737 for (
int i = 0; i < 50; i++) {
738 auto filter = flutter::DlBlurImageFilter::Make(i, 2, flutter::DlTileMode::kClamp);
739 stack.PushBackdropFilter(filter,
740 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
743 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
744 screenScaleMatrix, flutter::DlSize(20, 20), stack);
746 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
747 withParams:std::move(embeddedViewParams)];
748 [flutterPlatformViewsController
754 [flutterView addSubview:childClippingView];
756 [flutterView setNeedsLayout];
757 [flutterView layoutIfNeeded];
759 NSUInteger numberOfExpectedVisualEffectView = 0;
760 for (UIView* subview in childClippingView.subviews) {
761 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
764 XCTAssertLessThan(numberOfExpectedVisualEffectView, 50u);
765 if ([
self validateOneVisualEffectView:subview
766 expectedFrame:CGRectMake(0, 0, 10, 10)
767 inputRadius:(CGFloat)numberOfExpectedVisualEffectView]) {
768 numberOfExpectedVisualEffectView++;
771 XCTAssertEqual(numberOfExpectedVisualEffectView, (NSUInteger)numberOfExpectedVisualEffectView);
774 - (void)testAddBackdropFilters {
775 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
781 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
783 flutterPlatformViewsController,
785 std::make_shared<fml::SyncSwitch>());
789 [flutterPlatformViewsController
791 withId:@"MockFlutterPlatformView"
795 [flutterPlatformViewsController
799 @"viewType" : @"MockFlutterPlatformView",
800 @"gestureBlockingPolicy" : @"eager"
806 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
807 flutterPlatformViewsController.
flutterView = flutterView;
809 flutter::MutatorsStack stack;
811 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
812 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
813 stack.PushTransform(screenScaleMatrix);
815 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
816 stack.PushBackdropFilter(filter,
817 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
819 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
820 screenScaleMatrix, flutter::DlSize(10, 10), stack);
822 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
823 withParams:std::move(embeddedViewParams)];
824 [flutterPlatformViewsController
830 [flutterView addSubview:childClippingView];
832 [flutterView setNeedsLayout];
833 [flutterView layoutIfNeeded];
835 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
836 for (UIView* subview in childClippingView.subviews) {
837 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
840 XCTAssertLessThan(originalVisualEffectViews.count, 1u);
841 if ([
self validateOneVisualEffectView:subview
842 expectedFrame:CGRectMake(0, 0, 10, 10)
843 inputRadius:(CGFloat)5]) {
844 [originalVisualEffectViews addObject:subview];
847 XCTAssertEqual(originalVisualEffectViews.count, 1u);
852 flutter::MutatorsStack stack2;
854 stack2.PushTransform(screenScaleMatrix);
856 for (
int i = 0; i < 2; i++) {
857 stack2.PushBackdropFilter(filter,
858 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
861 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
862 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
864 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
865 withParams:std::move(embeddedViewParams)];
866 [flutterPlatformViewsController
870 [flutterView setNeedsLayout];
871 [flutterView layoutIfNeeded];
873 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
874 for (UIView* subview in childClippingView.subviews) {
875 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
878 XCTAssertLessThan(newVisualEffectViews.count, 2u);
880 if ([
self validateOneVisualEffectView:subview
881 expectedFrame:CGRectMake(0, 0, 10, 10)
882 inputRadius:(CGFloat)5]) {
883 [newVisualEffectViews addObject:subview];
886 XCTAssertEqual(newVisualEffectViews.count, 2u);
887 for (NSUInteger i = 0; i < originalVisualEffectViews.count; i++) {
888 UIView* originalView = originalVisualEffectViews[i];
889 UIView* newView = newVisualEffectViews[i];
891 XCTAssertEqual(originalView, newView);
892 id mockOrignalView = OCMPartialMock(originalView);
893 OCMReject([mockOrignalView removeFromSuperview]);
894 [mockOrignalView stopMocking];
898 - (void)testRemoveBackdropFilters {
899 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
905 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
907 flutterPlatformViewsController,
909 std::make_shared<fml::SyncSwitch>());
913 [flutterPlatformViewsController
915 withId:@"MockFlutterPlatformView"
919 [flutterPlatformViewsController
923 @"viewType" : @"MockFlutterPlatformView",
924 @"gestureBlockingPolicy" : @"eager"
930 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
931 flutterPlatformViewsController.
flutterView = flutterView;
933 flutter::MutatorsStack stack;
935 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
936 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
937 stack.PushTransform(screenScaleMatrix);
939 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
940 for (
int i = 0; i < 5; i++) {
941 stack.PushBackdropFilter(filter,
942 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
945 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
946 screenScaleMatrix, flutter::DlSize(10, 10), stack);
948 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
949 withParams:std::move(embeddedViewParams)];
950 [flutterPlatformViewsController
956 [flutterView addSubview:childClippingView];
958 [flutterView setNeedsLayout];
959 [flutterView layoutIfNeeded];
961 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
962 for (UIView* subview in childClippingView.subviews) {
963 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
966 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
967 if ([
self validateOneVisualEffectView:subview
968 expectedFrame:CGRectMake(0, 0, 10, 10)
969 inputRadius:(CGFloat)5]) {
970 [originalVisualEffectViews addObject:subview];
976 flutter::MutatorsStack stack2;
978 stack2.PushTransform(screenScaleMatrix);
980 for (
int i = 0; i < 4; i++) {
981 stack2.PushBackdropFilter(filter,
982 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
985 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
986 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
988 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
989 withParams:std::move(embeddedViewParams)];
990 [flutterPlatformViewsController
994 [flutterView setNeedsLayout];
995 [flutterView layoutIfNeeded];
997 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
998 for (UIView* subview in childClippingView.subviews) {
999 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1002 XCTAssertLessThan(newVisualEffectViews.count, 4u);
1003 if ([
self validateOneVisualEffectView:subview
1004 expectedFrame:CGRectMake(0, 0, 10, 10)
1005 inputRadius:(CGFloat)5]) {
1006 [newVisualEffectViews addObject:subview];
1009 XCTAssertEqual(newVisualEffectViews.count, 4u);
1011 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1012 UIView* newView = newVisualEffectViews[i];
1013 id mockNewView = OCMPartialMock(newView);
1014 UIView* originalView = originalVisualEffectViews[i];
1016 XCTAssertEqual(originalView, newView);
1017 OCMReject([mockNewView removeFromSuperview]);
1018 [mockNewView stopMocking];
1023 for (
int i = 0; i < 5; i++) {
1028 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1029 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1031 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1032 withParams:std::move(embeddedViewParams)];
1033 [flutterPlatformViewsController
1037 [flutterView setNeedsLayout];
1038 [flutterView layoutIfNeeded];
1040 NSUInteger numberOfExpectedVisualEffectView = 0u;
1041 for (UIView* subview in childClippingView.subviews) {
1042 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1043 numberOfExpectedVisualEffectView++;
1046 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1049 - (void)testEditBackdropFilters {
1050 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1056 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1058 flutterPlatformViewsController,
1060 std::make_shared<fml::SyncSwitch>());
1064 [flutterPlatformViewsController
1066 withId:@"MockFlutterPlatformView"
1070 [flutterPlatformViewsController
1074 @"viewType" : @"MockFlutterPlatformView",
1075 @"gestureBlockingPolicy" : @"eager"
1081 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1082 flutterPlatformViewsController.
flutterView = flutterView;
1084 flutter::MutatorsStack stack;
1086 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1087 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1088 stack.PushTransform(screenScaleMatrix);
1090 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1091 for (
int i = 0; i < 5; i++) {
1092 stack.PushBackdropFilter(filter,
1093 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1096 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1097 screenScaleMatrix, flutter::DlSize(10, 10), stack);
1099 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1100 withParams:std::move(embeddedViewParams)];
1101 [flutterPlatformViewsController
1107 [flutterView addSubview:childClippingView];
1109 [flutterView setNeedsLayout];
1110 [flutterView layoutIfNeeded];
1112 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
1113 for (UIView* subview in childClippingView.subviews) {
1114 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1117 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
1118 if ([
self validateOneVisualEffectView:subview
1119 expectedFrame:CGRectMake(0, 0, 10, 10)
1120 inputRadius:(CGFloat)5]) {
1121 [originalVisualEffectViews addObject:subview];
1127 flutter::MutatorsStack stack2;
1129 stack2.PushTransform(screenScaleMatrix);
1131 for (
int i = 0; i < 5; i++) {
1133 auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1135 stack2.PushBackdropFilter(
1136 filter2, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1140 stack2.PushBackdropFilter(filter,
1141 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1144 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1145 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1147 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1148 withParams:std::move(embeddedViewParams)];
1149 [flutterPlatformViewsController
1153 [flutterView setNeedsLayout];
1154 [flutterView layoutIfNeeded];
1156 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
1157 for (UIView* subview in childClippingView.subviews) {
1158 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1161 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1162 CGFloat expectInputRadius = 5;
1163 if (newVisualEffectViews.count == 3) {
1164 expectInputRadius = 2;
1166 if ([
self validateOneVisualEffectView:subview
1167 expectedFrame:CGRectMake(0, 0, 10, 10)
1168 inputRadius:expectInputRadius]) {
1169 [newVisualEffectViews addObject:subview];
1172 XCTAssertEqual(newVisualEffectViews.count, 5u);
1173 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1174 UIView* newView = newVisualEffectViews[i];
1175 id mockNewView = OCMPartialMock(newView);
1176 UIView* originalView = originalVisualEffectViews[i];
1178 XCTAssertEqual(originalView, newView);
1179 OCMReject([mockNewView removeFromSuperview]);
1180 [mockNewView stopMocking];
1182 [newVisualEffectViews removeAllObjects];
1186 for (
int i = 0; i < 5; i++) {
1190 for (
int i = 0; i < 5; i++) {
1192 auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1193 stack2.PushBackdropFilter(
1194 filter2, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1198 stack2.PushBackdropFilter(filter,
1199 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1202 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1203 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1205 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1206 withParams:std::move(embeddedViewParams)];
1207 [flutterPlatformViewsController
1211 [flutterView setNeedsLayout];
1212 [flutterView layoutIfNeeded];
1214 for (UIView* subview in childClippingView.subviews) {
1215 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1218 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1219 CGFloat expectInputRadius = 5;
1220 if (newVisualEffectViews.count == 0) {
1221 expectInputRadius = 2;
1223 if ([
self validateOneVisualEffectView:subview
1224 expectedFrame:CGRectMake(0, 0, 10, 10)
1225 inputRadius:expectInputRadius]) {
1226 [newVisualEffectViews addObject:subview];
1229 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1230 UIView* newView = newVisualEffectViews[i];
1231 id mockNewView = OCMPartialMock(newView);
1232 UIView* originalView = originalVisualEffectViews[i];
1234 XCTAssertEqual(originalView, newView);
1235 OCMReject([mockNewView removeFromSuperview]);
1236 [mockNewView stopMocking];
1238 [newVisualEffectViews removeAllObjects];
1242 for (
int i = 0; i < 5; i++) {
1246 for (
int i = 0; i < 5; i++) {
1248 auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1249 stack2.PushBackdropFilter(
1250 filter2, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1254 stack2.PushBackdropFilter(filter,
1255 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1258 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1259 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1261 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1262 withParams:std::move(embeddedViewParams)];
1263 [flutterPlatformViewsController
1267 [flutterView setNeedsLayout];
1268 [flutterView layoutIfNeeded];
1270 for (UIView* subview in childClippingView.subviews) {
1271 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1274 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1275 CGFloat expectInputRadius = 5;
1276 if (newVisualEffectViews.count == 4) {
1277 expectInputRadius = 2;
1279 if ([
self validateOneVisualEffectView:subview
1280 expectedFrame:CGRectMake(0, 0, 10, 10)
1281 inputRadius:expectInputRadius]) {
1282 [newVisualEffectViews addObject:subview];
1285 XCTAssertEqual(newVisualEffectViews.count, 5u);
1287 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1288 UIView* newView = newVisualEffectViews[i];
1289 id mockNewView = OCMPartialMock(newView);
1290 UIView* originalView = originalVisualEffectViews[i];
1292 XCTAssertEqual(originalView, newView);
1293 OCMReject([mockNewView removeFromSuperview]);
1294 [mockNewView stopMocking];
1296 [newVisualEffectViews removeAllObjects];
1300 for (
int i = 0; i < 5; i++) {
1304 for (
int i = 0; i < 5; i++) {
1305 auto filter2 = flutter::DlBlurImageFilter::Make(i, 2, flutter::DlTileMode::kClamp);
1307 stack2.PushBackdropFilter(filter2,
1308 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1311 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1312 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1314 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1315 withParams:std::move(embeddedViewParams)];
1316 [flutterPlatformViewsController
1320 [flutterView setNeedsLayout];
1321 [flutterView layoutIfNeeded];
1323 for (UIView* subview in childClippingView.subviews) {
1324 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1327 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1328 if ([
self validateOneVisualEffectView:subview
1329 expectedFrame:CGRectMake(0, 0, 10, 10)
1330 inputRadius:(CGFloat)newVisualEffectViews.count]) {
1331 [newVisualEffectViews addObject:subview];
1334 XCTAssertEqual(newVisualEffectViews.count, 5u);
1336 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1337 UIView* newView = newVisualEffectViews[i];
1338 id mockNewView = OCMPartialMock(newView);
1339 UIView* originalView = originalVisualEffectViews[i];
1341 XCTAssertEqual(originalView, newView);
1342 OCMReject([mockNewView removeFromSuperview]);
1343 [mockNewView stopMocking];
1345 [newVisualEffectViews removeAllObjects];
1348 - (void)testApplyBackdropFilterNotDlBlurImageFilter {
1349 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1355 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1357 flutterPlatformViewsController,
1359 std::make_shared<fml::SyncSwitch>());
1363 [flutterPlatformViewsController
1365 withId:@"MockFlutterPlatformView"
1369 [flutterPlatformViewsController
1373 @"viewType" : @"MockFlutterPlatformView",
1374 @"gestureBlockingPolicy" : @"eager"
1380 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1381 flutterPlatformViewsController.
flutterView = flutterView;
1383 flutter::MutatorsStack stack;
1385 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1386 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1387 stack.PushTransform(screenScaleMatrix);
1389 auto dilateFilter = flutter::DlDilateImageFilter::Make(5, 2);
1390 stack.PushBackdropFilter(dilateFilter, flutter::DlRect());
1392 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1393 screenScaleMatrix, flutter::DlSize(10, 10), stack);
1395 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1396 withParams:std::move(embeddedViewParams)];
1397 [flutterPlatformViewsController
1404 [flutterView addSubview:childClippingView];
1406 [flutterView setNeedsLayout];
1407 [flutterView layoutIfNeeded];
1409 NSUInteger numberOfExpectedVisualEffectView = 0;
1410 for (UIView* subview in childClippingView.subviews) {
1411 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1412 numberOfExpectedVisualEffectView++;
1415 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1419 flutter::MutatorsStack stack2;
1421 stack2.PushTransform(screenScaleMatrix);
1423 auto blurFilter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1425 for (
int i = 0; i < 5; i++) {
1427 stack2.PushBackdropFilter(
1428 dilateFilter, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1432 stack2.PushBackdropFilter(blurFilter,
1433 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1436 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1437 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1439 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1440 withParams:std::move(embeddedViewParams)];
1441 [flutterPlatformViewsController
1445 [flutterView setNeedsLayout];
1446 [flutterView layoutIfNeeded];
1448 numberOfExpectedVisualEffectView = 0;
1449 for (UIView* subview in childClippingView.subviews) {
1450 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1453 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1454 if ([
self validateOneVisualEffectView:subview
1455 expectedFrame:CGRectMake(0, 0, 10, 10)
1456 inputRadius:(CGFloat)5]) {
1457 numberOfExpectedVisualEffectView++;
1460 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1464 for (
int i = 0; i < 5; i++) {
1468 for (
int i = 0; i < 5; i++) {
1470 stack2.PushBackdropFilter(
1471 dilateFilter, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1475 stack2.PushBackdropFilter(blurFilter,
1476 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1479 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1480 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1482 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1483 withParams:std::move(embeddedViewParams)];
1484 [flutterPlatformViewsController
1488 [flutterView setNeedsLayout];
1489 [flutterView layoutIfNeeded];
1491 numberOfExpectedVisualEffectView = 0;
1492 for (UIView* subview in childClippingView.subviews) {
1493 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1496 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1497 if ([
self validateOneVisualEffectView:subview
1498 expectedFrame:CGRectMake(0, 0, 10, 10)
1499 inputRadius:(CGFloat)5]) {
1500 numberOfExpectedVisualEffectView++;
1503 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1507 for (
int i = 0; i < 5; i++) {
1511 for (
int i = 0; i < 5; i++) {
1513 stack2.PushBackdropFilter(
1514 dilateFilter, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1518 stack2.PushBackdropFilter(blurFilter,
1519 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1522 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1523 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1525 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1526 withParams:std::move(embeddedViewParams)];
1527 [flutterPlatformViewsController
1531 [flutterView setNeedsLayout];
1532 [flutterView layoutIfNeeded];
1534 numberOfExpectedVisualEffectView = 0;
1535 for (UIView* subview in childClippingView.subviews) {
1536 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1539 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1540 if ([
self validateOneVisualEffectView:subview
1541 expectedFrame:CGRectMake(0, 0, 10, 10)
1542 inputRadius:(CGFloat)5]) {
1543 numberOfExpectedVisualEffectView++;
1546 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1550 for (
int i = 0; i < 5; i++) {
1554 for (
int i = 0; i < 5; i++) {
1555 stack2.PushBackdropFilter(dilateFilter,
1556 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1559 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1560 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1562 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1563 withParams:std::move(embeddedViewParams)];
1564 [flutterPlatformViewsController
1568 [flutterView setNeedsLayout];
1569 [flutterView layoutIfNeeded];
1571 numberOfExpectedVisualEffectView = 0;
1572 for (UIView* subview in childClippingView.subviews) {
1573 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1574 numberOfExpectedVisualEffectView++;
1577 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1580 - (void)testApplyBackdropFilterCorrectAPI {
1585 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1586 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1591 isRoundedSuperellipse:NO
1592 visualEffectView:visualEffectView];
1593 XCTAssertNotNil(platformViewFilter);
1596 - (void)testApplyBackdropFilterAPIChangedInvalidUIVisualEffectView {
1598 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc] init];
1603 isRoundedSuperellipse:NO
1604 visualEffectView:visualEffectView];
1605 XCTAssertNil(platformViewFilter);
1608 - (void)testApplyBackdropFilterAPIChangedNoGaussianBlurFilter {
1610 UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1611 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1612 NSArray* subviews = editedUIVisualEffectView.subviews;
1613 for (UIView* view in subviews) {
1614 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1615 for (CIFilter* filter in view.layer.filters) {
1616 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1617 [filter setValue:@"notGaussianBlur" forKey:@"name"];
1628 isRoundedSuperellipse:NO
1629 visualEffectView:editedUIVisualEffectView];
1630 XCTAssertNil(platformViewFilter);
1633 - (void)testApplyBackdropFilterAPIChangedInvalidInputRadius {
1635 UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1636 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1637 NSArray* subviews = editedUIVisualEffectView.subviews;
1638 for (UIView* view in subviews) {
1639 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1640 for (CIFilter* filter in view.layer.filters) {
1641 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1642 [filter setValue:@"invalidInputRadius" forKey:@"inputRadius"];
1654 isRoundedSuperellipse:NO
1655 visualEffectView:editedUIVisualEffectView];
1656 XCTAssertNil(platformViewFilter);
1659 - (void)testApplyBackdropFilterRespectsClipRRect {
1660 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1666 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1668 flutterPlatformViewsController,
1670 std::make_shared<fml::SyncSwitch>());
1674 [flutterPlatformViewsController
1676 withId:@"MockFlutterPlatformView"
1680 [flutterPlatformViewsController
1685 @"viewType" : @"MockFlutterPlatformView",
1686 @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
1692 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1693 flutterPlatformViewsController.
flutterView = flutterView;
1695 flutter::MutatorsStack stack;
1697 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1698 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1699 stack.PushTransform(screenScaleMatrix);
1702 auto clipRect = flutter::DlRect::MakeXYWH(2, 2, 6, 6);
1703 auto clipRRect = flutter::DlRoundRect::MakeRectXY(clipRect, 3, 3);
1704 stack.PushPlatformViewClipRRect(clipRRect);
1707 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1708 stack.PushBackdropFilter(filter,
1709 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1711 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1712 screenScaleMatrix, flutter::DlSize(10, 10), stack);
1714 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1715 withParams:std::move(embeddedViewParams)];
1716 [flutterPlatformViewsController
1722 [flutterView addSubview:childClippingView];
1724 [flutterView setNeedsLayout];
1725 [flutterView layoutIfNeeded];
1728 XCTAssertEqual(filters.count, 1u);
1730 UIVisualEffectView* visualEffectView = filters[0];
1731 auto radii = clipRRect.GetRadii();
1733 XCTAssertEqual(visualEffectView.layer.cornerRadius, radii.top_left.width);
1734 XCTAssertEqual(visualEffectView.layer.cornerCurve, kCACornerCurveCircular);
1737 - (void)testApplyBackdropFilterRespectsClipRSuperellipse {
1738 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1744 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1746 flutterPlatformViewsController,
1748 std::make_shared<fml::SyncSwitch>());
1752 [flutterPlatformViewsController
1754 withId:@"MockFlutterPlatformView"
1758 [flutterPlatformViewsController
1763 @"viewType" : @"MockFlutterPlatformView",
1764 @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
1770 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1771 flutterPlatformViewsController.
flutterView = flutterView;
1773 flutter::MutatorsStack stack;
1775 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1776 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1777 stack.PushTransform(screenScaleMatrix);
1780 auto clipRect = flutter::DlRect::MakeXYWH(2, 2, 6, 6);
1781 auto clipRSE = flutter::DlRoundSuperellipse::MakeRectXY(clipRect, 3, 3);
1782 stack.PushPlatformViewClipRSuperellipse(clipRSE);
1785 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1786 stack.PushBackdropFilter(filter,
1787 flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1789 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1790 screenScaleMatrix, flutter::DlSize(10, 10), stack);
1792 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1793 withParams:std::move(embeddedViewParams)];
1794 [flutterPlatformViewsController
1800 [flutterView addSubview:childClippingView];
1802 [flutterView setNeedsLayout];
1803 [flutterView layoutIfNeeded];
1806 XCTAssertEqual(filters.count, 1u);
1808 UIVisualEffectView* visualEffectView = filters[0];
1809 auto radii = clipRSE.GetRadii();
1811 XCTAssertEqual(visualEffectView.layer.cornerRadius, radii.top_left.width);
1812 XCTAssertEqual(visualEffectView.layer.cornerCurve, kCACornerCurveContinuous);
1815 - (void)testBackdropFilterVisualEffectSubviewBackgroundColor {
1816 __weak UIVisualEffectView* weakVisualEffectView;
1819 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1820 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1821 weakVisualEffectView = visualEffectView;
1826 isRoundedSuperellipse:NO
1827 visualEffectView:visualEffectView];
1828 CGColorRef visualEffectSubviewBackgroundColor = nil;
1829 for (UIView* view in [platformViewFilter backdropFilterView].subviews) {
1830 if ([NSStringFromClass([view
class]) hasSuffix:
@"VisualEffectSubview"]) {
1831 visualEffectSubviewBackgroundColor = view.layer.backgroundColor;
1835 CGColorEqualToColor(visualEffectSubviewBackgroundColor, UIColor.clearColor.CGColor));
1837 XCTAssertNil(weakVisualEffectView);
1840 - (void)testCompositePlatformView {
1841 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1847 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1849 flutterPlatformViewsController,
1851 std::make_shared<fml::SyncSwitch>());
1855 [flutterPlatformViewsController
1857 withId:@"MockFlutterPlatformView"
1861 [flutterPlatformViewsController
1865 @"viewType" : @"MockFlutterPlatformView",
1866 @"gestureBlockingPolicy" : @"eager"
1872 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
1873 flutterPlatformViewsController.
flutterView = flutterView;
1875 flutter::MutatorsStack stack;
1877 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1878 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1879 stack.PushTransform(screenScaleMatrix);
1881 flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
1882 stack.PushTransform(translateMatrix);
1883 flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
1885 auto embeddedViewParams =
1886 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
1888 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1889 withParams:std::move(embeddedViewParams)];
1890 [flutterPlatformViewsController
1894 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1895 toView:flutterView];
1896 XCTAssertTrue(CGRectEqualToRect(platformViewRectInFlutterView, CGRectMake(100, 100, 300, 300)));
1899 - (void)testBackdropFilterCorrectlyPushedAndReset {
1900 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1906 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1908 flutterPlatformViewsController,
1910 std::make_shared<fml::SyncSwitch>());
1914 [flutterPlatformViewsController
1916 withId:@"MockFlutterPlatformView"
1920 [flutterPlatformViewsController
1924 @"viewType" : @"MockFlutterPlatformView",
1925 @"gestureBlockingPolicy" : @"eager"
1931 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1932 flutterPlatformViewsController.
flutterView = flutterView;
1934 flutter::MutatorsStack stack;
1936 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1937 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1938 stack.PushTransform(screenScaleMatrix);
1940 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1941 screenScaleMatrix, flutter::DlSize(10, 10), stack);
1943 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(0, 0)];
1944 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1945 withParams:std::move(embeddedViewParams)];
1947 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp, std::nullopt);
1948 [flutterPlatformViewsController
1949 pushFilterToVisitedPlatformViews:filter
1950 withRect:flutter::DlRect::MakeXYWH(0, 0, screenScale * 10,
1952 [flutterPlatformViewsController
1958 [flutterView addSubview:childClippingView];
1960 [flutterView setNeedsLayout];
1961 [flutterView layoutIfNeeded];
1964 NSUInteger numberOfExpectedVisualEffectView = 0;
1965 for (UIView* subview in childClippingView.subviews) {
1966 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1969 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
1970 if ([
self validateOneVisualEffectView:subview
1971 expectedFrame:CGRectMake(0, 0, 10, 10)
1973 numberOfExpectedVisualEffectView++;
1976 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
1979 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
1980 screenScaleMatrix, flutter::DlSize(10, 10), stack);
1981 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(0, 0)];
1982 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1983 withParams:std::move(embeddedViewParams2)];
1984 [flutterPlatformViewsController
1990 [flutterView setNeedsLayout];
1991 [flutterView layoutIfNeeded];
1993 numberOfExpectedVisualEffectView = 0;
1994 for (UIView* subview in childClippingView.subviews) {
1995 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1998 numberOfExpectedVisualEffectView++;
2000 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
2003 - (void)testChildClippingViewShouldBeTheBoundingRectOfPlatformView {
2004 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2010 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2012 flutterPlatformViewsController,
2014 std::make_shared<fml::SyncSwitch>());
2018 [flutterPlatformViewsController
2020 withId:@"MockFlutterPlatformView"
2024 [flutterPlatformViewsController
2028 @"viewType" : @"MockFlutterPlatformView",
2029 @"gestureBlockingPolicy" : @"eager"
2035 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2036 flutterPlatformViewsController.
flutterView = flutterView;
2038 flutter::MutatorsStack stack;
2040 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2041 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2042 stack.PushTransform(screenScaleMatrix);
2044 flutter::DlMatrix rotateMatrix = flutter::DlMatrix::MakeRotationZ(flutter::DlDegrees(10));
2045 stack.PushTransform(rotateMatrix);
2046 flutter::DlMatrix finalMatrix = screenScaleMatrix * rotateMatrix;
2048 auto embeddedViewParams =
2049 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
2051 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2052 withParams:std::move(embeddedViewParams)];
2053 [flutterPlatformViewsController
2057 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
2058 toView:flutterView];
2064 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.x - childClippingView.frame.origin.x),
2066 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.y - childClippingView.frame.origin.y),
2069 fabs(platformViewRectInFlutterView.size.width - childClippingView.frame.size.width),
2072 fabs(platformViewRectInFlutterView.size.height - childClippingView.frame.size.height),
2076 - (void)testClipsDoNotInterceptWithPlatformViewShouldNotAddMaskView {
2077 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2083 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2085 flutterPlatformViewsController,
2087 std::make_shared<fml::SyncSwitch>());
2091 [flutterPlatformViewsController
2093 withId:@"MockFlutterPlatformView"
2097 [flutterPlatformViewsController
2101 @"viewType" : @"MockFlutterPlatformView",
2102 @"gestureBlockingPolicy" : @"eager"
2108 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
2109 flutterPlatformViewsController.
flutterView = flutterView;
2111 flutter::MutatorsStack stack;
2113 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2114 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2115 stack.PushTransform(screenScaleMatrix);
2116 flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({5, 5});
2118 stack.PushTransform(translateMatrix);
2120 flutter::DlRect rect = flutter::DlRect::MakeXYWH(0, 0, 25, 25);
2121 stack.PushClipRect(rect);
2124 flutter::DlRect rect_for_rrect = flutter::DlRect::MakeXYWH(-1, -1, 25, 25);
2125 flutter::DlRoundRect rrect = flutter::DlRoundRect::MakeRectXY(rect_for_rrect, 1, 1);
2126 stack.PushClipRRect(rrect);
2128 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2129 screenScaleMatrix * translateMatrix, flutter::DlSize(5, 5), stack);
2131 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2132 withParams:std::move(embeddedViewParams)];
2133 [flutterPlatformViewsController
2140 [flutterView addSubview:childClippingView];
2142 [flutterView setNeedsLayout];
2143 [flutterView layoutIfNeeded];
2144 XCTAssertNil(childClippingView.maskView);
2147 - (void)testClipRRectOnlyHasCornersInterceptWithPlatformViewShouldAddMaskView {
2148 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2154 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2156 flutterPlatformViewsController,
2158 std::make_shared<fml::SyncSwitch>());
2162 [flutterPlatformViewsController
2164 withId:@"MockFlutterPlatformView"
2168 [flutterPlatformViewsController
2172 @"viewType" : @"MockFlutterPlatformView",
2173 @"gestureBlockingPolicy" : @"eager"
2179 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
2180 flutterPlatformViewsController.
flutterView = flutterView;
2182 flutter::MutatorsStack stack;
2184 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2185 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2186 stack.PushTransform(screenScaleMatrix);
2187 flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({5, 5});
2189 stack.PushTransform(translateMatrix);
2193 flutter::DlRect rect_for_rrect = flutter::DlRect::MakeXYWH(0, 0, 10, 10);
2194 flutter::DlRoundRect rrect = flutter::DlRoundRect::MakeRectXY(rect_for_rrect, 1, 1);
2195 stack.PushClipRRect(rrect);
2197 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2198 screenScaleMatrix * translateMatrix, flutter::DlSize(5, 5), stack);
2200 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2201 withParams:std::move(embeddedViewParams)];
2202 [flutterPlatformViewsController
2209 [flutterView addSubview:childClippingView];
2211 [flutterView setNeedsLayout];
2212 [flutterView layoutIfNeeded];
2214 XCTAssertNotNil(childClippingView.maskView);
2217 - (void)testClipRect {
2218 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2224 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2226 flutterPlatformViewsController,
2228 std::make_shared<fml::SyncSwitch>());
2232 [flutterPlatformViewsController
2234 withId:@"MockFlutterPlatformView"
2238 [flutterPlatformViewsController
2242 @"viewType" : @"MockFlutterPlatformView",
2243 @"gestureBlockingPolicy" : @"eager"
2249 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2250 flutterPlatformViewsController.
flutterView = flutterView;
2252 flutter::MutatorsStack stack;
2254 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2255 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2256 stack.PushTransform(screenScaleMatrix);
2258 flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
2259 stack.PushClipRect(rect);
2261 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2262 screenScaleMatrix, flutter::DlSize(10, 10), stack);
2264 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2265 withParams:std::move(embeddedViewParams)];
2266 [flutterPlatformViewsController
2273 [flutterView addSubview:childClippingView];
2275 [flutterView setNeedsLayout];
2276 [flutterView layoutIfNeeded];
2278 CGRect insideClipping = CGRectMake(2, 2, 3, 3);
2279 for (
int i = 0; i < 10; i++) {
2280 for (
int j = 0; j < 10; j++) {
2281 CGPoint point = CGPointMake(i, j);
2282 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2283 if (CGRectContainsPoint(insideClipping, point)) {
2284 XCTAssertEqual(alpha, 255);
2286 XCTAssertEqual(alpha, 0);
2292 - (void)testClipRect_multipleClips {
2293 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2299 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2301 flutterPlatformViewsController,
2303 std::make_shared<fml::SyncSwitch>());
2307 [flutterPlatformViewsController
2309 withId:@"MockFlutterPlatformView"
2313 [flutterPlatformViewsController
2317 @"viewType" : @"MockFlutterPlatformView",
2318 @"gestureBlockingPolicy" : @"eager"
2324 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2325 flutterPlatformViewsController.
flutterView = flutterView;
2327 flutter::MutatorsStack stack;
2329 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2330 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2331 stack.PushTransform(screenScaleMatrix);
2333 flutter::DlRect rect1 = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
2334 stack.PushClipRect(rect1);
2336 flutter::DlRect rect2 = flutter::DlRect::MakeXYWH(3, 3, 3, 3);
2337 stack.PushClipRect(rect2);
2339 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2340 screenScaleMatrix, flutter::DlSize(10, 10), stack);
2342 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2343 withParams:std::move(embeddedViewParams)];
2344 [flutterPlatformViewsController
2351 [flutterView addSubview:childClippingView];
2353 [flutterView setNeedsLayout];
2354 [flutterView layoutIfNeeded];
2373 CGRect insideClipping = CGRectMake(3, 3, 2, 2);
2374 for (
int i = 0; i < 10; i++) {
2375 for (
int j = 0; j < 10; j++) {
2376 CGPoint point = CGPointMake(i, j);
2377 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2378 if (CGRectContainsPoint(insideClipping, point)) {
2379 XCTAssertEqual(alpha, 255);
2381 XCTAssertEqual(alpha, 0);
2387 - (void)testClipRRect {
2388 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2394 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2396 flutterPlatformViewsController,
2398 std::make_shared<fml::SyncSwitch>());
2402 [flutterPlatformViewsController
2404 withId:@"MockFlutterPlatformView"
2408 [flutterPlatformViewsController
2412 @"viewType" : @"MockFlutterPlatformView",
2413 @"gestureBlockingPolicy" : @"eager"
2419 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2420 flutterPlatformViewsController.
flutterView = flutterView;
2422 flutter::MutatorsStack stack;
2424 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2425 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2426 stack.PushTransform(screenScaleMatrix);
2428 flutter::DlRoundRect rrect =
2429 flutter::DlRoundRect::MakeRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2430 stack.PushClipRRect(rrect);
2432 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2433 screenScaleMatrix, flutter::DlSize(10, 10), stack);
2435 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2436 withParams:std::move(embeddedViewParams)];
2437 [flutterPlatformViewsController
2444 [flutterView addSubview:childClippingView];
2446 [flutterView setNeedsLayout];
2447 [flutterView layoutIfNeeded];
2468 CGRect innerClipping1 = CGRectMake(3, 2, 4, 6);
2469 CGRect innerClipping2 = CGRectMake(2, 3, 6, 4);
2470 CGRect outterClipping = CGRectMake(2, 2, 6, 6);
2471 for (
int i = 0; i < 10; i++) {
2472 for (
int j = 0; j < 10; j++) {
2473 CGPoint point = CGPointMake(i, j);
2474 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2475 if (CGRectContainsPoint(innerClipping1, point) ||
2476 CGRectContainsPoint(innerClipping2, point)) {
2478 XCTAssertEqual(alpha, 255);
2479 }
else if (CGRectContainsPoint(outterClipping, point)) {
2481 XCTAssert(0 < alpha && alpha < 255);
2484 XCTAssertEqual(alpha, 0);
2490 - (void)testClipRRect_multipleClips {
2491 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2497 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2499 flutterPlatformViewsController,
2501 std::make_shared<fml::SyncSwitch>());
2505 [flutterPlatformViewsController
2507 withId:@"MockFlutterPlatformView"
2511 [flutterPlatformViewsController
2515 @"viewType" : @"MockFlutterPlatformView",
2516 @"gestureBlockingPolicy" : @"eager"
2522 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2523 flutterPlatformViewsController.
flutterView = flutterView;
2525 flutter::MutatorsStack stack;
2527 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2528 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2529 stack.PushTransform(screenScaleMatrix);
2531 flutter::DlRoundRect rrect =
2532 flutter::DlRoundRect::MakeRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2533 stack.PushClipRRect(rrect);
2535 flutter::DlRect rect = flutter::DlRect::MakeXYWH(4, 2, 6, 6);
2536 stack.PushClipRect(rect);
2538 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2539 screenScaleMatrix, flutter::DlSize(10, 10), stack);
2541 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2542 withParams:std::move(embeddedViewParams)];
2543 [flutterPlatformViewsController
2550 [flutterView addSubview:childClippingView];
2552 [flutterView setNeedsLayout];
2553 [flutterView layoutIfNeeded];
2574 CGRect clipping = CGRectMake(4, 2, 4, 6);
2575 for (
int i = 0; i < 10; i++) {
2576 for (
int j = 0; j < 10; j++) {
2577 CGPoint point = CGPointMake(i, j);
2578 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2579 if (i == 7 && (j == 2 || j == 7)) {
2581 XCTAssert(0 < alpha && alpha < 255);
2584 (i == 4 && j >= 2 && j <= 7) ||
2586 (i == 7 && j >= 2 && j <= 7) ||
2588 (j == 2 && i >= 4 && i <= 7) ||
2590 (j == 7 && i >= 4 && i <= 7)) {
2593 XCTAssert(alpha > 127);
2594 }
else if ((i == 3 && j >= 1 && j <= 8) || (i == 8 && j >= 1 && j <= 8) ||
2595 (j == 1 && i >= 3 && i <= 8) || (j == 8 && i >= 3 && i <= 8)) {
2598 XCTAssert(alpha < 127);
2599 }
else if (CGRectContainsPoint(clipping, point)) {
2601 XCTAssertEqual(alpha, 255);
2604 XCTAssertEqual(alpha, 0);
2610 - (void)testClipPath {
2611 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2617 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2619 flutterPlatformViewsController,
2621 std::make_shared<fml::SyncSwitch>());
2625 [flutterPlatformViewsController
2627 withId:@"MockFlutterPlatformView"
2631 [flutterPlatformViewsController
2635 @"viewType" : @"MockFlutterPlatformView",
2636 @"gestureBlockingPolicy" : @"eager"
2642 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2643 flutterPlatformViewsController.
flutterView = flutterView;
2645 flutter::MutatorsStack stack;
2647 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2648 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2649 stack.PushTransform(screenScaleMatrix);
2651 flutter::DlPath path =
2652 flutter::DlPath::MakeRoundRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2653 stack.PushClipPath(path);
2655 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2656 screenScaleMatrix, flutter::DlSize(10, 10), stack);
2658 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2659 withParams:std::move(embeddedViewParams)];
2660 [flutterPlatformViewsController
2667 [flutterView addSubview:childClippingView];
2669 [flutterView setNeedsLayout];
2670 [flutterView layoutIfNeeded];
2691 CGRect innerClipping1 = CGRectMake(3, 2, 4, 6);
2692 CGRect innerClipping2 = CGRectMake(2, 3, 6, 4);
2693 CGRect outterClipping = CGRectMake(2, 2, 6, 6);
2694 for (
int i = 0; i < 10; i++) {
2695 for (
int j = 0; j < 10; j++) {
2696 CGPoint point = CGPointMake(i, j);
2697 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2698 if (CGRectContainsPoint(innerClipping1, point) ||
2699 CGRectContainsPoint(innerClipping2, point)) {
2701 XCTAssertEqual(alpha, 255);
2702 }
else if (CGRectContainsPoint(outterClipping, point)) {
2704 XCTAssert(0 < alpha && alpha < 255);
2707 XCTAssertEqual(alpha, 0);
2713 - (void)testClipPath_multipleClips {
2714 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2720 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2722 flutterPlatformViewsController,
2724 std::make_shared<fml::SyncSwitch>());
2728 [flutterPlatformViewsController
2730 withId:@"MockFlutterPlatformView"
2734 [flutterPlatformViewsController
2738 @"viewType" : @"MockFlutterPlatformView",
2739 @"gestureBlockingPolicy" : @"eager"
2745 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2746 flutterPlatformViewsController.
flutterView = flutterView;
2748 flutter::MutatorsStack stack;
2750 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2751 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2752 stack.PushTransform(screenScaleMatrix);
2754 flutter::DlPath path =
2755 flutter::DlPath::MakeRoundRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2756 stack.PushClipPath(path);
2758 flutter::DlRect rect = flutter::DlRect::MakeXYWH(4, 2, 6, 6);
2759 stack.PushClipRect(rect);
2761 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2762 screenScaleMatrix, flutter::DlSize(10, 10), stack);
2764 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2765 withParams:std::move(embeddedViewParams)];
2766 [flutterPlatformViewsController
2773 [flutterView addSubview:childClippingView];
2775 [flutterView setNeedsLayout];
2776 [flutterView layoutIfNeeded];
2797 CGRect clipping = CGRectMake(4, 2, 4, 6);
2798 for (
int i = 0; i < 10; i++) {
2799 for (
int j = 0; j < 10; j++) {
2800 CGPoint point = CGPointMake(i, j);
2801 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2802 if (i == 7 && (j == 2 || j == 7)) {
2804 XCTAssert(0 < alpha && alpha < 255);
2807 (i == 4 && j >= 2 && j <= 7) ||
2809 (i == 7 && j >= 2 && j <= 7) ||
2811 (j == 2 && i >= 4 && i <= 7) ||
2813 (j == 7 && i >= 4 && i <= 7)) {
2816 XCTAssert(alpha > 127);
2817 }
else if ((i == 3 && j >= 1 && j <= 8) || (i == 8 && j >= 1 && j <= 8) ||
2818 (j == 1 && i >= 3 && i <= 8) || (j == 8 && i >= 3 && i <= 8)) {
2821 XCTAssert(alpha < 127);
2822 }
else if (CGRectContainsPoint(clipping, point)) {
2824 XCTAssertEqual(alpha, 255);
2827 XCTAssertEqual(alpha, 0);
2833 - (void)testSetFlutterViewControllerAfterCreateCanStillDispatchTouchEvents {
2834 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2840 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2842 flutterPlatformViewsController,
2844 std::make_shared<fml::SyncSwitch>());
2848 [flutterPlatformViewsController
2850 withId:@"MockFlutterPlatformView"
2854 [flutterPlatformViewsController
2858 @"viewType" : @"MockFlutterPlatformView",
2859 @"gestureBlockingPolicy" : @"eager"
2866 XCTAssertNotNil(touchInterceptorView);
2868 UIGestureRecognizer* forwardGectureRecognizer =
2869 FindForwardingGestureRecognizer(touchInterceptorView);
2872 NSSet* touches1 = [[NSSet alloc] init];
2873 id event1 = OCMClassMock([UIEvent
class]);
2875 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2876 OCMReject([flutterViewController touchesBegan:touches1 withEvent:event1]);
2879 NSSet* touches2 = [[NSSet alloc] init];
2880 id event2 = OCMClassMock([UIEvent
class]);
2882 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
2883 OCMVerify([flutterViewController touchesBegan:touches2 withEvent:event2]);
2886 - (void)testSetFlutterViewControllerInTheMiddleOfTouchEventShouldStillAllowGesturesToBeHandled {
2887 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2893 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2895 flutterPlatformViewsController,
2897 std::make_shared<fml::SyncSwitch>());
2901 [flutterPlatformViewsController
2903 withId:@"MockFlutterPlatformView"
2907 [flutterPlatformViewsController
2911 @"viewType" : @"MockFlutterPlatformView",
2912 @"gestureBlockingPolicy" : @"eager"
2919 XCTAssertNotNil(touchInterceptorView);
2921 UIGestureRecognizer* forwardGectureRecognizer =
2922 FindForwardingGestureRecognizer(touchInterceptorView);
2928 NSSet* touches1 = [[NSSet alloc] init];
2929 id event1 = OCMClassMock([UIEvent
class]);
2930 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2931 OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
2936 NSSet* touches2 = [[NSSet alloc] init];
2937 id event2 = OCMClassMock([UIEvent
class]);
2938 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2939 OCMVerify([flutterViewController touchesMoved:touches2 withEvent:event2]);
2941 NSSet* touches3 = [[NSSet alloc] init];
2942 id event3 = OCMClassMock([UIEvent
class]);
2943 [forwardGectureRecognizer touchesEnded:touches3 withEvent:event3];
2944 OCMVerify([flutterViewController touchesEnded:touches3 withEvent:event3]);
2947 NSSet* touches4 = [[NSSet alloc] init];
2948 id event4 = OCMClassMock([UIEvent
class]);
2949 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2950 OCMReject([flutterViewController touchesBegan:touches4 withEvent:event4]);
2952 NSSet* touches5 = [[NSSet alloc] init];
2953 id event5 = OCMClassMock([UIEvent
class]);
2954 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2955 OCMReject([flutterViewController touchesEnded:touches5 withEvent:event5]);
2962 NSSet* touches1 = [[NSSet alloc] init];
2963 id event1 = OCMClassMock([UIEvent
class]);
2964 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2965 OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
2970 NSSet* touches2 = [[NSSet alloc] init];
2971 id event2 = OCMClassMock([UIEvent
class]);
2972 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2973 OCMVerify([flutterViewController touchesMoved:touches2 withEvent:event2]);
2975 NSSet* touches3 = [[NSSet alloc] init];
2976 id event3 = OCMClassMock([UIEvent
class]);
2977 [forwardGectureRecognizer touchesCancelled:touches3 withEvent:event3];
2978 OCMVerify([flutterViewController forceTouchesCancelled:touches3]);
2981 NSSet* touches4 = [[NSSet alloc] init];
2982 id event4 = OCMClassMock([UIEvent
class]);
2983 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2984 OCMReject([flutterViewController touchesBegan:touches4 withEvent:event4]);
2986 NSSet* touches5 = [[NSSet alloc] init];
2987 id event5 = OCMClassMock([UIEvent
class]);
2988 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2989 OCMReject([flutterViewController touchesEnded:touches5 withEvent:event5]);
2992 [flutterPlatformViewsController
reset];
2996 testSetFlutterViewControllerInTheMiddleOfTouchEventAllowsTheNewControllerToHandleSecondTouchSequence {
2997 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3003 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3005 flutterPlatformViewsController,
3007 std::make_shared<fml::SyncSwitch>());
3011 [flutterPlatformViewsController
3013 withId:@"MockFlutterPlatformView"
3017 [flutterPlatformViewsController
3021 @"viewType" : @"MockFlutterPlatformView",
3022 @"gestureBlockingPolicy" : @"eager"
3029 XCTAssertNotNil(touchInterceptorView);
3031 UIGestureRecognizer* forwardGectureRecognizer =
3032 FindForwardingGestureRecognizer(touchInterceptorView);
3037 NSSet* touches1 = [NSSet setWithObject:@1];
3038 id event1 = OCMClassMock([UIEvent
class]);
3039 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
3040 OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
3047 NSSet* touches2 = [NSSet setWithObject:@1];
3048 id event2 = OCMClassMock([UIEvent
class]);
3049 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
3050 OCMVerify([flutterViewController touchesBegan:touches2 withEvent:event2]);
3051 OCMReject([flutterViewController2 touchesBegan:touches2 withEvent:event2]);
3053 NSSet* touches3 = [NSSet setWithObject:@1];
3054 id event3 = OCMClassMock([UIEvent
class]);
3055 [forwardGectureRecognizer touchesMoved:touches3 withEvent:event3];
3056 OCMVerify([flutterViewController touchesMoved:touches3 withEvent:event3]);
3057 OCMReject([flutterViewController2 touchesMoved:touches3 withEvent:event3]);
3059 NSSet* touches4 = [NSSet setWithObject:@1];
3060 id event4 = OCMClassMock([UIEvent
class]);
3061 [forwardGectureRecognizer touchesEnded:touches4 withEvent:event4];
3062 OCMVerify([flutterViewController touchesEnded:touches4 withEvent:event4]);
3063 OCMReject([flutterViewController2 touchesEnded:touches4 withEvent:event4]);
3065 NSSet* touches5 = [NSSet setWithObject:@1];
3066 id event5 = OCMClassMock([UIEvent
class]);
3067 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
3068 OCMVerify([flutterViewController touchesEnded:touches5 withEvent:event5]);
3069 OCMReject([flutterViewController2 touchesEnded:touches5 withEvent:event5]);
3073 NSSet* touches6 = [NSSet setWithObject:@1];
3074 id event6 = OCMClassMock([UIEvent
class]);
3075 [forwardGectureRecognizer touchesBegan:touches6 withEvent:event6];
3076 OCMVerify([flutterViewController2 touchesBegan:touches6 withEvent:event6]);
3077 OCMReject([flutterViewController touchesBegan:touches6 withEvent:event6]);
3080 NSSet* touches7 = [NSSet setWithObject:@1];
3081 id event7 = OCMClassMock([UIEvent
class]);
3082 [forwardGectureRecognizer touchesMoved:touches7 withEvent:event7];
3083 OCMVerify([flutterViewController2 touchesMoved:touches7 withEvent:event7]);
3084 OCMReject([flutterViewController touchesMoved:touches7 withEvent:event7]);
3086 NSSet* touches8 = [NSSet setWithObject:@1];
3087 id event8 = OCMClassMock([UIEvent
class]);
3088 [forwardGectureRecognizer touchesEnded:touches8 withEvent:event8];
3089 OCMVerify([flutterViewController2 touchesEnded:touches8 withEvent:event8]);
3090 OCMReject([flutterViewController touchesEnded:touches8 withEvent:event8]);
3092 [flutterPlatformViewsController
reset];
3095 - (void)testFlutterPlatformViewTouchesCancelledEventAreForcedToBeCancelled {
3096 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3102 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3104 flutterPlatformViewsController,
3106 std::make_shared<fml::SyncSwitch>());
3110 [flutterPlatformViewsController
3112 withId:@"MockFlutterPlatformView"
3116 [flutterPlatformViewsController
3120 @"viewType" : @"MockFlutterPlatformView",
3121 @"gestureBlockingPolicy" : @"eager"
3128 XCTAssertNotNil(touchInterceptorView);
3130 UIGestureRecognizer* forwardGectureRecognizer =
3131 FindForwardingGestureRecognizer(touchInterceptorView);
3135 NSSet* touches1 = [NSSet setWithObject:@1];
3136 id event1 = OCMClassMock([UIEvent
class]);
3137 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
3139 [forwardGectureRecognizer touchesCancelled:touches1 withEvent:event1];
3140 OCMVerify([flutterViewController forceTouchesCancelled:touches1]);
3142 [flutterPlatformViewsController
reset];
3145 - (void)testFlutterPlatformViewTouchesEndedOrTouchesCancelledEventDoesNotFailTheGestureRecognizer {
3150 if (@available(iOS 26.0, *)) {
3154 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3160 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3162 flutterPlatformViewsController,
3164 std::make_shared<fml::SyncSwitch>());
3168 [flutterPlatformViewsController
3170 withId:@"MockFlutterPlatformView"
3174 [flutterPlatformViewsController
3178 @"viewType" : @"MockFlutterPlatformView",
3179 @"gestureBlockingPolicy" : @"eager"
3186 XCTAssertNotNil(touchInterceptorView);
3188 __block UIGestureRecognizer* forwardGestureRecognizer =
3189 FindForwardingGestureRecognizer(touchInterceptorView);
3193 NSSet* touches1 = [NSSet setWithObject:@1];
3194 id event1 = OCMClassMock([UIEvent
class]);
3195 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3196 @"Forwarding gesture recognizer must start with possible state.");
3197 [forwardGestureRecognizer touchesBegan:touches1 withEvent:event1];
3198 [forwardGestureRecognizer touchesEnded:touches1 withEvent:event1];
3199 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStateFailed,
3200 @"Forwarding gesture recognizer must end with failed state.");
3202 XCTestExpectation* touchEndedExpectation =
3203 [
self expectationWithDescription:@"Wait for gesture recognizer's state change."];
3204 dispatch_async(dispatch_get_main_queue(), ^{
3206 forwardGestureRecognizer = FindForwardingGestureRecognizer(touchInterceptorView);
3207 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3208 @"Forwarding gesture recognizer must be reset to possible state.");
3209 [touchEndedExpectation fulfill];
3211 [
self waitForExpectationsWithTimeout:30 handler:nil];
3213 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3214 @"Forwarding gesture recognizer must start with possible state.");
3215 [forwardGestureRecognizer touchesBegan:touches1 withEvent:event1];
3216 [forwardGestureRecognizer touchesCancelled:touches1 withEvent:event1];
3217 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStateFailed,
3218 @"Forwarding gesture recognizer must end with failed state.");
3219 XCTestExpectation* touchCancelledExpectation =
3220 [
self expectationWithDescription:@"Wait for gesture recognizer's state change."];
3221 dispatch_async(dispatch_get_main_queue(), ^{
3223 forwardGestureRecognizer = FindForwardingGestureRecognizer(touchInterceptorView);
3224 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3225 @"Forwarding gesture recognizer must be reset to possible state.");
3226 [touchCancelledExpectation fulfill];
3228 [
self waitForExpectationsWithTimeout:30 handler:nil];
3230 [flutterPlatformViewsController
reset];
3234 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForWebView {
3235 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3241 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3243 flutterPlatformViewsController,
3245 std::make_shared<fml::SyncSwitch>());
3249 [flutterPlatformViewsController
3255 [flutterPlatformViewsController
3259 @"viewType" : @"MockWebView",
3260 @"gestureBlockingPolicy" : @"eager"
3267 XCTAssertNotNil(touchInterceptorView);
3269 XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3270 UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3271 UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3278 BOOL shouldReAddDelayingRecognizer = NO;
3279 if (@available(iOS 26.0, *)) {
3283 }
else if (@available(iOS 18.2, *)) {
3284 shouldReAddDelayingRecognizer = YES;
3286 if (shouldReAddDelayingRecognizer) {
3288 XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], forwardingRecognizer);
3289 XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], delayingRecognizer);
3291 XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3292 XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3297 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForWrapperWebView {
3298 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3304 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3306 flutterPlatformViewsController,
3308 std::make_shared<fml::SyncSwitch>());
3312 [flutterPlatformViewsController
3314 withId:@"MockWrapperWebView"
3318 [flutterPlatformViewsController
3323 @"viewType" : @"MockWrapperWebView",
3324 @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3331 XCTAssertNotNil(touchInterceptorView);
3333 XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3334 UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3335 UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3342 BOOL shouldReAddDelayingRecognizer = NO;
3343 if (@available(iOS 26.0, *)) {
3347 }
else if (@available(iOS 18.2, *)) {
3348 shouldReAddDelayingRecognizer = YES;
3350 if (shouldReAddDelayingRecognizer) {
3352 XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], forwardingRecognizer);
3353 XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], delayingRecognizer);
3355 XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3356 XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3361 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForNestedWrapperWebView {
3362 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3368 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3370 flutterPlatformViewsController,
3372 std::make_shared<fml::SyncSwitch>());
3376 [flutterPlatformViewsController
3378 withId:@"MockNestedWrapperWebView"
3382 [flutterPlatformViewsController
3386 @"viewType" : @"MockNestedWrapperWebView",
3387 @"gestureBlockingPolicy" : @"eager"
3394 XCTAssertNotNil(touchInterceptorView);
3396 XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3397 UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3398 UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3405 BOOL shouldReAddDelayingRecognizer = NO;
3406 if (@available(iOS 26.0, *)) {
3410 }
else if (@available(iOS 18.2, *)) {
3411 shouldReAddDelayingRecognizer = YES;
3413 if (shouldReAddDelayingRecognizer) {
3415 XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], forwardingRecognizer);
3416 XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], delayingRecognizer);
3418 XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3419 XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3424 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldNotRemoveAndAddBackDelayingRecognizerForNonWebView {
3425 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3431 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3433 flutterPlatformViewsController,
3435 std::make_shared<fml::SyncSwitch>());
3439 [flutterPlatformViewsController
3441 withId:@"MockFlutterPlatformView"
3445 [flutterPlatformViewsController
3449 @"viewType" : @"MockFlutterPlatformView",
3450 @"gestureBlockingPolicy" : @"eager"
3457 XCTAssertNotNil(touchInterceptorView);
3459 XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3460 UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3461 UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3468 XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3469 XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3473 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForSimpleWebView {
3474 if (@available(iOS 26.4, *)) {
3476 }
else if (@available(iOS 26.0, *)) {
3477 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3483 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3485 flutterPlatformViewsController,
3487 std::make_shared<fml::SyncSwitch>());
3491 [flutterPlatformViewsController
3497 [flutterPlatformViewsController
3502 @"viewType" : @"MockWebView",
3503 @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3511 XCTAssertNotNil(touchInterceptorView);
3525 root.gestureRecognizers = nil;
3526 for (UIView* subview in root.subviews) {
3527 [subview removeFromSuperview];
3531 [root addGestureRecognizer:normalRecognizer0];
3533 UIView* child1 = [[UIView alloc] init];
3534 [root addSubview:child1];
3536 [child1 addGestureRecognizer:normalRecognizer1];
3538 UIView* child2 = [[UIView alloc] init];
3539 [root addSubview:child2];
3541 [child2 addGestureRecognizer:normalRecognizer2];
3543 UIView* child2_1 = [[UIView alloc] init];
3544 [child2 addSubview:child2_1];
3546 [child2_1 addGestureRecognizer:normalRecognizer2_1];
3548 UIView* child2_2 = [[UIView alloc] init];
3549 [child2 addSubview:child2_2];
3551 [child2_2 addGestureRecognizer:normalRecognizer2_2];
3556 [root addGestureRecognizer:targetRecognizer0];
3560 [child2_2 addGestureRecognizer:targetRecognizer2_2];
3564 NSArray* normalRecognizers = @[
3565 normalRecognizer0, normalRecognizer1, normalRecognizer2, normalRecognizer2_1,
3569 NSArray* targetRecognizers = @[ targetRecognizer0, targetRecognizer2_2 ];
3571 NSArray* expectedEmptyHistory = @[];
3572 NSArray* expectedToggledHistory = @[ @NO, @YES ];
3575 XCTAssertEqualObjects(recognizer.toggleHistory, expectedEmptyHistory);
3578 XCTAssertEqualObjects(recognizer.toggleHistory, expectedToggledHistory);
3584 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForMultipleWebViewInDifferentBranches {
3585 if (@available(iOS 26.4, *)) {
3587 }
else if (@available(iOS 26.0, *)) {
3588 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3594 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3596 flutterPlatformViewsController,
3598 std::make_shared<fml::SyncSwitch>());
3602 [flutterPlatformViewsController
3604 withId:@"MockWrapperWebView"
3608 [flutterPlatformViewsController
3613 @"viewType" : @"MockWrapperWebView",
3614 @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3622 XCTAssertNotNil(touchInterceptorView);
3640 for (UIView* subview in root.subviews) {
3641 [subview removeFromSuperview];
3645 [root addGestureRecognizer:normalRecognizer0];
3647 UIView* child1 = [[UIView alloc] init];
3648 [root addSubview:child1];
3650 [child1 addGestureRecognizer:normalRecognizer1];
3652 UIView* child2 = [[WKWebView alloc] init];
3653 child2.gestureRecognizers = nil;
3654 for (UIView* subview in child2.subviews) {
3655 [subview removeFromSuperview];
3657 [root addSubview:child2];
3659 [child2 addGestureRecognizer:normalRecognizer2];
3661 UIView* child2_1 = [[UIView alloc] init];
3662 [child2 addSubview:child2_1];
3664 [child2_1 addGestureRecognizer:normalRecognizer2_1];
3666 UIView* child2_2 = [[UIView alloc] init];
3667 [child2 addSubview:child2_2];
3669 [child2_2 addGestureRecognizer:normalRecognizer2_2];
3671 UIView* child3 = [[UIView alloc] init];
3672 [root addSubview:child3];
3674 [child3 addGestureRecognizer:normalRecognizer3];
3676 UIView* child3_1 = [[WKWebView alloc] init];
3677 child3_1.gestureRecognizers = nil;
3678 for (UIView* subview in child3_1.subviews) {
3679 [subview removeFromSuperview];
3681 [child3 addSubview:child3_1];
3683 [child3_1 addGestureRecognizer:normalRecognizer3_1];
3685 UIView* child3_1_1 = [[UIView alloc] init];
3686 [child3_1 addSubview:child3_1_1];
3688 [child3_1_1 addGestureRecognizer:normalRecognizer3_1_1];
3690 UIView* child3_1_2 = [[UIView alloc] init];
3691 [child3_1 addSubview:child3_1_2];
3693 [child3_1_2 addGestureRecognizer:normalRecognizer3_1_2];
3699 [child2_2 addGestureRecognizer:targetRecognizer2_2];
3703 [child3_1_2 addGestureRecognizer:targetRecognizer3_1_2];
3707 NSArray* normalRecognizers = @[
3708 normalRecognizer0, normalRecognizer1, normalRecognizer2, normalRecognizer2_1,
3709 normalRecognizer2_2, normalRecognizer3, normalRecognizer3_1, normalRecognizer3_1_1,
3710 normalRecognizer3_1_2
3712 NSArray* targetRecognizers = @[ targetRecognizer2_2, targetRecognizer3_1_2 ];
3714 NSArray* expectedEmptyHistory = @[];
3715 NSArray* expectedToggledHistory = @[ @NO, @YES ];
3718 XCTAssertEqualObjects(recognizer.toggleHistory, expectedEmptyHistory);
3722 XCTAssertEqualObjects(recognizer.toggleHistory, expectedToggledHistory);
3728 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForNestedMultipleWebView {
3729 if (@available(iOS 26.4, *)) {
3731 }
else if (@available(iOS 26.0, *)) {
3732 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3738 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3740 flutterPlatformViewsController,
3742 std::make_shared<fml::SyncSwitch>());
3746 [flutterPlatformViewsController
3752 [flutterPlatformViewsController
3757 @"viewType" : @"MockWebView",
3758 @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3766 XCTAssertNotNil(touchInterceptorView);
3786 root.gestureRecognizers = nil;
3787 for (UIView* subview in root.subviews) {
3788 [subview removeFromSuperview];
3792 [root addGestureRecognizer:normalRecognizer0];
3794 UIView* child1 = [[UIView alloc] init];
3795 [root addSubview:child1];
3797 [child1 addGestureRecognizer:normalRecognizer1];
3799 UIView* child2 = [[UIView alloc] init];
3800 [root addSubview:child2];
3802 [child2 addGestureRecognizer:normalRecognizer2];
3804 UIView* child2_1 = [[UIView alloc] init];
3805 [child2 addSubview:child2_1];
3807 [child2_1 addGestureRecognizer:normalRecognizer2_1];
3809 UIView* child2_2 = [[UIView alloc] init];
3810 [child2 addSubview:child2_2];
3812 [child2_2 addGestureRecognizer:normalRecognizer2_2];
3814 UIView* child3 = [[UIView alloc] init];
3815 [root addSubview:child3];
3817 [child3 addGestureRecognizer:normalRecognizer3];
3819 UIView* child3_1 = [[WKWebView alloc] init];
3820 child3_1.gestureRecognizers = nil;
3821 for (UIView* subview in child3_1.subviews) {
3822 [subview removeFromSuperview];
3824 [child3 addSubview:child3_1];
3826 [child3_1 addGestureRecognizer:normalRecognizer3_1];
3828 UIView* child3_1_1 = [[UIView alloc] init];
3829 [child3_1 addSubview:child3_1_1];
3831 [child3_1_1 addGestureRecognizer:normalRecognizer3_1_1];
3833 UIView* child3_1_2 = [[UIView alloc] init];
3834 [child3_1 addSubview:child3_1_2];
3836 [child3_1_2 addGestureRecognizer:normalRecognizer3_1_2];
3838 UIView* child3_1_2_1 = [[UIView alloc] init];
3839 [child3_1_2 addSubview:child3_1_2_1];
3841 [child3_1_2_1 addGestureRecognizer:normalRecognizer3_1_2_1];
3843 UIView* child3_1_2_2 = [[UIView alloc] init];
3844 [child3_1_2 addSubview:child3_1_2_2];
3846 [child3_1_2_2 addGestureRecognizer:normalRecognizer3_1_2_2];
3852 [child2_2 addGestureRecognizer:targetRecognizer2_2];
3856 [child3_1_2_2 addGestureRecognizer:targetRecognizer3_1_2_2];
3860 NSArray* normalRecognizers = @[
3861 normalRecognizer0, normalRecognizer1, normalRecognizer2, normalRecognizer2_1,
3862 normalRecognizer2_2, normalRecognizer3, normalRecognizer3_1, normalRecognizer3_1_1,
3863 normalRecognizer3_1_2, normalRecognizer3_1_2_1, normalRecognizer3_1_2_2
3866 NSArray* targetRecognizers = @[ targetRecognizer2_2, targetRecognizer3_1_2_2 ];
3868 NSArray* expectedEmptyHistory = @[];
3869 NSArray* expectedToggledHistory = @[ @NO, @YES ];
3872 XCTAssertEqualObjects(recognizer.toggleHistory, expectedEmptyHistory);
3876 XCTAssertEqualObjects(recognizer.toggleHistory, expectedToggledHistory);
3882 testFlutterPlatformViewGestureBlockingPolicy_ShouldNotAddDelayingRecognizerUnderDoNotBlockGesturePolicy {
3883 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3889 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3891 flutterPlatformViewsController,
3893 std::make_shared<fml::SyncSwitch>());
3898 withId:@"MockFlutterPlatformView"
3900 FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture];
3903 [flutterPlatformViewsController
3908 @"viewType" : @"MockFlutterPlatformView",
3909 @"gestureBlockingPolicy" : @"doNotBlockGesture"
3916 XCTAssertNotNil(touchInterceptorView);
3918 XCTAssert(touchInterceptorView.gestureRecognizers.count == 1);
3919 UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[0];
3923 - (void)testFlutterPlatformViewGestureBlockingPolicy_ShouldAddDelayingRecognizerUnderEagerPolicy {
3924 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3930 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3932 flutterPlatformViewsController,
3934 std::make_shared<fml::SyncSwitch>());
3938 [flutterPlatformViewsController
3940 withId:@"MockFlutterPlatformView"
3944 [flutterPlatformViewsController
3948 @"viewType" : @"MockFlutterPlatformView",
3949 @"gestureBlockingPolicy" : @"eager"
3956 XCTAssertNotNil(touchInterceptorView);
3958 XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3959 UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3960 UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3965 - (void)testFlutterPlatformViewHitTest_AcceptTouchIfInstructedByFramework {
3966 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3976 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3978 flutterPlatformViewsController,
3980 std::make_shared<fml::SyncSwitch>());
3985 withId:@"MockFlutterPlatformView"
3987 FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture];
3990 [flutterPlatformViewsController
3995 @"viewType" : @"MockFlutterPlatformView",
3996 @"gestureBlockingPolicy" : @"doNotBlockGesture"
4003 XCTAssertNotNil(touchInterceptorView);
4005 touchInterceptorView.frame = CGRectMake(0, 0, 100, 100);
4006 CGPoint touchBeganLocation = CGPointMake(1, 1);
4008 UIEvent* mockEvent = OCMClassMock([UIEvent
class]);
4009 OCMStub([mockEvent type]).andReturn(UIEventTypeTouches);
4012 OCMStub([mockFlutterViewController
4013 platformViewShouldAcceptTouchAtTouchBeganLocation:touchBeganLocation])
4015 UIView* hitTestResult = [touchInterceptorView hitTest:touchBeganLocation withEvent:mockEvent];
4020 - (void)testFlutterPlatformViewHitTest_RejectTouchIfInstructedByFramework {
4021 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4031 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4033 flutterPlatformViewsController,
4035 std::make_shared<fml::SyncSwitch>());
4040 withId:@"MockFlutterPlatformView"
4042 FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture];
4045 [flutterPlatformViewsController
4050 @"viewType" : @"MockFlutterPlatformView",
4051 @"gestureBlockingPolicy" : @"doNotBlockGesture"
4058 XCTAssertNotNil(touchInterceptorView);
4060 touchInterceptorView.frame = CGRectMake(0, 0, 100, 100);
4061 CGPoint touchBeganLocation = CGPointMake(1, 1);
4063 UIEvent* mockEvent = OCMClassMock([UIEvent
class]);
4064 OCMStub([mockEvent type]).andReturn(UIEventTypeTouches);
4067 OCMStub([mockFlutterViewController
4068 platformViewShouldAcceptTouchAtTouchBeganLocation:touchBeganLocation])
4070 UIView* hitTestResult = [touchInterceptorView hitTest:touchBeganLocation withEvent:mockEvent];
4072 XCTAssert(hitTestResult == touchInterceptorView);
4075 - (void)testFlutterPlatformViewGestureBlockingPolicy_PolicyMappingIsCorrect {
4076 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4086 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4088 flutterPlatformViewsController,
4090 std::make_shared<fml::SyncSwitch>());
4095 withId:@"MockFlutterPlatformView"
4099 FlutterPlatformViewGestureRecognizersBlockingPolicyWaitUntilTouchesEnded];
4100 __block
id methodResult;
4102 methodResult = result;
4106 [flutterPlatformViewsController
4110 @"viewType" : @"MockFlutterPlatformView",
4111 @"gestureBlockingPolicy" : @"eager"
4120 [flutterPlatformViewsController
4125 @"viewType" : @"MockFlutterPlatformView",
4126 @"gestureBlockingPolicy" : @"waitUntilTouchesEnded"
4133 [flutterPlatformViewsController
4138 @"viewType" : @"MockFlutterPlatformView",
4139 @"gestureBlockingPolicy" : @"doNotBlockGesture"
4145 XCTAssertNil(methodResult);
4148 [flutterPlatformViewsController
4153 @"viewType" : @"MockFlutterPlatformView",
4154 @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
4160 XCTAssertNil(methodResult);
4163 [flutterPlatformViewsController
4167 @"viewType" : @"MockFlutterPlatformView",
4168 @"gestureBlockingPolicy" : @"unknownPolicy"
4171 XCTAssertTrue([methodResult isKindOfClass:[
FlutterError class]]);
4173 XCTAssertEqualObjects(resultError.
code,
@"unknown_gesture_blocking_policy");
4174 XCTAssertEqualObjects(
4176 @"Trying to create a platform view with an unknown gesture blocking policy");
4177 XCTAssertEqualObjects(resultError.
details,
@"view id: '6'");
4180 - (void)testFlutterPlatformViewControllerSubmitFrameWithoutFlutterViewNotCrashing {
4181 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4187 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4189 flutterPlatformViewsController,
4191 std::make_shared<fml::SyncSwitch>());
4195 [flutterPlatformViewsController
4197 withId:@"MockFlutterPlatformView"
4201 [flutterPlatformViewsController
4205 @"viewType" : @"MockFlutterPlatformView",
4206 @"gestureBlockingPolicy" : @"eager"
4213 flutter::MutatorsStack stack;
4214 flutter::DlMatrix finalMatrix;
4216 auto embeddedViewParams_1 =
4217 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4219 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4220 withParams:std::move(embeddedViewParams_1)];
4221 [flutterPlatformViewsController
4225 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4226 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4227 nullptr, framebuffer_info,
4228 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return false; },
4229 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4230 flutter::DlISize(800, 600));
4231 XCTAssertFalse([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4232 withIosContext:std::make_shared<FakeIOSContext>()]);
4234 auto embeddedViewParams_2 =
4235 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4236 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4237 withParams:std::move(embeddedViewParams_2)];
4238 [flutterPlatformViewsController
4242 auto mock_surface_submit_true = std::make_unique<flutter::SurfaceFrame>(
4243 nullptr, framebuffer_info,
4244 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4245 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4246 flutter::DlISize(800, 600));
4247 XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface_submit_true)
4248 withIosContext:std::make_shared<FakeIOSContext>()]);
4252 testFlutterPlatformViewControllerResetDeallocsPlatformViewWhenRootViewsNotBindedToFlutterView {
4253 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4259 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4261 flutterPlatformViewsController,
4263 std::make_shared<fml::SyncSwitch>());
4265 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4266 flutterPlatformViewsController.
flutterView = flutterView;
4270 [flutterPlatformViewsController
4272 withId:@"MockFlutterPlatformView"
4278 [flutterPlatformViewsController
4282 @"viewType" : @"MockFlutterPlatformView",
4283 @"gestureBlockingPolicy" : @"eager"
4287 flutter::MutatorsStack stack;
4288 flutter::DlMatrix finalMatrix;
4289 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
4290 finalMatrix, flutter::DlSize(300, 300), stack);
4291 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4292 withParams:std::move(embeddedViewParams)];
4298 [flutterPlatformViewsController
reset];
4303 - (void)testFlutterPlatformViewControllerBeginFrameShouldResetCompisitionOrder {
4304 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4310 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4312 flutterPlatformViewsController,
4314 std::make_shared<fml::SyncSwitch>());
4316 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4317 flutterPlatformViewsController.
flutterView = flutterView;
4321 [flutterPlatformViewsController
4323 withId:@"MockFlutterPlatformView"
4328 [flutterPlatformViewsController
4332 @"viewType" : @"MockFlutterPlatformView",
4333 @"gestureBlockingPolicy" : @"eager"
4339 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4340 flutter::MutatorsStack stack;
4341 flutter::DlMatrix finalMatrix;
4342 auto embeddedViewParams1 =
4343 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4344 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4345 withParams:std::move(embeddedViewParams1)];
4346 [flutterPlatformViewsController
4353 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4356 auto embeddedViewParams2 =
4357 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4358 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4359 withParams:std::move(embeddedViewParams2)];
4360 [flutterPlatformViewsController
4368 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithDifferentViewHierarchy {
4369 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4375 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4377 flutterPlatformViewsController,
4379 std::make_shared<fml::SyncSwitch>());
4381 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4382 flutterPlatformViewsController.
flutterView = flutterView;
4386 [flutterPlatformViewsController
4388 withId:@"MockFlutterPlatformView"
4392 [flutterPlatformViewsController
4396 @"viewType" : @"MockFlutterPlatformView",
4397 @"gestureBlockingPolicy" : @"eager"
4403 [flutterPlatformViewsController
4407 @"viewType" : @"MockFlutterPlatformView",
4408 @"gestureBlockingPolicy" : @"eager"
4413 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4414 flutter::MutatorsStack stack;
4415 flutter::DlMatrix finalMatrix;
4416 auto embeddedViewParams1 =
4417 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4418 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4419 withParams:std::move(embeddedViewParams1)];
4421 auto embeddedViewParams2 =
4422 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4423 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4424 withParams:std::move(embeddedViewParams2)];
4426 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4427 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4428 nullptr, framebuffer_info,
4429 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4430 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4431 flutter::DlISize(800, 600),
nullptr,
true);
4432 XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4433 withIosContext:std::make_shared<FakeIOSContext>()]);
4436 UIView* clippingView1 = view1.superview.superview;
4437 UIView* clippingView2 = view2.superview.superview;
4438 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
4439 [flutterView.subviews indexOfObject:clippingView2],
4440 @"The first clipping view should be added before the second clipping view.");
4443 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4445 embeddedViewParams2 =
4446 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4447 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4448 withParams:std::move(embeddedViewParams2)];
4450 embeddedViewParams1 =
4451 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4452 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4453 withParams:std::move(embeddedViewParams1)];
4455 mock_surface = std::make_unique<flutter::SurfaceFrame>(
4456 nullptr, framebuffer_info,
4457 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4458 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4459 flutter::DlISize(800, 600),
nullptr,
true);
4460 XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4461 withIosContext:std::make_shared<FakeIOSContext>()]);
4463 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] >
4464 [flutterView.subviews indexOfObject:clippingView2],
4465 @"The first clipping view should be added after the second clipping view.");
4469 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithSameViewHierarchy {
4470 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4476 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4478 flutterPlatformViewsController,
4480 std::make_shared<fml::SyncSwitch>());
4482 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4483 flutterPlatformViewsController.
flutterView = flutterView;
4487 [flutterPlatformViewsController
4489 withId:@"MockFlutterPlatformView"
4493 [flutterPlatformViewsController
4497 @"viewType" : @"MockFlutterPlatformView",
4498 @"gestureBlockingPolicy" : @"eager"
4504 [flutterPlatformViewsController
4508 @"viewType" : @"MockFlutterPlatformView",
4509 @"gestureBlockingPolicy" : @"eager"
4514 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4515 flutter::MutatorsStack stack;
4516 flutter::DlMatrix finalMatrix;
4517 auto embeddedViewParams1 =
4518 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4519 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4520 withParams:std::move(embeddedViewParams1)];
4522 auto embeddedViewParams2 =
4523 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4524 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4525 withParams:std::move(embeddedViewParams2)];
4527 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4528 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4529 nullptr, framebuffer_info,
4530 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4531 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4532 flutter::DlISize(800, 600),
nullptr,
true);
4533 XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4534 withIosContext:std::make_shared<FakeIOSContext>()]);
4537 UIView* clippingView1 = view1.superview.superview;
4538 UIView* clippingView2 = view2.superview.superview;
4539 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
4540 [flutterView.subviews indexOfObject:clippingView2],
4541 @"The first clipping view should be added before the second clipping view.");
4544 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4546 embeddedViewParams1 =
4547 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4548 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4549 withParams:std::move(embeddedViewParams1)];
4551 embeddedViewParams2 =
4552 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4553 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4554 withParams:std::move(embeddedViewParams2)];
4556 mock_surface = std::make_unique<flutter::SurfaceFrame>(
4557 nullptr, framebuffer_info,
4558 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4559 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4560 flutter::DlISize(800, 600),
nullptr,
true);
4561 XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4562 withIosContext:std::make_shared<FakeIOSContext>()]);
4564 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
4565 [flutterView.subviews indexOfObject:clippingView2],
4566 @"The first clipping view should be added before the second clipping view.");
4569 - (int)alphaOfPoint:(CGPoint)point onView:(UIView*)view {
4570 unsigned char pixel[4] = {0};
4572 CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
4575 CGContextRef context =
4576 CGBitmapContextCreate(pixel, 1, 1, 8, 4, colorSpace,
4577 static_cast<uint32_t
>(kCGBitmapAlphaInfoMask) &
4578 static_cast<uint32_t
>(kCGImageAlphaPremultipliedLast));
4579 CGContextTranslateCTM(context, -point.x, -point.y);
4580 [view.layer renderInContext:context];
4582 CGContextRelease(context);
4583 CGColorSpaceRelease(colorSpace);
4588 - (void)testHasFirstResponderInViewHierarchySubtree_viewItselfBecomesFirstResponder {
4590 UIWindow* window = [[UIWindow alloc] init];
4591 UITextField* textField = [[UITextField alloc] init];
4592 [window addSubview:textField];
4594 [textField becomeFirstResponder];
4595 XCTAssertTrue(textField.isFirstResponder);
4596 XCTAssertTrue(textField.flt_hasFirstResponderInViewHierarchySubtree);
4597 [textField resignFirstResponder];
4598 XCTAssertFalse(textField.isFirstResponder);
4599 XCTAssertFalse(textField.flt_hasFirstResponderInViewHierarchySubtree);
4602 - (void)testHasFirstResponderInViewHierarchySubtree_descendantViewBecomesFirstResponder {
4604 UIWindow* window = [[UIWindow alloc] init];
4605 UIView* view = [[UIView alloc] init];
4606 UIView* childView = [[UIView alloc] init];
4607 UITextField* textField = [[UITextField alloc] init];
4608 [window addSubview:view];
4609 [view addSubview:childView];
4610 [childView addSubview:textField];
4612 [textField becomeFirstResponder];
4613 XCTAssertTrue(textField.isFirstResponder);
4614 XCTAssertTrue(view.flt_hasFirstResponderInViewHierarchySubtree);
4615 [textField resignFirstResponder];
4616 XCTAssertFalse(textField.isFirstResponder);
4617 XCTAssertFalse(view.flt_hasFirstResponderInViewHierarchySubtree);
4620 - (void)testFlutterClippingMaskViewPoolReuseViewsAfterRecycle {
4626 CGRect newRect = CGRectMake(0, 0, 10, 10);
4630 NSSet* set1 = [NSSet setWithObjects:view1, view2, nil];
4631 NSSet* set2 = [NSSet setWithObjects:view3, view4, nil];
4632 XCTAssertEqualObjects(set1, set2);
4633 XCTAssertTrue(CGRectEqualToRect(view3.frame, newRect));
4634 XCTAssertTrue(CGRectEqualToRect(view4.frame, newRect));
4637 - (void)testFlutterClippingMaskViewPoolAllocsNewMaskViewsAfterReachingCapacity {
4642 XCTAssertNotEqual(view1, view3);
4643 XCTAssertNotEqual(view2, view3);
4646 - (void)testMaskViewsReleasedWhenPoolIsReleased {
4647 __weak UIView* weakView;
4652 XCTAssertNotNil(weakView);
4654 XCTAssertNil(weakView);
4657 - (void)testClipMaskViewIsReused {
4658 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4664 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4666 flutterPlatformViewsController,
4668 std::make_shared<fml::SyncSwitch>());
4672 [flutterPlatformViewsController
4674 withId:@"MockFlutterPlatformView"
4678 [flutterPlatformViewsController
4682 @"viewType" : @"MockFlutterPlatformView",
4683 @"gestureBlockingPolicy" : @"eager"
4688 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4689 flutterPlatformViewsController.
flutterView = flutterView;
4691 flutter::MutatorsStack stack1;
4693 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
4694 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
4695 stack1.PushTransform(screenScaleMatrix);
4697 flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
4698 stack1.PushClipRect(rect);
4700 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4701 screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4703 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4704 withParams:std::move(embeddedViewParams1)];
4705 [flutterPlatformViewsController
4710 UIView* maskView1 = childClippingView1.maskView;
4711 XCTAssertNotNil(maskView1);
4714 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(100, 100)];
4715 flutter::MutatorsStack stack2;
4716 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4717 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4718 auto embeddedViewParams3 = std::make_unique<flutter::EmbeddedViewParams>(
4719 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4720 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4721 withParams:std::move(embeddedViewParams3)];
4722 [flutterPlatformViewsController
4729 [flutterPlatformViewsController
4733 @"viewType" : @"MockFlutterPlatformView",
4734 @"gestureBlockingPolicy" : @"eager"
4738 auto embeddedViewParams4 = std::make_unique<flutter::EmbeddedViewParams>(
4739 screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4740 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4741 withParams:std::move(embeddedViewParams4)];
4742 [flutterPlatformViewsController
4748 UIView* maskView2 = childClippingView2.maskView;
4749 XCTAssertEqual(maskView1, maskView2);
4750 XCTAssertNotNil(childClippingView2.maskView);
4751 XCTAssertNil(childClippingView1.maskView);
4754 - (void)testDifferentClipMaskViewIsUsedForEachView {
4755 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4761 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4763 flutterPlatformViewsController,
4765 std::make_shared<fml::SyncSwitch>());
4769 [flutterPlatformViewsController
4771 withId:@"MockFlutterPlatformView"
4776 [flutterPlatformViewsController
4780 @"viewType" : @"MockFlutterPlatformView",
4781 @"gestureBlockingPolicy" : @"eager"
4787 [flutterPlatformViewsController
4791 @"viewType" : @"MockFlutterPlatformView",
4792 @"gestureBlockingPolicy" : @"eager"
4798 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4799 flutterPlatformViewsController.
flutterView = flutterView;
4801 flutter::MutatorsStack stack1;
4803 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
4804 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
4805 stack1.PushTransform(screenScaleMatrix);
4807 flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
4808 stack1.PushClipRect(rect);
4810 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4811 screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4813 flutter::MutatorsStack stack2;
4814 stack2.PushClipRect(rect);
4815 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4816 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4818 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4819 withParams:std::move(embeddedViewParams1)];
4820 [flutterPlatformViewsController
4824 UIView* childClippingView1 = view1.superview.superview;
4826 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4827 withParams:std::move(embeddedViewParams2)];
4828 [flutterPlatformViewsController
4832 UIView* childClippingView2 = view2.superview.superview;
4833 UIView* maskView1 = childClippingView1.maskView;
4834 UIView* maskView2 = childClippingView2.maskView;
4835 XCTAssertNotEqual(maskView1, maskView2);
4838 - (void)testMaskViewUsesCAShapeLayerAsTheBackingLayer {
4839 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4845 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4847 flutterPlatformViewsController,
4849 std::make_shared<fml::SyncSwitch>());
4853 [flutterPlatformViewsController
4855 withId:@"MockFlutterPlatformView"
4860 [flutterPlatformViewsController
4864 @"viewType" : @"MockFlutterPlatformView",
4865 @"gestureBlockingPolicy" : @"eager"
4870 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4871 flutterPlatformViewsController.
flutterView = flutterView;
4873 flutter::MutatorsStack stack1;
4875 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
4876 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
4877 stack1.PushTransform(screenScaleMatrix);
4879 flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
4880 stack1.PushClipRect(rect);
4882 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4883 screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4885 flutter::MutatorsStack stack2;
4886 stack2.PushClipRect(rect);
4887 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4888 screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4890 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4891 withParams:std::move(embeddedViewParams1)];
4892 [flutterPlatformViewsController
4898 UIView* maskView = childClippingView.maskView;
4899 XCTAssert([maskView.layer isKindOfClass:[CAShapeLayer
class]],
4900 @"Mask view must use CAShapeLayer as its backing layer.");
4908 - (BOOL)validateOneVisualEffectView:(UIView*)visualEffectView
4909 expectedFrame:(CGRect)frame
4910 inputRadius:(CGFloat)inputRadius {
4911 XCTAssertTrue(CGRectEqualToRect(visualEffectView.frame, frame));
4912 for (UIView* view in visualEffectView.subviews) {
4913 if (![NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
4916 XCTAssertEqual(view.layer.filters.count, 1u);
4917 NSObject* filter = view.layer.filters.firstObject;
4919 XCTAssertEqualObjects([filter valueForKey:
@"name"],
@"gaussianBlur");
4921 NSObject* inputRadiusInFilter = [filter valueForKey:@"inputRadius"];
4922 XCTAssertTrue([inputRadiusInFilter isKindOfClass:[NSNumber
class]] &&
4923 flutter::BlurRadiusEqualToBlurRadius(((NSNumber*)inputRadiusInFilter).floatValue,
4930 - (void)testDisposingViewInCompositionOrderDoNotCrash {
4931 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4937 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4939 flutterPlatformViewsController,
4941 std::make_shared<fml::SyncSwitch>());
4943 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4944 flutterPlatformViewsController.
flutterView = flutterView;
4948 [flutterPlatformViewsController
4950 withId:@"MockFlutterPlatformView"
4955 [flutterPlatformViewsController
4959 @"viewType" : @"MockFlutterPlatformView",
4960 @"gestureBlockingPolicy" : @"eager"
4963 [flutterPlatformViewsController
4967 @"viewType" : @"MockFlutterPlatformView",
4968 @"gestureBlockingPolicy" : @"eager"
4975 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4976 flutter::MutatorsStack stack;
4977 flutter::DlMatrix finalMatrix;
4978 auto embeddedViewParams0 = std::make_unique<flutter::EmbeddedViewParams>(
4979 finalMatrix, flutter::DlSize(300, 300), stack);
4980 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4981 withParams:std::move(embeddedViewParams0)];
4983 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4984 finalMatrix, flutter::DlSize(300, 300), stack);
4985 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4986 withParams:std::move(embeddedViewParams1)];
4990 XCTestExpectation* expectation = [
self expectationWithDescription:@"dispose call ended."];
4992 [expectation fulfill];
4995 [flutterPlatformViewsController
4998 [
self waitForExpectationsWithTimeout:30 handler:nil];
5000 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5001 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5002 nullptr, framebuffer_info,
5003 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
5004 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
5005 flutter::DlISize(800, 600),
nullptr,
5007 XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
5008 withIosContext:std::make_shared<FakeIOSContext>()]);
5012 XCTAssertNotNil([flutterPlatformViewsController platformViewForId:0]);
5013 XCTAssertNotNil([flutterPlatformViewsController platformViewForId:1]);
5019 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
5020 flutter::MutatorsStack stack;
5021 flutter::DlMatrix finalMatrix;
5022 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
5023 finalMatrix, flutter::DlSize(300, 300), stack);
5024 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
5025 withParams:std::move(embeddedViewParams1)];
5027 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5028 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5029 nullptr, framebuffer_info,
5030 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
5031 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
5032 flutter::DlISize(800, 600),
nullptr,
true);
5033 XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
5034 withIosContext:std::make_shared<FakeIOSContext>()]);
5038 XCTAssertNil([flutterPlatformViewsController platformViewForId:0]);
5039 XCTAssertNotNil([flutterPlatformViewsController platformViewForId:1]);
5042 - (void)testOnlyPlatformViewsAreRemovedWhenReset {
5043 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5049 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5051 flutterPlatformViewsController,
5053 std::make_shared<fml::SyncSwitch>());
5057 [flutterPlatformViewsController
5059 withId:@"MockFlutterPlatformView"
5063 [flutterPlatformViewsController
5067 @"viewType" : @"MockFlutterPlatformView",
5068 @"gestureBlockingPolicy" : @"eager"
5071 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5072 flutterPlatformViewsController.
flutterView = flutterView;
5074 flutter::MutatorsStack stack;
5076 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5077 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5078 stack.PushTransform(screenScaleMatrix);
5080 flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
5081 stack.PushTransform(translateMatrix);
5082 flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
5084 auto embeddedViewParams =
5085 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5087 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5088 withParams:std::move(embeddedViewParams)];
5090 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5091 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5092 nullptr, framebuffer_info,
5093 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
5094 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
5095 flutter::DlISize(800, 600),
nullptr,
true);
5096 [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5097 withIosContext:std::make_shared<FakeIOSContext>()];
5099 UIView* someView = [[UIView alloc] init];
5100 [flutterView addSubview:someView];
5102 [flutterPlatformViewsController
reset];
5103 XCTAssertEqual(flutterView.subviews.count, 1u);
5104 XCTAssertEqual(flutterView.subviews.firstObject, someView);
5107 - (void)testResetClearsPreviousCompositionOrder {
5108 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5114 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5116 flutterPlatformViewsController,
5118 std::make_shared<fml::SyncSwitch>());
5122 [flutterPlatformViewsController
5124 withId:@"MockFlutterPlatformView"
5128 [flutterPlatformViewsController
5132 @"viewType" : @"MockFlutterPlatformView",
5133 @"gestureBlockingPolicy" : @"eager"
5136 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5137 flutterPlatformViewsController.
flutterView = flutterView;
5139 flutter::MutatorsStack stack;
5141 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5142 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5143 stack.PushTransform(screenScaleMatrix);
5145 flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
5146 stack.PushTransform(translateMatrix);
5147 flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
5149 auto embeddedViewParams =
5150 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5152 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5153 withParams:std::move(embeddedViewParams)];
5155 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5156 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5157 nullptr, framebuffer_info,
5158 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
5159 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
5160 flutter::DlISize(800, 600),
nullptr,
true);
5161 [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5162 withIosContext:std::make_shared<FakeIOSContext>()];
5168 [flutterPlatformViewsController
reset];
5174 - (void)testNilPlatformViewDoesntCrash {
5175 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5181 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5183 flutterPlatformViewsController,
5185 std::make_shared<fml::SyncSwitch>());
5189 [flutterPlatformViewsController
5191 withId:@"MockFlutterPlatformView"
5195 [flutterPlatformViewsController
5199 @"viewType" : @"MockFlutterPlatformView",
5200 @"gestureBlockingPolicy" : @"eager"
5203 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5204 flutterPlatformViewsController.
flutterView = flutterView;
5207 flutter::MutatorsStack stack;
5209 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5210 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5211 stack.PushTransform(screenScaleMatrix);
5213 flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
5214 stack.PushTransform(translateMatrix);
5215 flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
5217 auto embeddedViewParams =
5218 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5220 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5221 withParams:std::move(embeddedViewParams)];
5223 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5224 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5225 nullptr, framebuffer_info,
5226 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
5227 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
5228 flutter::DlISize(800, 600),
nullptr,
true);
5229 [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5230 withIosContext:std::make_shared<FakeIOSContext>()];
5232 XCTAssertEqual(flutterView.subviews.count, 1u);
5235 - (void)testFlutterTouchInterceptingViewLinksToAccessibilityContainer {
5237 NSObject* container = [[NSObject alloc] init];
5238 [touchInterceptorView setFlutterAccessibilityContainer:container];
5239 XCTAssertEqualObjects([touchInterceptorView accessibilityContainer], container);
5242 - (void)testLayerPool {
5246 XCTAssertTrue(
engine.platformView !=
nullptr);
5247 auto ios_context =
engine.platformView->GetIosContext();
5252 pool.
CreateLayer(ios_context, MTLPixelFormatBGRA8Unorm);
5253 XCTAssertEqual(pool.size(), 1u);
5254 pool.CreateLayer(ios_context, MTLPixelFormatBGRA8Unorm);
5255 XCTAssertEqual(pool.size(), 2u);
5258 pool.RecycleLayers();
5259 XCTAssertEqual(pool.size(), 2u);
5262 auto unused_layers = pool.RemoveUnusedLayers();
5263 XCTAssertEqual(unused_layers.size(), 2u);
5264 XCTAssertEqual(pool.size(), 1u);
5267 - (void)testFlutterPlatformViewControllerSubmitFramePreservingFrameDamage {
5268 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5274 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5276 flutterPlatformViewsController,
5278 std::make_shared<fml::SyncSwitch>());
5280 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5281 flutterPlatformViewsController.
flutterView = flutterView;
5285 [flutterPlatformViewsController
5287 withId:@"MockFlutterPlatformView"
5291 [flutterPlatformViewsController
5295 @"viewType" : @"MockFlutterPlatformView",
5296 @"gestureBlockingPolicy" : @"eager"
5301 [flutterPlatformViewsController
5305 @"viewType" : @"MockFlutterPlatformView",
5306 @"gestureBlockingPolicy" : @"eager"
5310 [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
5311 flutter::MutatorsStack stack;
5312 flutter::DlMatrix finalMatrix;
5313 auto embeddedViewParams1 =
5314 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5315 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
5316 withParams:std::move(embeddedViewParams1)];
5318 auto embeddedViewParams2 =
5319 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
5320 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
5321 withParams:std::move(embeddedViewParams2)];
5323 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5324 std::optional<flutter::SurfaceFrame::SubmitInfo> submit_info;
5325 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5326 nullptr, framebuffer_info,
5327 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
5328 [&](
const flutter::SurfaceFrame& surface_frame) {
5329 submit_info = surface_frame.submit_info();
5332 flutter::DlISize(800, 600),
nullptr,
5334 mock_surface->set_submit_info({
5335 .frame_damage = flutter::DlIRect::MakeWH(800, 600),
5336 .buffer_damage = flutter::DlIRect::MakeWH(400, 600),
5339 [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5340 withIosContext:std::make_shared<FakeIOSContext>()];
5342 XCTAssertTrue(submit_info.has_value());
5343 XCTAssertEqual(*submit_info->frame_damage, flutter::DlIRect::MakeWH(800, 600));
5344 XCTAssertEqual(*submit_info->buffer_damage, flutter::DlIRect::MakeWH(400, 600));
5347 - (void)testClipSuperellipse {
5348 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5354 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5356 flutterPlatformViewsController,
5358 std::make_shared<fml::SyncSwitch>());
5362 [flutterPlatformViewsController
5364 withId:@"MockFlutterPlatformView"
5368 [flutterPlatformViewsController
5372 @"viewType" : @"MockFlutterPlatformView",
5373 @"gestureBlockingPolicy" : @"eager"
5379 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
5380 flutterPlatformViewsController.
flutterView = flutterView;
5382 flutter::MutatorsStack stack;
5384 flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5385 flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5386 stack.PushTransform(screenScaleMatrix);
5388 flutter::DlRect rect = flutter::DlRect::MakeXYWH(3, 3, 5, 5);
5389 stack.PushClipRSE(flutter::DlRoundSuperellipse::MakeOval(rect));
5391 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
5392 screenScaleMatrix, flutter::DlSize(10, 10), stack);
5394 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5395 withParams:std::move(embeddedViewParams)];
5396 [flutterPlatformViewsController
5403 [flutterView addSubview:childClippingView];
5405 [flutterView setNeedsLayout];
5406 [flutterView layoutIfNeeded];
5408 CGPoint corners[] = {CGPointMake(rect.GetLeft(), rect.GetTop()),
5409 CGPointMake(rect.GetRight(), rect.GetTop()),
5410 CGPointMake(rect.GetLeft(), rect.GetBottom()),
5411 CGPointMake(rect.GetRight(), rect.GetBottom())};
5412 for (
auto point : corners) {
5413 int alpha = [
self alphaOfPoint:point onView:flutterView];
5414 XCTAssertNotEqual(alpha, 255);
5417 CGPointMake(rect.GetLeft() + rect.GetWidth() / 2, rect.GetTop() + rect.GetHeight() / 2);
5418 int alpha = [
self alphaOfPoint:center onView:flutterView];
5419 XCTAssertEqual(alpha, 255);
void(^ FlutterResult)(id _Nullable result)
@ FlutterPlatformViewGestureRecognizersBlockingPolicyEager
@ FlutterPlatformViewGestureRecognizersBlockingPolicyWaitUntilTouchesEnded
@ FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture
NSMutableArray * backdropFilterSubviews()
void applyBlurBackdropFilters:(NSArray< PlatformViewFilter * > *filters)
std::unique_ptr< flutter::Texture > CreateExternalTexture(int64_t texture_id, NSObject< FlutterTexture > *texture) override
Creates an external texture proxy of the appropriate client rendering API.
~FakeIOSContext() override=default
FlutterClippingMaskView * getMaskViewWithFrame:(CGRect frame)
void insertViewToPoolIfNeeded:(FlutterClippingMaskView *maskView)
FlutterPlatformViewGestureRecognizersBlockingPolicy blockingPolicy
Manages the lifetime of the on-screen and off-screen rendering contexts on iOS. On-screen contexts ar...
Storage for Overlay layers across frames.
void CreateLayer(const std::shared_ptr< IOSContext > &ios_context, MTLPixelFormat pixel_format)
Create a new overlay layer.
const flutter::TaskRunners & taskRunners
instancetype methodCallWithMethodName:arguments:(NSString *method,[arguments] id _Nullable arguments)
FlutterFMLTaskRunner * GetDefaultTaskRunner()
FlutterPlatformViewsController * CreateTestPlatformViewsController(NSString *label)
FlutterFMLTaskRunners * CreateTestTaskRunners(NSString *label)