발리 도서관에서 바이트 데이터를 보내는 방법

Question

데이터가 바이트 배열로되어 있기 때문에 Volley library에서 서비스로 보내야합니다. 이

StringRequest stringRequest = new StringRequest(Request.Method.GET, URL, 
     new Response.Listener<String>() { 
      @Override 
      public void onResponse(String response) { 
       Log.d("Success", response.toString()); 

      } 
     }, new Response.ErrorListener() { 
    @Override 
    public void onErrorResponse(VolleyError error) { 
     Log.d("Error", error.toString()); 
    } 
}){ 

    @Override 
    public byte[] getBody() throws AuthFailureError { 
     return bytesObject; 
    } 

     @Override 
     public String getBodyContentType() { 
      return "application/json; charset=utf-8"; 
     } 

}; 

RequestQueue requestQueue = Volley.newRequestQueue(AnalyticsApplication.getAppContext()); 
requestQueue.add(stringRequest); 

친절 Volley 라이브러리에서 byte array를 보내는 방법을 나를 인도, 내가 뭔가를 놓친 거지가 될 수 있습니다, 내가 시도하지만 getBody() 방법에 도달하지 그 무엇, 독서 몸 전에 응답을 반환합니다.

Answer 1

이

public void actionCallWebServiceWithFiles(String url, final HashMap<String, String> params, final Map<String, VolleyMultipartRequest.DataPart> file) { 

     VolleyMultipartRequest multipartRequest = new VolleyMultipartRequest(Request.Method.POST, url, new Response.Listener<NetworkResponse>() { 
      @Override 
      public void onResponse(NetworkResponse response) { 
       String resultResponse = new String(response.data); 
       try { 
        JSONObject result = new JSONObject(resultResponse); 
        /*String status = result.getString("status"); 
        String message = result.getString("message"); 

        if (status.equals(Constants.SUCCESS)) { 
         // tell everybody you have succed upload image and post strings 
         Log.i("Messsage", message); 
        } else { 
         Log.i("Unexpected", message); 
        }*/ 
       } catch (JSONException e) { 
        e.printStackTrace(); 
       } 
      } 
     }, new Response.ErrorListener() { 
      @Override 
      public void onErrorResponse(VolleyError error) { 
       NetworkResponse networkResponse = error.networkResponse; 
       String errorMessage = "Unknown error"; 
       if (networkResponse == null) { 
        if (error.getClass().equals(TimeoutError.class)) { 
         errorMessage = "Request timeout"; 
        } else if (error.getClass().equals(NoConnectionError.class)) { 
         errorMessage = "Failed to connect server"; 
        } 
       } else { 
        String result = new String(networkResponse.data); 
        try { 
         JSONObject response = new JSONObject(result); 
         String status = response.getString("status"); 
         String message = response.getString("message"); 

         Log.e("Error Status", status); 
         Log.e("Error Message", message); 

         if (networkResponse.statusCode == 404) { 
          errorMessage = "Resource not found"; 
         } else if (networkResponse.statusCode == 401) { 
          errorMessage = message + " Please login again"; 
         } else if (networkResponse.statusCode == 400) { 
          errorMessage = message + " Check your inputs"; 
         } else if (networkResponse.statusCode == 500) { 
          errorMessage = message + " Something is getting wrong"; 
         } 
        } catch (JSONException e) { 
         e.printStackTrace(); 
        } 
       } 
       Log.i("Error", errorMessage); 
       error.printStackTrace(); 
      } 
     }, onProgressUpdate) { 
      @Override 
      protected Map<String, String> getParams() { 

       return params; 
      } 


      @Override 
      protected Map<String, DataPart> getByteData() { 
       Map<String, DataPart> params = new HashMap<>(); 
       // file name could found file base or direct access from real path 
       // for now just get bitmap data from ImageView 
//    params.put("doc_file", new DataPart("file_avatar.jpg", Common.getFileDataFromDrawable(context, context.getDrawable(R.drawable.ic_app_icon)), "image/png")); 
//    params.put("upload_file", new DataPart("screens.zip",file,"application/zip")); 


       return file; 
      } 
     }; 

     MyApplication.getInstance().addToRequestQueue(multipartRequest); 
    } 

VolleyMultiPartRequest.java

을 시도

public class VolleyMultipartRequest extends Request<NetworkResponse> { 
    private final String twoHyphens = "--"; 
    private final String lineEnd = "\r\n"; 
    private final String boundary = "apiclient-" + System.currentTimeMillis(); 

    private Response.Listener<NetworkResponse> mListener; 
    private Response.ErrorListener mErrorListener; 
    private Map<String, String> mHeaders; 
    private OnProgressUpdate onProgressUpdate; 
    private int transferred = 0; 

    /** 
    * Default constructor with predefined header and post method. 
    * 
    * @param url   request destination 
    * @param headers  predefined custom header 
    * @param listener  on success achieved 200 code from request 
    * @param errorListener on error http or library timeout 
    */ 
    public VolleyMultipartRequest(String url, Map<String, String> headers, 
            Response.Listener<NetworkResponse> listener, 
            Response.ErrorListener errorListener) { 
     super(Method.POST, url, errorListener); 
     this.mListener = listener; 
     this.mErrorListener = errorListener; 
     this.mHeaders = headers; 
    } 

    /** 
    * Constructor with option method and default header configuration. 
    * 
    * @param method  method for now accept POST and GET only 
    * @param url   request destination 
    * @param listener  on success event handler 
    * @param errorListener on error event handler 
    */ 
    public VolleyMultipartRequest(int method, String url, 
            Response.Listener<NetworkResponse> listener, 
            Response.ErrorListener errorListener, OnProgressUpdate onProgressUpdate) { 
     super(method, url, errorListener); 
     this.mListener = listener; 
     this.mErrorListener = errorListener; 
     this.onProgressUpdate = onProgressUpdate; 
    } 

    @Override 
    public Map<String, String> getHeaders() throws AuthFailureError { 
     return (mHeaders != null) ? mHeaders : super.getHeaders(); 
    } 

    @Override 
    public String getBodyContentType() { 
     return "multipart/form-data;boundary=" + boundary; 
    } 

    @Override 
    public byte[] getBody() throws AuthFailureError { 
     ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
     DataOutputStream dos = new DataOutputStream(bos); 

     try { 
      // populate text payload 
      Map<String, String> params = getParams(); 
      if (params != null && params.size() > 0) { 
       textParse(dos, params, getParamsEncoding()); 
      } 

      // populate data byte payload 
      Map<String, DataPart> data = getByteData(); 
      if (data != null && data.size() > 0) { 
       dataParse(dos, data); 
      } 

      // close multipart form data after text and file data 
      dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd); 

      return bos.toByteArray(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
     return null; 
    } 

    /** 
    * Custom method handle data payload. 
    * 
    * @return Map data part label with data byte 
    * @throws AuthFailureError 
    */ 
    protected Map<String, DataPart> getByteData() throws AuthFailureError { 
     return null; 
    } 

    @Override 
    protected Response<NetworkResponse> parseNetworkResponse(NetworkResponse response) { 
     try { 
      return Response.success(
        response, 
        HttpHeaderParser.parseCacheHeaders(response)); 
     } catch (Exception e) { 
      return Response.error(new ParseError(e)); 
     } 
    } 

    @Override 
    protected void deliverResponse(NetworkResponse response) { 
     mListener.onResponse(response); 
    } 

    @Override 
    public void deliverError(VolleyError error) { 
     mErrorListener.onErrorResponse(error); 
    } 

    /** 
    * Parse string map into data output stream by key and value. 
    * 
    * @param dataOutputStream data output stream handle string parsing 
    * @param params   string inputs collection 
    * @param encoding   encode the inputs, default UTF-8 
    * @throws IOException 
    */ 
    private void textParse(DataOutputStream dataOutputStream, Map<String, String> params, String encoding) throws IOException { 
     try { 
      for (Map.Entry<String, String> entry : params.entrySet()) { 
       buildTextPart(dataOutputStream, entry.getKey(), entry.getValue()); 
      } 
     } catch (UnsupportedEncodingException uee) { 
      throw new RuntimeException("Encoding not supported: " + encoding, uee); 
     } 
    } 

    /** 
    * Parse data into data output stream. 
    * 
    * @param dataOutputStream data output stream handle file attachment 
    * @param data    loop through data 
    * @throws IOException 
    */ 
    private void dataParse(DataOutputStream dataOutputStream, Map<String, DataPart> data) throws IOException { 
     for (Map.Entry<String, DataPart> entry : data.entrySet()) { 
      buildDataPart(dataOutputStream, entry.getValue(), entry.getKey()); 
     } 
    } 

    /** 
    * Write string data into header and data output stream. 
    * 
    * @param dataOutputStream data output stream handle string parsing 
    * @param parameterName name of input 
    * @param parameterValue value of input 
    * @throws IOException 
    */ 
    private void buildTextPart(DataOutputStream dataOutputStream, String parameterName, String parameterValue) throws IOException { 
     dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd); 
     dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" + parameterName + "\"" + lineEnd); 
     //dataOutputStream.writeBytes("Content-Type: text/plain; charset=UTF-8" + lineEnd); 
     dataOutputStream.writeBytes(lineEnd); 
     dataOutputStream.writeBytes(parameterValue + lineEnd); 
    } 

    /** 
    * Write data file into header and data output stream. 
    * 
    * @param dataOutputStream data output stream handle data parsing 
    * @param dataFile   data byte as DataPart from collection 
    * @param inputName  name of data input 
    * @throws IOException 
    */ 
    private void buildDataPart(DataOutputStream dataOutputStream, DataPart dataFile, String inputName) throws IOException { 
     dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd); 
     dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" + 
       inputName + "\"; filename=\"" + dataFile.getFileName() + "\"" + lineEnd); 
     if (dataFile.getType() != null && !dataFile.getType().trim().isEmpty()) { 
      dataOutputStream.writeBytes("Content-Type: " + dataFile.getType() + lineEnd); 
     } 
     dataOutputStream.writeBytes(lineEnd); 

     ByteArrayInputStream fileInputStream = new ByteArrayInputStream(dataFile.getContent()); 
     int bytesAvailable = fileInputStream.available(); 

     int maxBufferSize = 1024 * 1024; 
     int bufferSize = Math.min(bytesAvailable, maxBufferSize); 
     byte[] buffer = new byte[bufferSize]; 

     int bytesRead = fileInputStream.read(buffer, 0, bufferSize); 
     long total = 0; 

     while (bytesRead > 0) { 
      dataOutputStream.write(buffer, 0, bufferSize); 
      total = dataOutputStream.size(); 
      transferred = (int) (total * 100/dataFile.getContent().length) ; 
      onProgressUpdate.onTransferred(transferred); 
      bytesAvailable = fileInputStream.available(); 
      bufferSize = Math.min(bytesAvailable, maxBufferSize); 
      bytesRead = fileInputStream.read(buffer, 0, bufferSize); 
     } 

     dataOutputStream.writeBytes(lineEnd); 

    } 

    /** 
    * Simple data container use for passing byte file 
    */ 
    public static class DataPart { 
     private String fileName; 
     private byte[] content; 
     private String type; 

     /** 
     * Default data part 
     */ 
     public DataPart() { 
     } 

     /** 
     * Constructor with data. 
     * 
     * @param name label of data 
     * @param data byte data 
     */ 
     public DataPart(String name, byte[] data) { 
      fileName = name; 
      content = data; 
     } 

     /** 
     * Constructor with mime data type. 
     * 
     * @param name  label of data 
     * @param data  byte data 
     * @param mimeType mime data like "image/jpeg" 
     */ 
     public DataPart(String name, byte[] data, String mimeType) { 
      fileName = name; 
      content = data; 
      type = mimeType; 
     } 

     /** 
     * Getter file name. 
     * 
     * @return file name 
     */ 
     public String getFileName() { 
      return fileName; 
     } 

     /** 
     * Setter file name. 
     * 
     * @param fileName string file name 
     */ 
     public void setFileName(String fileName) { 
      this.fileName = fileName; 
     } 

     /** 
     * Getter content. 
     * 
     * @return byte file data 
     */ 
     public byte[] getContent() { 
      return content; 
     } 

     /** 
     * Setter content. 
     * 
     * @param content byte file data 
     */ 
     public void setContent(byte[] content) { 
      this.content = content; 
     } 

     /** 
     * Getter mime type. 
     * 
     * @return mime type 
     */ 
     public String getType() { 
      return type; 
     } 

     /** 
     * Setter mime type. 
     * 
     * @param type mime type 
     */ 
     public void setType(String type) { 
      this.type = type; 
     } 
    } 
}