feat(ios)!: forward port to firebase-ios-sdk v7.3.0

remote-config debugMode is removed, use minimumFetchInterval instead

this should work on ios and android platforms

Author: mikehardy

packages/firebase_core/firebase_core/ios/firebase_sdk_version.rb

@@ -1,3 +1,3 @@
 def firebase_sdk_version!()
-  '6.33.0'
+  '7.3.0'
 end

packages/firebase_messaging/firebase_messaging/ios/Classes/FLTFirebaseMessagingPlugin.m

@@ -164,7 +164,7 @@ - (void)messagingSetForegroundNotificationPresentationOptions:(id)arguments
 #pragma mark - Firebase Messaging Delegate
 
 - (void)messaging:(nonnull FIRMessaging *)messaging
-    didReceiveRegistrationToken:(nonnull NSString *)fcmToken {
+    didReceiveRegistrationToken:(nullable NSString *)fcmToken {
   // Don't crash if the token is reset.
   if (fcmToken == nil) {
     return;

packages/firebase_ml_vision/example/ios/Podfile

@@ -37,7 +37,3 @@ post_install do |installer|
   end
 end
 
-pod 'Firebase/MLVisionBarcodeModel'
-pod 'Firebase/MLVisionFaceModel'
-pod 'Firebase/MLVisionLabelModel'
-pod 'Firebase/MLVisionTextModel'

packages/firebase_remote_config/android/src/main/java/io/flutter/plugins/firebase/firebaseremoteconfig/MethodCallHandlerImpl.java

@@ -42,18 +42,28 @@ public void onMethodCall(MethodCall call, final MethodChannel.Result result) {
           properties.put(
               "lastFetchStatus", mapLastFetchStatus(firebaseRemoteConfigInfo.getLastFetchStatus()));
           properties.put(
-              "inDebugMode", firebaseRemoteConfigInfo.getConfigSettings().isDeveloperModeEnabled());
+              "minimumFetchInterval",
+              firebaseRemoteConfigInfo.getConfigSettings().getMinimumFetchIntervalInSeconds());
+          properties.put(
+              "fetchTimeout",
+              firebaseRemoteConfigInfo.getConfigSettings().getFetchTimeoutInSeconds());
           properties.put("parameters", getConfigParameters());
           result.success(properties);
           break;
         }
       case "RemoteConfig#setConfigSettings":
         {
-          boolean debugMode = call.argument("debugMode");
           final FirebaseRemoteConfig firebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
-          FirebaseRemoteConfigSettings settings =
-              new FirebaseRemoteConfigSettings.Builder().setDeveloperModeEnabled(debugMode).build();
-          firebaseRemoteConfig.setConfigSettings(settings);
+          FirebaseRemoteConfigSettings.Builder configSettingsBuilder =
+              new FirebaseRemoteConfigSettings.Builder();
+          if (call.argument("minimumFetchInterval") != null) {
+            configSettingsBuilder.setMinimumFetchIntervalInSeconds(
+                (int) call.argument("minimumFetchInterval"));
+          }
+          if (call.argument("fetchTimeout") != null) {
+            configSettingsBuilder.setFetchTimeoutInSeconds((int) call.argument("fetchTimeout"));
+          }
+          firebaseRemoteConfig.setConfigSettingsAsync(configSettingsBuilder.build());
           result.success(null);
           break;
         }

packages/firebase_remote_config/example/lib/main.dart

@@ -57,8 +57,9 @@ class WelcomeWidget extends AnimatedWidget {
 Future<RemoteConfig> setupRemoteConfig() async {
   await Firebase.initializeApp();
   final RemoteConfig remoteConfig = await RemoteConfig.instance;
-  // Enable developer mode to relax fetch throttling
-  remoteConfig.setConfigSettings(RemoteConfigSettings(debugMode: true));
+  // Allow a fetch every millisecond. Default is 12 hours.
+  remoteConfig
+      .setConfigSettings(RemoteConfigSettings(minimumFetchIntervalMillis: 1));
   remoteConfig.setDefaults(<String, dynamic>{
     'welcome': 'default welcome',
     'hello': 'default hello',

packages/firebase_remote_config/example/test_driver/firebase_remote_config_e2e.dart

@@ -12,8 +12,9 @@ void main() {
     setUp(() async {
       await Firebase.initializeApp();
       remoteConfig = await RemoteConfig.instance;
-      await remoteConfig
-          .setConfigSettings(RemoteConfigSettings(debugMode: true));
+      // Set our config to no minimum fetch interval so that settings change immediately
+      await remoteConfig.setConfigSettings(RemoteConfigSettings(
+          minimumFetchIntervalMillis: 0, fetchTimeoutMillis: 30 * 1000));
       await remoteConfig.setDefaults(<String, dynamic>{
         'welcome': 'default welcome',
         'hello': 'default hello',
@@ -25,14 +26,18 @@ void main() {
       expect(lastFetchTime.isBefore(DateTime.now()), true);
       await remoteConfig.fetch(expiration: const Duration(seconds: 0));
       expect(remoteConfig.lastFetchStatus, LastFetchStatus.success);
-      await remoteConfig.activateFetched();
+      final activated = await remoteConfig.activateFetched();
+      expect(activated, true);
 
+      // TODO should verify that our config settings actually took
       expect(remoteConfig.getString('welcome'), 'Earth, welcome! Hello!');
+      expect(remoteConfig.getValue('welcome').source, ValueSource.valueRemote);
+
       expect(remoteConfig.getString('hello'), 'default hello');
+      expect(remoteConfig.getValue('hello').source, ValueSource.valueDefault);
+
       expect(remoteConfig.getInt('nonexisting'), 0);
 
-      expect(remoteConfig.getValue('welcome').source, ValueSource.valueRemote);
-      expect(remoteConfig.getValue('hello').source, ValueSource.valueDefault);
       expect(
         remoteConfig.getValue('nonexisting').source,
         ValueSource.valueStatic,

packages/firebase_remote_config/ios/Classes/FirebaseRemoteConfigPlugin.m

@@ -40,17 +40,24 @@ - (void)handleMethodCall:(FlutterMethodCall *)call result:(FlutterResult)result
         initWithLong:(long)[[remoteConfig lastFetchTime] timeIntervalSince1970] * 1000];
     resultDict[@"lastFetchStatus"] =
         [self mapLastFetchStatus:(FIRRemoteConfigFetchStatus)[remoteConfig lastFetchStatus]];
-    resultDict[@"inDebugMode"] =
-        [[NSNumber alloc] initWithBool:[firRemoteConfigSettings isDeveloperModeEnabled]];
+    resultDict[@"minimumFetchInterval"] =
+        [[NSNumber alloc] initWithLong:(long)[firRemoteConfigSettings minimumFetchInterval]];
+    resultDict[@"fetchTimeout"] =
+        [[NSNumber alloc] initWithLong:(long)[firRemoteConfigSettings fetchTimeout]];
 
     resultDict[@"parameters"] = [self getConfigParameters];
 
     result(resultDict);
   } else if ([@"RemoteConfig#setConfigSettings" isEqualToString:call.method]) {
     FIRRemoteConfig *remoteConfig = [FIRRemoteConfig remoteConfig];
-    bool debugMode = (bool)call.arguments[@"debugMode"];
-    FIRRemoteConfigSettings *remoteConfigSettings =
-        [[FIRRemoteConfigSettings alloc] initWithDeveloperModeEnabled:debugMode];
+    FIRRemoteConfigSettings *remoteConfigSettings = [[FIRRemoteConfigSettings alloc] init];
+    if ([call.arguments objectForKey:@"minimumFetchInterval"]) {
+      remoteConfigSettings.minimumFetchInterval =
+          [call.arguments[@"minimumFetchInterval"] longValue];
+    }
+    if ([call.arguments objectForKey:@"fetchTimeout"]) {
+      remoteConfigSettings.fetchTimeout = [call.arguments[@"fetchTimeout"] longValue];
+    }
     [remoteConfig setConfigSettings:remoteConfigSettings];
     result(nil);
   } else if ([@"RemoteConfig#fetch" isEqualToString:call.method]) {
@@ -97,12 +104,37 @@ - (void)handleMethodCall:(FlutterMethodCall *)call result:(FlutterResult)result
                     }
                   }];
   } else if ([@"RemoteConfig#activate" isEqualToString:call.method]) {
-    BOOL newConfig = [[FIRRemoteConfig remoteConfig] activateFetched];
-    NSDictionary *parameters = [self getConfigParameters];
-    NSMutableDictionary *resultDict = [[NSMutableDictionary alloc] init];
-    resultDict[@"newConfig"] = [NSNumber numberWithBool:newConfig];
-    resultDict[@"parameters"] = parameters;
-    result(resultDict);
+    [[FIRRemoteConfig remoteConfig]
+        activateWithCompletion:^(BOOL changed, NSError *_Nullable error) {
+          BOOL newConfig = YES;
+
+          // If the config was already activated, we get an error from the SDK.
+          // Our goal is to map that specific error to a normal return with "false" for newConfig
+          // All other errors are rethrown as actual errors.
+          if (error) {
+            NSString *failureReason = @"";
+            if (error.userInfo && error.userInfo[@"ActivationFailureReason"] != nil) {
+              failureReason = error.userInfo[@"ActivationFailureReason"];
+            }
+            if ([failureReason containsString:@"already activated"]) {
+              newConfig = NO;
+            } else {
+              FlutterError *flutterError;
+              flutterError = [FlutterError errorWithCode:@"activateFailed"
+                                                 message:failureReason
+                                                 details:nil];
+              result(flutterError);
+              return;
+            }
+          }
+
+          // If no real error, return all configs with boolean indicating if newly activated
+          NSDictionary *parameters = [self getConfigParameters];
+          NSMutableDictionary *resultDict = [[NSMutableDictionary alloc] init];
+          resultDict[@"newConfig"] = [NSNumber numberWithBool:newConfig];
+          resultDict[@"parameters"] = parameters;
+          result(resultDict);
+        }];
   } else if ([@"RemoteConfig#setDefaults" isEqualToString:call.method]) {
     FIRRemoteConfig *remoteConfig = [FIRRemoteConfig remoteConfig];
     NSDictionary *defaults = call.arguments[@"defaults"];
@@ -128,8 +160,7 @@ - (NSDictionary *)getConfigParameters {
     parameterDict[key] = [self createRemoteConfigValueDict:[remoteConfig configValueForKey:key]];
   }
   // Add default parameters if missing since `keysWithPrefix` does not return default keys.
-  NSArray *defaultKeys = [remoteConfig allKeysFromSource:FIRRemoteConfigSourceDefault
-                                               namespace:FIRNamespaceGoogleMobilePlatform];
+  NSArray *defaultKeys = [remoteConfig allKeysFromSource:FIRRemoteConfigSourceDefault];
   for (NSString *key in defaultKeys) {
     if ([parameterDict valueForKey:key] == nil) {
       parameterDict[key] = [self createRemoteConfigValueDict:[remoteConfig configValueForKey:key]];

packages/firebase_remote_config/lib/src/remote_config.dart

@@ -48,8 +48,9 @@ class RemoteConfig extends ChangeNotifier {
         DateTime.fromMillisecondsSinceEpoch(properties['lastFetchTime']);
     instance._lastFetchStatus =
         _parseLastFetchStatus(properties['lastFetchStatus']);
-    final RemoteConfigSettings remoteConfigSettings =
-        RemoteConfigSettings(debugMode: properties['inDebugMode']);
+    final RemoteConfigSettings remoteConfigSettings = RemoteConfigSettings(
+        minimumFetchIntervalMillis: (properties['minimumFetchInterval'] * 1000),
+        fetchTimeoutMillis: (properties['fetchTimeout'] * 1000));
     instance._remoteConfigSettings = remoteConfigSettings;
     instance._parameters =
         _parseRemoteConfigParameters(parameters: properties['parameters']);
@@ -99,12 +100,14 @@ class RemoteConfig extends ChangeNotifier {
 
   /// Set the configuration settings for this [RemoteConfig] instance.
   ///
-  /// This can be used for enabling developer mode.
+  /// This can be used to set minimum fetch time and fetch timeout.
   Future<void> setConfigSettings(
       RemoteConfigSettings remoteConfigSettings) async {
     await channel
         .invokeMethod<void>('RemoteConfig#setConfigSettings', <String, dynamic>{
-      'debugMode': remoteConfigSettings.debugMode,
+      'minimumFetchInterval':
+          (remoteConfigSettings.minimumFetchIntervalMillis ~/ 1000),
+      'fetchTimeout': (remoteConfigSettings.fetchTimeoutMillis ~/ 1000)
     });
     _remoteConfigSettings = remoteConfigSettings;
   }

packages/firebase_remote_config/lib/src/remote_config_settings.dart

@@ -6,13 +6,20 @@ part of firebase_remote_config;
 
 /// RemoteConfigSettings can be used to configure how Remote Config operates.
 class RemoteConfigSettings {
-  RemoteConfigSettings({this.debugMode = false});
+  RemoteConfigSettings(
+      {this.minimumFetchIntervalMillis = 43200000,
+      this.fetchTimeoutMillis = 60000});
 
-  /// Enable or disable developer mode for Remote Config.
+  /// Set the minimum fetch interval for Remote Config, in milliseconds
   ///
-  /// When set to true developer mode is enabled, when set to false developer
-  /// mode is disabled. When developer mode is enabled fetch throttling is
-  /// relaxed to allow many more fetch calls per hour to the remote server than
-  /// the 5 per hour that is enforced when developer mode is disabled.
-  final bool debugMode;
+  /// Indicates the default value in milliseconds to set for the minimum
+  /// interval that needs to elapse before a fetch request can again be made
+  /// to the Remote Config server. Defaults to 43200000 (Twelve hours).
+  final int minimumFetchIntervalMillis;
+
+  /// Set the fetch timeout for Remote Config, in milliseconds
+  ///
+  /// Indicates the default value in milliseconds to abandon a pending fetch
+  /// request made to the Remote Config server. Defaults to 60000 (One minute).
+  final int fetchTimeoutMillis;
 }

packages/firebase_remote_config/test/firebase_remote_config_test.dart

@@ -14,7 +14,8 @@ void main() {
     return <String, dynamic>{
       'lastFetchTime': lastFetchTime,
       'lastFetchStatus': 'success',
-      'inDebugMode': true,
+      'minimumFetchInterval': 0, // 12 hours is default, 0 seconds in test
+      'fetchTimeout': 60, // 60 seconds is remote-config default
       'parameters': <String, dynamic>{
         'param1': <String, dynamic>{
           'source': 'static',
@@ -48,7 +49,8 @@ void main() {
           isMethodCall('RemoteConfig#instance', arguments: null),
         ],
       );
-      expect(remoteConfig.remoteConfigSettings.debugMode, true);
+      expect(remoteConfig.remoteConfigSettings.minimumFetchIntervalMillis, 0);
+      expect(remoteConfig.remoteConfigSettings.fetchTimeoutMillis, 60 * 1000);
       expect(remoteConfig.lastFetchTime,
           DateTime.fromMillisecondsSinceEpoch(lastFetchTime));
       expect(remoteConfig.lastFetchStatus, LastFetchStatus.values[0]);
@@ -218,22 +220,27 @@ void main() {
     });
 
     test('setConfigSettings', () async {
-      expect(remoteConfig.remoteConfigSettings.debugMode, true);
+      var intervalSecs = 100;
+      expect(remoteConfig.remoteConfigSettings.minimumFetchIntervalMillis, 0);
       final RemoteConfigSettings remoteConfigSettings =
-          RemoteConfigSettings(debugMode: false);
+          // milliseconds in the Dart API (to match firebase-js-sdk)
+          RemoteConfigSettings(minimumFetchIntervalMillis: intervalSecs * 1000);
       await remoteConfig.setConfigSettings(remoteConfigSettings);
       expect(
         log,
         <Matcher>[
           isMethodCall(
             'RemoteConfig#setConfigSettings',
             arguments: <String, dynamic>{
-              'debugMode': false,
+              // milliseconds in Dart API, but just seconds for native ios/android
+              'minimumFetchInterval': intervalSecs,
+              'fetchTimeout': 60, // from our mock instance above
             },
           ),
         ],
       );
-      expect(remoteConfig.remoteConfigSettings.debugMode, false);
+      expect(remoteConfig.remoteConfigSettings.minimumFetchIntervalMillis,
+          intervalSecs * 1000);
     });
   });
 }