Flutter macOS Embedder
FlutterViewControllerTest.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 "KeyCodeMap_Internal.h"
8 
9 #import <OCMock/OCMock.h>
10 
11 #include "flutter/common/constants.h"
12 #include "flutter/fml/platform/darwin/cf_utils.h"
20 #include "flutter/shell/platform/embedder/test_utils/key_codes.g.h"
21 #include "flutter/testing/autoreleasepool_test.h"
22 #include "flutter/testing/testing.h"
23 
24 #pragma mark - Test Helper Classes
25 
26 static const FlutterPointerEvent kDefaultFlutterPointerEvent = {};
27 static const FlutterKeyEvent kDefaultFlutterKeyEvent = {};
28 
29 // A wrap to convert FlutterKeyEvent to a ObjC class.
30 @interface KeyEventWrapper : NSObject
31 @property(nonatomic) FlutterKeyEvent* data;
32 - (nonnull instancetype)initWithEvent:(const FlutterKeyEvent*)event;
33 @end
34 
35 @implementation KeyEventWrapper
36 - (instancetype)initWithEvent:(const FlutterKeyEvent*)event {
37  self = [super init];
38  _data = new FlutterKeyEvent(*event);
39  return self;
40 }
41 
42 - (void)dealloc {
43  delete _data;
44 }
45 @end
46 
47 /// Responder wrapper that forwards key events to another responder. This is a necessary middle step
48 /// for mocking responder because when setting the responder to controller AppKit will access ivars
49 /// of the objects, which means it must extend NSResponder instead of just implementing the
50 /// selectors.
51 @interface FlutterResponderWrapper : NSResponder {
52  NSResponder* _responder;
53 }
54 @end
55 
56 @implementation FlutterResponderWrapper
57 
58 - (instancetype)initWithResponder:(NSResponder*)responder {
59  if (self = [super init]) {
60  _responder = responder;
61  }
62  return self;
63 }
64 
65 - (void)keyDown:(NSEvent*)event {
66  [_responder keyDown:event];
67 }
68 
69 - (void)keyUp:(NSEvent*)event {
70  [_responder keyUp:event];
71 }
72 
73 - (BOOL)performKeyEquivalent:(NSEvent*)event {
74  return [_responder performKeyEquivalent:event];
75 }
76 
77 - (void)flagsChanged:(NSEvent*)event {
78  [_responder flagsChanged:event];
79 }
80 
81 @end
82 
83 // A FlutterViewController subclass for testing that mouseDown/mouseUp get called when
84 // mouse events are sent to the associated view.
86 @property(nonatomic, assign) BOOL mouseDownCalled;
87 @property(nonatomic, assign) BOOL mouseUpCalled;
88 @end
89 
90 @implementation MouseEventFlutterViewController
91 - (void)mouseDown:(NSEvent*)event {
92  self.mouseDownCalled = YES;
93 }
94 
95 - (void)mouseUp:(NSEvent*)event {
96  self.mouseUpCalled = YES;
97 }
98 @end
99 
100 // Matches an encoded JSON message whose content equals that of |expected|.
101 static id JSONMessageWithContentOf(NSData* expected) {
102  id expectedContent = [[FlutterJSONMessageCodec sharedInstance] decode:expected];
103  return [OCMArg checkWithBlock:^BOOL(NSData* message) {
104  return [[[FlutterJSONMessageCodec sharedInstance] decode:message] isEqual:expectedContent];
105  }];
106 }
107 
108 @interface FlutterViewControllerTestObjC : NSObject
109 - (bool)testKeyEventsAreSentToFramework:(id)mockEngine;
110 - (bool)testKeyEventsArePropagatedIfNotHandled:(id)mockEngine;
111 - (bool)testKeyEventsAreNotPropagatedIfHandled:(id)mockEngine;
112 - (bool)testCtrlTabKeyEventIsPropagated:(id)mockEngine;
113 - (bool)testKeyEquivalentIsPassedToTextInputPlugin:(id)mockEngine;
114 - (bool)testFlagsChangedEventsArePropagatedIfNotHandled:(id)mockEngine;
115 - (bool)testKeyboardIsRestartedOnEngineRestart:(id)mockEngine;
116 - (bool)testTrackpadGesturesAreSentToFramework:(id)mockEngine;
117 - (bool)mouseAndGestureEventsAreHandledSeparately:(id)engineMock;
118 - (bool)testMouseDownUpEventsSentToNextResponder:(id)mockEngine;
119 - (bool)testModifierKeysAreSynthesizedOnMouseMove:(id)mockEngine;
120 - (bool)testViewWillAppearCalledMultipleTimes:(id)mockEngine;
121 - (bool)testFlutterViewIsConfigured:(id)mockEngine;
122 - (bool)testLookupKeyAssets;
125 
126 + (void)respondFalseForSendEvent:(const FlutterKeyEvent&)event
127  callback:(nullable FlutterKeyEventCallback)callback
128  userData:(nullable void*)userData;
129 @end
130 
131 #pragma mark - Static helper functions
132 
133 using namespace ::flutter::testing::keycodes;
134 
135 namespace flutter::testing {
136 
137 namespace {
138 
139 id MockGestureEvent(NSEventType type, NSEventPhase phase, double magnification, double rotation) {
140  id event = [OCMockObject mockForClass:[NSEvent class]];
141  NSPoint locationInWindow = NSMakePoint(0, 0);
142  CGFloat deltaX = 0;
143  CGFloat deltaY = 0;
144  NSTimeInterval timestamp = 1;
145  NSUInteger modifierFlags = 0;
146  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(type)] type];
147  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(phase)] phase];
148  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(locationInWindow)] locationInWindow];
149  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(deltaX)] deltaX];
150  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(deltaY)] deltaY];
151  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(timestamp)] timestamp];
152  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(modifierFlags)] modifierFlags];
153  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(magnification)] magnification];
154  [(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(rotation)] rotation];
155  return event;
156 }
157 
158 // Allocates and returns an engine configured for the test fixture resource configuration.
159 FlutterEngine* CreateTestEngine() {
160  NSString* fixtures = @(testing::GetFixturesPath());
161  FlutterDartProject* project = [[FlutterDartProject alloc]
162  initWithAssetsPath:fixtures
163  ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
164  return [[FlutterEngine alloc] initWithName:@"test" project:project allowHeadlessExecution:true];
165 }
166 
167 NSResponder* mockResponder() {
168  NSResponder* mock = OCMStrictClassMock([NSResponder class]);
169  OCMStub([mock keyDown:[OCMArg any]]).andDo(nil);
170  OCMStub([mock keyUp:[OCMArg any]]).andDo(nil);
171  OCMStub([mock flagsChanged:[OCMArg any]]).andDo(nil);
172  return mock;
173 }
174 
175 NSEvent* CreateMouseEvent(NSEventModifierFlags modifierFlags) {
176  return [NSEvent mouseEventWithType:NSEventTypeMouseMoved
177  location:NSZeroPoint
178  modifierFlags:modifierFlags
179  timestamp:0
180  windowNumber:0
181  context:nil
182  eventNumber:0
183  clickCount:1
184  pressure:1.0];
185 }
186 
187 } // namespace
188 
189 #pragma mark - gtest tests
190 
191 // Test-specific names for AutoreleasePoolTest, MockFlutterEngineTest fixtures.
192 using FlutterViewControllerTest = AutoreleasePoolTest;
194 
195 TEST_F(FlutterViewControllerTest, HasViewThatHidesOtherViewsInAccessibility) {
196  FlutterViewController* viewControllerMock = CreateMockViewController();
197 
198  [viewControllerMock loadView];
199  auto subViews = [viewControllerMock.view subviews];
200 
201  EXPECT_EQ([subViews count], 1u);
202  EXPECT_EQ(subViews[0], viewControllerMock.flutterView);
203 
204  NSTextField* textField = [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 1, 1)];
205  [viewControllerMock.view addSubview:textField];
206 
207  subViews = [viewControllerMock.view subviews];
208  EXPECT_EQ([subViews count], 2u);
209 
210  auto accessibilityChildren = viewControllerMock.view.accessibilityChildren;
211  // The accessibilityChildren should only contains the FlutterView.
212  EXPECT_EQ([accessibilityChildren count], 1u);
213  EXPECT_EQ(accessibilityChildren[0], viewControllerMock.flutterView);
214 }
215 
216 TEST_F(FlutterViewControllerTest, FlutterViewAcceptsFirstMouse) {
217  FlutterViewController* viewControllerMock = CreateMockViewController();
218  [viewControllerMock loadView];
219  EXPECT_EQ([viewControllerMock.flutterView acceptsFirstMouse:nil], YES);
220 }
221 
222 TEST_F(FlutterViewControllerTest, ReparentsPluginWhenAccessibilityDisabled) {
223  FlutterEngine* engine = CreateTestEngine();
224  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
225  nibName:nil
226  bundle:nil];
227  [viewController loadView];
228  // Creates a NSWindow so that sub view can be first responder.
229  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
230  styleMask:NSBorderlessWindowMask
231  backing:NSBackingStoreBuffered
232  defer:NO];
233  window.contentView = viewController.view;
234  NSView* dummyView = [[NSView alloc] initWithFrame:CGRectZero];
235  [viewController.view addSubview:dummyView];
236 
237  NSDictionary* setClientConfig = @{
238  @"viewId" : @(flutter::kFlutterImplicitViewId),
239  };
240  FlutterMethodCall* methodCall =
241  [FlutterMethodCall methodCallWithMethodName:@"TextInput.setClient"
242  arguments:@[ @(1), setClientConfig ]];
243  FlutterResult result = ^(id result) {
244  };
245  [engine.textInputPlugin handleMethodCall:methodCall result:result];
246 
247  // Attaches FlutterTextInputPlugin to the view;
248  [dummyView addSubview:engine.textInputPlugin];
249  // Makes sure the textInputPlugin can be the first responder.
250 
251  EXPECT_TRUE([window makeFirstResponder:engine.textInputPlugin]);
252  EXPECT_EQ([window firstResponder], engine.textInputPlugin);
253  EXPECT_FALSE(engine.textInputPlugin.superview == viewController.view);
254  [viewController onAccessibilityStatusChanged:NO];
255  // FlutterView becomes child of view controller
256  EXPECT_TRUE(viewController.engine.textInputPlugin.superview == viewController.view);
257 }
258 
259 TEST_F(FlutterViewControllerTest, CanSetMouseTrackingModeBeforeViewLoaded) {
260  NSString* fixtures = @(testing::GetFixturesPath());
261  FlutterDartProject* project = [[FlutterDartProject alloc]
262  initWithAssetsPath:fixtures
263  ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
264  FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:project];
265  viewController.mouseTrackingMode = kFlutterMouseTrackingModeInActiveApp;
266  ASSERT_EQ(viewController.mouseTrackingMode, kFlutterMouseTrackingModeInActiveApp);
267 }
268 
269 TEST_F(FlutterViewControllerMockEngineTest, TestKeyEventsAreSentToFramework) {
270  id mockEngine = GetMockEngine();
271  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testKeyEventsAreSentToFramework:mockEngine]);
272 }
273 
274 TEST_F(FlutterViewControllerMockEngineTest, TestKeyEventsArePropagatedIfNotHandled) {
275  id mockEngine = GetMockEngine();
276  ASSERT_TRUE(
277  [[FlutterViewControllerTestObjC alloc] testKeyEventsArePropagatedIfNotHandled:mockEngine]);
278 }
279 
280 TEST_F(FlutterViewControllerMockEngineTest, TestKeyEventsAreNotPropagatedIfHandled) {
281  id mockEngine = GetMockEngine();
282  ASSERT_TRUE(
283  [[FlutterViewControllerTestObjC alloc] testKeyEventsAreNotPropagatedIfHandled:mockEngine]);
284 }
285 
286 TEST_F(FlutterViewControllerMockEngineTest, TestCtrlTabKeyEventIsPropagated) {
287  id mockEngine = GetMockEngine();
288  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testCtrlTabKeyEventIsPropagated:mockEngine]);
289 }
290 
291 TEST_F(FlutterViewControllerMockEngineTest, TestKeyEquivalentIsPassedToTextInputPlugin) {
292  id mockEngine = GetMockEngine();
293  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc]
294  testKeyEquivalentIsPassedToTextInputPlugin:mockEngine]);
295 }
296 
297 TEST_F(FlutterViewControllerMockEngineTest, TestFlagsChangedEventsArePropagatedIfNotHandled) {
298  id mockEngine = GetMockEngine();
299  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc]
300  testFlagsChangedEventsArePropagatedIfNotHandled:mockEngine]);
301 }
302 
303 TEST_F(FlutterViewControllerMockEngineTest, TestKeyboardIsRestartedOnEngineRestart) {
304  id mockEngine = GetMockEngine();
305  ASSERT_TRUE(
306  [[FlutterViewControllerTestObjC alloc] testKeyboardIsRestartedOnEngineRestart:mockEngine]);
307 }
308 
309 TEST_F(FlutterViewControllerMockEngineTest, TestTrackpadGesturesAreSentToFramework) {
310  id mockEngine = GetMockEngine();
311  ASSERT_TRUE(
312  [[FlutterViewControllerTestObjC alloc] testTrackpadGesturesAreSentToFramework:mockEngine]);
313 }
314 
315 TEST_F(FlutterViewControllerMockEngineTest, TestmouseAndGestureEventsAreHandledSeparately) {
316  id mockEngine = GetMockEngine();
317  ASSERT_TRUE(
318  [[FlutterViewControllerTestObjC alloc] mouseAndGestureEventsAreHandledSeparately:mockEngine]);
319 }
320 
321 TEST_F(FlutterViewControllerMockEngineTest, TestMouseDownUpEventsSentToNextResponder) {
322  id mockEngine = GetMockEngine();
323  ASSERT_TRUE(
324  [[FlutterViewControllerTestObjC alloc] testMouseDownUpEventsSentToNextResponder:mockEngine]);
325 }
326 
327 TEST_F(FlutterViewControllerMockEngineTest, TestModifierKeysAreSynthesizedOnMouseMove) {
328  id mockEngine = GetMockEngine();
329  ASSERT_TRUE(
330  [[FlutterViewControllerTestObjC alloc] testModifierKeysAreSynthesizedOnMouseMove:mockEngine]);
331 }
332 
333 TEST_F(FlutterViewControllerMockEngineTest, testViewWillAppearCalledMultipleTimes) {
334  id mockEngine = GetMockEngine();
335  ASSERT_TRUE(
336  [[FlutterViewControllerTestObjC alloc] testViewWillAppearCalledMultipleTimes:mockEngine]);
337 }
338 
339 TEST_F(FlutterViewControllerMockEngineTest, testFlutterViewIsConfigured) {
340  id mockEngine = GetMockEngine();
341  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testFlutterViewIsConfigured:mockEngine]);
342 }
343 
344 TEST_F(FlutterViewControllerTest, testLookupKeyAssets) {
345  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testLookupKeyAssets]);
346 }
347 
348 TEST_F(FlutterViewControllerTest, testLookupKeyAssetsWithPackage) {
349  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testLookupKeyAssetsWithPackage]);
350 }
351 
352 TEST_F(FlutterViewControllerTest, testViewControllerIsReleased) {
353  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testViewControllerIsReleased]);
354 }
355 
356 } // namespace flutter::testing
357 
358 #pragma mark - FlutterViewControllerTestObjC
359 
360 @implementation FlutterViewControllerTestObjC
361 
362 - (bool)testKeyEventsAreSentToFramework:(id)engineMock {
363  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
364  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
365  [engineMock binaryMessenger])
366  .andReturn(binaryMessengerMock);
367  FlutterKeyboardManager* keyboardManager =
368  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
369  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
370 
371  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
372  callback:nil
373  userData:nil])
374  .andCall([FlutterViewControllerTestObjC class],
375  @selector(respondFalseForSendEvent:callback:userData:));
376  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
377  nibName:@""
378  bundle:nil];
379  NSDictionary* expectedEvent = @{
380  @"keymap" : @"macos",
381  @"type" : @"keydown",
382  @"keyCode" : @(65),
383  @"modifiers" : @(538968064),
384  @"characters" : @".",
385  @"charactersIgnoringModifiers" : @".",
386  };
387  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
388  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
389  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
390  [viewController viewWillAppear]; // Initializes the event channel.
391  [viewController keyDown:event];
392  @try {
393  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
394  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
395  message:JSONMessageWithContentOf(encodedKeyEvent)
396  binaryReply:[OCMArg any]]);
397  } @catch (...) {
398  return false;
399  }
400  return true;
401 }
402 
403 // Regression test for https://github.com/flutter/flutter/issues/122084.
404 - (bool)testCtrlTabKeyEventIsPropagated:(id)engineMock {
405  __block bool called = false;
406  __block FlutterKeyEvent last_event;
407  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
408  callback:nil
409  userData:nil])
410  .andDo((^(NSInvocation* invocation) {
411  FlutterKeyEvent* event;
412  [invocation getArgument:&event atIndex:2];
413  called = true;
414  last_event = *event;
415  }));
416  FlutterKeyboardManager* keyboardManager =
417  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
418  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
419 
420  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
421  nibName:@""
422  bundle:nil];
423  // Ctrl+tab
424  NSEvent* event = [NSEvent keyEventWithType:NSEventTypeKeyDown
425  location:NSZeroPoint
426  modifierFlags:0x40101
427  timestamp:0
428  windowNumber:0
429  context:nil
430  characters:@""
431  charactersIgnoringModifiers:@""
432  isARepeat:NO
433  keyCode:48];
434  const uint64_t kPhysicalKeyTab = 0x7002b;
435 
436  [viewController viewWillAppear]; // Initializes the event channel.
437  // Creates a NSWindow so that FlutterView view can be first responder.
438  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
439  styleMask:NSBorderlessWindowMask
440  backing:NSBackingStoreBuffered
441  defer:NO];
442  window.contentView = viewController.view;
443  [window makeFirstResponder:viewController.flutterView];
444  [viewController.view performKeyEquivalent:event];
445 
446  EXPECT_TRUE(called);
447  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
448  EXPECT_EQ(last_event.physical, kPhysicalKeyTab);
449  return true;
450 }
451 
452 - (bool)testKeyEquivalentIsPassedToTextInputPlugin:(id)engineMock {
453  __block bool called = false;
454  __block FlutterKeyEvent last_event;
455  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
456  callback:nil
457  userData:nil])
458  .andDo((^(NSInvocation* invocation) {
459  FlutterKeyEvent* event;
460  [invocation getArgument:&event atIndex:2];
461  called = true;
462  last_event = *event;
463  }));
464  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
465  nibName:@""
466  bundle:nil];
467  // Ctrl+tab
468  NSEvent* event = [NSEvent keyEventWithType:NSEventTypeKeyDown
469  location:NSZeroPoint
470  modifierFlags:0x40101
471  timestamp:0
472  windowNumber:0
473  context:nil
474  characters:@""
475  charactersIgnoringModifiers:@""
476  isARepeat:NO
477  keyCode:48];
478  const uint64_t kPhysicalKeyTab = 0x7002b;
479 
480  [viewController viewWillAppear]; // Initializes the event channel.
481 
482  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
483  styleMask:NSBorderlessWindowMask
484  backing:NSBackingStoreBuffered
485  defer:NO];
486  window.contentView = viewController.view;
487 
488  NSDictionary* setClientConfig = @{
489  @"viewId" : @(flutter::kFlutterImplicitViewId),
490  };
491  FlutterMethodCall* methodCall =
492  [FlutterMethodCall methodCallWithMethodName:@"TextInput.setClient"
493  arguments:@[ @(1), setClientConfig ]];
494  FlutterResult result = ^(id result) {
495  };
496  [viewController.engine.textInputPlugin handleMethodCall:methodCall result:result];
497 
498  [viewController.engine.textInputPlugin
499  handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"TextInput.show" arguments:@[]]
500  result:^(id){
501  }];
502 
503  // Make the textInputPlugin first responder. This should still result in
504  // view controller reporting the key event.
505  [window makeFirstResponder:viewController.engine.textInputPlugin];
506 
507  [viewController.view performKeyEquivalent:event];
508 
509  EXPECT_TRUE(called);
510  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
511  EXPECT_EQ(last_event.physical, kPhysicalKeyTab);
512  return true;
513 }
514 
515 - (bool)testKeyEventsArePropagatedIfNotHandled:(id)engineMock {
516  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
517  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
518  [engineMock binaryMessenger])
519  .andReturn(binaryMessengerMock);
520  FlutterKeyboardManager* keyboardManager =
521  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
522  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
523  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
524  callback:nil
525  userData:nil])
526  .andCall([FlutterViewControllerTestObjC class],
527  @selector(respondFalseForSendEvent:callback:userData:));
528  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
529  nibName:@""
530  bundle:nil];
531  id responderMock = flutter::testing::mockResponder();
532  id responderWrapper = [[FlutterResponderWrapper alloc] initWithResponder:responderMock];
533  viewController.nextResponder = responderWrapper;
534  NSDictionary* expectedEvent = @{
535  @"keymap" : @"macos",
536  @"type" : @"keydown",
537  @"keyCode" : @(65),
538  @"modifiers" : @(538968064),
539  @"characters" : @".",
540  @"charactersIgnoringModifiers" : @".",
541  };
542  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
543  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
544  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
545  OCMExpect( // NOLINT(google-objc-avoid-throwing-exception)
546  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
547  message:JSONMessageWithContentOf(encodedKeyEvent)
548  binaryReply:[OCMArg any]])
549  .andDo((^(NSInvocation* invocation) {
550  FlutterBinaryReply handler;
551  [invocation getArgument:&handler atIndex:4];
552  NSDictionary* reply = @{
553  @"handled" : @(false),
554  };
555  NSData* encodedReply = [[FlutterJSONMessageCodec sharedInstance] encode:reply];
556  handler(encodedReply);
557  }));
558  [viewController viewWillAppear]; // Initializes the event channel.
559  [viewController keyDown:event];
560  @try {
561  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
562  [responderMock keyDown:[OCMArg any]]);
563  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
564  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
565  message:JSONMessageWithContentOf(encodedKeyEvent)
566  binaryReply:[OCMArg any]]);
567  } @catch (...) {
568  return false;
569  }
570  return true;
571 }
572 
573 - (bool)testFlutterViewIsConfigured:(id)engineMock {
574  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
575  OCMStub([engineMock renderer]).andReturn(renderer_);
576 
577  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
578  nibName:@""
579  bundle:nil];
580  [viewController loadView];
581 
582  @try {
583  // Make sure "renderer" was called during "loadView", which means "flutterView" is created
584  OCMVerify([engineMock renderer]);
585  } @catch (...) {
586  return false;
587  }
588 
589  return true;
590 }
591 
592 - (bool)testFlagsChangedEventsArePropagatedIfNotHandled:(id)engineMock {
593  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
594  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
595  [engineMock binaryMessenger])
596  .andReturn(binaryMessengerMock);
597  FlutterKeyboardManager* keyboardManager =
598  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
599  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
600  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
601  callback:nil
602  userData:nil])
603  .andCall([FlutterViewControllerTestObjC class],
604  @selector(respondFalseForSendEvent:callback:userData:));
605  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
606  nibName:@""
607  bundle:nil];
608  id responderMock = flutter::testing::mockResponder();
609  id responderWrapper = [[FlutterResponderWrapper alloc] initWithResponder:responderMock];
610  viewController.nextResponder = responderWrapper;
611  NSDictionary* expectedEvent = @{
612  @"keymap" : @"macos",
613  @"type" : @"keydown",
614  @"keyCode" : @(56), // SHIFT key
615  @"modifiers" : @(537001986),
616  };
617  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
618  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 56, TRUE); // SHIFT key
619  CGEventSetType(cgEvent, kCGEventFlagsChanged);
620  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
621  OCMExpect( // NOLINT(google-objc-avoid-throwing-exception)
622  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
623  message:JSONMessageWithContentOf(encodedKeyEvent)
624  binaryReply:[OCMArg any]])
625  .andDo((^(NSInvocation* invocation) {
626  FlutterBinaryReply handler;
627  [invocation getArgument:&handler atIndex:4];
628  NSDictionary* reply = @{
629  @"handled" : @(false),
630  };
631  NSData* encodedReply = [[FlutterJSONMessageCodec sharedInstance] encode:reply];
632  handler(encodedReply);
633  }));
634  [viewController viewWillAppear]; // Initializes the event channel.
635  [viewController flagsChanged:event];
636  @try {
637  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
638  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
639  message:JSONMessageWithContentOf(encodedKeyEvent)
640  binaryReply:[OCMArg any]]);
641  } @catch (NSException* e) {
642  NSLog(@"%@", e.reason);
643  return false;
644  }
645  return true;
646 }
647 
648 - (bool)testKeyEventsAreNotPropagatedIfHandled:(id)engineMock {
649  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
650  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
651  [engineMock binaryMessenger])
652  .andReturn(binaryMessengerMock);
653  FlutterKeyboardManager* keyboardManager =
654  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
655  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
656  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
657  callback:nil
658  userData:nil])
659  .andCall([FlutterViewControllerTestObjC class],
660  @selector(respondFalseForSendEvent:callback:userData:));
661  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
662  nibName:@""
663  bundle:nil];
664  id responderMock = flutter::testing::mockResponder();
665  id responderWrapper = [[FlutterResponderWrapper alloc] initWithResponder:responderMock];
666  viewController.nextResponder = responderWrapper;
667  NSDictionary* expectedEvent = @{
668  @"keymap" : @"macos",
669  @"type" : @"keydown",
670  @"keyCode" : @(65),
671  @"modifiers" : @(538968064),
672  @"characters" : @".",
673  @"charactersIgnoringModifiers" : @".",
674  };
675  NSData* encodedKeyEvent = [[FlutterJSONMessageCodec sharedInstance] encode:expectedEvent];
676  CGEventRef cgEvent = CGEventCreateKeyboardEvent(NULL, 65, TRUE);
677  NSEvent* event = [NSEvent eventWithCGEvent:cgEvent];
678  OCMExpect( // NOLINT(google-objc-avoid-throwing-exception)
679  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
680  message:JSONMessageWithContentOf(encodedKeyEvent)
681  binaryReply:[OCMArg any]])
682  .andDo((^(NSInvocation* invocation) {
683  FlutterBinaryReply handler;
684  [invocation getArgument:&handler atIndex:4];
685  NSDictionary* reply = @{
686  @"handled" : @(true),
687  };
688  NSData* encodedReply = [[FlutterJSONMessageCodec sharedInstance] encode:reply];
689  handler(encodedReply);
690  }));
691  [viewController viewWillAppear]; // Initializes the event channel.
692  [viewController keyDown:event];
693  @try {
694  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
695  never(), [responderMock keyDown:[OCMArg any]]);
696  OCMVerify( // NOLINT(google-objc-avoid-throwing-exception)
697  [binaryMessengerMock sendOnChannel:@"flutter/keyevent"
698  message:JSONMessageWithContentOf(encodedKeyEvent)
699  binaryReply:[OCMArg any]]);
700  } @catch (...) {
701  return false;
702  }
703  return true;
704 }
705 
706 - (bool)testKeyboardIsRestartedOnEngineRestart:(id)engineMock {
707  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
708  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
709  [engineMock binaryMessenger])
710  .andReturn(binaryMessengerMock);
711  __block bool called = false;
712  __block FlutterKeyEvent last_event;
713  __block FlutterKeyboardManager* keyboardManager =
714  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
715 
716  OCMStub([engineMock keyboardManager]).andDo(^(NSInvocation* invocation) {
717  [invocation setReturnValue:&keyboardManager];
718  });
719 
720  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
721  callback:nil
722  userData:nil])
723  .andDo((^(NSInvocation* invocation) {
724  FlutterKeyEvent* event;
725  [invocation getArgument:&event atIndex:2];
726  called = true;
727  last_event = *event;
728  }));
729 
730  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
731  nibName:@""
732  bundle:nil];
733  [viewController viewWillAppear];
734  NSEvent* keyADown = [NSEvent keyEventWithType:NSEventTypeKeyDown
735  location:NSZeroPoint
736  modifierFlags:0x100
737  timestamp:0
738  windowNumber:0
739  context:nil
740  characters:@"a"
741  charactersIgnoringModifiers:@"a"
742  isARepeat:FALSE
743  keyCode:0];
744  const uint64_t kPhysicalKeyA = 0x70004;
745 
746  // Send KeyA key down event twice. Without restarting the keyboard during
747  // onPreEngineRestart, the second event received will be an empty event with
748  // physical key 0x0 because duplicate key down events are ignored.
749 
750  called = false;
751  [viewController keyDown:keyADown];
752  EXPECT_TRUE(called);
753  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
754  EXPECT_EQ(last_event.physical, kPhysicalKeyA);
755 
756  keyboardManager = [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
757 
758  called = false;
759  [viewController keyDown:keyADown];
760  EXPECT_TRUE(called);
761  EXPECT_EQ(last_event.type, kFlutterKeyEventTypeDown);
762  EXPECT_EQ(last_event.physical, kPhysicalKeyA);
763  return true;
764 }
765 
766 + (void)respondFalseForSendEvent:(const FlutterKeyEvent&)event
767  callback:(nullable FlutterKeyEventCallback)callback
768  userData:(nullable void*)userData {
769  if (callback != nullptr) {
770  callback(false, userData);
771  }
772 }
773 
774 - (bool)testTrackpadGesturesAreSentToFramework:(id)engineMock {
775  // Need to return a real renderer to allow view controller to load.
776  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
777  OCMStub([engineMock renderer]).andReturn(renderer_);
778  __block bool called = false;
779  __block FlutterPointerEvent last_event;
780  OCMStub([[engineMock ignoringNonObjectArgs] sendPointerEvent:kDefaultFlutterPointerEvent])
781  .andDo((^(NSInvocation* invocation) {
782  FlutterPointerEvent* event;
783  [invocation getArgument:&event atIndex:2];
784  called = true;
785  last_event = *event;
786  }));
787 
788  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
789  nibName:@""
790  bundle:nil];
791  [viewController loadView];
792 
793  // Test for pan events.
794  // Start gesture.
795  CGEventRef cgEventStart = CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
796  CGEventSetType(cgEventStart, kCGEventScrollWheel);
797  CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventScrollPhase, kCGScrollPhaseBegan);
798  CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventIsContinuous, 1);
799 
800  called = false;
801  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventStart]];
802  EXPECT_TRUE(called);
803  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
804  EXPECT_EQ(last_event.phase, kPanZoomStart);
805  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
806  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
807 
808  // Update gesture.
809  CGEventRef cgEventUpdate = CGEventCreateCopy(cgEventStart);
810  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventScrollPhase, kCGScrollPhaseChanged);
811  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis2, 1); // pan_x
812  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis1, 2); // pan_y
813 
814  called = false;
815  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
816  EXPECT_TRUE(called);
817  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
818  EXPECT_EQ(last_event.phase, kPanZoomUpdate);
819  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
820  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
821  EXPECT_EQ(last_event.pan_x, 8 * viewController.flutterView.layer.contentsScale);
822  EXPECT_EQ(last_event.pan_y, 16 * viewController.flutterView.layer.contentsScale);
823 
824  // Make sure the pan values accumulate.
825  called = false;
826  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
827  EXPECT_TRUE(called);
828  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
829  EXPECT_EQ(last_event.phase, kPanZoomUpdate);
830  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
831  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
832  EXPECT_EQ(last_event.pan_x, 16 * viewController.flutterView.layer.contentsScale);
833  EXPECT_EQ(last_event.pan_y, 32 * viewController.flutterView.layer.contentsScale);
834 
835  // End gesture.
836  CGEventRef cgEventEnd = CGEventCreateCopy(cgEventStart);
837  CGEventSetIntegerValueField(cgEventEnd, kCGScrollWheelEventScrollPhase, kCGScrollPhaseEnded);
838 
839  called = false;
840  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventEnd]];
841  EXPECT_TRUE(called);
842  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
843  EXPECT_EQ(last_event.phase, kPanZoomEnd);
844  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
845  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
846 
847  // Start system momentum.
848  CGEventRef cgEventMomentumStart = CGEventCreateCopy(cgEventStart);
849  CGEventSetIntegerValueField(cgEventMomentumStart, kCGScrollWheelEventScrollPhase, 0);
850  CGEventSetIntegerValueField(cgEventMomentumStart, kCGScrollWheelEventMomentumPhase,
851  kCGMomentumScrollPhaseBegin);
852 
853  called = false;
854  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumStart]];
855  EXPECT_FALSE(called);
856 
857  // Advance system momentum.
858  CGEventRef cgEventMomentumUpdate = CGEventCreateCopy(cgEventStart);
859  CGEventSetIntegerValueField(cgEventMomentumUpdate, kCGScrollWheelEventScrollPhase, 0);
860  CGEventSetIntegerValueField(cgEventMomentumUpdate, kCGScrollWheelEventMomentumPhase,
861  kCGMomentumScrollPhaseContinue);
862 
863  called = false;
864  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumUpdate]];
865  EXPECT_FALSE(called);
866 
867  // Mock a touch on the trackpad.
868  id touchMock = OCMClassMock([NSTouch class]);
869  NSSet* touchSet = [NSSet setWithObject:touchMock];
870  id touchEventMock1 = OCMClassMock([NSEvent class]);
871  OCMStub([touchEventMock1 allTouches]).andReturn(touchSet);
872  CGPoint touchLocation = {0, 0};
873  OCMStub([touchEventMock1 locationInWindow]).andReturn(touchLocation);
874  OCMStub([(NSEvent*)touchEventMock1 timestamp]).andReturn(0.150); // 150 milliseconds.
875 
876  // Scroll inertia cancel event should not be issued (timestamp too far in the future).
877  called = false;
878  [viewController touchesBeganWithEvent:touchEventMock1];
879  EXPECT_FALSE(called);
880 
881  // Mock another touch on the trackpad.
882  id touchEventMock2 = OCMClassMock([NSEvent class]);
883  OCMStub([touchEventMock2 allTouches]).andReturn(touchSet);
884  OCMStub([touchEventMock2 locationInWindow]).andReturn(touchLocation);
885  OCMStub([(NSEvent*)touchEventMock2 timestamp]).andReturn(0.005); // 5 milliseconds.
886 
887  // Scroll inertia cancel event should be issued.
888  called = false;
889  [viewController touchesBeganWithEvent:touchEventMock2];
890  EXPECT_TRUE(called);
891  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScrollInertiaCancel);
892  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
893 
894  // End system momentum.
895  CGEventRef cgEventMomentumEnd = CGEventCreateCopy(cgEventStart);
896  CGEventSetIntegerValueField(cgEventMomentumEnd, kCGScrollWheelEventScrollPhase, 0);
897  CGEventSetIntegerValueField(cgEventMomentumEnd, kCGScrollWheelEventMomentumPhase,
898  kCGMomentumScrollPhaseEnd);
899 
900  called = false;
901  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMomentumEnd]];
902  EXPECT_FALSE(called);
903 
904  // May-begin and cancel are used while macOS determines which type of gesture to choose.
905  CGEventRef cgEventMayBegin = CGEventCreateCopy(cgEventStart);
906  CGEventSetIntegerValueField(cgEventMayBegin, kCGScrollWheelEventScrollPhase,
907  kCGScrollPhaseMayBegin);
908 
909  called = false;
910  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventMayBegin]];
911  EXPECT_TRUE(called);
912  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
913  EXPECT_EQ(last_event.phase, kPanZoomStart);
914  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
915  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
916 
917  // Cancel gesture.
918  CGEventRef cgEventCancel = CGEventCreateCopy(cgEventStart);
919  CGEventSetIntegerValueField(cgEventCancel, kCGScrollWheelEventScrollPhase,
920  kCGScrollPhaseCancelled);
921 
922  called = false;
923  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventCancel]];
924  EXPECT_TRUE(called);
925  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
926  EXPECT_EQ(last_event.phase, kPanZoomEnd);
927  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
928  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
929 
930  // A discrete scroll event should use the PointerSignal system.
931  CGEventRef cgEventDiscrete = CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
932  CGEventSetType(cgEventDiscrete, kCGEventScrollWheel);
933  CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventIsContinuous, 0);
934  CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventDeltaAxis2, 1); // scroll_delta_x
935  CGEventSetIntegerValueField(cgEventDiscrete, kCGScrollWheelEventDeltaAxis1, 2); // scroll_delta_y
936 
937  called = false;
938  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventDiscrete]];
939  EXPECT_TRUE(called);
940  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScroll);
941  // pixelsPerLine is 40.0 and direction is reversed.
942  EXPECT_EQ(last_event.scroll_delta_x, -40 * viewController.flutterView.layer.contentsScale);
943  EXPECT_EQ(last_event.scroll_delta_y, -80 * viewController.flutterView.layer.contentsScale);
944 
945  // A discrete scroll event should use the PointerSignal system, and flip the
946  // direction when shift is pressed.
947  CGEventRef cgEventDiscreteShift =
948  CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0);
949  CGEventSetType(cgEventDiscreteShift, kCGEventScrollWheel);
950  CGEventSetFlags(cgEventDiscreteShift, static_cast<uint64_t>(kCGEventFlagMaskShift) |
951  static_cast<uint64_t>(flutter::kModifierFlagShiftLeft));
952  CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventIsContinuous, 0);
953  CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventDeltaAxis2,
954  0); // scroll_delta_x
955  CGEventSetIntegerValueField(cgEventDiscreteShift, kCGScrollWheelEventDeltaAxis1,
956  2); // scroll_delta_y
957 
958  called = false;
959  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventDiscreteShift]];
960  EXPECT_TRUE(called);
961  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindScroll);
962  // pixelsPerLine is 40.0, direction is reversed and axes have been flipped back.
963  EXPECT_FLOAT_EQ(last_event.scroll_delta_x, 0.0 * viewController.flutterView.layer.contentsScale);
964  EXPECT_FLOAT_EQ(last_event.scroll_delta_y,
965  -80.0 * viewController.flutterView.layer.contentsScale);
966 
967  // Test for scale events.
968  // Start gesture.
969  called = false;
970  [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
971  NSEventPhaseBegan, 1, 0)];
972  EXPECT_TRUE(called);
973  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
974  EXPECT_EQ(last_event.phase, kPanZoomStart);
975  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
976  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
977 
978  // Update gesture.
979  called = false;
980  [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
981  NSEventPhaseChanged, 1, 0)];
982  EXPECT_TRUE(called);
983  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
984  EXPECT_EQ(last_event.phase, kPanZoomUpdate);
985  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
986  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
987  EXPECT_EQ(last_event.pan_x, 0);
988  EXPECT_EQ(last_event.pan_y, 0);
989  EXPECT_EQ(last_event.scale, 2); // macOS uses logarithmic scaling values, the linear value for
990  // flutter here should be 2^1 = 2.
991  EXPECT_EQ(last_event.rotation, 0);
992 
993  // Make sure the scale values accumulate.
994  called = false;
995  [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
996  NSEventPhaseChanged, 1, 0)];
997  EXPECT_TRUE(called);
998  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
999  EXPECT_EQ(last_event.phase, kPanZoomUpdate);
1000  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1001  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1002  EXPECT_EQ(last_event.pan_x, 0);
1003  EXPECT_EQ(last_event.pan_y, 0);
1004  EXPECT_EQ(last_event.scale, 4); // macOS uses logarithmic scaling values, the linear value for
1005  // flutter here should be 2^(1+1) = 2.
1006  EXPECT_EQ(last_event.rotation, 0);
1007 
1008  // End gesture.
1009  called = false;
1010  [viewController magnifyWithEvent:flutter::testing::MockGestureEvent(NSEventTypeMagnify,
1011  NSEventPhaseEnded, 0, 0)];
1012  EXPECT_TRUE(called);
1013  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1014  EXPECT_EQ(last_event.phase, kPanZoomEnd);
1015  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1016  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1017 
1018  // Test for rotation events.
1019  // Start gesture.
1020  called = false;
1021  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(NSEventTypeRotate,
1022  NSEventPhaseBegan, 1, 0)];
1023  EXPECT_TRUE(called);
1024  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1025  EXPECT_EQ(last_event.phase, kPanZoomStart);
1026  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1027  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1028 
1029  // Update gesture.
1030  called = false;
1031  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(
1032  NSEventTypeRotate, NSEventPhaseChanged, 0, -180)]; // degrees
1033  EXPECT_TRUE(called);
1034  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1035  EXPECT_EQ(last_event.phase, kPanZoomUpdate);
1036  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1037  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1038  EXPECT_EQ(last_event.pan_x, 0);
1039  EXPECT_EQ(last_event.pan_y, 0);
1040  EXPECT_EQ(last_event.scale, 1);
1041  EXPECT_EQ(last_event.rotation, M_PI); // radians
1042 
1043  // Make sure the rotation values accumulate.
1044  called = false;
1045  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(
1046  NSEventTypeRotate, NSEventPhaseChanged, 0, -360)]; // degrees
1047  EXPECT_TRUE(called);
1048  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1049  EXPECT_EQ(last_event.phase, kPanZoomUpdate);
1050  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1051  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1052  EXPECT_EQ(last_event.pan_x, 0);
1053  EXPECT_EQ(last_event.pan_y, 0);
1054  EXPECT_EQ(last_event.scale, 1);
1055  EXPECT_EQ(last_event.rotation, 3 * M_PI); // radians
1056 
1057  // End gesture.
1058  called = false;
1059  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(NSEventTypeRotate,
1060  NSEventPhaseEnded, 0, 0)];
1061  EXPECT_TRUE(called);
1062  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1063  EXPECT_EQ(last_event.phase, kPanZoomEnd);
1064  EXPECT_EQ(last_event.device_kind, kFlutterPointerDeviceKindTrackpad);
1065  EXPECT_EQ(last_event.signal_kind, kFlutterPointerSignalKindNone);
1066 
1067  // Test that stray NSEventPhaseCancelled event does not crash
1068  called = false;
1069  [viewController rotateWithEvent:flutter::testing::MockGestureEvent(NSEventTypeRotate,
1070  NSEventPhaseCancelled, 0, 0)];
1071  EXPECT_FALSE(called);
1072 
1073  return true;
1074 }
1075 
1076 // Magic mouse can interleave mouse events with scroll events. This must not crash.
1077 - (bool)mouseAndGestureEventsAreHandledSeparately:(id)engineMock {
1078  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1079  nibName:@""
1080  bundle:nil];
1081  [viewController loadView];
1082 
1083  // Test for pan events.
1084  // Start gesture.
1085  fml::CFRef<CGEventRef> cgEventStart(
1086  CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitPixel, 1, 0));
1087  CGEventSetType(cgEventStart, kCGEventScrollWheel);
1088  CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventScrollPhase, kCGScrollPhaseBegan);
1089  CGEventSetIntegerValueField(cgEventStart, kCGScrollWheelEventIsContinuous, 1);
1090  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventStart]];
1091 
1092  fml::CFRef<CGEventRef> cgEventUpdate(CGEventCreateCopy(cgEventStart));
1093  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventScrollPhase, kCGScrollPhaseChanged);
1094  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis2, 1); // pan_x
1095  CGEventSetIntegerValueField(cgEventUpdate, kCGScrollWheelEventDeltaAxis1, 2); // pan_y
1096  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventUpdate]];
1097 
1098  NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1099  [viewController mouseEntered:mouseEvent];
1100  [viewController mouseExited:mouseEvent];
1101 
1102  // End gesture.
1103  fml::CFRef<CGEventRef> cgEventEnd(CGEventCreateCopy(cgEventStart));
1104  CGEventSetIntegerValueField(cgEventEnd, kCGScrollWheelEventScrollPhase, kCGScrollPhaseEnded);
1105  [viewController scrollWheel:[NSEvent eventWithCGEvent:cgEventEnd]];
1106 
1107  return true;
1108 }
1109 
1110 - (bool)testViewWillAppearCalledMultipleTimes:(id)engineMock {
1111  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1112  nibName:@""
1113  bundle:nil];
1114  [viewController viewWillAppear];
1115  [viewController viewWillAppear];
1116  return true;
1117 }
1118 
1119 - (bool)testLookupKeyAssets {
1120  FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:nil];
1121  NSString* key = [viewController lookupKeyForAsset:@"test.png"];
1122  EXPECT_TRUE(
1123  [key isEqualToString:@"Contents/Frameworks/App.framework/Resources/flutter_assets/test.png"]);
1124  return true;
1125 }
1126 
1128  FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:nil];
1129 
1130  NSString* packageKey = [viewController lookupKeyForAsset:@"test.png" fromPackage:@"test"];
1131  EXPECT_TRUE([packageKey
1132  isEqualToString:
1133  @"Contents/Frameworks/App.framework/Resources/flutter_assets/packages/test/test.png"]);
1134  return true;
1135 }
1136 
1137 static void SwizzledNoop(id self, SEL _cmd) {}
1138 
1139 // Verify workaround an AppKit bug where mouseDown/mouseUp are not called on the view controller if
1140 // the view is the content view of an NSPopover AND macOS's Reduced Transparency accessibility
1141 // setting is enabled.
1142 //
1143 // See: https://github.com/flutter/flutter/issues/115015
1144 // See: http://www.openradar.me/FB12050037
1145 // See: https://developer.apple.com/documentation/appkit/nsresponder/1524634-mousedown
1146 //
1147 // TODO(cbracken): https://github.com/flutter/flutter/issues/154063
1148 // Remove this test when we drop support for macOS 12 (Monterey).
1149 - (bool)testMouseDownUpEventsSentToNextResponder:(id)engineMock {
1150  if (@available(macOS 13.3.1, *)) {
1151  // This workaround is disabled for macOS 13.3.1 onwards, since the underlying AppKit bug is
1152  // fixed.
1153  return true;
1154  }
1155 
1156  // The root cause of the above bug is NSResponder mouseDown/mouseUp methods that don't correctly
1157  // walk the responder chain calling the appropriate method on the next responder under certain
1158  // conditions. Simulate this by swizzling out the default implementations and replacing them with
1159  // no-ops.
1160  Method mouseDown = class_getInstanceMethod([NSResponder class], @selector(mouseDown:));
1161  Method mouseUp = class_getInstanceMethod([NSResponder class], @selector(mouseUp:));
1162  IMP noopImp = (IMP)SwizzledNoop;
1163  IMP origMouseDown = method_setImplementation(mouseDown, noopImp);
1164  IMP origMouseUp = method_setImplementation(mouseUp, noopImp);
1165 
1166  // Verify that mouseDown/mouseUp trigger mouseDown/mouseUp calls on FlutterViewController.
1167  MouseEventFlutterViewController* viewController =
1168  [[MouseEventFlutterViewController alloc] initWithEngine:engineMock nibName:@"" bundle:nil];
1169  FlutterView* view = (FlutterView*)[viewController view];
1170 
1171  EXPECT_FALSE(viewController.mouseDownCalled);
1172  EXPECT_FALSE(viewController.mouseUpCalled);
1173 
1174  NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1175  [view mouseDown:mouseEvent];
1176  EXPECT_TRUE(viewController.mouseDownCalled);
1177  EXPECT_FALSE(viewController.mouseUpCalled);
1178 
1179  viewController.mouseDownCalled = NO;
1180  [view mouseUp:mouseEvent];
1181  EXPECT_FALSE(viewController.mouseDownCalled);
1182  EXPECT_TRUE(viewController.mouseUpCalled);
1183 
1184  // Restore the original NSResponder mouseDown/mouseUp implementations.
1185  method_setImplementation(mouseDown, origMouseDown);
1186  method_setImplementation(mouseUp, origMouseUp);
1187 
1188  return true;
1189 }
1190 
1191 - (bool)testModifierKeysAreSynthesizedOnMouseMove:(id)engineMock {
1192  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
1193  OCMStub( // NOLINT(google-objc-avoid-throwing-exception)
1194  [engineMock binaryMessenger])
1195  .andReturn(binaryMessengerMock);
1196 
1197  // Need to return a real renderer to allow view controller to load.
1198  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
1199  OCMStub([engineMock renderer]).andReturn(renderer_);
1200 
1201  FlutterKeyboardManager* keyboardManager =
1202  [[FlutterKeyboardManager alloc] initWithDelegate:engineMock];
1203  OCMStub([engineMock keyboardManager]).andReturn(keyboardManager);
1204 
1205  // Capture calls to sendKeyEvent
1206  __block NSMutableArray<KeyEventWrapper*>* events = [NSMutableArray array];
1207  OCMStub([[engineMock ignoringNonObjectArgs] sendKeyEvent:kDefaultFlutterKeyEvent
1208  callback:nil
1209  userData:nil])
1210  .andDo((^(NSInvocation* invocation) {
1211  FlutterKeyEvent* event;
1212  [invocation getArgument:&event atIndex:2];
1213  [events addObject:[[KeyEventWrapper alloc] initWithEvent:event]];
1214  }));
1215 
1216  __block NSMutableArray<NSDictionary*>* channelEvents = [NSMutableArray array];
1217  OCMStub([binaryMessengerMock sendOnChannel:@"flutter/keyevent"
1218  message:[OCMArg any]
1219  binaryReply:[OCMArg any]])
1220  .andDo((^(NSInvocation* invocation) {
1221  NSData* data;
1222  [invocation getArgument:&data atIndex:3];
1223  id event = [[FlutterJSONMessageCodec sharedInstance] decode:data];
1224  [channelEvents addObject:event];
1225  }));
1226 
1227  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1228  nibName:@""
1229  bundle:nil];
1230  [viewController loadView];
1231  [viewController viewWillAppear];
1232 
1233  // Zeroed modifier flag should not synthesize events.
1234  NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1235  [viewController mouseMoved:mouseEvent];
1236  EXPECT_EQ([events count], 0u);
1237 
1238  // For each modifier key, check that key events are synthesized.
1239  for (NSNumber* keyCode in flutter::keyCodeToModifierFlag) {
1240  FlutterKeyEvent* event;
1241  NSDictionary* channelEvent;
1242  NSNumber* logicalKey;
1243  NSNumber* physicalKey;
1244  NSEventModifierFlags flag = [flutter::keyCodeToModifierFlag[keyCode] unsignedLongValue];
1245 
1246  // Cocoa event always contain combined flags.
1248  flag |= NSEventModifierFlagShift;
1249  }
1251  flag |= NSEventModifierFlagControl;
1252  }
1254  flag |= NSEventModifierFlagOption;
1255  }
1257  flag |= NSEventModifierFlagCommand;
1258  }
1259 
1260  // Should synthesize down event.
1261  NSEvent* mouseEvent = flutter::testing::CreateMouseEvent(flag);
1262  [viewController mouseMoved:mouseEvent];
1263  EXPECT_EQ([events count], 1u);
1264  event = events[0].data;
1265  logicalKey = [flutter::keyCodeToLogicalKey objectForKey:keyCode];
1266  physicalKey = [flutter::keyCodeToPhysicalKey objectForKey:keyCode];
1267  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
1268  EXPECT_EQ(event->logical, logicalKey.unsignedLongLongValue);
1269  EXPECT_EQ(event->physical, physicalKey.unsignedLongLongValue);
1270  EXPECT_EQ(event->synthesized, true);
1271 
1272  channelEvent = channelEvents[0];
1273  EXPECT_TRUE([channelEvent[@"type"] isEqual:@"keydown"]);
1274  EXPECT_TRUE([channelEvent[@"keyCode"] isEqual:keyCode]);
1275  EXPECT_TRUE([channelEvent[@"modifiers"] isEqual:@(flag)]);
1276 
1277  // Should synthesize up event.
1278  mouseEvent = flutter::testing::CreateMouseEvent(0x00);
1279  [viewController mouseMoved:mouseEvent];
1280  EXPECT_EQ([events count], 2u);
1281  event = events[1].data;
1282  logicalKey = [flutter::keyCodeToLogicalKey objectForKey:keyCode];
1283  physicalKey = [flutter::keyCodeToPhysicalKey objectForKey:keyCode];
1284  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
1285  EXPECT_EQ(event->logical, logicalKey.unsignedLongLongValue);
1286  EXPECT_EQ(event->physical, physicalKey.unsignedLongLongValue);
1287  EXPECT_EQ(event->synthesized, true);
1288 
1289  channelEvent = channelEvents[1];
1290  EXPECT_TRUE([channelEvent[@"type"] isEqual:@"keyup"]);
1291  EXPECT_TRUE([channelEvent[@"keyCode"] isEqual:keyCode]);
1292  EXPECT_TRUE([channelEvent[@"modifiers"] isEqual:@(0)]);
1293 
1294  [events removeAllObjects];
1295  [channelEvents removeAllObjects];
1296  };
1297 
1298  return true;
1299 }
1300 
1302  __weak FlutterViewController* weakController;
1303  @autoreleasepool {
1304  id engineMock = flutter::testing::CreateMockFlutterEngine(@"");
1305 
1306  FlutterRenderer* renderer_ = [[FlutterRenderer alloc] initWithFlutterEngine:engineMock];
1307  OCMStub([engineMock renderer]).andReturn(renderer_);
1308 
1309  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
1310  nibName:@""
1311  bundle:nil];
1312  [viewController loadView];
1313  weakController = viewController;
1314 
1315  [engineMock shutDownEngine];
1316  }
1317 
1318  EXPECT_EQ(weakController, nil);
1319  return true;
1320 }
1321 
1322 @end
NS_ASSUME_NONNULL_BEGIN typedef void(^ FlutterBinaryReply)(NSData *_Nullable reply)
void(^ FlutterResult)(id _Nullable result)
static const FlutterKeyEvent kDefaultFlutterKeyEvent
static const FlutterPointerEvent kDefaultFlutterPointerEvent
static id JSONMessageWithContentOf(NSData *expected)
instancetype methodCallWithMethodName:arguments:(NSString *method,[arguments] id _Nullable arguments)
nonnull NSString * lookupKeyForAsset:(nonnull NSString *asset)
nonnull NSString * lookupKeyForAsset:fromPackage:(nonnull NSString *asset,[fromPackage] nonnull NSString *package)
FlutterMouseTrackingMode mouseTrackingMode
void onAccessibilityStatusChanged:(BOOL enabled)
id CreateMockFlutterEngine(NSString *pasteboardString)
AutoreleasePoolTest FlutterViewControllerTest
TEST_F(FlutterViewControllerTest, testViewControllerIsReleased)
const NSDictionary * keyCodeToModifierFlag
@ kModifierFlagControlLeft
@ kModifierFlagControlRight
instancetype sharedInstance()