谷歌地图中两个标记之间的路线-Swift

我想让他画出两个坐标之间的路线，然后去路线，但他没有画路线。它打印出成功，但无法绘制路线。有什么问题？如何在地图上绘制两条路线并显示该路线的详细信息

   func drawPath()
        {

            let kordinatgetir = keychain.get("uyeKordinat")
                  let doubleKordinat :Double = Double(kordinatgetir!)!

                  let kordinatgetir1 = keychain.get("uyeKordinat1")
                  let doubleKordinat1 :Double = Double(kordinatgetir1!)!


            let origin = "\(doubleKordinat),\(doubleKordinat1)"
            let destination = "\(doubleKordinat1),\(doubleKordinat)"
            let url = "https://maps.googleapis.com/maps/api/directions/json?origin=\(origin)&destination=\(destination)&mode=driving&key=..."

            Alamofire.request(url).responseJSON { response in
              print(response.request)  // original URL request
              print(response.response) // HTTP URL response
              print(response.data)     // server data
              print(response.result)   // result of response serialization

                do {
                    let json = try JSON(data: response.data!)
                       let routes = json["routes"].arrayValue

                       for route in routes
                       {
                         let routeOverviewPolyline = route["overview_polyline"].dictionary
                         let points = routeOverviewPolyline?["points"]?.stringValue
                         let path = GMSPath.init(fromEncodedPath: points!)
                         let polyline = GMSPolyline.init(path: path)
                         polyline.map = self.mapView
                       }
                   } catch {
                       print(error)
                   }
            }
        }

func-drowRoute（从源：CLLocationCoordinate2D到目标：CLLocationCoordinate2D）{
self.mapView.clear（）
let origin=“\（源.纬度），\（源.经度）”
let destinationn=“\（目的地.纬度），\（目的地.经度）”
guard let url=url（字符串：https://maps.googleapis.com/maps/api/directions/json?origin=\（起点）&destination=\（终点n）&mode=driving&key=Your key“）其他{
let error=NSError（域：“LocalDomain”，代码：0，用户信息：[NSLocalizedDescriptionKey:“未能创建对象URL”]）
打印（“错误：\（错误）”）
//completionHandler（无，错误）
返回
}
让config=URLSessionConfiguration.default
let session=URLSession（配置：config）
SVProgressHUD.show（）
让task=session.dataTask（带url，completionHandler:{
（数据、响应、错误）
如果错误！=nil{
打印（错误！.localizedDescription）
SVProgressHUD.disclose（）
}
否则{
做{
如果让json:[String:Any]=尝试JSONSerialization.jsonObject（使用：data！，选项：.allowFragments）作为？[String:Any]{
guard let routes=json[“routes”]作为？NSArray else{
DispatchQueue.main.async{
SVProgressHUD.disclose（）
}
返回
}
如果（routes.count>0）{
让overview_polyline=将[0]布线为NSDictionary
让dictPolyline=overview\u polyline？[“overview\u polyline”]as？NSDictionary
让点=多段线？对象（forKey：“点”）作为？字符串
DispatchQueue.main.async{
//
让legs=overview_折线？[“legs”]作为！数组
让距离=腿[0][“距离”]为？N
设距离值=距离？[“值”]为？Int？？0
让duration=legs[0][“duration”]as？NSDictionary
将totalDurationInSeconds=持续时间？[“值”]设为？Int？？0
让英里数=双倍（距离值）/1609.344
打印（“\（英里）”）
如果距离值>整数（32186.9）{
SVProgressHUD.disclose（）
self.showarter（标题：Appname，消息：“您的降落点超过20英里”）
self.txtToLocation.text=“”
self.txtToLocation.becomeFirstResponder（）
}否则{
self.showPath（polyStr:points！）
让startLocationDictionary=legs[0][“开始位置”]作为！Dictionary
让originCoordinate=CLLocationCoordinate2DMake（startLocationDictionary[“lat”]as！Double，startLocationDictionary[“lng”]as！Double）
让endLocationDictionary=legs[legs.count-1][“end\u location”]作为！Dictionary
让destinationcoordination=CLLocationCoordinate2DMake（endLocationDictionary[“lat”]as！Double，endLocationDictionary[“lng”]as！Double）
设marker1=GMSMarker（）
marker1.position=CLLocationCoordinate2D（纬度：destinationCoordinate.latitude，经度：destinationCoordinate.latitude）
marker1.icon=UIImage（命名为：“icn_pin-1”）
marker1.map=self.mapView
设marker2=GMSMarker（）
marker2.position=CLLocationCoordinate2D（纬度：originCoordinate.lation，经度：originCoordinate.longitude）
marker2.icon=UIImage（命名为：“icn_pin2”）
marker2.map=self.mapView
}
}
}
否则{
打印（json）
DispatchQueue.main.async{
SVProgressHUD.disclose（）
}
}
}
}
抓住{
打印（“JSONSerialization中的错误”）
DispatchQueue.main.async{
SVProgressHUD.disclose（）
}
}
}
})
task.resume（）
}
func showPath（polyStr:String）{
SVProgressHUD.disclose（）
let path=GMSPath（fromEncodedPath:polyStr）
设多段线=GMSPolyline（路径：path）
折线.strokeWidth=5.0
polyline.strokeColor=UIColor.UIColorFromHex（hex:#F6881F）
polyline.map=mapView
DispatchQueue.main.async{
让边界=GMSCoordinateBounds（路径：path！）
让update=GMSCameraUpdate.fit（边界，带：UIEdgeInsets（顶部：170，左侧：30，底部：30，右侧：30））
self.mapView.moveCamera（更新）
}
}

您是否能够获得

积分

？另外，我认为您缺少了

strokeWidth

。因此，请尝试以下操作：

polyline.strokeWidth=6.0

斑点是无错误的。我添加了代码，但仍然不起作用。你能通过屏幕截图告诉我你在哪里调用这个函数，它现在看起来怎么样？

func drowRoute(from source: CLLocationCoordinate2D, to destination: CLLocationCoordinate2D) {
    self.mapView.clear()

    let origin = "\(source.latitude),\(source.longitude)"
    let destinationn = "\(destination.latitude),\(destination.longitude)"

    guard let url = URL(string: "https://maps.googleapis.com/maps/api/directions/json?origin=\(origin)&destination=\(destinationn)&mode=driving&key=Your Key") else {
        let error = NSError(domain: "LocalDomain", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to create object URL"])
        print("Error: \(error)")
        //completionHandler(nil, error)
        return
    }
    let config = URLSessionConfiguration.default
    let session = URLSession(configuration: config)
    SVProgressHUD.show()
    let task = session.dataTask(with: url, completionHandler: {
        (data, response, error) in
        if error != nil {
            print(error!.localizedDescription)
            SVProgressHUD.dismiss()
        }
        else {
            do {
                if let json : [String:Any] = try JSONSerialization.jsonObject(with: data!, options: .allowFragments) as? [String: Any]{

                    guard let routes = json["routes"] as? NSArray else {
                        DispatchQueue.main.async {
                            SVProgressHUD.dismiss()
                        }
                        return
                    }

                    if (routes.count > 0) {
                        let overview_polyline = routes[0] as? NSDictionary
                        let dictPolyline = overview_polyline?["overview_polyline"] as? NSDictionary
                        let points = dictPolyline?.object(forKey: "points") as? String

                        DispatchQueue.main.async {
                            //
                            let legs = overview_polyline?["legs"] as! Array<Dictionary<String, AnyObject>>

                            let distance = legs[0]["distance"] as? NSDictionary
                            let distanceValue = distance?["value"] as? Int ?? 0

                            let duration = legs[0]["duration"] as? NSDictionary
                            let totalDurationInSeconds = duration?["value"] as? Int ?? 0

                            let miles = Double(distanceValue) / 1609.344
                            print("\(miles)")

                            if distanceValue > Int(32186.9){
                                SVProgressHUD.dismiss()
                                self.showAlert(title: Appname, message: "Your dropping point is more than 20 miles")
                                self.txtToLocation.text = ""
                                self.txtToLocation.becomeFirstResponder()

                            }else{
                                self.showPath(polyStr: points!)

                                let startLocationDictionary = legs[0]["start_location"] as! Dictionary<String, AnyObject>
                                let originCoordinate = CLLocationCoordinate2DMake(startLocationDictionary["lat"] as! Double, startLocationDictionary["lng"] as! Double)

                                let endLocationDictionary = legs[legs.count - 1]["end_location"] as! Dictionary<String, AnyObject>
                                let destinationCoordinate = CLLocationCoordinate2DMake(endLocationDictionary["lat"] as! Double, endLocationDictionary["lng"] as! Double)

                                let marker1 = GMSMarker()
                                marker1.position = CLLocationCoordinate2D(latitude:destinationCoordinate.latitude, longitude: destinationCoordinate.longitude)
                                marker1.icon = UIImage(named: "icn_pin-1")
                                marker1.map = self.mapView

                                let marker2 = GMSMarker()
                                marker2.position = CLLocationCoordinate2D(latitude:originCoordinate.latitude, longitude: originCoordinate.longitude)
                                marker2.icon = UIImage(named: "icn_pin2")
                                marker2.map = self.mapView

                            }

                        }
                    }
                    else {
                        print(json)
                        DispatchQueue.main.async {
                            SVProgressHUD.dismiss()
                        }
                    }
                }
            }
            catch {
                print("error in JSONSerialization")
                DispatchQueue.main.async {
                    SVProgressHUD.dismiss()
                }
            }
        }
    })
    task.resume()
}

func showPath(polyStr :String){
    SVProgressHUD.dismiss()
    let path = GMSPath(fromEncodedPath: polyStr)
    let polyline = GMSPolyline(path: path)
    polyline.strokeWidth = 5.0
    polyline.strokeColor = UIColor.UIColorFromHex(hex: "#F6881F")
    polyline.map = mapView
    DispatchQueue.main.async {
        let bounds = GMSCoordinateBounds(path: path!)
        let update = GMSCameraUpdate.fit(bounds, with: UIEdgeInsets(top: 170, left: 30, bottom: 30, right: 30))
        self.mapView.moveCamera(update)

    }
}