Java Assertions.checkNotNull方法代码示例

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * Instantiates a new sample extractor reading from the specified seekable {@code fileDescriptor}.
 * The caller is responsible for releasing the file descriptor.
 *
 * @param fileDescriptor File descriptor from which to read.
 * @param fileDescriptorOffset The offset in bytes where the data to be extracted starts.
 * @param fileDescriptorLength The length in bytes of the data to be extracted.
 */
public FrameworkSampleSource(FileDescriptor fileDescriptor, long fileDescriptorOffset,
    long fileDescriptorLength) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.fileDescriptor = Assertions.checkNotNull(fileDescriptor);
  this.fileDescriptorOffset = fileDescriptorOffset;
  this.fileDescriptorLength = fileDescriptorLength;
  context = null;
  uri = null;
  headers = null;
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
@Override
public void clearRequestProperty(String name) {
    Assertions.checkNotNull(name);
    synchronized (requestProperties) {
        requestProperties.remove(name);
    }
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
@Override
public void clearRequestProperty(String name) {
  Assertions.checkNotNull(name);
  synchronized (requestProperties) {
    requestProperties.remove(name);
  }
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * Instantiates a new sample extractor reading from the specified {@code uri}.
 *
 * @param context Context for resolving {@code uri}.
 * @param uri The content URI from which to extract data.
 * @param headers Headers to send with requests for data.
 */
public FrameworkSampleSource(Context context, Uri uri, Map<String, String> headers) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.context = Assertions.checkNotNull(context);
  this.uri = Assertions.checkNotNull(uri);
  this.headers = headers;
  fileDescriptor = null;
  fileDescriptorOffset = 0;
  fileDescriptorLength = 0;
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param source A source from which samples containing metadata can be read.
 * @param metadataParser A parser for parsing the metadata.
 * @param metadataRenderer The metadata renderer to receive the parsed metadata.
 * @param metadataRendererLooper The looper associated with the thread on which metadataRenderer
 *     should be invoked. If the renderer makes use of standard Android UI components, then this
 *     should normally be the looper associated with the applications' main thread, which can be
 *     obtained using {@link android.app.Activity#getMainLooper()}. Null may be passed if the
 *     renderer should be invoked directly on the player's internal rendering thread.
 */
public MetadataTrackRenderer(SampleSource source, MetadataParser<T> metadataParser,
    MetadataRenderer<T> metadataRenderer, Looper metadataRendererLooper) {
  super(source);
  this.metadataParser = Assertions.checkNotNull(metadataParser);
  this.metadataRenderer = Assertions.checkNotNull(metadataRenderer);
  this.metadataHandler = metadataRendererLooper == null ? null
      : new Handler(metadataRendererLooper, this);
  formatHolder = new MediaFormatHolder();
  sampleHolder = new SampleHolder(SampleHolder.BUFFER_REPLACEMENT_MODE_NORMAL);
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
@Override
public void setRequestProperty(String name, String value) {
  Assertions.checkNotNull(name);
  Assertions.checkNotNull(value);
  synchronized (requestProperties) {
    requestProperties.put(name, value);
  }
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param id The format identifier.
 * @param mimeType The format mime type.
 * @param width The width of the video in pixels, or -1 if unknown or not applicable.
 * @param height The height of the video in pixels, or -1 if unknown or not applicable.
 * @param frameRate The frame rate of the video in frames per second, or -1 if unknown or not
 *     applicable.
 * @param audioChannels The number of audio channels, or -1 if unknown or not applicable.
 * @param audioSamplingRate The audio sampling rate in Hz, or -1 if unknown or not applicable.
 * @param bitrate The average bandwidth of the format in bits per second.
 * @param language The language of the format.
 * @param codecs The codecs used to decode the format.
 */
public Format(String id, String mimeType, int width, int height, float frameRate,
    int audioChannels, int audioSamplingRate, int bitrate, String language, String codecs) {
  this.id = Assertions.checkNotNull(id);
  this.mimeType = mimeType;
  this.width = width;
  this.height = height;
  this.frameRate = frameRate;
  this.audioChannels = audioChannels;
  this.audioSamplingRate = audioSamplingRate;
  this.bitrate = bitrate;
  this.language = language;
  this.codecs = codecs;
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param upstream The upstream {@link DataSource}.
 * @param dataSink The {@link DataSink} into which data is written.
 */
public TeeDataSource(DataSource upstream, DataSink dataSink) {
  this.upstream = Assertions.checkNotNull(upstream);
  this.dataSink = Assertions.checkNotNull(dataSink);
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * Peeks and returns a {@code WavHeader}.
 *
 * @param input Input stream to peek the WAV header from.
 * @throws IOException If peeking from the input fails.
 * @throws InterruptedException If interrupted while peeking from input.
 * @throws ParserException If the input file is an incorrect RIFF WAV.
 * @return A new {@code WavHeader} peeked from {@code input}, or null if the input is not a
 *     supported WAV format.
 */
public static WavHeader peek(ExtractorInput input)
    throws IOException, InterruptedException, ParserException {
  Assertions.checkNotNull(input);

  // Allocate a scratch buffer large enough to store the format chunk.
  ParsableByteArray scratch = new ParsableByteArray(16);

  // Attempt to read the RIFF chunk.
  ChunkHeader chunkHeader = ChunkHeader.peek(input, scratch);
  if (chunkHeader.id != Util.getIntegerCodeForString("RIFF")) {
    return null;
  }

  input.peekFully(scratch.data, 0, 4);
  scratch.setPosition(0);
  int riffFormat = scratch.readInt();
  if (riffFormat != Util.getIntegerCodeForString("WAVE")) {
    Log.e(TAG, "Unsupported RIFF format: " + riffFormat);
    return null;
  }

  // Skip chunks until we find the format chunk.
  chunkHeader = ChunkHeader.peek(input, scratch);
  while (chunkHeader.id != Util.getIntegerCodeForString("fmt ")) {
    input.advancePeekPosition((int) chunkHeader.size);
    chunkHeader = ChunkHeader.peek(input, scratch);
  }

  Assertions.checkState(chunkHeader.size >= 16);
  input.peekFully(scratch.data, 0, 16);
  scratch.setPosition(0);
  int type = scratch.readLittleEndianUnsignedShort();
  int numChannels = scratch.readLittleEndianUnsignedShort();
  int sampleRateHz = scratch.readLittleEndianUnsignedIntToInt();
  int averageBytesPerSecond = scratch.readLittleEndianUnsignedIntToInt();
  int blockAlignment = scratch.readLittleEndianUnsignedShort();
  int bitsPerSample = scratch.readLittleEndianUnsignedShort();

  int expectedBlockAlignment = numChannels * bitsPerSample / 8;
  if (blockAlignment != expectedBlockAlignment) {
    throw new ParserException("Expected block alignment: " + expectedBlockAlignment + "; got: "
        + blockAlignment);
  }

  int encoding = Util.getPcmEncoding(bitsPerSample);
  if (encoding == C.ENCODING_INVALID) {
    Log.e(TAG, "Unsupported WAV bit depth: " + bitsPerSample);
    return null;
  }

  if (type != TYPE_PCM && type != TYPE_WAVE_FORMAT_EXTENSIBLE) {
    Log.e(TAG, "Unsupported WAV format type: " + type);
    return null;
  }

  // If present, skip extensionSize, validBitsPerSample, channelMask, subFormatGuid, ...
  input.advancePeekPosition((int) chunkHeader.size - 16);

  return new WavHeader(numChannels, sampleRateHz, averageBytesPerSecond, blockAlignment,
      bitsPerSample, encoding);
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param priority The priority of the source.
 * @param upstream The upstream {@link DataSource}.
 */
public PriorityDataSource(int priority, DataSource upstream) {
  this.priority = priority;
  this.upstream = Assertions.checkNotNull(upstream);
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param dataSource The source from which the data should be loaded.
 * @param dataSpec Defines the data to be loaded. {@code dataSpec.length} must not exceed
 *     {@link Integer#MAX_VALUE}. If {@code dataSpec.length == C.LENGTH_UNBOUNDED} then
 *     the length resolved by {@code dataSource.open(dataSpec)} must not exceed
 *     {@link Integer#MAX_VALUE}.
 * @param type See {@link #type}.
 * @param trigger See {@link #trigger}.
 * @param format See {@link #format}.
 */
public Chunk(DataSource dataSource, DataSpec dataSpec, int type, int trigger, Format format) {
  this.dataSource = Assertions.checkNotNull(dataSource);
  this.dataSpec = Assertions.checkNotNull(dataSpec);
  this.type = type;
  this.trigger = trigger;
  this.format = format;
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param dataSource A {@link DataSource} for loading the data.
 * @param dataSpec Defines the data to be loaded.
 * @param trigger The reason for this chunk being selected.
 * @param format The format of the stream to which this chunk belongs.
 * @param startTimeUs The start time of the media contained by the chunk, in microseconds.
 * @param endTimeUs The end time of the media contained by the chunk, in microseconds.
 * @param chunkIndex The index of the chunk.
 * @param isLastChunk True if this is the last chunk in the media. False otherwise.
 */
public MediaChunk(DataSource dataSource, DataSpec dataSpec, int trigger, Format format,
    long startTimeUs, long endTimeUs, int chunkIndex, boolean isLastChunk) {
  super(dataSource, dataSpec, Chunk.TYPE_MEDIA, trigger, format);
  Assertions.checkNotNull(format);
  this.startTimeUs = startTimeUs;
  this.endTimeUs = endTimeUs;
  this.chunkIndex = chunkIndex;
  this.isLastChunk = isLastChunk;
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param client An {@link OkHttpClient} for use by the source.
 * @param userAgent The User-Agent string that should be used.
 * @param contentTypePredicate An optional {@link Predicate}. If a content type is rejected by the
 *     predicate then a
 *     {@link InvalidContentTypeException} is
 *     thrown from {@link #open(DataSpec)}.
 * @param listener An optional listener.
 * @param cacheControl An optional {@link CacheControl} which sets all requests' Cache-Control
 *     header. For example, you could force the network response for all requests.
 *
 */
public OkHttpDataSource(OkHttpClient client, String userAgent,
                        Predicate<String> contentTypePredicate, TransferListener listener,
                        CacheControl cacheControl) {
    this.okHttpClient = Assertions.checkNotNull(client);
    this.userAgent = Assertions.checkNotEmpty(userAgent);
    this.contentTypePredicate = contentTypePredicate;
    this.listener = listener;
    this.cacheControl = cacheControl;
    this.requestProperties = new HashMap<>();
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * @param cache The cache into which data should be written.
 * @param maxCacheFileSize The maximum size of a cache file, in bytes. If the sink is opened for
 *    a {@link DataSpec} whose size exceeds this value, then the data will be fragmented into
 *    multiple cache files.
 */
public CacheDataSink(Cache cache, long maxCacheFileSize) {
  this.cache = Assertions.checkNotNull(cache);
  this.maxCacheFileSize = maxCacheFileSize;
}
 

import com.google.android.exoplayer.util.Assertions; //导入方法依赖的package包/类
/**
 * Constructs a new audio capabilities receiver.
 *
 * @param context Context for registering to receive broadcasts.
 * @param listener Listener to notify when audio capabilities change.
 */
public AudioCapabilitiesReceiver(Context context, Listener listener) {
  this.context = Assertions.checkNotNull(context);
  this.listener = Assertions.checkNotNull(listener);
  this.receiver = Util.SDK_INT >= 21 ? new HdmiAudioPlugBroadcastReceiver() : null;
}