Flutter iOS Embedder
FlutterPlatformViewsTest.mm
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "display_list/geometry/dl_geometry_types.h"
7 
8 #import <OCMock/OCMock.h>
9 #import <UIKit/UIKit.h>
10 #import <WebKit/WebKit.h>
11 #import <XCTest/XCTest.h>
12 
13 #include <memory>
14 
15 #include "flutter/display_list/effects/dl_image_filters.h"
16 #include "flutter/fml/synchronization/count_down_latch.h"
17 #include "flutter/fml/thread.h"
31 
33 
34 namespace {
35 // An IOSContext fake for tests that do not need a real GPU context.
37  public:
38  FakeIOSContext() = default;
39  ~FakeIOSContext() override = default;
40 
41  // |IOSContext|
42  std::unique_ptr<flutter::Texture> CreateExternalTexture(
43  int64_t texture_id,
44  NSObject<FlutterTexture>* texture) override {
45  return nullptr;
46  }
47 };
48 } // namespace
49 
51 __weak static UIView* gMockPlatformView = nil;
52 const float kFloatCompareEpsilon = 0.001;
53 
55 @end
57 
58 - (instancetype)init {
59  self = [super init];
60  if (self) {
61  gMockPlatformView = self;
62  }
63  return self;
64 }
65 
66 - (void)dealloc {
67  gMockPlatformView = nil;
68 }
69 
70 @end
71 
72 // A mock recognizer without "TouchEventsGestureRecognizer" suffix in class name.
73 // This is to verify a fix to a bug on iOS 26 where web view link is not tappable.
74 // We reset the web view's WKTouchEventsGestureRecognizer in a bad state
75 // by disabling and re-enabling it.
76 // See: https://github.com/flutter/flutter/issues/175099.
77 @interface MockGestureRecognizer : UIGestureRecognizer
78 @property(nonatomic, strong) NSMutableArray<NSNumber*>* toggleHistory;
79 @end
80 
81 @implementation MockGestureRecognizer
82 - (instancetype)init {
83  self = [super init];
84  if (self) {
85  _toggleHistory = [NSMutableArray array];
86  }
87  return self;
88 }
89 - (void)setEnabled:(BOOL)enabled {
90  [super setEnabled:enabled];
91  [self.toggleHistory addObject:@(enabled)];
92 }
93 @end
94 
95 // A mock recognizer with "TouchEventsGestureRecognizer" suffix in class name.
97 @end
98 
100 @end
101 
103 @property(nonatomic, strong) UIView* view;
104 @property(nonatomic, assign) BOOL viewCreated;
105 @end
106 
108 
109 - (instancetype)init {
110  if (self = [super init]) {
111  _view = [[FlutterPlatformViewsTestMockPlatformView alloc] init];
112  _viewCreated = NO;
113  }
114  return self;
115 }
116 
117 - (UIView*)view {
118  [self checkViewCreatedOnce];
119  return _view;
120 }
121 
122 - (void)checkViewCreatedOnce {
123  if (self.viewCreated) {
124  abort();
125  }
126  self.viewCreated = YES;
127 }
128 
129 - (void)dealloc {
130  gMockPlatformView = nil;
131 }
132 @end
133 
135  : NSObject <FlutterPlatformViewFactory>
136 @end
137 
139 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
140  viewIdentifier:(int64_t)viewId
141  arguments:(id _Nullable)args {
143 }
144 
145 @end
146 
148 @property(nonatomic, strong) UIView* view;
149 @property(nonatomic, assign) BOOL viewCreated;
150 @end
151 
153 - (instancetype)init {
154  if (self = [super init]) {
155  _view = [[WKWebView alloc] init];
156  gMockPlatformView = _view;
157  _viewCreated = NO;
158  }
159  return self;
160 }
161 
162 - (UIView*)view {
163  [self checkViewCreatedOnce];
164  return _view;
165 }
166 
167 - (void)checkViewCreatedOnce {
168  if (self.viewCreated) {
169  abort();
170  }
171  self.viewCreated = YES;
172 }
173 
174 - (void)dealloc {
175  gMockPlatformView = nil;
176 }
177 @end
178 
180 @end
181 
183 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
184  viewIdentifier:(int64_t)viewId
185  arguments:(id _Nullable)args {
186  return [[FlutterPlatformViewsTestMockWebView alloc] init];
187 }
188 @end
189 
191 @end
192 
194 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
195  viewIdentifier:(int64_t)viewId
196  arguments:(id _Nullable)args {
197  return nil;
198 }
199 
200 @end
201 
203 @property(nonatomic, strong) UIView* view;
204 @property(nonatomic, assign) BOOL viewCreated;
205 @end
206 
208 - (instancetype)init {
209  if (self = [super init]) {
210  _view = [[UIView alloc] init];
211  [_view addSubview:[[WKWebView alloc] init]];
212  gMockPlatformView = _view;
213  _viewCreated = NO;
214  }
215  return self;
216 }
217 
218 - (UIView*)view {
219  [self checkViewCreatedOnce];
220  return _view;
221 }
222 
223 - (void)checkViewCreatedOnce {
224  if (self.viewCreated) {
225  abort();
226  }
227  self.viewCreated = YES;
228 }
229 
230 - (void)dealloc {
231  gMockPlatformView = nil;
232 }
233 @end
234 
236 @end
237 
239 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
240  viewIdentifier:(int64_t)viewId
241  arguments:(id _Nullable)args {
242  return [[FlutterPlatformViewsTestMockWrapperWebView alloc] init];
243 }
244 @end
245 
247 @property(nonatomic, strong) UIView* view;
248 @property(nonatomic, assign) BOOL viewCreated;
249 @end
250 
252 - (instancetype)init {
253  if (self = [super init]) {
254  _view = [[UIView alloc] init];
255  UIView* childView = [[UIView alloc] init];
256  [_view addSubview:childView];
257  [childView addSubview:[[WKWebView alloc] init]];
258  gMockPlatformView = _view;
259  _viewCreated = NO;
260  }
261  return self;
262 }
263 
264 - (UIView*)view {
265  [self checkViewCreatedOnce];
266  return _view;
267 }
268 
269 - (void)checkViewCreatedOnce {
270  if (self.viewCreated) {
271  abort();
272  }
273  self.viewCreated = YES;
274 }
275 @end
276 
278  : NSObject <FlutterPlatformViewFactory>
279 @end
280 
282 - (NSObject<FlutterPlatformView>*)createWithFrame:(CGRect)frame
283  viewIdentifier:(int64_t)viewId
284  arguments:(id _Nullable)args {
286 }
287 @end
288 
289 namespace flutter {
290 namespace {
291 class FlutterPlatformViewsTestMockPlatformViewDelegate : public PlatformView::Delegate {
292  public:
293  void OnPlatformViewCreated(std::unique_ptr<Surface> surface) override {}
294  void OnPlatformViewDestroyed() override {}
295  void OnPlatformViewScheduleFrame() override {}
296  void OnPlatformViewAddView(int64_t view_id,
297  const ViewportMetrics& viewport_metrics,
298  AddViewCallback callback) override {}
299  void OnPlatformViewRemoveView(int64_t view_id, RemoveViewCallback callback) override {}
300  void OnPlatformViewSendViewFocusEvent(const ViewFocusEvent& event) override {};
301  void OnPlatformViewSetNextFrameCallback(const fml::closure& closure) override {}
302  void OnPlatformViewSetViewportMetrics(int64_t view_id, const ViewportMetrics& metrics) override {}
303  const flutter::Settings& OnPlatformViewGetSettings() const override { return settings_; }
304  void OnPlatformViewDispatchPlatformMessage(std::unique_ptr<PlatformMessage> message) override {}
305  void OnPlatformViewDispatchPointerDataPacket(std::unique_ptr<PointerDataPacket> packet) override {
306  }
307  HitTestResponse OnPlatformViewHitTest(int64_t view_id, const flutter::PointData offset) override {
308  return {.has_platform_view = false};
309  }
310  void OnPlatformViewDispatchSemanticsAction(int64_t view_id,
311  int32_t node_id,
312  SemanticsAction action,
313  fml::MallocMapping args) override {}
314  void OnPlatformViewSetSemanticsEnabled(bool enabled) override {}
315  void OnPlatformViewSetAccessibilityFeatures(int32_t flags) override {}
316  void OnPlatformViewRegisterTexture(std::shared_ptr<Texture> texture) override {}
317  void OnPlatformViewUnregisterTexture(int64_t texture_id) override {}
318  void OnPlatformViewMarkTextureFrameAvailable(int64_t texture_id) override {}
319 
320  void LoadDartDeferredLibrary(intptr_t loading_unit_id,
321  std::unique_ptr<const fml::Mapping> snapshot_data,
322  std::unique_ptr<const fml::Mapping> snapshot_instructions) override {
323  }
324  void LoadDartDeferredLibraryError(intptr_t loading_unit_id,
325  const std::string error_message,
326  bool transient) override {}
327  void UpdateAssetResolverByType(std::unique_ptr<flutter::AssetResolver> updated_asset_resolver,
328  flutter::AssetResolver::AssetResolverType type) override {}
329  std::shared_ptr<fml::BasicTaskRunner> OnPlatformViewGetShutdownSafeIOTaskRunner() const override {
330  return nullptr;
331  }
332 
333  flutter::Settings settings_;
334 };
335 
336 BOOL BlurRadiusEqualToBlurRadius(CGFloat radius1, CGFloat radius2) {
337  const CGFloat epsilon = 0.01;
338  return std::abs(radius1 - radius2) < epsilon;
339 }
340 
341 } // namespace
342 } // namespace flutter
343 
344 @interface FlutterPlatformViewsTest : XCTestCase
345 @end
346 
347 @implementation FlutterPlatformViewsTest
348 
349 namespace {
350 using namespace flutter::testing;
351 } // namespace
352 
353 // Walks up the superview chain from the given view and returns the first
354 // FlutterTouchInterceptingView found, or nil if none exists.
355 static FlutterTouchInterceptingView* FindTouchInterceptingView(UIView* view) {
356  while (view != nil && ![view isKindOfClass:[FlutterTouchInterceptingView class]]) {
357  view = view.superview;
358  }
359  return (FlutterTouchInterceptingView*)view;
360 }
361 
362 // Returns the first ForwardingGestureRecognizer attached to the given view,
363 // or nil if none exists.
364 static UIGestureRecognizer* FindForwardingGestureRecognizer(UIView* view) {
365  for (UIGestureRecognizer* gestureRecognizer in view.gestureRecognizers) {
366  if ([gestureRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]) {
367  return gestureRecognizer;
368  }
369  }
370  return nil;
371 }
372 
373 // Verifies that a create call whose viewType is not a string returns an error rather than raising.
374 // An omitted argument arrives as nil and an explicit Dart null as NSNull, and neither can be
375 // converted to the view type the factory lookup needs.
376 - (void)testCreateWithInvalidViewTypeReturnsError {
377  FlutterPlatformViewsController* flutterPlatformViewsController =
379 
380  NSArray<NSDictionary*>* invalidArguments = @[
381  @{@"id" : @2}, // 'viewType' omitted.
382  @{@"id" : @2, @"viewType" : [NSNull null]}, // 'viewType' explicitly null in Dart.
383  @{@"id" : @2, @"viewType" : @7}, // 'viewType' not a string.
384  ];
385 
386  for (NSDictionary* arguments in invalidArguments) {
387  __block BOOL errored = NO;
388  FlutterResult result = ^(id result) {
389  if ([result isKindOfClass:[FlutterError class]]) {
390  errored = YES;
391  }
392  };
393  [flutterPlatformViewsController
395  result:result];
396  XCTAssertTrue(errored, @"arguments: %@", arguments);
397  }
398 }
399 
400 - (void)testFlutterViewOnlyCreateOnceInOneFrame {
401  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
402 
403  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
404  FlutterPlatformViewsController* flutterPlatformViewsController =
406  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
407  /*delegate=*/mock_delegate,
408  /*platform_views_controller=*/flutterPlatformViewsController,
409  /*task_runners=*/runners.taskRunners,
410  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
411 
414  [flutterPlatformViewsController
415  registerViewFactory:factory
416  withId:@"MockFlutterPlatformView"
417  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
418  FlutterResult result = ^(id result) {
419  };
420  [flutterPlatformViewsController
422  arguments:@{
423  @"id" : @2,
424  @"viewType" : @"MockFlutterPlatformView",
425  @"gestureBlockingPolicy" : @"eager"
426  }]
427  result:result];
428  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
429  flutterPlatformViewsController.flutterView = flutterView;
430  // Create embedded view params
431  flutter::MutatorsStack stack;
432  // Layer tree always pushes a screen scale factor to the stack
433  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
434  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
435  stack.PushTransform(screenScaleMatrix);
436  // Push a translate matrix
437  flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
438  stack.PushTransform(translateMatrix);
439  flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
440 
441  auto embeddedViewParams =
442  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
443 
444  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
445  withParams:std::move(embeddedViewParams)];
446 
447  XCTAssertNotNil(gMockPlatformView);
448 
449  [flutterPlatformViewsController reset];
450 }
451 
452 - (void)testCanCreatePlatformViewWithoutFlutterView {
453  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
454 
455  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
456  FlutterPlatformViewsController* flutterPlatformViewsController =
458  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
459  /*delegate=*/mock_delegate,
460  /*platform_views_controller=*/flutterPlatformViewsController,
461  /*task_runners=*/runners.taskRunners,
462  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
463 
466  [flutterPlatformViewsController
467  registerViewFactory:factory
468  withId:@"MockFlutterPlatformView"
469  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
470  FlutterResult result = ^(id result) {
471  };
472  [flutterPlatformViewsController
474  arguments:@{
475  @"id" : @2,
476  @"viewType" : @"MockFlutterPlatformView",
477  @"gestureBlockingPolicy" : @"eager"
478  }]
479  result:result];
480 
481  XCTAssertNotNil(gMockPlatformView);
482 }
483 
484 - (void)testChildClippingViewHitTests {
485  ChildClippingView* childClippingView =
486  [[ChildClippingView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
487  UIView* childView = [[UIView alloc] initWithFrame:CGRectMake(100, 100, 100, 100)];
488  [childClippingView addSubview:childView];
489 
490  XCTAssertFalse([childClippingView pointInside:CGPointMake(50, 50) withEvent:nil]);
491  XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 100) withEvent:nil]);
492  XCTAssertFalse([childClippingView pointInside:CGPointMake(100, 99) withEvent:nil]);
493  XCTAssertFalse([childClippingView pointInside:CGPointMake(201, 200) withEvent:nil]);
494  XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 201) withEvent:nil]);
495  XCTAssertFalse([childClippingView pointInside:CGPointMake(99, 200) withEvent:nil]);
496  XCTAssertFalse([childClippingView pointInside:CGPointMake(200, 299) withEvent:nil]);
497 
498  XCTAssertTrue([childClippingView pointInside:CGPointMake(150, 150) withEvent:nil]);
499  XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 100) withEvent:nil]);
500  XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 100) withEvent:nil]);
501  XCTAssertTrue([childClippingView pointInside:CGPointMake(100, 199) withEvent:nil]);
502  XCTAssertTrue([childClippingView pointInside:CGPointMake(199, 199) withEvent:nil]);
503 }
504 
505 - (void)testReleasesBackdropFilterSubviewsOnChildClippingViewDealloc {
506  __weak NSMutableArray<UIVisualEffectView*>* weakBackdropFilterSubviews = nil;
507  __weak UIVisualEffectView* weakVisualEffectView1 = nil;
508  __weak UIVisualEffectView* weakVisualEffectView2 = nil;
509 
510  @autoreleasepool {
511  ChildClippingView* clippingView = [[ChildClippingView alloc] initWithFrame:CGRectZero];
512  UIVisualEffectView* visualEffectView1 = [[UIVisualEffectView alloc]
513  initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
514  weakVisualEffectView1 = visualEffectView1;
515  PlatformViewFilter* platformViewFilter1 =
516  [[PlatformViewFilter alloc] initWithFrame:CGRectMake(0, 0, 10, 10)
517  blurRadius:5
518  cornerRadius:0
519  isRoundedSuperellipse:NO
520  visualEffectView:visualEffectView1];
521 
522  [clippingView applyBlurBackdropFilters:@[ platformViewFilter1 ]];
523 
524  // Replace the blur filter to validate the original and new UIVisualEffectView are released.
525  UIVisualEffectView* visualEffectView2 = [[UIVisualEffectView alloc]
526  initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleDark]];
527  weakVisualEffectView2 = visualEffectView2;
528  PlatformViewFilter* platformViewFilter2 =
529  [[PlatformViewFilter alloc] initWithFrame:CGRectMake(0, 0, 10, 10)
530  blurRadius:5
531  cornerRadius:0
532  isRoundedSuperellipse:NO
533  visualEffectView:visualEffectView2];
534  [clippingView applyBlurBackdropFilters:@[ platformViewFilter2 ]];
535 
536  weakBackdropFilterSubviews = clippingView.backdropFilterSubviews;
537  XCTAssertNotNil(weakBackdropFilterSubviews);
538  clippingView = nil;
539  }
540  XCTAssertNil(weakBackdropFilterSubviews);
541  XCTAssertNil(weakVisualEffectView1);
542  XCTAssertNil(weakVisualEffectView2);
543 }
544 
545 - (void)testApplyBackdropFilter {
546  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
547 
548  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
549  FlutterPlatformViewsController* flutterPlatformViewsController =
551  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
552  /*delegate=*/mock_delegate,
553  /*platform_views_controller=*/flutterPlatformViewsController,
554  /*task_runners=*/runners.taskRunners,
555  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
556 
559  [flutterPlatformViewsController
560  registerViewFactory:factory
561  withId:@"MockFlutterPlatformView"
562  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
563  FlutterResult result = ^(id result) {
564  };
565  [flutterPlatformViewsController
567  arguments:@{
568  @"id" : @2,
569  @"viewType" : @"MockFlutterPlatformView",
570  @"gestureBlockingPolicy" : @"eager"
571  }]
572  result:result];
573 
574  XCTAssertNotNil(gMockPlatformView);
575 
576  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
577  flutterPlatformViewsController.flutterView = flutterView;
578  // Create embedded view params
579  flutter::MutatorsStack stack;
580  // Layer tree always pushes a screen scale factor to the stack
581  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
582  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
583  stack.PushTransform(screenScaleMatrix);
584  // Push a backdrop filter
585  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
586  stack.PushBackdropFilter(filter,
587  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
588 
589  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
590  screenScaleMatrix, flutter::DlSize(10, 10), stack);
591 
592  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
593  withParams:std::move(embeddedViewParams)];
594  [flutterPlatformViewsController
595  compositeView:2
596  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
597 
598  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
599  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
600  [flutterView addSubview:childClippingView];
601 
602  [flutterView setNeedsLayout];
603  [flutterView layoutIfNeeded];
604 
605  // childClippingView has visual effect view with the correct configurations.
606  NSUInteger numberOfExpectedVisualEffectView = 0;
607  for (UIView* subview in childClippingView.subviews) {
608  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
609  continue;
610  }
611  XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
612  if ([self validateOneVisualEffectView:subview
613  expectedFrame:CGRectMake(0, 0, 10, 10)
614  inputRadius:5]) {
615  numberOfExpectedVisualEffectView++;
616  }
617  }
618  XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
619 }
620 
621 - (void)testApplyBackdropFilterWithCorrectFrame {
622  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
623 
624  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
625  FlutterPlatformViewsController* flutterPlatformViewsController =
627  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
628  /*delegate=*/mock_delegate,
629  /*platform_views_controller=*/flutterPlatformViewsController,
630  /*task_runners=*/runners.taskRunners,
631  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
632 
635  [flutterPlatformViewsController
636  registerViewFactory:factory
637  withId:@"MockFlutterPlatformView"
638  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
639  FlutterResult result = ^(id result) {
640  };
641  [flutterPlatformViewsController
643  arguments:@{
644  @"id" : @2,
645  @"viewType" : @"MockFlutterPlatformView",
646  @"gestureBlockingPolicy" : @"eager"
647  }]
648  result:result];
649 
650  XCTAssertNotNil(gMockPlatformView);
651 
652  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
653  flutterPlatformViewsController.flutterView = flutterView;
654  // Create embedded view params
655  flutter::MutatorsStack stack;
656  // Layer tree always pushes a screen scale factor to the stack
657  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
658  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
659  stack.PushTransform(screenScaleMatrix);
660  // Push a backdrop filter
661  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
662  stack.PushBackdropFilter(filter,
663  flutter::DlRect::MakeXYWH(0, 0, screenScale * 8, screenScale * 8));
664 
665  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
666  screenScaleMatrix, flutter::DlSize(5, 10), stack);
667 
668  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
669  withParams:std::move(embeddedViewParams)];
670  [flutterPlatformViewsController
671  compositeView:2
672  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
673 
674  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
675  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
676  [flutterView addSubview:childClippingView];
677 
678  [flutterView setNeedsLayout];
679  [flutterView layoutIfNeeded];
680 
681  // childClippingView has visual effect view with the correct configurations.
682  NSUInteger numberOfExpectedVisualEffectView = 0;
683  for (UIView* subview in childClippingView.subviews) {
684  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
685  continue;
686  }
687  XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
688  if ([self validateOneVisualEffectView:subview
689  expectedFrame:CGRectMake(0, 0, 5, 8)
690  inputRadius:5]) {
691  numberOfExpectedVisualEffectView++;
692  }
693  }
694  XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
695 }
696 
697 - (void)testApplyMultipleBackdropFilters {
698  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
699 
700  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
701  FlutterPlatformViewsController* flutterPlatformViewsController =
703  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
704  /*delegate=*/mock_delegate,
705  /*platform_views_controller=*/flutterPlatformViewsController,
706  /*task_runners=*/runners.taskRunners,
707  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
708 
711  [flutterPlatformViewsController
712  registerViewFactory:factory
713  withId:@"MockFlutterPlatformView"
714  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
715  FlutterResult result = ^(id result) {
716  };
717  [flutterPlatformViewsController
719  arguments:@{
720  @"id" : @2,
721  @"viewType" : @"MockFlutterPlatformView",
722  @"gestureBlockingPolicy" : @"eager"
723  }]
724  result:result];
725 
726  XCTAssertNotNil(gMockPlatformView);
727 
728  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
729  flutterPlatformViewsController.flutterView = flutterView;
730  // Create embedded view params
731  flutter::MutatorsStack stack;
732  // Layer tree always pushes a screen scale factor to the stack
733  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
734  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
735  stack.PushTransform(screenScaleMatrix);
736  // Push backdrop filters
737  for (int i = 0; i < 50; i++) {
738  auto filter = flutter::DlBlurImageFilter::Make(i, 2, flutter::DlTileMode::kClamp);
739  stack.PushBackdropFilter(filter,
740  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
741  }
742 
743  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
744  screenScaleMatrix, flutter::DlSize(20, 20), stack);
745 
746  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
747  withParams:std::move(embeddedViewParams)];
748  [flutterPlatformViewsController
749  compositeView:2
750  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
751 
752  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
753  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
754  [flutterView addSubview:childClippingView];
755 
756  [flutterView setNeedsLayout];
757  [flutterView layoutIfNeeded];
758 
759  NSUInteger numberOfExpectedVisualEffectView = 0;
760  for (UIView* subview in childClippingView.subviews) {
761  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
762  continue;
763  }
764  XCTAssertLessThan(numberOfExpectedVisualEffectView, 50u);
765  if ([self validateOneVisualEffectView:subview
766  expectedFrame:CGRectMake(0, 0, 10, 10)
767  inputRadius:(CGFloat)numberOfExpectedVisualEffectView]) {
768  numberOfExpectedVisualEffectView++;
769  }
770  }
771  XCTAssertEqual(numberOfExpectedVisualEffectView, (NSUInteger)numberOfExpectedVisualEffectView);
772 }
773 
774 - (void)testAddBackdropFilters {
775  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
776 
777  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
778  FlutterPlatformViewsController* flutterPlatformViewsController =
779  [[FlutterPlatformViewsController alloc] init];
780  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
781  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
782  /*delegate=*/mock_delegate,
783  /*platform_views_controller=*/flutterPlatformViewsController,
784  /*task_runners=*/runners.taskRunners,
785  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
786 
789  [flutterPlatformViewsController
790  registerViewFactory:factory
791  withId:@"MockFlutterPlatformView"
792  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
793  FlutterResult result = ^(id result) {
794  };
795  [flutterPlatformViewsController
797  arguments:@{
798  @"id" : @2,
799  @"viewType" : @"MockFlutterPlatformView",
800  @"gestureBlockingPolicy" : @"eager"
801  }]
802  result:result];
803 
804  XCTAssertNotNil(gMockPlatformView);
805 
806  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
807  flutterPlatformViewsController.flutterView = flutterView;
808  // Create embedded view params
809  flutter::MutatorsStack stack;
810  // Layer tree always pushes a screen scale factor to the stack
811  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
812  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
813  stack.PushTransform(screenScaleMatrix);
814  // Push a backdrop filter
815  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
816  stack.PushBackdropFilter(filter,
817  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
818 
819  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
820  screenScaleMatrix, flutter::DlSize(10, 10), stack);
821 
822  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
823  withParams:std::move(embeddedViewParams)];
824  [flutterPlatformViewsController
825  compositeView:2
826  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
827 
828  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
829  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
830  [flutterView addSubview:childClippingView];
831 
832  [flutterView setNeedsLayout];
833  [flutterView layoutIfNeeded];
834 
835  NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
836  for (UIView* subview in childClippingView.subviews) {
837  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
838  continue;
839  }
840  XCTAssertLessThan(originalVisualEffectViews.count, 1u);
841  if ([self validateOneVisualEffectView:subview
842  expectedFrame:CGRectMake(0, 0, 10, 10)
843  inputRadius:(CGFloat)5]) {
844  [originalVisualEffectViews addObject:subview];
845  }
846  }
847  XCTAssertEqual(originalVisualEffectViews.count, 1u);
848 
849  //
850  // Simulate adding 1 backdrop filter (create a new mutators stack)
851  // Create embedded view params
852  flutter::MutatorsStack stack2;
853  // Layer tree always pushes a screen scale factor to the stack
854  stack2.PushTransform(screenScaleMatrix);
855  // Push backdrop filters
856  for (int i = 0; i < 2; i++) {
857  stack2.PushBackdropFilter(filter,
858  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
859  }
860 
861  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
862  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
863 
864  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
865  withParams:std::move(embeddedViewParams)];
866  [flutterPlatformViewsController
867  compositeView:2
868  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
869 
870  [flutterView setNeedsLayout];
871  [flutterView layoutIfNeeded];
872 
873  NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
874  for (UIView* subview in childClippingView.subviews) {
875  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
876  continue;
877  }
878  XCTAssertLessThan(newVisualEffectViews.count, 2u);
879 
880  if ([self validateOneVisualEffectView:subview
881  expectedFrame:CGRectMake(0, 0, 10, 10)
882  inputRadius:(CGFloat)5]) {
883  [newVisualEffectViews addObject:subview];
884  }
885  }
886  XCTAssertEqual(newVisualEffectViews.count, 2u);
887  for (NSUInteger i = 0; i < originalVisualEffectViews.count; i++) {
888  UIView* originalView = originalVisualEffectViews[i];
889  UIView* newView = newVisualEffectViews[i];
890  // Compare reference.
891  XCTAssertEqual(originalView, newView);
892  id mockOrignalView = OCMPartialMock(originalView);
893  OCMReject([mockOrignalView removeFromSuperview]);
894  [mockOrignalView stopMocking];
895  }
896 }
897 
898 - (void)testRemoveBackdropFilters {
899  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
900 
901  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
902  FlutterPlatformViewsController* flutterPlatformViewsController =
903  [[FlutterPlatformViewsController alloc] init];
904  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
905  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
906  /*delegate=*/mock_delegate,
907  /*platform_views_controller=*/flutterPlatformViewsController,
908  /*task_runners=*/runners.taskRunners,
909  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
910 
913  [flutterPlatformViewsController
914  registerViewFactory:factory
915  withId:@"MockFlutterPlatformView"
916  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
917  FlutterResult result = ^(id result) {
918  };
919  [flutterPlatformViewsController
921  arguments:@{
922  @"id" : @2,
923  @"viewType" : @"MockFlutterPlatformView",
924  @"gestureBlockingPolicy" : @"eager"
925  }]
926  result:result];
927 
928  XCTAssertNotNil(gMockPlatformView);
929 
930  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
931  flutterPlatformViewsController.flutterView = flutterView;
932  // Create embedded view params
933  flutter::MutatorsStack stack;
934  // Layer tree always pushes a screen scale factor to the stack
935  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
936  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
937  stack.PushTransform(screenScaleMatrix);
938  // Push backdrop filters
939  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
940  for (int i = 0; i < 5; i++) {
941  stack.PushBackdropFilter(filter,
942  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
943  }
944 
945  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
946  screenScaleMatrix, flutter::DlSize(10, 10), stack);
947 
948  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
949  withParams:std::move(embeddedViewParams)];
950  [flutterPlatformViewsController
951  compositeView:2
952  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
953 
954  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
955  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
956  [flutterView addSubview:childClippingView];
957 
958  [flutterView setNeedsLayout];
959  [flutterView layoutIfNeeded];
960 
961  NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
962  for (UIView* subview in childClippingView.subviews) {
963  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
964  continue;
965  }
966  XCTAssertLessThan(originalVisualEffectViews.count, 5u);
967  if ([self validateOneVisualEffectView:subview
968  expectedFrame:CGRectMake(0, 0, 10, 10)
969  inputRadius:(CGFloat)5]) {
970  [originalVisualEffectViews addObject:subview];
971  }
972  }
973 
974  // Simulate removing 1 backdrop filter (create a new mutators stack)
975  // Create embedded view params
976  flutter::MutatorsStack stack2;
977  // Layer tree always pushes a screen scale factor to the stack
978  stack2.PushTransform(screenScaleMatrix);
979  // Push backdrop filters
980  for (int i = 0; i < 4; i++) {
981  stack2.PushBackdropFilter(filter,
982  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
983  }
984 
985  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
986  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
987 
988  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
989  withParams:std::move(embeddedViewParams)];
990  [flutterPlatformViewsController
991  compositeView:2
992  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
993 
994  [flutterView setNeedsLayout];
995  [flutterView layoutIfNeeded];
996 
997  NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
998  for (UIView* subview in childClippingView.subviews) {
999  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1000  continue;
1001  }
1002  XCTAssertLessThan(newVisualEffectViews.count, 4u);
1003  if ([self validateOneVisualEffectView:subview
1004  expectedFrame:CGRectMake(0, 0, 10, 10)
1005  inputRadius:(CGFloat)5]) {
1006  [newVisualEffectViews addObject:subview];
1007  }
1008  }
1009  XCTAssertEqual(newVisualEffectViews.count, 4u);
1010 
1011  for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1012  UIView* newView = newVisualEffectViews[i];
1013  id mockNewView = OCMPartialMock(newView);
1014  UIView* originalView = originalVisualEffectViews[i];
1015  // Compare reference.
1016  XCTAssertEqual(originalView, newView);
1017  OCMReject([mockNewView removeFromSuperview]);
1018  [mockNewView stopMocking];
1019  }
1020 
1021  // Simulate removing all backdrop filters (replace the mutators stack)
1022  // Update embedded view params, delete except screenScaleMatrix
1023  for (int i = 0; i < 5; i++) {
1024  stack2.Pop();
1025  }
1026  // No backdrop filters in the stack, so no nothing to push
1027 
1028  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1029  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1030 
1031  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1032  withParams:std::move(embeddedViewParams)];
1033  [flutterPlatformViewsController
1034  compositeView:2
1035  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1036 
1037  [flutterView setNeedsLayout];
1038  [flutterView layoutIfNeeded];
1039 
1040  NSUInteger numberOfExpectedVisualEffectView = 0u;
1041  for (UIView* subview in childClippingView.subviews) {
1042  if ([subview isKindOfClass:[UIVisualEffectView class]]) {
1043  numberOfExpectedVisualEffectView++;
1044  }
1045  }
1046  XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1047 }
1048 
1049 - (void)testEditBackdropFilters {
1050  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1051 
1052  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
1053  FlutterPlatformViewsController* flutterPlatformViewsController =
1054  [[FlutterPlatformViewsController alloc] init];
1055  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
1056  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1057  /*delegate=*/mock_delegate,
1058  /*platform_views_controller=*/flutterPlatformViewsController,
1059  /*task_runners=*/runners.taskRunners,
1060  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
1061 
1064  [flutterPlatformViewsController
1065  registerViewFactory:factory
1066  withId:@"MockFlutterPlatformView"
1067  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
1068  FlutterResult result = ^(id result) {
1069  };
1070  [flutterPlatformViewsController
1072  arguments:@{
1073  @"id" : @2,
1074  @"viewType" : @"MockFlutterPlatformView",
1075  @"gestureBlockingPolicy" : @"eager"
1076  }]
1077  result:result];
1078 
1079  XCTAssertNotNil(gMockPlatformView);
1080 
1081  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1082  flutterPlatformViewsController.flutterView = flutterView;
1083  // Create embedded view params
1084  flutter::MutatorsStack stack;
1085  // Layer tree always pushes a screen scale factor to the stack
1086  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1087  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1088  stack.PushTransform(screenScaleMatrix);
1089  // Push backdrop filters
1090  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1091  for (int i = 0; i < 5; i++) {
1092  stack.PushBackdropFilter(filter,
1093  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1094  }
1095 
1096  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1097  screenScaleMatrix, flutter::DlSize(10, 10), stack);
1098 
1099  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1100  withParams:std::move(embeddedViewParams)];
1101  [flutterPlatformViewsController
1102  compositeView:2
1103  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1104 
1105  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
1106  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
1107  [flutterView addSubview:childClippingView];
1108 
1109  [flutterView setNeedsLayout];
1110  [flutterView layoutIfNeeded];
1111 
1112  NSMutableArray* originalVisualEffectViews = [[NSMutableArray alloc] init];
1113  for (UIView* subview in childClippingView.subviews) {
1114  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1115  continue;
1116  }
1117  XCTAssertLessThan(originalVisualEffectViews.count, 5u);
1118  if ([self validateOneVisualEffectView:subview
1119  expectedFrame:CGRectMake(0, 0, 10, 10)
1120  inputRadius:(CGFloat)5]) {
1121  [originalVisualEffectViews addObject:subview];
1122  }
1123  }
1124 
1125  // Simulate editing 1 backdrop filter in the middle of the stack (create a new mutators stack)
1126  // Create embedded view params
1127  flutter::MutatorsStack stack2;
1128  // Layer tree always pushes a screen scale factor to the stack
1129  stack2.PushTransform(screenScaleMatrix);
1130  // Push backdrop filters
1131  for (int i = 0; i < 5; i++) {
1132  if (i == 3) {
1133  auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1134 
1135  stack2.PushBackdropFilter(
1136  filter2, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1137  continue;
1138  }
1139 
1140  stack2.PushBackdropFilter(filter,
1141  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1142  }
1143 
1144  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1145  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1146 
1147  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1148  withParams:std::move(embeddedViewParams)];
1149  [flutterPlatformViewsController
1150  compositeView:2
1151  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1152 
1153  [flutterView setNeedsLayout];
1154  [flutterView layoutIfNeeded];
1155 
1156  NSMutableArray* newVisualEffectViews = [[NSMutableArray alloc] init];
1157  for (UIView* subview in childClippingView.subviews) {
1158  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1159  continue;
1160  }
1161  XCTAssertLessThan(newVisualEffectViews.count, 5u);
1162  CGFloat expectInputRadius = 5;
1163  if (newVisualEffectViews.count == 3) {
1164  expectInputRadius = 2;
1165  }
1166  if ([self validateOneVisualEffectView:subview
1167  expectedFrame:CGRectMake(0, 0, 10, 10)
1168  inputRadius:expectInputRadius]) {
1169  [newVisualEffectViews addObject:subview];
1170  }
1171  }
1172  XCTAssertEqual(newVisualEffectViews.count, 5u);
1173  for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1174  UIView* newView = newVisualEffectViews[i];
1175  id mockNewView = OCMPartialMock(newView);
1176  UIView* originalView = originalVisualEffectViews[i];
1177  // Compare reference.
1178  XCTAssertEqual(originalView, newView);
1179  OCMReject([mockNewView removeFromSuperview]);
1180  [mockNewView stopMocking];
1181  }
1182  [newVisualEffectViews removeAllObjects];
1183 
1184  // Simulate editing 1 backdrop filter in the beginning of the stack (replace the mutators stack)
1185  // Update embedded view params, delete except screenScaleMatrix
1186  for (int i = 0; i < 5; i++) {
1187  stack2.Pop();
1188  }
1189  // Push backdrop filters
1190  for (int i = 0; i < 5; i++) {
1191  if (i == 0) {
1192  auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1193  stack2.PushBackdropFilter(
1194  filter2, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1195  continue;
1196  }
1197 
1198  stack2.PushBackdropFilter(filter,
1199  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1200  }
1201 
1202  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1203  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1204 
1205  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1206  withParams:std::move(embeddedViewParams)];
1207  [flutterPlatformViewsController
1208  compositeView:2
1209  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1210 
1211  [flutterView setNeedsLayout];
1212  [flutterView layoutIfNeeded];
1213 
1214  for (UIView* subview in childClippingView.subviews) {
1215  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1216  continue;
1217  }
1218  XCTAssertLessThan(newVisualEffectViews.count, 5u);
1219  CGFloat expectInputRadius = 5;
1220  if (newVisualEffectViews.count == 0) {
1221  expectInputRadius = 2;
1222  }
1223  if ([self validateOneVisualEffectView:subview
1224  expectedFrame:CGRectMake(0, 0, 10, 10)
1225  inputRadius:expectInputRadius]) {
1226  [newVisualEffectViews addObject:subview];
1227  }
1228  }
1229  for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1230  UIView* newView = newVisualEffectViews[i];
1231  id mockNewView = OCMPartialMock(newView);
1232  UIView* originalView = originalVisualEffectViews[i];
1233  // Compare reference.
1234  XCTAssertEqual(originalView, newView);
1235  OCMReject([mockNewView removeFromSuperview]);
1236  [mockNewView stopMocking];
1237  }
1238  [newVisualEffectViews removeAllObjects];
1239 
1240  // Simulate editing 1 backdrop filter in the end of the stack (replace the mutators stack)
1241  // Update embedded view params, delete except screenScaleMatrix
1242  for (int i = 0; i < 5; i++) {
1243  stack2.Pop();
1244  }
1245  // Push backdrop filters
1246  for (int i = 0; i < 5; i++) {
1247  if (i == 4) {
1248  auto filter2 = flutter::DlBlurImageFilter::Make(2, 5, flutter::DlTileMode::kClamp);
1249  stack2.PushBackdropFilter(
1250  filter2, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1251  continue;
1252  }
1253 
1254  stack2.PushBackdropFilter(filter,
1255  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1256  }
1257 
1258  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1259  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1260 
1261  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1262  withParams:std::move(embeddedViewParams)];
1263  [flutterPlatformViewsController
1264  compositeView:2
1265  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1266 
1267  [flutterView setNeedsLayout];
1268  [flutterView layoutIfNeeded];
1269 
1270  for (UIView* subview in childClippingView.subviews) {
1271  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1272  continue;
1273  }
1274  XCTAssertLessThan(newVisualEffectViews.count, 5u);
1275  CGFloat expectInputRadius = 5;
1276  if (newVisualEffectViews.count == 4) {
1277  expectInputRadius = 2;
1278  }
1279  if ([self validateOneVisualEffectView:subview
1280  expectedFrame:CGRectMake(0, 0, 10, 10)
1281  inputRadius:expectInputRadius]) {
1282  [newVisualEffectViews addObject:subview];
1283  }
1284  }
1285  XCTAssertEqual(newVisualEffectViews.count, 5u);
1286 
1287  for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1288  UIView* newView = newVisualEffectViews[i];
1289  id mockNewView = OCMPartialMock(newView);
1290  UIView* originalView = originalVisualEffectViews[i];
1291  // Compare reference.
1292  XCTAssertEqual(originalView, newView);
1293  OCMReject([mockNewView removeFromSuperview]);
1294  [mockNewView stopMocking];
1295  }
1296  [newVisualEffectViews removeAllObjects];
1297 
1298  // Simulate editing all backdrop filters in the stack (replace the mutators stack)
1299  // Update embedded view params, delete except screenScaleMatrix
1300  for (int i = 0; i < 5; i++) {
1301  stack2.Pop();
1302  }
1303  // Push backdrop filters
1304  for (int i = 0; i < 5; i++) {
1305  auto filter2 = flutter::DlBlurImageFilter::Make(i, 2, flutter::DlTileMode::kClamp);
1306 
1307  stack2.PushBackdropFilter(filter2,
1308  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1309  }
1310 
1311  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1312  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1313 
1314  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1315  withParams:std::move(embeddedViewParams)];
1316  [flutterPlatformViewsController
1317  compositeView:2
1318  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1319 
1320  [flutterView setNeedsLayout];
1321  [flutterView layoutIfNeeded];
1322 
1323  for (UIView* subview in childClippingView.subviews) {
1324  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1325  continue;
1326  }
1327  XCTAssertLessThan(newVisualEffectViews.count, 5u);
1328  if ([self validateOneVisualEffectView:subview
1329  expectedFrame:CGRectMake(0, 0, 10, 10)
1330  inputRadius:(CGFloat)newVisualEffectViews.count]) {
1331  [newVisualEffectViews addObject:subview];
1332  }
1333  }
1334  XCTAssertEqual(newVisualEffectViews.count, 5u);
1335 
1336  for (NSUInteger i = 0; i < newVisualEffectViews.count; i++) {
1337  UIView* newView = newVisualEffectViews[i];
1338  id mockNewView = OCMPartialMock(newView);
1339  UIView* originalView = originalVisualEffectViews[i];
1340  // Compare reference.
1341  XCTAssertEqual(originalView, newView);
1342  OCMReject([mockNewView removeFromSuperview]);
1343  [mockNewView stopMocking];
1344  }
1345  [newVisualEffectViews removeAllObjects];
1346 }
1347 
1348 - (void)testApplyBackdropFilterNotDlBlurImageFilter {
1349  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1350 
1351  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
1352  FlutterPlatformViewsController* flutterPlatformViewsController =
1353  [[FlutterPlatformViewsController alloc] init];
1354  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
1355  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1356  /*delegate=*/mock_delegate,
1357  /*platform_views_controller=*/flutterPlatformViewsController,
1358  /*task_runners=*/runners.taskRunners,
1359  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
1360 
1363  [flutterPlatformViewsController
1364  registerViewFactory:factory
1365  withId:@"MockFlutterPlatformView"
1366  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
1367  FlutterResult result = ^(id result) {
1368  };
1369  [flutterPlatformViewsController
1371  arguments:@{
1372  @"id" : @2,
1373  @"viewType" : @"MockFlutterPlatformView",
1374  @"gestureBlockingPolicy" : @"eager"
1375  }]
1376  result:result];
1377 
1378  XCTAssertNotNil(gMockPlatformView);
1379 
1380  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1381  flutterPlatformViewsController.flutterView = flutterView;
1382  // Create embedded view params
1383  flutter::MutatorsStack stack;
1384  // Layer tree always pushes a screen scale factor to the stack
1385  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1386  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1387  stack.PushTransform(screenScaleMatrix);
1388  // Push a dilate backdrop filter
1389  auto dilateFilter = flutter::DlDilateImageFilter::Make(5, 2);
1390  stack.PushBackdropFilter(dilateFilter, flutter::DlRect());
1391 
1392  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1393  screenScaleMatrix, flutter::DlSize(10, 10), stack);
1394 
1395  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1396  withParams:std::move(embeddedViewParams)];
1397  [flutterPlatformViewsController
1398  compositeView:2
1399  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1400 
1401  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
1402  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
1403 
1404  [flutterView addSubview:childClippingView];
1405 
1406  [flutterView setNeedsLayout];
1407  [flutterView layoutIfNeeded];
1408 
1409  NSUInteger numberOfExpectedVisualEffectView = 0;
1410  for (UIView* subview in childClippingView.subviews) {
1411  if ([subview isKindOfClass:[UIVisualEffectView class]]) {
1412  numberOfExpectedVisualEffectView++;
1413  }
1414  }
1415  XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1416 
1417  // Simulate adding a non-DlBlurImageFilter in the middle of the stack (create a new mutators
1418  // stack) Create embedded view params
1419  flutter::MutatorsStack stack2;
1420  // Layer tree always pushes a screen scale factor to the stack
1421  stack2.PushTransform(screenScaleMatrix);
1422  // Push backdrop filters and dilate filter
1423  auto blurFilter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1424 
1425  for (int i = 0; i < 5; i++) {
1426  if (i == 2) {
1427  stack2.PushBackdropFilter(
1428  dilateFilter, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1429  continue;
1430  }
1431 
1432  stack2.PushBackdropFilter(blurFilter,
1433  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1434  }
1435 
1436  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1437  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1438 
1439  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1440  withParams:std::move(embeddedViewParams)];
1441  [flutterPlatformViewsController
1442  compositeView:2
1443  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1444 
1445  [flutterView setNeedsLayout];
1446  [flutterView layoutIfNeeded];
1447 
1448  numberOfExpectedVisualEffectView = 0;
1449  for (UIView* subview in childClippingView.subviews) {
1450  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1451  continue;
1452  }
1453  XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1454  if ([self validateOneVisualEffectView:subview
1455  expectedFrame:CGRectMake(0, 0, 10, 10)
1456  inputRadius:(CGFloat)5]) {
1457  numberOfExpectedVisualEffectView++;
1458  }
1459  }
1460  XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1461 
1462  // Simulate adding a non-DlBlurImageFilter to the beginning of the stack (replace the mutators
1463  // stack) Update embedded view params, delete except screenScaleMatrix
1464  for (int i = 0; i < 5; i++) {
1465  stack2.Pop();
1466  }
1467  // Push backdrop filters and dilate filter
1468  for (int i = 0; i < 5; i++) {
1469  if (i == 0) {
1470  stack2.PushBackdropFilter(
1471  dilateFilter, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1472  continue;
1473  }
1474 
1475  stack2.PushBackdropFilter(blurFilter,
1476  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1477  }
1478 
1479  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1480  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1481 
1482  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1483  withParams:std::move(embeddedViewParams)];
1484  [flutterPlatformViewsController
1485  compositeView:2
1486  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1487 
1488  [flutterView setNeedsLayout];
1489  [flutterView layoutIfNeeded];
1490 
1491  numberOfExpectedVisualEffectView = 0;
1492  for (UIView* subview in childClippingView.subviews) {
1493  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1494  continue;
1495  }
1496  XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1497  if ([self validateOneVisualEffectView:subview
1498  expectedFrame:CGRectMake(0, 0, 10, 10)
1499  inputRadius:(CGFloat)5]) {
1500  numberOfExpectedVisualEffectView++;
1501  }
1502  }
1503  XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1504 
1505  // Simulate adding a non-DlBlurImageFilter to the end of the stack (replace the mutators stack)
1506  // Update embedded view params, delete except screenScaleMatrix
1507  for (int i = 0; i < 5; i++) {
1508  stack2.Pop();
1509  }
1510  // Push backdrop filters and dilate filter
1511  for (int i = 0; i < 5; i++) {
1512  if (i == 4) {
1513  stack2.PushBackdropFilter(
1514  dilateFilter, flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1515  continue;
1516  }
1517 
1518  stack2.PushBackdropFilter(blurFilter,
1519  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1520  }
1521 
1522  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1523  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1524 
1525  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1526  withParams:std::move(embeddedViewParams)];
1527  [flutterPlatformViewsController
1528  compositeView:2
1529  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1530 
1531  [flutterView setNeedsLayout];
1532  [flutterView layoutIfNeeded];
1533 
1534  numberOfExpectedVisualEffectView = 0;
1535  for (UIView* subview in childClippingView.subviews) {
1536  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1537  continue;
1538  }
1539  XCTAssertLessThan(numberOfExpectedVisualEffectView, 4u);
1540  if ([self validateOneVisualEffectView:subview
1541  expectedFrame:CGRectMake(0, 0, 10, 10)
1542  inputRadius:(CGFloat)5]) {
1543  numberOfExpectedVisualEffectView++;
1544  }
1545  }
1546  XCTAssertEqual(numberOfExpectedVisualEffectView, 4u);
1547 
1548  // Simulate adding only non-DlBlurImageFilter to the stack (replace the mutators stack)
1549  // Update embedded view params, delete except screenScaleMatrix
1550  for (int i = 0; i < 5; i++) {
1551  stack2.Pop();
1552  }
1553  // Push dilate filters
1554  for (int i = 0; i < 5; i++) {
1555  stack2.PushBackdropFilter(dilateFilter,
1556  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1557  }
1558 
1559  embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1560  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
1561 
1562  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1563  withParams:std::move(embeddedViewParams)];
1564  [flutterPlatformViewsController
1565  compositeView:2
1566  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1567 
1568  [flutterView setNeedsLayout];
1569  [flutterView layoutIfNeeded];
1570 
1571  numberOfExpectedVisualEffectView = 0;
1572  for (UIView* subview in childClippingView.subviews) {
1573  if ([subview isKindOfClass:[UIVisualEffectView class]]) {
1574  numberOfExpectedVisualEffectView++;
1575  }
1576  }
1577  XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
1578 }
1579 
1580 - (void)testApplyBackdropFilterCorrectAPI {
1582  // The gaussianBlur filter is extracted from UIVisualEffectView.
1583  // Each test requires a new PlatformViewFilter
1584  // Valid UIVisualEffectView API
1585  UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1586  initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1587  PlatformViewFilter* platformViewFilter =
1588  [[PlatformViewFilter alloc] initWithFrame:CGRectMake(0, 0, 10, 10)
1589  blurRadius:5
1590  cornerRadius:0
1591  isRoundedSuperellipse:NO
1592  visualEffectView:visualEffectView];
1593  XCTAssertNotNil(platformViewFilter);
1594 }
1595 
1596 - (void)testApplyBackdropFilterAPIChangedInvalidUIVisualEffectView {
1598  UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc] init];
1599  PlatformViewFilter* platformViewFilter =
1600  [[PlatformViewFilter alloc] initWithFrame:CGRectMake(0, 0, 10, 10)
1601  blurRadius:5
1602  cornerRadius:0
1603  isRoundedSuperellipse:NO
1604  visualEffectView:visualEffectView];
1605  XCTAssertNil(platformViewFilter);
1606 }
1607 
1608 - (void)testApplyBackdropFilterAPIChangedNoGaussianBlurFilter {
1610  UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1611  initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1612  NSArray* subviews = editedUIVisualEffectView.subviews;
1613  for (UIView* view in subviews) {
1614  if ([NSStringFromClass([view class]) hasSuffix:@"BackdropView"]) {
1615  for (CIFilter* filter in view.layer.filters) {
1616  if ([[filter valueForKey:@"name"] isEqual:@"gaussianBlur"]) {
1617  [filter setValue:@"notGaussianBlur" forKey:@"name"];
1618  break;
1619  }
1620  }
1621  break;
1622  }
1623  }
1624  PlatformViewFilter* platformViewFilter =
1625  [[PlatformViewFilter alloc] initWithFrame:CGRectMake(0, 0, 10, 10)
1626  blurRadius:5
1627  cornerRadius:0
1628  isRoundedSuperellipse:NO
1629  visualEffectView:editedUIVisualEffectView];
1630  XCTAssertNil(platformViewFilter);
1631 }
1632 
1633 - (void)testApplyBackdropFilterAPIChangedInvalidInputRadius {
1635  UIVisualEffectView* editedUIVisualEffectView = [[UIVisualEffectView alloc]
1636  initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1637  NSArray* subviews = editedUIVisualEffectView.subviews;
1638  for (UIView* view in subviews) {
1639  if ([NSStringFromClass([view class]) hasSuffix:@"BackdropView"]) {
1640  for (CIFilter* filter in view.layer.filters) {
1641  if ([[filter valueForKey:@"name"] isEqual:@"gaussianBlur"]) {
1642  [filter setValue:@"invalidInputRadius" forKey:@"inputRadius"];
1643  break;
1644  }
1645  }
1646  break;
1647  }
1648  }
1649 
1650  PlatformViewFilter* platformViewFilter =
1651  [[PlatformViewFilter alloc] initWithFrame:CGRectMake(0, 0, 10, 10)
1652  blurRadius:5
1653  cornerRadius:0
1654  isRoundedSuperellipse:NO
1655  visualEffectView:editedUIVisualEffectView];
1656  XCTAssertNil(platformViewFilter);
1657 }
1658 
1659 - (void)testApplyBackdropFilterRespectsClipRRect {
1660  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1661 
1662  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
1663  FlutterPlatformViewsController* flutterPlatformViewsController =
1664  [[FlutterPlatformViewsController alloc] init];
1665  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
1666  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1667  /*delegate=*/mock_delegate,
1668  /*platform_views_controller=*/flutterPlatformViewsController,
1669  /*task_runners=*/runners.taskRunners,
1670  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
1671 
1674  [flutterPlatformViewsController
1675  registerViewFactory:factory
1676  withId:@"MockFlutterPlatformView"
1677  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
1678  FlutterResult result = ^(id result) {
1679  };
1680  [flutterPlatformViewsController
1682  methodCallWithMethodName:@"create"
1683  arguments:@{
1684  @"id" : @2,
1685  @"viewType" : @"MockFlutterPlatformView",
1686  @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
1687  }]
1688  result:result];
1689 
1690  XCTAssertNotNil(gMockPlatformView);
1691 
1692  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1693  flutterPlatformViewsController.flutterView = flutterView;
1694  // Create embedded view params
1695  flutter::MutatorsStack stack;
1696  // Layer tree always pushes a screen scale factor to the stack
1697  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1698  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1699  stack.PushTransform(screenScaleMatrix);
1700 
1701  // Push a rounded rect clip
1702  auto clipRect = flutter::DlRect::MakeXYWH(2, 2, 6, 6);
1703  auto clipRRect = flutter::DlRoundRect::MakeRectXY(clipRect, 3, 3);
1704  stack.PushPlatformViewClipRRect(clipRRect);
1705 
1706  // Push a backdrop filter
1707  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1708  stack.PushBackdropFilter(filter,
1709  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1710 
1711  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1712  screenScaleMatrix, flutter::DlSize(10, 10), stack);
1713 
1714  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1715  withParams:std::move(embeddedViewParams)];
1716  [flutterPlatformViewsController
1717  compositeView:2
1718  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1719 
1720  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
1721  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
1722  [flutterView addSubview:childClippingView];
1723 
1724  [flutterView setNeedsLayout];
1725  [flutterView layoutIfNeeded];
1726 
1727  NSArray<UIVisualEffectView*>* filters = childClippingView.backdropFilterSubviews;
1728  XCTAssertEqual(filters.count, 1u);
1729 
1730  UIVisualEffectView* visualEffectView = filters[0];
1731  auto radii = clipRRect.GetRadii();
1732 
1733  XCTAssertEqual(visualEffectView.layer.cornerRadius, radii.top_left.width);
1734  XCTAssertEqual(visualEffectView.layer.cornerCurve, kCACornerCurveCircular);
1735 }
1736 
1737 - (void)testApplyBackdropFilterRespectsClipRSuperellipse {
1738  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1739 
1740  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
1741  FlutterPlatformViewsController* flutterPlatformViewsController =
1742  [[FlutterPlatformViewsController alloc] init];
1743  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
1744  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1745  /*delegate=*/mock_delegate,
1746  /*platform_views_controller=*/flutterPlatformViewsController,
1747  /*task_runners=*/runners.taskRunners,
1748  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
1749 
1752  [flutterPlatformViewsController
1753  registerViewFactory:factory
1754  withId:@"MockFlutterPlatformView"
1755  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
1756  FlutterResult result = ^(id result) {
1757  };
1758  [flutterPlatformViewsController
1760  methodCallWithMethodName:@"create"
1761  arguments:@{
1762  @"id" : @2,
1763  @"viewType" : @"MockFlutterPlatformView",
1764  @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
1765  }]
1766  result:result];
1767 
1768  XCTAssertNotNil(gMockPlatformView);
1769 
1770  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1771  flutterPlatformViewsController.flutterView = flutterView;
1772  // Create embedded view params
1773  flutter::MutatorsStack stack;
1774  // Layer tree always pushes a screen scale factor to the stack
1775  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1776  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1777  stack.PushTransform(screenScaleMatrix);
1778 
1779  // Push a rounded superellipse clip
1780  auto clipRect = flutter::DlRect::MakeXYWH(2, 2, 6, 6);
1781  auto clipRSE = flutter::DlRoundSuperellipse::MakeRectXY(clipRect, 3, 3);
1782  stack.PushPlatformViewClipRSuperellipse(clipRSE);
1783 
1784  // Push a backdrop filter
1785  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp);
1786  stack.PushBackdropFilter(filter,
1787  flutter::DlRect::MakeXYWH(0, 0, screenScale * 10, screenScale * 10));
1788 
1789  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1790  screenScaleMatrix, flutter::DlSize(10, 10), stack);
1791 
1792  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1793  withParams:std::move(embeddedViewParams)];
1794  [flutterPlatformViewsController
1795  compositeView:2
1796  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1797 
1798  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
1799  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
1800  [flutterView addSubview:childClippingView];
1801 
1802  [flutterView setNeedsLayout];
1803  [flutterView layoutIfNeeded];
1804 
1805  NSArray<UIVisualEffectView*>* filters = childClippingView.backdropFilterSubviews;
1806  XCTAssertEqual(filters.count, 1u);
1807 
1808  UIVisualEffectView* visualEffectView = filters[0];
1809  auto radii = clipRSE.GetRadii();
1810 
1811  XCTAssertEqual(visualEffectView.layer.cornerRadius, radii.top_left.width);
1812  XCTAssertEqual(visualEffectView.layer.cornerCurve, kCACornerCurveContinuous);
1813 }
1814 
1815 - (void)testBackdropFilterVisualEffectSubviewBackgroundColor {
1816  __weak UIVisualEffectView* weakVisualEffectView;
1817 
1818  @autoreleasepool {
1819  UIVisualEffectView* visualEffectView = [[UIVisualEffectView alloc]
1820  initWithEffect:[UIBlurEffect effectWithStyle:UIBlurEffectStyleLight]];
1821  weakVisualEffectView = visualEffectView;
1822  PlatformViewFilter* platformViewFilter =
1823  [[PlatformViewFilter alloc] initWithFrame:CGRectMake(0, 0, 10, 10)
1824  blurRadius:5
1825  cornerRadius:0
1826  isRoundedSuperellipse:NO
1827  visualEffectView:visualEffectView];
1828  CGColorRef visualEffectSubviewBackgroundColor = nil;
1829  for (UIView* view in [platformViewFilter backdropFilterView].subviews) {
1830  if ([NSStringFromClass([view class]) hasSuffix:@"VisualEffectSubview"]) {
1831  visualEffectSubviewBackgroundColor = view.layer.backgroundColor;
1832  }
1833  }
1834  XCTAssertTrue(
1835  CGColorEqualToColor(visualEffectSubviewBackgroundColor, UIColor.clearColor.CGColor));
1836  }
1837  XCTAssertNil(weakVisualEffectView);
1838 }
1839 
1840 - (void)testCompositePlatformView {
1841  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1842 
1843  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
1844  FlutterPlatformViewsController* flutterPlatformViewsController =
1845  [[FlutterPlatformViewsController alloc] init];
1846  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
1847  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1848  /*delegate=*/mock_delegate,
1849  /*platform_views_controller=*/flutterPlatformViewsController,
1850  /*task_runners=*/runners.taskRunners,
1851  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
1852 
1855  [flutterPlatformViewsController
1856  registerViewFactory:factory
1857  withId:@"MockFlutterPlatformView"
1858  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
1859  FlutterResult result = ^(id result) {
1860  };
1861  [flutterPlatformViewsController
1863  arguments:@{
1864  @"id" : @2,
1865  @"viewType" : @"MockFlutterPlatformView",
1866  @"gestureBlockingPolicy" : @"eager"
1867  }]
1868  result:result];
1869 
1870  XCTAssertNotNil(gMockPlatformView);
1871 
1872  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
1873  flutterPlatformViewsController.flutterView = flutterView;
1874  // Create embedded view params
1875  flutter::MutatorsStack stack;
1876  // Layer tree always pushes a screen scale factor to the stack
1877  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1878  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1879  stack.PushTransform(screenScaleMatrix);
1880  // Push a translate matrix
1881  flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
1882  stack.PushTransform(translateMatrix);
1883  flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
1884 
1885  auto embeddedViewParams =
1886  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
1887 
1888  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1889  withParams:std::move(embeddedViewParams)];
1890  [flutterPlatformViewsController
1891  compositeView:2
1892  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1893 
1894  CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
1895  toView:flutterView];
1896  XCTAssertTrue(CGRectEqualToRect(platformViewRectInFlutterView, CGRectMake(100, 100, 300, 300)));
1897 }
1898 
1899 - (void)testBackdropFilterCorrectlyPushedAndReset {
1900  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
1901 
1902  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
1903  FlutterPlatformViewsController* flutterPlatformViewsController =
1904  [[FlutterPlatformViewsController alloc] init];
1905  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
1906  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
1907  /*delegate=*/mock_delegate,
1908  /*platform_views_controller=*/flutterPlatformViewsController,
1909  /*task_runners=*/runners.taskRunners,
1910  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
1911 
1914  [flutterPlatformViewsController
1915  registerViewFactory:factory
1916  withId:@"MockFlutterPlatformView"
1917  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
1918  FlutterResult result = ^(id result) {
1919  };
1920  [flutterPlatformViewsController
1922  arguments:@{
1923  @"id" : @2,
1924  @"viewType" : @"MockFlutterPlatformView",
1925  @"gestureBlockingPolicy" : @"eager"
1926  }]
1927  result:result];
1928 
1929  XCTAssertNotNil(gMockPlatformView);
1930 
1931  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
1932  flutterPlatformViewsController.flutterView = flutterView;
1933  // Create embedded view params
1934  flutter::MutatorsStack stack;
1935  // Layer tree always pushes a screen scale factor to the stack
1936  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
1937  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
1938  stack.PushTransform(screenScaleMatrix);
1939 
1940  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
1941  screenScaleMatrix, flutter::DlSize(10, 10), stack);
1942 
1943  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(0, 0)];
1944  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1945  withParams:std::move(embeddedViewParams)];
1946  [flutterPlatformViewsController pushVisitedPlatformViewId:2];
1947  auto filter = flutter::DlBlurImageFilter::Make(5, 2, flutter::DlTileMode::kClamp, std::nullopt);
1948  [flutterPlatformViewsController
1949  pushFilterToVisitedPlatformViews:filter
1950  withRect:flutter::DlRect::MakeXYWH(0, 0, screenScale * 10,
1951  screenScale * 10)];
1952  [flutterPlatformViewsController
1953  compositeView:2
1954  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1955 
1956  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
1957  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
1958  [flutterView addSubview:childClippingView];
1959 
1960  [flutterView setNeedsLayout];
1961  [flutterView layoutIfNeeded];
1962 
1963  // childClippingView has visual effect view with the correct configurations.
1964  NSUInteger numberOfExpectedVisualEffectView = 0;
1965  for (UIView* subview in childClippingView.subviews) {
1966  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1967  continue;
1968  }
1969  XCTAssertLessThan(numberOfExpectedVisualEffectView, 1u);
1970  if ([self validateOneVisualEffectView:subview
1971  expectedFrame:CGRectMake(0, 0, 10, 10)
1972  inputRadius:5]) {
1973  numberOfExpectedVisualEffectView++;
1974  }
1975  }
1976  XCTAssertEqual(numberOfExpectedVisualEffectView, 1u);
1977 
1978  // New frame, with no filter pushed.
1979  auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
1980  screenScaleMatrix, flutter::DlSize(10, 10), stack);
1981  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(0, 0)];
1982  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
1983  withParams:std::move(embeddedViewParams2)];
1984  [flutterPlatformViewsController
1985  compositeView:2
1986  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
1987 
1988  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:[ChildClippingView class]]);
1989 
1990  [flutterView setNeedsLayout];
1991  [flutterView layoutIfNeeded];
1992 
1993  numberOfExpectedVisualEffectView = 0;
1994  for (UIView* subview in childClippingView.subviews) {
1995  if (![subview isKindOfClass:[UIVisualEffectView class]]) {
1996  continue;
1997  }
1998  numberOfExpectedVisualEffectView++;
1999  }
2000  XCTAssertEqual(numberOfExpectedVisualEffectView, 0u);
2001 }
2002 
2003 - (void)testChildClippingViewShouldBeTheBoundingRectOfPlatformView {
2004  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2005 
2006  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2007  FlutterPlatformViewsController* flutterPlatformViewsController =
2008  [[FlutterPlatformViewsController alloc] init];
2009  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
2010  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2011  /*delegate=*/mock_delegate,
2012  /*platform_views_controller=*/flutterPlatformViewsController,
2013  /*task_runners=*/runners.taskRunners,
2014  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2015 
2018  [flutterPlatformViewsController
2019  registerViewFactory:factory
2020  withId:@"MockFlutterPlatformView"
2021  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2022  FlutterResult result = ^(id result) {
2023  };
2024  [flutterPlatformViewsController
2026  arguments:@{
2027  @"id" : @2,
2028  @"viewType" : @"MockFlutterPlatformView",
2029  @"gestureBlockingPolicy" : @"eager"
2030  }]
2031  result:result];
2032 
2033  XCTAssertNotNil(gMockPlatformView);
2034 
2035  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
2036  flutterPlatformViewsController.flutterView = flutterView;
2037  // Create embedded view params
2038  flutter::MutatorsStack stack;
2039  // Layer tree always pushes a screen scale factor to the stack
2040  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2041  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2042  stack.PushTransform(screenScaleMatrix);
2043  // Push a rotate matrix
2044  flutter::DlMatrix rotateMatrix = flutter::DlMatrix::MakeRotationZ(flutter::DlDegrees(10));
2045  stack.PushTransform(rotateMatrix);
2046  flutter::DlMatrix finalMatrix = screenScaleMatrix * rotateMatrix;
2047 
2048  auto embeddedViewParams =
2049  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
2050 
2051  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2052  withParams:std::move(embeddedViewParams)];
2053  [flutterPlatformViewsController
2054  compositeView:2
2055  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2056 
2057  CGRect platformViewRectInFlutterView = [gMockPlatformView convertRect:gMockPlatformView.bounds
2058  toView:flutterView];
2059  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2060  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2061  // The childclippingview's frame is set based on flow, but the platform view's frame is set based
2062  // on quartz. Although they should be the same, but we should tolerate small floating point
2063  // errors.
2064  XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.x - childClippingView.frame.origin.x),
2066  XCTAssertLessThan(fabs(platformViewRectInFlutterView.origin.y - childClippingView.frame.origin.y),
2068  XCTAssertLessThan(
2069  fabs(platformViewRectInFlutterView.size.width - childClippingView.frame.size.width),
2071  XCTAssertLessThan(
2072  fabs(platformViewRectInFlutterView.size.height - childClippingView.frame.size.height),
2074 }
2075 
2076 - (void)testClipsDoNotInterceptWithPlatformViewShouldNotAddMaskView {
2077  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2078 
2079  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2080  FlutterPlatformViewsController* flutterPlatformViewsController =
2081  [[FlutterPlatformViewsController alloc] init];
2082  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
2083  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2084  /*delegate=*/mock_delegate,
2085  /*platform_views_controller=*/flutterPlatformViewsController,
2086  /*task_runners=*/runners.taskRunners,
2087  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2088 
2091  [flutterPlatformViewsController
2092  registerViewFactory:factory
2093  withId:@"MockFlutterPlatformView"
2094  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2095  FlutterResult result = ^(id result) {
2096  };
2097  [flutterPlatformViewsController
2099  arguments:@{
2100  @"id" : @2,
2101  @"viewType" : @"MockFlutterPlatformView",
2102  @"gestureBlockingPolicy" : @"eager"
2103  }]
2104  result:result];
2105 
2106  XCTAssertNotNil(gMockPlatformView);
2107 
2108  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
2109  flutterPlatformViewsController.flutterView = flutterView;
2110  // Create embedded view params.
2111  flutter::MutatorsStack stack;
2112  // Layer tree always pushes a screen scale factor to the stack.
2113  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2114  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2115  stack.PushTransform(screenScaleMatrix);
2116  flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({5, 5});
2117  // The platform view's rect for this test will be (5, 5, 10, 10).
2118  stack.PushTransform(translateMatrix);
2119  // Push a clip rect, big enough to contain the entire platform view bound.
2120  flutter::DlRect rect = flutter::DlRect::MakeXYWH(0, 0, 25, 25);
2121  stack.PushClipRect(rect);
2122  // Push a clip rrect, big enough to contain the entire platform view bound without clipping it.
2123  // Make the origin (-1, -1) so that the top left rounded corner isn't clipping the PlatformView.
2124  flutter::DlRect rect_for_rrect = flutter::DlRect::MakeXYWH(-1, -1, 25, 25);
2125  flutter::DlRoundRect rrect = flutter::DlRoundRect::MakeRectXY(rect_for_rrect, 1, 1);
2126  stack.PushClipRRect(rrect);
2127 
2128  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2129  screenScaleMatrix * translateMatrix, flutter::DlSize(5, 5), stack);
2130 
2131  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2132  withParams:std::move(embeddedViewParams)];
2133  [flutterPlatformViewsController
2134  compositeView:2
2135  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2136 
2137  gMockPlatformView.backgroundColor = UIColor.redColor;
2138  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2139  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2140  [flutterView addSubview:childClippingView];
2141 
2142  [flutterView setNeedsLayout];
2143  [flutterView layoutIfNeeded];
2144  XCTAssertNil(childClippingView.maskView);
2145 }
2146 
2147 - (void)testClipRRectOnlyHasCornersInterceptWithPlatformViewShouldAddMaskView {
2148  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2149 
2150  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2151  FlutterPlatformViewsController* flutterPlatformViewsController =
2152  [[FlutterPlatformViewsController alloc] init];
2153  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
2154  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2155  /*delegate=*/mock_delegate,
2156  /*platform_views_controller=*/flutterPlatformViewsController,
2157  /*task_runners=*/runners.taskRunners,
2158  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2159 
2162  [flutterPlatformViewsController
2163  registerViewFactory:factory
2164  withId:@"MockFlutterPlatformView"
2165  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2166  FlutterResult result = ^(id result) {
2167  };
2168  [flutterPlatformViewsController
2170  arguments:@{
2171  @"id" : @2,
2172  @"viewType" : @"MockFlutterPlatformView",
2173  @"gestureBlockingPolicy" : @"eager"
2174  }]
2175  result:result];
2176 
2177  XCTAssertNotNil(gMockPlatformView);
2178 
2179  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 30, 30)];
2180  flutterPlatformViewsController.flutterView = flutterView;
2181  // Create embedded view params
2182  flutter::MutatorsStack stack;
2183  // Layer tree always pushes a screen scale factor to the stack.
2184  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2185  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2186  stack.PushTransform(screenScaleMatrix);
2187  flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({5, 5});
2188  // The platform view's rect for this test will be (5, 5, 10, 10).
2189  stack.PushTransform(translateMatrix);
2190 
2191  // Push a clip rrect, the rect of the rrect is the same as the PlatformView of the corner should.
2192  // clip the PlatformView.
2193  flutter::DlRect rect_for_rrect = flutter::DlRect::MakeXYWH(0, 0, 10, 10);
2194  flutter::DlRoundRect rrect = flutter::DlRoundRect::MakeRectXY(rect_for_rrect, 1, 1);
2195  stack.PushClipRRect(rrect);
2196 
2197  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2198  screenScaleMatrix * translateMatrix, flutter::DlSize(5, 5), stack);
2199 
2200  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2201  withParams:std::move(embeddedViewParams)];
2202  [flutterPlatformViewsController
2203  compositeView:2
2204  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2205 
2206  gMockPlatformView.backgroundColor = UIColor.redColor;
2207  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2208  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2209  [flutterView addSubview:childClippingView];
2210 
2211  [flutterView setNeedsLayout];
2212  [flutterView layoutIfNeeded];
2213 
2214  XCTAssertNotNil(childClippingView.maskView);
2215 }
2216 
2217 - (void)testClipRect {
2218  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2219 
2220  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2221  FlutterPlatformViewsController* flutterPlatformViewsController =
2222  [[FlutterPlatformViewsController alloc] init];
2223  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
2224  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2225  /*delegate=*/mock_delegate,
2226  /*platform_views_controller=*/flutterPlatformViewsController,
2227  /*task_runners=*/runners.taskRunners,
2228  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2229 
2232  [flutterPlatformViewsController
2233  registerViewFactory:factory
2234  withId:@"MockFlutterPlatformView"
2235  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2236  FlutterResult result = ^(id result) {
2237  };
2238  [flutterPlatformViewsController
2240  arguments:@{
2241  @"id" : @2,
2242  @"viewType" : @"MockFlutterPlatformView",
2243  @"gestureBlockingPolicy" : @"eager"
2244  }]
2245  result:result];
2246 
2247  XCTAssertNotNil(gMockPlatformView);
2248 
2249  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2250  flutterPlatformViewsController.flutterView = flutterView;
2251  // Create embedded view params
2252  flutter::MutatorsStack stack;
2253  // Layer tree always pushes a screen scale factor to the stack
2254  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2255  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2256  stack.PushTransform(screenScaleMatrix);
2257  // Push a clip rect
2258  flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
2259  stack.PushClipRect(rect);
2260 
2261  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2262  screenScaleMatrix, flutter::DlSize(10, 10), stack);
2263 
2264  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2265  withParams:std::move(embeddedViewParams)];
2266  [flutterPlatformViewsController
2267  compositeView:2
2268  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2269 
2270  gMockPlatformView.backgroundColor = UIColor.redColor;
2271  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2272  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2273  [flutterView addSubview:childClippingView];
2274 
2275  [flutterView setNeedsLayout];
2276  [flutterView layoutIfNeeded];
2277 
2278  CGRect insideClipping = CGRectMake(2, 2, 3, 3);
2279  for (int i = 0; i < 10; i++) {
2280  for (int j = 0; j < 10; j++) {
2281  CGPoint point = CGPointMake(i, j);
2282  int alpha = [self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2283  if (CGRectContainsPoint(insideClipping, point)) {
2284  XCTAssertEqual(alpha, 255);
2285  } else {
2286  XCTAssertEqual(alpha, 0);
2287  }
2288  }
2289  }
2290 }
2291 
2292 - (void)testClipRect_multipleClips {
2293  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2294 
2295  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2296  FlutterPlatformViewsController* flutterPlatformViewsController =
2297  [[FlutterPlatformViewsController alloc] init];
2298  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
2299  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2300  /*delegate=*/mock_delegate,
2301  /*platform_views_controller=*/flutterPlatformViewsController,
2302  /*task_runners=*/runners.taskRunners,
2303  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2304 
2307  [flutterPlatformViewsController
2308  registerViewFactory:factory
2309  withId:@"MockFlutterPlatformView"
2310  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2311  FlutterResult result = ^(id result) {
2312  };
2313  [flutterPlatformViewsController
2315  arguments:@{
2316  @"id" : @2,
2317  @"viewType" : @"MockFlutterPlatformView",
2318  @"gestureBlockingPolicy" : @"eager"
2319  }]
2320  result:result];
2321 
2322  XCTAssertNotNil(gMockPlatformView);
2323 
2324  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2325  flutterPlatformViewsController.flutterView = flutterView;
2326  // Create embedded view params
2327  flutter::MutatorsStack stack;
2328  // Layer tree always pushes a screen scale factor to the stack
2329  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2330  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2331  stack.PushTransform(screenScaleMatrix);
2332  // Push a clip rect
2333  flutter::DlRect rect1 = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
2334  stack.PushClipRect(rect1);
2335  // Push another clip rect
2336  flutter::DlRect rect2 = flutter::DlRect::MakeXYWH(3, 3, 3, 3);
2337  stack.PushClipRect(rect2);
2338 
2339  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2340  screenScaleMatrix, flutter::DlSize(10, 10), stack);
2341 
2342  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2343  withParams:std::move(embeddedViewParams)];
2344  [flutterPlatformViewsController
2345  compositeView:2
2346  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2347 
2348  gMockPlatformView.backgroundColor = UIColor.redColor;
2349  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2350  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2351  [flutterView addSubview:childClippingView];
2352 
2353  [flutterView setNeedsLayout];
2354  [flutterView layoutIfNeeded];
2355 
2356  /*
2357  clip 1 clip 2
2358  2 3 4 5 6 2 3 4 5 6
2359  2 + - - + 2
2360  3 | | 3 + - - +
2361  4 | | 4 | |
2362  5 + - - + 5 | |
2363  6 6 + - - +
2364 
2365  Result should be the intersection of 2 clips
2366  2 3 4 5 6
2367  2
2368  3 + - +
2369  4 | |
2370  5 + - +
2371  6
2372  */
2373  CGRect insideClipping = CGRectMake(3, 3, 2, 2);
2374  for (int i = 0; i < 10; i++) {
2375  for (int j = 0; j < 10; j++) {
2376  CGPoint point = CGPointMake(i, j);
2377  int alpha = [self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2378  if (CGRectContainsPoint(insideClipping, point)) {
2379  XCTAssertEqual(alpha, 255);
2380  } else {
2381  XCTAssertEqual(alpha, 0);
2382  }
2383  }
2384  }
2385 }
2386 
2387 - (void)testClipRRect {
2388  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2389 
2390  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2391  FlutterPlatformViewsController* flutterPlatformViewsController =
2392  [[FlutterPlatformViewsController alloc] init];
2393  flutterPlatformViewsController.taskRunner = flutter::testing::GetDefaultTaskRunner();
2394  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2395  /*delegate=*/mock_delegate,
2396  /*platform_views_controller=*/flutterPlatformViewsController,
2397  /*task_runners=*/runners.taskRunners,
2398  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2399 
2402  [flutterPlatformViewsController
2403  registerViewFactory:factory
2404  withId:@"MockFlutterPlatformView"
2405  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2406  FlutterResult result = ^(id result) {
2407  };
2408  [flutterPlatformViewsController
2410  arguments:@{
2411  @"id" : @2,
2412  @"viewType" : @"MockFlutterPlatformView",
2413  @"gestureBlockingPolicy" : @"eager"
2414  }]
2415  result:result];
2416 
2417  XCTAssertNotNil(gMockPlatformView);
2418 
2419  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2420  flutterPlatformViewsController.flutterView = flutterView;
2421  // Create embedded view params
2422  flutter::MutatorsStack stack;
2423  // Layer tree always pushes a screen scale factor to the stack
2424  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2425  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2426  stack.PushTransform(screenScaleMatrix);
2427  // Push a clip rrect
2428  flutter::DlRoundRect rrect =
2429  flutter::DlRoundRect::MakeRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2430  stack.PushClipRRect(rrect);
2431 
2432  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2433  screenScaleMatrix, flutter::DlSize(10, 10), stack);
2434 
2435  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2436  withParams:std::move(embeddedViewParams)];
2437  [flutterPlatformViewsController
2438  compositeView:2
2439  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2440 
2441  gMockPlatformView.backgroundColor = UIColor.redColor;
2442  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2443  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2444  [flutterView addSubview:childClippingView];
2445 
2446  [flutterView setNeedsLayout];
2447  [flutterView layoutIfNeeded];
2448 
2449  /*
2450  ClippingMask outterClipping
2451  2 3 4 5 6 7 2 3 4 5 6 7
2452  2 / - - - - \ 2 + - - - - +
2453  3 | | 3 | |
2454  4 | | 4 | |
2455  5 | | 5 | |
2456  6 | | 6 | |
2457  7 \ - - - - / 7 + - - - - +
2458 
2459  innerClipping1 innerClipping2
2460  2 3 4 5 6 7 2 3 4 5 6 7
2461  2 + - - + 2
2462  3 | | 3 + - - - - +
2463  4 | | 4 | |
2464  5 | | 5 | |
2465  6 | | 6 + - - - - +
2466  7 + - - + 7
2467  */
2468  CGRect innerClipping1 = CGRectMake(3, 2, 4, 6);
2469  CGRect innerClipping2 = CGRectMake(2, 3, 6, 4);
2470  CGRect outterClipping = CGRectMake(2, 2, 6, 6);
2471  for (int i = 0; i < 10; i++) {
2472  for (int j = 0; j < 10; j++) {
2473  CGPoint point = CGPointMake(i, j);
2474  int alpha = [self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2475  if (CGRectContainsPoint(innerClipping1, point) ||
2476  CGRectContainsPoint(innerClipping2, point)) {
2477  // Pixels inside either of the 2 inner clippings should be fully opaque.
2478  XCTAssertEqual(alpha, 255);
2479  } else if (CGRectContainsPoint(outterClipping, point)) {
2480  // Corner pixels (i.e. (2, 2), (2, 7), (7, 2) and (7, 7)) should be partially transparent.
2481  XCTAssert(0 < alpha && alpha < 255);
2482  } else {
2483  // Pixels outside outterClipping should be fully transparent.
2484  XCTAssertEqual(alpha, 0);
2485  }
2486  }
2487  }
2488 }
2489 
2490 - (void)testClipRRect_multipleClips {
2491  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2492 
2493  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2494  FlutterPlatformViewsController* flutterPlatformViewsController =
2495  [[FlutterPlatformViewsController alloc] init];
2496  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
2497  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2498  /*delegate=*/mock_delegate,
2499  /*platform_views_controller=*/flutterPlatformViewsController,
2500  /*task_runners=*/runners.taskRunners,
2501  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2502 
2505  [flutterPlatformViewsController
2506  registerViewFactory:factory
2507  withId:@"MockFlutterPlatformView"
2508  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2509  FlutterResult result = ^(id result) {
2510  };
2511  [flutterPlatformViewsController
2513  arguments:@{
2514  @"id" : @2,
2515  @"viewType" : @"MockFlutterPlatformView",
2516  @"gestureBlockingPolicy" : @"eager"
2517  }]
2518  result:result];
2519 
2520  XCTAssertNotNil(gMockPlatformView);
2521 
2522  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2523  flutterPlatformViewsController.flutterView = flutterView;
2524  // Create embedded view params
2525  flutter::MutatorsStack stack;
2526  // Layer tree always pushes a screen scale factor to the stack
2527  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2528  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2529  stack.PushTransform(screenScaleMatrix);
2530  // Push a clip rrect
2531  flutter::DlRoundRect rrect =
2532  flutter::DlRoundRect::MakeRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2533  stack.PushClipRRect(rrect);
2534  // Push a clip rect
2535  flutter::DlRect rect = flutter::DlRect::MakeXYWH(4, 2, 6, 6);
2536  stack.PushClipRect(rect);
2537 
2538  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2539  screenScaleMatrix, flutter::DlSize(10, 10), stack);
2540 
2541  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2542  withParams:std::move(embeddedViewParams)];
2543  [flutterPlatformViewsController
2544  compositeView:2
2545  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2546 
2547  gMockPlatformView.backgroundColor = UIColor.redColor;
2548  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2549  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2550  [flutterView addSubview:childClippingView];
2551 
2552  [flutterView setNeedsLayout];
2553  [flutterView layoutIfNeeded];
2554 
2555  /*
2556  clip 1 clip 2
2557  2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9
2558  2 / - - - - \ 2 + - - - - +
2559  3 | | 3 | |
2560  4 | | 4 | |
2561  5 | | 5 | |
2562  6 | | 6 | |
2563  7 \ - - - - / 7 + - - - - +
2564 
2565  Result should be the intersection of 2 clips
2566  2 3 4 5 6 7 8 9
2567  2 + - - \
2568  3 | |
2569  4 | |
2570  5 | |
2571  6 | |
2572  7 + - - /
2573  */
2574  CGRect clipping = CGRectMake(4, 2, 4, 6);
2575  for (int i = 0; i < 10; i++) {
2576  for (int j = 0; j < 10; j++) {
2577  CGPoint point = CGPointMake(i, j);
2578  int alpha = [self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2579  if (i == 7 && (j == 2 || j == 7)) {
2580  // Upper and lower right corners should be partially transparent.
2581  XCTAssert(0 < alpha && alpha < 255);
2582  } else if (
2583  // left
2584  (i == 4 && j >= 2 && j <= 7) ||
2585  // right
2586  (i == 7 && j >= 2 && j <= 7) ||
2587  // top
2588  (j == 2 && i >= 4 && i <= 7) ||
2589  // bottom
2590  (j == 7 && i >= 4 && i <= 7)) {
2591  // Since we are falling back to software rendering for this case
2592  // The edge pixels can be anti-aliased, so it may not be fully opaque.
2593  XCTAssert(alpha > 127);
2594  } else if ((i == 3 && j >= 1 && j <= 8) || (i == 8 && j >= 1 && j <= 8) ||
2595  (j == 1 && i >= 3 && i <= 8) || (j == 8 && i >= 3 && i <= 8)) {
2596  // Since we are falling back to software rendering for this case
2597  // The edge pixels can be anti-aliased, so it may not be fully transparent.
2598  XCTAssert(alpha < 127);
2599  } else if (CGRectContainsPoint(clipping, point)) {
2600  // Other pixels inside clipping should be fully opaque.
2601  XCTAssertEqual(alpha, 255);
2602  } else {
2603  // Pixels outside clipping should be fully transparent.
2604  XCTAssertEqual(alpha, 0);
2605  }
2606  }
2607  }
2608 }
2609 
2610 - (void)testClipPath {
2611  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2612 
2613  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2614  FlutterPlatformViewsController* flutterPlatformViewsController =
2615  [[FlutterPlatformViewsController alloc] init];
2616  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
2617  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2618  /*delegate=*/mock_delegate,
2619  /*platform_views_controller=*/flutterPlatformViewsController,
2620  /*task_runners=*/runners.taskRunners,
2621  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2622 
2625  [flutterPlatformViewsController
2626  registerViewFactory:factory
2627  withId:@"MockFlutterPlatformView"
2628  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2629  FlutterResult result = ^(id result) {
2630  };
2631  [flutterPlatformViewsController
2633  arguments:@{
2634  @"id" : @2,
2635  @"viewType" : @"MockFlutterPlatformView",
2636  @"gestureBlockingPolicy" : @"eager"
2637  }]
2638  result:result];
2639 
2640  XCTAssertNotNil(gMockPlatformView);
2641 
2642  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2643  flutterPlatformViewsController.flutterView = flutterView;
2644  // Create embedded view params
2645  flutter::MutatorsStack stack;
2646  // Layer tree always pushes a screen scale factor to the stack
2647  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2648  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2649  stack.PushTransform(screenScaleMatrix);
2650  // Push a clip path
2651  flutter::DlPath path =
2652  flutter::DlPath::MakeRoundRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2653  stack.PushClipPath(path);
2654 
2655  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2656  screenScaleMatrix, flutter::DlSize(10, 10), stack);
2657 
2658  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2659  withParams:std::move(embeddedViewParams)];
2660  [flutterPlatformViewsController
2661  compositeView:2
2662  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2663 
2664  gMockPlatformView.backgroundColor = UIColor.redColor;
2665  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2666  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2667  [flutterView addSubview:childClippingView];
2668 
2669  [flutterView setNeedsLayout];
2670  [flutterView layoutIfNeeded];
2671 
2672  /*
2673  ClippingMask outterClipping
2674  2 3 4 5 6 7 2 3 4 5 6 7
2675  2 / - - - - \ 2 + - - - - +
2676  3 | | 3 | |
2677  4 | | 4 | |
2678  5 | | 5 | |
2679  6 | | 6 | |
2680  7 \ - - - - / 7 + - - - - +
2681 
2682  innerClipping1 innerClipping2
2683  2 3 4 5 6 7 2 3 4 5 6 7
2684  2 + - - + 2
2685  3 | | 3 + - - - - +
2686  4 | | 4 | |
2687  5 | | 5 | |
2688  6 | | 6 + - - - - +
2689  7 + - - + 7
2690  */
2691  CGRect innerClipping1 = CGRectMake(3, 2, 4, 6);
2692  CGRect innerClipping2 = CGRectMake(2, 3, 6, 4);
2693  CGRect outterClipping = CGRectMake(2, 2, 6, 6);
2694  for (int i = 0; i < 10; i++) {
2695  for (int j = 0; j < 10; j++) {
2696  CGPoint point = CGPointMake(i, j);
2697  int alpha = [self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2698  if (CGRectContainsPoint(innerClipping1, point) ||
2699  CGRectContainsPoint(innerClipping2, point)) {
2700  // Pixels inside either of the 2 inner clippings should be fully opaque.
2701  XCTAssertEqual(alpha, 255);
2702  } else if (CGRectContainsPoint(outterClipping, point)) {
2703  // Corner pixels (i.e. (2, 2), (2, 7), (7, 2) and (7, 7)) should be partially transparent.
2704  XCTAssert(0 < alpha && alpha < 255);
2705  } else {
2706  // Pixels outside outterClipping should be fully transparent.
2707  XCTAssertEqual(alpha, 0);
2708  }
2709  }
2710  }
2711 }
2712 
2713 - (void)testClipPath_multipleClips {
2714  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2715 
2716  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2717  FlutterPlatformViewsController* flutterPlatformViewsController =
2718  [[FlutterPlatformViewsController alloc] init];
2719  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
2720  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2721  /*delegate=*/mock_delegate,
2722  /*platform_views_controller=*/flutterPlatformViewsController,
2723  /*task_runners=*/runners.taskRunners,
2724  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2725 
2728  [flutterPlatformViewsController
2729  registerViewFactory:factory
2730  withId:@"MockFlutterPlatformView"
2731  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2732  FlutterResult result = ^(id result) {
2733  };
2734  [flutterPlatformViewsController
2736  arguments:@{
2737  @"id" : @2,
2738  @"viewType" : @"MockFlutterPlatformView",
2739  @"gestureBlockingPolicy" : @"eager"
2740  }]
2741  result:result];
2742 
2743  XCTAssertNotNil(gMockPlatformView);
2744 
2745  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
2746  flutterPlatformViewsController.flutterView = flutterView;
2747  // Create embedded view params
2748  flutter::MutatorsStack stack;
2749  // Layer tree always pushes a screen scale factor to the stack
2750  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
2751  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
2752  stack.PushTransform(screenScaleMatrix);
2753  // Push a clip path
2754  flutter::DlPath path =
2755  flutter::DlPath::MakeRoundRectXY(flutter::DlRect::MakeXYWH(2, 2, 6, 6), 1, 1);
2756  stack.PushClipPath(path);
2757  // Push a clip rect
2758  flutter::DlRect rect = flutter::DlRect::MakeXYWH(4, 2, 6, 6);
2759  stack.PushClipRect(rect);
2760 
2761  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
2762  screenScaleMatrix, flutter::DlSize(10, 10), stack);
2763 
2764  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
2765  withParams:std::move(embeddedViewParams)];
2766  [flutterPlatformViewsController
2767  compositeView:2
2768  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
2769 
2770  gMockPlatformView.backgroundColor = UIColor.redColor;
2771  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
2772  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
2773  [flutterView addSubview:childClippingView];
2774 
2775  [flutterView setNeedsLayout];
2776  [flutterView layoutIfNeeded];
2777 
2778  /*
2779  clip 1 clip 2
2780  2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9
2781  2 / - - - - \ 2 + - - - - +
2782  3 | | 3 | |
2783  4 | | 4 | |
2784  5 | | 5 | |
2785  6 | | 6 | |
2786  7 \ - - - - / 7 + - - - - +
2787 
2788  Result should be the intersection of 2 clips
2789  2 3 4 5 6 7 8 9
2790  2 + - - \
2791  3 | |
2792  4 | |
2793  5 | |
2794  6 | |
2795  7 + - - /
2796  */
2797  CGRect clipping = CGRectMake(4, 2, 4, 6);
2798  for (int i = 0; i < 10; i++) {
2799  for (int j = 0; j < 10; j++) {
2800  CGPoint point = CGPointMake(i, j);
2801  int alpha = [self alphaOfPoint:CGPointMake(i, j) onView:flutterView];
2802  if (i == 7 && (j == 2 || j == 7)) {
2803  // Upper and lower right corners should be partially transparent.
2804  XCTAssert(0 < alpha && alpha < 255);
2805  } else if (
2806  // left
2807  (i == 4 && j >= 2 && j <= 7) ||
2808  // right
2809  (i == 7 && j >= 2 && j <= 7) ||
2810  // top
2811  (j == 2 && i >= 4 && i <= 7) ||
2812  // bottom
2813  (j == 7 && i >= 4 && i <= 7)) {
2814  // Since we are falling back to software rendering for this case
2815  // The edge pixels can be anti-aliased, so it may not be fully opaque.
2816  XCTAssert(alpha > 127);
2817  } else if ((i == 3 && j >= 1 && j <= 8) || (i == 8 && j >= 1 && j <= 8) ||
2818  (j == 1 && i >= 3 && i <= 8) || (j == 8 && i >= 3 && i <= 8)) {
2819  // Since we are falling back to software rendering for this case
2820  // The edge pixels can be anti-aliased, so it may not be fully transparent.
2821  XCTAssert(alpha < 127);
2822  } else if (CGRectContainsPoint(clipping, point)) {
2823  // Other pixels inside clipping should be fully opaque.
2824  XCTAssertEqual(alpha, 255);
2825  } else {
2826  // Pixels outside clipping should be fully transparent.
2827  XCTAssertEqual(alpha, 0);
2828  }
2829  }
2830  }
2831 }
2832 
2833 - (void)testSetFlutterViewControllerAfterCreateCanStillDispatchTouchEvents {
2834  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2835 
2836  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2837  FlutterPlatformViewsController* flutterPlatformViewsController =
2838  [[FlutterPlatformViewsController alloc] init];
2839  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
2840  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2841  /*delegate=*/mock_delegate,
2842  /*platform_views_controller=*/flutterPlatformViewsController,
2843  /*task_runners=*/runners.taskRunners,
2844  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2845 
2848  [flutterPlatformViewsController
2849  registerViewFactory:factory
2850  withId:@"MockFlutterPlatformView"
2851  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2852  FlutterResult result = ^(id result) {
2853  };
2854  [flutterPlatformViewsController
2856  arguments:@{
2857  @"id" : @2,
2858  @"viewType" : @"MockFlutterPlatformView",
2859  @"gestureBlockingPolicy" : @"eager"
2860  }]
2861  result:result];
2862 
2863  XCTAssertNotNil(gMockPlatformView);
2864 
2865  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
2866  XCTAssertNotNil(touchInterceptorView);
2867 
2868  UIGestureRecognizer* forwardGectureRecognizer =
2869  FindForwardingGestureRecognizer(touchInterceptorView);
2870 
2871  // Before setting flutter view controller, events are not dispatched.
2872  NSSet* touches1 = [[NSSet alloc] init];
2873  id event1 = OCMClassMock([UIEvent class]);
2874  id flutterViewController = OCMClassMock([FlutterViewController class]);
2875  [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2876  OCMReject([flutterViewController touchesBegan:touches1 withEvent:event1]);
2877 
2878  // Set flutter view controller allows events to be dispatched.
2879  NSSet* touches2 = [[NSSet alloc] init];
2880  id event2 = OCMClassMock([UIEvent class]);
2881  flutterPlatformViewsController.flutterViewController = flutterViewController;
2882  [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
2883  OCMVerify([flutterViewController touchesBegan:touches2 withEvent:event2]);
2884 }
2885 
2886 - (void)testSetFlutterViewControllerInTheMiddleOfTouchEventShouldStillAllowGesturesToBeHandled {
2887  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2888 
2889  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
2890  FlutterPlatformViewsController* flutterPlatformViewsController =
2891  [[FlutterPlatformViewsController alloc] init];
2892  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
2893  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
2894  /*delegate=*/mock_delegate,
2895  /*platform_views_controller=*/flutterPlatformViewsController,
2896  /*task_runners=*/runners.taskRunners,
2897  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
2898 
2901  [flutterPlatformViewsController
2902  registerViewFactory:factory
2903  withId:@"MockFlutterPlatformView"
2904  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
2905  FlutterResult result = ^(id result) {
2906  };
2907  [flutterPlatformViewsController
2909  arguments:@{
2910  @"id" : @2,
2911  @"viewType" : @"MockFlutterPlatformView",
2912  @"gestureBlockingPolicy" : @"eager"
2913  }]
2914  result:result];
2915 
2916  XCTAssertNotNil(gMockPlatformView);
2917 
2918  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
2919  XCTAssertNotNil(touchInterceptorView);
2920 
2921  UIGestureRecognizer* forwardGectureRecognizer =
2922  FindForwardingGestureRecognizer(touchInterceptorView);
2923  id flutterViewController = OCMClassMock([FlutterViewController class]);
2924  {
2925  // ***** Sequence 1, finishing touch event with touchEnded ***** //
2926  flutterPlatformViewsController.flutterViewController = flutterViewController;
2927 
2928  NSSet* touches1 = [[NSSet alloc] init];
2929  id event1 = OCMClassMock([UIEvent class]);
2930  [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2931  OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
2932 
2933  flutterPlatformViewsController.flutterViewController = nil;
2934 
2935  // Allow the touch events to finish
2936  NSSet* touches2 = [[NSSet alloc] init];
2937  id event2 = OCMClassMock([UIEvent class]);
2938  [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2939  OCMVerify([flutterViewController touchesMoved:touches2 withEvent:event2]);
2940 
2941  NSSet* touches3 = [[NSSet alloc] init];
2942  id event3 = OCMClassMock([UIEvent class]);
2943  [forwardGectureRecognizer touchesEnded:touches3 withEvent:event3];
2944  OCMVerify([flutterViewController touchesEnded:touches3 withEvent:event3]);
2945 
2946  // Now the 2nd touch sequence should not be allowed.
2947  NSSet* touches4 = [[NSSet alloc] init];
2948  id event4 = OCMClassMock([UIEvent class]);
2949  [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2950  OCMReject([flutterViewController touchesBegan:touches4 withEvent:event4]);
2951 
2952  NSSet* touches5 = [[NSSet alloc] init];
2953  id event5 = OCMClassMock([UIEvent class]);
2954  [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2955  OCMReject([flutterViewController touchesEnded:touches5 withEvent:event5]);
2956  }
2957 
2958  {
2959  // ***** Sequence 2, finishing touch event with touchCancelled ***** //
2960  flutterPlatformViewsController.flutterViewController = flutterViewController;
2961 
2962  NSSet* touches1 = [[NSSet alloc] init];
2963  id event1 = OCMClassMock([UIEvent class]);
2964  [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
2965  OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
2966 
2967  flutterPlatformViewsController.flutterViewController = nil;
2968 
2969  // Allow the touch events to finish
2970  NSSet* touches2 = [[NSSet alloc] init];
2971  id event2 = OCMClassMock([UIEvent class]);
2972  [forwardGectureRecognizer touchesMoved:touches2 withEvent:event2];
2973  OCMVerify([flutterViewController touchesMoved:touches2 withEvent:event2]);
2974 
2975  NSSet* touches3 = [[NSSet alloc] init];
2976  id event3 = OCMClassMock([UIEvent class]);
2977  [forwardGectureRecognizer touchesCancelled:touches3 withEvent:event3];
2978  OCMVerify([flutterViewController forceTouchesCancelled:touches3]);
2979 
2980  // Now the 2nd touch sequence should not be allowed.
2981  NSSet* touches4 = [[NSSet alloc] init];
2982  id event4 = OCMClassMock([UIEvent class]);
2983  [forwardGectureRecognizer touchesBegan:touches4 withEvent:event4];
2984  OCMReject([flutterViewController touchesBegan:touches4 withEvent:event4]);
2985 
2986  NSSet* touches5 = [[NSSet alloc] init];
2987  id event5 = OCMClassMock([UIEvent class]);
2988  [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
2989  OCMReject([flutterViewController touchesEnded:touches5 withEvent:event5]);
2990  }
2991 
2992  [flutterPlatformViewsController reset];
2993 }
2994 
2995 - (void)
2996  testSetFlutterViewControllerInTheMiddleOfTouchEventAllowsTheNewControllerToHandleSecondTouchSequence {
2997  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
2998 
2999  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3000  FlutterPlatformViewsController* flutterPlatformViewsController =
3001  [[FlutterPlatformViewsController alloc] init];
3002  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3003  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3004  /*delegate=*/mock_delegate,
3005  /*platform_views_controller=*/flutterPlatformViewsController,
3006  /*task_runners=*/runners.taskRunners,
3007  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3008 
3011  [flutterPlatformViewsController
3012  registerViewFactory:factory
3013  withId:@"MockFlutterPlatformView"
3014  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3015  FlutterResult result = ^(id result) {
3016  };
3017  [flutterPlatformViewsController
3019  arguments:@{
3020  @"id" : @2,
3021  @"viewType" : @"MockFlutterPlatformView",
3022  @"gestureBlockingPolicy" : @"eager"
3023  }]
3024  result:result];
3025 
3026  XCTAssertNotNil(gMockPlatformView);
3027 
3028  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3029  XCTAssertNotNil(touchInterceptorView);
3030 
3031  UIGestureRecognizer* forwardGectureRecognizer =
3032  FindForwardingGestureRecognizer(touchInterceptorView);
3033  id flutterViewController = OCMClassMock([FlutterViewController class]);
3034  flutterPlatformViewsController.flutterViewController = flutterViewController;
3035 
3036  // The touches in this sequence requires 1 touch object, we always create the NSSet with one item.
3037  NSSet* touches1 = [NSSet setWithObject:@1];
3038  id event1 = OCMClassMock([UIEvent class]);
3039  [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
3040  OCMVerify([flutterViewController touchesBegan:touches1 withEvent:event1]);
3041 
3042  FlutterViewController* flutterViewController2 = OCMClassMock([FlutterViewController class]);
3043  flutterPlatformViewsController.flutterViewController = flutterViewController2;
3044 
3045  // Touch events should still send to the old FlutterViewController if FlutterViewController
3046  // is updated in between.
3047  NSSet* touches2 = [NSSet setWithObject:@1];
3048  id event2 = OCMClassMock([UIEvent class]);
3049  [forwardGectureRecognizer touchesBegan:touches2 withEvent:event2];
3050  OCMVerify([flutterViewController touchesBegan:touches2 withEvent:event2]);
3051  OCMReject([flutterViewController2 touchesBegan:touches2 withEvent:event2]);
3052 
3053  NSSet* touches3 = [NSSet setWithObject:@1];
3054  id event3 = OCMClassMock([UIEvent class]);
3055  [forwardGectureRecognizer touchesMoved:touches3 withEvent:event3];
3056  OCMVerify([flutterViewController touchesMoved:touches3 withEvent:event3]);
3057  OCMReject([flutterViewController2 touchesMoved:touches3 withEvent:event3]);
3058 
3059  NSSet* touches4 = [NSSet setWithObject:@1];
3060  id event4 = OCMClassMock([UIEvent class]);
3061  [forwardGectureRecognizer touchesEnded:touches4 withEvent:event4];
3062  OCMVerify([flutterViewController touchesEnded:touches4 withEvent:event4]);
3063  OCMReject([flutterViewController2 touchesEnded:touches4 withEvent:event4]);
3064 
3065  NSSet* touches5 = [NSSet setWithObject:@1];
3066  id event5 = OCMClassMock([UIEvent class]);
3067  [forwardGectureRecognizer touchesEnded:touches5 withEvent:event5];
3068  OCMVerify([flutterViewController touchesEnded:touches5 withEvent:event5]);
3069  OCMReject([flutterViewController2 touchesEnded:touches5 withEvent:event5]);
3070 
3071  // Now the 2nd touch sequence should go to the new FlutterViewController
3072 
3073  NSSet* touches6 = [NSSet setWithObject:@1];
3074  id event6 = OCMClassMock([UIEvent class]);
3075  [forwardGectureRecognizer touchesBegan:touches6 withEvent:event6];
3076  OCMVerify([flutterViewController2 touchesBegan:touches6 withEvent:event6]);
3077  OCMReject([flutterViewController touchesBegan:touches6 withEvent:event6]);
3078 
3079  // Allow the touch events to finish
3080  NSSet* touches7 = [NSSet setWithObject:@1];
3081  id event7 = OCMClassMock([UIEvent class]);
3082  [forwardGectureRecognizer touchesMoved:touches7 withEvent:event7];
3083  OCMVerify([flutterViewController2 touchesMoved:touches7 withEvent:event7]);
3084  OCMReject([flutterViewController touchesMoved:touches7 withEvent:event7]);
3085 
3086  NSSet* touches8 = [NSSet setWithObject:@1];
3087  id event8 = OCMClassMock([UIEvent class]);
3088  [forwardGectureRecognizer touchesEnded:touches8 withEvent:event8];
3089  OCMVerify([flutterViewController2 touchesEnded:touches8 withEvent:event8]);
3090  OCMReject([flutterViewController touchesEnded:touches8 withEvent:event8]);
3091 
3092  [flutterPlatformViewsController reset];
3093 }
3094 
3095 - (void)testFlutterPlatformViewTouchesCancelledEventAreForcedToBeCancelled {
3096  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3097 
3098  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3099  FlutterPlatformViewsController* flutterPlatformViewsController =
3100  [[FlutterPlatformViewsController alloc] init];
3101  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3102  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3103  /*delegate=*/mock_delegate,
3104  /*platform_views_controller=*/flutterPlatformViewsController,
3105  /*task_runners=*/runners.taskRunners,
3106  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3107 
3110  [flutterPlatformViewsController
3111  registerViewFactory:factory
3112  withId:@"MockFlutterPlatformView"
3113  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3114  FlutterResult result = ^(id result) {
3115  };
3116  [flutterPlatformViewsController
3118  arguments:@{
3119  @"id" : @2,
3120  @"viewType" : @"MockFlutterPlatformView",
3121  @"gestureBlockingPolicy" : @"eager"
3122  }]
3123  result:result];
3124 
3125  XCTAssertNotNil(gMockPlatformView);
3126 
3127  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3128  XCTAssertNotNil(touchInterceptorView);
3129 
3130  UIGestureRecognizer* forwardGectureRecognizer =
3131  FindForwardingGestureRecognizer(touchInterceptorView);
3132  id flutterViewController = OCMClassMock([FlutterViewController class]);
3133  flutterPlatformViewsController.flutterViewController = flutterViewController;
3134 
3135  NSSet* touches1 = [NSSet setWithObject:@1];
3136  id event1 = OCMClassMock([UIEvent class]);
3137  [forwardGectureRecognizer touchesBegan:touches1 withEvent:event1];
3138 
3139  [forwardGectureRecognizer touchesCancelled:touches1 withEvent:event1];
3140  OCMVerify([flutterViewController forceTouchesCancelled:touches1]);
3141 
3142  [flutterPlatformViewsController reset];
3143 }
3144 
3145 - (void)testFlutterPlatformViewTouchesEndedOrTouchesCancelledEventDoesNotFailTheGestureRecognizer {
3146  // This test verifies a workaround for an Apple bug (flutter/flutter#136244) where the gesture
3147  // recognizer gets stuck at UIGestureRecognizerStateFailed. Apple fixed this bug in iOS 26,
3148  // so the workaround (and this test) is no longer needed on iOS 26+.
3149  // See: https://github.com/flutter/flutter/issues/179907
3150  if (@available(iOS 26.0, *)) {
3151  return;
3152  }
3153 
3154  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3155 
3156  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3157  FlutterPlatformViewsController* flutterPlatformViewsController =
3158  [[FlutterPlatformViewsController alloc] init];
3159  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3160  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3161  /*delegate=*/mock_delegate,
3162  /*platform_views_controller=*/flutterPlatformViewsController,
3163  /*task_runners=*/runners.taskRunners,
3164  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3165 
3168  [flutterPlatformViewsController
3169  registerViewFactory:factory
3170  withId:@"MockFlutterPlatformView"
3171  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3172  FlutterResult result = ^(id result) {
3173  };
3174  [flutterPlatformViewsController
3176  arguments:@{
3177  @"id" : @2,
3178  @"viewType" : @"MockFlutterPlatformView",
3179  @"gestureBlockingPolicy" : @"eager"
3180  }]
3181  result:result];
3182 
3183  XCTAssertNotNil(gMockPlatformView);
3184 
3185  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3186  XCTAssertNotNil(touchInterceptorView);
3187 
3188  __block UIGestureRecognizer* forwardGestureRecognizer =
3189  FindForwardingGestureRecognizer(touchInterceptorView);
3190  id flutterViewController = OCMClassMock([FlutterViewController class]);
3191  flutterPlatformViewsController.flutterViewController = flutterViewController;
3192 
3193  NSSet* touches1 = [NSSet setWithObject:@1];
3194  id event1 = OCMClassMock([UIEvent class]);
3195  XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3196  @"Forwarding gesture recognizer must start with possible state.");
3197  [forwardGestureRecognizer touchesBegan:touches1 withEvent:event1];
3198  [forwardGestureRecognizer touchesEnded:touches1 withEvent:event1];
3199  XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStateFailed,
3200  @"Forwarding gesture recognizer must end with failed state.");
3201 
3202  XCTestExpectation* touchEndedExpectation =
3203  [self expectationWithDescription:@"Wait for gesture recognizer's state change."];
3204  dispatch_async(dispatch_get_main_queue(), ^{
3205  // Re-query forward gesture recognizer since it's recreated.
3206  forwardGestureRecognizer = FindForwardingGestureRecognizer(touchInterceptorView);
3207  XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3208  @"Forwarding gesture recognizer must be reset to possible state.");
3209  [touchEndedExpectation fulfill];
3210  });
3211  [self waitForExpectationsWithTimeout:30 handler:nil];
3212 
3213  XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3214  @"Forwarding gesture recognizer must start with possible state.");
3215  [forwardGestureRecognizer touchesBegan:touches1 withEvent:event1];
3216  [forwardGestureRecognizer touchesCancelled:touches1 withEvent:event1];
3217  XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStateFailed,
3218  @"Forwarding gesture recognizer must end with failed state.");
3219  XCTestExpectation* touchCancelledExpectation =
3220  [self expectationWithDescription:@"Wait for gesture recognizer's state change."];
3221  dispatch_async(dispatch_get_main_queue(), ^{
3222  // Re-query forward gesture recognizer since it's recreated.
3223  forwardGestureRecognizer = FindForwardingGestureRecognizer(touchInterceptorView);
3224  XCTAssert(forwardGestureRecognizer.state == UIGestureRecognizerStatePossible,
3225  @"Forwarding gesture recognizer must be reset to possible state.");
3226  [touchCancelledExpectation fulfill];
3227  });
3228  [self waitForExpectationsWithTimeout:30 handler:nil];
3229 
3230  [flutterPlatformViewsController reset];
3231 }
3232 
3233 - (void)
3234  testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForWebView {
3235  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3236 
3237  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3238  FlutterPlatformViewsController* flutterPlatformViewsController =
3239  [[FlutterPlatformViewsController alloc] init];
3240  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3241  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3242  /*delegate=*/mock_delegate,
3243  /*platform_views_controller=*/flutterPlatformViewsController,
3244  /*task_runners=*/runners.taskRunners,
3245  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3246 
3249  [flutterPlatformViewsController
3250  registerViewFactory:factory
3251  withId:@"MockWebView"
3252  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3253  FlutterResult result = ^(id result) {
3254  };
3255  [flutterPlatformViewsController
3257  arguments:@{
3258  @"id" : @2,
3259  @"viewType" : @"MockWebView",
3260  @"gestureBlockingPolicy" : @"eager"
3261  }]
3262  result:result];
3263 
3264  XCTAssertNotNil(gMockPlatformView);
3265 
3266  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3267  XCTAssertNotNil(touchInterceptorView);
3268 
3269  XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3270  UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3271  UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3272 
3273  XCTAssert([delayingRecognizer isKindOfClass:[FlutterDelayingGestureRecognizer class]]);
3274  XCTAssert([forwardingRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]);
3275 
3276  [touchInterceptorView blockGesture];
3277 
3278  BOOL shouldReAddDelayingRecognizer = NO;
3279  if (@available(iOS 26.0, *)) {
3280  // We use a different workaround for iOS 26 and it is tested separately.
3281  // See:
3282  // testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForSimpleWebView.
3283  } else if (@available(iOS 18.2, *)) {
3284  shouldReAddDelayingRecognizer = YES;
3285  }
3286  if (shouldReAddDelayingRecognizer) {
3287  // Since we remove and add back delayingRecognizer, it would be reordered to the last.
3288  XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], forwardingRecognizer);
3289  XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], delayingRecognizer);
3290  } else {
3291  XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3292  XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3293  }
3294 }
3295 
3296 - (void)
3297  testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForWrapperWebView {
3298  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3299 
3300  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3301  FlutterPlatformViewsController* flutterPlatformViewsController =
3302  [[FlutterPlatformViewsController alloc] init];
3303  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3304  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3305  /*delegate=*/mock_delegate,
3306  /*platform_views_controller=*/flutterPlatformViewsController,
3307  /*task_runners=*/runners.taskRunners,
3308  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3309 
3312  [flutterPlatformViewsController
3313  registerViewFactory:factory
3314  withId:@"MockWrapperWebView"
3315  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3316  FlutterResult result = ^(id result) {
3317  };
3318  [flutterPlatformViewsController
3320  methodCallWithMethodName:@"create"
3321  arguments:@{
3322  @"id" : @2,
3323  @"viewType" : @"MockWrapperWebView",
3324  @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3325  }]
3326  result:result];
3327 
3328  XCTAssertNotNil(gMockPlatformView);
3329 
3330  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3331  XCTAssertNotNil(touchInterceptorView);
3332 
3333  XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3334  UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3335  UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3336 
3337  XCTAssert([delayingRecognizer isKindOfClass:[FlutterDelayingGestureRecognizer class]]);
3338  XCTAssert([forwardingRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]);
3339 
3340  [touchInterceptorView blockGesture];
3341 
3342  BOOL shouldReAddDelayingRecognizer = NO;
3343  if (@available(iOS 26.0, *)) {
3344  // We use a different workaround for iOS 26 and it is tested separately.
3345  // See:
3346  // testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForSimpleWebView.
3347  } else if (@available(iOS 18.2, *)) {
3348  shouldReAddDelayingRecognizer = YES;
3349  }
3350  if (shouldReAddDelayingRecognizer) {
3351  // Since we remove and add back delayingRecognizer, it would be reordered to the last.
3352  XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], forwardingRecognizer);
3353  XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], delayingRecognizer);
3354  } else {
3355  XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3356  XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3357  }
3358 }
3359 
3360 - (void)
3361  testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldRemoveAndAddBackDelayingRecognizerForNestedWrapperWebView {
3362  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3363 
3364  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3365  FlutterPlatformViewsController* flutterPlatformViewsController =
3366  [[FlutterPlatformViewsController alloc] init];
3367  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3368  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3369  /*delegate=*/mock_delegate,
3370  /*platform_views_controller=*/flutterPlatformViewsController,
3371  /*task_runners=*/runners.taskRunners,
3372  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3373 
3376  [flutterPlatformViewsController
3377  registerViewFactory:factory
3378  withId:@"MockNestedWrapperWebView"
3379  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3380  FlutterResult result = ^(id result) {
3381  };
3382  [flutterPlatformViewsController
3384  arguments:@{
3385  @"id" : @2,
3386  @"viewType" : @"MockNestedWrapperWebView",
3387  @"gestureBlockingPolicy" : @"eager"
3388  }]
3389  result:result];
3390 
3391  XCTAssertNotNil(gMockPlatformView);
3392 
3393  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3394  XCTAssertNotNil(touchInterceptorView);
3395 
3396  XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3397  UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3398  UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3399 
3400  XCTAssert([delayingRecognizer isKindOfClass:[FlutterDelayingGestureRecognizer class]]);
3401  XCTAssert([forwardingRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]);
3402 
3403  [touchInterceptorView blockGesture];
3404 
3405  BOOL shouldReAddDelayingRecognizer = NO;
3406  if (@available(iOS 26.0, *)) {
3407  // We use a different workaround for iOS 26 and it is tested separately.
3408  // See:
3409  // testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForSimpleWebView.
3410  } else if (@available(iOS 18.2, *)) {
3411  shouldReAddDelayingRecognizer = YES;
3412  }
3413  if (shouldReAddDelayingRecognizer) {
3414  // Since we remove and add back delayingRecognizer, it would be reordered to the last.
3415  XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], forwardingRecognizer);
3416  XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], delayingRecognizer);
3417  } else {
3418  XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3419  XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3420  }
3421 }
3422 
3423 - (void)
3424  testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldNotRemoveAndAddBackDelayingRecognizerForNonWebView {
3425  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3426 
3427  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3428  FlutterPlatformViewsController* flutterPlatformViewsController =
3429  [[FlutterPlatformViewsController alloc] init];
3430  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3431  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3432  /*delegate=*/mock_delegate,
3433  /*platform_views_controller=*/flutterPlatformViewsController,
3434  /*task_runners=*/runners.taskRunners,
3435  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3436 
3439  [flutterPlatformViewsController
3440  registerViewFactory:factory
3441  withId:@"MockFlutterPlatformView"
3442  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3443  FlutterResult result = ^(id result) {
3444  };
3445  [flutterPlatformViewsController
3447  arguments:@{
3448  @"id" : @2,
3449  @"viewType" : @"MockFlutterPlatformView",
3450  @"gestureBlockingPolicy" : @"eager"
3451  }]
3452  result:result];
3453 
3454  XCTAssertNotNil(gMockPlatformView);
3455 
3456  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3457  XCTAssertNotNil(touchInterceptorView);
3458 
3459  XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3460  UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3461  UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3462 
3463  XCTAssert([delayingRecognizer isKindOfClass:[FlutterDelayingGestureRecognizer class]]);
3464  XCTAssert([forwardingRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]);
3465 
3466  [touchInterceptorView blockGesture];
3467 
3468  XCTAssertEqual(touchInterceptorView.gestureRecognizers[0], delayingRecognizer);
3469  XCTAssertEqual(touchInterceptorView.gestureRecognizers[1], forwardingRecognizer);
3470 }
3471 
3472 - (void)
3473  testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForSimpleWebView {
3474  if (@available(iOS 26.4, *)) {
3475  // Skip workaround as this non-tappable web view bug has been fixed on iOS 26.4.
3476  } else if (@available(iOS 26.0, *)) {
3477  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3478 
3479  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3480  FlutterPlatformViewsController* flutterPlatformViewsController =
3481  [[FlutterPlatformViewsController alloc] init];
3482  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3483  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3484  /*delegate=*/mock_delegate,
3485  /*platform_views_controller=*/flutterPlatformViewsController,
3486  /*task_runners=*/runners.taskRunners,
3487  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3488 
3491  [flutterPlatformViewsController
3492  registerViewFactory:factory
3493  withId:@"MockWebView"
3494  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3495  FlutterResult result = ^(id result) {
3496  };
3497  [flutterPlatformViewsController
3499  methodCallWithMethodName:@"create"
3500  arguments:@{
3501  @"id" : @2,
3502  @"viewType" : @"MockWebView",
3503  @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3504  }]
3505  result:result];
3506 
3507  XCTAssertNotNil(gMockPlatformView);
3508 
3509  FlutterTouchInterceptingView* touchInterceptorView =
3510  FindTouchInterceptingView(gMockPlatformView);
3511  XCTAssertNotNil(touchInterceptorView);
3512 
3513  /*
3514  Simple Web View at root, with [*] indicating views containing
3515  MockTouchEventsGestureRecognizer.
3516 
3517  Root (Web View) [*]
3518  ├── Child 1
3519  └── Child 2
3520  ├── Child 2.1
3521  └── Child 2.2 [*]
3522  */
3523 
3524  UIView* root = gMockPlatformView;
3525  root.gestureRecognizers = nil;
3526  for (UIView* subview in root.subviews) {
3527  [subview removeFromSuperview];
3528  }
3529 
3530  MockGestureRecognizer* normalRecognizer0 = [[MockGestureRecognizer alloc] init];
3531  [root addGestureRecognizer:normalRecognizer0];
3532 
3533  UIView* child1 = [[UIView alloc] init];
3534  [root addSubview:child1];
3535  MockGestureRecognizer* normalRecognizer1 = [[MockGestureRecognizer alloc] init];
3536  [child1 addGestureRecognizer:normalRecognizer1];
3537 
3538  UIView* child2 = [[UIView alloc] init];
3539  [root addSubview:child2];
3540  MockGestureRecognizer* normalRecognizer2 = [[MockGestureRecognizer alloc] init];
3541  [child2 addGestureRecognizer:normalRecognizer2];
3542 
3543  UIView* child2_1 = [[UIView alloc] init];
3544  [child2 addSubview:child2_1];
3545  MockGestureRecognizer* normalRecognizer2_1 = [[MockGestureRecognizer alloc] init];
3546  [child2_1 addGestureRecognizer:normalRecognizer2_1];
3547 
3548  UIView* child2_2 = [[UIView alloc] init];
3549  [child2 addSubview:child2_2];
3550  MockGestureRecognizer* normalRecognizer2_2 = [[MockGestureRecognizer alloc] init];
3551  [child2_2 addGestureRecognizer:normalRecognizer2_2];
3552 
3553  // Add the target recognizer at root & child2_2.
3554  MockTouchEventsGestureRecognizer* targetRecognizer0 =
3555  [[MockTouchEventsGestureRecognizer alloc] init];
3556  [root addGestureRecognizer:targetRecognizer0];
3557 
3558  MockTouchEventsGestureRecognizer* targetRecognizer2_2 =
3559  [[MockTouchEventsGestureRecognizer alloc] init];
3560  [child2_2 addGestureRecognizer:targetRecognizer2_2];
3561 
3562  [touchInterceptorView blockGesture];
3563 
3564  NSArray* normalRecognizers = @[
3565  normalRecognizer0, normalRecognizer1, normalRecognizer2, normalRecognizer2_1,
3566  normalRecognizer2_2
3567  ];
3568 
3569  NSArray* targetRecognizers = @[ targetRecognizer0, targetRecognizer2_2 ];
3570 
3571  NSArray* expectedEmptyHistory = @[];
3572  NSArray* expectedToggledHistory = @[ @NO, @YES ];
3573 
3574  for (MockGestureRecognizer* recognizer in normalRecognizers) {
3575  XCTAssertEqualObjects(recognizer.toggleHistory, expectedEmptyHistory);
3576  }
3577  for (MockGestureRecognizer* recognizer in targetRecognizers) {
3578  XCTAssertEqualObjects(recognizer.toggleHistory, expectedToggledHistory);
3579  }
3580  }
3581 }
3582 
3583 - (void)
3584  testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForMultipleWebViewInDifferentBranches {
3585  if (@available(iOS 26.4, *)) {
3586  // Skip workaround as this non-tappable web view bug has been fixed on iOS 26.4.
3587  } else if (@available(iOS 26.0, *)) {
3588  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3589 
3590  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3591  FlutterPlatformViewsController* flutterPlatformViewsController =
3592  [[FlutterPlatformViewsController alloc] init];
3593  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3594  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3595  /*delegate=*/mock_delegate,
3596  /*platform_views_controller=*/flutterPlatformViewsController,
3597  /*task_runners=*/runners.taskRunners,
3598  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3599 
3602  [flutterPlatformViewsController
3603  registerViewFactory:factory
3604  withId:@"MockWrapperWebView"
3605  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3606  FlutterResult result = ^(id result) {
3607  };
3608  [flutterPlatformViewsController
3610  methodCallWithMethodName:@"create"
3611  arguments:@{
3612  @"id" : @2,
3613  @"viewType" : @"MockWrapperWebView",
3614  @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3615  }]
3616  result:result];
3617 
3618  XCTAssertNotNil(gMockPlatformView);
3619 
3620  FlutterTouchInterceptingView* touchInterceptorView =
3621  FindTouchInterceptingView(gMockPlatformView);
3622  XCTAssertNotNil(touchInterceptorView);
3623 
3624  /*
3625  Platform View with Multiple Web Views in different branches, with [*] indicating views
3626  containing MockTouchEventsGestureRecognizer.
3627 
3628  Root (Platform View)
3629  ├── Child 1
3630  ├── Child 2 (Web View)
3631  | ├── Child 2.1
3632  | └── Child 2.2 [*]
3633  └── Child 3
3634  └── Child 3.1 (Web View)
3635  ├── Child 3.1.1
3636  └── Child 3.1.2 [*]
3637  */
3638 
3639  UIView* root = gMockPlatformView;
3640  for (UIView* subview in root.subviews) {
3641  [subview removeFromSuperview];
3642  }
3643 
3644  MockGestureRecognizer* normalRecognizer0 = [[MockGestureRecognizer alloc] init];
3645  [root addGestureRecognizer:normalRecognizer0];
3646 
3647  UIView* child1 = [[UIView alloc] init];
3648  [root addSubview:child1];
3649  MockGestureRecognizer* normalRecognizer1 = [[MockGestureRecognizer alloc] init];
3650  [child1 addGestureRecognizer:normalRecognizer1];
3651 
3652  UIView* child2 = [[WKWebView alloc] init];
3653  child2.gestureRecognizers = nil;
3654  for (UIView* subview in child2.subviews) {
3655  [subview removeFromSuperview];
3656  }
3657  [root addSubview:child2];
3658  MockGestureRecognizer* normalRecognizer2 = [[MockGestureRecognizer alloc] init];
3659  [child2 addGestureRecognizer:normalRecognizer2];
3660 
3661  UIView* child2_1 = [[UIView alloc] init];
3662  [child2 addSubview:child2_1];
3663  MockGestureRecognizer* normalRecognizer2_1 = [[MockGestureRecognizer alloc] init];
3664  [child2_1 addGestureRecognizer:normalRecognizer2_1];
3665 
3666  UIView* child2_2 = [[UIView alloc] init];
3667  [child2 addSubview:child2_2];
3668  MockGestureRecognizer* normalRecognizer2_2 = [[MockGestureRecognizer alloc] init];
3669  [child2_2 addGestureRecognizer:normalRecognizer2_2];
3670 
3671  UIView* child3 = [[UIView alloc] init];
3672  [root addSubview:child3];
3673  MockGestureRecognizer* normalRecognizer3 = [[MockGestureRecognizer alloc] init];
3674  [child3 addGestureRecognizer:normalRecognizer3];
3675 
3676  UIView* child3_1 = [[WKWebView alloc] init];
3677  child3_1.gestureRecognizers = nil;
3678  for (UIView* subview in child3_1.subviews) {
3679  [subview removeFromSuperview];
3680  }
3681  [child3 addSubview:child3_1];
3682  MockGestureRecognizer* normalRecognizer3_1 = [[MockGestureRecognizer alloc] init];
3683  [child3_1 addGestureRecognizer:normalRecognizer3_1];
3684 
3685  UIView* child3_1_1 = [[UIView alloc] init];
3686  [child3_1 addSubview:child3_1_1];
3687  MockGestureRecognizer* normalRecognizer3_1_1 = [[MockGestureRecognizer alloc] init];
3688  [child3_1_1 addGestureRecognizer:normalRecognizer3_1_1];
3689 
3690  UIView* child3_1_2 = [[UIView alloc] init];
3691  [child3_1 addSubview:child3_1_2];
3692  MockGestureRecognizer* normalRecognizer3_1_2 = [[MockGestureRecognizer alloc] init];
3693  [child3_1_2 addGestureRecognizer:normalRecognizer3_1_2];
3694 
3695  // Add the target recognizer at child2_2 & child3_1_2
3696 
3697  MockTouchEventsGestureRecognizer* targetRecognizer2_2 =
3698  [[MockTouchEventsGestureRecognizer alloc] init];
3699  [child2_2 addGestureRecognizer:targetRecognizer2_2];
3700 
3701  MockTouchEventsGestureRecognizer* targetRecognizer3_1_2 =
3702  [[MockTouchEventsGestureRecognizer alloc] init];
3703  [child3_1_2 addGestureRecognizer:targetRecognizer3_1_2];
3704 
3705  [touchInterceptorView blockGesture];
3706 
3707  NSArray* normalRecognizers = @[
3708  normalRecognizer0, normalRecognizer1, normalRecognizer2, normalRecognizer2_1,
3709  normalRecognizer2_2, normalRecognizer3, normalRecognizer3_1, normalRecognizer3_1_1,
3710  normalRecognizer3_1_2
3711  ];
3712  NSArray* targetRecognizers = @[ targetRecognizer2_2, targetRecognizer3_1_2 ];
3713 
3714  NSArray* expectedEmptyHistory = @[];
3715  NSArray* expectedToggledHistory = @[ @NO, @YES ];
3716 
3717  for (MockGestureRecognizer* recognizer in normalRecognizers) {
3718  XCTAssertEqualObjects(recognizer.toggleHistory, expectedEmptyHistory);
3719  }
3720 
3721  for (MockGestureRecognizer* recognizer in targetRecognizers) {
3722  XCTAssertEqualObjects(recognizer.toggleHistory, expectedToggledHistory);
3723  }
3724  }
3725 }
3726 
3727 - (void)
3728  testFlutterPlatformViewBlockGestureUnderEagerPolicyShouldDisableAndReEnableTouchEventsGestureRecognizerForNestedMultipleWebView {
3729  if (@available(iOS 26.4, *)) {
3730  // Skip workaround as this non-tappable web view bug has been fixed on iOS 26.4.
3731  } else if (@available(iOS 26.0, *)) {
3732  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3733 
3734  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3735  FlutterPlatformViewsController* flutterPlatformViewsController =
3736  [[FlutterPlatformViewsController alloc] init];
3737  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3738  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3739  /*delegate=*/mock_delegate,
3740  /*platform_views_controller=*/flutterPlatformViewsController,
3741  /*task_runners=*/runners.taskRunners,
3742  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3743 
3746  [flutterPlatformViewsController
3747  registerViewFactory:factory
3748  withId:@"MockWebView"
3749  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3750  FlutterResult result = ^(id result) {
3751  };
3752  [flutterPlatformViewsController
3754  methodCallWithMethodName:@"create"
3755  arguments:@{
3756  @"id" : @2,
3757  @"viewType" : @"MockWebView",
3758  @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
3759  }]
3760  result:result];
3761 
3762  XCTAssertNotNil(gMockPlatformView);
3763 
3764  FlutterTouchInterceptingView* touchInterceptorView =
3765  FindTouchInterceptingView(gMockPlatformView);
3766  XCTAssertNotNil(touchInterceptorView);
3767 
3768  /*
3769  Platform View with nested web views, with [*] indicating views containing
3770  MockTouchEventsGestureRecognizer.
3771 
3772  Root (Web View)
3773  ├── Child 1
3774  ├── Child 2
3775  | ├── Child 2.1
3776  | └── Child 2.2 [*]
3777  └── Child 3
3778  └── Child 3.1 (Another Web View)
3779  └── Child 3.1.1
3780  └── Child 3.1.2
3781  ├── Child 3.1.2.1
3782  └── Child 3.1.2.2 [*]
3783  */
3784 
3785  UIView* root = gMockPlatformView;
3786  root.gestureRecognizers = nil;
3787  for (UIView* subview in root.subviews) {
3788  [subview removeFromSuperview];
3789  }
3790 
3791  MockGestureRecognizer* normalRecognizer0 = [[MockGestureRecognizer alloc] init];
3792  [root addGestureRecognizer:normalRecognizer0];
3793 
3794  UIView* child1 = [[UIView alloc] init];
3795  [root addSubview:child1];
3796  MockGestureRecognizer* normalRecognizer1 = [[MockGestureRecognizer alloc] init];
3797  [child1 addGestureRecognizer:normalRecognizer1];
3798 
3799  UIView* child2 = [[UIView alloc] init];
3800  [root addSubview:child2];
3801  MockGestureRecognizer* normalRecognizer2 = [[MockGestureRecognizer alloc] init];
3802  [child2 addGestureRecognizer:normalRecognizer2];
3803 
3804  UIView* child2_1 = [[UIView alloc] init];
3805  [child2 addSubview:child2_1];
3806  MockGestureRecognizer* normalRecognizer2_1 = [[MockGestureRecognizer alloc] init];
3807  [child2_1 addGestureRecognizer:normalRecognizer2_1];
3808 
3809  UIView* child2_2 = [[UIView alloc] init];
3810  [child2 addSubview:child2_2];
3811  MockGestureRecognizer* normalRecognizer2_2 = [[MockGestureRecognizer alloc] init];
3812  [child2_2 addGestureRecognizer:normalRecognizer2_2];
3813 
3814  UIView* child3 = [[UIView alloc] init];
3815  [root addSubview:child3];
3816  MockGestureRecognizer* normalRecognizer3 = [[MockGestureRecognizer alloc] init];
3817  [child3 addGestureRecognizer:normalRecognizer3];
3818 
3819  UIView* child3_1 = [[WKWebView alloc] init];
3820  child3_1.gestureRecognizers = nil;
3821  for (UIView* subview in child3_1.subviews) {
3822  [subview removeFromSuperview];
3823  }
3824  [child3 addSubview:child3_1];
3825  MockGestureRecognizer* normalRecognizer3_1 = [[MockGestureRecognizer alloc] init];
3826  [child3_1 addGestureRecognizer:normalRecognizer3_1];
3827 
3828  UIView* child3_1_1 = [[UIView alloc] init];
3829  [child3_1 addSubview:child3_1_1];
3830  MockGestureRecognizer* normalRecognizer3_1_1 = [[MockGestureRecognizer alloc] init];
3831  [child3_1_1 addGestureRecognizer:normalRecognizer3_1_1];
3832 
3833  UIView* child3_1_2 = [[UIView alloc] init];
3834  [child3_1 addSubview:child3_1_2];
3835  MockGestureRecognizer* normalRecognizer3_1_2 = [[MockGestureRecognizer alloc] init];
3836  [child3_1_2 addGestureRecognizer:normalRecognizer3_1_2];
3837 
3838  UIView* child3_1_2_1 = [[UIView alloc] init];
3839  [child3_1_2 addSubview:child3_1_2_1];
3840  MockGestureRecognizer* normalRecognizer3_1_2_1 = [[MockGestureRecognizer alloc] init];
3841  [child3_1_2_1 addGestureRecognizer:normalRecognizer3_1_2_1];
3842 
3843  UIView* child3_1_2_2 = [[UIView alloc] init];
3844  [child3_1_2 addSubview:child3_1_2_2];
3845  MockGestureRecognizer* normalRecognizer3_1_2_2 = [[MockGestureRecognizer alloc] init];
3846  [child3_1_2_2 addGestureRecognizer:normalRecognizer3_1_2_2];
3847 
3848  // Add the target recognizer at child2_2 & child3_1_2_2
3849 
3850  MockTouchEventsGestureRecognizer* targetRecognizer2_2 =
3851  [[MockTouchEventsGestureRecognizer alloc] init];
3852  [child2_2 addGestureRecognizer:targetRecognizer2_2];
3853 
3854  MockTouchEventsGestureRecognizer* targetRecognizer3_1_2_2 =
3855  [[MockTouchEventsGestureRecognizer alloc] init];
3856  [child3_1_2_2 addGestureRecognizer:targetRecognizer3_1_2_2];
3857 
3858  [touchInterceptorView blockGesture];
3859 
3860  NSArray* normalRecognizers = @[
3861  normalRecognizer0, normalRecognizer1, normalRecognizer2, normalRecognizer2_1,
3862  normalRecognizer2_2, normalRecognizer3, normalRecognizer3_1, normalRecognizer3_1_1,
3863  normalRecognizer3_1_2, normalRecognizer3_1_2_1, normalRecognizer3_1_2_2
3864  ];
3865 
3866  NSArray* targetRecognizers = @[ targetRecognizer2_2, targetRecognizer3_1_2_2 ];
3867 
3868  NSArray* expectedEmptyHistory = @[];
3869  NSArray* expectedToggledHistory = @[ @NO, @YES ];
3870 
3871  for (MockGestureRecognizer* recognizer in normalRecognizers) {
3872  XCTAssertEqualObjects(recognizer.toggleHistory, expectedEmptyHistory);
3873  }
3874 
3875  for (MockGestureRecognizer* recognizer in targetRecognizers) {
3876  XCTAssertEqualObjects(recognizer.toggleHistory, expectedToggledHistory);
3877  }
3878  }
3879 }
3880 
3881 - (void)
3882  testFlutterPlatformViewGestureBlockingPolicy_ShouldNotAddDelayingRecognizerUnderDoNotBlockGesturePolicy {
3883  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3884 
3885  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3886  FlutterPlatformViewsController* flutterPlatformViewsController =
3887  [[FlutterPlatformViewsController alloc] init];
3888  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3889  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3890  /*delegate=*/mock_delegate,
3891  /*platform_views_controller=*/flutterPlatformViewsController,
3892  /*task_runners=*/runners.taskRunners,
3893  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3894 
3897  [flutterPlatformViewsController registerViewFactory:factory
3898  withId:@"MockFlutterPlatformView"
3900  FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture];
3901  FlutterResult result = ^(id result) {
3902  };
3903  [flutterPlatformViewsController
3905  methodCallWithMethodName:@"create"
3906  arguments:@{
3907  @"id" : @2,
3908  @"viewType" : @"MockFlutterPlatformView",
3909  @"gestureBlockingPolicy" : @"doNotBlockGesture"
3910  }]
3911  result:result];
3912 
3913  XCTAssertNotNil(gMockPlatformView);
3914 
3915  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3916  XCTAssertNotNil(touchInterceptorView);
3917 
3918  XCTAssert(touchInterceptorView.gestureRecognizers.count == 1);
3919  UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[0];
3920  XCTAssert([forwardingRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]);
3921 }
3922 
3923 - (void)testFlutterPlatformViewGestureBlockingPolicy_ShouldAddDelayingRecognizerUnderEagerPolicy {
3924  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3925 
3926  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3927  FlutterPlatformViewsController* flutterPlatformViewsController =
3928  [[FlutterPlatformViewsController alloc] init];
3929  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3930  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3931  /*delegate=*/mock_delegate,
3932  /*platform_views_controller=*/flutterPlatformViewsController,
3933  /*task_runners=*/runners.taskRunners,
3934  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3935 
3938  [flutterPlatformViewsController
3939  registerViewFactory:factory
3940  withId:@"MockFlutterPlatformView"
3941  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
3942  FlutterResult result = ^(id result) {
3943  };
3944  [flutterPlatformViewsController
3946  arguments:@{
3947  @"id" : @2,
3948  @"viewType" : @"MockFlutterPlatformView",
3949  @"gestureBlockingPolicy" : @"eager"
3950  }]
3951  result:result];
3952 
3953  XCTAssertNotNil(gMockPlatformView);
3954 
3955  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
3956  XCTAssertNotNil(touchInterceptorView);
3957 
3958  XCTAssert(touchInterceptorView.gestureRecognizers.count == 2);
3959  UIGestureRecognizer* delayingRecognizer = touchInterceptorView.gestureRecognizers[0];
3960  UIGestureRecognizer* forwardingRecognizer = touchInterceptorView.gestureRecognizers[1];
3961  XCTAssert([delayingRecognizer isKindOfClass:[FlutterDelayingGestureRecognizer class]]);
3962  XCTAssert([forwardingRecognizer isKindOfClass:[ForwardingGestureRecognizer class]]);
3963 }
3964 
3965 - (void)testFlutterPlatformViewHitTest_AcceptTouchIfInstructedByFramework {
3966  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
3967 
3968  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
3969  FlutterPlatformViewsController* flutterPlatformViewsController =
3970  [[FlutterPlatformViewsController alloc] init];
3971 
3972  FlutterViewController* mockFlutterViewController = OCMClassMock([FlutterViewController class]);
3973  flutterPlatformViewsController.flutterViewController = mockFlutterViewController;
3974 
3975  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
3976  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
3977  /*delegate=*/mock_delegate,
3978  /*platform_views_controller=*/flutterPlatformViewsController,
3979  /*task_runners=*/runners.taskRunners,
3980  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
3981 
3984  [flutterPlatformViewsController registerViewFactory:factory
3985  withId:@"MockFlutterPlatformView"
3987  FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture];
3988  FlutterResult result = ^(id result) {
3989  };
3990  [flutterPlatformViewsController
3992  methodCallWithMethodName:@"create"
3993  arguments:@{
3994  @"id" : @2,
3995  @"viewType" : @"MockFlutterPlatformView",
3996  @"gestureBlockingPolicy" : @"doNotBlockGesture"
3997  }]
3998  result:result];
3999 
4000  XCTAssertNotNil(gMockPlatformView);
4001 
4002  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
4003  XCTAssertNotNil(touchInterceptorView);
4004 
4005  touchInterceptorView.frame = CGRectMake(0, 0, 100, 100);
4006  CGPoint touchBeganLocation = CGPointMake(1, 1);
4007 
4008  UIEvent* mockEvent = OCMClassMock([UIEvent class]);
4009  OCMStub([mockEvent type]).andReturn(UIEventTypeTouches);
4010 
4011  // Framework instructs "accept touch".
4012  OCMStub([mockFlutterViewController
4013  platformViewShouldAcceptTouchAtTouchBeganLocation:touchBeganLocation])
4014  .andReturn(YES);
4015  UIView* hitTestResult = [touchInterceptorView hitTest:touchBeganLocation withEvent:mockEvent];
4016  // HitTest returning the platform view means platform view will receive touch events.
4017  XCTAssert(hitTestResult == gMockPlatformView);
4018 }
4019 
4020 - (void)testFlutterPlatformViewHitTest_RejectTouchIfInstructedByFramework {
4021  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4022 
4023  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4024  FlutterPlatformViewsController* flutterPlatformViewsController =
4025  [[FlutterPlatformViewsController alloc] init];
4026 
4027  FlutterViewController* mockFlutterViewController = OCMClassMock([FlutterViewController class]);
4028  flutterPlatformViewsController.flutterViewController = mockFlutterViewController;
4029 
4030  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4031  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4032  /*delegate=*/mock_delegate,
4033  /*platform_views_controller=*/flutterPlatformViewsController,
4034  /*task_runners=*/runners.taskRunners,
4035  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4036 
4039  [flutterPlatformViewsController registerViewFactory:factory
4040  withId:@"MockFlutterPlatformView"
4042  FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture];
4043  FlutterResult result = ^(id result) {
4044  };
4045  [flutterPlatformViewsController
4047  methodCallWithMethodName:@"create"
4048  arguments:@{
4049  @"id" : @2,
4050  @"viewType" : @"MockFlutterPlatformView",
4051  @"gestureBlockingPolicy" : @"doNotBlockGesture"
4052  }]
4053  result:result];
4054 
4055  XCTAssertNotNil(gMockPlatformView);
4056 
4057  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
4058  XCTAssertNotNil(touchInterceptorView);
4059 
4060  touchInterceptorView.frame = CGRectMake(0, 0, 100, 100);
4061  CGPoint touchBeganLocation = CGPointMake(1, 1);
4062 
4063  UIEvent* mockEvent = OCMClassMock([UIEvent class]);
4064  OCMStub([mockEvent type]).andReturn(UIEventTypeTouches);
4065 
4066  // Framework instructs "reject touch".
4067  OCMStub([mockFlutterViewController
4068  platformViewShouldAcceptTouchAtTouchBeganLocation:touchBeganLocation])
4069  .andReturn(NO);
4070  UIView* hitTestResult = [touchInterceptorView hitTest:touchBeganLocation withEvent:mockEvent];
4071  // HitTest returning the touch interceptor view means platform view will not receive touch events.
4072  XCTAssert(hitTestResult == touchInterceptorView);
4073 }
4074 
4075 - (void)testFlutterPlatformViewGestureBlockingPolicy_PolicyMappingIsCorrect {
4076  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4077 
4078  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4079  FlutterPlatformViewsController* flutterPlatformViewsController =
4080  [[FlutterPlatformViewsController alloc] init];
4081 
4082  FlutterViewController* mockFlutterViewController = OCMClassMock([FlutterViewController class]);
4083  flutterPlatformViewsController.flutterViewController = mockFlutterViewController;
4084 
4085  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4086  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4087  /*delegate=*/mock_delegate,
4088  /*platform_views_controller=*/flutterPlatformViewsController,
4089  /*task_runners=*/runners.taskRunners,
4090  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4091 
4094  [flutterPlatformViewsController registerViewFactory:factory
4095  withId:@"MockFlutterPlatformView"
4096  // the policy set by engine API will be overwritten by the dart API, unless
4097  // `fallbackToPluginDefault` is used in dart API.
4099  FlutterPlatformViewGestureRecognizersBlockingPolicyWaitUntilTouchesEnded];
4100  __block id methodResult;
4101  FlutterResult result = ^(id result) {
4102  methodResult = result;
4103  };
4104 
4105  // eager
4106  [flutterPlatformViewsController
4108  arguments:@{
4109  @"id" : @2,
4110  @"viewType" : @"MockFlutterPlatformView",
4111  @"gestureBlockingPolicy" : @"eager"
4112  }]
4113  result:result];
4114 
4115  FlutterTouchInterceptingView* touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
4116  XCTAssertEqual(touchInterceptorView.blockingPolicy,
4118 
4119  // waitUntilTouchesEnded
4120  [flutterPlatformViewsController
4122  methodCallWithMethodName:@"create"
4123  arguments:@{
4124  @"id" : @3,
4125  @"viewType" : @"MockFlutterPlatformView",
4126  @"gestureBlockingPolicy" : @"waitUntilTouchesEnded"
4127  }]
4128  result:result];
4129  touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
4130  XCTAssertEqual(touchInterceptorView.blockingPolicy,
4132 
4133  [flutterPlatformViewsController
4135  methodCallWithMethodName:@"create"
4136  arguments:@{
4137  @"id" : @4,
4138  @"viewType" : @"MockFlutterPlatformView",
4139  @"gestureBlockingPolicy" : @"doNotBlockGesture"
4140  }]
4141  result:result];
4142  touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
4143  XCTAssertEqual(touchInterceptorView.blockingPolicy,
4145  XCTAssertNil(methodResult);
4146 
4147  // fallbackToPluginDefault (which is waitUntilTouchesEnded)
4148  [flutterPlatformViewsController
4150  methodCallWithMethodName:@"create"
4151  arguments:@{
4152  @"id" : @5,
4153  @"viewType" : @"MockFlutterPlatformView",
4154  @"gestureBlockingPolicy" : @"fallbackToPluginDefault"
4155  }]
4156  result:result];
4157  touchInterceptorView = FindTouchInterceptingView(gMockPlatformView);
4158  XCTAssertEqual(touchInterceptorView.blockingPolicy,
4160  XCTAssertNil(methodResult);
4161 
4162  // Unkonwn gesture blocking policy should fail
4163  [flutterPlatformViewsController
4165  arguments:@{
4166  @"id" : @6,
4167  @"viewType" : @"MockFlutterPlatformView",
4168  @"gestureBlockingPolicy" : @"unknownPolicy"
4169  }]
4170  result:result];
4171  XCTAssertTrue([methodResult isKindOfClass:[FlutterError class]]);
4172  FlutterError* resultError = (FlutterError*)methodResult;
4173  XCTAssertEqualObjects(resultError.code, @"unknown_gesture_blocking_policy");
4174  XCTAssertEqualObjects(
4175  resultError.message,
4176  @"Trying to create a platform view with an unknown gesture blocking policy");
4177  XCTAssertEqualObjects(resultError.details, @"view id: '6'");
4178 }
4179 
4180 - (void)testFlutterPlatformViewControllerSubmitFrameWithoutFlutterViewNotCrashing {
4181  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4182 
4183  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4184  FlutterPlatformViewsController* flutterPlatformViewsController =
4185  [[FlutterPlatformViewsController alloc] init];
4186  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4187  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4188  /*delegate=*/mock_delegate,
4189  /*platform_views_controller=*/flutterPlatformViewsController,
4190  /*task_runners=*/runners.taskRunners,
4191  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4192 
4195  [flutterPlatformViewsController
4196  registerViewFactory:factory
4197  withId:@"MockFlutterPlatformView"
4198  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4199  FlutterResult result = ^(id result) {
4200  };
4201  [flutterPlatformViewsController
4203  arguments:@{
4204  @"id" : @2,
4205  @"viewType" : @"MockFlutterPlatformView",
4206  @"gestureBlockingPolicy" : @"eager"
4207  }]
4208  result:result];
4209 
4210  XCTAssertNotNil(gMockPlatformView);
4211 
4212  // Create embedded view params
4213  flutter::MutatorsStack stack;
4214  flutter::DlMatrix finalMatrix;
4215 
4216  auto embeddedViewParams_1 =
4217  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4218 
4219  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4220  withParams:std::move(embeddedViewParams_1)];
4221  [flutterPlatformViewsController
4222  compositeView:2
4223  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
4224 
4225  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4226  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4227  nullptr, framebuffer_info,
4228  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return false; },
4229  [](const flutter::SurfaceFrame& surface_frame) { return true; },
4230  /*frame_size=*/flutter::DlISize(800, 600));
4231  XCTAssertFalse([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4232  withIosContext:std::make_shared<FakeIOSContext>()]);
4233 
4234  auto embeddedViewParams_2 =
4235  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4236  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4237  withParams:std::move(embeddedViewParams_2)];
4238  [flutterPlatformViewsController
4239  compositeView:2
4240  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
4241 
4242  auto mock_surface_submit_true = std::make_unique<flutter::SurfaceFrame>(
4243  nullptr, framebuffer_info,
4244  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
4245  [](const flutter::SurfaceFrame& surface_frame) { return true; },
4246  /*frame_size=*/flutter::DlISize(800, 600));
4247  XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface_submit_true)
4248  withIosContext:std::make_shared<FakeIOSContext>()]);
4249 }
4250 
4251 - (void)
4252  testFlutterPlatformViewControllerResetDeallocsPlatformViewWhenRootViewsNotBindedToFlutterView {
4253  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4254 
4255  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4256  FlutterPlatformViewsController* flutterPlatformViewsController =
4257  [[FlutterPlatformViewsController alloc] init];
4258  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4259  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4260  /*delegate=*/mock_delegate,
4261  /*platform_views_controller=*/flutterPlatformViewsController,
4262  /*task_runners=*/runners.taskRunners,
4263  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4264 
4265  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4266  flutterPlatformViewsController.flutterView = flutterView;
4267 
4270  [flutterPlatformViewsController
4271  registerViewFactory:factory
4272  withId:@"MockFlutterPlatformView"
4273  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4274  FlutterResult result = ^(id result) {
4275  };
4276  // autorelease pool to trigger an autorelease for all the root_views_ and touch_interceptors_.
4277  @autoreleasepool {
4278  [flutterPlatformViewsController
4280  arguments:@{
4281  @"id" : @2,
4282  @"viewType" : @"MockFlutterPlatformView",
4283  @"gestureBlockingPolicy" : @"eager"
4284  }]
4285  result:result];
4286 
4287  flutter::MutatorsStack stack;
4288  flutter::DlMatrix finalMatrix;
4289  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
4290  finalMatrix, flutter::DlSize(300, 300), stack);
4291  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4292  withParams:std::move(embeddedViewParams)];
4293 
4294  // Not calling |[flutterPlatformViewsController submitFrame:withIosContext:]| so that
4295  // the platform views are not added to flutter_view_.
4296 
4297  XCTAssertNotNil(gMockPlatformView);
4298  [flutterPlatformViewsController reset];
4299  }
4300  XCTAssertNil(gMockPlatformView);
4301 }
4302 
4303 - (void)testFlutterPlatformViewControllerBeginFrameShouldResetCompisitionOrder {
4304  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4305 
4306  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4307  FlutterPlatformViewsController* flutterPlatformViewsController =
4308  [[FlutterPlatformViewsController alloc] init];
4309  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4310  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4311  /*delegate=*/mock_delegate,
4312  /*platform_views_controller=*/flutterPlatformViewsController,
4313  /*task_runners=*/runners.taskRunners,
4314  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4315 
4316  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4317  flutterPlatformViewsController.flutterView = flutterView;
4318 
4321  [flutterPlatformViewsController
4322  registerViewFactory:factory
4323  withId:@"MockFlutterPlatformView"
4324  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4325  FlutterResult result = ^(id result) {
4326  };
4327 
4328  [flutterPlatformViewsController
4330  arguments:@{
4331  @"id" : @0,
4332  @"viewType" : @"MockFlutterPlatformView",
4333  @"gestureBlockingPolicy" : @"eager"
4334 
4335  }]
4336  result:result];
4337 
4338  // First frame, |embeddedViewCount| is not empty after composite.
4339  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4340  flutter::MutatorsStack stack;
4341  flutter::DlMatrix finalMatrix;
4342  auto embeddedViewParams1 =
4343  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4344  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4345  withParams:std::move(embeddedViewParams1)];
4346  [flutterPlatformViewsController
4347  compositeView:0
4348  withParams:[flutterPlatformViewsController compositionParamsForView:0]];
4349 
4350  XCTAssertEqual(flutterPlatformViewsController.embeddedViewCount, 1UL);
4351 
4352  // Second frame, |embeddedViewCount| should be empty at the start
4353  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4354  XCTAssertEqual(flutterPlatformViewsController.embeddedViewCount, 0UL);
4355 
4356  auto embeddedViewParams2 =
4357  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4358  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4359  withParams:std::move(embeddedViewParams2)];
4360  [flutterPlatformViewsController
4361  compositeView:0
4362  withParams:[flutterPlatformViewsController compositionParamsForView:0]];
4363 
4364  XCTAssertEqual(flutterPlatformViewsController.embeddedViewCount, 1UL);
4365 }
4366 
4367 - (void)
4368  testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithDifferentViewHierarchy {
4369  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4370 
4371  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4372  FlutterPlatformViewsController* flutterPlatformViewsController =
4373  [[FlutterPlatformViewsController alloc] init];
4374  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4375  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4376  /*delegate=*/mock_delegate,
4377  /*platform_views_controller=*/flutterPlatformViewsController,
4378  /*task_runners=*/runners.taskRunners,
4379  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4380 
4381  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4382  flutterPlatformViewsController.flutterView = flutterView;
4383 
4386  [flutterPlatformViewsController
4387  registerViewFactory:factory
4388  withId:@"MockFlutterPlatformView"
4389  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4390  FlutterResult result = ^(id result) {
4391  };
4392  [flutterPlatformViewsController
4394  arguments:@{
4395  @"id" : @0,
4396  @"viewType" : @"MockFlutterPlatformView",
4397  @"gestureBlockingPolicy" : @"eager"
4398  }]
4399  result:result];
4400  UIView* view1 = gMockPlatformView;
4401 
4402  // This overwrites `gMockPlatformView` to another view.
4403  [flutterPlatformViewsController
4405  arguments:@{
4406  @"id" : @1,
4407  @"viewType" : @"MockFlutterPlatformView",
4408  @"gestureBlockingPolicy" : @"eager"
4409  }]
4410  result:result];
4411  UIView* view2 = gMockPlatformView;
4412 
4413  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4414  flutter::MutatorsStack stack;
4415  flutter::DlMatrix finalMatrix;
4416  auto embeddedViewParams1 =
4417  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4418  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4419  withParams:std::move(embeddedViewParams1)];
4420 
4421  auto embeddedViewParams2 =
4422  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4423  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4424  withParams:std::move(embeddedViewParams2)];
4425 
4426  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4427  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4428  nullptr, framebuffer_info,
4429  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
4430  [](const flutter::SurfaceFrame& surface_frame) { return true; },
4431  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
4432  XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4433  withIosContext:std::make_shared<FakeIOSContext>()]);
4434 
4435  // platform view is wrapped by touch interceptor, which itself is wrapped by clipping view.
4436  UIView* clippingView1 = view1.superview.superview;
4437  UIView* clippingView2 = view2.superview.superview;
4438  XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
4439  [flutterView.subviews indexOfObject:clippingView2],
4440  @"The first clipping view should be added before the second clipping view.");
4441 
4442  // Need to recreate these params since they are `std::move`ed.
4443  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4444  // Process the second frame in the opposite order.
4445  embeddedViewParams2 =
4446  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4447  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4448  withParams:std::move(embeddedViewParams2)];
4449 
4450  embeddedViewParams1 =
4451  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4452  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4453  withParams:std::move(embeddedViewParams1)];
4454 
4455  mock_surface = std::make_unique<flutter::SurfaceFrame>(
4456  nullptr, framebuffer_info,
4457  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
4458  [](const flutter::SurfaceFrame& surface_frame) { return true; },
4459  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
4460  XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4461  withIosContext:std::make_shared<FakeIOSContext>()]);
4462 
4463  XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] >
4464  [flutterView.subviews indexOfObject:clippingView2],
4465  @"The first clipping view should be added after the second clipping view.");
4466 }
4467 
4468 - (void)
4469  testFlutterPlatformViewControllerSubmitFrameShouldOrderSubviewsCorrectlyWithSameViewHierarchy {
4470  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4471 
4472  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4473  FlutterPlatformViewsController* flutterPlatformViewsController =
4474  [[FlutterPlatformViewsController alloc] init];
4475  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4476  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4477  /*delegate=*/mock_delegate,
4478  /*platform_views_controller=*/flutterPlatformViewsController,
4479  /*task_runners=*/runners.taskRunners,
4480  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4481 
4482  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4483  flutterPlatformViewsController.flutterView = flutterView;
4484 
4487  [flutterPlatformViewsController
4488  registerViewFactory:factory
4489  withId:@"MockFlutterPlatformView"
4490  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4491  FlutterResult result = ^(id result) {
4492  };
4493  [flutterPlatformViewsController
4495  arguments:@{
4496  @"id" : @0,
4497  @"viewType" : @"MockFlutterPlatformView",
4498  @"gestureBlockingPolicy" : @"eager"
4499  }]
4500  result:result];
4501  UIView* view1 = gMockPlatformView;
4502 
4503  // This overwrites `gMockPlatformView` to another view.
4504  [flutterPlatformViewsController
4506  arguments:@{
4507  @"id" : @1,
4508  @"viewType" : @"MockFlutterPlatformView",
4509  @"gestureBlockingPolicy" : @"eager"
4510  }]
4511  result:result];
4512  UIView* view2 = gMockPlatformView;
4513 
4514  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4515  flutter::MutatorsStack stack;
4516  flutter::DlMatrix finalMatrix;
4517  auto embeddedViewParams1 =
4518  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4519  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4520  withParams:std::move(embeddedViewParams1)];
4521 
4522  auto embeddedViewParams2 =
4523  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4524  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4525  withParams:std::move(embeddedViewParams2)];
4526 
4527  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
4528  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
4529  nullptr, framebuffer_info,
4530  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
4531  [](const flutter::SurfaceFrame& surface_frame) { return true; },
4532  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
4533  XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4534  withIosContext:std::make_shared<FakeIOSContext>()]);
4535 
4536  // platform view is wrapped by touch interceptor, which itself is wrapped by clipping view.
4537  UIView* clippingView1 = view1.superview.superview;
4538  UIView* clippingView2 = view2.superview.superview;
4539  XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
4540  [flutterView.subviews indexOfObject:clippingView2],
4541  @"The first clipping view should be added before the second clipping view.");
4542 
4543  // Need to recreate these params since they are `std::move`ed.
4544  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4545  // Process the second frame in the same order.
4546  embeddedViewParams1 =
4547  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
4548  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4549  withParams:std::move(embeddedViewParams1)];
4550 
4551  embeddedViewParams2 =
4552  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
4553  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4554  withParams:std::move(embeddedViewParams2)];
4555 
4556  mock_surface = std::make_unique<flutter::SurfaceFrame>(
4557  nullptr, framebuffer_info,
4558  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
4559  [](const flutter::SurfaceFrame& surface_frame) { return true; },
4560  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
4561  XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
4562  withIosContext:std::make_shared<FakeIOSContext>()]);
4563 
4564  XCTAssertTrue([flutterView.subviews indexOfObject:clippingView1] <
4565  [flutterView.subviews indexOfObject:clippingView2],
4566  @"The first clipping view should be added before the second clipping view.");
4567 }
4568 
4569 - (int)alphaOfPoint:(CGPoint)point onView:(UIView*)view {
4570  unsigned char pixel[4] = {0};
4571 
4572  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
4573 
4574  // Draw the pixel on `point` in the context.
4575  CGContextRef context =
4576  CGBitmapContextCreate(pixel, 1, 1, 8, 4, colorSpace,
4577  static_cast<uint32_t>(kCGBitmapAlphaInfoMask) &
4578  static_cast<uint32_t>(kCGImageAlphaPremultipliedLast));
4579  CGContextTranslateCTM(context, -point.x, -point.y);
4580  [view.layer renderInContext:context];
4581 
4582  CGContextRelease(context);
4583  CGColorSpaceRelease(colorSpace);
4584  // Get the alpha from the pixel that we just rendered.
4585  return pixel[3];
4586 }
4587 
4588 - (void)testHasFirstResponderInViewHierarchySubtree_viewItselfBecomesFirstResponder {
4589  // For view to become the first responder, it must be a descendant of a UIWindow
4590  UIWindow* window = [[UIWindow alloc] init];
4591  UITextField* textField = [[UITextField alloc] init];
4592  [window addSubview:textField];
4593 
4594  [textField becomeFirstResponder];
4595  XCTAssertTrue(textField.isFirstResponder);
4596  XCTAssertTrue(textField.flt_hasFirstResponderInViewHierarchySubtree);
4597  [textField resignFirstResponder];
4598  XCTAssertFalse(textField.isFirstResponder);
4599  XCTAssertFalse(textField.flt_hasFirstResponderInViewHierarchySubtree);
4600 }
4601 
4602 - (void)testHasFirstResponderInViewHierarchySubtree_descendantViewBecomesFirstResponder {
4603  // For view to become the first responder, it must be a descendant of a UIWindow
4604  UIWindow* window = [[UIWindow alloc] init];
4605  UIView* view = [[UIView alloc] init];
4606  UIView* childView = [[UIView alloc] init];
4607  UITextField* textField = [[UITextField alloc] init];
4608  [window addSubview:view];
4609  [view addSubview:childView];
4610  [childView addSubview:textField];
4611 
4612  [textField becomeFirstResponder];
4613  XCTAssertTrue(textField.isFirstResponder);
4614  XCTAssertTrue(view.flt_hasFirstResponderInViewHierarchySubtree);
4615  [textField resignFirstResponder];
4616  XCTAssertFalse(textField.isFirstResponder);
4617  XCTAssertFalse(view.flt_hasFirstResponderInViewHierarchySubtree);
4618 }
4619 
4620 - (void)testFlutterClippingMaskViewPoolReuseViewsAfterRecycle {
4621  FlutterClippingMaskViewPool* pool = [[FlutterClippingMaskViewPool alloc] initWithCapacity:2];
4622  FlutterClippingMaskView* view1 = [pool getMaskViewWithFrame:CGRectZero];
4623  FlutterClippingMaskView* view2 = [pool getMaskViewWithFrame:CGRectZero];
4624  [pool insertViewToPoolIfNeeded:view1];
4625  [pool insertViewToPoolIfNeeded:view2];
4626  CGRect newRect = CGRectMake(0, 0, 10, 10);
4627  FlutterClippingMaskView* view3 = [pool getMaskViewWithFrame:newRect];
4628  FlutterClippingMaskView* view4 = [pool getMaskViewWithFrame:newRect];
4629  // view3 and view4 should randomly get either of view1 and view2.
4630  NSSet* set1 = [NSSet setWithObjects:view1, view2, nil];
4631  NSSet* set2 = [NSSet setWithObjects:view3, view4, nil];
4632  XCTAssertEqualObjects(set1, set2);
4633  XCTAssertTrue(CGRectEqualToRect(view3.frame, newRect));
4634  XCTAssertTrue(CGRectEqualToRect(view4.frame, newRect));
4635 }
4636 
4637 - (void)testFlutterClippingMaskViewPoolAllocsNewMaskViewsAfterReachingCapacity {
4638  FlutterClippingMaskViewPool* pool = [[FlutterClippingMaskViewPool alloc] initWithCapacity:2];
4639  FlutterClippingMaskView* view1 = [pool getMaskViewWithFrame:CGRectZero];
4640  FlutterClippingMaskView* view2 = [pool getMaskViewWithFrame:CGRectZero];
4641  FlutterClippingMaskView* view3 = [pool getMaskViewWithFrame:CGRectZero];
4642  XCTAssertNotEqual(view1, view3);
4643  XCTAssertNotEqual(view2, view3);
4644 }
4645 
4646 - (void)testMaskViewsReleasedWhenPoolIsReleased {
4647  __weak UIView* weakView;
4648  @autoreleasepool {
4649  FlutterClippingMaskViewPool* pool = [[FlutterClippingMaskViewPool alloc] initWithCapacity:2];
4650  FlutterClippingMaskView* view = [pool getMaskViewWithFrame:CGRectZero];
4651  weakView = view;
4652  XCTAssertNotNil(weakView);
4653  }
4654  XCTAssertNil(weakView);
4655 }
4656 
4657 - (void)testClipMaskViewIsReused {
4658  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4659 
4660  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4661  FlutterPlatformViewsController* flutterPlatformViewsController =
4662  [[FlutterPlatformViewsController alloc] init];
4663  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4664  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4665  /*delegate=*/mock_delegate,
4666  /*platform_views_controller=*/flutterPlatformViewsController,
4667  /*task_runners=*/runners.taskRunners,
4668  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4669 
4672  [flutterPlatformViewsController
4673  registerViewFactory:factory
4674  withId:@"MockFlutterPlatformView"
4675  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4676  FlutterResult result = ^(id result) {
4677  };
4678  [flutterPlatformViewsController
4680  arguments:@{
4681  @"id" : @1,
4682  @"viewType" : @"MockFlutterPlatformView",
4683  @"gestureBlockingPolicy" : @"eager"
4684  }]
4685  result:result];
4686 
4687  XCTAssertNotNil(gMockPlatformView);
4688  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4689  flutterPlatformViewsController.flutterView = flutterView;
4690  // Create embedded view params
4691  flutter::MutatorsStack stack1;
4692  // Layer tree always pushes a screen scale factor to the stack
4693  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
4694  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
4695  stack1.PushTransform(screenScaleMatrix);
4696  // Push a clip rect
4697  flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
4698  stack1.PushClipRect(rect);
4699 
4700  auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4701  screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4702 
4703  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4704  withParams:std::move(embeddedViewParams1)];
4705  [flutterPlatformViewsController
4706  compositeView:1
4707  withParams:[flutterPlatformViewsController compositionParamsForView:1]];
4708 
4709  UIView* childClippingView1 = gMockPlatformView.superview.superview;
4710  UIView* maskView1 = childClippingView1.maskView;
4711  XCTAssertNotNil(maskView1);
4712 
4713  // Composite a new frame.
4714  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(100, 100)];
4715  flutter::MutatorsStack stack2;
4716  auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4717  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4718  auto embeddedViewParams3 = std::make_unique<flutter::EmbeddedViewParams>(
4719  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4720  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4721  withParams:std::move(embeddedViewParams3)];
4722  [flutterPlatformViewsController
4723  compositeView:1
4724  withParams:[flutterPlatformViewsController compositionParamsForView:1]];
4725 
4726  childClippingView1 = gMockPlatformView.superview.superview;
4727 
4728  // This overrides gMockPlatformView to point to the newly created platform view.
4729  [flutterPlatformViewsController
4731  arguments:@{
4732  @"id" : @2,
4733  @"viewType" : @"MockFlutterPlatformView",
4734  @"gestureBlockingPolicy" : @"eager"
4735  }]
4736  result:result];
4737 
4738  auto embeddedViewParams4 = std::make_unique<flutter::EmbeddedViewParams>(
4739  screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4740  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4741  withParams:std::move(embeddedViewParams4)];
4742  [flutterPlatformViewsController
4743  compositeView:2
4744  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
4745 
4746  UIView* childClippingView2 = gMockPlatformView.superview.superview;
4747 
4748  UIView* maskView2 = childClippingView2.maskView;
4749  XCTAssertEqual(maskView1, maskView2);
4750  XCTAssertNotNil(childClippingView2.maskView);
4751  XCTAssertNil(childClippingView1.maskView);
4752 }
4753 
4754 - (void)testDifferentClipMaskViewIsUsedForEachView {
4755  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4756 
4757  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4758  FlutterPlatformViewsController* flutterPlatformViewsController =
4759  [[FlutterPlatformViewsController alloc] init];
4760  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4761  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4762  /*delegate=*/mock_delegate,
4763  /*platform_views_controller=*/flutterPlatformViewsController,
4764  /*task_runners=*/runners.taskRunners,
4765  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4766 
4769  [flutterPlatformViewsController
4770  registerViewFactory:factory
4771  withId:@"MockFlutterPlatformView"
4772  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4773  FlutterResult result = ^(id result) {
4774  };
4775 
4776  [flutterPlatformViewsController
4778  arguments:@{
4779  @"id" : @1,
4780  @"viewType" : @"MockFlutterPlatformView",
4781  @"gestureBlockingPolicy" : @"eager"
4782  }]
4783  result:result];
4784  UIView* view1 = gMockPlatformView;
4785 
4786  // This overwrites `gMockPlatformView` to another view.
4787  [flutterPlatformViewsController
4789  arguments:@{
4790  @"id" : @2,
4791  @"viewType" : @"MockFlutterPlatformView",
4792  @"gestureBlockingPolicy" : @"eager"
4793  }]
4794  result:result];
4795  UIView* view2 = gMockPlatformView;
4796 
4797  XCTAssertNotNil(gMockPlatformView);
4798  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4799  flutterPlatformViewsController.flutterView = flutterView;
4800  // Create embedded view params
4801  flutter::MutatorsStack stack1;
4802  // Layer tree always pushes a screen scale factor to the stack
4803  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
4804  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
4805  stack1.PushTransform(screenScaleMatrix);
4806  // Push a clip rect
4807  flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
4808  stack1.PushClipRect(rect);
4809 
4810  auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4811  screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4812 
4813  flutter::MutatorsStack stack2;
4814  stack2.PushClipRect(rect);
4815  auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4816  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4817 
4818  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4819  withParams:std::move(embeddedViewParams1)];
4820  [flutterPlatformViewsController
4821  compositeView:1
4822  withParams:[flutterPlatformViewsController compositionParamsForView:1]];
4823 
4824  UIView* childClippingView1 = view1.superview.superview;
4825 
4826  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
4827  withParams:std::move(embeddedViewParams2)];
4828  [flutterPlatformViewsController
4829  compositeView:2
4830  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
4831 
4832  UIView* childClippingView2 = view2.superview.superview;
4833  UIView* maskView1 = childClippingView1.maskView;
4834  UIView* maskView2 = childClippingView2.maskView;
4835  XCTAssertNotEqual(maskView1, maskView2);
4836 }
4837 
4838 - (void)testMaskViewUsesCAShapeLayerAsTheBackingLayer {
4839  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4840 
4841  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4842  FlutterPlatformViewsController* flutterPlatformViewsController =
4843  [[FlutterPlatformViewsController alloc] init];
4844  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4845  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4846  /*delegate=*/mock_delegate,
4847  /*platform_views_controller=*/flutterPlatformViewsController,
4848  /*task_runners=*/runners.taskRunners,
4849  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4850 
4853  [flutterPlatformViewsController
4854  registerViewFactory:factory
4855  withId:@"MockFlutterPlatformView"
4856  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4857  FlutterResult result = ^(id result) {
4858  };
4859 
4860  [flutterPlatformViewsController
4862  arguments:@{
4863  @"id" : @1,
4864  @"viewType" : @"MockFlutterPlatformView",
4865  @"gestureBlockingPolicy" : @"eager"
4866  }]
4867  result:result];
4868 
4869  XCTAssertNotNil(gMockPlatformView);
4870  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
4871  flutterPlatformViewsController.flutterView = flutterView;
4872  // Create embedded view params
4873  flutter::MutatorsStack stack1;
4874  // Layer tree always pushes a screen scale factor to the stack
4875  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
4876  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
4877  stack1.PushTransform(screenScaleMatrix);
4878  // Push a clip rect
4879  flutter::DlRect rect = flutter::DlRect::MakeXYWH(2, 2, 3, 3);
4880  stack1.PushClipRect(rect);
4881 
4882  auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4883  screenScaleMatrix, flutter::DlSize(10, 10), stack1);
4884 
4885  flutter::MutatorsStack stack2;
4886  stack2.PushClipRect(rect);
4887  auto embeddedViewParams2 = std::make_unique<flutter::EmbeddedViewParams>(
4888  screenScaleMatrix, flutter::DlSize(10, 10), stack2);
4889 
4890  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4891  withParams:std::move(embeddedViewParams1)];
4892  [flutterPlatformViewsController
4893  compositeView:1
4894  withParams:[flutterPlatformViewsController compositionParamsForView:1]];
4895 
4896  UIView* childClippingView = gMockPlatformView.superview.superview;
4897 
4898  UIView* maskView = childClippingView.maskView;
4899  XCTAssert([maskView.layer isKindOfClass:[CAShapeLayer class]],
4900  @"Mask view must use CAShapeLayer as its backing layer.");
4901 }
4902 
4903 // Return true if a correct visual effect view is found. It also implies all the validation in this
4904 // method passes.
4905 //
4906 // There are two fail states for this method. 1. One of the XCTAssert method failed; or 2. No
4907 // correct visual effect view found.
4908 - (BOOL)validateOneVisualEffectView:(UIView*)visualEffectView
4909  expectedFrame:(CGRect)frame
4910  inputRadius:(CGFloat)inputRadius {
4911  XCTAssertTrue(CGRectEqualToRect(visualEffectView.frame, frame));
4912  for (UIView* view in visualEffectView.subviews) {
4913  if (![NSStringFromClass([view class]) hasSuffix:@"BackdropView"]) {
4914  continue;
4915  }
4916  XCTAssertEqual(view.layer.filters.count, 1u);
4917  NSObject* filter = view.layer.filters.firstObject;
4918 
4919  XCTAssertEqualObjects([filter valueForKey:@"name"], @"gaussianBlur");
4920 
4921  NSObject* inputRadiusInFilter = [filter valueForKey:@"inputRadius"];
4922  XCTAssertTrue([inputRadiusInFilter isKindOfClass:[NSNumber class]] &&
4923  flutter::BlurRadiusEqualToBlurRadius(((NSNumber*)inputRadiusInFilter).floatValue,
4924  inputRadius));
4925  return YES;
4926  }
4927  return NO;
4928 }
4929 
4930 - (void)testDisposingViewInCompositionOrderDoNotCrash {
4931  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
4932 
4933  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
4934  FlutterPlatformViewsController* flutterPlatformViewsController =
4935  [[FlutterPlatformViewsController alloc] init];
4936  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
4937  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
4938  /*delegate=*/mock_delegate,
4939  /*platform_views_controller=*/flutterPlatformViewsController,
4940  /*task_runners=*/runners.taskRunners,
4941  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
4942 
4943  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
4944  flutterPlatformViewsController.flutterView = flutterView;
4945 
4948  [flutterPlatformViewsController
4949  registerViewFactory:factory
4950  withId:@"MockFlutterPlatformView"
4951  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
4952  FlutterResult result = ^(id result) {
4953  };
4954 
4955  [flutterPlatformViewsController
4957  arguments:@{
4958  @"id" : @0,
4959  @"viewType" : @"MockFlutterPlatformView",
4960  @"gestureBlockingPolicy" : @"eager"
4961  }]
4962  result:result];
4963  [flutterPlatformViewsController
4965  arguments:@{
4966  @"id" : @1,
4967  @"viewType" : @"MockFlutterPlatformView",
4968  @"gestureBlockingPolicy" : @"eager"
4969  }]
4970  result:result];
4971 
4972  {
4973  // **** First frame, view id 0, 1 in the composition_order_, disposing view 0 is called. **** //
4974  // No view should be disposed, or removed from the composition order.
4975  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
4976  flutter::MutatorsStack stack;
4977  flutter::DlMatrix finalMatrix;
4978  auto embeddedViewParams0 = std::make_unique<flutter::EmbeddedViewParams>(
4979  finalMatrix, flutter::DlSize(300, 300), stack);
4980  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
4981  withParams:std::move(embeddedViewParams0)];
4982 
4983  auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
4984  finalMatrix, flutter::DlSize(300, 300), stack);
4985  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
4986  withParams:std::move(embeddedViewParams1)];
4987 
4988  XCTAssertEqual(flutterPlatformViewsController.embeddedViewCount, 2UL);
4989 
4990  XCTestExpectation* expectation = [self expectationWithDescription:@"dispose call ended."];
4991  FlutterResult disposeResult = ^(id result) {
4992  [expectation fulfill];
4993  };
4994 
4995  [flutterPlatformViewsController
4997  result:disposeResult];
4998  [self waitForExpectationsWithTimeout:30 handler:nil];
4999 
5000  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5001  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5002  nullptr, framebuffer_info,
5003  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
5004  [](const flutter::SurfaceFrame& surface_frame) { return true; },
5005  /*frame_size=*/flutter::DlISize(800, 600), nullptr,
5006  /*display_list_fallback=*/true);
5007  XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
5008  withIosContext:std::make_shared<FakeIOSContext>()]);
5009 
5010  // Disposing won't remove embedded views until the view is removed from the composition_order_
5011  XCTAssertEqual(flutterPlatformViewsController.embeddedViewCount, 2UL);
5012  XCTAssertNotNil([flutterPlatformViewsController platformViewForId:0]);
5013  XCTAssertNotNil([flutterPlatformViewsController platformViewForId:1]);
5014  }
5015 
5016  {
5017  // **** Second frame, view id 1 in the composition_order_, no disposing view is called, **** //
5018  // View 0 is removed from the composition order in this frame, hence also disposed.
5019  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
5020  flutter::MutatorsStack stack;
5021  flutter::DlMatrix finalMatrix;
5022  auto embeddedViewParams1 = std::make_unique<flutter::EmbeddedViewParams>(
5023  finalMatrix, flutter::DlSize(300, 300), stack);
5024  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
5025  withParams:std::move(embeddedViewParams1)];
5026 
5027  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5028  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5029  nullptr, framebuffer_info,
5030  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
5031  [](const flutter::SurfaceFrame& surface_frame) { return true; },
5032  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
5033  XCTAssertTrue([flutterPlatformViewsController submitFrame:std::move(mock_surface)
5034  withIosContext:std::make_shared<FakeIOSContext>()]);
5035 
5036  // Disposing won't remove embedded views until the view is removed from the composition_order_
5037  XCTAssertEqual(flutterPlatformViewsController.embeddedViewCount, 1UL);
5038  XCTAssertNil([flutterPlatformViewsController platformViewForId:0]);
5039  XCTAssertNotNil([flutterPlatformViewsController platformViewForId:1]);
5040  }
5041 }
5042 - (void)testOnlyPlatformViewsAreRemovedWhenReset {
5043  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5044 
5045  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
5046  FlutterPlatformViewsController* flutterPlatformViewsController =
5047  [[FlutterPlatformViewsController alloc] init];
5048  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
5049  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5050  /*delegate=*/mock_delegate,
5051  /*platform_views_controller=*/flutterPlatformViewsController,
5052  /*task_runners=*/runners.taskRunners,
5053  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
5054 
5057  [flutterPlatformViewsController
5058  registerViewFactory:factory
5059  withId:@"MockFlutterPlatformView"
5060  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
5061  FlutterResult result = ^(id result) {
5062  };
5063  [flutterPlatformViewsController
5065  arguments:@{
5066  @"id" : @2,
5067  @"viewType" : @"MockFlutterPlatformView",
5068  @"gestureBlockingPolicy" : @"eager"
5069  }]
5070  result:result];
5071  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5072  flutterPlatformViewsController.flutterView = flutterView;
5073  // Create embedded view params
5074  flutter::MutatorsStack stack;
5075  // Layer tree always pushes a screen scale factor to the stack
5076  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5077  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5078  stack.PushTransform(screenScaleMatrix);
5079  // Push a translate matrix
5080  flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
5081  stack.PushTransform(translateMatrix);
5082  flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
5083 
5084  auto embeddedViewParams =
5085  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5086 
5087  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5088  withParams:std::move(embeddedViewParams)];
5089 
5090  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5091  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5092  nullptr, framebuffer_info,
5093  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
5094  [](const flutter::SurfaceFrame& surface_frame) { return true; },
5095  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
5096  [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5097  withIosContext:std::make_shared<FakeIOSContext>()];
5098 
5099  UIView* someView = [[UIView alloc] init];
5100  [flutterView addSubview:someView];
5101 
5102  [flutterPlatformViewsController reset];
5103  XCTAssertEqual(flutterView.subviews.count, 1u);
5104  XCTAssertEqual(flutterView.subviews.firstObject, someView);
5105 }
5106 
5107 - (void)testResetClearsPreviousCompositionOrder {
5108  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5109 
5110  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
5111  FlutterPlatformViewsController* flutterPlatformViewsController =
5112  [[FlutterPlatformViewsController alloc] init];
5113  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
5114  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5115  /*delegate=*/mock_delegate,
5116  /*platform_views_controller=*/flutterPlatformViewsController,
5117  /*task_runners=*/runners.taskRunners,
5118  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
5119 
5122  [flutterPlatformViewsController
5123  registerViewFactory:factory
5124  withId:@"MockFlutterPlatformView"
5125  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
5126  FlutterResult result = ^(id result) {
5127  };
5128  [flutterPlatformViewsController
5130  arguments:@{
5131  @"id" : @2,
5132  @"viewType" : @"MockFlutterPlatformView",
5133  @"gestureBlockingPolicy" : @"eager"
5134  }]
5135  result:result];
5136  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5137  flutterPlatformViewsController.flutterView = flutterView;
5138  // Create embedded view params
5139  flutter::MutatorsStack stack;
5140  // Layer tree always pushes a screen scale factor to the stack
5141  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5142  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5143  stack.PushTransform(screenScaleMatrix);
5144  // Push a translate matrix
5145  flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
5146  stack.PushTransform(translateMatrix);
5147  flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
5148 
5149  auto embeddedViewParams =
5150  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5151 
5152  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5153  withParams:std::move(embeddedViewParams)];
5154 
5155  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5156  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5157  nullptr, framebuffer_info,
5158  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
5159  [](const flutter::SurfaceFrame& surface_frame) { return true; },
5160  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
5161  [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5162  withIosContext:std::make_shared<FakeIOSContext>()];
5163 
5164  // The above code should result in previousCompositionOrder having one viewId in it
5165  XCTAssertEqual(flutterPlatformViewsController.previousCompositionOrder.count, 1ul);
5166 
5167  // reset should clear previousCompositionOrder
5168  [flutterPlatformViewsController reset];
5169 
5170  // previousCompositionOrder should now be empty
5171  XCTAssertEqual(flutterPlatformViewsController.previousCompositionOrder.count, 0ul);
5172 }
5173 
5174 - (void)testNilPlatformViewDoesntCrash {
5175  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5176 
5177  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
5178  FlutterPlatformViewsController* flutterPlatformViewsController =
5179  [[FlutterPlatformViewsController alloc] init];
5180  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
5181  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5182  /*delegate=*/mock_delegate,
5183  /*platform_views_controller=*/flutterPlatformViewsController,
5184  /*task_runners=*/runners.taskRunners,
5185  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
5186 
5189  [flutterPlatformViewsController
5190  registerViewFactory:factory
5191  withId:@"MockFlutterPlatformView"
5192  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
5193  FlutterResult result = ^(id result) {
5194  };
5195  [flutterPlatformViewsController
5197  arguments:@{
5198  @"id" : @2,
5199  @"viewType" : @"MockFlutterPlatformView",
5200  @"gestureBlockingPolicy" : @"eager"
5201  }]
5202  result:result];
5203  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5204  flutterPlatformViewsController.flutterView = flutterView;
5205 
5206  // Create embedded view params
5207  flutter::MutatorsStack stack;
5208  // Layer tree always pushes a screen scale factor to the stack
5209  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5210  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5211  stack.PushTransform(screenScaleMatrix);
5212  // Push a translate matrix
5213  flutter::DlMatrix translateMatrix = flutter::DlMatrix::MakeTranslation({100, 100});
5214  stack.PushTransform(translateMatrix);
5215  flutter::DlMatrix finalMatrix = screenScaleMatrix * translateMatrix;
5216 
5217  auto embeddedViewParams =
5218  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5219 
5220  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5221  withParams:std::move(embeddedViewParams)];
5222 
5223  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5224  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5225  nullptr, framebuffer_info,
5226  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
5227  [](const flutter::SurfaceFrame& surface_frame) { return true; },
5228  /*frame_size=*/flutter::DlISize(800, 600), nullptr, /*display_list_fallback=*/true);
5229  [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5230  withIosContext:std::make_shared<FakeIOSContext>()];
5231 
5232  XCTAssertEqual(flutterView.subviews.count, 1u);
5233 }
5234 
5235 - (void)testFlutterTouchInterceptingViewLinksToAccessibilityContainer {
5236  FlutterTouchInterceptingView* touchInterceptorView = [[FlutterTouchInterceptingView alloc] init];
5237  NSObject* container = [[NSObject alloc] init];
5238  [touchInterceptorView setFlutterAccessibilityContainer:container];
5239  XCTAssertEqualObjects([touchInterceptorView accessibilityContainer], container);
5240 }
5241 
5242 - (void)testLayerPool {
5243  // Create an IOSContext.
5244  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"foobar"];
5245  [engine run];
5246  XCTAssertTrue(engine.platformView != nullptr);
5247  auto ios_context = engine.platformView->GetIosContext();
5248 
5249  auto pool = flutter::OverlayLayerPool{};
5250 
5251  // Add layers to the pool.
5252  pool.CreateLayer(ios_context, MTLPixelFormatBGRA8Unorm);
5253  XCTAssertEqual(pool.size(), 1u);
5254  pool.CreateLayer(ios_context, MTLPixelFormatBGRA8Unorm);
5255  XCTAssertEqual(pool.size(), 2u);
5256 
5257  // Mark all layers as unused.
5258  pool.RecycleLayers();
5259  XCTAssertEqual(pool.size(), 2u);
5260 
5261  // Free the unused layers. One should remain.
5262  auto unused_layers = pool.RemoveUnusedLayers();
5263  XCTAssertEqual(unused_layers.size(), 2u);
5264  XCTAssertEqual(pool.size(), 1u);
5265 }
5266 
5267 - (void)testFlutterPlatformViewControllerSubmitFramePreservingFrameDamage {
5268  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5269 
5270  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
5271  FlutterPlatformViewsController* flutterPlatformViewsController =
5272  [[FlutterPlatformViewsController alloc] init];
5273  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
5274  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5275  /*delegate=*/mock_delegate,
5276  /*platform_views_controller=*/flutterPlatformViewsController,
5277  /*task_runners=*/runners.taskRunners,
5278  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
5279 
5280  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 500, 500)];
5281  flutterPlatformViewsController.flutterView = flutterView;
5282 
5285  [flutterPlatformViewsController
5286  registerViewFactory:factory
5287  withId:@"MockFlutterPlatformView"
5288  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
5289  FlutterResult result = ^(id result) {
5290  };
5291  [flutterPlatformViewsController
5293  arguments:@{
5294  @"id" : @0,
5295  @"viewType" : @"MockFlutterPlatformView",
5296  @"gestureBlockingPolicy" : @"eager"
5297  }]
5298  result:result];
5299 
5300  // This overwrites `gMockPlatformView` to another view.
5301  [flutterPlatformViewsController
5303  arguments:@{
5304  @"id" : @1,
5305  @"viewType" : @"MockFlutterPlatformView",
5306  @"gestureBlockingPolicy" : @"eager"
5307  }]
5308  result:result];
5309 
5310  [flutterPlatformViewsController beginFrameWithSize:flutter::DlISize(300, 300)];
5311  flutter::MutatorsStack stack;
5312  flutter::DlMatrix finalMatrix;
5313  auto embeddedViewParams1 =
5314  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(300, 300), stack);
5315  [flutterPlatformViewsController prerollCompositeEmbeddedView:0
5316  withParams:std::move(embeddedViewParams1)];
5317 
5318  auto embeddedViewParams2 =
5319  std::make_unique<flutter::EmbeddedViewParams>(finalMatrix, flutter::DlSize(500, 500), stack);
5320  [flutterPlatformViewsController prerollCompositeEmbeddedView:1
5321  withParams:std::move(embeddedViewParams2)];
5322 
5323  flutter::SurfaceFrame::FramebufferInfo framebuffer_info;
5324  std::optional<flutter::SurfaceFrame::SubmitInfo> submit_info;
5325  auto mock_surface = std::make_unique<flutter::SurfaceFrame>(
5326  nullptr, framebuffer_info,
5327  [](const flutter::SurfaceFrame& surface_frame, flutter::DlCanvas* canvas) { return true; },
5328  [&](const flutter::SurfaceFrame& surface_frame) {
5329  submit_info = surface_frame.submit_info();
5330  return true;
5331  },
5332  /*frame_size=*/flutter::DlISize(800, 600), nullptr,
5333  /*display_list_fallback=*/true);
5334  mock_surface->set_submit_info({
5335  .frame_damage = flutter::DlIRect::MakeWH(800, 600),
5336  .buffer_damage = flutter::DlIRect::MakeWH(400, 600),
5337  });
5338 
5339  [flutterPlatformViewsController submitFrame:std::move(mock_surface)
5340  withIosContext:std::make_shared<FakeIOSContext>()];
5341 
5342  XCTAssertTrue(submit_info.has_value());
5343  XCTAssertEqual(*submit_info->frame_damage, flutter::DlIRect::MakeWH(800, 600));
5344  XCTAssertEqual(*submit_info->buffer_damage, flutter::DlIRect::MakeWH(400, 600));
5345 }
5346 
5347 - (void)testClipSuperellipse {
5348  flutter::FlutterPlatformViewsTestMockPlatformViewDelegate mock_delegate;
5349 
5350  FlutterFMLTaskRunners* runners = CreateTestTaskRunners(self.name);
5351  FlutterPlatformViewsController* flutterPlatformViewsController =
5352  [[FlutterPlatformViewsController alloc] init];
5353  flutterPlatformViewsController.taskRunner = GetDefaultTaskRunner();
5354  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
5355  /*delegate=*/mock_delegate,
5356  /*platform_views_controller=*/flutterPlatformViewsController,
5357  /*task_runners=*/runners.taskRunners,
5358  /*is_gpu_disabled_jsync_switch=*/std::make_shared<fml::SyncSwitch>());
5359 
5362  [flutterPlatformViewsController
5363  registerViewFactory:factory
5364  withId:@"MockFlutterPlatformView"
5365  gestureRecognizersBlockingPolicy:FlutterPlatformViewGestureRecognizersBlockingPolicyEager];
5366  FlutterResult result = ^(id result) {
5367  };
5368  [flutterPlatformViewsController
5370  arguments:@{
5371  @"id" : @2,
5372  @"viewType" : @"MockFlutterPlatformView",
5373  @"gestureBlockingPolicy" : @"eager"
5374  }]
5375  result:result];
5376 
5377  XCTAssertNotNil(gMockPlatformView);
5378 
5379  UIView* flutterView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 10, 10)];
5380  flutterPlatformViewsController.flutterView = flutterView;
5381  // Create embedded view params
5382  flutter::MutatorsStack stack;
5383  // Layer tree always pushes a screen scale factor to the stack
5384  flutter::DlScalar screenScale = [UIScreen mainScreen].scale;
5385  flutter::DlMatrix screenScaleMatrix = flutter::DlMatrix::MakeScale({screenScale, screenScale, 1});
5386  stack.PushTransform(screenScaleMatrix);
5387  // Push a clip superellipse
5388  flutter::DlRect rect = flutter::DlRect::MakeXYWH(3, 3, 5, 5);
5389  stack.PushClipRSE(flutter::DlRoundSuperellipse::MakeOval(rect));
5390 
5391  auto embeddedViewParams = std::make_unique<flutter::EmbeddedViewParams>(
5392  screenScaleMatrix, flutter::DlSize(10, 10), stack);
5393 
5394  [flutterPlatformViewsController prerollCompositeEmbeddedView:2
5395  withParams:std::move(embeddedViewParams)];
5396  [flutterPlatformViewsController
5397  compositeView:2
5398  withParams:[flutterPlatformViewsController compositionParamsForView:2]];
5399 
5400  gMockPlatformView.backgroundColor = UIColor.redColor;
5401  XCTAssertTrue([gMockPlatformView.superview.superview isKindOfClass:ChildClippingView.class]);
5402  ChildClippingView* childClippingView = (ChildClippingView*)gMockPlatformView.superview.superview;
5403  [flutterView addSubview:childClippingView];
5404 
5405  [flutterView setNeedsLayout];
5406  [flutterView layoutIfNeeded];
5407 
5408  CGPoint corners[] = {CGPointMake(rect.GetLeft(), rect.GetTop()),
5409  CGPointMake(rect.GetRight(), rect.GetTop()),
5410  CGPointMake(rect.GetLeft(), rect.GetBottom()),
5411  CGPointMake(rect.GetRight(), rect.GetBottom())};
5412  for (auto point : corners) {
5413  int alpha = [self alphaOfPoint:point onView:flutterView];
5414  XCTAssertNotEqual(alpha, 255);
5415  }
5416  CGPoint center =
5417  CGPointMake(rect.GetLeft() + rect.GetWidth() / 2, rect.GetTop() + rect.GetHeight() / 2);
5418  int alpha = [self alphaOfPoint:center onView:flutterView];
5419  XCTAssertEqual(alpha, 255);
5420 }
5421 
5422 @end
void(^ FlutterResult)(id _Nullable result)
flutter::Settings settings_
std::unique_ptr< flutter::PlatformViewIOS > platform_view
static __weak UIView * gMockPlatformView
const float kFloatCompareEpsilon
@ FlutterPlatformViewGestureRecognizersBlockingPolicyEager
@ FlutterPlatformViewGestureRecognizersBlockingPolicyWaitUntilTouchesEnded
@ FlutterPlatformViewGestureRecognizersBlockingPolicyDoNotBlockGesture
NSMutableArray * backdropFilterSubviews()
void applyBlurBackdropFilters:(NSArray< PlatformViewFilter * > *filters)
std::unique_ptr< flutter::Texture > CreateExternalTexture(int64_t texture_id, NSObject< FlutterTexture > *texture) override
Creates an external texture proxy of the appropriate client rendering API.
~FakeIOSContext() override=default
FlutterClippingMaskView * getMaskViewWithFrame:(CGRect frame)
void insertViewToPoolIfNeeded:(FlutterClippingMaskView *maskView)
FlutterPlatformViewGestureRecognizersBlockingPolicy blockingPolicy
Manages the lifetime of the on-screen and off-screen rendering contexts on iOS. On-screen contexts ar...
Definition: ios_context.h:38
Storage for Overlay layers across frames.
void CreateLayer(const std::shared_ptr< IOSContext > &ios_context, MTLPixelFormat pixel_format)
Create a new overlay layer.
NSString * message
NSString * code
const flutter::TaskRunners & taskRunners
instancetype methodCallWithMethodName:arguments:(NSString *method,[arguments] id _Nullable arguments)
const flutter::EmbeddedViewParams & compositionParamsForView:(int64_t viewId)
void pushVisitedPlatformViewId:(int64_t viewId)
Pushes the view id of a visted platform view to the list of visied platform views.
void reset()
Discards all platform views instances and auxiliary resources.
void registerViewFactory:withId:gestureRecognizersBlockingPolicy:(NSObject< FlutterPlatformViewFactory > *factory,[withId] NSString *factoryId,[gestureRecognizersBlockingPolicy] FlutterPlatformViewGestureRecognizersBlockingPolicy gestureRecognizerBlockingPolicy)
set the factory used to construct embedded UI Views.
FlutterFMLTaskRunner * taskRunner
The task runner used to post rendering tasks to the platform thread.
NSArray< NSNumber * > * previousCompositionOrder()
UIViewController< FlutterViewResponder > *_Nullable flutterViewController
The flutter view controller.
void compositeView:withParams:(int64_t viewId,[withParams] const flutter::EmbeddedViewParams &params)
UIView *_Nullable flutterView
The flutter view.
void onMethodCall:result:(FlutterMethodCall *call,[result] FlutterResult result)
Handler for platform view message channels.
FlutterFMLTaskRunner * GetDefaultTaskRunner()
FlutterPlatformViewsController * CreateTestPlatformViewsController(NSString *label)
FlutterFMLTaskRunners * CreateTestTaskRunners(NSString *label)
int64_t texture_id