一，先来看下okhttp文件上传的写法

File file = new File(Environment.getExternalStorageDirectory(), "hahah.rar");
OkHttpClient httpClient = new OkHttpClient();

// 构建请求 Body , 这个我们之前自己动手写过
MultipartBody.Builder builder = new MultipartBody.Builder()
                .setType(MultipartBody.FORM);
builder.addFormDataPart("platform", "android");
builder.addFormDataPart("file", 
                        file.getName(),
                        RequestBody.create(
                               MediaType.parse(
                               guessMimeType(file.getAbsolutePath())), file));
 
  
 // 构建一个请求
 final Request request = new Request.Builder()
                .url(url)
                .post(builder.build()).build();

okhttp没有提供有文件总大小和实时上传大小的回调，所以无法进行进度监听。
二，思路
文件上传的原理就是讲二进制通过网络输出流写入服务器，那如果找到了是谁操作输出流的，就能知道文件大小和每次写入输出流的大小，就知道进度了。
实际上，是MultipartBody执行了这个动作。
所以我们通过静态代理的方式来加强MultipartBody的写入功能，使其支持进度监听。

File file = new File(Environment.getExternalStorageDirectory(), "hahah.rar");
        OkHttpClient httpClient = new OkHttpClient();
        // 构建请求 Body , 这个我们之前自己动手写过
        MultipartBody.Builder builder = new MultipartBody.Builder()
                .setType(MultipartBody.FORM);
        builder.addFormDataPart("platform", "android");
        builder.addFormDataPart("file", file.getName(),
                RequestBody.create(MediaType.parse(guessMimeType(file.getAbsolutePath())), file));
 
        // 这是使用了加强的MultipartBody,通过代理该类的输出流操作，
        // 获取流的总大小和每次写入的大小
        ExMultipartBody exMultipartBody = new ExMultipartBody(builder.build()
                ,new UploadProgressListener(){
 
            @Override
            public void onProgress(long total, long current) {
                showToast(total,current);
            }
        });
 
        // 怎么监听上传文件的进度？
 
        // 构建一个请求
        final Request request = new Request.Builder()
                .url(url)
                .post(exMultipartBody).build();

ExMultipartBody本质上是一个RequestBody的静态代理。

import android.support.annotation.Nullable;
import android.util.Log;

import java.io.IOException;

import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import okio.Buffer;
import okio.BufferedSink;
import okio.ForwardingSink;
import okio.Okio;

public class ExMultipartBody extends RequestBody {
   private RequestBody mRequestBody;
   private int mCurrentLength;
   private UploadProgressListener mProgressListener;

   public ExMultipartBody(MultipartBody requestBody) {
       this.mRequestBody = requestBody;
   }

   public ExMultipartBody(MultipartBody requestBody, UploadProgressListener progressListener) {
       this.mRequestBody = requestBody;
       this.mProgressListener = progressListener;
   }

   @Nullable
   @Override
   public MediaType contentType() {
       // 静态代理最终还是调用的代理对象的方法
       return mRequestBody.contentType();
   }

   @Override
   public long contentLength() throws IOException {
       return mRequestBody.contentLength();
   }

   @Override
   public void writeTo(BufferedSink sink) throws IOException {
       Log.e("TAG","监听");
       // 总的长度
       final long contentLength = contentLength();
       // 获取当前写了多少数据？BufferedSink Sink(okio 就是 io )就是一个 服务器的 输出流，我还是不知道写了多少数据

       // 又来一个代理 ForwardingSink
       ForwardingSink forwardingSink = new ForwardingSink(sink) {
           @Override
           public void write(Buffer source, long byteCount) throws IOException {
               // 每次写都会来这里
               mCurrentLength += byteCount;
               if(mProgressListener!=null){
                   mProgressListener.onProgress(contentLength,mCurrentLength);
               }
               Log.e("TAG",contentLength+" : "+mCurrentLength);
               super.write(source, byteCount);
           }
       };
       // 转一把
       BufferedSink bufferedSink = Okio.buffer(forwardingSink);
       mRequestBody.writeTo(bufferedSink);
       // 刷新，RealConnection 连接池
       bufferedSink.flush();
   }
}

重点是writeTo方法，这个方法里面拿到了一，文件总长度；二，实时写入长度