func prepareMeeting()

in AmazonChimeSDKDemo/AmazonChimeSDKDemo/MeetingModule.swift [36:124]
86 lines of code
7 McCabe index (conditional complexity)

    func prepareMeeting(meetingId: String,
                        selfName: String,
                        audioMode: AudioMode,
                        audioDeviceCapabilities: AudioDeviceCapabilities,
                        callKitOption: CallKitOption,
                        enableAudioRedundancy: Bool,
                        reconnectTimeoutMs: Int,
                        overriddenEndpoint: String,
                        primaryExternalMeetingId: String,
                        completion: @escaping (Bool) -> Void) {
        requestRecordPermission(audioDeviceCapabilities: audioDeviceCapabilities) { success in
            guard success else {
                completion(false)
                return
            }
            self.cachedOverriddenEndpoint = overriddenEndpoint
            self.cachedPrimaryExternalMeetingId = primaryExternalMeetingId
            JoinRequestService.postJoinRequest(meetingId: meetingId,
                                               name: selfName,
                                               overriddenEndpoint: overriddenEndpoint,
                                               primaryExternalMeetingId: primaryExternalMeetingId) { joinMeetingResponse in
                guard let joinMeetingResponse = joinMeetingResponse else {
                    DispatchQueue.main.async {
                        completion(false)
                    }
                    return
                }
                let meetingResp = JoinRequestService.getCreateMeetingResponse(from: joinMeetingResponse)
                let attendeeResp = JoinRequestService.getCreateAttendeeResponse(from: joinMeetingResponse)
                let meetingSessionConfiguration = MeetingSessionConfiguration(createMeetingResponse: meetingResp,
                                                   createAttendeeResponse: attendeeResp,
                                                   urlRewriter: self.urlRewriter)
                
                let audioVideoConfig: AudioVideoConfiguration
                if (meetingSessionConfiguration.meetingFeatures.videoMaxResolution == VideoResolution.videoDisabled
                    || meetingSessionConfiguration.meetingFeatures.videoMaxResolution == VideoResolution.videoResolutionHD
                    || meetingSessionConfiguration.meetingFeatures.videoMaxResolution == VideoResolution.videoResolutionFHD
                ) {
                    audioVideoConfig = AudioVideoConfiguration(audioMode: audioMode,
                                                               audioDeviceCapabilities: audioDeviceCapabilities,
                                                               callKitEnabled: callKitOption != .disabled,
                                                               enableAudioRedundancy: enableAudioRedundancy,
                                                               videoMaxResolution: meetingSessionConfiguration.meetingFeatures.videoMaxResolution,
                                                               reconnectTimeoutMs: reconnectTimeoutMs)
                } else {
                    audioVideoConfig = AudioVideoConfiguration(audioMode: audioMode,
                                                               audioDeviceCapabilities: audioDeviceCapabilities,
                                                               callKitEnabled: callKitOption != .disabled,
                                                               enableAudioRedundancy: enableAudioRedundancy,
                                                               videoMaxResolution: AudioVideoConfiguration.defaultVideoMaxResolution,
                                                               reconnectTimeoutMs: reconnectTimeoutMs)
                }
                
                let meetingModel = MeetingModel(meetingSessionConfig: meetingSessionConfiguration,
                                                meetingId: meetingId,
                                                primaryMeetingId: meetingSessionConfiguration.primaryMeetingId ?? "",
                                                primaryExternalMeetingId: joinMeetingResponse.joinInfo.primaryExternalMeetingId ?? "",
                                                selfName: selfName,
                                                audioVideoConfig: audioVideoConfig,
                                                callKitOption: callKitOption,
                                                meetingEndpointUrl: overriddenEndpoint)
                self.meetings[meetingModel.uuid] = meetingModel

                switch callKitOption {
                case .incoming:
                    guard let call = meetingModel.call else {
                        completion(false)
                        return
                    }
                    let backgroundTaskIdentifier = UIApplication.shared.beginBackgroundTask(expirationHandler: nil)
                    DispatchQueue.main.asyncAfter(deadline: .now() + incomingCallKitDelayInSeconds) {
                        CallKitManager.shared().reportNewIncomingCall(with: call)
                        UIApplication.shared.endBackgroundTask(backgroundTaskIdentifier)
                    }
                case .outgoing:
                    guard let call = meetingModel.call else {
                        completion(false)
                        return
                    }
                    CallKitManager.shared().startOutgoingCall(with: call)
                case .disabled:
                    DispatchQueue.main.async { [weak self] in
                        self?.selectDevice(meetingModel, completion: completion)
                    }
                }
                completion(true)
            }
        }
    }