@jwplayer/jwplayer-react-native 1.0.1 → 1.0.3

package/android/src/main/java/com/jwplayer/rnjwplayer/RNJWPlayerView.java

@@ -2,7 +2,11 @@ package com.jwplayer.rnjwplayer;
 
 
 import android.app.Activity;
+import android.app.ActivityManager;
+import android.content.BroadcastReceiver;
 import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.pm.ActivityInfo;
 import android.graphics.Color;
 import android.graphics.PorterDuff;
@@ -12,6 +16,8 @@ import android.media.AudioAttributes;
 import android.media.AudioFocusRequest;
 import android.media.AudioManager;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
@@ -20,7 +26,13 @@ import android.view.WindowManager;
 import android.widget.LinearLayout;
 import android.widget.RelativeLayout;
 
+import androidx.annotation.NonNull;
 import androidx.appcompat.app.AppCompatActivity;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
 
 import com.facebook.react.ReactActivity;
 import com.facebook.react.bridge.Arguments;
@@ -28,15 +40,17 @@ import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.google.common.collect.ImmutableMap;
 import com.google.gson.Gson;
-import com.jwplayer.pub.api.JsonHelper;
 import com.jwplayer.pub.api.JWPlayer;
+import com.jwplayer.pub.api.JsonHelper;
 import com.jwplayer.pub.api.UiGroup;
+import com.jwplayer.pub.api.background.MediaService;
 import com.jwplayer.pub.api.background.MediaServiceController;
 import com.jwplayer.pub.api.configuration.PlayerConfig;
 import com.jwplayer.pub.api.configuration.UiConfig;
@@ -96,18 +110,25 @@ import com.jwplayer.pub.api.events.listeners.AdvertisingEvents;
 import com.jwplayer.pub.api.events.listeners.CastingEvents;
 import com.jwplayer.pub.api.events.listeners.PipPluginEvents;
 import com.jwplayer.pub.api.events.listeners.VideoPlayerEvents;
+import com.jwplayer.pub.api.fullscreen.ExtensibleFullscreenHandler;
+import com.jwplayer.pub.api.fullscreen.FullscreenDialog;
 import com.jwplayer.pub.api.fullscreen.FullscreenHandler;
+import com.jwplayer.pub.api.fullscreen.delegates.DeviceOrientationDelegate;
+import com.jwplayer.pub.api.fullscreen.delegates.DialogLayoutDelegate;
+import com.jwplayer.pub.api.fullscreen.delegates.SystemUiDelegate;
 import com.jwplayer.pub.api.license.LicenseUtil;
+import com.jwplayer.pub.api.media.captions.Caption;
 import com.jwplayer.pub.api.media.playlists.PlaylistItem;
 import com.jwplayer.ui.views.CueMarkerSeekbar;
 
+import org.json.JSONObject;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-
-import org.json.JSONObject;
+import java.util.Objects;
 
 public class RNJWPlayerView extends RelativeLayout implements
         VideoPlayerEvents.OnFullscreenListener,
@@ -166,7 +187,7 @@ public class RNJWPlayerView extends RelativeLayout implements
 
         AudioManager.OnAudioFocusChangeListener,
 
-        LifecycleEventListener {
+        LifecycleEventListener, LifecycleOwner {
     public RNJWPlayer mPlayerView = null;
     public JWPlayer mPlayer = null;
 
@@ -183,6 +204,7 @@ public class RNJWPlayerView extends RelativeLayout implements
     Boolean fullScreenOnLandscape = false;
     Boolean portraitOnExitFullScreen = false;
     Boolean exitFullScreenOnPortrait = false;
+    Boolean playerInModal = false;
 
     Number currentPlayingIndex;
 
@@ -212,10 +234,17 @@ public class RNJWPlayerView extends RelativeLayout implements
     private ThemedReactContext mThemedReactContext;
 
     private MediaServiceController mMediaServiceController;
+    private PipHandlerReceiver mReceiver = null;
 
     private void doBindService() {
         if (mMediaServiceController != null) {
-            mMediaServiceController.bindService();
+            if (!isBackgroundAudioServiceRunning()) {
+                // This may not be your expected behavior, but is necessary to avoid crashing
+                // Do not use multiple player instances with background audio enabled
+
+                // don't rebind me if the service is already active with a player.
+                mMediaServiceController.bindService();
+            }
         }
     }
 
@@ -233,7 +262,7 @@ public class RNJWPlayerView extends RelativeLayout implements
     }
 
     private static Context getNonBuggyContext(ThemedReactContext reactContext,
-            ReactApplicationContext appContext) {
+                                              ReactApplicationContext appContext) {
         Context superContext = reactContext;
         if (!contextHasBug(appContext.getCurrentActivity())) {
             superContext = appContext.getCurrentActivity();
@@ -250,10 +279,23 @@ public class RNJWPlayerView extends RelativeLayout implements
         return superContext;
     }
 
+    private boolean isBackgroundAudioServiceRunning() {
+        ActivityManager manager = (ActivityManager) mAppContext.getSystemService(Context.ACTIVITY_SERVICE);
+        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
+            if (MediaService.class.getName().equals(service.service.getClassName())) {
+                Log.w(TAG, "MediaService is already running with another player loaded. To avoid crashing, this player, "
+                        + mPlayerView.getTag() + "  will not be loaded into the background service.");
+                return true;
+            }
+        }
+        return false;
+    }
+
     public RNJWPlayerView(ThemedReactContext reactContext, ReactApplicationContext appContext) {
         super(getNonBuggyContext(reactContext, appContext));
         mAppContext = appContext;
 
+        registry.setCurrentState(Lifecycle.State.CREATED);
         mThemedReactContext = reactContext;
 
         mActivity = (ReactActivity) getActivity();
@@ -261,11 +303,25 @@ public class RNJWPlayerView extends RelativeLayout implements
             mWindow = mActivity.getWindow();
         }
 
+        if (mActivity != null) {
+            mActivity.getLifecycle().addObserver(lifecycleObserver);
+        }
+
         mRootView = mActivity.findViewById(android.R.id.content);
 
         getReactContext().addLifecycleEventListener(this);
     }
 
+    private LifecycleObserver lifecycleObserver = new LifecycleEventObserver() {
+        @Override
+        public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
+            if (event.getTargetState() == Lifecycle.State.DESTROYED) {
+                return; // no op: handled elsewhere
+            }
+            registry.setCurrentState(event.getTargetState());
+        }
+    };
+
     public ReactApplicationContext getAppContext() {
         return mAppContext;
     }
@@ -288,10 +344,41 @@ public class RNJWPlayerView extends RelativeLayout implements
         return mThemedReactContext.getReactApplicationContext().getCurrentActivity();
     }
 
+    // The registry for lifecycle events. Required by player object. Main use case if for garbage collection / teardown
+    private final LifecycleRegistry registry = new LifecycleRegistry(this);
+
+    @NonNull
+    @Override
+    public Lifecycle getLifecycle() {
+        return registry;
+    }
+
+    // // closest to `ondestroy` for a view without listening to the activity event
+    // // The activity event can be deceptive in React-Native
+    // @Override
+    // protected void onDetachedFromWindow() {
+    //     super.onDetachedFromWindow();
+    //     registry.setCurrentState(Lifecycle.State.DESTROYED);
+    // }
+
     public void destroyPlayer() {
         if (mPlayer != null) {
+            unRegisterReceiver();
+
+            // If we are casting we need to break the cast session as there is no simple
+            // way to reconnect to an existing session if the player that created it is dead
+            
+            // If this doesn't match your use case, using a single player object and load content
+            // into it rather than creating a new player for every piece of content. 
             mPlayer.stop();
 
+            // send signal to JW SDK player is destroyed
+            registry.setCurrentState(Lifecycle.State.DESTROYED);
+
+            // Stop listening to activities lifecycle
+            mActivity.getLifecycle().removeObserver(lifecycleObserver);
+            mPlayer.deregisterActivityForPip();
+
             mPlayer.removeListeners(this,
                     // VideoPlayerEvents
                     EventType.READY,
@@ -348,7 +435,7 @@ public class RNJWPlayerView extends RelativeLayout implements
                     EventType.PIP_OPEN
             );
 
-            mPlayer  = null;
+            mPlayer = null;
             mPlayerView = null;
 
             getReactContext().removeLifecycleEventListener(this);
@@ -427,12 +514,117 @@ public class RNJWPlayerView extends RelativeLayout implements
                     EventType.PIP_OPEN
             );
 
-            mPlayer.setFullscreenHandler(new fullscreenHandler());
+            if (playerInModal) {
+                mPlayer.setFullscreenHandler(createModalFullscreenHandler());
+            } else {
+                mPlayer.setFullscreenHandler(new fullscreenHandler());
+            }
 
             mPlayer.allowBackgroundAudio(backgroundAudioEnabled);
         }
     }
 
+    /**
+     * Helper to build the a generic `ExtensibleFullscreenHandler` with small tweaks to play nice with Modals
+     *
+     * @return {@link ExtensibleFullscreenHandler}
+     */
+    private ExtensibleFullscreenHandler createModalFullscreenHandler() {
+        DeviceOrientationDelegate delegate = getDeviceOrientationDelegate();
+        FullscreenDialog dialog = new FullscreenDialog(
+                mActivity,
+                mActivity,
+                android.R.style.Theme_Black_NoTitleBar_Fullscreen
+        );
+
+        return new ExtensibleFullscreenHandler(
+                new DialogLayoutDelegate(
+                        mPlayerView,
+                        dialog
+                ),
+                delegate,
+                new SystemUiDelegate(
+                        mActivity,
+                        mActivity.getLifecycle(),
+                        new Handler(),
+                        dialog.getWindow().getDecorView()
+                )
+        ) {
+            @Override
+            public void onFullscreenRequested() {
+                // if landscape is priorty we have to turn off full-screen portrait before allowing
+                // the default call for full-screen
+                mPlayer.allowFullscreenPortrait(!landscapeOnFullScreen);
+                super.onFullscreenRequested();
+                // safely set it back on UI thread after work can be finished
+                final Handler handler = new Handler(Looper.getMainLooper());
+                handler.postDelayed(() -> {
+                    if (mPlayer != null) {
+                        mPlayer.allowFullscreenPortrait(true);
+                    }
+                }, 100);
+                WritableMap eventEnterFullscreen = Arguments.createMap();
+                eventEnterFullscreen.putString("message", "onFullscreenRequested");
+                getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(
+                        getId(),
+                        "topFullScreenRequested",
+                        eventEnterFullscreen);
+            }
+
+            @Override
+            public void onFullscreenExitRequested() {
+                super.onFullscreenExitRequested();
+
+                WritableMap eventExitFullscreen = Arguments.createMap();
+                eventExitFullscreen.putString("message", "onFullscreenExitRequested");
+                getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(
+                        getId(),
+                        "topFullScreenExitRequested",
+                        eventExitFullscreen);
+            }
+        };
+    }
+
+    /**
+     * Add logic here for your custom orientation implementation
+     *
+     * @return Default {@link DeviceOrientationDelegate}
+     */
+    private DeviceOrientationDelegate getDeviceOrientationDelegate() {
+        DeviceOrientationDelegate delegate = new DeviceOrientationDelegate(
+                mActivity,
+                mActivity.getLifecycle(),
+                new Handler()
+        ) {
+            @Override
+            public void setFullscreen(boolean fullscreen) {
+                super.setFullscreen(fullscreen);
+            }
+
+            @Override
+            public void onAllowRotationChanged(boolean allowRotation) {
+                super.onAllowRotationChanged(allowRotation);
+            }
+
+            @Override
+            protected void doRotation(boolean fullscreen, boolean allowFullscreenPortrait) {
+                super.doRotation(fullscreen, allowFullscreenPortrait);
+            }
+
+            @Override
+            protected void doRotationListener() {
+                super.doRotationListener();
+            }
+
+            @Override
+            public void onAllowFullscreenPortrait(boolean allowFullscreenPortrait) {
+                super.onAllowFullscreenPortrait(allowFullscreenPortrait);
+            }
+        };
+        delegate.onAllowRotationChanged(true);
+        return delegate;
+    }
+
     private class fullscreenHandler implements FullscreenHandler {
         ViewGroup mPlayerViewContainer = (ViewGroup) mPlayerView.getParent();
         private View mDecorView;
@@ -501,11 +693,21 @@ public class RNJWPlayerView extends RelativeLayout implements
             mPlayerViewContainer.post(new Runnable() {
                 @Override
                 public void run() {
+                    // View may not have been removed properly (especially if returning from PiP)
+                    mPlayerViewContainer.removeView(mPlayerView);
+                    
                     mPlayerViewContainer.addView(mPlayerView, new ViewGroup.LayoutParams(
                             ViewGroup.LayoutParams.MATCH_PARENT,
                             ViewGroup.LayoutParams.MATCH_PARENT));
-                    mPlayerView.layout(mPlayerViewContainer.getLeft(), mPlayerViewContainer.getTop(),
-                            mPlayerViewContainer.getRight(), mPlayerViewContainer.getBottom());
+                    // returning from full-screen portrait requires a different measure
+                    if (mActivity.getResources().getConfiguration().orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+                    ) {
+                        mPlayerView.layout(mPlayerView.getLeft(), mPlayerViewContainer.getTop(),
+                                mPlayerViewContainer.getMeasuredWidth(), mPlayerViewContainer.getBottom());
+                    } else {
+                        mPlayerView.layout(mPlayerViewContainer.getLeft(), mPlayerViewContainer.getTop(),
+                                mPlayerViewContainer.getRight(), mPlayerViewContainer.getBottom());
+                    }
                 }
             });
 
@@ -519,12 +721,12 @@ public class RNJWPlayerView extends RelativeLayout implements
 
         @Override
         public void onAllowRotationChanged(boolean b) {
-            Log.e(TAG, "onAllowRotationChanged: " + b );
+            Log.e(TAG, "onAllowRotationChanged: " + b);
         }
 
         @Override
         public void onAllowFullscreenPortraitChanged(boolean allowFullscreenPortrait) {
-            Log.e(TAG, "onAllowFullscreenPortraitChanged: " + allowFullscreenPortrait );
+            Log.e(TAG, "onAllowFullscreenPortraitChanged: " + allowFullscreenPortrait);
         }
 
         @Override
@@ -540,10 +742,101 @@ public class RNJWPlayerView extends RelativeLayout implements
         }
     }
 
+    private ArrayList<Integer> rootViewChildrenOriginalVisibility = new ArrayList<Integer>();
+
+    private class PipHandlerReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (intent == null) {
+                return;
+            }
+            if (Objects.equals(intent.getAction(), "onPictureInPictureModeChanged")) {
+                if (intent.hasExtra("newConfig") && intent.hasExtra("isInPictureInPictureMode")) {
+                    // Tell the JWP SDK we are toggling so it can handle toolbar / internal setup
+                    mPlayer.onPictureInPictureModeChanged(intent.getBooleanExtra("isInPictureInPictureMode", false), intent.getParcelableExtra("newConfig"));
+
+                    View decorView = mActivity.getWindow().getDecorView();
+                    ViewGroup rootView = decorView.findViewById(android.R.id.content);
+
+                    ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(
+                            ViewGroup.LayoutParams.MATCH_PARENT,
+                            ViewGroup.LayoutParams.MATCH_PARENT);
+
+                    if (intent.getBooleanExtra("isInPictureInPictureMode", false)) {
+                        // Going into Picture in Picture
+                        ViewGroup parent = (ViewGroup) mPlayerView.getParent();
+
+                        // Remove the player view temporarily
+                        if (parent != null) {
+                            parent.removeView(mPlayerView);
+                        }
+
+                        // Hide all views but player view and keep a handle on them for later
+                        for (int i = 0; i < rootView.getChildCount(); i++) {
+                            if (rootView.getChildAt(i) != mPlayerView) {
+                                rootViewChildrenOriginalVisibility.add(rootView.getChildAt(i).getVisibility());
+                                rootView.getChildAt(i).setVisibility(View.GONE);
+                            }
+                        }
+                        // Add player view back (This is safe since the JWP SDK has already calculated the PiP size/aspect off the View)
+                        rootView.addView(mPlayerView, layoutParams);
+                    } else {
+                        // Exiting Picture in Picture
+
+                        // Toggle controls to ensure we don't lose them -- weird UX bug fix where controls got lost
+                        mPlayer.setForceControlsVisibility(true);
+                        mPlayer.setForceControlsVisibility(false);
+
+                        // If player was in fullscreen when going into PiP, we need to force it back out
+                        if (mPlayer.getFullscreen()) {
+                            mPlayer.setFullscreen(false, true);
+                        }
+
+                        // Strip player view
+                        rootView.removeView(mPlayerView);
+
+                        // Add visibility back to  any other controls
+                        for (int i = 0; i < rootView.getChildCount(); i++) {
+                            rootView.getChildAt(i).setVisibility(rootViewChildrenOriginalVisibility.get(i));
+                        }
+                        // Clear our list of views
+                        rootViewChildrenOriginalVisibility.clear();
+                        // Add player view back in main spot
+                        addView(mPlayerView, 0, layoutParams);
+                    }
+                }
+            }
+        }
+    }
+
+    private void registerReceiver() {
+        mReceiver = new PipHandlerReceiver();
+        IntentFilter intentFilter = new IntentFilter("onPictureInPictureModeChanged");
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                // Must be Exported to get intents
+                mActivity.registerReceiver(mReceiver, intentFilter, Context.RECEIVER_EXPORTED);
+            } else {
+                mActivity.registerReceiver(mReceiver, intentFilter); // Safe API level < 34
+            }
+        } else {
+            mActivity.registerReceiver(mReceiver, intentFilter); // Safe API level < 34
+        }
+    }
+
+    private void unRegisterReceiver() {
+        if (mReceiver != null) {
+            mActivity.unregisterReceiver(mReceiver);
+            mReceiver = null;
+        }
+
+    }
+
     public void setConfig(ReadableMap prop) {
         if (mConfig == null || !mConfig.equals(prop)) {
             if (mConfig != null && isOnlyDiff(prop, "playlist") && mPlayer != null) { // still safe check, even with JW
-                                                                                      // JSON change
+                // JSON change
                 PlayerConfig oldConfig = mPlayer.getConfig();
                 PlayerConfig config = new PlayerConfig.Builder()
                         .autostart(oldConfig.getAutostart())
@@ -610,7 +903,7 @@ public class RNJWPlayerView extends RelativeLayout implements
 
     boolean playlistNotTheSame(ReadableMap prop) {
         return prop.hasKey("playlist") && mPlaylistProp != prop.getArray("playlist") && !Arrays
-                .deepEquals(new ReadableArray[] { mPlaylistProp }, new ReadableArray[] { prop.getArray("playlist") });
+                .deepEquals(new ReadableArray[]{mPlaylistProp}, new ReadableArray[]{prop.getArray("playlist")});
     }
 
     private void setupPlayer(ReadableMap prop) {
@@ -621,7 +914,7 @@ public class RNJWPlayerView extends RelativeLayout implements
         PlayerConfig jwConfig = null;
         Boolean forceLegacy = prop.hasKey("forceLegacyConfig") ? prop.getBoolean("forceLegacyConfig") : false;
         Boolean isJwConfig = false;
-        if(!forceLegacy){
+        if (!forceLegacy) {
             try {
                 obj = MapUtil.toJSONObject(prop);
                 jwConfig = JsonHelper.parseConfigJson(obj);
@@ -752,6 +1045,11 @@ public class RNJWPlayerView extends RelativeLayout implements
                 LinearLayout.LayoutParams.MATCH_PARENT));
         addView(mPlayerView);
 
+        // Ensure we have a valid state before applying to the player
+        registry.setCurrentState(Lifecycle.State.STARTED);
+
+        mPlayer = mPlayerView.getPlayer(this);
+
         if (prop.hasKey("controls")) { // Hack for controls hiding not working right away
             mPlayerView.getPlayer().setControls(prop.getBoolean("controls"));
         }
@@ -761,13 +1059,23 @@ public class RNJWPlayerView extends RelativeLayout implements
             mPlayerView.fullScreenOnLandscape = fullScreenOnLandscape;
         }
 
+        if (prop.hasKey("landscapeOnFullScreen")) {
+            landscapeOnFullScreen = prop.getBoolean("landscapeOnFullScreen");
+        }
+
+        if (prop.hasKey("portraitOnExitFullScreen")) {
+            portraitOnExitFullScreen = prop.getBoolean("fullScreenOnLandscape");
+        }
+
+        if (prop.hasKey("playerInModal")) {
+            playerInModal = prop.getBoolean("playerInModal");
+        }
+
         if (prop.hasKey("exitFullScreenOnPortrait")) {
             exitFullScreenOnPortrait = prop.getBoolean("exitFullScreenOnPortrait");
             mPlayerView.exitFullScreenOnPortrait = exitFullScreenOnPortrait;
         }
 
-        mPlayer = mPlayerView.getPlayer();
-
         if (isJwConfig) {
             mPlayer.setup(jwConfig);
         } else {
@@ -778,16 +1086,18 @@ public class RNJWPlayerView extends RelativeLayout implements
         if (mActivity != null && prop.hasKey("pipEnabled")) {
             boolean pipEnabled = prop.getBoolean("pipEnabled");
             if (pipEnabled) {
+                registerReceiver();
                 mPlayer.registerActivityForPip(mActivity, mActivity.getSupportActionBar());
             } else {
                 mPlayer.deregisterActivityForPip();
+                unRegisterReceiver();
             }
         }
 
         // Legacy
         // This isn't the ideal way to do this on Android. All drawables/colors/themes shoudld
         // be targed using styling. See `https://docs.jwplayer.com/players/docs/android-styling-guide`
-        // for more information on how best to override the JWP styles using XML. If you are unsure of a 
+        // for more information on how best to override the JWP styles using XML. If you are unsure of a
         // color/drawable/theme, open an `Ask` issue.
         if (mColors != null) {
             if (mColors.hasKey("backgroundColor")) {
@@ -844,8 +1154,6 @@ public class RNJWPlayerView extends RelativeLayout implements
 
         if (backgroundAudioEnabled) {
             audioManager = (AudioManager) simpleContext.getSystemService(Context.AUDIO_SERVICE);
-            // Throws a fatal error if using a playlistURL instead of manually created playlist
-            // Related to SDK-11346
             mMediaServiceController = new MediaServiceController.Builder((AppCompatActivity) mActivity, mPlayer)
                     .build();
         }
@@ -1103,7 +1411,7 @@ public class RNJWPlayerView extends RelativeLayout implements
         event.putString("message", "onPlayerAdWarning");
         event.putInt("code", adWarningEvent.getCode());
         event.putInt("adErrorCode", adWarningEvent.getAdErrorCode());
-        event.putString("error", adWarningEvent.getMessage());
+        event.putString("warning", adWarningEvent.getMessage());
         getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(getId(), "topPlayerAdWarning", event);
     }
 
@@ -1209,6 +1517,38 @@ public class RNJWPlayerView extends RelativeLayout implements
 
     }
 
+    // Captions Events
+
+    @Override
+    public void onCaptionsChanged(CaptionsChangedEvent captionsChangedEvent) {
+        WritableMap event = Arguments.createMap();
+        event.putString("message", "onCaptionsChanged");
+        event.putInt("index", captionsChangedEvent.getCurrentTrack());
+        getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(getId(), "topCaptionsChanged", event);
+    }
+
+    @Override
+    public void onCaptionsList(CaptionsListEvent captionsListEvent) {
+        WritableMap event = Arguments.createMap();
+        List<Caption> captionTrackList = captionsListEvent.getCaptions();
+        WritableArray captionTracks = Arguments.createArray();
+        if (captionTrackList != null) {
+            for(int i = 0; i < captionTrackList.size(); i++) {
+                WritableMap captionTrack = Arguments.createMap();
+                Caption track = captionTrackList.get(i);
+                captionTrack.putString("file", track.getFile());
+                captionTrack.putString("label", track.getLabel());
+                captionTrack.putBoolean("default", track.isDefault());
+                captionTracks.pushMap(captionTrack);
+            }
+        }
+        event.putString("message", "onCaptionsList");
+        event.putInt("index", captionsListEvent.getCurrentCaptionIndex());
+        event.putArray("tracks", captionTracks);
+        getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(getId(), "topCaptionsList", event);
+
+    }
+
     // Player Events
 
     @Override
@@ -1257,6 +1597,7 @@ public class RNJWPlayerView extends RelativeLayout implements
         if (ex != null) {
             event.putString("error", ex.toString());
             event.putString("description", errorEvent.getMessage());
+            event.putInt("errorCode", errorEvent.getErrorCode());
         }
         getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(getId(), "topPlayerError", event);
 
@@ -1269,6 +1610,13 @@ public class RNJWPlayerView extends RelativeLayout implements
             doBindService();
             requestAudioFocus();
         }
+        WritableMap onFirstFrame = Arguments.createMap();
+        onFirstFrame.putString("message", "onLoaded");
+        onFirstFrame.putDouble("loadTime", firstFrameEvent.getLoadTime());
+        getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(
+                getId(),
+                "topFirstFrame",
+                onFirstFrame);
     }
 
     @Override
@@ -1400,6 +1748,8 @@ public class RNJWPlayerView extends RelativeLayout implements
     public void onSetupError(SetupErrorEvent setupErrorEvent) {
         WritableMap event = Arguments.createMap();
         event.putString("message", "onSetupError");
+        event.putString("errorMessage", setupErrorEvent.getMessage());
+        event.putInt("errorCode", setupErrorEvent.getCode());
         getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(getId(), "topSetupPlayerError", event);
 
         updateWakeLock(false);
@@ -1414,16 +1764,6 @@ public class RNJWPlayerView extends RelativeLayout implements
         getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(getId(), "topTime", event);
     }
 
-    @Override
-    public void onCaptionsChanged(CaptionsChangedEvent captionsChangedEvent) {
-
-    }
-
-    @Override
-    public void onCaptionsList(CaptionsListEvent captionsListEvent) {
-
-    }
-
     @Override
     public void onMeta(MetaEvent metaEvent) {
 
@@ -1443,6 +1783,17 @@ public class RNJWPlayerView extends RelativeLayout implements
 
     // Casting events
 
+    private boolean mIsCastActive = false;
+
+    /**
+     * Get if this player-view is currently casting
+     *
+     * @return true if casting
+     */
+    public boolean getIsCastActive() {
+        return mIsCastActive;
+    }
+
     @Override
     public void onCast(CastEvent castEvent) {
         WritableMap event = Arguments.createMap();
@@ -1451,13 +1802,14 @@ public class RNJWPlayerView extends RelativeLayout implements
         event.putBoolean("active", castEvent.isActive());
         event.putBoolean("available", castEvent.isAvailable());
         getReactContext().getJSModule(RCTEventEmitter.class).receiveEvent(getId(), "topCasting", event);
+        mIsCastActive = castEvent.isActive();
         // stop/start the background audio service if it's running and we're casting
         if (castEvent.isActive()) {
             doUnbindService();
         } else {
             if (backgroundAudioEnabled) {
                 mMediaServiceController = new MediaServiceController.Builder((AppCompatActivity) mActivity, mPlayer)
-                    .build();
+                        .build();
                 doBindService();
             }
         }