Sending Byte array by httpost in Android

Question

I have a question about sending byte array in Android.

i previous tried to use Android httpclient file upload data corruption and timeout issues

but, i didn't really understand how to use it......

In my project, I previously used list of NameValuePair to send String type of data to Apache server such as

In post method (DB_Packet is string variable)

List nameValuePair = new ArrayList(2);

 nameValuePair.add(new BasicNameValuePair("content", DB_Packet)); nameValuePair.add(new BasicNameValuePair("guestbookName", "default")); httpPost.setEntity(new UrlEncodedFormEntity(nameValuePair));

However, String becomes larger size ( 13mb). I needed to use compression method to zip the Spring.

This compression method is return "byte type array". Therefore, I need to send byte Array to Apache server and i need to pass parameter "guestbookName" because

my jsp file contains

   <form action="/sign" method="post">
  <div><textarea name="content" rows="3" cols="60"></textarea></div>
  <div><input type="submit" value="Post Greeting" /></div>
  <input type="hidden" name="guestbookName" value="default"/>
</form>

However, I am not really sure the the function which I can send byte array to server.

What function do i need to use to send ("Paramenter", "byte Array") ?

and in server side

req.getParameter("content").getBytes();

is the right way yo get byte array?

thanks

Answer 1

To send binary data you need to use multipart/form-data encoding. Here is some example code. This class encodes data (including byte arrays - you could extend this to read files too)

package com.example;

import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;

public class PostData {

    class ByteData {
        byte[] data;
        String header;
        String name;

        ByteData(String name, String contentType, byte[] data) {
            this.name = name;
            this.data = data;
            try {
                header = "--" + BOUNDARY + CRLF + "Content-Disposition: form-data; name=\"file\"; filename=\"" + URLEncoder.encode(name, encoding) + "\";" + CRLF +
                        "Content-Type: " + contentType + CRLF + CRLF;
            } catch(UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }

        public int getSize() {
            return header.length() + data.length + CRLF.length();
        }


        public void write(OutputStream out) throws IOException {
            out.write(header.getBytes());
            out.write(data);
            out.write(CRLF.getBytes());
        }
    }

    private static final String TAG = PostData.class.getSimpleName();
    static final String BOUNDARY = "3C3F786D6C2076657273696F6E2E302220656E636F64696E673D662D38223F3E0A3C6D616E6966";
    static final String CRLF = "\r\n";
    private final String encoding;
    private StringBuilder sb;
    private String trailer;
    private List<ByteData> dataList = new ArrayList<ByteData>();


    public PostData() {
        this("UTF-8");
    }

    public PostData(String encoding) {
        this.encoding = encoding;
        sb = new StringBuilder();
        trailer = "--" + BOUNDARY + "--" + CRLF;
    }

    public String getContentType() {
        return "multipart/form-data; boundary=" + BOUNDARY;
    }

    public void addValue(String name, int value) {
        addValue(name, Integer.toString(value));
    }

    public void addValue(String name, String value) {
        sb.append("--" + BOUNDARY + CRLF);
        sb.append("Content-Disposition: form-data; name=\"");
        try {
            sb.append(URLEncoder.encode(name, encoding));
            sb.append('"');
            sb.append(CRLF + CRLF);
            sb.append(value);
            sb.append(CRLF);
        } catch(UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    public void addData(String name, String contentType, byte[] data) {
        dataList.add(new ByteData(name, contentType, data));
    }


    public long getLength() {
        long length = sb.toString().getBytes().length;
        length += trailer.length();
        for(ByteData byteData : dataList)
            length += byteData.getSize();
        return length;
    }

    public String toString() {
        return sb.toString();
    }

    public void write(OutputStream out) throws IOException {
        out.write(sb.toString().getBytes());
        for(ByteData byteData : dataList)
            byteData.write(out);
        out.write(trailer.getBytes());
    }
}

This class opens a connection and sends data:

package com.example;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class Uploader {

    private static final int CONNECTION_TIMEOUT = 10 * 1000;
    private static final int READ_TIMEOUT = 10 * 1000;
    final private String protocol;
    final private String server;

    public Uploader(String protocol, String server) {
        this.protocol = protocol;
        this.server = server;
    }

    protected HttpURLConnection getBaseConnection(String endpoint) throws IOException {
        HttpURLConnection connection;
        URL url;

        try {
            url = new URL(protocol + "://" + server + "/" + endpoint);
            connection = (HttpURLConnection)url.openConnection();
        } catch(MalformedURLException e) {
            throw new IOException("Malformed URL");
        }
        connection.setDoInput(true);
        connection.setConnectTimeout(CONNECTION_TIMEOUT);
        connection.setReadTimeout(READ_TIMEOUT);
        return connection;
    }

    public int upload(String endpoint, PostData postData) throws IOException {
        HttpURLConnection connection = null;

        connection = getBaseConnection(endpoint);
        connection.setDoOutput(true);
        connection.setInstanceFollowRedirects(false);
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Charset", "utf-8");
        connection.setRequestProperty("Content-Type", postData.getContentType());
        connection.setRequestProperty("Accept", "text/json");
        OutputStream out = new BufferedOutputStream(connection.getOutputStream(), 8192);
        postData.write(out);
        out.flush();
        int response = connection.getResponseCode();
        connection.disconnect();
        return response;
        }
}

Finally a test program using these classes.

package com.example;


import java.io.FileOutputStream;
import java.io.IOException;

public class UploadTest {

    private static byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5 , 4, 3, 2, 1};

    static public void main(String args[]) {

        PostData pd = new PostData();
        pd.addValue("user", "joe");
        pd.addValue("name", "Joe Smith");
        pd.addData("binary_data", "application/octet-stream", data);
        Uploader uploader = new Uploader("http", "localhost");
        try {
            uploader.upload("upload.php", pd);
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
}