Examples with DataSpec com.google.android.exoplayer2.upstream.DataSpec used on opensource projects

Example 26 with DataSpec

use of com.google.android.exoplayer2.upstream.DataSpec in project ExoPlayer by google.

the class CronetDataSourceTest method testRangeRequestWith200Response.

@Test
public void testRangeRequestWith200Response() throws HttpDataSourceException {
    mockResponseStartSuccess();
    mockReadSuccess(0, 7000);
    // Server does not support range requests.
    testUrlResponseInfo = createUrlResponseInfo(200);
    testDataSpec = new DataSpec(Uri.parse(TEST_URL), 1000, 5000, null);
    dataSourceUnderTest.open(testDataSpec);
    byte[] returnedBuffer = new byte[16];
    int bytesRead = dataSourceUnderTest.read(returnedBuffer, 0, 16);
    assertEquals(16, bytesRead);
    assertArrayEquals(buildTestDataArray(1000, 16), returnedBuffer);
    verify(mockTransferListener).onBytesTransferred(dataSourceUnderTest, 16);
}

Example 27 with DataSpec

use of com.google.android.exoplayer2.upstream.DataSpec in project ExoPlayer by google.

the class CacheDataSource method openNextSource.

/**
   * Opens the next source. If the cache contains data spanning the current read position then
   * {@link #cacheReadDataSource} is opened to read from it. Else {@link #upstreamDataSource} is
   * opened to read from the upstream source and write into the cache.
   * @param initial Whether it is the initial open call.
   */
private boolean openNextSource(boolean initial) throws IOException {
    DataSpec dataSpec;
    CacheSpan span;
    if (currentRequestIgnoresCache) {
        span = null;
    } else if (blockOnCache) {
        try {
            span = cache.startReadWrite(key, readPosition);
        } catch (InterruptedException e) {
            throw new InterruptedIOException();
        }
    } else {
        span = cache.startReadWriteNonBlocking(key, readPosition);
    }
    if (span == null) {
        // The data is locked in the cache, or we're ignoring the cache. Bypass the cache and read
        // from upstream.
        currentDataSource = upstreamDataSource;
        dataSpec = new DataSpec(uri, readPosition, bytesRemaining, key, flags);
    } else if (span.isCached) {
        // Data is cached, read from cache.
        Uri fileUri = Uri.fromFile(span.file);
        long filePosition = readPosition - span.position;
        long length = span.length - filePosition;
        if (bytesRemaining != C.LENGTH_UNSET) {
            length = Math.min(length, bytesRemaining);
        }
        dataSpec = new DataSpec(fileUri, readPosition, filePosition, length, key, flags);
        currentDataSource = cacheReadDataSource;
    } else {
        // Data is not cached, and data is not locked, read from upstream with cache backing.
        long length;
        if (span.isOpenEnded()) {
            length = bytesRemaining;
        } else {
            length = span.length;
            if (bytesRemaining != C.LENGTH_UNSET) {
                length = Math.min(length, bytesRemaining);
            }
        }
        dataSpec = new DataSpec(uri, readPosition, length, key, flags);
        if (cacheWriteDataSource != null) {
            currentDataSource = cacheWriteDataSource;
            lockedSpan = span;
        } else {
            currentDataSource = upstreamDataSource;
            cache.releaseHoleSpan(span);
        }
    }
    currentRequestUnbounded = dataSpec.length == C.LENGTH_UNSET;
    boolean successful = false;
    long currentBytesRemaining = 0;
    try {
        currentBytesRemaining = currentDataSource.open(dataSpec);
        successful = true;
    } catch (IOException e) {
        // end of the stream.
        if (!initial && currentRequestUnbounded) {
            Throwable cause = e;
            while (cause != null) {
                if (cause instanceof DataSourceException) {
                    int reason = ((DataSourceException) cause).reason;
                    if (reason == DataSourceException.POSITION_OUT_OF_RANGE) {
                        e = null;
                        break;
                    }
                }
                cause = cause.getCause();
            }
        }
        if (e != null) {
            throw e;
        }
    }
    // bytesRemaining == C.LENGTH_UNSET) and got a resolved length from open() request
    if (currentRequestUnbounded && currentBytesRemaining != C.LENGTH_UNSET) {
        bytesRemaining = currentBytesRemaining;
        setContentLength(dataSpec.position + bytesRemaining);
    }
    return successful;
}