Retrofit上传多张图片到服务器,并带进度条显示

Retrofit上传多张图片到服务器

Api接口:

public class API {

    private static RetrofitAPI retrofitAPI;
    private static OkHttpClient okHttpClient;

    static {
        okHttpClient =
                ProgressManager.getInstance().with(new OkHttpClient().newBuilder())
                .connectTimeout(300, TimeUnit.SECONDS)//设置超时时间
                .readTimeout(300, TimeUnit.SECONDS)//设置读取超时时间
                .writeTimeout(300, TimeUnit.SECONDS)//设置写入超时时间
                //.addInterceptor(new LogInterceptor())//拦截器
                .retryOnConnectionFailure(true)

                .build();
    }

    public static RetrofitAPI Retrofit() {
        if (retrofitAPI == null) {
            retrofitAPI = new Retrofit.Builder()
                    .baseUrl("http://61.144.121.138:8090/UpData/")
                    .addConverterFactory(StringConverterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .client(okHttpClient)
                    .build()
                    .create(RetrofitAPI.class);
        }
        return retrofitAPI;
    }

    public interface RetrofitAPI {

        //图片上传
        @Multipart
        @POST("ReceiveImg.aspx")
        Call<ResultBean.DataBean.FileUploadBean> updateImage(@PartMap Map<String, RequestBody> params);

        @Multipart
        @POST("ReceiveImg.aspx")
        Observable<ResponseBody> uploadFileInfo(@QueryMap Map<String, String> options,
                                                @PartMap Map<String, RequestBody> Parameters) ;


    }

    public interface ProgressListener {
        void onProgress(long hasWrittenLen, long totalLen, boolean hasFinish);
    }

}

public class UploadFileRequestBody extends RequestBody {

    private RequestBody mRequestBody;
    private API.ProgressListener mProgressListener;

    private BufferedSink bufferedSink;


    public UploadFileRequestBody(File file , API.ProgressListener progressListener) {
        this.mRequestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file) ;
        this.mProgressListener = progressListener ;
    }


    public UploadFileRequestBody(RequestBody requestBody, API.ProgressListener progressListener) {
        this.mRequestBody = requestBody;
        this.mProgressListener = progressListener;
    }



    //返回了requestBody的类型，像什么form-data/MP3/MP4/png等等等格式
    @Override
    public MediaType contentType() {
        return mRequestBody.contentType();
    }

    //返回了本RequestBody的长度，也就是上传的totalLength
    @Override
    public long contentLength() throws IOException {
        return mRequestBody.contentLength();
    }

    @Override
    public void writeTo(BufferedSink sink) throws IOException {
        if (bufferedSink == null) {
            //包装
            bufferedSink = Okio.buffer(sink(sink));
        }
        //写入
        mRequestBody.writeTo(bufferedSink);
        //必须调用flush，否则最后一部分数据可能不会被写入
        bufferedSink.flush();
    }

    private Sink sink(Sink sink) {
        return new ForwardingSink(sink) {
            //当前写入字节数
            long bytesWritten = 0L;
            //总字节长度，避免多次调用contentLength()方法
            long contentLength = 0L;

            @Override
            public void write(Buffer source, long byteCount) throws IOException {
                super.write(source, byteCount);
                if (contentLength == 0) {
                    //获得contentLength的值，后续不再调用
                    contentLength = contentLength();
                }
                //增加当前写入的字节数
                bytesWritten += byteCount;
                //回调
                mProgressListener.onProgress(bytesWritten, contentLength, bytesWritten == contentLength);
            }
        };
    }
}

/**
 * Created by hl
 */
public class DefaultProgressListener implements API.ProgressListener {

    private Handler mHandler;
    //多文件上传时，index作为上传的位置的标志
    private int mIndex;
    private MainMVP.IExportView exportView;

    public DefaultProgressListener(Handler mHandler, int mIndex) {
        this.mHandler = mHandler;
        this.mIndex = mIndex;
    }

    @Override
    public void onProgress(long hasWrittenLen, long totalLen, boolean hasFinish) {
//        Log.d("DDDBBB",
//                "----上传中 ----hasWrittenLen(写入的长度)=" + hasWrittenLen +
//                ",----totalLen(总长度)=" + totalLen +
//                ",-----hasFinish(上传进度)=" + (hasWrittenLen * 100 / totalLen));

        int percent = (int) (hasWrittenLen * 100 / totalLen);
        if (percent > 100) percent = 100;
        if (percent < 0) percent = 0;


        Message msg = Message.obtain();
        msg.what = percent;
        msg.arg1 = mIndex;
        mHandler.sendMessage(msg);

    }
}

调用:

 private void rxupimg(){
        mImagePaths = PathUtils.getImagePaths(context);
        final String IMEI = DeviceUtil.getDeviceId(context);
        final String uinStr = String.valueOf(SharedPerfUtil.getUin(context));

        if (mImagePaths != null && mImagePaths.size() > 0) {
            for (int i = 0; i <mImagePaths.size() ; i++) {
                Map<String, String> optionMap = new HashMap<>();
                optionMap.put("IMEI", IMEI);
                optionMap.put("uin",uinStr) ;
                Map<String, RequestBody> requestBodyMap = new HashMap<>();
                UploadFileRequestBody fileRequestBody = new UploadFileRequestBody(new File(mImagePaths.get(i)), new DefaultProgressListener(mHandler,1));
                requestBodyMap.put(FileUtil.getFileNameNoExtension(mImagePaths.get(i)), fileRequestBody);
                API.Retrofit().
                        uploadFileInfo(optionMap, requestBodyMap).
                        subscribeOn(Schedulers.io()).
                        observeOn(AndroidSchedulers.mainThread()).
                        subscribe(new Subscriber<ResponseBody>() {
                            @Override
                            public void onCompleted() {

                                //单个上传结束
                            }

                            @Override
                            public void onError(Throwable e) {
                                Log.d(TAG,"---上传失败 ---" + e);
                            }

                            @Override
                            public void onNext(ResponseBody s) {
                                try {
                                    String response = s.string();
                                if (response.equals("error")){
                                   String exportDir = PathUtils.getExportDir();
                                  FileUtil.copyFile(file,new File(exportDir+"2"));
                                 Log.d(TAG,file.getName()+"++++++");
                                }
                                    Log.d(TAG,"---上传完成 --" + response +"*******");
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }

                        });
            }
        }

    }

@SuppressLint("HandlerLeak")
private Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.arg1) {
            case 1:
                if (msg.what > 0) {
                  //  exportView.setProgress(msg.what);
                    return;
                }
                break;
        }
    }
};