@sbhjt-gr/react-native-webrtc 137.0.4 → 137.0.6

package/android/src/main/java/com/oney/WebRTCModule/WebRTCModule.java

@@ -21,11 +21,13 @@ import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.oney.WebRTCModule.virtualaudio.VirtualAudioController;
 import com.oney.WebRTCModule.webrtcutils.H264AndSoftwareVideoDecoderFactory;
 import com.oney.WebRTCModule.webrtcutils.H264AndSoftwareVideoEncoderFactory;
 
 import org.webrtc.AddIceObserver;
 import org.webrtc.AudioProcessingFactory;
+import org.webrtc.AudioSource;
 import org.webrtc.AudioTrack;
 import org.webrtc.AudioTrackSink;
 import org.webrtc.CryptoOptions;
@@ -62,6 +64,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.UUID;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
@@ -74,6 +77,9 @@ public class WebRTCModule extends ReactContextBaseJavaModule {
     VideoEncoderFactory mVideoEncoderFactory;
     VideoDecoderFactory mVideoDecoderFactory;
     AudioDeviceModule mAudioDeviceModule;
+    private PeerConnectionFactory virtualFactory;
+    private JavaAudioDeviceModule virtualAdm;
+    private VirtualAudioController virtualAudioCtrl;
 
     // Need to expose the peer connection codec factories here to get capabilities
     private final SparseArray<PeerConnectionObserver> mPeerConnectionObservers;
@@ -164,9 +170,48 @@ public class WebRTCModule extends ReactContextBaseJavaModule {
         return "WebRTCModule";
     }
 
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        disposeVirtualAudioResources();
+    }
+
     public PeerConnectionObserver getPeerConnectionObserver(int id) {
         return mPeerConnectionObservers.get(id);
     }
+
+    private PeerConnectionFactory getVirtualPeerConnectionFactory() {
+        if (virtualFactory != null) {
+            return virtualFactory;
+        }
+
+        JavaAudioDeviceModule module = JavaAudioDeviceModule.builder(getReactApplicationContext())
+                                               .setUseHardwareAcousticEchoCanceler(false)
+                                               .setUseHardwareNoiseSuppressor(false)
+                                               .createAudioDeviceModule();
+        module.setAudioRecordEnabled(false);
+        virtualAdm = module;
+        virtualAudioCtrl = new VirtualAudioController(module.audioInput);
+
+        PeerConnectionFactory.Builder builder = PeerConnectionFactory.builder()
+                                                        .setAudioDeviceModule(module)
+                                                        .setVideoEncoderFactory(mVideoEncoderFactory)
+                                                        .setVideoDecoderFactory(mVideoDecoderFactory);
+        virtualFactory = builder.createPeerConnectionFactory();
+        return virtualFactory;
+    }
+
+    private void disposeVirtualAudioResources() {
+        if (virtualFactory != null) {
+            virtualFactory.dispose();
+            virtualFactory = null;
+        }
+        if (virtualAdm != null) {
+            virtualAdm.release();
+            virtualAdm = null;
+        }
+        virtualAudioCtrl = null;
+    }
     private PeerConnection getPeerConnection(int id) {
         PeerConnectionObserver pco = mPeerConnectionObservers.get(id);
         return (pco == null) ? null : pco.getPeerConnection();
@@ -835,6 +880,78 @@ public class WebRTCModule extends ReactContextBaseJavaModule {
         ThreadUtils.runOnExecutor(() -> callback.invoke(getUserMediaImpl.enumerateDevices()));
     }
 
+    @ReactMethod
+    public void createVirtualAudioTrack(Promise promise) {
+        ThreadUtils.runOnExecutor(() -> {
+            PeerConnectionFactory factory = getVirtualPeerConnectionFactory();
+            if (factory == null || virtualAudioCtrl == null) {
+                promise.reject("virtual_factory_error", "Virtual audio unavailable");
+                return;
+            }
+
+            MediaConstraints constraints = new MediaConstraints();
+            AudioSource source = factory.createAudioSource(constraints);
+            AudioTrack audioTrack = factory.createAudioTrack(UUID.randomUUID().toString(), source);
+            String streamId = UUID.randomUUID().toString();
+            MediaStream mediaStream = factory.createLocalMediaStream(streamId);
+            mediaStream.addTrack(audioTrack);
+            localStreams.put(streamId, mediaStream);
+
+            WritableMap trackInfo = Arguments.createMap();
+            trackInfo.putBoolean("enabled", audioTrack.enabled());
+            trackInfo.putString("id", audioTrack.id());
+            trackInfo.putString("kind", audioTrack.kind());
+            trackInfo.putString("readyState", "live");
+            trackInfo.putBoolean("remote", false);
+            WritableMap settings = Arguments.createMap();
+            settings.putString("deviceId", "virtual-audio");
+            settings.putString("groupId", "");
+            trackInfo.putMap("settings", settings);
+
+            WritableArray tracks = Arguments.createArray();
+            tracks.pushMap(trackInfo);
+
+            WritableMap payload = Arguments.createMap();
+            payload.putString("streamId", streamId);
+            payload.putArray("tracks", tracks);
+            promise.resolve(payload);
+
+            if (virtualAdm != null) {
+                virtualAdm.requestStartRecording();
+            }
+        });
+    }
+
+    @ReactMethod
+    public void pushVirtualAudioSamples(ReadableArray samples, double sampleRate, double channels) {
+        ThreadUtils.runOnExecutor(() -> {
+            if (virtualAudioCtrl == null || samples == null) {
+                return;
+            }
+
+            int rate = (int) sampleRate;
+            int channelCount = (int) channels;
+            if (rate <= 0 || channelCount <= 0 || samples.size() == 0) {
+                return;
+            }
+
+            short[] data = new short[samples.size()];
+            for (int i = 0; i < samples.size(); i++) {
+                double value = samples.getDouble(i);
+                int sample = (int) Math.round(value);
+                if (sample > Short.MAX_VALUE) {
+                    sample = Short.MAX_VALUE;
+                } else if (sample < Short.MIN_VALUE) {
+                    sample = Short.MIN_VALUE;
+                }
+                data[i] = (short) sample;
+            }
+
+            virtualAudioCtrl.configure(rate, channelCount);
+            virtualAudioCtrl.push(data);
+        });
+    }
+
     @ReactMethod
     public void mediaStreamCreate(String id) {
         ThreadUtils.runOnExecutor(() -> {

package/android/src/main/java/com/oney/WebRTCModule/virtualaudio/VirtualAudioController.java

@@ -0,0 +1,134 @@
+package com.oney.WebRTCModule.virtualaudio;
+
+import org.webrtc.audio.WebRtcAudioRecord;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+
+public class VirtualAudioController {
+    private final WebRtcAudioRecord audioRecord;
+    private final Method nativeDataIsRecorded;
+    private final Method nativeCacheDirectBufferAddress;
+    private final Field nativeAudioRecordField;
+    private final Field byteBufferField;
+    private final Field sampleRateField;
+    private final Field channelCountField;
+    private final Field expectedSampleRateField;
+    private final Field expectedChannelCountField;
+
+    private ByteBuffer buffer;
+    private int bufferBytes;
+    private int currentSampleRate;
+    private int currentChannels;
+
+    public VirtualAudioController(WebRtcAudioRecord audioRecord) {
+        this.audioRecord = audioRecord;
+        try {
+            Class<?> clazz = audioRecord.getClass();
+            nativeDataIsRecorded = clazz.getDeclaredMethod("nativeDataIsRecorded", long.class, int.class, long.class);
+            nativeDataIsRecorded.setAccessible(true);
+            nativeCacheDirectBufferAddress =
+                    clazz.getDeclaredMethod("nativeCacheDirectBufferAddress", long.class, ByteBuffer.class);
+            nativeCacheDirectBufferAddress.setAccessible(true);
+            nativeAudioRecordField = clazz.getDeclaredField("nativeAudioRecord");
+            nativeAudioRecordField.setAccessible(true);
+            byteBufferField = clazz.getDeclaredField("byteBuffer");
+            byteBufferField.setAccessible(true);
+            sampleRateField = clazz.getDeclaredField("sampleRate");
+            sampleRateField.setAccessible(true);
+            channelCountField = clazz.getDeclaredField("channelCount");
+            channelCountField.setAccessible(true);
+            expectedSampleRateField = clazz.getDeclaredField("expectedSampleRate");
+            expectedSampleRateField.setAccessible(true);
+            expectedChannelCountField = clazz.getDeclaredField("expectedChannelCount");
+            expectedChannelCountField.setAccessible(true);
+            buffer = (ByteBuffer) byteBufferField.get(audioRecord);
+            bufferBytes = buffer != null ? buffer.capacity() : 0;
+        } catch (IllegalAccessException | NoSuchFieldException | NoSuchMethodException e) {
+            throw new IllegalStateException("Failed to initialize VirtualAudioController", e);
+        }
+    }
+
+    public synchronized void configure(int sampleRate, int channels) {
+        if (sampleRate <= 0 || channels <= 0) {
+            return;
+        }
+        if (sampleRate == currentSampleRate && channels == currentChannels && buffer != null) {
+            return;
+        }
+        currentSampleRate = sampleRate;
+        currentChannels = channels;
+        int bytesPerFrame = channels * 2;
+        int framesPerBuffer = Math.max(sampleRate / 100, 1);
+        int capacity = Math.max(framesPerBuffer * bytesPerFrame, bytesPerFrame);
+        buffer = ByteBuffer.allocateDirect(capacity).order(ByteOrder.nativeOrder());
+        bufferBytes = capacity;
+        try {
+            byteBufferField.set(audioRecord, buffer);
+            expectedSampleRateField.setInt(audioRecord, sampleRate);
+            expectedChannelCountField.setInt(audioRecord, channels);
+            sampleRateField.setInt(audioRecord, sampleRate);
+            channelCountField.setInt(audioRecord, channels);
+            cacheBuffer();
+        } catch (IllegalAccessException e) {
+            throw new IllegalStateException("Unable to configure VirtualAudioController", e);
+        }
+    }
+
+    public synchronized void push(short[] samples) {
+        if (samples == null || samples.length == 0 || buffer == null) {
+            return;
+        }
+        long nativePtr = nativePointer();
+        if (nativePtr == 0) {
+            cacheBuffer();
+            nativePtr = nativePointer();
+            if (nativePtr == 0) {
+                return;
+            }
+        }
+        int offset = 0;
+        ShortBuffer shortView = buffer.asShortBuffer();
+        int framesCapacity = shortView.capacity();
+        while (offset < samples.length) {
+            shortView.clear();
+            int framesToCopy = Math.min(framesCapacity, samples.length - offset);
+            shortView.put(samples, offset, framesToCopy);
+            int bytes = framesToCopy * 2;
+            invokeNative(nativePtr, bytes);
+            offset += framesToCopy;
+        }
+    }
+
+    private void cacheBuffer() {
+        long nativePtr = nativePointer();
+        if (nativePtr == 0 || buffer == null) {
+            return;
+        }
+        try {
+            nativeCacheDirectBufferAddress.invoke(audioRecord, nativePtr, buffer);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new IllegalStateException("Failed to cache direct buffer", e);
+        }
+    }
+
+    private void invokeNative(long nativePtr, int bytes) {
+        try {
+            nativeDataIsRecorded.invoke(audioRecord, nativePtr, bytes, System.nanoTime());
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new IllegalStateException("Failed to deliver audio samples", e);
+        }
+    }
+
+    private long nativePointer() {
+        try {
+            return nativeAudioRecordField.getLong(audioRecord);
+        } catch (IllegalAccessException e) {
+            return 0;
+        }
+    }
+}

package/ios/RCTWebRTC/WLVAudioDevice.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import <WebRTC/WebRTC.h>
+
+@interface WLVAudioDevice : NSObject<RTCAudioDevice>
+
+- (void)pushAudioData:(NSData *)data sampleRate:(double)sampleRate channels:(NSInteger)channels;
+
+@end

package/ios/RCTWebRTC/WLVAudioDevice.m

@@ -0,0 +1,201 @@
+#import "WLVAudioDevice.h"
+#import <AudioToolbox/AudioToolbox.h>
+#import <math.h>
+
+static const double kDefaultSampleRate = 48000.0;
+static const NSInteger kDefaultChannels = 1;
+static const NSTimeInterval kDefaultBufferDuration = 0.02;
+
+@interface WLVAudioDevice ()
+
+@property(nonatomic, weak) id<RTCAudioDeviceDelegate> delegate;
+@property(nonatomic) BOOL initialized;
+@property(nonatomic) BOOL playoutInitialized;
+@property(nonatomic) BOOL recordingInitialized;
+@property(nonatomic) BOOL playing;
+@property(nonatomic) BOOL recording;
+@property(nonatomic) double inRate;
+@property(nonatomic) NSInteger inChannels;
+@property(nonatomic) double outRate;
+@property(nonatomic) NSInteger outChannels;
+@property(nonatomic) NSTimeInterval inBufferDuration;
+@property(nonatomic) NSTimeInterval outBufferDuration;
+@property(nonatomic) NSTimeInterval inLatency;
+@property(nonatomic) NSTimeInterval outLatency;
+@property(nonatomic) double sampleTime;
+@property(nonatomic, strong) dispatch_queue_t queue;
+
+@end
+
+@implementation WLVAudioDevice
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _inRate = kDefaultSampleRate;
+        _outRate = kDefaultSampleRate;
+        _inChannels = kDefaultChannels;
+        _outChannels = kDefaultChannels;
+        _inBufferDuration = kDefaultBufferDuration;
+        _outBufferDuration = kDefaultBufferDuration;
+        _queue = dispatch_queue_create("webrtc.virtual.audio", DISPATCH_QUEUE_SERIAL);
+    }
+    return self;
+}
+
+- (void)pushAudioData:(NSData *)data sampleRate:(double)sampleRate channels:(NSInteger)channels {
+    if (!self.recording || !self.delegate || data.length == 0) {
+        return;
+    }
+    NSInteger bytesPerFrame = channels * sizeof(int16_t);
+    if (bytesPerFrame == 0) {
+        return;
+    }
+    UInt32 frames = (UInt32)(data.length / bytesPerFrame);
+    if (frames == 0) {
+        return;
+    }
+    [self updateInputRate:sampleRate channels:channels];
+    NSData *chunk = [data copy];
+    dispatch_async(self.queue, ^{
+        if (!self.recording || !self.delegate) {
+            return;
+        }
+        AudioBuffer buffer;
+        buffer.mNumberChannels = (UInt32)channels;
+        buffer.mDataByteSize = (UInt32)chunk.length;
+        buffer.mData = (void *)chunk.bytes;
+        AudioBufferList list;
+        list.mNumberBuffers = 1;
+        list.mBuffers[0] = buffer;
+        AudioUnitRenderActionFlags flags = 0;
+        AudioTimeStamp stamp;
+        memset(&stamp, 0, sizeof(AudioTimeStamp));
+        stamp.mFlags = kAudioTimeStampSampleTimeValid;
+        stamp.mSampleTime = self.sampleTime;
+        self.sampleTime += frames;
+        RTC_OBJC_TYPE(RTCAudioDeviceDeliverRecordedDataBlock) block = self.delegate.deliverRecordedData;
+        if (block) {
+            block(&flags, &stamp, 0, frames, &list, NULL, nil);
+        }
+    });
+}
+
+- (void)updateInputRate:(double)rate channels:(NSInteger)channels {
+    BOOL rateChanged = fabs(self.inRate - rate) > 0.1;
+    BOOL channelChanged = self.inChannels != channels;
+    if (rateChanged) {
+        self.inRate = rate;
+    }
+    if (channelChanged) {
+        self.inChannels = channels;
+    }
+    if ((rateChanged || channelChanged) && self.delegate) {
+        [self.delegate dispatchAsync:^{
+            [self.delegate notifyAudioInputParametersChange];
+        }];
+    }
+}
+
+#pragma mark - RTCAudioDevice
+
+- (double)deviceInputSampleRate {
+    return self.inRate;
+}
+
+- (NSTimeInterval)inputIOBufferDuration {
+    return self.inBufferDuration;
+}
+
+- (NSInteger)inputNumberOfChannels {
+    return self.inChannels;
+}
+
+- (NSTimeInterval)inputLatency {
+    return self.inLatency;
+}
+
+- (double)deviceOutputSampleRate {
+    return self.outRate;
+}
+
+- (NSTimeInterval)outputIOBufferDuration {
+    return self.outBufferDuration;
+}
+
+- (NSInteger)outputNumberOfChannels {
+    return self.outChannels;
+}
+
+- (NSTimeInterval)outputLatency {
+    return self.outLatency;
+}
+
+- (BOOL)isInitialized {
+    return self.initialized;
+}
+
+- (BOOL)initializeWithDelegate:(id<RTCAudioDeviceDelegate>)delegate {
+    self.delegate = delegate;
+    self.initialized = YES;
+    return YES;
+}
+
+- (BOOL)terminateDevice {
+    self.delegate = nil;
+    self.initialized = NO;
+    self.playoutInitialized = NO;
+    self.recordingInitialized = NO;
+    self.playing = NO;
+    self.recording = NO;
+    self.sampleTime = 0;
+    return YES;
+}
+
+- (BOOL)isPlayoutInitialized {
+    return self.playoutInitialized;
+}
+
+- (BOOL)initializePlayout {
+    self.playoutInitialized = YES;
+    return YES;
+}
+
+- (BOOL)isPlaying {
+    return self.playing;
+}
+
+- (BOOL)startPlayout {
+    self.playing = YES;
+    return YES;
+}
+
+- (BOOL)stopPlayout {
+    self.playing = NO;
+    return YES;
+}
+
+- (BOOL)isRecordingInitialized {
+    return self.recordingInitialized;
+}
+
+- (BOOL)initializeRecording {
+    self.recordingInitialized = YES;
+    return YES;
+}
+
+- (BOOL)isRecording {
+    return self.recording;
+}
+
+- (BOOL)startRecording {
+    self.recording = YES;
+    return YES;
+}
+
+- (BOOL)stopRecording {
+    self.recording = NO;
+    return YES;
+}
+
+@end

package/ios/RCTWebRTC/WebRTCModule+RTCMediaStream.m

@@ -323,6 +323,53 @@ RCT_EXPORT_METHOD(getDisplayMedia : (RCTPromiseResolveBlock)resolve rejecter : (
 #endif
 }
 
+RCT_EXPORT_METHOD(createVirtualAudioTrack : (RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+#if TARGET_OS_TV
+    reject(@"unsupported_platform", @"tvOS is not supported", nil);
+    return;
+#else
+    RTCPeerConnectionFactory *factory = [self virtualFactory];
+    if (!factory) {
+        reject(@"virtual_factory_error", @"Factory unavailable", nil);
+        return;
+    }
+    NSString *trackId = [[NSUUID UUID] UUIDString];
+    RTCAudioSource *source = [factory audioSourceWithConstraints:nil];
+    RTCAudioTrack *track = [factory audioTrackWithSource:source trackId:trackId];
+    NSArray *components = [self createMediaStream:@[ track ]];
+    resolve(@{ @"streamId" : components[0], @"tracks" : components[1] });
+#endif
+}
+
+RCT_EXPORT_METHOD(pushVirtualAudioSamples
+                  : (nonnull NSArray<NSNumber *> *)samples
+                  sampleRate
+                  : (nonnull NSNumber *)sampleRate
+                  channels
+                  : (nonnull NSNumber *)channels) {
+#if TARGET_OS_TV
+    return;
+#else
+    if (samples.count == 0) {
+        return;
+    }
+    if (!self.virtualAudioDevice) {
+        [self virtualFactory];
+    }
+    if (!self.virtualAudioDevice) {
+        return;
+    }
+    NSUInteger length = samples.count * sizeof(int16_t);
+    NSMutableData *data = [NSMutableData dataWithLength:length];
+    int16_t *buffer = data.mutableBytes;
+    NSUInteger idx = 0;
+    for (NSNumber *value in samples) {
+        buffer[idx++] = (int16_t)value.shortValue;
+    }
+    [self.virtualAudioDevice pushAudioData:data sampleRate:sampleRate.doubleValue channels:channels.integerValue];
+#endif
+}
+
 /**
  * Implements {@code getUserMedia}. Note that at this point constraints have
  * been normalized and permissions have been granted. The constraints only

package/ios/RCTWebRTC/WebRTCModule.h

@@ -43,5 +43,6 @@ static NSString *const kEventAudioSamples = @"audioSamples";
 @property(nonatomic, strong) NSMutableDictionary<NSString *, RTCDataPacketCryptor *> *dataPacketCryptors;
 
 - (RTCMediaStream *)streamForReactTag:(NSString *)reactTag;
+- (RTCPeerConnectionFactory *)virtualFactory;
 
 @end

package/ios/RCTWebRTC/WebRTCModule.m

@@ -10,8 +10,13 @@
 #import "WebRTCModule+RTCPeerConnection.h"
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
+#import "WLVAudioDevice.h"
 
 @interface WebRTCModule ()
+
+@property(nonatomic, strong) WLVAudioDevice *virtualAudioDevice;
+@property(nonatomic, strong) RTCPeerConnectionFactory *virtualPeerConnectionFactory;
+
 @end
 
 @implementation WebRTCModule
@@ -128,6 +133,16 @@ RCT_EXPORT_MODULE();
     return _workerQueue;
 }
 
+- (RTCPeerConnectionFactory *)virtualFactory {
+    if (_virtualPeerConnectionFactory == nil) {
+        self.virtualAudioDevice = [[WLVAudioDevice alloc] init];
+        _virtualPeerConnectionFactory = [[RTCPeerConnectionFactory alloc] initWithEncoderFactory:_encoderFactory
+                                                                                       decoderFactory:_decoderFactory
+                                                                                          audioDevice:self.virtualAudioDevice];
+    }
+    return _virtualPeerConnectionFactory;
+}
+
 - (NSArray<NSString *> *)supportedEvents {
     return @[
         kEventPeerConnectionSignalingStateChanged,

package/ios/RCTWebRTC.xcodeproj/project.pbxproj

@@ -22,6 +22,7 @@
 		4EE3A8D225B841DD00FAA24A /* CaptureController.m in Sources */ = {isa = PBXBuildFile; fileRef = 4EE3A8C925B841DD00FAA24A /* CaptureController.m */; };
 		4EE3A8D325B841DD00FAA24A /* ScreenCaptureController.m in Sources */ = {isa = PBXBuildFile; fileRef = 4EE3A8CC25B841DD00FAA24A /* ScreenCaptureController.m */; };
 		4EE3A8D425B841DD00FAA24A /* ScreenCapturer.m in Sources */ = {isa = PBXBuildFile; fileRef = 4EE3A8CD25B841DD00FAA24A /* ScreenCapturer.m */; };
+		E0C37C1F2D8D1C6A009E2E63 /* WLVAudioDevice.m in Sources */ = {isa = PBXBuildFile; fileRef = E0C37C1E2D8D1C6A009E2E63 /* WLVAudioDevice.m */; };
 		D3FF699919D2664B25C9D458 /* Pods_RCTWebRTC.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A20F721AD842563B66292D5B /* Pods_RCTWebRTC.framework */; };
 		D74EF94829652169000742E1 /* TrackCapturerEventsEmitter.m in Sources */ = {isa = PBXBuildFile; fileRef = D74EF94629652169000742E1 /* TrackCapturerEventsEmitter.m */; };
 		D7F0711E2C6DC91F0031F594 /* WebRTCModule+RTCAudioSession.m in Sources */ = {isa = PBXBuildFile; fileRef = D7F0711D2C6DC91F0031F594 /* WebRTCModule+RTCAudioSession.m */; };
@@ -72,6 +73,8 @@
 		4EE3A8CC25B841DD00FAA24A /* ScreenCaptureController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = ScreenCaptureController.m; path = RCTWebRTC/ScreenCaptureController.m; sourceTree = SOURCE_ROOT; };
 		4EE3A8CD25B841DD00FAA24A /* ScreenCapturer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = ScreenCapturer.m; path = RCTWebRTC/ScreenCapturer.m; sourceTree = SOURCE_ROOT; };
 		4EE3A8CE25B841DD00FAA24A /* SocketConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SocketConnection.h; path = RCTWebRTC/SocketConnection.h; sourceTree = SOURCE_ROOT; };
+		E0C37C1D2D8D1C6A009E2E63 /* WLVAudioDevice.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = WLVAudioDevice.h; path = RCTWebRTC/WLVAudioDevice.h; sourceTree = SOURCE_ROOT; };
+		E0C37C1E2D8D1C6A009E2E63 /* WLVAudioDevice.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = WLVAudioDevice.m; path = RCTWebRTC/WLVAudioDevice.m; sourceTree = SOURCE_ROOT; };
 		A20F721AD842563B66292D5B /* Pods_RCTWebRTC.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RCTWebRTC.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		D74EF94529652148000742E1 /* CapturerEventsDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = CapturerEventsDelegate.h; path = RCTWebRTC/CapturerEventsDelegate.h; sourceTree = SOURCE_ROOT; };
 		D74EF94629652169000742E1 /* TrackCapturerEventsEmitter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = TrackCapturerEventsEmitter.m; path = RCTWebRTC/TrackCapturerEventsEmitter.m; sourceTree = SOURCE_ROOT; };
@@ -157,6 +160,8 @@
 				4EE3A8CD25B841DD00FAA24A /* ScreenCapturer.m */,
 				4EE3A8CE25B841DD00FAA24A /* SocketConnection.h */,
 				4EE3A8C825B841DD00FAA24A /* SocketConnection.m */,
+				E0C37C1D2D8D1C6A009E2E63 /* WLVAudioDevice.h */,
+				E0C37C1E2D8D1C6A009E2E63 /* WLVAudioDevice.m */,
 				DEC96579264176DF0052DB35 /* DataChannelWrapper.h */,
 				DEC96576264176C10052DB35 /* DataChannelWrapper.m */,
 			);
@@ -255,6 +260,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				E0C37C1F2D8D1C6A009E2E63 /* WLVAudioDevice.m in Sources */,
 				4EE3A8C525B8417800FAA24A /* WebRTCModule+VideoTrackAdapter.m in Sources */,
 				4EE3A8BA25B8415900FAA24A /* WebRTCModule+RTCDataChannel.m in Sources */,
 				4EE3A8B625B8414A00FAA24A /* WebRTCModule+Permissions.m in Sources */,

package/lib/commonjs/MediaDevices.js

@@ -42,6 +42,19 @@ class MediaDevices extends _index.EventTarget {
   getUserMedia(constraints) {
     return (0, _getUserMedia.default)(constraints);
   }
+  createVirtualAudioTrack() {
+    if (!WebRTCModule.createVirtualAudioTrack) {
+      return Promise.reject(new Error('virtual audio unavailable'));
+    }
+    return WebRTCModule.createVirtualAudioTrack();
+  }
+  pushVirtualAudioSamples(samples, sampleRate, channels) {
+    if (!WebRTCModule.pushVirtualAudioSamples) {
+      return;
+    }
+    const array = samples instanceof Int16Array ? Array.from(samples) : samples.slice();
+    WebRTCModule.pushVirtualAudioSamples(array, sampleRate, channels);
+  }
 }
 
 /**

package/lib/commonjs/MediaDevices.js.map

@@ -1 +1 @@
-{"version":3,"names":["_index","require","_reactNative","_getDisplayMedia","_interopRequireDefault","_getUserMedia","obj","__esModule","default","WebRTCModule","NativeModules","MediaDevices","EventTarget","enumerateDevices","Promise","resolve","getDisplayMedia","getUserMedia","constraints","proto","prototype","defineEventAttribute","_default","exports"],"sources":["MediaDevices.ts"],"sourcesContent":["import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';\nimport { NativeModules } from 'react-native';\n\nimport getDisplayMedia from './getDisplayMedia';\nimport getUserMedia, { Constraints } from './getUserMedia';\n\nconst { WebRTCModule } = NativeModules;\n\ntype MediaDevicesEventMap = {\n    devicechange: Event<'devicechange'>\n}\n\nclass MediaDevices extends EventTarget<MediaDevicesEventMap> {\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code enumerateDevices}\n     * implementation.\n     */\n    enumerateDevices() {\n        return new Promise(resolve => WebRTCModule.enumerateDevices(resolve));\n    }\n\n    /**\n     * W3C \"Screen Capture\" compatible {@code getDisplayMedia} implementation.\n     * See: https://w3c.github.io/mediacapture-screen-share/\n     *\n     * @returns {Promise}\n     */\n    getDisplayMedia() {\n        return getDisplayMedia();\n    }\n\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code getUserMedia}\n     * implementation.\n     * See: https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-enumeratedevices\n     *\n     * @param {*} constraints\n     * @returns {Promise}\n     */\n    getUserMedia(constraints: Constraints) {\n        return getUserMedia(constraints);\n    }\n}\n\n/**\n * Define the `onxxx` event handlers.\n */\nconst proto = MediaDevices.prototype;\n\ndefineEventAttribute(proto, 'devicechange');\n\n\nexport default new MediaDevices();\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,IAAAE,gBAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,aAAA,GAAAD,sBAAA,CAAAH,OAAA;AAA2D,SAAAG,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAE3D,MAAM;EAAEG;AAAa,CAAC,GAAGC,0BAAa;AAMtC,MAAMC,YAAY,SAASC,kBAAW,CAAuB;EACzD;AACJ;AACA;AACA;EACIC,gBAAgBA,CAAA,EAAG;IACf,OAAO,IAAIC,OAAO,CAACC,OAAO,IAAIN,YAAY,CAACI,gBAAgB,CAACE,OAAO,CAAC,CAAC;EACzE;;EAEA;AACJ;AACA;AACA;AACA;AACA;EACIC,eAAeA,CAAA,EAAG;IACd,OAAO,IAAAA,wBAAe,EAAC,CAAC;EAC5B;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;EACIC,YAAYA,CAACC,WAAwB,EAAE;IACnC,OAAO,IAAAD,qBAAY,EAACC,WAAW,CAAC;EACpC;AACJ;;AAEA;AACA;AACA;AACA,MAAMC,KAAK,GAAGR,YAAY,CAACS,SAAS;AAEpC,IAAAC,2BAAoB,EAACF,KAAK,EAAE,cAAc,CAAC;AAAC,IAAAG,QAAA,GAG7B,IAAIX,YAAY,CAAC,CAAC;AAAAY,OAAA,CAAAf,OAAA,GAAAc,QAAA"}
+{"version":3,"names":["_index","require","_reactNative","_getDisplayMedia","_interopRequireDefault","_getUserMedia","obj","__esModule","default","WebRTCModule","NativeModules","MediaDevices","EventTarget","enumerateDevices","Promise","resolve","getDisplayMedia","getUserMedia","constraints","createVirtualAudioTrack","reject","Error","pushVirtualAudioSamples","samples","sampleRate","channels","array","Int16Array","Array","from","slice","proto","prototype","defineEventAttribute","_default","exports"],"sources":["MediaDevices.ts"],"sourcesContent":["import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';\nimport { NativeModules } from 'react-native';\n\nimport { type MediaTrackSettings } from './MediaStreamTrack';\nimport getDisplayMedia from './getDisplayMedia';\nimport getUserMedia, { Constraints } from './getUserMedia';\n\nconst { WebRTCModule } = NativeModules;\n\ntype MediaDevicesEventMap = {\n    devicechange: Event<'devicechange'>\n}\n\ntype VirtualTrackInfo = {\n    enabled: boolean;\n    id: string;\n    kind: string;\n    readyState: string;\n    remote: boolean;\n    settings: MediaTrackSettings;\n}\n\ntype VirtualAudioResponse = {\n    streamId: string;\n    tracks: VirtualTrackInfo[];\n}\n\nclass MediaDevices extends EventTarget<MediaDevicesEventMap> {\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code enumerateDevices}\n     * implementation.\n     */\n    enumerateDevices() {\n        return new Promise(resolve => WebRTCModule.enumerateDevices(resolve));\n    }\n\n    /**\n     * W3C \"Screen Capture\" compatible {@code getDisplayMedia} implementation.\n     * See: https://w3c.github.io/mediacapture-screen-share/\n     *\n     * @returns {Promise}\n     */\n    getDisplayMedia() {\n        return getDisplayMedia();\n    }\n\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code getUserMedia}\n     * implementation.\n     * See: https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-enumeratedevices\n     *\n     * @param {*} constraints\n     * @returns {Promise}\n     */\n    getUserMedia(constraints: Constraints) {\n        return getUserMedia(constraints);\n    }\n\n    createVirtualAudioTrack(): Promise<VirtualAudioResponse> {\n        if (!WebRTCModule.createVirtualAudioTrack) {\n            return Promise.reject(new Error('virtual audio unavailable'));\n        }\n\n        return WebRTCModule.createVirtualAudioTrack();\n    }\n\n    pushVirtualAudioSamples(samples: Int16Array | number[], sampleRate: number, channels: number) {\n        if (!WebRTCModule.pushVirtualAudioSamples) {\n            return;\n        }\n\n        const array = samples instanceof Int16Array ? Array.from(samples) : samples.slice();\n\n        WebRTCModule.pushVirtualAudioSamples(array, sampleRate, channels);\n    }\n}\n\n/**\n * Define the `onxxx` event handlers.\n */\nconst proto = MediaDevices.prototype;\n\ndefineEventAttribute(proto, 'devicechange');\n\n\nexport default new MediaDevices();\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAGA,IAAAE,gBAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,aAAA,GAAAD,sBAAA,CAAAH,OAAA;AAA2D,SAAAG,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAE3D,MAAM;EAAEG;AAAa,CAAC,GAAGC,0BAAa;AAoBtC,MAAMC,YAAY,SAASC,kBAAW,CAAuB;EACzD;AACJ;AACA;AACA;EACIC,gBAAgBA,CAAA,EAAG;IACf,OAAO,IAAIC,OAAO,CAACC,OAAO,IAAIN,YAAY,CAACI,gBAAgB,CAACE,OAAO,CAAC,CAAC;EACzE;;EAEA;AACJ;AACA;AACA;AACA;AACA;EACIC,eAAeA,CAAA,EAAG;IACd,OAAO,IAAAA,wBAAe,EAAC,CAAC;EAC5B;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;EACIC,YAAYA,CAACC,WAAwB,EAAE;IACnC,OAAO,IAAAD,qBAAY,EAACC,WAAW,CAAC;EACpC;EAEAC,uBAAuBA,CAAA,EAAkC;IACrD,IAAI,CAACV,YAAY,CAACU,uBAAuB,EAAE;MACvC,OAAOL,OAAO,CAACM,MAAM,CAAC,IAAIC,KAAK,CAAC,2BAA2B,CAAC,CAAC;IACjE;IAEA,OAAOZ,YAAY,CAACU,uBAAuB,CAAC,CAAC;EACjD;EAEAG,uBAAuBA,CAACC,OAA8B,EAAEC,UAAkB,EAAEC,QAAgB,EAAE;IAC1F,IAAI,CAAChB,YAAY,CAACa,uBAAuB,EAAE;MACvC;IACJ;IAEA,MAAMI,KAAK,GAAGH,OAAO,YAAYI,UAAU,GAAGC,KAAK,CAACC,IAAI,CAACN,OAAO,CAAC,GAAGA,OAAO,CAACO,KAAK,CAAC,CAAC;IAEnFrB,YAAY,CAACa,uBAAuB,CAACI,KAAK,EAAEF,UAAU,EAAEC,QAAQ,CAAC;EACrE;AACJ;;AAEA;AACA;AACA;AACA,MAAMM,KAAK,GAAGpB,YAAY,CAACqB,SAAS;AAEpC,IAAAC,2BAAoB,EAACF,KAAK,EAAE,cAAc,CAAC;AAAC,IAAAG,QAAA,GAG7B,IAAIvB,YAAY,CAAC,CAAC;AAAAwB,OAAA,CAAA3B,OAAA,GAAA0B,QAAA"}

package/lib/module/MediaDevices.js

@@ -35,6 +35,19 @@ class MediaDevices extends EventTarget {
   getUserMedia(constraints) {
     return getUserMedia(constraints);
   }
+  createVirtualAudioTrack() {
+    if (!WebRTCModule.createVirtualAudioTrack) {
+      return Promise.reject(new Error('virtual audio unavailable'));
+    }
+    return WebRTCModule.createVirtualAudioTrack();
+  }
+  pushVirtualAudioSamples(samples, sampleRate, channels) {
+    if (!WebRTCModule.pushVirtualAudioSamples) {
+      return;
+    }
+    const array = samples instanceof Int16Array ? Array.from(samples) : samples.slice();
+    WebRTCModule.pushVirtualAudioSamples(array, sampleRate, channels);
+  }
 }
 
 /**

package/lib/module/MediaDevices.js.map

@@ -1 +1 @@
-{"version":3,"names":["EventTarget","defineEventAttribute","NativeModules","getDisplayMedia","getUserMedia","WebRTCModule","MediaDevices","enumerateDevices","Promise","resolve","constraints","proto","prototype"],"sources":["MediaDevices.ts"],"sourcesContent":["import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';\nimport { NativeModules } from 'react-native';\n\nimport getDisplayMedia from './getDisplayMedia';\nimport getUserMedia, { Constraints } from './getUserMedia';\n\nconst { WebRTCModule } = NativeModules;\n\ntype MediaDevicesEventMap = {\n    devicechange: Event<'devicechange'>\n}\n\nclass MediaDevices extends EventTarget<MediaDevicesEventMap> {\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code enumerateDevices}\n     * implementation.\n     */\n    enumerateDevices() {\n        return new Promise(resolve => WebRTCModule.enumerateDevices(resolve));\n    }\n\n    /**\n     * W3C \"Screen Capture\" compatible {@code getDisplayMedia} implementation.\n     * See: https://w3c.github.io/mediacapture-screen-share/\n     *\n     * @returns {Promise}\n     */\n    getDisplayMedia() {\n        return getDisplayMedia();\n    }\n\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code getUserMedia}\n     * implementation.\n     * See: https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-enumeratedevices\n     *\n     * @param {*} constraints\n     * @returns {Promise}\n     */\n    getUserMedia(constraints: Constraints) {\n        return getUserMedia(constraints);\n    }\n}\n\n/**\n * Define the `onxxx` event handlers.\n */\nconst proto = MediaDevices.prototype;\n\ndefineEventAttribute(proto, 'devicechange');\n\n\nexport default new MediaDevices();\n"],"mappings":"AAAA,SAASA,WAAW,EAASC,oBAAoB,QAAQ,yBAAyB;AAClF,SAASC,aAAa,QAAQ,cAAc;AAE5C,OAAOC,eAAe,MAAM,mBAAmB;AAC/C,OAAOC,YAAY,MAAuB,gBAAgB;AAE1D,MAAM;EAAEC;AAAa,CAAC,GAAGH,aAAa;AAMtC,MAAMI,YAAY,SAASN,WAAW,CAAuB;EACzD;AACJ;AACA;AACA;EACIO,gBAAgBA,CAAA,EAAG;IACf,OAAO,IAAIC,OAAO,CAACC,OAAO,IAAIJ,YAAY,CAACE,gBAAgB,CAACE,OAAO,CAAC,CAAC;EACzE;;EAEA;AACJ;AACA;AACA;AACA;AACA;EACIN,eAAeA,CAAA,EAAG;IACd,OAAOA,eAAe,CAAC,CAAC;EAC5B;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;EACIC,YAAYA,CAACM,WAAwB,EAAE;IACnC,OAAON,YAAY,CAACM,WAAW,CAAC;EACpC;AACJ;;AAEA;AACA;AACA;AACA,MAAMC,KAAK,GAAGL,YAAY,CAACM,SAAS;AAEpCX,oBAAoB,CAACU,KAAK,EAAE,cAAc,CAAC;AAG3C,eAAe,IAAIL,YAAY,CAAC,CAAC"}
+{"version":3,"names":["EventTarget","defineEventAttribute","NativeModules","getDisplayMedia","getUserMedia","WebRTCModule","MediaDevices","enumerateDevices","Promise","resolve","constraints","createVirtualAudioTrack","reject","Error","pushVirtualAudioSamples","samples","sampleRate","channels","array","Int16Array","Array","from","slice","proto","prototype"],"sources":["MediaDevices.ts"],"sourcesContent":["import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';\nimport { NativeModules } from 'react-native';\n\nimport { type MediaTrackSettings } from './MediaStreamTrack';\nimport getDisplayMedia from './getDisplayMedia';\nimport getUserMedia, { Constraints } from './getUserMedia';\n\nconst { WebRTCModule } = NativeModules;\n\ntype MediaDevicesEventMap = {\n    devicechange: Event<'devicechange'>\n}\n\ntype VirtualTrackInfo = {\n    enabled: boolean;\n    id: string;\n    kind: string;\n    readyState: string;\n    remote: boolean;\n    settings: MediaTrackSettings;\n}\n\ntype VirtualAudioResponse = {\n    streamId: string;\n    tracks: VirtualTrackInfo[];\n}\n\nclass MediaDevices extends EventTarget<MediaDevicesEventMap> {\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code enumerateDevices}\n     * implementation.\n     */\n    enumerateDevices() {\n        return new Promise(resolve => WebRTCModule.enumerateDevices(resolve));\n    }\n\n    /**\n     * W3C \"Screen Capture\" compatible {@code getDisplayMedia} implementation.\n     * See: https://w3c.github.io/mediacapture-screen-share/\n     *\n     * @returns {Promise}\n     */\n    getDisplayMedia() {\n        return getDisplayMedia();\n    }\n\n    /**\n     * W3C \"Media Capture and Streams\" compatible {@code getUserMedia}\n     * implementation.\n     * See: https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-enumeratedevices\n     *\n     * @param {*} constraints\n     * @returns {Promise}\n     */\n    getUserMedia(constraints: Constraints) {\n        return getUserMedia(constraints);\n    }\n\n    createVirtualAudioTrack(): Promise<VirtualAudioResponse> {\n        if (!WebRTCModule.createVirtualAudioTrack) {\n            return Promise.reject(new Error('virtual audio unavailable'));\n        }\n\n        return WebRTCModule.createVirtualAudioTrack();\n    }\n\n    pushVirtualAudioSamples(samples: Int16Array | number[], sampleRate: number, channels: number) {\n        if (!WebRTCModule.pushVirtualAudioSamples) {\n            return;\n        }\n\n        const array = samples instanceof Int16Array ? Array.from(samples) : samples.slice();\n\n        WebRTCModule.pushVirtualAudioSamples(array, sampleRate, channels);\n    }\n}\n\n/**\n * Define the `onxxx` event handlers.\n */\nconst proto = MediaDevices.prototype;\n\ndefineEventAttribute(proto, 'devicechange');\n\n\nexport default new MediaDevices();\n"],"mappings":"AAAA,SAASA,WAAW,EAASC,oBAAoB,QAAQ,yBAAyB;AAClF,SAASC,aAAa,QAAQ,cAAc;AAG5C,OAAOC,eAAe,MAAM,mBAAmB;AAC/C,OAAOC,YAAY,MAAuB,gBAAgB;AAE1D,MAAM;EAAEC;AAAa,CAAC,GAAGH,aAAa;AAoBtC,MAAMI,YAAY,SAASN,WAAW,CAAuB;EACzD;AACJ;AACA;AACA;EACIO,gBAAgBA,CAAA,EAAG;IACf,OAAO,IAAIC,OAAO,CAACC,OAAO,IAAIJ,YAAY,CAACE,gBAAgB,CAACE,OAAO,CAAC,CAAC;EACzE;;EAEA;AACJ;AACA;AACA;AACA;AACA;EACIN,eAAeA,CAAA,EAAG;IACd,OAAOA,eAAe,CAAC,CAAC;EAC5B;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;EACIC,YAAYA,CAACM,WAAwB,EAAE;IACnC,OAAON,YAAY,CAACM,WAAW,CAAC;EACpC;EAEAC,uBAAuBA,CAAA,EAAkC;IACrD,IAAI,CAACN,YAAY,CAACM,uBAAuB,EAAE;MACvC,OAAOH,OAAO,CAACI,MAAM,CAAC,IAAIC,KAAK,CAAC,2BAA2B,CAAC,CAAC;IACjE;IAEA,OAAOR,YAAY,CAACM,uBAAuB,CAAC,CAAC;EACjD;EAEAG,uBAAuBA,CAACC,OAA8B,EAAEC,UAAkB,EAAEC,QAAgB,EAAE;IAC1F,IAAI,CAACZ,YAAY,CAACS,uBAAuB,EAAE;MACvC;IACJ;IAEA,MAAMI,KAAK,GAAGH,OAAO,YAAYI,UAAU,GAAGC,KAAK,CAACC,IAAI,CAACN,OAAO,CAAC,GAAGA,OAAO,CAACO,KAAK,CAAC,CAAC;IAEnFjB,YAAY,CAACS,uBAAuB,CAACI,KAAK,EAAEF,UAAU,EAAEC,QAAQ,CAAC;EACrE;AACJ;;AAEA;AACA;AACA;AACA,MAAMM,KAAK,GAAGjB,YAAY,CAACkB,SAAS;AAEpCvB,oBAAoB,CAACsB,KAAK,EAAE,cAAc,CAAC;AAG3C,eAAe,IAAIjB,YAAY,CAAC,CAAC"}

package/lib/typescript/MediaDevices.d.ts

@@ -1,8 +1,21 @@
 import { EventTarget, Event } from 'event-target-shim/index';
+import { type MediaTrackSettings } from './MediaStreamTrack';
 import { Constraints } from './getUserMedia';
 declare type MediaDevicesEventMap = {
     devicechange: Event<'devicechange'>;
 };
+declare type VirtualTrackInfo = {
+    enabled: boolean;
+    id: string;
+    kind: string;
+    readyState: string;
+    remote: boolean;
+    settings: MediaTrackSettings;
+};
+declare type VirtualAudioResponse = {
+    streamId: string;
+    tracks: VirtualTrackInfo[];
+};
 declare class MediaDevices extends EventTarget<MediaDevicesEventMap> {
     /**
      * W3C "Media Capture and Streams" compatible {@code enumerateDevices}
@@ -25,6 +38,8 @@ declare class MediaDevices extends EventTarget<MediaDevicesEventMap> {
      * @returns {Promise}
      */
     getUserMedia(constraints: Constraints): Promise<import("./MediaStream").default>;
+    createVirtualAudioTrack(): Promise<VirtualAudioResponse>;
+    pushVirtualAudioSamples(samples: Int16Array | number[], sampleRate: number, channels: number): void;
 }
 declare const _default: MediaDevices;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sbhjt-gr/react-native-webrtc",
-  "version": "137.0.4",
+  "version": "137.0.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sbhjt-gr/react-native-webrtc.git"

package/src/MediaDevices.ts

@@ -1,6 +1,7 @@
 import { EventTarget, Event, defineEventAttribute } from 'event-target-shim/index';
 import { NativeModules } from 'react-native';
 
+import { type MediaTrackSettings } from './MediaStreamTrack';
 import getDisplayMedia from './getDisplayMedia';
 import getUserMedia, { Constraints } from './getUserMedia';
 
@@ -10,6 +11,20 @@ type MediaDevicesEventMap = {
     devicechange: Event<'devicechange'>
 }
 
+type VirtualTrackInfo = {
+    enabled: boolean;
+    id: string;
+    kind: string;
+    readyState: string;
+    remote: boolean;
+    settings: MediaTrackSettings;
+}
+
+type VirtualAudioResponse = {
+    streamId: string;
+    tracks: VirtualTrackInfo[];
+}
+
 class MediaDevices extends EventTarget<MediaDevicesEventMap> {
     /**
      * W3C "Media Capture and Streams" compatible {@code enumerateDevices}
@@ -40,6 +55,24 @@ class MediaDevices extends EventTarget<MediaDevicesEventMap> {
     getUserMedia(constraints: Constraints) {
         return getUserMedia(constraints);
     }
+
+    createVirtualAudioTrack(): Promise<VirtualAudioResponse> {
+        if (!WebRTCModule.createVirtualAudioTrack) {
+            return Promise.reject(new Error('virtual audio unavailable'));
+        }
+
+        return WebRTCModule.createVirtualAudioTrack();
+    }
+
+    pushVirtualAudioSamples(samples: Int16Array | number[], sampleRate: number, channels: number) {
+        if (!WebRTCModule.pushVirtualAudioSamples) {
+            return;
+        }
+
+        const array = samples instanceof Int16Array ? Array.from(samples) : samples.slice();
+
+        WebRTCModule.pushVirtualAudioSamples(array, sampleRate, channels);
+    }
 }
 
 /**