Core Types

struct ImuSample {
    Timestamp timestamp;                 // device clock
    uint64_t  sequence;                  // monotonic; gaps = wire loss
    float     acceleration[3];           // m/s^2
    float     angular_velocity[3];       // rad/s
    float     temperature_c;
};

struct SensorsData {                     // filled by retrieve_imu()
    std::vector<ImuSample> samples;      // all samples since the last drain
    uint64_t     dropped;                // host ring overruns
    MOTION_STATE motion_state;           // STATIC / MOVING / FALLING
};

struct DeviceInformation {
    std::string  serial;             // full serial (may be non-numeric)
    unsigned int serial_number;      // numeric form; 0 when not numeric
    MODEL        model;
    std::string  model_name;
    std::string  hw_rev;
    unsigned int firmware_version;
    std::string  firmware_version_str;    // human-readable "XX.XX.XX"
    INPUT_TYPE   input_type;
    CameraConfiguration  camera_configuration;    // resolution, fps, codec, calibration
    SensorsConfiguration sensors_configuration;   // IMU params + extrinsics
    WirelessConfiguration wireless;               // WiFi/BT state
    Capabilities         capabilities;            // enabled modes + codecs

    // Access + at-rest state, reported on the ungated GetDeviceInformation, so a
    // host can read these before authenticating.
    bool usb_locked;                 // USB gates like BLE; authenticate first
    bool session_unlocked;           // read WITH usb_locked, not instead of it
    bool encryption_enabled;         // new recordings will be encrypted
    bool encryption_key_present;     // a key exists
    std::string encryption_key_id;   // "" when absent; never the key itself
    ENCRYPTION_ALGORITHM encryption_algorithm;
};

struct HealthStatus {
    CAMERA_STATE camera;             // live availability
    SENSOR_STATE imu;
    bool         passed;             // last sweep: no probe failed
    bool         deep;               // stress tier included
    std::vector<HealthCheck> checks; // per-probe {name, passed, detail}
    Timestamp    timestamp;
};

struct RecordingStatus {
    std::string      name;
    RECORDING_TARGET target;
    bool     recording;
    bool     encrypted;              // read off the file, not from the setting
    STOP_REASON stopped_reason;      // why the session ended (>= v00.09.16)
    bool     partial;                // unrepaired power-loss torso, served as-is
    uint64_t bytes, frames, duration_ms;
    uint64_t storage_free_bytes, storage_total_bytes;
    UPLOAD_STATE upload;             // + upload_bytes_sent / _total
    ERROR_CODE   last_error;
};

struct EncryptionKey {
    ENCRYPTION_ALGORITHM algorithm;
    std::vector<uint8_t> key;        // 32 bytes for AES-256-GCM
    std::string          key_id;     // first 4 bytes of SHA-256(key), hex
    bool                 present;    // false from delete: `key` is the destroyed copy
};

struct UpdateAvailability {
    bool         available;          // false when current, or nothing published
    unsigned int target_version;     // version of the bundle at `url`
    std::string  target_version_str; // display only
    std::string  url;                // empty unless available
    std::string  notes;              // optional one-line service message
    std::string  service_error;      // why no answer was usable
};

struct UpdateStatus {
    bool         active;
    UPDATE_STATE state;              // current UPDATE_STATE phase
    int          progress;           // 0-100, -1 indeterminate
    std::string  message;
    std::string  running_version;    // human-readable current firmware
    uint32_t     running_version_int, target_version_int;
    ERROR_CODE   last_error;
};