libwebrtc-objc-iosrtc.patch

diff -ruN objc/RTCMediaStream+Internal.h objc.iosrtc/RTCMediaStream+Internal.h
--- objc/RTCMediaStream+Internal.h  2016-02-16 18:13:43.000000000 +0100
+++ objc.iosrtc/RTCMediaStream+Internal.h 2016-02-16 18:23:22.000000000 +0100
@@ -37,4 +37,12 @@
 - (id)initWithMediaStream:
         (rtc::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream;

+- (void)update;
+- (BOOL)hasNativeAudioTrack:(RTCAudioTrack *)objcTrack;
+- (BOOL)hasNativeVideoTrack:(RTCVideoTrack *)objcTrack;
+- (BOOL)hasObjcAudioTrack:
+    (rtc::scoped_refptr<webrtc::AudioTrackInterface>)nativeTrack;
+- (BOOL)hasObjcVideoTrack:
+    (rtc::scoped_refptr<webrtc::VideoTrackInterface>)nativeTrack;
+
 @end
diff -ruN objc/RTCMediaStream.mm objc.iosrtc/RTCMediaStream.mm
--- objc/RTCMediaStream.mm  2016-02-16 18:13:43.000000000 +0100
+++ objc.iosrtc/RTCMediaStream.mm 2016-02-16 18:34:04.000000000 +0100
@@ -31,16 +31,31 @@

 #import "RTCMediaStream+Internal.h"

-#import "RTCAudioTrack+Internal.h"
 #import "RTCMediaStreamTrack+Internal.h"
+#import "RTCAudioTrack+Internal.h"
 #import "RTCVideoTrack+Internal.h"

 #include "webrtc/api/mediastreaminterface.h"

+namespace webrtc {
+  class RTCMediaStreamObserver : public ObserverInterface {
+    public:
+    RTCMediaStreamObserver(RTCMediaStream* stream) { _stream = stream; }
+
+    void OnChanged() override {
+      [_stream update];
+    }
+
+   private:
+    __weak RTCMediaStream* _stream;
+  };
+}
+
 @implementation RTCMediaStream {
   NSMutableArray* _audioTracks;
   NSMutableArray* _videoTracks;
   rtc::scoped_refptr<webrtc::MediaStreamInterface> _mediaStream;
+  rtc::scoped_ptr<webrtc::RTCMediaStreamObserver> _observer;
 }

 - (NSString*)description {
@@ -64,7 +79,6 @@

 - (BOOL)addAudioTrack:(RTCAudioTrack*)track {
   if (self.mediaStream->AddTrack(track.audioTrack)) {
-    [_audioTracks addObject:track];
     return YES;
   }
   return NO;
@@ -72,7 +86,6 @@

 - (BOOL)addVideoTrack:(RTCVideoTrack*)track {
   if (self.mediaStream->AddTrack(track.nativeVideoTrack)) {
-    [_videoTracks addObject:track];
     return YES;
   }
   return NO;
@@ -83,7 +96,6 @@
   NSAssert(index != NSNotFound,
            @"|removeAudioTrack| called on unexpected RTCAudioTrack");
   if (index != NSNotFound && self.mediaStream->RemoveTrack(track.audioTrack)) {
-    [_audioTracks removeObjectAtIndex:index];
     return YES;
   }
   return NO;
@@ -93,9 +105,7 @@
   NSUInteger index = [_videoTracks indexOfObjectIdenticalTo:track];
   NSAssert(index != NSNotFound,
            @"|removeAudioTrack| called on unexpected RTCVideoTrack");
-  if (index != NSNotFound &&
-      self.mediaStream->RemoveTrack(track.nativeVideoTrack)) {
-    [_videoTracks removeObjectAtIndex:index];
+  if (index != NSNotFound && self.mediaStream->RemoveTrack(track.nativeVideoTrack)) {
     return YES;
   }
   return NO;
@@ -119,6 +129,8 @@
     _audioTracks = [NSMutableArray arrayWithCapacity:audio_tracks.size()];
     _videoTracks = [NSMutableArray arrayWithCapacity:video_tracks.size()];
     _mediaStream = mediaStream;
+    _observer.reset(new webrtc::RTCMediaStreamObserver(self));
+    _mediaStream->RegisterObserver(_observer.get());

     for (size_t i = 0; i < audio_tracks.size(); ++i) {
       rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
@@ -139,8 +151,157 @@
   return self;
 }

+- (void)dealloc {
+  _mediaStream->UnregisterObserver(_observer.get());
+}
+
 - (rtc::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream {
   return _mediaStream;
 }

+- (void)update {
+  size_t i;
+  webrtc::AudioTrackVector native_audio_tracks = _mediaStream->GetAudioTracks();
+  webrtc::VideoTrackVector native_video_tracks = _mediaStream->GetVideoTracks();
+  std::vector<size_t> removedAudioTrackIndexes;
+  std::vector<size_t> removedVideoTrackIndexes;
+
+  // Detect audio tracks removal.
+  for (i = 0; i < [_audioTracks count]; i++) {
+    RTCAudioTrack* objcTrack = [_audioTracks objectAtIndex:i];
+    NSNumber* index;
+
+    if (![self hasNativeAudioTrack:objcTrack]) {
+      removedAudioTrackIndexes.push_back(i);
+    }
+  }
+
+  // Detect video tracks removal.
+  for (i = 0; i < [_videoTracks count]; i++) {
+    RTCVideoTrack* objcTrack = [_videoTracks objectAtIndex:i];
+    NSNumber* index;
+
+    if (![self hasNativeVideoTrack:objcTrack]) {
+      removedVideoTrackIndexes.push_back(i);
+    }
+  }
+
+  // Remove old audio tracks and notify the delegate.
+  for (std::vector<size_t>::iterator it = removedAudioTrackIndexes.begin();
+    it != removedAudioTrackIndexes.end(); ++it) {
+    RTCAudioTrack* objcTrack = [_audioTracks objectAtIndex:*it];
+
+    // Remove the track from the ObjC container.
+    [_audioTracks removeObjectAtIndex:*it];
+
+    // Notify the delegate.
+    [_delegate OnRemoveAudioTrack:self track:objcTrack];
+  }
+
+  // Remove old video tracks and notify the delegate.
+  for (std::vector<size_t>::iterator it = removedVideoTrackIndexes.begin();
+    it != removedVideoTrackIndexes.end(); ++it) {
+    RTCVideoTrack* objcTrack = [_videoTracks objectAtIndex:*it];
+
+    // Remove the track from the ObjC container.
+    [_videoTracks removeObjectAtIndex:*it];
+
+    // Notify the delegate.
+    [_delegate OnRemoveVideoTrack:self track:objcTrack];
+  }
+
+  // Detect audio tracks addition and notify the delegate.
+  for (i = 0; i < native_audio_tracks.size(); ++i) {
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> nativeTrack =
+      native_audio_tracks[i];
+
+    if (![self hasObjcAudioTrack:nativeTrack]) {
+      // Create the RTCAudioTrack instance and add it to the ObjC container.
+      RTCAudioTrack* objcTrack =
+        [[RTCAudioTrack alloc] initWithMediaTrack:nativeTrack];
+      [_audioTracks addObject:objcTrack];
+
+      // Notify the delegate.
+      [_delegate OnAddAudioTrack:self track:objcTrack];
+    }
+  }
+
+  // Detect video tracks addition and notify the delegate.
+  for (i = 0; i < native_video_tracks.size(); ++i) {
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> nativeTrack =
+      native_video_tracks[i];
+
+    if (![self hasObjcVideoTrack:nativeTrack]) {
+      // Create the RTCVideoTrack instance and add it to the ObjC container.
+      RTCVideoTrack* objcTrack =
+        [[RTCVideoTrack alloc] initWithMediaTrack:nativeTrack];
+      [_videoTracks addObject:objcTrack];
+
+      // Notify the delegate.
+      [_delegate OnAddVideoTrack:self track:objcTrack];
+    }
+  }
+
+  unsigned long num_native_audios = native_audio_tracks.size();
+  unsigned long num_native_videos = native_video_tracks.size();
+  unsigned long num_objc_audios = (unsigned long)[_audioTracks count];
+  unsigned long num_objc_videos = (unsigned long)[_videoTracks count];
+
+  NSAssert(num_native_audios == num_objc_audios,
+    @"ObjC audio tracks does not match number of native audio tracks");
+
+  NSAssert(num_native_videos == num_objc_videos,
+    @"ObjC video tracks does not match number of native video tracks");
+}
+
+- (BOOL)hasNativeAudioTrack:(RTCAudioTrack *)objcTrack {
+  webrtc::AudioTrackVector audio_tracks = _mediaStream->GetAudioTracks();
+
+  for (size_t i = 0; i < audio_tracks.size(); ++i) {
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> track = audio_tracks[i];
+
+    if (track->id().compare(objcTrack.audioTrack->id()) == 0) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (BOOL)hasNativeVideoTrack:(RTCVideoTrack *)objcTrack {
+  webrtc::VideoTrackVector video_tracks = _mediaStream->GetVideoTracks();
+
+  for (size_t i = 0; i < video_tracks.size(); ++i) {
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> track = video_tracks[i];
+
+    if (track->id().compare(objcTrack.nativeVideoTrack->id()) == 0) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (BOOL)hasObjcAudioTrack:
+    (rtc::scoped_refptr<webrtc::AudioTrackInterface>)nativeTrack {
+  for (size_t i = 0; i < [_audioTracks count]; i++) {
+    RTCAudioTrack* track = [_audioTracks objectAtIndex:i];
+
+    if (track.audioTrack->id().compare(nativeTrack->id()) == 0) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (BOOL)hasObjcVideoTrack:
+    (rtc::scoped_refptr<webrtc::VideoTrackInterface>)nativeTrack {
+  for (size_t i = 0; i < [_videoTracks count]; i++) {
+    RTCVideoTrack* track = [_videoTracks objectAtIndex:i];
+
+    if (track.nativeVideoTrack->id().compare(nativeTrack->id()) == 0) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
 @end
diff -ruN objc/public/RTCMediaStream.h objc.iosrtc/public/RTCMediaStream.h
--- objc/public/RTCMediaStream.h  2016-02-16 18:13:43.000000000 +0100
+++ objc.iosrtc/public/RTCMediaStream.h 2016-02-16 18:24:45.000000000 +0100
@@ -29,6 +29,21 @@

 @class RTCAudioTrack;
 @class RTCVideoTrack;
+@class RTCMediaStream;
+@class RTCMediaStreamTrack;
+
+@protocol RTCMediaStreamDelegate<NSObject>
+
+- (void)OnAddAudioTrack:
+    (RTCMediaStream*)mediaStream track:(RTCMediaStreamTrack*)track;
+- (void)OnAddVideoTrack:
+    (RTCMediaStream*)mediaStream track:(RTCMediaStreamTrack*)track;
+- (void)OnRemoveAudioTrack:
+    (RTCMediaStream*)mediaStream track:(RTCMediaStreamTrack*)track;
+- (void)OnRemoveVideoTrack:
+    (RTCMediaStream*)mediaStream track:(RTCMediaStreamTrack*)track;
+
+@end

 // RTCMediaStream is an ObjectiveC wrapper for MediaStreamInterface.
 @interface RTCMediaStream : NSObject
@@ -36,6 +51,7 @@
 @property(nonatomic, strong, readonly) NSArray *audioTracks;
 @property(nonatomic, strong, readonly) NSArray *videoTracks;
 @property(nonatomic, strong, readonly) NSString *label;
+@property(nonatomic, weak) id<RTCMediaStreamDelegate> delegate;

 - (BOOL)addAudioTrack:(RTCAudioTrack *)track;
 - (BOOL)addVideoTrack:(RTCVideoTrack *)track;