[WIP] Support iOS Premotion refresh rate

lib/ui/platform_dispatcher.dart

@@ -617,6 +617,12 @@ class PlatformDispatcher {
   ///    scheduling of frames.
   void scheduleFrame() native 'PlatformConfiguration_scheduleFrame';
 
+  /// Update the refresh frame rate of the operating system.
+  ///
+  /// The Flutter framework will call this function to tell engine the max frame rate
+  /// that the screen will take
+  void updateFrameRate(int frequency) native 'PlatformConfiguration_updateFrameRate';
+
   /// Additional accessibility features that may be enabled by the platform.
   AccessibilityFeatures get accessibilityFeatures => configuration.accessibilityFeatures;
 

lib/ui/window.dart

@@ -624,6 +624,9 @@ class SingletonFlutterWindow extends FlutterWindow {
   ///   scheduling of frames.
   void scheduleFrame() => platformDispatcher.scheduleFrame();
 
+  /// Update the refresh frame rate of the operating system.
+  void updateFrameRate(int frequency) => platformDispatcher.updateFrameRate(frequency);
+
   /// Whether the user has requested that [updateSemantics] be called when
   /// the semantic contents of window changes.
   ///

lib/ui/window/platform_configuration.cc

@@ -35,6 +35,19 @@ void ScheduleFrame(Dart_NativeArguments args) {
   UIDartState::Current()->platform_configuration()->client()->ScheduleFrame();
 }
 
+void UpdateFrameRate(Dart_NativeArguments args) {
+  UIDartState::ThrowIfUIOperationsProhibited();
+  Dart_Handle exception = nullptr;
+  int64_t frequency =
+      tonic::DartConverter<int64_t>::FromArguments(args, 1, exception);
+  if (exception) {
+    Dart_ThrowException(exception);
+    return;
+  }
+  UIDartState::Current()->platform_configuration()->client()->UpdateFrameRate(
+      frequency);
+}
+
 void Render(Dart_NativeArguments args) {
   UIDartState::ThrowIfUIOperationsProhibited();
   Dart_Handle exception = nullptr;
@@ -454,6 +467,7 @@ void PlatformConfiguration::RegisterNatives(
   natives->Register({
       {"PlatformConfiguration_defaultRouteName", DefaultRouteName, 1, true},
       {"PlatformConfiguration_scheduleFrame", ScheduleFrame, 1, true},
+      {"PlatformConfiguration_updateFrameRate", UpdateFrameRate, 2, true},
       {"PlatformConfiguration_sendPlatformMessage", _SendPlatformMessage, 4,
        true},
       {"PlatformConfiguration_respondToPlatformMessage",

lib/ui/window/platform_configuration.h

@@ -73,6 +73,14 @@ class PlatformConfigurationClient {
   ///
   virtual void UpdateSemantics(SemanticsUpdate* update) = 0;
 
+  //--------------------------------------------------------------------------
+  /// @brief      Update the refresh frame rate for operating system
+  ///
+  /// @param[in] frequency The frequency the operating system will take for
+  /// refresh rate
+  ///
+  virtual void UpdateFrameRate(int64_t frequency) = 0;
+
   //--------------------------------------------------------------------------
   /// @brief      When the Flutter application has a message to send to the
   ///             underlying platform, the message needs to be forwarded to

runtime/runtime_controller.cc

@@ -277,6 +277,11 @@ void RuntimeController::ScheduleFrame() {
   client_.ScheduleFrame();
 }
 
+// |PlatformConfigurationClient|
+void RuntimeController::UpdateFrameRate(int64_t frequency) {
+  client_.UpdateFrameRate(frequency);
+}
+
 // |PlatformConfigurationClient|
 void RuntimeController::Render(Scene* scene) {
   client_.Render(scene->takeLayerTree());

runtime/runtime_controller.h

@@ -597,6 +597,9 @@ class RuntimeController : public PlatformConfigurationClient {
   // |PlatformConfigurationClient|
   void ScheduleFrame() override;
 
+  // |PlatformConfigurationClient|
+  void UpdateFrameRate(int64_t frequency) override;
+
   // |PlatformConfigurationClient|
   void Render(Scene* scene) override;
 

runtime/runtime_delegate.h

@@ -23,6 +23,8 @@ class RuntimeDelegate {
 
   virtual void ScheduleFrame(bool regenerate_layer_tree = true) = 0;
 
+  virtual void UpdateFrameRate(int64_t frequency) = 0;
+
   virtual void Render(std::unique_ptr<flutter::LayerTree> layer_tree) = 0;
 
   virtual void UpdateSemantics(SemanticsNodeUpdates update,

shell/common/animator.cc

@@ -236,6 +236,10 @@ void Animator::RequestFrame(bool regenerate_layer_tree) {
   frame_scheduled_ = true;
 }
 
+void Animator::UpdateFrameRate(int64_t frequency) {
+  waiter_->UpdateFrameRate(frequency);
+}
+
 void Animator::AwaitVSync() {
   waiter_->AsyncWaitForVsync(
       [self = weak_factory_.GetWeakPtr()](

shell/common/animator.h

@@ -52,6 +52,8 @@ class Animator final {
 
   void RequestFrame(bool regenerate_layer_tree = true);
 
+  void UpdateFrameRate(int64_t frequency);
+
   void Render(std::unique_ptr<flutter::LayerTree> layer_tree);
 
   const VsyncWaiter& GetVsyncWaiter() const;

shell/common/engine.cc

@@ -437,6 +437,10 @@ void Engine::ScheduleFrame(bool regenerate_layer_tree) {
   animator_->RequestFrame(regenerate_layer_tree);
 }
 
+void Engine::UpdateFrameRate(int64_t frequency) {
+  animator_->UpdateFrameRate(frequency);
+}
+
 void Engine::Render(std::unique_ptr<flutter::LayerTree> layer_tree) {
   if (!layer_tree) {
     return;

shell/common/engine.h

@@ -751,6 +751,9 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
   /// tree.
   void ScheduleFrame() { ScheduleFrame(true); }
 
+  // |RuntimeDelegate|
+  void UpdateFrameRate(int64_t frequency) override;
+
   // |RuntimeDelegate|
   FontCollection& GetFontCollection() override;
 

shell/common/vsync_waiter.h

@@ -32,6 +32,10 @@ class VsyncWaiter : public std::enable_shared_from_this<VsyncWaiter> {
   /// |Animator::ScheduleMaybeClearTraceFlowIds|.
   void ScheduleSecondaryCallback(uintptr_t id, const fml::closure& callback);
 
+  /// Update the screen's refresh rate,different platforms may have different
+  /// ways to implement this function to change refresh rate.
+  virtual void UpdateFrameRate(int64_t frequency){};
+
  protected:
   // On some backends, the |FireCallback| needs to be made from a static C
   // method.

shell/platform/darwin/ios/framework/Source/vsync_waiter_ios.h

@@ -37,6 +37,8 @@
 
 - (double)getRefreshRate;
 
+- (void)updateFrameRate:(int64_t)frequency;
+
 @end
 
 namespace flutter {
@@ -53,6 +55,9 @@ class VsyncWaiterIOS final : public VsyncWaiter, public VariableRefreshRateRepor
  private:
   fml::scoped_nsobject<VSyncClient> client_;
 
+  // |VsyncWaiter|
+  void UpdateFrameRate(int64_t frequency) override;
+
   // |VsyncWaiter|
   void AwaitVSync() override;
 

shell/platform/darwin/ios/framework/Source/vsync_waiter_ios.mm

@@ -17,6 +17,10 @@
 
 namespace flutter {
 
+const int64_t kNormalRate = -1;
+const int64_t kMinRate = 0;
+const int64_t kMaxRate = 2147483647;
+
 VsyncWaiterIOS::VsyncWaiterIOS(flutter::TaskRunners task_runners)
     : VsyncWaiter(std::move(task_runners)) {
   auto callback = [this](std::unique_ptr<flutter::FrameTimingsRecorder> recorder) {
@@ -35,6 +39,10 @@
   [client_.get() invalidate];
 }
 
+void VsyncWaiterIOS::UpdateFrameRate(int64_t frequency) {
+  [client_.get() updateFrameRate:frequency];
+}
+
 void VsyncWaiterIOS::AwaitVSync() {
   [client_.get() await];
 }
@@ -74,6 +82,46 @@ - (instancetype)initWithTaskRunner:(fml::RefPtr<fml::TaskRunner>)task_runner
   return self;
 }
 
+- (void)updateFrameRate:(int64_t)rate {
+  float targetPreferredFrameRate = 60.0;
+  const float minFrameRate = 10.0;
+  const float normalFrameRate = 60.0;
+  const float maxFrameRate = fmax([DisplayLinkManager displayRefreshRate], 60.0);
+
+  switch (rate) {
+    case flutter::kNormalRate:
+      targetPreferredFrameRate = normalFrameRate;
+      break;
+    case flutter::kMinRate:
+      targetPreferredFrameRate = minFrameRate;
+      break;
+    case flutter::kMaxRate:
+      targetPreferredFrameRate = maxFrameRate;
+      break;
+    default:
+      targetPreferredFrameRate = fmax(rate, minFrameRate);
+      break;
+  }
+
+  assert(targetPreferredFrameRate >= minFrameRate);
+
+  float currentPreferredFrame = 0.0;
+  if (@available(iOS 15.0, *)) {
+    currentPreferredFrame = display_link_.get().preferredFrameRateRange.preferred;
+    if (currentPreferredFrame == targetPreferredFrameRate) {
+      return;
+    }
+    display_link_.get().preferredFrameRateRange =
+        CAFrameRateRangeMake(minFrameRate, maxFrameRate, targetPreferredFrameRate);
+  } else if (@available(iOS 10.0, *)) {
+    currentPreferredFrame = display_link_.get().preferredFramesPerSecond;
+    if (currentPreferredFrame == targetPreferredFrameRate) {
+      return;
+    }
+    display_link_.get().preferredFramesPerSecond = targetPreferredFrameRate;
+  }
+}
+
 - (void)await {
   display_link_.get().paused = NO;
 }