Introduce to TizenViewElementary

There are two ways to draw FlutterTizenView in Tizen. (TizenWindowElementary and TizenWindowEcore)
Both ways are drawing on Window component(surface).

We try to draw FlutterTizenView on the appropriate component
provided by Tizen UIFW and support it to be place with other components.
To do that, we created a TizenView class on the same level as TizenWindow
and abstracted common methods to TizenBaseHandle.
we can add FlutterTizenView to other UIFW of Tizen while adding TizenView{?}(maybe Tizen NUI).

 TizenBaseHandle -> TizenView -> TizenViewElementary
                              -> TizenView{?}
                 -> TizenWindow -> TizenWindowElementary
                                -> TizenWindowEcore

There are a few unimplemented things. This is a plan to be added later.
- We need to add API related to App Event (Resume, etc..).
- The plans for key input are not yet cleared up.

Author: JSUYA

shell/platform/tizen/BUILD.gn

@@ -187,6 +187,7 @@ template("embedder") {
       sources += [
         "flutter_tizen_elementary.cc",
         "tizen_renderer_evas_gl.cc",
+        "tizen_view_elementary.cc",
         "tizen_window_elementary.cc",
       ]
 

shell/platform/tizen/channels/platform_channel.cc

@@ -58,12 +58,12 @@ std::string text_clipboard = "";
 }  // namespace
 
 PlatformChannel::PlatformChannel(BinaryMessenger* messenger,
-                                 TizenWindow* window)
+                                 TizenBaseHandle* handle)
     : channel_(std::make_unique<MethodChannel<rapidjson::Document>>(
           messenger,
           kChannelName,
           &JsonMethodCodec::GetInstance())),
-      window_(window) {
+      handle_(handle) {
   channel_->SetMethodCallHandler(
       [this](const MethodCall<rapidjson::Document>& call,
              std::unique_ptr<MethodResult<rapidjson::Document>> result) {
@@ -164,13 +164,13 @@ void PlatformChannel::HapticFeedbackVibrate(const std::string& feedback_type) {
 }
 
 void PlatformChannel::RestoreSystemUiOverlays() {
-  if (!window_) {
+  if (!handle_) {
     return;
   }
 
 #ifdef COMMON_PROFILE
   auto& shell = TizenShell::GetInstance();
-  shell.InitializeSoftkey(window_->GetWindowId());
+  shell.InitializeSoftkey(handle_->GetWindowId());
 
   if (shell.IsSoftkeyShown()) {
     shell.ShowSoftkey();
@@ -182,13 +182,13 @@ void PlatformChannel::RestoreSystemUiOverlays() {
 
 void PlatformChannel::SetEnabledSystemUiOverlays(
     const std::vector<std::string>& overlays) {
-  if (!window_) {
+  if (!handle_) {
     return;
   }
 
 #ifdef COMMON_PROFILE
   auto& shell = TizenShell::GetInstance();
-  shell.InitializeSoftkey(window_->GetWindowId());
+  shell.InitializeSoftkey(handle_->GetWindowId());
 
   if (std::find(overlays.begin(), overlays.end(), kSystemUiOverlayBottom) !=
       overlays.end()) {
@@ -201,7 +201,7 @@ void PlatformChannel::SetEnabledSystemUiOverlays(
 
 void PlatformChannel::SetPreferredOrientations(
     const std::vector<std::string>& orientations) {
-  if (!window_) {
+  if (!handle_) {
     return;
   }
 
@@ -220,7 +220,7 @@ void PlatformChannel::SetPreferredOrientations(
     // default.
     rotations = {0, 90, 180, 270};
   }
-  window_->SetPreferredOrientations(rotations);
+  handle_->SetPreferredOrientations(rotations);
 }
 
 }  // namespace flutter

shell/platform/tizen/channels/platform_channel.h

@@ -11,14 +11,14 @@
 
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/binary_messenger.h"
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/method_channel.h"
-#include "flutter/shell/platform/tizen/tizen_window.h"
+#include "flutter/shell/platform/tizen/tizen_base_handle.h"
 #include "rapidjson/document.h"
 
 namespace flutter {
 
 class PlatformChannel {
  public:
-  explicit PlatformChannel(BinaryMessenger* messenger, TizenWindow* window);
+  explicit PlatformChannel(BinaryMessenger* messenger, TizenBaseHandle* handle);
   virtual ~PlatformChannel();
 
  private:
@@ -35,9 +35,9 @@ class PlatformChannel {
 
   std::unique_ptr<MethodChannel<rapidjson::Document>> channel_;
 
-  // A reference to the window object managed by FlutterTizenView.
+  // A reference to the base handle object managed by FlutterTizenView.
   // This can be nullptr if the engine is running in headless mode.
-  TizenWindow* window_;
+  TizenBaseHandle* handle_;
 };
 
 }  // namespace flutter

shell/platform/tizen/channels/window_channel.cc

@@ -16,8 +16,9 @@ constexpr char kChannelName[] = "tizen/internal/window";
 
 }  // namespace
 
-WindowChannel::WindowChannel(BinaryMessenger* messenger, TizenWindow* window)
-    : window_(window) {
+WindowChannel::WindowChannel(BinaryMessenger* messenger,
+                             TizenBaseHandle* handle)
+    : handle_(handle) {
   channel_ = std::make_unique<MethodChannel<EncodableValue>>(
       messenger, kChannelName, &StandardMethodCodec::GetInstance());
   channel_->SetMethodCallHandler(
@@ -35,7 +36,7 @@ void WindowChannel::HandleMethodCall(
   const std::string& method_name = method_call.method_name();
 
   if (method_name == "getWindowGeometry") {
-    TizenWindow::Geometry geometry = window_->GetWindowGeometry();
+    TizenBaseHandle::Geometry geometry = handle_->GetRenderTargetGeometry();
     EncodableMap map;
     map[EncodableValue("x")] = EncodableValue(geometry.left);
     map[EncodableValue("y")] = EncodableValue(geometry.top);
@@ -57,11 +58,11 @@ void WindowChannel::HandleMethodCall(
     EncodableValueHolder<int32_t> width(arguments, "width");
     EncodableValueHolder<int32_t> height(arguments, "height");
 
-    TizenWindow::Geometry geometry = window_->GetWindowGeometry();
+    TizenBaseHandle::Geometry geometry = handle_->GetRenderTargetGeometry();
     // FIXME: Use SetWindowGeometry() instead of OnGeometryChanged()
     // After the SetWindowGeometry was successfully executed, I expected a
     // handler of ECORE_WL2_EVENT_WINDOW_CONFIGURE  to be called, but it didn't.
-    window_->OnGeometryChanged({
+    handle_->OnGeometryChanged({
         x ? *x : geometry.left,
         y ? *y : geometry.top,
         width ? *width : geometry.width,
@@ -70,7 +71,7 @@ void WindowChannel::HandleMethodCall(
     result->Success();
 #endif
   } else if (method_name == "getScreenGeometry") {
-    TizenWindow::Geometry geometry = window_->GetScreenGeometry();
+    TizenBaseHandle::Geometry geometry = handle_->GetScreenGeometry();
     EncodableMap map;
     map[EncodableValue("width")] = EncodableValue(geometry.width);
     map[EncodableValue("height")] = EncodableValue(geometry.height);

shell/platform/tizen/channels/window_channel.h

@@ -10,14 +10,14 @@
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/binary_messenger.h"
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/encodable_value.h"
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/method_channel.h"
-#include "flutter/shell/platform/tizen/tizen_window.h"
+#include "flutter/shell/platform/tizen/tizen_base_handle.h"
 
 namespace flutter {
 
 // Channel to get/set application's window size and device's screen size.
 class WindowChannel {
  public:
-  explicit WindowChannel(BinaryMessenger* messenger, TizenWindow* window);
+  explicit WindowChannel(BinaryMessenger* messenger, TizenBaseHandle* window);
   virtual ~WindowChannel();
 
  private:
@@ -27,7 +27,7 @@ class WindowChannel {
   std::unique_ptr<MethodChannel<EncodableValue>> channel_;
 
   // A reference to the renderer object managed by FlutterTizenView.
-  TizenWindow* window_;
+  TizenBaseHandle* handle_;
 };
 
 }  // namespace flutter

shell/platform/tizen/flutter_tizen.cc

@@ -71,7 +71,7 @@ void FlutterDesktopEngineShutdown(FlutterDesktopEngineRef engine_ref) {
 
 void* FlutterDesktopPluginRegistrarGetNativeWindow(
     FlutterDesktopPluginRegistrarRef registrar) {
-  return registrar->engine->view()->window()->GetWindowHandle();
+  return registrar->engine->view()->handle()->GetWindowHandle();
 }
 
 void FlutterDesktopPluginRegistrarEnableInputBlocking(

shell/platform/tizen/flutter_tizen_ecore.cc

@@ -24,7 +24,7 @@ FlutterDesktopViewRef HandleForView(flutter::FlutterTizenView* view) {
 FlutterDesktopViewRef FlutterDesktopViewCreateFromNewWindow(
     const FlutterDesktopWindowProperties& window_properties,
     FlutterDesktopEngineRef engine) {
-  flutter::TizenWindow::Geometry window_geometry = {
+  flutter::TizenBaseHandle::Geometry window_geometry = {
       window_properties.x,
       window_properties.y,
       window_properties.width,
@@ -52,3 +52,17 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromNewWindow(
 
   return HandleForView(view.release());
 }
+
+FlutterDesktopViewRef FlutterDesktopViewCreateFromNewView(
+    const FlutterDesktopViewProperties& view_properties,
+    FlutterDesktopEngineRef engine,
+    void* elm_parent) {
+  // Not supported.
+
+  return nullptr;
+}
+
+void* FlutterDesktopViewGetEvasImageHandle(FlutterDesktopEngineRef engine) {
+  // Not supported.
+  return nullptr;
+}

shell/platform/tizen/flutter_tizen_elementary.cc

@@ -6,6 +6,7 @@
 
 #include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
 #include "flutter/shell/platform/tizen/flutter_tizen_view.h"
+#include "flutter/shell/platform/tizen/tizen_view_elementary.h"
 #include "flutter/shell/platform/tizen/tizen_window_elementary.h"
 
 namespace {
@@ -24,7 +25,7 @@ FlutterDesktopViewRef HandleForView(flutter::FlutterTizenView* view) {
 FlutterDesktopViewRef FlutterDesktopViewCreateFromNewWindow(
     const FlutterDesktopWindowProperties& window_properties,
     FlutterDesktopEngineRef engine) {
-  flutter::TizenWindow::Geometry window_geometry = {
+  flutter::TizenBaseHandle::Geometry window_geometry = {
       window_properties.x,
       window_properties.y,
       window_properties.width,
@@ -52,3 +53,42 @@ FlutterDesktopViewRef FlutterDesktopViewCreateFromNewWindow(
 
   return HandleForView(view.release());
 }
+
+FlutterDesktopViewRef FlutterDesktopViewCreateFromNewView(
+    const FlutterDesktopViewProperties& view_properties,
+    FlutterDesktopEngineRef engine,
+    void* elm_parent) {
+  flutter::TizenBaseHandle::Geometry view_geometry = {
+      0,
+      0,
+      view_properties.width,
+      view_properties.height,
+  };
+
+  std::unique_ptr<flutter::TizenBaseHandle> view =
+      std::make_unique<flutter::TizenViewElementary>(
+          view_geometry, (Evas_Object*)(view_properties.elm_parent));
+
+  auto flutter_view =
+      std::make_unique<flutter::FlutterTizenView>(std::move(view));
+
+  // Take ownership of the engine, starting it if necessary.
+  flutter_view->SetEngine(
+      std::unique_ptr<flutter::FlutterTizenEngine>(EngineFromHandle(engine)));
+  flutter_view->CreateRenderSurface();
+  if (!flutter_view->engine()->IsRunning()) {
+    if (!flutter_view->engine()->RunEngine()) {
+      return nullptr;
+    }
+  }
+
+  flutter_view->SendInitialGeometry();
+
+  return HandleForView(flutter_view.release());
+}
+
+void* FlutterDesktopViewGetEvasImageHandle(FlutterDesktopEngineRef engine) {
+  flutter::TizenViewElementary* tizenView =
+      (flutter::TizenViewElementary*)EngineFromHandle(engine)->view()->handle();
+  return tizenView->GetRenderTargetDisplay();
+}

shell/platform/tizen/flutter_tizen_engine.cc

@@ -536,8 +536,8 @@ void FlutterTizenEngine::OnUpdateSemanticsCustomActions(
           bridge->GetFlutterPlatformNodeDelegateFromID(0);
       std::shared_ptr<FlutterPlatformWindowDelegateTizen> window =
           FlutterPlatformAppDelegateTizen::GetInstance().GetWindow().lock();
-      TizenWindow::Geometry geometry =
-          engine->view_->window()->GetWindowGeometry();
+      TizenBaseHandle::Geometry geometry =
+          engine->view_->handle()->GetRenderTargetGeometry();
       window->SetGeometry(geometry.left, geometry.top, geometry.width,
                           geometry.height);
       window->SetRootNode(root);

shell/platform/tizen/flutter_tizen_view.cc

@@ -40,10 +40,10 @@ const std::vector<std::string> kBindableSystemKeys = {
 
 namespace flutter {
 
-FlutterTizenView::FlutterTizenView(std::unique_ptr<TizenWindow> window)
-    : window_(std::move(window)) {
-  window_->SetView(this);
-  window_->BindKeys(kBindableSystemKeys);
+FlutterTizenView::FlutterTizenView(std::unique_ptr<TizenBaseHandle> handle)
+    : handle_(std::move(handle)) {
+  handle_->SetView(this);
+  handle_->BindKeys(kBindableSystemKeys);
 }
 
 FlutterTizenView::~FlutterTizenView() {}
@@ -58,18 +58,18 @@ void FlutterTizenView::SetEngine(std::unique_ptr<FlutterTizenEngine> engine) {
   // Set up window dependent channels.
   BinaryMessenger* messenger = internal_plugin_registrar_->messenger();
   platform_channel_ =
-      std::make_unique<PlatformChannel>(messenger, window_.get());
-  window_channel_ = std::make_unique<WindowChannel>(messenger, window_.get());
+      std::make_unique<PlatformChannel>(messenger, handle_.get());
+  window_channel_ = std::make_unique<WindowChannel>(messenger, handle_.get());
   text_input_channel_ = std::make_unique<TextInputChannel>(
       internal_plugin_registrar_->messenger(),
-      std::make_unique<TizenInputMethodContext>(window_.get()));
+      std::make_unique<TizenInputMethodContext>(handle_.get()));
 }
 
 void FlutterTizenView::CreateRenderSurface() {
   if (engine_ && engine_->renderer()) {
-    TizenWindow::Geometry geometry = window_->GetWindowGeometry();
-    engine_->renderer()->CreateSurface(window_->GetRenderTarget(),
-                                       window_->GetRenderTargetDisplay(),
+    TizenBaseHandle::Geometry geometry = handle_->GetRenderTargetGeometry();
+    engine_->renderer()->CreateSurface(handle_->GetRenderTarget(),
+                                       handle_->GetRenderTargetDisplay(),
                                        geometry.width, geometry.height);
   }
 }
@@ -112,7 +112,7 @@ void FlutterTizenView::OnResize(int32_t left,
     std::swap(width, height);
   }
 
-  window_->ResizeRenderTargetWithRotation({left, top, width, height},
+  handle_->ResizeRenderTargetWithRotation({left, top, width, height},
                                           rotation_degree_);
   SendWindowMetrics(left, top, width, height, 0.0);
 }
@@ -121,7 +121,7 @@ void FlutterTizenView::OnRotate(int32_t degree) {
   rotation_degree_ = degree;
   // Compute renderer transformation based on the angle of rotation.
   double rad = (360 - rotation_degree_) * M_PI / 180;
-  TizenWindow::Geometry geometry = window_->GetWindowGeometry();
+  TizenBaseHandle::Geometry geometry = handle_->GetRenderTargetGeometry();
   int32_t width = geometry.width;
   int32_t height = geometry.height;
 
@@ -145,7 +145,7 @@ void FlutterTizenView::OnRotate(int32_t degree) {
     std::swap(width, height);
   }
 
-  window_->ResizeRenderTargetWithRotation(
+  handle_->ResizeRenderTargetWithRotation(
       {geometry.left, geometry.top, width, height}, rotation_degree_);
 
   // Window position does not change on rotation regardless of its orientation.
@@ -231,7 +231,7 @@ void FlutterTizenView::OnKey(Ecore_Event_Key* event, bool is_down) {
 }
 
 void FlutterTizenView::SendInitialGeometry() {
-  OnRotate(window_->GetRotation());
+  OnRotate(handle_->GetRotation());
 }
 
 void FlutterTizenView::SendWindowMetrics(int32_t left,
@@ -247,7 +247,7 @@ void FlutterTizenView::SendWindowMetrics(int32_t left,
 #ifdef TV_PROFILE
     double dpi = 72.0;
 #else
-    double dpi = static_cast<double>(window_->GetDpi());
+    double dpi = static_cast<double>(handle_->GetDpi());
 #endif
     double scale_factor = dpi / 90.0 * kProfileFactor;
     computed_pixel_ratio = std::max(scale_factor, 1.0);
@@ -267,7 +267,7 @@ void FlutterTizenView::SendFlutterPointerEvent(
     size_t timestamp,
     FlutterPointerDeviceKind device_kind,
     int device_id) {
-  TizenWindow::Geometry geometry = window_->GetWindowGeometry();
+  TizenBaseHandle::Geometry geometry = handle_->GetRenderTargetGeometry();
   double new_x = x, new_y = y;
 
   if (rotation_degree_ == 90) {
@@ -284,8 +284,8 @@ void FlutterTizenView::SendFlutterPointerEvent(
   FlutterPointerEvent event = {};
   event.struct_size = sizeof(event);
   event.phase = phase;
-  event.x = new_x;
-  event.y = new_y;
+  event.x = new_x - geometry.left;
+  event.y = new_y - geometry.top;
   if (delta_x != 0 || delta_y != 0) {
     event.signal_kind = kFlutterPointerSignalKindScroll;
   }