content: /*
      Android Asynchronous Http Client
      Copyright (c) 2011 James Smith <james@loopj.com>
      https://github.com/android-async-http/android-async-http
  
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
  
          https://www.apache.org/licenses/LICENSE-2.0
  
      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
  */
  
  /*
      This code is taken from Rafael Sanches' blog. Link is no longer working (as of 17th July 2015)
      https://blog.rafaelsanches.com/2011/01/29/upload-using-multipart-post-using-httpclient-in-android/
  */
  
  package com.loopj.android.http;
  
  import android.text.TextUtils;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Random;
  
  import cz.msebera.android.httpclient.Header;
  import cz.msebera.android.httpclient.HttpEntity;
  import cz.msebera.android.httpclient.message.BasicHeader;
  import cz.msebera.android.httpclient.protocol.HTTP;
  
  /**
   * Simplified multipart entity mainly used for sending one or more files.
   */
  class SimpleMultipartEntity implements HttpEntity {
  
      private static final String LOG_TAG = "SimpleMultipartEntity";
  
      private static final String STR_CR_LF = "\r\n";
      private static final byte[] CR_LF = STR_CR_LF.getBytes();
      private static final byte[] TRANSFER_ENCODING_BINARY =
              ("Content-Transfer-Encoding: binary" + STR_CR_LF).getBytes();
  
      private final static char[] MULTIPART_CHARS =
              "-_1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
  
      private final String boundary;
      private final byte[] boundaryLine;
      private final byte[] boundaryEnd;
      private final List<FilePart> fileParts = new ArrayList<FilePart>();
      // The buffer we use for building the message excluding files and the last
      // boundary
      private final ByteArrayOutputStream out = new ByteArrayOutputStream();
      private final ResponseHandlerInterface progressHandler;
      private boolean isRepeatable;
      private long bytesWritten;
  
      private long totalSize;
  
      public SimpleMultipartEntity(ResponseHandlerInterface progressHandler) {
          final StringBuilder buf = new StringBuilder();
          final Random rand = new Random();
          for (int i = 0; i < 30; i++) {
              buf.append(MULTIPART_CHARS[rand.nextInt(MULTIPART_CHARS.length)]);
          }
  
          boundary = buf.toString();
          boundaryLine = ("--" + boundary + STR_CR_LF).getBytes();
          boundaryEnd = ("--" + boundary + "--" + STR_CR_LF).getBytes();
  
          this.progressHandler = progressHandler;
      }
  
      public void addPart(String key, String value, String contentType) {
          try {
              out.write(boundaryLine);
              out.write(createContentDisposition(key));
              out.write(createContentType(contentType));
              out.write(CR_LF);
              out.write(value.getBytes());
              out.write(CR_LF);
          } catch (final IOException e) {
              // Shall not happen on ByteArrayOutputStream
              AsyncHttpClient.log.e(LOG_TAG, "addPart ByteArrayOutputStream exception", e);
          }
      }
  
      public void addPartWithCharset(String key, String value, String charset) {
          if (charset == null) charset = HTTP.UTF_8;
          addPart(key, value, "text/plain; charset=" + charset);
      }
  
      public void addPart(String key, String value) {
          addPartWithCharset(key, value, null);
      }
  
      public void addPart(String key, File file) {
          addPart(key, file, null);
      }
  
      public void addPart(String key, File file, String type) {
          fileParts.add(new FilePart(key, file, normalizeContentType(type)));
      }
  
      public void addPart(String key, File file, String type, String customFileName) {
          fileParts.add(new FilePart(key, file, normalizeContentType(type), customFileName));
      }
  
      public void addPart(String key, String streamName, InputStream inputStream, String type)
              throws IOException {
  
          out.write(boundaryLine);
  
          // Headers
          out.write(createContentDisposition(key, streamName));
          out.write(createContentType(type));
          out.write(TRANSFER_ENCODING_BINARY);
          out.write(CR_LF);
  
          // Stream (file)
          final byte[] tmp = new byte[4096];
          int l;
          while ((l = inputStream.read(tmp)) != -1) {
              out.write(tmp, 0, l);
          }
  
          out.write(CR_LF);
          out.flush();
      }
  
      private String normalizeContentType(String type) {
          return type == null ? RequestParams.APPLICATION_OCTET_STREAM : type;
      }
  
      private byte[] createContentType(String type) {
          String result = AsyncHttpClient.HEADER_CONTENT_TYPE + ": " + normalizeContentType(type) + STR_CR_LF;
          return result.getBytes();
      }
  
      private byte[] createContentDisposition(String key) {
          return (
                  AsyncHttpClient.HEADER_CONTENT_DISPOSITION +
                          ": form-data; name=\"" + key + "\"" + STR_CR_LF).getBytes();
      }
  
      private byte[] createContentDisposition(String key, String fileName) {
          return (
                  AsyncHttpClient.HEADER_CONTENT_DISPOSITION +
                          ": form-data; name=\"" + key + "\"" +
                          "; filename=\"" + fileName + "\"" + STR_CR_LF).getBytes();
      }
  
      private void updateProgress(long count) {
          bytesWritten += count;
          progressHandler.sendProgressMessage(bytesWritten, totalSize);
      }
  
      @Override
      public long getContentLength() {
          long contentLen = out.size();
          for (FilePart filePart : fileParts) {
              long len = filePart.getTotalLength();
              if (len < 0) {
                  return -1; // Should normally not happen
              }
              contentLen += len;
          }
          contentLen += boundaryEnd.length;
          return contentLen;
      }
  
      // The following methods are from the HttpEntity interface
  
      @Override
      public Header getContentType() {
          return new BasicHeader(
                  AsyncHttpClient.HEADER_CONTENT_TYPE,
                  "multipart/form-data; boundary=" + boundary);
      }
  
      @Override
      public boolean isChunked() {
          return false;
      }
  
      public void setIsRepeatable(boolean isRepeatable) {
          this.isRepeatable = isRepeatable;
      }
  
      @Override
      public boolean isRepeatable() {
          return isRepeatable;
      }
  
      @Override
      public boolean isStreaming() {
          return false;
      }
  
      @Override
      public void writeTo(final OutputStream outstream) throws IOException {
          bytesWritten = 0;
          totalSize = (int) getContentLength();
          out.writeTo(outstream);
          updateProgress(out.size());
  
          for (FilePart filePart : fileParts) {
              filePart.writeTo(outstream);
          }
          outstream.write(boundaryEnd);
          updateProgress(boundaryEnd.length);
      }
  
      @Override
      public Header getContentEncoding() {
          return null;
      }
  
      @Override
      public void consumeContent() throws IOException, UnsupportedOperationException {
          if (isStreaming()) {
              throw new UnsupportedOperationException(
                      "Streaming entity does not implement #consumeContent()");
          }
      }
  
      @Override
      public InputStream getContent() throws IOException, UnsupportedOperationException {
          throw new UnsupportedOperationException(
                  "getContent() is not supported. Use writeTo() instead.");
      }
  
      private class FilePart {
          public final File file;
          public final byte[] header;
  
          public FilePart(String key, File file, String type, String customFileName) {
              header = createHeader(key, TextUtils.isEmpty(customFileName) ? file.getName() : customFileName, type);
              this.file = file;
          }
  
          public FilePart(String key, File file, String type) {
              header = createHeader(key, file.getName(), type);
              this.file = file;
          }
  
          private byte[] createHeader(String key, String filename, String type) {
              ByteArrayOutputStream headerStream = new ByteArrayOutputStream();
              try {
                  headerStream.write(boundaryLine);
  
                  // Headers
                  headerStream.write(createContentDisposition(key, filename));
                  headerStream.write(createContentType(type));
                  headerStream.write(TRANSFER_ENCODING_BINARY);
                  headerStream.write(CR_LF);
              } catch (IOException e) {
                  // Can't happen on ByteArrayOutputStream
                  AsyncHttpClient.log.e(LOG_TAG, "createHeader ByteArrayOutputStream exception", e);
              }
              return headerStream.toByteArray();
          }
  
          public long getTotalLength() {
              long streamLength = file.length() + CR_LF.length;
              return header.length + streamLength;
          }
  
          public void writeTo(OutputStream out) throws IOException {
              out.write(header);
              updateProgress(header.length);
  
              FileInputStream inputStream = new FileInputStream(file);
              final byte[] tmp = new byte[4096];
              int bytesRead;
              while ((bytesRead = inputStream.read(tmp)) != -1) {
                  out.write(tmp, 0, bytesRead);
                  updateProgress(bytesRead);
              }
              out.write(CR_LF);
              updateProgress(CR_LF.length);
              out.flush();
              AsyncHttpClient.silentCloseInputStream(inputStream);
          }
      }
  }
  