Platform resolved locale and Android localization refactor

ci/licenses_golden/licenses_flutter

@@ -762,6 +762,7 @@ FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/common/StringCod
 FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/editing/FlutterTextUtils.java
 FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/editing/InputConnectionAdaptor.java
 FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/editing/TextInputPlugin.java
+FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/localization/LocalizationPlugin.java
 FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/mouse/MouseCursorPlugin.java
 FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/platform/AccessibilityEventsDelegate.java
 FILE: ../../../flutter/shell/platform/android/io/flutter/plugin/platform/PlatformPlugin.java

lib/ui/window.dart

@@ -809,6 +809,34 @@ class Window {
   Locale? get platformResolvedLocale => _platformResolvedLocale;
   Locale? _platformResolvedLocale;
 
+  /// Performs the platform-native locale resolution.
+  ///
+  /// Each platform may return different results.
+  ///
+  /// If the platform fails to resolve a locale, then this will return null.
+  ///
+  /// This method returns synchronously and is a direct call to
+  /// platform specific APIs without invoking method channels.
+  Locale? computePlatformResolvedLocale(List<Locale> supportedLocales) {
+    final List<String?> supportedLocalesData = <String?>[];
+    for (Locale locale in supportedLocales) {
+      supportedLocalesData.add(locale.languageCode);
+      supportedLocalesData.add(locale.countryCode);
+      supportedLocalesData.add(locale.scriptCode);
+    }
+
+    final List<String> result = _computePlatformResolvedLocale(supportedLocalesData);
+
+    if (result.isNotEmpty) {
+      return Locale.fromSubtags(
+        languageCode: result[0],
+        countryCode: result[1] == '' ? null : result[1],
+        scriptCode: result[2] == '' ? null : result[2]);
+    }
+    return null;
+  }
+  List<String> _computePlatformResolvedLocale(List<String?> supportedLocalesData) native 'Window_computePlatformResolvedLocale';
+
   /// A callback that is invoked whenever [locale] changes value.
   ///
   /// The framework invokes this callback in the same zone in which the

lib/ui/window/window.cc

@@ -425,6 +425,27 @@ void Window::CompletePlatformMessageResponse(int response_id,
   response->Complete(std::make_unique<fml::DataMapping>(std::move(data)));
 }
 
+Dart_Handle ComputePlatformResolvedLocale(Dart_Handle supportedLocalesHandle) {
+  std::vector<std::string> supportedLocales =
+      tonic::DartConverter<std::vector<std::string>>::FromDart(
+          supportedLocalesHandle);
+
+  std::vector<std::string> results =
+      *UIDartState::Current()
+           ->window()
+           ->client()
+           ->ComputePlatformResolvedLocale(supportedLocales);
+
+  return tonic::DartConverter<std::vector<std::string>>::ToDart(results);
+}
+
+static void _ComputePlatformResolvedLocale(Dart_NativeArguments args) {
+  UIDartState::ThrowIfUIOperationsProhibited();
+  Dart_Handle result =
+      ComputePlatformResolvedLocale(Dart_GetNativeArgument(args, 1));
+  Dart_SetReturnValue(args, result);
+}
+
 void Window::RegisterNatives(tonic::DartLibraryNatives* natives) {
   natives->Register({
       {"Window_defaultRouteName", DefaultRouteName, 1, true},
@@ -437,6 +458,8 @@ void Window::RegisterNatives(tonic::DartLibraryNatives* natives) {
       {"Window_reportUnhandledException", ReportUnhandledException, 2, true},
       {"Window_setNeedsReportTimings", SetNeedsReportTimings, 2, true},
       {"Window_getPersistentIsolateData", GetPersistentIsolateData, 1, true},
+      {"Window_computePlatformResolvedLocale", _ComputePlatformResolvedLocale,
+       2, true},
   });
 }
 

lib/ui/window/window.h

@@ -59,6 +59,9 @@ class WindowClient {
                                         int64_t isolate_port) = 0;
   virtual void SetNeedsReportTimings(bool value) = 0;
   virtual std::shared_ptr<const fml::Mapping> GetPersistentIsolateData() = 0;
+  virtual std::unique_ptr<std::vector<std::string>>
+  ComputePlatformResolvedLocale(
+      const std::vector<std::string>& supported_locale_data) = 0;
 
  protected:
   virtual ~WindowClient();

lib/web_ui/lib/src/ui/window.dart

@@ -616,6 +616,19 @@ abstract class Window {
   /// See [locales], which is the list of locales the user/device prefers.
   Locale/*?*/ get platformResolvedLocale;
 
+  /// Performs the platform-native locale resolution.
+  ///
+  /// Each platform may return different results.
+  ///
+  /// If the platform fails to resolve a locale, then this will return null.
+  ///
+  /// This method returns synchronously and is a direct call to
+  /// platform specific APIs without invoking method channels.
+  Locale computePlatformResolvedLocale(List<Locale> supportedLocales) {
+    // TODO(garyq): Implement on web.
+    return null;
+  }
+
   /// A callback that is invoked whenever [locale] changes value.
   ///
   /// The framework invokes this callback in the same zone in which the

runtime/runtime_controller.cc

@@ -340,6 +340,13 @@ RuntimeController::GetPersistentIsolateData() {
   return persistent_isolate_data_;
 }
 
+// |WindowClient|
+std::unique_ptr<std::vector<std::string>>
+RuntimeController::ComputePlatformResolvedLocale(
+    const std::vector<std::string>& supported_locale_data) {
+  return client_.ComputePlatformResolvedLocale(supported_locale_data);
+}
+
 Dart_Port RuntimeController::GetMainPort() {
   std::shared_ptr<DartIsolate> root_isolate = root_isolate_.lock();
   return root_isolate ? root_isolate->main_port() : ILLEGAL_PORT;

runtime/runtime_controller.h

@@ -522,6 +522,10 @@ class RuntimeController final : public WindowClient {
   // |WindowClient|
   std::shared_ptr<const fml::Mapping> GetPersistentIsolateData() override;
 
+  // |WindowClient|
+  std::unique_ptr<std::vector<std::string>> ComputePlatformResolvedLocale(
+      const std::vector<std::string>& supported_locale_data) override;
+
   FML_DISALLOW_COPY_AND_ASSIGN(RuntimeController);
 };
 

runtime/runtime_delegate.h

@@ -37,6 +37,10 @@ class RuntimeDelegate {
 
   virtual void SetNeedsReportTimings(bool value) = 0;
 
+  virtual std::unique_ptr<std::vector<std::string>>
+  ComputePlatformResolvedLocale(
+      const std::vector<std::string>& supported_locale_data) = 0;
+
  protected:
   virtual ~RuntimeDelegate();
 };

shell/common/engine.cc

@@ -492,6 +492,11 @@ void Engine::UpdateIsolateDescription(const std::string isolate_name,
   delegate_.UpdateIsolateDescription(isolate_name, isolate_port);
 }
 
+std::unique_ptr<std::vector<std::string>> Engine::ComputePlatformResolvedLocale(
+    const std::vector<std::string>& supported_locale_data) {
+  return delegate_.ComputePlatformResolvedLocale(supported_locale_data);
+}
+
 void Engine::SetNeedsReportTimings(bool needs_reporting) {
   delegate_.SetNeedsReportTimings(needs_reporting);
 }

shell/common/engine.h

@@ -227,6 +227,25 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
     ///                              collected and send back to Dart.
     ///
     virtual void SetNeedsReportTimings(bool needs_reporting) = 0;
+
+    //--------------------------------------------------------------------------
+    /// @brief      Directly invokes platform-specific APIs to compute the
+    ///             locale the platform would have natively resolved to.
+    ///
+    /// @param[in]  supported_locale_data  The vector of strings that represents
+    ///                                    the locales supported by the app.
+    ///                                    Each locale consists of three
+    ///                                    strings: languageCode, countryCode,
+    ///                                    and scriptCode in that order.
+    ///
+    /// @return     A vector of 3 strings languageCode, countryCode, and
+    ///             scriptCode that represents the locale selected by the
+    ///             platform. Empty strings mean the value was unassigned. Empty
+    ///             vector represents a null locale.
+    ///
+    virtual std::unique_ptr<std::vector<std::string>>
+    ComputePlatformResolvedLocale(
+        const std::vector<std::string>& supported_locale_data) = 0;
   };
 
   //----------------------------------------------------------------------------
@@ -765,6 +784,10 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
   void UpdateIsolateDescription(const std::string isolate_name,
                                 int64_t isolate_port) override;
 
+  // |RuntimeDelegate|
+  std::unique_ptr<std::vector<std::string>> ComputePlatformResolvedLocale(
+      const std::vector<std::string>& supported_locale_data) override;
+
   void SetNeedsReportTimings(bool value) override;
 
   void StopAnimator();

shell/common/platform_view.cc

@@ -137,4 +137,12 @@ void PlatformView::SetNextFrameCallback(const fml::closure& closure) {
   delegate_.OnPlatformViewSetNextFrameCallback(closure);
 }
 
+std::unique_ptr<std::vector<std::string>>
+PlatformView::ComputePlatformResolvedLocales(
+    const std::vector<std::string>& supported_locale_data) {
+  std::unique_ptr<std::vector<std::string>> out =
+      std::make_unique<std::vector<std::string>>();
+  return out;
+}
+
 }  // namespace flutter

shell/common/platform_view.h

@@ -209,6 +209,25 @@ class PlatformView {
     ///
     virtual void OnPlatformViewMarkTextureFrameAvailable(
         int64_t texture_id) = 0;
+
+    //--------------------------------------------------------------------------
+    /// @brief      Directly invokes platform-specific APIs to compute the
+    ///             locale the platform would have natively resolved to.
+    ///
+    /// @param[in]  supported_locale_data  The vector of strings that represents
+    ///                                    the locales supported by the app.
+    ///                                    Each locale consists of three
+    ///                                    strings: languageCode, countryCode,
+    ///                                    and scriptCode in that order.
+    ///
+    /// @return     A vector of 3 strings languageCode, countryCode, and
+    ///             scriptCode that represents the locale selected by the
+    ///             platform. Empty strings mean the value was unassigned. Empty
+    ///             vector represents a null locale.
+    ///
+    virtual std::unique_ptr<std::vector<std::string>>
+    ComputePlatformViewResolvedLocale(
+        const std::vector<std::string>& supported_locale_data) = 0;
   };
 
   //----------------------------------------------------------------------------
@@ -543,6 +562,25 @@ class PlatformView {
   ///
   void MarkTextureFrameAvailable(int64_t texture_id);
 
+  //--------------------------------------------------------------------------
+  /// @brief      Directly invokes platform-specific APIs to compute the
+  ///             locale the platform would have natively resolved to.
+  ///
+  /// @param[in]  supported_locale_data  The vector of strings that represents
+  ///                                    the locales supported by the app.
+  ///                                    Each locale consists of three
+  ///                                    strings: languageCode, countryCode,
+  ///                                    and scriptCode in that order.
+  ///
+  /// @return     A vector of 3 strings languageCode, countryCode, and
+  ///             scriptCode that represents the locale selected by the
+  ///             platform. Empty strings mean the value was unassigned. Empty
+  ///             vector represents a null locale.
+  ///
+  virtual std::unique_ptr<std::vector<std::string>>
+  ComputePlatformResolvedLocales(
+      const std::vector<std::string>& supported_locale_data);
+
  protected:
   PlatformView::Delegate& delegate_;
   const TaskRunners task_runners_;

shell/common/shell.cc

@@ -1097,6 +1097,19 @@ void Shell::SetNeedsReportTimings(bool value) {
   needs_report_timings_ = value;
 }
 
+// |Engine::Delegate|
+std::unique_ptr<std::vector<std::string>> Shell::ComputePlatformResolvedLocale(
+    const std::vector<std::string>& supported_locale_data) {
+  return ComputePlatformViewResolvedLocale(supported_locale_data);
+}
+
+// |PlatformView::Delegate|
+std::unique_ptr<std::vector<std::string>>
+Shell::ComputePlatformViewResolvedLocale(
+    const std::vector<std::string>& supported_locale_data) {
+  return platform_view_->ComputePlatformResolvedLocales(supported_locale_data);
+}
+
 void Shell::ReportTimings() {
   FML_DCHECK(is_setup_);
   FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());

shell/common/shell.h

@@ -483,6 +483,10 @@ class Shell final : public PlatformView::Delegate,
   // |PlatformView::Delegate|
   void OnPlatformViewSetNextFrameCallback(const fml::closure& closure) override;
 
+  // |PlatformView::Delegate|
+  std::unique_ptr<std::vector<std::string>> ComputePlatformViewResolvedLocale(
+      const std::vector<std::string>& supported_locale_data) override;
+
   // |Animator::Delegate|
   void OnAnimatorBeginFrame(fml::TimePoint frame_target_time) override;
 
@@ -517,6 +521,10 @@ class Shell final : public PlatformView::Delegate,
   // |Engine::Delegate|
   void SetNeedsReportTimings(bool value) override;
 
+  // |Engine::Delegate|
+  std::unique_ptr<std::vector<std::string>> ComputePlatformResolvedLocale(
+      const std::vector<std::string>& supported_locale_data) override;
+
   // |Rasterizer::Delegate|
   void OnFrameRasterized(const FrameTiming&) override;
 

shell/platform/android/BUILD.gn

@@ -210,6 +210,7 @@ android_java_sources = [
   "io/flutter/plugin/editing/FlutterTextUtils.java",
   "io/flutter/plugin/editing/InputConnectionAdaptor.java",
   "io/flutter/plugin/editing/TextInputPlugin.java",
+  "io/flutter/plugin/localization/LocalizationPlugin.java",
   "io/flutter/plugin/mouse/MouseCursorPlugin.java",
   "io/flutter/plugin/platform/AccessibilityEventsDelegate.java",
   "io/flutter/plugin/platform/PlatformPlugin.java",