public class FileUploadEntity {
private static final String TAG = FileUploadEntity.class.getSimpleName();
private static final String BOUNDARY ="__FILE_UPLOAD_ENTITY__";
private ByteArrayOutputStream mOutputStream;
public static HashMap<String,String> hashMap =new HashMap<>();
static {
hashMap.put("png" ,"image/png" );
hashMap.put("gif" ,"image/gif" );
hashMap.put("jpg" ,"image/jpeg" );
hashMap.put("jpeg" ,"image/jpeg" );
hashMap.put("bmp" ,"image/bmp" );
}
public FileUploadEntity() {
mOutputStream =new ByteArrayOutputStream();
try {
writeFirstBoundary();
}catch (IOException e) {
e.printStackTrace();
}
}
private void writeFirstBoundary()throws IOException {
VolleyLog.e("writeFirstBoundary");
mOutputStream.write(("--" + BOUNDARY +"\r\n").getBytes());
mOutputStream.write(("Content-Disposition: form-data; name=\"" +"name" +"\"\r\n\r\n").getBytes());
mOutputStream.write("Content-Transfer-Encoding: binary\n\n".getBytes());
mOutputStream.flush();
}
private void writeLastBoundary()throws IOException {
VolleyLog.e("writeLastBoundary");
mOutputStream.write(("\r\n--" + BOUNDARY +"--\r\n").getBytes());
}
/**
* 获取文件扩展名
* @return
*/
public static String ext(String filename) {
int index = filename.lastIndexOf(".");
if (index == -1) {
return null;
}
String result = filename.substring(index + 1);
return result;
}
public void addFile(final String key,final File file) {
VolleyLog.e("addFile");
InputStream inputStream =null;
try {
mOutputStream.write(("\r\n--" + BOUNDARY +"\r\n").getBytes());
StringBuilder stringBuilderContentDisposition =new StringBuilder();
stringBuilderContentDisposition.append("Content-Disposition: ");
stringBuilderContentDisposition.append("form-data; ");
stringBuilderContentDisposition.append("name=\"" + key +"\"; ");
String fileName = file.getName();
if(!TextUtils.isEmpty(ContextUtils.getGameId())){
fileName = ContextUtils.getGameId()+"_"+System.currentTimeMillis()+"."+ext(file.getName());
}
stringBuilderContentDisposition.append("filename=\"" + fileName +"\"\r\n");
mOutputStream.write(stringBuilderContentDisposition.toString().getBytes());
StringBuilder stringBuilderContentType =new StringBuilder();
stringBuilderContentType.append("Content-Type: ");
stringBuilderContentType.append(hashMap.get(ext(file.getName()).toLowerCase()));//"image/png"
stringBuilderContentType.append("\r\n\r\n");
mOutputStream.write(stringBuilderContentType.toString().getBytes());
inputStream =new FileInputStream(file);
final byte[] buffer =new byte[1024];
int len =0;
while ((len = inputStream.read(buffer)) != -1) {
mOutputStream.write(buffer,0, len);
}
VolleyLog.e("===last====len --> %s", String.valueOf(len));
mOutputStream.flush();
}catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}finally {
closeSilently(inputStream);
}
}
private void closeSilently(Closeable closeable) {
try {
if (closeable !=null) {
closeable.close();
}
}catch (final IOException e) {
e.printStackTrace();
}
}
public boolean isRepeatable() {
return false;
}
public boolean isChunked() {
return false;
}
public long getContentLength() {
return mOutputStream.toByteArray().length;
}
public Header getContentType() {
return new Header("Content-Type","multipart/form-data; boundary=" + BOUNDARY);
}
public Header getContentEncoding() {
return null;
}
public InputStream getContent()throws IOException, UnsupportedOperationException {
return new ByteArrayInputStream(mOutputStream.toByteArray());
}
public void writeTo(OutputStream outputStream)throws IOException {
writeLastBoundary();
outputStream.write(mOutputStream.toByteArray());
}
public boolean isStreaming() {
return false;
}
public void consumeContent()throws IOException {
}
}
public class FileUploadRequest extends Request<JSONObject> {
private final Response.Listener<JSONObject> mListener;
private FileUploadEntity mFileUploadEntity = new FileUploadEntity();
private Map<String, String> mHeaders = new HashMap<>();
private long requestStartTs =0;
public FileUploadRequest(String url, Response.Listener<JSONObject> listener, Response.ErrorListener errorListener) {
this(Method.POST, url, listener, errorListener);
requestStartTs = System.currentTimeMillis();
setRetryPolicy(new DefaultRetryPolicy(
10000,
DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
}
public FileUploadRequest(int method, String url, Response.Listener<JSONObject> listener, Response.ErrorListener errorListener) {
super(method, url, errorListener);
requestStartTs = System.currentTimeMillis();
this.mListener = listener;
setRetryPolicy(new DefaultRetryPolicy(
20000,
DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
}
public void setAuth(String auth) {
mHeaders.put("Authorization", auth);
}
public FileUploadEntity getFileUploadEntity() {
return mFileUploadEntity;
}
@Override
public String getBodyContentType() {
return mFileUploadEntity.getContentType().getValue();
}
public void addHeader(String key, String value) {
mHeaders.put(key, value);
}
@Override
public Map<String, String> getHeaders() throws AuthFailureError {
return mHeaders;
}
@Override
public byte[] getBody() throws AuthFailureError {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try {
mFileUploadEntity.writeTo(outputStream);
} catch (IOException e) {
e.printStackTrace();
}
return outputStream.toByteArray();
}
@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
String parsed = "";
try {
parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
LogUtil.terminal(LogUtil.LogType.d, null, CGJsonRequest.class.getSimpleName()
, String.format("report original data:%s", TextUtils.isEmpty(parsed) ? "null" : parsed));
return Response.success(new JSONObject(parsed), HttpHeaderParser.parseCacheHeaders(response));
} catch (JSONException | UnsupportedEncodingException e) {
e.printStackTrace();
return Response.error(new ParseError(e));
}
}
@Override
protected void deliverResponse(JSONObject response) {
if (mListener != null) {
mListener.onResponse(response);
}
}
}
