Unit tests for the settings channel

shell/platform/tizen/BUILD.gn

@@ -130,6 +130,7 @@ template("embedder_for_profile") {
       "channels/localization_channel.cc",
       "channels/platform_channel.cc",
       "channels/settings_channel.cc",
+      "channels/settings_channel_tizen.cc",
       "external_texture_pixel_gl.cc",
       "external_texture_surface_gl.cc",
       "tizen_log.cc",
@@ -245,7 +246,8 @@ template("embedder_executable") {
     sources += [
       "channels/localization_channel_stub.cc",
       "channels/platform_channel_stub.cc",
-      "channels/settings_channel_stub.cc",
+      "channels/settings_channel.cc",
+      "channels/settings_channel_linux.cc",
       "external_texture_pixel_gl_stub.cc",
       "external_texture_surface_gl_stub.cc",
       "tizen_log_stub.cc",

shell/platform/tizen/channels/platform_view_channel.cc

@@ -12,10 +12,12 @@
 #include "flutter/shell/platform/tizen/public/flutter_platform_view.h"
 #include "flutter/shell/platform/tizen/tizen_log.h"
 
-static constexpr char kChannelName[] = "flutter/platform_views";
-
 namespace flutter {
 
+namespace {
+constexpr char kChannelName[] = "flutter/platform_views";
+}  // namespace
+
 template <typename T>
 bool GetValueFromEncodableMap(const EncodableValue& arguments,
                               std::string key,

shell/platform/tizen/channels/settings_channel.cc

@@ -23,34 +23,24 @@ SettingsChannel::SettingsChannel(BinaryMessenger* messenger)
           messenger,
           kChannelName,
           &JsonMessageCodec::GetInstance())) {
-  system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR,
-                                 OnSettingsChangedCallback, this);
+  Init();
   SendSettingsEvent();
 }
 
 SettingsChannel::~SettingsChannel() {
-  system_settings_unset_changed_cb(
-      SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR);
+  Dispose();
 }
 
 void SettingsChannel::SendSettingsEvent() {
-  rapidjson::Document event(rapidjson::kObjectType);
-  auto& allocator = event.GetAllocator();
   bool value = false;
-  int ret = system_settings_get_value_bool(
-      SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, &value);
-  if (ret == SYSTEM_SETTINGS_ERROR_NONE) {
+  if (GetSettingValueOf24Format(&value)) {
+    rapidjson::Document event(rapidjson::kObjectType);
+    auto& allocator = event.GetAllocator();
     event.AddMember(kTextScaleFactorKey, 1.0, allocator);
     event.AddMember(kPlatformBrightnessKey, "light", allocator);
     event.AddMember(kAlwaysUse24HourFormatKey, value, allocator);
     channel_->Send(event);
   }
 }
 
-void SettingsChannel::OnSettingsChangedCallback(system_settings_key_e key,
-                                                void* user_data) {
-  auto settings_channel = reinterpret_cast<SettingsChannel*>(user_data);
-  settings_channel->SendSettingsEvent();
-}
-
 }  // namespace flutter

shell/platform/tizen/channels/settings_channel.h

@@ -5,10 +5,6 @@
 #ifndef EMBEDDER_SETTINGS_CHANNEL_H_
 #define EMBEDDER_SETTINGS_CHANNEL_H_
 
-#ifndef __X64_SHELL__
-#include <system/system_settings.h>
-#endif
-
 #include <memory>
 
 #include "flutter/shell/platform/common/client_wrapper/include/flutter/basic_message_channel.h"
@@ -21,15 +17,14 @@ class SettingsChannel {
  public:
   explicit SettingsChannel(BinaryMessenger* messenger);
   virtual ~SettingsChannel();
+  void SendSettingsEvent();
 
  private:
-#ifndef __X64_SHELL__
-  static void OnSettingsChangedCallback(system_settings_key_e key,
-                                        void* user_data);
-  void SendSettingsEvent();
+  bool GetSettingValueOf24Format(bool* value);
+  void Init();
+  void Dispose();
 
   std::unique_ptr<BasicMessageChannel<rapidjson::Document>> channel_;
-#endif
 };
 
 }  // namespace flutter

shell/platform/tizen/channels/settings_channel_linux.cc

@@ -0,0 +1,40 @@
+// Copyright 2021 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 "settings_channel.h"
+
+#include <chrono>
+#include <ctime>
+
+namespace flutter {
+
+void SettingsChannel::Init() {
+  std::locale::global(std::locale(""));
+}
+
+void SettingsChannel::Dispose() {}
+
+bool SettingsChannel::GetSettingValueOf24Format(bool* value) {
+  // This is a temporary implementation because I didn't know how to properly implement it.
+  // I believe someone will replace it with a better implementation.
+  // This function operates normally only in the following locale.
+  // en_US.UTF-8, ko_KR.UTF-8
+  char buf[64];
+  std::time_t current = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+  if(!strftime(buf, sizeof(buf), "%c", std::localtime(&current))){
+    return false;
+  }
+  std::string current_local_time(buf);
+  if ((current_local_time.find("AM")!=std::string::npos)
+  || (current_local_time.find("PM")!=std::string::npos)
+  || (current_local_time.find("오전")!=std::string::npos)
+  || (current_local_time.find("오후")!=std::string::npos)
+  ){
+    *value = true;
+  }
+  *value = false;
+  return true;
+}
+
+}  // namespace flutter

shell/platform/tizen/channels/settings_channel_tizen.cc

@@ -0,0 +1,35 @@
+// Copyright 2021 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 <system/system_settings.h>
+#include "settings_channel.h"
+
+namespace flutter {
+
+static void OnSettingsChangedCallback(system_settings_key_e key,
+                                      void* user_data) {
+  auto settings_channel = reinterpret_cast<SettingsChannel*>(user_data);
+  settings_channel->SendSettingsEvent();
+}
+
+void SettingsChannel::Init() {
+  system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR,
+                                 OnSettingsChangedCallback, this);
+}
+
+void SettingsChannel::Dispose() {
+  system_settings_unset_changed_cb(
+      SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR);
+}
+
+bool SettingsChannel::GetSettingValueOf24Format(bool* value) {
+  if (system_settings_get_value_bool(
+          SYSTEM_SETTINGS_KEY_LOCALE_TIMEFORMAT_24HOUR, value) ==
+      SYSTEM_SETTINGS_ERROR_NONE) {
+    return true;
+  }
+  return false;
+}
+
+}  // namespace flutter

shell/platform/tizen/flutter_tizen_engine_unittest.cc

@@ -2,7 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <filesystem>
+
+#include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
 #include "flutter/shell/platform/tizen/flutter_tizen_engine.h"
+#include "flutter/shell/platform/tizen/testing/engine_modifier.h"
 #include "gtest/gtest.h"
 
 namespace flutter {
@@ -18,9 +22,9 @@ class FlutterTizenEngineTest : public ::testing::Test {
  protected:
   void SetUp() {
     FlutterDesktopEngineProperties engine_prop = {};
-    engine_prop.assets_path = "foo/flutter_assets";
-    engine_prop.icu_data_path = "foo/icudtl.dat";
-    engine_prop.aot_library_path = "foo/libapp.so";
+    engine_prop.assets_path = "/foo/flutter_assets";
+    engine_prop.icu_data_path = "/foo/icudtl.dat";
+    engine_prop.aot_library_path = "/foo/libapp.so";
 
     FlutterProjectBundle project(engine_prop);
     auto engine = std::make_unique<FlutterTizenEngine>(project);
@@ -81,5 +85,64 @@ TEST_F(FlutterTizenEngineTestHeaded, GetTextureRegistrar) {
   EXPECT_TRUE(engine_->GetTextureRegistrar() != nullptr);
 }
 
+TEST_F(FlutterTizenEngineTest, RunDoesExpectedInitialization) {
+  EngineModifier modifier(engine_);
+  bool run_called = false;
+  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
+      Run, ([&run_called, engine_instance = engine_](
+                size_t version, const FlutterRendererConfig* config,
+                const FlutterProjectArgs* args, void* user_data,
+                FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
+        std::string current_path = std::filesystem::current_path().string();
+        run_called = true;
+        *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
+
+        EXPECT_EQ(version, (size_t)FLUTTER_ENGINE_VERSION);
+        EXPECT_NE(config, nullptr);
+        EXPECT_EQ(user_data, engine_instance);
+
+        EXPECT_STREQ(args->assets_path, "/foo/flutter_assets");
+        EXPECT_STREQ(args->icu_data_path, "/foo/icudtl.dat");
+        EXPECT_EQ(args->dart_entrypoint_argc, 0);
+        EXPECT_NE(args->platform_message_callback, nullptr);
+        EXPECT_NE(args->custom_task_runners, nullptr);
+        EXPECT_EQ(args->custom_dart_entrypoint, nullptr);
+
+        return kSuccess;
+      }));
+
+  // It should send locale info.
+  bool update_locales_called = false;
+  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
+      UpdateLocales,
+      ([&update_locales_called](auto engine, const FlutterLocale** locales,
+                                size_t locales_count) {
+        update_locales_called = true;
+        EXPECT_GT(locales_count, (size_t)0);
+        EXPECT_NE(locales, nullptr);
+
+        return kSuccess;
+      }));
+
+  // And it should send initial settings info.
+  bool settings_message_sent = false;
+  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
+      SendPlatformMessage,
+      ([&settings_message_sent](auto engine, auto message) {
+        if (std::string(message->channel) == std::string("flutter/settings")) {
+          settings_message_sent = true;
+        }
+
+        return kSuccess;
+      }));
+
+  engine_->RunEngine();
+
+  EXPECT_TRUE(run_called);
+  EXPECT_TRUE(update_locales_called);
+  EXPECT_TRUE(settings_message_sent);
+
+  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
+}
 }  // namespace testing
 }  // namespace flutter