### Swift Package Installation and Module Imports

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Instructions on how to install the FIT SDK using Swift Package Manager and import the necessary modules for both Swift and Objective-C projects.

```APIDOC
## Swift package installation and module imports

The SDK is distributed as a Swift Package. After installation, import the appropriate modules based on which API layer you need. The `SwiftFIT` module is required only for `FITListener` and `FITMessages`; pure Objective-C projects use `@import ObjcFIT` alone.

```swift
// Swift — basic decode/encode (no FITListener)
import ObjcFIT

// Swift — high-level FITListener + FITMessages API
import ObjcFIT
import SwiftFIT
```

```objc
// Objective-C
@import ObjcFIT;
```

```swift
// Package.swift dependency (when used in another package)
dependencies: [
    .package(url: "https://github.com/garmin/fit-objective-c-sdk", from: "21.202.0")
],
targets: [
    .target(name: "MyTarget", dependencies: [
        .product(name: "FIT", package: "fit-objective-c-sdk")
    ])
]
```
```

--------------------------------

### FITSessionMesg, FITLapMesg, and FITLengthMesg Usage

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Examples demonstrating how to create and populate FITSessionMesg, FITLapMesg, and FITLengthMesg objects for tracking exercise sessions, laps, and individual pool lengths.

```APIDOC
## FITSessionMesg and FITLapMesg — Activity structure messages

`FITSessionMesg` summarizes one continuous exercise session (sport, duration, distance, laps). `FITLapMesg` summarizes one lap within a session. Both share a similar field set and are typically written once after all `FITRecordMesg` and `FITEventMesg` entries. For swim activities, `FITLengthMesg` models each pool length within a lap.

```swift
import ObjcFIT

// Session for a 500 m pool swim
let session = FITSessionMesg()
session.setMessageIndex(0)
session.setTimestamp(FITDate())
session.setStartTime(FITDate())
session.setSport(FITSportSwimming)
session.setSubSport(FITSubSportLapSwimming)
session.setTotalElapsedTime(840)      // 14 minutes in seconds
session.setTotalTimerTime(840)
session.setTotalDistance(500)         // metres
session.setPoolLength(25.0)           // metres
session.setPoolLengthUnit(FITDisplayMeasureMetric)
session.setNumLengths(20)
session.setNumActiveLengths(20)
session.setTotalStrokes(400)
session.setFirstLapIndex(0)
session.setNumLaps(1)

// Lap for first 250 m
let lap = FITLapMesg()
lap.setMessageIndex(0)
lap.setStartTime(FITDate())
lap.setTimestamp(FITDate())
lap.setTotalElapsedTime(420)
lap.setTotalDistance(250)
lap.setSport(FITSportSwimming)
lap.setSubSport(FITSubSportLapSwimming)
lap.setNumLengths(10)
lap.setNumActiveLengths(10)

// Individual pool length
let length = FITLengthMesg()
length.setMessageIndex(0)
length.setStartTime(FITDate())
length.setTotalElapsedTime(42.0)       // seconds
length.setTotalTimerTime(42.0)
length.setLengthType(FITLengthTypeActive)
length.setSwimStroke(FITSwimStrokeFreestyle)
length.setTotalStrokes(20)
length.setAvgSwimmingCadence(FITUInt8((20.0 * 60) / 42.0))  // strokes/min

print("Pool length avg speed: \(25.0 / 42.0) m/s")
```
```

--------------------------------

### Create FIT Session, Lap, and Length Messages

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Example demonstrating the creation and population of FITSessionMesg, FITLapMesg, and FITLengthMesg objects for a pool swim activity. Ensure correct units and values are set for accurate data representation.

```swift
import ObjcFIT

// Session for a 500 m pool swim
let session = FITSessionMesg()
session.setMessageIndex(0)
session.setTimestamp(FITDate())
session.setStartTime(FITDate())
session.setSport(FITSportSwimming)
session.setSubSport(FITSubSportLapSwimming)
session.setTotalElapsedTime(840)      // 14 minutes in seconds
session.setTotalTimerTime(840)
session.setTotalDistance(500)         // metres
session.setPoolLength(25.0)           // metres
session.setPoolLengthUnit(FITDisplayMeasureMetric)
session.setNumLengths(20)
session.setNumActiveLengths(20)
session.setTotalStrokes(400)
session.setFirstLapIndex(0)
session.setNumLaps(1)

// Lap for first 250 m
let lap = FITLapMesg()
lap.setMessageIndex(0)
lap.setStartTime(FITDate())
lap.setTimestamp(FITDate())
lap.setTotalElapsedTime(420)
lap.setTotalDistance(250)
lap.setSport(FITSportSwimming)
lap.setSubSport(FITSubSportLapSwimming)
lap.setNumLengths(10)
lap.setNumActiveLengths(10)

// Individual pool length
let length = FITLengthMesg()
length.setMessageIndex(0)
length.setStartTime(FITDate())
length.setTotalElapsedTime(42.0)       // seconds
length.setTotalTimerTime(42.0)
length.setLengthType(FITLengthTypeActive)
length.setSwimStroke(FITSwimStrokeFreestyle)
length.setTotalStrokes(20)
length.setAvgSwimmingCadence(FITUInt8((20.0 * 60) / 42.0))  // strokes/min

print("Pool length avg speed: \(25.0 / 42.0) m/s")
```

--------------------------------

### Create and Write a .fit file with FITEncoder

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Use FITEncoder to create a new .fit file. The file must start with a FITFileIdMesg and end with a FITActivityMesg. The encoder handles writing the file header and calculating the CRC.

```swift
import ObjcFIT

let encoder = FITEncoder(version: .V20)
let filePath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]
    + "/myActivity.fit"

guard encoder.open(filePath) else { fatalError("Could not open file") }

// Every FIT file MUST start with a FileId message
let startTime = FITDate()
let fileId = FITFileIdMesg()
fileId.setType(FITFileActivity)
fileId.setManufacturer(FITManufacturerDevelopment)
fileId.setProduct(0)
fileId.setTimeCreated(startTime)
fileId.setSerialNumber(UInt32.random(in: 1..<UInt32.max))
encoder.write(fileId)

// Write a single record
let record = FITRecordMesg()
record.setTimestamp(startTime)
record.setHeartRate(142)
record.setSpeed(3.2)
record.setDistance(0)
encoder.write(record)

// Bulk-write an array
let moreMessages: [FITMessage] = [/*...*/]
encoder.writeMessages(moreMessages)

// Finalize: updates data size in header and calculates CRC
let ok = encoder.close()   // returns false only if the file was never opened
```

--------------------------------

### FITDeveloperField - Custom application-defined fields

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

`FITDeveloperField` allows third-party applications to attach custom metrics to standard FIT messages, identified by a GUID and described by a `FITFieldDescriptionMesg`.

```APIDOC
## FITDeveloperField

### Description
`FITDeveloperField` lets third-party apps attach custom metrics to standard messages. A `FITDeveloperDataIdMesg` identifies the application (16-byte GUID + version), and a `FITFieldDescriptionMesg` describes each custom field (name, units, base type, optional native field mapping). The developer field is then instantiated and attached to any `FITMessage`.

### Usage Example
```swift
import ObjcFIT

// 1. Identify the developer/application
let devId = FITDeveloperDataIdMesg()
let guid: [UInt8] = [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
                     0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f]
guid.enumerated().forEach { devId.setApplicationId($1, for: $0) }
devId.setDeveloperDataIndex(0)
devId.setApplicationVersion(110)

// 2. Describe the custom field
let powerZoneDesc = FITFieldDescriptionMesg()
powerZoneDesc.setDeveloperDataIndex(0)
powerZoneDesc.setFieldDefinitionNumber(0)
powerZoneDesc.setFitBaseTypeId(FITFitBaseTypeUint8)
powerZoneDesc.setFieldName("Power Zone", for: 0)
powerZoneDesc.setUnits("zone", for: 0)
powerZoneDesc.setNativeMesgNum(FITMesgNumRecord)

// 3. Create and populate the developer field
let zoneField = FITDeveloperField(fieldDescriptionMesg: powerZoneDesc,
                                  andDeveloperDataIdMesg: devId)
zoneField.addValue(NSNumber(value: 4), for: 0)   // zone 4

// 4. Attach to a message
let record = FITRecordMesg()
record.setTimestamp(FITDate())
record.setHeartRate(168)
record.add(zoneField)

// 5. Read back
let retrieved = zoneField.getValueFor(0)   // NSNumber → .intValue == 4

// String developer field
let effortDesc = FITFieldDescriptionMesg()
effortDesc.setDeveloperDataIndex(0)
effortDesc.setFieldDefinitionNumber(1)
effortDesc.setFitBaseTypeId(FITFitBaseTypeString)
effortDesc.setFieldName("Effort", for: 0)
let effortField = FITDeveloperField(fieldDescriptionMesg: effortDesc,
                                    andDeveloperDataIdMesg: devId)
effortField.addStringValue("Hard", for: 0)
print(effortField.getStringValue(for: 0))   // "Hard"
```
```

--------------------------------

### Import FIT SDK Modules in Swift

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Import the necessary modules for using the FIT SDK in Swift projects. Use `ObjcFIT` for basic decode/encode functionality and `SwiftFIT` for the high-level FITListener and FITMessages API.

```swift
// Swift — basic decode/encode (no FITListener)
import ObjcFIT

// Swift — high-level FITListener + FITMessages API
import ObjcFIT
import SwiftFIT
```

--------------------------------

### Swift Package Manager Dependency Configuration

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Configure your Swift package's `Package.swift` file to include the FIT SDK as a dependency. Specify the URL and version, and then list the 'FIT' product as a dependency for your target.

```swift
// Package.swift dependency (when used in another package)
dependencies: [
    .package(url: "https://github.com/garmin/fit-objective-c-sdk", from: "21.202.0")
],
targets: [
    .target(name: "MyTarget", dependencies: [
        .product(name: "FIT", package: "fit-objective-c-sdk")
    ])
]
```

--------------------------------

### Create and Populate FITRecordMesg

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Instantiate a FITRecordMesg and populate it with various activity data points. Use validation methods before reading values. Array fields require setting values for specific indices.

```swift
import ObjcFIT

let record = FITRecordMesg()
record.setTimestamp(FITDate())
record.setPositionLat(FITSInt32(37.3382 * 11_930_465))   // degrees → semicircles
record.setPositionLong(FITSInt32(-121.8863 * 11_930_465))
record.setAltitude(25.0)          // metres
record.setHeartRate(155)          // bpm
record.setCadence(90)             // rpm
record.setSpeed(8.3)              // m/s
record.setPower(280)              // watts
record.setDistance(1500.0)        // metres

// Validate before reading
if record.isHeartRateValid() {
    print("Heart rate: \(record.getHeartRate()) bpm")
}

// Array field — left power phase (two values: start and end degrees)
record.setLeftPowerPhase(45.0, forIndex: 0)
record.setLeftPowerPhase(180.0, forIndex: 1)
print("Left power phase count: \(record.numLeftPowerPhaseValues)")  // 2

// Copy constructor
let copy = FITRecordMesg(message: record)
print(copy.getSpeed())   // 8.3
```

--------------------------------

### Import FIT SDK Module in Objective-C

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Import the `ObjcFIT` module for using the FIT SDK in Objective-C projects.

```objc
// Objective-C
@import ObjcFIT;
```

--------------------------------

### Encode Full Activity File

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

This Swift function demonstrates how to construct and encode a complete activity .fit file. It includes mandatory and best-practice messages in the correct order. Ensure the ObjcFIT framework is imported.

```swift
import ObjcFIT

func encodeActivity(to path: String) {
    let startTime = FITDate()
    var ts = FITDate(fitDate: startTime)

    // FileId — mandatory first message
    let fileId = FITFileIdMesg()
    fileId.setType(FITFileActivity)
    fileId.setManufacturer(FITManufacturerDevelopment)
    fileId.setProduct(0)
    fileId.setSerialNumber(UInt32.random(in: 1..<UInt32.max))
    fileId.setTimeCreated(startTime)

    // DeviceInfo — best practice
    let devInfo = FITDeviceInfoMesg()
    devInfo.setDeviceIndex(FITDeviceIndexCreator)
    devInfo.setManufacturer(FITManufacturerDevelopment)
    devInfo.setProductName("MyApp")
    devInfo.setTimestamp(startTime)

    // Timer start event — best practice
    let evtStart = FITEventMesg()
    evtStart.setTimestamp(startTime)
    evtStart.setEvent(FITEventTimer)
    evtStart.setEventType(FITEventTypeStart)

    // Build 60 seconds of record data
    var records: [FITMessage] = []
    for i in 0..<60 {
        let rec = FITRecordMesg()
        rec.setTimestamp(ts)
        rec.setDistance(FITFloat32(i * 3))
        rec.setSpeed(3.0)
        rec.setHeartRate(FITUInt8(140 + i % 10))
        records.append(rec)
        ts = ts.addingTimeInterval(1)
    }

    // Timer stop event
    let evtStop = FITEventMesg()
    evtStop.setTimestamp(ts)
    evtStop.setEvent(FITEventTimer)
    evtStop.setEventType(FITEventTypeStopAll)

    // Lap — at least one required
    let lap = FITLapMesg()
    lap.setMessageIndex(0)
    lap.setTimestamp(ts)
    lap.setStartTime(startTime)
    lap.setTotalElapsedTime(FITFloat32(ts.timestamp - startTime.timestamp))
    lap.setTotalTimerTime(FITFloat32(ts.timestamp - startTime.timestamp))

    // Session — at least one required
    let session = FITSessionMesg()
    session.setMessageIndex(0)
    session.setTimestamp(ts)
    session.setStartTime(startTime)
    session.setTotalElapsedTime(FITFloat32(ts.timestamp - startTime.timestamp))
    session.setTotalTimerTime(FITFloat32(ts.timestamp - startTime.timestamp))
    session.setSport(FITSportRunning)
    session.setSubSport(FITSubSportGeneric)
    session.setFirstLapIndex(0)
    session.setNumLaps(1)

    // Activity — exactly one required, must be last
    let activity = FITActivityMesg()
    activity.setTimestamp(ts)
    activity.setNumSessions(1)
    activity.setTotalTimerTime(session.getTotalTimerTime())
    activity.setLocalTimestamp(FITLocalDateTime(Int(ts.timestamp) + TimeZone.current.secondsFromGMT()))

    // Encode
    let encoder = FITEncoder(version: .V20)
    guard encoder.open(path) else { fatalError("Cannot create file at \(path)") }
    encoder.write(fileId)
    encoder.write(devInfo)
    encoder.write(evtStart)
    encoder.writeMessages(records)
    encoder.write(evtStop)
    encoder.write(lap)
    encoder.write(session)
    encoder.write(activity)
    guard encoder.close() else { fatalError("Failed to finalize FIT file") }
    print("Wrote activity to \(path)")
}

encodeActivity(to: NSTemporaryDirectory() + "test_activity.fit")
```

--------------------------------

### Import ObjcFIT Module

Source: https://github.com/garmin/fit-objective-c-sdk/blob/main/README.md

Import the ObjcFIT module to use the SDK in your Swift or Objective-C project. For Swift projects, SwiftFIT also needs to be imported when using FITListener and FITMessages classes.

```swift
import ObjcFIT  // Swift
```

```objectivec
@import ObjcFIT // Objective C
```

```swift
import SwiftFIT // Swift
```

--------------------------------

### FITListener: Swift-only High-Level FIT Decode API

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Utilize FITListener for a Swift-only high-level API to decode FIT files and access messages through typed arrays. This simplifies message aggregation and retrieval after decoding.

```swift
import ObjcFIT
import SwiftFIT

let decoder = FITDecoder()
let listener = FITListener()
decoder.mesgDelegate = listener

guard decoder.isFIT("/path/to/activity.fit"),
      decoder.decodeFile("/path/to/activity.fit") else {
    fatalError("Decode failed")
}

let messages = listener.messages

// File identity
let fileId = messages.getFileIdMesgs().first!
print("File type: \(fileId.getType())")   // e.g. FITFileActivity

// Session summary
for session in messages.getSessionMesgs() {
    print("Sport: \(session.getSport())")
    print("Total time: \(session.getTotalElapsedTime()) s")
    print("Total distance: \(session.getTotalDistance()) m")
}

// Per-second GPS + biometric data
for record in messages.getRecordMesgs() {
    if record.isPositionLatValid(), record.isPositionLongValid() {
        let lat = Double(record.getPositionLat()) / 11930465.0  // semicircles → degrees
        let lon = Double(record.getPositionLong()) / 11930465.0
        print("(\(lat), \(lon))  HR=\(record.getHeartRate()) bpm")
    }
}

// HRV intervals
for hrv in messages.getHrvMesgs() {
    for i in 0..<hrv.numTimeValues {
        print("R-R interval[\(i)]: \(hrv.getTimeforIndex(i)) s")
    }
}
```

--------------------------------

### FITRecordMesg - Per-second activity data

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

`FITRecordMesg` captures detailed per-second activity data, including GPS, biometrics, and power. It follows a `isFooValid()/getFoo()/setFoo(_:)` pattern for fields, with additional support for array fields.

```APIDOC
## FITRecordMesg

### Description
`FITRecordMesg` is the most field-rich message type, carrying GPS coordinates, biometrics, power, and environmental data sampled once per second. Every field follows the `isFooValid() / getFoo() / setFoo(_:)` pattern. Array fields (e.g., compressed speed/distance, power phase) additionally expose a `numFooValues` count and index-based accessors.

### Usage Example
```swift
import ObjcFIT

let record = FITRecordMesg()
record.setTimestamp(FITDate())
record.setPositionLat(FITSInt32(37.3382 * 11_930_465))   // degrees → semicircles
record.setPositionLong(FITSInt32(-121.8863 * 11_930_465))
record.setAltitude(25.0)          // metres
record.setHeartRate(155)          // bpm
record.setCadence(90)             // rpm
record.setSpeed(8.3)              // m/s
record.setPower(280)              // watts
record.setDistance(1500.0)        // metres

// Validate before reading
if record.isHeartRateValid() {
    print("Heart rate: \(record.getHeartRate()) bpm")
}

// Array field — left power phase (two values: start and end degrees)
record.setLeftPowerPhase(45.0, forIndex: 0)
record.setLeftPowerPhase(180.0, forIndex: 1)
print("Left power phase count: \(record.numLeftPowerPhaseValues)")  // 2

// Copy constructor
let copy = FITRecordMesg(message: record)
print(copy.getSpeed())   // 8.3
```
```

--------------------------------

### FITMessageBroadcaster: Route FIT Messages to Specific Delegates

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Use FITMessageBroadcaster to route decoded FIT messages to type-specific delegates. Implement FITMesgDelegate and strongly-typed delegate properties for custom handling.

```swift
import ObjcFIT

class ActivityHandler: NSObject, FITMesgDelegate, FITSessionMesgDelegate, FITRecordMesgDelegate {
    var totalDistance: Float = 0

    func onMesg(_ message: FITMessage) {
        // called for every message, regardless of type
    }
    func onSessionMesg(_ message: FITSessionMesg) {
        print("Sport: \(message.getSport()), Duration: \(message.getTotalElapsedTime()) s")
    }
    func onRecordMesg(_ message: FITRecordMesg) {
        if message.isDistanceValid() { totalDistance = message.getDistance() }
    }
}

let handler = ActivityHandler()
let broadcaster = FITMessageBroadcaster()
let decoder = FITDecoder()

decoder.mesgDelegate = broadcaster
broadcaster.mesgDelegate = handler          // generic catch-all
broadcaster.fitSessionMesgDelegate = handler
broadcaster.fitRecordMesgDelegate = handler

_ = decoder.decodeFile("/path/to/activity.fit")
print("Final distance: \(handler.totalDistance) m")
```

--------------------------------

### FITMessage - Low-level generic field access

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

`FITMessage` provides base-level access to FIT message data, including raw field retrieval by number, index, and sub-field, as well as developer field attachment.

```APIDOC
## FITMessage

### Description
`FITMessage` is the base class for all typed message classes and also the type delivered to `FITMesgDelegate.onMesg(_:)`. It exposes raw field access by field number, array index, and sub-field index, plus developer-field attachment. Prefer the typed subclasses (e.g., `FITRecordMesg`) over these low-level methods in normal usage.

### Usage Example
```swift
import ObjcFIT

// Received in a FITMesgDelegate callback
func onMesg(_ mesg: FITMessage) {
    print("Message number: \(mesg.getNum())")   // e.g. FITMesgNumRecord

    // Attach a developer field
    // mesg.addDeveloperField(myDevField)

    // Read all attached developer fields
    let devFields = mesg.getDeveloperFields() as! [FITDeveloperField]
    for df in devFields {
        print("Dev field name: \(df.definition.getFieldName(for: 0) ?? "")")
    }

    // Subfield support check
    let supported = mesg.canField(3, supportSubField: 0)

    // Raw typed read (field 6 = distance in FITRecordMesg)
    let rawDistance = mesg.getFieldFLOAT32Value(forField: 6,
                                                forIndex: 0,
                                                andSubFieldIndex: FITSubFieldIndexMainField)
    print("Raw distance: \(rawDistance)")
}
```
```

--------------------------------

### Validate and Decode a .fit file with FITDecoder

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Use FITDecoder to check if a file is a FIT file and validate its integrity (CRC check) before decoding. Register a FITMesgDelegate to receive decoded messages.

```swift
import ObjcFIT

// --- Simple validation ---
let decoder = FITDecoder()
let path = "/path/to/activity.fit"

guard decoder.isFIT(path) else { fatalError("Not a FIT file") }
guard decoder.checkIntegrity(path) else { fatalError("CRC check failed") }

// --- Decode using a custom delegate ---
class MyDelegate: NSObject, FITMesgDelegate {
    func onMesg(_ mesg: FITMessage) {
        if mesg.getNum() == FITMesgNumRecord {
            let record = FITRecordMesg(message: mesg)
            if record.isHeartRateValid() {
                print("HR: \(record.getHeartRate()) bpm")
            }
            if record.isDistanceValid() {
                print("Distance: \(record.getDistance()) m")
            }
        }
    }
}

let delegate = MyDelegate()
decoder.mesgDelegate = delegate
let success = decoder.decodeFile(path)
// success == true on normal completion
```

--------------------------------

### FITDate: Manage FIT Epoch Timestamps

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Use FITDate to manage Garmin's FIT epoch timestamps, which include seconds and optional sub-second precision. It provides interoperability with NSDate/Date and supports arithmetic and comparison operations.

```swift
import ObjcFIT

// Current time as FITDate
let now = FITDate()

// From a Swift/ObjC Date
let swiftDate = Date()
let fitDate = FITDate(date: swiftDate)

// From a raw FIT timestamp (seconds since Garmin epoch)
let fromRaw = FITDate(timestamp: 1_000_000_000)

// With sub-second precision
let precise = FITDate(timestamp: 1_000_000_000, andFractionalTimestamp: 0.5)

// Convert back to NSDate / Date
let nsDate: NSDate = FITDate.date(from: now) as NSDate
let rawUInt32: FITDateTime = FITDate.fitDateTime(from: swiftDate)

// Arithmetic — used when building activity record timestamps
var ts = FITDate(fitDate: now)
for _ in 0..<3600 {
    ts = ts.addingTimeInterval(1)   // advance by 1 second
}
let elapsed = ts.timeInterval(since: now)   // → 3600.0

// Comparison
let earlier = FITDate(date: Date(timeIntervalSinceNow: -3600))
print(now.compare(earlier))   // .orderedDescending
print(now.laterDate(earlier) === now)   // true
```

--------------------------------

### Define and Attach FITDeveloperField

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Use FITDeveloperField to attach custom application-defined metrics to standard FIT messages. This involves identifying the developer, describing the custom field, creating the developer field instance, and attaching it to a message.

```swift
import ObjcFIT

// 1. Identify the developer/application
let devId = FITDeveloperDataIdMesg()
let guid: [UInt8] = [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
                     0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f]
guid.enumerated().forEach { devId.setApplicationId($1, for: $0) }
devId.setDeveloperDataIndex(0)
devId.setApplicationVersion(110)

// 2. Describe the custom field
let powerZoneDesc = FITFieldDescriptionMesg()
powerZoneDesc.setDeveloperDataIndex(0)
powerZoneDesc.setFieldDefinitionNumber(0)
powerZoneDesc.setFitBaseTypeId(FITFitBaseTypeUint8)
powerZoneDesc.setFieldName("Power Zone", for: 0)
powerZoneDesc.setUnits("zone", for: 0)
powerZoneDesc.setNativeMesgNum(FITMesgNumRecord)

// 3. Create and populate the developer field
let zoneField = FITDeveloperField(fieldDescriptionMesg: powerZoneDesc,
                                  andDeveloperDataIdMesg: devId)
zoneField.addValue(NSNumber(value: 4), for: 0)   // zone 4

// 4. Attach to a message
let record = FITRecordMesg()
record.setTimestamp(FITDate())
record.setHeartRate(168)
record.add(zoneField)

// 5. Read back
let retrieved = zoneField.getValueFor(0)   // NSNumber → .intValue == 4

// String developer field
let effortDesc = FITFieldDescriptionMesg()
effortDesc.setDeveloperDataIndex(0)
effortDesc.setFieldDefinitionNumber(1)
effortDesc.setFitBaseTypeId(FITFitBaseTypeString)
effortDesc.setFieldName("Effort", for: 0)
let effortField = FITDeveloperField(fieldDescriptionMesg: effortDesc,
                                    andDeveloperDataIdMesg: devId)
effortField.addStringValue("Hard", for: 0)
print(effortField.getStringValue(for: 0))   // "Hard"
```

--------------------------------

### Generic FITMessage Field Access

Source: https://context7.com/garmin/fit-objective-c-sdk/llms.txt

Access raw field data from a FITMessage, which is the base class for all typed message classes. This method is useful for accessing developer fields and raw typed values by field number, index, and sub-field index.

```swift
import ObjcFIT

// Received in a FITMesgDelegate callback
func onMesg(_ mesg: FITMessage) {
    print("Message number: \(mesg.getNum())")   // e.g. FITMesgNumRecord

    // Attach a developer field
    // mesg.addDeveloperField(myDevField)

    // Read all attached developer fields
    let devFields = mesg.getDeveloperFields() as! [FITDeveloperField]
    for df in devFields {
        print("Dev field name: \(df.definition.getFieldName(for: 0) ?? "")")
    }

    // Subfield support check
    let supported = mesg.canField(3, supportSubField: 0)

    // Raw typed read (field 6 = distance in FITRecordMesg)
    let rawDistance = mesg.getFieldFLOAT32Value(forField: 6,
                                                forIndex: 0,
                                                andSubFieldIndex: FITSubFieldIndexMainField)
    print("Raw distance: \(rawDistance)")
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.