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.
- package/VdoCastButton.tsx +22 -0
- package/VdoCastMiniController.tsx +21 -0
- package/VdoPlayerView.tsx +64 -0
- package/android/build.gradle +5 -3
- package/android/src/main/java/com/vdocipher/rnbridge/AudioFocusManager.java +7 -2
- package/android/src/main/java/com/vdocipher/rnbridge/PlayerViewRegistry.java +21 -0
- package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoCastButtonManagerImpl.java +40 -0
- package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoCastMiniControllerManagerImpl.java +12 -0
- package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerUIView.java +85 -59
- package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerUIViewManagerImpl.java +18 -0
- package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerView.java +450 -103
- package/android/src/main/java/com/vdocipher/rnbridge/ReactVdoPlayerViewManagerImpl.java +30 -1
- package/android/src/main/java/com/vdocipher/rnbridge/TrackSelectionModuleImpl.java +13 -28
- package/android/src/main/java/com/vdocipher/rnbridge/Utils.java +36 -0
- package/android/src/main/java/com/vdocipher/rnbridge/VdoCastButtonView.java +59 -0
- package/android/src/main/java/com/vdocipher/rnbridge/VdoCastMiniControllerView.java +83 -0
- package/android/src/main/java/com/vdocipher/rnbridge/VdoDownloadModuleImpl.java +15 -3
- package/android/src/main/java/com/vdocipher/rnbridge/VdoEventEmitter.java +15 -2
- package/android/src/main/java/com/vdocipher/rnbridge/VdoPlayerModuleImpl.java +8 -10
- package/android/src/main/java/com/vdocipher/rnbridge/VdoPlayerSettingsModuleImpl.java +5 -0
- package/android/src/main/java/com/vdocipher/rnbridge/VdocipherRnBridgeModuleImpl.java +12 -0
- package/android/src/main/java/com/vdocipher/rnbridge/VdocipherRnBridgePackage.java +3 -1
- package/android/src/main/res/layout/vdo_cast_mini_controller.xml +9 -0
- package/android/src/main/res/values/vdo_cast_arrays.xml +9 -0
- package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoCastButtonManager.java +44 -0
- package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoCastMiniControllerManager.java +37 -0
- package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoPlayerUIViewManager.java +12 -0
- package/android/src/newarch/java/com/vdocipher/rnbridge/ReactVdoPlayerViewManager.java +30 -0
- package/android/src/newarch/java/com/vdocipher/rnbridge/VdoPlayerModule.java +5 -0
- package/android/src/newarch/java/com/vdocipher/rnbridge/VdoPlayerSettingsModule.java +5 -0
- package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoCastButtonManager.java +27 -0
- package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoCastMiniControllerManager.java +19 -0
- package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoPlayerUIViewManager.java +4 -0
- package/android/src/oldarch/java/com/vdocipher/rnbridge/ReactVdoPlayerViewManager.java +13 -0
- package/android/src/oldarch/java/com/vdocipher/rnbridge/VdoPlayerModule.java +5 -0
- package/android/src/oldarch/java/com/vdocipher/rnbridge/VdoPlayerSettingsModule.java +5 -0
- package/downloads.ts +4 -1
- package/index.ts +4 -0
- package/ios/RCTVdoPlayerUIView.swift +38 -11
- package/ios/RCTVdoPlayerUIViewComponentView.mm +1 -0
- package/ios/RCTVdoPlayerView.swift +5 -2
- package/ios/RCTVdoPlayerViewComponentView.mm +1 -0
- package/ios/VdoCipherRNView.h +1 -0
- package/ios/VdoCipherRNView.swift +142 -19
- package/ios/VdoEventEmitter.swift +2 -0
- package/ios/VdoPlaybackProperties.h +1 -0
- package/ios/VdoPlaybackProperties.swift +5 -0
- package/ios/VdoPlayerCommandDispatch.h +4 -0
- package/ios/VdoPlayerSettings.swift +5 -0
- package/ios/VdocipherRnBridgeViewManager.mm +12 -0
- package/ios/VdocipherRnBridgeViewManager.swift +5 -1
- package/package.json +3 -1
- package/specs/NativeVdoPlayer.ts +1 -0
- package/specs/NativeVdoPlayerSettings.ts +2 -0
- package/specs/RCTVdoCastButtonNativeComponent.ts +11 -0
- package/specs/RCTVdoCastMiniControllerNativeComponent.ts +9 -0
- package/specs/RCTVdoPlayerUIViewNativeComponent.ts +13 -0
- package/specs/RCTVdoPlayerViewNativeComponent.ts +19 -0
- 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
|
-
|
|
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
|
-
|
|
160
|
-
|
|
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(
|
|
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
|
|
187
|
-
vdoPlayer.
|
|
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
|
-
|
|
192
|
-
|
|
193
|
-
|
|
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(
|
|
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
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
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
|
-
|
|
259
|
-
|
|
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
|
-
|
|
272
|
-
|
|
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
|
-
|
|
278
|
-
|
|
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
|
-
|
|
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
|
|
528
|
+
postSelectTrack(Track.SET_ADAPTIVE);
|
|
529
|
+
}
|
|
442
530
|
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
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
|
|
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
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
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
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
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
|
-
|
|
948
|
+
if (isLocalActive()) {
|
|
949
|
+
applyMuted();
|
|
950
|
+
updatePlaybackState(playing ? PlaybackStateCompat.STATE_PLAYING : PlaybackStateCompat.STATE_PAUSED, vdoPlayer.getCurrentTime(), vdoPlayer.getPlaybackSpeed());
|
|
622
951
|
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
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
|
-
|
|
663
|
-
|
|
664
|
-
vdoPlayer.
|
|
665
|
-
pendingPlaybackSpeed
|
|
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
|
-
|
|
689
|
-
|
|
690
|
-
|
|
1033
|
+
if (isLocalActive()) {
|
|
1034
|
+
availableTracks = tracksAvailable;
|
|
1035
|
+
selectedTracks = tracksSelected;
|
|
1036
|
+
}
|
|
1037
|
+
eventEmitter.tracksChanged(tracksAvailable, tracksSelected);
|
|
691
1038
|
}
|
|
692
1039
|
|
|
693
1040
|
@Override
|