Initial commit

Author: michallaskowski

Diff for: Package.resolved

@@ -0,0 +1,25 @@
+{
+  "object": {
+    "pins": [
+      {
+        "package": "FitFileParser",
+        "repositoryURL": "https://github.com/roznet/FitFileParser",
+        "state": {
+          "branch": null,
+          "revision": "d693f598db2000359e7cb56bc4219a3806b39dec",
+          "version": "1.4.1"
+        }
+      },
+      {
+        "package": "SwiftyXMLParser",
+        "repositoryURL": "https://github.com/yahoojapan/SwiftyXMLParser",
+        "state": {
+          "branch": null,
+          "revision": "ec7f183642adf429babd867d1a38c5c6912408ba",
+          "version": "5.3.0"
+        }
+      }
+    ]
+  },
+  "version": 1
+}

Diff for: Package.swift

@@ -5,22 +5,40 @@ import PackageDescription
 
 let package = Package(
     name: "WorkoutDecoders",
+    platforms: [.iOS(.v11), .macOS(.v10_14), .watchOS(.v4)],
     products: [
-        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "ZwoWorkoutDecoder",
+            targets: ["ZwoWorkoutDecoder"]),
+        .library(
+            name: "FitWorkoutDecoder",
+            targets: ["FitWorkoutDecoder"]),
         .library(
             name: "WorkoutDecoders",
-            targets: ["WorkoutDecoders"]),
+            targets: ["WorkoutDecoders"])
     ],
     dependencies: [
-        // Dependencies declare other packages that this package depends on.
-        // .package(url: /* package url */, from: "1.0.0"),
+
+        .package(
+            name: "SwiftyXMLParser",
+            url: "https://github.com/yahoojapan/SwiftyXMLParser", from: "5.3.0"),
+        .package(
+            name: "FitFileParser",
+            url: "https://github.com/roznet/FitFileParser", from: "1.4.1")
     ],
     targets: [
-        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
-        // Targets can depend on other targets in this package, and on products in packages this package depends on.
         .target(
-            name: "WorkoutDecoders",
+            name: "WorkoutDecoderBase",
             dependencies: []),
+        .target(
+            name: "ZwoWorkoutDecoder",
+            dependencies: ["SwiftyXMLParser", "WorkoutDecoderBase"]),
+        .target(
+            name: "FitWorkoutDecoder",
+            dependencies: ["FitFileParser", "WorkoutDecoderBase"]),
+        .target(
+            name: "WorkoutDecoders",
+            dependencies: ["ZwoWorkoutDecoder", "FitWorkoutDecoder"]),
         .testTarget(
             name: "WorkoutDecodersTests",
             dependencies: ["WorkoutDecoders"]),

Diff for: Sources/FitWorkoutDecoder/FitWorkoutDecoder.swift

@@ -0,0 +1,110 @@
+//
+//  FitWorkoutDecoder.swift
+//  WatchTrainer
+//
+//  Created by Laskowski, Michal on 14/12/2020.
+//
+
+import Foundation
+import WorkoutDecoderBase
+import FitFileParser
+
+public enum FitDecodeError: Error {
+    case notOneWorkoutMessage
+    case notSupportedRange
+}
+
+private struct RepeatSteps {
+    let range: Range<Int>
+    let repeatCount: Int
+}
+
+public final class FitWorkoutDecoder: WorkoutDecoding {
+    private let userFtp: Int
+    public init(userFtp: Int) {
+        self.userFtp = userFtp
+    }
+
+    public func decodeWorkout(from url: URL, data: Data) throws -> Workout {
+        let file = FitFile(data: data)
+
+        let workoutMessages = file.messages(forMessageType: .workout)
+        guard workoutMessages.count == 1 else {
+            throw FitDecodeError.notOneWorkoutMessage
+        }
+        let workoutName = workoutMessages[0].interpretedField(key: "wkt_name")?.name ?? ""
+        assert(!workoutName.isEmpty)
+
+        let workoutSteps = file.messages(forMessageType: .workout_step)
+        let repeatSteps = workoutSteps.enumerated()
+            .filter { step in
+                step.element.interpretedField(key: "duration_type")?.name == "repeat_until_steps_cmplt"
+            }
+            .map { repeatStep -> RepeatSteps in
+                let startIndex = repeatStep.element.interpretedField(key: "duration_value")?.value.map {
+                    Int($0)
+                } ?? -1
+                assert(startIndex >= 0)
+                let repeatRange = Range<Int>(uncheckedBounds: (lower: startIndex, upper: repeatStep.offset - 1))
+                let repeatCount = repeatStep.element.interpretedField(key: "target_value")?.value.map {
+                    Int($0)
+                } ?? -1
+                assert(repeatCount >= 0)
+
+                return RepeatSteps(range: repeatRange, repeatCount: repeatCount)
+            }
+
+        let parts = try repeatSteps.map { repeatStep -> WorkoutPart in
+            let stepsDistance = repeatStep.range.upperBound - repeatStep.range.lowerBound
+            switch stepsDistance {
+            case 0:
+                let workoutStep = workoutSteps[repeatStep.range.lowerBound]
+                return WorkoutPart.steady(duration: workoutStep.duration, power: workoutStep.power(for: userFtp))
+            case 1:
+                let firstWorkoutStep = workoutSteps[repeatStep.range.lowerBound]
+                let secondWorkoutStep = workoutSteps[repeatStep.range.upperBound]
+                return WorkoutPart.intervals(repeat: repeatStep.repeatCount,
+                                             onDuration: firstWorkoutStep.duration, onPower: firstWorkoutStep.power(for: userFtp),
+                                             offDuration: secondWorkoutStep.duration, offPower: secondWorkoutStep.power(for: userFtp))
+            default:
+                throw FitDecodeError.notSupportedRange
+            }
+        }
+
+        return Workout(name: workoutName,
+                       parts: parts,
+                       messages: [])
+    }
+}
+
+private extension FitFileParser.FitMessage {
+    var duration: Int {
+        let duration = interpretedField(key: "duration_value")?.value.map {
+            Int($0 / 1000.0)
+        } ?? -1
+        assert(duration > 0)
+        return duration
+    }
+
+    func power(for ftp: Int) -> Double {
+        let power = interpretedField(key: "custom_target_value_high")?.value.map {
+            $0.fitPowerValueToRelativeFtp(for: ftp)
+        } ?? -1
+        assert(power > 0)
+        return power
+    }
+}
+
+// based on https://developer.garmin.com/fit/cookbook/encoding-workout-files/
+// Relative values are provided as an integer value ranging 0 – 1000% functional threshold power (FTP)
+// the ranges 0 to 1000 (power) are reserved for relative values
+// power values must be offset 1000 watts.
+extension Double {
+    func fitPowerValueToRelativeFtp(for ftp: Int) -> Double {
+        if self < 1000 {
+            return self / 100.0
+        } else {
+            return (self - 1000.0) / Double(ftp)
+        }
+    }
+}

Diff for: Sources/WorkoutDecoderBase/WorkoutDecoding.swift

@@ -0,0 +1,86 @@
+//
+//  WorkoutDecoding.swift
+//  WatchTrainer
+//
+//  Created by Laskowski, Michal on 14/12/2020.
+//
+
+import Foundation
+
+public protocol WorkoutDecoding {
+    func decodeWorkout(from url: URL, data: Data) throws -> Workout
+}
+
+public enum WorkoutPart {
+    case steady(duration: Int, power: Double)
+    case intervals(repeat: Int, onDuration: Int, onPower: Double, offDuration: Int, offPower: Double)
+    case ramp(duration: Int, powerLow: Double, powerHigh: Double)
+    case freeRide(duration: Int)
+
+    public func toSegments(startIndex: Int) -> [WorkoutSegment] {
+        switch self {
+        case .steady(let duration, let power):
+            return [WorkoutSegment(duration: duration, index: startIndex, intervalIndex: nil, powerStart: power, powerEnd: nil)]
+        case .intervals(let repeats, let onDuration, let onPower, let offDuration, let offPower):
+            return (0...repeats).map { index -> [WorkoutSegment] in
+                [
+                    WorkoutSegment(duration: onDuration, index: startIndex + index * 2,
+                                   intervalIndex: index, powerStart: onPower, powerEnd: nil),
+                    WorkoutSegment(duration: offDuration, index: startIndex + index * 2 + 1,
+                                   intervalIndex: index, powerStart: offPower, powerEnd: nil),
+                ]
+            }.flatMap { $0 }
+
+        case .ramp(let duration, let powerLow, let powerHigh):
+            return [WorkoutSegment(duration: duration, index: startIndex,
+                                   intervalIndex: nil, powerStart: powerLow, powerEnd: powerHigh)]
+        case .freeRide(let duration):
+            return [WorkoutSegment(duration: duration, index: startIndex, intervalIndex: nil, powerStart: -1.0, powerEnd: nil)]
+        }
+    }
+}
+
+public struct WorkoutSegment: Codable {
+    public let duration: Int
+    public let index: Int
+    public let intervalIndex: Int?
+    public let powerStart: Double // negative power means free ride
+    public let powerEnd: Double?
+
+    public func powerAt(second: Int, for ftp: Double) -> Int {
+        let power: Double
+        if let powerOff = powerEnd {
+            power = Double(second) / Double(duration) * (powerOff - powerStart) + powerStart
+        } else {
+            power = powerStart
+        }
+        return Int(power * ftp)
+    }
+}
+
+public struct WorkoutMessage: Codable {
+    public let timeOffset: Int
+    public let message: String
+
+    public init(timeOffset: Int, message: String) {
+        self.timeOffset = timeOffset
+        self.message = message
+    }
+}
+
+public struct Workout: Codable {
+    public let name: String
+    public let segments: [WorkoutSegment]
+    public let duration: Int
+    public let messages: [WorkoutMessage]
+
+    public init(name: String, parts: [WorkoutPart], messages: [WorkoutMessage]) {
+        self.name = name
+        self.messages = messages
+        segments = parts.reduce([WorkoutSegment](), { (accumulator, part) -> [WorkoutSegment] in
+            let index = (accumulator.last?.index ?? -1) + 1
+            return accumulator + part.toSegments(startIndex: index)
+        })
+        duration = segments.reduce(0, { $0 + $1.duration })
+    }
+}

Diff for: Sources/WorkoutDecoders/WorkoutDecoder.swift

@@ -0,0 +1,39 @@
+//
+//  WorkoutDecoder.swift
+//  WatchTrainer
+//
+//  Created by Laskowski, Michal on 14/12/2020.
+//
+
+import Foundation
+import WorkoutDecoderBase
+import FitWorkoutDecoder
+import ZwoWorkoutDecoder
+
+public struct UnknownFileException: Error {}
+
+final class WorkoutDecoder: WorkoutDecoding {
+
+    private let userFtp: Int
+    private lazy var fitDecoder: FitWorkoutDecoder = {
+        FitWorkoutDecoder(userFtp: userFtp)
+    }()
+    private lazy var zwoDecoder: ZwoWorkoutDecoder = {
+        ZwoWorkoutDecoder()
+    }()
+
+    init(userFtp: Int) {
+        self.userFtp = userFtp
+    }
+
+    func decodeWorkout(from url: URL, data: Data) throws -> Workout {
+        switch url.pathExtension {
+        case "zwo":
+            return try zwoDecoder.decodeWorkout(from: url, data: data)
+        case "fit":
+            return try fitDecoder.decodeWorkout(from: url, data: data)
+        default:
+            throw UnknownFileException()
+        }
+    }
+}