5 #import <OCMock/OCMock.h>
6 #import <UIKit/UIKit.h>
7 #import <XCTest/XCTest.h>
28 - (instancetype)init {
43 @property(nonatomic, strong) UIView* view;
44 @property(nonatomic, assign) BOOL viewCreated;
49 - (instancetype)init {
50 if (
self = [super init]) {
58 [
self checkViewCreatedOnce];
62 - (void)checkViewCreatedOnce {
66 self.viewCreated = YES;
72 : NSObject <FlutterPlatformViewFactory>
77 viewIdentifier:(int64_t)viewId
78 arguments:(
id _Nullable)args {
86 class FlutterPlatformViewsTestMockPlatformViewDelegate :
public PlatformView::Delegate {
88 void OnPlatformViewCreated(std::unique_ptr<Surface> surface)
override {}
89 void OnPlatformViewDestroyed()
override {}
90 void OnPlatformViewScheduleFrame()
override {}
91 void OnPlatformViewSetNextFrameCallback(
const fml::closure& closure)
override {}
92 void OnPlatformViewSetViewportMetrics(int64_t view_id,
const ViewportMetrics& metrics)
override {}
93 const flutter::Settings& OnPlatformViewGetSettings()
const override {
return settings_; }
94 void OnPlatformViewDispatchPlatformMessage(std::unique_ptr<PlatformMessage> message)
override {}
95 void OnPlatformViewDispatchPointerDataPacket(std::unique_ptr<PointerDataPacket> packet)
override {
97 void OnPlatformViewDispatchSemanticsAction(int32_t
id,
98 SemanticsAction action,
99 fml::MallocMapping args)
override {}
100 void OnPlatformViewSetSemanticsEnabled(
bool enabled)
override {}
101 void OnPlatformViewSetAccessibilityFeatures(int32_t flags)
override {}
102 void OnPlatformViewRegisterTexture(std::shared_ptr<Texture> texture)
override {}
103 void OnPlatformViewUnregisterTexture(int64_t
texture_id)
override {}
104 void OnPlatformViewMarkTextureFrameAvailable(int64_t
texture_id)
override {}
106 void LoadDartDeferredLibrary(intptr_t loading_unit_id,
107 std::unique_ptr<const fml::Mapping> snapshot_data,
108 std::unique_ptr<const fml::Mapping> snapshot_instructions)
override {
110 void LoadDartDeferredLibraryError(intptr_t loading_unit_id,
111 const std::string error_message,
112 bool transient)
override {}
113 void UpdateAssetResolverByType(std::unique_ptr<flutter::AssetResolver> updated_asset_resolver,
114 flutter::AssetResolver::AssetResolverType type)
override {}
123 fml::RefPtr<fml::TaskRunner>
CreateNewThread(
const std::string& name) {
124 auto thread = std::make_unique<fml::Thread>(name);
125 auto runner = thread->GetTaskRunner();
135 - (void)testFlutterViewOnlyCreateOnceInOneFrame {
136 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
138 flutter::TaskRunners runners(
self.name.UTF8String,
143 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
144 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
146 mock_delegate.settings_.enable_impeller
149 flutterPlatformViewsController,
152 std::make_shared<fml::SyncSwitch>());
156 flutterPlatformViewsController->RegisterViewFactory(
157 factory,
@"MockFlutterPlatformView",
161 flutterPlatformViewsController->OnMethodCall(
163 methodCallWithMethodName:
@"create"
164 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
166 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
167 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
169 flutter::MutatorsStack stack;
171 SkMatrix screenScaleMatrix =
172 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
173 stack.PushTransform(screenScaleMatrix);
175 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
176 stack.PushTransform(translateMatrix);
177 SkMatrix finalMatrix;
178 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
180 auto embeddedViewParams =
181 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
183 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
184 flutterPlatformViewsController->CompositeEmbeddedView(2);
186 flutterPlatformViewsController->GetPlatformViewRect(2);
190 flutterPlatformViewsController->Reset();
193 - (void)testCanCreatePlatformViewWithoutFlutterView {
194 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
196 flutter::TaskRunners runners(
self.name.UTF8String,
201 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
202 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
204 mock_delegate.settings_.enable_impeller
207 flutterPlatformViewsController,
210 std::make_shared<fml::SyncSwitch>());
214 flutterPlatformViewsController->RegisterViewFactory(
215 factory,
@"MockFlutterPlatformView",
219 flutterPlatformViewsController->OnMethodCall(
221 methodCallWithMethodName:
@"create"
222 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
228 - (void)testChildClippingViewHitTests {
231 UIView* childView = [[UIView alloc] initWithFrame:CGRectMake(100, 100, 100, 100)];
232 [childClippingView addSubview:childView];
234 XCTAssertFalse([childClippingView pointInside:CGPointMake(50, 50) withEvent:nil]);
235 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 100) withEvent:nil]);
236 XCTAssertFalse([childClippingView pointInside:CGPointMake(100, 99) withEvent:nil]);
237 XCTAssertFalse([childClippingView pointInside:CGPointMake(201, 200) withEvent:nil]);
238 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 201) withEvent:nil]);
239 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 200) withEvent:nil]);
240 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 299) withEvent:nil]);
242 XCTAssertTrue([childClippingView pointInside:CGPointMake(150, 150) withEvent:nil]);
243 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 100) withEvent:nil]);
244 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 100) withEvent:nil]);
245 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 199) withEvent:nil]);
246 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 199) withEvent:nil]);
249 - (void)testApplyBackdropFilter {
250 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
252 flutter::TaskRunners runners(
self.name.UTF8String,
257 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
258 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
260 mock_delegate.settings_.enable_impeller
263 flutterPlatformViewsController,
266 std::make_shared<fml::SyncSwitch>());
270 flutterPlatformViewsController->RegisterViewFactory(
271 factory,
@"MockFlutterPlatformView",
275 flutterPlatformViewsController->OnMethodCall(
277 methodCallWithMethodName:
@"create"
278 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
283 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
284 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
286 flutter::MutatorsStack stack;
288 CGFloat screenScale = [UIScreen mainScreen].scale;
289 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
290 stack.PushTransform(screenScaleMatrix);
292 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
293 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
295 auto embeddedViewParams =
296 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
298 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
299 flutterPlatformViewsController->CompositeEmbeddedView(2);
302 [mockFlutterView addSubview:childClippingView];
304 [mockFlutterView setNeedsLayout];
305 [mockFlutterView layoutIfNeeded];
308 NSUInteger numberOfExpectedVisualEffectView = 0;
309 for (UIView* subview in childClippingView.subviews) {
310 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
313 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
314 if ([
self validateOneVisualEffectView:subview
315 expectedFrame:CGRectMake(0, 0, 10, 10)
317 numberOfExpectedVisualEffectView++;
320 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
323 - (void)testApplyBackdropFilterWithCorrectFrame {
324 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
326 flutter::TaskRunners runners(
self.name.UTF8String,
331 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
332 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
334 mock_delegate.settings_.enable_impeller
337 flutterPlatformViewsController,
340 std::make_shared<fml::SyncSwitch>());
344 flutterPlatformViewsController->RegisterViewFactory(
345 factory,
@"MockFlutterPlatformView",
349 flutterPlatformViewsController->OnMethodCall(
351 methodCallWithMethodName:
@"create"
352 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
357 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
358 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
360 flutter::MutatorsStack stack;
362 CGFloat screenScale = [UIScreen mainScreen].scale;
363 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
364 stack.PushTransform(screenScaleMatrix);
366 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
367 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 8, screenScale * 8));
369 auto embeddedViewParams =
370 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(5, 10), stack);
372 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
373 flutterPlatformViewsController->CompositeEmbeddedView(2);
376 [mockFlutterView addSubview:childClippingView];
378 [mockFlutterView setNeedsLayout];
379 [mockFlutterView layoutIfNeeded];
382 NSUInteger numberOfExpectedVisualEffectView = 0;
383 for (UIView* subview in childClippingView.subviews) {
384 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
387 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
388 if ([
self validateOneVisualEffectView:subview
389 expectedFrame:CGRectMake(0, 0, 5, 8)
391 numberOfExpectedVisualEffectView++;
394 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
397 - (void)testApplyMultipleBackdropFilters {
398 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
400 flutter::TaskRunners runners(
self.name.UTF8String,
405 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
406 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
408 mock_delegate.settings_.enable_impeller
411 flutterPlatformViewsController,
414 std::make_shared<fml::SyncSwitch>());
418 flutterPlatformViewsController->RegisterViewFactory(
419 factory,
@"MockFlutterPlatformView",
423 flutterPlatformViewsController->OnMethodCall(
425 methodCallWithMethodName:
@"create"
426 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
431 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
432 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
434 flutter::MutatorsStack stack;
436 CGFloat screenScale = [UIScreen mainScreen].scale;
437 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
438 stack.PushTransform(screenScaleMatrix);
440 for (
int i = 0; i < 50; i++) {
441 auto filter = std::make_shared<flutter::DlBlurImageFilter>(i, 2, flutter::DlTileMode::kClamp);
442 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
445 auto embeddedViewParams =
446 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(20, 20), stack);
448 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
449 flutterPlatformViewsController->CompositeEmbeddedView(2);
452 [mockFlutterView addSubview:childClippingView];
454 [mockFlutterView setNeedsLayout];
455 [mockFlutterView layoutIfNeeded];
457 NSUInteger numberOfExpectedVisualEffectView = 0;
458 for (UIView* subview in childClippingView.subviews) {
459 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
462 XCTAssertLessThan(numberOfExpectedVisualEffectView, 50u);
463 if ([
self validateOneVisualEffectView:subview
464 expectedFrame:CGRectMake(0, 0, 10, 10)
465 inputRadius:(CGFloat)numberOfExpectedVisualEffectView]) {
466 numberOfExpectedVisualEffectView++;
469 XCTAssertEqual(numberOfExpectedVisualEffectView, (NSUInteger)numberOfExpectedVisualEffectView);
472 - (void)testAddBackdropFilters {
473 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
475 flutter::TaskRunners runners(
self.name.UTF8String,
480 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
481 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
483 mock_delegate.settings_.enable_impeller
486 flutterPlatformViewsController,
489 std::make_shared<fml::SyncSwitch>());
493 flutterPlatformViewsController->RegisterViewFactory(
494 factory,
@"MockFlutterPlatformView",
498 flutterPlatformViewsController->OnMethodCall(
500 methodCallWithMethodName:
@"create"
501 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
506 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
507 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
509 flutter::MutatorsStack stack;
511 CGFloat screenScale = [UIScreen mainScreen].scale;
512 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
513 stack.PushTransform(screenScaleMatrix);
515 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
516 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
518 auto embeddedViewParams =
519 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
521 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
522 flutterPlatformViewsController->CompositeEmbeddedView(2);
525 [mockFlutterView addSubview:childClippingView];
527 [mockFlutterView setNeedsLayout];
528 [mockFlutterView layoutIfNeeded];
530 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
531 for (UIView* subview in childClippingView.subviews) {
532 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
535 XCTAssertLessThan(originalVisualEffectViews.count, 1u);
536 if ([
self validateOneVisualEffectView:subview
537 expectedFrame:CGRectMake(0, 0, 10, 10)
538 inputRadius:(CGFloat)5]) {
539 [originalVisualEffectViews addObject:subview];
542 XCTAssertEqual(originalVisualEffectViews.count, 1u);
547 flutter::MutatorsStack stack2;
549 stack2.PushTransform(screenScaleMatrix);
551 for (
int i = 0; i < 2; i++) {
552 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
555 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
556 SkSize::Make(10, 10), stack2);
558 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
559 flutterPlatformViewsController->CompositeEmbeddedView(2);
560 [mockFlutterView setNeedsLayout];
561 [mockFlutterView layoutIfNeeded];
563 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
564 for (UIView* subview in childClippingView.subviews) {
565 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
568 XCTAssertLessThan(newVisualEffectViews.count, 2u);
570 if ([
self validateOneVisualEffectView:subview
571 expectedFrame:CGRectMake(0, 0, 10, 10)
572 inputRadius:(CGFloat)5]) {
573 [newVisualEffectViews addObject:subview];
576 XCTAssertEqual(newVisualEffectViews.count, 2u);
577 for (NSUInteger i = 0; i < originalVisualEffectViews.count; i++) {
578 UIView* originalView = originalVisualEffectViews[i];
579 UIView* newView = newVisualEffectViews[i];
581 XCTAssertEqual(originalView, newView);
582 id mockOrignalView = OCMPartialMock(originalView);
583 OCMReject([mockOrignalView removeFromSuperview]);
587 - (void)testRemoveBackdropFilters {
588 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
590 flutter::TaskRunners runners(
self.name.UTF8String,
595 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
596 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
598 mock_delegate.settings_.enable_impeller
601 flutterPlatformViewsController,
604 std::make_shared<fml::SyncSwitch>());
608 flutterPlatformViewsController->RegisterViewFactory(
609 factory,
@"MockFlutterPlatformView",
613 flutterPlatformViewsController->OnMethodCall(
615 methodCallWithMethodName:
@"create"
616 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
621 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
622 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
624 flutter::MutatorsStack stack;
626 CGFloat screenScale = [UIScreen mainScreen].scale;
627 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
628 stack.PushTransform(screenScaleMatrix);
630 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
631 for (
int i = 0; i < 5; i++) {
632 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
635 auto embeddedViewParams =
636 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
638 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
639 flutterPlatformViewsController->CompositeEmbeddedView(2);
642 [mockFlutterView addSubview:childClippingView];
644 [mockFlutterView setNeedsLayout];
645 [mockFlutterView layoutIfNeeded];
647 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
648 for (UIView* subview in childClippingView.subviews) {
649 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
652 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
653 if ([
self validateOneVisualEffectView:subview
654 expectedFrame:CGRectMake(0, 0, 10, 10)
655 inputRadius:(CGFloat)5]) {
656 [originalVisualEffectViews addObject:subview];
662 flutter::MutatorsStack stack2;
664 stack2.PushTransform(screenScaleMatrix);
666 for (
int i = 0; i < 4; i++) {
667 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
670 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
671 SkSize::Make(10, 10), stack2);
673 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
674 flutterPlatformViewsController->CompositeEmbeddedView(2);
675 [mockFlutterView setNeedsLayout];
676 [mockFlutterView layoutIfNeeded];
678 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
679 for (UIView* subview in childClippingView.subviews) {
680 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
683 XCTAssertLessThan(newVisualEffectViews.count, 4u);
684 if ([
self validateOneVisualEffectView:subview
685 expectedFrame:CGRectMake(0, 0, 10, 10)
686 inputRadius:(CGFloat)5]) {
687 [newVisualEffectViews addObject:subview];
690 XCTAssertEqual(newVisualEffectViews.count, 4u);
692 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
693 UIView* newView = newVisualEffectViews[i];
694 id mockNewView = OCMPartialMock(newView);
695 UIView* originalView = originalVisualEffectViews[i];
697 XCTAssertEqual(originalView, newView);
698 OCMReject([mockNewView removeFromSuperview]);
699 [mockNewView stopMocking];
704 for (
int i = 0; i < 5; i++) {
709 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
710 SkSize::Make(10, 10), stack2);
712 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
713 flutterPlatformViewsController->CompositeEmbeddedView(2);
714 [mockFlutterView setNeedsLayout];
715 [mockFlutterView layoutIfNeeded];
717 NSUInteger numberOfExpectedVisualEffectView = 0u;
718 for (UIView* subview in childClippingView.subviews) {
719 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
720 numberOfExpectedVisualEffectView++;
723 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
726 - (void)testEditBackdropFilters {
727 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
729 flutter::TaskRunners runners(
self.name.UTF8String,
734 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
735 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
737 mock_delegate.settings_.enable_impeller
740 flutterPlatformViewsController,
743 std::make_shared<fml::SyncSwitch>());
747 flutterPlatformViewsController->RegisterViewFactory(
748 factory,
@"MockFlutterPlatformView",
752 flutterPlatformViewsController->OnMethodCall(
754 methodCallWithMethodName:
@"create"
755 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
760 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
761 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
763 flutter::MutatorsStack stack;
765 CGFloat screenScale = [UIScreen mainScreen].scale;
766 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
767 stack.PushTransform(screenScaleMatrix);
769 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
770 for (
int i = 0; i < 5; i++) {
771 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
774 auto embeddedViewParams =
775 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
777 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
778 flutterPlatformViewsController->CompositeEmbeddedView(2);
781 [mockFlutterView addSubview:childClippingView];
783 [mockFlutterView setNeedsLayout];
784 [mockFlutterView layoutIfNeeded];
786 NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
787 for (UIView* subview in childClippingView.subviews) {
788 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
791 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
792 if ([
self validateOneVisualEffectView:subview
793 expectedFrame:CGRectMake(0, 0, 10, 10)
794 inputRadius:(CGFloat)5]) {
795 [originalVisualEffectViews addObject:subview];
801 flutter::MutatorsStack stack2;
803 stack2.PushTransform(screenScaleMatrix);
805 for (
int i = 0; i < 5; i++) {
808 std::make_shared<flutter::DlBlurImageFilter>(2, 5, flutter::DlTileMode::kClamp);
810 stack2.PushBackdropFilter(filter2,
811 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
815 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
818 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
819 SkSize::Make(10, 10), stack2);
821 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
822 flutterPlatformViewsController->CompositeEmbeddedView(2);
823 [mockFlutterView setNeedsLayout];
824 [mockFlutterView layoutIfNeeded];
826 NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
827 for (UIView* subview in childClippingView.subviews) {
828 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
831 XCTAssertLessThan(newVisualEffectViews.count, 5u);
832 CGFloat expectInputRadius = 5;
833 if (newVisualEffectViews.count == 3) {
834 expectInputRadius = 2;
836 if ([
self validateOneVisualEffectView:subview
837 expectedFrame:CGRectMake(0, 0, 10, 10)
838 inputRadius:(CGFloat)expectInputRadius]) {
839 [newVisualEffectViews addObject:subview];
842 XCTAssertEqual(newVisualEffectViews.count, 5u);
843 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
844 UIView* newView = newVisualEffectViews[i];
845 id mockNewView = OCMPartialMock(newView);
846 UIView* originalView = originalVisualEffectViews[i];
848 XCTAssertEqual(originalView, newView);
849 OCMReject([mockNewView removeFromSuperview]);
850 [mockNewView stopMocking];
852 [newVisualEffectViews removeAllObjects];
856 for (
int i = 0; i < 5; i++) {
860 for (
int i = 0; i < 5; i++) {
863 std::make_shared<flutter::DlBlurImageFilter>(2, 5, flutter::DlTileMode::kClamp);
864 stack2.PushBackdropFilter(filter2,
865 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
869 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
872 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
873 SkSize::Make(10, 10), stack2);
875 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
876 flutterPlatformViewsController->CompositeEmbeddedView(2);
877 [mockFlutterView setNeedsLayout];
878 [mockFlutterView layoutIfNeeded];
880 for (UIView* subview in childClippingView.subviews) {
881 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
884 XCTAssertLessThan(newVisualEffectViews.count, 5u);
885 CGFloat expectInputRadius = 5;
886 if (newVisualEffectViews.count == 0) {
887 expectInputRadius = 2;
889 if ([
self validateOneVisualEffectView:subview
890 expectedFrame:CGRectMake(0, 0, 10, 10)
891 inputRadius:(CGFloat)expectInputRadius]) {
892 [newVisualEffectViews addObject:subview];
895 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
896 UIView* newView = newVisualEffectViews[i];
897 id mockNewView = OCMPartialMock(newView);
898 UIView* originalView = originalVisualEffectViews[i];
900 XCTAssertEqual(originalView, newView);
901 OCMReject([mockNewView removeFromSuperview]);
902 [mockNewView stopMocking];
904 [newVisualEffectViews removeAllObjects];
908 for (
int i = 0; i < 5; i++) {
912 for (
int i = 0; i < 5; i++) {
915 std::make_shared<flutter::DlBlurImageFilter>(2, 5, flutter::DlTileMode::kClamp);
916 stack2.PushBackdropFilter(filter2,
917 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
921 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
924 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
925 SkSize::Make(10, 10), stack2);
927 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
928 flutterPlatformViewsController->CompositeEmbeddedView(2);
929 [mockFlutterView setNeedsLayout];
930 [mockFlutterView layoutIfNeeded];
932 for (UIView* subview in childClippingView.subviews) {
933 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
936 XCTAssertLessThan(newVisualEffectViews.count, 5u);
937 CGFloat expectInputRadius = 5;
938 if (newVisualEffectViews.count == 4) {
939 expectInputRadius = 2;
941 if ([
self validateOneVisualEffectView:subview
942 expectedFrame:CGRectMake(0, 0, 10, 10)
943 inputRadius:(CGFloat)expectInputRadius]) {
944 [newVisualEffectViews addObject:subview];
947 XCTAssertEqual(newVisualEffectViews.count, 5u);
949 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
950 UIView* newView = newVisualEffectViews[i];
951 id mockNewView = OCMPartialMock(newView);
952 UIView* originalView = originalVisualEffectViews[i];
954 XCTAssertEqual(originalView, newView);
955 OCMReject([mockNewView removeFromSuperview]);
956 [mockNewView stopMocking];
958 [newVisualEffectViews removeAllObjects];
962 for (
int i = 0; i < 5; i++) {
966 for (
int i = 0; i < 5; i++) {
967 auto filter2 = std::make_shared<flutter::DlBlurImageFilter>(i, 2, flutter::DlTileMode::kClamp);
969 stack2.PushBackdropFilter(filter2, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
972 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
973 SkSize::Make(10, 10), stack2);
975 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
976 flutterPlatformViewsController->CompositeEmbeddedView(2);
977 [mockFlutterView setNeedsLayout];
978 [mockFlutterView layoutIfNeeded];
980 for (UIView* subview in childClippingView.subviews) {
981 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
984 XCTAssertLessThan(newVisualEffectViews.count, 5u);
985 if ([
self validateOneVisualEffectView:subview
986 expectedFrame:CGRectMake(0, 0, 10, 10)
987 inputRadius:(CGFloat)newVisualEffectViews.count]) {
988 [newVisualEffectViews addObject:subview];
991 XCTAssertEqual(newVisualEffectViews.count, 5u);
993 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
994 UIView* newView = newVisualEffectViews[i];
995 id mockNewView = OCMPartialMock(newView);
996 UIView* originalView = originalVisualEffectViews[i];
998 XCTAssertEqual(originalView, newView);
999 OCMReject([mockNewView removeFromSuperview]);
1000 [mockNewView stopMocking];
1002 [newVisualEffectViews removeAllObjects];
1005 - (void)testApplyBackdropFilterNotDlBlurImageFilter {
1006 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1007 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1008 flutter::TaskRunners runners(
self.name.UTF8String,
1012 thread_task_runner);
1013 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1014 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1016 mock_delegate.settings_.enable_impeller
1019 flutterPlatformViewsController,
1022 std::make_shared<fml::SyncSwitch>());
1026 flutterPlatformViewsController->RegisterViewFactory(
1027 factory,
@"MockFlutterPlatformView",
1031 flutterPlatformViewsController->OnMethodCall(
1033 methodCallWithMethodName:
@"create"
1034 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1039 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1040 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1042 flutter::MutatorsStack stack;
1044 CGFloat screenScale = [UIScreen mainScreen].scale;
1045 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
1046 stack.PushTransform(screenScaleMatrix);
1048 auto dilateFilter = std::make_shared<flutter::DlDilateImageFilter>(5, 2);
1049 stack.PushBackdropFilter(dilateFilter, SkRect::MakeEmpty());
1051 auto embeddedViewParams =
1052 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1054 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1055 flutterPlatformViewsController->CompositeEmbeddedView(2);
1059 [mockFlutterView addSubview:childClippingView];
1061 [mockFlutterView setNeedsLayout];
1062 [mockFlutterView layoutIfNeeded];
1064 NSUInteger numberOfExpectedVisualEffectView = 0;
1065 for (UIView* subview in childClippingView.subviews) {
1066 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1067 numberOfExpectedVisualEffectView++;
1070 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1074 flutter::MutatorsStack stack2;
1076 stack2.PushTransform(screenScaleMatrix);
1078 auto blurFilter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
1080 for (
int i = 0; i < 5; i++) {
1082 stack2.PushBackdropFilter(dilateFilter,
1083 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1087 stack2.PushBackdropFilter(blurFilter,
1088 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1091 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1092 SkSize::Make(10, 10), stack2);
1094 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1095 flutterPlatformViewsController->CompositeEmbeddedView(2);
1096 [mockFlutterView setNeedsLayout];
1097 [mockFlutterView layoutIfNeeded];
1099 numberOfExpectedVisualEffectView = 0;
1100 for (UIView* subview in childClippingView.subviews) {
1101 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1104 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1105 if ([
self validateOneVisualEffectView:subview
1106 expectedFrame:CGRectMake(0, 0, 10, 10)
1107 inputRadius:(CGFloat)5]) {
1108 numberOfExpectedVisualEffectView++;
1111 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1115 for (
int i = 0; i < 5; i++) {
1119 for (
int i = 0; i < 5; i++) {
1121 stack2.PushBackdropFilter(dilateFilter,
1122 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1126 stack2.PushBackdropFilter(blurFilter,
1127 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1130 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1131 SkSize::Make(10, 10), stack2);
1133 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1134 flutterPlatformViewsController->CompositeEmbeddedView(2);
1135 [mockFlutterView setNeedsLayout];
1136 [mockFlutterView layoutIfNeeded];
1138 numberOfExpectedVisualEffectView = 0;
1139 for (UIView* subview in childClippingView.subviews) {
1140 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1143 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1144 if ([
self validateOneVisualEffectView:subview
1145 expectedFrame:CGRectMake(0, 0, 10, 10)
1146 inputRadius:(CGFloat)5]) {
1147 numberOfExpectedVisualEffectView++;
1150 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1154 for (
int i = 0; i < 5; i++) {
1158 for (
int i = 0; i < 5; i++) {
1160 stack2.PushBackdropFilter(dilateFilter,
1161 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1165 stack2.PushBackdropFilter(blurFilter,
1166 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1169 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1170 SkSize::Make(10, 10), stack2);
1172 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1173 flutterPlatformViewsController->CompositeEmbeddedView(2);
1174 [mockFlutterView setNeedsLayout];
1175 [mockFlutterView layoutIfNeeded];
1177 numberOfExpectedVisualEffectView = 0;
1178 for (UIView* subview in childClippingView.subviews) {
1179 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1182 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1183 if ([
self validateOneVisualEffectView:subview
1184 expectedFrame:CGRectMake(0, 0, 10, 10)
1185 inputRadius:(CGFloat)5]) {
1186 numberOfExpectedVisualEffectView++;
1189 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1193 for (
int i = 0; i < 5; i++) {
1197 for (
int i = 0; i < 5; i++) {
1198 stack2.PushBackdropFilter(dilateFilter,
1199 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1202 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1203 SkSize::Make(10, 10), stack2);
1205 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1206 flutterPlatformViewsController->CompositeEmbeddedView(2);
1207 [mockFlutterView setNeedsLayout];
1208 [mockFlutterView layoutIfNeeded];
1210 numberOfExpectedVisualEffectView = 0;
1211 for (UIView* subview in childClippingView.subviews) {
1212 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1213 numberOfExpectedVisualEffectView++;
1216 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1219 - (void)testApplyBackdropFilterCorrectAPI {
1224 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1225 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1229 visualEffectView:visualEffectView];
1230 XCTAssertNotNil(platformViewFilter);
1233 - (void)testApplyBackdropFilterAPIChangedInvalidUIVisualEffectView {
1235 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc] init];
1239 visualEffectView:visualEffectView];
1240 XCTAssertNil(platformViewFilter);
1243 - (void)testApplyBackdropFilterAPIChangedNoGaussianBlurFilter {
1245 UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1246 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1247 NSArray* subviews = editedUIVisualEffectView.subviews;
1248 for (UIView* view in subviews) {
1249 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1250 for (CIFilter* filter in view.layer.filters) {
1251 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1252 [filter setValue:@"notGaussianBlur" forKey:@"name"];
1262 visualEffectView:editedUIVisualEffectView];
1263 XCTAssertNil(platformViewFilter);
1266 - (void)testApplyBackdropFilterAPIChangedInvalidInputRadius {
1268 UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1269 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1270 NSArray* subviews = editedUIVisualEffectView.subviews;
1271 for (UIView* view in subviews) {
1272 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1273 for (CIFilter* filter in view.layer.filters) {
1274 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1275 [filter setValue:@"invalidInputRadius" forKey:@"inputRadius"];
1286 visualEffectView:editedUIVisualEffectView];
1287 XCTAssertNil(platformViewFilter);
1290 - (void)testBackdropFilterVisualEffectSubviewBackgroundColor {
1291 UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1292 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1296 visualEffectView:visualEffectView];
1297 CGColorRef visualEffectSubviewBackgroundColor = nil;
1298 for (UIView* view in [platformViewFilter backdropFilterView].subviews) {
1299 if ([NSStringFromClass([view
class]) hasSuffix:
@"VisualEffectSubview"]) {
1300 visualEffectSubviewBackgroundColor = view.layer.backgroundColor;
1304 CGColorEqualToColor(visualEffectSubviewBackgroundColor, UIColor.clearColor.CGColor));
1307 - (void)testCompositePlatformView {
1308 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1309 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1310 flutter::TaskRunners runners(
self.name.UTF8String,
1314 thread_task_runner);
1315 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1316 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1318 mock_delegate.settings_.enable_impeller
1321 flutterPlatformViewsController,
1324 std::make_shared<fml::SyncSwitch>());
1328 flutterPlatformViewsController->RegisterViewFactory(
1329 factory,
@"MockFlutterPlatformView",
1333 flutterPlatformViewsController->OnMethodCall(
1335 methodCallWithMethodName:
@"create"
1336 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1341 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
1342 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1344 flutter::MutatorsStack stack;
1346 SkMatrix screenScaleMatrix =
1347 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1348 stack.PushTransform(screenScaleMatrix);
1350 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
1351 stack.PushTransform(translateMatrix);
1352 SkMatrix finalMatrix;
1353 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
1355 auto embeddedViewParams =
1356 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
1358 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1359 flutterPlatformViewsController->CompositeEmbeddedView(2);
1360 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1361 toView:mockFlutterView];
1362 XCTAssertTrue(CGRectEqualToRect(platformViewRectInFlutterView, CGRectMake(100, 100, 300, 300)));
1365 - (void)testBackdropFilterCorrectlyPushedAndReset {
1366 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1367 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1368 flutter::TaskRunners runners(
self.name.UTF8String,
1372 thread_task_runner);
1373 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1374 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1376 mock_delegate.settings_.enable_impeller
1379 flutterPlatformViewsController,
1382 std::make_shared<fml::SyncSwitch>());
1386 flutterPlatformViewsController->RegisterViewFactory(
1387 factory,
@"MockFlutterPlatformView",
1391 flutterPlatformViewsController->OnMethodCall(
1393 methodCallWithMethodName:
@"create"
1394 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1399 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1400 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1402 flutter::MutatorsStack stack;
1404 CGFloat screenScale = [UIScreen mainScreen].scale;
1405 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
1406 stack.PushTransform(screenScaleMatrix);
1408 auto embeddedViewParams =
1409 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1411 flutterPlatformViewsController->BeginFrame(SkISize::Make(0, 0));
1412 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1413 flutterPlatformViewsController->PushVisitedPlatformView(2);
1414 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
1415 flutterPlatformViewsController->PushFilterToVisitedPlatformViews(
1416 filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1417 flutterPlatformViewsController->CompositeEmbeddedView(2);
1420 [mockFlutterView addSubview:childClippingView];
1422 [mockFlutterView setNeedsLayout];
1423 [mockFlutterView layoutIfNeeded];
1426 NSUInteger numberOfExpectedVisualEffectView = 0;
1427 for (UIView* subview in childClippingView.subviews) {
1428 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1431 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
1432 if ([
self validateOneVisualEffectView:subview
1433 expectedFrame:CGRectMake(0, 0, 10, 10)
1435 numberOfExpectedVisualEffectView++;
1438 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
1441 auto embeddedViewParams2 =
1442 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1443 flutterPlatformViewsController->BeginFrame(SkISize::Make(0, 0));
1444 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams2));
1445 flutterPlatformViewsController->CompositeEmbeddedView(2);
1448 [mockFlutterView setNeedsLayout];
1449 [mockFlutterView layoutIfNeeded];
1451 numberOfExpectedVisualEffectView = 0;
1452 for (UIView* subview in childClippingView.subviews) {
1453 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1456 numberOfExpectedVisualEffectView++;
1458 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1461 - (void)testChildClippingViewShouldBeTheBoundingRectOfPlatformView {
1462 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1463 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1464 flutter::TaskRunners runners(
self.name.UTF8String,
1468 thread_task_runner);
1469 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1470 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1472 mock_delegate.settings_.enable_impeller
1475 flutterPlatformViewsController,
1478 std::make_shared<fml::SyncSwitch>());
1482 flutterPlatformViewsController->RegisterViewFactory(
1483 factory,
@"MockFlutterPlatformView",
1487 flutterPlatformViewsController->OnMethodCall(
1489 methodCallWithMethodName:
@"create"
1490 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1495 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
1496 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1498 flutter::MutatorsStack stack;
1500 SkMatrix screenScaleMatrix =
1501 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1502 stack.PushTransform(screenScaleMatrix);
1504 SkMatrix rotateMatrix;
1505 rotateMatrix.setRotate(10);
1506 stack.PushTransform(rotateMatrix);
1507 SkMatrix finalMatrix;
1508 finalMatrix.setConcat(screenScaleMatrix, rotateMatrix);
1510 auto embeddedViewParams =
1511 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
1513 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1514 flutterPlatformViewsController->CompositeEmbeddedView(2);
1515 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1516 toView:mockFlutterView];
1522 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.x - childClippingView.frame.origin.x),
1524 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.y - childClippingView.frame.origin.y),
1527 fabs(platformViewRectInFlutterView.size.width - childClippingView.frame.size.width),
1530 fabs(platformViewRectInFlutterView.size.height - childClippingView.frame.size.height),
1534 - (void)testClipsDoNotInterceptWithPlatformViewShouldNotAddMaskView {
1535 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1536 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1537 flutter::TaskRunners runners(
self.name.UTF8String,
1541 thread_task_runner);
1542 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1543 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1545 mock_delegate.settings_.enable_impeller
1548 flutterPlatformViewsController,
1551 std::make_shared<fml::SyncSwitch>());
1555 flutterPlatformViewsController->RegisterViewFactory(
1556 factory,
@"MockFlutterPlatformView",
1560 flutterPlatformViewsController->OnMethodCall(
1562 methodCallWithMethodName:
@"create"
1563 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1568 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
1569 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1571 flutter::MutatorsStack stack;
1573 SkMatrix screenScaleMatrix =
1574 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1575 stack.PushTransform(screenScaleMatrix);
1576 SkMatrix translateMatrix = SkMatrix::Translate(5, 5);
1578 stack.PushTransform(translateMatrix);
1580 SkRect rect = SkRect::MakeXYWH(0, 0, 25, 25);
1581 stack.PushClipRect(rect);
1584 SkRect rect_for_rrect = SkRect::MakeXYWH(-1, -1, 25, 25);
1585 SkRRect rrect = SkRRect::MakeRectXY(rect_for_rrect, 1, 1);
1586 stack.PushClipRRect(rrect);
1588 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1589 SkMatrix::Concat(screenScaleMatrix, translateMatrix), SkSize::Make(5, 5), stack);
1591 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1592 flutterPlatformViewsController->CompositeEmbeddedView(2);
1596 [mockFlutterView addSubview:childClippingView];
1598 [mockFlutterView setNeedsLayout];
1599 [mockFlutterView layoutIfNeeded];
1600 XCTAssertNil(childClippingView.maskView);
1603 - (void)testClipRRectOnlyHasCornersInterceptWithPlatformViewShouldAddMaskView {
1604 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1605 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1606 flutter::TaskRunners runners(
self.name.UTF8String,
1610 thread_task_runner);
1611 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1612 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1614 mock_delegate.settings_.enable_impeller
1617 flutterPlatformViewsController,
1620 std::make_shared<fml::SyncSwitch>());
1624 flutterPlatformViewsController->RegisterViewFactory(
1625 factory,
@"MockFlutterPlatformView",
1629 flutterPlatformViewsController->OnMethodCall(
1631 methodCallWithMethodName:
@"create"
1632 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1637 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
1638 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1640 flutter::MutatorsStack stack;
1642 SkMatrix screenScaleMatrix =
1643 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1644 stack.PushTransform(screenScaleMatrix);
1645 SkMatrix translateMatrix = SkMatrix::Translate(5, 5);
1647 stack.PushTransform(translateMatrix);
1651 SkRect rect_for_rrect = SkRect::MakeXYWH(0, 0, 10, 10);
1652 SkRRect rrect = SkRRect::MakeRectXY(rect_for_rrect, 1, 1);
1653 stack.PushClipRRect(rrect);
1655 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1656 SkMatrix::Concat(screenScaleMatrix, translateMatrix), SkSize::Make(5, 5), stack);
1658 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1659 flutterPlatformViewsController->CompositeEmbeddedView(2);
1663 [mockFlutterView addSubview:childClippingView];
1665 [mockFlutterView setNeedsLayout];
1666 [mockFlutterView layoutIfNeeded];
1668 XCTAssertNotNil(childClippingView.maskView);
1671 - (void)testClipRect {
1672 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1673 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1674 flutter::TaskRunners runners(
self.name.UTF8String,
1678 thread_task_runner);
1679 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1680 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1682 mock_delegate.settings_.enable_impeller
1685 flutterPlatformViewsController,
1688 std::make_shared<fml::SyncSwitch>());
1692 flutterPlatformViewsController->RegisterViewFactory(
1693 factory,
@"MockFlutterPlatformView",
1697 flutterPlatformViewsController->OnMethodCall(
1699 methodCallWithMethodName:
@"create"
1700 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1705 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1706 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1708 flutter::MutatorsStack stack;
1710 SkMatrix screenScaleMatrix =
1711 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1712 stack.PushTransform(screenScaleMatrix);
1714 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
1715 stack.PushClipRect(rect);
1717 auto embeddedViewParams =
1718 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1720 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1721 flutterPlatformViewsController->CompositeEmbeddedView(2);
1725 [mockFlutterView addSubview:childClippingView];
1727 [mockFlutterView setNeedsLayout];
1728 [mockFlutterView layoutIfNeeded];
1730 for (
int i = 0; i < 10; i++) {
1731 for (
int j = 0; j < 10; j++) {
1732 CGPoint point = CGPointMake(i, j);
1733 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:mockFlutterView];
1736 CGRect insideClipping = CGRectMake(3, 3, 1, 1);
1737 if (CGRectContainsPoint(insideClipping, point)) {
1738 XCTAssertEqual(alpha, 255);
1740 XCTAssertLessThan(alpha, 255);
1746 - (void)testClipRRect {
1747 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1748 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1749 flutter::TaskRunners runners(
self.name.UTF8String,
1753 thread_task_runner);
1754 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1755 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1757 mock_delegate.settings_.enable_impeller
1760 flutterPlatformViewsController,
1763 std::make_shared<fml::SyncSwitch>());
1767 flutterPlatformViewsController->RegisterViewFactory(
1768 factory,
@"MockFlutterPlatformView",
1772 flutterPlatformViewsController->OnMethodCall(
1774 methodCallWithMethodName:
@"create"
1775 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1780 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1781 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1783 flutter::MutatorsStack stack;
1785 SkMatrix screenScaleMatrix =
1786 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1787 stack.PushTransform(screenScaleMatrix);
1789 SkRRect rrect = SkRRect::MakeRectXY(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
1790 stack.PushClipRRect(rrect);
1792 auto embeddedViewParams =
1793 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1795 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1796 flutterPlatformViewsController->CompositeEmbeddedView(2);
1800 [mockFlutterView addSubview:childClippingView];
1802 [mockFlutterView setNeedsLayout];
1803 [mockFlutterView layoutIfNeeded];
1805 for (
int i = 0; i < 10; i++) {
1806 for (
int j = 0; j < 10; j++) {
1807 CGPoint point = CGPointMake(i, j);
1808 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:mockFlutterView];
1811 CGRect insideClipping = CGRectMake(3, 3, 4, 4);
1812 if (CGRectContainsPoint(insideClipping, point)) {
1813 XCTAssertEqual(alpha, 255);
1815 XCTAssertLessThan(alpha, 255);
1821 - (void)testClipPath {
1822 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1823 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1824 flutter::TaskRunners runners(
self.name.UTF8String,
1828 thread_task_runner);
1829 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1830 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1832 mock_delegate.settings_.enable_impeller
1835 flutterPlatformViewsController,
1838 std::make_shared<fml::SyncSwitch>());
1842 flutterPlatformViewsController->RegisterViewFactory(
1843 factory,
@"MockFlutterPlatformView",
1847 flutterPlatformViewsController->OnMethodCall(
1849 methodCallWithMethodName:
@"create"
1850 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1855 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1856 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1858 flutter::MutatorsStack stack;
1860 SkMatrix screenScaleMatrix =
1861 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1862 stack.PushTransform(screenScaleMatrix);
1865 path.addRoundRect(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
1866 stack.PushClipPath(path);
1868 auto embeddedViewParams =
1869 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1871 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1872 flutterPlatformViewsController->CompositeEmbeddedView(2);
1876 [mockFlutterView addSubview:childClippingView];
1878 [mockFlutterView setNeedsLayout];
1879 [mockFlutterView layoutIfNeeded];
1881 for (
int i = 0; i < 10; i++) {
1882 for (
int j = 0; j < 10; j++) {
1883 CGPoint point = CGPointMake(i, j);
1884 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:mockFlutterView];
1887 CGRect insideClipping = CGRectMake(3, 3, 4, 4);
1888 if (CGRectContainsPoint(insideClipping, point)) {
1889 XCTAssertEqual(alpha, 255);
1891 XCTAssertLessThan(alpha, 255);
1897 - (void)testSetFlutterViewControllerAfterCreateCanStillDispatchTouchEvents {
1898 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1899 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1900 flutter::TaskRunners runners(
self.name.UTF8String,
1904 thread_task_runner);
1905 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1906 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1908 mock_delegate.settings_.enable_impeller
1911 flutterPlatformViewsController,
1914 std::make_shared<fml::SyncSwitch>());
1918 flutterPlatformViewsController->RegisterViewFactory(
1919 factory,
@"MockFlutterPlatformView",
1923 flutterPlatformViewsController->OnMethodCall(
1925 methodCallWithMethodName:
@"create"
1926 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1933 while (touchInteceptorView != nil &&
1935 touchInteceptorView = touchInteceptorView.superview;
1937 XCTAssertNotNil(touchInteceptorView);
1940 UIGestureRecognizer* forwardGectureRecognizer = nil;
1941 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
1942 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
1943 forwardGectureRecognizer = gestureRecognizer;
1949 NSSet* touches1 = [[NSSet alloc] init];
1950 id event1 = OCMClassMock([UIEvent
class]);
1952 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
1953 OCMReject([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
1956 NSSet* touches2 = [[NSSet alloc] init];
1957 id event2 = OCMClassMock([UIEvent
class]);
1958 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
1959 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
1960 OCMVerify([mockFlutterViewContoller touchesBegan:touches2 withEvent:event2]);
1963 - (void)testSetFlutterViewControllerInTheMiddleOfTouchEventShouldStillAllowGesturesToBeHandled {
1964 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1965 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1966 flutter::TaskRunners runners(
self.name.UTF8String,
1970 thread_task_runner);
1971 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1972 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1974 mock_delegate.settings_.enable_impeller
1977 flutterPlatformViewsController,
1980 std::make_shared<fml::SyncSwitch>());
1984 flutterPlatformViewsController->RegisterViewFactory(
1985 factory,
@"MockFlutterPlatformView",
1989 flutterPlatformViewsController->OnMethodCall(
1991 methodCallWithMethodName:
@"create"
1992 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1999 while (touchInteceptorView != nil &&
2001 touchInteceptorView = touchInteceptorView.superview;
2003 XCTAssertNotNil(touchInteceptorView);
2006 UIGestureRecognizer* forwardGectureRecognizer = nil;
2007 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2008 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
2009 forwardGectureRecognizer = gestureRecognizer;
2016 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
2018 NSSet* touches1 = [[NSSet alloc] init];
2019 id event1 = OCMClassMock([UIEvent
class]);
2020 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2021 OCMVerify([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
2023 flutterPlatformViewsController->SetFlutterViewController(nil);
2026 NSSet* touches2 = [[NSSet alloc] init];
2027 id event2 = OCMClassMock([UIEvent
class]);
2028 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2029 OCMVerify([mockFlutterViewContoller touchesMoved:touches2 withEvent:event2]);
2031 NSSet* touches3 = [[NSSet alloc] init];
2032 id event3 = OCMClassMock([UIEvent
class]);
2033 [forwardGectureRecognizer touchesEnded:touches3 withEvent:event3];
2034 OCMVerify([mockFlutterViewContoller touchesEnded:touches3 withEvent:event3]);
2037 NSSet* touches4 = [[NSSet alloc] init];
2038 id event4 = OCMClassMock([UIEvent
class]);
2039 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2040 OCMReject([mockFlutterViewContoller touchesBegan:touches4 withEvent:event4]);
2042 NSSet* touches5 = [[NSSet alloc] init];
2043 id event5 = OCMClassMock([UIEvent
class]);
2044 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2045 OCMReject([mockFlutterViewContoller touchesEnded:touches5 withEvent:event5]);
2050 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
2052 NSSet* touches1 = [[NSSet alloc] init];
2053 id event1 = OCMClassMock([UIEvent
class]);
2054 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2055 OCMVerify([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
2057 flutterPlatformViewsController->SetFlutterViewController(nil);
2060 NSSet* touches2 = [[NSSet alloc] init];
2061 id event2 = OCMClassMock([UIEvent
class]);
2062 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2063 OCMVerify([mockFlutterViewContoller touchesMoved:touches2 withEvent:event2]);
2065 NSSet* touches3 = [[NSSet alloc] init];
2066 id event3 = OCMClassMock([UIEvent
class]);
2067 [forwardGectureRecognizer touchesCancelled:touches3 withEvent:event3];
2068 OCMVerify([mockFlutterViewContoller forceTouchesCancelled:touches3]);
2071 NSSet* touches4 = [[NSSet alloc] init];
2072 id event4 = OCMClassMock([UIEvent
class]);
2073 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2074 OCMReject([mockFlutterViewContoller touchesBegan:touches4 withEvent:event4]);
2076 NSSet* touches5 = [[NSSet alloc] init];
2077 id event5 = OCMClassMock([UIEvent
class]);
2078 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2079 OCMReject([mockFlutterViewContoller touchesEnded:touches5 withEvent:event5]);
2082 flutterPlatformViewsController->Reset();
2086 testSetFlutterViewControllerInTheMiddleOfTouchEventAllowsTheNewControllerToHandleSecondTouchSequence {
2087 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2088 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2089 flutter::TaskRunners runners(
self.name.UTF8String,
2093 thread_task_runner);
2094 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2095 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2097 mock_delegate.settings_.enable_impeller
2100 flutterPlatformViewsController,
2103 std::make_shared<fml::SyncSwitch>());
2107 flutterPlatformViewsController->RegisterViewFactory(
2108 factory,
@"MockFlutterPlatformView",
2112 flutterPlatformViewsController->OnMethodCall(
2114 methodCallWithMethodName:
@"create"
2115 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2122 while (touchInteceptorView != nil &&
2124 touchInteceptorView = touchInteceptorView.superview;
2126 XCTAssertNotNil(touchInteceptorView);
2129 UIGestureRecognizer* forwardGectureRecognizer = nil;
2130 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2131 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
2132 forwardGectureRecognizer = gestureRecognizer;
2138 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
2141 NSSet* touches1 = [NSSet setWithObject:@1];
2142 id event1 = OCMClassMock([UIEvent
class]);
2143 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2144 OCMVerify([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
2146 UIViewController* mockFlutterViewContoller2 = OCMClassMock([UIViewController
class]);
2147 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller2);
2151 NSSet* touches2 = [NSSet setWithObject:@1];
2152 id event2 = OCMClassMock([UIEvent
class]);
2153 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
2154 OCMVerify([mockFlutterViewContoller touchesBegan:touches2 withEvent:event2]);
2155 OCMReject([mockFlutterViewContoller2 touchesBegan:touches2 withEvent:event2]);
2157 NSSet* touches3 = [NSSet setWithObject:@1];
2158 id event3 = OCMClassMock([UIEvent
class]);
2159 [forwardGectureRecognizer touchesMoved:touches3 withEvent:event3];
2160 OCMVerify([mockFlutterViewContoller touchesMoved:touches3 withEvent:event3]);
2161 OCMReject([mockFlutterViewContoller2 touchesMoved:touches3 withEvent:event3]);
2163 NSSet* touches4 = [NSSet setWithObject:@1];
2164 id event4 = OCMClassMock([UIEvent
class]);
2165 [forwardGectureRecognizer touchesEnded:touches4 withEvent:event4];
2166 OCMVerify([mockFlutterViewContoller touchesEnded:touches4 withEvent:event4]);
2167 OCMReject([mockFlutterViewContoller2 touchesEnded:touches4 withEvent:event4]);
2169 NSSet* touches5 = [NSSet setWithObject:@1];
2170 id event5 = OCMClassMock([UIEvent
class]);
2171 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2172 OCMVerify([mockFlutterViewContoller touchesEnded:touches5 withEvent:event5]);
2173 OCMReject([mockFlutterViewContoller2 touchesEnded:touches5 withEvent:event5]);
2177 NSSet* touches6 = [NSSet setWithObject:@1];
2178 id event6 = OCMClassMock([UIEvent
class]);
2179 [forwardGectureRecognizer touchesBegan:touches6 withEvent:event6];
2180 OCMVerify([mockFlutterViewContoller2 touchesBegan:touches6 withEvent:event6]);
2181 OCMReject([mockFlutterViewContoller touchesBegan:touches6 withEvent:event6]);
2184 NSSet* touches7 = [NSSet setWithObject:@1];
2185 id event7 = OCMClassMock([UIEvent
class]);
2186 [forwardGectureRecognizer touchesMoved:touches7 withEvent:event7];
2187 OCMVerify([mockFlutterViewContoller2 touchesMoved:touches7 withEvent:event7]);
2188 OCMReject([mockFlutterViewContoller touchesMoved:touches7 withEvent:event7]);
2190 NSSet* touches8 = [NSSet setWithObject:@1];
2191 id event8 = OCMClassMock([UIEvent
class]);
2192 [forwardGectureRecognizer touchesEnded:touches8 withEvent:event8];
2193 OCMVerify([mockFlutterViewContoller2 touchesEnded:touches8 withEvent:event8]);
2194 OCMReject([mockFlutterViewContoller touchesEnded:touches8 withEvent:event8]);
2196 flutterPlatformViewsController->Reset();
2199 - (void)testFlutterPlatformViewTouchesCancelledEventAreForcedToBeCancelled {
2200 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2201 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2202 flutter::TaskRunners runners(
self.name.UTF8String,
2206 thread_task_runner);
2207 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2208 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2210 mock_delegate.settings_.enable_impeller
2213 flutterPlatformViewsController,
2216 std::make_shared<fml::SyncSwitch>());
2220 flutterPlatformViewsController->RegisterViewFactory(
2221 factory,
@"MockFlutterPlatformView",
2225 flutterPlatformViewsController->OnMethodCall(
2227 methodCallWithMethodName:
@"create"
2228 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2235 while (touchInteceptorView != nil &&
2237 touchInteceptorView = touchInteceptorView.superview;
2239 XCTAssertNotNil(touchInteceptorView);
2242 UIGestureRecognizer* forwardGectureRecognizer = nil;
2243 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2244 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
2245 forwardGectureRecognizer = gestureRecognizer;
2251 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
2253 NSSet* touches1 = [NSSet setWithObject:@1];
2254 id event1 = OCMClassMock([UIEvent
class]);
2255 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2257 [forwardGectureRecognizer touchesCancelled:touches1 withEvent:event1];
2258 OCMVerify([mockFlutterViewContoller forceTouchesCancelled:touches1]);
2260 flutterPlatformViewsController->Reset();
2263 - (void)testFlutterPlatformViewControllerSubmitFrameWithoutFlutterViewNotCrashing {
2264 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2265 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2266 flutter::TaskRunners runners(
self.name.UTF8String,
2270 thread_task_runner);
2271 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2272 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2274 mock_delegate.settings_.enable_impeller
2277 flutterPlatformViewsController,
2280 std::make_shared<fml::SyncSwitch>());
2284 flutterPlatformViewsController->RegisterViewFactory(
2285 factory,
@"MockFlutterPlatformView",
2289 flutterPlatformViewsController->OnMethodCall(
2291 methodCallWithMethodName:
@"create"
2292 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2298 flutter::MutatorsStack stack;
2299 SkMatrix finalMatrix;
2301 auto embeddedViewParams_1 =
2302 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2304 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams_1));
2305 flutterPlatformViewsController->CompositeEmbeddedView(2);
2306 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
2307 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
2308 nullptr, framebuffer_info,
2309 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return false; },
2310 SkISize::Make(800, 600));
2312 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2314 auto embeddedViewParams_2 =
2315 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2316 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams_2));
2317 flutterPlatformViewsController->CompositeEmbeddedView(2);
2318 auto mock_surface_submit_true = std::make_unique<flutter::SurfaceFrame>(
2319 nullptr, framebuffer_info,
2320 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2321 SkISize::Make(800, 600));
2322 XCTAssertTrue(flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr,
2323 std::move(mock_surface_submit_true)));
2327 testFlutterPlatformViewControllerResetDeallocsPlatformViewWhenRootViewsNotBindedToFlutterView {
2328 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2329 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2330 flutter::TaskRunners runners(
self.name.UTF8String,
2334 thread_task_runner);
2335 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2336 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2338 mock_delegate.settings_.enable_impeller
2341 flutterPlatformViewsController,
2344 std::make_shared<fml::SyncSwitch>());
2346 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2347 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2351 flutterPlatformViewsController->RegisterViewFactory(
2352 factory,
@"MockFlutterPlatformView",
2358 flutterPlatformViewsController->OnMethodCall(
2360 methodCallWithMethodName:
@"create"
2361 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2364 flutter::MutatorsStack stack;
2365 SkMatrix finalMatrix;
2366 auto embeddedViewParams =
2367 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2368 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
2369 flutterPlatformViewsController->CompositeEmbeddedView(2);
2374 flutterPlatformViewsController->Reset();
2379 - (void)testFlutterPlatformViewControllerBeginFrameShouldResetCompisitionOrder {
2380 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2381 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2382 flutter::TaskRunners runners(
self.name.UTF8String,
2386 thread_task_runner);
2387 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2388 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2390 mock_delegate.settings_.enable_impeller
2393 flutterPlatformViewsController,
2396 std::make_shared<fml::SyncSwitch>());
2398 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2399 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2403 flutterPlatformViewsController->RegisterViewFactory(
2404 factory,
@"MockFlutterPlatformView",
2409 flutterPlatformViewsController->OnMethodCall(
2411 methodCallWithMethodName:
@"create"
2412 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
2416 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2417 flutter::MutatorsStack stack;
2418 SkMatrix finalMatrix;
2419 auto embeddedViewParams1 =
2420 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2421 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2422 flutterPlatformViewsController->CompositeEmbeddedView(0);
2423 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 1UL);
2426 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2427 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 0UL);
2429 auto embeddedViewParams2 =
2430 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2431 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams2));
2432 flutterPlatformViewsController->CompositeEmbeddedView(0);
2433 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 1UL);
2437 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithDifferentViewHierarchy {
2438 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2439 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2440 flutter::TaskRunners runners(
self.name.UTF8String,
2444 thread_task_runner);
2445 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2446 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2448 mock_delegate.settings_.enable_impeller
2451 flutterPlatformViewsController,
2454 std::make_shared<fml::SyncSwitch>());
2456 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2457 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2461 flutterPlatformViewsController->RegisterViewFactory(
2462 factory,
@"MockFlutterPlatformView",
2466 flutterPlatformViewsController->OnMethodCall(
2468 methodCallWithMethodName:
@"create"
2469 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
2474 flutterPlatformViewsController->OnMethodCall(
2476 methodCallWithMethodName:
@"create"
2477 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2481 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2482 flutter::MutatorsStack stack;
2483 SkMatrix finalMatrix;
2484 auto embeddedViewParams1 =
2485 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2486 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2487 flutterPlatformViewsController->CompositeEmbeddedView(0);
2488 auto embeddedViewParams2 =
2489 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2490 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2491 flutterPlatformViewsController->CompositeEmbeddedView(1);
2494 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
2495 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
2496 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
2497 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
2498 std::move(mock_sk_surface), framebuffer_info,
2499 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2500 SkISize::Make(800, 600));
2503 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2505 UIView* clippingView1 = view1.superview.superview;
2506 UIView* clippingView2 = view2.superview.superview;
2507 UIView* flutterView = clippingView1.superview;
2508 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
2509 [flutterView.subviews indexOfObject:clippingView2],
2510 @"The first clipping view should be added before the second clipping view.");
2513 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2515 embeddedViewParams2 =
2516 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2517 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2518 flutterPlatformViewsController->CompositeEmbeddedView(1);
2519 embeddedViewParams1 =
2520 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2521 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2522 flutterPlatformViewsController->CompositeEmbeddedView(0);
2524 mock_sk_surface = SkSurfaces::Raster(image_info);
2525 mock_surface = std::make_unique<flutter::SurfaceFrame>(
2526 std::move(mock_sk_surface), framebuffer_info,
2527 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2528 SkISize::Make(800, 600));
2530 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2531 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] >
2532 [flutterView.subviews indexOfObject:clippingView2],
2533 @"The first clipping view should be added after the second clipping view.");
2537 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithSameViewHierarchy {
2538 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2539 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2540 flutter::TaskRunners runners(
self.name.UTF8String,
2544 thread_task_runner);
2545 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2546 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2548 mock_delegate.settings_.enable_impeller
2551 flutterPlatformViewsController,
2554 std::make_shared<fml::SyncSwitch>());
2556 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2557 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2561 flutterPlatformViewsController->RegisterViewFactory(
2562 factory,
@"MockFlutterPlatformView",
2566 flutterPlatformViewsController->OnMethodCall(
2568 methodCallWithMethodName:
@"create"
2569 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
2574 flutterPlatformViewsController->OnMethodCall(
2576 methodCallWithMethodName:
@"create"
2577 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2581 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2582 flutter::MutatorsStack stack;
2583 SkMatrix finalMatrix;
2584 auto embeddedViewParams1 =
2585 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2586 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2587 flutterPlatformViewsController->CompositeEmbeddedView(0);
2588 auto embeddedViewParams2 =
2589 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2590 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2591 flutterPlatformViewsController->CompositeEmbeddedView(1);
2594 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
2595 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
2596 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
2597 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
2598 std::move(mock_sk_surface), framebuffer_info,
2599 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2600 SkISize::Make(800, 600));
2603 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2605 UIView* clippingView1 = view1.superview.superview;
2606 UIView* clippingView2 = view2.superview.superview;
2607 UIView* flutterView = clippingView1.superview;
2608 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
2609 [flutterView.subviews indexOfObject:clippingView2],
2610 @"The first clipping view should be added before the second clipping view.");
2613 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2615 embeddedViewParams1 =
2616 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2617 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2618 flutterPlatformViewsController->CompositeEmbeddedView(0);
2619 embeddedViewParams2 =
2620 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2621 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2622 flutterPlatformViewsController->CompositeEmbeddedView(1);
2624 mock_sk_surface = SkSurfaces::Raster(image_info);
2625 mock_surface = std::make_unique<flutter::SurfaceFrame>(
2626 std::move(mock_sk_surface), framebuffer_info,
2627 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2628 SkISize::Make(800, 600));
2630 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2631 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
2632 [flutterView.subviews indexOfObject:clippingView2],
2633 @"The first clipping view should be added before the second clipping view.");
2636 - (void)testThreadMergeAtEndFrame {
2637 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2638 auto thread_task_runner_platform =
CreateNewThread(
"FlutterPlatformViewsTest1");
2639 auto thread_task_runner_other =
CreateNewThread(
"FlutterPlatformViewsTest2");
2640 flutter::TaskRunners runners(
self.name.UTF8String,
2641 thread_task_runner_platform,
2642 thread_task_runner_other,
2643 thread_task_runner_other,
2644 thread_task_runner_other);
2645 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2646 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2648 mock_delegate.settings_.enable_impeller
2651 flutterPlatformViewsController,
2654 std::make_shared<fml::SyncSwitch>());
2656 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2657 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2661 flutterPlatformViewsController->RegisterViewFactory(
2662 factory,
@"MockFlutterPlatformView",
2664 XCTestExpectation* waitForPlatformView =
2665 [
self expectationWithDescription:@"wait for platform view to be created"];
2667 [waitForPlatformView fulfill];
2670 flutterPlatformViewsController->OnMethodCall(
2672 methodCallWithMethodName:
@"create"
2673 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2675 [
self waitForExpectations:@[ waitForPlatformView ] timeout:30];
2678 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2679 SkMatrix finalMatrix;
2680 flutter::MutatorsStack stack;
2681 auto embeddedViewParams =
2682 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2683 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
2685 fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger =
2686 fml::MakeRefCounted<fml::RasterThreadMerger>(thread_task_runner_platform->GetTaskQueueId(),
2687 thread_task_runner_other->GetTaskQueueId());
2688 XCTAssertEqual(flutterPlatformViewsController->PostPrerollAction(raster_thread_merger),
2689 flutter::PostPrerollResult::kSkipAndRetryFrame);
2690 XCTAssertFalse(raster_thread_merger->IsMerged());
2692 flutterPlatformViewsController->EndFrame(
true, raster_thread_merger);
2693 XCTAssertTrue(raster_thread_merger->IsMerged());
2697 while (raster_thread_merger->DecrementLease() != fml::RasterThreadStatus::kUnmergedNow) {
2701 - (int)alphaOfPoint:(CGPoint)point onView:(UIView*)view {
2702 unsigned char pixel[4] = {0};
2704 CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
2707 CGContextRef context = CGBitmapContextCreate(
2708 pixel, 1, 1, 8, 4, colorSpace, kCGBitmapAlphaInfoMask & kCGImageAlphaPremultipliedLast);
2709 CGContextTranslateCTM(context, -point.x, -point.y);
2710 [view.layer renderInContext:context];
2712 CGContextRelease(context);
2713 CGColorSpaceRelease(colorSpace);
2718 - (void)testHasFirstResponderInViewHierarchySubtree_viewItselfBecomesFirstResponder {
2720 UIWindow* window = [[UIWindow alloc] init];
2721 UITextField* textField = [[UITextField alloc] init];
2722 [window addSubview:textField];
2724 [textField becomeFirstResponder];
2725 XCTAssertTrue(textField.isFirstResponder);
2726 XCTAssertTrue(textField.flt_hasFirstResponderInViewHierarchySubtree);
2727 [textField resignFirstResponder];
2728 XCTAssertFalse(textField.isFirstResponder);
2729 XCTAssertFalse(textField.flt_hasFirstResponderInViewHierarchySubtree);
2732 - (void)testHasFirstResponderInViewHierarchySubtree_descendantViewBecomesFirstResponder {
2734 UIWindow* window = [[UIWindow alloc] init];
2735 UIView* view = [[UIView alloc] init];
2736 UIView* childView = [[UIView alloc] init];
2737 UITextField* textField = [[UITextField alloc] init];
2738 [window addSubview:view];
2739 [view addSubview:childView];
2740 [childView addSubview:textField];
2742 [textField becomeFirstResponder];
2743 XCTAssertTrue(textField.isFirstResponder);
2744 XCTAssertTrue(view.flt_hasFirstResponderInViewHierarchySubtree);
2745 [textField resignFirstResponder];
2746 XCTAssertFalse(textField.isFirstResponder);
2747 XCTAssertFalse(view.flt_hasFirstResponderInViewHierarchySubtree);
2750 - (void)testFlutterClippingMaskViewPoolReuseViewsAfterRecycle {
2756 CGRect newRect = CGRectMake(0, 0, 10, 10);
2760 NSSet* set1 = [NSSet setWithObjects:view1, view2, nil];
2761 NSSet* set2 = [NSSet setWithObjects:view3, view4, nil];
2762 XCTAssertEqualObjects(set1, set2);
2763 XCTAssertTrue(CGRectEqualToRect(view3.frame, newRect));
2764 XCTAssertTrue(CGRectEqualToRect(view4.frame, newRect));
2767 - (void)testFlutterClippingMaskViewPoolAllocsNewMaskViewsAfterReachingCapacity {
2772 XCTAssertNotEqual(view1, view3);
2773 XCTAssertNotEqual(view2, view3);
2776 - (void)testMaskViewsReleasedWhenPoolIsReleased {
2777 __weak UIView* weakView;
2782 XCTAssertNotNil(weakView);
2784 XCTAssertNil(weakView);
2787 - (void)testClipMaskViewIsReused {
2788 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2789 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2790 flutter::TaskRunners runners(
self.name.UTF8String,
2794 thread_task_runner);
2795 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2796 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2798 mock_delegate.settings_.enable_impeller
2801 flutterPlatformViewsController,
2804 std::make_shared<fml::SyncSwitch>());
2808 flutterPlatformViewsController->RegisterViewFactory(
2809 factory,
@"MockFlutterPlatformView",
2813 flutterPlatformViewsController->OnMethodCall(
2815 methodCallWithMethodName:
@"create"
2816 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2820 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2821 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2823 flutter::MutatorsStack stack1;
2825 SkMatrix screenScaleMatrix =
2826 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2827 stack1.PushTransform(screenScaleMatrix);
2829 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
2830 stack1.PushClipRect(rect);
2832 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
2833 screenScaleMatrix, SkSize::Make(10, 10), stack1);
2835 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
2836 flutterPlatformViewsController->CompositeEmbeddedView(1);
2838 UIView* maskView1 = childClippingView1.maskView;
2839 XCTAssertNotNil(maskView1);
2842 flutterPlatformViewsController->BeginFrame(SkISize::Make(100, 100));
2843 flutter::MutatorsStack stack2;
2844 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
2845 screenScaleMatrix, SkSize::Make(10, 10), stack2);
2846 auto embeddedViewParams3 = std::make_unique<flutter::EmbeddedViewParams>(
2847 screenScaleMatrix, SkSize::Make(10, 10), stack2);
2848 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams3));
2849 flutterPlatformViewsController->CompositeEmbeddedView(1);
2853 flutterPlatformViewsController->OnMethodCall(
2855 methodCallWithMethodName:
@"create"
2856 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2859 auto embeddedViewParams4 = std::make_unique<flutter::EmbeddedViewParams>(
2860 screenScaleMatrix, SkSize::Make(10, 10), stack1);
2861 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams4));
2862 flutterPlatformViewsController->CompositeEmbeddedView(2);
2865 UIView* maskView2 = childClippingView2.maskView;
2866 XCTAssertEqual(maskView1, maskView2);
2867 XCTAssertNotNil(childClippingView2.maskView);
2868 XCTAssertNil(childClippingView1.maskView);
2871 - (void)testDifferentClipMaskViewIsUsedForEachView {
2872 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2873 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2874 flutter::TaskRunners runners(
self.name.UTF8String,
2878 thread_task_runner);
2879 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2880 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2882 mock_delegate.settings_.enable_impeller
2885 flutterPlatformViewsController,
2888 std::make_shared<fml::SyncSwitch>());
2892 flutterPlatformViewsController->RegisterViewFactory(
2893 factory,
@"MockFlutterPlatformView",
2898 flutterPlatformViewsController->OnMethodCall(
2900 methodCallWithMethodName:
@"create"
2901 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2906 flutterPlatformViewsController->OnMethodCall(
2908 methodCallWithMethodName:
@"create"
2909 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2914 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2915 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2917 flutter::MutatorsStack stack1;
2919 SkMatrix screenScaleMatrix =
2920 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2921 stack1.PushTransform(screenScaleMatrix);
2923 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
2924 stack1.PushClipRect(rect);
2926 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
2927 screenScaleMatrix, SkSize::Make(10, 10), stack1);
2929 flutter::MutatorsStack stack2;
2930 stack2.PushClipRect(rect);
2931 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
2932 screenScaleMatrix, SkSize::Make(10, 10), stack2);
2934 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
2935 flutterPlatformViewsController->CompositeEmbeddedView(1);
2936 UIView* childClippingView1 = view1.superview.superview;
2938 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams2));
2939 flutterPlatformViewsController->CompositeEmbeddedView(2);
2940 UIView* childClippingView2 = view2.superview.superview;
2941 UIView* maskView1 = childClippingView1.maskView;
2942 UIView* maskView2 = childClippingView2.maskView;
2943 XCTAssertNotEqual(maskView1, maskView2);
2951 - (BOOL)validateOneVisualEffectView:(UIView*)visualEffectView
2952 expectedFrame:(CGRect)frame
2953 inputRadius:(CGFloat)inputRadius {
2954 XCTAssertTrue(CGRectEqualToRect(visualEffectView.frame, frame));
2955 for (UIView* view in visualEffectView.subviews) {
2956 if (![NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
2959 XCTAssertEqual(view.layer.filters.count, 1u);
2960 NSObject* filter = view.layer.filters.firstObject;
2962 XCTAssertEqualObjects([filter valueForKey:
@"name"],
@"gaussianBlur");
2964 NSObject* inputRadiusInFilter = [filter valueForKey:@"inputRadius"];
2965 XCTAssertTrue([inputRadiusInFilter isKindOfClass:[NSNumber
class]] &&
2973 - (void)testDisposingViewInCompositionOrderDoNotCrash {
2974 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2975 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2976 flutter::TaskRunners runners(
self.name.UTF8String,
2980 thread_task_runner);
2981 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2982 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2984 mock_delegate.settings_.enable_impeller
2987 flutterPlatformViewsController,
2990 std::make_shared<fml::SyncSwitch>());
2992 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2993 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2997 flutterPlatformViewsController->RegisterViewFactory(
2998 factory,
@"MockFlutterPlatformView",
3003 flutterPlatformViewsController->OnMethodCall(
3005 methodCallWithMethodName:
@"create"
3006 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
3008 flutterPlatformViewsController->OnMethodCall(
3010 methodCallWithMethodName:
@"create"
3011 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
3017 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
3018 flutter::MutatorsStack stack;
3019 SkMatrix finalMatrix;
3020 auto embeddedViewParams0 =
3021 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3022 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams0));
3023 flutterPlatformViewsController->CompositeEmbeddedView(0);
3025 auto embeddedViewParams1 =
3026 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3027 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
3028 flutterPlatformViewsController->CompositeEmbeddedView(1);
3029 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 2UL);
3031 XCTestExpectation* expectation = [
self expectationWithDescription:@"dispose call ended."];
3033 [expectation fulfill];
3036 flutterPlatformViewsController->OnMethodCall(
3037 [
FlutterMethodCall methodCallWithMethodName:
@"dispose" arguments:@0], disposeResult);
3038 [
self waitForExpectationsWithTimeout:30 handler:nil];
3040 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
3041 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
3042 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3043 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3044 std::move(mock_sk_surface), framebuffer_info,
3045 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3046 SkISize::Make(800, 600));
3048 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
3051 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 2UL);
3052 XCTAssertNotNil(flutterPlatformViewsController->GetPlatformViewByID(0));
3053 XCTAssertNotNil(flutterPlatformViewsController->GetPlatformViewByID(1));
3059 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
3060 flutter::MutatorsStack stack;
3061 SkMatrix finalMatrix;
3062 auto embeddedViewParams1 =
3063 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3064 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
3065 flutterPlatformViewsController->CompositeEmbeddedView(1);
3067 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
3068 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
3069 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3070 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3071 std::move(mock_sk_surface), framebuffer_info,
3072 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3073 SkISize::Make(800, 600));
3075 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
3078 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 1UL);
3079 XCTAssertNil(flutterPlatformViewsController->GetPlatformViewByID(0));
3080 XCTAssertNotNil(flutterPlatformViewsController->GetPlatformViewByID(1));
3083 - (void)testOnlyPlatformViewsAreRemovedWhenReset {
3084 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3085 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
3086 flutter::TaskRunners runners(
self.name.UTF8String,
3090 thread_task_runner);
3091 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
3092 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3094 mock_delegate.settings_.enable_impeller
3097 flutterPlatformViewsController,
3100 std::make_shared<fml::SyncSwitch>());
3104 flutterPlatformViewsController->RegisterViewFactory(
3105 factory,
@"MockFlutterPlatformView",
3109 flutterPlatformViewsController->OnMethodCall(
3111 methodCallWithMethodName:
@"create"
3112 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
3114 UIView* mockFlutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
3115 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
3117 flutter::MutatorsStack stack;
3119 SkMatrix screenScaleMatrix =
3120 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
3121 stack.PushTransform(screenScaleMatrix);
3123 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
3124 stack.PushTransform(translateMatrix);
3125 SkMatrix finalMatrix;
3126 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
3128 auto embeddedViewParams =
3129 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3131 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
3132 flutterPlatformViewsController->CompositeEmbeddedView(2);
3135 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
3136 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
3137 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3138 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3139 std::move(mock_sk_surface), framebuffer_info,
3140 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3141 SkISize::Make(800, 600));
3143 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface));
3145 UIView* someView = [[UIView alloc] init];
3146 [mockFlutterView addSubview:someView];
3148 flutterPlatformViewsController->Reset();
3149 XCTAssertEqual(mockFlutterView.subviews.count, 1u);
3150 XCTAssertEqual(mockFlutterView.subviews.firstObject, someView);
3153 - (void)testFlutterTouchInterceptingViewLinksToAccessibilityContainer {
3155 NSObject* container = [[NSObject alloc] init];
3157 XCTAssertEqualObjects([touchInteceptorView accessibilityContainer], container);