Cherry-pick "Enable Evas GL direct mode (#54)"

- Cherry-pick the commit from flutter-2.0.1-tizen-dev
- Rename FLUTTER_TIZEN_EVASGL with TIZEN_RENDERER_EVAS_GL
- Add missing switches and fix build errors

Co-authored-by: Boram Bae <[email protected]>
Co-authored-by: MuHong Byun <[email protected]>

Author: 3 people

shell/common/animator.cc

@@ -35,11 +35,14 @@ Animator::Animator(Delegate& delegate,
       // TODO(dnfield): We should remove this logic and set the pipeline depth
       // back to 2 in this case. See
       // https://github.com/flutter/engine/pull/9132 for discussion.
-      layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(
-          task_runners.GetPlatformTaskRunner() ==
-                  task_runners.GetRasterTaskRunner()
-              ? 1
-              : 2)),
+      // layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(
+      //     task_runners.GetPlatformTaskRunner() ==
+      //             task_runners.GetRasterTaskRunner()
+      //         ? 1
+      //         : 2)),
+      // FIXME(bbrto21): This is a workaround to avoid flickering that occurs
+      // in evas gl direct mode.
+      layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(1)),
 #endif  // SHELL_ENABLE_METAL
       pending_frame_semaphore_(1),
       frame_number_(1),

shell/platform/tizen/BUILD.gn

@@ -1,6 +1,7 @@
 # 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.
+
 import("//flutter/shell/platform/common/cpp/client_wrapper/publish.gni")
 import("//flutter/shell/platform/tizen/config.gni")
 
@@ -52,15 +53,34 @@ config("tizen_rootstrap_include_dirs") {
     "$custom_sysroot/usr/include/eo-1",
     "$custom_sysroot/usr/include/evas-1",
     "$custom_sysroot/usr/include/system",
-    "$custom_sysroot/usr/include/wayland-extension"
+    "$custom_sysroot/usr/include/wayland-extension",
+    # For Evas_GL.
+    "$custom_sysroot/usr/include/ecore-con-1",
+    "$custom_sysroot/usr/include/ecore-file-1",
+    "$custom_sysroot/usr/include/edje-1",
+    "$custom_sysroot/usr/include/eet-1",
+    "$custom_sysroot/usr/include/efl-1/interfaces",
+    "$custom_sysroot/usr/include/efreet-1",
+    "$custom_sysroot/usr/include/elementary-1",
+    "$custom_sysroot/usr/include/ethumb-1",
+    "$custom_sysroot/usr/include/ethumb-client-1",
   ]
 
   lib_dirs = [ "$custom_sysroot/usr/lib" ]
 }
 
 # Template for the embedder build. Used to generate embedders for different
 # device profiles. The output library name is "flutter_tizen_[profile]".
+#
+# If use_evas_gl_renderer is provided as true, the Evas_GL renderer is used,
+# otherwise the Ecore_Wl2 renderer is used.
 template("embedder_for_profile") {
+  forward_variables_from(invoker, [ "use_evas_gl_renderer" ])
+
+  if (!defined(use_evas_gl_renderer)) {
+    use_evas_gl_renderer = false
+  }
+
   shared_library("flutter_tizen_${target_name}") {
     public = _public_headers
 
@@ -80,7 +100,6 @@ template("embedder_for_profile") {
       "tizen_event_loop.cc",
       "tizen_log.cc",
       "tizen_renderer.cc",
-      "tizen_vsync_waiter.cc",
       "touch_event_handler.cc",
     ]
 
@@ -104,6 +123,24 @@ template("embedder_for_profile") {
 
     defines = invoker.defines
 
+    if (use_evas_gl_renderer) {
+      sources += [ "tizen_renderer_evas_gl.cc" ]
+
+      libs += [
+        "ecore_evas",
+        "elementary",
+      ]
+
+      defines += [ "TIZEN_RENDERER_EVAS_GL" ]
+    } else {
+      sources += [
+        "tizen_renderer_ecore_wl2.cc",
+        "tizen_vsync_waiter.cc",
+      ]
+
+      libs += [ "ecore_wl2" ]
+    }
+
     cflags_cc = [
       "-Wno-newline-eof",
       "-Wno-macro-redefined",
@@ -125,10 +162,6 @@ template("embedder_for_profile") {
       "//flutter/shell/platform/common/cpp/client_wrapper:client_wrapper",
       "//third_party/rapidjson",
     ]
-
-    sources += [ "tizen_renderer_ecore_wl2.cc" ]
-
-    libs += [ "ecore_wl2" ]
   }
 }
 
@@ -138,6 +171,8 @@ embedder_for_profile("mobile") {
 
 embedder_for_profile("wearable") {
   defines = [ "WEARABLE_PROFILE" ]
+
+  use_evas_gl_renderer = true
 }
 
 embedder_for_profile("tv") {
@@ -181,6 +216,6 @@ group("tizen") {
     ":flutter_tizen_common",
     ":publish_cpp_client_wrapper",
     ":publish_headers_tizen",
-    ":copy_icu"
+    ":copy_icu",
   ]
 }

shell/platform/tizen/channels/text_input_channel.cc

@@ -202,61 +202,6 @@ Ecore_IMF_Keyboard_Locks EcoreInputModifierToEcoreIMFLock(
   return static_cast<Ecore_IMF_Keyboard_Locks>(lock);
 }
 
-Ecore_IMF_Device_Class EoreDeviceClassToEcoreIMFDeviceClass(
-    Ecore_Device_Class ecoreDeviceClass) {
-  switch (ecoreDeviceClass) {
-    case ECORE_DEVICE_CLASS_SEAT:
-      return ECORE_IMF_DEVICE_CLASS_SEAT;
-    case ECORE_DEVICE_CLASS_KEYBOARD:
-      return ECORE_IMF_DEVICE_CLASS_KEYBOARD;
-    case ECORE_DEVICE_CLASS_MOUSE:
-      return ECORE_IMF_DEVICE_CLASS_MOUSE;
-    case ECORE_DEVICE_CLASS_TOUCH:
-      return ECORE_IMF_DEVICE_CLASS_TOUCH;
-    case ECORE_DEVICE_CLASS_PEN:
-      return ECORE_IMF_DEVICE_CLASS_PEN;
-    case ECORE_DEVICE_CLASS_POINTER:
-      return ECORE_IMF_DEVICE_CLASS_POINTER;
-    case ECORE_DEVICE_CLASS_GAMEPAD:
-      return ECORE_IMF_DEVICE_CLASS_GAMEPAD;
-    case ECORE_DEVICE_CLASS_NONE:
-    default:
-      return ECORE_IMF_DEVICE_CLASS_NONE;
-  }
-}
-
-Ecore_IMF_Device_Subclass EoreDeviceSubClassToEcoreIMFDeviceSubClass(
-    Ecore_Device_Subclass ecoreDeviceSubclass) {
-  switch (ecoreDeviceSubclass) {
-    case ECORE_DEVICE_SUBCLASS_FINGER:
-      return ECORE_IMF_DEVICE_SUBCLASS_FINGER;
-    case ECORE_DEVICE_SUBCLASS_FINGERNAIL:
-      return ECORE_IMF_DEVICE_SUBCLASS_FINGERNAIL;
-    case ECORE_DEVICE_SUBCLASS_KNUCKLE:
-      return ECORE_IMF_DEVICE_SUBCLASS_KNUCKLE;
-    case ECORE_DEVICE_SUBCLASS_PALM:
-      return ECORE_IMF_DEVICE_SUBCLASS_PALM;
-    case ECORE_DEVICE_SUBCLASS_HAND_SIZE:
-      return ECORE_IMF_DEVICE_SUBCLASS_HAND_SIZE;
-    case ECORE_DEVICE_SUBCLASS_HAND_FLAT:
-      return ECORE_IMF_DEVICE_SUBCLASS_HAND_FLAT;
-    case ECORE_DEVICE_SUBCLASS_PEN_TIP:
-      return ECORE_IMF_DEVICE_SUBCLASS_PEN_TIP;
-    case ECORE_DEVICE_SUBCLASS_TRACKPAD:
-      return ECORE_IMF_DEVICE_SUBCLASS_TRACKPAD;
-    case ECORE_DEVICE_SUBCLASS_TRACKPOINT:
-      return ECORE_IMF_DEVICE_SUBCLASS_TRACKPOINT;
-    case ECORE_DEVICE_SUBCLASS_TRACKBALL:
-      return ECORE_IMF_DEVICE_SUBCLASS_TRACKBALL;
-    case ECORE_DEVICE_SUBCLASS_REMOCON:
-    case ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD:
-      // FT_LOGW("There is no corresponding type");
-    case ECORE_DEVICE_SUBCLASS_NONE:
-    default:
-      return ECORE_IMF_DEVICE_SUBCLASS_NONE;
-  }
-}
-
 TextInputChannel::TextInputChannel(flutter::BinaryMessenger* messenger,
                                    TizenEmbedderEngine* engine)
     : channel_(std::make_unique<flutter::MethodChannel<rapidjson::Document>>(
@@ -418,7 +363,8 @@ void TextInputChannel::SendStateUpdate(const flutter::TextInputModel& model) {
 
 bool TextInputChannel::FilterEvent(Ecore_Event_Key* keyDownEvent) {
   bool handled = false;
-  const char* device = ecore_device_name_get(keyDownEvent->dev);
+  bool isIME = ecore_imf_context_keyboard_mode_get(imf_context_) ==
+               ECORE_IMF_INPUT_PANEL_SW_KEYBOARD_MODE;
 
   Ecore_IMF_Event_Key_Down ecoreKeyDownEvent;
   ecoreKeyDownEvent.keyname = keyDownEvent->keyname;
@@ -430,15 +376,13 @@ bool TextInputChannel::FilterEvent(Ecore_Event_Key* keyDownEvent) {
       EcoreInputModifierToEcoreIMFModifier(keyDownEvent->modifiers);
   ecoreKeyDownEvent.locks =
       EcoreInputModifierToEcoreIMFLock(keyDownEvent->modifiers);
-  ecoreKeyDownEvent.dev_name = device;
-  ecoreKeyDownEvent.dev_class = EoreDeviceClassToEcoreIMFDeviceClass(
-      ecore_device_class_get(keyDownEvent->dev));
-  ecoreKeyDownEvent.dev_subclass = EoreDeviceSubClassToEcoreIMFDeviceSubClass(
-      ecore_device_subclass_get(keyDownEvent->dev));
+  if (isIME) {
+    ecoreKeyDownEvent.dev_name = "ime";
+  } else {
+    ecoreKeyDownEvent.dev_name = "";
+  }
   ecoreKeyDownEvent.keycode = keyDownEvent->keycode;
 
-  bool isIME = strcmp(device, "ime") == 0;
-
   if (isIME && strcmp(keyDownEvent->key, "Select") == 0) {
     if (engine_->device_profile == DeviceProfile::kWearable) {
       // FIXME: for wearable

shell/platform/tizen/external_texture_gl.cc

@@ -4,11 +4,20 @@
 
 #include "external_texture_gl.h"
 
+#ifdef TIZEN_RENDERER_EVAS_GL
+#undef EFL_BETA_API_SUPPORT
+#include <Ecore.h>
+#include <Elementary.h>
+#include <Evas_GL_GLES3_Helpers.h>
+extern Evas_GL* g_evas_gl;
+EVAS_GL_GLOBAL_GLES3_DECLARE();
+#else
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES3/gl32.h>
+#endif
 
 #include <atomic>
 #include <iostream>
@@ -48,13 +57,13 @@ bool ExternalTextureGL::OnFrameAvailable(tbm_surface_h tbm_surface) {
     mutex_.unlock();
     return false;
   }
-  if (!tbm_surface_internal_is_valid(tbm_surface)) {
+  tbm_surface_info_s info;
+  if (tbm_surface_get_info(tbm_surface, &info) != TBM_SURFACE_ERROR_NONE) {
     FT_LOGD("tbm_surface not valid, pass");
     mutex_.unlock();
     return false;
   }
   texture_tbm_surface_ = tbm_surface;
-  tbm_surface_internal_ref(texture_tbm_surface_);
   mutex_.unlock();
   return true;
 }
@@ -67,22 +76,54 @@ bool ExternalTextureGL::PopulateTextureWithIdentifier(
     mutex_.unlock();
     return false;
   }
-  if (!tbm_surface_internal_is_valid(texture_tbm_surface_)) {
+  tbm_surface_info_s info;
+  if (tbm_surface_get_info(texture_tbm_surface_, &info) !=
+      TBM_SURFACE_ERROR_NONE) {
     FT_LOGD("tbm_surface not valid");
     DestructionTbmSurface();
     mutex_.unlock();
     return false;
   }
 
+#ifdef TIZEN_RENDERER_EVAS_GL
+  int eglImgAttr[] = {EVAS_GL_IMAGE_PRESERVED, GL_TRUE, 0};
+  EvasGLImage egl_src_image = evasglCreateImageForContext(
+      g_evas_gl, evas_gl_current_context_get(g_evas_gl),
+      EVAS_GL_NATIVE_SURFACE_TIZEN, (void*)(intptr_t)texture_tbm_surface_,
+      eglImgAttr);
+  if (!egl_src_image) {
+    // FT_LOGE("egl_src_image create fail!!, errorcode == %d", eglGetError());
+    mutex_.unlock();
+    return false;
+  }
+  if (state_->gl_texture == 0) {
+    glGenTextures(1, &state_->gl_texture);
+    glBindTexture(GL_TEXTURE_EXTERNAL_OES, state_->gl_texture);
+    // set the texture wrapping parameters
+    glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S,
+                    GL_CLAMP_TO_BORDER);
+    glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T,
+                    GL_CLAMP_TO_BORDER);
+    // set texture filtering parameters
+    glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else {
+    glBindTexture(GL_TEXTURE_EXTERNAL_OES, state_->gl_texture);
+  }
+  glEvasGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_src_image);
+  if (egl_src_image) {
+    evasglDestroyImage(egl_src_image);
+  }
+#else
   PFNEGLCREATEIMAGEKHRPROC n_eglCreateImageKHR =
       (PFNEGLCREATEIMAGEKHRPROC)eglGetProcAddress("eglCreateImageKHR");
   const EGLint attrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE,
                           EGL_NONE};
-  EGLImageKHR eglSrcImage = n_eglCreateImageKHR(
+  EGLImageKHR egl_src_image = n_eglCreateImageKHR(
       eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_NATIVE_SURFACE_TIZEN,
       (EGLClientBuffer)texture_tbm_surface_, attrs);
-  if (!eglSrcImage) {
-    FT_LOGE("eglSrcImage create fail!!, errorcode == %d", eglGetError());
+  if (!egl_src_image) {
+    FT_LOGE("egl_src_image create fail!!, errorcode == %d", eglGetError());
     mutex_.unlock();
     return false;
   }
@@ -103,12 +144,14 @@ bool ExternalTextureGL::PopulateTextureWithIdentifier(
   PFNGLEGLIMAGETARGETTEXTURE2DOESPROC glEGLImageTargetTexture2DOES =
       (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)eglGetProcAddress(
           "glEGLImageTargetTexture2DOES");
-  glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, eglSrcImage);
-  if (eglSrcImage) {
+  glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_src_image);
+  if (egl_src_image) {
     PFNEGLDESTROYIMAGEKHRPROC n_eglDestoryImageKHR =
         (PFNEGLDESTROYIMAGEKHRPROC)eglGetProcAddress("eglDestroyImageKHR");
-    n_eglDestoryImageKHR(eglGetCurrentDisplay(), eglSrcImage);
+    n_eglDestoryImageKHR(eglGetCurrentDisplay(), egl_src_image);
   }
+#endif
+
   opengl_texture->target = GL_TEXTURE_EXTERNAL_OES;
   opengl_texture->name = state_->gl_texture;
   opengl_texture->format = GL_RGBA8;
@@ -131,7 +174,7 @@ void ExternalTextureGL::DestructionTbmSurface() {
     FT_LOGE("tbm_surface_h is NULL");
     return;
   }
-  tbm_surface_internal_unref(texture_tbm_surface_);
+  tbm_surface_destroy(texture_tbm_surface_);
   texture_tbm_surface_ = NULL;
 }