DefaultHttpDataSource.java 源代码
package com.mbridge.msdk.playercommon.exoplayer2.upstream;
import android.net.Uri;
import android.text.TextUtils;
import android.util.Log;
import com.mbridge.msdk.foundation.download.Command;
import com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource;
import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
import com.mbridge.msdk.playercommon.exoplayer2.util.Predicate;
import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
import com.x8zs.plugin.apache.http.HttpHost;
import com.x8zs.plugin.apache.http.protocol.HTTP;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.HttpURLConnection;
import java.net.NoRouteToHostException;
import java.net.ProtocolException;
import java.net.URL;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class DefaultHttpDataSource implements HttpDataSource {
public static final int DEFAULT_CONNECT_TIMEOUT_MILLIS = 8000;
public static final int DEFAULT_READ_TIMEOUT_MILLIS = 8000;
private static final long MAX_BYTES_TO_DRAIN = 2048;
private static final int MAX_REDIRECTS = 20;
private static final String TAG = "DefaultHttpDataSource";
private final boolean allowCrossProtocolRedirects;
private long bytesRead;
private long bytesSkipped;
private long bytesToRead;
private long bytesToSkip;
private final int connectTimeoutMillis;
private HttpURLConnection connection;
private final Predicate<String> contentTypePredicate;
private DataSpec dataSpec;
private final HttpDataSource.RequestProperties defaultRequestProperties;
private InputStream inputStream;
private final TransferListener<? super DefaultHttpDataSource> listener;
private boolean opened;
private final int readTimeoutMillis;
private final HttpDataSource.RequestProperties requestProperties;
private final String userAgent;
private static final Pattern CONTENT_RANGE_HEADER = Pattern.compile("^bytes (\\d+)-(\\d+)/(\\d+)$");
private static final AtomicReference<byte[]> skipBufferReference = new AtomicReference<>();
public DefaultHttpDataSource(String str, Predicate<String> predicate) {
this(str, predicate, null);
}
private void closeConnectionQuietly() {
HttpURLConnection httpURLConnection = this.connection;
if (httpURLConnection != null) {
try {
httpURLConnection.disconnect();
} catch (Exception e6) {
Log.e(TAG, "Unexpected error while disconnecting", e6);
}
this.connection = null;
}
}
private static long getContentLength(HttpURLConnection httpURLConnection) {
long parseLong;
String headerField;
String headerField2 = httpURLConnection.getHeaderField(HTTP.CONTENT_LEN);
if (!TextUtils.isEmpty(headerField2)) {
try {
parseLong = Long.parseLong(headerField2);
} catch (NumberFormatException unused) {
Log.e(TAG, "Unexpected Content-Length [" + headerField2 + "]");
}
headerField = httpURLConnection.getHeaderField("Content-Range");
if (TextUtils.isEmpty(headerField)) {
Matcher matcher = CONTENT_RANGE_HEADER.matcher(headerField);
if (matcher.find()) {
try {
long parseLong2 = (Long.parseLong(matcher.group(2)) - Long.parseLong(matcher.group(1))) + 1;
if (parseLong < 0) {
return parseLong2;
}
if (parseLong != parseLong2) {
Log.w(TAG, "Inconsistent headers [" + headerField2 + "] [" + headerField + "]");
return Math.max(parseLong, parseLong2);
}
return parseLong;
} catch (NumberFormatException unused2) {
Log.e(TAG, "Unexpected Content-Range [" + headerField + "]");
return parseLong;
}
}
return parseLong;
}
return parseLong;
}
parseLong = -1;
headerField = httpURLConnection.getHeaderField("Content-Range");
if (TextUtils.isEmpty(headerField)) {
}
}
private static URL handleRedirect(URL url, String str) throws IOException {
if (str != null) {
URL url2 = new URL(url, str);
String protocol = url2.getProtocol();
if (!"https".equals(protocol) && !HttpHost.DEFAULT_SCHEME_NAME.equals(protocol)) {
throw new ProtocolException("Unsupported protocol redirect: " + protocol);
}
return url2;
}
throw new ProtocolException("Null location redirect");
}
private HttpURLConnection makeConnection(DataSpec dataSpec) throws IOException {
HttpURLConnection makeConnection;
URL url = new URL(dataSpec.uri.toString());
byte[] bArr = dataSpec.postBody;
long j6 = dataSpec.position;
long j7 = dataSpec.length;
boolean isFlagSet = dataSpec.isFlagSet(1);
if (!this.allowCrossProtocolRedirects) {
return makeConnection(url, bArr, j6, j7, isFlagSet, true);
}
int i6 = 0;
while (true) {
int i7 = i6 + 1;
if (i6 <= 20) {
long j8 = j6;
makeConnection = makeConnection(url, bArr, j6, j7, isFlagSet, false);
int responseCode = makeConnection.getResponseCode();
if (responseCode == 300 || responseCode == 301 || responseCode == 302 || responseCode == 303 || (bArr == null && (responseCode == 307 || responseCode == 308))) {
String headerField = makeConnection.getHeaderField("Location");
makeConnection.disconnect();
url = handleRedirect(url, headerField);
bArr = null;
i6 = i7;
j6 = j8;
}
} else {
throw new NoRouteToHostException("Too many redirects: " + i7);
}
}
return makeConnection;
}
private static void maybeTerminateInputStream(HttpURLConnection httpURLConnection, long j6) {
int i6 = Util.SDK_INT;
if (i6 != 19 && i6 != 20) {
return;
}
try {
InputStream inputStream = httpURLConnection.getInputStream();
if (j6 == -1) {
if (inputStream.read() == -1) {
return;
}
} else if (j6 <= MAX_BYTES_TO_DRAIN) {
return;
}
String name = inputStream.getClass().getName();
if ("com.android.okhttp.internal.http.HttpTransport$ChunkedInputStream".equals(name) || "com.android.okhttp.internal.http.HttpTransport$FixedLengthInputStream".equals(name)) {
Method declaredMethod = inputStream.getClass().getSuperclass().getDeclaredMethod("unexpectedEndOfInput", new Class[0]);
declaredMethod.setAccessible(true);
declaredMethod.invoke(inputStream, new Object[0]);
}
} catch (Exception unused) {
}
}
private int readInternal(byte[] bArr, int i6, int i7) throws IOException {
if (i7 == 0) {
return 0;
}
long j6 = this.bytesToRead;
if (j6 != -1) {
long j7 = j6 - this.bytesRead;
if (j7 == 0) {
return -1;
}
i7 = (int) Math.min(i7, j7);
}
int read = this.inputStream.read(bArr, i6, i7);
if (read == -1) {
if (this.bytesToRead == -1) {
return -1;
}
throw new EOFException();
}
this.bytesRead += read;
TransferListener<? super DefaultHttpDataSource> transferListener = this.listener;
if (transferListener != null) {
transferListener.onBytesTransferred(this, read);
}
return read;
}
private void skipInternal() throws IOException {
if (this.bytesSkipped == this.bytesToSkip) {
return;
}
byte[] andSet = skipBufferReference.getAndSet(null);
if (andSet == null) {
andSet = new byte[4096];
}
while (true) {
long j6 = this.bytesSkipped;
long j7 = this.bytesToSkip;
if (j6 != j7) {
int read = this.inputStream.read(andSet, 0, (int) Math.min(j7 - j6, andSet.length));
if (!Thread.currentThread().isInterrupted()) {
if (read != -1) {
this.bytesSkipped += read;
TransferListener<? super DefaultHttpDataSource> transferListener = this.listener;
if (transferListener != null) {
transferListener.onBytesTransferred(this, read);
}
} else {
throw new EOFException();
}
} else {
throw new InterruptedIOException();
}
} else {
skipBufferReference.set(andSet);
return;
}
}
}
protected final long bytesRead() {
return this.bytesRead;
}
protected final long bytesRemaining() {
long j6 = this.bytesToRead;
if (j6 != -1) {
return j6 - this.bytesRead;
}
return j6;
}
protected final long bytesSkipped() {
return this.bytesSkipped;
}
@Override
public void clearAllRequestProperties() {
this.requestProperties.clear();
}
@Override
public void clearRequestProperty(String str) {
Assertions.checkNotNull(str);
this.requestProperties.remove(str);
}
@Override
public void close() throws HttpDataSource.HttpDataSourceException {
try {
if (this.inputStream != null) {
maybeTerminateInputStream(this.connection, bytesRemaining());
try {
this.inputStream.close();
} catch (IOException e6) {
throw new HttpDataSource.HttpDataSourceException(e6, this.dataSpec, 3);
}
}
} finally {
this.inputStream = null;
closeConnectionQuietly();
if (this.opened) {
this.opened = false;
TransferListener<? super DefaultHttpDataSource> transferListener = this.listener;
if (transferListener != null) {
transferListener.onTransferEnd(this);
}
}
}
}
protected final HttpURLConnection getConnection() {
return this.connection;
}
@Override
public Map<String, List<String>> getResponseHeaders() {
HttpURLConnection httpURLConnection = this.connection;
if (httpURLConnection == null) {
return null;
}
return httpURLConnection.getHeaderFields();
}
@Override
public Uri getUri() {
HttpURLConnection httpURLConnection = this.connection;
if (httpURLConnection == null) {
return null;
}
return Uri.parse(httpURLConnection.getURL().toString());
}
@Override
public long open(DataSpec dataSpec) throws HttpDataSource.HttpDataSourceException {
this.dataSpec = dataSpec;
long j6 = 0;
this.bytesRead = 0L;
this.bytesSkipped = 0L;
try {
HttpURLConnection makeConnection = makeConnection(dataSpec);
this.connection = makeConnection;
try {
int responseCode = makeConnection.getResponseCode();
if (responseCode >= 200 && responseCode <= 299) {
String contentType = this.connection.getContentType();
Predicate<String> predicate = this.contentTypePredicate;
if (predicate != null && !predicate.evaluate(contentType)) {
closeConnectionQuietly();
throw new HttpDataSource.InvalidContentTypeException(contentType, dataSpec);
}
if (responseCode == 200) {
long j7 = dataSpec.position;
if (j7 != 0) {
j6 = j7;
}
}
this.bytesToSkip = j6;
if (!dataSpec.isFlagSet(1)) {
long j8 = dataSpec.length;
long j9 = -1;
if (j8 != -1) {
this.bytesToRead = j8;
} else {
long contentLength = getContentLength(this.connection);
if (contentLength != -1) {
j9 = contentLength - this.bytesToSkip;
}
this.bytesToRead = j9;
}
} else {
this.bytesToRead = dataSpec.length;
}
try {
this.inputStream = this.connection.getInputStream();
this.opened = true;
TransferListener<? super DefaultHttpDataSource> transferListener = this.listener;
if (transferListener != null) {
transferListener.onTransferStart(this, dataSpec);
}
return this.bytesToRead;
} catch (IOException e6) {
closeConnectionQuietly();
throw new HttpDataSource.HttpDataSourceException(e6, dataSpec, 1);
}
}
Map<String, List<String>> headerFields = this.connection.getHeaderFields();
closeConnectionQuietly();
HttpDataSource.InvalidResponseCodeException invalidResponseCodeException = new HttpDataSource.InvalidResponseCodeException(responseCode, headerFields, dataSpec);
if (responseCode == 416) {
invalidResponseCodeException.initCause(new DataSourceException(0));
throw invalidResponseCodeException;
}
throw invalidResponseCodeException;
} catch (IOException e7) {
closeConnectionQuietly();
throw new HttpDataSource.HttpDataSourceException("Unable to connect to " + dataSpec.uri.toString(), e7, dataSpec, 1);
}
} catch (IOException e8) {
throw new HttpDataSource.HttpDataSourceException("Unable to connect to " + dataSpec.uri.toString(), e8, dataSpec, 1);
}
}
@Override
public int read(byte[] bArr, int i6, int i7) throws HttpDataSource.HttpDataSourceException {
try {
skipInternal();
return readInternal(bArr, i6, i7);
} catch (IOException e6) {
throw new HttpDataSource.HttpDataSourceException(e6, this.dataSpec, 2);
}
}
@Override
public void setRequestProperty(String str, String str2) {
Assertions.checkNotNull(str);
Assertions.checkNotNull(str2);
this.requestProperties.set(str, str2);
}
public DefaultHttpDataSource(String str, Predicate<String> predicate, TransferListener<? super DefaultHttpDataSource> transferListener) {
this(str, predicate, transferListener, 8000, 8000);
}
public DefaultHttpDataSource(String str, Predicate<String> predicate, TransferListener<? super DefaultHttpDataSource> transferListener, int i6, int i7) {
this(str, predicate, transferListener, i6, i7, false, null);
}
public DefaultHttpDataSource(String str, Predicate<String> predicate, TransferListener<? super DefaultHttpDataSource> transferListener, int i6, int i7, boolean z6, HttpDataSource.RequestProperties requestProperties) {
this.userAgent = Assertions.checkNotEmpty(str);
this.contentTypePredicate = predicate;
this.listener = transferListener;
this.requestProperties = new HttpDataSource.RequestProperties();
this.connectTimeoutMillis = i6;
this.readTimeoutMillis = i7;
this.allowCrossProtocolRedirects = z6;
this.defaultRequestProperties = requestProperties;
}
private HttpURLConnection makeConnection(URL url, byte[] bArr, long j6, long j7, boolean z6, boolean z7) throws IOException {
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
httpURLConnection.setConnectTimeout(this.connectTimeoutMillis);
httpURLConnection.setReadTimeout(this.readTimeoutMillis);
HttpDataSource.RequestProperties requestProperties = this.defaultRequestProperties;
if (requestProperties != null) {
for (Map.Entry<String, String> entry : requestProperties.getSnapshot().entrySet()) {
httpURLConnection.setRequestProperty(entry.getKey(), entry.getValue());
}
}
for (Map.Entry<String, String> entry2 : this.requestProperties.getSnapshot().entrySet()) {
httpURLConnection.setRequestProperty(entry2.getKey(), entry2.getValue());
}
if (j6 != 0 || j7 != -1) {
String str = "bytes=" + j6 + "-";
if (j7 != -1) {
str = str + ((j6 + j7) - 1);
}
httpURLConnection.setRequestProperty(Command.HTTP_HEADER_RANGE, str);
}
httpURLConnection.setRequestProperty("User-Agent", this.userAgent);
if (!z6) {
httpURLConnection.setRequestProperty("Accept-Encoding", HTTP.IDENTITY_CODING);
}
httpURLConnection.setInstanceFollowRedirects(z7);
httpURLConnection.setDoOutput(bArr != null);
if (bArr != null) {
httpURLConnection.setRequestMethod("POST");
if (bArr.length != 0) {
httpURLConnection.setFixedLengthStreamingMode(bArr.length);
httpURLConnection.connect();
OutputStream outputStream = httpURLConnection.getOutputStream();
outputStream.write(bArr);
outputStream.close();
return httpURLConnection;
}
}
httpURLConnection.connect();
return httpURLConnection;
}
}