react-native-theoplayer 1.0.0 → 1.1.0

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

@@ -0,0 +1,204 @@
+package com.theoplayer.track;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+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.QualityList;
+import com.theoplayer.android.api.player.track.mediatrack.quality.VideoQuality;
+import com.theoplayer.android.api.player.track.texttrack.TextTrack;
+import com.theoplayer.android.api.player.track.texttrack.TextTrackList;
+import com.theoplayer.android.api.player.track.texttrack.cue.TextTrackCue;
+import com.theoplayer.android.api.player.track.texttrack.cue.TextTrackCueList;
+
+import org.json.JSONObject;
+
+public class TrackListInfo {
+
+  private static final String PROP_ID = "id";
+  private static final String PROP_UID = "uid";
+  private static final String PROP_KIND = "kind";
+  private static final String PROP_LANGUAGE = "language";
+  private static final String PROP_MODE = "mode";
+  private static final String PROP_LABEL = "label";
+  private static final String PROP_TYPE = "type";
+  private static final String PROP_CODECS = "codecs";
+  private static final String PROP_NAME = "name";
+  private static final String PROP_SRC = "src";
+  private static final String PROP_FORCED = "forced";
+  private static final String PROP_AUDIO_SAMPLING_RATE = "audioSamplingRate";
+  private static final String PROP_BANDWIDTH = "bandwidth";
+  private static final String PROP_QUALITIES = "qualities";
+  private static final String PROP_ACTIVE_QUALITY = "activeQuality";
+  private static final String PROP_TARGET_QUALITY = "targetQuality";
+  private static final String PROP_WIDTH = "width";
+  private static final String PROP_HEIGHT = "height";
+  private static final String PROP_FRAMERATE = "framerate";
+  private static final String PROP_STARTTIME = "startTime";
+  private static final String PROP_ENDTIME = "endTime";
+  private static final String PROP_CUES = "cues";
+  private static final String PROP_CUE_CONTENT = "content";
+
+  public static WritableArray fromTextTrackList(final TextTrackList textTrackList) {
+    WritableArray textTracks = Arguments.createArray();
+    for (int i = 0; i < textTrackList.length(); i++) {
+      textTracks.pushMap(fromTextTrack(textTrackList.getItem(i)));
+    }
+    return textTracks;
+  }
+
+  public static WritableMap fromTextTrack(final TextTrack textTrack) {
+    WritableMap textTrackPayload = Arguments.createMap();
+    textTrackPayload.putString(PROP_ID, textTrack.getId());
+    textTrackPayload.putInt(PROP_UID, textTrack.getUid());
+    textTrackPayload.putString(PROP_KIND, textTrack.getKind());
+    textTrackPayload.putString(PROP_LANGUAGE, textTrack.getLanguage());
+    textTrackPayload.putString(PROP_MODE, textTrack.getMode().getMode());
+    textTrackPayload.putString(PROP_LABEL, textTrack.getLabel());
+    textTrackPayload.putString(PROP_TYPE, textTrack.getType().getType());
+
+    // THEOplayer v3.5+
+    textTrackPayload.putString(PROP_SRC, textTrack.getSource());
+    textTrackPayload.putBoolean(PROP_FORCED, textTrack.isForced());
+
+    // Optionally pass cue list.
+    final TextTrackCueList cueList = textTrack.getCues();
+    if (cueList != null) {
+      WritableArray cueListPayload = Arguments.createArray();
+      for (TextTrackCue cue : cueList) {
+        cueListPayload.pushMap(fromTextTrackCue(cue));
+      }
+      textTrackPayload.putArray(PROP_CUES, cueListPayload);
+    }
+    return textTrackPayload;
+  }
+
+  public static WritableMap fromTextTrackCue(final TextTrackCue cue) {
+    WritableMap cuePayload = Arguments.createMap();
+    cuePayload.putString(PROP_ID, cue.getId());
+    cuePayload.putDouble(PROP_UID, cue.getUid());
+    cuePayload.putDouble(PROP_STARTTIME, (long) (1e03 * cue.getStartTime()));
+    cuePayload.putDouble(PROP_ENDTIME, (long) (1e03 * cue.getEndTime()));
+    final JSONObject content = cue.getContent();
+    if (content != null) {
+      cuePayload.putString(PROP_CUE_CONTENT, content.optString("content"));
+    }
+    return cuePayload;
+  }
+
+  @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);
+        }
+      }
+
+      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());
+      }
+
+      audioTracks.pushMap(audioTrackPayload);
+    }
+    return audioTracks;
+  }
+
+  @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) {
+        for (int j = 0; j < qualityList.length(); j++) {
+          final VideoQuality quality = qualityList.getItem(j);
+          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);
+    }
+    return videoTracks;
+  }
+}

package/ios/THEOplayerRCTBridge.m

@@ -0,0 +1,46 @@
+//
+//  THEOplayerRCTBridge.m
+//  Theoplayer
+//
+//  Created by William van Haevre on 14/01/2022.
+//  Copyright © 2022 Facebook. All rights reserved.
+//
+
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(THEOplayerRCTViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(src, NSDictionary);
+RCT_EXPORT_VIEW_PROPERTY(config, NSDictionary);
+RCT_EXPORT_VIEW_PROPERTY(paused, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(volume, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(muted, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(playbackRate, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(selectedTextTrack, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(selectedAudioTrack, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(selectedVideoTrack, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(seek, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(fullscreen, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(onNativePause, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativePlay, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeSourceChange, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeLoadStart, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeReadyStateChange, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeDurationChange, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeProgress, RCTBubblingEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeTimeUpdate, RCTBubblingEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativePlaying, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeSeeking, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeSeeked, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeEnded, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeError, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeLoadedData, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeLoadedMetadata, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerWillPresent, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerDidPresent, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerWillDismiss, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerDidDismiss, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackListEvent, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackEvent, RCTDirectEventBlock);
+
+@end

package/ios/THEOplayerRCTDebug.swift

@@ -0,0 +1,16 @@
+// THEOplayerRCTDebug.swift
+
+// General debug flag, if set to false none of the debug prints will appear
+let DEBUG = true
+
+// Debug flag to monitor incoming Theoplayer events
+let DEBUG_THEOPLAYER_EVENTS = DEBUG && true
+
+// Debug flag to monitor eventhandler setup and breakdown
+let DEBUG_EVENTHANDLER = DEBUG && true
+
+// Debug flag to monitor the interactions for each view with its underlying theoplayer instance
+let DEBUG_THEOPLAYER_INTERACTION = DEBUG && true
+
+// Debug flag to monitor all updates made  on bridged properties
+let DEBUG_PROP_UPDATES = DEBUG && true

package/ios/THEOplayerRCTMetadataAggregator.swift

@@ -0,0 +1,169 @@
+// THEOplayerRCTMetadataAggregator.swift
+
+import Foundation
+import THEOplayerSDK
+
+let EVENT_PROP_TEXT_TRACKS: String = "textTracks"
+let EVENT_PROP_AUDIO_TRACKS: String = "audioTracks"
+let EVENT_PROP_VIDEO_TRACKS: String = "videoTracks"
+let EVENT_PROP_SELECTED_TEXT_TRACK: String = "selectedTextTrack"
+let EVENT_PROP_SELECTED_AUDIO_TRACK: String = "selectedAudioTrack"
+let EVENT_PROP_SELECTED_VIDEO_TRACK: String = "selectedVideoTrack"
+let EVENT_PROP_DURATION: String = "duration"
+let PROP_ID: String = "id"
+let PROP_UID: String = "uid"
+let PROP_KIND: String = "kind"
+let PROP_LANGUAGE: String = "language"
+let PROP_MODE: String = "mode"
+let PROP_LABEL: String = "label"
+let PROP_TYPE: String = "type"
+let PROP_QUALITIES: String = "qualities"
+let PROP_ACTIVE_QUALITY: String = "activeQuality"
+let PROP_TARGET_QUALITY: String = "targetQuality"
+let PROP_STARTTIME: String = "startTime"
+let PROP_ENDTIME: String = "endTime"
+let PROP_CUES: String = "cues"
+let PROP_CUE_CONTENT: String = "content"
+let PROP_SRC: String = "src"
+
+class THEOplayerRCTMetadataAggregator {
+
+    class func aggregateMetadata(player: THEOplayer) -> [String:Any] {
+        let textTracks: TextTrackList = player.textTracks
+        let audioTracks: AudioTrackList = player.audioTracks
+        let videoTracks: VideoTrackList = player.videoTracks
+        return [
+            EVENT_PROP_TEXT_TRACKS : THEOplayerRCTMetadataAggregator.aggregatedTextTrackListInfo(textTracks: textTracks),
+            EVENT_PROP_AUDIO_TRACKS : THEOplayerRCTMetadataAggregator.aggregatedAudioTrackListInfo(audioTracks: audioTracks),
+            EVENT_PROP_VIDEO_TRACKS : THEOplayerRCTMetadataAggregator.aggregatedVideoTrackListInfo(videoTracks: videoTracks),
+            EVENT_PROP_SELECTED_TEXT_TRACK: THEOplayerRCTMetadataAggregator.selectedTextTrack(textTracks: textTracks),
+            EVENT_PROP_SELECTED_AUDIO_TRACK: THEOplayerRCTMetadataAggregator.selectedAudioTrack(audioTracks: audioTracks),
+            EVENT_PROP_SELECTED_VIDEO_TRACK: THEOplayerRCTMetadataAggregator.selectedVideoTrack(videoTracks: videoTracks),
+            EVENT_PROP_DURATION: player.duration ?? 0
+        ]
+    }
+
+    class func aggregatedTextTrackListInfo(textTracks: TextTrackList) -> [[String:Any]] {
+        var textTrackEntries:[[String:Any]] = []
+        guard textTracks.count > 0 else {
+            return textTrackEntries
+        }
+        for i in 0...textTracks.count-1 {
+            let textTrack: TextTrack = textTracks.get(i)
+            textTrackEntries.append(THEOplayerRCTMetadataAggregator.aggregatedTextTrackInfo(textTrack: textTrack))
+        }
+        return textTrackEntries
+    }
+    
+    class func aggregatedTextTrackInfo(textTrack: TextTrack) -> [String:Any] {
+        var entry: [String:Any] = [:]
+        entry[PROP_ID] = textTrack.id
+        entry[PROP_UID] = textTrack.uid
+        entry[PROP_KIND] = textTrack.kind
+        entry[PROP_LANGUAGE] = textTrack.language
+        entry[PROP_MODE] = String(describing: textTrack.mode)
+        entry[PROP_LABEL] = textTrack.label
+        entry[PROP_TYPE] = textTrack.type
+        entry[PROP_SRC] = textTrack.src
+        // process cues when texttrack contains them
+        if !textTrack.cues.isEmpty {
+            var cueList: [[String:Any]] = []
+            for cue in textTrack.cues {
+                cueList.append(THEOplayerRCTMetadataAggregator.aggregatedTextTrackCueInfo(textTrackCue: cue))
+            }
+            entry[PROP_CUES] = cueList
+        }
+        return entry
+    }
+    
+    class func aggregatedTextTrackCueInfo(textTrackCue: TextTrackCue) -> [String:Any] {
+        var entry: [String:Any] = [:]
+        entry[PROP_ID] = textTrackCue.id
+        entry[PROP_UID] = textTrackCue.uid
+        entry[PROP_STARTTIME] = (textTrackCue.startTime ?? 0) * 1000
+        entry[PROP_ENDTIME] = (textTrackCue.endTime ?? 0) * 1000
+        entry[PROP_CUE_CONTENT] = textTrackCue.contentString
+        return entry
+    }
+
+    private class func aggregatedAudioTrackListInfo(audioTracks: AudioTrackList) -> [[String:Any]] {
+        var audioTrackEntries:[[String:Any]] = []
+        guard audioTracks.count > 0 else {
+            return audioTrackEntries
+        }
+        for i in 0...audioTracks.count-1 {
+            let audioTrack: MediaTrack = audioTracks.get(i)
+            var entry: [String:Any] = [:]
+            entry[PROP_ID] = audioTrack.id
+            entry[PROP_UID] = audioTrack.uid
+            entry[PROP_KIND] = audioTrack.kind
+            entry[PROP_LANGUAGE] = audioTrack.language
+            entry[PROP_LABEL] = audioTrack.label
+            entry[PROP_QUALITIES] = []          // empty: qualities are not being exposed on iOS
+            //entry[PROP_ACTIVE_QUALITY] =      // undefined: qualities are not being exposed on iOS
+            //entry[PROP_TARGET_QUALITY] =      // undefined: qualities are not being exposed on iOS
+            audioTrackEntries.append(entry)
+        }
+        return audioTrackEntries
+    }
+
+    private class func aggregatedVideoTrackListInfo(videoTracks: VideoTrackList) -> [[String:Any]] {
+        var videoTrackEntries:[[String:Any]] = []
+        guard videoTracks.count > 0 else {
+            return videoTrackEntries
+        }
+        for i in 0...videoTracks.count-1 {
+            let videoTrack: MediaTrack = videoTracks.get(i)
+            var entry: [String:Any] = [:]
+            entry[PROP_ID] = videoTrack.id
+            entry[PROP_UID] = videoTrack.uid
+            entry[PROP_KIND] = videoTrack.kind
+            entry[PROP_LANGUAGE] = videoTrack.language
+            entry[PROP_LABEL] = videoTrack.label
+            entry[PROP_QUALITIES] = []          // empty: qualities are not being exposed on iOS
+            //entry[PROP_ACTIVE_QUALITY] =      // undefined: qualities are not being exposed on iOS
+            //entry[PROP_TARGET_QUALITY] =      // undefined: qualities are not being exposed on iOS
+            videoTrackEntries.append(entry)
+        }
+        return videoTrackEntries
+    }
+
+    private class func selectedTextTrack(textTracks: TextTrackList) -> Int {
+        guard textTracks.count > 0 else {
+            return 0
+        }
+        for i in 0...textTracks.count-1 {
+            let textTrack: TextTrack = textTracks.get(i)
+            if textTrack.mode == TextTrackMode.showing {
+                return textTrack.uid
+            }
+        }
+        return 0
+    }
+
+    private class func selectedAudioTrack(audioTracks: AudioTrackList) -> Int {
+        guard audioTracks.count > 0 else {
+            return 0
+        }
+        for i in 0...audioTracks.count-1 {
+            let audioTrack: MediaTrack = audioTracks.get(i)
+            if audioTrack.enabled {
+                return audioTrack.uid
+            }
+        }
+        return 0
+    }
+
+    private class func selectedVideoTrack(videoTracks: VideoTrackList) -> Int {
+        guard videoTracks.count > 0 else {
+            return 0
+        }
+        for i in 0...videoTracks.count-1 {
+            let videoTrack: MediaTrack = videoTracks.get(i)
+            if videoTracks.get(i).enabled {
+                return videoTrack.uid
+            }
+        }
+        return 0
+    }
+}