MIDI2Kit

Unified high-level API for MIDI 2.0 applications. MIDI2Client provides automatic device discovery, Property Exchange, and event streaming.

MIDI2Client

The main entry point for MIDI 2.0 applications. Manages device discovery, Property Exchange, and event streaming.

Initialization

// Basic initialization
let client = try MIDI2Client(name: "MyApp")

// With custom configuration
var config = MIDI2ClientConfiguration()
config.discoveryInterval = .seconds(10)
config.peTimeout = .seconds(5)
let client = try MIDI2Client(name: "MyApp", configuration: config)

// With preset for KORG BLE MIDI devices
let client = try MIDI2Client(name: "MyApp", preset: .korgBLEMIDI)

Lifecycle Methods

Properties

Property Exchange Methods

// Get device info
let info = try await client.getDeviceInfo(from: device.muid)

// Get resource list
let resources = try await client.getResourceList(from: device.muid)

// Generic GET
let response = try await client.get("Volume", from: device.muid)

// Generic SET
try await client.set("Volume", data: ["level": 80], to: device.muid)

Diagnostics

// Get comprehensive diagnostics
let diagnostics = await client.diagnostics
print(diagnostics.lastDestinationDiagnostics)
print(diagnostics.lastCommunicationTrace)

MIDI2Device

Wrapper for discovered MIDI-CI devices with automatic caching and type-safe property access.

Properties

Cached Properties

// These are automatically cached after first fetch
let info = try await device.deviceInfo       // DeviceInfo
let resources = try await device.resourceList // [ResourceListEntry]

// Invalidate cache to force refresh
await device.invalidateCache()

Type-Safe Property Access

// Define your property type
struct VolumeInfo: Codable {
    let level: Int
    let muted: Bool
}

// Get with type inference
if let volume = try await device.getProperty("Volume", as: VolumeInfo.self) {
    print("Level: \(volume.level), Muted: \(volume.muted)")
}

// Set property
try await device.setProperty("Volume", value: VolumeInfo(level: 80, muted: false))

MockDevice

Built-in MIDI-CI Responder for testing without hardware. Simulate devices with customizable presets.

Creating a MockDevice

import MIDI2Kit
import MIDI2Transport

// Create loopback transport pair
let (initiatorTransport, responderTransport) = LoopbackTransport.createPair()

// Create mock device with preset
let mockDevice = MockDevice(
    transport: responderTransport,
    preset: .korgModulePro
)
try await mockDevice.start()

Available Presets

Testing with MockDevice

// Set up initiator side
let ciManager = CIManager(transport: initiatorTransport, ...)
let peManager = PEManager(transport: initiatorTransport, ...)
try await ciManager.start()

// Discover the mock device
await ciManager.startDiscovery()
// MockDevice responds to Discovery Inquiry automatically

// PE operations work exactly like with real devices
let response = try await peManager.get("DeviceInfo", from: mockDevice.handle)

// Custom resources
await mockDevice.setResource("CustomProp", value: ["key": "value"])

MIDI2ClientConfiguration

Configuration options for MIDI2Client behavior.

Discovery Settings

Property Exchange Settings

Resilience Settings

Configuration Presets

Pre-configured settings optimized for common scenarios.

// Use preset
let client = try MIDI2Client(name: "MyApp", preset: .korgBLEMIDI)

// Or apply preset to existing config
var config = MIDI2ClientConfiguration()
config.applyPreset(.korgBLEMIDI)
config.peTimeout = .seconds(15)  // Further customize
let client = try MIDI2Client(name: "MyApp", configuration: config)

MIDI2ClientEvent

Events emitted by MIDI2Client during operation.

for await event in await client.makeEventStream() {
    switch event {
    case .deviceDiscovered(let device):
        print("Found: \(device.displayName)")
    case .deviceLost(let muid):
        print("Lost: \(muid)")
    case .notification(let notification):
        print("Property changed: \(notification.resource)")
    case .error(let error):
        print("Error: \(error)")
    default:
        break
    }
}

MIDI2Error

Structured errors for MIDI2Kit operations.

do {
    let info = try await client.getDeviceInfo(from: device.muid)
} catch let error as MIDI2Error {
    switch error {
    case .deviceNotResponding(let muid, let resource, let timeout):
        print("Device \(muid) timed out after \(timeout)")
    case .propertyNotSupported(let resource):
        print("Property '\(resource)' not supported")
    default:
        print("Error: \(error)")
    }
}