/*
* Android Asynchronous Http Client Copyright (c) 2011 James Smith <james@loopj.com>
* http://loopj.com
*
* 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 com.letv.commonjar.http;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.HttpResponseException;
import org.apache.http.util.ByteArrayBuffer;
import com.letv.commonjar.CLog;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
public abstract class HttpJsonCallBack implements ResponseInterface {
private static final String TAG = CLog.makeTag(HttpJsonCallBack.class);
protected static final int SUCCESS_MESSAGE = 0;
protected static final int FAILURE_MESSAGE = 1;
protected static final int START_MESSAGE = 2;
protected static final int FINISH_MESSAGE = 3;
protected static final int PROGRESS_MESSAGE = 4;
protected static final int RETRY_MESSAGE = 5;
protected static final int BUFFER_SIZE = 4096;
public static final String DEFAULT_CHARSET = "UTF-8";
private String responseCharset = DEFAULT_CHARSET;
private Boolean useSynchronousMode = false;
private URI requestURI = null;
private Header[] requestHeaders = null;
public abstract void onSuccess(byte[] json);
public abstract void onFailure(int errorCode, Throwable e);
@Override
public URI getRequestURI() {
return this.requestURI;
}
@Override
public Header[] getRequestHeaders() {
return this.requestHeaders;
}
@Override
public void setRequestURI(URI requestURI) {
this.requestURI = requestURI;
}
@Override
public void setRequestHeaders(Header[] requestHeaders) {
this.requestHeaders = requestHeaders;
}
@Override
public boolean getUseSynchronousMode() {
return useSynchronousMode;
}
@Override
public void setUseSynchronousMode(boolean value) {
useSynchronousMode = value;
}
/**
* Sets the charset for the response string. If not set, the default is UTF-8.
*
* @param charset to be used for the response string.
* @see <a
* href="http://docs.oracle.com/javase/7/docs/api/java/nio/charset/Charset.html">Charset</a>
*/
public void setCharset(final String charset) {
this.responseCharset = charset;
}
public String getCharset() {
return this.responseCharset == null ? DEFAULT_CHARSET : this.responseCharset;
}
/**
* Fired when the request progress, override to handle in your own code
*
* @param bytesWritten offset from start of file
* @param totalSize total size of file
*/
public void onProgress(int bytesWritten, int totalSize) {
CLog.d(TAG, String.format("Progress %d from %d (%d)", bytesWritten, totalSize, bytesWritten / (totalSize / 100)));
}
/**
* Fired when the request is started, override to handle in your own code
*/
public void onStart() {}
/**
* Fired in all cases when the request is finished, after both success and failure, override to
* handle in your own code
*/
public void onFinish() {}
@Override
public void handlerResponse(HttpResponse response) throws IOException {
if (!Thread.currentThread().isInterrupted()) {
StatusLine status = response.getStatusLine();
byte[] responseBody;
responseBody = getResponseData(response.getEntity());
if (!Thread.currentThread().isInterrupted()) {
if (status.getStatusCode() >= 300) {
onFailure(status.getStatusCode(), new HttpResponseException(status.getStatusCode(), status.getReasonPhrase()));
} else {
onSuccess(responseBody);
}
}
}
}
@Override
public void handlerError(Integer code, Throwable e) {
onFailure(code, e);
}
public void onRetryCount(int retryNo) {
CLog.d(TAG, String.format("Request retry no. %d", retryNo));
}
/**
*
* @param entity
* @return
* @throws IOException
*/
byte[] getResponseData(HttpEntity entity) throws IOException {
byte[] responseBody = null;
if (entity != null) {
InputStream instream = entity.getContent();
if (instream != null) {
long contentLength = entity.getContentLength();
if (contentLength > Integer.MAX_VALUE) {
throw new IllegalArgumentException("HTTP entity too large to be buffered in memory");
}
if (contentLength < 0) {
contentLength = BUFFER_SIZE;
}
try {
ByteArrayBuffer buffer = new ByteArrayBuffer((int) contentLength);
try {
byte[] tmp = new byte[BUFFER_SIZE];
int l, count = 0;
// do not send messages if request has been cancelled
while ((l = instream.read(tmp)) != -1 && !Thread.currentThread().isInterrupted()) {
count += l;
buffer.append(tmp, 0, l);
onProgress(count, (int) contentLength);
}
} finally {
instream.close();
}
responseBody = buffer.toByteArray();
} catch (OutOfMemoryError e) {
System.gc();
throw new IOException("File too large to fit into available memory");
}
}
}
return responseBody;
}
}