public interface

BandwidthMeter

 androidx.media3.exoplayer.upstream.BandwidthMeter

Subclasses:

DefaultBandwidthMeter

Gradle dependencies

compile group: 'androidx.media3', name: 'media3-exoplayer', version: '1.0.0-alpha03'

  • groupId: androidx.media3
  • artifactId: media3-exoplayer
  • version: 1.0.0-alpha03

Artifact androidx.media3:media3-exoplayer:1.0.0-alpha03 it located at Google repository (https://maven.google.com/)

Overview

Provides estimates of the currently available bandwidth.

Summary

Methods
public voidaddEventListener(Handler eventHandler, BandwidthMeter.EventListener eventListener)

Adds an BandwidthMeter.EventListener.

public longgetBitrateEstimate()

Returns the estimated bitrate.

public longgetTimeToFirstByteEstimateUs()

Returns the estimated time to first byte, in microseconds, or C.TIME_UNSET if no estimate is available.

public TransferListenergetTransferListener()

Returns the TransferListener that this instance uses to gather bandwidth information from data transfers.

public voidremoveEventListener(BandwidthMeter.EventListener eventListener)

Removes an BandwidthMeter.EventListener.

Methods

public long getBitrateEstimate()

Returns the estimated bitrate.

public long getTimeToFirstByteEstimateUs()

Returns the estimated time to first byte, in microseconds, or C.TIME_UNSET if no estimate is available.

public TransferListener getTransferListener()

Returns the TransferListener that this instance uses to gather bandwidth information from data transfers. May be null if the implementation does not listen to data transfers.

public void addEventListener(Handler eventHandler, BandwidthMeter.EventListener eventListener)

Adds an BandwidthMeter.EventListener.

Parameters:

eventHandler: A handler for events.
eventListener: A listener of events.

public void removeEventListener(BandwidthMeter.EventListener eventListener)

Removes an BandwidthMeter.EventListener.

Parameters:

eventListener: The listener to be removed.

Source

/*
 * Copyright (C) 2016 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 androidx.media3.exoplayer.upstream;

import android.os.Handler;
import androidx.annotation.Nullable;
import androidx.media3.common.C;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.datasource.TransferListener;
import java.util.concurrent.CopyOnWriteArrayList;

/** Provides estimates of the currently available bandwidth. */
@UnstableApi
public interface BandwidthMeter {

  /** A listener of {@link BandwidthMeter} events. */
  interface EventListener {

    /**
     * Called periodically to indicate that bytes have been transferred or the estimated bitrate has
     * changed.
     *
     * <p>Note: The estimated bitrate is typically derived from more information than just {@code
     * bytesTransferred} and {@code elapsedMs}.
     *
     * @param elapsedMs The time taken to transfer {@code bytesTransferred}, in milliseconds. This
     *     is at most the elapsed time since the last callback, but may be less if there were
     *     periods during which data was not being transferred.
     * @param bytesTransferred The number of bytes transferred since the last callback.
     * @param bitrateEstimate The estimated bitrate in bits/sec.
     */
    void onBandwidthSample(int elapsedMs, long bytesTransferred, long bitrateEstimate);

    /** Event dispatcher which allows listener registration. */
    final class EventDispatcher {

      private final CopyOnWriteArrayList<HandlerAndListener> listeners;

      /** Creates an event dispatcher. */
      public EventDispatcher() {
        listeners = new CopyOnWriteArrayList<>();
      }

      /** Adds a listener to the event dispatcher. */
      public void addListener(Handler eventHandler, BandwidthMeter.EventListener eventListener) {
        Assertions.checkNotNull(eventHandler);
        Assertions.checkNotNull(eventListener);
        removeListener(eventListener);
        listeners.add(new HandlerAndListener(eventHandler, eventListener));
      }

      /** Removes a listener from the event dispatcher. */
      public void removeListener(BandwidthMeter.EventListener eventListener) {
        for (HandlerAndListener handlerAndListener : listeners) {
          if (handlerAndListener.listener == eventListener) {
            handlerAndListener.release();
            listeners.remove(handlerAndListener);
          }
        }
      }

      public void bandwidthSample(int elapsedMs, long bytesTransferred, long bitrateEstimate) {
        for (HandlerAndListener handlerAndListener : listeners) {
          if (!handlerAndListener.released) {
            handlerAndListener.handler.post(
                () ->
                    handlerAndListener.listener.onBandwidthSample(
                        elapsedMs, bytesTransferred, bitrateEstimate));
          }
        }
      }

      private static final class HandlerAndListener {

        private final Handler handler;
        private final BandwidthMeter.EventListener listener;

        private boolean released;

        public HandlerAndListener(Handler handler, BandwidthMeter.EventListener eventListener) {
          this.handler = handler;
          this.listener = eventListener;
        }

        public void release() {
          released = true;
        }
      }
    }
  }

  /** Returns the estimated bitrate. */
  long getBitrateEstimate();

  /**
   * Returns the estimated time to first byte, in microseconds, or {@link C#TIME_UNSET} if no
   * estimate is available.
   */
  default long getTimeToFirstByteEstimateUs() {
    return C.TIME_UNSET;
  }

  /**
   * Returns the {@link TransferListener} that this instance uses to gather bandwidth information
   * from data transfers. May be null if the implementation does not listen to data transfers.
   */
  @Nullable
  TransferListener getTransferListener();

  /**
   * Adds an {@link EventListener}.
   *
   * @param eventHandler A handler for events.
   * @param eventListener A listener of events.
   */
  void addEventListener(Handler eventHandler, EventListener eventListener);

  /**
   * Removes an {@link EventListener}.
   *
   * @param eventListener The listener to be removed.
   */
  void removeEventListener(EventListener eventListener);
}