Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (c) 2010 Sonatype, Inc. All rights reserved.
*
* This program is licensed to you under the Apache License Version 2.0,
* and you may not use this file except in compliance with the Apache License Version 2.0.
* You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the Apache License Version 2.0 is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
*/package org.asynchttpclient.extras.simple;
importstatic org.asynchttpclient.Dsl.*;
importstatic org.asynchttpclient.util.MiscUtils.*;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.ssl.SslContext;
import java.io.Closeable;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import org.asynchttpclient.AsyncCompletionHandlerBase;
import org.asynchttpclient.AsyncHandler;
import org.asynchttpclient.AsyncHttpClient;
import org.asynchttpclient.AsyncHttpClientConfig;
import org.asynchttpclient.DefaultAsyncHttpClientConfig;
import org.asynchttpclient.HttpResponseBodyPart;
import org.asynchttpclient.HttpResponseHeaders;
import org.asynchttpclient.HttpResponseStatus;
import org.asynchttpclient.Param;
import org.asynchttpclient.Realm;
import org.asynchttpclient.Realm.AuthScheme;
import org.asynchttpclient.Request;
import org.asynchttpclient.RequestBuilder;
import org.asynchttpclient.Response;
import org.asynchttpclient.SslEngineFactory;
import org.asynchttpclient.cookie.Cookie;
import org.asynchttpclient.handler.ProgressAsyncHandler;
import org.asynchttpclient.handler.resumable.ResumableAsyncHandler;
import org.asynchttpclient.handler.resumable.ResumableIOExceptionFilter;
import org.asynchttpclient.proxy.ProxyServer;
import org.asynchttpclient.request.body.generator.BodyGenerator;
import org.asynchttpclient.request.body.multipart.Part;
import org.asynchttpclient.uri.Uri;
/**
* Simple implementation of {@link AsyncHttpClient} and it's related builders ({@link AsyncHttpClientConfig},
* {@link Realm}, {@link ProxyServer} and {@link AsyncHandler}. You can
* build powerful application by just using this class.
*
* This class rely on {@link BodyGenerator} and {@link BodyConsumer} for handling the request and response body. No
* {@link AsyncHandler} are required. As simple as:
*
* SimpleAsyncHttpClient client = new SimpleAsyncHttpClient.Builder()
* .setIdleConnectionInPoolTimeout(100)
* .setMaximumConnectionsTotal(50)
* .setRequestTimeout(5 * 60 * 1000)
* .setUrl(getTargetUrl())
* .setHeader("Content-Type", "text/html").build();
*
* StringBuilder s = new StringBuilder();
* Future<Response> future = client.post(new InputStreamBodyGenerator(new ByteArrayInputStream(MY_MESSAGE.getBytes())), new AppendableBodyConsumer(s));
*
* or
*
* public void ByteArrayOutputStreamBodyConsumerTest() throws Throwable {
*
* SimpleAsyncHttpClient client = new SimpleAsyncHttpClient.Builder()
* .setUrl(getTargetUrl())
* .build();
*
* ByteArrayOutputStream o = new ByteArrayOutputStream(10);
* Future<Response> future = client.post(new FileBodyGenerator(myFile), new OutputStreamBodyConsumer(o));
*
*/publicclassSimpleAsyncHttpClientimplementsCloseable{
privatefinal AsyncHttpClientConfig config;
privatefinal RequestBuilder requestBuilder;
private AsyncHttpClient asyncHttpClient;
privatefinal ThrowableHandler defaultThrowableHandler;
privatefinalboolean resumeEnabled;
privatefinal ErrorDocumentBehaviour errorDocumentBehaviour;
privatefinal SimpleAHCTransferListener listener;
privatefinalboolean derived;
privateSimpleAsyncHttpClient(AsyncHttpClientConfig config, RequestBuilder requestBuilder, ThrowableHandler defaultThrowableHandler,
ErrorDocumentBehaviour errorDocumentBehaviour, boolean resumeEnabled, AsyncHttpClient ahc, SimpleAHCTransferListener listener){
this.config = config;
this.requestBuilder = requestBuilder;
this.defaultThrowableHandler = defaultThrowableHandler;
this.resumeEnabled = resumeEnabled;
this.errorDocumentBehaviour = errorDocumentBehaviour;
this.asyncHttpClient = ahc;
this.listener = listener;
this.derived = ahc != null;
}
public Futurepost(Part... parts)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
for (Part part : parts) {
r.addBodyPart(part);
}
return execute(r, null, null);
}
public Futurepost(BodyConsumer consumer, Part... parts)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
for (Part part : parts) {
r.addBodyPart(part);
}
return execute(r, consumer, null);
}
public Futurepost(BodyGenerator bodyGenerator)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
r.setBody(bodyGenerator);
return execute(r, null, null);
}
public Futurepost(BodyGenerator bodyGenerator, ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
r.setBody(bodyGenerator);
return execute(r, null, throwableHandler);
}
public Futurepost(BodyGenerator bodyGenerator, BodyConsumer bodyConsumer)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
r.setBody(bodyGenerator);
return execute(r, bodyConsumer, null);
}
public Futurepost(BodyGenerator bodyGenerator, BodyConsumer bodyConsumer, ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
r.setBody(bodyGenerator);
return execute(r, bodyConsumer, throwableHandler);
}
public Futureput(Part... parts)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
for (Part part : parts) {
r.addBodyPart(part);
}
return execute(r, null, null);
}
public Futureput(BodyConsumer consumer, Part... parts)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("POST");
for (Part part : parts) {
r.addBodyPart(part);
}
return execute(r, consumer, null);
}
public Futureput(BodyGenerator bodyGenerator, BodyConsumer bodyConsumer)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("PUT");
r.setBody(bodyGenerator);
return execute(r, bodyConsumer, null);
}
public Futureput(BodyGenerator bodyGenerator, BodyConsumer bodyConsumer, ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("PUT");
r.setBody(bodyGenerator);
return execute(r, bodyConsumer, throwableHandler);
}
public Futureput(BodyGenerator bodyGenerator)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("PUT");
r.setBody(bodyGenerator);
return execute(r, null, null);
}
public Futureput(BodyGenerator bodyGenerator, ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("PUT");
r.setBody(bodyGenerator);
return execute(r, null, throwableHandler);
}
public Futureget()throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
return execute(r, null, null);
}
public Futureget(ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
return execute(r, null, throwableHandler);
}
public Futureget(BodyConsumer bodyConsumer)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
return execute(r, bodyConsumer, null);
}
public Futureget(BodyConsumer bodyConsumer, ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
return execute(r, bodyConsumer, throwableHandler);
}
public Futuredelete()throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("DELETE");
return execute(r, null, null);
}
public Futuredelete(ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("DELETE");
return execute(r, null, throwableHandler);
}
public Futuredelete(BodyConsumer bodyConsumer)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("DELETE");
return execute(r, bodyConsumer, null);
}
public Futuredelete(BodyConsumer bodyConsumer, ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("DELETE");
return execute(r, bodyConsumer, throwableHandler);
}
public Futurehead()throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("HEAD");
return execute(r, null, null);
}
public Futurehead(ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("HEAD");
return execute(r, null, throwableHandler);
}
public Futureoptions()throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("OPTIONS");
return execute(r, null, null);
}
public Futureoptions(ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("OPTIONS");
return execute(r, null, throwableHandler);
}
public Futureoptions(BodyConsumer bodyConsumer)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("OPTIONS");
return execute(r, bodyConsumer, null);
}
public Futureoptions(BodyConsumer bodyConsumer, ThrowableHandler throwableHandler)throws IOException {
RequestBuilder r = rebuildRequest(requestBuilder.build());
r.setMethod("OPTIONS");
return execute(r, bodyConsumer, throwableHandler);
}
private RequestBuilder rebuildRequest(Request rb){
returnnew RequestBuilder(rb);
}
private Futureexecute(RequestBuilder rb, BodyConsumer bodyConsumer, ThrowableHandler throwableHandler)throws IOException {
if (throwableHandler == null) {
throwableHandler = defaultThrowableHandler;
}
Request request = rb.build();
ProgressAsyncHandler handler = new BodyConsumerAsyncHandler(bodyConsumer, throwableHandler, errorDocumentBehaviour,
request.getUri(), listener);
if (resumeEnabled && request.getMethod().equals("GET") && bodyConsumer != null && bodyConsumer instanceof ResumableBodyConsumer) {
ResumableBodyConsumer fileBodyConsumer = (ResumableBodyConsumer) bodyConsumer;
long length = fileBodyConsumer.getTransferredBytes();
fileBodyConsumer.resume();
handler = new ResumableBodyConsumerAsyncHandler(length, handler);
}
return getAsyncHttpClient().executeRequest(request, handler);
}
private AsyncHttpClient getAsyncHttpClient(){
synchronized (config) {
if (asyncHttpClient == null) {
asyncHttpClient = asyncHttpClient(config);
}
}
return asyncHttpClient;
}
/**
* Close the underlying AsyncHttpClient for this instance.
*
* If this instance is derived from another instance, this method does
* nothing as the client instance is managed by the original
* SimpleAsyncHttpClient.
*
* @see #derive()
* @see AsyncHttpClient#close()
*/publicvoidclose()throws IOException {
if (!derived && asyncHttpClient != null) {
asyncHttpClient.close();
}
}
/**
* Returns a Builder for a derived SimpleAsyncHttpClient that uses the same
* instance of {@link AsyncHttpClient} to execute requests.
*
* The original SimpleAsyncHttpClient is responsible for managing the
* underlying AsyncHttpClient. For the derived instance, {@link #close()} is
* a NOOP. If the original SimpleAsyncHttpClient is closed, all derived
* instances become invalid.
*
* @return a Builder for a derived SimpleAsyncHttpClient that uses the same
* instance of {@link AsyncHttpClient} to execute requests, never
* {@code null}.
*/public DerivedBuilder derive(){
returnnew Builder(this);
}
publicenum ErrorDocumentBehaviour {
/**
* Write error documents as usual via
* {@link BodyConsumer#consume(java.nio.ByteBuffer)}.
*/
WRITE,
/**
* Accumulate error documents in memory but do not consume.
*/
ACCUMULATE,
/**
* Omit error documents. An error document will neither be available in
* the response nor written via a {@link BodyConsumer}.
*/
OMIT;
}
/**
* This interface contains possible configuration changes for a derived SimpleAsyncHttpClient.
*
* @see SimpleAsyncHttpClient#derive()
*//**
* This interface contains possible configuration changes for a derived SimpleAsyncHttpClient.
*
* @see SimpleAsyncHttpClient#derive()
*/publicinterfaceDerivedBuilder{
DerivedBuilder setFollowRedirect(boolean followRedirect);
DerivedBuilder setVirtualHost(String virtualHost);
DerivedBuilder setUrl(String url);
DerivedBuilder setFormParams(List params);
DerivedBuilder setFormParams(Map> params);
DerivedBuilder setHeaders(Map> headers);
DerivedBuilder setHeaders(HttpHeaders headers);
DerivedBuilder setHeader(String name, String value);
DerivedBuilder addQueryParam(String name, String value);
DerivedBuilder addFormParam(String key, String value);
DerivedBuilder addHeader(String name, String value);
DerivedBuilder addCookie(Cookie cookie);
DerivedBuilder addBodyPart(Part part);
DerivedBuilder setResumableDownload(boolean resume);
SimpleAsyncHttpClient build();
}
publicfinalstaticclassBuilderimplementsDerivedBuilder{
privatefinal RequestBuilder requestBuilder;
privatefinal DefaultAsyncHttpClientConfig.Builder configBuilder = config();
private Realm.Builder realmBuilder = null;
private Realm.AuthScheme proxyAuthScheme;
private String proxyHost = null;
private String proxyPrincipal = null;
private String proxyPassword = null;
privateint proxyPort = 80;
private ThrowableHandler defaultThrowableHandler = null;
privateboolean enableResumableDownload = false;
private ErrorDocumentBehaviour errorDocumentBehaviour = ErrorDocumentBehaviour.WRITE;
private AsyncHttpClient ahc = null;
private SimpleAHCTransferListener listener = null;
publicBuilder(){
requestBuilder = new RequestBuilder("GET", false);
}
privateBuilder(SimpleAsyncHttpClient client){
this.requestBuilder = new RequestBuilder(client.requestBuilder.build());
this.defaultThrowableHandler = client.defaultThrowableHandler;
this.errorDocumentBehaviour = client.errorDocumentBehaviour;
this.enableResumableDownload = client.resumeEnabled;
this.ahc = client.getAsyncHttpClient();
this.listener = client.listener;
}
public Builder addBodyPart(Part part){
requestBuilder.addBodyPart(part);
returnthis;
}
public Builder addCookie(Cookie cookie){
requestBuilder.addCookie(cookie);
returnthis;
}
public Builder addHeader(String name, String value){
requestBuilder.addHeader(name, value);
returnthis;
}
public Builder addFormParam(String key, String value){
requestBuilder.addFormParam(key, value);
returnthis;
}
public Builder addQueryParam(String name, String value){
requestBuilder.addQueryParam(name, value);
returnthis;
}
public Builder setHeader(String name, String value){
requestBuilder.setHeader(name, value);
returnthis;
}
public Builder setHeaders(HttpHeaders headers){
requestBuilder.setHeaders(headers);
returnthis;
}
public Builder setHeaders(Map> headers){
requestBuilder.setHeaders(headers);
returnthis;
}
public Builder setFormParams(Map> parameters){
requestBuilder.setFormParams(parameters);
returnthis;
}
public Builder setFormParams(List params){
requestBuilder.setFormParams(params);
returnthis;
}
public Builder setUrl(String url){
requestBuilder.setUrl(url);
returnthis;
}
public Builder setVirtualHost(String virtualHost){
requestBuilder.setVirtualHost(virtualHost);
returnthis;
}
public Builder setFollowRedirect(boolean followRedirect){
requestBuilder.setFollowRedirect(followRedirect);
returnthis;
}
public Builder setMaxConnections(int defaultMaxConnections){
configBuilder.setMaxConnections(defaultMaxConnections);
returnthis;
}
public Builder setMaxConnectionsPerHost(int defaultMaxConnectionsPerHost){
configBuilder.setMaxConnectionsPerHost(defaultMaxConnectionsPerHost);
returnthis;
}
public Builder setConnectTimeout(int connectTimeuot){
configBuilder.setConnectTimeout(connectTimeuot);
returnthis;
}
public Builder setPooledConnectionIdleTimeout(int pooledConnectionIdleTimeout){
configBuilder.setPooledConnectionIdleTimeout(pooledConnectionIdleTimeout);
returnthis;
}
public Builder setRequestTimeout(int defaultRequestTimeout){
configBuilder.setRequestTimeout(defaultRequestTimeout);
returnthis;
}
public Builder setMaxRedirects(int maxRedirects){
configBuilder.setMaxRedirects(maxRedirects);
returnthis;
}
public Builder setCompressionEnforced(boolean compressionEnforced){
configBuilder.setCompressionEnforced(compressionEnforced);
returnthis;
}
public Builder setUserAgent(String userAgent){
configBuilder.setUserAgent(userAgent);
returnthis;
}
public Builder setKeepAlive(boolean allowPoolingConnections){
configBuilder.setKeepAlive(allowPoolingConnections);
returnthis;
}
public Builder setThreadFactory(ThreadFactory threadFactory){
configBuilder.setThreadFactory(threadFactory);
returnthis;
}
public Builder setSslContext(SslContext sslContext){
configBuilder.setSslContext(sslContext);
returnthis;
}
public Builder setSslEngineFactory(SslEngineFactory sslEngineFactory){
configBuilder.setSslEngineFactory(sslEngineFactory);
returnthis;
}
public Builder setRealm(Realm realm){
configBuilder.setRealm(realm);
returnthis;
}
public Builder setProxyAuthScheme(Realm.AuthScheme proxyAuthScheme){
this.proxyAuthScheme = proxyAuthScheme;
returnthis;
}
public Builder setProxyHost(String host){
this.proxyHost = host;
returnthis;
}
public Builder setProxyPrincipal(String principal){
this.proxyPrincipal = principal;
returnthis;
}
public Builder setProxyPassword(String password){
this.proxyPassword = password;
returnthis;
}
public Builder setProxyPort(int port){
this.proxyPort = port;
returnthis;
}
public Builder setDefaultThrowableHandler(ThrowableHandler throwableHandler){
this.defaultThrowableHandler = throwableHandler;
returnthis;
}
/**
* This setting controls whether an error document should be written via
* the {@link BodyConsumer} after an error status code was received (e.g.
* 404). Default is {@link ErrorDocumentBehaviour#WRITE}.
*
* @param behaviour the behaviour
* @return this
*/public Builder setErrorDocumentBehaviour(ErrorDocumentBehaviour behaviour){
this.errorDocumentBehaviour = behaviour;
returnthis;
}
/**
* Enable resumable downloads for the SimpleAHC. Resuming downloads will only work for GET requests
* with an instance of {@link ResumableBodyConsumer}.
*/@Overridepublic Builder setResumableDownload(boolean enableResumableDownload){
this.enableResumableDownload = enableResumableDownload;
returnthis;
}
/**
* Set the listener to notify about connection progress.
*
* @param listener a listener
* @return this
*/public Builder setListener(SimpleAHCTransferListener listener){
this.listener = listener;
returnthis;
}
/**
* Set the number of time a request will be retried when an {@link java.io.IOException} occurs because of a Network exception.
*
* @param maxRequestRetry the number of time a request will be retried
* @return this
*/public Builder setMaxRequestRetry(int maxRequestRetry){
configBuilder.setMaxRequestRetry(maxRequestRetry);
returnthis;
}
public Builder setAcceptAnyCertificate(boolean acceptAnyCertificate){
configBuilder.setAcceptAnyCertificate(acceptAnyCertificate);
returnthis;
}
public SimpleAsyncHttpClient build(){
if (realmBuilder != null) {
configBuilder.setRealm(realmBuilder.build());
}
if (proxyHost != null) {
Realm realm = null;
if (proxyPrincipal != null) {
AuthScheme proxyAuthScheme = withDefault(this.proxyAuthScheme, AuthScheme.BASIC);
realm = realm(proxyAuthScheme, proxyPrincipal, proxyPassword).build();
}
configBuilder.setProxyServer(proxyServer(proxyHost, proxyPort).setRealm(realm).build());
}
configBuilder.addIOExceptionFilter(new ResumableIOExceptionFilter());
SimpleAsyncHttpClient sc = new SimpleAsyncHttpClient(configBuilder.build(), requestBuilder, defaultThrowableHandler,
errorDocumentBehaviour, enableResumableDownload, ahc, listener);
return sc;
}
}
privatefinalstaticclassResumableBodyConsumerAsyncHandlerextendsResumableAsyncHandlerimplementsProgressAsyncHandler{
privatefinal ProgressAsyncHandler delegate;
publicResumableBodyConsumerAsyncHandler(long byteTransferred, ProgressAsyncHandler delegate){
super(byteTransferred, delegate);
this.delegate = delegate;
}
public AsyncHandler.State onHeadersWritten(){
return delegate.onHeadersWritten();
}
public AsyncHandler.State onContentWritten(){
return delegate.onContentWritten();
}
public AsyncHandler.State onContentWriteProgress(long amount, long current, long total){
return delegate.onContentWriteProgress(amount, current, total);
}
}
privatefinalstaticclassBodyConsumerAsyncHandlerextendsAsyncCompletionHandlerBase{
privatefinal BodyConsumer bodyConsumer;
privatefinal ThrowableHandler exceptionHandler;
privatefinal ErrorDocumentBehaviour errorDocumentBehaviour;
privatefinal Uri uri;
privatefinal SimpleAHCTransferListener listener;
privateboolean accumulateBody = false;
privateboolean omitBody = false;
privateint amount = 0;
privatelong total = -1;
publicBodyConsumerAsyncHandler(BodyConsumer bodyConsumer, ThrowableHandler exceptionHandler,
ErrorDocumentBehaviour errorDocumentBehaviour, Uri uri, SimpleAHCTransferListener listener){
this.bodyConsumer = bodyConsumer;
this.exceptionHandler = exceptionHandler;
this.errorDocumentBehaviour = errorDocumentBehaviour;
this.uri = uri;
this.listener = listener;
}
@OverridepublicvoidonThrowable(Throwable t){
try {
if (exceptionHandler != null) {
exceptionHandler.onThrowable(t);
} else {
super.onThrowable(t);
}
} finally {
closeConsumer();
}
}
/**
* {@inheritDoc}
*/public State onBodyPartReceived(final HttpResponseBodyPart content)throws Exception {
fireReceived(content);
if (omitBody) {
return State.CONTINUE;
}
if (!accumulateBody && bodyConsumer != null) {
bodyConsumer.consume(content.getBodyByteBuffer());
} else {
returnsuper.onBodyPartReceived(content);
}
return State.CONTINUE;
}
/**
* {@inheritDoc}
*/@Overridepublic Response onCompleted(Response response)throws Exception {
fireCompleted(response);
closeConsumer();
returnsuper.onCompleted(response);
}
privatevoidcloseConsumer(){
if (bodyConsumer != null)
closeSilently(bodyConsumer);
}
@Overridepublic State onStatusReceived(HttpResponseStatus status)throws Exception {
fireStatus(status);
if (isErrorStatus(status)) {
switch (errorDocumentBehaviour) {
case ACCUMULATE:
accumulateBody = true;
break;
case OMIT:
omitBody = true;
break;
default:
break;
}
}
returnsuper.onStatusReceived(status);
}
privatebooleanisErrorStatus(HttpResponseStatus status){
return status.getStatusCode() >= 400;
}
@Overridepublic State onHeadersReceived(HttpResponseHeaders headers)throws Exception {
calculateTotal(headers);
fireHeaders(headers);
returnsuper.onHeadersReceived(headers);
}
privatevoidcalculateTotal(HttpResponseHeaders headers){
String length = headers.getHeaders().get(HttpHeaders.Names.CONTENT_LENGTH);
try {
total = Integer.valueOf(length);
} catch (Exception e) {
total = -1;
}
}
@Overridepublic State onContentWriteProgress(long amount, long current, long total){
fireSent(uri, amount, current, total);
returnsuper.onContentWriteProgress(amount, current, total);
}
privatevoidfireStatus(HttpResponseStatus status){
if (listener != null) {
listener.onStatus(uri, status.getStatusCode(), status.getStatusText());
}
}
privatevoidfireReceived(HttpResponseBodyPart content){
int remaining = content.getBodyByteBuffer().remaining();
amount += remaining;
if (listener != null) {
listener.onBytesReceived(uri, amount, remaining, total);
}
}
privatevoidfireHeaders(HttpResponseHeaders headers){
if (listener != null) {
listener.onHeaders(uri, headers.getHeaders());
}
}
privatevoidfireSent(Uri uri, long amount, long current, long total){
if (listener != null) {
listener.onBytesSent(uri, amount, current, total);
}
}
privatevoidfireCompleted(Response response){
if (listener != null) {
listener.onCompleted(uri, response.getStatusCode(), response.getStatusText());
}
}
}
}