ios – Property ‘utmParametersDictionary’ not discovered on object of sort ‘FIRDynamicLink *’

Semantic Subject (Xcode): Property ‘utmParametersDictionary’ not discovered on object of sort ‘FIRDynamicLink *’
/Customers/jeremydormevil/.pub-cache/hosted/pub.dartlang.org/firebase_dynamic_links-4.1.1/ios/Courses/FLTFirebaseDynamicLinksPlugin.m:26:47
When i have a look into the code, the issue appear to got here from this line :

dictionary[@"utmParameters"] = dynamicLink.utmParametersDictionary;

CODE:

// Copyright 2021 The Chromium Authors. All rights reserved.
// Use of this supply code is ruled by a BSD-style license that may be
// discovered within the LICENSE file.
#import <Firebase/Firebase.h>
#import <TargetConditionals.h>
#import <firebase_core/FLTFirebasePluginRegistry.h>

#import "FLTFirebaseDynamicLinksPlugin.h"

NSString *const kFLTFirebaseDynamicLinksChannelName = @"plugins.flutter.io/firebase_dynamic_links";
NSString *const kDLAppName = @"appName";
NSString *const kUrl = @"url";
NSString *const kCode = @"code";
NSString *const kMessage = @"message";
NSString *const kDynamicLinkParametersOptions = @"dynamicLinkParametersOptions";
NSString *const kDefaultAppName = @"[DEFAULT]";

static NSMutableDictionary *getDictionaryFromDynamicLink(FIRDynamicLink *dynamicLink) {
  if (dynamicLink != nil) {
    NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];
    dictionary[@"link"] = dynamicLink.url.absoluteString;

    NSMutableDictionary *iosData = [[NSMutableDictionary alloc] init];
    if (dynamicLink.minimumAppVersion) {
      iosData[@"minimumVersion"] = dynamicLink.minimumAppVersion;
    }
    dictionary[@"utmParameters"] = dynamicLink.utmParametersDictionary;
    dictionary[@"ios"] = iosData;
    return dictionary;
  } else {
    return nil;
  }
}

static NSDictionary *getDictionaryFromNSError(NSError *error) {
  NSString *code = @"unknown";
  NSString *message = @"An unknown error has occurred.";
  if (error == nil) {
    return @{
      kCode : code,
      kMessage : message,
      @"additionalData" : @{},
    };
  }

  NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];
  dictionary[kCode] = [NSString stringWithFormat:@"%d", (int)error.code];
  dictionary[kMessage] = [error localizedDescription];
  id additionalData = [NSMutableDictionary dictionary];

  if ([error userInfo] != nil) {
    additionalData = [error userInfo];
  }

  return @{
    kCode : code,
    kMessage : message,
    @"additionalData" : additionalData,
  };
}

@implementation FLTFirebaseDynamicLinksPlugin {
  NSObject<FlutterBinaryMessenger> *_binaryMessenger;
}

#pragma mark - FlutterPlugin

- (instancetype)init:(NSObject<FlutterBinaryMessenger> *)messenger
         withChannel:(FlutterMethodChannel *)channel {
  self = [super init];
  if (self) {
    [[FLTFirebasePluginRegistry sharedInstance] registerFirebasePlugin:self];
    _binaryMessenger = messenger;
    _channel = channel;
  }
  return self;
}
+ (void)registerWithRegistrar:(NSObject<FlutterPluginRegistrar> *)registrar {
  FlutterMethodChannel *channel =
      [FlutterMethodChannel methodChannelWithName:kFLTFirebaseDynamicLinksChannelName
                                  binaryMessenger:[registrar messenger]];
  FLTFirebaseDynamicLinksPlugin *occasion =
      [[FLTFirebaseDynamicLinksPlugin alloc] init:registrar.messenger withChannel:channel];

  [registrar addMethodCallDelegate:instance channel:channel];

#if TARGET_OS_OSX
  // Publish doesn't exist on MacOS model of FlutterPluginRegistrar.
  // FlutterPluginRegistrar. (https://github.com/flutter/flutter/points/41471)
#else
  [registrar publish:instance];
  [registrar addApplicationDelegate:instance];
#endif
}

- (void)cleanupWithCompletion:(void (^)(void))completion {
  if (completion != nil) completion();
}

- (void)detachFromEngineForRegistrar:(NSObject<FlutterPluginRegistrar> *)registrar {
  [self cleanupWithCompletion:nil];
}

- (void)handleMethodCall:(FlutterMethodCall *)name outcome:(FlutterResult)outcome {
  FLTFirebaseMethodCallErrorBlock errorBlock = ^(
      NSString *_Nullable code, NSString *_Nullable message, NSDictionary *_Nullable particulars,
      NSError *_Nullable error) {
    if (code == nil) {
      NSDictionary *errorDetails = getDictionaryFromNSError(error);
      code = errorDetails[kCode];
      message = errorDetails[kMessage];
      particulars = errorDetails;
    } else {
      particulars = @{
        kCode : code,
        kMessage : message,
        @"additionalData" : @{},
      };
    }

    if ([@"unknown" isEqualToString:code]) {
      NSLog(@"FLTFirebaseDynamicLinks: An error occurred whereas calling methodology %@, errorOrNil => %@",
            name.methodology, [error userInfo]);
    }

    outcome([FLTFirebasePlugin createFlutterErrorFromCode:code
                                                 message:message
                                         optionalDetails:details
                                      andOptionalNSError:error]);
  };

  FLTFirebaseMethodCallResult *methodCallResult =
      [FLTFirebaseMethodCallResult createWithSuccess:result andErrorBlock:errorBlock];

  NSString *appName = name.arguments[kDLAppName];
  if (appName != nil && ![appName isEqualToString:kDefaultAppName]) {
    // TODO - doc iOS default app solely
    NSLog(@"FLTFirebaseDynamicLinks: iOS plugin solely helps the Firebase default app");
  }

  if ([@"FirebaseDynamicLinks#buildLink" isEqualToString:call.method]) {
    [self buildLink:call.arguments withMethodCallResult:methodCallResult];
  } else if ([@"FirebaseDynamicLinks#buildShortLink" isEqualToString:call.method]) {
    [self buildShortLink:call.arguments withMethodCallResult:methodCallResult];
  } else if ([@"FirebaseDynamicLinks#getInitialLink" isEqualToString:call.method]) {
    [self getInitialLink:methodCallResult];
  } else if ([@"FirebaseDynamicLinks#getDynamicLink" isEqualToString:call.method]) {
    [self getDynamicLink:call.arguments withMethodCallResult:methodCallResult];
  } else {
    outcome(FlutterMethodNotImplemented);
  }
}

#pragma mark - Firebase Dynamic Hyperlinks API

- (void)buildLink:(id)arguments withMethodCallResult:(FLTFirebaseMethodCallResult *)outcome {
  FIRDynamicLinkComponents *elements = [self setupParameters:arguments];
  outcome.success([components.url absoluteString]);
}

- (void)buildShortLink:(id)arguments withMethodCallResult:(FLTFirebaseMethodCallResult *)outcome {
  FIRDynamicLinkComponentsOptions *choices = [self setupOptions:arguments];
  NSString *longDynamicLink = arguments[@"longDynamicLink"];

  if (longDynamicLink != nil) {
    NSURL *url = [NSURL URLWithString:longDynamicLink];
    [FIRDynamicLinkComponents
        shortenURL:url
           options:options
        completion:^(NSURL *_Nullable shortURL, NSArray<NSString *> *_Nullable warnings,
                     NSError *_Nullable error) {
          if (error != nil) {
            result.error(nil, nil, nil, error);
          } else {
            if (warnings == nil) {
              warnings = [NSMutableArray array];
            }

            outcome.success(@{
              kUrl : [shortURL absoluteString],
              @"warnings" : warnings,
            });
          }
        }];
  } else {
    FIRDynamicLinkComponents *elements = [self setupParameters:arguments];
    elements.choices = choices;
    [components
        shortenWithCompletion:^(NSURL *_Nullable shortURL, NSArray<NSString *> *_Nullable warnings,
                                NSError *_Nullable error) {
          if (error != nil) {
            result.error(nil, nil, nil, error);
          } else {
            if (warnings == nil) {
              warnings = [NSMutableArray array];
            }

            outcome.success(@{
              kUrl : [shortURL absoluteString],
              @"warnings" : warnings,
            });
          }
        }];
  }
}

- (void)getInitialLink:(FLTFirebaseMethodCallResult *)outcome {
  _initiated = YES;
  NSMutableDictionary *dict = getDictionaryFromDynamicLink(_initialLink);
  if (dict == nil && self.initialError != nil) {
    outcome.error(nil, nil, nil, self.initialError);
  } else {
    outcome.success(dict);
  }
}

- (void)getDynamicLink:(id)arguments withMethodCallResult:(FLTFirebaseMethodCallResult *)outcome {
  NSURL *shortLink = [NSURL URLWithString:arguments[kUrl]];
  FIRDynamicLinkUniversalLinkHandler completion =
      ^(FIRDynamicLink *_Nullable dynamicLink, NSError *_Nullable error) {
        if (error) {
          outcome.error(nil, nil, nil, error);
        } else {
          outcome.success(getDictionaryFromDynamicLink(dynamicLink));
        }
      };
  [[FIRDynamicLinks dynamicLinks] handleUniversalLink:shortLink completion:completion];
}

#pragma mark - AppDelegate
// Deal with hyperlinks obtained by way of your app's customized URL scheme. Referred to as when your
// app receives a hyperlink and your app is opened for the primary time after set up.
- (BOOL)software:(UIApplication *)software
            openURL:(NSURL *)url
            choices:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)choices {
  [self checkForDynamicLink:url];
  // Outcomes of this are ORed and NO does not have an effect on different delegate interceptors' outcome.
  return NO;
}

// Deal with hyperlinks obtained as Common Hyperlinks when the app is already put in (on iOS 9 and newer).
- (BOOL)software:(UIApplication *)software
    continueUserActivity:(NSUserActivity *)userActivity
      restorationHandler:(nonnull void (^)(NSArray *_Nullable))restorationHandler {
  __block BOOL retried = NO;
  void (^completionBlock)(FIRDynamicLink *_Nullable dynamicLink, NSError *_Nullable error);

  void (^__block __weak weakCompletionBlock)(FIRDynamicLink *_Nullable dynamicLink,
                                             NSError *_Nullable error);
  weakCompletionBlock = completionBlock =
      ^(FIRDynamicLink *_Nullable dynamicLink, NSError *_Nullable error) {
        if (!error && dynamicLink && dynamicLink.url) {
          [self onDeepLinkResult:dynamicLink error:nil];
        }

        if (!error && dynamicLink && !dynamicLink.url) {
          NSLog(@"FLTFirebaseDynamicLinks: The url has not been equipped with the dynamic hyperlink."
                @"Please attempt opening your app with the lengthy dynamic hyperlink to see if that works");
        }
        // Per Apple Tech Assist, a community failure may happen when getting back from background on
        // iOS 12. https://github.com/AFNetworking/AFNetworking/points/4279#issuecomment-447108981
        // So we'll retry the request as soon as
        if (error && !retried && [NSPOSIXErrorDomain isEqualToString:error.domain] &&
            error.code == 53) {
          retried = YES;
          [[FIRDynamicLinks dynamicLinks] handleUniversalLink:userActivity.webpageURL
                                                   completion:weakCompletionBlock];
        }

        if (error && retried) {
          // Have to replace any occasion channel the common hyperlink failed
          [self onDeepLinkResult:nil error:error];
        }
      };

  [[FIRDynamicLinks dynamicLinks] handleUniversalLink:userActivity.webpageURL
                                           completion:completionBlock];

  // Outcomes of this are ORed and NO does not have an effect on different delegate interceptors' outcome.
  return NO;
}

#pragma mark - Utilities

- (void)checkForDynamicLink:(NSURL *)url {
  FIRDynamicLink *dynamicLink = [[FIRDynamicLinks dynamicLinks] dynamicLinkFromCustomSchemeURL:url];
  if (dynamicLink) {
    [self onDeepLinkResult:dynamicLink error:nil];
  }
}

// Used to motion occasions from firebase-ios-sdk customized & common dynamic hyperlink occasion listeners
- (void)onDeepLinkResult:(FIRDynamicLink *_Nullable)dynamicLink error:(NSError *_Nullable)error {
  if (error) {
    if (_initialLink == nil) {
      // retailer preliminary error to move again to consumer if getInitialLink known as
      _initialError = error;
    }

    NSDictionary *errorDetails = getDictionaryFromNSError(error);

    FlutterError *flutterError =
        [FLTFirebasePlugin createFlutterErrorFromCode:errorDetails[kCode]
                                              message:errorDetails[kMessage]
                                      optionalDetails:errorDetails
                                   andOptionalNSError:error];

    NSLog(@"FLTFirebaseDynamicLinks: Unknown error occurred when trying to deal with a dynamic "
          @"hyperlink: %@",
          flutterError);

    [_channel invokeMethod:@"FirebaseDynamicLink#onLinkError" arguments:flutterError];
  } else {
    NSMutableDictionary *dictionary = getDictionaryFromDynamicLink(dynamicLink);
    if (dictionary != nil) {
      [_channel invokeMethod:@"FirebaseDynamicLink#onLinkSuccess" arguments:dictionary];
    }
  }

  if (_initialLink == nil && dynamicLink.url != nil) {
    _initialLink = dynamicLink;
  }

  if (dynamicLink.url != nil) {
    _latestLink = dynamicLink;
  }
}

- (FIRDynamicLinkComponentsOptions *)setupOptions:(NSDictionary *)arguments {
  FIRDynamicLinkComponentsOptions *choices = [FIRDynamicLinkComponentsOptions options];

  NSNumber *shortDynamicLinkPathLength = arguments[@"shortLinkType"];
  if (![shortDynamicLinkPathLength isEqual:[NSNull null]]) {
    change (shortDynamicLinkPathLength.intValue) {
      case 0:
        choices.pathLength = FIRShortDynamicLinkPathLengthUnguessable;
        break;
      case 1:
        choices.pathLength = FIRShortDynamicLinkPathLengthShort;
        break;
      default:
        break;
    }
  }

  return choices;
}

- (FIRDynamicLinkComponents *)setupParameters:(NSDictionary *)arguments {
  NSURL *hyperlink = [NSURL URLWithString:arguments[@"link"]];
  NSString *uriPrefix = arguments[@"uriPrefix"];

  FIRDynamicLinkComponents *elements = [FIRDynamicLinkComponents componentsWithLink:link
                                                                      domainURIPrefix:uriPrefix];

  if (![arguments[@"androidParameters"] isEqual:[NSNull null]]) {
    NSDictionary *params = arguments[@"androidParameters"];

    FIRDynamicLinkAndroidParameters *androidParams =
        [FIRDynamicLinkAndroidParameters parametersWithPackageName:params[@"packageName"]];

    NSString *fallbackUrl = params[@"fallbackUrl"];
    NSNumber *minimumVersion = params[@"minimumVersion"];

    if (![fallbackUrl isEqual:[NSNull null]])
      androidParams.fallbackURL = [NSURL URLWithString:fallbackUrl];
    if (![minimumVersion isEqual:[NSNull null]])
      androidParams.minimumVersion = ((NSNumber *)minimumVersion).integerValue;

    elements.androidParameters = androidParams;
  }

  elements.choices = [self setupOptions:arguments];

  if (![arguments[@"googleAnalyticsParameters"] isEqual:[NSNull null]]) {
    NSDictionary *params = arguments[@"googleAnalyticsParameters"];

    FIRDynamicLinkGoogleAnalyticsParameters *googleAnalyticsParameters =
        [FIRDynamicLinkGoogleAnalyticsParameters parameters];

    NSString *marketing campaign = params[@"campaign"];
    NSString *content material = params[@"content"];
    NSString *medium = params[@"medium"];
    NSString *supply = params[@"source"];
    NSString *time period = params[@"term"];

    if (![campaign isEqual:[NSNull null]]) googleAnalyticsParameters.marketing campaign = marketing campaign;
    if (![content isEqual:[NSNull null]]) googleAnalyticsParameters.content material = content material;
    if (![medium isEqual:[NSNull null]]) googleAnalyticsParameters.medium = medium;
    if (![source isEqual:[NSNull null]]) googleAnalyticsParameters.supply = supply;
    if (![term isEqual:[NSNull null]]) googleAnalyticsParameters.time period = time period;

    elements.analyticsParameters = googleAnalyticsParameters;
  }

  if (![arguments[@"iosParameters"] isEqual:[NSNull null]]) {
    NSDictionary *params = arguments[@"iosParameters"];

    FIRDynamicLinkIOSParameters *iosParameters =
        [FIRDynamicLinkIOSParameters parametersWithBundleID:params[@"bundleId"]];

    NSString *appStoreID = params[@"appStoreId"];
    NSString *customScheme = params[@"customScheme"];
    NSString *fallbackURL = params[@"fallbackUrl"];
    NSString *iPadBundleID = params[@"ipadBundleId"];
    NSString *iPadFallbackURL = params[@"ipadFallbackUrl"];
    NSString *minimumAppVersion = params[@"minimumVersion"];

    if (![appStoreID isEqual:[NSNull null]]) iosParameters.appStoreID = appStoreID;
    if (![customScheme isEqual:[NSNull null]]) iosParameters.customScheme = customScheme;
    if (![fallbackURL isEqual:[NSNull null]])
      iosParameters.fallbackURL = [NSURL URLWithString:fallbackURL];
    if (![iPadBundleID isEqual:[NSNull null]]) iosParameters.iPadBundleID = iPadBundleID;
    if (![iPadFallbackURL isEqual:[NSNull null]])
      iosParameters.iPadFallbackURL = [NSURL URLWithString:iPadFallbackURL];
    if (![minimumAppVersion isEqual:[NSNull null]])
      iosParameters.minimumAppVersion = minimumAppVersion;

    elements.iOSParameters = iosParameters;
  }

  if (![arguments[@"itunesConnectAnalyticsParameters"] isEqual:[NSNull null]]) {
    NSDictionary *params = arguments[@"itunesConnectAnalyticsParameters"];

    FIRDynamicLinkItunesConnectAnalyticsParameters *itunesConnectAnalyticsParameters =
        [FIRDynamicLinkItunesConnectAnalyticsParameters parameters];

    NSString *affiliateToken = params[@"affiliateToken"];
    NSString *campaignToken = params[@"campaignToken"];
    NSString *providerToken = params[@"providerToken"];

    if (![affiliateToken isEqual:[NSNull null]])
      itunesConnectAnalyticsParameters.affiliateToken = affiliateToken;
    if (![campaignToken isEqual:[NSNull null]])
      itunesConnectAnalyticsParameters.campaignToken = campaignToken;
    if (![providerToken isEqual:[NSNull null]])
      itunesConnectAnalyticsParameters.providerToken = providerToken;

    elements.iTunesConnectParameters = itunesConnectAnalyticsParameters;
  }

  if (![arguments[@"navigationInfoParameters"] isEqual:[NSNull null]]) {
    NSDictionary *params = arguments[@"navigationInfoParameters"];

    FIRDynamicLinkNavigationInfoParameters *navigationInfoParameters =
        [FIRDynamicLinkNavigationInfoParameters parameters];

    NSNumber *forcedRedirectEnabled = params[@"forcedRedirectEnabled"];
    if (![forcedRedirectEnabled isEqual:[NSNull null]])
      navigationInfoParameters.forcedRedirectEnabled = [forcedRedirectEnabled boolValue];

    elements.navigationInfoParameters = navigationInfoParameters;
  }

  if (![arguments[@"socialMetaTagParameters"] isEqual:[NSNull null]]) {
    NSDictionary *params = arguments[@"socialMetaTagParameters"];

    FIRDynamicLinkSocialMetaTagParameters *socialMetaTagParameters =
        [FIRDynamicLinkSocialMetaTagParameters parameters];

    NSString *descriptionText = params[@"description"];
    NSString *imageURL = params[@"imageUrl"];
    NSString *title = params[@"title"];

    if (![descriptionText isEqual:[NSNull null]])
      socialMetaTagParameters.descriptionText = descriptionText;
    if (![imageURL isEqual:[NSNull null]])
      socialMetaTagParameters.imageURL = [NSURL URLWithString:imageURL];
    if (![title isEqual:[NSNull null]]) socialMetaTagParameters.title = title;

    elements.socialMetaTagParameters = socialMetaTagParameters;
  }

  return elements;
}

#pragma mark - FLTFirebasePlugin

- (void)didReinitializeFirebaseCore:(void (^)(void))completion {
  [self cleanupWithCompletion:completion];
}

- (NSDictionary *_Nonnull)pluginConstantsForFIRApp:(FIRApp *)firebase_app {
  return @{};
}

- (NSString *_Nonnull)firebaseLibraryName {
  return LIBRARY_NAME;
}

- (NSString *_Nonnull)firebaseLibraryVersion {
  return LIBRARY_VERSION;
}

- (NSString *_Nonnull)flutterChannelName {
  return kFLTFirebaseDynamicLinksChannelName;
}

@finish

Can somebody assist me ? Thanks prematurely.