@capgo/capacitor-video-player 8.1.6 → 8.1.8

package/README.md

@@ -29,6 +29,50 @@ npm install @capgo/capacitor-video-player
 npx cap sync
 ```
 
+## Supported Features
+
+| Feature                        | iOS | Android | Web |
+| ------------------------------ | --- | ------- | --- |
+| Fullscreen native video player | ✅  | ✅      | ❌  |
+| Embedded web video player      | ❌  | ❌      | ✅  |
+| Picture in Picture             | ✅  | ✅      | ❌  |
+| Subtitles                      | ✅  | ✅      | ✅  |
+| DRM-protected playback         | ✅  | ✅      | ❌  |
+| Chromecast sender playback     | ❌  | ✅      | ❌  |
+
+## Chromecast (Android)
+
+Chromecast is supported on Android in fullscreen mode. Enable it with the `chromecast` option. When a Cast session starts, the plugin loads the same media URL on the receiver, keeps the current playback position, and routes play, pause, seek, and timeline controls through the Cast session.
+
+```ts
+await VideoPlayer.initPlayer({
+  mode: 'fullscreen',
+  playerId: 'main-player',
+  url: 'https://example.com/video.m3u8',
+  title: 'Video title',
+  smallTitle: 'Optional subtitle',
+  artwork: 'https://example.com/artwork.jpg',
+  chromecast: true,
+  showControls: true,
+});
+```
+
+### Chromecast Options
+
+| Option       | Type      | Default | Description                                                |
+| ------------ | --------- | ------- | ---------------------------------------------------------- |
+| `chromecast` | `boolean` | `true`  | Shows the Android Cast button and enables sender playback. |
+| `title`      | `string`  | `""`    | Title shown in the sender controls and receiver metadata.  |
+| `smallTitle` | `string`  | `""`    | Subtitle shown in the sender controls and metadata.        |
+| `artwork`    | `string`  | `""`    | Image URL used for Cast metadata and sender Cast artwork.  |
+
+### Requirements and Notes
+
+- The media URL must be reachable by the Chromecast device, not only by the Android app.
+- Cast support depends on the receiver app and device media support. MP4, HLS, DASH, and SmoothStreaming streams are mapped to Cast-compatible MIME types by the plugin.
+- Widevine DRM metadata is forwarded to the Cast media item. DRM-protected streams may still require a receiver that supports your license server and DRM flow.
+- Request headers used by the Android local player are not automatically available to the Chromecast receiver. Use public URLs, signed URLs, cookies supported by your receiver, or a custom receiver for secured media.
+
 ## API
 
 <docgen-index>

package/android/build.gradle

@@ -65,7 +65,7 @@ dependencies {
     implementation 'com.google.android.exoplayer:extension-mediasession:2.19.1'
     implementation 'com.google.android.exoplayer:exoplayer:2.19.1'
     implementation 'com.google.android.exoplayer:extension-cast:2.19.1'
-    implementation 'com.squareup.picasso:picasso:2.8'
+    implementation 'com.squareup.picasso:picasso:2.71828'
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"

package/android/src/main/java/com/capgo/videoplayer/FullscreenExoPlayerFragment.java

@@ -56,6 +56,8 @@ import com.google.android.exoplayer2.PlaybackParameters;
 import com.google.android.exoplayer2.Player;
 import com.google.android.exoplayer2.audio.AudioAttributes;
 import com.google.android.exoplayer2.ext.cast.CastPlayer;
+import com.google.android.exoplayer2.ext.cast.DefaultMediaItemConverter;
+import com.google.android.exoplayer2.ext.cast.MediaItemConverter;
 import com.google.android.exoplayer2.ext.cast.SessionAvailabilityListener;
 import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector;
 import com.google.android.exoplayer2.source.MediaSource;
@@ -79,16 +81,21 @@ import com.google.android.exoplayer2.upstream.DefaultBandwidthMeter;
 import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
 import com.google.android.exoplayer2.upstream.DefaultHttpDataSource;
 import com.google.android.exoplayer2.util.MimeTypes;
+import com.google.android.gms.cast.MediaInfo;
+import com.google.android.gms.cast.MediaQueueItem;
+import com.google.android.gms.cast.MediaTrack;
 import com.google.android.gms.cast.framework.CastButtonFactory;
 import com.google.android.gms.cast.framework.CastContext;
 import com.google.android.gms.cast.framework.CastState;
 import com.google.android.gms.cast.framework.CastStateListener;
+import com.google.android.gms.common.images.WebImage;
 import com.google.android.gms.tasks.OnCompleteListener;
 import com.google.android.gms.tasks.Task;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -97,6 +104,7 @@ import java.util.Map;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import org.json.JSONException;
+import org.json.JSONObject;
 
 public class FullscreenExoPlayerFragment extends Fragment {
 
@@ -188,7 +196,6 @@ public class FullscreenExoPlayerFragment extends Fragment {
     private MediaRouteButton mediaRouteButton;
     private CastContext castContext;
     private CastPlayer castPlayer;
-    private MediaItem mediaItem;
     private MediaRouter mRouter;
     private MediaRouter.Callback mCallback = new EmptyCallback();
     private MediaRouteSelector mSelector;
@@ -996,18 +1003,7 @@ public class FullscreenExoPlayerFragment extends Fragment {
         mediaSources[0] = mediaSource;
         String mimeType = getMimeType(sturi);
 
-        // We get the language label from the language code
-        String languageLabel = Locale.forLanguageTag(language).getDisplayLanguage();
-        MediaItem.SubtitleConfiguration subConfig = new MediaItem.SubtitleConfiguration.Builder(sturi)
-            .setMimeType(mimeType)
-            .setUri(sturi)
-            .setId(subTitle)
-            .setLabel(languageLabel)
-            .setRoleFlags(C.ROLE_FLAG_CAPTION)
-            .setSelectionFlags(C.SELECTION_FLAG_DEFAULT)
-            .setLanguage(language)
-            .build();
-
+        MediaItem.SubtitleConfiguration subConfig = buildSubtitleConfiguration(sturi, mimeType);
         SingleSampleMediaSource subtitleSource = new SingleSampleMediaSource.Factory(dataSourceFactory).createMediaSource(
             subConfig,
             C.TIME_UNSET
@@ -1331,7 +1327,7 @@ public class FullscreenExoPlayerFragment extends Fragment {
                 public void onComplete(Task<CastContext> task) {
                     if (task.isSuccessful()) {
                         castContext = task.getResult();
-                        castPlayer = new CastPlayer(castContext);
+                        castPlayer = new CastPlayer(castContext, new SubtitleMediaItemConverter());
                         mRouter = MediaRouter.getInstance(context);
                         mSelector = new MediaRouteSelector.Builder()
                             .addControlCategories(
@@ -1355,38 +1351,37 @@ public class FullscreenExoPlayerFragment extends Fragment {
                         };
                         CastButtonFactory.setUpMediaRouteButton(context, mediaRouteButton);
 
-                        MediaMetadata movieMetadata;
-                        if (artwork != "") {
-                            movieMetadata = new MediaMetadata.Builder()
-                                .setTitle(title)
-                                .setSubtitle(smallTitle)
-                                .setMediaType(MediaMetadata.MEDIA_TYPE_MOVIE)
-                                .setArtworkUri(Uri.parse(artwork))
-                                .build();
+                        if (hasArtwork()) {
                             new setCastImage().execute();
-                        } else {
-                            movieMetadata = new MediaMetadata.Builder().setTitle(title).setSubtitle(smallTitle).build();
                         }
-                        mediaItem = new MediaItem.Builder()
-                            .setUri(videoPath)
-                            .setMimeType(MimeTypes.VIDEO_UNKNOWN)
-                            .setMediaMetadata(movieMetadata)
-                            .build();
 
                         castPlayer.setSessionAvailabilityListener(
                             new SessionAvailabilityListener() {
                                 @Override
                                 public void onCastSessionAvailable() {
+                                    Uri castUri = getCastUri();
+                                    if (!isNetworkUri(castUri)) {
+                                        Toast.makeText(
+                                            context,
+                                            "Chromecast requires a network-reachable media URL",
+                                            Toast.LENGTH_SHORT
+                                        ).show();
+                                        castContext.getSessionManager().endCurrentSession(false);
+                                        return;
+                                    }
                                     isCastSession = true;
                                     final Long videoPosition = player.getCurrentPosition();
+                                    final boolean shouldPlay = player.getPlayWhenReady();
                                     if (pipEnabled) {
                                         pipBtn.setVisibility(View.GONE);
                                     }
                                     resizeBtn.setVisibility(View.GONE);
                                     player.setPlayWhenReady(false);
                                     cast_image.setVisibility(View.VISIBLE);
-                                    castPlayer.setMediaItem(mediaItem, videoPosition);
                                     styledPlayerView.setPlayer(castPlayer);
+                                    castPlayer.setMediaItem(buildCastMediaItem(castUri), videoPosition);
+                                    castPlayer.setPlayWhenReady(shouldPlay);
+                                    castPlayer.prepare();
                                     styledPlayerView.setControllerShowTimeoutMs(0);
                                     styledPlayerView.setControllerHideOnTouch(false);
                                     //We perform a click because for some weird reason, the layout is black until the user clicks on it
@@ -1395,16 +1390,20 @@ public class FullscreenExoPlayerFragment extends Fragment {
 
                                 @Override
                                 public void onCastSessionUnavailable() {
+                                    if (!isCastSession) return;
                                     isCastSession = false;
                                     final Long videoPosition = castPlayer.getCurrentPosition();
+                                    final boolean shouldPlay = castPlayer.getPlayWhenReady();
                                     if (pipEnabled) {
                                         pipBtn.setVisibility(View.VISIBLE);
                                     }
                                     resizeBtn.setVisibility(View.VISIBLE);
                                     cast_image.setVisibility(View.GONE);
+                                    castPlayer.stop();
+                                    castPlayer.clearMediaItems();
                                     styledPlayerView.setPlayer(player);
-                                    player.setPlayWhenReady(true);
                                     player.seekTo(videoPosition);
+                                    player.setPlayWhenReady(shouldPlay);
                                     styledPlayerView.setControllerShowTimeoutMs(3000);
                                     styledPlayerView.setControllerHideOnTouch(true);
                                 }
@@ -1418,7 +1417,7 @@ public class FullscreenExoPlayerFragment extends Fragment {
                                     Map<String, Object> info = new HashMap<String, Object>() {
                                         {
                                             put("fromPlayerId", playerId);
-                                            put("currentTime", String.valueOf(player.getCurrentPosition() / 1000));
+                                            put("currentTime", String.valueOf(castPlayer.getCurrentPosition() / 1000));
                                         }
                                     };
                                     switch (state) {
@@ -1449,6 +1448,261 @@ public class FullscreenExoPlayerFragment extends Fragment {
 
     private final class EmptyCallback extends MediaRouter.Callback {}
 
+    private Uri getCastUri() {
+        return uri != null ? uri : Uri.parse(videoPath);
+    }
+
+    private boolean isNetworkUri(Uri mediaUri) {
+        String scheme = mediaUri.getScheme();
+        return "http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme);
+    }
+
+    private MediaItem buildCastMediaItem(Uri castUri) {
+        MediaItem.Builder builder = buildMediaItem(castUri).buildUpon().setMediaMetadata(buildCastMediaMetadata());
+        String mimeType = getMediaItemMimeType(castUri);
+        if (mimeType != null) {
+            builder.setMimeType(mimeType);
+        }
+        if (sturi != null && isNetworkUri(sturi)) {
+            builder.setSubtitleConfigurations(Arrays.asList(buildSubtitleConfiguration(sturi, getMimeType(sturi))));
+        }
+        return builder.build();
+    }
+
+    private MediaMetadata buildCastMediaMetadata() {
+        MediaMetadata.Builder metadataBuilder = new MediaMetadata.Builder().setTitle(title).setSubtitle(smallTitle);
+        if (hasArtwork()) {
+            metadataBuilder.setMediaType(MediaMetadata.MEDIA_TYPE_MOVIE).setArtworkUri(Uri.parse(artwork));
+        }
+        return metadataBuilder.build();
+    }
+
+    private boolean hasArtwork() {
+        return artwork != null && !artwork.isEmpty();
+    }
+
+    private MediaItem.SubtitleConfiguration buildSubtitleConfiguration(Uri subtitleUri, String mimeType) {
+        String languageLabel = Locale.forLanguageTag(language).getDisplayLanguage();
+        return new MediaItem.SubtitleConfiguration.Builder(subtitleUri)
+            .setMimeType(mimeType)
+            .setUri(subtitleUri)
+            .setId(subTitle)
+            .setLabel(languageLabel)
+            .setRoleFlags(C.ROLE_FLAG_CAPTION)
+            .setSelectionFlags(C.SELECTION_FLAG_DEFAULT)
+            .setLanguage(language)
+            .build();
+    }
+
+    private String getMediaItemMimeType(Uri mediaUri) {
+        String mediaType = vType != null ? vType : getVideoType(mediaUri);
+        switch (mediaType) {
+            case "dash":
+            case "mpd":
+                return MimeTypes.APPLICATION_MPD;
+            case "m3u8":
+                return MimeTypes.APPLICATION_M3U8;
+            case "ism":
+                return MimeTypes.APPLICATION_SS;
+            case "webm":
+                return MimeTypes.VIDEO_WEBM;
+            case "ogv":
+                return "video/ogg";
+            case "3gp":
+                return "video/3gpp";
+            case "flv":
+                return "video/x-flv";
+            case "mp4":
+                return MimeTypes.VIDEO_MP4;
+            case "ytube":
+            case "":
+            default:
+                return null;
+        }
+    }
+
+    private final class SubtitleMediaItemConverter implements MediaItemConverter {
+
+        private static final String KEY_MEDIA_ITEM = "mediaItem";
+        private static final String KEY_PLAYER_CONFIG = "exoPlayerConfig";
+        private static final String KEY_MEDIA_ID = "mediaId";
+        private static final String KEY_URI = "uri";
+        private static final String KEY_TITLE = "title";
+        private static final String KEY_MIME_TYPE = "mimeType";
+        private static final String KEY_DRM_CONFIGURATION = "drmConfiguration";
+        private static final String KEY_UUID = "uuid";
+        private static final String KEY_LICENSE_URI = "licenseUri";
+        private static final String KEY_REQUEST_HEADERS = "requestHeaders";
+
+        private final DefaultMediaItemConverter defaultConverter = new DefaultMediaItemConverter();
+
+        @Override
+        public MediaQueueItem toMediaQueueItem(MediaItem mediaItem) {
+            MediaItem.LocalConfiguration localConfiguration = mediaItem.localConfiguration;
+            if (localConfiguration == null) {
+                throw new IllegalArgumentException("The item must specify its local configuration");
+            }
+
+            MediaInfo.Builder mediaInfoBuilder = new MediaInfo.Builder(getContentId(mediaItem, localConfiguration))
+                .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
+                .setContentUrl(localConfiguration.uri.toString())
+                .setMetadata(buildCastMediaInfoMetadata(mediaItem))
+                .setCustomData(buildCastCustomData(mediaItem));
+
+            if (localConfiguration.mimeType != null) {
+                mediaInfoBuilder.setContentType(localConfiguration.mimeType);
+            }
+
+            ArrayList<Long> activeTrackIds = new ArrayList<>();
+            List<MediaTrack> mediaTracks = buildCastSubtitleTracks(localConfiguration.subtitleConfigurations, activeTrackIds);
+            if (!mediaTracks.isEmpty()) {
+                mediaInfoBuilder.setMediaTracks(mediaTracks);
+            }
+
+            MediaQueueItem.Builder mediaQueueItemBuilder = new MediaQueueItem.Builder(mediaInfoBuilder.build());
+            if (!activeTrackIds.isEmpty()) {
+                mediaQueueItemBuilder.setActiveTrackIds(toLongArray(activeTrackIds));
+            }
+            return mediaQueueItemBuilder.build();
+        }
+
+        @Override
+        public MediaItem toMediaItem(MediaQueueItem mediaQueueItem) {
+            return defaultConverter.toMediaItem(mediaQueueItem);
+        }
+
+        private String getContentId(MediaItem mediaItem, MediaItem.LocalConfiguration localConfiguration) {
+            return mediaItem.mediaId.equals(MediaItem.DEFAULT_MEDIA_ID) ? localConfiguration.uri.toString() : mediaItem.mediaId;
+        }
+
+        private com.google.android.gms.cast.MediaMetadata buildCastMediaInfoMetadata(MediaItem mediaItem) {
+            MediaItem.LocalConfiguration localConfiguration = mediaItem.localConfiguration;
+            String mimeType = localConfiguration != null ? localConfiguration.mimeType : null;
+            com.google.android.gms.cast.MediaMetadata metadata = new com.google.android.gms.cast.MediaMetadata(
+                mimeType != null && MimeTypes.isAudio(mimeType)
+                    ? com.google.android.gms.cast.MediaMetadata.MEDIA_TYPE_MUSIC_TRACK
+                    : com.google.android.gms.cast.MediaMetadata.MEDIA_TYPE_MOVIE
+            );
+
+            if (mediaItem.mediaMetadata.title != null) {
+                metadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_TITLE, mediaItem.mediaMetadata.title.toString());
+            }
+            if (mediaItem.mediaMetadata.subtitle != null) {
+                metadata.putString(com.google.android.gms.cast.MediaMetadata.KEY_SUBTITLE, mediaItem.mediaMetadata.subtitle.toString());
+            }
+            if (mediaItem.mediaMetadata.artworkUri != null) {
+                metadata.addImage(new WebImage(mediaItem.mediaMetadata.artworkUri));
+            }
+            return metadata;
+        }
+
+        private List<MediaTrack> buildCastSubtitleTracks(
+            List<MediaItem.SubtitleConfiguration> subtitleConfigurations,
+            ArrayList<Long> activeTrackIds
+        ) {
+            ArrayList<MediaTrack> mediaTracks = new ArrayList<>();
+            for (int i = 0; i < subtitleConfigurations.size(); i++) {
+                MediaItem.SubtitleConfiguration subtitleConfiguration = subtitleConfigurations.get(i);
+                if (subtitleConfiguration.uri == null) {
+                    continue;
+                }
+                long trackId = i + 1L;
+                MediaTrack.Builder trackBuilder = new MediaTrack.Builder(trackId, MediaTrack.TYPE_TEXT)
+                    .setContentId(subtitleConfiguration.uri.toString())
+                    .setSubtype(MediaTrack.SUBTYPE_SUBTITLES);
+                if (subtitleConfiguration.mimeType != null) {
+                    trackBuilder.setContentType(subtitleConfiguration.mimeType);
+                }
+                if (subtitleConfiguration.label != null) {
+                    trackBuilder.setName(subtitleConfiguration.label.toString());
+                }
+                if (subtitleConfiguration.language != null) {
+                    trackBuilder.setLanguage(subtitleConfiguration.language);
+                }
+                mediaTracks.add(trackBuilder.build());
+                if ((subtitleConfiguration.selectionFlags & C.SELECTION_FLAG_DEFAULT) != 0) {
+                    activeTrackIds.add(trackId);
+                }
+            }
+            return mediaTracks;
+        }
+
+        private long[] toLongArray(List<Long> values) {
+            long[] result = new long[values.size()];
+            for (int i = 0; i < values.size(); i++) {
+                result[i] = values.get(i);
+            }
+            return result;
+        }
+
+        private JSONObject buildCastCustomData(MediaItem mediaItem) {
+            try {
+                JSONObject customData = new JSONObject();
+                customData.put(KEY_MEDIA_ITEM, buildMediaItemJson(mediaItem));
+                JSONObject playerConfig = buildPlayerConfigJson(mediaItem);
+                if (playerConfig != null) {
+                    customData.put(KEY_PLAYER_CONFIG, playerConfig);
+                }
+                return customData;
+            } catch (JSONException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        private JSONObject buildMediaItemJson(MediaItem mediaItem) throws JSONException {
+            MediaItem.LocalConfiguration localConfiguration = mediaItem.localConfiguration;
+            JSONObject json = new JSONObject();
+            json.put(KEY_MEDIA_ID, mediaItem.mediaId);
+            if (mediaItem.mediaMetadata.title != null) {
+                json.put(KEY_TITLE, mediaItem.mediaMetadata.title.toString());
+            }
+            json.put(KEY_URI, localConfiguration.uri.toString());
+            if (localConfiguration.mimeType != null) {
+                json.put(KEY_MIME_TYPE, localConfiguration.mimeType);
+            }
+            if (localConfiguration.drmConfiguration != null) {
+                json.put(KEY_DRM_CONFIGURATION, buildDrmConfigurationJson(localConfiguration.drmConfiguration));
+            }
+            return json;
+        }
+
+        private JSONObject buildDrmConfigurationJson(MediaItem.DrmConfiguration drmConfiguration) throws JSONException {
+            JSONObject json = new JSONObject();
+            json.put(KEY_UUID, drmConfiguration.scheme.toString());
+            json.put(KEY_LICENSE_URI, drmConfiguration.licenseUri.toString());
+            json.put(KEY_REQUEST_HEADERS, new JSONObject(drmConfiguration.licenseRequestHeaders));
+            return json;
+        }
+
+        private JSONObject buildPlayerConfigJson(MediaItem mediaItem) throws JSONException {
+            MediaItem.LocalConfiguration localConfiguration = mediaItem.localConfiguration;
+            if (localConfiguration == null || localConfiguration.drmConfiguration == null) {
+                return null;
+            }
+
+            MediaItem.DrmConfiguration drmConfiguration = localConfiguration.drmConfiguration;
+            String protectionSystem;
+            if (C.WIDEVINE_UUID.equals(drmConfiguration.scheme)) {
+                protectionSystem = "widevine";
+            } else if (C.PLAYREADY_UUID.equals(drmConfiguration.scheme)) {
+                protectionSystem = "playready";
+            } else {
+                return null;
+            }
+
+            JSONObject json = new JSONObject();
+            json.put("withCredentials", false);
+            json.put("protectionSystem", protectionSystem);
+            if (drmConfiguration.licenseUri != null) {
+                json.put("licenseUrl", drmConfiguration.licenseUri.toString());
+            }
+            if (!drmConfiguration.licenseRequestHeaders.isEmpty()) {
+                json.put("headers", new JSONObject(drmConfiguration.licenseRequestHeaders));
+            }
+            return json;
+        }
+    }
+
     @Override
     public void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);

package/android/src/main/java/com/capgo/videoplayer/VideoPlayerPlugin.java

@@ -38,7 +38,7 @@ import java.util.Map;
 )
 public class VideoPlayerPlugin extends Plugin {
 
-    private final String pluginVersion = "8.1.6";
+    private final String pluginVersion = "8.1.8";
 
     // Permission alias constants
     private static final String PERMISSION_DENIED_ERROR = "Unable to access media videos, user denied permission request";

package/ios/Sources/VideoPlayerPlugin/VideoPlayerPlugin.swift

@@ -8,7 +8,7 @@ import AVKit
  */
 @objc(VideoPlayerPlugin)
 public class VideoPlayerPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.1.6"
+    private let pluginVersion: String = "8.1.8"
     public let identifier = "VideoPlayerPlugin"
     public let jsName = "VideoPlayer"
     public let pluginMethods: [CAPPluginMethod] = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-video-player",
-  "version": "8.1.6",
+  "version": "8.1.8",
   "description": "Capacitor plugin to play video in native player",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",