dualsense-ts

import { PulseOptions, Brightness, MuteLedMode } from "./command"; import { HIDProvider, DualsenseHIDState } from "./hid_provider"; import { FirmwareInfo } from "./firmware_info"; import { FactoryInfo } from "./factory_info"; import type { ResolvedCalibration } from "./calibration"; export type HIDCallback = (state: DualsenseHIDState) => void; export type ErrorCallback = (error: Error) => void; export type ReadyCallback = () => void; export type ConnectionCallback = (connected: boolean) => void; /** Coordinates a HIDProvider and tracks the latest HID state */ export declare class DualsenseHID { readonly provider: HIDProvider; /** Subscribers waiting for HID state updates */ private readonly subscribers; /** Subscribers waiting for error updates */ private readonly errorSubscribers; /** Subscribers waiting for firmware/factory info to become available */ private readonly readySubscribers; /** Subscribers tracking transport-level connect/disconnect events */ private readonly connectionSubscribers; /** True once firmware/factory info has been loaded for the current connection */ private identityResolved; /** Pending retry timer for identity loading after a transient failure */ private identityRetryTimer?; /** Number of identity-load attempts made for the current connection */ private identityRetryCount; /** Queue of pending HID commands */ private pendingCommands; /** Most recent HID state of the device */ state: DualsenseHIDState; /** Firmware and hardware information, populated after connection */ firmwareInfo: FirmwareInfo; /** Factory information (serial, color, board revision), populated after connection */ factoryInfo: FactoryInfo; /** Bluetooth MAC address from Feature Report 0x09, populated after connection */ macAddress?: string; /** * Precomputed IMU calibration factors, populated during provider connection. * Applied automatically to gyro and accelerometer readings in each input report. */ get calibration(): ResolvedCalibration; /** Active interval timer for the command flush loop */ private commandTimer?; constructor(provider: HIDProvider, refreshRate?: number); /** Stop the command flush loop and cancel pending identity retries */ dispose(): void; get wireless(): boolean; /** Register a handler for HID state updates */ register(callback: HIDCallback): void; /** Cancel a previously registered handler */ unregister(callback: HIDCallback): void; /** Add a subscriber for errors */ on(type: string, callback: ErrorCallback): void; /** * Subscribe to notification when firmware/factory info finishes loading * after a connect. Fires once per connection — either when identity has * been resolved, or when we've given up retrying. If identity is already * resolved at the time of subscription, the callback fires synchronously. */ onReady(callback: ReadyCallback): () => void; /** True if firmware/factory info has been loaded (or given up on) for the current connection */ get ready(): boolean; /** * Subscribe to transport-level connect/disconnect events. Useful for * mirroring connection state into an Input without polling. Returns * an unsubscribe function. */ onConnectionChange(callback: ConnectionCallback): () => void; /** * Stable hardware identity for this controller, derived from the most * trustworthy info available. Prefers the Bluetooth MAC address (from * Feature Report 0x09, works on every transport and platform), then * falls back to the factory serial, then firmware deviceInfo. * Returns undefined until identity info has been read. */ get identity(): string | undefined; /** Update the HID state and pass it along to all state subscribers */ private set; /** Pass errors along to all error subscribers */ private handleError; /** Maximum identity-load retry attempts per connection */ private static readonly IDENTITY_MAX_ATTEMPTS; /** Backoff schedule (ms) for identity-load retries */ private static readonly IDENTITY_BACKOFF_MS; /** * Attempt to read firmware + factory info for the current connection, * with retry on failure. Marks identity as resolved on success or after * exhausting all attempts (so consumers don't wait forever). * * If cached firmware/factory info exists from a prior session, identity * is resolved immediately (so the connection event has full details), * then a background verification re-reads the device to confirm. */ private loadIdentity; /** Mark identity loading as complete and notify subscribers */ private markIdentityResolved; /** Cancel any pending identity-load retry */ private cancelIdentityRetry; /** In-flight firmware info fetch, deduped across callers within a connection */ private firmwareFetch?; /** In-flight factory info fetch, deduped across callers within a connection */ private factoryFetch?; /** * Read firmware info from the controller (Feature Report 0x20). * Idempotent: returns the cached value if already fetched, or the * in-flight promise if a fetch is already underway. */ fetchFirmwareInfo(): Promise<FirmwareInfo>; /** * Read factory info (serial number, body color, board revision) from the controller. * Requires firmware info to be fetched first for feature gating. * Idempotent across the lifetime of a single connection. */ fetchFactoryInfo(): Promise<FactoryInfo>; /** Condense all pending commands into one HID feature report */ private static buildFeatureReport; /** Set intensity for left and right rumbles */ setRumble(left: number, right: number): void; /** Set left trigger effect from an 11-byte effect block */ setLeftTriggerFeedback(block: Uint8Array): void; /** Set right trigger effect from an 11-byte effect block */ setRightTriggerFeedback(block: Uint8Array): void; /** Set microphone mute LED mode */ setMicrophoneLED(mode: MuteLedMode): void; /** Set player indicator LEDs from a 5-bit bitmask and brightness */ setPlayerLeds(bitmask: number, brightness?: Brightness): void; /** Set headphone volume (0x00–0x7F) */ setHeadphoneVolume(volume: number): void; /** Set internal speaker volume (0x00–0x64, where 0x64 is full volume) */ setSpeakerVolume(volume: number): void; /** Set internal microphone volume (0x00–0x40) */ setMicrophoneVolume(volume: number): void; /** Set audio output routing and microphone flags */ setAudioFlags(flags: number): void; /** Set power save control bitfield (per-subsystem mute/disable) */ setPowerSave(flags: number): void; /** Set speaker preamp gain (0–7) and optional beam forming */ setSpeakerPreamp(gain: number, beamForming?: boolean): void; /** Set the light bar color and pulse effect */ setLightbar(r: number, g: number, b: number, pulse?: PulseOptions): void; /** Feature report ID for DSP test commands */ private static readonly TEST_REPORT_ID; /** DSP device ID for audio subsystem */ private static readonly DSP_DEVICE_AUDIO; /** Action ID: configure output routing before waveout */ private static readonly DSP_ACTION_CONFIGURE; /** Action ID: start or stop waveform playback */ private static readonly DSP_ACTION_WAVEOUT; /** * Build a feature report 0x80 payload. * Format: [reportId, deviceId, actionId, ...params] */ private static buildTestCommand; /** * Start a DSP test tone on speaker or headphone. * Sets volume routing via the standard output report before triggering. * * @param target Output destination — "speaker" (default) or "headphone" * @param tone Which tone to play — "1khz" (default), "100hz", or "both" */ startTestTone(target?: "speaker" | "headphone", tone?: "1khz" | "100hz" | "both"): Promise<void>; /** Stop the DSP test tone */ stopTestTone(): Promise<void>; /** * Send a raw DSP test command (Feature Report 0x80). * For experimentation — lets you send arbitrary device/action/params. */ sendTestCommand(deviceId: number, actionId: number, params?: Uint8Array): Promise<void>; /** Feature report ID for DSP test responses */ private static readonly TEST_RESPONSE_ID; /** * Read the DSP test response (Feature Report 0x81). * Returns the raw response bytes, or undefined if not available. */ readTestResponse(): Promise<Uint8Array | undefined>; } //# sourceMappingURL=dualsense_hid.d.ts.map