5 #import <OCMock/OCMock.h>
6 #import <UIKit/UIKit.h>
7 #import <XCTest/XCTest.h>
27 - (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;
78 : NSObject <FlutterPlatformViewFactory>
83 viewIdentifier:(int64_t)viewId
84 arguments:(
id _Nullable)args {
92 class FlutterPlatformViewsTestMockPlatformViewDelegate :
public PlatformView::Delegate {
93 void OnPlatformViewCreated(std::unique_ptr<Surface> surface)
override {}
94 void OnPlatformViewDestroyed()
override {}
95 void OnPlatformViewScheduleFrame()
override {}
96 void OnPlatformViewSetNextFrameCallback(
const fml::closure& closure)
override {}
97 void OnPlatformViewSetViewportMetrics(int64_t view_id,
const ViewportMetrics& metrics)
override {}
98 const flutter::Settings& OnPlatformViewGetSettings()
const override {
return settings_; }
99 void OnPlatformViewDispatchPlatformMessage(std::unique_ptr<PlatformMessage> message)
override {}
100 void OnPlatformViewDispatchPointerDataPacket(std::unique_ptr<PointerDataPacket> packet)
override {
102 void OnPlatformViewDispatchSemanticsAction(int32_t
id,
104 fml::MallocMapping args)
override {}
105 void OnPlatformViewSetSemanticsEnabled(
bool enabled)
override {}
106 void OnPlatformViewSetAccessibilityFeatures(int32_t flags)
override {}
107 void OnPlatformViewRegisterTexture(std::shared_ptr<Texture> texture)
override {}
108 void OnPlatformViewUnregisterTexture(int64_t
texture_id)
override {}
109 void OnPlatformViewMarkTextureFrameAvailable(int64_t
texture_id)
override {}
111 void LoadDartDeferredLibrary(intptr_t loading_unit_id,
112 std::unique_ptr<const fml::Mapping> snapshot_data,
113 std::unique_ptr<const fml::Mapping> snapshot_instructions)
override {
115 void LoadDartDeferredLibraryError(intptr_t loading_unit_id,
116 const std::string error_message,
117 bool transient)
override {}
118 void UpdateAssetResolverByType(std::unique_ptr<flutter::AssetResolver> updated_asset_resolver,
119 flutter::AssetResolver::AssetResolverType type)
override {}
129 fml::RefPtr<fml::TaskRunner>
CreateNewThread(
const std::string& name) {
130 auto thread = std::make_unique<fml::Thread>(name);
131 auto runner = thread->GetTaskRunner();
141 - (void)testFlutterViewOnlyCreateOnceInOneFrame {
142 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
144 flutter::TaskRunners runners(
self.name.UTF8String,
149 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
150 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
153 flutterPlatformViewsController,
160 flutterPlatformViewsController->RegisterViewFactory(
161 factory,
@"MockFlutterPlatformView",
165 flutterPlatformViewsController->OnMethodCall(
167 methodCallWithMethodName:
@"create"
168 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
170 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
171 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
173 flutter::MutatorsStack stack;
175 SkMatrix screenScaleMatrix =
176 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
177 stack.PushTransform(screenScaleMatrix);
179 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
180 stack.PushTransform(translateMatrix);
181 SkMatrix finalMatrix;
182 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
184 auto embeddedViewParams =
185 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
187 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
188 flutterPlatformViewsController->CompositeEmbeddedView(2);
190 flutterPlatformViewsController->GetPlatformViewRect(2);
194 flutterPlatformViewsController->Reset();
197 - (void)testCanCreatePlatformViewWithoutFlutterView {
198 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
200 flutter::TaskRunners runners(
self.name.UTF8String,
205 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
206 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
209 flutterPlatformViewsController,
216 flutterPlatformViewsController->RegisterViewFactory(
217 factory,
@"MockFlutterPlatformView",
221 flutterPlatformViewsController->OnMethodCall(
223 methodCallWithMethodName:
@"create"
224 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
230 - (void)testChildClippingViewHitTests {
232 [[[
ChildClippingView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
233 UIView* childView = [[[UIView alloc] initWithFrame:CGRectMake(100, 100, 100, 100)] autorelease];
234 [childClippingView addSubview:childView];
236 XCTAssertFalse([childClippingView pointInside:CGPointMake(50, 50) withEvent:nil]);
237 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 100) withEvent:nil]);
238 XCTAssertFalse([childClippingView pointInside:CGPointMake(100, 99) withEvent:nil]);
239 XCTAssertFalse([childClippingView pointInside:CGPointMake(201, 200) withEvent:nil]);
240 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 201) withEvent:nil]);
241 XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 200) withEvent:nil]);
242 XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 299) withEvent:nil]);
244 XCTAssertTrue([childClippingView pointInside:CGPointMake(150, 150) withEvent:nil]);
245 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 100) withEvent:nil]);
246 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 100) withEvent:nil]);
247 XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 199) withEvent:nil]);
248 XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 199) withEvent:nil]);
251 - (void)testApplyBackdropFilter {
252 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
254 flutter::TaskRunners runners(
self.name.UTF8String,
259 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
260 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
263 flutterPlatformViewsController,
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)] autorelease];
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>(
335 flutterPlatformViewsController,
342 flutterPlatformViewsController->RegisterViewFactory(
343 factory,
@"MockFlutterPlatformView",
347 flutterPlatformViewsController->OnMethodCall(
349 methodCallWithMethodName:
@"create"
350 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
355 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
356 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
358 flutter::MutatorsStack stack;
360 CGFloat screenScale = [UIScreen mainScreen].scale;
361 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
362 stack.PushTransform(screenScaleMatrix);
364 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
365 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 8, screenScale * 8));
367 auto embeddedViewParams =
368 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(5, 10), stack);
370 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
371 flutterPlatformViewsController->CompositeEmbeddedView(2);
374 [mockFlutterView addSubview:childClippingView];
376 [mockFlutterView setNeedsLayout];
377 [mockFlutterView layoutIfNeeded];
380 NSUInteger numberOfExpectedVisualEffectView = 0;
381 for (UIView* subview in childClippingView.subviews) {
382 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
385 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
386 if ([
self validateOneVisualEffectView:subview
387 expectedFrame:CGRectMake(0, 0, 5, 8)
389 numberOfExpectedVisualEffectView++;
392 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
395 - (void)testApplyMultipleBackdropFilters {
396 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
398 flutter::TaskRunners runners(
self.name.UTF8String,
403 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
404 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
407 flutterPlatformViewsController,
414 flutterPlatformViewsController->RegisterViewFactory(
415 factory,
@"MockFlutterPlatformView",
419 flutterPlatformViewsController->OnMethodCall(
421 methodCallWithMethodName:
@"create"
422 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
427 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
428 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
430 flutter::MutatorsStack stack;
432 CGFloat screenScale = [UIScreen mainScreen].scale;
433 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
434 stack.PushTransform(screenScaleMatrix);
436 for (
int i = 0; i < 50; i++) {
437 auto filter = std::make_shared<flutter::DlBlurImageFilter>(i, 2, flutter::DlTileMode::kClamp);
438 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
441 auto embeddedViewParams =
442 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(20, 20), stack);
444 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
445 flutterPlatformViewsController->CompositeEmbeddedView(2);
448 [mockFlutterView addSubview:childClippingView];
450 [mockFlutterView setNeedsLayout];
451 [mockFlutterView layoutIfNeeded];
453 NSUInteger numberOfExpectedVisualEffectView = 0;
454 for (UIView* subview in childClippingView.subviews) {
455 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
458 XCTAssertLessThan(numberOfExpectedVisualEffectView, 50u);
459 if ([
self validateOneVisualEffectView:subview
460 expectedFrame:CGRectMake(0, 0, 10, 10)
461 inputRadius:(CGFloat)numberOfExpectedVisualEffectView]) {
462 numberOfExpectedVisualEffectView++;
465 XCTAssertEqual(numberOfExpectedVisualEffectView, (NSUInteger)numberOfExpectedVisualEffectView);
468 - (void)testAddBackdropFilters {
469 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
471 flutter::TaskRunners runners(
self.name.UTF8String,
476 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
477 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
480 flutterPlatformViewsController,
487 flutterPlatformViewsController->RegisterViewFactory(
488 factory,
@"MockFlutterPlatformView",
492 flutterPlatformViewsController->OnMethodCall(
494 methodCallWithMethodName:
@"create"
495 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
500 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
501 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
503 flutter::MutatorsStack stack;
505 CGFloat screenScale = [UIScreen mainScreen].scale;
506 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
507 stack.PushTransform(screenScaleMatrix);
509 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
510 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
512 auto embeddedViewParams =
513 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
515 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
516 flutterPlatformViewsController->CompositeEmbeddedView(2);
519 [mockFlutterView addSubview:childClippingView];
521 [mockFlutterView setNeedsLayout];
522 [mockFlutterView layoutIfNeeded];
524 NSMutableArray* originalVisualEffectViews = [[[NSMutableArray alloc] init] autorelease];
525 for (UIView* subview in childClippingView.subviews) {
526 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
529 XCTAssertLessThan(originalVisualEffectViews.count, 1u);
530 if ([
self validateOneVisualEffectView:subview
531 expectedFrame:CGRectMake(0, 0, 10, 10)
532 inputRadius:(CGFloat)5]) {
533 [originalVisualEffectViews addObject:subview];
536 XCTAssertEqual(originalVisualEffectViews.count, 1u);
541 flutter::MutatorsStack stack2;
543 stack2.PushTransform(screenScaleMatrix);
545 for (
int i = 0; i < 2; i++) {
546 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
549 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
550 SkSize::Make(10, 10), stack2);
552 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
553 flutterPlatformViewsController->CompositeEmbeddedView(2);
554 [mockFlutterView setNeedsLayout];
555 [mockFlutterView layoutIfNeeded];
557 NSMutableArray* newVisualEffectViews = [[[NSMutableArray alloc] init] autorelease];
558 for (UIView* subview in childClippingView.subviews) {
559 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
562 XCTAssertLessThan(newVisualEffectViews.count, 2u);
564 if ([
self validateOneVisualEffectView:subview
565 expectedFrame:CGRectMake(0, 0, 10, 10)
566 inputRadius:(CGFloat)5]) {
567 [newVisualEffectViews addObject:subview];
570 XCTAssertEqual(newVisualEffectViews.count, 2u);
571 for (NSUInteger i = 0; i < originalVisualEffectViews.count; i++) {
572 UIView* originalView = originalVisualEffectViews[i];
573 UIView* newView = newVisualEffectViews[i];
575 XCTAssertEqual(originalView, newView);
576 id mockOrignalView = OCMPartialMock(originalView);
577 OCMReject([mockOrignalView removeFromSuperview]);
581 - (void)testRemoveBackdropFilters {
582 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
584 flutter::TaskRunners runners(
self.name.UTF8String,
589 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
590 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
593 flutterPlatformViewsController,
600 flutterPlatformViewsController->RegisterViewFactory(
601 factory,
@"MockFlutterPlatformView",
605 flutterPlatformViewsController->OnMethodCall(
607 methodCallWithMethodName:
@"create"
608 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
613 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
614 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
616 flutter::MutatorsStack stack;
618 CGFloat screenScale = [UIScreen mainScreen].scale;
619 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
620 stack.PushTransform(screenScaleMatrix);
622 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
623 for (
int i = 0; i < 5; i++) {
624 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
627 auto embeddedViewParams =
628 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
630 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
631 flutterPlatformViewsController->CompositeEmbeddedView(2);
634 [mockFlutterView addSubview:childClippingView];
636 [mockFlutterView setNeedsLayout];
637 [mockFlutterView layoutIfNeeded];
639 NSMutableArray* originalVisualEffectViews = [[[NSMutableArray alloc] init] autorelease];
640 for (UIView* subview in childClippingView.subviews) {
641 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
644 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
645 if ([
self validateOneVisualEffectView:subview
646 expectedFrame:CGRectMake(0, 0, 10, 10)
647 inputRadius:(CGFloat)5]) {
648 [originalVisualEffectViews addObject:subview];
654 flutter::MutatorsStack stack2;
656 stack2.PushTransform(screenScaleMatrix);
658 for (
int i = 0; i < 4; i++) {
659 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
662 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
663 SkSize::Make(10, 10), stack2);
665 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
666 flutterPlatformViewsController->CompositeEmbeddedView(2);
667 [mockFlutterView setNeedsLayout];
668 [mockFlutterView layoutIfNeeded];
670 NSMutableArray* newVisualEffectViews = [[[NSMutableArray alloc] init] autorelease];
671 for (UIView* subview in childClippingView.subviews) {
672 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
675 XCTAssertLessThan(newVisualEffectViews.count, 4u);
676 if ([
self validateOneVisualEffectView:subview
677 expectedFrame:CGRectMake(0, 0, 10, 10)
678 inputRadius:(CGFloat)5]) {
679 [newVisualEffectViews addObject:subview];
682 XCTAssertEqual(newVisualEffectViews.count, 4u);
684 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
685 UIView* newView = newVisualEffectViews[i];
686 id mockNewView = OCMPartialMock(newView);
687 UIView* originalView = originalVisualEffectViews[i];
689 XCTAssertEqual(originalView, newView);
690 OCMReject([mockNewView removeFromSuperview]);
691 [mockNewView stopMocking];
696 for (
int i = 0; i < 5; i++) {
701 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
702 SkSize::Make(10, 10), stack2);
704 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
705 flutterPlatformViewsController->CompositeEmbeddedView(2);
706 [mockFlutterView setNeedsLayout];
707 [mockFlutterView layoutIfNeeded];
709 NSUInteger numberOfExpectedVisualEffectView = 0u;
710 for (UIView* subview in childClippingView.subviews) {
711 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
712 numberOfExpectedVisualEffectView++;
715 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
718 - (void)testEditBackdropFilters {
719 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
721 flutter::TaskRunners runners(
self.name.UTF8String,
726 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
727 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
730 flutterPlatformViewsController,
737 flutterPlatformViewsController->RegisterViewFactory(
738 factory,
@"MockFlutterPlatformView",
742 flutterPlatformViewsController->OnMethodCall(
744 methodCallWithMethodName:
@"create"
745 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
750 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
751 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
753 flutter::MutatorsStack stack;
755 CGFloat screenScale = [UIScreen mainScreen].scale;
756 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
757 stack.PushTransform(screenScaleMatrix);
759 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
760 for (
int i = 0; i < 5; i++) {
761 stack.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
764 auto embeddedViewParams =
765 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
767 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
768 flutterPlatformViewsController->CompositeEmbeddedView(2);
771 [mockFlutterView addSubview:childClippingView];
773 [mockFlutterView setNeedsLayout];
774 [mockFlutterView layoutIfNeeded];
776 NSMutableArray* originalVisualEffectViews = [[[NSMutableArray alloc] init] autorelease];
777 for (UIView* subview in childClippingView.subviews) {
778 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
781 XCTAssertLessThan(originalVisualEffectViews.count, 5u);
782 if ([
self validateOneVisualEffectView:subview
783 expectedFrame:CGRectMake(0, 0, 10, 10)
784 inputRadius:(CGFloat)5]) {
785 [originalVisualEffectViews addObject:subview];
791 flutter::MutatorsStack stack2;
793 stack2.PushTransform(screenScaleMatrix);
795 for (
int i = 0; i < 5; i++) {
798 std::make_shared<flutter::DlBlurImageFilter>(2, 5, flutter::DlTileMode::kClamp);
800 stack2.PushBackdropFilter(filter2,
801 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
805 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
808 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
809 SkSize::Make(10, 10), stack2);
811 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
812 flutterPlatformViewsController->CompositeEmbeddedView(2);
813 [mockFlutterView setNeedsLayout];
814 [mockFlutterView layoutIfNeeded];
816 NSMutableArray* newVisualEffectViews = [[[NSMutableArray alloc] init] autorelease];
817 for (UIView* subview in childClippingView.subviews) {
818 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
821 XCTAssertLessThan(newVisualEffectViews.count, 5u);
822 CGFloat expectInputRadius = 5;
823 if (newVisualEffectViews.count == 3) {
824 expectInputRadius = 2;
826 if ([
self validateOneVisualEffectView:subview
827 expectedFrame:CGRectMake(0, 0, 10, 10)
828 inputRadius:(CGFloat)expectInputRadius]) {
829 [newVisualEffectViews addObject:subview];
832 XCTAssertEqual(newVisualEffectViews.count, 5u);
833 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
834 UIView* newView = newVisualEffectViews[i];
835 id mockNewView = OCMPartialMock(newView);
836 UIView* originalView = originalVisualEffectViews[i];
838 XCTAssertEqual(originalView, newView);
839 OCMReject([mockNewView removeFromSuperview]);
840 [mockNewView stopMocking];
842 [newVisualEffectViews removeAllObjects];
846 for (
int i = 0; i < 5; i++) {
850 for (
int i = 0; i < 5; i++) {
853 std::make_shared<flutter::DlBlurImageFilter>(2, 5, flutter::DlTileMode::kClamp);
854 stack2.PushBackdropFilter(filter2,
855 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
859 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
862 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
863 SkSize::Make(10, 10), stack2);
865 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
866 flutterPlatformViewsController->CompositeEmbeddedView(2);
867 [mockFlutterView setNeedsLayout];
868 [mockFlutterView layoutIfNeeded];
870 for (UIView* subview in childClippingView.subviews) {
871 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
874 XCTAssertLessThan(newVisualEffectViews.count, 5u);
875 CGFloat expectInputRadius = 5;
876 if (newVisualEffectViews.count == 0) {
877 expectInputRadius = 2;
879 if ([
self validateOneVisualEffectView:subview
880 expectedFrame:CGRectMake(0, 0, 10, 10)
881 inputRadius:(CGFloat)expectInputRadius]) {
882 [newVisualEffectViews addObject:subview];
885 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
886 UIView* newView = newVisualEffectViews[i];
887 id mockNewView = OCMPartialMock(newView);
888 UIView* originalView = originalVisualEffectViews[i];
890 XCTAssertEqual(originalView, newView);
891 OCMReject([mockNewView removeFromSuperview]);
892 [mockNewView stopMocking];
894 [newVisualEffectViews removeAllObjects];
898 for (
int i = 0; i < 5; i++) {
902 for (
int i = 0; i < 5; i++) {
905 std::make_shared<flutter::DlBlurImageFilter>(2, 5, flutter::DlTileMode::kClamp);
906 stack2.PushBackdropFilter(filter2,
907 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
911 stack2.PushBackdropFilter(filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
914 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
915 SkSize::Make(10, 10), stack2);
917 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
918 flutterPlatformViewsController->CompositeEmbeddedView(2);
919 [mockFlutterView setNeedsLayout];
920 [mockFlutterView layoutIfNeeded];
922 for (UIView* subview in childClippingView.subviews) {
923 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
926 XCTAssertLessThan(newVisualEffectViews.count, 5u);
927 CGFloat expectInputRadius = 5;
928 if (newVisualEffectViews.count == 4) {
929 expectInputRadius = 2;
931 if ([
self validateOneVisualEffectView:subview
932 expectedFrame:CGRectMake(0, 0, 10, 10)
933 inputRadius:(CGFloat)expectInputRadius]) {
934 [newVisualEffectViews addObject:subview];
937 XCTAssertEqual(newVisualEffectViews.count, 5u);
939 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
940 UIView* newView = newVisualEffectViews[i];
941 id mockNewView = OCMPartialMock(newView);
942 UIView* originalView = originalVisualEffectViews[i];
944 XCTAssertEqual(originalView, newView);
945 OCMReject([mockNewView removeFromSuperview]);
946 [mockNewView stopMocking];
948 [newVisualEffectViews removeAllObjects];
952 for (
int i = 0; i < 5; i++) {
956 for (
int i = 0; i < 5; i++) {
957 auto filter2 = std::make_shared<flutter::DlBlurImageFilter>(i, 2, flutter::DlTileMode::kClamp);
959 stack2.PushBackdropFilter(filter2, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
962 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
963 SkSize::Make(10, 10), stack2);
965 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
966 flutterPlatformViewsController->CompositeEmbeddedView(2);
967 [mockFlutterView setNeedsLayout];
968 [mockFlutterView layoutIfNeeded];
970 for (UIView* subview in childClippingView.subviews) {
971 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
974 XCTAssertLessThan(newVisualEffectViews.count, 5u);
975 if ([
self validateOneVisualEffectView:subview
976 expectedFrame:CGRectMake(0, 0, 10, 10)
977 inputRadius:(CGFloat)newVisualEffectViews.count]) {
978 [newVisualEffectViews addObject:subview];
981 XCTAssertEqual(newVisualEffectViews.count, 5u);
983 for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
984 UIView* newView = newVisualEffectViews[i];
985 id mockNewView = OCMPartialMock(newView);
986 UIView* originalView = originalVisualEffectViews[i];
988 XCTAssertEqual(originalView, newView);
989 OCMReject([mockNewView removeFromSuperview]);
990 [mockNewView stopMocking];
992 [newVisualEffectViews removeAllObjects];
995 - (void)testApplyBackdropFilterNotDlBlurImageFilter {
996 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
998 flutter::TaskRunners runners(
self.name.UTF8String,
1002 thread_task_runner);
1003 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1004 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1007 flutterPlatformViewsController,
1014 flutterPlatformViewsController->RegisterViewFactory(
1015 factory,
@"MockFlutterPlatformView",
1019 flutterPlatformViewsController->OnMethodCall(
1021 methodCallWithMethodName:
@"create"
1022 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1027 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
1028 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1030 flutter::MutatorsStack stack;
1032 CGFloat screenScale = [UIScreen mainScreen].scale;
1033 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
1034 stack.PushTransform(screenScaleMatrix);
1036 auto dilateFilter = std::make_shared<flutter::DlDilateImageFilter>(5, 2);
1037 stack.PushBackdropFilter(dilateFilter, SkRect::MakeEmpty());
1039 auto embeddedViewParams =
1040 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1042 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1043 flutterPlatformViewsController->CompositeEmbeddedView(2);
1047 [mockFlutterView addSubview:childClippingView];
1049 [mockFlutterView setNeedsLayout];
1050 [mockFlutterView layoutIfNeeded];
1052 NSUInteger numberOfExpectedVisualEffectView = 0;
1053 for (UIView* subview in childClippingView.subviews) {
1054 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1055 numberOfExpectedVisualEffectView++;
1058 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1062 flutter::MutatorsStack stack2;
1064 stack2.PushTransform(screenScaleMatrix);
1066 auto blurFilter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
1068 for (
int i = 0; i < 5; i++) {
1070 stack2.PushBackdropFilter(dilateFilter,
1071 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1075 stack2.PushBackdropFilter(blurFilter,
1076 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1079 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1080 SkSize::Make(10, 10), stack2);
1082 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1083 flutterPlatformViewsController->CompositeEmbeddedView(2);
1084 [mockFlutterView setNeedsLayout];
1085 [mockFlutterView layoutIfNeeded];
1087 numberOfExpectedVisualEffectView = 0;
1088 for (UIView* subview in childClippingView.subviews) {
1089 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1092 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1093 if ([
self validateOneVisualEffectView:subview
1094 expectedFrame:CGRectMake(0, 0, 10, 10)
1095 inputRadius:(CGFloat)5]) {
1096 numberOfExpectedVisualEffectView++;
1099 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1103 for (
int i = 0; i < 5; i++) {
1107 for (
int i = 0; i < 5; i++) {
1109 stack2.PushBackdropFilter(dilateFilter,
1110 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1114 stack2.PushBackdropFilter(blurFilter,
1115 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1118 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1119 SkSize::Make(10, 10), stack2);
1121 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1122 flutterPlatformViewsController->CompositeEmbeddedView(2);
1123 [mockFlutterView setNeedsLayout];
1124 [mockFlutterView layoutIfNeeded];
1126 numberOfExpectedVisualEffectView = 0;
1127 for (UIView* subview in childClippingView.subviews) {
1128 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1131 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1132 if ([
self validateOneVisualEffectView:subview
1133 expectedFrame:CGRectMake(0, 0, 10, 10)
1134 inputRadius:(CGFloat)5]) {
1135 numberOfExpectedVisualEffectView++;
1138 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1142 for (
int i = 0; i < 5; i++) {
1146 for (
int i = 0; i < 5; i++) {
1148 stack2.PushBackdropFilter(dilateFilter,
1149 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1153 stack2.PushBackdropFilter(blurFilter,
1154 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1157 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1158 SkSize::Make(10, 10), stack2);
1160 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1161 flutterPlatformViewsController->CompositeEmbeddedView(2);
1162 [mockFlutterView setNeedsLayout];
1163 [mockFlutterView layoutIfNeeded];
1165 numberOfExpectedVisualEffectView = 0;
1166 for (UIView* subview in childClippingView.subviews) {
1167 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1170 XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1171 if ([
self validateOneVisualEffectView:subview
1172 expectedFrame:CGRectMake(0, 0, 10, 10)
1173 inputRadius:(CGFloat)5]) {
1174 numberOfExpectedVisualEffectView++;
1177 XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1181 for (
int i = 0; i < 5; i++) {
1185 for (
int i = 0; i < 5; i++) {
1186 stack2.PushBackdropFilter(dilateFilter,
1187 SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1190 embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix,
1191 SkSize::Make(10, 10), stack2);
1193 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1194 flutterPlatformViewsController->CompositeEmbeddedView(2);
1195 [mockFlutterView setNeedsLayout];
1196 [mockFlutterView layoutIfNeeded];
1198 numberOfExpectedVisualEffectView = 0;
1199 for (UIView* subview in childClippingView.subviews) {
1200 if ([subview isKindOfClass:[UIVisualEffectView
class]]) {
1201 numberOfExpectedVisualEffectView++;
1204 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1207 - (void)testApplyBackdropFilterCorrectAPI {
1212 UIVisualEffectView* visualEffectView = [[[UIVisualEffectView alloc]
1213 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]] autorelease];
1217 visualEffectView:visualEffectView] autorelease];
1218 XCTAssertNotNil(platformViewFilter);
1221 - (void)testApplyBackdropFilterAPIChangedInvalidUIVisualEffectView {
1223 UIVisualEffectView* visualEffectView = [[[UIVisualEffectView alloc] init] autorelease];
1227 visualEffectView:visualEffectView] autorelease];
1228 XCTAssertNil(platformViewFilter);
1231 - (void)testApplyBackdropFilterAPIChangedNoGaussianBlurFilter {
1233 UIVisualEffectView* editedUIVisualEffectView = [[[UIVisualEffectView alloc]
1234 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]] autorelease];
1235 NSArray* subviews = editedUIVisualEffectView.subviews;
1236 for (UIView* view in subviews) {
1237 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1238 for (CIFilter* filter in view.layer.filters) {
1239 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1240 [filter setValue:@"notGaussianBlur" forKey:@"name"];
1250 visualEffectView:editedUIVisualEffectView] autorelease];
1251 XCTAssertNil(platformViewFilter);
1254 - (void)testApplyBackdropFilterAPIChangedInvalidInputRadius {
1256 UIVisualEffectView* editedUIVisualEffectView = [[[UIVisualEffectView alloc]
1257 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]] autorelease];
1258 NSArray* subviews = editedUIVisualEffectView.subviews;
1259 for (UIView* view in subviews) {
1260 if ([NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
1261 for (CIFilter* filter in view.layer.filters) {
1262 if ([[filter valueForKey:
@"name"] isEqual:
@"gaussianBlur"]) {
1263 [filter setValue:@"invalidInputRadius" forKey:@"inputRadius"];
1274 visualEffectView:editedUIVisualEffectView] autorelease];
1275 XCTAssertNil(platformViewFilter);
1278 - (void)testBackdropFilterVisualEffectSubviewBackgroundColor {
1279 UIVisualEffectView* visualEffectView = [[[UIVisualEffectView alloc]
1280 initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]] autorelease];
1284 visualEffectView:visualEffectView] autorelease];
1285 CGColorRef visualEffectSubviewBackgroundColor = nil;
1286 for (UIView* view in [platformViewFilter backdropFilterView].subviews) {
1287 if ([NSStringFromClass([view
class]) hasSuffix:
@"VisualEffectSubview"]) {
1288 visualEffectSubviewBackgroundColor = view.layer.backgroundColor;
1292 CGColorEqualToColor(visualEffectSubviewBackgroundColor, UIColor.clearColor.CGColor));
1295 - (void)testCompositePlatformView {
1296 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1297 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1298 flutter::TaskRunners runners(
self.name.UTF8String,
1302 thread_task_runner);
1303 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1304 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1307 flutterPlatformViewsController,
1314 flutterPlatformViewsController->RegisterViewFactory(
1315 factory,
@"MockFlutterPlatformView",
1319 flutterPlatformViewsController->OnMethodCall(
1321 methodCallWithMethodName:
@"create"
1322 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1327 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
1328 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1330 flutter::MutatorsStack stack;
1332 SkMatrix screenScaleMatrix =
1333 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1334 stack.PushTransform(screenScaleMatrix);
1336 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
1337 stack.PushTransform(translateMatrix);
1338 SkMatrix finalMatrix;
1339 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
1341 auto embeddedViewParams =
1342 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
1344 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1345 flutterPlatformViewsController->CompositeEmbeddedView(2);
1346 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1347 toView:mockFlutterView];
1348 XCTAssertTrue(CGRectEqualToRect(platformViewRectInFlutterView, CGRectMake(100, 100, 300, 300)));
1351 - (void)testBackdropFilterCorrectlyPushedAndReset {
1352 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1353 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1354 flutter::TaskRunners runners(
self.name.UTF8String,
1358 thread_task_runner);
1359 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1360 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1363 flutterPlatformViewsController,
1370 flutterPlatformViewsController->RegisterViewFactory(
1371 factory,
@"MockFlutterPlatformView",
1375 flutterPlatformViewsController->OnMethodCall(
1377 methodCallWithMethodName:
@"create"
1378 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1383 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
1384 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1386 flutter::MutatorsStack stack;
1388 CGFloat screenScale = [UIScreen mainScreen].scale;
1389 SkMatrix screenScaleMatrix = SkMatrix::Scale(screenScale, screenScale);
1390 stack.PushTransform(screenScaleMatrix);
1392 auto embeddedViewParams =
1393 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1395 flutterPlatformViewsController->BeginFrame(SkISize::Make(0, 0));
1396 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1397 flutterPlatformViewsController->PushVisitedPlatformView(2);
1398 auto filter = std::make_shared<flutter::DlBlurImageFilter>(5, 2, flutter::DlTileMode::kClamp);
1399 flutterPlatformViewsController->PushFilterToVisitedPlatformViews(
1400 filter, SkRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1401 flutterPlatformViewsController->CompositeEmbeddedView(2);
1404 [mockFlutterView addSubview:childClippingView];
1406 [mockFlutterView setNeedsLayout];
1407 [mockFlutterView layoutIfNeeded];
1410 NSUInteger numberOfExpectedVisualEffectView = 0;
1411 for (UIView* subview in childClippingView.subviews) {
1412 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1415 XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
1416 if ([
self validateOneVisualEffectView:subview
1417 expectedFrame:CGRectMake(0, 0, 10, 10)
1419 numberOfExpectedVisualEffectView++;
1422 XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
1425 auto embeddedViewParams2 =
1426 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1427 flutterPlatformViewsController->BeginFrame(SkISize::Make(0, 0));
1428 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams2));
1429 flutterPlatformViewsController->CompositeEmbeddedView(2);
1432 [mockFlutterView setNeedsLayout];
1433 [mockFlutterView layoutIfNeeded];
1435 numberOfExpectedVisualEffectView = 0;
1436 for (UIView* subview in childClippingView.subviews) {
1437 if (![subview isKindOfClass:[UIVisualEffectView
class]]) {
1440 numberOfExpectedVisualEffectView++;
1442 XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1445 - (void)testChildClippingViewShouldBeTheBoundingRectOfPlatformView {
1446 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1447 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1448 flutter::TaskRunners runners(
self.name.UTF8String,
1452 thread_task_runner);
1453 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1454 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1457 flutterPlatformViewsController,
1464 flutterPlatformViewsController->RegisterViewFactory(
1465 factory,
@"MockFlutterPlatformView",
1469 flutterPlatformViewsController->OnMethodCall(
1471 methodCallWithMethodName:
@"create"
1472 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1477 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
1478 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1480 flutter::MutatorsStack stack;
1482 SkMatrix screenScaleMatrix =
1483 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1484 stack.PushTransform(screenScaleMatrix);
1486 SkMatrix rotateMatrix;
1487 rotateMatrix.setRotate(10);
1488 stack.PushTransform(rotateMatrix);
1489 SkMatrix finalMatrix;
1490 finalMatrix.setConcat(screenScaleMatrix, rotateMatrix);
1492 auto embeddedViewParams =
1493 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
1495 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1496 flutterPlatformViewsController->CompositeEmbeddedView(2);
1497 CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1498 toView:mockFlutterView];
1504 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.x - childClippingView.frame.origin.x),
1506 XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.y - childClippingView.frame.origin.y),
1509 fabs(platformViewRectInFlutterView.size.width - childClippingView.frame.size.width),
1512 fabs(platformViewRectInFlutterView.size.height - childClippingView.frame.size.height),
1516 - (void)testClipsDoNotInterceptWithPlatformViewShouldNotAddMaskView {
1517 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1518 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1519 flutter::TaskRunners runners(
self.name.UTF8String,
1523 thread_task_runner);
1524 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1525 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1528 flutterPlatformViewsController,
1535 flutterPlatformViewsController->RegisterViewFactory(
1536 factory,
@"MockFlutterPlatformView",
1540 flutterPlatformViewsController->OnMethodCall(
1542 methodCallWithMethodName:
@"create"
1543 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1548 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)] autorelease];
1549 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1551 flutter::MutatorsStack stack;
1553 SkMatrix screenScaleMatrix =
1554 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1555 stack.PushTransform(screenScaleMatrix);
1556 SkMatrix translateMatrix = SkMatrix::Translate(5, 5);
1558 stack.PushTransform(translateMatrix);
1560 SkRect rect = SkRect::MakeXYWH(0, 0, 25, 25);
1561 stack.PushClipRect(rect);
1564 SkRect rect_for_rrect = SkRect::MakeXYWH(-1, -1, 25, 25);
1565 SkRRect rrect = SkRRect::MakeRectXY(rect_for_rrect, 1, 1);
1566 stack.PushClipRRect(rrect);
1568 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1569 SkMatrix::Concat(screenScaleMatrix, translateMatrix), SkSize::Make(5, 5), stack);
1571 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1572 flutterPlatformViewsController->CompositeEmbeddedView(2);
1576 [mockFlutterView addSubview:childClippingView];
1578 [mockFlutterView setNeedsLayout];
1579 [mockFlutterView layoutIfNeeded];
1580 XCTAssertNil(childClippingView.maskView);
1583 - (void)testClipRRectOnlyHasCornersInterceptWithPlatformViewShouldAddMaskView {
1584 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1585 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1586 flutter::TaskRunners runners(
self.name.UTF8String,
1590 thread_task_runner);
1591 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1592 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1595 flutterPlatformViewsController,
1602 flutterPlatformViewsController->RegisterViewFactory(
1603 factory,
@"MockFlutterPlatformView",
1607 flutterPlatformViewsController->OnMethodCall(
1609 methodCallWithMethodName:
@"create"
1610 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1615 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)] autorelease];
1616 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1618 flutter::MutatorsStack stack;
1620 SkMatrix screenScaleMatrix =
1621 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1622 stack.PushTransform(screenScaleMatrix);
1623 SkMatrix translateMatrix = SkMatrix::Translate(5, 5);
1625 stack.PushTransform(translateMatrix);
1629 SkRect rect_for_rrect = SkRect::MakeXYWH(0, 0, 10, 10);
1630 SkRRect rrect = SkRRect::MakeRectXY(rect_for_rrect, 1, 1);
1631 stack.PushClipRRect(rrect);
1633 auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1634 SkMatrix::Concat(screenScaleMatrix, translateMatrix), SkSize::Make(5, 5), stack);
1636 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1637 flutterPlatformViewsController->CompositeEmbeddedView(2);
1641 [mockFlutterView addSubview:childClippingView];
1643 [mockFlutterView setNeedsLayout];
1644 [mockFlutterView layoutIfNeeded];
1646 XCTAssertNotNil(childClippingView.maskView);
1649 - (void)testClipRect {
1650 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1651 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1652 flutter::TaskRunners runners(
self.name.UTF8String,
1656 thread_task_runner);
1657 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1658 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1661 flutterPlatformViewsController,
1668 flutterPlatformViewsController->RegisterViewFactory(
1669 factory,
@"MockFlutterPlatformView",
1673 flutterPlatformViewsController->OnMethodCall(
1675 methodCallWithMethodName:
@"create"
1676 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1681 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
1682 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1684 flutter::MutatorsStack stack;
1686 SkMatrix screenScaleMatrix =
1687 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1688 stack.PushTransform(screenScaleMatrix);
1690 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
1691 stack.PushClipRect(rect);
1693 auto embeddedViewParams =
1694 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1696 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1697 flutterPlatformViewsController->CompositeEmbeddedView(2);
1701 [mockFlutterView addSubview:childClippingView];
1703 [mockFlutterView setNeedsLayout];
1704 [mockFlutterView layoutIfNeeded];
1706 for (
int i = 0; i < 10; i++) {
1707 for (
int j = 0; j < 10; j++) {
1708 CGPoint point = CGPointMake(i, j);
1709 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:mockFlutterView];
1712 CGRect insideClipping = CGRectMake(3, 3, 1, 1);
1713 if (CGRectContainsPoint(insideClipping, point)) {
1714 XCTAssertEqual(alpha, 255);
1716 XCTAssertLessThan(alpha, 255);
1722 - (void)testClipRRect {
1723 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1724 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1725 flutter::TaskRunners runners(
self.name.UTF8String,
1729 thread_task_runner);
1730 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1731 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1734 flutterPlatformViewsController,
1741 flutterPlatformViewsController->RegisterViewFactory(
1742 factory,
@"MockFlutterPlatformView",
1746 flutterPlatformViewsController->OnMethodCall(
1748 methodCallWithMethodName:
@"create"
1749 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1754 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
1755 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1757 flutter::MutatorsStack stack;
1759 SkMatrix screenScaleMatrix =
1760 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1761 stack.PushTransform(screenScaleMatrix);
1763 SkRRect rrect = SkRRect::MakeRectXY(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
1764 stack.PushClipRRect(rrect);
1766 auto embeddedViewParams =
1767 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1769 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1770 flutterPlatformViewsController->CompositeEmbeddedView(2);
1774 [mockFlutterView addSubview:childClippingView];
1776 [mockFlutterView setNeedsLayout];
1777 [mockFlutterView layoutIfNeeded];
1779 for (
int i = 0; i < 10; i++) {
1780 for (
int j = 0; j < 10; j++) {
1781 CGPoint point = CGPointMake(i, j);
1782 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:mockFlutterView];
1785 CGRect insideClipping = CGRectMake(3, 3, 4, 4);
1786 if (CGRectContainsPoint(insideClipping, point)) {
1787 XCTAssertEqual(alpha, 255);
1789 XCTAssertLessThan(alpha, 255);
1795 - (void)testClipPath {
1796 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1797 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1798 flutter::TaskRunners runners(
self.name.UTF8String,
1802 thread_task_runner);
1803 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1804 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1807 flutterPlatformViewsController,
1814 flutterPlatformViewsController->RegisterViewFactory(
1815 factory,
@"MockFlutterPlatformView",
1819 flutterPlatformViewsController->OnMethodCall(
1821 methodCallWithMethodName:
@"create"
1822 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1827 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
1828 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
1830 flutter::MutatorsStack stack;
1832 SkMatrix screenScaleMatrix =
1833 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
1834 stack.PushTransform(screenScaleMatrix);
1837 path.addRoundRect(SkRect::MakeXYWH(2, 2, 6, 6), 1, 1);
1838 stack.PushClipPath(path);
1840 auto embeddedViewParams =
1841 std::make_unique<flutter::EmbeddedViewParams>(screenScaleMatrix, SkSize::Make(10, 10), stack);
1843 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
1844 flutterPlatformViewsController->CompositeEmbeddedView(2);
1848 [mockFlutterView addSubview:childClippingView];
1850 [mockFlutterView setNeedsLayout];
1851 [mockFlutterView layoutIfNeeded];
1853 for (
int i = 0; i < 10; i++) {
1854 for (
int j = 0; j < 10; j++) {
1855 CGPoint point = CGPointMake(i, j);
1856 int alpha = [
self alphaOfPoint:CGPointMake(i, j) onView:mockFlutterView];
1859 CGRect insideClipping = CGRectMake(3, 3, 4, 4);
1860 if (CGRectContainsPoint(insideClipping, point)) {
1861 XCTAssertEqual(alpha, 255);
1863 XCTAssertLessThan(alpha, 255);
1869 - (void)testSetFlutterViewControllerAfterCreateCanStillDispatchTouchEvents {
1870 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1871 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1872 flutter::TaskRunners runners(
self.name.UTF8String,
1876 thread_task_runner);
1877 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1878 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1881 flutterPlatformViewsController,
1888 flutterPlatformViewsController->RegisterViewFactory(
1889 factory,
@"MockFlutterPlatformView",
1893 flutterPlatformViewsController->OnMethodCall(
1895 methodCallWithMethodName:
@"create"
1896 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1903 while (touchInteceptorView != nil &&
1905 touchInteceptorView = touchInteceptorView.superview;
1907 XCTAssertNotNil(touchInteceptorView);
1910 UIGestureRecognizer* forwardGectureRecognizer = nil;
1911 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
1912 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
1913 forwardGectureRecognizer = gestureRecognizer;
1919 NSSet* touches1 = [[[NSSet alloc] init] autorelease];
1920 id event1 = OCMClassMock([UIEvent
class]);
1922 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
1923 OCMReject([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
1926 NSSet* touches2 = [[[NSSet alloc] init] autorelease];
1927 id event2 = OCMClassMock([UIEvent
class]);
1928 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
1929 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
1930 OCMVerify([mockFlutterViewContoller touchesBegan:touches2 withEvent:event2]);
1933 - (void)testSetFlutterViewControllerInTheMiddleOfTouchEventShouldStillAllowGesturesToBeHandled {
1934 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1935 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
1936 flutter::TaskRunners runners(
self.name.UTF8String,
1940 thread_task_runner);
1941 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
1942 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1945 flutterPlatformViewsController,
1952 flutterPlatformViewsController->RegisterViewFactory(
1953 factory,
@"MockFlutterPlatformView",
1957 flutterPlatformViewsController->OnMethodCall(
1959 methodCallWithMethodName:
@"create"
1960 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
1967 while (touchInteceptorView != nil &&
1969 touchInteceptorView = touchInteceptorView.superview;
1971 XCTAssertNotNil(touchInteceptorView);
1974 UIGestureRecognizer* forwardGectureRecognizer = nil;
1975 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
1976 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
1977 forwardGectureRecognizer = gestureRecognizer;
1984 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
1986 NSSet* touches1 = [[[NSSet alloc] init] autorelease];
1987 id event1 = OCMClassMock([UIEvent
class]);
1988 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
1989 OCMVerify([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
1991 flutterPlatformViewsController->SetFlutterViewController(nil);
1994 NSSet* touches2 = [[[NSSet alloc] init] autorelease];
1995 id event2 = OCMClassMock([UIEvent
class]);
1996 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
1997 OCMVerify([mockFlutterViewContoller touchesMoved:touches2 withEvent:event2]);
1999 NSSet* touches3 = [[[NSSet alloc] init] autorelease];
2000 id event3 = OCMClassMock([UIEvent
class]);
2001 [forwardGectureRecognizer touchesEnded:touches3 withEvent:event3];
2002 OCMVerify([mockFlutterViewContoller touchesEnded:touches3 withEvent:event3]);
2005 NSSet* touches4 = [[[NSSet alloc] init] autorelease];
2006 id event4 = OCMClassMock([UIEvent
class]);
2007 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2008 OCMReject([mockFlutterViewContoller touchesBegan:touches4 withEvent:event4]);
2010 NSSet* touches5 = [[[NSSet alloc] init] autorelease];
2011 id event5 = OCMClassMock([UIEvent
class]);
2012 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2013 OCMReject([mockFlutterViewContoller touchesEnded:touches5 withEvent:event5]);
2018 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
2020 NSSet* touches1 = [[[NSSet alloc] init] autorelease];
2021 id event1 = OCMClassMock([UIEvent
class]);
2022 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2023 OCMVerify([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
2025 flutterPlatformViewsController->SetFlutterViewController(nil);
2028 NSSet* touches2 = [[[NSSet alloc] init] autorelease];
2029 id event2 = OCMClassMock([UIEvent
class]);
2030 [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2031 OCMVerify([mockFlutterViewContoller touchesMoved:touches2 withEvent:event2]);
2033 NSSet* touches3 = [[[NSSet alloc] init] autorelease];
2034 id event3 = OCMClassMock([UIEvent
class]);
2035 [forwardGectureRecognizer touchesCancelled:touches3 withEvent:event3];
2036 OCMVerify([mockFlutterViewContoller forceTouchesCancelled:touches3]);
2039 NSSet* touches4 = [[[NSSet alloc] init] autorelease];
2040 id event4 = OCMClassMock([UIEvent
class]);
2041 [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2042 OCMReject([mockFlutterViewContoller touchesBegan:touches4 withEvent:event4]);
2044 NSSet* touches5 = [[[NSSet alloc] init] autorelease];
2045 id event5 = OCMClassMock([UIEvent
class]);
2046 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2047 OCMReject([mockFlutterViewContoller touchesEnded:touches5 withEvent:event5]);
2050 flutterPlatformViewsController->Reset();
2054 testSetFlutterViewControllerInTheMiddleOfTouchEventAllowsTheNewControllerToHandleSecondTouchSequence {
2055 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2056 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2057 flutter::TaskRunners runners(
self.name.UTF8String,
2061 thread_task_runner);
2062 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2063 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2066 flutterPlatformViewsController,
2073 flutterPlatformViewsController->RegisterViewFactory(
2074 factory,
@"MockFlutterPlatformView",
2078 flutterPlatformViewsController->OnMethodCall(
2080 methodCallWithMethodName:
@"create"
2081 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2088 while (touchInteceptorView != nil &&
2090 touchInteceptorView = touchInteceptorView.superview;
2092 XCTAssertNotNil(touchInteceptorView);
2095 UIGestureRecognizer* forwardGectureRecognizer = nil;
2096 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2097 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
2098 forwardGectureRecognizer = gestureRecognizer;
2104 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
2107 NSSet* touches1 = [NSSet setWithObject:@1];
2108 id event1 = OCMClassMock([UIEvent
class]);
2109 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2110 OCMVerify([mockFlutterViewContoller touchesBegan:touches1 withEvent:event1]);
2112 UIViewController* mockFlutterViewContoller2 = OCMClassMock([UIViewController
class]);
2113 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller2);
2117 NSSet* touches2 = [NSSet setWithObject:@1];
2118 id event2 = OCMClassMock([UIEvent
class]);
2119 [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
2120 OCMVerify([mockFlutterViewContoller touchesBegan:touches2 withEvent:event2]);
2121 OCMReject([mockFlutterViewContoller2 touchesBegan:touches2 withEvent:event2]);
2123 NSSet* touches3 = [NSSet setWithObject:@1];
2124 id event3 = OCMClassMock([UIEvent
class]);
2125 [forwardGectureRecognizer touchesMoved:touches3 withEvent:event3];
2126 OCMVerify([mockFlutterViewContoller touchesMoved:touches3 withEvent:event3]);
2127 OCMReject([mockFlutterViewContoller2 touchesMoved:touches3 withEvent:event3]);
2129 NSSet* touches4 = [NSSet setWithObject:@1];
2130 id event4 = OCMClassMock([UIEvent
class]);
2131 [forwardGectureRecognizer touchesEnded:touches4 withEvent:event4];
2132 OCMVerify([mockFlutterViewContoller touchesEnded:touches4 withEvent:event4]);
2133 OCMReject([mockFlutterViewContoller2 touchesEnded:touches4 withEvent:event4]);
2135 NSSet* touches5 = [NSSet setWithObject:@1];
2136 id event5 = OCMClassMock([UIEvent
class]);
2137 [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2138 OCMVerify([mockFlutterViewContoller touchesEnded:touches5 withEvent:event5]);
2139 OCMReject([mockFlutterViewContoller2 touchesEnded:touches5 withEvent:event5]);
2143 NSSet* touches6 = [NSSet setWithObject:@1];
2144 id event6 = OCMClassMock([UIEvent
class]);
2145 [forwardGectureRecognizer touchesBegan:touches6 withEvent:event6];
2146 OCMVerify([mockFlutterViewContoller2 touchesBegan:touches6 withEvent:event6]);
2147 OCMReject([mockFlutterViewContoller touchesBegan:touches6 withEvent:event6]);
2150 NSSet* touches7 = [NSSet setWithObject:@1];
2151 id event7 = OCMClassMock([UIEvent
class]);
2152 [forwardGectureRecognizer touchesMoved:touches7 withEvent:event7];
2153 OCMVerify([mockFlutterViewContoller2 touchesMoved:touches7 withEvent:event7]);
2154 OCMReject([mockFlutterViewContoller touchesMoved:touches7 withEvent:event7]);
2156 NSSet* touches8 = [NSSet setWithObject:@1];
2157 id event8 = OCMClassMock([UIEvent
class]);
2158 [forwardGectureRecognizer touchesEnded:touches8 withEvent:event8];
2159 OCMVerify([mockFlutterViewContoller2 touchesEnded:touches8 withEvent:event8]);
2160 OCMReject([mockFlutterViewContoller touchesEnded:touches8 withEvent:event8]);
2162 flutterPlatformViewsController->Reset();
2165 - (void)testFlutterPlatformViewTouchesCancelledEventAreForcedToBeCancelled {
2166 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2167 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2168 flutter::TaskRunners runners(
self.name.UTF8String,
2172 thread_task_runner);
2173 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2174 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2177 flutterPlatformViewsController,
2184 flutterPlatformViewsController->RegisterViewFactory(
2185 factory,
@"MockFlutterPlatformView",
2189 flutterPlatformViewsController->OnMethodCall(
2191 methodCallWithMethodName:
@"create"
2192 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2199 while (touchInteceptorView != nil &&
2201 touchInteceptorView = touchInteceptorView.superview;
2203 XCTAssertNotNil(touchInteceptorView);
2206 UIGestureRecognizer* forwardGectureRecognizer = nil;
2207 for (UIGestureRecognizer* gestureRecognizer in touchInteceptorView.gestureRecognizers) {
2208 if ([gestureRecognizer isKindOfClass:NSClassFromString(
@"ForwardingGestureRecognizer")]) {
2209 forwardGectureRecognizer = gestureRecognizer;
2215 flutterPlatformViewsController->SetFlutterViewController(mockFlutterViewContoller);
2217 NSSet* touches1 = [NSSet setWithObject:@1];
2218 id event1 = OCMClassMock([UIEvent
class]);
2219 [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2221 [forwardGectureRecognizer touchesCancelled:touches1 withEvent:event1];
2222 OCMVerify([mockFlutterViewContoller forceTouchesCancelled:touches1]);
2224 flutterPlatformViewsController->Reset();
2227 - (void)testFlutterPlatformViewControllerSubmitFrameWithoutFlutterViewNotCrashing {
2228 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2229 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2230 flutter::TaskRunners runners(
self.name.UTF8String,
2234 thread_task_runner);
2235 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2236 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2239 flutterPlatformViewsController,
2246 flutterPlatformViewsController->RegisterViewFactory(
2247 factory,
@"MockFlutterPlatformView",
2251 flutterPlatformViewsController->OnMethodCall(
2253 methodCallWithMethodName:
@"create"
2254 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2260 flutter::MutatorsStack stack;
2261 SkMatrix finalMatrix;
2263 auto embeddedViewParams_1 =
2264 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2266 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams_1));
2267 flutterPlatformViewsController->CompositeEmbeddedView(2);
2268 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
2269 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
2270 nullptr, framebuffer_info,
2271 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return false; },
2272 SkISize::Make(800, 600));
2274 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2276 auto embeddedViewParams_2 =
2277 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2278 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams_2));
2279 flutterPlatformViewsController->CompositeEmbeddedView(2);
2280 auto mock_surface_submit_true = std::make_unique<flutter::SurfaceFrame>(
2281 nullptr, framebuffer_info,
2282 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2283 SkISize::Make(800, 600));
2284 XCTAssertTrue(flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr,
2285 std::move(mock_surface_submit_true)));
2289 testFlutterPlatformViewControllerResetDeallocsPlatformViewWhenRootViewsNotBindedToFlutterView {
2290 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2291 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2292 flutter::TaskRunners runners(
self.name.UTF8String,
2296 thread_task_runner);
2297 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2298 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2301 flutterPlatformViewsController,
2306 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
2307 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2311 flutterPlatformViewsController->RegisterViewFactory(
2312 factory,
@"MockFlutterPlatformView",
2318 flutterPlatformViewsController->OnMethodCall(
2320 methodCallWithMethodName:
@"create"
2321 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2324 flutter::MutatorsStack stack;
2325 SkMatrix finalMatrix;
2326 auto embeddedViewParams =
2327 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2328 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
2329 flutterPlatformViewsController->CompositeEmbeddedView(2);
2334 flutterPlatformViewsController->Reset();
2339 - (void)testFlutterPlatformViewControllerBeginFrameShouldResetCompisitionOrder {
2340 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2341 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2342 flutter::TaskRunners runners(
self.name.UTF8String,
2346 thread_task_runner);
2347 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2348 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2351 flutterPlatformViewsController,
2356 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
2357 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2361 flutterPlatformViewsController->RegisterViewFactory(
2362 factory,
@"MockFlutterPlatformView",
2367 flutterPlatformViewsController->OnMethodCall(
2369 methodCallWithMethodName:
@"create"
2370 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
2374 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2375 flutter::MutatorsStack stack;
2376 SkMatrix finalMatrix;
2377 auto embeddedViewParams1 =
2378 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2379 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2380 flutterPlatformViewsController->CompositeEmbeddedView(0);
2381 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 1UL);
2384 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2385 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 0UL);
2387 auto embeddedViewParams2 =
2388 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2389 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams2));
2390 flutterPlatformViewsController->CompositeEmbeddedView(0);
2391 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 1UL);
2395 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithDifferentViewHierarchy {
2396 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2397 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2398 flutter::TaskRunners runners(
self.name.UTF8String,
2402 thread_task_runner);
2403 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2404 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2407 flutterPlatformViewsController,
2412 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
2413 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2417 flutterPlatformViewsController->RegisterViewFactory(
2418 factory,
@"MockFlutterPlatformView",
2422 flutterPlatformViewsController->OnMethodCall(
2424 methodCallWithMethodName:
@"create"
2425 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
2430 flutterPlatformViewsController->OnMethodCall(
2432 methodCallWithMethodName:
@"create"
2433 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2437 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2438 flutter::MutatorsStack stack;
2439 SkMatrix finalMatrix;
2440 auto embeddedViewParams1 =
2441 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2442 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2443 flutterPlatformViewsController->CompositeEmbeddedView(0);
2444 auto embeddedViewParams2 =
2445 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2446 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2447 flutterPlatformViewsController->CompositeEmbeddedView(1);
2450 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
2451 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
2452 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
2453 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
2454 std::move(mock_sk_surface), framebuffer_info,
2455 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2456 SkISize::Make(800, 600));
2459 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2461 UIView* clippingView1 = view1.superview.superview;
2462 UIView* clippingView2 = view2.superview.superview;
2463 UIView* flutterView = clippingView1.superview;
2464 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
2465 [flutterView.subviews indexOfObject:clippingView2],
2466 @"The first clipping view should be added before the second clipping view.");
2469 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2471 embeddedViewParams2 =
2472 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2473 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2474 flutterPlatformViewsController->CompositeEmbeddedView(1);
2475 embeddedViewParams1 =
2476 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2477 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2478 flutterPlatformViewsController->CompositeEmbeddedView(0);
2480 mock_sk_surface = SkSurfaces::Raster(image_info);
2481 mock_surface = std::make_unique<flutter::SurfaceFrame>(
2482 std::move(mock_sk_surface), framebuffer_info,
2483 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2484 SkISize::Make(800, 600));
2486 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2487 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] >
2488 [flutterView.subviews indexOfObject:clippingView2],
2489 @"The first clipping view should be added after the second clipping view.");
2493 testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithSameViewHierarchy {
2494 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2495 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2496 flutter::TaskRunners runners(
self.name.UTF8String,
2500 thread_task_runner);
2501 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2502 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2505 flutterPlatformViewsController,
2510 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
2511 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2515 flutterPlatformViewsController->RegisterViewFactory(
2516 factory,
@"MockFlutterPlatformView",
2520 flutterPlatformViewsController->OnMethodCall(
2522 methodCallWithMethodName:
@"create"
2523 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
2528 flutterPlatformViewsController->OnMethodCall(
2530 methodCallWithMethodName:
@"create"
2531 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2535 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2536 flutter::MutatorsStack stack;
2537 SkMatrix finalMatrix;
2538 auto embeddedViewParams1 =
2539 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2540 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2541 flutterPlatformViewsController->CompositeEmbeddedView(0);
2542 auto embeddedViewParams2 =
2543 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2544 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2545 flutterPlatformViewsController->CompositeEmbeddedView(1);
2548 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
2549 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
2550 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
2551 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
2552 std::move(mock_sk_surface), framebuffer_info,
2553 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2554 SkISize::Make(800, 600));
2557 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2559 UIView* clippingView1 = view1.superview.superview;
2560 UIView* clippingView2 = view2.superview.superview;
2561 UIView* flutterView = clippingView1.superview;
2562 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
2563 [flutterView.subviews indexOfObject:clippingView2],
2564 @"The first clipping view should be added before the second clipping view.");
2567 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2569 embeddedViewParams1 =
2570 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2571 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams1));
2572 flutterPlatformViewsController->CompositeEmbeddedView(0);
2573 embeddedViewParams2 =
2574 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(500, 500), stack);
2575 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams2));
2576 flutterPlatformViewsController->CompositeEmbeddedView(1);
2578 mock_sk_surface = SkSurfaces::Raster(image_info);
2579 mock_surface = std::make_unique<flutter::SurfaceFrame>(
2580 std::move(mock_sk_surface), framebuffer_info,
2581 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2582 SkISize::Make(800, 600));
2584 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
2585 XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
2586 [flutterView.subviews indexOfObject:clippingView2],
2587 @"The first clipping view should be added before the second clipping view.");
2590 - (void)testThreadMergeAtEndFrame {
2591 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2592 auto thread_task_runner_platform =
CreateNewThread(
"FlutterPlatformViewsTest1");
2593 auto thread_task_runner_other =
CreateNewThread(
"FlutterPlatformViewsTest2");
2594 flutter::TaskRunners runners(
self.name.UTF8String,
2595 thread_task_runner_platform,
2596 thread_task_runner_other,
2597 thread_task_runner_other,
2598 thread_task_runner_other);
2599 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2600 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2603 flutterPlatformViewsController,
2608 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
2609 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2613 flutterPlatformViewsController->RegisterViewFactory(
2614 factory,
@"MockFlutterPlatformView",
2616 XCTestExpectation* waitForPlatformView =
2617 [
self expectationWithDescription:@"wait for platform view to be created"];
2619 [waitForPlatformView fulfill];
2622 flutterPlatformViewsController->OnMethodCall(
2624 methodCallWithMethodName:
@"create"
2625 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2627 [
self waitForExpectations:@[ waitForPlatformView ] timeout:30];
2630 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2631 SkMatrix finalMatrix;
2632 flutter::MutatorsStack stack;
2633 auto embeddedViewParams =
2634 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2635 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
2637 fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger =
2638 fml::MakeRefCounted<fml::RasterThreadMerger>(thread_task_runner_platform->GetTaskQueueId(),
2639 thread_task_runner_other->GetTaskQueueId());
2640 XCTAssertEqual(flutterPlatformViewsController->PostPrerollAction(raster_thread_merger),
2641 flutter::PostPrerollResult::kSkipAndRetryFrame);
2642 XCTAssertFalse(raster_thread_merger->IsMerged());
2644 flutterPlatformViewsController->EndFrame(
true, raster_thread_merger);
2645 XCTAssertTrue(raster_thread_merger->IsMerged());
2649 while (raster_thread_merger->DecrementLease() != fml::RasterThreadStatus::kUnmergedNow) {
2653 - (int)alphaOfPoint:(CGPoint)point onView:(UIView*)view {
2654 unsigned char pixel[4] = {0};
2656 CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
2659 CGContextRef context = CGBitmapContextCreate(
2660 pixel, 1, 1, 8, 4, colorSpace, kCGBitmapAlphaInfoMask & kCGImageAlphaPremultipliedLast);
2661 CGContextTranslateCTM(context, -point.x, -point.y);
2662 [view.layer renderInContext:context];
2664 CGContextRelease(context);
2665 CGColorSpaceRelease(colorSpace);
2670 - (void)testHasFirstResponderInViewHierarchySubtree_viewItselfBecomesFirstResponder {
2672 UIWindow* window = [[[UIWindow alloc] init] autorelease];
2673 UITextField* textField = [[[UITextField alloc] init] autorelease];
2674 [window addSubview:textField];
2676 [textField becomeFirstResponder];
2677 XCTAssertTrue(textField.isFirstResponder);
2678 XCTAssertTrue(textField.flt_hasFirstResponderInViewHierarchySubtree);
2679 [textField resignFirstResponder];
2680 XCTAssertFalse(textField.isFirstResponder);
2681 XCTAssertFalse(textField.flt_hasFirstResponderInViewHierarchySubtree);
2684 - (void)testHasFirstResponderInViewHierarchySubtree_descendantViewBecomesFirstResponder {
2686 UIWindow* window = [[[UIWindow alloc] init] autorelease];
2687 UIView* view = [[[UIView alloc] init] autorelease];
2688 UIView* childView = [[[UIView alloc] init] autorelease];
2689 UITextField* textField = [[[UITextField alloc] init] autorelease];
2690 [window addSubview:view];
2691 [view addSubview:childView];
2692 [childView addSubview:textField];
2694 [textField becomeFirstResponder];
2695 XCTAssertTrue(textField.isFirstResponder);
2696 XCTAssertTrue(view.flt_hasFirstResponderInViewHierarchySubtree);
2697 [textField resignFirstResponder];
2698 XCTAssertFalse(textField.isFirstResponder);
2699 XCTAssertFalse(view.flt_hasFirstResponderInViewHierarchySubtree);
2702 - (void)testFlutterClippingMaskViewPoolReuseViewsAfterRecycle {
2709 CGRect newRect = CGRectMake(0, 0, 10, 10);
2713 NSSet* set1 = [NSSet setWithObjects:view1, view2, nil];
2714 NSSet* set2 = [NSSet setWithObjects:view3, view4, nil];
2715 XCTAssertEqualObjects(set1, set2);
2716 XCTAssertTrue(CGRectEqualToRect(view3.frame, newRect));
2717 XCTAssertTrue(CGRectEqualToRect(view4.frame, newRect));
2720 - (void)testFlutterClippingMaskViewPoolAllocsNewMaskViewsAfterReachingCapacity {
2726 XCTAssertNotEqual(view1, view3);
2727 XCTAssertNotEqual(view2, view3);
2730 - (void)testMaskViewsReleasedWhenPoolIsReleased {
2731 UIView* retainedView;
2736 retainedView = [view retain];
2737 XCTAssertGreaterThan(retainedView.retainCount, 1u);
2741 XCTAssertEqual(retainedView.retainCount, 1u);
2742 [retainedView release];
2745 - (void)testClipMaskViewIsReused {
2746 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2747 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2748 flutter::TaskRunners runners(
self.name.UTF8String,
2752 thread_task_runner);
2753 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2754 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2757 flutterPlatformViewsController,
2764 flutterPlatformViewsController->RegisterViewFactory(
2765 factory,
@"MockFlutterPlatformView",
2769 flutterPlatformViewsController->OnMethodCall(
2771 methodCallWithMethodName:
@"create"
2772 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2776 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
2777 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2779 flutter::MutatorsStack stack1;
2781 SkMatrix screenScaleMatrix =
2782 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2783 stack1.PushTransform(screenScaleMatrix);
2785 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
2786 stack1.PushClipRect(rect);
2788 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
2789 screenScaleMatrix, SkSize::Make(10, 10), stack1);
2791 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
2792 flutterPlatformViewsController->CompositeEmbeddedView(1);
2794 UIView* maskView1 = childClippingView1.maskView;
2795 XCTAssertNotNil(maskView1);
2798 flutterPlatformViewsController->BeginFrame(SkISize::Make(100, 100));
2799 flutter::MutatorsStack stack2;
2800 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
2801 screenScaleMatrix, SkSize::Make(10, 10), stack2);
2802 auto embeddedViewParams3 = std::make_unique<flutter::EmbeddedViewParams>(
2803 screenScaleMatrix, SkSize::Make(10, 10), stack2);
2804 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams3));
2805 flutterPlatformViewsController->CompositeEmbeddedView(1);
2809 flutterPlatformViewsController->OnMethodCall(
2811 methodCallWithMethodName:
@"create"
2812 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2815 auto embeddedViewParams4 = std::make_unique<flutter::EmbeddedViewParams>(
2816 screenScaleMatrix, SkSize::Make(10, 10), stack1);
2817 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams4));
2818 flutterPlatformViewsController->CompositeEmbeddedView(2);
2821 UIView* maskView2 = childClippingView2.maskView;
2822 XCTAssertEqual(maskView1, maskView2);
2823 XCTAssertNotNil(childClippingView2.maskView);
2824 XCTAssertNil(childClippingView1.maskView);
2827 - (void)testDifferentClipMaskViewIsUsedForEachView {
2828 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2829 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2830 flutter::TaskRunners runners(
self.name.UTF8String,
2834 thread_task_runner);
2835 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2836 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2839 flutterPlatformViewsController,
2846 flutterPlatformViewsController->RegisterViewFactory(
2847 factory,
@"MockFlutterPlatformView",
2852 flutterPlatformViewsController->OnMethodCall(
2854 methodCallWithMethodName:
@"create"
2855 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2860 flutterPlatformViewsController->OnMethodCall(
2862 methodCallWithMethodName:
@"create"
2863 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
2868 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)] autorelease];
2869 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2871 flutter::MutatorsStack stack1;
2873 SkMatrix screenScaleMatrix =
2874 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
2875 stack1.PushTransform(screenScaleMatrix);
2877 SkRect rect = SkRect::MakeXYWH(2, 2, 3, 3);
2878 stack1.PushClipRect(rect);
2880 auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
2881 screenScaleMatrix, SkSize::Make(10, 10), stack1);
2883 flutter::MutatorsStack stack2;
2884 stack2.PushClipRect(rect);
2885 auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
2886 screenScaleMatrix, SkSize::Make(10, 10), stack2);
2888 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
2889 flutterPlatformViewsController->CompositeEmbeddedView(1);
2890 UIView* childClippingView1 = view1.superview.superview;
2892 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams2));
2893 flutterPlatformViewsController->CompositeEmbeddedView(2);
2894 UIView* childClippingView2 = view2.superview.superview;
2895 UIView* maskView1 = childClippingView1.maskView;
2896 UIView* maskView2 = childClippingView2.maskView;
2897 XCTAssertNotEqual(maskView1, maskView2);
2905 - (BOOL)validateOneVisualEffectView:(UIView*)visualEffectView
2906 expectedFrame:(CGRect)frame
2907 inputRadius:(CGFloat)inputRadius {
2908 XCTAssertTrue(CGRectEqualToRect(visualEffectView.frame, frame));
2909 for (UIView* view in visualEffectView.subviews) {
2910 if (![NSStringFromClass([view
class]) hasSuffix:
@"BackdropView"]) {
2913 XCTAssertEqual(view.layer.filters.count, 1u);
2914 NSObject* filter = view.layer.filters.firstObject;
2916 XCTAssertEqualObjects([filter valueForKey:
@"name"],
@"gaussianBlur");
2918 NSObject* inputRadiusInFilter = [filter valueForKey:@"inputRadius"];
2919 XCTAssertTrue([inputRadiusInFilter isKindOfClass:[NSNumber
class]] &&
2927 - (void)testDisposingViewInCompositionOrderDoNotCrash {
2928 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2929 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
2930 flutter::TaskRunners runners(
self.name.UTF8String,
2934 thread_task_runner);
2935 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
2936 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2939 flutterPlatformViewsController,
2944 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
2945 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
2949 flutterPlatformViewsController->RegisterViewFactory(
2950 factory,
@"MockFlutterPlatformView",
2955 flutterPlatformViewsController->OnMethodCall(
2957 methodCallWithMethodName:
@"create"
2958 arguments:@{
@"id" : @0,
@"viewType" :
@"MockFlutterPlatformView"}],
2960 flutterPlatformViewsController->OnMethodCall(
2962 methodCallWithMethodName:
@"create"
2963 arguments:@{
@"id" : @1,
@"viewType" :
@"MockFlutterPlatformView"}],
2969 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
2970 flutter::MutatorsStack stack;
2971 SkMatrix finalMatrix;
2972 auto embeddedViewParams0 =
2973 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2974 flutterPlatformViewsController->PrerollCompositeEmbeddedView(0, std::move(embeddedViewParams0));
2975 flutterPlatformViewsController->CompositeEmbeddedView(0);
2977 auto embeddedViewParams1 =
2978 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
2979 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
2980 flutterPlatformViewsController->CompositeEmbeddedView(1);
2981 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 2UL);
2983 XCTestExpectation* expectation = [
self expectationWithDescription:@"dispose call ended."];
2985 [expectation fulfill];
2988 flutterPlatformViewsController->OnMethodCall(
2989 [
FlutterMethodCall methodCallWithMethodName:
@"dispose" arguments:@0], disposeResult);
2990 [
self waitForExpectationsWithTimeout:30 handler:nil];
2992 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
2993 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
2994 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
2995 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
2996 std::move(mock_sk_surface), framebuffer_info,
2997 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
2998 SkISize::Make(800, 600));
3000 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
3003 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 2UL);
3004 XCTAssertNotNil(flutterPlatformViewsController->GetPlatformViewByID(0));
3005 XCTAssertNotNil(flutterPlatformViewsController->GetPlatformViewByID(1));
3011 flutterPlatformViewsController->BeginFrame(SkISize::Make(300, 300));
3012 flutter::MutatorsStack stack;
3013 SkMatrix finalMatrix;
3014 auto embeddedViewParams1 =
3015 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3016 flutterPlatformViewsController->PrerollCompositeEmbeddedView(1, std::move(embeddedViewParams1));
3017 flutterPlatformViewsController->CompositeEmbeddedView(1);
3019 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
3020 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
3021 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3022 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3023 std::move(mock_sk_surface), framebuffer_info,
3024 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3025 SkISize::Make(800, 600));
3027 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface)));
3030 XCTAssertEqual(flutterPlatformViewsController->EmbeddedViewCount(), 1UL);
3031 XCTAssertNil(flutterPlatformViewsController->GetPlatformViewByID(0));
3032 XCTAssertNotNil(flutterPlatformViewsController->GetPlatformViewByID(1));
3035 - (void)testOnlyPlatformViewsAreRemovedWhenReset {
3036 flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3037 auto thread_task_runner =
CreateNewThread(
"FlutterPlatformViewsTest");
3038 flutter::TaskRunners runners(
self.name.UTF8String,
3042 thread_task_runner);
3043 auto flutterPlatformViewsController = std::make_shared<flutter::FlutterPlatformViewsController>();
3044 auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3047 flutterPlatformViewsController,
3054 flutterPlatformViewsController->RegisterViewFactory(
3055 factory,
@"MockFlutterPlatformView",
3059 flutterPlatformViewsController->OnMethodCall(
3061 methodCallWithMethodName:
@"create"
3062 arguments:@{
@"id" : @2,
@"viewType" :
@"MockFlutterPlatformView"}],
3064 UIView* mockFlutterView = [[[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)] autorelease];
3065 flutterPlatformViewsController->SetFlutterView(mockFlutterView);
3067 flutter::MutatorsStack stack;
3069 SkMatrix screenScaleMatrix =
3070 SkMatrix::Scale([UIScreen mainScreen].scale, [UIScreen mainScreen].scale);
3071 stack.PushTransform(screenScaleMatrix);
3073 SkMatrix translateMatrix = SkMatrix::Translate(100, 100);
3074 stack.PushTransform(translateMatrix);
3075 SkMatrix finalMatrix;
3076 finalMatrix.setConcat(screenScaleMatrix, translateMatrix);
3078 auto embeddedViewParams =
3079 std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, SkSize::Make(300, 300), stack);
3081 flutterPlatformViewsController->PrerollCompositeEmbeddedView(2, std::move(embeddedViewParams));
3082 flutterPlatformViewsController->CompositeEmbeddedView(2);
3085 const SkImageInfo image_info = SkImageInfo::MakeN32Premul(1000, 1000);
3086 sk_sp<SkSurface> mock_sk_surface = SkSurfaces::Raster(image_info);
3087 flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
3088 auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
3089 std::move(mock_sk_surface), framebuffer_info,
3090 [](
const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) {
return true; },
3091 SkISize::Make(800, 600));
3093 flutterPlatformViewsController->SubmitFrame(
nullptr,
nullptr, std::move(mock_surface));
3095 UIView* someView = [[[UIView alloc] init] autorelease];
3096 [mockFlutterView addSubview:someView];
3098 flutterPlatformViewsController->Reset();
3099 XCTAssertEqual(mockFlutterView.subviews.count, 1u);
3100 XCTAssertEqual(mockFlutterView.subviews.firstObject, someView);
3103 - (void)testFlutterTouchInterceptingViewLinksToAccessibilityContainer {
3106 NSObject* container = [[[NSObject alloc] init] autorelease];
3108 XCTAssertEqualObjects([touchInteceptorView accessibilityContainer], container);