@livekit/react-native 2.5.1 → 2.6.1

package/ios/audio/AudioProcessing.swift

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Accelerate
+import AVFoundation
+import Foundation
+import livekit_react_native_webrtc
+
+public struct AudioLevel {
+    /// Linear Scale RMS Value
+    public let average: Float
+    public let peak: Float
+}
+
+public extension RTCAudioBuffer {
+    /// Convert to AVAudioPCMBuffer Int16 format.
+    @objc
+    func toAVAudioPCMBuffer() -> AVAudioPCMBuffer? {
+        guard let audioFormat = AVAudioFormat(commonFormat: .pcmFormatInt16,
+                                              sampleRate: Double(frames * 100),
+                                              channels: AVAudioChannelCount(channels),
+                                              interleaved: false),
+            let pcmBuffer = AVAudioPCMBuffer(pcmFormat: audioFormat,
+                                             frameCapacity: AVAudioFrameCount(frames))
+        else { return nil }
+
+        pcmBuffer.frameLength = AVAudioFrameCount(frames)
+
+        guard let targetBufferPointer = pcmBuffer.int16ChannelData else { return nil }
+
+        for i in 0 ..< channels {
+            let sourceBuffer = rawBuffer(forChannel: i)
+            let targetBuffer = targetBufferPointer[i]
+            // sourceBuffer is in the format of [Int16] but is stored in 32-bit alignment, we need to pack the Int16 data correctly.
+
+            for frame in 0 ..< frames {
+                // Cast and pack the source 32-bit Int16 data into the target 16-bit buffer
+                let clampedValue = max(Float(Int16.min), min(Float(Int16.max), sourceBuffer[frame]))
+                targetBuffer[frame] = Int16(clampedValue)
+            }
+        }
+
+        return pcmBuffer
+    }
+}
+
+public extension AVAudioPCMBuffer {
+    /// Computes Peak and Linear Scale RMS Value (Average) for all channels.
+    func audioLevels() -> [AudioLevel] {
+        var result: [AudioLevel] = []
+        guard let data = floatChannelData else {
+            // Not containing float data
+            return result
+        }
+
+        for i in 0 ..< Int(format.channelCount) {
+            let channelData = data[i]
+            var max: Float = 0.0
+            vDSP_maxv(channelData, stride, &max, vDSP_Length(frameLength))
+            var rms: Float = 0.0
+            vDSP_rmsqv(channelData, stride, &rms, vDSP_Length(frameLength))
+
+            // No conversion to dB, return linear scale values directly
+            result.append(AudioLevel(average: rms, peak: max))
+        }
+
+        return result
+    }
+}
+
+public extension Sequence where Iterator.Element == AudioLevel {
+    /// Combines all elements into a single audio level by computing the average value of all elements.
+    func combine() -> AudioLevel? {
+        var count = 0
+        let totalSums: (averageSum: Float, peakSum: Float) = reduce((averageSum: 0.0, peakSum: 0.0)) { totals, audioLevel in
+            count += 1
+            return (totals.averageSum + audioLevel.average,
+                    totals.peakSum + audioLevel.peak)
+        }
+
+        guard count > 0 else { return nil }
+
+        return AudioLevel(average: totalSums.averageSum / Float(count),
+                          peak: totalSums.peakSum / Float(count))
+    }
+}
+
+public class AudioVisualizeProcessor {
+    static let bufferSize = 1024
+
+    // MARK: - Public
+
+    public let minFrequency: Float
+    public let maxFrequency: Float
+    public let minDB: Float
+    public let maxDB: Float
+    public let bandsCount: Int
+
+    private var bands: [Float]?
+
+    // MARK: - Private
+
+    private let ringBuffer = RingBuffer<Float>(size: AudioVisualizeProcessor.bufferSize)
+    private let processor: FFTProcessor
+
+    public init(minFrequency: Float = 10,
+                maxFrequency: Float = 8000,
+                minDB: Float = -32.0,
+                maxDB: Float = 32.0,
+                bandsCount: Int = 100)
+    {
+        self.minFrequency = minFrequency
+        self.maxFrequency = maxFrequency
+        self.minDB = minDB
+        self.maxDB = maxDB
+        self.bandsCount = bandsCount
+
+        processor = FFTProcessor(bufferSize: Self.bufferSize)
+        bands = [Float](repeating: 0.0, count: bandsCount)
+    }
+
+    public func process(pcmBuffer: AVAudioPCMBuffer) -> [Float]? {
+        guard let pcmBuffer = pcmBuffer.convert(toCommonFormat: .pcmFormatFloat32) else { return nil }
+        guard let floatChannelData = pcmBuffer.floatChannelData else { return nil }
+
+        // Get the float array.
+        let floats = Array(UnsafeBufferPointer(start: floatChannelData[0], count: Int(pcmBuffer.frameLength)))
+        ringBuffer.write(floats)
+
+        // Get full-size buffer if available, otherwise return
+        guard let buffer = ringBuffer.read() else { return nil }
+
+        // Process FFT and compute frequency bands
+        let fftRes = processor.process(buffer: buffer)
+        let bands = fftRes.computeBands(
+            minFrequency: minFrequency,
+            maxFrequency: maxFrequency,
+            bandsCount: bandsCount,
+            sampleRate: Float(pcmBuffer.format.sampleRate)
+        )
+
+        let headroom = maxDB - minDB
+
+        // Normalize magnitudes (already in decibels)
+        return bands.magnitudes.map { magnitude in
+            let adjustedMagnitude = max(0, magnitude + abs(minDB))
+            return min(1.0, adjustedMagnitude / headroom)
+        }
+    }
+}

package/ios/audio/AudioRendererManager.swift

@@ -0,0 +1,71 @@
+import livekit_react_native_webrtc
+
+@objc
+public class AudioRendererManager: NSObject {
+    private let bridge: RCTBridge
+    public private(set) var renderers: [String: RTCAudioRenderer] = [:]
+    
+    init(bridge: RCTBridge) {
+        self.bridge = bridge
+    }
+    
+    @objc
+    public func registerRenderer(_ audioRenderer: RTCAudioRenderer) -> String {
+        let reactTag = NSUUID().uuidString
+        self.renderers[reactTag] = audioRenderer
+        return reactTag
+    }
+    
+    @objc
+    public func unregisterRenderer(forReactTag: String) {
+        self.renderers.removeValue(forKey: forReactTag)
+    }
+    
+    @objc
+    public func unregisterRenderer(_ audioRenderer: RTCAudioRenderer) {
+        self.renderers = self.renderers.filter({ $0.value !== audioRenderer })
+    }
+    
+    @objc
+    public func attach(renderer: RTCAudioRenderer, pcId: NSNumber, trackId: String) {
+        let webrtcModule = self.bridge.module(for: WebRTCModule.self) as! WebRTCModule
+        guard let track = webrtcModule.track(forId: trackId, pcId: pcId) as? RTCAudioTrack
+        else {
+            lklog("couldn't find audio track: pcId: \(pcId), trackId: \(trackId)")
+            return
+        }
+        
+        if (pcId == -1) {
+            LKAudioProcessingManager.sharedInstance().addLocalAudioRenderer(renderer);
+        } else {
+            track.add(renderer)
+        }
+    }
+    
+    @objc
+    public func detach(rendererByTag reactTag:String, pcId: NSNumber, trackId: String){
+        guard let renderer = self.renderers[reactTag]
+        else {
+            lklog("couldn't find renderer: tag: \(reactTag)")
+            return
+        }
+        
+        detach(renderer: renderer, pcId: pcId, trackId: trackId)
+    }
+    
+    @objc
+    public func detach(renderer: RTCAudioRenderer, pcId: NSNumber, trackId: String) {
+        let webrtcModule = self.bridge.module(for: WebRTCModule.self) as! WebRTCModule
+        guard let track = webrtcModule.track(forId: trackId, pcId: pcId) as? RTCAudioTrack
+        else {
+            lklog("couldn't find audio track: pcId: \(pcId), trackId: \(trackId)")
+            return
+        }
+        
+        if (pcId == -1) {
+            LKAudioProcessingManager.sharedInstance().removeLocalAudioRenderer(renderer);
+        } else {
+            track.remove(renderer)
+        }
+    }
+}

package/ios/audio/FFTProcessor.swift

@@ -0,0 +1,147 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Accelerate
+import AVFoundation
+
+extension Float {
+    var nyquistFrequency: Float { self / 2.0 }
+}
+
+public struct FFTComputeBandsResult {
+    let count: Int
+    let magnitudes: [Float]
+    let frequencies: [Float]
+}
+
+public class FFTResult {
+    public let magnitudes: [Float]
+
+    init(magnitudes: [Float]) {
+        self.magnitudes = magnitudes
+    }
+
+    func computeBands(minFrequency: Float, maxFrequency: Float, bandsCount: Int, sampleRate: Float) -> FFTComputeBandsResult {
+        let actualMaxFrequency = min(sampleRate.nyquistFrequency, maxFrequency)
+        var bandMagnitudes = [Float](repeating: 0.0, count: bandsCount)
+        var bandFrequencies = [Float](repeating: 0.0, count: bandsCount)
+
+        let magLowerRange = _magnitudeIndex(for: minFrequency, sampleRate: sampleRate)
+        let magUpperRange = _magnitudeIndex(for: actualMaxFrequency, sampleRate: sampleRate)
+        let ratio = Float(magUpperRange - magLowerRange) / Float(bandsCount)
+
+        return magnitudes.withUnsafeBufferPointer { magnitudesPtr in
+            for i in 0 ..< bandsCount {
+                let magsStartIdx = vDSP_Length(floorf(Float(i) * ratio)) + magLowerRange
+                let magsEndIdx = vDSP_Length(floorf(Float(i + 1) * ratio)) + magLowerRange
+
+                let count = magsEndIdx - magsStartIdx
+                if count > 0 {
+                    var sum: Float = 0
+                    vDSP_sve(magnitudesPtr.baseAddress! + Int(magsStartIdx), 1, &sum, count)
+                    bandMagnitudes[i] = sum / Float(count)
+                } else {
+                    bandMagnitudes[i] = magnitudes[Int(magsStartIdx)]
+                }
+
+                // Compute average frequency
+                let bandwidth = sampleRate.nyquistFrequency / Float(magnitudes.count)
+                bandFrequencies[i] = (bandwidth * Float(magsStartIdx) + bandwidth * Float(magsEndIdx)) / 2
+            }
+
+            return FFTComputeBandsResult(count: bandsCount, magnitudes: bandMagnitudes, frequencies: bandFrequencies)
+        }
+    }
+
+    @inline(__always) private func _magnitudeIndex(for frequency: Float, sampleRate: Float) -> vDSP_Length {
+        vDSP_Length(Float(magnitudes.count) * frequency / sampleRate.nyquistFrequency)
+    }
+}
+
+class FFTProcessor {
+    public enum WindowType {
+        case none
+        case hanning
+        case hamming
+    }
+
+    public let bufferSize: vDSP_Length
+    public let windowType: WindowType
+
+    private let bufferHalfSize: vDSP_Length
+    private let bufferLog2Size: vDSP_Length
+    private var window: [Float] = []
+    private var fftSetup: FFTSetup
+    private var realBuffer: [Float]
+    private var imaginaryBuffer: [Float]
+    private var zeroDBReference: Float = 1.0
+
+    init(bufferSize: Int, windowType: WindowType = .hanning) {
+        self.bufferSize = vDSP_Length(bufferSize)
+        self.windowType = windowType
+
+        bufferHalfSize = vDSP_Length(bufferSize / 2)
+        bufferLog2Size = vDSP_Length(log2f(Float(bufferSize)))
+
+        realBuffer = [Float](repeating: 0.0, count: Int(bufferHalfSize))
+        imaginaryBuffer = [Float](repeating: 0.0, count: Int(bufferHalfSize))
+        window = [Float](repeating: 1.0, count: Int(bufferSize))
+
+        fftSetup = vDSP_create_fftsetup(UInt(bufferLog2Size), FFTRadix(FFT_RADIX2))!
+
+        switch windowType {
+        case .none:
+            break
+        case .hanning:
+            vDSP_hann_window(&window, vDSP_Length(bufferSize), Int32(vDSP_HANN_NORM))
+        case .hamming:
+            vDSP_hamm_window(&window, vDSP_Length(bufferSize), 0)
+        }
+    }
+
+    deinit {
+        vDSP_destroy_fftsetup(fftSetup)
+    }
+
+    func process(buffer: [Float]) -> FFTResult {
+        precondition(buffer.count == Int(bufferSize), "Input buffer size mismatch.")
+
+        var windowedBuffer = [Float](repeating: 0.0, count: Int(bufferSize))
+
+        vDSP_vmul(buffer, 1, window, 1, &windowedBuffer, 1, bufferSize)
+
+        return realBuffer.withUnsafeMutableBufferPointer { realPtr in
+            imaginaryBuffer.withUnsafeMutableBufferPointer { imagPtr in
+                var complexBuffer = DSPSplitComplex(realp: realPtr.baseAddress!, imagp: imagPtr.baseAddress!)
+
+                windowedBuffer.withUnsafeBufferPointer { bufferPtr in
+                    let complexPtr = UnsafeRawPointer(bufferPtr.baseAddress!).bindMemory(to: DSPComplex.self, capacity: Int(bufferHalfSize))
+                    vDSP_ctoz(complexPtr, 2, &complexBuffer, 1, bufferHalfSize)
+                }
+
+                vDSP_fft_zrip(fftSetup, &complexBuffer, 1, bufferLog2Size, FFTDirection(FFT_FORWARD))
+
+                var magnitudes = [Float](repeating: 0.0, count: Int(bufferHalfSize))
+                vDSP_zvabs(&complexBuffer, 1, &magnitudes, 1, bufferHalfSize)
+
+                // Convert magnitudes to decibels
+                vDSP_vdbcon(magnitudes, 1, &zeroDBReference, &magnitudes, 1, vDSP_Length(magnitudes.count), 1)
+
+                return FFTResult(magnitudes: magnitudes)
+            }
+        }
+    }
+}

package/ios/audio/MultibandVolumeAudioRenderer.swift

@@ -0,0 +1,67 @@
+import livekit_react_native_webrtc
+import React
+
+@objc
+public class MultibandVolumeAudioRenderer: BaseMultibandVolumeAudioRenderer {
+    private let eventEmitter: RCTEventEmitter
+    
+    @objc
+    public var reactTag: String? = nil
+
+    @objc
+    public init(
+        bands: Int,
+        minFrequency: Float,
+        maxFrequency: Float,
+        intervalMs: Float,
+        eventEmitter: RCTEventEmitter
+    ) {
+        self.eventEmitter = eventEmitter
+        super.init(bands: bands,
+                   minFrequency: minFrequency,
+                   maxFrequency: maxFrequency,
+                   intervalMs: intervalMs)
+    }
+    
+    override func onMagnitudesCalculated(_ magnitudes: [Float]) {
+        guard !magnitudes.isEmpty, let reactTag = self.reactTag
+        else { return }
+        eventEmitter.sendEvent(withName: LKEvents.kEventMultibandProcessed, body: [
+            "magnitudes": magnitudes,
+            "id": reactTag
+        ])
+    }
+    
+}
+
+public class BaseMultibandVolumeAudioRenderer: NSObject, RTCAudioRenderer {
+    private let frameInterval: Int
+    private var skippedFrames = 0
+    private let audioProcessor: AudioVisualizeProcessor
+    
+    init(
+        bands: Int,
+        minFrequency: Float,
+        maxFrequency: Float,
+        intervalMs: Float
+    ) {
+        self.frameInterval = Int((intervalMs / 10.0).rounded())
+        self.audioProcessor = AudioVisualizeProcessor(minFrequency: minFrequency, maxFrequency: maxFrequency, bandsCount: bands)
+    }
+    
+    public func render(pcmBuffer: AVAudioPCMBuffer) {
+        if(skippedFrames < frameInterval - 1) {
+            skippedFrames += 1
+            return
+        }
+        
+        skippedFrames = 0
+        guard let magnitudes = audioProcessor.process(pcmBuffer: pcmBuffer)
+        else {
+            return
+        }
+        onMagnitudesCalculated(magnitudes)
+    }
+    
+    func onMagnitudesCalculated(_ magnitudes: [Float]) { }
+}

package/ios/audio/RingBuffer.swift

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+// Simple ring-buffer used for internal audio processing. Not thread-safe.
+class RingBuffer<T: Numeric> {
+    private var _isFull = false
+    private var _buffer: [T]
+    private var _head: Int = 0
+
+    init(size: Int) {
+        _buffer = [T](repeating: 0, count: size)
+    }
+
+    func write(_ value: T) {
+        _buffer[_head] = value
+        _head = (_head + 1) % _buffer.count
+        if _head == 0 { _isFull = true }
+    }
+
+    func write(_ sequence: [T]) {
+        for value in sequence {
+            write(value)
+        }
+    }
+
+    func read() -> [T]? {
+        guard _isFull else { return nil }
+
+        if _head == 0 {
+            return _buffer // Return the entire buffer if _head is at the start
+        } else {
+            // Return the buffer in the correct order
+            return Array(_buffer[_head ..< _buffer.count] + _buffer[0 ..< _head])
+        }
+    }
+}

package/ios/audio/VolumeAudioRenderer.swift

@@ -0,0 +1,50 @@
+import livekit_react_native_webrtc
+import React
+
+@objc
+public class VolumeAudioRenderer: BaseVolumeAudioRenderer {
+    private let eventEmitter: RCTEventEmitter
+    
+    @objc
+    public var reactTag: String? = nil
+    
+    @objc
+    public init(intervalMs: Double, eventEmitter: RCTEventEmitter) {
+        self.eventEmitter = eventEmitter
+        super.init(intervalMs: intervalMs)
+    }
+    
+    override public func onVolumeCalculated(_ audioLevels: [AudioLevel]) {
+        guard let rmsAvg = audioLevels.combine()?.average,
+            let reactTag = self.reactTag
+        else { return }
+        eventEmitter.sendEvent(withName: LKEvents.kEventVolumeProcessed, body: [
+            "volume": rmsAvg,
+            "id": reactTag
+        ])
+    }
+}
+
+public class BaseVolumeAudioRenderer: NSObject, RTCAudioRenderer {
+    private let frameInterval: Int
+    private var skippedFrames = 0
+    public init(intervalMs: Double = 30) {
+        self.frameInterval = Int((intervalMs / 10.0).rounded())
+    }
+    
+    public func render(pcmBuffer: AVAudioPCMBuffer) {
+        if(skippedFrames < frameInterval - 1) {
+            skippedFrames += 1
+            return
+        }
+        
+        skippedFrames = 0
+        guard let pcmBuffer = pcmBuffer.convert(toCommonFormat: .pcmFormatFloat32) else { return }
+        let audioLevels = pcmBuffer.audioLevels()
+        onVolumeCalculated(audioLevels)
+    }
+    
+    public func onVolumeCalculated(_ audioLevels: [AudioLevel]) {
+        
+    }
+}

package/lib/commonjs/LKNativeModule.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+const LINKING_ERROR = `The package '@livekit/react-native' doesn't seem to be linked. Make sure: \n\n` + _reactNative.Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo managed workflow\n';
+const LiveKitModule = _reactNative.NativeModules.LivekitReactNativeModule ? _reactNative.NativeModules.LivekitReactNativeModule : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+var _default = exports.default = LiveKitModule;
+//# sourceMappingURL=LKNativeModule.js.map

package/lib/commonjs/LKNativeModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","LINKING_ERROR","Platform","select","ios","default","LiveKitModule","NativeModules","LivekitReactNativeModule","Proxy","get","Error","_default","exports"],"sources":["LKNativeModule.ts"],"sourcesContent":["import { NativeModules, Platform } from 'react-native';\nconst LINKING_ERROR =\n  `The package '@livekit/react-native' doesn't seem to be linked. Make sure: \\n\\n` +\n  Platform.select({ ios: \"- You have run 'pod install'\\n\", default: '' }) +\n  '- You rebuilt the app after installing the package\\n' +\n  '- You are not using Expo managed workflow\\n';\n\nconst LiveKitModule = NativeModules.LivekitReactNativeModule\n  ? NativeModules.LivekitReactNativeModule\n  : new Proxy(\n      {},\n      {\n        get() {\n          throw new Error(LINKING_ERROR);\n        },\n      }\n    );\n\nexport default LiveKitModule;\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,MAAMC,aAAa,GACjB,gFAAgF,GAChFC,qBAAQ,CAACC,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,6CAA6C;AAE/C,MAAMC,aAAa,GAAGC,0BAAa,CAACC,wBAAwB,GACxDD,0BAAa,CAACC,wBAAwB,GACtC,IAAIC,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACV,aAAa,CAAC;EAChC;AACF,CACF,CAAC;AAAC,IAAAW,QAAA,GAAAC,OAAA,CAAAR,OAAA,GAESC,aAAa","ignoreList":[]}

package/lib/commonjs/audio/AudioSession.js

@@ -6,19 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = exports.AndroidAudioTypePresets = void 0;
 exports.getDefaultAppleAudioConfigurationForMode = getDefaultAppleAudioConfigurationForMode;
 var _reactNative = require("react-native");
+var _LKNativeModule = _interopRequireDefault(require("../LKNativeModule"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-const LINKING_ERROR = `The package '@livekit/react-native' doesn't seem to be linked. Make sure: \n\n` + _reactNative.Platform.select({
-  ios: "- You have run 'pod install'\n",
-  default: ''
-}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo managed workflow\n';
-const LivekitReactNative = _reactNative.NativeModules.LivekitReactNative ? _reactNative.NativeModules.LivekitReactNative : new Proxy({}, {
-  get() {
-    throw new Error(LINKING_ERROR);
-  }
-});
-
 /**
  * Configuration for the underlying AudioSession.
  *
@@ -95,19 +87,19 @@ exports.default = AudioSession;
  * See also useIOSAudioManagement for automatic configuration of iOS audio options.
  */
 _defineProperty(AudioSession, "configureAudio", async config => {
-  await LivekitReactNative.configureAudio(config);
+  await _LKNativeModule.default.configureAudio(config);
 });
 /**
  * Starts an AudioSession.
  */
 _defineProperty(AudioSession, "startAudioSession", async () => {
-  await LivekitReactNative.startAudioSession();
+  await _LKNativeModule.default.startAudioSession();
 });
 /**
  * Stops the existing AudioSession.
  */
 _defineProperty(AudioSession, "stopAudioSession", async () => {
-  await LivekitReactNative.stopAudioSession();
+  await _LKNativeModule.default.stopAudioSession();
 });
 /**
  * Gets the available audio outputs for use with {@link selectAudioOutput}.
@@ -137,7 +129,7 @@ _defineProperty(AudioSession, "getAudioOutputs", async () => {
   if (_reactNative.Platform.OS === 'ios') {
     return ['default', 'force_speaker'];
   } else if (_reactNative.Platform.OS === 'android') {
-    return await LivekitReactNative.getAudioOutputs();
+    return await _LKNativeModule.default.getAudioOutputs();
   } else {
     return [];
   }
@@ -150,7 +142,7 @@ _defineProperty(AudioSession, "getAudioOutputs", async () => {
  * @param deviceId A deviceId retrieved from {@link getAudioOutputs}
  */
 _defineProperty(AudioSession, "selectAudioOutput", async deviceId => {
-  await LivekitReactNative.selectAudioOutput(deviceId);
+  await _LKNativeModule.default.selectAudioOutput(deviceId);
 });
 /**
  * iOS only, requires iOS 11+.
@@ -159,7 +151,7 @@ _defineProperty(AudioSession, "selectAudioOutput", async deviceId => {
  */
 _defineProperty(AudioSession, "showAudioRoutePicker", async () => {
   if (_reactNative.Platform.OS === 'ios') {
-    await LivekitReactNative.showAudioRoutePicker();
+    await _LKNativeModule.default.showAudioRoutePicker();
   }
 });
 /**
@@ -170,7 +162,7 @@ _defineProperty(AudioSession, "showAudioRoutePicker", async () => {
  */
 _defineProperty(AudioSession, "setAppleAudioConfiguration", async config => {
   if (_reactNative.Platform.OS === 'ios') {
-    await LivekitReactNative.setAppleAudioConfiguration(config);
+    await _LKNativeModule.default.setAppleAudioConfiguration(config);
   }
 });
 //# sourceMappingURL=AudioSession.js.map