Create system_utils and add the desktop implementation

Author: swift-kim

shell/platform/tizen/BUILD.gn

@@ -131,6 +131,7 @@ template("embedder_for_profile") {
       "channels/settings_channel.cc",
       "external_texture_pixel_gl.cc",
       "external_texture_surface_gl.cc",
+      "system_utils_tizen.cc",
       "tizen_log.cc",
     ]
 
@@ -246,6 +247,7 @@ template("embedder_executable") {
       "channels/settings_channel_stub.cc",
       "external_texture_pixel_gl_stub.cc",
       "external_texture_surface_gl_stub.cc",
+      "system_utils_linux.cc",
       "tizen_log_stub.cc",
       "tizen_renderer_evas_gl.cc",
     ]

shell/platform/tizen/flutter_tizen_engine.cc

@@ -5,14 +5,11 @@
 
 #include "flutter_tizen_engine.h"
 
-#ifndef __X64_SHELL__
-#include <utils_i18n.h>
-#endif
-
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include "flutter/shell/platform/tizen/system_utils.h"
 #include "flutter/shell/platform/tizen/tizen_log.h"
 
 namespace flutter {
@@ -35,17 +32,9 @@ constexpr double kProfileFactor = 2.0;
 constexpr double kProfileFactor = 1.0;
 #endif
 
-#ifndef __X64_SHELL__
-struct LocaleInfo {
-  std::string language;
-  std::string country;
-  std::string script;
-  std::string variant;
-};
-
-// Converts a LocaleInfo struct to a FlutterLocale struct. |info| must outlive
+// Converts a LanguageInfo struct to a FlutterLocale struct. |info| must outlive
 // the returned value, since the returned FlutterLocale has pointers into it.
-FlutterLocale CovertToFlutterLocale(const LocaleInfo& info) {
+FlutterLocale CovertToFlutterLocale(const LanguageInfo& info) {
   FlutterLocale locale = {};
   locale.struct_size = sizeof(FlutterLocale);
   locale.language_code = info.language.c_str();
@@ -60,7 +49,6 @@ FlutterLocale CovertToFlutterLocale(const LocaleInfo& info) {
   }
   return locale;
 }
-#endif
 
 }  // namespace
 
@@ -416,64 +404,13 @@ void FlutterTizenEngine::OnVsync(intptr_t baton,
 }
 
 void FlutterTizenEngine::SetupLocales() {
-#ifndef __X64_SHELL__
-  i18n_ulocale_set_default(getenv("LANG"));
-
-  const char* locale_id;
-  int ret = i18n_ulocale_get_default(&locale_id);
-  if (ret != I18N_ERROR_NONE) {
-    FT_LOGE("i18n_ulocale_get_default() failed.");
-    return;
-  }
-  std::string preferred_locale(locale_id);
-  preferred_locale = preferred_locale.substr(0, preferred_locale.find("."));
-
-  std::vector<LocaleInfo> locales;
-  int32_t count = i18n_ulocale_count_available();
-  locales.reserve(count);
-  for (int i = 0; i < count; i++) {
-    LocaleInfo locale;
-    int ret;
-    char buffer[128] = {0};
-    int32_t size;
-
-    // The "language" field is required.
-    locale_id = i18n_ulocale_get_available(i);
-    ret = i18n_ulocale_get_language(locale_id, buffer, sizeof(buffer), &size);
-    if (ret != I18N_ERROR_NONE || size == 0) {
-      continue;
-    }
-    locale.language = std::string(buffer, size);
-
-    // "country", "script", and "variant" are optional.
-    size = i18n_ulocale_get_country(locale_id, buffer, sizeof(buffer), &ret);
-    if (ret == I18N_ERROR_NONE && size > 0) {
-      locale.country = std::string(buffer, size);
-    }
-    size = i18n_ulocale_get_script(locale_id, buffer, sizeof(buffer));
-    if (size > 0) {
-      locale.script = std::string(buffer, size);
-    }
-    size = i18n_ulocale_get_variant(locale_id, buffer, sizeof(buffer));
-    if (size > 0) {
-      locale.variant = std::string(buffer, size);
-    }
-
-    if (preferred_locale.compare(locale_id) == 0) {
-      locales.insert(locales.begin(), locale);
-    } else {
-      locales.push_back(locale);
-    }
-  }
-  FT_LOGI("Found %zu locales.", locales.size());
-
-  // The locale list should be converted into the FlutterLocale list, and again
-  // to the FlutterLocale* list.
+  std::vector<LanguageInfo> languages = GetPreferredLanguageInfo();
   std::vector<FlutterLocale> flutter_locales;
-  flutter_locales.reserve(locales.size());
-  for (const auto& info : locales) {
+  flutter_locales.reserve(languages.size());
+  for (const auto& info : languages) {
     flutter_locales.push_back(CovertToFlutterLocale(info));
   }
+  // Convert the locale list to the locale pointer list that must be provided.
   std::vector<const FlutterLocale*> flutter_locale_list;
   flutter_locale_list.reserve(flutter_locales.size());
   std::transform(
@@ -483,7 +420,6 @@ void FlutterTizenEngine::SetupLocales() {
 
   embedder_api_.UpdateLocales(engine_, flutter_locale_list.data(),
                               flutter_locale_list.size());
-#endif
 }
 
 void FlutterTizenEngine::NotifyLowMemoryWarning() {

shell/platform/tizen/system_utils.h

@@ -0,0 +1,27 @@
+// 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.
+
+#ifndef EMBEDDER_SYSTEM_UTILS_H_
+#define EMBEDDER_SYSTEM_UTILS_H_
+
+#include <string>
+#include <vector>
+
+namespace flutter {
+
+// Components of a system language/locale.
+struct LanguageInfo {
+  std::string language;
+  std::string country;
+  std::string script;
+  std::string variant;
+};
+
+// Returns the list of user-preferred locales, in preference order,
+// parsed into LanguageInfo structures.
+std::vector<LanguageInfo> GetPreferredLanguageInfo();
+
+}  // namespace flutter
+
+#endif  // EMBEDDER_SYSTEM_UTILS_H_

shell/platform/tizen/system_utils_linux.cc

@@ -0,0 +1,56 @@
+// 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_utils.h"
+
+#include <cstdlib>
+
+namespace flutter {
+
+namespace {
+
+const char* GetLocaleStringFromEnvironment() {
+  const char* retval;
+  retval = getenv("LANGUAGE");
+  if (retval && (retval[0] != '\0')) {
+    return retval;
+  }
+  retval = getenv("LC_ALL");
+  if (retval && (retval[0] != '\0')) {
+    return retval;
+  }
+  retval = getenv("LC_MESSAGES");
+  if (retval && (retval[0] != '\0')) {
+    return retval;
+  }
+  retval = getenv("LANG");
+  if (retval && (retval[0] != '\0')) {
+    return retval;
+  }
+  return "";
+}
+
+}  // namespace
+
+std::vector<LanguageInfo> GetPreferredLanguageInfo() {
+  std::vector<LanguageInfo> languages;
+
+  std::string locale(GetLocaleStringFromEnvironment());
+  if (locale.empty()) {
+    // This is the default locale if none is specified according to ISO C.
+    locale = "C";
+  }
+  LanguageInfo info;
+  size_t country_pos = locale.find("_");
+  size_t codeset_pos = locale.find(".");
+  info.language = locale.substr(0, country_pos);
+  if (country_pos != std::string::npos) {
+    info.country = locale.substr(country_pos + 1, codeset_pos);
+  }
+  languages.push_back(info);
+
+  return languages;
+}
+
+}  // namespace flutter

shell/platform/tizen/system_utils_tizen.cc

@@ -0,0 +1,68 @@
+// 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_utils.h"
+
+#include <utils_i18n.h>
+
+#include "flutter/shell/platform/tizen/tizen_log.h"
+
+namespace flutter {
+
+std::vector<LanguageInfo> GetPreferredLanguageInfo() {
+  std::vector<LanguageInfo> languages;
+  const char* locale;
+
+  i18n_ulocale_set_default(getenv("LANG"));
+  int ret = i18n_ulocale_get_default(&locale);
+  if (ret != I18N_ERROR_NONE) {
+    FT_LOGE("i18n_ulocale_get_default() failed.");
+    return languages;
+  }
+  std::string preferred_locale(locale);
+  size_t codeset_pos = preferred_locale.find(".");
+  preferred_locale = preferred_locale.substr(0, codeset_pos);
+
+  int32_t count = i18n_ulocale_count_available();
+  languages.reserve(count);
+  for (int i = 0; i < count; i++) {
+    LanguageInfo info;
+    int ret;
+    char buffer[128] = {0};
+    int32_t size;
+
+    // The "language" field is required.
+    locale = i18n_ulocale_get_available(i);
+    ret = i18n_ulocale_get_language(locale, buffer, sizeof(buffer), &size);
+    if (ret != I18N_ERROR_NONE || size == 0) {
+      continue;
+    }
+    info.language = std::string(buffer, size);
+
+    // "country", "script", and "variant" are optional.
+    size = i18n_ulocale_get_country(locale, buffer, sizeof(buffer), &ret);
+    if (ret == I18N_ERROR_NONE && size > 0) {
+      info.country = std::string(buffer, size);
+    }
+    size = i18n_ulocale_get_script(locale, buffer, sizeof(buffer));
+    if (size > 0) {
+      info.script = std::string(buffer, size);
+    }
+    size = i18n_ulocale_get_variant(locale, buffer, sizeof(buffer));
+    if (size > 0) {
+      info.variant = std::string(buffer, size);
+    }
+
+    if (preferred_locale.compare(locale) == 0) {
+      languages.insert(languages.begin(), info);
+    } else {
+      languages.push_back(info);
+    }
+  }
+  FT_LOGI("Found %zu locales.", languages.size());
+
+  return languages;
+}
+
+}  // namespace flutter