[Linux] add testable FlSettings

FlSettings provides desktop settings and notifies changes, whereas
FlSettingsPlugin merely communicates them to the framework. This
makes it straightforward to test both separately. As a bonus, it
will be easy to add FlSettings implementations for other DEs too.

Author: jpnurmi

shell/platform/linux/BUILD.gn

@@ -106,6 +106,7 @@ source_set("flutter_linux_sources") {
     "fl_engine.cc",
     "fl_event_channel.cc",
     "fl_gl_area.cc",
+    "fl_gnome_settings.cc",
     "fl_json_message_codec.cc",
     "fl_json_method_codec.cc",
     "fl_key_channel_responder.cc",
@@ -126,6 +127,7 @@ source_set("flutter_linux_sources") {
     "fl_renderer.cc",
     "fl_renderer_gl.cc",
     "fl_renderer_headless.cc",
+    "fl_settings.cc",
     "fl_settings_plugin.cc",
     "fl_standard_message_codec.cc",
     "fl_standard_method_codec.cc",
@@ -173,6 +175,16 @@ test_fixtures("flutter_linux_fixtures") {
   fixtures = []
 }
 
+copy("flutter_linux_gschemas") {
+  testonly = true
+
+  sources = [
+    "testing/gschemas/ubuntu-20.04.compiled",
+    "testing/gschemas/ubuntu-22.04.compiled",
+  ]
+  outputs = [ "$target_gen_dir/assets/{{source_name_part}}/gschemas.compiled" ]
+}
+
 executable("flutter_linux_unittests") {
   testonly = true
 
@@ -184,6 +196,7 @@ executable("flutter_linux_unittests") {
     "fl_dart_project_test.cc",
     "fl_engine_test.cc",
     "fl_event_channel_test.cc",
+    "fl_gnome_settings_test.cc",
     "fl_json_message_codec_test.cc",
     "fl_json_method_codec_test.cc",
     "fl_key_channel_responder_test.cc",
@@ -195,6 +208,7 @@ executable("flutter_linux_unittests") {
     "fl_method_response_test.cc",
     "fl_pixel_buffer_texture_test.cc",
     "fl_plugin_registrar_test.cc",
+    "fl_settings_plugin_test.cc",
     "fl_standard_message_codec_test.cc",
     "fl_standard_method_codec_test.cc",
     "fl_string_codec_test.cc",
@@ -208,6 +222,7 @@ executable("flutter_linux_unittests") {
     "testing/mock_epoxy.cc",
     "testing/mock_plugin_registrar.cc",
     "testing/mock_renderer.cc",
+    "testing/mock_settings.cc",
     "testing/mock_signal_handler.cc",
     "testing/mock_text_input_plugin.cc",
     "testing/mock_texture_registrar.cc",
@@ -227,6 +242,7 @@ executable("flutter_linux_unittests") {
 
   deps = [
     ":flutter_linux_fixtures",
+    ":flutter_linux_gschemas",
     ":flutter_linux_sources",
     "//flutter/runtime:libdart",
     "//flutter/shell/platform/embedder:embedder_headers",

shell/platform/linux/fl_engine.cc

@@ -516,8 +516,9 @@ gboolean fl_engine_start(FlEngine* self, GError** error) {
 
   setup_locales(self);
 
+  g_autoptr(FlSettings) settings = fl_settings_new();
   self->settings_plugin = fl_settings_plugin_new(self->binary_messenger);
-  fl_settings_plugin_start(self->settings_plugin);
+  fl_settings_plugin_start(self->settings_plugin, settings);
 
   result = self->embedder_api.UpdateSemanticsEnabled(self->engine, TRUE);
   if (result != kSuccess) {

shell/platform/linux/fl_gnome_settings.cc

@@ -0,0 +1,140 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/linux/fl_gnome_settings.h"
+
+#include <glib.h>
+
+static constexpr char kDesktopInterfaceSchema[] = "org.gnome.desktop.interface";
+static constexpr char kDesktopTextScalingFactorKey[] = "text-scaling-factor";
+static constexpr char kDesktopClockFormatKey[] = "clock-format";
+static constexpr char kDesktopGtkThemeKey[] = "gtk-theme";
+
+static constexpr char kClockFormat12Hour[] = "12h";
+static constexpr char kColorSchemePreferDark[] = "prefer-dark";
+static constexpr char kGtkThemeDarkSuffix[] = "-dark";
+
+G_DECLARE_FINAL_TYPE(FlGnomeSettings,
+                     fl_gnome_settings,
+                     FL,
+                     GNOME_SETTINGS,
+                     GObject);
+
+struct _FlGnomeSettings {
+  GObject parent_instance;
+
+  GSettings* interface_settings;
+};
+
+static void fl_gnome_settings_iface_init(FlSettingsInterface* iface);
+
+#define FL_UNUSED(x) (void)x;
+
+G_DEFINE_TYPE_WITH_CODE(FlGnomeSettings,
+                        fl_gnome_settings,
+                        G_TYPE_OBJECT,
+                        G_IMPLEMENT_INTERFACE(fl_settings_get_type(),
+                                              fl_gnome_settings_iface_init)
+                            FL_UNUSED(FL_IS_GNOME_SETTINGS))
+
+static FlClockFormat fl_gnome_settings_get_clock_format(FlSettings* settings) {
+  FlGnomeSettings* self = FL_GNOME_SETTINGS(settings);
+
+  FlClockFormat clock_format = FL_CLOCK_FORMAT_24H;
+
+  if (self->interface_settings != nullptr) {
+    g_autofree gchar* value =
+        g_settings_get_string(self->interface_settings, kDesktopClockFormatKey);
+    if (g_strcmp0(value, kClockFormat12Hour) == 0) {
+      clock_format = FL_CLOCK_FORMAT_12H;
+    }
+  }
+  return clock_format;
+}
+
+static FlColorScheme fl_gnome_settings_get_color_scheme(FlSettings* settings) {
+  FlGnomeSettings* self = FL_GNOME_SETTINGS(settings);
+
+  FlColorScheme color_scheme = FL_COLOR_SCHEME_LIGHT;
+
+  if (self->interface_settings != nullptr) {
+    // check whether org.gnome.desktop.interface.gtk-theme ends with "-dark"
+    g_autofree gchar* value =
+        g_settings_get_string(self->interface_settings, kDesktopGtkThemeKey);
+    if (g_str_has_suffix(value, kGtkThemeDarkSuffix)) {
+      color_scheme = FL_COLOR_SCHEME_DARK;
+    }
+  }
+  return color_scheme;
+}
+
+static gdouble fl_gnome_settings_get_text_scaling_factor(FlSettings* settings) {
+  FlGnomeSettings* self = FL_GNOME_SETTINGS(settings);
+
+  gdouble scaling_factor = 1.0;
+
+  if (self->interface_settings != nullptr) {
+    scaling_factor = g_settings_get_double(self->interface_settings,
+                                           kDesktopTextScalingFactorKey);
+  }
+  return scaling_factor;
+}
+
+static void fl_gnome_settings_dispose(GObject* object) {
+  FlGnomeSettings* self = FL_GNOME_SETTINGS(object);
+
+  g_clear_object(&self->interface_settings);
+
+  G_OBJECT_CLASS(fl_gnome_settings_parent_class)->dispose(object);
+}
+
+static void fl_gnome_settings_class_init(FlGnomeSettingsClass* klass) {
+  G_OBJECT_CLASS(klass)->dispose = fl_gnome_settings_dispose;
+}
+
+static void fl_gnome_settings_iface_init(FlSettingsInterface* iface) {
+  iface->get_clock_format = fl_gnome_settings_get_clock_format;
+  iface->get_color_scheme = fl_gnome_settings_get_color_scheme;
+  iface->get_text_scaling_factor = fl_gnome_settings_get_text_scaling_factor;
+}
+
+static void fl_gnome_settings_init(FlGnomeSettings* self) {}
+
+static GSettings* default_interface_settings() {
+  GSettings* interface_settings = nullptr;
+  GSettingsSchemaSource* source = g_settings_schema_source_get_default();
+  if (source != nullptr) {
+    g_autoptr(GSettingsSchema) schema =
+        g_settings_schema_source_lookup(source, kDesktopInterfaceSchema, TRUE);
+    if (schema != nullptr) {
+      interface_settings = g_settings_new_full(schema, nullptr, nullptr);
+    }
+  }
+  return interface_settings;
+}
+
+FlSettings* fl_gnome_settings_new(GSettings* interface_settings) {
+  FlGnomeSettings* self =
+      FL_GNOME_SETTINGS(g_object_new(fl_gnome_settings_get_type(), nullptr));
+
+  if (interface_settings != nullptr) {
+    self->interface_settings = G_SETTINGS(g_object_ref(interface_settings));
+  } else {
+    self->interface_settings = default_interface_settings();
+  }
+
+  if (self->interface_settings != nullptr) {
+    g_signal_connect_object(self->interface_settings, "changed::clock-format",
+                            G_CALLBACK(fl_settings_emit_changed), self,
+                            G_CONNECT_SWAPPED);
+    g_signal_connect_object(self->interface_settings, "changed::gtk-theme",
+                            G_CALLBACK(fl_settings_emit_changed), self,
+                            G_CONNECT_SWAPPED);
+    g_signal_connect_object(
+        self->interface_settings, "changed::text-scaling-factor",
+        G_CALLBACK(fl_settings_emit_changed), self, G_CONNECT_SWAPPED);
+  }
+
+  return FL_SETTINGS(self);
+}

shell/platform/linux/fl_gnome_settings.h

@@ -0,0 +1,26 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_SHELL_PLATFORM_LINUX_FL_GNOME_SETTINGS_H_
+#define FLUTTER_SHELL_PLATFORM_LINUX_FL_GNOME_SETTINGS_H_
+
+#include "flutter/shell/platform/linux/fl_settings.h"
+
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+/**
+ * fl_gnome_settings_new:
+ * @interface_settings: (allow-none): #GSettings for testing purposes, or %NULL.
+ *
+ * Creates a new settings instance for GNOME.
+ *
+ * Returns: a new #FlSettings.
+ */
+FlSettings* fl_gnome_settings_new(GSettings* interface_settings);
+
+G_END_DECLS
+
+#endif  // FLUTTER_SHELL_PLATFORM_LINUX_FL_GNOME_SETTINGS_H_

shell/platform/linux/fl_gnome_settings_test.cc

@@ -0,0 +1,104 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/linux/fl_gnome_settings.h"
+#include "flutter/shell/platform/linux/testing/fl_test.h"
+#include "flutter/shell/platform/linux/testing/mock_settings.h"
+#include "flutter/shell/platform/linux/testing/mock_signal_handler.h"
+#include "flutter/testing/testing.h"
+
+#include <gio/gio.h>
+#define G_SETTINGS_ENABLE_BACKEND
+#include <gio/gsettingsbackend.h>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+class FlGnomeSettingsTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    // force _g_io_modules_ensure_extension_points_registered() to get called
+    g_settings_backend_get_default();
+  }
+};
+
+static GSettings* create_interface_settings(const gchar* name) {
+  g_autofree gchar* path =
+      g_build_filename(flutter::testing::GetFixturesPath(), name, nullptr);
+  g_autoptr(GSettingsSchemaSource) source =
+      g_settings_schema_source_new_from_directory(path, nullptr, false,
+                                                  nullptr);
+  g_autoptr(GSettingsSchema) schema = g_settings_schema_source_lookup(
+      source, "org.gnome.desktop.interface", false);
+  g_autoptr(GSettingsBackend) backend = g_memory_settings_backend_new();
+  return g_settings_new_full(schema, backend, nullptr);
+}
+
+TEST_F(FlGnomeSettingsTest, ClockFormat) {
+  g_autoptr(GSettings) interface_settings =
+      create_interface_settings("ubuntu-20.04");
+  g_settings_set_string(interface_settings, "clock-format", "24h");
+
+  g_autoptr(FlSettings) settings = fl_gnome_settings_new(interface_settings);
+  EXPECT_EQ(fl_settings_get_clock_format(settings), FL_CLOCK_FORMAT_24H);
+
+  flutter::testing::MockSignalHandler settings_changed(settings, "changed");
+  EXPECT_SIGNAL(settings_changed).Times(1);
+
+  g_settings_set_string(interface_settings, "clock-format", "12h");
+  EXPECT_EQ(fl_settings_get_clock_format(settings), FL_CLOCK_FORMAT_12H);
+}
+
+TEST_F(FlGnomeSettingsTest, GtkTheme) {
+  g_autoptr(GSettings) interface_settings =
+      create_interface_settings("ubuntu-20.04");
+  g_settings_set_string(interface_settings, "gtk-theme", "Yaru");
+
+  g_autoptr(FlSettings) settings = fl_gnome_settings_new(interface_settings);
+  EXPECT_EQ(fl_settings_get_color_scheme(settings), FL_COLOR_SCHEME_LIGHT);
+
+  flutter::testing::MockSignalHandler settings_changed(settings, "changed");
+  EXPECT_SIGNAL(settings_changed).Times(1);
+
+  g_settings_set_string(interface_settings, "gtk-theme", "Yaru-dark");
+  EXPECT_EQ(fl_settings_get_color_scheme(settings), FL_COLOR_SCHEME_DARK);
+}
+
+TEST_F(FlGnomeSettingsTest, TextScalingFactor) {
+  g_autoptr(GSettings) interface_settings =
+      create_interface_settings("ubuntu-20.04");
+  g_settings_set_double(interface_settings, "text-scaling-factor", 1.0);
+
+  g_autoptr(FlSettings) settings = fl_gnome_settings_new(interface_settings);
+  EXPECT_EQ(fl_settings_get_text_scaling_factor(settings), 1.0);
+
+  flutter::testing::MockSignalHandler settings_changed(settings, "changed");
+  EXPECT_SIGNAL(settings_changed).Times(1);
+
+  g_settings_set_double(interface_settings, "text-scaling-factor", 1.5);
+  EXPECT_EQ(fl_settings_get_text_scaling_factor(settings), 1.5);
+}
+
+TEST_F(FlGnomeSettingsTest, SignalHandlers) {
+  g_autoptr(GSettings) interface_settings =
+      create_interface_settings("ubuntu-20.04");
+
+  FlSettings* settings = fl_gnome_settings_new(interface_settings);
+  flutter::testing::MockSignalHandler settings_changed(settings, "changed");
+
+  EXPECT_SIGNAL(settings_changed).Times(3);
+
+  g_settings_set_string(interface_settings, "clock-format", "12h");
+  g_settings_set_string(interface_settings, "gtk-theme", "Yaru-dark");
+  g_settings_set_double(interface_settings, "text-scaling-factor", 1.5);
+
+  EXPECT_SIGNAL(settings_changed).Times(0);
+
+  g_clear_object(&settings);
+
+  // destroyed FlSettings object must have disconnected its signal handlers
+  g_settings_set_string(interface_settings, "clock-format", "24h");
+  g_settings_set_string(interface_settings, "gtk-theme", "Yaru");
+  g_settings_set_double(interface_settings, "text-scaling-factor", 2.0);
+}

shell/platform/linux/fl_settings.cc

@@ -0,0 +1,49 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/linux/fl_settings.h"
+#include "flutter/shell/platform/linux/fl_gnome_settings.h"
+
+G_DEFINE_INTERFACE(FlSettings, fl_settings, G_TYPE_OBJECT)
+
+enum {
+  SIGNAL_CHANGED,
+  SIGNAL_LAST_SIGNAL,
+};
+
+static guint signals[SIGNAL_LAST_SIGNAL];
+
+static void fl_settings_default_init(FlSettingsInterface* iface) {
+  /**
+   * FlSettings::changed:
+   * @settings: an #FlSettings
+   *
+   * This signal is emitted after the settings have been changed.
+   */
+  signals[SIGNAL_CHANGED] =
+      g_signal_new("changed", G_TYPE_FROM_INTERFACE(iface), G_SIGNAL_RUN_LAST,
+                   0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+FlClockFormat fl_settings_get_clock_format(FlSettings* self) {
+  return FL_SETTINGS_GET_IFACE(self)->get_clock_format(self);
+}
+
+FlColorScheme fl_settings_get_color_scheme(FlSettings* self) {
+  return FL_SETTINGS_GET_IFACE(self)->get_color_scheme(self);
+}
+
+gdouble fl_settings_get_text_scaling_factor(FlSettings* self) {
+  return FL_SETTINGS_GET_IFACE(self)->get_text_scaling_factor(self);
+}
+
+void fl_settings_emit_changed(FlSettings* self) {
+  g_return_if_fail(FL_IS_SETTINGS(self));
+  g_signal_emit(self, signals[SIGNAL_CHANGED], 0);
+}
+
+FlSettings* fl_settings_new() {
+  // TODO(jpnurmi): add support for other desktop environments
+  return FL_SETTINGS(fl_gnome_settings_new(nullptr));
+}