@sbhjt-gr/react-native-webrtc 137.0.5 → 137.0.7

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,132 @@
+package com.oney.WebRTCModule.virtualaudio;
+
+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 Object 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(Object 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/package.json

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