Advanced text input options

flutter/shell/platform/tizen/BUILD.gn

@@ -143,12 +143,15 @@ template("embedder") {
         "external_texture_pixel_egl.cc",
         "external_texture_surface_egl.cc",
         "flutter_platform_node_delegate_tizen.cc",
+        "tizen_autofill.cc",
         "tizen_renderer_egl.cc",
         "tizen_vsync_waiter.cc",
         "tizen_window_ecore_wl2.cc",
       ]
 
       libs += [
+        "capi-ui-autofill",
+        "capi-ui-autofill-common",
         "ecore_wl2",
         "tdm-client",
         "tizen-extension-client",
@@ -177,12 +180,14 @@ template("embedder") {
     if (api_version == "6.5" && target_name != "flutter_tizen_wearable") {
       sources += [
         "flutter_tizen_nui.cc",
+        "nui_autofill_popup.cc",
         "tizen_view_nui.cc",
       ]
 
       libs += [
         "dali2-adaptor",
         "dali2-core",
+        "dali2-toolkit",
       ]
 
       defines += [ "NUI_SUPPORT" ]

flutter/shell/platform/tizen/channels/text_input_channel.cc

@@ -7,6 +7,9 @@
 #include "flutter/shell/platform/common/json_method_codec.h"
 #include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
 #include "flutter/shell/platform/tizen/logger.h"
+#ifndef WEARABLE_PROFILE
+#include "flutter/shell/platform/tizen/tizen_autofill.h"
+#endif
 
 namespace flutter {
 
@@ -23,8 +26,15 @@ constexpr char kMultilineInputType[] = "TextInputType.multiline";
 constexpr char kUpdateEditingStateMethod[] =
     "TextInputClient.updateEditingState";
 constexpr char kPerformActionMethod[] = "TextInputClient.performAction";
-constexpr char kSetPlatformViewClient[] = "TextInput.setPlatformViewClient";
+#ifndef WEARABLE_PROFILE
+constexpr char kRequestAutofillMethod[] = "TextInput.requestAutofill";
+#endif
+constexpr char kSetPlatformViewClientMethod[] =
+    "TextInput.setPlatformViewClient";
+constexpr char kSetEditableSizeAndTransformMethod[] =
+    "TextInput.setEditableSizeAndTransform";
 constexpr char kTextCapitalization[] = "textCapitalization";
+constexpr char kTextEnableSuggestions[] = "enableSuggestions";
 constexpr char kTextInputAction[] = "inputAction";
 constexpr char kTextInputType[] = "inputType";
 constexpr char kTextInputTypeName[] = "name";
@@ -38,8 +48,12 @@ constexpr char kSelectionBaseKey[] = "selectionBase";
 constexpr char kSelectionExtentKey[] = "selectionExtent";
 constexpr char kSelectionIsDirectionalKey[] = "selectionIsDirectional";
 constexpr char kTextKey[] = "text";
+constexpr char kTransformKey[] = "transform";
 constexpr char kBadArgumentError[] = "Bad Arguments";
 constexpr char kInternalConsistencyError[] = "Internal Consistency Error";
+constexpr char kAutofill[] = "autofill";
+constexpr char kUniqueIdentifier[] = "uniqueIdentifier";
+constexpr char kHints[] = "hints";
 
 bool IsAsciiPrintableKey(char ch) {
   return ch >= 32 && ch <= 126;
@@ -60,6 +74,11 @@ TextInputChannel::TextInputChannel(
              std::unique_ptr<MethodResult<rapidjson::Document>> result) {
         HandleMethodCall(call, std::move(result));
       });
+
+#ifndef WEARABLE_PROFILE
+  TizenAutofill& autofill = TizenAutofill::GetInstance();
+  autofill.SetOnCommit([this](std::string value) { OnCommit(value); });
+#endif
 }
 
 TextInputChannel::~TextInputChannel() {}
@@ -136,7 +155,7 @@ void TextInputChannel::HandleMethodCall(
   } else if (method.compare(kHideMethod) == 0) {
     input_method_context_->HideInputPanel();
     input_method_context_->ResetInputMethodContext();
-  } else if (method.compare(kSetPlatformViewClient) == 0) {
+  } else if (method.compare(kSetPlatformViewClientMethod) == 0) {
     result->NotImplemented();
     return;
   } else if (method.compare(kClearClientMethod) == 0) {
@@ -162,11 +181,21 @@ void TextInputChannel::HandleMethodCall(
     }
 
     client_id_ = client_id_json.GetInt();
+
+    auto enable_suggestions_iter =
+        client_config.FindMember(kTextEnableSuggestions);
+    if (enable_suggestions_iter != client_config.MemberEnd() &&
+        enable_suggestions_iter->value.IsBool()) {
+      bool enable = enable_suggestions_iter->value.GetBool();
+      input_method_context_->SetEnableSuggestions(enable);
+    }
+
     input_action_ = "";
     auto input_action_iter = client_config.FindMember(kTextInputAction);
     if (input_action_iter != client_config.MemberEnd() &&
         input_action_iter->value.IsString()) {
       input_action_ = input_action_iter->value.GetString();
+      input_method_context_->SetInputAction(input_action_);
     }
 
     text_capitalization_ = "";
@@ -211,6 +240,27 @@ void TextInputChannel::HandleMethodCall(
       }
     }
 
+    auto autofill_iter = client_config.FindMember(kAutofill);
+    if (autofill_iter != client_config.MemberEnd() &&
+        autofill_iter->value.IsObject()) {
+      auto unique_identifier_iter =
+          autofill_iter->value.FindMember(kUniqueIdentifier);
+      if (unique_identifier_iter != autofill_iter->value.MemberEnd() &&
+          unique_identifier_iter->value.IsString()) {
+        autofill_id_ = unique_identifier_iter->value.GetString();
+      }
+
+      auto hints_iter = autofill_iter->value.FindMember(kHints);
+      if (hints_iter != autofill_iter->value.MemberEnd() &&
+          hints_iter->value.IsArray()) {
+        autofill_hints_.clear();
+        for (auto hint = hints_iter->value.GetArray().Begin();
+             hint != hints_iter->value.GetArray().End(); hint++) {
+          autofill_hints_.push_back(hint->GetString());
+        }
+      }
+    }
+
     active_model_ = std::make_unique<TextInputModel>();
   } else if (method.compare(kSetEditingStateMethod) == 0) {
     input_method_context_->ResetInputMethodContext();
@@ -273,6 +323,28 @@ void TextInputChannel::HandleMethodCall(
           cursor_offset);
     }
     SendStateUpdate();
+#ifndef WEARABLE_PROFILE
+  } else if (method.compare(kRequestAutofillMethod) == 0) {
+    TizenAutofill::GetInstance().RequestAutofill(autofill_id_, autofill_hints_);
+#endif
+  } else if (method.compare(kSetEditableSizeAndTransformMethod) == 0) {
+    if (!method_call.arguments() || method_call.arguments()->IsNull()) {
+      result->Error(kBadArgumentError, "Method invoked without args.");
+      return;
+    }
+    const rapidjson::Document& args = *method_call.arguments();
+    auto transform_iter = args.FindMember(kTransformKey);
+    if (transform_iter != args.MemberEnd() && transform_iter->value.IsArray()) {
+      // The 12th and 13th values of the array stores x and y values,
+      // respectively.
+      auto x_iter = transform_iter->value.GetArray().Begin() + 12;
+      auto y_iter = transform_iter->value.GetArray().Begin() + 13;
+
+      InputFieldGeometry geometry;
+      geometry.x = x_iter->GetDouble();
+      geometry.y = y_iter->GetDouble();
+      input_method_context_->SetInputFieldGeometry(geometry);
+    }
   } else {
     result->NotImplemented();
     return;

flutter/shell/platform/tizen/channels/text_input_channel.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/binary_messenger.h"
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/method_channel.h"
@@ -79,6 +80,13 @@ class TextInputChannel {
   // Automatic text capitalization type. See available options:
   // https://api.flutter.dev/flutter/services/TextCapitalization.html
   std::string text_capitalization_ = "";
+
+  // The active autofill client id.
+  std::string autofill_id_;
+
+  // A list of autofill hint strings. See available options:
+  // https://api.flutter.dev/flutter/services/AutofillHints-class.html
+  std::vector<std::string> autofill_hints_;
 };
 
 }  // namespace flutter

flutter/shell/platform/tizen/nui_autofill_popup.cc

@@ -0,0 +1,96 @@
+// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/tizen/nui_autofill_popup.h"
+
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
+
+namespace flutter {
+
+bool NuiAutofillPopup::Touched(Dali::Actor actor,
+                               const Dali::TouchEvent& event) {
+  const Dali::PointState::Type state = event.GetState(0);
+  if (Dali::PointState::DOWN == state) {
+    std::string text =
+        actor.GetProperty(Dali::Actor::Property::NAME).Get<std::string>();
+    on_commit_(text);
+    popup_.SetDisplayState(Dali::Toolkit::Popup::HIDDEN);
+  }
+  return true;
+}
+
+void NuiAutofillPopup::Hidden() {
+  // TODO(Swanseo0): There is a phenomenon where white traces remain for a
+  // while when popup disappears.
+  popup_.Unparent();
+  popup_.Reset();
+}
+
+void NuiAutofillPopup::OutsideTouched() {
+  popup_.SetDisplayState(Dali::Toolkit::Popup::HIDDEN);
+}
+
+Dali::Toolkit::TableView NuiAutofillPopup::MakeContent(
+    const std::vector<std::unique_ptr<AutofillItem>>& items) {
+  Dali::Toolkit::TableView content =
+      Dali::Toolkit::TableView::New(items.size(), 1);
+  content.SetResizePolicy(Dali::ResizePolicy::FILL_TO_PARENT,
+                          Dali::Dimension::ALL_DIMENSIONS);
+  content.SetProperty(Dali::Actor::Property::PADDING,
+                      Dali::Vector4(10, 10, 0, 0));
+  for (uint32_t i = 0; i < items.size(); ++i) {
+    Dali::Toolkit::TextLabel label =
+        Dali::Toolkit::TextLabel::New(items[i]->label);
+    label.SetProperty(Dali::Actor::Property::NAME, items[i]->value);
+    label.SetResizePolicy(Dali::ResizePolicy::DIMENSION_DEPENDENCY,
+                          Dali::Dimension::HEIGHT);
+    label.SetProperty(Dali::Toolkit::TextLabel::Property::TEXT_COLOR,
+                      Dali::Color::WHITE_SMOKE);
+    label.SetProperty(Dali::Toolkit::TextLabel::Property::POINT_SIZE, 7.0f);
+    label.TouchedSignal().Connect(this, &NuiAutofillPopup::Touched);
+    content.AddChild(label, Dali::Toolkit::TableView::CellPosition(i, 0));
+    content.SetFitHeight(i);
+  }
+  return content;
+}
+
+void NuiAutofillPopup::Prepare(
+    const std::vector<std::unique_ptr<AutofillItem>>& items) {
+  popup_ = Dali::Toolkit::Popup::New();
+  popup_.SetProperty(Dali::Actor::Property::NAME, "popup");
+  popup_.SetProperty(Dali::Actor::Property::PARENT_ORIGIN,
+                     Dali::ParentOrigin::TOP_LEFT);
+  popup_.SetProperty(Dali::Actor::Property::ANCHOR_POINT,
+                     Dali::AnchorPoint::TOP_LEFT);
+  popup_.SetProperty(Dali::Toolkit::Popup::Property::TAIL_VISIBILITY, false);
+  popup_.SetBackgroundColor(Dali::Color::WHITE_SMOKE);
+  popup_.OutsideTouchedSignal().Connect(this,
+                                        &NuiAutofillPopup::OutsideTouched);
+  popup_.HiddenSignal().Connect(this, &NuiAutofillPopup::Hidden);
+  popup_.SetProperty(Dali::Toolkit::Popup::Property::BACKING_ENABLED, false);
+  popup_.SetProperty(Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY, 2500);
+  popup_.SetProperty(Dali::Actor::Property::SIZE,
+                     Dali::Vector2(140.0f, 35.0f * items.size()));
+
+  Dali::Toolkit::TableView content = MakeContent(items);
+  popup_.SetContent(content);
+}
+
+void NuiAutofillPopup::Show(Dali::Actor* actor, double_t x, double_t y) {
+  const std::vector<std::unique_ptr<AutofillItem>>& items =
+      TizenAutofill::GetInstance().GetResponseItems();
+  if (items.empty()) {
+    return;
+  }
+
+  Prepare(items);
+
+  popup_.SetProperty(Dali::Actor::Property::POSITION,
+                     Dali::Vector3(x, y, 0.5f));
+  popup_.SetDisplayState(Dali::Toolkit::Popup::SHOWN);
+  actor->Add(popup_);
+}
+
+}  // namespace flutter

flutter/shell/platform/tizen/nui_autofill_popup.h

@@ -0,0 +1,43 @@
+// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef EMBEDDER_NUI_AUTOFILL_POPUP_H_
+#define EMBEDDER_NUI_AUTOFILL_POPUP_H_
+
+#include <dali-toolkit/devel-api/controls/popup/popup.h>
+#include <dali-toolkit/devel-api/controls/table-view/table-view.h>
+
+#include <functional>
+
+#include "flutter/shell/platform/tizen/tizen_autofill.h"
+
+using OnCommit = std::function<void(const std::string& str)>;
+
+namespace flutter {
+
+class NuiAutofillPopup : public Dali::ConnectionTracker {
+ public:
+  void Show(Dali::Actor* actor, double_t x, double_t y);
+
+  void SetOnCommit(OnCommit callback) { on_commit_ = callback; }
+
+ private:
+  void Prepare(const std::vector<std::unique_ptr<AutofillItem>>& items);
+
+  void Hidden();
+
+  void OutsideTouched();
+
+  bool Touched(Dali::Actor actor, const Dali::TouchEvent& event);
+
+  Dali::Toolkit::TableView MakeContent(
+      const std::vector<std::unique_ptr<AutofillItem>>& items);
+
+  Dali::Toolkit::Popup popup_;
+  OnCommit on_commit_;
+};
+
+}  // namespace flutter
+
+#endif  // EMBEDDER_NUI_AUTOFILL_POPUP_H_