FLUTTER_ASSERT_ARC Namespace Reference

Classes
class	MachThreads
class	MockPlatformMessageResponse

Functions
typedef	NS_OPTIONS (NSInteger, kKeyboardModifier)
static NSString *	getEventCharacters (NSString *characters, UIKeyboardHIDUsage keyCode) API_AVAILABLE(ios(13.4))
static NSUInteger	lowestSetBit (NSUInteger bitmask)
static bool	IsControlCharacter (NSUInteger length, NSString *label)
static bool	IsUnprintableKey (NSUInteger length, NSString *label)
static uint64_t	KeyOfPlane (uint64_t baseKey, uint64_t plane)
static uint64_t	GetPhysicalKeyForKeyCode (UInt32 keyCode)
static uint64_t	GetLogicalKeyForModifier (UInt32 keyCode, uint64_t hidCode)
static uint64_t	toLower (uint64_t n)
static const char *	getEventCharacters (NSString *characters, UIKeyboardHIDUsage keyCode) API_AVAILABLE(ios(13.4))
static uint64_t	GetLogicalKeyForEvent (FlutterUIPressProxy *press, NSNumber *maybeSpecialKey) API_AVAILABLE(ios(13.4))
static double	GetFlutterTimestampFrom (NSTimeInterval timestamp)
static NSUInteger	computeModifierFlagOfInterestMask ()
static bool	isKeyDown (FlutterUIPressProxy *press) API_AVAILABLE(ios(13.4))
void	HandleResponse (bool handled, void *user_data)
fml::RefPtr< fml::TaskRunner >	CreateNewThread (const std::string &name)
fml::RefPtr< fml::TaskRunner >	GetCurrentTaskRunner ()

Function Documentation

computeModifierFlagOfInterestMask()

static NSUInteger FLUTTER_ASSERT_ARC::computeModifierFlagOfInterestMask ( )

static

Compute |modifierFlagOfInterestMask| out of |keyCodeToModifierFlag|.

This is equal to the bitwise-or of all values of |keyCodeToModifierFlag|.

Definition at line 211 of file FlutterEmbedderKeyResponder.mm.

                                                      {
  NSUInteger modifierFlagOfInterestMask = kModifierFlagCapsLock | kModifierFlagShiftAny |
                                          kModifierFlagControlAny | kModifierFlagAltAny |
                                          kModifierFlagMetaAny;
  for (std::pair<UInt32, ModifierFlag> entry : keyCodeToModifierFlag) {
    modifierFlagOfInterestMask = modifierFlagOfInterestMask | entry.second;
  }
  return modifierFlagOfInterestMask;
}

CreateNewThread()

fml::RefPtr< fml::TaskRunner > FLUTTER_ASSERT_ARC::CreateNewThread

(

const std::string &

name

)

Definition at line 16 of file VsyncWaiterIosTest.mm.

                                                                {
  auto thread = std::make_unique<fml::Thread>(name);
  auto runner = thread->GetTaskRunner();
  return runner;
}

GetCurrentTaskRunner()

fml::RefPtr< fml::TaskRunner > FLUTTER_ASSERT_ARC::GetCurrentTaskRunner

(

)

Definition at line 27 of file platform_message_handler_ios_test.mm.

                                                {
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  return fml::MessageLoop::GetCurrent().GetTaskRunner();
}

getEventCharacters() [1/2]

static NSString * FLUTTER_ASSERT_ARC::getEventCharacters ( NSString *  characters, UIKeyboardHIDUsage  keyCode  )

static

Filters out some special cases in the characters field on UIKey.

Definition at line 53 of file FlutterChannelKeyResponder.mm.

                             {
  if (characters == nil) {
    return nil;
  }
  if ([characters length] == 0) {
    return nil;
  }
  if (@available(iOS 13.4, *)) {
    // On iOS, function keys return the UTF8 string "\^P" (with a literal '/',
    // '^' and a 'P', not escaped ctrl-P) as their "characters" field. This
    // isn't a valid (single) UTF8 character. Looking at the only UTF16
    // character for a function key yields a value of "16", which is a Unicode
    // "SHIFT IN" character, which is just odd. UTF8 conversion of that string
    // is what generates the three characters "\^P".
    //
    // Anyhow, we strip them all out and replace them with empty strings, since
    // function keys shouldn't be printable.
    if (functionKeyCodes.find(keyCode) != functionKeyCodes.end()) {
      return nil;
    }
  }
  return characters;
}

getEventCharacters() [2/2]

static const char * FLUTTER_ASSERT_ARC::getEventCharacters ( NSString *  characters, UIKeyboardHIDUsage  keyCode  )

static

Filters out some special cases in the characters field on UIKey.

Definition at line 124 of file FlutterEmbedderKeyResponder.mm.

                             {
  if (characters == nil) {
    return nullptr;
  }
  if ([characters length] == 0) {
    return nullptr;
  }
  if (@available(iOS 13.4, *)) {
    // On iOS, function keys return the UTF8 string "\^P" (with a literal '/',
    // '^' and a 'P', not escaped ctrl-P) as their "characters" field. This
    // isn't a valid (single) UTF8 character. Looking at the only UTF16
    // character for a function key yields a value of "16", which is a Unicode
    // "SHIFT IN" character, which is just odd. UTF8 conversion of that string
    // is what generates the three characters "\^P".
    //
    // Anyhow, we strip them all out and replace them with empty strings, since
    // function keys shouldn't be printable.
    if (functionKeyCodes.find(keyCode) != functionKeyCodes.end()) {
      return nullptr;
    }
  }
  return [characters UTF8String];
}

GetFlutterTimestampFrom()

static double FLUTTER_ASSERT_ARC::GetFlutterTimestampFrom ( NSTimeInterval  timestamp )

static

Converts NSEvent.timestamp to the timestamp for Flutter.

Definition at line 201 of file FlutterEmbedderKeyResponder.mm.

                                                                {
  // Timestamp in microseconds. The event.timestamp is in seconds with sub-ms precision.
  return timestamp * 1000000.0;
}

GetLogicalKeyForEvent()

static uint64_t FLUTTER_ASSERT_ARC::GetLogicalKeyForEvent ( FlutterUIPressProxy *  press, NSNumber *  maybeSpecialKey  )

static

Returns the logical key of a KeyUp or KeyDown event.

The maybeSpecialKey is a nullable integer, and if not nil, indicates that the event key is a special key as defined by specialKeyMapping, and is the corresponding logical key.

For modifier keys, use GetLogicalKeyForModifier.

Definition at line 158 of file FlutterEmbedderKeyResponder.mm.

                             {
  if (maybeSpecialKey != nil) {
    return [maybeSpecialKey unsignedLongLongValue];
  }
  // Look to see if the keyCode can be mapped from keycode.
  auto fromKeyCode = keyCodeToLogicalKey.find(press.key.keyCode);
  if (fromKeyCode != keyCodeToLogicalKey.end()) {
    return fromKeyCode->second;
  }
  const char* characters =
      getEventCharacters(press.key.charactersIgnoringModifiers, press.key.keyCode);
  NSString* keyLabel =
      characters == nullptr ? nil : [[NSString alloc] initWithUTF8String:characters];
  NSUInteger keyLabelLength = [keyLabel length];
  // If this key is printable, generate the logical key from its Unicode
  // value. Control keys such as ESC, CTRL, and SHIFT are not printable. HOME,
  // DEL, arrow keys, and function keys are considered modifier function keys,
  // which generate invalid Unicode scalar values.
  if (keyLabelLength != 0 && !IsControlCharacter(keyLabelLength, keyLabel) &&
      !IsUnprintableKey(keyLabelLength, keyLabel)) {
    // Given that charactersIgnoringModifiers can contain a string of arbitrary
    // length, limit to a maximum of two Unicode scalar values. It is unlikely
    // that a keyboard would produce a code point bigger than 32 bits, but it is
    // still worth defending against this case.
    NSCAssert((keyLabelLength < 2), @"Unexpected long key label: |%@|.", keyLabel);
 
    uint64_t codeUnit = (uint64_t)[keyLabel characterAtIndex:0];
    if (keyLabelLength == 2) {
      uint64_t secondCode = (uint64_t)[keyLabel characterAtIndex:1];
      codeUnit = (codeUnit << 16) | secondCode;
    }
    return KeyOfPlane(toLower(codeUnit), kUnicodePlane);
  }
 
  // This is a non-printable key that is unrecognized, so a new code is minted
  // with the autogenerated bit set.
  return KeyOfPlane(press.key.keyCode, kIosPlane);
}

GetLogicalKeyForModifier()

static uint64_t FLUTTER_ASSERT_ARC::GetLogicalKeyForModifier ( UInt32  keyCode, uint64_t  hidCode  )

static

Returns the logical key for a modifier physical key.

Definition at line 84 of file FlutterEmbedderKeyResponder.mm.

                                                                           {
  auto fromKeyCode = keyCodeToLogicalKey.find(keyCode);
  if (fromKeyCode != keyCodeToLogicalKey.end()) {
    return fromKeyCode->second;
  }
  return KeyOfPlane(hidCode, kIosPlane);
}

GetPhysicalKeyForKeyCode()

static uint64_t FLUTTER_ASSERT_ARC::GetPhysicalKeyForKeyCode ( UInt32  keyCode )

static

Returns the physical key for a key code.

Definition at line 73 of file FlutterEmbedderKeyResponder.mm.

                                                         {
  auto physicalKey = keyCodeToPhysicalKey.find(keyCode);
  if (physicalKey == keyCodeToPhysicalKey.end()) {
    return KeyOfPlane(keyCode, kIosPlane);
  }
  return physicalKey->second;
}

HandleResponse()

void FLUTTER_ASSERT_ARC::HandleResponse	(	bool	handled,
		void *	user_data
	)

The C-function sent to the engine's |sendKeyEvent|, wrapping |FlutterEmbedderKeyResponder.handleResponse|.

For the reason of this wrap, see |FlutterKeyPendingResponse|.

IsControlCharacter()

static bool FLUTTER_ASSERT_ARC::IsControlCharacter ( NSUInteger  length, NSString *  label  )

static

Whether a string represents a control character.

Definition at line 37 of file FlutterEmbedderKeyResponder.mm.

                                                                   {
  if (length > 1) {
    return false;
  }
  unichar codeUnit = [label characterAtIndex:0];
  return (codeUnit <= 0x1f && codeUnit >= 0x00) || (codeUnit >= 0x7f && codeUnit <= 0x9f);
}

isKeyDown()

static bool FLUTTER_ASSERT_ARC::isKeyDown ( FlutterUIPressProxy *  press )

static

Definition at line 221 of file FlutterEmbedderKeyResponder.mm.

                                                                           {
  switch (press.phase) {
    case UIPressPhaseStationary:
    case UIPressPhaseChanged:
      // Not sure if this is the right thing to do for these two, but true seems
      // more correct than false.
      return true;
    case UIPressPhaseBegan:
      return true;
    case UIPressPhaseCancelled:
    case UIPressPhaseEnded:
      return false;
  }
  return false;
}

IsUnprintableKey()

static bool FLUTTER_ASSERT_ARC::IsUnprintableKey ( NSUInteger  length, NSString *  label  )

static

Whether a string represents an unprintable key.

Definition at line 48 of file FlutterEmbedderKeyResponder.mm.

                                                                 {
  if (length > 1) {
    return false;
  }
  unichar codeUnit = [label characterAtIndex:0];
  return codeUnit >= 0xF700 && codeUnit <= 0xF8FF;
}

KeyOfPlane()

static uint64_t FLUTTER_ASSERT_ARC::KeyOfPlane ( uint64_t  baseKey, uint64_t  plane  )

static

Returns a key code composed with a base key and a plane.

Examples of unprintable keys are "NSUpArrowFunctionKey = 0xF700" or "NSHomeFunctionKey = 0xF729".

See https://developer.apple.com/documentation/appkit/1535851-function-key_unicodes?language=objc for more information.

Definition at line 66 of file FlutterEmbedderKeyResponder.mm.

                                                             {
  return plane | (baseKey & kValueMask);
}

lowestSetBit()

static NSUInteger FLUTTER_ASSERT_ARC::lowestSetBit ( NSUInteger  bitmask )

static

Isolate the least significant 1-bit.

For example,

• lowestSetBit(0x1010) returns 0x10.
• lowestSetBit(0) returns 0.

Definition at line 28 of file FlutterEmbedderKeyResponder.mm.

                                                   {
  // This utilizes property of two's complement (negation), which propagates a
  // carry bit from LSB to the lowest set bit.
  return bitmask & -bitmask;
}

NS_OPTIONS()

typedef FLUTTER_ASSERT_ARC::NS_OPTIONS	(	NSInteger	,
		kKeyboardModifier
	)

Definition at line 19 of file FlutterChannelKeyResponder.mm.

                                                 {
  kKeyboardModifierAlphaShift = 0x10000,
  kKeyboardModifierShift = 0x20000,
  kKeyboardModifierLeftShift = 0x02,
  kKeyboardModifierRightShift = 0x04,
  kKeyboardModifierControl = 0x40000,
  kKeyboardModifierLeftControl = 0x01,
  kKeyboardModifierRightControl = 0x2000,
  kKeyboardModifierOption = 0x80000,
  kKeyboardModifierLeftOption = 0x20,
  kKeyboardModifierRightOption = 0x40,
  kKeyboardModifierCommand = 0x100000,
  kKeyboardModifierLeftCommand = 0x08,
  kKeyboardModifierRightCommand = 0x10,
  kKeyboardModifierNumericPad = 0x200000,
  kKeyboardModifierMask = kKeyboardModifierAlphaShift |    //
                          kKeyboardModifierShift |         //
                          kKeyboardModifierLeftShift |     //
                          kKeyboardModifierRightShift |    //
                          kKeyboardModifierControl |       //
                          kKeyboardModifierLeftControl |   //
                          kKeyboardModifierRightControl |  //
                          kKeyboardModifierOption |        //
                          kKeyboardModifierLeftOption |    //
                          kKeyboardModifierRightOption |   //
                          kKeyboardModifierCommand |       //
                          kKeyboardModifierLeftCommand |   //
                          kKeyboardModifierRightCommand |  //
                          kKeyboardModifierNumericPad,
};

toLower()

static uint64_t FLUTTER_ASSERT_ARC::toLower ( uint64_t  n )

static

Converts upper letters to lower letters in ASCII and extended ASCII, and returns as-is otherwise.

Independent of locale.

Definition at line 98 of file FlutterEmbedderKeyResponder.mm.

                                    {
  constexpr uint64_t lower_a = 0x61;
  constexpr uint64_t upper_a = 0x41;
  constexpr uint64_t upper_z = 0x5a;
 
  constexpr uint64_t lower_a_grave = 0xe0;
  constexpr uint64_t upper_a_grave = 0xc0;
  constexpr uint64_t upper_thorn = 0xde;
  constexpr uint64_t division = 0xf7;
 
  // ASCII range.
  if (n >= upper_a && n <= upper_z) {
    return n - upper_a + lower_a;
  }
 
  // EASCII range.
  if (n >= upper_a_grave && n <= upper_thorn && n != division) {
    return n - upper_a_grave + lower_a_grave;
  }
 
  return n;
}