Refactor tizen surface

shell/platform/tizen/BUILD.gn

@@ -46,6 +46,7 @@ source_set("flutter_tizen") {
     "tizen_surface.cc",
     "tizen_surface_gl.cc",
     "tizen_vsync_waiter.cc",
+    "tizen_native_window.cc",
     "touch_event_handler.cc",
   ]
 

shell/platform/tizen/channels/text_input_channel.cc

@@ -105,9 +105,11 @@ void TextInputChannel::InputPanelStateChangedCallback(
             0.25,
             [](void* data) -> Eina_Bool {
               TextInputChannel* self = (TextInputChannel*)data;
-              int32_t surface_w = self->engine_->tizen_surface->GetWidth();
-              int32_t surface_h = self->engine_->tizen_surface->GetHeight() -
-                                  self->current_keyboard_geometry_.h;
+              auto window_geometry =
+                  self->engine_->tizen_native_window->GetGeometry();
+              int32_t surface_w = window_geometry.w;
+              int32_t surface_h =
+                  window_geometry.h - self->current_keyboard_geometry_.h;
               self->engine_->tizen_surface->SetSize(surface_w, surface_h);
               if (self->rotation == 90 || self->rotation == 270) {
                 self->engine_->SendWindowMetrics(surface_h, surface_w, 0);
@@ -293,7 +295,7 @@ TextInputChannel::TextInputChannel(flutter::BinaryMessenger* messenger,
   }
   if (imfContext_) {
     Ecore_Wl2_Window* ecoreWindow =
-        ((TizenSurfaceGL*)engine_->tizen_surface.get())->wl2_window();
+        engine_->tizen_native_window->GetWindowHandle();
     ecore_imf_context_client_window_set(
         imfContext_, (void*)ecore_wl2_window_id_get(ecoreWindow));
     RegisterIMFCallback(ecoreWindow);
@@ -604,15 +606,14 @@ void TextInputChannel::HideSoftwareKeyboard() {
 
     if (engine_->device_profile ==
         "mobile") {  // FIXME : Needs improvement on other devices.
-      auto w = engine_->tizen_surface->GetWidth();
-      auto h = engine_->tizen_surface->GetHeight();
+      auto window_geometry = engine_->tizen_native_window->GetGeometry();
 
       if (rotation == 90 || rotation == 270) {
-        engine_->SendWindowMetrics(h, w, 0);
+        engine_->SendWindowMetrics(window_geometry.h, window_geometry.w, 0);
       } else {
-        engine_->SendWindowMetrics(w, h, 0);
+        engine_->SendWindowMetrics(window_geometry.w, window_geometry.h, 0);
       }
-      engine_->tizen_surface->SetSize(w, h);
+      engine_->tizen_surface->SetSize(window_geometry.w, window_geometry.h);
       ecore_timer_add(
           0.05,
           [](void* data) -> Eina_Bool {

shell/platform/tizen/tizen_embedder_engine.cc

@@ -35,9 +35,10 @@ static double GetDeviceDpi() {
 TizenEmbedderEngine::TizenEmbedderEngine(
     const FlutterWindowProperties& window_properties)
     : device_profile(GetDeviceProfile()), device_dpi(GetDeviceDpi()) {
-  tizen_surface = std::make_unique<TizenSurfaceGL>(
+  tizen_native_window = std::make_unique<TizenNativeWindow>(
       window_properties.x, window_properties.y, window_properties.width,
       window_properties.height);
+  tizen_surface = std::make_unique<TizenSurfaceGL>(tizen_native_window.get());
 
   // Run flutter task on Tizen main loop.
   // Tizen engine has four threads (GPU thread, UI thread, IO thread, platform
@@ -58,7 +59,7 @@ TizenEmbedderEngine::TizenEmbedderEngine(
   tizen_vsync_waiter_ = std::make_unique<TizenVsyncWaiter>();
 }
 
-TizenEmbedderEngine::~TizenEmbedderEngine() {}
+TizenEmbedderEngine::~TizenEmbedderEngine() { LoggerD("Destroy"); }
 
 // Attempts to load AOT data from the given path, which must be absolute and
 // non-empty. Logs and returns nullptr on failure.
@@ -262,8 +263,9 @@ void TizenEmbedderEngine::SetWindowOrientation(int32_t degree) {
 
   // Compute renderer transformation based on the angle of rotation.
   double rad = (360 - degree) * M_PI / 180;
-  double width = tizen_surface->GetWidth();
-  double height = tizen_surface->GetHeight();
+  auto geometry = tizen_native_window->GetGeometry();
+  double width = geometry.w;
+  double height = geometry.h;
 
   if (text_input_channel->isSoftwareKeyboardShowing()) {
     height -= text_input_channel->GetCurrentKeyboardGeometry().h;

shell/platform/tizen/tizen_embedder_engine.h

@@ -95,6 +95,7 @@ class TizenEmbedderEngine {
 
   // The interface between the Flutter rasterizer and the platform.
   std::unique_ptr<TizenSurface> tizen_surface;
+  std::unique_ptr<TizenNativeWindow> tizen_native_window;
 
   // The system channels for communicating between Flutter and the platform.
   std::unique_ptr<KeyEventChannel> key_event_channel;

shell/platform/tizen/tizen_native_window.cc

@@ -0,0 +1,112 @@
+// Copyright 2020 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 "tizen_native_window.h"
+
+#include "flutter/shell/platform/tizen/logger.h"
+
+class TizenWl2Display {
+ public:
+  TizenWl2Display() {
+    if (!ecore_wl2_init()) {
+      LoggerE("Could not initialize ecore_wl2");
+      return;
+    }
+    // ecore_wl2 DISPLAY
+    wl2_display_ = ecore_wl2_display_connect(nullptr);
+    if (wl2_display_ == nullptr) {
+      LoggerE("Display not found");
+      return;
+    }
+    ecore_wl2_sync();
+  }
+
+  ~TizenWl2Display() {
+    if (wl2_display_) {
+      ecore_wl2_display_destroy(wl2_display_);
+      wl2_display_ = nullptr;
+    }
+    ecore_wl2_shutdown();
+  }
+  Ecore_Wl2_Display* GetHandle() { return wl2_display_; }
+
+ private:
+  Ecore_Wl2_Display* wl2_display_{nullptr};
+};
+TizenWl2Display g_tizen_wl2_display;
+
+TizenNativeEGLWindow::TizenNativeEGLWindow(
+    TizenNativeWindow* tizen_native_window, int32_t w, int32_t h) {
+  egl_window_ =
+      ecore_wl2_egl_window_create(tizen_native_window->GetWindowHandle(), w, h);
+
+  egl_display_ = eglGetDisplay((EGLNativeDisplayType)ecore_wl2_display_get(
+      g_tizen_wl2_display.GetHandle()));
+  if (egl_display_ == EGL_NO_DISPLAY) {
+    LoggerE("Could not access EGL display");
+    return;
+  }
+
+  EGLint major_version;
+  EGLint minor_version;
+  if (eglInitialize(egl_display_, &major_version, &minor_version) != EGL_TRUE) {
+    LoggerE("Could not initialize EGL display");
+    return;
+  }
+
+  LoggerD("eglInitialized: %d.%d", major_version, minor_version);
+
+  if (eglBindAPI(EGL_OPENGL_ES_API) != EGL_TRUE) {
+    LoggerE("Could not bind API");
+    return;
+  }
+}
+
+TizenNativeEGLWindow::~TizenNativeEGLWindow() {
+  if (egl_window_) {
+    ecore_wl2_egl_window_destroy(egl_window_);
+    egl_window_ = nullptr;
+  }
+  if (egl_display_ != EGL_NO_CONTEXT) {
+    eglTerminate(egl_display_);
+  }
+}
+
+TizenNativeWindow::TizenNativeWindow(int32_t x, int32_t y, int32_t w,
+                                     int32_t h) {
+  if (g_tizen_wl2_display.GetHandle() == nullptr) {
+    LoggerE("Faild to get display handle");
+    return;
+  }
+  if (w == 0 || h == 0) {
+    LoggerE("Failed to create because of the wrong size");
+    return;
+  }
+
+  wl2_window_ = ecore_wl2_window_new(g_tizen_wl2_display.GetHandle(), nullptr,
+                                     x, y, w, h);
+
+  ecore_wl2_window_type_set(wl2_window_, ECORE_WL2_WINDOW_TYPE_TOPLEVEL);
+  ecore_wl2_window_alpha_set(wl2_window_, EINA_FALSE);
+  ecore_wl2_window_aux_hint_add(wl2_window_, 0, "wm.policy.win.user.geometry",
+                                "1");
+  ecore_wl2_window_show(wl2_window_);
+
+  tizen_native_egl_window_ = std::make_unique<TizenNativeEGLWindow>(this, w, h);
+  is_valid_ = true;
+}
+
+TizenNativeWindow::~TizenNativeWindow() {
+  if (wl2_window_) {
+    ecore_wl2_window_free(wl2_window_);
+    wl2_window_ = nullptr;
+  }
+}
+
+TizenNativeWindow::TizenNativeWindowGeometry TizenNativeWindow::GetGeometry() {
+  TizenNativeWindowGeometry result;
+  ecore_wl2_window_geometry_get(wl2_window_, &result.x, &result.y, &result.w,
+                                &result.h);
+  return result;
+}

shell/platform/tizen/tizen_native_window.h

@@ -0,0 +1,53 @@
+// Copyright 2020 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_TIZEN_WINDOW_H_
+#define EMBEDDER_TIZEN_WINDOW_H_
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#define EFL_BETA_API_SUPPORT
+#include <Ecore_Wl2.h>
+
+#include <memory>
+class TizenNativeWindow;
+
+class TizenNativeEGLWindow {
+ public:
+  TizenNativeEGLWindow(TizenNativeWindow* tizen_native_window, int32_t w,
+                       int32_t h);
+  ~TizenNativeEGLWindow();
+  bool IsValid() {
+    return egl_window_ != nullptr && egl_display_ != EGL_NO_DISPLAY;
+  };
+
+  Ecore_Wl2_Egl_Window* GetEglWindowHandle() { return egl_window_; };
+  EGLDisplay GetEGLDisplayHandle() { return egl_display_; }
+
+ private:
+  Ecore_Wl2_Egl_Window* egl_window_ = nullptr;
+  EGLDisplay egl_display_ = EGL_NO_DISPLAY;
+};
+
+class TizenNativeWindow {
+ public:
+  struct TizenNativeWindowGeometry {
+    int32_t x{0}, y{0}, w{0}, h{0};
+  };
+
+  TizenNativeWindow(int32_t x, int32_t y, int32_t w, int32_t h);
+  ~TizenNativeWindow();
+  bool IsValid() { return is_valid_; }
+  Ecore_Wl2_Window* GetWindowHandle() { return wl2_window_; }
+  TizenNativeEGLWindow* GetTizenNativeEGLWindow() {
+    return tizen_native_egl_window_.get();
+  };
+  TizenNativeWindowGeometry GetGeometry();
+
+ private:
+  std::unique_ptr<TizenNativeEGLWindow> tizen_native_egl_window_;
+  Ecore_Wl2_Window* wl2_window_{nullptr};
+  bool is_valid_{false};
+};
+
+#endif

shell/platform/tizen/tizen_surface.cc

@@ -4,11 +4,4 @@
 
 #include "tizen_surface.h"
 
-TizenSurface::TizenSurface(int32_t x, int32_t y, int32_t width, int32_t height)
-    : window_width_(width), window_height_(height), x_(x), y_(y) {}
-
-TizenSurface::~TizenSurface() {}
-
-int32_t TizenSurface::GetWidth() { return window_width_; }
-
-int32_t TizenSurface::GetHeight() { return window_height_; }
+TizenSurface::~TizenSurface() = default;

shell/platform/tizen/tizen_surface.h

@@ -9,7 +9,6 @@
 
 class TizenSurface {
  public:
-  TizenSurface(int32_t x, int32_t y, int32_t width, int32_t height);
   virtual ~TizenSurface();
   virtual bool OnMakeCurrent() = 0;
   virtual bool OnClearCurrent() = 0;
@@ -19,14 +18,6 @@ class TizenSurface {
   virtual void* OnProcResolver(const char* name) = 0;
   virtual bool IsValid() = 0;
   virtual void SetSize(int32_t width, int32_t height) = 0;
-  int32_t GetWidth();
-  int32_t GetHeight();
-
- protected:
-  const int32_t window_width_;
-  const int32_t window_height_;
-  int32_t x_;
-  int32_t y_;
 };
 
 #endif  // EMBEDDER_TIZEN_SURFACE_H_