flutter_runner::TextDelegate Class Reference

#include <text_delegate.h>

Inheritance diagram for flutter_runner::TextDelegate:

Public Member Functions
	TextDelegate (fuchsia::ui::views::ViewRef view_ref, fuchsia::ui::input::ImeServiceHandle ime_service, fuchsia::ui::input3::KeyboardHandle keyboard, std::function< void(std::unique_ptr< flutter::PlatformMessage >)> dispatch_callback)
void	OnKeyEvent (fuchsia::ui::input3::KeyEvent key_event, fuchsia::ui::input3::KeyboardListener::OnKeyEventCallback callback) override
void	DidUpdateState (fuchsia::ui::input::TextInputState state, std::unique_ptr< fuchsia::ui::input::InputEvent > event) override
void	OnAction (fuchsia::ui::input::InputMethodAction action) override
void	ActivateIme ()
void	DeactivateIme ()
bool	HandleFlutterTextInputChannelPlatformMessage (std::unique_ptr< flutter::PlatformMessage > message)
	Channel handler for kTextInputChannel.
bool	HasTextState ()

Detailed Description

TextDelegate handles keyboard inpout and text editing.

It mediates between Fuchsia's input and Flutter's platform messages. When it is initialized, it contacts fuchsia.ui.input.Keyboard to register itself as listener of key events.

Whenever a text editing request comes from the Flutter app, it will activate Fuchsia's input method editor, and will send text edit actions coming from the Fuchsia platform over to the Flutter app, by converting FIDL messages (fuchsia.ui.input.InputMethodEditorClient calls) to appropriate text editing Flutter platform messages.

For details refer to:

• Flutter side: https://api.flutter.dev/javadoc/io/flutter/embedding/engine/systemchannels/TextInputChannel.html
• Fuchsia side: https://fuchsia.dev/reference/fidl/fuchsia.ui.input

Definition at line 46 of file text_delegate.h.

Constructor & Destructor Documentation

TextDelegate()

flutter_runner::TextDelegate::TextDelegate	(	fuchsia::ui::views::ViewRef	view_ref,
		fuchsia::ui::input::ImeServiceHandle	ime_service,
		fuchsia::ui::input3::KeyboardHandle	keyboard,
		std::function< void(std::unique_ptr< flutter::PlatformMessage >)>	dispatch_callback
	)

Creates a new TextDelegate.

Args: view_ref: the reference to the app's view. Required for registration with Fuchsia. ime_service: a handle to Fuchsia's input method service. keyboard: the keyboard listener, gets notified of key presses and releases. dispatch_callback: a function used to send a Flutter platform message.

Definition at line 113 of file text_delegate.cc.

    : dispatch_callback_(dispatch_callback),
      ime_client_(this),
      text_sync_service_(ime_service.Bind()),
      keyboard_listener_binding_(this),
      keyboard_(keyboard.Bind()) {
  // Register all error handlers.
  SetInterfaceErrorHandler(ime_, "Input Method Editor");
  SetInterfaceErrorHandler(ime_client_, "IME Client");
  SetInterfaceErrorHandler(text_sync_service_, "Text Sync Service");
  SetInterfaceErrorHandler(keyboard_listener_binding_, "Keyboard Listener");
  SetInterfaceErrorHandler(keyboard_, "Keyboard");
 
  // Configure keyboard listener.
  keyboard_->AddListener(std::move(view_ref),
                         keyboard_listener_binding_.NewBinding(), [] {});
}

References flutter_runner::SetInterfaceErrorHandler().

Member Function Documentation

ActivateIme()

void flutter_runner::TextDelegate::ActivateIme

(

)

Gets a new input method editor from the input connection. Run when both Scenic has focus and Flutter has requested input with setClient.

Definition at line 136 of file text_delegate.cc.

                               {
  ActivateIme(requested_text_action_.value_or(
      fuchsia::ui::input::InputMethodAction::DONE));
}

References ActivateIme().

Referenced by ActivateIme(), and HandleFlutterTextInputChannelPlatformMessage().

DeactivateIme()

void flutter_runner::TextDelegate::DeactivateIme

(

)

Detaches the input method editor connection, ending the edit session and closing the onscreen keyboard. Call when input is no longer desired, either because Scenic says we lost focus or when Flutter no longer has a text field focused.

Definition at line 154 of file text_delegate.cc.

                                 {
  if (ime_) {
    text_sync_service_->HideKeyboard();
    ime_ = nullptr;
  }
  if (ime_client_.is_bound()) {
    ime_client_.Unbind();
  }
}

Referenced by HandleFlutterTextInputChannelPlatformMessage().

DidUpdateState()

void flutter_runner::TextDelegate::DidUpdateState ( fuchsia::ui::input::TextInputState  state, std::unique_ptr< fuchsia::ui::input::InputEvent >  event  )

override

|fuchsia::ui::input::InputMethodEditorClient| Called by the embedder every time the edit state is updated.

Definition at line 165 of file text_delegate.cc.

                                                         {
  rapidjson::Document document;
  auto& allocator = document.GetAllocator();
  rapidjson::Value encoded_state(rapidjson::kObjectType);
  encoded_state.AddMember("text", state.text, allocator);
  encoded_state.AddMember("selectionBase", state.selection.base, allocator);
  encoded_state.AddMember("selectionExtent", state.selection.extent, allocator);
  switch (state.selection.affinity) {
    case fuchsia::ui::input::TextAffinity::UPSTREAM:
      encoded_state.AddMember("selectionAffinity",
                              rapidjson::Value("TextAffinity.upstream"),
                              allocator);
      break;
    case fuchsia::ui::input::TextAffinity::DOWNSTREAM:
      encoded_state.AddMember("selectionAffinity",
                              rapidjson::Value("TextAffinity.downstream"),
                              allocator);
      break;
  }
  encoded_state.AddMember("selectionIsDirectional", true, allocator);
  encoded_state.AddMember("composingBase", state.composing.start, allocator);
  encoded_state.AddMember("composingExtent", state.composing.end, allocator);
 
  rapidjson::Value args(rapidjson::kArrayType);
  args.PushBack(current_text_input_client_, allocator);
  args.PushBack(encoded_state, allocator);
 
  document.SetObject();
  document.AddMember("method",
                     rapidjson::Value("TextInputClient.updateEditingState"),
                     allocator);
  document.AddMember("args", args, allocator);
 
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
 
  const uint8_t* data = reinterpret_cast<const uint8_t*>(buffer.GetString());
  dispatch_callback_(std::make_unique<flutter::PlatformMessage>(
      kTextInputChannel,                                 // channel
      fml::MallocMapping::Copy(data, buffer.GetSize()),  // message
      nullptr)                                           // response
  );
  last_text_state_ = std::move(state);
}

References allocator, args, fml::MallocMapping::Copy(), and flutter_runner::kTextInputChannel.

HandleFlutterTextInputChannelPlatformMessage()

bool flutter_runner::TextDelegate::HandleFlutterTextInputChannelPlatformMessage

(

std::unique_ptr< flutter::PlatformMessage >

message

)

Channel handler for kTextInputChannel.

Definition at line 244 of file text_delegate.cc.

                                                   {
  FML_DCHECK(message->channel() == kTextInputChannel);
  const auto& data = message->data();
 
  rapidjson::Document document;
  document.Parse(reinterpret_cast<const char*>(data.GetMapping()),
                 data.GetSize());
  if (document.HasParseError() || !document.IsObject()) {
    return false;
  }
  auto root = document.GetObject();
  auto method = root.FindMember("method");
  if (method == root.MemberEnd() || !method->value.IsString()) {
    return false;
  }
 
  if (method->value == "TextInput.show") {
    if (ime_) {
      text_sync_service_->ShowKeyboard();
    }
  } else if (method->value == "TextInput.hide") {
    if (ime_) {
      text_sync_service_->HideKeyboard();
    }
  } else if (method->value == "TextInput.setClient") {
    // Sample "setClient" message:
    //
    // {
    //   "method": "TextInput.setClient",
    //   "args": [
    //      7,
    //      {
    //        "inputType": {
    //          "name": "TextInputType.multiline",
    //          "signed":null,
    //          "decimal":null
    //        },
    //        "readOnly": false,
    //        "obscureText": false,
    //        "autocorrect":true,
    //        "smartDashesType":"1",
    //        "smartQuotesType":"1",
    //        "enableSuggestions":true,
    //        "enableInteractiveSelection":true,
    //        "actionLabel":null,
    //        "inputAction":"TextInputAction.newline",
    //        "textCapitalization":"TextCapitalization.none",
    //        "keyboardAppearance":"Brightness.dark",
    //        "enableIMEPersonalizedLearning":true,
    //        "enableDeltaModel":false
    //     }
    //  ]
    // }
 
    current_text_input_client_ = 0;
    DeactivateIme();
    auto args = root.FindMember("args");
    if (args == root.MemberEnd() || !args->value.IsArray() ||
        args->value.Size() != 2)
      return false;
    const auto& configuration = args->value[1];
    if (!configuration.IsObject()) {
      return false;
    }
    // TODO(abarth): Read the keyboard type from the configuration.
    current_text_input_client_ = args->value[0].GetInt();
 
    auto initial_text_input_state = fuchsia::ui::input::TextInputState{};
    initial_text_input_state.text = "";
    last_text_state_ = std::move(initial_text_input_state);
 
    const auto configuration_object = configuration.GetObject();
    if (!configuration_object.HasMember(kInputActionKey)) {
      return false;
    }
    const auto& action_object = configuration_object[kInputActionKey];
    if (!action_object.IsString()) {
      return false;
    }
    const auto action_string =
        std::string(action_object.GetString(), action_object.GetStringLength());
    ActivateIme(IntoInputMethodAction(std::move(action_string)));
  } else if (method->value == "TextInput.setEditingState") {
    if (ime_) {
      auto args_it = root.FindMember("args");
      if (args_it == root.MemberEnd() || !args_it->value.IsObject()) {
        return false;
      }
      const auto& args = args_it->value;
      fuchsia::ui::input::TextInputState state;
      state.text = "";
      // TODO(abarth): Deserialize state.
      auto text = args.FindMember("text");
      if (text != args.MemberEnd() && text->value.IsString()) {
        state.text = text->value.GetString();
      }
      auto selection_base = args.FindMember("selectionBase");
      if (selection_base != args.MemberEnd() && selection_base->value.IsInt()) {
        state.selection.base = selection_base->value.GetInt();
      }
      auto selection_extent = args.FindMember("selectionExtent");
      if (selection_extent != args.MemberEnd() &&
          selection_extent->value.IsInt()) {
        state.selection.extent = selection_extent->value.GetInt();
      }
      auto selection_affinity = args.FindMember("selectionAffinity");
      if (selection_affinity != args.MemberEnd() &&
          selection_affinity->value.IsString() &&
          selection_affinity->value == "TextAffinity.upstream") {
        state.selection.affinity = fuchsia::ui::input::TextAffinity::UPSTREAM;
      } else {
        state.selection.affinity = fuchsia::ui::input::TextAffinity::DOWNSTREAM;
      }
      // We ignore selectionIsDirectional because that concept doesn't exist on
      // Fuchsia.
      auto composing_base = args.FindMember("composingBase");
      if (composing_base != args.MemberEnd() && composing_base->value.IsInt()) {
        state.composing.start = composing_base->value.GetInt();
      }
      auto composing_extent = args.FindMember("composingExtent");
      if (composing_extent != args.MemberEnd() &&
          composing_extent->value.IsInt()) {
        state.composing.end = composing_extent->value.GetInt();
      }
      ime_->SetState(std::move(state));
    }
  } else if (method->value == "TextInput.clearClient") {
    current_text_input_client_ = 0;
    last_text_state_ = std::nullopt;
    requested_text_action_ = std::nullopt;
    DeactivateIme();
  } else if (method->value == "TextInput.setCaretRect" ||
             method->value == "TextInput.setEditableSizeAndTransform" ||
             method->value == "TextInput.setMarkedTextRect" ||
             method->value == "TextInput.setStyle") {
    // We don't have these methods implemented and they get
    // sent a lot during text input, so we create an empty case for them
    // here to avoid "Unknown flutter/textinput method TextInput.*"
    // log spam.
    //
    // TODO(fxb/101619): We should implement these.
  } else {
    FML_LOG(ERROR) << "Unknown " << message->channel() << " method "
                   << method->value.GetString();
  }
  // Complete with an empty response.
  return false;
}

References ActivateIme(), args, DeactivateIme(), FML_DCHECK, FML_LOG, flutter_runner::IntoInputMethodAction(), flutter_runner::kInputActionKey, flutter_runner::kTextInputChannel, message, and text.

HasTextState()

bool flutter_runner::TextDelegate::HasTextState ( )

inline

Returns true if there is a text state (i.e. if some text editing is in progress).

Definition at line 97 of file text_delegate.h.

{ return last_text_state_.has_value(); }

OnAction()

void flutter_runner::TextDelegate::OnAction ( fuchsia::ui::input::InputMethodAction  action )

override

|fuchsia::ui::input::InputMethodEditorClient| Called by the embedder when the action key is pressed, and the requested action is supplied to Flutter.

Definition at line 214 of file text_delegate.cc.

                                                                  {
  rapidjson::Document document;
  auto& allocator = document.GetAllocator();
 
  rapidjson::Value args(rapidjson::kArrayType);
  args.PushBack(current_text_input_client_, allocator);
 
  const std::string action_string = IntoTextInputAction(action);
  args.PushBack(rapidjson::Value{}.SetString(action_string.c_str(),
                                             action_string.length()),
                allocator);
 
  document.SetObject();
  document.AddMember(
      "method", rapidjson::Value("TextInputClient.performAction"), allocator);
  document.AddMember("args", args, allocator);
 
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
 
  const uint8_t* data = reinterpret_cast<const uint8_t*>(buffer.GetString());
  dispatch_callback_(std::make_unique<flutter::PlatformMessage>(
      kTextInputChannel,                                 // channel
      fml::MallocMapping::Copy(data, buffer.GetSize()),  // message
      nullptr)                                           // response
  );
}

References action, allocator, args, fml::MallocMapping::Copy(), flutter_runner::IntoTextInputAction(), and flutter_runner::kTextInputChannel.

OnKeyEvent()

void flutter_runner::TextDelegate::OnKeyEvent ( fuchsia::ui::input3::KeyEvent  key_event, fuchsia::ui::input3::KeyboardListener::OnKeyEventCallback  callback  )

override

|fuchsia.ui.input3.KeyboardListener| Called by the embedder every time there is a key event to process.

Definition at line 395 of file text_delegate.cc.

                                                                {
  const char* type = nullptr;
  switch (key_event.type()) {
    case fuchsia::ui::input3::KeyEventType::PRESSED:
      type = "keydown";
      break;
    case fuchsia::ui::input3::KeyEventType::RELEASED:
      type = "keyup";
      break;
    case fuchsia::ui::input3::KeyEventType::SYNC:
      // SYNC means the key was pressed while focus was not on this application.
      // This should possibly behave like PRESSED in the future, though it
      // doesn't hurt to ignore it today.
    case fuchsia::ui::input3::KeyEventType::CANCEL:
      // CANCEL means the key was released while focus was not on this
      // application.
      // This should possibly behave like RELEASED in the future to ensure that
      // a key is not repeated forever if it is pressed while focus is lost.
    default:
      break;
  }
  if (type == nullptr) {
    FML_VLOG(1) << "Unknown key event phase.";
    callback(fuchsia::ui::input3::KeyEventStatus::NOT_HANDLED);
    return;
  }
  keyboard_translator_.ConsumeEvent(std::move(key_event));
 
  rapidjson::Document document;
  auto& allocator = document.GetAllocator();
  document.SetObject();
  document.AddMember("type", rapidjson::Value(type, strlen(type)), allocator);
  document.AddMember("keymap", rapidjson::Value("fuchsia"), allocator);
  document.AddMember("hidUsage", keyboard_translator_.LastHIDUsage(),
                     allocator);
  document.AddMember("codePoint", keyboard_translator_.LastCodePoint(),
                     allocator);
  document.AddMember("modifiers", keyboard_translator_.Modifiers(), allocator);
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
 
  const uint8_t* data = reinterpret_cast<const uint8_t*>(buffer.GetString());
  dispatch_callback_(std::make_unique<flutter::PlatformMessage>(
      kKeyEventChannel,                                  // channel
      fml::MallocMapping::Copy(data, buffer.GetSize()),  // data
      nullptr)                                           // response
  );
  callback(fuchsia::ui::input3::KeyEventStatus::HANDLED);
}

References allocator, callback, flutter_runner::Keyboard::ConsumeEvent(), fml::MallocMapping::Copy(), FML_VLOG, key_event, flutter_runner::kKeyEventChannel, flutter_runner::Keyboard::LastCodePoint(), flutter_runner::Keyboard::LastHIDUsage(), flutter_runner::Keyboard::Modifiers(), type, and FlutterKeyEvent::type.

---

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

• shell/platform/fuchsia/flutter/text_delegate.h
• shell/platform/fuchsia/flutter/text_delegate.cc