| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.google.android.exoplayer2.source; |
| |
| import android.os.Handler; |
| import androidx.annotation.CallSuper; |
| import androidx.annotation.Nullable; |
| import com.google.android.exoplayer2.Timeline; |
| import com.google.android.exoplayer2.drm.DrmSessionEventListener; |
| import com.google.android.exoplayer2.upstream.TransferListener; |
| import com.google.android.exoplayer2.util.Assertions; |
| import com.google.android.exoplayer2.util.UnknownNull; |
| import com.google.android.exoplayer2.util.Util; |
| import java.io.IOException; |
| import java.util.HashMap; |
| |
| /** |
| * Composite {@link MediaSource} consisting of multiple child sources. |
| * |
| * @param <T> The type of the id used to identify prepared child sources. |
| */ |
| public abstract class CompositeMediaSource<T> extends BaseMediaSource { |
| |
| private final HashMap<T, MediaSourceAndListener> childSources; |
| |
| @Nullable private Handler eventHandler; |
| @Nullable private TransferListener mediaTransferListener; |
| |
| /** Creates composite media source without child sources. */ |
| protected CompositeMediaSource() { |
| childSources = new HashMap<>(); |
| } |
| |
| @Override |
| @CallSuper |
| protected void prepareSourceInternal(@Nullable TransferListener mediaTransferListener) { |
| this.mediaTransferListener = mediaTransferListener; |
| eventHandler = Util.createHandler(); |
| } |
| |
| @Override |
| @CallSuper |
| public void maybeThrowSourceInfoRefreshError() throws IOException { |
| for (MediaSourceAndListener childSource : childSources.values()) { |
| childSource.mediaSource.maybeThrowSourceInfoRefreshError(); |
| } |
| } |
| |
| @Override |
| @CallSuper |
| protected void enableInternal() { |
| for (MediaSourceAndListener childSource : childSources.values()) { |
| childSource.mediaSource.enable(childSource.caller); |
| } |
| } |
| |
| @Override |
| @CallSuper |
| protected void disableInternal() { |
| for (MediaSourceAndListener childSource : childSources.values()) { |
| childSource.mediaSource.disable(childSource.caller); |
| } |
| } |
| |
| @Override |
| @CallSuper |
| protected void releaseSourceInternal() { |
| for (MediaSourceAndListener childSource : childSources.values()) { |
| childSource.mediaSource.releaseSource(childSource.caller); |
| childSource.mediaSource.removeEventListener(childSource.eventListener); |
| } |
| childSources.clear(); |
| } |
| |
| /** |
| * Called when the source info of a child source has been refreshed. |
| * |
| * @param id The unique id used to prepare the child source. |
| * @param mediaSource The child source whose source info has been refreshed. |
| * @param timeline The timeline of the child source. |
| */ |
| protected abstract void onChildSourceInfoRefreshed( |
| @UnknownNull T id, MediaSource mediaSource, Timeline timeline); |
| |
| /** |
| * Prepares a child source. |
| * |
| * <p>{@link #onChildSourceInfoRefreshed(Object, MediaSource, Timeline)} will be called when the |
| * child source updates its timeline with the same {@code id} passed to this method. |
| * |
| * <p>Any child sources that aren't explicitly released with {@link #releaseChildSource(Object)} |
| * will be released in {@link #releaseSourceInternal()}. |
| * |
| * @param id A unique id to identify the child source preparation. Null is allowed as an id. |
| * @param mediaSource The child {@link MediaSource}. |
| */ |
| protected final void prepareChildSource(@UnknownNull T id, MediaSource mediaSource) { |
| Assertions.checkArgument(!childSources.containsKey(id)); |
| MediaSourceCaller caller = |
| (source, timeline) -> onChildSourceInfoRefreshed(id, source, timeline); |
| ForwardingEventListener eventListener = new ForwardingEventListener(id); |
| childSources.put(id, new MediaSourceAndListener(mediaSource, caller, eventListener)); |
| mediaSource.addEventListener(Assertions.checkNotNull(eventHandler), eventListener); |
| mediaSource.addDrmEventListener(Assertions.checkNotNull(eventHandler), eventListener); |
| mediaSource.prepareSource(caller, mediaTransferListener); |
| if (!isEnabled()) { |
| mediaSource.disable(caller); |
| } |
| } |
| |
| /** |
| * Enables a child source. |
| * |
| * @param id The unique id used to prepare the child source. |
| */ |
| protected final void enableChildSource(@UnknownNull T id) { |
| MediaSourceAndListener enabledChild = Assertions.checkNotNull(childSources.get(id)); |
| enabledChild.mediaSource.enable(enabledChild.caller); |
| } |
| |
| /** |
| * Disables a child source. |
| * |
| * @param id The unique id used to prepare the child source. |
| */ |
| protected final void disableChildSource(@UnknownNull T id) { |
| MediaSourceAndListener disabledChild = Assertions.checkNotNull(childSources.get(id)); |
| disabledChild.mediaSource.disable(disabledChild.caller); |
| } |
| |
| /** |
| * Releases a child source. |
| * |
| * @param id The unique id used to prepare the child source. |
| */ |
| protected final void releaseChildSource(@UnknownNull T id) { |
| MediaSourceAndListener removedChild = Assertions.checkNotNull(childSources.remove(id)); |
| removedChild.mediaSource.releaseSource(removedChild.caller); |
| removedChild.mediaSource.removeEventListener(removedChild.eventListener); |
| } |
| |
| /** |
| * Returns the window index in the composite source corresponding to the specified window index in |
| * a child source. The default implementation does not change the window index. |
| * |
| * @param id The unique id used to prepare the child source. |
| * @param windowIndex A window index of the child source. |
| * @return The corresponding window index in the composite source. |
| */ |
| protected int getWindowIndexForChildWindowIndex(@UnknownNull T id, int windowIndex) { |
| return windowIndex; |
| } |
| |
| /** |
| * Returns the {@link MediaPeriodId} in the composite source corresponding to the specified {@link |
| * MediaPeriodId} in a child source. The default implementation does not change the media period |
| * id. |
| * |
| * @param id The unique id used to prepare the child source. |
| * @param mediaPeriodId A {@link MediaPeriodId} of the child source. |
| * @return The corresponding {@link MediaPeriodId} in the composite source. Null if no |
| * corresponding media period id can be determined. |
| */ |
| @Nullable |
| protected MediaPeriodId getMediaPeriodIdForChildMediaPeriodId( |
| @UnknownNull T id, MediaPeriodId mediaPeriodId) { |
| return mediaPeriodId; |
| } |
| |
| /** |
| * Returns the media time in the composite source corresponding to the specified media time in a |
| * child source. The default implementation does not change the media time. |
| * |
| * @param id The unique id used to prepare the child source. |
| * @param mediaTimeMs A media time of the child source, in milliseconds. |
| * @return The corresponding media time in the composite source, in milliseconds. |
| */ |
| protected long getMediaTimeForChildMediaTime(@UnknownNull T id, long mediaTimeMs) { |
| return mediaTimeMs; |
| } |
| |
| /** |
| * Returns whether {@link MediaSourceEventListener#onMediaPeriodCreated(int, MediaPeriodId)} and |
| * {@link MediaSourceEventListener#onMediaPeriodReleased(int, MediaPeriodId)} events of the given |
| * media period should be reported. The default implementation is to always report these events. |
| * |
| * @param mediaPeriodId A {@link MediaPeriodId} in the composite media source. |
| * @return Whether create and release events for this media period should be reported. |
| */ |
| protected boolean shouldDispatchCreateOrReleaseEvent(MediaPeriodId mediaPeriodId) { |
| return true; |
| } |
| |
| private static final class MediaSourceAndListener { |
| |
| public final MediaSource mediaSource; |
| public final MediaSourceCaller caller; |
| public final MediaSourceEventListener eventListener; |
| |
| public MediaSourceAndListener( |
| MediaSource mediaSource, MediaSourceCaller caller, MediaSourceEventListener eventListener) { |
| this.mediaSource = mediaSource; |
| this.caller = caller; |
| this.eventListener = eventListener; |
| } |
| } |
| |
| private final class ForwardingEventListener |
| implements MediaSourceEventListener, DrmSessionEventListener { |
| |
| @UnknownNull private final T id; |
| private EventDispatcher eventDispatcher; |
| |
| public ForwardingEventListener(@UnknownNull T id) { |
| this.eventDispatcher = createEventDispatcher(/* mediaPeriodId= */ null); |
| this.id = id; |
| } |
| |
| // MediaSourceEventListener implementation |
| |
| @Override |
| public void onMediaPeriodCreated(int windowIndex, MediaPeriodId mediaPeriodId) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| if (shouldDispatchCreateOrReleaseEvent( |
| Assertions.checkNotNull(eventDispatcher.mediaPeriodId))) { |
| eventDispatcher.mediaPeriodCreated(); |
| } |
| } |
| } |
| |
| @Override |
| public void onMediaPeriodReleased(int windowIndex, MediaPeriodId mediaPeriodId) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| if (shouldDispatchCreateOrReleaseEvent( |
| Assertions.checkNotNull(eventDispatcher.mediaPeriodId))) { |
| eventDispatcher.mediaPeriodReleased(); |
| } |
| } |
| } |
| |
| @Override |
| public void onLoadStarted( |
| int windowIndex, |
| @Nullable MediaPeriodId mediaPeriodId, |
| LoadEventInfo loadEventData, |
| MediaLoadData mediaLoadData) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| eventDispatcher.loadStarted(loadEventData, maybeUpdateMediaLoadData(mediaLoadData)); |
| } |
| } |
| |
| @Override |
| public void onLoadCompleted( |
| int windowIndex, |
| @Nullable MediaPeriodId mediaPeriodId, |
| LoadEventInfo loadEventData, |
| MediaLoadData mediaLoadData) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| eventDispatcher.loadCompleted(loadEventData, maybeUpdateMediaLoadData(mediaLoadData)); |
| } |
| } |
| |
| @Override |
| public void onLoadCanceled( |
| int windowIndex, |
| @Nullable MediaPeriodId mediaPeriodId, |
| LoadEventInfo loadEventData, |
| MediaLoadData mediaLoadData) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| eventDispatcher.loadCanceled(loadEventData, maybeUpdateMediaLoadData(mediaLoadData)); |
| } |
| } |
| |
| @Override |
| public void onLoadError( |
| int windowIndex, |
| @Nullable MediaPeriodId mediaPeriodId, |
| LoadEventInfo loadEventData, |
| MediaLoadData mediaLoadData, |
| IOException error, |
| boolean wasCanceled) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| eventDispatcher.loadError( |
| loadEventData, maybeUpdateMediaLoadData(mediaLoadData), error, wasCanceled); |
| } |
| } |
| |
| @Override |
| public void onReadingStarted(int windowIndex, MediaPeriodId mediaPeriodId) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| eventDispatcher.readingStarted(); |
| } |
| } |
| |
| @Override |
| public void onUpstreamDiscarded( |
| int windowIndex, @Nullable MediaPeriodId mediaPeriodId, MediaLoadData mediaLoadData) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| eventDispatcher.upstreamDiscarded(maybeUpdateMediaLoadData(mediaLoadData)); |
| } |
| } |
| |
| @Override |
| public void onDownstreamFormatChanged( |
| int windowIndex, @Nullable MediaPeriodId mediaPeriodId, MediaLoadData mediaLoadData) { |
| if (maybeUpdateEventDispatcher(windowIndex, mediaPeriodId)) { |
| eventDispatcher.downstreamFormatChanged(maybeUpdateMediaLoadData(mediaLoadData)); |
| } |
| } |
| |
| // DrmSessionEventListener implementation |
| |
| @Override |
| public void onDrmSessionAcquired() { |
| eventDispatcher.dispatch( |
| (listener, windowIndex, mediaPeriodId) -> listener.onDrmSessionAcquired(), |
| DrmSessionEventListener.class); |
| } |
| |
| @Override |
| public void onDrmKeysLoaded() { |
| eventDispatcher.dispatch( |
| (listener, windowIndex, mediaPeriodId) -> listener.onDrmKeysLoaded(), |
| DrmSessionEventListener.class); |
| } |
| |
| @Override |
| public void onDrmSessionManagerError(Exception error) { |
| eventDispatcher.dispatch( |
| (listener, windowIndex, mediaPeriodId) -> listener.onDrmSessionManagerError(error), |
| DrmSessionEventListener.class); |
| } |
| |
| @Override |
| public void onDrmKeysRestored() { |
| eventDispatcher.dispatch( |
| (listener, windowIndex, mediaPeriodId) -> listener.onDrmKeysRestored(), |
| DrmSessionEventListener.class); |
| } |
| |
| @Override |
| public void onDrmKeysRemoved() { |
| eventDispatcher.dispatch( |
| (listener, windowIndex, mediaPeriodId) -> listener.onDrmKeysRemoved(), |
| DrmSessionEventListener.class); |
| } |
| |
| @Override |
| public void onDrmSessionReleased() { |
| eventDispatcher.dispatch( |
| (listener, windowIndex, mediaPeriodId) -> listener.onDrmSessionReleased(), |
| DrmSessionEventListener.class); |
| } |
| |
| /** Updates the event dispatcher and returns whether the event should be dispatched. */ |
| private boolean maybeUpdateEventDispatcher( |
| int childWindowIndex, @Nullable MediaPeriodId childMediaPeriodId) { |
| @Nullable MediaPeriodId mediaPeriodId = null; |
| if (childMediaPeriodId != null) { |
| mediaPeriodId = getMediaPeriodIdForChildMediaPeriodId(id, childMediaPeriodId); |
| if (mediaPeriodId == null) { |
| // Media period not found. Ignore event. |
| return false; |
| } |
| } |
| int windowIndex = getWindowIndexForChildWindowIndex(id, childWindowIndex); |
| if (eventDispatcher.windowIndex != windowIndex |
| || !Util.areEqual(eventDispatcher.mediaPeriodId, mediaPeriodId)) { |
| eventDispatcher = |
| createEventDispatcher(windowIndex, mediaPeriodId, /* mediaTimeOffsetMs= */ 0); |
| } |
| return true; |
| } |
| |
| private MediaLoadData maybeUpdateMediaLoadData(MediaLoadData mediaLoadData) { |
| long mediaStartTimeMs = getMediaTimeForChildMediaTime(id, mediaLoadData.mediaStartTimeMs); |
| long mediaEndTimeMs = getMediaTimeForChildMediaTime(id, mediaLoadData.mediaEndTimeMs); |
| if (mediaStartTimeMs == mediaLoadData.mediaStartTimeMs |
| && mediaEndTimeMs == mediaLoadData.mediaEndTimeMs) { |
| return mediaLoadData; |
| } |
| return new MediaLoadData( |
| mediaLoadData.dataType, |
| mediaLoadData.trackType, |
| mediaLoadData.trackFormat, |
| mediaLoadData.trackSelectionReason, |
| mediaLoadData.trackSelectionData, |
| mediaStartTimeMs, |
| mediaEndTimeMs); |
| } |
| } |
| } |