vdocipher-rn-bridge 2.0.1 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (59) hide show
  1. package/VdoCastButton.tsx +22 -0
  2. package/VdoCastMiniController.tsx +21 -0
  3. package/VdoPlayerView.tsx +64 -0
  4. package/android/build.gradle +5 -3
  5. package/android/src/main/java/com/vdocipher/rnbridge/AudioFocusManager.java +7 -2
  6. package/android/src/main/java/com/vdocipher/rnbridge/PlayerViewRegistry.java +21 -0
  7. package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoCastButtonManagerImpl.java +40 -0
  8. package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoCastMiniControllerManagerImpl.java +12 -0
  9. package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerUIView.java +85 -59
  10. package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerUIViewManagerImpl.java +18 -0
  11. package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerView.java +450 -103
  12. package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerViewManagerImpl.java +30 -1
  13. package/android/src/main/java/com/vdocipher/rnbridge/TrackSelectionModuleImpl.java +13 -28
  14. package/android/src/main/java/com/vdocipher/rnbridge/Utils.java +36 -0
  15. package/android/src/main/java/com/vdocipher/rnbridge/VdoCastButtonView.java +59 -0
  16. package/android/src/main/java/com/vdocipher/rnbridge/VdoCastMiniControllerView.java +83 -0
  17. package/android/src/main/java/com/vdocipher/rnbridge/VdoDownloadModuleImpl.java +15 -3
  18. package/android/src/main/java/com/vdocipher/rnbridge/VdoEventEmitter.java +15 -2
  19. package/android/src/main/java/com/vdocipher/rnbridge/VdoPlayerModuleImpl.java +8 -10
  20. package/android/src/main/java/com/vdocipher/rnbridge/VdoPlayerSettingsModuleImpl.java +5 -0
  21. package/android/src/main/java/com/vdocipher/rnbridge/VdocipherRnBridgeModuleImpl.java +12 -0
  22. package/android/src/main/java/com/vdocipher/rnbridge/VdocipherRnBridgePackage.java +3 -1
  23. package/android/src/main/res/layout/vdo_cast_mini_controller.xml +9 -0
  24. package/android/src/main/res/values/vdo_cast_arrays.xml +9 -0
  25. package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoCastButtonManager.java +44 -0
  26. package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoCastMiniControllerManager.java +37 -0
  27. package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoPlayerUIViewManager.java +12 -0
  28. package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoPlayerViewManager.java +30 -0
  29. package/android/src/newarch/java/com/vdocipher/rnbridge/VdoPlayerModule.java +5 -0
  30. package/android/src/newarch/java/com/vdocipher/rnbridge/VdoPlayerSettingsModule.java +5 -0
  31. package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoCastButtonManager.java +27 -0
  32. package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoCastMiniControllerManager.java +19 -0
  33. package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoPlayerUIViewManager.java +4 -0
  34. package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoPlayerViewManager.java +13 -0
  35. package/android/src/oldarch/java/com/vdocipher/rnbridge/VdoPlayerModule.java +5 -0
  36. package/android/src/oldarch/java/com/vdocipher/rnbridge/VdoPlayerSettingsModule.java +5 -0
  37. package/downloads.ts +4 -1
  38. package/index.ts +4 -0
  39. package/ios/RCTVdoPlayerUIView.swift +38 -11
  40. package/ios/RCTVdoPlayerUIViewComponentView.mm +1 -0
  41. package/ios/RCTVdoPlayerView.swift +5 -2
  42. package/ios/RCTVdoPlayerViewComponentView.mm +1 -0
  43. package/ios/VdoCipherRNView.h +1 -0
  44. package/ios/VdoCipherRNView.swift +142 -19
  45. package/ios/VdoEventEmitter.swift +2 -0
  46. package/ios/VdoPlaybackProperties.h +1 -0
  47. package/ios/VdoPlaybackProperties.swift +5 -0
  48. package/ios/VdoPlayerCommandDispatch.h +4 -0
  49. package/ios/VdoPlayerSettings.swift +5 -0
  50. package/ios/VdocipherRnBridgeViewManager.mm +12 -0
  51. package/ios/VdocipherRnBridgeViewManager.swift +5 -1
  52. package/package.json +3 -1
  53. package/specs/NativeVdoPlayer.ts +1 -0
  54. package/specs/NativeVdoPlayerSettings.ts +2 -0
  55. package/specs/RCTVdoCastButtonNativeComponent.ts +11 -0
  56. package/specs/RCTVdoCastMiniControllerNativeComponent.ts +9 -0
  57. package/specs/RCTVdoPlayerUIViewNativeComponent.ts +13 -0
  58. package/specs/RCTVdoPlayerViewNativeComponent.ts +19 -0
  59. package/type.ts +51 -1
@@ -7,7 +7,6 @@ import android.widget.FrameLayout;
7
7
  import android.content.pm.ActivityInfo;
8
8
  import androidx.appcompat.app.AppCompatActivity;
9
9
  import androidx.fragment.app.FragmentManager;
10
- import androidx.fragment.app.Fragment;
11
10
 
12
11
  import android.view.LayoutInflater;
13
12
 
@@ -22,8 +21,17 @@ import com.vdocipher.aegis.player.PlayerHost.InitializationListener;
22
21
  import com.vdocipher.aegis.player.VdoPlayer.PlaybackEventListener;
23
22
  import com.vdocipher.aegis.player.VdoInitParams;
24
23
  import com.vdocipher.aegis.ui.view.VdoPlayerUIFragment;
24
+ import android.content.Intent;
25
+ import com.vdocipher.aegis.cast.CastVdoPlayer;
26
+ import com.vdocipher.aegis.cast.CastSessionAvailabilityListener;
27
+ import com.vdocipher.aegis.cast.internal.CustomExpandedControlsActivity;
28
+ import com.google.android.gms.cast.framework.CastContext;
29
+ import com.google.android.gms.cast.framework.CastSession;
30
+ import com.google.android.gms.cast.framework.CastState;
31
+ import com.google.android.gms.cast.framework.CastStateListener;
32
+ import com.google.android.gms.common.ConnectionResult;
33
+ import com.google.android.gms.common.GoogleApiAvailability;
25
34
  import android.media.AudioManager;
26
- import com.vdocipher.aegis.ui.view.internal.AudioFocusManager;
27
35
  import android.content.Context;
28
36
 
29
37
  import androidx.core.app.PictureInPictureModeChangedInfo;
@@ -73,6 +81,10 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
73
81
  private boolean playWhenReady = true;
74
82
  private float pendingPlaybackSpeed = 0;
75
83
  private boolean fullscreen = false;
84
+ // startMuted of new media, then the last mute/unmute. Re-applied while local media loads: Aegis
85
+ // ignores mute until then, and a reload of the same media (e.g. after casting) would reset it.
86
+ private boolean muted = false;
87
+ private VdoInitParams mutedForParams;
76
88
 
77
89
  private MediaSessionCompat mSession;
78
90
  public static final long MEDIA_ACTIONS_PLAY_PAUSE =
@@ -81,6 +93,19 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
81
93
  | PlaybackStateCompat.ACTION_PLAY_PAUSE;
82
94
 
83
95
  private VdoInitParams pendingInitParams;
96
+ private VdoInitParams currentInitParams;
97
+
98
+ private boolean chromecastEnabled = false;
99
+ private boolean offlinePlayback = false;
100
+ private CastContext castContext;
101
+ private CastVdoPlayer castPlayer;
102
+ private VdoPlayer currentPlayer;
103
+ private boolean localNeedsReload = false;
104
+ private boolean castLoadPending = false;
105
+ // Resume on focus gain only what a transient loss paused
106
+ private boolean pausedForTransientFocusLoss = false;
107
+ // SDK callbacks can still arrive after cleanUp()
108
+ private boolean isDropped = false;
84
109
 
85
110
  private AppCompatActivity activity;
86
111
 
@@ -120,6 +145,7 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
120
145
  @Override
121
146
  public void onViewAttachedToWindow(View v) {
122
147
  Log.d(TAG, "onViewAttachedToWindow");
148
+ if (isDropped) return;
123
149
  if (vdoPlayerUIFragment == null) {
124
150
  vdoPlayerUIFragment = new VdoPlayerUIFragment();
125
151
  Bundle bundle = new Bundle();
@@ -130,10 +156,8 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
130
156
  }
131
157
 
132
158
  playbackMode = sharedPreferences.getString(VDO_PLAYBACK_MODE, null);
133
- if (playWhenReady && vdoPlayer != null && VdoPlayerSetting.VdoPlaybackMode.DEFAULT == vdoPlaybackModeFromName(playbackMode)) {
134
- if (vdoPlayer != null) {
135
- vdoPlayer.setPlayWhenReady(true);
136
- }
159
+ if (playWhenReady && vdoPlayer != null && isLocalActive() && VdoPlayerSetting.VdoPlaybackMode.DEFAULT == vdoPlaybackModeFromName(playbackMode)) {
160
+ vdoPlayer.setPlayWhenReady(true);
137
161
  }
138
162
  }
139
163
 
@@ -156,8 +180,9 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
156
180
 
157
181
  private void initializePlayer() {
158
182
  if (vdoPlayerUIFragment != null) {
159
- new Handler().postDelayed(() -> {
160
- if (fragmentManager != null && !fragmentManager.isDestroyed()) {
183
+ mainHandler.postDelayed(() -> {
184
+ // The view can be unmounted during the delay, which clears the fragment in cleanUp()
185
+ if (vdoPlayerUIFragment != null && fragmentManager != null && !fragmentManager.isDestroyed()) {
161
186
  try {
162
187
  fragmentManager.beginTransaction().replace(frameLayoutId, vdoPlayerUIFragment, "VdoPlayerUIFragmentRN").commitAllowingStateLoss();
163
188
  fragmentManager.executePendingTransactions();
@@ -165,7 +190,9 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
165
190
  // in onInitializationSuccess() callback
166
191
  vdoPlayerUIFragment.initialize(initializationListener);
167
192
  vdoPlayerUIFragment.setResizeMode(this.resizeMode);
168
- } catch(IllegalStateException e) {
193
+ } catch(Exception e) {
194
+ // executePendingTransactions() throws IllegalArgumentException, not
195
+ // IllegalStateException, when the container view is already gone
169
196
  Log.e(TAG, Log.getStackTraceString(e));
170
197
  }
171
198
  }
@@ -177,26 +204,39 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
177
204
  * Clean up all resources, references to this instance which may prevent it from being GC'ed.
178
205
  */
179
206
  public void cleanUp() {
207
+ isDropped = true;
180
208
  themedReactContext.removeLifecycleEventListener(this);
209
+ releaseCast();
181
210
  if (pictureModeChangedInfoConsumer != null) {
182
211
  activity.removeOnPictureInPictureModeChangedListener(pictureModeChangedInfoConsumer);
183
212
  }
184
213
 
214
+ // Drop any work still queued for this view, in particular the delayed transaction
215
+ // scheduled by initializePlayer(), which would otherwise keep it reachable
216
+ mainHandler.removeCallbacksAndMessages(null);
217
+
185
218
  playbackMode = sharedPreferences.getString(VDO_PLAYBACK_MODE, null);
186
- if (vdoPlayer != null && VdoPlayerSetting.VdoPlaybackMode.DEFAULT == vdoPlaybackModeFromName(playbackMode)) {
187
- vdoPlayer.stop();
219
+ if (vdoPlayer != null) {
220
+ vdoPlayer.removePlaybackEventListener(playbackListener);
221
+ if (VdoPlayerSetting.VdoPlaybackMode.DEFAULT == vdoPlaybackModeFromName(playbackMode)) {
222
+ vdoPlayer.stop();
223
+ }
188
224
  }
189
- if (fragmentManager != null && !fragmentManager.isDestroyed()) {
225
+ if (vdoPlayerUIFragment != null && fragmentManager != null && !fragmentManager.isDestroyed()) {
190
226
  try {
191
- Fragment fragment = fragmentManager.findFragmentById(vdoPlayerUIFragment.getId());
192
- if (fragment != null) {
193
- fragmentManager.beginTransaction().remove(fragment).commitAllowingStateLoss();
227
+ // Remove our own fragment rather than looking it up by id: when the delayed
228
+ // transaction never ran, getId() is still 0 and findFragmentById(0) matches
229
+ // any headless fragment in the activity
230
+ if (vdoPlayerUIFragment.isAdded()) {
231
+ fragmentManager.beginTransaction().remove(vdoPlayerUIFragment).commitAllowingStateLoss();
194
232
  }
195
- } catch(IllegalStateException e) {
233
+ } catch(Exception e) {
196
234
  Log.e(TAG, Log.getStackTraceString(e));
197
235
  }
198
236
  }
199
237
  vdoPlayerUIFragment = null;
238
+ vdoPlayer = null;
239
+ currentPlayer = null;
200
240
  }
201
241
 
202
242
  public boolean setFullscreen(boolean enterFullscreen) {
@@ -239,25 +279,31 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
239
279
  public void getPlaybackPropertiesV2(Callback callback) {
240
280
  WritableMap playbackProperties = Arguments.createMap();
241
281
  if (vdoPlayer != null) {
242
- mainHandler.post(() -> {
243
- Object tp = vdoPlayer.getPlaybackProperty("totalPlayed");
244
- long totalPlayed = (tp instanceof Long) ? (long)tp : 0L;
245
- Object tc = vdoPlayer.getPlaybackProperty("totalCovered");
246
- long totalCovered = (tc instanceof Long) ? (long)tc : 0L;
247
- playbackProperties.putInt("totalPlayed", (int)totalPlayed);
248
- playbackProperties.putInt("totalCovered", (int)totalCovered);
249
- callback.invoke(playbackProperties);
250
- });
251
- } else {
252
- callback.invoke(playbackProperties);
282
+ Object tp = vdoPlayer.getPlaybackProperty("totalPlayed");
283
+ long totalPlayed = (tp instanceof Long) ? (long)tp : 0L;
284
+ Object tc = vdoPlayer.getPlaybackProperty("totalCovered");
285
+ long totalCovered = (tc instanceof Long) ? (long)tc : 0L;
286
+ playbackProperties.putInt("totalPlayed", (int)totalPlayed);
287
+ playbackProperties.putInt("totalCovered", (int)totalCovered);
253
288
  }
289
+ callback.invoke(playbackProperties);
254
290
  }
255
291
 
256
292
  public void setPlayWhenReady(boolean playWhenReady) {
257
293
  this.playWhenReady = playWhenReady;
258
- if (vdoPlayer != null) {
259
- vdoPlayer.setPlayWhenReady(playWhenReady);
294
+ pausedForTransientFocusLoss = false;
295
+ VdoPlayer player = controlPlayer();
296
+ if (player == null) {
297
+ return;
260
298
  }
299
+ // The receiver unloads the media once it finishes, so replaying needs a fresh load.
300
+ if (playWhenReady && player == castPlayer && castHasNoMedia() && currentInitParams != null) {
301
+ currentInitParams = currentInitParams.getBuilder().setAutoplay(true).build();
302
+ castLoadPending = true;
303
+ castPlayer.load(currentInitParams);
304
+ return;
305
+ }
306
+ player.setPlayWhenReady(playWhenReady);
261
307
  }
262
308
 
263
309
  public void setAutoPlay(boolean autoPlay) {
@@ -266,17 +312,69 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
266
312
  }
267
313
  }
268
314
 
315
+ // Goes to the local player even while casting (the cast player cannot mute), ready for the return.
316
+ public void setMuted(boolean muted) {
317
+ this.muted = muted;
318
+ applyMuted();
319
+ }
320
+
321
+ public boolean isMuted() {
322
+ return muted;
323
+ }
324
+
325
+ private void applyMuted() {
326
+ if (vdoPlayer == null || vdoPlayer.isMuted() == muted) {
327
+ return;
328
+ }
329
+ if (muted) {
330
+ vdoPlayer.mute();
331
+ } else {
332
+ vdoPlayer.unmute();
333
+ }
334
+ updateAudioFocusForMute();
335
+ }
336
+
337
+ // Muted playback does not hold audio focus, except while paused for a transient loss so that
338
+ // AUDIOFOCUS_GAIN still resumes it.
339
+ private void updateAudioFocusForMute() {
340
+ if (audioFocusManager == null || !isLocalActive()) {
341
+ return;
342
+ }
343
+ if (vdoPlayer.isMuted()) {
344
+ if (!pausedForTransientFocusLoss) {
345
+ audioFocusManager.abandonAudioFocus();
346
+ }
347
+ } else if (isLocalPlaying() && !audioFocusManager.requestAudioFocus()) {
348
+ Log.i(TAG, "Audio focus not granted");
349
+ }
350
+ }
351
+
352
+ private boolean isLocalPlaying() {
353
+ int state = vdoPlayer.getPlaybackState();
354
+ return vdoPlayer.getPlayWhenReady() && state != VdoPlayer.STATE_IDLE && state != VdoPlayer.STATE_ENDED;
355
+ }
356
+
269
357
  public void setPlaybackSpeed(float playbackSpeed) {
270
358
  this.pendingPlaybackSpeed = playbackSpeed;
271
- if (vdoPlayer != null) {
272
- vdoPlayer.setPlaybackSpeed(playbackSpeed);
359
+ VdoPlayer player = controlPlayer();
360
+ if (player != null) {
361
+ player.setPlaybackSpeed(playbackSpeed);
273
362
  }
274
363
  }
275
364
 
276
365
  public void seekTo(int targetMs) {
277
- if (vdoPlayer != null) {
278
- vdoPlayer.seekTo(targetMs);
366
+ VdoPlayer player = controlPlayer();
367
+ if (player == null) {
368
+ return;
369
+ }
370
+ // Nothing to seek on a finished cast session; remember where the next play should start.
371
+ if (player == castPlayer && castHasNoMedia()) {
372
+ if (currentInitParams != null) {
373
+ currentInitParams = currentInitParams.getBuilder().setResumeTime(targetMs).build();
374
+ }
375
+ return;
279
376
  }
377
+ player.seekTo(targetMs);
280
378
  }
281
379
 
282
380
  public void setPictureInPictureSupport() {
@@ -384,15 +482,7 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
384
482
  }
385
483
 
386
484
  public void isAdaptive(Callback callback) {
387
-
388
- if (vdoPlayer != null) {
389
- mainHandler.post(() -> {
390
- boolean isAdaptive = vdoPlayer.isAdaptive();
391
- callback.invoke(isAdaptive);
392
- });
393
- } else {
394
- callback.invoke(false);
395
- }
485
+ callback.invoke(vdoPlayer != null && vdoPlayer.isAdaptive());
396
486
  }
397
487
 
398
488
  public void getVideoQualities(Callback callback) {
@@ -429,22 +519,22 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
429
519
 
430
520
  public void setSelectedTrack(ReadableMap selectedTrackMap) {
431
521
  Track selectedTrack = makeTrack(selectedTrackMap, availableTracks);
432
-
433
- if (vdoPlayer != null && selectedTrack != null) {
434
- mainHandler.post(() -> {
435
- vdoPlayer.setSelectedTracks(new Track[]{selectedTrack});
436
- });
522
+ if (selectedTrack != null) {
523
+ postSelectTrack(selectedTrack);
437
524
  }
438
525
  }
439
526
 
440
527
  public void enableAdaptiveVideo() {
441
- Track selectedTrack = Track.SET_ADAPTIVE;
528
+ postSelectTrack(Track.SET_ADAPTIVE);
529
+ }
442
530
 
443
- if (vdoPlayer != null) {
444
- mainHandler.post(() -> {
445
- vdoPlayer.setSelectedTracks(new Track[]{selectedTrack});
446
- });
447
- }
531
+ private void postSelectTrack(Track track) {
532
+ mainHandler.post(() -> {
533
+ VdoPlayer player = controlPlayer();
534
+ if (player != null) {
535
+ player.setSelectedTracks(new Track[]{track});
536
+ }
537
+ });
448
538
  }
449
539
 
450
540
  public void getCaptionLanguages(Callback callback) {
@@ -456,27 +546,17 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
456
546
  }
457
547
 
458
548
  public void disableCaptions() {
459
- Track selectedTrack = Track.DISABLE_CAPTIONS;
460
-
461
- if (vdoPlayer != null) {
462
- mainHandler.post(() -> {
463
- vdoPlayer.setSelectedTracks(new Track[]{selectedTrack});
464
- });
465
- }
549
+ postSelectTrack(Track.DISABLE_CAPTIONS);
466
550
  }
467
551
 
468
552
  public void getDuration(Callback callback) {
469
-
470
- if (vdoPlayer != null) {
471
- mainHandler.post(() -> {
472
- double videoDuration = vdoPlayer.getDuration();
473
- WritableMap videoDurationMap = Arguments.createMap();
474
- videoDurationMap.putDouble("duration", videoDuration);
475
- callback.invoke(videoDurationMap);
476
- });
477
- } else {
553
+ if (vdoPlayer == null) {
478
554
  callback.invoke(0);
555
+ return;
479
556
  }
557
+ WritableMap videoDurationMap = Arguments.createMap();
558
+ videoDurationMap.putDouble("duration", vdoPlayer.getDuration());
559
+ callback.invoke(videoDurationMap);
480
560
  }
481
561
 
482
562
  @Override
@@ -510,11 +590,16 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
510
590
  @Override
511
591
  public void onHostResume() {
512
592
  Log.d(TAG, "onHostResume");
593
+ enableCastIfNeeded();
513
594
  }
514
595
 
515
596
  @Override
516
597
  public void onHostPause() {
517
598
  Log.d(TAG, "onHostPause");
599
+ // Ignore cast session events while backgrounded so the expanded controller doesn't swap back to local.
600
+ if (castPlayer != null) {
601
+ castPlayer.setSessionAvailabilityListenerWeakRef(null);
602
+ }
518
603
  }
519
604
 
520
605
  @Override
@@ -544,7 +629,10 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
544
629
  @Override
545
630
  public void onInitializationSuccess(PlayerHost playerHost, VdoPlayer player, boolean restored) {
546
631
  Log.d(TAG, "init success");
632
+ if (isDropped) return;
547
633
  vdoPlayer = player;
634
+ // Stay on cast if a session is already active so pending params load onto the TV, not local.
635
+ currentPlayer = (castPlayer != null && castPlayer.isCastSessionAvailable()) ? castPlayer : vdoPlayer;
548
636
  availableTracks = vdoPlayer.getAvailableTracks();
549
637
  selectedTracks = vdoPlayer.getSelectedTracks();
550
638
  vdoPlayer.addPlaybackEventListener(playbackListener);
@@ -557,11 +645,13 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
557
645
  pendingInitParams = null;
558
646
  }
559
647
 
648
+ enableCastIfNeeded();
560
649
  }
561
650
 
562
651
  @Override
563
652
  public void onInitializationFailure(PlayerHost playerHost, ErrorDescription errorDescription) {
564
653
  Log.e(TAG, "init failure: " + errorDescription.toString());
654
+ if (isDropped) return;
565
655
  eventEmitter.initFailure(errorDescription);
566
656
  }
567
657
 
@@ -573,38 +663,265 @@ public class ReactVdoPlayerView extends LinearLayout implements LifecycleEventLi
573
663
  };
574
664
 
575
665
  public void load(VdoInitParams params) {
666
+ // Equal params are the same media, which keeps its mute state. Not compared with
667
+ // currentInitParams, which cast handoffs rebuild with a new resume time.
668
+ if (params != null && !params.equals(mutedForParams)) {
669
+ mutedForParams = params;
670
+ muted = params.startMuted;
671
+ }
672
+ currentInitParams = params;
673
+ pausedForTransientFocusLoss = false;
674
+ if (!isLocalActive()) {
675
+ localNeedsReload = true;
676
+ maybeLoadCast();
677
+ return;
678
+ }
576
679
  if (vdoPlayer != null && params != null) {
577
680
  try {
578
681
  vdoPlayer.load(params);
682
+ localNeedsReload = false;
579
683
  } catch(Exception e) {
580
684
  Log.e(TAG, Log.getStackTraceString(e));
581
685
  }
686
+ // Re-evaluate cast here, where the new params are already current.
687
+ enableCastIfNeeded();
582
688
  } else {
583
689
  pendingInitParams = params;
584
690
  }
585
691
  }
586
692
 
693
+ private VdoPlayer controlPlayer() {
694
+ return currentPlayer != null ? currentPlayer : vdoPlayer;
695
+ }
696
+
697
+ private boolean isLocalActive() {
698
+ return castPlayer == null || currentPlayer != castPlayer;
699
+ }
700
+
701
+ private boolean castHasNoMedia() {
702
+ // A load in flight is also STATE_IDLE, so it must not look like unloaded media.
703
+ if (castPlayer == null || castLoadPending) {
704
+ return false;
705
+ }
706
+ int state = castPlayer.getPlaybackState();
707
+ return state == VdoPlayer.STATE_ENDED || state == VdoPlayer.STATE_IDLE;
708
+ }
709
+
710
+ public void setChromecastEnabled(boolean enabled) {
711
+ this.chromecastEnabled = enabled;
712
+ if (enabled) {
713
+ enableCastIfNeeded();
714
+ } else {
715
+ // Hand playback back to local before tearing the cast player down.
716
+ setCurrentPlayer(vdoPlayer);
717
+ releaseCast();
718
+ }
719
+ }
720
+
721
+ public void setOfflinePlayback(boolean offline) {
722
+ this.offlinePlayback = offline;
723
+ // Offline media has no receiver tokens, so never leave a cast player attached to it.
724
+ // A load() of the offline media always follows, so local is not resumed here.
725
+ if (offline) {
726
+ if (castPlayer != null) {
727
+ castPlayer.stop();
728
+ }
729
+ releaseCast();
730
+ }
731
+ }
732
+
733
+ public void stopCasting() {
734
+ if (castContext != null) {
735
+ castContext.getSessionManager().endCurrentSession(true);
736
+ }
737
+ }
738
+
739
+ public void openCastControls() {
740
+ if (castContext == null || castContext.getSessionManager().getCurrentCastSession() == null) {
741
+ return;
742
+ }
743
+ Intent intent = new Intent(themedReactContext, CustomExpandedControlsActivity.class);
744
+ if (activity != null) {
745
+ activity.startActivity(intent);
746
+ } else {
747
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
748
+ themedReactContext.startActivity(intent);
749
+ }
750
+ }
751
+
752
+ private boolean isCastApiAvailable() {
753
+ try {
754
+ return GoogleApiAvailability.getInstance()
755
+ .isGooglePlayServicesAvailable(themedReactContext) == ConnectionResult.SUCCESS;
756
+ } catch (Exception e) {
757
+ return false;
758
+ }
759
+ }
760
+
761
+ private void enableCastIfNeeded() {
762
+ if (!chromecastEnabled || offlinePlayback || activity == null || !isCastApiAvailable()) {
763
+ return;
764
+ }
765
+ try {
766
+ if (castContext == null) {
767
+ castContext = CastContext.getSharedInstance(activity);
768
+ castContext.addCastStateListener(castStateListener);
769
+ emitCastState(castContext.getCastState());
770
+ }
771
+ if (castPlayer == null) {
772
+ castPlayer = new CastVdoPlayer(castContext);
773
+ castPlayer.addPlaybackEventListener(playbackListener);
774
+ }
775
+ castPlayer.setSessionAvailabilityListenerWeakRef(castSessionAvailabilityListener);
776
+ setCurrentPlayer(castPlayer.isCastSessionAvailable() ? castPlayer : vdoPlayer);
777
+ } catch (Exception e) {
778
+ Log.e(TAG, Log.getStackTraceString(e));
779
+ }
780
+ }
781
+
782
+ private void releaseCastPlayer() {
783
+ if (castPlayer != null) {
784
+ castPlayer.setSessionAvailabilityListenerWeakRef(null);
785
+ castPlayer.removePlaybackEventListener(playbackListener);
786
+ castPlayer.release();
787
+ castPlayer = null;
788
+ }
789
+ castLoadPending = false;
790
+ currentPlayer = vdoPlayer;
791
+ }
792
+
793
+ private void releaseCast() {
794
+ releaseCastPlayer();
795
+ if (castContext != null) {
796
+ castContext.removeCastStateListener(castStateListener);
797
+ castContext = null;
798
+ }
799
+ }
800
+
801
+ private void setCurrentPlayer(VdoPlayer newPlayer) {
802
+ if (currentPlayer == newPlayer || newPlayer == null) {
803
+ return;
804
+ }
805
+ int position = 0;
806
+ boolean autoplay = playWhenReady;
807
+ if (currentPlayer != null) {
808
+ position = (int) currentPlayer.getCurrentTime();
809
+ autoplay = currentPlayer.getPlayWhenReady();
810
+ if (currentInitParams != null) {
811
+ currentInitParams = currentInitParams.getBuilder()
812
+ .setResumeTime(position)
813
+ .setAutoplay(autoplay)
814
+ .build();
815
+ }
816
+ }
817
+ if (newPlayer == castPlayer) {
818
+ // Keep the local player loaded but paused so returning to it is instant.
819
+ if (vdoPlayer != null) vdoPlayer.setPlayWhenReady(false);
820
+ // The cast session has its own notification; ours must not drive local playback.
821
+ if (mSession != null) mSession.setActive(false);
822
+ if (audioFocusManager != null) audioFocusManager.abandonAudioFocus();
823
+ currentPlayer = newPlayer;
824
+ maybeLoadCast();
825
+ } else {
826
+ if (castPlayer != null) castPlayer.stop();
827
+ if (mSession != null) mSession.setActive(true);
828
+ currentPlayer = newPlayer;
829
+ resumeLocal(position, autoplay);
830
+ }
831
+ }
832
+
833
+ private void maybeLoadCast() {
834
+ if (castPlayer == null || currentInitParams == null) {
835
+ return;
836
+ }
837
+ castLoadPending = true;
838
+ if (!castPlayer.joinSession(currentInitParams)) {
839
+ castPlayer.load(currentInitParams);
840
+ }
841
+ }
842
+
843
+ private void resumeLocal(int position, boolean autoplay) {
844
+ if (vdoPlayer == null) {
845
+ return;
846
+ }
847
+ // Resume in place when the same video is still loaded; otherwise reload.
848
+ if (!localNeedsReload && vdoPlayer.getPlaybackState() != VdoPlayer.STATE_IDLE) {
849
+ vdoPlayer.seekTo(position);
850
+ vdoPlayer.setPlayWhenReady(autoplay);
851
+ } else if (currentInitParams != null) {
852
+ vdoPlayer.load(currentInitParams);
853
+ localNeedsReload = false;
854
+ }
855
+ }
856
+
857
+ private void emitCastState(int castState) {
858
+ String state;
859
+ switch (castState) {
860
+ case CastState.CONNECTED: state = "connected"; break;
861
+ case CastState.CONNECTING: state = "connecting"; break;
862
+ case CastState.NOT_CONNECTED: state = "notConnected"; break;
863
+ default: state = "noDevices"; break;
864
+ }
865
+ String deviceName = "";
866
+ if (castState == CastState.CONNECTED && castContext != null) {
867
+ CastSession session = castContext.getSessionManager().getCurrentCastSession();
868
+ if (session != null && session.getCastDevice() != null) {
869
+ deviceName = session.getCastDevice().getFriendlyName();
870
+ }
871
+ }
872
+ eventEmitter.castStateChanged(state, deviceName);
873
+ }
874
+
875
+ private final CastSessionAvailabilityListener castSessionAvailabilityListener = new CastSessionAvailabilityListener() {
876
+ @Override
877
+ public void onCastSessionAvailable() {
878
+ setCurrentPlayer(castPlayer);
879
+ }
880
+
881
+ @Override
882
+ public void onCastSessionUnavailable() {
883
+ setCurrentPlayer(vdoPlayer);
884
+ }
885
+ };
886
+
887
+ private final CastStateListener castStateListener = newState -> emitCastState(newState);
888
+
587
889
  private final AudioManager.OnAudioFocusChangeListener audioFocusChangeListener = new AudioManager.OnAudioFocusChangeListener() {
588
890
  @Override
589
891
  public void onAudioFocusChange(int focusChange) {
590
- switch (focusChange) {
591
- case AudioManager.AUDIOFOCUS_GAIN:
592
- //resume playing
593
- if (vdoPlayer != null)
594
- vdoPlayer.setPlayWhenReady(true);
595
- break;
596
- case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
597
- //depending on your app reduce audio to a minimum if you want to continue playing or pause
598
- break;
599
- case AudioManager.AUDIOFOCUS_LOSS:
600
- //pause playing
601
- if (vdoPlayer != null)
892
+ // Audio focus callbacks arrive on the looper that registered them, which is not
893
+ // necessarily the main thread; the player only accepts calls on the main thread.
894
+ mainHandler.post(() -> {
895
+ if (vdoPlayer == null) return;
896
+ switch (focusChange) {
897
+ case AudioManager.AUDIOFOCUS_GAIN:
898
+ //resume playing
899
+ if (pausedForTransientFocusLoss && isLocalActive())
900
+ vdoPlayer.setPlayWhenReady(true);
901
+ pausedForTransientFocusLoss = false;
902
+ // Kept while muted only to receive this gain.
903
+ if (vdoPlayer.isMuted() && audioFocusManager != null) {
904
+ audioFocusManager.abandonAudioFocus();
905
+ }
906
+ break;
907
+ case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
908
+ //depending on your app reduce audio to a minimum if you want to continue playing or pause
909
+ break;
910
+ case AudioManager.AUDIOFOCUS_LOSS:
911
+ //pause playing
912
+ pausedForTransientFocusLoss = false;
602
913
  vdoPlayer.setPlayWhenReady(false);
603
- case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
604
- default:
605
- //stop playing
606
- break;
607
- }
914
+ break;
915
+ case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
916
+ if (vdoPlayer.getPlayWhenReady()) {
917
+ vdoPlayer.setPlayWhenReady(false);
918
+ pausedForTransientFocusLoss = true;
919
+ }
920
+ break;
921
+ default:
922
+ break;
923
+ }
924
+ });
608
925
  }
609
926
  };
610
927
 
@@ -615,19 +932,33 @@ private final VdoPlayer.PlaybackEventListener playbackListener = new VdoPlayer.P
615
932
  public void onPlayerStateChanged(boolean playWhenReady, int playerState) {
616
933
  boolean playing = playerState != VdoPlayer.STATE_IDLE && playerState != VdoPlayer.STATE_ENDED && playWhenReady;
617
934
 
935
+ // Covers play from outside JS too, e.g. notification or PiP
936
+ if (playing) {
937
+ pausedForTransientFocusLoss = false;
938
+ }
939
+
940
+ // Any non-idle cast state means media is live, so no load is still in flight.
941
+ if (!isLocalActive() && playerState != VdoPlayer.STATE_IDLE) {
942
+ castLoadPending = false;
943
+ }
944
+
618
945
  // We are playing the video now. Update the media session state and the PiP
619
946
  // window will update the actions.
620
947
 
621
- updatePlaybackState(playing ? PlaybackStateCompat.STATE_PLAYING : PlaybackStateCompat.STATE_PAUSED, vdoPlayer.getCurrentTime(), vdoPlayer.getPlaybackSpeed());
948
+ if (isLocalActive()) {
949
+ applyMuted();
950
+ updatePlaybackState(playing ? PlaybackStateCompat.STATE_PLAYING : PlaybackStateCompat.STATE_PAUSED, vdoPlayer.getCurrentTime(), vdoPlayer.getPlaybackSpeed());
622
951
 
623
- if (playing) {
624
- //Request audio focus and notify other players to stop playback.
625
- if (!(audioFocusManager != null && audioFocusManager.requestAudioFocus())) {
626
- Log.i(TAG, "Audio focus not granted");
952
+ if (playing) {
953
+ //Request audio focus and notify other players to stop playback, unless muted.
954
+ if (!vdoPlayer.isMuted()
955
+ && !(audioFocusManager != null && audioFocusManager.requestAudioFocus())) {
956
+ Log.i(TAG, "Audio focus not granted");
957
+ }
958
+ } else if (playerState == VdoPlayer.STATE_ENDED && audioFocusManager != null) {
959
+ // Abandon audio focus when playback complete
960
+ audioFocusManager.abandonAudioFocus();
627
961
  }
628
- } else if (playerState == VdoPlayer.STATE_ENDED && audioFocusManager != null) {
629
- // Abandon audio focus when playback complete
630
- audioFocusManager.abandonAudioFocus();
631
962
  }
632
963
  eventEmitter.playerStateChanged(playWhenReady, playerState);
633
964
  }
@@ -659,22 +990,36 @@ private final VdoPlayer.PlaybackEventListener playbackListener = new VdoPlayer.P
659
990
 
660
991
  @Override
661
992
  public void onLoaded(VdoInitParams vdoInitParams) {
662
- vdoPlayer.setPlayWhenReady(playWhenReady);
663
- if (pendingPlaybackSpeed > 0) {
664
- vdoPlayer.setPlaybackSpeed(pendingPlaybackSpeed);
665
- pendingPlaybackSpeed = 0;
993
+ if (isLocalActive()) {
994
+ applyMuted();
995
+ vdoPlayer.setPlayWhenReady(playWhenReady);
996
+ if (pendingPlaybackSpeed > 0) {
997
+ vdoPlayer.setPlaybackSpeed(pendingPlaybackSpeed);
998
+ pendingPlaybackSpeed = 0;
999
+ }
1000
+ initializeMediaSession();
1001
+ eventEmitter.loaded(vdoInitParams, vdoPlayer.getCurrentMedia());
1002
+ } else {
1003
+ castLoadPending = false;
1004
+ // Apply any play/pause pressed while the load was in flight, as the local branch does.
1005
+ castPlayer.setPlayWhenReady(playWhenReady);
1006
+ eventEmitter.loaded(vdoInitParams, castPlayer.getCurrentMedia());
666
1007
  }
667
- initializeMediaSession();
668
- eventEmitter.loaded(vdoInitParams, vdoPlayer.getCurrentMedia());
669
1008
  }
670
1009
 
671
1010
  @Override
672
1011
  public void onLoadError(VdoInitParams vdoInitParams, ErrorDescription errorDescription) {
1012
+ if (!isLocalActive()) {
1013
+ castLoadPending = false;
1014
+ }
673
1015
  eventEmitter.loadError(vdoInitParams, errorDescription);
674
1016
  }
675
1017
 
676
1018
  @Override
677
1019
  public void onMediaEnded(VdoInitParams vdoInitParams) {
1020
+ if (!isLocalActive() && currentInitParams != null) {
1021
+ currentInitParams = currentInitParams.getBuilder().setResumeTime(0).build();
1022
+ }
678
1023
  eventEmitter.mediaEnded(vdoInitParams);
679
1024
  }
680
1025
 
@@ -685,9 +1030,11 @@ private final VdoPlayer.PlaybackEventListener playbackListener = new VdoPlayer.P
685
1030
 
686
1031
  @Override
687
1032
  public void onTracksChanged(Track[] tracksAvailable, Track[] tracksSelected) {
688
- availableTracks = tracksAvailable;
689
- selectedTracks = tracksSelected;
690
- eventEmitter.tracksChanged(availableTracks, selectedTracks);
1033
+ if (isLocalActive()) {
1034
+ availableTracks = tracksAvailable;
1035
+ selectedTracks = tracksSelected;
1036
+ }
1037
+ eventEmitter.tracksChanged(tracksAvailable, tracksSelected);
691
1038
  }
692
1039
 
693
1040
  @Override