Use proc table for embedder APIs

* Use the proc table like other platform implementations
* Use FlutterEngine as private memeber of FlutterTizenEngine
* Only FlutterTizenEngine is dependent on FlutterEngine

Signed-off-by: Boram Bae <[email protected]>

Author: bbrto21

shell/platform/tizen/channels/lifecycle_channel.cc

@@ -4,6 +4,7 @@
 
 #include "lifecycle_channel.h"
 
+#include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
 #include "flutter/shell/platform/tizen/tizen_log.h"
 
 static constexpr char kChannelName[] = "flutter/lifecycle";
@@ -12,20 +13,15 @@ static constexpr char kResumed[] = "AppLifecycleState.resumed";
 static constexpr char kPaused[] = "AppLifecycleState.paused";
 static constexpr char kDetached[] = "AppLifecycleState.detached";
 
-LifecycleChannel::LifecycleChannel(FLUTTER_API_SYMBOL(FlutterEngine)
-                                       flutter_engine)
-    : flutter_engine_(flutter_engine) {}
+LifecycleChannel::LifecycleChannel(FlutterTizenEngine* engine)
+    : engine_(engine) {}
 
 LifecycleChannel::~LifecycleChannel() {}
 
 void LifecycleChannel::SendLifecycleMessage(const char message[]) {
-  FlutterPlatformMessage platformMessage = {};
-  platformMessage.struct_size = sizeof(FlutterPlatformMessage);
-  platformMessage.channel = kChannelName;
-  platformMessage.message = reinterpret_cast<const uint8_t*>(message);
-  platformMessage.message_size = strlen(message);
-  platformMessage.response_handle = nullptr;
-  FlutterEngineSendPlatformMessage(flutter_engine_, &platformMessage);
+  engine_->SendPlatformMessage(kChannelName,
+                               reinterpret_cast<const uint8_t*>(message),
+                               strlen(message), nullptr, nullptr);
 }
 
 void LifecycleChannel::AppIsInactive() {

shell/platform/tizen/channels/lifecycle_channel.h

@@ -5,11 +5,11 @@
 #ifndef EMBEDDER_LIFECYCLE_CHANNEL_H_
 #define EMBEDDER_LIFECYCLE_CHANNEL_H_
 
-#include "flutter/shell/platform/embedder/embedder.h"
+class FlutterTizenEngine;
 
 class LifecycleChannel {
  public:
-  explicit LifecycleChannel(FLUTTER_API_SYMBOL(FlutterEngine) flutter_engine);
+  explicit LifecycleChannel(FlutterTizenEngine* engine);
   virtual ~LifecycleChannel();
 
   void AppIsInactive();
@@ -19,7 +19,7 @@ class LifecycleChannel {
   void SendLifecycleMessage(const char message[]);
 
  private:
-  FLUTTER_API_SYMBOL(FlutterEngine) flutter_engine_;
+  FlutterTizenEngine* engine_{nullptr};
 };
 
 #endif  // EMBEDDER_LIFECYCLE_CHANNEL_H_

shell/platform/tizen/channels/localization_channel.cc

@@ -5,18 +5,17 @@
 #include "localization_channel.h"
 
 #include <utils_i18n.h>
-
 #include <vector>
 
+#include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
 #include "flutter/shell/platform/tizen/tizen_log.h"
 #include "rapidjson/document.h"
 #include "rapidjson/writer.h"
 
 static constexpr char kChannelName[] = "flutter/localization";
 
-LocalizationChannel::LocalizationChannel(FLUTTER_API_SYMBOL(FlutterEngine)
-                                             flutter_engine)
-    : flutter_engine_(flutter_engine) {}
+LocalizationChannel::LocalizationChannel(FlutterTizenEngine* engine)
+    : engine_(engine) {}
 
 LocalizationChannel::~LocalizationChannel() {}
 
@@ -54,9 +53,8 @@ void LocalizationChannel::SendLocales() {
   }
 
   FT_LOGD("Send %zu available locales", flutter_locales.size());
-  // send locales to engine
-  FlutterEngineUpdateLocales(
-      flutter_engine_,
+  // Send locales to engine
+  engine_->UpdateLocales(
       const_cast<const FlutterLocale**>(flutter_locales.data()),
       flutter_locales.size());
 
@@ -111,13 +109,9 @@ void LocalizationChannel::SendPlatformResolvedLocale() {
     return;
   }
 
-  FlutterPlatformMessage message = {};
-  message.struct_size = sizeof(FlutterPlatformMessage);
-  message.channel = kChannelName;
-  message.message = reinterpret_cast<const uint8_t*>(buffer.GetString());
-  message.message_size = buffer.GetSize();
-  message.response_handle = nullptr;
-  FlutterEngineSendPlatformMessage(flutter_engine_, &message);
+  engine_->SendPlatformMessage(
+      kChannelName, reinterpret_cast<const uint8_t*>(buffer.GetString()),
+      buffer.GetSize(), nullptr, nullptr);
 
   DestroyFlutterLocale(flutter_locale);
 }

shell/platform/tizen/channels/localization_channel.h

@@ -7,10 +7,11 @@
 
 #include "flutter/shell/platform/embedder/embedder.h"
 
+class FlutterTizenEngine;
+
 class LocalizationChannel {
  public:
-  explicit LocalizationChannel(FLUTTER_API_SYMBOL(FlutterEngine)
-                                   flutter_engine);
+  explicit LocalizationChannel(FlutterTizenEngine* engine);
   virtual ~LocalizationChannel();
 
   void SendLocales();
@@ -20,7 +21,7 @@ class LocalizationChannel {
   FlutterLocale* GetFlutterLocale(const char* locale);
   void DestroyFlutterLocale(FlutterLocale* flutter_locale);
 
-  FLUTTER_API_SYMBOL(FlutterEngine) flutter_engine_;
+  FlutterTizenEngine* engine_;
 };
 
 #endif  // EMBEDDER_LOCALIZATION_CHANNEL_H_

shell/platform/tizen/flutter_tizen.cc

@@ -88,38 +88,16 @@ bool FlutterDesktopMessengerSendWithReply(FlutterDesktopMessengerRef messenger,
                                           const size_t message_size,
                                           const FlutterDesktopBinaryReply reply,
                                           void* user_data) {
-  FlutterPlatformMessageResponseHandle* response_handle = nullptr;
-  if (reply != nullptr && user_data != nullptr) {
-    FlutterEngineResult result = FlutterPlatformMessageCreateResponseHandle(
-        messenger->engine->flutter_engine, reply, user_data, &response_handle);
-    if (result != kSuccess) {
-      FT_LOGE("Failed to create response handle");
-      return false;
-    }
-  }
-  FlutterPlatformMessage platform_message = {
-      sizeof(FlutterPlatformMessage),
-      channel,
-      message,
-      message_size,
-      response_handle,
-  };
-  FlutterEngineResult message_result = FlutterEngineSendPlatformMessage(
-      messenger->engine->flutter_engine, &platform_message);
-  if (response_handle != nullptr) {
-    FlutterPlatformMessageReleaseResponseHandle(
-        messenger->engine->flutter_engine, response_handle);
-  }
-  return message_result == kSuccess;
+  return messenger->engine->SendPlatformMessage(channel, message, message_size,
+                                                reply, user_data);
 }
 
 void FlutterDesktopMessengerSendResponse(
     FlutterDesktopMessengerRef messenger,
     const FlutterDesktopMessageResponseHandle* handle,
     const uint8_t* data,
     size_t data_length) {
-  FlutterEngineSendPlatformMessageResponse(messenger->engine->flutter_engine,
-                                           handle, data, data_length);
+  messenger->engine->SendPlatformMessageResponse(handle, data, data_length);
 }
 
 void FlutterDesktopMessengerSetCallback(FlutterDesktopMessengerRef messenger,
@@ -151,8 +129,7 @@ void FlutterDesktopNotifyAppIsDetached(FlutterDesktopEngineRef engine) {
 }
 
 void FlutterDesktopNotifyLowMemoryWarning(FlutterDesktopEngineRef engine) {
-  auto flutter_engine = EngineFromHandle(engine)->flutter_engine;
-  FlutterEngineNotifyLowMemoryWarning(flutter_engine);
+  EngineFromHandle(engine)->NotifyLowMemoryWarning();
 }
 
 void FlutterRegisterViewFactory(

shell/platform/tizen/flutter_tizen_engine.cc

@@ -40,13 +40,16 @@ static DeviceProfile GetDeviceProfile() {
 
 FlutterTizenEngine::FlutterTizenEngine(bool headed)
     : device_profile(GetDeviceProfile()) {
+  embedder_api_.struct_size = sizeof(FlutterEngineProcTable);
+  FlutterEngineGetProcAddresses(&embedder_api_);
+
   // Run flutter task on Tizen main loop.
   // Tizen engine has four threads (GPU thread, UI thread, IO thread, platform
   // thread). UI threads need to send flutter task to platform thread.
   event_loop_ = std::make_unique<TizenPlatformEventLoop>(
       std::this_thread::get_id(),  // main thread
       [this](const auto* task) {
-        if (FlutterEngineRunTask(this->flutter_engine, task) != kSuccess) {
+        if (embedder_api_.RunTask(this->flutter_engine, task) != kSuccess) {
           FT_LOGE("Could not post an engine task.");
         }
       });
@@ -75,7 +78,7 @@ void FlutterTizenEngine::InitializeRenderer() {
   render_loop_ = std::make_unique<TizenRenderEventLoop>(
       std::this_thread::get_id(),  // main thread
       [this](const auto* task) {
-        if (FlutterEngineRunTask(this->flutter_engine, task) != kSuccess) {
+        if (embedder_api_.RunTask(this->flutter_engine, task) != kSuccess) {
           FT_LOGE("Could not post an engine task.");
         }
       },
@@ -87,9 +90,13 @@ void FlutterTizenEngine::InitializeRenderer() {
 #endif
 }
 
+void FlutterTizenEngine::NotifyLowMemoryWarning() {
+  embedder_api_.NotifyLowMemoryWarning(flutter_engine);
+}
+
 // Attempts to load AOT data from the given path, which must be absolute and
 // non-empty. Logs and returns nullptr on failure.
-UniqueAotDataPtr LoadAotData(std::string aot_data_path) {
+UniqueAotDataPtr FlutterTizenEngine::LoadAotData(std::string aot_data_path) {
   if (aot_data_path.empty()) {
     FT_LOGE(
         "Attempted to load AOT data, but no aot_library_path was provided.");
@@ -104,7 +111,7 @@ UniqueAotDataPtr LoadAotData(std::string aot_data_path) {
   source.type = kFlutterEngineAOTDataSourceTypeElfPath;
   source.elf_path = aot_data_path.c_str();
   FlutterEngineAOTData data = nullptr;
-  auto result = FlutterEngineCreateAOTData(&source, &data);
+  auto result = embedder_api_.CreateAOTData(&source, &data);
   if (result != kSuccess) {
     FT_LOGE("Failed to load AOT data from: %s", aot_data_path.c_str());
     return nullptr;
@@ -180,7 +187,7 @@ bool FlutterTizenEngine::RunEngine(
   }
 #endif
 
-  if (FlutterEngineRunsAOTCompiledDartCode()) {
+  if (embedder_api_.RunsAOTCompiledDartCode()) {
     aot_data_ = LoadAotData(engine_properties.aot_library_path);
     if (!aot_data_) {
       FT_LOGE("Unable to start engine without AOT data.");
@@ -191,8 +198,8 @@ bool FlutterTizenEngine::RunEngine(
 
   FlutterRendererConfig renderer_config = GetRendererConfig();
 
-  auto result = FlutterEngineRun(FLUTTER_ENGINE_VERSION, &renderer_config,
-                                 &args, this, &flutter_engine);
+  auto result = embedder_api_.Run(FLUTTER_ENGINE_VERSION, &renderer_config,
+                                  &args, this, &flutter_engine);
   if (result == kSuccess && flutter_engine != nullptr) {
     FT_LOGD("FlutterEngineRun Success!");
   } else {
@@ -207,9 +214,10 @@ bool FlutterTizenEngine::RunEngine(
       internal_plugin_registrar_->messenger(), renderer.get());
   settings_channel = std::make_unique<SettingsChannel>(
       internal_plugin_registrar_->messenger());
-  localization_channel = std::make_unique<LocalizationChannel>(flutter_engine);
+  localization_channel = std::make_unique<LocalizationChannel>(this);
   localization_channel->SendLocales();
-  lifecycle_channel = std::make_unique<LifecycleChannel>(flutter_engine);
+  lifecycle_channel = std::make_unique<LifecycleChannel>(this);
+
   if (IsHeaded()) {
     texture_registrar_ = std::make_unique<FlutterTizenTextureRegistrar>(this);
     key_event_channel = std::make_unique<KeyEventChannel>(
@@ -237,7 +245,7 @@ bool FlutterTizenEngine::StopEngine() {
     if (plugin_registrar_destruction_callback_) {
       plugin_registrar_destruction_callback_(plugin_registrar_.get());
     }
-    FlutterEngineResult result = FlutterEngineShutdown(flutter_engine);
+    FlutterEngineResult result = embedder_api_.Shutdown(flutter_engine);
     flutter_engine = nullptr;
     return (result == kSuccess);
   }
@@ -257,6 +265,52 @@ void FlutterTizenEngine::SetPluginRegistrarDestructionCallback(
   plugin_registrar_destruction_callback_ = callback;
 }
 
+bool FlutterTizenEngine::SendPlatformMessage(
+    const char* channel,
+    const uint8_t* message,
+    const size_t message_size,
+    const FlutterDesktopBinaryReply reply,
+    void* user_data) {
+  FlutterPlatformMessageResponseHandle* response_handle = nullptr;
+  if (reply != nullptr && user_data != nullptr) {
+    FlutterEngineResult result =
+        embedder_api_.PlatformMessageCreateResponseHandle(
+            flutter_engine, reply, user_data, &response_handle);
+    if (result != kSuccess) {
+      std::cout << "Failed to create response handle\n";
+      return false;
+    }
+  }
+
+  FlutterPlatformMessage platform_message = {
+      sizeof(FlutterPlatformMessage),
+      channel,
+      message,
+      message_size,
+      response_handle,
+  };
+
+  FlutterEngineResult message_result =
+      embedder_api_.SendPlatformMessage(flutter_engine, &platform_message);
+  if (response_handle != nullptr) {
+    embedder_api_.PlatformMessageReleaseResponseHandle(flutter_engine,
+                                                       response_handle);
+  }
+  return message_result == kSuccess;
+}
+
+void FlutterTizenEngine::SendPlatformMessageResponse(
+    const FlutterDesktopMessageResponseHandle* handle,
+    const uint8_t* data,
+    size_t data_length) {
+  embedder_api_.SendPlatformMessageResponse(flutter_engine, handle, data,
+                                            data_length);
+}
+
+void FlutterTizenEngine::SendPointerEvent(const FlutterPointerEvent& event) {
+  embedder_api_.SendPointerEvent(flutter_engine, &event, 1);
+}
+
 void FlutterTizenEngine::SendWindowMetrics(int32_t width,
                                            int32_t height,
                                            double pixel_ratio) {
@@ -285,7 +339,7 @@ void FlutterTizenEngine::SendWindowMetrics(int32_t width,
   } else {
     event.pixel_ratio = pixel_ratio;
   }
-  FlutterEngineSendWindowMetricsEvent(flutter_engine, &event);
+  embedder_api_.SendWindowMetricsEvent(flutter_engine, &event);
 }
 
 // This must be called at least once in order to initialize the value of
@@ -331,6 +385,33 @@ void FlutterTizenEngine::OnOrientationChange(int32_t degree) {
   SetWindowOrientation(degree);
 }
 
+void FlutterTizenEngine::OnVsync(intptr_t baton,
+                                 uint64_t frame_start_time_nanos,
+                                 uint64_t frame_target_time_nanos) {
+  embedder_api_.OnVsync(flutter_engine, baton, frame_start_time_nanos,
+                        frame_target_time_nanos);
+}
+
+void FlutterTizenEngine::UpdateLocales(const FlutterLocale** locales,
+                                       size_t locales_count) {
+  embedder_api_.UpdateLocales(flutter_engine, locales, locales_count);
+}
+
+bool FlutterTizenEngine::RegisterExternalTexture(int64_t texture_id) {
+  return (embedder_api_.RegisterExternalTexture(flutter_engine, texture_id) ==
+          kSuccess);
+}
+
+bool FlutterTizenEngine::UnregisterExternalTexture(int64_t texture_id) {
+  return (embedder_api_.UnregisterExternalTexture(flutter_engine, texture_id) ==
+          kSuccess);
+}
+
+bool FlutterTizenEngine::MarkExternalTextureFrameAvailable(int64_t texture_id) {
+  return (embedder_api_.MarkExternalTextureFrameAvailable(
+              flutter_engine, texture_id) == kSuccess);
+}
+
 // The Flutter Engine calls out to this function when new platform messages are
 // available.
 void FlutterTizenEngine::OnFlutterPlatformMessage(