Отправка аудиофайла с android на сервлет

Question

Как отправить аудиофайл с телефона android на сервлет. Я занимаюсь серфингом на многих сайтах, но не получаю надлежащего решения. Может ли кто-нибудь помочь мне. Как много способов отправить аудиофайл с android на сервер.

Answer 1

Наконец я добиться успеха в отправке аудио файлов с андроида на сервлет. Ниже мой стороне клиента код

public class MainActivity extends Activity { 

// static final String UPLOAD_URL = "http://192.168.223.1:8080/ReceiveFileServlet/RecFileServlet"; 
    static final int BUFFER_SIZE = 4096; 
    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     new sendFile().execute(new String[] { "http://10.0.2.2:8080/ReceiveFileServlet/RecFileServlet" }); 
    } 
    private class sendFile extends AsyncTask<String, Void, String> 
    { 

     @Override 
     protected String doInBackground(String... urls) { 
      HttpURLConnection httpConn=null; 

      try 
      { 
      String file = Environment.getExternalStorageDirectory().getAbsolutePath() + "/Tdt.aac"; 
      File uploadFile = new File(file); 
      FileInputStream inputStream = new FileInputStream(uploadFile); 

      System.out.println("File to upload: " + file); 

      // creates a HTTP connection 
      URL url1 = new URL(urls[0]); 
      httpConn = (HttpURLConnection) url1.openConnection(); 
      httpConn.setUseCaches(false); 
      httpConn.setDoOutput(true); 
      httpConn.setRequestMethod("POST"); 
      httpConn.setRequestProperty("fileName", uploadFile.getName()); 
      httpConn.connect(); 
      // sets file name as a HTTP header 

      Log.i("fileName", uploadFile.getName()); 
      // opens output stream of the HTTP connection for writing data 

      OutputStream outputStream = httpConn.getOutputStream(); 

      // Opens input stream of the file for reading data 


      byte[] buffer = new byte[BUFFER_SIZE]; 
      int bytesRead = -1; 

      System.out.println("Start writing data..."); 

      while ((bytesRead = inputStream.read(buffer)) != -1) { 
       outputStream.write(buffer, 0, bytesRead); 
      } 

      System.out.println("Data was written."); 
      outputStream.close(); 
      inputStream.close(); 
      } 
      catch(SocketTimeoutException e) 
      { 
       Log.e("Debug", "error: " + e.getMessage(), e); 
      } 
      catch (MalformedURLException ex) 
      { 
        Log.e("Debug", "error: " + ex.getMessage(), ex); 
      } 
      catch (IOException ioe) 
      { 
        Log.e("Debug", "error: " + ioe.getMessage(), ioe); 
      } 

      try 
      { 

      // always check HTTP response code from server 
      int responseCode = httpConn.getResponseCode(); 
      if (responseCode == HttpURLConnection.HTTP_OK) { 
       // reads server's response 
       BufferedReader reader = new BufferedReader(new InputStreamReader(httpConn.getInputStream())); 
       String response = reader.readLine(); 
       System.out.println("Server's response: " + response); 
      } else { 
       System.out.println("Server returned non-OK code: " + responseCode); 
      } 
      } 
      catch (IOException ioex){ 
        Log.e("Debug", "error: " + ioex.getMessage(), ioex); 
      } 
      return null; 
     } 
     @Override 
     protected void onPostExecute(String result) {    
     } 

     @Override 
     protected void onPreExecute() { 
     } 

     @Override 
     protected void onProgressUpdate(Void... values) { 
     } 
    } 
} 

вот мой сервлет код

public class RecFileServlet extends HttpServlet { 
    static final String SAVE_DIR = "D:/temp/"; 
    static final int BUFFER_SIZE = 4096; 

    @Override 
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
     doPost(req, resp); 
    } 


    protected void doPost(HttpServletRequest request, 
      HttpServletResponse response) throws ServletException, IOException { 

     // Gets file name for HTTP header 
     String fileName = request.getHeader("fileName"); 
     File saveFile = new File(SAVE_DIR + fileName); 

     // prints out all header values 
     System.out.println("===== Begin headers ====="); 
     Enumeration<String> names = request.getHeaderNames(); 
     while (names.hasMoreElements()) { 
      String headerName = names.nextElement(); 
      System.out.println(headerName + " = " + request.getHeader(headerName)); 
     } 
     System.out.println("===== End headers =====\n"); 

     // opens input stream of the request for reading data 
     InputStream inputStream = request.getInputStream(); 

     // opens an output stream for writing file 
     FileOutputStream outputStream = new FileOutputStream(saveFile); 

     byte[] buffer = new byte[BUFFER_SIZE]; 
     int bytesRead = -1; 
     System.out.println("Receiving data..."); 

     while ((bytesRead = inputStream.read(buffer)) != -1) { 
      outputStream.write(buffer, 0, bytesRead); 
     } 

     System.out.println("Data received."); 
     outputStream.close(); 
     inputStream.close(); 

     System.out.println("File written to: " + saveFile.getAbsolutePath()); 

     // sends response to client 
     response.getWriter().print("UPLOAD DONE"); 
    } 

} 

Answer 2

HttpRequestWithEntity.java

import java.net.URI; 
import java.net.URISyntaxException; 

import org.apache.http.client.methods.HttpEntityEnclosingRequestBase; 

public class HttpRequestWithEntity extends HttpEntityEnclosingRequestBase { 

    private String method; 

    public HttpRequestWithEntity(String url, String method) { 
     if (method == null || (method != null && method.isEmpty())) { 
      this.method = HttpMethod.GET; 
     } else { 
      this.method = method; 
     } 
     try { 
      setURI(new URI(url)); 
     } catch (URISyntaxException e) { 
      e.printStackTrace(); 
     } 
    } 

    @Override 
    public String getMethod() { 
     return this.method; 
    } 

} 

А вот если вы хотите загрузить фотографии или видео, и вы можете показать ProgressBar, если вы хотите.

public static class UploadPhoto extends AsyncTask<String, Void, InputStream> { 
    private static final String TAG = "UploadImage"; 
    byte[] buffer; 
    byte[] data; 
    //private long dataLength = 0; 
    private INotifyProgressBar iNotifyProgressBar; 
    private int user_id; 
    private IAddNewItemOnGridView mAddNewItemOnGridView; 
    public UploadPhoto(INotifyProgressBar iNotifyProgressBar, 
      IAddNewItemOnGridView mAddNewItemOnGridView, int user_id) { 
     this.iNotifyProgressBar = iNotifyProgressBar; 
     this.user_id = user_id; 
     this.mAddNewItemOnGridView = mAddNewItemOnGridView; 
    } 

    @Override 
    protected InputStream doInBackground(String... names) { 
     File mFile = null; 
     FileBody mBody = null; 
     File dcimDir = null; 
     try { 
      String fileName = names[0]; 
      dcimDir = Environment 
        .getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM); 
      mFile = new File(dcimDir, Def.PHOTO_TEMP_DIR + fileName); 
      if (!mFile.isFile()) { 
       iNotifyProgressBar.notify(0, UploadStatus.FAILED); 
       return null; 
      } 
      HttpClient httpClient = new DefaultHttpClient(); 
      HttpPost postRequest = new HttpPost(Def.BASE_URL 
        + String.format("/%d/list", this.user_id)); 
      final int maxBufferSize = 10 * 1024; 
      mBody = new FileBody(mFile, fileName, "image/jpeg", "UTF-8"){ 
       int bytesRead, bytesAvailable, bufferSize; 
       InputStream mInputStream = super.getInputStream(); 
       int dataLength = mInputStream.available(); 
       @Override 
       public void writeTo(OutputStream out) throws IOException { 
        bytesAvailable = mInputStream.available(); 
        bufferSize = Math.min(bytesAvailable, maxBufferSize); 
        buffer = new byte[bufferSize]; 
        bytesRead = mInputStream.read(buffer, 0, bufferSize); 
        while (bytesRead > 0) { 
         out.write(buffer, 0, bufferSize); 
         bytesAvailable = mInputStream.available(); 
         bufferSize = Math.min(bytesAvailable, maxBufferSize); 
         bytesRead = mInputStream.read(buffer, 0, bufferSize); 
         int progress = (int) (100 - ((bytesAvailable * 1.0)/dataLength) * 100); 
         Log.d(TAG, "Result: " + progress + "%"); 
         if (progress == 100) { 
          iNotifyProgressBar.notify(progress, UploadStatus.SUCCESS); 
         } else { 
          iNotifyProgressBar.notify(progress, UploadStatus.UPLOADING); 
         } 
        } 
       } 
       @Override 
       protected void finalize() throws Throwable { 
        super.finalize(); 
        if (mInputStream != null) { 
         mInputStream.close(); 
        } 
       } 
      }; 

      MultipartEntity reqEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);    
      reqEntity.addPart("photo", mBody); 
      postRequest.setEntity(reqEntity); 
      HttpResponse response = httpClient.execute(postRequest); 
      InputStream mInputStream = response.getEntity().getContent(); 
      return mInputStream == null ? null : mInputStream; 
     } catch (IOException e) { 
      Log.e(TAG, "Error causes during upload image: " + e.getMessage()); 
      e.printStackTrace(); 
      iNotifyProgressBar.notify(0, UploadStatus.FAILED); 
     } finally { 
      Log.v(TAG, "Close file"); 
      if (mFile != null) { 
       mFile = null; 
      } 
      if (mBody != null) { 
       mBody = null; 
      } 
      if (dcimDir != null) { 
       dcimDir = null; 
      } 
     } 
     return null; 
    } 

    @Override 
    protected void onPostExecute(InputStream result) { 
     if (result == null) { 
      iNotifyProgressBar.notify(0, UploadStatus.FAILED); 
     } else { 
      PhotoInfo mPhotoInfo = ApiUtils.convertStreamToPhotoInfo(result); 
      if (mAddNewItemOnGridView != null && mPhotoInfo != null) { 
       mAddNewItemOnGridView.notifyAdded(mPhotoInfo); 
       Log.d(TAG, "Upload completed!!"); 
      } else { 
       Log.d(TAG, "Upload is failed!!"); 
       iNotifyProgressBar.notify(0, UploadStatus.FAILED); 
      } 
     } 
    } 

    @Override 
    protected void onPreExecute() { 
     super.onPreExecute(); 
    } 
} 

Servlet

package jp.co.bits.cpa.controller; 

import java.awt.Image; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.ArrayList; 
import java.util.List; 
import javax.imageio.ImageIO; 
import javax.servlet.http.HttpServletRequest; 
import org.apache.commons.io.FileUtils; 
import org.apache.struts2.ServletActionContext; 
import org.apache.struts2.convention.annotation.Action; 
import org.apache.struts2.convention.annotation.Actions; 
import org.apache.struts2.convention.annotation.Namespace; 
import org.apache.struts2.convention.annotation.ParentPackage; 
import org.apache.struts2.convention.annotation.Result; 
import org.apache.struts2.rest.DefaultHttpHeaders; 
import org.apache.struts2.rest.HttpHeaders; 

@ParentPackage(value="json-default") 
@Namespace("/api/users/{user_id}") 
@Result(
     name=MyAction.GETDATA, type="json", 
     params={ 
       "excludeNullProperties", "true", 
       "excludeProperties", "list.*\\.owner_id" 
     }) 
public class ListController implements Status, MyAction { //ModelDriven<Object>, 
    private static int STATUS = REQUEST_INVALID; 
    private File file; 
    private String contentType; 
    private String filename; 
    private String contentDisposition = "inline"; 
    private String user_id; 
    private String sort; // asc || desc 
    private String type; // thumbnail || full 
    private String photo_id;  
    private PhotoHandler photoHandler = new PhotoHandler(); 
    private HttpServletRequest request = ServletActionContext.getRequest(); 
    private InputStream fileInputStream; 
    private String photoUrl; 
    private List<Photo> list = new ArrayList<Photo>(); 
    private Photo photo; 

    @Actions( 
      value={ 
        @Action(results={ 
          @Result(name=SUCCESS, type="stream", 
            params={ 
            "contentType", "image/jpeg", 
            "inputName", "fileInputStream", 
            "contentDisposition", "filename=\"photo.jpg\"", 
            "bufferSize", "1024", 
            "allowCaching", "false" 
          }), 
          @Result(name=UPLOAD, type="json", params={ 
            "excludeNullProperties", "true", 
            "allowCaching", "false", 
            "excludeProperties", "contentType,photoFilename" 
          }) 
         }) 
      } 
    ) 

    public HttpHeaders execute() throws FileNotFoundException { 
     HttpMethod method = HttpMethod.valueOf(request.getMethod()); 
     String action = GETDATA; 
     switch (method) { 
      case GET: { 
       System.out.println("GET..."); 
       if (this.sort != null && this.type == null) { 
        System.out.println(this.user_id); 
        STATUS = photoList(); 
       } else if (this.type != null){ 
        STATUS = download(); 
        if (STATUS == CREATED) { 
         fileInputStream = new FileInputStream(new File(photoUrl)); 
         if (fileInputStream != null) { 
          System.out.println("FileInputStream: " + fileInputStream.toString()); 
         } 
        } 
        return new DefaultHttpHeaders(STATUS == CREATED ? SUCCESS : GETDATA).withStatus(STATUS); 
       } else { 
        STATUS = REQUEST_INVALID; 
       } 
       break; 
      } 
      case POST: { 
       System.out.println("Upload file..."); 
       STATUS = saveFile(); 
       System.out.println("Status: " + STATUS); 
       action = UPLOAD; 
       break; 
      } 
      default: 
       break; 
     } 
     System.out.println("Status: " + STATUS); 
     return new DefaultHttpHeaders(action).withStatus(STATUS); 
    } 

    public InputStream getFileInputStream() { 
     if (this.fileInputStream != null) { 
      return this.fileInputStream; 
     } else { 
      return null; 
     } 
    } 
    /** 
    * 
    * Get list photo by user_id and sort type (asc || desc) 
    * @return status code 
    */ 
    public int photoList() { 
     System.out.println("Get list..."); 
     list.clear(); 
     if (user_id == null || this.sort == null) { 
      return REQUEST_INVALID; 
     } else { 
      if (sort.equalsIgnoreCase(Def.SORT_ASC) || 
        sort.equalsIgnoreCase(Def.SORT_DESC)) { 
       List<Photo> mPhotos = photoHandler.getList(user_id, this.sort); 
       if (mPhotos.size() == 0) { 
        return NO_PHOTO; 
       } else { 
        list.addAll(mPhotos); 
        return OK; 
       } 
      } else { 
       return REQUEST_INVALID; 
      } 
     } 
    } 

    /** 
    * using download image by using photo_id and type of photo (thumbnail || full) 
    * @return status code 
    */ 
    public int download() { 
     list.clear(); 
     System.out.println("Download..."); 
     if (type == null) { 
      type = Def.PHOTO_THUMBNAIL; 
     } else { 
      if (photo_id == null) { 
       return REQUEST_INVALID; 
      } 
     } 
     if (type.equalsIgnoreCase(Def.PHOTO_THUMBNAIL) || 
       type.equalsIgnoreCase(Def.PHOTO_FULL)) { 
      String url = photoHandler.getUrl(this.photo_id, this.type); 
      if (url == null) { 
       return NO_PHOTO; 
      } else { 
       request = ServletActionContext.getRequest(); 
       @SuppressWarnings("deprecation") 
       String path = request.getRealPath("/images/files/"); 
       photoUrl = path + "/" + url; 
       return CREATED; 
      } 
     } else { 
      return REQUEST_INVALID; 
     } 
    } 

    /** 
    * 
    * @param pathImage 
    * @return true or false 
    */ 
    private boolean cropImage(String pathImage) { 
     Image originalImage; 
     BufferedImage thumbImage; 
     try { 
      originalImage = ImageIO.read(this.file); 
      thumbImage = Utils.makeThumbnail(originalImage, 100, 100, true); 
      File thumbFile = new File(pathImage); 
      System.out.println("Crop... " + pathImage); 
      return ImageIO.write(thumbImage, Def.DEFAULT_PHOTO_TYPE, 
        thumbFile); 
     } catch (Exception e) { 
      System.out.println("Error at CropIMAGE: " + e.getMessage()); 
      return false; 
     } 
    } 

    private int saveFile() { 
     try { 
      int userId = Integer.parseInt(this.user_id); // Parse user_id can be failed 

      if (file != null && new UserHandler().isExisted(userId)) { // user_id always != null, please change to check user_id existed 
       System.out.println("Save File..."); 
       request = ServletActionContext.getRequest(); 
       @SuppressWarnings("deprecation") 
       String path = request.getRealPath("/images/files/"); 
       System.out.println("Path-->: " + path); 
       System.out.println(this.filename); // Save file name to database 

       File fileToCreate = new File(path, this.filename);   
       String thumb_url = Def.THUMBNAIL_PREFIX + this.filename; 
       try { 
        FileUtils.copyFile(this.file, fileToCreate); 
        if (fileToCreate.isFile()) { 
//      int photoId = photoHandler.insertGetId(new Photo(
//        Integer.parseInt(this.user_id), this.filename, 
//        this.filename, thumb_url)); 
         if (cropImage(path + "/" + thumb_url)) { 
          this.photo = photoHandler.insertGetPhoto(new Photo(
            Integer.parseInt(this.user_id), this.filename, 
            this.filename, thumb_url)); 
          if (photo != null) { 
           return CREATED; 
          } else { 
           return REQUEST_INVALID; 
          } 
         } else { 
          System.out.println("Crop failed"); 
          return REQUEST_INVALID; 
         } 
        } else { 
         System.out.println("create failed"); 
         return REQUEST_INVALID; 
        } 
       } catch (IOException e) { 
        System.out.println("Error at Save file: " + e.getMessage()); 
        if (fileToCreate.isFile()) { // Sometime, we upload fail but the filename or file still created. 
         fileToCreate.delete(); 
        } 
        return REQUEST_INVALID; 
       } 
      } else { 
       System.out.println("File not found"); 
       return REQUEST_INVALID; 
      }   
     } catch (Exception e) { 
      return REQUEST_INVALID; 
     } 
    } 

    public void setPhoto(File file) { 
     System.out.println("Set Photo File..."); 
     this.file = file; 
    } 

    public void setPhotoContentType(String contentType) { 
     this.setContentType(contentType); 
    } 

    public void setPhotoFileName(String filename) { 
     this.filename = filename; 
    } 

    /** 
    * 
    * Get list for parse json 
    * @return list for parse json 
    */ 
    public List<Photo> getList() { 
     if (list.size() > 0) { 
      return list; 
     } else { 
      return null; 
     } 
    } 
    public String getPhotoFilename() { 
     if (this.filename == null) { 
      return null; 
     } 
     if (this.filename.isEmpty()) { 
      return null; 
     } 
     return this.filename; 

    } 
    public void setServletRequest(HttpServletRequest servletRequest) { 
     this.request = servletRequest; 
    } 
    public void setPhotoContentDisposition(String contentDisposition) { 
     this.setContentDisposition(contentDisposition); 
    } 
    public void setContentDisposition(String contentDisposition) { 
     this.contentDisposition = contentDisposition; 
    } 
    public String getContentDisposition() { 
     if (this.contentDisposition == null) { 
      return null; 
     } 
     if (this.contentDisposition.isEmpty()) { 
      return null; 
     } 
     if (this.contentDisposition.equals("inline")) { 
      return null; 
     } 
     return this.contentDisposition; 
    } 
    public String getContentType() { 
     if (this.contentType == null) { 
      return null; 
     } 
     if (this.contentType.isEmpty()) { 
      return null; 
     } 
     return this.contentType; 
    } 
    public void setUser_id(String user_id) { 
     this.user_id = user_id; 
    } 
    public void setSort(String sort) { 
     this.sort = sort.trim(); 
    } 
    public void setPhoto_id(String photo_id) { 
     this.photo_id = photo_id.trim(); 
    } 
    public void setType(String type) { 
     this.type = type.trim(); 
    } 
    public void setContentType(String contentType) { 
     this.contentType = contentType; 
    } 

    public Photo getPhoto() { 
     return photo; 
    } 

    public void setPhoto(Photo detail) { 
     this.photo = detail; 
    } 
}