initializationQueue.sync()

in AWSAuthSDK/Sources/AWSMobileClient/AWSMobileClient.swift [224:352]
108 lines of code
22 McCabe index (conditional complexity)

        initializationQueue.sync {
            
            if (operateInLegacyMode) {
                completionHandler(nil, AWSMobileClientError.invalidState(message: "The AWSMobileClient is being used in the legacy mode. To use this initialize method please refer to the documentation."))
                return
            }
            
            if (isInitialized) {
                completionHandler(self.currentUserState, nil)
                return
            }
            
            self.loadLoginsMapFromKeychain()
            // Updated logic to determine federation provider from keychain.
            self.loadFederationProviderMetadataFromKeychain()
            
            DeviceOperations.sharedInstance.mobileClient = self
            
            // legacy fallback logic to determine federation provider for AWSMobileClient
            if self.federationProvider == .none && self.cachedLoginsMap.count > 0 {
                if self.userPoolClient?.currentUser()?.isSignedIn == true {
                    self.federationProvider = .userPools
                } else {
                    self.federationProvider = .oidcFederation
                }
            }
            
            if self.federationProvider == .hostedUI {
                loadHostedUIScopesFromKeychain()
                loadOAuthURIQueryParametersFromKeychain()
                
                let infoDictionaryMobileClient = self.awsInfo.rootInfoDictionary["Auth"] as? [String: [String: Any]]
                let infoDictionary: [String: Any]? = infoDictionaryMobileClient?["Default"]?["OAuth"] as? [String: Any]
                
                let clientId = infoDictionary?["AppClientId"] as? String
                let secret = infoDictionary?["AppClientSecret"] as? String
                let webDomain = infoDictionary?["WebDomain"] as? String
                let hostURL = "https://\(webDomain!)"
                
                if self.scopes == nil {
                    self.scopes = infoDictionary?["Scopes"] as? [String]
                }
                
                let signInRedirectURI = infoDictionary?["SignInRedirectURI"] as? String
                let signInURI = infoDictionary?["SignInURI"] as? String
                if self.signInURIQueryParameters == nil {
                    self.signInURIQueryParameters = infoDictionary?["SignInURIQueryParameters"] as? [String: String]
                }
                
                let signOutRedirectURI = infoDictionary?["SignOutRedirectURI"] as? String
                let signOutURI = infoDictionary?["SignOutURI"] as? String
                if self.signOutURIQueryParameters == nil {
                    self.signOutURIQueryParameters = infoDictionary?["SignOutURIQueryParameters"] as? [String: String]
                }
                
                let tokensURI = infoDictionary?["TokenURI"] as? String
                if self.tokenURIQueryParameters == nil {
                    self.tokenURIQueryParameters = infoDictionary?["TokenURIQueryParameters"] as? [String: String]
                }
                
                if (clientId == nil || scopes == nil || signInRedirectURI == nil || signOutRedirectURI == nil) {
                    completionHandler(nil, AWSMobileClientError.invalidConfiguration(message: "Please provide all configuration parameters to use the hosted UI feature."))
                }
                
                let cognitoAuthConfig = AWSCognitoAuthConfiguration.init(appClientId: clientId!,
                                                                         appClientSecret: secret,
                                                                         scopes: Set<String>(self.scopes!.map { $0 }),
                                                                         signInRedirectUri: signInRedirectURI!,
                                                                         signOutRedirectUri: signOutRedirectURI!,
                                                                         webDomain: hostURL,
                                                                         identityProvider: nil,
                                                                         idpIdentifier: nil,
                                                                         signInUri: signInURI,
                                                                         signOutUri: signOutURI,
                                                                         tokensUri: tokensURI,
                                                                         signInUriQueryParameters: self.signInURIQueryParameters,
                                                                         signOutUriQueryParameters: self.signOutURIQueryParameters,
                                                                         tokenUriQueryParameters: self.tokenURIQueryParameters,
                                                                         userPoolServiceConfiguration: AWSMobileClient.serviceConfiguration?.userPoolServiceConfiguration,
                                                                         signInPrivateSession: false)
                
                if (isCognitoAuthRegistered) {
                    AWSCognitoAuth.remove(forKey: CognitoAuthRegistrationKey)
                }
                AWSCognitoAuth.registerCognitoAuth(with: cognitoAuthConfig, forKey: CognitoAuthRegistrationKey)
                isCognitoAuthRegistered = true
                let cognitoAuth = AWSCognitoAuth.init(forKey: CognitoAuthRegistrationKey)
                cognitoAuth.delegate = self
            }
            
            let infoDictionaryMobileClient = self.awsInfo.rootInfoDictionary["Auth"] as? [String: [String: Any]]
            if let authFlowType = infoDictionaryMobileClient?["Default"]?["authenticationFlowType"] as? String,
                authFlowType == "CUSTOM_AUTH" {
                self.userPoolClient?.isCustomAuth = true
            }
            
            let infoObject = AWSInfo.default().defaultServiceInfo("IdentityManager")
            if let credentialsProvider = infoObject?.cognitoCredentialsProvider {
                
                self.isAuthorizationAvailable = true
                self.internalCredentialsProvider = credentialsProvider
                self.update(self)
                self.internalCredentialsProvider?.setIdentityProviderManagerOnce(self)
                self.registerConfigSignInProviders()
                
               if (self.internalCredentialsProvider?.identityId != nil) {
                    if (federationProvider == .none) {
                        currentUserState = .guest
                        completionHandler(.guest, nil)
                    } else {
                        currentUserState = .signedIn
                        completionHandler(.signedIn, nil)
                    }
               } else  if (self.cachedLoginsMap.count > 0) {
                currentUserState = .signedIn
                completionHandler(.signedIn, nil)
               } else {
                    currentUserState = .signedOut
                    completionHandler(.signedOut, nil)
                }
            } else if self.cachedLoginsMap.count > 0 {
                currentUserState = .signedIn
                completionHandler(.signedIn, nil)
            } else {
                currentUserState = .signedOut
                completionHandler(.signedOut, nil)
            }
            isInitialized = true
        }