Retrofit2.0实现文件批量上传监听进度的一种蠢办法

最近项目需要做文件批量上传的进度监听,这也就是一个常见的需求。但是项目中用的是Retrofit,官方并没有提供此类的API,于是只能Google啦。找了一圈,资源很少,仅仅找到了几篇单文件上传的进度监听,不能直接ctrl+c ctrl+v啦,只有自己用笨办法,稍微封装一下。

PS:本人习惯在代码中分析,总结性的文字很少。

由于没有测试接口,于是就使用项目中的上传接口。先贴一张最终实现的效果图。

凑活看看吧

以上是公司的项目录的gif,录的不太流畅,信息都是事先填好的,凑活看看吧。由于是内部使用的app,所以界面是真的丑啊。。。

废话说太多了,正式开始吧。

批量上传


从效果图可以看到,客户签字完毕后,取车成功就是上传操作了。需求是要将之前所有信息全部上传到服务器,包含了文字和大量的图片(所有字段都填满,最多可以达到上百张)。关于Retrofit的批量上传,我使用的是Multipart,具体使用请自行百度Google,这里简要贴一下代码。

先贴出Api接口代码,info字段为将所有文字参数封装成的json串上传:

//上传取车信息
    @Multipart
    @POST("reportgetcarlisttoservice.tag")
    Observable uploadGetCarData(@Part("info") RequestBody info,                                           
                                               @PartMap Map imgs);

(上传部分代码较长,筛选了关键部分的代码贴出来)

public void upload() {
      //检测上传参数完整性  略
      ...

      //开启一个线程   由于涉及大量图片的信息,压缩等耗时操作,开启一个线程处理是必须的
      new Thread(() -> {
            //文字参数
            UploadGetCarDataRequest request = new UploadGetCarDataRequest();
            request.orderkey = Session.currentOrderKey;
            if (Integer.parseInt(Session.currentOrderStatus) >= 33 && Integer.parseInt(Session.currentOrderStatus) != 34) {
                request.orderstate = Integer.parseInt(Session.currentOrderStatus);
            } else {
                request.orderstate = 33;
            }
            request.sgwxsm = spotData.getWeixiushuoming();
            request.fsgwxsm = spotData.getFeiweixiushuoming();
            ...
            request.remark = otherData.getBeizhu();
            request.deleteimages = updateGetCarInfo.getDelete_imgs();

            //使用Map存储RequestBody,打包上传图片
            Map bodyMap = new HashMap<>();

            //判断图片若以http开头,则表示服务器图片(已经上传过),则不必上传,反之本地图片压缩后上传
            if (!spotData.getMenpai().startsWith("http")) {
                if (!new File(spotData.getMenpai()).exists()) {
                    Message m = Message.obtain();
                    m.what = 3;
                    m.obj = "接车门牌地址照片有问题,请检查";
                    mHandler.sendMessage(m);
                    return;
                }
                //checkFile方法为检验图片大小,若大于200k,则压缩到200k以下,节省上传流量和时间
                File menpai = checkFile(new File(spotData.getMenpai()));
                bodyMap.put("0" + "-0-0\";filename=\"" + menpai.getName(), new UploadFileRequestBody(RequestBody.create(MediaType.parse("image/png"), menpai), mProgressListener, Constant.GET_MEN_PAI + ""));
                totalLength += menpai.length();
            }
            ...

              mSubscription = GoldKeyRetrofit.getDefaultRetrofit(mContext)
                    .create(GoldKeyService.class)
                     //文字参数转换成json串上传,RequestFactory是我自己封装的将Request转换为json的类
                    .uploadGetCarData(RequestBody.create(MediaType.parse("application/json"), RequestFactory.getInstance().getParams(request)), bodyMap)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Observer() {
                        @Override
                        public void onCompleted() {
                        }

                        @Override
                        public void onError(Throwable e) {
                            mView.showToast("上传失败,请检查网络是否通畅");
                            mView.showUploadProgress(0, ProgressView.STATE_FAILURE);
                            isFinish = true;
                        }

                        @Override
                        public void onNext(CheckBaseBean checkBaseBean) {
                            if (checkBaseBean.sign) {
                                mView.showToast("上传成功");
                                mView.showUploadProgress(100, ProgressView.STATE_SUCCESS);
                                mHandler.sendEmptyMessageDelayed(2, 2000);
                                isFinish = true;
                                clearDB();
                                clearCache();
//                                mView.backToMain();
                            } else {
                                mView.showUploadProgress(0, ProgressView.STATE_FAILURE);
                                mView.showToast("上传失败,请反馈给开发人员,谢谢");
                                isFinish = true;
                            }
                        }
                    });
        }).start();
      }
}

批量上传就先说到这里,其实讲了等于没讲,不懂的依然是不懂,哈哈。

上传进度监听


仔细说一下这一块。
以前做上传的时候,用的是Xutils框架,其提供了上传和下载的进度监听,而强大的Retrofit居然没有提供相关的Api,好蛋疼。
百度了一下相关的资料,发现大多数都是模仿Retrofit官方提供的ChunkingConverter,写一个转换器来监听进度。刚开始我也是采用这种思路,想通过封装一个Converter来监听多文件上传的进度。但是开发过程中碰到了几个坑。首先,添加转换器是通过Retrofit.Builder创建Retrofit实例时添加的,而这个实例我们通常使用的是单例,其他接口又没必要添加这个转换器,所以要使用上传监听必须重新new一个Retrofit实例,很麻烦。第二,Converter只能拿到单个RequestBody的数据,但是要实现多文件的监听,很麻烦。第三,大姨夫来了,很烦。
于是换个思路,既然converter是通过监听RequestBody获取其已写的字节,那么我们为什么不直接封装一个RequsetBody,直接返回这些数据呢?
首先,先定义一个回调接口:

public interface ProgressListener {
    //要是单文件上传,就不必再根据字节去计算了,直接在requestbody中计算好进度直接返回
    void onProgress(int progress, String tag);
    //处理多文件时,需要获取每个文件的即时上传量来计算整体的进度
    void onDetailProgress(long written, long total, String tag);
}

先贴出自己封装的UploadFileRequestBody:

public class UploadFileRequestBody extends RequestBody {

    private RequestBody mRequestBody;
    private ProgressListener mProgressListener;

    private BufferedSink bufferedSink;

    //每个RequestBody对应一个tag,存放在map中,保证计算的时候不会出现重复
    private String tag;

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

    //其实只是添加一个回调和tag标识,实际起作用的还是requestBody
    public UploadFileRequestBody(RequestBody requestBody, ProgressListener progressListener, String tag) {
        this.mRequestBody = requestBody;
        this.mProgressListener = progressListener;
        this.tag = tag;
    }

    //返回了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((int) ((double) bytesWritten / (double) contentLength) * 100, tag);
                mProgressListener.onDetailProgress(bytesWritten, contentLength, tag);
            }
        };
    }
}

在上传过程中,我们可以通过ProgressListener接口实时拿到每个RequestBody上传的字节数。我们的需求是计算出所有文件上传的总进度。其实就是要计算出 (所有文件已上传的大小)/(所有文件的累加大小)。分母上文件总大小我们可以在创建RequestBody时,使用一个long变量,将每个file.length()累加,即可得到。分子上的已上传大小是要由回调中的bytesWritten参数统计而得。我们使用一个Map来记录每个文件的上传大小,通过标识tag来区分每个文件:

private Map mProgresses2 = new HashMap<>();

private void upload(){
      ...
      File menpai = checkFile(new File(spotData.getMenpai()));
      //创建UploadFileRequestBody对象,传入tag(保证不同)
      bodyMap.put("0" + "-0-0\";filename=\"" + menpai.getName(), new UploadFileRequestBody(RequestBody.create(MediaType.parse("image/png"), menpai), mProgressListener, Constant.GET_MEN_PAI + ""));
      //totalLength记录文件总大小 (记得在每次执行上传时,重置为0L)
      totalLength += menpai.length();
      ...
}

由于进度回调处理方式是可以统一处理的,所以所有的RequestBody都使用同一个mProgressListener:

mProgressListener = new ProgressListener() {
            @Override
            public void onProgress(int progress, String tag) {
            }

            @Override
            public void onDetailProgress(long written, long total, String tag) {
                //回调做的唯一事情就是实时更新这个Map
                mProgresses2.put(tag, written);
            }
        };

我们遍历整个map,累加所有的value值,便是当前所有的上传大小了,即拿到了最终要得到的上传进度。接下来要做的就是更新UI,显示这个进度了,我们可以开启一个线程循环更新,也可以通过handler。我这里采用的是handler:

private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            //isFinish是一个非常关键的标记位,记录是否还需要发送消息(在取消上传,或者上传成功失败后,置为true),若没有这个标记位,将在后台无限执行handleMessage。
            if (msg.what == 1 && !isFinish) {

                //统计已上传的大小
                long sum = 0;
                for (long p : mProgresses2.values()) {
                    sum += p;
                }

                //计算整体的进度   注意这里涉及到两个long类型相除的问题,若不先转换为float类型,则商为0   去尾操作保证了99.9%属于并没有上传完成的范畴
                int p = 0;
                if (totalLength != 0) {
                    p = (int) Math.floor((float) sum / (float) totalLength * 100);
                }
                //通知View层更新ProgressView的状态(自定义的一个进度View)  
                mView.showUploadProgress(p, ProgressView.STATE_LOADING);
                //每0.1秒更新一次UI
                mHandler.sendEmptyMessageDelayed(1, 100);
            } else if (msg.what == 2) {
                //what=2代表上传成功后  延迟两秒自动回到主页的操作
                isFinish = true;
                mView.dismissDialog();
                mView.backToMain();
            } else if (msg.what == 3) {
                //what=3为检查出图片有误,取消上传的操作
                mView.showToast(msg.obj.toString());
                mView.showUploadProgress(0, ProgressView.STATE_FAILURE);
                isFinish = true;
                //取消订阅方法  即取消上传请求
                unSubscribe();
            }
        }
    };

    @Override
    public void unSubscribe() {
        if (mSubscription != null) {
            if (!mSubscription.isUnsubscribed()) {
                mSubscription.unsubscribe();
                isFinish = true;
            }
        } else {
            canStart = false;
            isFinish = true;
        }
    }

上传成功的即onNext回调只要执行上传成功的操作:

@Override
                        public void onNext(CheckBaseBean checkBaseBean) {
                            //sign服务器返回的状态值true为成功
                            if (checkBaseBean.sign) {
                                mView.showToast("上传成功");
                                mView.showUploadProgress(100, ProgressView.STATE_SUCCESS);
                                //延迟两秒后回调主页
                                mHandler.sendEmptyMessageDelayed(2, 2000);
                                //操作已完成  无需更新UI  isFinish置为true
                                isFinish = true;
                                //上传成功后清除本地数据库缓存
                                clearDB();
                                clearCache();
//                                mView.backToMain();
                            } else {
                                mView.showUploadProgress(0, ProgressView.STATE_FAILURE);
                                mView.showToast("上传失败,请反馈给开发人员,谢谢");
                                isFinish = true;
                            }
                        }

小结

本人不善表达,水平也很臭,大家见谅。由于工作忙,难以挤出时间择代码,直接使用项目中的代码,因此代码很臃肿,并不能简洁地展示具体过程。本文仅仅提供一个思路,具体的实现相信大家都能自己将其封装到自己的项目中,毕竟每个项目的需求不同,实现方式也会有差异。

谢谢阅读,请自行左上返回或右上关闭。

你可能感兴趣的:(Retrofit2.0实现文件批量上传监听进度的一种蠢办法)