Flutter iOS Embedder
platform_view_ios_test.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 #import <OCMock/OCMock.h>
6 #import <XCTest/XCTest.h>
7 
8 #import "flutter/fml/message_loop.h"
9 #import "flutter/fml/thread.h"
13 
15 
16 namespace flutter {
17 
18 namespace {
19 
20 class MockDelegate : public PlatformView::Delegate {
21  public:
22  void OnPlatformViewCreated(std::unique_ptr<Surface> surface) override {}
23  void OnPlatformViewDestroyed() override {}
24  void OnPlatformViewScheduleFrame() override {}
25  void OnPlatformViewAddView(int64_t view_id,
26  const ViewportMetrics& viewport_metrics,
27  AddViewCallback callback) override {}
28  void OnPlatformViewRemoveView(int64_t view_id, RemoveViewCallback callback) override {}
29  void OnPlatformViewSetNextFrameCallback(const fml::closure& closure) override {}
30  void OnPlatformViewSetViewportMetrics(int64_t view_id, const ViewportMetrics& metrics) override {}
31  const flutter::Settings& OnPlatformViewGetSettings() const override { return settings_; }
32  void OnPlatformViewDispatchPlatformMessage(std::unique_ptr<PlatformMessage> message) override {}
33  void OnPlatformViewDispatchPointerDataPacket(std::unique_ptr<PointerDataPacket> packet) override {
34  }
35  HitTestResponse OnPlatformViewHitTest(int64_t view_id, const flutter::PointData offset) override {
36  return {.has_platform_view = false};
37  }
38  void OnPlatformViewSendViewFocusEvent(const ViewFocusEvent& event) override {}
39  void OnPlatformViewDispatchSemanticsAction(int64_t view_id,
40  int32_t node_id,
41  SemanticsAction action,
42  fml::MallocMapping args) override {}
43  void OnPlatformViewSetSemanticsEnabled(bool enabled) override {}
44  void OnPlatformViewSetAccessibilityFeatures(int32_t flags) override {}
45  void OnPlatformViewRegisterTexture(std::shared_ptr<Texture> texture) override {}
46  void OnPlatformViewUnregisterTexture(int64_t texture_id) override {}
47  void OnPlatformViewMarkTextureFrameAvailable(int64_t texture_id) override {}
48 
49  void LoadDartDeferredLibrary(intptr_t loading_unit_id,
50  std::unique_ptr<const fml::Mapping> snapshot_data,
51  std::unique_ptr<const fml::Mapping> snapshot_instructions) override {
52  }
53  void LoadDartDeferredLibraryError(intptr_t loading_unit_id,
54  const std::string error_message,
55  bool transient) override {}
56  void UpdateAssetResolverByType(std::unique_ptr<flutter::AssetResolver> updated_asset_resolver,
57  flutter::AssetResolver::AssetResolverType type) override {}
58  std::shared_ptr<fml::BasicTaskRunner> OnPlatformViewGetShutdownSafeIOTaskRunner() const override {
59  return nullptr;
60  }
61 
62  flutter::Settings settings_;
63 };
64 
65 } // namespace
66 } // namespace flutter
67 
68 @interface PlatformViewIOSTest : XCTestCase
69 @end
70 
71 @implementation PlatformViewIOSTest
72 
73 - (void)testSetSemanticsTreeEnabled {
74  flutter::MockDelegate mock_delegate;
75  auto thread = std::make_unique<fml::Thread>("PlatformViewIOSTest");
76  auto thread_task_runner = thread->GetTaskRunner();
77  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
78  /*platform=*/thread_task_runner,
79  /*raster=*/thread_task_runner,
80  /*ui=*/thread_task_runner,
81  /*io=*/thread_task_runner);
82  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
83  id engine = OCMClassMock([FlutterEngine class]);
84 
85  id flutterViewController = OCMClassMock([FlutterViewController class]);
86 
87  OCMStub([flutterViewController isViewLoaded]).andReturn(NO);
88  OCMStub([flutterViewController engine]).andReturn(engine);
89  OCMStub([engine binaryMessenger]).andReturn(messenger);
90 
91  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
92  /*delegate=*/mock_delegate,
93  /*platform_views_controller=*/nil,
94  /*task_runners=*/runners,
95  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
96  fml::AutoResetWaitableEvent latch;
97  thread_task_runner->PostTask([&] {
98  platform_view->SetOwnerViewController(flutterViewController);
99  XCTAssertFalse(platform_view->GetAccessibilityBridge());
100  platform_view->SetSemanticsTreeEnabled(true);
101  XCTAssertTrue(platform_view->GetAccessibilityBridge());
102  platform_view->SetSemanticsTreeEnabled(false);
103  XCTAssertFalse(platform_view->GetAccessibilityBridge());
104  latch.Signal();
105  });
106  latch.Wait();
107 
108  [engine stopMocking];
109 }
110 
111 - (void)testRebindsAccessibilityBridgeAfterOwnerControllerReattaches {
112  flutter::MockDelegate mock_delegate;
113  fml::MessageLoop::EnsureInitializedForCurrentThread();
114  auto thread_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
115  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
116  /*platform=*/thread_task_runner,
117  /*raster=*/thread_task_runner,
118  /*ui=*/thread_task_runner,
119  /*io=*/thread_task_runner);
120  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
121  id engine = OCMClassMock([FlutterEngine class]);
122 
123  id firstViewController = OCMClassMock([FlutterViewController class]);
124  id secondViewController = OCMClassMock([FlutterViewController class]);
125  FlutterView* firstView = [[FlutterView alloc] initWithDelegate:engine
126  opaque:YES
127  enableWideGamut:NO];
128  FlutterView* secondView = [[FlutterView alloc] initWithDelegate:engine
129  opaque:YES
130  enableWideGamut:NO];
131 
132  OCMStub([firstViewController isViewLoaded]).andReturn(YES);
133  OCMStub([firstViewController engine]).andReturn(engine);
134  OCMStub([firstViewController view]).andReturn(firstView);
135  OCMStub([firstViewController viewIfLoaded]).andReturn(firstView);
136  OCMStub([secondViewController isViewLoaded]).andReturn(YES);
137  OCMStub([secondViewController engine]).andReturn(engine);
138  OCMStub([secondViewController view]).andReturn(secondView);
139  OCMStub([secondViewController viewIfLoaded]).andReturn(secondView);
140  OCMStub([engine binaryMessenger]).andReturn(messenger);
141 
142  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
143  /*delegate=*/mock_delegate,
144  /*platform_views_controller=*/nil,
145  /*task_runners=*/runners,
146  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
147  platform_view->SetOwnerViewController(firstViewController);
148  platform_view->SetSemanticsTreeEnabled(true);
149  flutter::AccessibilityBridge* bridge = platform_view->GetAccessibilityBridge();
150  XCTAssertTrue(bridge != nullptr);
151  flutter::SemanticsNode root_node;
152  root_node.id = kRootNodeId;
153  root_node.label = "root";
154  flutter::SemanticsNodeUpdates update;
155  update[kRootNodeId] = root_node;
156  platform_view->UpdateSemantics(/*view_id=*/0, std::move(update),
157  flutter::CustomAccessibilityActionUpdates());
158  XCTAssertNotNil(firstView.accessibilityElements);
159 
160  platform_view->SetOwnerViewController(nil);
161  XCTAssertEqual(platform_view->GetAccessibilityBridge(), bridge);
162  XCTAssertNil(firstView.accessibilityElements);
163 
164  platform_view->SetOwnerViewController(secondViewController);
165  XCTAssertEqual(platform_view->GetAccessibilityBridge(), bridge);
166  XCTAssertNotNil(secondView.accessibilityElements);
167  platform_view->SetSemanticsTreeEnabled(false);
168 
169  [engine stopMocking];
170 }
171 
172 - (void)testSwappingOwnerControllersPreservesAccessibilityElementsInstalledByNewOwner {
173  flutter::MockDelegate first_delegate;
174  flutter::MockDelegate second_delegate;
175  fml::MessageLoop::EnsureInitializedForCurrentThread();
176  auto thread_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
177  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
178  /*platform=*/thread_task_runner,
179  /*raster=*/thread_task_runner,
180  /*ui=*/thread_task_runner,
181  /*io=*/thread_task_runner);
182  id firstMessenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
183  id secondMessenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
184  id firstEngine = OCMClassMock([FlutterEngine class]);
185  id secondEngine = OCMClassMock([FlutterEngine class]);
186  OCMStub([firstEngine binaryMessenger]).andReturn(firstMessenger);
187  OCMStub([secondEngine binaryMessenger]).andReturn(secondMessenger);
188 
189  id firstViewController = OCMClassMock([FlutterViewController class]);
190  id secondViewController = OCMClassMock([FlutterViewController class]);
191  FlutterView* firstView = [[FlutterView alloc] initWithDelegate:firstEngine
192  opaque:YES
193  enableWideGamut:NO];
194  FlutterView* secondView = [[FlutterView alloc] initWithDelegate:secondEngine
195  opaque:YES
196  enableWideGamut:NO];
197  OCMStub([firstViewController isViewLoaded]).andReturn(YES);
198  OCMStub([firstViewController engine]).andReturn(firstEngine);
199  OCMStub([firstViewController view]).andReturn(firstView);
200  OCMStub([firstViewController viewIfLoaded]).andReturn(firstView);
201  OCMStub([secondViewController isViewLoaded]).andReturn(YES);
202  OCMStub([secondViewController engine]).andReturn(secondEngine);
203  OCMStub([secondViewController view]).andReturn(secondView);
204  OCMStub([secondViewController viewIfLoaded]).andReturn(secondView);
205 
206  auto first_platform_view = std::make_unique<flutter::PlatformViewIOS>(
207  /*delegate=*/first_delegate,
208  /*platform_views_controller=*/nil,
209  /*task_runners=*/runners,
210  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
211  auto second_platform_view = std::make_unique<flutter::PlatformViewIOS>(
212  /*delegate=*/second_delegate,
213  /*platform_views_controller=*/nil,
214  /*task_runners=*/runners,
215  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
216 
217  first_platform_view->SetOwnerViewController(firstViewController);
218  first_platform_view->SetSemanticsTreeEnabled(true);
219  flutter::AccessibilityBridge* first_bridge = first_platform_view->GetAccessibilityBridge();
220  flutter::SemanticsNode first_root;
221  first_root.id = kRootNodeId;
222  flutter::SemanticsNodeUpdates first_update;
223  first_update[kRootNodeId] = first_root;
224  first_platform_view->UpdateSemantics(/*view_id=*/0, std::move(first_update),
225  flutter::CustomAccessibilityActionUpdates());
226 
227  second_platform_view->SetOwnerViewController(secondViewController);
228  second_platform_view->SetSemanticsTreeEnabled(true);
229  flutter::AccessibilityBridge* second_bridge = second_platform_view->GetAccessibilityBridge();
230  flutter::SemanticsNode second_root;
231  second_root.id = kRootNodeId;
232  flutter::SemanticsNodeUpdates second_update;
233  second_update[kRootNodeId] = second_root;
234  second_platform_view->UpdateSemantics(/*view_id=*/0, std::move(second_update),
235  flutter::CustomAccessibilityActionUpdates());
236 
237  first_platform_view->SetOwnerViewController(secondViewController);
238  SemanticsObjectContainer* secondViewRoot = secondView.accessibilityElements.firstObject;
239  XCTAssertEqual(secondViewRoot.semanticsObject.bridge, first_bridge);
240 
241  second_platform_view->SetOwnerViewController(firstViewController);
242  SemanticsObjectContainer* firstViewRoot = firstView.accessibilityElements.firstObject;
243  secondViewRoot = secondView.accessibilityElements.firstObject;
244  XCTAssertEqual(firstViewRoot.semanticsObject.bridge, second_bridge);
245  XCTAssertEqual(secondViewRoot.semanticsObject.bridge, first_bridge);
246 
247  first_platform_view->SetSemanticsTreeEnabled(false);
248  second_platform_view->SetSemanticsTreeEnabled(false);
249  [firstEngine stopMocking];
250  [secondEngine stopMocking];
251 }
252 
253 - (void)testUpdateSemanticsDoesNotLoadOwnerControllerView {
254  flutter::MockDelegate mock_delegate;
255  fml::MessageLoop::EnsureInitializedForCurrentThread();
256  auto thread_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
257  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
258  /*platform=*/thread_task_runner,
259  /*raster=*/thread_task_runner,
260  /*ui=*/thread_task_runner,
261  /*io=*/thread_task_runner);
262  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
263  id engine = OCMClassMock([FlutterEngine class]);
264 
265  id flutterViewController = OCMClassMock([FlutterViewController class]);
266  OCMStub([flutterViewController isViewLoaded]).andReturn(NO);
267  OCMStub([flutterViewController viewIfLoaded]).andReturn(nil);
268  OCMStub([flutterViewController engine]).andReturn(engine);
269  OCMReject([flutterViewController view]);
270  OCMStub([engine binaryMessenger]).andReturn(messenger);
271 
272  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
273  /*delegate=*/mock_delegate,
274  /*platform_views_controller=*/nil,
275  /*task_runners=*/runners,
276  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
277  platform_view->SetOwnerViewController(flutterViewController);
278  platform_view->SetSemanticsTreeEnabled(true);
279  XCTAssertTrue(platform_view->GetAccessibilityBridge());
280 
281  flutter::SemanticsNode root_node;
282  root_node.id = kRootNodeId;
283  root_node.label = "root";
284  flutter::SemanticsNodeUpdates update;
285  update[kRootNodeId] = root_node;
286  platform_view->UpdateSemantics(/*view_id=*/0, std::move(update),
287  flutter::CustomAccessibilityActionUpdates());
288  XCTAssertTrue(platform_view->GetAccessibilityBridge());
289  platform_view->SetSemanticsTreeEnabled(false);
290 
291  OCMVerifyAll(flutterViewController);
292  [engine stopMocking];
293 }
294 
295 - (void)testAttachViewAppliesSemanticsUpdatesReceivedBeforeViewLoaded {
296  flutter::MockDelegate mock_delegate;
297  fml::MessageLoop::EnsureInitializedForCurrentThread();
298  auto thread_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
299  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
300  /*platform=*/thread_task_runner,
301  /*raster=*/thread_task_runner,
302  /*ui=*/thread_task_runner,
303  /*io=*/thread_task_runner);
304  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
305  id engine = OCMClassMock([FlutterEngine class]);
306 
307  id flutterViewController = OCMClassMock([FlutterViewController class]);
308  FlutterView* flutterView = [[FlutterView alloc] initWithDelegate:engine
309  opaque:YES
310  enableWideGamut:NO];
311  __block BOOL isViewLoaded = NO;
312  __block UIView* viewIfLoaded = nil;
313  OCMStub([flutterViewController isViewLoaded]).andDo(^(NSInvocation* invocation) {
314  [invocation setReturnValue:&isViewLoaded];
315  });
316  OCMStub([flutterViewController viewIfLoaded]).andDo(^(NSInvocation* invocation) {
317  [invocation setReturnValue:&viewIfLoaded];
318  });
319  OCMStub([flutterViewController view]).andReturn(flutterView);
320  OCMStub([flutterViewController engine]).andReturn(engine);
321  OCMStub([engine binaryMessenger]).andReturn(messenger);
322 
323  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
324  /*delegate=*/mock_delegate,
325  /*platform_views_controller=*/nil,
326  /*task_runners=*/runners,
327  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
328  platform_view->SetOwnerViewController(flutterViewController);
329  platform_view->SetSemanticsTreeEnabled(true);
330  XCTAssertTrue(platform_view->GetAccessibilityBridge());
331 
332  __block NSInteger semanticsUpdateNotificationCount = 0;
333  id observer =
334  [[NSNotificationCenter defaultCenter] addObserverForName:FlutterSemanticsUpdateNotification
335  object:flutterViewController
336  queue:nil
337  usingBlock:^(NSNotification* notification) {
338  semanticsUpdateNotificationCount += 1;
339  }];
340 
341  flutter::SemanticsNode root_node;
342  root_node.id = kRootNodeId;
343  root_node.label = "root before view loaded";
344  flutter::SemanticsNodeUpdates update;
345  update[kRootNodeId] = root_node;
346  platform_view->UpdateSemantics(/*view_id=*/0, std::move(update),
347  flutter::CustomAccessibilityActionUpdates());
348  XCTAssertNil(flutterView.accessibilityElements);
349  XCTAssertEqual(semanticsUpdateNotificationCount, 0);
350 
351  isViewLoaded = YES;
352  viewIfLoaded = flutterView;
353  platform_view->attachView();
354 
355  XCTAssertEqual(semanticsUpdateNotificationCount, 1);
356  XCTAssertNotNil(flutterView.accessibilityElements);
357  id rootContainer = flutterView.accessibilityElements.firstObject;
358  id rootElement = [rootContainer accessibilityElementAtIndex:0];
359  XCTAssertEqualObjects([rootElement accessibilityLabel], @"root before view loaded");
360  platform_view->SetSemanticsTreeEnabled(false);
361  [[NSNotificationCenter defaultCenter] removeObserver:observer];
362 
363  [engine stopMocking];
364 }
365 
366 - (void)testPreservesSemanticsUpdatesWhileOwnerControllerIsDetached {
367  flutter::MockDelegate mock_delegate;
368  fml::MessageLoop::EnsureInitializedForCurrentThread();
369  auto thread_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
370  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
371  /*platform=*/thread_task_runner,
372  /*raster=*/thread_task_runner,
373  /*ui=*/thread_task_runner,
374  /*io=*/thread_task_runner);
375  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
376  id engine = OCMClassMock([FlutterEngine class]);
377 
378  id firstViewController = OCMClassMock([FlutterViewController class]);
379  id secondViewController = OCMClassMock([FlutterViewController class]);
380  FlutterView* firstView = [[FlutterView alloc] initWithDelegate:engine
381  opaque:YES
382  enableWideGamut:NO];
383  FlutterView* secondView = [[FlutterView alloc] initWithDelegate:engine
384  opaque:YES
385  enableWideGamut:NO];
386 
387  OCMStub([firstViewController isViewLoaded]).andReturn(YES);
388  OCMStub([firstViewController engine]).andReturn(engine);
389  OCMStub([firstViewController view]).andReturn(firstView);
390  OCMStub([firstViewController viewIfLoaded]).andReturn(firstView);
391  OCMStub([secondViewController isViewLoaded]).andReturn(YES);
392  OCMStub([secondViewController engine]).andReturn(engine);
393  OCMStub([secondViewController view]).andReturn(secondView);
394  OCMStub([secondViewController viewIfLoaded]).andReturn(secondView);
395  OCMStub([engine binaryMessenger]).andReturn(messenger);
396 
397  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
398  /*delegate=*/mock_delegate,
399  /*platform_views_controller=*/nil,
400  /*task_runners=*/runners,
401  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
402  platform_view->SetOwnerViewController(firstViewController);
403  platform_view->SetSemanticsTreeEnabled(true);
404  flutter::AccessibilityBridge* bridge = platform_view->GetAccessibilityBridge();
405  XCTAssertTrue(bridge != nullptr);
406 
407  flutter::SemanticsNode root_node;
408  root_node.id = kRootNodeId;
409  root_node.label = "root";
410  flutter::SemanticsNodeUpdates initial_update;
411  initial_update[kRootNodeId] = root_node;
412  platform_view->UpdateSemantics(/*view_id=*/0, std::move(initial_update),
413  flutter::CustomAccessibilityActionUpdates());
414  XCTAssertNotNil(firstView.accessibilityElements);
415 
416  platform_view->SetOwnerViewController(nil);
417 
418  flutter::SemanticsNode detached_root_node;
419  detached_root_node.id = kRootNodeId;
420  detached_root_node.label = "updated while detached";
421  flutter::SemanticsNodeUpdates detached_update;
422  detached_update[kRootNodeId] = detached_root_node;
423  platform_view->UpdateSemantics(/*view_id=*/0, std::move(detached_update),
424  flutter::CustomAccessibilityActionUpdates());
425  XCTAssertEqual(platform_view->GetAccessibilityBridge(), bridge);
426  XCTAssertNil(firstView.accessibilityElements);
427 
428  platform_view->SetOwnerViewController(secondViewController);
429  XCTAssertEqual(platform_view->GetAccessibilityBridge(), bridge);
430  XCTAssertNotNil(secondView.accessibilityElements);
431  id rootContainer = secondView.accessibilityElements.firstObject;
432  id rootElement = [rootContainer accessibilityElementAtIndex:0];
433  XCTAssertEqualObjects([rootElement accessibilityLabel], @"updated while detached");
434  platform_view->SetSemanticsTreeEnabled(false);
435 
436  [engine stopMocking];
437 }
438 
439 - (void)testRebindsScrollableSemanticsViewAfterOwnerControllerReattaches {
440  flutter::MockDelegate mock_delegate;
441  fml::MessageLoop::EnsureInitializedForCurrentThread();
442  auto thread_task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
443  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
444  /*platform=*/thread_task_runner,
445  /*raster=*/thread_task_runner,
446  /*ui=*/thread_task_runner,
447  /*io=*/thread_task_runner);
448  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
449  id engine = OCMClassMock([FlutterEngine class]);
450 
451  id firstViewController = OCMClassMock([FlutterViewController class]);
452  id secondViewController = OCMClassMock([FlutterViewController class]);
453  FlutterView* firstView = [[FlutterView alloc] initWithDelegate:engine
454  opaque:YES
455  enableWideGamut:NO];
456  FlutterView* secondView = [[FlutterView alloc] initWithDelegate:engine
457  opaque:YES
458  enableWideGamut:NO];
459 
460  OCMStub([firstViewController isViewLoaded]).andReturn(YES);
461  OCMStub([firstViewController engine]).andReturn(engine);
462  OCMStub([firstViewController view]).andReturn(firstView);
463  OCMStub([firstViewController viewIfLoaded]).andReturn(firstView);
464  OCMStub([secondViewController isViewLoaded]).andReturn(YES);
465  OCMStub([secondViewController engine]).andReturn(engine);
466  OCMStub([secondViewController view]).andReturn(secondView);
467  OCMStub([secondViewController viewIfLoaded]).andReturn(secondView);
468  OCMStub([engine binaryMessenger]).andReturn(messenger);
469 
470  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
471  /*delegate=*/mock_delegate,
472  /*platform_views_controller=*/nil,
473  /*task_runners=*/runners,
474  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
475  platform_view->SetOwnerViewController(firstViewController);
476  platform_view->SetSemanticsTreeEnabled(true);
477 
478  flutter::SemanticsNode root_node;
479  root_node.id = kRootNodeId;
480  root_node.childrenInTraversalOrder = {1};
481  root_node.childrenInHitTestOrder = {1};
482  flutter::SemanticsNode scrollable_node;
483  scrollable_node.id = 1;
484  scrollable_node.flags.hasImplicitScrolling = true;
485  scrollable_node.actions = flutter::kVerticalScrollSemanticsActions;
486  scrollable_node.rect = SkRect::MakeXYWH(0, 0, 100, 120);
487  scrollable_node.scrollExtentMax = 100.0;
488  scrollable_node.scrollPosition = 10.0;
489  flutter::SemanticsNodeUpdates update;
490  update[kRootNodeId] = root_node;
491  update[scrollable_node.id] = scrollable_node;
492  platform_view->UpdateSemantics(/*view_id=*/0, std::move(update),
493  flutter::CustomAccessibilityActionUpdates());
494  XCTAssertEqual(firstView.subviews.count, 1ul);
495  FlutterSemanticsScrollView* scrollable_view =
496  (FlutterSemanticsScrollView*)firstView.subviews.firstObject;
497  XCTAssertTrue([scrollable_view isKindOfClass:[FlutterSemanticsScrollView class]]);
498  CGRect expected_frame = scrollable_view.frame;
499  CGSize expected_content_size = scrollable_view.contentSize;
500  CGPoint expected_content_offset = scrollable_view.contentOffset;
501 
502  platform_view->SetOwnerViewController(nil);
503  XCTAssertEqual(firstView.subviews.count, 0ul);
504  scrollable_view.frame = CGRectMake(1, 2, 3, 4);
505  scrollable_view.contentSize = CGSizeMake(5, 6);
506  scrollable_view.contentOffset = CGPointMake(7, 8);
507 
508  platform_view->SetOwnerViewController(secondViewController);
509  XCTAssertEqual(secondView.subviews.count, 1ul);
510  XCTAssertEqual(secondView.subviews.firstObject, scrollable_view);
511  XCTAssertTrue(CGRectEqualToRect(scrollable_view.frame, expected_frame));
512  XCTAssertTrue(CGSizeEqualToSize(scrollable_view.contentSize, expected_content_size));
513  XCTAssertTrue(CGPointEqualToPoint(scrollable_view.contentOffset, expected_content_offset));
514  platform_view->SetSemanticsTreeEnabled(false);
515 
516  [engine stopMocking];
517 }
518 
519 - (void)testLocaleCanBeSetWithoutViewController {
520  flutter::MockDelegate mock_delegate;
521  auto thread = std::make_unique<fml::Thread>("PlatformViewIOSTest");
522  auto thread_task_runner = thread->GetTaskRunner();
523  flutter::TaskRunners runners(/*label=*/self.name.UTF8String,
524  /*platform=*/thread_task_runner,
525  /*raster=*/thread_task_runner,
526  /*ui=*/thread_task_runner,
527  /*io=*/thread_task_runner);
528  id messenger = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
529  id engine = OCMClassMock([FlutterEngine class]);
530 
531  id flutterViewController = OCMClassMock([FlutterViewController class]);
532 
533  OCMStub([flutterViewController isViewLoaded]).andReturn(NO);
534  OCMStub([flutterViewController engine]).andReturn(engine);
535  OCMStub([engine binaryMessenger]).andReturn(messenger);
536 
537  auto platform_view = std::make_unique<flutter::PlatformViewIOS>(
538  /*delegate=*/mock_delegate,
539  /*platform_views_controller=*/nil,
540  /*task_runners=*/runners,
541  /*is_gpu_disabled_sync_switch=*/std::make_shared<fml::SyncSwitch>());
542  fml::AutoResetWaitableEvent latch;
543  thread_task_runner->PostTask([&] {
544  std::string locale = "en-US";
545  platform_view->SetApplicationLocale(locale);
546  platform_view->SetOwnerViewController(flutterViewController);
547  OCMVerify([flutterViewController setApplicationLocale:@"en-US"]);
548  latch.Signal();
549  });
550  latch.Wait();
551 
552  [engine stopMocking];
553 }
554 
555 @end
std::unique_ptr< flutter::PlatformViewIOS > platform_view
constexpr NS_ASSUME_NONNULL_BEGIN int32_t kRootNodeId
SemanticsObject * semanticsObject
nullable flutter::AccessibilityBridgeIos * bridge()
flutter::Settings settings_
int64_t texture_id