Fix _availability_version_check for iOS 11 and 12

BUILD.gn

@@ -201,6 +201,7 @@ group("unittests") {
       public_deps += [
         "//flutter/impeller/golden_tests:impeller_golden_tests",
         "//flutter/shell/gpu:gpu_surface_metal_unittests",
+        "//flutter/shell/platform/darwin/common:availability_version_check_unittests",
         "//flutter/shell/platform/darwin/common:framework_common_unittests",
         "//flutter/third_party/spring_animation:spring_animation_unittests",
       ]

shell/platform/darwin/common/BUILD.gn

@@ -50,6 +50,25 @@ source_set("availability_version_check") {
   public_configs = [ "//flutter:config" ]
 }
 
+test_fixtures("availability_version_check_fixtures") {
+  fixtures = []
+}
+
+executable("availability_version_check_unittests") {
+  testonly = true
+
+  sources = [ "availability_version_check_unittests.cc" ]
+
+  deps = [
+    ":availability_version_check",
+    ":availability_version_check_fixtures",
+    "//flutter/fml",
+    "//flutter/testing",
+  ]
+
+  public_configs = [ "//flutter:config" ]
+}
+
 # Shared framework headers end up in the same folder as platform-specific
 # framework headers when consumed by clients, so the include paths assume they
 # are next to each other.

shell/platform/darwin/common/availability_version_check.cc

@@ -2,20 +2,129 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "flutter/shell/platform/darwin/common/availability_version_check.h"
+
+#include <cstdint>
+#include <optional>
+
+#include <CoreFoundation/CoreFoundation.h>
 #include <dispatch/dispatch.h>
 #include <dlfcn.h>
-#include <cstdint>
 
+#include "flutter/fml/build_config.h"
+#include "flutter/fml/file.h"
 #include "flutter/fml/logging.h"
+#include "flutter/fml/mapping.h"
+#include "flutter/fml/platform/darwin/cf_utils.h"
+
+// The implementation of _availability_version_check defined in this file is
+// based on the code in the clang-rt library at:
+//
+// https://github.com/llvm/llvm-project/blob/e315bf25a843582de39257e1345408a10dc08224/compiler-rt/lib/builtins/os_version_check.c
+//
+// Flutter provides its own implementation due to an issue introduced in recent
+// versions of Clang following Clang 18 in which the clang-rt library declares
+// weak linkage against the _availability_version_check symbol. This declaration
+// causes apps to be rejected from the App Store. When Flutter statically links
+// the implementation below, the weak linkage is satisfied at Engine build time,
+// the symbol is no longer exposed from the Engine dylib, and apps will then
+// not be rejected from the App Store.
+//
+// The implementation of _availability_version_check can delegate to the
+// dynamically looked-up symbol on recent iOS versions, but the lookup will fail
+// on iOS 11 and 12. When the lookup fails, the current OS version must be
+// retrieved from a plist file at a well-known path. The logic for this below is
+// copied from the clang-rt implementation and adapted for the Engine.
 
-// See context in https://github.com/flutter/flutter/issues/132130 and
+// See more context in https://github.com/flutter/flutter/issues/132130 and
 // https://github.com/flutter/engine/pull/44711.
 
 // TODO(zanderso): Remove this after Clang 18 rolls into Xcode.
-// https://github.com/flutter/flutter/issues/133203
+// https://github.com/flutter/flutter/issues/133203.
+
+#define CF_PROPERTY_LIST_IMMUTABLE 0
+
+namespace flutter {
+
+// This function parses the platform's version information out of a plist file
+// at a well-known path. It parses the plist file using CoreFoundation functions
+// to match the implementation in the clang-rt library.
+std::optional<ProductVersion> ProductVersionFromSystemVersionPList() {
+  std::string plist_path = "/System/Library/CoreServices/SystemVersion.plist";
+#if FML_OS_IOS_SIMULATOR
+  char* plist_path_prefix = getenv("IPHONE_SIMULATOR_ROOT");
+  if (!plist_path_prefix) {
+    FML_DLOG(ERROR) << "Failed to getenv IPHONE_SIMULATOR_ROOT";
+    return std::nullopt;
+  }
+  plist_path = std::string(plist_path_prefix) + plist_path;
+#endif
+
+  auto plist_mapping = fml::FileMapping::CreateReadOnly(plist_path);
+
+  // Get the file buffer into CF's format. We pass in a null allocator here *
+  // because we free PListBuf ourselves
+  auto file_contents = fml::CFRef<CFDataRef>(CFDataCreateWithBytesNoCopy(
+      nullptr, plist_mapping->GetMapping(),
+      static_cast<CFIndex>(plist_mapping->GetSize()), kCFAllocatorNull));
+  if (!file_contents) {
+    FML_DLOG(ERROR) << "Failed to CFDataCreateWithBytesNoCopyFunc";
+    return std::nullopt;
+  }
+
+  auto plist = fml::CFRef<CFDictionaryRef>(
+      reinterpret_cast<CFDictionaryRef>(CFPropertyListCreateWithData(
+          nullptr, file_contents, CF_PROPERTY_LIST_IMMUTABLE, nullptr,
+          nullptr)));
+  if (!plist) {
+    FML_DLOG(ERROR) << "Failed to CFPropertyListCreateWithDataFunc or "
+                       "CFPropertyListCreateFromXMLDataFunc";
+    return std::nullopt;
+  }
+
+  auto product_version =
+      fml::CFRef<CFStringRef>(CFStringCreateWithCStringNoCopy(
+          nullptr, "ProductVersion", kCFStringEncodingASCII, kCFAllocatorNull));
+  if (!product_version) {
+    FML_DLOG(ERROR) << "Failed to CFStringCreateWithCStringNoCopyFunc";
+    return std::nullopt;
+  }
+  CFTypeRef opaque_value = CFDictionaryGetValue(plist, product_version);
+  if (!opaque_value || CFGetTypeID(opaque_value) != CFStringGetTypeID()) {
+    FML_DLOG(ERROR) << "Failed to CFDictionaryGetValueFunc";
+    return std::nullopt;
+  }
+
+  char version_str[32];
+  if (!CFStringGetCString(reinterpret_cast<CFStringRef>(opaque_value),
+                          version_str, sizeof(version_str),
+                          kCFStringEncodingUTF8)) {
+    FML_DLOG(ERROR) << "Failed to CFStringGetCStringFunc";
+    return std::nullopt;
+  }
+
+  ProductVersion version(0, 0, 0);
+  int matches = sscanf(version_str, "%d.%d.%d", &version.major, &version.minor,
+                       &version.subminor);
+  // A major version number is sufficient. The minor and subminor numbers might
+  // not be present.
+  if (matches < 1) {
+    FML_DLOG(ERROR) << "Failed to match product version string: "
+                    << version_str;
+    return std::nullopt;
+  }
+
+  return version;
+}
+
+}  // namespace flutter
 
 namespace {
 
+// The host's OS version when the dynamic lookup of _availability_version_check
+// has failed.
+static flutter::ProductVersion g_version;
+
 typedef uint32_t dyld_platform_t;
 
 typedef struct {
@@ -36,13 +145,50 @@ void InitializeAvailabilityCheck(void* unused) {
   }
   AvailabilityVersionCheck = reinterpret_cast<AvailabilityVersionCheckFn>(
       dlsym(RTLD_DEFAULT, "_availability_version_check"));
-  FML_CHECK(AvailabilityVersionCheck);
+  if (AvailabilityVersionCheck) {
+    return;
+  }
+
+  // If _availability_version_check can't be dynamically loaded, then version
+  // information must be parsed out of a system plist file.
+  auto product_version = flutter::ProductVersionFromSystemVersionPList();
+  if (product_version.has_value()) {
+    g_version = product_version.value();
+  } else {
+    // If reading version info out of the system plist file fails, then
+    // fall back to the minimum version that Flutter supports.
+    g_version.major = 11;
+    g_version.minor = 0;
+    g_version.subminor = 0;
+  }
 }
 
 extern "C" bool _availability_version_check(uint32_t count,
                                             dyld_build_version_t versions[]) {
   dispatch_once_f(&DispatchOnceCounter, NULL, InitializeAvailabilityCheck);
-  return AvailabilityVersionCheck(count, versions);
+  if (AvailabilityVersionCheck) {
+    return AvailabilityVersionCheck(count, versions);
+  }
+  // Parse the values out of versions, then compare against g_version.
+  // This function is called in only one place in the clang-rt implementation
+  // where there is only one element in the array.
+  const int32_t major = ((versions[0].version) >> 16) & 0xffff;
+  const int32_t minor = ((versions[0].version) >> 8) & 0xff;
+  const int32_t subminor = versions[0].version & 0xff;
+
+  if (major < g_version.major) {
+    return true;
+  }
+  if (major > g_version.major) {
+    return false;
+  }
+  if (minor < g_version.minor) {
+    return true;
+  }
+  if (minor > g_version.minor) {
+    return false;
+  }
+  return subminor <= g_version.subminor;
 }
 
 }  // namespace

shell/platform/darwin/common/availability_version_check.h

@@ -0,0 +1,22 @@
+// 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 <cstdint>
+#include <optional>
+
+namespace flutter {
+
+struct ProductVersion {
+  ProductVersion() = default;
+  ProductVersion(int32_t major, int32_t minor, int32_t subminor)
+      : major(major), minor(minor), subminor(subminor) {}
+
+  int32_t major;
+  int32_t minor;
+  int32_t subminor;
+};
+
+std::optional<ProductVersion> ProductVersionFromSystemVersionPList();
+
+}  // namespace flutter

shell/platform/darwin/common/availability_version_check_unittests.cc

@@ -0,0 +1,15 @@
+// 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/darwin/common/availability_version_check.h"
+
+#include "gtest/gtest.h"
+
+TEST(AvailabilityVersionCheck, CanDecodeSystemPlist) {
+  auto product_version = flutter::ProductVersionFromSystemVersionPList();
+  ASSERT_TRUE(product_version.has_value());
+  if (product_version.has_value()) {
+    ASSERT_GT(product_version.value().major, 0);
+  }
+}

shell/platform/darwin/ios/BUILD.gn

@@ -273,6 +273,7 @@ shared_library("ios_test_flutter") {
     "framework/Source/UIViewController_FlutterScreenAndSceneIfLoadedTest.mm",
     "framework/Source/VsyncWaiterIosTest.mm",
     "framework/Source/accessibility_bridge_test.mm",
+    "framework/Source/availability_version_check_test.mm",
     "framework/Source/connection_collection_test.mm",
     "platform_message_handler_ios_test.mm",
   ]

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

@@ -0,0 +1,23 @@
+// 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.
+
+#import <OCMock/OCMock.h>
+#import <XCTest/XCTest.h>
+
+#import "flutter/shell/platform/darwin/common/availability_version_check.h"
+
+@interface AvailabilityVersionCheckTest : XCTestCase
+@end
+
+@implementation AvailabilityVersionCheckTest
+
+- (void)testSimple {
+  auto product_version = flutter::ProductVersionFromSystemVersionPList();
+  XCTAssertTrue(product_version.has_value());
+  if (product_version.has_value()) {
+    XCTAssertTrue(product_version.value().major > 0);
+  }
+}
+
+@end

testing/run_tests.py

@@ -435,6 +435,7 @@ def make_test(name, flags=None, extra_env=None):
     unittests += [
         # The accessibility library only supports Mac and Windows.
         make_test('accessibility_unittests'),
+        make_test('availability_version_check_unittests'),
         make_test('framework_common_unittests'),
         make_test('spring_animation_unittests'),
         make_test('gpu_surface_metal_unittests'),