Class DataChunk

  • All Implemented Interfaces:
    Loader.Loadable

    public abstract class DataChunk
    extends Chunk
    A base class for Chunk implementations where the data should be loaded into a byte[] before being consumed.
    • Constructor Detail

      • DataChunk

        public DataChunk​(DataSource dataSource,
                         DataSpec dataSpec,
                         int type,
                         Format trackFormat,
                         int trackSelectionReason,
                         @Nullable
                         Object trackSelectionData,
                         @Nullable
                         byte[] data)
        Parameters:
        dataSource - The source from which the data should be loaded.
        dataSpec - Defines the data to be loaded.
        type - See Chunk.type.
        trackFormat - See Chunk.trackFormat.
        trackSelectionReason - See Chunk.trackSelectionReason.
        trackSelectionData - See Chunk.trackSelectionData.
        data - An optional recycled array that can be used as a holder for the data.
    • Method Detail

      • getDataHolder

        public byte[] getDataHolder()
        Returns the array in which the data is held.

        This method should be used for recycling the holder only, and not for reading the data.

        Returns:
        The array in which the data is held.
      • cancelLoad

        public final void cancelLoad()
        Description copied from interface: Loader.Loadable
        Cancels the load.

        Loadable implementations should ensure that a currently executing Loader.Loadable.load() call will exit reasonably quickly after this method is called. The Loader.Loadable.load() call may exit either by returning or by throwing an IOException.

        If there is a currently executing Loader.Loadable.load() call, then the thread on which that call is being made will be interrupted immediately after the call to this method. Hence implementations do not need to (and should not attempt to) interrupt the loading thread themselves.

        Although the loading thread will be interrupted, Loadable implementations should not use the interrupted status of the loading thread in Loader.Loadable.load() to determine whether the load has been canceled. This approach is not robust [Internal ref: b/79223737]. Instead, implementations should use their own flag to signal cancelation (for example, using AtomicBoolean).

      • load

        public final void load()
                        throws IOException
        Description copied from interface: Loader.Loadable
        Performs the load, returning on completion or cancellation.
        Throws:
        IOException - If the input could not be loaded.
      • consume

        protected abstract void consume​(byte[] data,
                                        int limit)
                                 throws IOException
        Called by load(). Implementations should override this method to consume the loaded data.
        Parameters:
        data - An array containing the data.
        limit - The limit of the data.
        Throws:
        IOException - If an error occurs consuming the loaded data.