react-native-theoplayer 1.7.0 → 1.7.2

package/android/build.gradle

@@ -1,14 +1,12 @@
 buildscript {
-  if (project == rootProject) {
-    repositories {
-      google()
-      mavenCentral()
-    }
+  repositories {
+    google()
+    mavenCentral()
+  }
 
-    dependencies {
-      classpath 'com.android.tools.build:gradle:4.2.2'
-      classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.10'
-    }
+  dependencies {
+    classpath 'com.android.tools.build:gradle:4.2.2'
+    classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.10'
   }
 }
 

package/android/src/main/java/com/theoplayer/VideoEventEmitter.java

@@ -42,19 +42,31 @@ import com.theoplayer.android.api.event.player.SeekedEvent;
 import com.theoplayer.android.api.event.player.SeekingEvent;
 import com.theoplayer.android.api.event.player.SegmentNotFoundEvent;
 import com.theoplayer.android.api.event.player.TimeUpdateEvent;
+import com.theoplayer.android.api.event.track.mediatrack.audio.ActiveQualityChangedEvent;
+import com.theoplayer.android.api.event.track.mediatrack.audio.AudioTrackEventTypes;
+import com.theoplayer.android.api.event.track.mediatrack.audio.QualityChangedEvent;
+import com.theoplayer.android.api.event.track.mediatrack.audio.list.AudioTrackListEventTypes;
+import com.theoplayer.android.api.event.track.mediatrack.video.VideoTrackEventTypes;
+import com.theoplayer.android.api.event.track.mediatrack.video.list.VideoTrackListEventTypes;
 import com.theoplayer.android.api.event.track.texttrack.AddCueEvent;
 import com.theoplayer.android.api.event.track.texttrack.RemoveCueEvent;
 import com.theoplayer.android.api.event.track.texttrack.TextTrackEventTypes;
 import com.theoplayer.android.api.event.track.texttrack.list.AddTrackEvent;
 import com.theoplayer.android.api.event.track.texttrack.list.RemoveTrackEvent;
 import com.theoplayer.android.api.event.track.texttrack.list.TextTrackListEventTypes;
+import com.theoplayer.android.api.event.track.texttrack.list.TrackListChangeEvent;
 import com.theoplayer.android.api.player.Player;
 import com.theoplayer.android.api.player.track.mediatrack.MediaTrack;
+import com.theoplayer.android.api.player.track.mediatrack.MediaTrackList;
 import com.theoplayer.android.api.player.track.mediatrack.quality.AudioQuality;
+import com.theoplayer.android.api.player.track.mediatrack.quality.Quality;
 import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality;
 import com.theoplayer.android.api.player.track.texttrack.TextTrack;
+import com.theoplayer.track.MediaTrackEventType;
+import com.theoplayer.track.MediaTrackType;
 import com.theoplayer.track.TextTrackCueEventType;
 import com.theoplayer.track.TrackEventType;
+import com.theoplayer.track.TrackListInfo;
 import com.theoplayer.util.TypeUtils;
 
 import java.lang.annotation.Retention;
@@ -84,6 +96,8 @@ public class VideoEventEmitter {
   private static final String EVENT_SEGMENTNOTFOUND = "onNativeSegmentNotFound";
   private static final String EVENT_TEXTTRACK_LIST_EVENT = "onNativeTextTrackListEvent";
   private static final String EVENT_TEXTTRACK_EVENT = "onNativeTextTrackEvent";
+  private static final String EVENT_MEDIATRACK_LIST_EVENT = "onNativeMediaTrackListEvent";
+  private static final String EVENT_MEDIATRACK_EVENT = "onNativeMediaTrackEvent";
   private static final String EVENT_AD_EVENT = "onNativeAdEvent";
   private static final String EVENT_FULLSCREEN_WILL_PRESENT = "onNativeFullscreenPlayerWillPresent";
   private static final String EVENT_FULLSCREEN_DID_PRESENT = "onNativeFullscreenPlayerDidPresent";
@@ -111,6 +125,8 @@ public class VideoEventEmitter {
     EVENT_SEGMENTNOTFOUND,
     EVENT_TEXTTRACK_LIST_EVENT,
     EVENT_TEXTTRACK_EVENT,
+    EVENT_MEDIATRACK_LIST_EVENT,
+    EVENT_MEDIATRACK_EVENT,
     EVENT_AD_EVENT,
     EVENT_FULLSCREEN_WILL_PRESENT,
     EVENT_FULLSCREEN_DID_PRESENT,
@@ -138,6 +154,8 @@ public class VideoEventEmitter {
     EVENT_SEGMENTNOTFOUND,
     EVENT_TEXTTRACK_LIST_EVENT,
     EVENT_TEXTTRACK_EVENT,
+    EVENT_MEDIATRACK_LIST_EVENT,
+    EVENT_MEDIATRACK_EVENT,
     EVENT_AD_EVENT,
     EVENT_FULLSCREEN_WILL_PRESENT,
     EVENT_FULLSCREEN_DID_PRESENT,
@@ -167,13 +185,17 @@ public class VideoEventEmitter {
   private static final String EVENT_PROP_SEGMENTSTARTTIME = "segmentStartTime";
   private static final String EVENT_PROP_TRACK = "track";
   private static final String EVENT_PROP_TRACK_UID = "trackUid";
+  private static final String EVENT_PROP_TRACK_TYPE = "trackType";
   private static final String EVENT_PROP_CUE = "cue";
   private static final String EVENT_PROP_TYPE = "type";
+  private static final String EVENT_PROP_QUALITIES = "qualities";
 
   private final RCTEventEmitter eventEmitter;
   private int viewId = View.NO_ID;
   private final HashMap<EventType, EventListener> playerListeners = new HashMap<>();
   private final HashMap<EventType, EventListener> textTrackListeners = new HashMap<>();
+  private final HashMap<EventType, EventListener> audioTrackListeners = new HashMap<>();
+  private final HashMap<EventType, EventListener> videoTrackListeners = new HashMap<>();
   private final ReactTHEOplayerView playerView;
 
   private AdEventAdapter adEventAdapter;
@@ -204,6 +226,13 @@ public class VideoEventEmitter {
 
     textTrackListeners.put(TextTrackListEventTypes.ADDTRACK, (EventListener<AddTrackEvent>) this::onTextTrackAdd);
     textTrackListeners.put(TextTrackListEventTypes.REMOVETRACK, (EventListener<RemoveTrackEvent>) this::onTextTrackRemove);
+    textTrackListeners.put(TextTrackListEventTypes.TRACKLISTCHANGE, (EventListener<TrackListChangeEvent>) this::onTextTrackChange);
+    audioTrackListeners.put(AudioTrackListEventTypes.ADDTRACK, (EventListener<com.theoplayer.android.api.event.track.mediatrack.audio.list.AddTrackEvent>) this::onAudioTrackAdd);
+    audioTrackListeners.put(AudioTrackListEventTypes.REMOVETRACK, (EventListener<com.theoplayer.android.api.event.track.mediatrack.audio.list.RemoveTrackEvent>) this::onAudioTrackRemove);
+    audioTrackListeners.put(AudioTrackListEventTypes.TRACKLISTCHANGE, (EventListener<com.theoplayer.android.api.event.track.mediatrack.audio.list.TrackListChangeEvent>) this::onAudioTrackChange);
+    videoTrackListeners.put(VideoTrackListEventTypes.ADDTRACK, (EventListener<com.theoplayer.android.api.event.track.mediatrack.video.list.AddTrackEvent>) this::onVideoTrackAdd);
+    videoTrackListeners.put(VideoTrackListEventTypes.REMOVETRACK, (EventListener<com.theoplayer.android.api.event.track.mediatrack.video.list.RemoveTrackEvent>) this::onVideoTrackRemove);
+    videoTrackListeners.put(VideoTrackListEventTypes.TRACKLISTCHANGE, (EventListener<com.theoplayer.android.api.event.track.mediatrack.video.list.TrackListChangeEvent>) this::onVideoTrackChange);
   }
 
   public void setViewId(int viewId) {
@@ -345,24 +374,33 @@ public class VideoEventEmitter {
     receiveEvent(EVENT_SEGMENTNOTFOUND, payload);
   }
 
-  private void onTextTrackAdd(@NonNull AddTrackEvent event) {
+  private void dispatchTextTrackEvent(TrackEventType eventType, TextTrack textTrack) {
     WritableMap payload = Arguments.createMap();
-    TextTrack textTrack = event.getTrack();
     payload.putMap(EVENT_PROP_TRACK, playerView.getTextTrackInfo(textTrack));
-    payload.putInt(EVENT_PROP_TYPE, TrackEventType.ADD_TRACK.type);
-    textTrack.addEventListener(TextTrackEventTypes.ADDCUE, this::onTextTrackAddCue);
-    textTrack.addEventListener(TextTrackEventTypes.REMOVECUE, this::onTextTrackRemoveCue);
+    payload.putInt(EVENT_PROP_TYPE, eventType.type);
+    switch (eventType) {
+      case ADD_TRACK:
+        textTrack.addEventListener(TextTrackEventTypes.ADDCUE, this::onTextTrackAddCue);
+        textTrack.addEventListener(TextTrackEventTypes.REMOVECUE, this::onTextTrackRemoveCue);
+        break;
+      case REMOVE_TRACK:
+        textTrack.removeEventListener(TextTrackEventTypes.ADDCUE, this::onTextTrackAddCue);
+        textTrack.removeEventListener(TextTrackEventTypes.REMOVECUE, this::onTextTrackRemoveCue);
+        break;
+    }
     receiveEvent(EVENT_TEXTTRACK_LIST_EVENT, payload);
   }
 
+  private void onTextTrackAdd(@NonNull AddTrackEvent event) {
+    dispatchTextTrackEvent(TrackEventType.ADD_TRACK, event.getTrack());
+  }
+
   private void onTextTrackRemove(@NonNull RemoveTrackEvent event) {
-    WritableMap payload = Arguments.createMap();
-    TextTrack textTrack = event.getTrack();
-    payload.putMap(EVENT_PROP_TRACK, playerView.getTextTrackInfo(textTrack));
-    payload.putInt(EVENT_PROP_TYPE, TrackEventType.REMOVE_TRACK.type);
-    textTrack.removeEventListener(TextTrackEventTypes.ADDCUE, this::onTextTrackAddCue);
-    textTrack.removeEventListener(TextTrackEventTypes.REMOVECUE, this::onTextTrackRemoveCue);
-    receiveEvent(EVENT_TEXTTRACK_LIST_EVENT, payload);
+    dispatchTextTrackEvent(TrackEventType.REMOVE_TRACK, event.getTrack());
+  }
+
+  private void onTextTrackChange(@NonNull TrackListChangeEvent event) {
+    dispatchTextTrackEvent(TrackEventType.CHANGE_TRACK, event.getTrack());
   }
 
   private void onTextTrackAddCue(@NonNull AddCueEvent event) {
@@ -381,6 +419,84 @@ public class VideoEventEmitter {
     receiveEvent(EVENT_TEXTTRACK_EVENT, payload);
   }
 
+  private MediaTrack<AudioQuality> activeAudioTrack() {
+    return playerView.getPlayer() != null ? activeTrack(playerView.getPlayer().getAudioTracks()) : null;
+  }
+
+  private MediaTrack<VideoQuality> activeVideoTrack() {
+    return playerView.getPlayer() != null ? activeTrack(playerView.getPlayer().getVideoTracks()) : null;
+  }
+
+  private <T extends Quality> MediaTrack<T> activeTrack(final MediaTrackList<T> tracks) {
+    for (int i = 0; i < tracks.length(); i++) {
+      MediaTrack<T> track = tracks.getItem(i);
+      if (track.isEnabled()) {
+        return track;
+      }
+    }
+    return null;
+  }
+
+  private void onActiveQualityChanged(@NonNull QualityChangedEvent event) {
+    Quality quality = event.getQuality();
+    MediaTrackType trackType = quality instanceof AudioQuality ? MediaTrackType.AUDIO : MediaTrackType.VIDEO;
+    WritableMap payload = Arguments.createMap();
+    payload.putInt(EVENT_PROP_TYPE, MediaTrackEventType.ACTIVE_QUALITY_CHANGED.type);
+    payload.putInt(EVENT_PROP_TRACK_TYPE, trackType.type);
+    MediaTrack<? extends Quality> activeTrack = (trackType == MediaTrackType.AUDIO) ? activeAudioTrack() : activeVideoTrack();
+    if (activeTrack != null) {
+      payload.putInt(EVENT_PROP_TRACK_UID, activeTrack.getUid());
+    }
+    WritableArray qualities = Arguments.createArray();
+    qualities.pushMap(TrackListInfo.fromQuality(quality));
+    payload.putArray(EVENT_PROP_QUALITIES, qualities);
+    receiveEvent(EVENT_MEDIATRACK_EVENT, payload);
+  }
+
+  private <Q extends Quality> void dispatchMediaTrackEvent(TrackEventType eventType, MediaTrackType trackType, MediaTrack<Q> track) {
+    WritableMap payload = Arguments.createMap();
+    payload.putInt(EVENT_PROP_TYPE, eventType.type);
+    payload.putInt(EVENT_PROP_TRACK_TYPE, trackType.type);
+    payload.putMap(EVENT_PROP_TRACK, TrackListInfo.fromMediaTrack(track, trackType));
+    EventType<QualityChangedEvent<Q, ActiveQualityChangedEvent>> qualityChangedEventType =
+      (EventType<QualityChangedEvent<Q, ActiveQualityChangedEvent>>) (trackType == MediaTrackType.AUDIO ?
+        AudioTrackEventTypes.ACTIVEQUALITYCHANGEDEVENT : VideoTrackEventTypes.ACTIVEQUALITYCHANGEDEVENT);
+
+    switch (eventType) {
+      case ADD_TRACK:
+        track.addEventListener(qualityChangedEventType, this::onActiveQualityChanged);
+        break;
+      case REMOVE_TRACK:
+        track.removeEventListener(qualityChangedEventType, this::onActiveQualityChanged);
+        break;
+    }
+    receiveEvent(EVENT_MEDIATRACK_LIST_EVENT, payload);
+  }
+
+  private void onAudioTrackAdd(@NonNull com.theoplayer.android.api.event.track.mediatrack.audio.list.AddTrackEvent event) {
+    dispatchMediaTrackEvent(TrackEventType.ADD_TRACK, MediaTrackType.AUDIO, event.getTrack());
+  }
+
+  private void onVideoTrackAdd(@NonNull com.theoplayer.android.api.event.track.mediatrack.video.list.AddTrackEvent event) {
+    dispatchMediaTrackEvent(TrackEventType.ADD_TRACK, MediaTrackType.VIDEO, event.getTrack());
+  }
+
+  private void onAudioTrackRemove(@NonNull com.theoplayer.android.api.event.track.mediatrack.audio.list.RemoveTrackEvent event) {
+    dispatchMediaTrackEvent(TrackEventType.REMOVE_TRACK, MediaTrackType.AUDIO, event.getTrack());
+  }
+
+  private void onVideoTrackRemove(@NonNull com.theoplayer.android.api.event.track.mediatrack.video.list.RemoveTrackEvent event) {
+    dispatchMediaTrackEvent(TrackEventType.REMOVE_TRACK, MediaTrackType.VIDEO, event.getTrack());
+  }
+
+  private void onAudioTrackChange(@NonNull com.theoplayer.android.api.event.track.mediatrack.audio.list.TrackListChangeEvent event) {
+    dispatchMediaTrackEvent(TrackEventType.CHANGE_TRACK, MediaTrackType.AUDIO, event.getTrack());
+  }
+
+  private void onVideoTrackChange(@NonNull com.theoplayer.android.api.event.track.mediatrack.video.list.TrackListChangeEvent event) {
+    dispatchMediaTrackEvent(TrackEventType.CHANGE_TRACK, MediaTrackType.VIDEO, event.getTrack());
+  }
+
   public void onFullscreenWillPresent() {
     receiveEvent(EVENT_FULLSCREEN_WILL_PRESENT, null);
   }
@@ -418,6 +534,16 @@ public class VideoEventEmitter {
       player.getTextTracks().addEventListener(entry.getKey(), entry.getValue());
     }
 
+    // Attach audio track listeners
+    for (Map.Entry<EventType, EventListener> entry : audioTrackListeners.entrySet()) {
+      player.getAudioTracks().addEventListener(entry.getKey(), entry.getValue());
+    }
+
+    // Attach video track listeners
+    for (Map.Entry<EventType, EventListener> entry : videoTrackListeners.entrySet()) {
+      player.getVideoTracks().addEventListener(entry.getKey(), entry.getValue());
+    }
+
     // Attach AdStateHolder
     if (BuildConfig.EXTENSION_ADS) {
       adEventAdapter = new AdEventAdapter(playerView.getAdsApi(), payload -> receiveEvent(EVENT_AD_EVENT, payload));
@@ -435,6 +561,16 @@ public class VideoEventEmitter {
       player.getTextTracks().removeEventListener(entry.getKey(), entry.getValue());
     }
 
+    // Remove audio track listeners
+    for (Map.Entry<EventType, EventListener> entry : audioTrackListeners.entrySet()) {
+      player.getAudioTracks().removeEventListener(entry.getKey(), entry.getValue());
+    }
+
+    // Remove video track listeners
+    for (Map.Entry<EventType, EventListener> entry : videoTrackListeners.entrySet()) {
+      player.getVideoTracks().removeEventListener(entry.getKey(), entry.getValue());
+    }
+
     if (adEventAdapter != null) {
       adEventAdapter.destroy();
     }

package/android/src/main/java/com/theoplayer/drm/ContentProtectionModule.kt

@@ -56,6 +56,10 @@ class ContentProtectionModule(private val context: ReactApplicationContext) :
   fun registerContentProtectionIntegration(integrationId: String, keySystemIdStr: String) {
     val keySystemId = KeySystemAdapter.fromString(keySystemIdStr)
     if (keySystemId != null) {
+      // We only support Widevine currently.
+      if (keySystemId != KeySystemId.WIDEVINE) {
+        return
+      }
       handler.post {
         val factory = ProxyContentProtectionIntegrationFactory(integrationId, keySystemId, this)
         THEOplayerGlobal.getSharedInstance(context.applicationContext)

package/android/src/main/java/com/theoplayer/track/MediaTrackEventType.java

@@ -0,0 +1,11 @@
+package com.theoplayer.track;
+
+public enum MediaTrackEventType {
+  ACTIVE_QUALITY_CHANGED(0),
+  TARGET_QUALITY_CHANGED(1);
+
+  public final int type;
+  MediaTrackEventType(int type) {
+    this.type = type;
+  }
+}

package/android/src/main/java/com/theoplayer/track/MediaTrackType.java

@@ -0,0 +1,11 @@
+package com.theoplayer.track;
+
+public enum MediaTrackType {
+  AUDIO(0),
+  VIDEO(1);
+
+  public final int type;
+  MediaTrackType(int type) {
+    this.type = type;
+  }
+}

package/android/src/main/java/com/theoplayer/track/TrackEventType.java

@@ -2,7 +2,8 @@ package com.theoplayer.track;
 
 public enum TrackEventType {
   ADD_TRACK(0),
-  REMOVE_TRACK(1);
+  REMOVE_TRACK(1),
+  CHANGE_TRACK(2);
 
   public final int type;
   TrackEventType(int type) {

package/android/src/main/java/com/theoplayer/track/TrackListInfo.java

@@ -8,6 +8,7 @@ import com.facebook.react.bridge.WritableMap;
 import com.theoplayer.android.api.player.track.mediatrack.MediaTrack;
 import com.theoplayer.android.api.player.track.mediatrack.MediaTrackList;
 import com.theoplayer.android.api.player.track.mediatrack.quality.AudioQuality;
+import com.theoplayer.android.api.player.track.mediatrack.quality.Quality;
 import com.theoplayer.android.api.player.track.mediatrack.quality.QualityList;
 import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality;
 import com.theoplayer.android.api.player.track.texttrack.TextTrack;
@@ -90,122 +91,143 @@ public class TrackListInfo {
     return cuePayload;
   }
 
+  static public WritableMap fromQuality(@NonNull final Quality quality) {
+    return quality instanceof AudioQuality ? fromAudioQuality((AudioQuality)quality) : fromVideoQuality((VideoQuality) quality);
+  }
+
+  static public WritableMap fromAudioQuality(@NonNull final AudioQuality quality) {
+    WritableMap audioQualityPayload = Arguments.createMap();
+    audioQualityPayload.putString(PROP_ID, quality.getId());
+    audioQualityPayload.putInt(PROP_UID, quality.getUid());
+    audioQualityPayload.putString(PROP_CODECS, quality.getCodecs());
+    audioQualityPayload.putString(PROP_NAME, quality.getName());
+    audioQualityPayload.putDouble(PROP_BANDWIDTH, quality.getBandwidth());
+    audioQualityPayload.putDouble(PROP_AUDIO_SAMPLING_RATE, quality.getAudioSamplingRate());
+    return audioQualityPayload;
+  }
+
+  static public <Q extends Quality> WritableMap fromMediaTrack(@NonNull final MediaTrack<Q> track,
+                                                               MediaTrackType trackType) {
+    //noinspection unchecked
+    return trackType == MediaTrackType.AUDIO ?
+      fromAudioTrack((MediaTrack<AudioQuality>)track) :
+      fromVideoTrack((MediaTrack<VideoQuality>)track);
+  }
+
+  static public WritableMap fromAudioTrack(@NonNull final MediaTrack<AudioQuality> audioTrack) {
+    WritableMap audioTrackPayload = Arguments.createMap();
+    audioTrackPayload.putString(PROP_ID, audioTrack.getId());
+    audioTrackPayload.putInt(PROP_UID, audioTrack.getUid());
+    audioTrackPayload.putString(PROP_KIND, audioTrack.getKind());
+    audioTrackPayload.putString(PROP_LABEL, audioTrack.getLabel());
+    audioTrackPayload.putString(PROP_LANGUAGE, audioTrack.getLanguage());
+
+    final QualityList<AudioQuality> qualityList = audioTrack.getQualities();
+    WritableArray qualities = Arguments.createArray();
+    if (qualityList != null) {
+      for (int j = 0; j < qualityList.length(); j++) {
+        qualities.pushMap(fromAudioQuality(qualityList.getItem(j)));
+      }
+    }
+    audioTrackPayload.putArray(PROP_QUALITIES, qualities);
+
+    final QualityList<AudioQuality> targetQualityList = audioTrack.getTargetQualities();
+    WritableArray targetQualities = Arguments.createArray();
+    if (targetQualityList != null) {
+      for (int j = 0; j < targetQualityList.length(); j++) {
+        final AudioQuality quality = targetQualityList.getItem(j);
+        WritableMap audioQualityPayload = Arguments.createMap();
+        audioQualityPayload.putInt(PROP_UID, quality.getUid());
+        targetQualities.pushMap(audioQualityPayload);
+      }
+    }
+    final AudioQuality activeQuality = audioTrack.getActiveQuality();
+    if (activeQuality != null) {
+      audioTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.getUid());
+    }
+    final AudioQuality targetQuality = audioTrack.getTargetQuality();
+    if (targetQuality != null) {
+      audioTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.getUid());
+    }
+    return audioTrackPayload;
+  }
+
   @NonNull
   public static WritableArray fromAudioTrackList(@NonNull final MediaTrackList<AudioQuality> audioTrackList) {
     WritableArray audioTracks = Arguments.createArray();
     for (int i = 0; i < audioTrackList.length(); i++) {
-      final MediaTrack<AudioQuality> audioTrack = audioTrackList.getItem(i);
-      WritableMap audioTrackPayload = Arguments.createMap();
-      audioTrackPayload.putString(PROP_ID, audioTrack.getId());
-      audioTrackPayload.putInt(PROP_UID, audioTrack.getUid());
-      audioTrackPayload.putString(PROP_KIND, audioTrack.getKind());
-      audioTrackPayload.putString(PROP_LABEL, audioTrack.getLabel());
-      audioTrackPayload.putString(PROP_LANGUAGE, audioTrack.getLanguage());
-
-      final QualityList<AudioQuality> qualityList = audioTrack.getQualities();
-      WritableArray qualities = Arguments.createArray();
-      if (qualityList != null) {
-        for (int j = 0; j < qualityList.length(); j++) {
-          final AudioQuality audioQuality = qualityList.getItem(j);
-          WritableMap audioQualityPayload = Arguments.createMap();
-          audioQualityPayload.putString(PROP_ID, audioQuality.getId());
-          audioQualityPayload.putInt(PROP_UID, audioQuality.getUid());
-          audioQualityPayload.putString(PROP_CODECS, audioQuality.getCodecs());
-          audioQualityPayload.putString(PROP_NAME, audioQuality.getName());
-          audioQualityPayload.putDouble(PROP_BANDWIDTH, audioQuality.getBandwidth());
-          audioQualityPayload.putDouble(PROP_AUDIO_SAMPLING_RATE, audioQuality.getAudioSamplingRate());
-          qualities.pushMap(audioQualityPayload);
-        }
-      }
-      audioTrackPayload.putArray(PROP_QUALITIES, qualities);
-
-      final QualityList<AudioQuality> targetQualityList = audioTrack.getTargetQualities();
-      WritableArray targetQualities = Arguments.createArray();
-      if (targetQualityList != null) {
-        for (int j = 0; j < targetQualityList.length(); j++) {
-          final AudioQuality quality = targetQualityList.getItem(j);
-          WritableMap audioQualityPayload = Arguments.createMap();
-          audioQualityPayload.putInt(PROP_UID, quality.getUid());
-          targetQualities.pushMap(audioQualityPayload);
-        }
-      }
+      audioTracks.pushMap(fromAudioTrack(audioTrackList.getItem(i)));
+    }
+    return audioTracks;
+  }
 
-      final AudioQuality activeQuality = audioTrack.getActiveQuality();
-      if (activeQuality != null) {
-        audioTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.getUid());
-      }
+  static public WritableMap fromVideoQuality(@NonNull final VideoQuality quality) {
+    WritableMap videoQualityPayload = Arguments.createMap();
+    videoQualityPayload.putString(PROP_ID, quality.getId());
+    videoQualityPayload.putInt(PROP_UID, quality.getUid());
+    videoQualityPayload.putString(PROP_CODECS, quality.getCodecs());
+    videoQualityPayload.putString(PROP_NAME, quality.getName());
+    videoQualityPayload.putDouble(PROP_BANDWIDTH, quality.getBandwidth());
+    videoQualityPayload.putDouble(PROP_WIDTH, quality.getWidth());
+    videoQualityPayload.putDouble(PROP_HEIGHT, quality.getHeight());
+    videoQualityPayload.putDouble(PROP_FRAMERATE, quality.getFrameRate());
+    return videoQualityPayload;
+  }
 
-      final AudioQuality targetQuality = audioTrack.getTargetQuality();
-      if (targetQuality != null) {
-        audioTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.getUid());
+  static public WritableMap fromVideoTrack(@NonNull final MediaTrack<VideoQuality> videoTrack) {
+    WritableMap videoTrackPayload = Arguments.createMap();
+    videoTrackPayload.putString(PROP_ID, videoTrack.getId());
+    videoTrackPayload.putInt(PROP_UID, videoTrack.getUid());
+    videoTrackPayload.putString(PROP_KIND, videoTrack.getKind());
+    videoTrackPayload.putString(PROP_LABEL, videoTrack.getLabel());
+    videoTrackPayload.putString(PROP_LANGUAGE, videoTrack.getLanguage());
+
+    final QualityList<VideoQuality> qualityList = videoTrack.getQualities();
+    WritableArray qualities = Arguments.createArray();
+
+    if (qualityList != null) {
+      // Sort qualities according to (height, bandwidth)
+      final QualityListAdapter<VideoQuality> sortedQualityList = new QualityListAdapter<>(qualityList);
+      sortedQualityList.sort(
+        (o, t1) ->
+          (o.getHeight() == t1.getHeight()) ?
+            Long.compare(t1.getBandwidth(), o.getBandwidth()) : Integer.compare(t1.getHeight(), o.getHeight())
+      );
+
+      for (final VideoQuality quality : sortedQualityList) {
+        qualities.pushMap(fromVideoQuality(quality));
       }
+    }
+    videoTrackPayload.putArray(PROP_QUALITIES, qualities);
+
+    final QualityList<VideoQuality> targetQualityList = videoTrack.getTargetQualities();
+    WritableArray targetQualities = Arguments.createArray();
+    if (targetQualityList != null) {
+      for (int j = 0; j < targetQualityList.length(); j++) {
+        final VideoQuality quality = targetQualityList.getItem(j);
+        WritableMap videoQualityPayload = Arguments.createMap();
+        videoQualityPayload.putInt(PROP_UID, quality.getUid());
+        targetQualities.pushMap(videoQualityPayload);
+      }
+    }
 
-      audioTracks.pushMap(audioTrackPayload);
+    final VideoQuality activeQuality = videoTrack.getActiveQuality();
+    if (activeQuality != null) {
+      videoTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.getUid());
     }
-    return audioTracks;
+
+    final VideoQuality targetQuality = videoTrack.getTargetQuality();
+    if (targetQuality != null) {
+      videoTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.getUid());
+    }
+    return videoTrackPayload;
   }
 
   @NonNull
   static public WritableArray fromVideoTrackList(@NonNull final MediaTrackList<VideoQuality> videoTrackList) {
     WritableArray videoTracks = Arguments.createArray();
     for (int i = 0; i < videoTrackList.length(); i++) {
-      final MediaTrack<VideoQuality> videoTrack = videoTrackList.getItem(i);
-      WritableMap videoTrackPayload = Arguments.createMap();
-      videoTrackPayload.putString(PROP_ID, videoTrack.getId());
-      videoTrackPayload.putInt(PROP_UID, videoTrack.getUid());
-      videoTrackPayload.putString(PROP_KIND, videoTrack.getKind());
-      videoTrackPayload.putString(PROP_LABEL, videoTrack.getLabel());
-      videoTrackPayload.putString(PROP_LANGUAGE, videoTrack.getLanguage());
-
-      final QualityList<VideoQuality> qualityList = videoTrack.getQualities();
-      WritableArray qualities = Arguments.createArray();
-
-      if (qualityList != null) {
-        // Sort qualities according to (height, bandwidth)
-        final QualityListAdapter<VideoQuality> sortedQualityList = new QualityListAdapter<>(qualityList);
-        sortedQualityList.sort(
-          (o, t1) ->
-            (o.getHeight() == t1.getHeight()) ?
-              Long.compare(t1.getBandwidth(), o.getBandwidth()) : Integer.compare(t1.getHeight(), o.getHeight())
-        );
-
-        for (final VideoQuality quality : sortedQualityList) {
-          WritableMap videoQualityPayload = Arguments.createMap();
-          videoQualityPayload.putString(PROP_ID, quality.getId());
-          videoQualityPayload.putInt(PROP_UID, quality.getUid());
-          videoQualityPayload.putString(PROP_CODECS, quality.getCodecs());
-          videoQualityPayload.putString(PROP_NAME, quality.getName());
-          videoQualityPayload.putDouble(PROP_BANDWIDTH, quality.getBandwidth());
-          videoQualityPayload.putDouble(PROP_WIDTH, quality.getWidth());
-          videoQualityPayload.putDouble(PROP_HEIGHT, quality.getHeight());
-          videoQualityPayload.putDouble(PROP_FRAMERATE, quality.getFrameRate());
-          qualities.pushMap(videoQualityPayload);
-        }
-      }
-      videoTrackPayload.putArray(PROP_QUALITIES, qualities);
-
-      final QualityList<VideoQuality> targetQualityList = videoTrack.getTargetQualities();
-      WritableArray targetQualities = Arguments.createArray();
-      if (targetQualityList != null) {
-        for (int j = 0; j < targetQualityList.length(); j++) {
-          final VideoQuality quality = targetQualityList.getItem(j);
-          WritableMap videoQualityPayload = Arguments.createMap();
-          videoQualityPayload.putInt(PROP_UID, quality.getUid());
-          targetQualities.pushMap(videoQualityPayload);
-        }
-      }
-
-      final VideoQuality activeQuality = videoTrack.getActiveQuality();
-      if (activeQuality != null) {
-        videoTrackPayload.putInt(PROP_ACTIVE_QUALITY, activeQuality.getUid());
-      }
-
-      final VideoQuality targetQuality = videoTrack.getTargetQuality();
-      if (targetQuality != null) {
-        videoTrackPayload.putInt(PROP_TARGET_QUALITY, targetQuality.getUid());
-      }
-
-      videoTracks.pushMap(videoTrackPayload);
+      videoTracks.pushMap(fromVideoTrack(videoTrackList.getItem(i)));
     }
     return videoTracks;
   }

package/ios/THEOplayerRCTAdAggregator.swift

@@ -40,6 +40,7 @@ let PROP_COMPANION_RESOURCE_URI: String = "resourceURI"
 
 class THEOplayerRCTAdAggregator {
 
+#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
     class func aggregateAd(ad: Ad, processAdBreak: Bool = true) -> [String:Any] {
         var adData: [String:Any] = [:]
         adData[PROP_AD_INTEGRATION] = ad.integration._rawValue
@@ -155,4 +156,6 @@ class THEOplayerRCTAdAggregator {
         }
         return nil
     }
+#endif
+    
 }

package/ios/THEOplayerRCTBridge.m

@@ -46,6 +46,8 @@ RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerDidDismiss, RCTDirectEventBlock
 
 RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackListEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackEvent, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeMediaTrackListEvent, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeMediaTrackEvent, RCTDirectEventBlock);
 
 RCT_EXPORT_VIEW_PROPERTY(onNativeAdEvent, RCTDirectEventBlock);