chore: bump webrtc to m137 + sync with flutter_webrtc 1.2.0

.github/workflows/build.yml

@@ -61,6 +61,8 @@ jobs:
           channel: 'stable'
       - name: Install project dependencies
         run: flutter pub get
+      - name: Install xcode platform support for iOS
+        run: xcodebuild -downloadPlatform iOS
       - name: Build for iOS
         working-directory: ./example
         run: flutter build ios --release --no-codesign

.gitignore

@@ -26,14 +26,22 @@ example/ios/Flutter/flutter_export_environment.sh
 .buildlog/
 .history
 .svn/
+migrate_working_dir/
 
 # IntelliJ related
 *.iml
 *.ipr
 *.iws
 .idea/
 
+# The .vscode folder contains launch configuration and tasks you configure in
+# VS Code which you may wish to be included in version control, so this line
+# is commented out by default.
+#.vscode/
+
 # Flutter/Dart/Pub related
+# Libraries should not include pubspec.lock, per https://dart.dev/guides/libraries/private-files#pubspeclock.
+/pubspec.lock
 **/doc/api/
 .dart_tool/
 .flutter-plugins
@@ -56,4 +64,5 @@ android/.settings/org.eclipse.buildship.core.prefs
 !webrtc.iml
 
 # vs
-*.pdb
+*.pdb
+ios/Frameworks

CHANGELOG.md

@@ -1,6 +1,25 @@
 
 # Changelog
 
+[1.1.0]
+* Synced flutter-webrtc v0.14.2
+	* [Doc] fix: typo in package description (#1895)
+	* [Android] fix: Video recording crashing and freezing on Android 14 Devices (#1886)
+	* [Android] fix: Add audio recording for Android Platform (#1884)
+	* [Dart] fix: Removed outdated code to avoid UI not being displayed in Windows release mode (#1890)
+	* [Apple] fix: Fix compile warnings (#1887)
+	* [Android] fix: Ensure both video and audio tracks are added before starting the muxer (#1879)
+	* [Apple/Android] feat: Add H265/HEVC support.
+	* [Mobile/Desktop] feat: Support write logs with Logger (logger package) (#1891)
+	* [Android] fix: Reduce Recording Stop Delay and Prevent Encoder OOM Crashes (Android) (#1912)
+	* [Native/Web] feat: small setVolume addition (#1904)
+	* [Web] feat: Add texture-based video rendering for web (#1911)
+	* [Android] fix: RECORDINGS - Add fallback resolutions for unsupported stream frame sizes on low-end Android devices (#1900)
+	* [Android] fix: Update proguard-rules.pro (#1902)
+	* [Android] upgrade compileSdk to 36 as standard for 16kb pages support (#1925)
+	* [Apple/Android] Local recording API for Darwin and Android (#1880)
+	* [Apple/Android] Data Packet Cryptor Support.
+
 [1.0.13] - 2025-10-28
 * Exposed `eventStream` in `MediaDevices`.
 * [Android] Sends event when screen capture ends.

android/build.gradle

@@ -29,7 +29,7 @@ android {
     if (project.android.hasProperty("namespace")) {
         namespace 'io.getstream.webrtc.flutter'
     }
-    compileSdkVersion 31
+    compileSdkVersion 36
 
     defaultConfig {
         minSdkVersion 21
@@ -47,12 +47,12 @@ android {
     }
 
     kotlinOptions {
-        jvmTarget = '1.8'
+        jvmTarget = JavaVersion.VERSION_1_8
     }
 }
 
 dependencies {
-    implementation 'io.getstream:stream-webrtc-android:1.3.8'
+    implementation 'io.getstream:stream-video-webrtc-android:137.0.1'
     implementation 'com.github.davidliu:audioswitch:89582c47c9a04c62f90aa5e57251af4800a62c9a'
     implementation 'androidx.annotation:annotation:1.1.0'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"

android/gradle.properties

@@ -1,4 +1,3 @@
-org.gradle.jvmargs=-Xmx1536M
+org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
 android.useAndroidX=true
 android.enableJetifier=true
-

android/proguard-rules.pro

@@ -1,3 +1,4 @@
 # Flutter WebRTC
 -keep class io.getstream.webrtc.flutter.** { *; }
 -keep class org.webrtc.** { *; }
+-keep class org.jni_zero.** { *; }

android/src/main/java/io/getstream/webrtc/flutter/FlutterDataPacketCryptor.java

@@ -0,0 +1,183 @@
+package io.getstream.webrtc.flutter;
+
+import androidx.annotation.NonNull;
+
+import io.getstream.webrtc.flutter.utils.ConstraintsMap;
+
+import org.webrtc.DataPacketCryptor;
+import org.webrtc.DataPacketCryptorFactory;
+import org.webrtc.FrameCryptor;
+import org.webrtc.FrameCryptorAlgorithm;
+import org.webrtc.FrameCryptorKeyProvider;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import io.flutter.plugin.common.MethodCall;
+import io.flutter.plugin.common.MethodChannel;
+
+class FlutterDataPacketCryptor {
+    private static final String TAG = "FlutterDataPacketCryptor";
+    private final Map<String, DataPacketCryptor> dataCryptos = new HashMap<>();
+
+    private final FlutterRTCFrameCryptor frameCryptor;
+
+    public FlutterDataPacketCryptor(FlutterRTCFrameCryptor frameCryptor) {
+        this.frameCryptor = frameCryptor;
+    }
+
+    public boolean handleMethodCall(@NonNull MethodCall call, @NonNull MethodChannel.Result result) {
+        String method_name = call.method;
+        Map<String, Object> params = (Map<String, Object>) call.arguments;
+        if (method_name.equals("createDataPacketCryptor")) {
+            createDataPacketCryptor(params, result);
+        } else if (method_name.equals("dataPacketCryptorEncrypt")) {
+            dataPacketCryptorEncrypt(params, result);
+        } else if (method_name.equals("dataPacketCryptorDecrypt")) {
+            dataPacketCryptorDecrypt(params, result);
+        } else if (method_name.equals("dataPacketCryptorDispose")) {
+            dataPacketCryptorDispose(params, result);
+        } else {
+            return false;
+        }
+        return true;
+    }
+
+    private void createDataPacketCryptor(@NonNull Map<String, Object> params, @NonNull MethodChannel.Result result) {
+        String keyProviderId = (String) params.get("keyProviderId");
+        FrameCryptorKeyProvider keyProvider = frameCryptor.getKeyProvider(keyProviderId);
+        if (keyProvider == null) {
+            result.error("createDataPacketCryptorFailed", "keyProvider not found", null);
+            return;
+        }
+
+        if (params.get("algorithm") == null) {
+            result.error("createDataPacketCryptorFailed", "algorithm is null", null);
+            return;
+        }
+
+        int algorithm = (int) params.get("algorithm");
+
+        DataPacketCryptor dataPacketCryptor = DataPacketCryptorFactory.createDataPacketCryptor(
+                frameCryptor.frameCryptorAlgorithmFromInt(algorithm),
+                keyProvider);
+        if (dataPacketCryptor == null) {
+            result.error("createDataPacketCryptorFailed", "createDataPacketCryptor failed", null);
+            return;
+        }
+
+        String dataCryptorId = UUID.randomUUID().toString();
+        dataCryptos.put(dataCryptorId, dataPacketCryptor);
+
+        ConstraintsMap paramsResult = new ConstraintsMap();
+        paramsResult.putString("dataCryptorId", dataCryptorId);
+        result.success(paramsResult.toMap());
+    }
+
+    private void dataPacketCryptorEncrypt(@NonNull Map<String, Object> params, @NonNull MethodChannel.Result result) {
+        String dataCryptorId = (String) params.get("dataCryptorId");
+        if (dataCryptorId == null) {
+            result.error("dataPacketCryptorEncryptFailed", "dataCryptorId is null", null);
+            return;
+        }
+
+        DataPacketCryptor dataPacketCryptor = dataCryptos.get(dataCryptorId);
+        if (dataPacketCryptor == null) {
+            result.error("dataPacketCryptorEncryptFailed", "dataPacketCryptor not found", null);
+            return;
+        }
+
+        String participantId = (String) params.get("participantId");
+        if (participantId == null) {
+            result.error("dataPacketCryptorEncryptFailed", "participantId is null", null);
+            return;
+        }
+
+        byte[] data = (byte[]) params.get("data");
+        if (data == null) {
+            result.error("dataPacketCryptorEncryptFailed", "data is null", null);
+            return;
+        }
+
+        int keyIndex = (int) params.get("keyIndex");
+        if (keyIndex < 0) {
+            result.error("dataPacketCryptorEncryptFailed", "keyIndex is invalid", null);
+            return;
+        }
+
+        DataPacketCryptor.EncryptedPacket packet = dataPacketCryptor.encrypt(participantId, keyIndex, data);
+        ConstraintsMap paramsResult = new ConstraintsMap();
+        paramsResult.putInt("keyIndex", packet.keyIndex);
+        paramsResult.putByte("data", packet.payload);
+        paramsResult.putByte("iv", packet.iv);
+        result.success(paramsResult.toMap());
+    }
+
+    private void dataPacketCryptorDecrypt(@NonNull Map<String, Object> params, @NonNull MethodChannel.Result result) {
+        String dataCryptorId = (String) params.get("dataCryptorId");
+        if (dataCryptorId == null) {
+            result.error("dataPacketCryptorEncryptFailed", "dataCryptorId is null", null);
+            return;
+        }
+
+        DataPacketCryptor dataPacketCryptor = dataCryptos.get(dataCryptorId);
+        if (dataPacketCryptor == null) {
+            result.error("dataPacketCryptorEncryptFailed", "dataPacketCryptor not found", null);
+            return;
+        }
+
+        String participantId = (String) params.get("participantId");
+        if (participantId == null) {
+            result.error("dataPacketCryptorEncryptFailed", "participantId is null", null);
+            return;
+        }
+
+        byte[] data = (byte[]) params.get("data");
+        if (data == null) {
+            result.error("dataPacketCryptorEncryptFailed", "data is null", null);
+            return;
+        }
+
+        byte[] iv = (byte[]) params.get("iv");
+        if (iv == null) {
+            result.error("dataPacketCryptorEncryptFailed", "iv is null", null);
+            return;
+        }
+
+        int keyIndex = (int) params.get("keyIndex");
+        if (keyIndex < 0) {
+            result.error("dataPacketCryptorEncryptFailed", "keyIndex is invalid", null);
+            return;
+        }
+        DataPacketCryptor.EncryptedPacket encryptedPacket = new DataPacketCryptor.EncryptedPacket(data, iv, keyIndex);
+        byte[] decrypted = dataPacketCryptor.decrypt(participantId, encryptedPacket);
+        if (decrypted == null) {
+            result.error("dataPacketCryptorDecryptFailed", "decrypt failed", null);
+            return;
+        }
+
+        ConstraintsMap paramsResult = new ConstraintsMap();
+        paramsResult.putByte("data", decrypted);
+        result.success(paramsResult.toMap());
+    }
+
+    private void dataPacketCryptorDispose(@NonNull Map<String, Object> params, @NonNull MethodChannel.Result result) {
+        String dataCryptorId = (String) params.get("dataCryptorId");
+        if (dataCryptorId == null) {
+            result.error("dataPacketCryptorDisposeFailed", "dataCryptorId is null", null);
+            return;
+        }
+
+        DataPacketCryptor dataPacketCryptor = dataCryptos.remove(dataCryptorId);
+        if (dataPacketCryptor == null) {
+            result.error("dataPacketCryptorDisposeFailed", "dataPacketCryptor not found", null);
+            return;
+        }
+
+        if (dataPacketCryptor != null) {
+            dataPacketCryptor.dispose();
+        }
+        result.success(null);
+    }
+}

android/src/main/java/io/getstream/webrtc/flutter/FlutterRTCFrameCryptor.java

@@ -148,7 +148,7 @@ public boolean handleMethodCall(MethodCall call, @NonNull Result result) {
         return true;
     }
 
-    private FrameCryptorAlgorithm frameCryptorAlgorithmFromInt(int algorithm) {
+    public FrameCryptorAlgorithm frameCryptorAlgorithmFromInt(int algorithm) {
         switch (algorithm) {
             case 0:
                 return FrameCryptorAlgorithm.AES_GCM;
@@ -210,7 +210,6 @@ private void frameCryptorFactoryCreateFrameCryptor(Map<String, Object> params, @
             result.success(paramsResult.toMap());
         } else {
             result.error("frameCryptorFactoryCreateFrameCryptorFailed", "type must be sender or receiver", null);
-            return;
         }
     }
 
@@ -431,4 +430,8 @@ private void keyProviderDispose(Map<String, Object> params, @NonNull Result resu
         paramsResult.putString("result", "success");
         result.success(paramsResult.toMap());
     }
+
+    public FrameCryptorKeyProvider getKeyProvider(String id) {
+        return keyProviders.get(id);
+    }
 }

android/src/main/java/io/getstream/webrtc/flutter/FlutterWebRTCPlugin.java

@@ -42,7 +42,11 @@ public class FlutterWebRTCPlugin implements FlutterPlugin, ActivityAware, EventC
     private LifeCycleObserver observer;
     private Lifecycle lifecycle;
     private EventChannel eventChannel;
-    public EventChannel.EventSink eventSink;
+
+    // eventSink is static because FlutterWebRTCPlugin can be instantiated multiple times
+    // but the onListen(Object, EventChannel.EventSink) event only fires once for the first
+    // FlutterWebRTCPlugin instance, so for the next instances eventSink will be == null
+    public static EventChannel.EventSink eventSink;
 
     public FlutterWebRTCPlugin() {
         if (sharedSingleton == null) {