Why is my MKMapViewDelegate not reacting, despite finding the route?

Question

I have been following Sean Allens tutorial on MapKit and Directions. I used the code to fit it to my SwiftUI project.

Everything works fine, the screen zoom to fit start and destination on the screen, and calculated the rout correctly. However, it does to actually display the route.

The main Code in my ViewModel (note: .delegate = self is actually in a function, I wrote it at top level for easier understanding how I am setting the Delegat)

func checkForLocationServices() {
        if CLLocationManager.locationServicesEnabled() {
            
            locationManager = CLLocationManager()
            locationManager!.delegate = self
        }
    }

//MARK: Directions
func getDirections() {
    guard let location = locationManager?.location?.coordinate else {
        return
    }
    
    let request = createDirectionRequest(from: location)
    let directions = MKDirections(request: request)
    
    directions.calculate { calcResponse, error in
        
        guard let response = calcResponse else { return }
        
        for route in response.routes {
            print("Route \(route.name) is \(route.distance) long")
            self.mapView.addOverlay(route.polyline, level: .aboveRoads)
            self.mapView.setVisibleMapRect(route.polyline.boundingMapRect, animated: true)
        }
    }
    
}

func createDirectionRequest(from coordinate: CLLocationCoordinate2D) -> MKDirections.Request {
    
    let startLocation = MKPlacemark(coordinate: coordinate)
    let destinationLocation = MKPlacemark(coordinate: bbcLocation.coordinate)
    
    let request = MKDirections.Request()
    request.source = MKMapItem(placemark: startLocation)
    request.destination = MKMapItem(placemark: destinationLocation)
    request.transportType = .automobile
    request.requestsAlternateRoutes = true
    
    return request
}

func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
        
    let renderer = MKPolylineRenderer(overlay: overlay as! MKPolyline)
    renderer.strokeColor = .blue
    renderer.lineWidth = 5.0
        
    print(renderer.strokeStart)
    print(renderer.strokeEnd)
        
    return renderer
}

The Delegate function rendererFor is never called, despite me setting the Delegate as seen above. I also checked via Breakpoints that it is actually set, as well as downloaded Seans source code, which set the Delegate the same way I did. My VM conforms to the MKMapViewDelegate Protocol. Another user had the same problem, but since he got no response, I thought I might try I someone can help me.

Core-question: Why is my delegate method not called, despite me setting it correctly, and knowing (through console logs) that my route is found, calculated, and in fact zoomed in on?

If you need more code, feel free to ask. Thanks in advance.

*Seans Project

func setupLocationManager() {
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyBest
    }

func getDirections() {
        guard let location = locationManager.location?.coordinate else {
            //TODO: Inform user we don't have their current location
            return
        }
        
        let request = createDirectionsRequest(from: location)
        let directions = MKDirections(request: request)
        resetMapView(withNew: directions)
        
        directions.calculate { [unowned self] (response, error) in
            //TODO: Handle error if needed
            guard let response = response else { return } //TODO: Show response not available in an alert
            
            for route in response.routes {
                self.mapView.addOverlay(route.polyline)
                self.mapView.setVisibleMapRect(route.polyline.boundingMapRect, animated: true)
            }
        }
    }
    
    
    func createDirectionsRequest(from coordinate: CLLocationCoordinate2D) -> MKDirections.Request {
        let destinationCoordinate       = getCenterLocation(for: mapView).coordinate
        let startingLocation            = MKPlacemark(coordinate: coordinate)
        let destination                 = MKPlacemark(coordinate: destinationCoordinate)
        
        let request                     = MKDirections.Request()
        request.source                  = MKMapItem(placemark: startingLocation)
        request.destination             = MKMapItem(placemark: destination)
        request.transportType           = .automobile
        request.requestsAlternateRoutes = true
        
        return request
    }

func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
        let renderer = MKPolylineRenderer(overlay: overlay as! MKPolyline)
        renderer.strokeColor = .blue
        
        return renderer
    }
``