Route

        let mapView = mapController?.getView("mapview") as! KakaoMap
        let manager = mapView.getRouteManager()
        
        // 레이어의 이름과 렌더링 우선순위를 지정하여 RouteLayer를 생성한다.
        // 생성된 RouteLayer가 리턴된다.
        let layer = manager.addRouteLayer(layerID: "RouteLayer", zOrder: 0)

    // RouteStyleSet을 생성한다.
    func createRouteStyleSet() {
        let mapView = mapController?.getView("mapview") as? KakaoMap
        let manager = mapView?.getRouteManager()
        let _ = manager?.addRouteLayer(layerID: "RouteLayer", zOrder: 0)
        let patternImages = [UIImage(named: "route_pattern_arrow.png"), UIImage(named: "route_pattern_walk.png"), UIImage(named: "route_pattern_long_dot.png")]
        
        // StyleSet에 pattern을 추가한다.
        let styleSet = RouteStyleSet(styleID: "routeStyleSet1")
        styleSet.addPattern(RoutePattern(pattern: patternImages[0]!, distance: 60, symbol: nil, pinStart: false, pinEnd: false))
        styleSet.addPattern(RoutePattern(pattern: patternImages[1]!, distance: 6, symbol: nil, pinStart: true, pinEnd: true))
        styleSet.addPattern(RoutePattern(pattern: patternImages[2]!, distance: 6, symbol: UIImage(named: "route_pattern_long_airplane.png")!, pinStart: true, pinEnd: true))
       
        let colors = [ UIColor(hex: 0x7796ffff),
                       UIColor(hex: 0x343434ff), 
                       UIColor(hex: 0x3396ff00),
                       UIColor(hex: 0xee63ae00) ]

        let strokeColors = [ UIColor(hex: 0xffffffff),
                             UIColor(hex: 0xffffffff),
                             UIColor(hex: 0xffffff00),
                             UIColor(hex: 0xffffff00) ]
            
        let patternIndex = [-1, 0, 1, 2]
        
        // 총 4개의 스타일을 생성한다.
        for index in 0 ..< colors.count {
            let routeStyle = RouteStyle()
            
            // 각 스타일은 1개의 표출 시작 레벨 = 0 인 PerLevelStyle을 갖는다. 즉, 전 레벨에서 동일하게 표출된다.
            // Style의 패턴인덱스가 -1로 지정되는 경우, 패턴을 사용하지 않고 컬러만 사용한다.
            routeStyle.addPerLevelStyle(PerLevelRouteStyle(width: 18, color: colors[index], strokeWidth: 4, strokeColor: strokeColors[index], level: 0, patternIndex: patternIndex[index]))
            
            styleSet.addStyle(routeStyle)
        }

        manager?.addRouteStyleSet(styleSet)
    }

    func createRouteline() {
        let mapView = mapController?.getView("mapview") as! KakaoMap
        let manager = mapView.getRouteManager()
        
        // Route 생성을 위해 RouteLayer를 생성한다.
        let layer = manager.addRouteLayer(layerID: "RouteLayer", zOrder: 0)
        
        // Route 생성을 위한 RouteSegment 생성
        let segmentPoints = routeSegmentPoints()
        var segments: [RouteSegment] = [RouteSegment]()
        var styleIndex: UInt = 0
        for points in segmentPoints {
            // 경로 포인트로 RouteSegment 생성. 사용할 스타일 인덱스도 지정한다.
            let seg = RouteSegment(points: points, styleIndex: styleIndex)
            segments.append(seg)
            styleIndex = (styleIndex + 1) % 4
        }
        
        // Route 생성을 위해 ID, styleID, zOrder, segment를 전달한다.
        let route = layer?.addRoute(routeID: "routes", styleID: "routeStyleSet1", zOrder: 0, segments: segments)
        route?.show()
    }

    // RouteLines을 표시할 Layer를 생성한다.
    func createRouteLayer() {
        let mapView = mapController?.getView("mapview") as? KakaoMap
        let manager = mapView?.getRouteManager()
        let _ = manager?.addRouteLayer(layerID: "RouteLinesLayer", zOrder: 0)
    }
    
    // Eanbled Style을 생성한다. => 제일 위에 그려지는 Route의 Style
    func createEnabledStyleSet() {
        let mapView = mapController?.getView("mapview") as? KakaoMap
        let manager = mapView?.getRouteManager()
    
        let patternImages = [UIImage(named: "route_pattern_arrow.png"), UIImage(named: "route_pattern_walk.png"), UIImage(named: "route_pattern_long_dot.png")]
        
        // pattern
        let styleSet = RouteStyleSet(styleID: "enabledRoute")
        styleSet.addPattern(RoutePattern(pattern: patternImages[0]!, distance: 60, symbol: nil, pinStart: false, pinEnd: false))
        styleSet.addPattern(RoutePattern(pattern: patternImages[1]!, distance: 6, symbol: nil, pinStart: true, pinEnd: true))
        styleSet.addPattern(RoutePattern(pattern: patternImages[2]!, distance: 6, symbol: UIImage(named: "route_pattern_long_airplane.png")!, pinStart: true, pinEnd: true))
        
        let colors = [ UIColor(hex: 0x7796ffff),
                       UIColor(hex: 0x343434ff),
                       UIColor(hex: 0x3396ff00),
                       UIColor(hex: 0xee63ae00) ]

        let strokeColors = [ UIColor(hex: 0xffffffff),
                             UIColor(hex: 0xffffffff),
                             UIColor(hex: 0xffffff00),
                             UIColor(hex: 0xffffff00) ]
            
        let patternIndex = [-1, 0, 1, 2]
        
        for index in 0 ..< colors.count {
            let routeStyle = RouteStyle()
            
            routeStyle.addPerLevelStyle(PerLevelRouteStyle(width: 18, color: colors[index], strokeWidth: 4, strokeColor: strokeColors[index], level: 0, patternIndex: patternIndex[index]))
            
            styleSet.addStyle(routeStyle)
        }

        manager?.addRouteStyleSet(styleSet)
    }
    
    // Disabled Style을 생성한다. 밑에 그려질 Route들의 style.
    func createDisabledStyleSet() {
        let mapView = mapController?.getView("mapview") as? KakaoMap
        let manager = mapView?.getRouteManager()
    
        // pattern
        let styleSet = RouteStyleSet(styleID: "disabledRoute")
        styleSet.addPattern(RoutePattern(pattern: UIImage(named: "route_pattern_arrow.png")!, distance: 60, symbol: nil, pinStart: false, pinEnd: false))
        
        let routeStyle = RouteStyle()
        routeStyle.addPerLevelStyle(PerLevelRouteStyle(width: 16, color: UIColor(hex: 0x8d8d8dff), strokeWidth: 2, strokeColor: UIColor(hex: 0xffffffff), level: 0, patternIndex: 0))
        styleSet.addStyle(routeStyle)
        
        manager?.addRouteStyleSet(styleSet)
    }
    
        // 4개의 Route를 생성한다.
    func createRouteLines() {
        let mapView = mapController?.getView("mapview") as! KakaoMap
        let manager = mapView.getRouteManager()
        let layer = manager.getRouteLayer(layerID: "RouteLinesLayer")
        
        for index in 0 ... 3 {
            var styleID: String
            var zOrder: Int = 0
            
            if index == _enabledIndex {
                styleID = "enabledRoute"
                zOrder = _enabledZOrder
            }
            else {
                styleID = "disabledRoute"
                zOrder = index
            }
            
            // 해당 예제에서는 route를 구성하는 points를 임의로 offset을 주어 4개의 다른 경로를 구성한다.
            let segmentPoints = routeSegmentPoints(offset: Double(500 * index))
            
            var styleIndex: UInt = 0
            var segments = [RouteSegment]()
            for points in segmentPoints {
                if index != _enabledIndex {
                    styleIndex = 0
                }
                
                let segment = RouteSegment(points: points, styleIndex: styleIndex)
                segments.append(segment)
                
                styleIndex = (styleIndex + 1)%4
            }
            
            // route 추가
            let route = layer?.addRoute(routeID: "route"+String(index+1), styleID: styleID, zOrder: zOrder, segments: segments)
            route?.show()
        }
    }
    
        func guiDidTapped(_ gui: GuiBase, componentName: String) {
        guard _enabledIndex != Int(componentName)! - 1 else {
            return
        }
        
        let mapView = mapController?.getView("mapview") as? KakaoMap
        let manager = mapView?.getRouteManager()
        let layer = manager?.getRouteLayer(layerID: "RouteLinesLayer")
        
        // disabled -> enabled로 먼저 바뀌는게 자연스럽다.
        let disabled = layer?.getRoute(routeID: "route"+componentName)
        
        var segments = [RouteSegment]()
        var styleIndex: UInt = 0
        
        // style 과 data를 업데이트 하기 위해 route segment 재 생성
        var segmentPoints = routeSegmentPoints(offset: Double(500 * (Int(componentName)!-1)))
        for points in segmentPoints {
            let segment = RouteSegment(points: points, styleIndex: styleIndex)
            styleIndex = (styleIndex + 1)%4
            
            segments.append(segment)
        }
        
        // 스타일과 데이터를 바꾸고, 제일 위에 표시되게 하기 위해 zOrder를 변경한다.
        disabled?.changeStyleAndData(styleID: "enabledRoute", segments: segments)
        disabled?.setZOrder(_enabledZOrder)
        
        segments.removeAll()
        
        // enabled로 표시되고 있던 route를 enabled로 바꾸기
        let enabled = layer?.getRoute(routeID: "route"+String(_enabledIndex+1))
        segmentPoints = routeSegmentPoints(offset: Double(500 * _enabledIndex))
        for points in segmentPoints {
            let segment = RouteSegment(points: points, styleIndex: 0)
            segments.append(segment)
        }
        
        // 스타일과 데이터를 바꾸고, 다시 아래로 내리기 위해 zOrder를 변경한다.
        enabled?.changeStyleAndData(styleID: "disabledRoute", segments: segments)
        enabled?.setZOrder(_enabledIndex)

        _enabledIndex = Int(componentName)!-1
    }

//RouteAnimator 생성.
func createRouteAnimators() {
    let mapView = mapController?.getView("mapview") as? KakaoMap
    let manager = mapView?.getRouteManager()
    let clearEffect = ProgressAnimationEffect(direction: .forward, type: .clearFromStart)   //시작점에서부터 비워지는 효과
    let fillEffect = ProgressAnimationEffect(direction: .forward, type: .fillFromStart)     //시적점에서부터 채워지는 효과
    clearEffect.interpolation = AnimationInterpolation(duration: 900000, method: .linear)
    fillEffect.interpolation = AnimationInterpolation(duration: 900000, method: .linear)
    let _ = manager?.addRouteAnimator(animatorID: "routeAnimator1", effect: clearEffect)
    let _ = manager?.addRoute
    Animator(animatorID: "routeAnimator2", effect: fillEffect)
}

// 진행을 표현하기 위해 fgRoute는 시작점에서부터 비워지는 효과를 사용하고, bgRoute는 시작점에서부터 채워지는 효과를 사용한다.
func runAnimation() {
    let mapView = mapController?.getView("mapview") as? KakaoMap
    let manager = mapView?.getRouteManager()
    let animator1 = manager?.getRouteAnimator(animatorID: "routeAnimator1")
    let animator2 = manager?.getRouteAnimator(animatorID: "routeAnimator2")
    let fgRoutes = manager?.getRouteLayer(layerID: "RouteLayer")?.getRoute(routeID: "fgRoutes")
    let bgRoutes = manager?.getRouteLayer(layerID: "RouteLayer")?.getRoute(routeID: "bgRoutes")
    
    animator1?.addRoute(fgRoutes!)
    animator2?.addRoute(bgRoutes!)
    
    animator1?.start()
    animator2?.start()
}

func progressBtnPressed() {
    let mapView = mapController?.getView("mapview") as? KakaoMap
    let manager = mapView?.getRouteManager()
    let fgRoutes = manager?.getRouteLayer(layerID: "RouteLayer")?.getRoute(routeID: "fgRoutes")
    let bgRoutes = manager?.getRouteLayer(layerID: "RouteLayer")?.getRoute(routeID: "bgRoutes")
    
    //setProgress는 현상태에서 새로 지정된 상태로 지정된 시간동안 변경됨. 기본 상태는 .clearFromStart의 progress 0 상태.
    //bgRoute가 비워진 상태에서 시작점에서부터 채워지도록 하기 위해 .fillFromStart의 progress 0 으로 먼저 지정.
    bgRoutes?.setProgress(progress: 0.0, type: .fillFromStart, duration: 0, callback: { (rt: Route?) in
        //progress 지정이 완료되면 변경될 상태로 지정. 진행도중 setProgress를 중복실행하면 진행중이던 내용은 무시되고 실행 시점의 상태에서 새로 지정된 상태로 변경을 진행함.
        fgRoutes?.setProgress(progress: 0.5, type: .clearFromStart, duration: 100000)
        bgRoutes?.setProgress(progress: 0.5, type: .fillFromStart, duration: 100000)
    })
}