7 #import <OCMock/OCMock.h>
8 #import <UIKit/UIKit.h>
9 #import <WebKit/WebKit.h>
10 #import <XCTest/XCTest.h>
14 #include "flutter/display_list/effects/dl_image_filters.h"
15 #include "flutter/fml/synchronization/count_down_latch.h"
16 #include "flutter/fml/thread.h"
36 - (instancetype)init {
51 @property(nonatomic, strong) UIView* view;
52 @property(nonatomic, assign) BOOL viewCreated;
57 - (instancetype)init {
58 if (
self = [super init]) {
66 [
self checkViewCreatedOnce];
70 - (void)checkViewCreatedOnce {
74 self.viewCreated = YES;
83 : NSObject <FlutterPlatformViewFactory>
88 viewIdentifier:(int64_t)viewId
89 arguments:(
id _Nullable)args {
96 @property(nonatomic, strong) UIView* view;
97 @property(nonatomic, assign) BOOL viewCreated;
101 - (instancetype)init {
102 if (
self = [super init]) {
103 _view = [[WKWebView alloc] init];
111 [
self checkViewCreatedOnce];
115 - (void)checkViewCreatedOnce {
119 self.viewCreated = YES;
131 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
132 viewIdentifier:(int64_t)viewId
133 arguments:(
id _Nullable)args {
142 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
143 viewIdentifier:(int64_t)viewId
144 arguments:(
id _Nullable)args {
151 @property(nonatomic, strong) UIView* view;
152 @property(nonatomic, assign) BOOL viewCreated;
156 - (instancetype)init {
157 if (
self = [super init]) {
158 _view = [[UIView alloc] init];
159 [_view addSubview:[[WKWebView alloc] init]];
167 [
self checkViewCreatedOnce];
171 - (void)checkViewCreatedOnce {
175 self.viewCreated = YES;
187 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
188 viewIdentifier:(int64_t)viewId
189 arguments:(
id _Nullable)args {
195 @property(nonatomic, strong) UIView* view;
196 @property(nonatomic, assign) BOOL viewCreated;
200 - (instancetype)init {
201 if (
self = [super init]) {
202 _view = [[UIView alloc] init];
203 UIView* childView = [[UIView alloc] init];
204 [_view addSubview:childView];
205 [childView addSubview:[[WKWebView alloc] init]];
213 [
self checkViewCreatedOnce];
217 - (void)checkViewCreatedOnce {
221 self.viewCreated = YES;
226 : NSObject <FlutterPlatformViewFactory>
231 viewIdentifier:(int64_t)viewId
232 arguments:(
id _Nullable)args {
239 class FlutterPlatformViewsTestMockPlatformViewDelegate :
public PlatformView::Delegate {
241 void OnPlatformViewCreated(std::unique_ptr<Surface> surface)
override {}
242 void OnPlatformViewDestroyed()
override {}
243 void OnPlatformViewScheduleFrame()
override {}
244 void OnPlatformViewAddView(int64_t view_id,
245 const ViewportMetrics& viewport_metrics,
246 AddViewCallback callback)
override {}
247 void OnPlatformViewRemoveView(int64_t view_id, RemoveViewCallback callback)
override {}
248 void OnPlatformViewSetNextFrameCallback(
const fml::closure& closure)
override {}
249 void OnPlatformViewSetViewportMetrics(int64_t view_id,
const ViewportMetrics& metrics)
override {}
250 const flutter::Settings& OnPlatformViewGetSettings()
const override {
return settings_; }
251 void OnPlatformViewDispatchPlatformMessage(std::unique_ptr<PlatformMessage> message)
override {}
252 void OnPlatformViewDispatchPointerDataPacket(std::unique_ptr<PointerDataPacket> packet)
override {
254 void OnPlatformViewDispatchSemanticsAction(int32_t
id,
255 SemanticsAction action,
256 fml::MallocMapping args)
override {}
257 void OnPlatformViewSetSemanticsEnabled(
bool enabled)
override {}
258 void OnPlatformViewSetAccessibilityFeatures(int32_t flags)
override {}
259 void OnPlatformViewRegisterTexture(std::shared_ptr<Texture> texture)
override {}
260 void OnPlatformViewUnregisterTexture(int64_t
texture_id)
override {}
261 void OnPlatformViewMarkTextureFrameAvailable(int64_t
texture_id)
override {}
263 void LoadDartDeferredLibrary(intptr_t loading_unit_id,
264 std::unique_ptr<const fml::Mapping> snapshot_data,
265 std::unique_ptr<const fml::Mapping> snapshot_instructions)
override {
267 void LoadDartDeferredLibraryError(intptr_t loading_unit_id,
268 const std::string error_message,
269 bool transient)
override {}
270 void UpdateAssetResolverByType(std::unique_ptr<flutter::AssetResolver> updated_asset_resolver,
271 flutter::AssetResolver::AssetResolverType type)
override {}
276 BOOL BlurRadiusEqualToBlurRadius(CGFloat radius1, CGFloat radius2) {
277 const CGFloat epsilon = 0.01;
278 return std::abs(radius1 - radius2) < epsilon;
290 fml::RefPtr<fml::TaskRunner> GetDefaultTaskRunner() {
291 fml::MessageLoop::EnsureInitializedForCurrentThread();
292 return fml::MessageLoop::GetCurrent().GetTaskRunner();
296 - (void)testFlutterViewOnlyCreateOnceInOneFrame {
297 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
299 flutter::TaskRunners runners(
self.name.UTF8String,
300 GetDefaultTaskRunner(),
301 GetDefaultTaskRunner(),
302 GetDefaultTaskRunner(),
303 GetDefaultTaskRunner());
306 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
307 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
309 mock_delegate.settings_.enable_impeller
312 flutterPlatformViewsController,
315 std::make_shared<fml::SyncSwitch>());
319 [flutterPlatformViewsController
321 withId:@"MockFlutterPlatformView"
325 [flutterPlatformViewsController
329 @"viewType" : @"MockFlutterPlatformView"
332 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
333 flutterPlatformViewsController.
flutterView = flutterView;
335 flutter::MutatorsStack stack;
337 SkMatrix screenScaleMatrix =
338 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
339 stack.PushTransform(screenScaleMatrix);
341 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
342 stack.PushTransform(translateMatrix);
343 SkMatrix finalMatrix;
344 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
346 auto embeddedViewParams =
347 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
349 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
350 withParams:std::move(embeddedViewParams)];
354 [flutterPlatformViewsController
reset];
357 - (void)testCanCreatePlatformViewWithoutFlutterView {
358 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
360 flutter::TaskRunners runners(
self.name.UTF8String,
361 GetDefaultTaskRunner(),
362 GetDefaultTaskRunner(),
363 GetDefaultTaskRunner(),
364 GetDefaultTaskRunner());
367 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
368 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
370 mock_delegate.settings_.enable_impeller
373 flutterPlatformViewsController,
376 std::make_shared<fml::SyncSwitch>());
380 [flutterPlatformViewsController
382 withId:@"MockFlutterPlatformView"
386 [flutterPlatformViewsController
390 @"viewType" : @"MockFlutterPlatformView"
397 - (void)testChildClippingViewHitTests {
400 UIView* childView = [[UIView alloc] initWithFrame:CGRectMake(100, 100, 100, 100)];
401 [childClippingView addSubview:childView];
403 XCTAssertFalse([childClippingView pointInside:CGPointMake(50, 50) withEvent:nil]);
404 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 100) withEvent:nil]);
405 XCTAssertFalse([childClippingView pointInside:CGPointMake(100, 99) withEvent:nil]);
406 XCTAssertFalse([childClippingView pointInside:CGPointMake(201, 200) withEvent:nil]);
407 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 201) withEvent:nil]);
408 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 200) withEvent:nil]);
409 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 299) withEvent:nil]);
411 XCTAssertTrue([childClippingView pointInside:CGPointMake(150, 150) withEvent:nil]);
412 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 100) withEvent:nil]);
413 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 100) withEvent:nil]);
414 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 199) withEvent:nil]);
415 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 199) withEvent:nil]);
418 - (void)testReleasesBackdropFilterSubviewsOnChildClippingViewDealloc {
419 __weak NSMutableArray<UIVisualEffectView*>* weakBackdropFilterSubviews = nil;
420 __weak UIVisualEffectView* weakVisualEffectView1 = nil;
421 __weak UIVisualEffectView* weakVisualEffectView2 = nil;
425 UIVisualEffectView* visualEffectView1 = [[UIVisualEffectView alloc]
426 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
427 weakVisualEffectView1 = visualEffectView1;
431 visualEffectView:visualEffectView1];
436 UIVisualEffectView* visualEffectView2 = [[UIVisualEffectView alloc]
437 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleDark]];
438 weakVisualEffectView2 = visualEffectView2;
442 visualEffectView:visualEffectView2];
446 XCTAssertNotNil(weakBackdropFilterSubviews);
449 XCTAssertNil(weakBackdropFilterSubviews);
450 XCTAssertNil(weakVisualEffectView1);
451 XCTAssertNil(weakVisualEffectView2);
454 - (void)testApplyBackdropFilter {
455 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
457 flutter::TaskRunners runners(
self.name.UTF8String,
458 GetDefaultTaskRunner(),
459 GetDefaultTaskRunner(),
460 GetDefaultTaskRunner(),
461 GetDefaultTaskRunner());
464 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
465 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
467 mock_delegate.settings_.enable_impeller
470 flutterPlatformViewsController,
473 std::make_shared<fml::SyncSwitch>());
477 [flutterPlatformViewsController
479 withId:@"MockFlutterPlatformView"
483 [flutterPlatformViewsController
487 @"viewType" : @"MockFlutterPlatformView"
493 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
494 flutterPlatformViewsController.
flutterView = flutterView;
496 flutter::MutatorsStack stack;
498 CGFloat screenScale = [UIScreen mainScreen].scale;
499 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
500 stack.PushTransform(screenScaleMatrix);
502 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
503 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
505 auto embeddedViewParams =
506 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
508 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
509 withParams:std::move(embeddedViewParams)];
510 [flutterPlatformViewsController
516 [flutterView addSubview:childClippingView];
518 [flutterView setNeedsLayout];
519 [flutterView layoutIfNeeded];
522 NSUInteger numberOfExpectedVisualEffectView = 0;
523 for (UIView* subview in childClippingView.subviews) {
524 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
527 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
528 if ([
self validateOneVisualEffectView:subview
529 expectedFrame:CGRectMake(0, 0, 10, 10)
531 numberOfExpectedVisualEffectView++;
534 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
537 - (void)testApplyBackdropFilterWithCorrectFrame {
538 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
540 flutter::TaskRunners runners(
self.name.UTF8String,
541 GetDefaultTaskRunner(),
542 GetDefaultTaskRunner(),
543 GetDefaultTaskRunner(),
544 GetDefaultTaskRunner());
547 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
548 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
550 mock_delegate.settings_.enable_impeller
553 flutterPlatformViewsController,
556 std::make_shared<fml::SyncSwitch>());
560 [flutterPlatformViewsController
562 withId:@"MockFlutterPlatformView"
566 [flutterPlatformViewsController
570 @"viewType" : @"MockFlutterPlatformView"
576 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
577 flutterPlatformViewsController.
flutterView = flutterView;
579 flutter::MutatorsStack stack;
581 CGFloat screenScale = [UIScreen mainScreen].scale;
582 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
583 stack.PushTransform(screenScaleMatrix);
585 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
586 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 8, screenScale * 8));
588 auto embeddedViewParams =
589 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(5, 10), stack);
591 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
592 withParams:std::move(embeddedViewParams)];
593 [flutterPlatformViewsController
599 [flutterView addSubview:childClippingView];
601 [flutterView setNeedsLayout];
602 [flutterView layoutIfNeeded];
605 NSUInteger numberOfExpectedVisualEffectView = 0;
606 for (UIView* subview in childClippingView.subviews) {
607 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
610 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
611 if ([
self validateOneVisualEffectView:subview
612 expectedFrame:CGRectMake(0, 0, 5, 8)
614 numberOfExpectedVisualEffectView++;
617 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
620 - (void)testApplyMultipleBackdropFilters {
621 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
623 flutter::TaskRunners runners(
self.name.UTF8String,
624 GetDefaultTaskRunner(),
625 GetDefaultTaskRunner(),
626 GetDefaultTaskRunner(),
627 GetDefaultTaskRunner());
630 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
631 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
633 mock_delegate.settings_.enable_impeller
636 flutterPlatformViewsController,
639 std::make_shared<fml::SyncSwitch>());
643 [flutterPlatformViewsController
645 withId:@"MockFlutterPlatformView"
649 [flutterPlatformViewsController
653 @"viewType" : @"MockFlutterPlatformView"
659 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
660 flutterPlatformViewsController.
flutterView = flutterView;
662 flutter::MutatorsStack stack;
664 CGFloat screenScale = [UIScreen mainScreen].scale;
665 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
666 stack.PushTransform(screenScaleMatrix);
668 for (
int i = 0; i < 50; i++) {
669 auto filter = flutter::DlBlurImageFilter::Make(i, 2, flutter::DlTileMode::kClamp);
670 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
673 auto embeddedViewParams =
674 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(20, 20), stack);
676 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
677 withParams:std::move(embeddedViewParams)];
678 [flutterPlatformViewsController
684 [flutterView addSubview:childClippingView];
686 [flutterView setNeedsLayout];
687 [flutterView layoutIfNeeded];
689 NSUInteger numberOfExpectedVisualEffectView = 0;
690 for (UIView* subview in childClippingView.subviews) {
691 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
694 XCTAssertLessThan(numberOfExpectedVisualEffectView, 50u);
695 if ([
self validateOneVisualEffectView:subview
696 expectedFrame:CGRectMake(0, 0, 10, 10)
697 inputRadius:(CGFloat)numberOfExpectedVisualEffectView]) {
698 numberOfExpectedVisualEffectView++;
701 XCTAssertEqual(numberOfExpectedVisualEffectView, (NSUInteger)numberOfExpectedVisualEffectView);
704 - (void)testAddBackdropFilters {
705 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
707 flutter::TaskRunners runners(
self.name.UTF8String,
708 GetDefaultTaskRunner(),
709 GetDefaultTaskRunner(),
710 GetDefaultTaskRunner(),
711 GetDefaultTaskRunner());
714 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
715 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
717 mock_delegate.settings_.enable_impeller
720 flutterPlatformViewsController,
723 std::make_shared<fml::SyncSwitch>());
727 [flutterPlatformViewsController
729 withId:@"MockFlutterPlatformView"
733 [flutterPlatformViewsController
737 @"viewType" : @"MockFlutterPlatformView"
743 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
744 flutterPlatformViewsController.
flutterView = flutterView;
746 flutter::MutatorsStack stack;
748 CGFloat screenScale = [UIScreen mainScreen].scale;
749 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
750 stack.PushTransform(screenScaleMatrix);
752 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
753 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
755 auto embeddedViewParams =
756 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
758 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
759 withParams:std::move(embeddedViewParams)];
760 [flutterPlatformViewsController
766 [flutterView addSubview:childClippingView];
768 [flutterView setNeedsLayout];
769 [flutterView layoutIfNeeded];
771 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
772 for (UIView* subview in childClippingView.subviews) {
773 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
776 XCTAssertLessThan(originalVisualEffectViews.count, 1u);
777 if ([
self validateOneVisualEffectView:subview
778 expectedFrame:CGRectMake(0, 0, 10, 10)
779 inputRadius:(CGFloat)5]) {
780 [originalVisualEffectViews addObject:subview];
783 XCTAssertEqual(originalVisualEffectViews.count, 1u);
788 flutter::MutatorsStack stack2;
790 stack2.PushTransform(screenScaleMatrix);
792 for (
int i = 0; i < 2; i++) {
793 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
796 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
797 SkSize::Make(10, 10), stack2);
799 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
800 withParams:std::move(embeddedViewParams)];
801 [flutterPlatformViewsController
805 [flutterView setNeedsLayout];
806 [flutterView layoutIfNeeded];
808 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
809 for (UIView* subview in childClippingView.subviews) {
810 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
813 XCTAssertLessThan(newVisualEffectViews.count, 2u);
815 if ([
self validateOneVisualEffectView:subview
816 expectedFrame:CGRectMake(0, 0, 10, 10)
817 inputRadius:(CGFloat)5]) {
818 [newVisualEffectViews addObject:subview];
821 XCTAssertEqual(newVisualEffectViews.count, 2u);
822 for (NSUInteger i = 0; i < originalVisualEffectViews.count; i++) {
823 UIView* originalView = originalVisualEffectViews[i];
824 UIView* newView = newVisualEffectViews[i];
826 XCTAssertEqual(originalView, newView);
827 id mockOrignalView = OCMPartialMock(originalView);
828 OCMReject([mockOrignalView removeFromSuperview]);
829 [mockOrignalView stopMocking];
833 - (void)testRemoveBackdropFilters {
834 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
836 flutter::TaskRunners runners(
self.name.UTF8String,
837 GetDefaultTaskRunner(),
838 GetDefaultTaskRunner(),
839 GetDefaultTaskRunner(),
840 GetDefaultTaskRunner());
843 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
844 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
846 mock_delegate.settings_.enable_impeller
849 flutterPlatformViewsController,
852 std::make_shared<fml::SyncSwitch>());
856 [flutterPlatformViewsController
858 withId:@"MockFlutterPlatformView"
862 [flutterPlatformViewsController
866 @"viewType" : @"MockFlutterPlatformView"
872 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
873 flutterPlatformViewsController.
flutterView = flutterView;
875 flutter::MutatorsStack stack;
877 CGFloat screenScale = [UIScreen mainScreen].scale;
878 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
879 stack.PushTransform(screenScaleMatrix);
881 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
882 for (
int i = 0; i < 5; i++) {
883 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
886 auto embeddedViewParams =
887 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
889 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
890 withParams:std::move(embeddedViewParams)];
891 [flutterPlatformViewsController
897 [flutterView addSubview:childClippingView];
899 [flutterView setNeedsLayout];
900 [flutterView layoutIfNeeded];
902 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
903 for (UIView* subview in childClippingView.subviews) {
904 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
907 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
908 if ([
self validateOneVisualEffectView:subview
909 expectedFrame:CGRectMake(0, 0, 10, 10)
910 inputRadius:(CGFloat)5]) {
911 [originalVisualEffectViews addObject:subview];
917 flutter::MutatorsStack stack2;
919 stack2.PushTransform(screenScaleMatrix);
921 for (
int i = 0; i < 4; i++) {
922 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
925 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
926 SkSize::Make(10, 10), stack2);
928 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
929 withParams:std::move(embeddedViewParams)];
930 [flutterPlatformViewsController
934 [flutterView setNeedsLayout];
935 [flutterView layoutIfNeeded];
937 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
938 for (UIView* subview in childClippingView.subviews) {
939 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
942 XCTAssertLessThan(newVisualEffectViews.count, 4u);
943 if ([
self validateOneVisualEffectView:subview
944 expectedFrame:CGRectMake(0, 0, 10, 10)
945 inputRadius:(CGFloat)5]) {
946 [newVisualEffectViews addObject:subview];
949 XCTAssertEqual(newVisualEffectViews.count, 4u);
951 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
952 UIView* newView = newVisualEffectViews[i];
953 id mockNewView = OCMPartialMock(newView);
954 UIView* originalView = originalVisualEffectViews[i];
956 XCTAssertEqual(originalView, newView);
957 OCMReject([mockNewView removeFromSuperview]);
958 [mockNewView stopMocking];
963 for (
int i = 0; i < 5; i++) {
968 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
969 SkSize::Make(10, 10), stack2);
971 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
972 withParams:std::move(embeddedViewParams)];
973 [flutterPlatformViewsController
977 [flutterView setNeedsLayout];
978 [flutterView layoutIfNeeded];
980 NSUInteger numberOfExpectedVisualEffectView = 0u;
981 for (UIView* subview in childClippingView.subviews) {
982 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
983 numberOfExpectedVisualEffectView++;
986 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
989 - (void)testEditBackdropFilters {
990 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
992 flutter::TaskRunners runners(
self.name.UTF8String,
993 GetDefaultTaskRunner(),
994 GetDefaultTaskRunner(),
995 GetDefaultTaskRunner(),
996 GetDefaultTaskRunner());
999 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
1000 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1002 mock_delegate.settings_.enable_impeller
1005 flutterPlatformViewsController,
1008 std::make_shared<fml::SyncSwitch>());
1012 [flutterPlatformViewsController
1014 withId:@"MockFlutterPlatformView"
1018 [flutterPlatformViewsController
1022 @"viewType" : @"MockFlutterPlatformView"
1028 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1029 flutterPlatformViewsController.
flutterView = flutterView;
1031 flutter::MutatorsStack stack;
1033 CGFloat screenScale = [UIScreen mainScreen].scale;
1034 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
1035 stack.PushTransform(screenScaleMatrix);
1037 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1038 for (
int i = 0; i < 5; i++) {
1039 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1042 auto embeddedViewParams =
1043 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1045 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1046 withParams:std::move(embeddedViewParams)];
1047 [flutterPlatformViewsController
1053 [flutterView addSubview:childClippingView];
1055 [flutterView setNeedsLayout];
1056 [flutterView layoutIfNeeded];
1058 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
1059 for (UIView* subview in childClippingView.subviews) {
1060 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1063 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
1064 if ([
self validateOneVisualEffectView:subview
1065 expectedFrame:CGRectMake(0, 0, 10, 10)
1066 inputRadius:(CGFloat)5]) {
1067 [originalVisualEffectViews addObject:subview];
1073 flutter::MutatorsStack stack2;
1075 stack2.PushTransform(screenScaleMatrix);
1077 for (
int i = 0; i < 5; i++) {
1079 auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1081 stack2.PushBackdropFilter(filter2,
1082 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1086 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1089 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1090 SkSize::Make(10, 10), stack2);
1092 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1093 withParams:std::move(embeddedViewParams)];
1094 [flutterPlatformViewsController
1098 [flutterView setNeedsLayout];
1099 [flutterView layoutIfNeeded];
1101 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
1102 for (UIView* subview in childClippingView.subviews) {
1103 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1106 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1107 CGFloat expectInputRadius = 5;
1108 if (newVisualEffectViews.count == 3) {
1109 expectInputRadius = 2;
1111 if ([
self validateOneVisualEffectView:subview
1112 expectedFrame:CGRectMake(0, 0, 10, 10)
1113 inputRadius:expectInputRadius]) {
1114 [newVisualEffectViews addObject:subview];
1117 XCTAssertEqual(newVisualEffectViews.count, 5u);
1118 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1119 UIView* newView = newVisualEffectViews[i];
1120 id mockNewView = OCMPartialMock(newView);
1121 UIView* originalView = originalVisualEffectViews[i];
1123 XCTAssertEqual(originalView, newView);
1124 OCMReject([mockNewView removeFromSuperview]);
1125 [mockNewView stopMocking];
1127 [newVisualEffectViews removeAllObjects];
1131 for (
int i = 0; i < 5; i++) {
1135 for (
int i = 0; i < 5; i++) {
1137 auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1138 stack2.PushBackdropFilter(filter2,
1139 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1143 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1146 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1147 SkSize::Make(10, 10), stack2);
1149 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1150 withParams:std::move(embeddedViewParams)];
1151 [flutterPlatformViewsController
1155 [flutterView setNeedsLayout];
1156 [flutterView layoutIfNeeded];
1158 for (UIView* subview in childClippingView.subviews) {
1159 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1162 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1163 CGFloat expectInputRadius = 5;
1164 if (newVisualEffectViews.count == 0) {
1165 expectInputRadius = 2;
1167 if ([
self validateOneVisualEffectView:subview
1168 expectedFrame:CGRectMake(0, 0, 10, 10)
1169 inputRadius:expectInputRadius]) {
1170 [newVisualEffectViews addObject:subview];
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(filter2,
1194 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1198 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1201 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1202 SkSize::Make(10, 10), stack2);
1204 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1205 withParams:std::move(embeddedViewParams)];
1206 [flutterPlatformViewsController
1210 [flutterView setNeedsLayout];
1211 [flutterView layoutIfNeeded];
1213 for (UIView* subview in childClippingView.subviews) {
1214 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1217 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1218 CGFloat expectInputRadius = 5;
1219 if (newVisualEffectViews.count == 4) {
1220 expectInputRadius = 2;
1222 if ([
self validateOneVisualEffectView:subview
1223 expectedFrame:CGRectMake(0, 0, 10, 10)
1224 inputRadius:expectInputRadius]) {
1225 [newVisualEffectViews addObject:subview];
1228 XCTAssertEqual(newVisualEffectViews.count, 5u);
1230 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1231 UIView* newView = newVisualEffectViews[i];
1232 id mockNewView = OCMPartialMock(newView);
1233 UIView* originalView = originalVisualEffectViews[i];
1235 XCTAssertEqual(originalView, newView);
1236 OCMReject([mockNewView removeFromSuperview]);
1237 [mockNewView stopMocking];
1239 [newVisualEffectViews removeAllObjects];
1243 for (
int i = 0; i < 5; i++) {
1247 for (
int i = 0; i < 5; i++) {
1248 auto filter2 = flutter::DlBlurImageFilter::Make(i, 2, flutter::DlTileMode::kClamp);
1250 stack2.PushBackdropFilter(filter2, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1253 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1254 SkSize::Make(10, 10), stack2);
1256 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1257 withParams:std::move(embeddedViewParams)];
1258 [flutterPlatformViewsController
1262 [flutterView setNeedsLayout];
1263 [flutterView layoutIfNeeded];
1265 for (UIView* subview in childClippingView.subviews) {
1266 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1269 XCTAssertLessThan(newVisualEffectViews.count, 5u);
1270 if ([
self validateOneVisualEffectView:subview
1271 expectedFrame:CGRectMake(0, 0, 10, 10)
1272 inputRadius:(CGFloat)newVisualEffectViews.count]) {
1273 [newVisualEffectViews addObject:subview];
1276 XCTAssertEqual(newVisualEffectViews.count, 5u);
1278 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1279 UIView* newView = newVisualEffectViews[i];
1280 id mockNewView = OCMPartialMock(newView);
1281 UIView* originalView = originalVisualEffectViews[i];
1283 XCTAssertEqual(originalView, newView);
1284 OCMReject([mockNewView removeFromSuperview]);
1285 [mockNewView stopMocking];
1287 [newVisualEffectViews removeAllObjects];
1290 - (void)testApplyBackdropFilterNotDlBlurImageFilter {
1291 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1293 flutter::TaskRunners runners(
self.name.UTF8String,
1294 GetDefaultTaskRunner(),
1295 GetDefaultTaskRunner(),
1296 GetDefaultTaskRunner(),
1297 GetDefaultTaskRunner());
1300 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
1301 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1303 mock_delegate.settings_.enable_impeller
1306 flutterPlatformViewsController,
1309 std::make_shared<fml::SyncSwitch>());
1313 [flutterPlatformViewsController
1315 withId:@"MockFlutterPlatformView"
1319 [flutterPlatformViewsController
1323 @"viewType" : @"MockFlutterPlatformView"
1329 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1330 flutterPlatformViewsController.
flutterView = flutterView;
1332 flutter::MutatorsStack stack;
1334 CGFloat screenScale = [UIScreen mainScreen].scale;
1335 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
1336 stack.PushTransform(screenScaleMatrix);
1338 auto dilateFilter = flutter::DlDilateImageFilter::Make(5, 2);
1339 stack.PushBackdropFilter(dilateFilter, SkRect::MakeEmpty());
1341 auto embeddedViewParams =
1342 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1344 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1345 withParams:std::move(embeddedViewParams)];
1346 [flutterPlatformViewsController
1353 [flutterView addSubview:childClippingView];
1355 [flutterView setNeedsLayout];
1356 [flutterView layoutIfNeeded];
1358 NSUInteger numberOfExpectedVisualEffectView = 0;
1359 for (UIView* subview in childClippingView.subviews) {
1360 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1361 numberOfExpectedVisualEffectView++;
1364 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1368 flutter::MutatorsStack stack2;
1370 stack2.PushTransform(screenScaleMatrix);
1372 auto blurFilter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1374 for (
int i = 0; i < 5; i++) {
1376 stack2.PushBackdropFilter(dilateFilter,
1377 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1381 stack2.PushBackdropFilter(blurFilter,
1382 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1385 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1386 SkSize::Make(10, 10), stack2);
1388 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1389 withParams:std::move(embeddedViewParams)];
1390 [flutterPlatformViewsController
1394 [flutterView setNeedsLayout];
1395 [flutterView layoutIfNeeded];
1397 numberOfExpectedVisualEffectView = 0;
1398 for (UIView* subview in childClippingView.subviews) {
1399 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1402 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1403 if ([
self validateOneVisualEffectView:subview
1404 expectedFrame:CGRectMake(0, 0, 10, 10)
1405 inputRadius:(CGFloat)5]) {
1406 numberOfExpectedVisualEffectView++;
1409 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1413 for (
int i = 0; i < 5; i++) {
1417 for (
int i = 0; i < 5; i++) {
1419 stack2.PushBackdropFilter(dilateFilter,
1420 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1424 stack2.PushBackdropFilter(blurFilter,
1425 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1428 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1429 SkSize::Make(10, 10), stack2);
1431 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1432 withParams:std::move(embeddedViewParams)];
1433 [flutterPlatformViewsController
1437 [flutterView setNeedsLayout];
1438 [flutterView layoutIfNeeded];
1440 numberOfExpectedVisualEffectView = 0;
1441 for (UIView* subview in childClippingView.subviews) {
1442 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1445 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1446 if ([
self validateOneVisualEffectView:subview
1447 expectedFrame:CGRectMake(0, 0, 10, 10)
1448 inputRadius:(CGFloat)5]) {
1449 numberOfExpectedVisualEffectView++;
1452 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1456 for (
int i = 0; i < 5; i++) {
1460 for (
int i = 0; i < 5; i++) {
1462 stack2.PushBackdropFilter(dilateFilter,
1463 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1467 stack2.PushBackdropFilter(blurFilter,
1468 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1471 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1472 SkSize::Make(10, 10), stack2);
1474 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1475 withParams:std::move(embeddedViewParams)];
1476 [flutterPlatformViewsController
1480 [flutterView setNeedsLayout];
1481 [flutterView layoutIfNeeded];
1483 numberOfExpectedVisualEffectView = 0;
1484 for (UIView* subview in childClippingView.subviews) {
1485 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1488 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1489 if ([
self validateOneVisualEffectView:subview
1490 expectedFrame:CGRectMake(0, 0, 10, 10)
1491 inputRadius:(CGFloat)5]) {
1492 numberOfExpectedVisualEffectView++;
1495 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1499 for (
int i = 0; i < 5; i++) {
1503 for (
int i = 0; i < 5; i++) {
1504 stack2.PushBackdropFilter(dilateFilter,
1505 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1508 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1509 SkSize::Make(10, 10), stack2);
1511 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1512 withParams:std::move(embeddedViewParams)];
1513 [flutterPlatformViewsController
1517 [flutterView setNeedsLayout];
1518 [flutterView layoutIfNeeded];
1520 numberOfExpectedVisualEffectView = 0;
1521 for (UIView* subview in childClippingView.subviews) {
1522 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1523 numberOfExpectedVisualEffectView++;
1526 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1529 - (void)testApplyBackdropFilterCorrectAPI {
1534 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1535 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1539 visualEffectView:visualEffectView];
1540 XCTAssertNotNil(platformViewFilter);
1543 - (void)testApplyBackdropFilterAPIChangedInvalidUIVisualEffectView {
1545 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc] init];
1549 visualEffectView:visualEffectView];
1550 XCTAssertNil(platformViewFilter);
1553 - (void)testApplyBackdropFilterAPIChangedNoGaussianBlurFilter {
1555 UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1556 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1557 NSArray* subviews = editedUIVisualEffectView.subviews;
1558 for (UIView* view in subviews) {
1559 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1560 for (CIFilter* filter in view.layer.filters) {
1561 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1562 [filter setValue:@"notGaussianBlur" forKey:@"name"];
1572 visualEffectView:editedUIVisualEffectView];
1573 XCTAssertNil(platformViewFilter);
1576 - (void)testApplyBackdropFilterAPIChangedInvalidInputRadius {
1578 UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1579 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1580 NSArray* subviews = editedUIVisualEffectView.subviews;
1581 for (UIView* view in subviews) {
1582 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1583 for (CIFilter* filter in view.layer.filters) {
1584 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1585 [filter setValue:@"invalidInputRadius" forKey:@"inputRadius"];
1596 visualEffectView:editedUIVisualEffectView];
1597 XCTAssertNil(platformViewFilter);
1600 - (void)testBackdropFilterVisualEffectSubviewBackgroundColor {
1601 __weak UIVisualEffectView* weakVisualEffectView;
1604 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1605 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1606 weakVisualEffectView = visualEffectView;
1610 visualEffectView:visualEffectView];
1611 CGColorRef visualEffectSubviewBackgroundColor = nil;
1612 for (UIView* view in [platformViewFilter backdropFilterView].subviews) {
1613 if ([NSStringFromClass([view
class]) hasSuffix:
@"VisualEffectSubview"]) {
1614 visualEffectSubviewBackgroundColor = view.layer.backgroundColor;
1618 CGColorEqualToColor(visualEffectSubviewBackgroundColor, UIColor.clearColor.CGColor));
1620 XCTAssertNil(weakVisualEffectView);
1623 - (void)testCompositePlatformView {
1624 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1626 flutter::TaskRunners runners(
self.name.UTF8String,
1627 GetDefaultTaskRunner(),
1628 GetDefaultTaskRunner(),
1629 GetDefaultTaskRunner(),
1630 GetDefaultTaskRunner());
1633 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
1634 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1636 mock_delegate.settings_.enable_impeller
1639 flutterPlatformViewsController,
1642 std::make_shared<fml::SyncSwitch>());
1646 [flutterPlatformViewsController
1648 withId:@"MockFlutterPlatformView"
1652 [flutterPlatformViewsController
1656 @"viewType" : @"MockFlutterPlatformView"
1662 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
1663 flutterPlatformViewsController.
flutterView = flutterView;
1665 flutter::MutatorsStack stack;
1667 SkMatrix screenScaleMatrix =
1668 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1669 stack.PushTransform(screenScaleMatrix);
1671 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
1672 stack.PushTransform(translateMatrix);
1673 SkMatrix finalMatrix;
1674 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
1676 auto embeddedViewParams =
1677 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
1679 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1680 withParams:std::move(embeddedViewParams)];
1681 [flutterPlatformViewsController
1685 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1686 toView:flutterView];
1687 XCTAssertTrue(CGRectEqualToRect(platformViewRectInFlutterView, CGRectMake(100, 100, 300, 300)));
1690 - (void)testBackdropFilterCorrectlyPushedAndReset {
1691 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1693 flutter::TaskRunners runners(
self.name.UTF8String,
1694 GetDefaultTaskRunner(),
1695 GetDefaultTaskRunner(),
1696 GetDefaultTaskRunner(),
1697 GetDefaultTaskRunner());
1700 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
1701 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1703 mock_delegate.settings_.enable_impeller
1706 flutterPlatformViewsController,
1709 std::make_shared<fml::SyncSwitch>());
1713 [flutterPlatformViewsController
1715 withId:@"MockFlutterPlatformView"
1719 [flutterPlatformViewsController
1723 @"viewType" : @"MockFlutterPlatformView"
1729 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1730 flutterPlatformViewsController.
flutterView = flutterView;
1732 flutter::MutatorsStack stack;
1734 CGFloat screenScale = [UIScreen mainScreen].scale;
1735 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
1736 stack.PushTransform(screenScaleMatrix);
1738 auto embeddedViewParams =
1739 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1741 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(0, 0)];
1742 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1743 withParams:std::move(embeddedViewParams)];
1745 auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1746 [flutterPlatformViewsController
1747 pushFilterToVisitedPlatformViews:filter
1748 withRect:SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10)];
1749 [flutterPlatformViewsController
1755 [flutterView addSubview:childClippingView];
1757 [flutterView setNeedsLayout];
1758 [flutterView layoutIfNeeded];
1761 NSUInteger numberOfExpectedVisualEffectView = 0;
1762 for (UIView* subview in childClippingView.subviews) {
1763 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1766 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
1767 if ([
self validateOneVisualEffectView:subview
1768 expectedFrame:CGRectMake(0, 0, 10, 10)
1770 numberOfExpectedVisualEffectView++;
1773 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
1776 auto embeddedViewParams2 =
1777 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1778 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(0, 0)];
1779 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1780 withParams:std::move(embeddedViewParams2)];
1781 [flutterPlatformViewsController
1787 [flutterView setNeedsLayout];
1788 [flutterView layoutIfNeeded];
1790 numberOfExpectedVisualEffectView = 0;
1791 for (UIView* subview in childClippingView.subviews) {
1792 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1795 numberOfExpectedVisualEffectView++;
1797 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1800 - (void)testChildClippingViewShouldBeTheBoundingRectOfPlatformView {
1801 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1803 flutter::TaskRunners runners(
self.name.UTF8String,
1804 GetDefaultTaskRunner(),
1805 GetDefaultTaskRunner(),
1806 GetDefaultTaskRunner(),
1807 GetDefaultTaskRunner());
1810 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
1811 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1813 mock_delegate.settings_.enable_impeller
1816 flutterPlatformViewsController,
1819 std::make_shared<fml::SyncSwitch>());
1823 [flutterPlatformViewsController
1825 withId:@"MockFlutterPlatformView"
1829 [flutterPlatformViewsController
1833 @"viewType" : @"MockFlutterPlatformView"
1839 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
1840 flutterPlatformViewsController.
flutterView = flutterView;
1842 flutter::MutatorsStack stack;
1844 SkMatrix screenScaleMatrix =
1845 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1846 stack.PushTransform(screenScaleMatrix);
1848 SkMatrix rotateMatrix;
1849 rotateMatrix.setRotate(10);
1850 stack.PushTransform(rotateMatrix);
1851 SkMatrix finalMatrix;
1852 finalMatrix.setConcat(screenScaleMatrix, rotateMatrix);
1854 auto embeddedViewParams =
1855 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
1857 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1858 withParams:std::move(embeddedViewParams)];
1859 [flutterPlatformViewsController
1863 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1864 toView:flutterView];
1870 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.x - childClippingView.frame.origin.x),
1872 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.y - childClippingView.frame.origin.y),
1875 fabs(platformViewRectInFlutterView.size.width - childClippingView.frame.size.width),
1878 fabs(platformViewRectInFlutterView.size.height - childClippingView.frame.size.height),
1882 - (void)testClipsDoNotInterceptWithPlatformViewShouldNotAddMaskView {
1883 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1885 flutter::TaskRunners runners(
self.name.UTF8String,
1886 GetDefaultTaskRunner(),
1887 GetDefaultTaskRunner(),
1888 GetDefaultTaskRunner(),
1889 GetDefaultTaskRunner());
1892 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
1893 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1895 mock_delegate.settings_.enable_impeller
1898 flutterPlatformViewsController,
1901 std::make_shared<fml::SyncSwitch>());
1905 [flutterPlatformViewsController
1907 withId:@"MockFlutterPlatformView"
1911 [flutterPlatformViewsController
1915 @"viewType" : @"MockFlutterPlatformView"
1921 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
1922 flutterPlatformViewsController.
flutterView = flutterView;
1924 flutter::MutatorsStack stack;
1926 SkMatrix screenScaleMatrix =
1927 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1928 stack.PushTransform(screenScaleMatrix);
1929 SkMatrix translateMatrix = SkMatrix::Translate(5, 5);
1931 stack.PushTransform(translateMatrix);
1933 SkRect rect = SkRect::MakeXYWH(0, 0, 25, 25);
1934 stack.PushClipRect(rect);
1937 SkRect rect_for_rrect = SkRect::MakeXYWH(-1, -1, 25, 25);
1938 SkRRect rrect = SkRRect::MakeRectXY(rect_for_rrect, 1, 1);
1939 stack.PushClipRRect(rrect);
1941 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1942 SkMatrix::Concat(screenScaleMatrix, translateMatrix), SkSize::Make(5, 5), stack);
1944 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1945 withParams:std::move(embeddedViewParams)];
1946 [flutterPlatformViewsController
1953 [flutterView addSubview:childClippingView];
1955 [flutterView setNeedsLayout];
1956 [flutterView layoutIfNeeded];
1957 XCTAssertNil(childClippingView.maskView);
1960 - (void)testClipRRectOnlyHasCornersInterceptWithPlatformViewShouldAddMaskView {
1961 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1963 flutter::TaskRunners runners(
self.name.UTF8String,
1964 GetDefaultTaskRunner(),
1965 GetDefaultTaskRunner(),
1966 GetDefaultTaskRunner(),
1967 GetDefaultTaskRunner());
1970 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
1971 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1973 mock_delegate.settings_.enable_impeller
1976 flutterPlatformViewsController,
1979 std::make_shared<fml::SyncSwitch>());
1983 [flutterPlatformViewsController
1985 withId:@"MockFlutterPlatformView"
1989 [flutterPlatformViewsController
1993 @"viewType" : @"MockFlutterPlatformView"
1999 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
2000 flutterPlatformViewsController.
flutterView = flutterView;
2002 flutter::MutatorsStack stack;
2004 SkMatrix screenScaleMatrix =
2005 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2006 stack.PushTransform(screenScaleMatrix);
2007 SkMatrix translateMatrix = SkMatrix::Translate(5, 5);
2009 stack.PushTransform(translateMatrix);
2013 SkRect rect_for_rrect = SkRect::MakeXYWH(0, 0, 10, 10);
2014 SkRRect rrect = SkRRect::MakeRectXY(rect_for_rrect, 1, 1);
2015 stack.PushClipRRect(rrect);
2017 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2018 SkMatrix::Concat(screenScaleMatrix, translateMatrix), SkSize::Make(5, 5), stack);
2020 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2021 withParams:std::move(embeddedViewParams)];
2022 [flutterPlatformViewsController
2029 [flutterView addSubview:childClippingView];
2031 [flutterView setNeedsLayout];
2032 [flutterView layoutIfNeeded];
2034 XCTAssertNotNil(childClippingView.maskView);
2037 - (void)testClipRect {
2038 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2040 flutter::TaskRunners runners(
self.name.UTF8String,
2041 GetDefaultTaskRunner(),
2042 GetDefaultTaskRunner(),
2043 GetDefaultTaskRunner(),
2044 GetDefaultTaskRunner());
2047 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2048 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2050 mock_delegate.settings_.enable_impeller
2053 flutterPlatformViewsController,
2056 std::make_shared<fml::SyncSwitch>());
2060 [flutterPlatformViewsController
2062 withId:@"MockFlutterPlatformView"
2066 [flutterPlatformViewsController
2070 @"viewType" : @"MockFlutterPlatformView"
2076 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2077 flutterPlatformViewsController.
flutterView = flutterView;
2079 flutter::MutatorsStack stack;
2081 SkMatrix screenScaleMatrix =
2082 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2083 stack.PushTransform(screenScaleMatrix);
2085 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
2086 stack.PushClipRect(rect);
2088 auto embeddedViewParams =
2089 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
2091 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2092 withParams:std::move(embeddedViewParams)];
2093 [flutterPlatformViewsController
2100 [flutterView addSubview:childClippingView];
2102 [flutterView setNeedsLayout];
2103 [flutterView layoutIfNeeded];
2105 CGRect insideClipping = CGRectMake(2, 2, 3, 3);
2106 for (
int i = 0; i < 10; i++) {
2107 for (
int j = 0; j < 10; j++) {
2108 CGPoint point = CGPointMake(i, j);
2109 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2110 if (CGRectContainsPoint(insideClipping, point)) {
2111 XCTAssertEqual(alpha, 255);
2113 XCTAssertEqual(alpha, 0);
2119 - (void)testClipRect_multipleClips {
2120 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2122 flutter::TaskRunners runners(
self.name.UTF8String,
2123 GetDefaultTaskRunner(),
2124 GetDefaultTaskRunner(),
2125 GetDefaultTaskRunner(),
2126 GetDefaultTaskRunner());
2129 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2130 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2132 mock_delegate.settings_.enable_impeller
2135 flutterPlatformViewsController,
2138 std::make_shared<fml::SyncSwitch>());
2142 [flutterPlatformViewsController
2144 withId:@"MockFlutterPlatformView"
2148 [flutterPlatformViewsController
2152 @"viewType" : @"MockFlutterPlatformView"
2158 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2159 flutterPlatformViewsController.
flutterView = flutterView;
2161 flutter::MutatorsStack stack;
2163 SkMatrix screenScaleMatrix =
2164 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2165 stack.PushTransform(screenScaleMatrix);
2167 SkRect rect1 = SkRect::MakeXYWH(2, 2, 3, 3);
2168 stack.PushClipRect(rect1);
2170 SkRect rect2 = SkRect::MakeXYWH(3, 3, 3, 3);
2171 stack.PushClipRect(rect2);
2173 auto embeddedViewParams =
2174 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
2176 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2177 withParams:std::move(embeddedViewParams)];
2178 [flutterPlatformViewsController
2185 [flutterView addSubview:childClippingView];
2187 [flutterView setNeedsLayout];
2188 [flutterView layoutIfNeeded];
2207 CGRect insideClipping = CGRectMake(3, 3, 2, 2);
2208 for (
int i = 0; i < 10; i++) {
2209 for (
int j = 0; j < 10; j++) {
2210 CGPoint point = CGPointMake(i, j);
2211 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2212 if (CGRectContainsPoint(insideClipping, point)) {
2213 XCTAssertEqual(alpha, 255);
2215 XCTAssertEqual(alpha, 0);
2221 - (void)testClipRRect {
2222 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2224 flutter::TaskRunners runners(
self.name.UTF8String,
2225 GetDefaultTaskRunner(),
2226 GetDefaultTaskRunner(),
2227 GetDefaultTaskRunner(),
2228 GetDefaultTaskRunner());
2231 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2232 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2234 mock_delegate.settings_.enable_impeller
2237 flutterPlatformViewsController,
2240 std::make_shared<fml::SyncSwitch>());
2244 [flutterPlatformViewsController
2246 withId:@"MockFlutterPlatformView"
2250 [flutterPlatformViewsController
2254 @"viewType" : @"MockFlutterPlatformView"
2260 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2261 flutterPlatformViewsController.
flutterView = flutterView;
2263 flutter::MutatorsStack stack;
2265 SkMatrix screenScaleMatrix =
2266 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2267 stack.PushTransform(screenScaleMatrix);
2269 SkRRect rrect = SkRRect::MakeRectXY(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2270 stack.PushClipRRect(rrect);
2272 auto embeddedViewParams =
2273 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
2275 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2276 withParams:std::move(embeddedViewParams)];
2277 [flutterPlatformViewsController
2284 [flutterView addSubview:childClippingView];
2286 [flutterView setNeedsLayout];
2287 [flutterView layoutIfNeeded];
2308 CGRect innerClipping1 = CGRectMake(3, 2, 4, 6);
2309 CGRect innerClipping2 = CGRectMake(2, 3, 6, 4);
2310 CGRect outterClipping = CGRectMake(2, 2, 6, 6);
2311 for (
int i = 0; i < 10; i++) {
2312 for (
int j = 0; j < 10; j++) {
2313 CGPoint point = CGPointMake(i, j);
2314 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2315 if (CGRectContainsPoint(innerClipping1, point) ||
2316 CGRectContainsPoint(innerClipping2, point)) {
2318 XCTAssertEqual(alpha, 255);
2319 }
else if (CGRectContainsPoint(outterClipping, point)) {
2321 XCTAssert(0 < alpha && alpha < 255);
2324 XCTAssertEqual(alpha, 0);
2330 - (void)testClipRRect_multipleClips {
2331 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2333 flutter::TaskRunners runners(
self.name.UTF8String,
2334 GetDefaultTaskRunner(),
2335 GetDefaultTaskRunner(),
2336 GetDefaultTaskRunner(),
2337 GetDefaultTaskRunner());
2340 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2341 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2343 mock_delegate.settings_.enable_impeller
2346 flutterPlatformViewsController,
2349 std::make_shared<fml::SyncSwitch>());
2353 [flutterPlatformViewsController
2355 withId:@"MockFlutterPlatformView"
2359 [flutterPlatformViewsController
2363 @"viewType" : @"MockFlutterPlatformView"
2369 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2370 flutterPlatformViewsController.
flutterView = flutterView;
2372 flutter::MutatorsStack stack;
2374 SkMatrix screenScaleMatrix =
2375 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2376 stack.PushTransform(screenScaleMatrix);
2378 SkRRect rrect = SkRRect::MakeRectXY(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2379 stack.PushClipRRect(rrect);
2381 SkRect rect = SkRect::MakeXYWH(4, 2, 6, 6);
2382 stack.PushClipRect(rect);
2384 auto embeddedViewParams =
2385 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
2387 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2388 withParams:std::move(embeddedViewParams)];
2389 [flutterPlatformViewsController
2396 [flutterView addSubview:childClippingView];
2398 [flutterView setNeedsLayout];
2399 [flutterView layoutIfNeeded];
2420 CGRect clipping = CGRectMake(4, 2, 4, 6);
2421 for (
int i = 0; i < 10; i++) {
2422 for (
int j = 0; j < 10; j++) {
2423 CGPoint point = CGPointMake(i, j);
2424 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2425 if (i == 7 && (j == 2 || j == 7)) {
2427 XCTAssert(0 < alpha && alpha < 255);
2430 (i == 4 && j >= 2 && j <= 7) ||
2432 (i == 7 && j >= 2 && j <= 7) ||
2434 (j == 2 && i >= 4 && i <= 7) ||
2436 (j == 7 && i >= 4 && i <= 7)) {
2439 XCTAssert(alpha > 127);
2440 }
else if ((i == 3 && j >= 1 && j <= 8) || (i == 8 && j >= 1 && j <= 8) ||
2441 (j == 1 && i >= 3 && i <= 8) || (j == 8 && i >= 3 && i <= 8)) {
2444 XCTAssert(alpha < 127);
2445 }
else if (CGRectContainsPoint(clipping, point)) {
2447 XCTAssertEqual(alpha, 255);
2450 XCTAssertEqual(alpha, 0);
2456 - (void)testClipPath {
2457 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2459 flutter::TaskRunners runners(
self.name.UTF8String,
2460 GetDefaultTaskRunner(),
2461 GetDefaultTaskRunner(),
2462 GetDefaultTaskRunner(),
2463 GetDefaultTaskRunner());
2466 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2467 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2469 mock_delegate.settings_.enable_impeller
2472 flutterPlatformViewsController,
2475 std::make_shared<fml::SyncSwitch>());
2479 [flutterPlatformViewsController
2481 withId:@"MockFlutterPlatformView"
2485 [flutterPlatformViewsController
2489 @"viewType" : @"MockFlutterPlatformView"
2495 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2496 flutterPlatformViewsController.
flutterView = flutterView;
2498 flutter::MutatorsStack stack;
2500 SkMatrix screenScaleMatrix =
2501 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2502 stack.PushTransform(screenScaleMatrix);
2505 path.addRoundRect(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2506 stack.PushClipPath(path);
2508 auto embeddedViewParams =
2509 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
2511 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2512 withParams:std::move(embeddedViewParams)];
2513 [flutterPlatformViewsController
2520 [flutterView addSubview:childClippingView];
2522 [flutterView setNeedsLayout];
2523 [flutterView layoutIfNeeded];
2544 CGRect innerClipping1 = CGRectMake(3, 2, 4, 6);
2545 CGRect innerClipping2 = CGRectMake(2, 3, 6, 4);
2546 CGRect outterClipping = CGRectMake(2, 2, 6, 6);
2547 for (
int i = 0; i < 10; i++) {
2548 for (
int j = 0; j < 10; j++) {
2549 CGPoint point = CGPointMake(i, j);
2550 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2551 if (CGRectContainsPoint(innerClipping1, point) ||
2552 CGRectContainsPoint(innerClipping2, point)) {
2554 XCTAssertEqual(alpha, 255);
2555 }
else if (CGRectContainsPoint(outterClipping, point)) {
2557 XCTAssert(0 < alpha && alpha < 255);
2560 XCTAssertEqual(alpha, 0);
2566 - (void)testClipPath_multipleClips {
2567 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2569 flutter::TaskRunners runners(
self.name.UTF8String,
2570 GetDefaultTaskRunner(),
2571 GetDefaultTaskRunner(),
2572 GetDefaultTaskRunner(),
2573 GetDefaultTaskRunner());
2576 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2577 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2579 mock_delegate.settings_.enable_impeller
2582 flutterPlatformViewsController,
2585 std::make_shared<fml::SyncSwitch>());
2589 [flutterPlatformViewsController
2591 withId:@"MockFlutterPlatformView"
2595 [flutterPlatformViewsController
2599 @"viewType" : @"MockFlutterPlatformView"
2605 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2606 flutterPlatformViewsController.
flutterView = flutterView;
2608 flutter::MutatorsStack stack;
2610 SkMatrix screenScaleMatrix =
2611 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2612 stack.PushTransform(screenScaleMatrix);
2615 path.addRoundRect(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2616 stack.PushClipPath(path);
2618 SkRect rect = SkRect::MakeXYWH(4, 2, 6, 6);
2619 stack.PushClipRect(rect);
2621 auto embeddedViewParams =
2622 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
2624 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2625 withParams:std::move(embeddedViewParams)];
2626 [flutterPlatformViewsController
2633 [flutterView addSubview:childClippingView];
2635 [flutterView setNeedsLayout];
2636 [flutterView layoutIfNeeded];
2657 CGRect clipping = CGRectMake(4, 2, 4, 6);
2658 for (
int i = 0; i < 10; i++) {
2659 for (
int j = 0; j < 10; j++) {
2660 CGPoint point = CGPointMake(i, j);
2661 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2662 if (i == 7 && (j == 2 || j == 7)) {
2664 XCTAssert(0 < alpha && alpha < 255);
2667 (i == 4 && j >= 2 && j <= 7) ||
2669 (i == 7 && j >= 2 && j <= 7) ||
2671 (j == 2 && i >= 4 && i <= 7) ||
2673 (j == 7 && i >= 4 && i <= 7)) {
2676 XCTAssert(alpha > 127);
2677 }
else if ((i == 3 && j >= 1 && j <= 8) || (i == 8 && j >= 1 && j <= 8) ||
2678 (j == 1 && i >= 3 && i <= 8) || (j == 8 && i >= 3 && i <= 8)) {
2681 XCTAssert(alpha < 127);
2682 }
else if (CGRectContainsPoint(clipping, point)) {
2684 XCTAssertEqual(alpha, 255);
2687 XCTAssertEqual(alpha, 0);
2693 - (void)testSetFlutterViewControllerAfterCreateCanStillDispatchTouchEvents {
2694 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2696 flutter::TaskRunners runners(
self.name.UTF8String,
2697 GetDefaultTaskRunner(),
2698 GetDefaultTaskRunner(),
2699 GetDefaultTaskRunner(),
2700 GetDefaultTaskRunner());
2703 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2704 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2706 mock_delegate.settings_.enable_impeller
2709 flutterPlatformViewsController,
2712 std::make_shared<fml::SyncSwitch>());
2716 [flutterPlatformViewsController
2718 withId:@"MockFlutterPlatformView"
2722 [flutterPlatformViewsController
2726 @"viewType" : @"MockFlutterPlatformView"
2734 while (touchInteceptorView != nil &&
2736 touchInteceptorView = touchInteceptorView.superview;
2738 XCTAssertNotNil(touchInteceptorView);
2741 UIGestureRecognizer* forwardGectureRecognizer = nil;
2742 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2744 forwardGectureRecognizer = gestureRecognizer;
2750 NSSet* touches1 = [[NSSet alloc] init];
2751 id event1 = OCMClassMock([UIEvent
class]);
2753 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2754 OCMReject([flutterViewController touchesBegan:touches1 withEvent:event1]);
2757 NSSet* touches2 = [[NSSet alloc] init];
2758 id event2 = OCMClassMock([UIEvent
class]);
2760 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
2761 OCMVerify([flutterViewController touchesBegan:touches2 withEvent:event2]);
2764 - (void)testSetFlutterViewControllerInTheMiddleOfTouchEventShouldStillAllowGesturesToBeHandled {
2765 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2767 flutter::TaskRunners runners(
self.name.UTF8String,
2768 GetDefaultTaskRunner(),
2769 GetDefaultTaskRunner(),
2770 GetDefaultTaskRunner(),
2771 GetDefaultTaskRunner());
2774 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2775 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2777 mock_delegate.settings_.enable_impeller
2780 flutterPlatformViewsController,
2783 std::make_shared<fml::SyncSwitch>());
2787 [flutterPlatformViewsController
2789 withId:@"MockFlutterPlatformView"
2793 [flutterPlatformViewsController
2797 @"viewType" : @"MockFlutterPlatformView"
2805 while (touchInteceptorView != nil &&
2807 touchInteceptorView = touchInteceptorView.superview;
2809 XCTAssertNotNil(touchInteceptorView);
2812 UIGestureRecognizer* forwardGectureRecognizer = nil;
2813 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2815 forwardGectureRecognizer = gestureRecognizer;
2824 NSSet* touches1 = [[NSSet alloc] init];
2825 id event1 = OCMClassMock([UIEvent
class]);
2826 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2827 OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
2832 NSSet* touches2 = [[NSSet alloc] init];
2833 id event2 = OCMClassMock([UIEvent
class]);
2834 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2835 OCMVerify([flutterViewController touchesMoved:touches2 withEvent:event2]);
2837 NSSet* touches3 = [[NSSet alloc] init];
2838 id event3 = OCMClassMock([UIEvent
class]);
2839 [forwardGectureRecognizer touchesEnded:touches3 withEvent:event3];
2840 OCMVerify([flutterViewController touchesEnded:touches3 withEvent:event3]);
2843 NSSet* touches4 = [[NSSet alloc] init];
2844 id event4 = OCMClassMock([UIEvent
class]);
2845 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2846 OCMReject([flutterViewController touchesBegan:touches4 withEvent:event4]);
2848 NSSet* touches5 = [[NSSet alloc] init];
2849 id event5 = OCMClassMock([UIEvent
class]);
2850 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2851 OCMReject([flutterViewController touchesEnded:touches5 withEvent:event5]);
2858 NSSet* touches1 = [[NSSet alloc] init];
2859 id event1 = OCMClassMock([UIEvent
class]);
2860 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2861 OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
2866 NSSet* touches2 = [[NSSet alloc] init];
2867 id event2 = OCMClassMock([UIEvent
class]);
2868 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2869 OCMVerify([flutterViewController touchesMoved:touches2 withEvent:event2]);
2871 NSSet* touches3 = [[NSSet alloc] init];
2872 id event3 = OCMClassMock([UIEvent
class]);
2873 [forwardGectureRecognizer touchesCancelled:touches3 withEvent:event3];
2874 OCMVerify([flutterViewController forceTouchesCancelled:touches3]);
2877 NSSet* touches4 = [[NSSet alloc] init];
2878 id event4 = OCMClassMock([UIEvent
class]);
2879 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2880 OCMReject([flutterViewController touchesBegan:touches4 withEvent:event4]);
2882 NSSet* touches5 = [[NSSet alloc] init];
2883 id event5 = OCMClassMock([UIEvent
class]);
2884 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2885 OCMReject([flutterViewController touchesEnded:touches5 withEvent:event5]);
2888 [flutterPlatformViewsController
reset];
2892 testSetFlutterViewControllerInTheMiddleOfTouchEventAllowsTheNewControllerToHandleSecondTouchSequence {
2893 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2895 flutter::TaskRunners runners(
self.name.UTF8String,
2896 GetDefaultTaskRunner(),
2897 GetDefaultTaskRunner(),
2898 GetDefaultTaskRunner(),
2899 GetDefaultTaskRunner());
2902 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
2903 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2905 mock_delegate.settings_.enable_impeller
2908 flutterPlatformViewsController,
2911 std::make_shared<fml::SyncSwitch>());
2915 [flutterPlatformViewsController
2917 withId:@"MockFlutterPlatformView"
2921 [flutterPlatformViewsController
2925 @"viewType" : @"MockFlutterPlatformView"
2933 while (touchInteceptorView != nil &&
2935 touchInteceptorView = touchInteceptorView.superview;
2937 XCTAssertNotNil(touchInteceptorView);
2940 UIGestureRecognizer* forwardGectureRecognizer = nil;
2941 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2943 forwardGectureRecognizer = gestureRecognizer;
2951 NSSet* touches1 = [NSSet setWithObject:@1];
2952 id event1 = OCMClassMock([UIEvent
class]);
2953 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2954 OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
2961 NSSet* touches2 = [NSSet setWithObject:@1];
2962 id event2 = OCMClassMock([UIEvent
class]);
2963 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
2964 OCMVerify([flutterViewController touchesBegan:touches2 withEvent:event2]);
2965 OCMReject([flutterViewController2 touchesBegan:touches2 withEvent:event2]);
2967 NSSet* touches3 = [NSSet setWithObject:@1];
2968 id event3 = OCMClassMock([UIEvent
class]);
2969 [forwardGectureRecognizer touchesMoved:touches3 withEvent:event3];
2970 OCMVerify([flutterViewController touchesMoved:touches3 withEvent:event3]);
2971 OCMReject([flutterViewController2 touchesMoved:touches3 withEvent:event3]);
2973 NSSet* touches4 = [NSSet setWithObject:@1];
2974 id event4 = OCMClassMock([UIEvent
class]);
2975 [forwardGectureRecognizer touchesEnded:touches4 withEvent:event4];
2976 OCMVerify([flutterViewController touchesEnded:touches4 withEvent:event4]);
2977 OCMReject([flutterViewController2 touchesEnded:touches4 withEvent:event4]);
2979 NSSet* touches5 = [NSSet setWithObject:@1];
2980 id event5 = OCMClassMock([UIEvent
class]);
2981 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2982 OCMVerify([flutterViewController touchesEnded:touches5 withEvent:event5]);
2983 OCMReject([flutterViewController2 touchesEnded:touches5 withEvent:event5]);
2987 NSSet* touches6 = [NSSet setWithObject:@1];
2988 id event6 = OCMClassMock([UIEvent
class]);
2989 [forwardGectureRecognizer touchesBegan:touches6 withEvent:event6];
2990 OCMVerify([flutterViewController2 touchesBegan:touches6 withEvent:event6]);
2991 OCMReject([flutterViewController touchesBegan:touches6 withEvent:event6]);
2994 NSSet* touches7 = [NSSet setWithObject:@1];
2995 id event7 = OCMClassMock([UIEvent
class]);
2996 [forwardGectureRecognizer touchesMoved:touches7 withEvent:event7];
2997 OCMVerify([flutterViewController2 touchesMoved:touches7 withEvent:event7]);
2998 OCMReject([flutterViewController touchesMoved:touches7 withEvent:event7]);
3000 NSSet* touches8 = [NSSet setWithObject:@1];
3001 id event8 = OCMClassMock([UIEvent
class]);
3002 [forwardGectureRecognizer touchesEnded:touches8 withEvent:event8];
3003 OCMVerify([flutterViewController2 touchesEnded:touches8 withEvent:event8]);
3004 OCMReject([flutterViewController touchesEnded:touches8 withEvent:event8]);
3006 [flutterPlatformViewsController
reset];
3009 - (void)testFlutterPlatformViewTouchesCancelledEventAreForcedToBeCancelled {
3010 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3012 flutter::TaskRunners runners(
self.name.UTF8String,
3013 GetDefaultTaskRunner(),
3014 GetDefaultTaskRunner(),
3015 GetDefaultTaskRunner(),
3016 GetDefaultTaskRunner());
3019 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3020 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3022 mock_delegate.settings_.enable_impeller
3025 flutterPlatformViewsController,
3028 std::make_shared<fml::SyncSwitch>());
3032 [flutterPlatformViewsController
3034 withId:@"MockFlutterPlatformView"
3038 [flutterPlatformViewsController
3042 @"viewType" : @"MockFlutterPlatformView"
3050 while (touchInteceptorView != nil &&
3052 touchInteceptorView = touchInteceptorView.superview;
3054 XCTAssertNotNil(touchInteceptorView);
3057 UIGestureRecognizer* forwardGectureRecognizer = nil;
3058 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
3060 forwardGectureRecognizer = gestureRecognizer;
3067 NSSet* touches1 = [NSSet setWithObject:@1];
3068 id event1 = OCMClassMock([UIEvent
class]);
3069 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
3071 [forwardGectureRecognizer touchesCancelled:touches1 withEvent:event1];
3072 OCMVerify([flutterViewController forceTouchesCancelled:touches1]);
3074 [flutterPlatformViewsController
reset];
3077 - (void)testFlutterPlatformViewTouchesEndedOrTouchesCancelledEventDoesNotFailTheGestureRecognizer {
3078 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3080 flutter::TaskRunners runners(
self.name.UTF8String,
3081 GetDefaultTaskRunner(),
3082 GetDefaultTaskRunner(),
3083 GetDefaultTaskRunner(),
3084 GetDefaultTaskRunner());
3087 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3088 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3090 mock_delegate.settings_.enable_impeller
3093 flutterPlatformViewsController,
3096 std::make_shared<fml::SyncSwitch>());
3100 [flutterPlatformViewsController
3102 withId:@"MockFlutterPlatformView"
3106 [flutterPlatformViewsController
3110 @"viewType" : @"MockFlutterPlatformView"
3118 while (touchInteceptorView != nil &&
3120 touchInteceptorView = touchInteceptorView.superview;
3122 XCTAssertNotNil(touchInteceptorView);
3125 __block UIGestureRecognizer* forwardGestureRecognizer = nil;
3126 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
3128 forwardGestureRecognizer = gestureRecognizer;
3135 NSSet* touches1 = [NSSet setWithObject:@1];
3136 id event1 = OCMClassMock([UIEvent
class]);
3137 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3138 @"Forwarding gesture recognizer must start with possible state.");
3139 [forwardGestureRecognizer touchesBegan:touches1 withEvent:event1];
3140 [forwardGestureRecognizer touchesEnded:touches1 withEvent:event1];
3141 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStateFailed,
3142 @"Forwarding gesture recognizer must end with failed state.");
3144 XCTestExpectation* touchEndedExpectation =
3145 [
self expectationWithDescription:@"Wait for gesture recognizer's state change."];
3146 dispatch_async(dispatch_get_main_queue(), ^{
3148 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
3149 if ([gestureRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]) {
3150 forwardGestureRecognizer = gestureRecognizer;
3154 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3155 @"Forwarding gesture recognizer must be reset to possible state.");
3156 [touchEndedExpectation fulfill];
3158 [
self waitForExpectationsWithTimeout:30 handler:nil];
3160 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3161 @"Forwarding gesture recognizer must start with possible state.");
3162 [forwardGestureRecognizer touchesBegan:touches1 withEvent:event1];
3163 [forwardGestureRecognizer touchesCancelled:touches1 withEvent:event1];
3164 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStateFailed,
3165 @"Forwarding gesture recognizer must end with failed state.");
3166 XCTestExpectation* touchCancelledExpectation =
3167 [
self expectationWithDescription:@"Wait for gesture recognizer's state change."];
3168 dispatch_async(dispatch_get_main_queue(), ^{
3170 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
3171 if ([gestureRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]) {
3172 forwardGestureRecognizer = gestureRecognizer;
3176 XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3177 @"Forwarding gesture recognizer must be reset to possible state.");
3178 [touchCancelledExpectation fulfill];
3180 [
self waitForExpectationsWithTimeout:30 handler:nil];
3182 [flutterPlatformViewsController reset];
3186 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForWebView {
3187 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3189 flutter::TaskRunners runners(
self.name.UTF8String,
3190 GetDefaultTaskRunner(),
3191 GetDefaultTaskRunner(),
3192 GetDefaultTaskRunner(),
3193 GetDefaultTaskRunner());
3196 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3197 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3199 mock_delegate.settings_.enable_impeller
3202 flutterPlatformViewsController,
3205 std::make_shared<fml::SyncSwitch>());
3209 [flutterPlatformViewsController
3215 [flutterPlatformViewsController
3218 arguments:@{@"id" : @2, @"viewType" : @"MockWebView"}]
3225 while (touchInteceptorView != nil &&
3227 touchInteceptorView = touchInteceptorView.superview;
3229 XCTAssertNotNil(touchInteceptorView);
3231 XCTAssert(touchInteceptorView.gestureRecognizers.count == 2);
3232 UIGestureRecognizer* delayingRecognizer = touchInteceptorView.gestureRecognizers[0];
3233 UIGestureRecognizer* forwardingRecognizer = touchInteceptorView.gestureRecognizers[1];
3240 if (@available(iOS 18.2, *)) {
3242 XCTAssertEqual(touchInteceptorView.gestureRecognizers[0], forwardingRecognizer);
3243 XCTAssertEqual(touchInteceptorView.gestureRecognizers[1], delayingRecognizer);
3245 XCTAssertEqual(touchInteceptorView.gestureRecognizers[0], delayingRecognizer);
3246 XCTAssertEqual(touchInteceptorView.gestureRecognizers[1], forwardingRecognizer);
3251 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForWrapperWebView {
3252 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3254 flutter::TaskRunners runners(
self.name.UTF8String,
3255 GetDefaultTaskRunner(),
3256 GetDefaultTaskRunner(),
3257 GetDefaultTaskRunner(),
3258 GetDefaultTaskRunner());
3261 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3262 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3264 mock_delegate.settings_.enable_impeller
3267 flutterPlatformViewsController,
3270 std::make_shared<fml::SyncSwitch>());
3274 [flutterPlatformViewsController
3276 withId:@"MockWrapperWebView"
3280 [flutterPlatformViewsController
3283 arguments:@{@"id" : @2, @"viewType" : @"MockWrapperWebView"}]
3290 while (touchInteceptorView != nil &&
3292 touchInteceptorView = touchInteceptorView.superview;
3294 XCTAssertNotNil(touchInteceptorView);
3296 XCTAssert(touchInteceptorView.gestureRecognizers.count == 2);
3297 UIGestureRecognizer* delayingRecognizer = touchInteceptorView.gestureRecognizers[0];
3298 UIGestureRecognizer* forwardingRecognizer = touchInteceptorView.gestureRecognizers[1];
3305 if (@available(iOS 18.2, *)) {
3307 XCTAssertEqual(touchInteceptorView.gestureRecognizers[0], forwardingRecognizer);
3308 XCTAssertEqual(touchInteceptorView.gestureRecognizers[1], delayingRecognizer);
3310 XCTAssertEqual(touchInteceptorView.gestureRecognizers[0], delayingRecognizer);
3311 XCTAssertEqual(touchInteceptorView.gestureRecognizers[1], forwardingRecognizer);
3316 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldNotRemoveAndAddBackDelayingRecognizerForNestedWrapperWebView {
3317 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3319 flutter::TaskRunners runners(
self.name.UTF8String,
3320 GetDefaultTaskRunner(),
3321 GetDefaultTaskRunner(),
3322 GetDefaultTaskRunner(),
3323 GetDefaultTaskRunner());
3326 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3327 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3329 mock_delegate.settings_.enable_impeller
3332 flutterPlatformViewsController,
3335 std::make_shared<fml::SyncSwitch>());
3339 [flutterPlatformViewsController
3341 withId:@"MockNestedWrapperWebView"
3345 [flutterPlatformViewsController
3349 @"viewType" : @"MockNestedWrapperWebView"
3357 while (touchInteceptorView != nil &&
3359 touchInteceptorView = touchInteceptorView.superview;
3361 XCTAssertNotNil(touchInteceptorView);
3363 XCTAssert(touchInteceptorView.gestureRecognizers.count == 2);
3364 UIGestureRecognizer* delayingRecognizer = touchInteceptorView.gestureRecognizers[0];
3365 UIGestureRecognizer* forwardingRecognizer = touchInteceptorView.gestureRecognizers[1];
3372 XCTAssertEqual(touchInteceptorView.gestureRecognizers[0], delayingRecognizer);
3373 XCTAssertEqual(touchInteceptorView.gestureRecognizers[1], forwardingRecognizer);
3377 testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldNotRemoveAndAddBackDelayingRecognizerForNonWebView {
3378 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3380 flutter::TaskRunners runners(
self.name.UTF8String,
3381 GetDefaultTaskRunner(),
3382 GetDefaultTaskRunner(),
3383 GetDefaultTaskRunner(),
3384 GetDefaultTaskRunner());
3387 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3388 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3390 mock_delegate.settings_.enable_impeller
3393 flutterPlatformViewsController,
3396 std::make_shared<fml::SyncSwitch>());
3400 [flutterPlatformViewsController
3402 withId:@"MockFlutterPlatformView"
3406 [flutterPlatformViewsController
3410 @"viewType" : @"MockFlutterPlatformView"
3418 while (touchInteceptorView != nil &&
3420 touchInteceptorView = touchInteceptorView.superview;
3422 XCTAssertNotNil(touchInteceptorView);
3424 XCTAssert(touchInteceptorView.gestureRecognizers.count == 2);
3425 UIGestureRecognizer* delayingRecognizer = touchInteceptorView.gestureRecognizers[0];
3426 UIGestureRecognizer* forwardingRecognizer = touchInteceptorView.gestureRecognizers[1];
3433 XCTAssertEqual(touchInteceptorView.gestureRecognizers[0], delayingRecognizer);
3434 XCTAssertEqual(touchInteceptorView.gestureRecognizers[1], forwardingRecognizer);
3437 - (void)testFlutterPlatformViewControllerSubmitFrameWithoutFlutterViewNotCrashing {
3438 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3440 flutter::TaskRunners runners(
self.name.UTF8String,
3441 GetDefaultTaskRunner(),
3442 GetDefaultTaskRunner(),
3443 GetDefaultTaskRunner(),
3444 GetDefaultTaskRunner());
3447 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3448 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3450 mock_delegate.settings_.enable_impeller
3453 flutterPlatformViewsController,
3456 std::make_shared<fml::SyncSwitch>());
3460 [flutterPlatformViewsController
3462 withId:@"MockFlutterPlatformView"
3466 [flutterPlatformViewsController
3470 @"viewType" : @"MockFlutterPlatformView"
3477 flutter::MutatorsStack stack;
3478 SkMatrix finalMatrix;
3480 auto embeddedViewParams_1 =
3481 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3483 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
3484 withParams:std::move(embeddedViewParams_1)];
3485 [flutterPlatformViewsController
3489 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3490 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3491 nullptr, framebuffer_info,
3492 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return false; },
3493 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
3494 SkISize::Make(800, 600));
3495 XCTAssertFalse([flutterPlatformViewsController
3496 submitFrame:std::move(mock_surface)
3497 withIosContext:std::make_shared<flutter::IOSContextNoop>()
3500 auto embeddedViewParams_2 =
3501 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3502 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
3503 withParams:std::move(embeddedViewParams_2)];
3504 [flutterPlatformViewsController
3508 auto mock_surface_submit_true = std::make_unique<flutter::SurfaceFrame>(
3509 nullptr, framebuffer_info,
3510 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3511 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
3512 SkISize::Make(800, 600));
3513 XCTAssertTrue([flutterPlatformViewsController
3514 submitFrame:std::move(mock_surface_submit_true)
3515 withIosContext:std::make_shared<flutter::IOSContextNoop>()
3520 testFlutterPlatformViewControllerResetDeallocsPlatformViewWhenRootViewsNotBindedToFlutterView {
3521 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3523 flutter::TaskRunners runners(
self.name.UTF8String,
3524 GetDefaultTaskRunner(),
3525 GetDefaultTaskRunner(),
3526 GetDefaultTaskRunner(),
3527 GetDefaultTaskRunner());
3530 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3531 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3533 mock_delegate.settings_.enable_impeller
3536 flutterPlatformViewsController,
3539 std::make_shared<fml::SyncSwitch>());
3541 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
3542 flutterPlatformViewsController.
flutterView = flutterView;
3546 [flutterPlatformViewsController
3548 withId:@"MockFlutterPlatformView"
3554 [flutterPlatformViewsController
3558 @"viewType" : @"MockFlutterPlatformView"
3562 flutter::MutatorsStack stack;
3563 SkMatrix finalMatrix;
3564 auto embeddedViewParams =
3565 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3566 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
3567 withParams:std::move(embeddedViewParams)];
3573 [flutterPlatformViewsController
reset];
3578 - (void)testFlutterPlatformViewControllerBeginFrameShouldResetCompisitionOrder {
3579 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3581 flutter::TaskRunners runners(
self.name.UTF8String,
3582 GetDefaultTaskRunner(),
3583 GetDefaultTaskRunner(),
3584 GetDefaultTaskRunner(),
3585 GetDefaultTaskRunner());
3588 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3589 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3591 mock_delegate.settings_.enable_impeller
3594 flutterPlatformViewsController,
3597 std::make_shared<fml::SyncSwitch>());
3599 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
3600 flutterPlatformViewsController.
flutterView = flutterView;
3604 [flutterPlatformViewsController
3606 withId:@"MockFlutterPlatformView"
3611 [flutterPlatformViewsController
3615 @"viewType" : @"MockFlutterPlatformView"
3620 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
3621 flutter::MutatorsStack stack;
3622 SkMatrix finalMatrix;
3623 auto embeddedViewParams1 =
3624 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3625 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
3626 withParams:std::move(embeddedViewParams1)];
3627 [flutterPlatformViewsController
3634 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
3637 auto embeddedViewParams2 =
3638 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3639 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
3640 withParams:std::move(embeddedViewParams2)];
3641 [flutterPlatformViewsController
3649 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithDifferentViewHierarchy {
3650 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3652 flutter::TaskRunners runners(
self.name.UTF8String,
3653 GetDefaultTaskRunner(),
3654 GetDefaultTaskRunner(),
3655 GetDefaultTaskRunner(),
3656 GetDefaultTaskRunner());
3659 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3660 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3662 mock_delegate.settings_.enable_impeller
3665 flutterPlatformViewsController,
3668 std::make_shared<fml::SyncSwitch>());
3670 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
3671 flutterPlatformViewsController.
flutterView = flutterView;
3675 [flutterPlatformViewsController
3677 withId:@"MockFlutterPlatformView"
3681 [flutterPlatformViewsController
3685 @"viewType" : @"MockFlutterPlatformView"
3691 [flutterPlatformViewsController
3695 @"viewType" : @"MockFlutterPlatformView"
3700 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
3701 flutter::MutatorsStack stack;
3702 SkMatrix finalMatrix;
3703 auto embeddedViewParams1 =
3704 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3705 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
3706 withParams:std::move(embeddedViewParams1)];
3708 auto embeddedViewParams2 =
3709 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
3710 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
3711 withParams:std::move(embeddedViewParams2)];
3714 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
3715 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
3716 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3717 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3718 std::move(mock_sk_surface), framebuffer_info,
3719 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3720 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
3721 SkISize::Make(800, 600));
3722 XCTAssertTrue([flutterPlatformViewsController
3723 submitFrame:std::move(mock_surface)
3724 withIosContext:std::make_shared<flutter::IOSContextNoop>()
3728 UIView* clippingView1 = view1.superview.superview;
3729 UIView* clippingView2 = view2.superview.superview;
3730 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
3731 [flutterView.subviews indexOfObject:clippingView2],
3732 @"The first clipping view should be added before the second clipping view.");
3735 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
3737 embeddedViewParams2 =
3738 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
3739 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
3740 withParams:std::move(embeddedViewParams2)];
3742 embeddedViewParams1 =
3743 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3744 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
3745 withParams:std::move(embeddedViewParams1)];
3747 mock_sk_surface = SkSurfaces::Raster(image_info);
3748 mock_surface = std::make_unique<flutter::SurfaceFrame>(
3749 std::move(mock_sk_surface), framebuffer_info,
3750 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3751 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
3752 SkISize::Make(800, 600));
3753 XCTAssertTrue([flutterPlatformViewsController
3754 submitFrame:std::move(mock_surface)
3755 withIosContext:std::make_shared<flutter::IOSContextNoop>()
3758 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] >
3759 [flutterView.subviews indexOfObject:clippingView2],
3760 @"The first clipping view should be added after the second clipping view.");
3764 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithSameViewHierarchy {
3765 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3767 flutter::TaskRunners runners(
self.name.UTF8String,
3768 GetDefaultTaskRunner(),
3769 GetDefaultTaskRunner(),
3770 GetDefaultTaskRunner(),
3771 GetDefaultTaskRunner());
3774 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3775 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3777 mock_delegate.settings_.enable_impeller
3780 flutterPlatformViewsController,
3783 std::make_shared<fml::SyncSwitch>());
3785 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
3786 flutterPlatformViewsController.
flutterView = flutterView;
3790 [flutterPlatformViewsController
3792 withId:@"MockFlutterPlatformView"
3796 [flutterPlatformViewsController
3800 @"viewType" : @"MockFlutterPlatformView"
3806 [flutterPlatformViewsController
3810 @"viewType" : @"MockFlutterPlatformView"
3815 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
3816 flutter::MutatorsStack stack;
3817 SkMatrix finalMatrix;
3818 auto embeddedViewParams1 =
3819 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3820 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
3821 withParams:std::move(embeddedViewParams1)];
3823 auto embeddedViewParams2 =
3824 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
3825 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
3826 withParams:std::move(embeddedViewParams2)];
3829 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
3830 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
3831 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3832 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3833 std::move(mock_sk_surface), framebuffer_info,
3834 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3835 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
3836 SkISize::Make(800, 600));
3837 XCTAssertTrue([flutterPlatformViewsController
3838 submitFrame:std::move(mock_surface)
3839 withIosContext:std::make_shared<flutter::IOSContextNoop>()
3843 UIView* clippingView1 = view1.superview.superview;
3844 UIView* clippingView2 = view2.superview.superview;
3845 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
3846 [flutterView.subviews indexOfObject:clippingView2],
3847 @"The first clipping view should be added before the second clipping view.");
3850 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
3852 embeddedViewParams1 =
3853 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3854 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
3855 withParams:std::move(embeddedViewParams1)];
3857 embeddedViewParams2 =
3858 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
3859 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
3860 withParams:std::move(embeddedViewParams2)];
3862 mock_sk_surface = SkSurfaces::Raster(image_info);
3863 mock_surface = std::make_unique<flutter::SurfaceFrame>(
3864 std::move(mock_sk_surface), framebuffer_info,
3865 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3866 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
3867 SkISize::Make(800, 600));
3868 XCTAssertTrue([flutterPlatformViewsController
3869 submitFrame:std::move(mock_surface)
3870 withIosContext:std::make_shared<flutter::IOSContextNoop>()
3873 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
3874 [flutterView.subviews indexOfObject:clippingView2],
3875 @"The first clipping view should be added before the second clipping view.");
3878 - (int)alphaOfPoint:(CGPoint)point onView:(UIView*)view {
3879 unsigned char pixel[4] = {0};
3881 CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
3884 CGContextRef context = CGBitmapContextCreate(
3885 pixel, 1, 1, 8, 4, colorSpace, kCGBitmapAlphaInfoMask & kCGImageAlphaPremultipliedLast);
3886 CGContextTranslateCTM(context, -point.x, -point.y);
3887 [view.layer renderInContext:context];
3889 CGContextRelease(context);
3890 CGColorSpaceRelease(colorSpace);
3895 - (void)testHasFirstResponderInViewHierarchySubtree_viewItselfBecomesFirstResponder {
3897 UIWindow* window = [[UIWindow alloc] init];
3898 UITextField* textField = [[UITextField alloc] init];
3899 [window addSubview:textField];
3901 [textField becomeFirstResponder];
3902 XCTAssertTrue(textField.isFirstResponder);
3903 XCTAssertTrue(textField.flt_hasFirstResponderInViewHierarchySubtree);
3904 [textField resignFirstResponder];
3905 XCTAssertFalse(textField.isFirstResponder);
3906 XCTAssertFalse(textField.flt_hasFirstResponderInViewHierarchySubtree);
3909 - (void)testHasFirstResponderInViewHierarchySubtree_descendantViewBecomesFirstResponder {
3911 UIWindow* window = [[UIWindow alloc] init];
3912 UIView* view = [[UIView alloc] init];
3913 UIView* childView = [[UIView alloc] init];
3914 UITextField* textField = [[UITextField alloc] init];
3915 [window addSubview:view];
3916 [view addSubview:childView];
3917 [childView addSubview:textField];
3919 [textField becomeFirstResponder];
3920 XCTAssertTrue(textField.isFirstResponder);
3921 XCTAssertTrue(view.flt_hasFirstResponderInViewHierarchySubtree);
3922 [textField resignFirstResponder];
3923 XCTAssertFalse(textField.isFirstResponder);
3924 XCTAssertFalse(view.flt_hasFirstResponderInViewHierarchySubtree);
3927 - (void)testFlutterClippingMaskViewPoolReuseViewsAfterRecycle {
3933 CGRect newRect = CGRectMake(0, 0, 10, 10);
3937 NSSet* set1 = [NSSet setWithObjects:view1, view2, nil];
3938 NSSet* set2 = [NSSet setWithObjects:view3, view4, nil];
3939 XCTAssertEqualObjects(set1, set2);
3940 XCTAssertTrue(CGRectEqualToRect(view3.frame, newRect));
3941 XCTAssertTrue(CGRectEqualToRect(view4.frame, newRect));
3944 - (void)testFlutterClippingMaskViewPoolAllocsNewMaskViewsAfterReachingCapacity {
3949 XCTAssertNotEqual(view1, view3);
3950 XCTAssertNotEqual(view2, view3);
3953 - (void)testMaskViewsReleasedWhenPoolIsReleased {
3954 __weak UIView* weakView;
3959 XCTAssertNotNil(weakView);
3961 XCTAssertNil(weakView);
3964 - (void)testClipMaskViewIsReused {
3965 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3967 flutter::TaskRunners runners(
self.name.UTF8String,
3968 GetDefaultTaskRunner(),
3969 GetDefaultTaskRunner(),
3970 GetDefaultTaskRunner(),
3971 GetDefaultTaskRunner());
3974 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
3975 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3977 mock_delegate.settings_.enable_impeller
3980 flutterPlatformViewsController,
3983 std::make_shared<fml::SyncSwitch>());
3987 [flutterPlatformViewsController
3989 withId:@"MockFlutterPlatformView"
3993 [flutterPlatformViewsController
3997 @"viewType" : @"MockFlutterPlatformView"
4002 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4003 flutterPlatformViewsController.
flutterView = flutterView;
4005 flutter::MutatorsStack stack1;
4007 SkMatrix screenScaleMatrix =
4008 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
4009 stack1.PushTransform(screenScaleMatrix);
4011 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
4012 stack1.PushClipRect(rect);
4014 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4015 screenScaleMatrix, SkSize::Make(10, 10), stack1);
4017 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4018 withParams:std::move(embeddedViewParams1)];
4019 [flutterPlatformViewsController
4024 UIView* maskView1 = childClippingView1.maskView;
4025 XCTAssertNotNil(maskView1);
4028 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(100, 100)];
4029 flutter::MutatorsStack stack2;
4030 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4031 screenScaleMatrix, SkSize::Make(10, 10), stack2);
4032 auto embeddedViewParams3 = std::make_unique<flutter::EmbeddedViewParams>(
4033 screenScaleMatrix, SkSize::Make(10, 10), stack2);
4034 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4035 withParams:std::move(embeddedViewParams3)];
4036 [flutterPlatformViewsController
4043 [flutterPlatformViewsController
4047 @"viewType" : @"MockFlutterPlatformView"
4051 auto embeddedViewParams4 = std::make_unique<flutter::EmbeddedViewParams>(
4052 screenScaleMatrix, SkSize::Make(10, 10), stack1);
4053 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4054 withParams:std::move(embeddedViewParams4)];
4055 [flutterPlatformViewsController
4061 UIView* maskView2 = childClippingView2.maskView;
4062 XCTAssertEqual(maskView1, maskView2);
4063 XCTAssertNotNil(childClippingView2.maskView);
4064 XCTAssertNil(childClippingView1.maskView);
4067 - (void)testDifferentClipMaskViewIsUsedForEachView {
4068 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4070 flutter::TaskRunners runners(
self.name.UTF8String,
4071 GetDefaultTaskRunner(),
4072 GetDefaultTaskRunner(),
4073 GetDefaultTaskRunner(),
4074 GetDefaultTaskRunner());
4077 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
4078 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4080 mock_delegate.settings_.enable_impeller
4083 flutterPlatformViewsController,
4086 std::make_shared<fml::SyncSwitch>());
4090 [flutterPlatformViewsController
4092 withId:@"MockFlutterPlatformView"
4097 [flutterPlatformViewsController
4101 @"viewType" : @"MockFlutterPlatformView"
4107 [flutterPlatformViewsController
4111 @"viewType" : @"MockFlutterPlatformView"
4117 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4118 flutterPlatformViewsController.
flutterView = flutterView;
4120 flutter::MutatorsStack stack1;
4122 SkMatrix screenScaleMatrix =
4123 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
4124 stack1.PushTransform(screenScaleMatrix);
4126 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
4127 stack1.PushClipRect(rect);
4129 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4130 screenScaleMatrix, SkSize::Make(10, 10), stack1);
4132 flutter::MutatorsStack stack2;
4133 stack2.PushClipRect(rect);
4134 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4135 screenScaleMatrix, SkSize::Make(10, 10), stack2);
4137 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4138 withParams:std::move(embeddedViewParams1)];
4139 [flutterPlatformViewsController
4143 UIView* childClippingView1 = view1.superview.superview;
4145 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4146 withParams:std::move(embeddedViewParams2)];
4147 [flutterPlatformViewsController
4151 UIView* childClippingView2 = view2.superview.superview;
4152 UIView* maskView1 = childClippingView1.maskView;
4153 UIView* maskView2 = childClippingView2.maskView;
4154 XCTAssertNotEqual(maskView1, maskView2);
4157 - (void)testMaskViewUsesCAShapeLayerAsTheBackingLayer {
4158 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4160 flutter::TaskRunners runners(
self.name.UTF8String,
4161 GetDefaultTaskRunner(),
4162 GetDefaultTaskRunner(),
4163 GetDefaultTaskRunner(),
4164 GetDefaultTaskRunner());
4167 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
4168 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4170 mock_delegate.settings_.enable_impeller
4173 flutterPlatformViewsController,
4176 std::make_shared<fml::SyncSwitch>());
4180 [flutterPlatformViewsController
4182 withId:@"MockFlutterPlatformView"
4187 [flutterPlatformViewsController
4191 @"viewType" : @"MockFlutterPlatformView"
4196 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4197 flutterPlatformViewsController.
flutterView = flutterView;
4199 flutter::MutatorsStack stack1;
4201 SkMatrix screenScaleMatrix =
4202 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
4203 stack1.PushTransform(screenScaleMatrix);
4205 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
4206 stack1.PushClipRect(rect);
4208 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4209 screenScaleMatrix, SkSize::Make(10, 10), stack1);
4211 flutter::MutatorsStack stack2;
4212 stack2.PushClipRect(rect);
4213 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4214 screenScaleMatrix, SkSize::Make(10, 10), stack2);
4216 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4217 withParams:std::move(embeddedViewParams1)];
4218 [flutterPlatformViewsController
4224 UIView* maskView = childClippingView.maskView;
4225 XCTAssert([maskView.layer isKindOfClass:[CAShapeLayer
class]],
4226 @"Mask view must use CAShapeLayer as its backing layer.");
4234 - (BOOL)validateOneVisualEffectView:(UIView*)visualEffectView
4235 expectedFrame:(CGRect)frame
4236 inputRadius:(CGFloat)inputRadius {
4237 XCTAssertTrue(CGRectEqualToRect(visualEffectView.frame, frame));
4238 for (UIView* view in visualEffectView.subviews) {
4239 if (![NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
4242 XCTAssertEqual(view.layer.filters.count, 1u);
4243 NSObject* filter = view.layer.filters.firstObject;
4245 XCTAssertEqualObjects([filter valueForKey:
@"name"],
@"gaussianBlur");
4247 NSObject* inputRadiusInFilter = [filter valueForKey:@"inputRadius"];
4248 XCTAssertTrue([inputRadiusInFilter isKindOfClass:[NSNumber
class]] &&
4249 flutter::BlurRadiusEqualToBlurRadius(((NSNumber*)inputRadiusInFilter).floatValue,
4256 - (void)testDisposingViewInCompositionOrderDoNotCrash {
4257 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4259 flutter::TaskRunners runners(
self.name.UTF8String,
4260 GetDefaultTaskRunner(),
4261 GetDefaultTaskRunner(),
4262 GetDefaultTaskRunner(),
4263 GetDefaultTaskRunner());
4266 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
4267 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4269 mock_delegate.settings_.enable_impeller
4272 flutterPlatformViewsController,
4275 std::make_shared<fml::SyncSwitch>());
4277 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4278 flutterPlatformViewsController.
flutterView = flutterView;
4282 [flutterPlatformViewsController
4284 withId:@"MockFlutterPlatformView"
4289 [flutterPlatformViewsController
4293 @"viewType" : @"MockFlutterPlatformView"
4296 [flutterPlatformViewsController
4300 @"viewType" : @"MockFlutterPlatformView"
4307 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
4308 flutter::MutatorsStack stack;
4309 SkMatrix finalMatrix;
4310 auto embeddedViewParams0 =
4311 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
4312 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4313 withParams:std::move(embeddedViewParams0)];
4315 auto embeddedViewParams1 =
4316 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
4317 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4318 withParams:std::move(embeddedViewParams1)];
4322 XCTestExpectation* expectation = [
self expectationWithDescription:@"dispose call ended."];
4324 [expectation fulfill];
4327 [flutterPlatformViewsController
4330 [
self waitForExpectationsWithTimeout:30 handler:nil];
4332 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
4333 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
4334 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4335 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4336 std::move(mock_sk_surface), framebuffer_info,
4337 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4338 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4339 SkISize::Make(800, 600));
4340 XCTAssertTrue([flutterPlatformViewsController
4341 submitFrame:std::move(mock_surface)
4342 withIosContext:std::make_shared<flutter::IOSContextNoop>()
4347 XCTAssertNotNil([flutterPlatformViewsController platformViewForId:0]);
4348 XCTAssertNotNil([flutterPlatformViewsController platformViewForId:1]);
4354 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
4355 flutter::MutatorsStack stack;
4356 SkMatrix finalMatrix;
4357 auto embeddedViewParams1 =
4358 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
4359 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4360 withParams:std::move(embeddedViewParams1)];
4362 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
4363 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
4364 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4365 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4366 std::move(mock_sk_surface), framebuffer_info,
4367 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4368 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4369 SkISize::Make(800, 600));
4370 XCTAssertTrue([flutterPlatformViewsController
4371 submitFrame:std::move(mock_surface)
4372 withIosContext:std::make_shared<flutter::IOSContextNoop>()
4377 XCTAssertNil([flutterPlatformViewsController platformViewForId:0]);
4378 XCTAssertNotNil([flutterPlatformViewsController platformViewForId:1]);
4381 - (void)testOnlyPlatformViewsAreRemovedWhenReset {
4382 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4384 flutter::TaskRunners runners(
self.name.UTF8String,
4385 GetDefaultTaskRunner(),
4386 GetDefaultTaskRunner(),
4387 GetDefaultTaskRunner(),
4388 GetDefaultTaskRunner());
4391 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
4392 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4394 mock_delegate.settings_.enable_impeller
4397 flutterPlatformViewsController,
4400 std::make_shared<fml::SyncSwitch>());
4404 [flutterPlatformViewsController
4406 withId:@"MockFlutterPlatformView"
4410 [flutterPlatformViewsController
4414 @"viewType" : @"MockFlutterPlatformView"
4417 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4418 flutterPlatformViewsController.
flutterView = flutterView;
4420 flutter::MutatorsStack stack;
4422 SkMatrix screenScaleMatrix =
4423 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
4424 stack.PushTransform(screenScaleMatrix);
4426 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
4427 stack.PushTransform(translateMatrix);
4428 SkMatrix finalMatrix;
4429 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
4431 auto embeddedViewParams =
4432 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
4434 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4435 withParams:std::move(embeddedViewParams)];
4438 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
4439 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
4440 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4441 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4442 std::move(mock_sk_surface), framebuffer_info,
4443 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4444 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4445 SkISize::Make(800, 600));
4446 [flutterPlatformViewsController submitFrame:std::move(mock_surface)
4447 withIosContext:std::make_shared<flutter::IOSContextNoop>()
4450 UIView* someView = [[UIView alloc] init];
4451 [flutterView addSubview:someView];
4453 [flutterPlatformViewsController
reset];
4454 XCTAssertEqual(flutterView.subviews.count, 1u);
4455 XCTAssertEqual(flutterView.subviews.firstObject, someView);
4458 - (void)testNilPlatformViewDoesntCrash {
4459 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4461 flutter::TaskRunners runners(
self.name.UTF8String,
4462 GetDefaultTaskRunner(),
4463 GetDefaultTaskRunner(),
4464 GetDefaultTaskRunner(),
4465 GetDefaultTaskRunner());
4468 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
4469 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4471 mock_delegate.settings_.enable_impeller
4474 flutterPlatformViewsController,
4477 std::make_shared<fml::SyncSwitch>());
4481 [flutterPlatformViewsController
4483 withId:@"MockFlutterPlatformView"
4487 [flutterPlatformViewsController
4491 @"viewType" : @"MockFlutterPlatformView"
4494 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4495 flutterPlatformViewsController.
flutterView = flutterView;
4498 flutter::MutatorsStack stack;
4500 SkMatrix screenScaleMatrix =
4501 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
4502 stack.PushTransform(screenScaleMatrix);
4504 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
4505 stack.PushTransform(translateMatrix);
4506 SkMatrix finalMatrix;
4507 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
4509 auto embeddedViewParams =
4510 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
4512 [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4513 withParams:std::move(embeddedViewParams)];
4516 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
4517 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
4518 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4519 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4520 std::move(mock_sk_surface), framebuffer_info,
4521 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4522 [](
const flutter::SurfaceFrame& surface_frame) {
return true; },
4523 SkISize::Make(800, 600));
4524 [flutterPlatformViewsController submitFrame:std::move(mock_surface)
4525 withIosContext:std::make_shared<flutter::IOSContextNoop>()
4528 XCTAssertEqual(flutterView.subviews.count, 1u);
4531 - (void)testFlutterTouchInterceptingViewLinksToAccessibilityContainer {
4533 NSObject* container = [[NSObject alloc] init];
4534 [touchInteceptorView setFlutterAccessibilityContainer:container];
4535 XCTAssertEqualObjects([touchInteceptorView accessibilityContainer], container);
4538 - (void)testLayerPool {
4542 XCTAssertTrue(
engine.platformView !=
nullptr);
4543 auto ios_context =
engine.platformView->GetIosContext();
4544 auto gr_context = ios_context->GetMainContext();
4549 pool.
CreateLayer(gr_context.get(), ios_context, MTLPixelFormatBGRA8Unorm);
4550 XCTAssertEqual(pool.size(), 1u);
4551 pool.CreateLayer(gr_context.get(), ios_context, MTLPixelFormatBGRA8Unorm);
4552 XCTAssertEqual(pool.size(), 2u);
4555 pool.RecycleLayers();
4556 XCTAssertEqual(pool.size(), 2u);
4559 auto unused_layers = pool.RemoveUnusedLayers();
4560 XCTAssertEqual(unused_layers.size(), 2u);
4561 XCTAssertEqual(pool.size(), 1u);
4564 - (void)testFlutterPlatformViewControllerSubmitFramePreservingFrameDamage {
4565 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4567 flutter::TaskRunners runners(
self.name.UTF8String,
4568 GetDefaultTaskRunner(),
4569 GetDefaultTaskRunner(),
4570 GetDefaultTaskRunner(),
4571 GetDefaultTaskRunner());
4574 flutterPlatformViewsController.
taskRunner = GetDefaultTaskRunner();
4575 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4577 mock_delegate.settings_.enable_impeller
4580 flutterPlatformViewsController,
4583 std::make_shared<fml::SyncSwitch>());
4585 UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4586 flutterPlatformViewsController.
flutterView = flutterView;
4590 [flutterPlatformViewsController
4592 withId:@"MockFlutterPlatformView"
4596 [flutterPlatformViewsController
4600 @"viewType" : @"MockFlutterPlatformView"
4605 [flutterPlatformViewsController
4609 @"viewType" : @"MockFlutterPlatformView"
4613 [flutterPlatformViewsController beginFrameWithSize:SkISize::Make(300, 300)];
4614 flutter::MutatorsStack stack;
4615 SkMatrix finalMatrix;
4616 auto embeddedViewParams1 =
4617 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
4618 [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4619 withParams:std::move(embeddedViewParams1)];
4621 auto embeddedViewParams2 =
4622 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
4623 [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4624 withParams:std::move(embeddedViewParams2)];
4627 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
4628 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
4629 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4630 std::optional<flutter::SurfaceFrame::SubmitInfo> submit_info;
4631 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4632 std::move(mock_sk_surface), framebuffer_info,
4633 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
4634 [&](
const flutter::SurfaceFrame& surface_frame) {
4635 submit_info = surface_frame.submit_info();
4638 SkISize::Make(800, 600));
4639 mock_surface->set_submit_info({
4640 .frame_damage = SkIRect::MakeWH(800, 600),
4641 .buffer_damage = SkIRect::MakeWH(400, 600),
4644 [flutterPlatformViewsController submitFrame:std::move(mock_surface)
4645 withIosContext:std::make_shared<flutter::IOSContextNoop>()
4648 XCTAssertTrue(submit_info.has_value());
4649 XCTAssertEqual(*submit_info->frame_damage, SkIRect::MakeWH(800, 600));
4650 XCTAssertEqual(*submit_info->buffer_damage, SkIRect::MakeWH(400, 600));