FlutterChannelKeyResponder Class Reference

#import <FlutterChannelKeyResponder.h>

Inheritance diagram for FlutterChannelKeyResponder:

Instance Methods
(nonnull instancetype)	- initWithChannel:
(nonnull instancetype)	- initWithChannel:
(void)	- handlePress:callback: [implementation]
(void)	- updatePressedModifiers: [implementation]
(NSInteger)	- adjustModifiers: [implementation]
(void)	- checkModifierFlag:forEventFlags:keyCode:timestamp: [implementation]
(void)	- syncModifiersIfNeeded:timestamp: [implementation]
(void)	- handleEvent:callback: [implementation]
Instance Methods inherited from <FlutterKeyPrimaryResponder>
(void)	- handlePress:callback:
(void)	- handleEvent:callback:
(void)	- syncModifiersIfNeeded:timestamp:

Properties
FlutterBasicMessageChannel *	channel [implementation]
kKeyboardModifier	pressedModifiers [implementation]
uint64_t	previouslyPressedFlags [implementation]
Properties inherited from <FlutterKeyPrimaryResponder>
NSMutableDictionary< NSNumber *, NSNumber * > *	layoutMap

Detailed Description

A primary responder of |FlutterKeyboardManager| that handles events by sending the raw information through a method channel.

This class corresponds to the RawKeyboard API in the framework.

A primary responder of |FlutterKeyboardManager| that handles events by sending the raw information through the method channel.

This class communicates with the RawKeyboard API in the framework.

Definition at line 20 of file FlutterChannelKeyResponder.h.

Method Documentation

adjustModifiers:

- (NSInteger) adjustModifiers: (ios(13.4))  API_AVAILABLE

implementation

Definition at line 89 of file FlutterChannelKeyResponder.mm.

                            :(nonnull FlutterUIPressProxy*)press API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // no-op
  } else {
    return press.key.modifierFlags;
  }
 
  [self updatePressedModifiers:press];
  // Replace the supplied modifier flags with our computed ones.
  return _pressedModifiers | (press.key.modifierFlags & ~kKeyboardModifierMask);
}

checkModifierFlag:forEventFlags:keyCode:timestamp:

- (void) checkModifierFlag: (NSUInteger)  targetMask forEventFlags: (NSEventModifierFlags)  eventFlags keyCode: (NSUInteger)  keyCode timestamp: (NSTimeInterval)  timestamp

implementation

Checks single modifier flag from event flags and sends appropriate key event if it is different from the previous state.

Definition at line 26 of file FlutterChannelKeyResponder.mm.

                         :(NSUInteger)targetMask
            forEventFlags:(NSEventModifierFlags)eventFlags
                  keyCode:(NSUInteger)keyCode
                timestamp:(NSTimeInterval)timestamp {
  NSAssert((targetMask & (targetMask - 1)) == 0, @"targetMask must only have one bit set");
  if ((eventFlags & targetMask) != (_previouslyPressedFlags & targetMask)) {
    uint64_t newFlags = (_previouslyPressedFlags & ~targetMask) | (eventFlags & targetMask);
 
    // Sets combined flag if either left or right modifier is pressed, unsets otherwise.
    auto updateCombinedFlag = [&](uint64_t side1, uint64_t side2, NSEventModifierFlags flag) {
      if (newFlags & (side1 | side2)) {
        newFlags |= flag;
      } else {
        newFlags &= ~flag;
      }
    };
    updateCombinedFlag(flutter::kModifierFlagShiftLeft, flutter::kModifierFlagShiftRight,
                       NSEventModifierFlagShift);
    updateCombinedFlag(flutter::kModifierFlagControlLeft, flutter::kModifierFlagControlRight,
                       NSEventModifierFlagControl);
    updateCombinedFlag(flutter::kModifierFlagAltLeft, flutter::kModifierFlagAltRight,
                       NSEventModifierFlagOption);
    updateCombinedFlag(flutter::kModifierFlagMetaLeft, flutter::kModifierFlagMetaRight,
                       NSEventModifierFlagCommand);
 
    NSEvent* event = [NSEvent keyEventWithType:NSEventTypeFlagsChanged
                                      location:NSZeroPoint
                                 modifierFlags:newFlags
                                     timestamp:timestamp
                                  windowNumber:0
                                       context:nil
                                    characters:@""
                   charactersIgnoringModifiers:@""
                                     isARepeat:NO
                                       keyCode:keyCode];
    [self handleEvent:event
             callback:^(BOOL){
             }];
  };
}

handleEvent:callback:

- (void) handleEvent: (NSEvent*)  event callback: (FlutterAsyncKeyCallback)  callback

implementation

Definition at line 26 of file FlutterChannelKeyResponder.mm.

                   :(NSEvent*)event callback:(FlutterAsyncKeyCallback)callback {
  // Remove the modifier bits that Flutter is not interested in.
  NSEventModifierFlags modifierFlags = event.modifierFlags & ~0x100;
  NSString* type;
  switch (event.type) {
    case NSEventTypeKeyDown:
      type = @"keydown";
      break;
    case NSEventTypeKeyUp:
      type = @"keyup";
      break;
    case NSEventTypeFlagsChanged:
      if (modifierFlags < _previouslyPressedFlags) {
        type = @"keyup";
      } else if (modifierFlags > _previouslyPressedFlags) {
        type = @"keydown";
      } else {
        // ignore duplicate modifiers; This can happen in situations like switching
        // between application windows when MacOS only sends the up event to new window.
        callback(true);
        return;
      }
      break;
    default: {
      NSAssert(false, @"Unexpected key event type (got %lu).", event.type);
      callback(false);
    }
  }
  _previouslyPressedFlags = modifierFlags;
  NSMutableDictionary* keyMessage = [@{
    @"keymap" : @"macos",
    @"type" : type,
    @"keyCode" : @(event.keyCode),
    @"modifiers" : @(modifierFlags),
  } mutableCopy];
  // Calling these methods on any other type of event
  // (e.g NSEventTypeFlagsChanged) will raise an exception.
  if (event.type == NSEventTypeKeyDown || event.type == NSEventTypeKeyUp) {
    keyMessage[@"characters"] = event.characters;
    keyMessage[@"charactersIgnoringModifiers"] = event.charactersIgnoringModifiers;
  }
  NSNumber* specifiedLogicalKey = layoutMap[@(event.keyCode)];
  if (specifiedLogicalKey != nil) {
    keyMessage[@"specifiedLogicalKey"] = specifiedLogicalKey;
  }
  [self.channel sendMessage:keyMessage
                      reply:^(id reply) {
                        if (!reply) {
                          return callback(true);
                        }
                        // Only propagate the event to other responders if the framework didn't
                        // handle it.
                        callback([[reply valueForKey:@"handled"] boolValue]);
                      }];
}

handlePress:callback:

- (void) handlePress: (nonnull FlutterUIPressProxy *)  press callback: (ios(13.4))  API_AVAILABLE

implementation

Process the event.

The |callback| should be called with a value that indicates whether the responder has handled the given press event. The |callback| must be called exactly once, and can be called before the return of this method, or after.

Reimplemented from <FlutterKeyPrimaryResponder>.

Definition at line 89 of file FlutterChannelKeyResponder.mm.

                   :(nonnull FlutterUIPressProxy*)press
           callback:(nonnull FlutterAsyncKeyCallback)callback API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // no-op
  } else {
    return;
  }
  NSString* type;
  switch (press.phase) {
    case UIPressPhaseBegan:
      type = @"keydown";
      break;
    case UIPressPhaseCancelled:
      // This event doesn't appear to happen on iOS, at least when switching
      // apps. Maybe on tvOS? In any case, it's probably best to send a keyup if
      // we do receive one, since if the event was canceled, it's likely that a
      // keyup will never be received otherwise.
    case UIPressPhaseEnded:
      type = @"keyup";
      break;
    case UIPressPhaseChanged:
      // This only happens for analog devices like joysticks.
      return;
    case UIPressPhaseStationary:
      // The entire volume of documentation of this phase on the Apple site, and
      // indeed the Internet, is:
      //   "A button was pressed but hasn’t moved since the previous event."
      // It's unclear what this is actually used for, and we've yet to see it in
      // the wild.
      return;
  }
 
  NSString* characters = getEventCharacters(press.key.characters, press.key.keyCode);
  NSString* charactersIgnoringModifiers =
      getEventCharacters(press.key.charactersIgnoringModifiers, press.key.keyCode);
  NSDictionary* keyMessage = @{
    @"keymap" : @"ios",
    @"type" : type,
    @"keyCode" : @(press.key.keyCode),
    @"modifiers" : @([self adjustModifiers:press]),
    @"characters" : characters == nil ? @"" : characters,
    @"charactersIgnoringModifiers" : charactersIgnoringModifiers == nil
        ? @""
        : charactersIgnoringModifiers,
  };
  [self.channel sendMessage:keyMessage
                      reply:^(id reply) {
                        bool handled = reply ? [[reply valueForKey:@"handled"] boolValue] : true;
                        callback(handled);
                      }];
}

initWithChannel: [1/2]

- (nonnull instancetype) initWithChannel:

(nonnull FlutterBasicMessageChannel*)

channel

Create an instance by specifying the method channel to use.

Definition at line 89 of file FlutterChannelKeyResponder.mm.

                                       :(nonnull FlutterBasicMessageChannel*)channel {
  self = [super init];
  if (self != nil) {
    _channel = channel;
    _pressedModifiers = 0;
  }
  return self;
}

initWithChannel: [2/2]

- (nonnull instancetype) initWithChannel:

(nonnull FlutterBasicMessageChannel *)

channel

Create an instance by specifying the method channel to use.

syncModifiersIfNeeded:timestamp:

- (void) syncModifiersIfNeeded: (NSEventModifierFlags)  modifierFlags timestamp: (NSTimeInterval)  timestamp

implementation

Synchronize the modifier flags if necessary. The new modifier flag would usually come from mouse event and may be out of sync with current keyboard state if the modifier flags have changed while window was not key.

Reimplemented from <FlutterKeyPrimaryResponder>.

Definition at line 26 of file FlutterChannelKeyResponder.mm.

                             :(NSEventModifierFlags)modifierFlags
                    timestamp:(NSTimeInterval)timestamp {
  modifierFlags = modifierFlags & ~0x100;
  if (_previouslyPressedFlags == modifierFlags) {
    return;
  }
 
  [flutter::modifierFlagToKeyCode
      enumerateKeysAndObjectsUsingBlock:^(NSNumber* flag, NSNumber* keyCode, BOOL* stop) {
        [self checkModifierFlag:[flag unsignedShortValue]
                  forEventFlags:modifierFlags
                        keyCode:[keyCode unsignedShortValue]
                      timestamp:timestamp];
      }];
 
  // Caps lock is not included in the modifierFlagToKeyCode map.
  [self checkModifierFlag:NSEventModifierFlagCapsLock
            forEventFlags:modifierFlags
                  keyCode:0x00000039  // kVK_CapsLock
                timestamp:timestamp];
 
  // At the end we should end up with the same modifier flags as the event.
  FML_DCHECK(_previouslyPressedFlags == modifierFlags);
}

updatePressedModifiers:

- (void) updatePressedModifiers: (ios(13.4))  API_AVAILABLE

implementation

Definition at line 89 of file FlutterChannelKeyResponder.mm.

                              :(nonnull FlutterUIPressProxy*)press API_AVAILABLE(ios(13.4)) {
  if (@available(iOS 13.4, *)) {
    // no-op
  } else {
    return;
  }
 
  bool isKeyDown = false;
  switch (press.phase) {
    case UIPressPhaseStationary:
    case UIPressPhaseChanged:
      // These kinds of events shouldn't get this far.
      NSAssert(false, @"Unexpected key event type received in updatePressedModifiers.");
      return;
    case UIPressPhaseBegan:
      isKeyDown = true;
      break;
    case UIPressPhaseCancelled:
    case UIPressPhaseEnded:
      isKeyDown = false;
      break;
  }
 
  void (^update)(kKeyboardModifier, bool) = ^(kKeyboardModifier mod, bool isOn) {
    if (isOn) {
      _pressedModifiers |= mod;
    } else {
      _pressedModifiers &= ~mod;
    }
  };
  switch (press.key.keyCode) {
    case UIKeyboardHIDUsageKeyboardCapsLock:
      update(kKeyboardModifierAlphaShift, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeypadNumLock:
      update(kKeyboardModifierNumericPad, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardLeftShift:
      update(kKeyboardModifierLeftShift, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardRightShift:
      update(kKeyboardModifierRightShift, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardLeftControl:
      update(kKeyboardModifierLeftControl, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardRightControl:
      update(kKeyboardModifierRightControl, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardLeftAlt:
      update(kKeyboardModifierLeftOption, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardRightAlt:
      update(kKeyboardModifierRightOption, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardLeftGUI:
      update(kKeyboardModifierLeftCommand, isKeyDown);
      break;
    case UIKeyboardHIDUsageKeyboardRightGUI:
      update(kKeyboardModifierRightCommand, isKeyDown);
      break;
    default:
      // If we didn't update any of the modifiers above, we're done.
      return;
  }
  // Update the non-sided modifier flags to match the content of the sided ones.
  update(kKeyboardModifierShift,
         _pressedModifiers & (kKeyboardModifierRightShift | kKeyboardModifierLeftShift));
  update(kKeyboardModifierControl,
         _pressedModifiers & (kKeyboardModifierRightControl | kKeyboardModifierLeftControl));
  update(kKeyboardModifierOption,
         _pressedModifiers & (kKeyboardModifierRightOption | kKeyboardModifierLeftOption));
  update(kKeyboardModifierCommand,
         _pressedModifiers & (kKeyboardModifierRightCommand | kKeyboardModifierLeftCommand));
}

Property Documentation

channel

- (FlutterBasicMessageChannel*) channel

readwritenonatomicassignimplementation

The channel used to communicate with Flutter.

Definition at line 84 of file FlutterChannelKeyResponder.mm.

pressedModifiers

- (kKeyboardModifier) pressedModifiers

readwritenonatomicassignimplementation

Definition at line 89 of file FlutterChannelKeyResponder.mm.

previouslyPressedFlags

- (uint64_t) previouslyPressedFlags

readwritenonatomicassignimplementation

The |NSEvent.modifierFlags| of the last event received.

Used to determine whether a FlagsChanged event should count as a keydown or a keyup event.

Definition at line 26 of file FlutterChannelKeyResponder.mm.

---

The documentation for this class was generated from the following files:

• shell/platform/darwin/ios/framework/Source/FlutterChannelKeyResponder.h
• shell/platform/darwin/macos/framework/Source/FlutterChannelKeyResponder.h
• shell/platform/darwin/ios/framework/Source/FlutterChannelKeyResponder.mm
• shell/platform/darwin/macos/framework/Source/FlutterChannelKeyResponder.mm