142 lines
5.8 KiB
Kotlin
142 lines
5.8 KiB
Kotlin
/*
|
|
* Garmin HUD Companion Application
|
|
* Copyright (C) 2022 Piotr Dec / ztsh.eu
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package eu.ztsh.garmin.data
|
|
|
|
import com.mapbox.navigation.tripdata.maneuver.model.Maneuver
|
|
import com.mapbox.navigation.core.trip.session.LocationMatcherResult
|
|
import com.mapbox.navigation.tripdata.progress.model.TripProgressUpdateValue
|
|
|
|
class MapboxMapper {
|
|
|
|
companion object {
|
|
|
|
fun asDirection(maneuver: Maneuver): Direction {
|
|
val direction = Direction()
|
|
maneuver.primary.apply {
|
|
when (this.type) {
|
|
"roundabout" -> {
|
|
direction.out = OutType.RightRoundabout
|
|
}
|
|
"arrive" -> {
|
|
direction.out = OutType.Flag
|
|
direction.angle = OutAngle.Right
|
|
}
|
|
"turn" -> {
|
|
when (this.modifier) {
|
|
"straight" -> direction.angle = OutAngle.Straight
|
|
"slight right" -> direction.angle = OutAngle.EasyRight
|
|
"slight left" -> direction.angle = OutAngle.EasyLeft
|
|
"sharp right" -> direction.angle = OutAngle.SharpRight
|
|
"sharp left" -> direction.angle = OutAngle.SharpLeft
|
|
"uturn" -> direction.angle = OutAngle.LeftDown
|
|
}
|
|
}
|
|
}
|
|
when (this.modifier) {
|
|
"right" -> {
|
|
direction.angle = OutAngle.Right
|
|
when (this.type) {
|
|
"roundabout" -> {
|
|
when (this.degrees!!.toInt()) {
|
|
in 22..66 -> direction.angle = OutAngle.SharpRight
|
|
in 67..111 -> direction.angle = OutAngle.Right
|
|
in 112..156 -> direction.angle = OutAngle.EasyRight
|
|
in 157..203 -> direction.angle = OutAngle.Straight
|
|
in 204..248 -> direction.angle = OutAngle.EasyLeft
|
|
in 249..293 -> direction.angle = OutAngle.Left
|
|
in 294..338 -> direction.angle = OutAngle.SharpLeft
|
|
else -> direction.angle = OutAngle.Down
|
|
}
|
|
}
|
|
"fork", "off ramp" -> {
|
|
direction.angle = OutAngle.EasyRight
|
|
direction.out = OutType.LongerLane
|
|
}
|
|
}
|
|
}
|
|
|
|
"left" -> {
|
|
direction.angle = OutAngle.Left
|
|
when (this.type) {
|
|
"fork", "off ramp" -> {
|
|
direction.angle = OutAngle.EasyLeft
|
|
direction.out = OutType.LongerLane
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return direction
|
|
}
|
|
|
|
fun asDistance(maneuver: Maneuver): Distance {
|
|
return maneuver.stepDistance.let { step ->
|
|
step.distanceFormatter.formatDistance(step.distanceRemaining!!).split(" ").let {
|
|
Distance(
|
|
it[0].replace(',', '.').toDouble(),
|
|
when (it[1]) {
|
|
"m" -> Unit.Metres
|
|
"km" -> Unit.Kilometres
|
|
else -> Unit.Any
|
|
}
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun asLanes(maneuver: Maneuver): Lanes {
|
|
val laneIterator = Lane.iterator()
|
|
val outlines = mutableSetOf<Lane>()
|
|
val lanes = mutableSetOf<Lane>()
|
|
maneuver.laneGuidance?.apply {
|
|
this.allLanes.reversed().let {
|
|
it.forEach{ indicator ->
|
|
val lane = if (laneIterator.hasNext()) laneIterator.next() else Lane.DotsLeft
|
|
if (lane == Lane.DotsLeft) {
|
|
outlines.add(Lane.DotsLeft)
|
|
} else {
|
|
outlines.add(lane)
|
|
if (indicator.isActive) {
|
|
lanes.add(lane)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Lanes(Arrows(lanes), Arrows(outlines))
|
|
}
|
|
|
|
fun asSpeed(locationMatcherResult: LocationMatcherResult): Speed {
|
|
return Speed(
|
|
locationMatcherResult.enhancedLocation.speed.let { it?.let { it / 1000.0 * 3600 }?.toInt() ?: 0 },
|
|
locationMatcherResult.speedLimitInfo.speed.let { it ?: 0 },
|
|
)
|
|
|
|
}
|
|
|
|
fun asEta(trip: TripProgressUpdateValue): Arrival {
|
|
val eta = trip.formatter
|
|
.getEstimatedTimeToArrival(trip.estimatedTimeToArrival)
|
|
.toString().split(":")
|
|
return Arrival(eta[0].toInt(), eta[1].toInt())
|
|
}
|
|
|
|
}
|
|
|
|
}
|