title: Tracking progress of multipart file upload using OKHTTP
body: <p>I am trying to implement a a progress bar to indicate the progress of a multipart file upload.</p>
  
  <p>I have read from a comment on this answer - <a href="https://stackoverflow.com/a/24285633/1022454">https://stackoverflow.com/a/24285633/1022454</a> that I have to wrap the sink passed to the RequestBody and provide a callback that tracks the bytes moved. </p>
  
  <p>I have created a custom RequestBody and wrapped the sink with a CustomSink class, however through debugging I can see that the bytes are being written by <a href="https://github.com/square/okio/blob/master/okio/src/main/java/okio/RealBufferedSink.java" rel="noreferrer">RealBufferedSink</a> ln 44 and the custom sink write method is only run once, not allowing me to track the bytes moved.</p>
  
  <pre><code>    private class CustomRequestBody extends RequestBody {
  
      MediaType contentType;
      byte[] content;
  
      private CustomRequestBody(final MediaType contentType, final byte[] content) {
          this.contentType = contentType;
          this.content = content;
      }
  
      @Override
      public MediaType contentType() {
          return contentType;
      }
  
      @Override
      public long contentLength() {
          return content.length;
      }
  
      @Override
      public void writeTo(BufferedSink sink) throws IOException {
          CustomSink customSink = new CustomSink(sink);
          customSink.write(content);
  
      }
  }
  
  
  private class CustomSink implements BufferedSink {
  
      private static final String TAG = "CUSTOM_SINK";
  
      BufferedSink bufferedSink;
  
      private CustomSink(BufferedSink bufferedSink) {
          this.bufferedSink = bufferedSink;
      }
  
      @Override
      public void write(Buffer source, long byteCount) throws IOException {
          Log.d(TAG, "source size: " + source.size() + " bytecount" + byteCount);
          bufferedSink.write(source, byteCount);
      }
  
      @Override
      public void flush() throws IOException {
          bufferedSink.flush();
      }
  
      @Override
      public Timeout timeout() {
          return bufferedSink.timeout();
      }
  
      @Override
      public void close() throws IOException {
          bufferedSink.close();
      }
  
      @Override
      public Buffer buffer() {
          return bufferedSink.buffer();
      }
  
      @Override
      public BufferedSink write(ByteString byteString) throws IOException {
          return bufferedSink.write(byteString);
      }
  
      @Override
      public BufferedSink write(byte[] source) throws IOException {
          return bufferedSink.write(source);
      }
  
      @Override
      public BufferedSink write(byte[] source, int offset, int byteCount) throws IOException {
          return bufferedSink.write(source, offset, byteCount);
      }
  
      @Override
      public long writeAll(Source source) throws IOException {
          return bufferedSink.writeAll(source);
      }
  
      @Override
      public BufferedSink writeUtf8(String string) throws IOException {
          return bufferedSink.writeUtf8(string);
      }
  
      @Override
      public BufferedSink writeString(String string, Charset charset) throws IOException {
          return bufferedSink.writeString(string, charset);
      }
  
      @Override
      public BufferedSink writeByte(int b) throws IOException {
          return bufferedSink.writeByte(b);
      }
  
      @Override
      public BufferedSink writeShort(int s) throws IOException {
          return bufferedSink.writeShort(s);
      }
  
      @Override
      public BufferedSink writeShortLe(int s) throws IOException {
          return bufferedSink.writeShortLe(s);
      }
  
      @Override
      public BufferedSink writeInt(int i) throws IOException {
          return bufferedSink.writeInt(i);
      }
  
      @Override
      public BufferedSink writeIntLe(int i) throws IOException {
          return bufferedSink.writeIntLe(i);
      }
  
      @Override
      public BufferedSink writeLong(long v) throws IOException {
          return bufferedSink.writeLong(v);
      }
  
      @Override
      public BufferedSink writeLongLe(long v) throws IOException {
          return bufferedSink.writeLongLe(v);
      }
  
      @Override
      public BufferedSink emitCompleteSegments() throws IOException {
          return bufferedSink.emitCompleteSegments();
      }
  
      @Override
      public OutputStream outputStream() {
          return bufferedSink.outputStream();
      }
  }
  </code></pre>
  
  <p>Does anybody have an example of how I would go about doing this?</p>