react-native-theoplayer 1.0.0 → 1.1.0

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

@@ -0,0 +1,420 @@
+package com.theoplayer;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.os.Build;
+import android.os.Handler;
+import android.util.Log;
+import android.view.View;
+import android.view.Window;
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.theoplayer.android.api.THEOplayerConfig;
+import com.theoplayer.android.api.THEOplayerView;
+import com.theoplayer.android.api.ads.ima.GoogleImaIntegration;
+import com.theoplayer.android.api.ads.ima.GoogleImaIntegrationFactory;
+import com.theoplayer.android.api.player.Player;
+import com.theoplayer.android.api.player.RequestCallback;
+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.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.TextTrackMode;
+import com.theoplayer.android.api.player.track.texttrack.cue.TextTrackCue;
+import com.theoplayer.android.api.source.SourceDescription;
+import com.theoplayer.android.api.timerange.TimeRanges;
+import com.theoplayer.track.TrackListInfo;
+
+@SuppressLint("ViewConstructor")
+public class ReactTHEOplayerView extends FrameLayout implements LifecycleEventListener {
+
+  private static final String TAG = ReactTHEOplayerView.class.getName();
+
+  public static final long TIME_UNSET = Long.MIN_VALUE + 1;
+
+  private final VideoEventEmitter eventEmitter;
+
+  private final ThemedReactContext reactContext;
+
+  private THEOplayerView playerView;
+
+  private Player player;
+
+  private boolean paused;
+  private boolean muted = false;
+  private boolean fullscreen = false;
+  private double playbackRate = 1.0;
+  private double volume = 1.0;
+  private double seekTime = TIME_UNSET;
+  private SourceDescription sourceDescription;
+  private final Handler handler = new Handler();
+
+  public ReactTHEOplayerView(ThemedReactContext context) {
+    super(context);
+    this.reactContext = context;
+    this.eventEmitter = new VideoEventEmitter(context, this);
+    reactContext.addLifecycleEventListener(this);
+  }
+
+  public void initialize(@Nullable ReadableMap configProps) {
+    createViews(PlayerConfigHelper.fromProps(configProps));
+  }
+
+  @NonNull
+  public WritableArray getTextTrackInfo() {
+    if (player != null) {
+      return TrackListInfo.fromTextTrackList(player.getTextTracks());
+    }
+    return Arguments.createArray();
+  }
+
+  @NonNull
+  public WritableMap getTextTrackInfo(TextTrack track) {
+    if (player != null) {
+      return TrackListInfo.fromTextTrack(track);
+    }
+    return Arguments.createMap();
+  }
+
+  @NonNull
+  public WritableMap getTextTrackCueInfo(TextTrackCue cue) {
+    if (player != null) {
+      return TrackListInfo.fromTextTrackCue(cue);
+    }
+    return Arguments.createMap();
+  }
+
+  @NonNull
+  public WritableArray getAudioTrackInfo() {
+    if (player != null) {
+      return TrackListInfo.fromAudioTrackList(player.getAudioTracks());
+    }
+    return Arguments.createArray();
+  }
+
+  @NonNull
+  public WritableArray getVideoTrackInfo() {
+    if (player != null) {
+      return TrackListInfo.fromVideoTrackList(player.getVideoTracks());
+    }
+    return Arguments.createArray();
+  }
+
+  public double getDuration() {
+    return player != null? 1e03 * player.getDuration() : Double.NaN;
+  }
+
+  public void getSeekableRange(RequestCallback<TimeRanges> callback) {
+    if (player != null) {
+      player.requestSeekable(callback);
+    } else {
+      callback.handleResult(null);
+    }
+  }
+
+  public void getBufferedRange(RequestCallback<TimeRanges> callback) {
+    if (player != null) {
+      player.requestBuffered(callback);
+    } else {
+      callback.handleResult(null);
+    }
+  }
+
+  @Override
+  public void setId(int id) {
+    super.setId(id);
+    eventEmitter.setViewId(id);
+  }
+
+  private void createViews(@NonNull THEOplayerConfig playerConfig) {
+    if (BuildConfig.LOG_VIEW_EVENTS) {
+      Log.d(TAG, "Create views");
+    }
+
+    LayoutParams layoutParams = new LayoutParams(
+      LayoutParams.MATCH_PARENT,
+      LayoutParams.MATCH_PARENT);
+
+    playerView = new THEOplayerView(reactContext.getCurrentActivity(), playerConfig) {
+      private void measureAndLayout() {
+        measure(
+          View.MeasureSpec.makeMeasureSpec(getMeasuredWidth(), View.MeasureSpec.EXACTLY),
+          View.MeasureSpec.makeMeasureSpec(getMeasuredHeight(), View.MeasureSpec.EXACTLY));
+        layout(getLeft(), getTop(), getRight(), getBottom());
+      }
+
+      @Override
+      public void requestLayout() {
+        super.requestLayout();
+
+        // schedule a forced layout
+        handler.post(this::measureAndLayout);
+      }
+    };
+    playerView.setLayoutParams(layoutParams);
+
+    addView(playerView, 0, layoutParams);
+    addIntegrations(playerView);
+  }
+
+  private void addIntegrations(@NonNull final THEOplayerView playerView) {
+    GoogleImaIntegration googleImaIntegration = GoogleImaIntegrationFactory.createGoogleImaIntegration(playerView);
+    playerView.getPlayer().addIntegration(googleImaIntegration);
+    // Add other future integrations here.
+  }
+
+  @Override
+  protected void onAttachedToWindow() {
+    if (BuildConfig.LOG_VIEW_EVENTS) {
+      Log.d(TAG, "onAttachedToWindow");
+    }
+    super.onAttachedToWindow();
+    initializePlayer();
+  }
+
+  @Override
+  protected void onDetachedFromWindow() {
+    if (BuildConfig.LOG_VIEW_EVENTS) {
+      Log.d(TAG, "onDetachedFromWindow");
+    }
+    super.onDetachedFromWindow();
+    /* We want to be able to continue playing audio when switching tabs.
+     * Leave this here in case it causes issues.
+     */
+    // stopPlayback();
+  }
+
+  private void initializePlayer() {
+    // This ensures all props have been settled, to avoid async racing conditions.
+    new Handler().postDelayed(() -> {
+      if (player == null) {
+        player = playerView.getPlayer();
+        eventEmitter.attachListeners(player);
+        player.setMuted(this.muted);
+        player.setVolume(this.volume);
+        player.setPlaybackRate(this.playbackRate);
+        player.setSource(this.sourceDescription);
+
+        if (!this.paused) {
+          player.play();
+        }
+
+        seekTo(this.seekTime);
+      }
+    }, 1);
+  }
+
+  @Override
+  public void onHostResume() {
+    if (BuildConfig.LOG_VIEW_EVENTS) {
+      Log.d(TAG, "onHostResume");
+    }
+    if (playerView != null) {
+      playerView.onResume();
+    }
+  }
+
+  @Override
+  public void onHostPause() {
+    if (BuildConfig.LOG_VIEW_EVENTS) {
+      Log.d(TAG, "onHostPause");
+    }
+    if (playerView != null) {
+      playerView.onPause();
+    }
+  }
+
+  @Override
+  public void onHostDestroy() {
+    if (BuildConfig.LOG_VIEW_EVENTS) {
+      Log.d(TAG, "onHostDestroy");
+    }
+    stopPlayback();
+    if (playerView != null) {
+      playerView.onDestroy();
+    }
+  }
+
+  public void cleanUpResources() {
+    if (BuildConfig.LOG_VIEW_EVENTS) {
+      Log.d(TAG, "cleanUpResources");
+    }
+    stopPlayback();
+  }
+
+  private void stopPlayback() {
+    releasePlayer();
+  }
+
+  private void releasePlayer() {
+    if (player != null) {
+      eventEmitter.removeListeners(player);
+      player.stop();
+      player = null;
+    }
+    reactContext.removeLifecycleEventListener(this);
+  }
+
+  public void setSource(@Nullable final SourceDescription sourceDescription) {
+    this.sourceDescription = sourceDescription;
+    if (player != null && sourceDescription != null) {
+      player.setSource(sourceDescription);
+    }
+  }
+
+  public void setPaused(boolean paused) {
+    this.paused = paused;
+    if (player != null) {
+      final boolean playerIsPaused = player.isPaused();
+      if (!paused && playerIsPaused) {
+        player.play();
+      } else if (paused && !playerIsPaused) {
+        player.pause();
+      }
+    }
+  }
+
+  public void setMuted(boolean muted) {
+    this.muted = muted;
+    if (player != null) {
+      player.setMuted(muted);
+    }
+  }
+
+  public void setVolume(double volume) {
+    this.volume = volume;
+    if (player != null) {
+      player.setVolume(volume);
+    }
+  }
+
+  public void setPlaybackRate(double playbackRate) {
+    this.playbackRate = playbackRate;
+    if (player != null) {
+      player.setPlaybackRate(playbackRate);
+    }
+  }
+
+  public void seekTo(double seekTime) {
+    this.seekTime = seekTime;
+    if (player != null) {
+      player.setCurrentTime(1e-03 * seekTime);
+      this.seekTime = TIME_UNSET;
+    }
+  }
+
+  @Nullable
+  public TextTrack getSelectedTextTrack() {
+    if (player != null) {
+      final TextTrackList tracks = player.getTextTracks();
+      for (int i = 0; i < tracks.length(); i++) {
+        final TextTrack track = tracks.getItem(i);
+        if (track.getMode() == TextTrackMode.SHOWING) {
+          return track;
+        }
+      }
+    }
+    return null;
+  }
+
+  public void setSelectedTextTrack(int uid) {
+    if (player != null) {
+      for (final TextTrack track: player.getTextTracks()) {
+        if (track.getUid() == uid) {
+          track.setMode(TextTrackMode.SHOWING);
+        } else {
+          track.setMode(TextTrackMode.HIDDEN);
+        }
+      }
+    }
+  }
+
+  @Nullable
+  public MediaTrack<AudioQuality> getSelectedAudioTrack() {
+    if (player != null) {
+      final MediaTrackList<AudioQuality> tracks = player.getAudioTracks();
+      for (int i = 0; i < tracks.length(); i++) {
+        final MediaTrack<AudioQuality> track = tracks.getItem(i);
+        if (track.isEnabled()) {
+          return track;
+        }
+      }
+    }
+    return null;
+  }
+
+  public void setSelectedAudioTrack(int uid) {
+    if (player != null) {
+      for (final MediaTrack<AudioQuality> track: player.getAudioTracks()) {
+        track.setEnabled(track.getUid() == uid);
+      }
+    }
+  }
+
+  @Nullable
+  public MediaTrack<VideoQuality> getSelectedVideoTrack() {
+    if (player != null) {
+      final MediaTrackList<VideoQuality> tracks = player.getVideoTracks();
+      for (int i = 0; i < tracks.length(); i++) {
+        final MediaTrack<VideoQuality> track = tracks.getItem(i);
+        if (track.isEnabled()) {
+          return track;
+        }
+      }
+    }
+    return null;
+  }
+
+  public void setSelectedVideoTrack(int uid) {
+    if (player != null) {
+      for (final MediaTrack<VideoQuality> track: player.getVideoTracks()) {
+        track.setEnabled(track.getUid() == uid);
+      }
+    }
+  }
+
+  @SuppressLint("ObsoleteSdkInt")
+  public void setFullscreen(boolean fullscreen) {
+    if (fullscreen == this.fullscreen) {
+      return; // Avoid generating events when nothing is changing
+    }
+    this.fullscreen = fullscreen;
+
+    Activity activity = reactContext.getCurrentActivity();
+    if (activity == null) {
+      return;
+    }
+    Window window = activity.getWindow();
+    View decorView = window.getDecorView();
+    int uiOptions;
+    if (fullscreen) {
+      if (Build.VERSION.SDK_INT >= 19) { // 4.4+
+        uiOptions = SYSTEM_UI_FLAG_HIDE_NAVIGATION
+          | SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+          | SYSTEM_UI_FLAG_FULLSCREEN;
+      } else {
+        uiOptions = SYSTEM_UI_FLAG_HIDE_NAVIGATION
+          | SYSTEM_UI_FLAG_FULLSCREEN;
+      }
+      eventEmitter.onFullscreenWillPresent();
+      decorView.setSystemUiVisibility(uiOptions);
+      eventEmitter.onFullscreenDidPresent();
+    } else {
+      uiOptions = View.SYSTEM_UI_FLAG_VISIBLE;
+      eventEmitter.onFullscreenWillDismiss();
+      decorView.setSystemUiVisibility(uiOptions);
+      eventEmitter.onFullscreenDidDismiss();
+    }
+  }
+}

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

@@ -0,0 +1,114 @@
+package com.theoplayer;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import java.util.Map;
+
+public class ReactTHEOplayerViewManager extends ViewGroupManager<ReactTHEOplayerView> {
+  public static final String REACT_CLASS = "THEOplayerRCTView";
+
+  private static final String PROP_CONFIG = "config";
+  private static final String PROP_SRC = "src";
+  private static final String PROP_SEEK = "seek";
+  private static final String PROP_PAUSED = "paused";
+  private static final String PROP_MUTED = "muted";
+  private static final String PROP_VOLUME = "volume";
+  private static final String PROP_PLAYBACKRATE = "playbackRate";
+  private static final String PROP_FULLSCREEN = "fullscreen";
+  private static final String PROP_SELECTED_TEXTTRACK = "selectedTextTrack";
+  private static final String PROP_SELECTED_AUDIOTRACK = "selectedAudioTrack";
+  private static final String PROP_SELECTED_VIDEOTRACK = "selectedVideoTrack";
+
+  @Override
+  @NonNull
+  public String getName() {
+    return REACT_CLASS;
+  }
+
+  @NonNull
+  @Override
+  protected ReactTHEOplayerView createViewInstance(@NonNull ThemedReactContext reactContext) {
+    return new ReactTHEOplayerView(reactContext);
+  }
+
+  @Override
+  public void onDropViewInstance(ReactTHEOplayerView view) {
+    view.cleanUpResources();
+  }
+
+  @ReactProp(name = PROP_CONFIG)
+  public void setConfig(final ReactTHEOplayerView videoView, @Nullable ReadableMap config) {
+    videoView.initialize(config);
+  }
+
+  @ReactProp(name = PROP_SRC)
+  public void setSource(final ReactTHEOplayerView videoView, @Nullable ReadableMap src) {
+    videoView.setSource(new SourceHelper().parseSourceFromJS(src));
+  }
+
+  @ReactProp(name = PROP_SEEK)
+  public void setSeek(final ReactTHEOplayerView videoView, final double seek) {
+    videoView.seekTo(seek);
+  }
+
+  @ReactProp(name = PROP_PAUSED, defaultBoolean = false)
+  public void setPaused(final ReactTHEOplayerView videoView, final boolean paused) {
+    videoView.setPaused(paused);
+  }
+
+  @ReactProp(name = PROP_MUTED, defaultBoolean = false)
+  public void setMuted(final ReactTHEOplayerView videoView, final boolean muted) {
+    videoView.setMuted(muted);
+  }
+
+  @ReactProp(name = PROP_VOLUME, defaultDouble = 1.0)
+  public void setVolume(final ReactTHEOplayerView videoView, final double volume) {
+    videoView.setVolume(volume);
+  }
+
+  @ReactProp(name = PROP_PLAYBACKRATE, defaultDouble = 1.0)
+  public void setPlaybackRate(final ReactTHEOplayerView videoView, final double playbackRate) {
+    videoView.setPlaybackRate(playbackRate);
+  }
+
+  @ReactProp(name = PROP_FULLSCREEN, defaultBoolean = false)
+  public void setFullscreen(final ReactTHEOplayerView videoView, final boolean fullscreen) {
+    videoView.setFullscreen(fullscreen);
+  }
+
+  @ReactProp(name = PROP_SELECTED_TEXTTRACK, defaultInt = -1)
+  public void setSelectedTextTrack(final ReactTHEOplayerView videoView, final int uid) {
+    videoView.setSelectedTextTrack(uid);
+  }
+
+  @ReactProp(name = PROP_SELECTED_AUDIOTRACK, defaultInt = -1)
+  public void setSelectedAudioTrack(final ReactTHEOplayerView videoView, final int uid) {
+    if (uid != -1) {
+      videoView.setSelectedAudioTrack(uid);
+    }
+  }
+
+  @ReactProp(name = PROP_SELECTED_VIDEOTRACK, defaultInt = -1)
+  public void setSelectedVideoTrack(final ReactTHEOplayerView videoView, final int uid) {
+    if (uid != -1) {
+      videoView.setSelectedVideoTrack(uid);
+    }
+  }
+
+  @Override
+  public @Nullable
+  Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+    MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+    for (String event : VideoEventEmitter.Events) {
+      builder.put(event, MapBuilder.of("registrationName", event));
+    }
+    return builder.build();
+  }
+}