m144

README.md

@@ -43,7 +43,7 @@ Software encode/decode factories have been enabled by default.
 
 ## WebRTC Revision
 
-* Currently used revision: [M125](https://github.com/webrtc-sdk/webrtc/tree/m125_release)
+* Currently used revision: [M144](https://github.com/webrtc-sdk/webrtc/tree/m144_release)
 * Supported architectures
   * Android: armeabi-v7a, arm64-v8a, x86, x86_64
   * iOS: arm64, x86_64

android/build.gradle

@@ -31,6 +31,6 @@ android {
 
 dependencies {
     implementation "com.facebook.react:react-android:+"
-    api 'io.github.webrtc-sdk:android:137.7151.05'
+    api 'io.github.webrtc-sdk:android:144.7559.01'
     implementation "androidx.core:core:1.7.0"
 }

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

@@ -15,6 +15,7 @@
 import org.webrtc.FrameCryptor;
 import org.webrtc.FrameCryptorAlgorithm;
 import org.webrtc.FrameCryptorFactory;
+import org.webrtc.FrameCryptorKeyDerivationAlgorithm;
 import org.webrtc.FrameCryptorKeyProvider;
 import org.webrtc.RtpReceiver;
 import org.webrtc.RtpSender;
@@ -92,6 +93,17 @@ private FrameCryptorAlgorithm frameCryptorAlgorithmFromInt(int algorithm) {
         }
     }
 
+    private FrameCryptorKeyDerivationAlgorithm keyDerivationAlgorithmFromInt(int algorithm) {
+        switch (algorithm) {
+            case 0:
+                return FrameCryptorKeyDerivationAlgorithm.PBKDF2;
+            case 1:
+                return FrameCryptorKeyDerivationAlgorithm.HKDF;
+            default:
+                return FrameCryptorKeyDerivationAlgorithm.PBKDF2;
+        }
+    }
+
     public String frameCryptorFactoryCreateFrameCryptor(ReadableMap params) {
         String keyProviderId = params.getString("keyProviderId");
         FrameCryptorKeyProvider keyProvider = keyProviders.get(keyProviderId);
@@ -238,13 +250,17 @@ public String frameCryptorFactoryCreateKeyProvider(ReadableMap keyProviderOption
         int keyRingSize = (int) keyProviderOptions.getInt("keyRingSize");
         boolean discardFrameWhenCryptorNotReady =
                 (boolean) keyProviderOptions.getBoolean("discardFrameWhenCryptorNotReady");
+        int keyDerivationAlgorithm = keyProviderOptions.hasKey("keyDerivationAlgorithm")
+                ? keyProviderOptions.getInt("keyDerivationAlgorithm")
+                : 0;
         FrameCryptorKeyProvider keyProvider = FrameCryptorFactory.createFrameCryptorKeyProvider(sharedKey,
                 ratchetSalt,
                 ratchetWindowSize,
                 uncryptedMagicBytes,
                 failureTolerance,
                 keyRingSize,
-                discardFrameWhenCryptorNotReady);
+                discardFrameWhenCryptorNotReady,
+                keyDerivationAlgorithmFromInt(keyDerivationAlgorithm));
         keyProviders.put(keyProviderId, keyProvider);
         return keyProviderId;
     }

ios/RCTWebRTC/WebRTCModule+RTCFrameCryptor.m

@@ -26,6 +26,17 @@ - (RTCCryptorAlgorithm)getAlgorithm:(NSNumber *)algorithm {
     }
 }
 
+- (RTCKeyDerivationAlgorithm)getKeyDerivationAlgorithm:(NSNumber *)algorithm {
+    switch ([algorithm intValue]) {
+        case 0:
+            return RTCKeyDerivationAlgorithmPBKDF2;
+        case 1:
+            return RTCKeyDerivationAlgorithmHKDF;
+        default:
+            return RTCKeyDerivationAlgorithmPBKDF2;
+    }
+}
+
 - (NSData *)bytesFromMap:(NSDictionary *)map key:(NSString *)key isBase64Key:(nullable NSString *)isBase64Key {
     BOOL isBase64 = YES;
     if (isBase64Key) {
@@ -257,6 +268,7 @@ - (NSData *)bytesFromMap:(NSDictionary *)map key:(NSString *)key isBase64Key:(nu
 
         NSNumber *keyRingSize = keyProviderOptions[@"keyRingSize"];
         NSNumber *discardFrameWhenCryptorNotReady = keyProviderOptions[@"discardFrameWhenCryptorNotReady"];
+        NSNumber *keyDerivationAlgorithm = keyProviderOptions[@"keyDerivationAlgorithm"];
 
         RTCFrameCryptorKeyProvider *keyProvider = [[RTCFrameCryptorKeyProvider alloc]
                         initWithRatchetSalt:ratchetSalt
@@ -267,7 +279,8 @@ - (NSData *)bytesFromMap:(NSDictionary *)map key:(NSString *)key isBase64Key:(nu
                                 keyRingSize:keyRingSize != nil ? [keyRingSize intValue] : 0
             discardFrameWhenCryptorNotReady:discardFrameWhenCryptorNotReady != nil
                                                 ? [discardFrameWhenCryptorNotReady boolValue]
-                                                : NO];
+                                                : NO
+                     keyDerivationAlgorithm:[self getKeyDerivationAlgorithm:keyDerivationAlgorithm]];
         self.keyProviders[keyProviderId] = keyProvider;
         return;
     });

livekit-react-native-webrtc.podspec

@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   s.libraries           = 'c', 'sqlite3', 'stdc++'
   s.framework           = 'AudioToolbox','AVFoundation', 'CoreAudio', 'CoreGraphics', 'CoreVideo', 'GLKit', 'VideoToolbox'
   s.dependency          'React-Core'
-  s.dependency          'WebRTC-SDK', '=137.7151.09'
+  s.dependency          'WebRTC-SDK', '=144.7559.01'
 
   # Swift/Objective-C compatibility
   s.pod_target_xcconfig = {

src/RTCFrameCryptorFactory.ts

@@ -12,14 +12,20 @@ export enum RTCFrameCryptorAlgorithm {
   // kAesCbc = 1,
 }
 
+export enum RTCKeyDerivationAlgorithm {
+  PBKDF2 = 0,
+  HKDF = 1,
+}
+
 export type RTCKeyProviderOptions = {
   sharedKey: boolean,
   ratchetSalt: string | Uint8Array,
   ratchetWindowSize: number,
   uncryptedMagicBytes?: Uint8Array,
   failureTolerance?: number,
   keyRingSize?: number,
-  discardFrameWhenCryptorNotReady?: boolean
+  discardFrameWhenCryptorNotReady?: boolean,
+  keyDerivationAlgorithm?: RTCKeyDerivationAlgorithm,
 }
 
 export default class RTCFrameCryptorFactory {
@@ -74,7 +80,8 @@ export default class RTCFrameCryptorFactory {
             'ratchetWindowSize': options.ratchetWindowSize,
             'failureTolerance': options.failureTolerance ?? -1,
             'keyRingSize': options.keyRingSize ?? 16,
-            'discardFrameWhenCryptorNotReady': options.discardFrameWhenCryptorNotReady ?? false
+            'discardFrameWhenCryptorNotReady': options.discardFrameWhenCryptorNotReady ?? false,
+            'keyDerivationAlgorithm': options.keyDerivationAlgorithm ?? 0
         };
 
         if (typeof options.ratchetSalt === 'string') {

src/RTCRtpSendParameters.ts

@@ -6,6 +6,7 @@ type DegradationPreferenceType = 'maintain-framerate'
     | 'maintain-resolution'
     | 'balanced'
     | 'disabled'
+    | 'maintain-framerate-and-resolution'
 
 
 /**

src/index.ts

@@ -20,7 +20,9 @@ import RTCDataPacketCryptor, { RTCEncryptedPacket } from './RTCDataPacketCryptor
 import RTCDataPacketCryptorFactory from './RTCDataPacketCryptorFactory';
 import RTCErrorEvent from './RTCErrorEvent';
 import RTCFrameCryptor, { RTCFrameCryptorState } from './RTCFrameCryptor';
-import RTCFrameCryptorFactory, { RTCFrameCryptorAlgorithm, RTCKeyProviderOptions } from './RTCFrameCryptorFactory';
+import RTCFrameCryptorFactory, {
+    RTCFrameCryptorAlgorithm, RTCKeyDerivationAlgorithm, RTCKeyProviderOptions,
+} from './RTCFrameCryptorFactory';
 import RTCIceCandidate from './RTCIceCandidate';
 import RTCKeyProvider from './RTCKeyProvider';
 import RTCPIPView, { startIOSPIP, stopIOSPIP } from './RTCPIPView';
@@ -64,6 +66,7 @@ export {
     RTCFrameCryptor,
     RTCFrameCryptorAlgorithm,
     RTCFrameCryptorState,
+    RTCKeyDerivationAlgorithm,
     RTCFrameCryptorFactory,
     RTCKeyProvider,
     RTCKeyProviderOptions,