Android invia file di grandi dimensioni tramite socket

Question

Al momento sto cercando di creare una piccola applicazione socket per il mio dispositivo Android.

Desidero inviare file di grandi dimensioni (~ 500 MB) tramite una connessione socket al mio laptop/PC o altro. Sto usando un client presa sul mio dispositivo Android per la connessione al mio server presa sul mio PC, ma quando provo a trasmettere un campo di prova (~ 460 MB) i miei applicazione si blocca e dice:

"Lanciare OutOfMemoryError "Impossibile allocare un 441.616.290 byte allocationwith 4194304 byte liberi e 90MB fino OOM""

credo che il mio cliente non è in grado di gestire il file-size. Quindi la mia domanda: esiste un modo per gestire file così grandi con una connessione socket TCP ?. Il mio codice funziona bene con piccoli file (ad esempio 5 MB), ma non riesce con i file più grandi.

Questo è quello che ho finora:

lato client in esecuzione sul mio dispositivo Android:

private class Connecting extends AsyncTask<String, Integer, String> 
{ 
    @Override 
    protected String doInBackground(String... serverAdd) 
    { 
     String filePath = "Path to file"; 

     File sdFile = new File(filePath); 

     try { 

      client = new Socket("ip", "port"); 

      outputStream = client.getOutputStream();     
      byte[] buffer = new byte[1024]; 
      FileInputStream in = new FileInputStream(sdFile); 
      int rBytes; 
      while((rBytes = in.read(buffer, 0, 1024)) != -1) 
      { 
       outputStream.write(buffer, 0, rBytes); 
      } 

      outputStream.flush(); 
      outputStream.close(); 
      client.close(); 


     } catch (UnknownHostException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     return null; 
    } 
} 

lato server:

public class Main { 

private static ServerSocket serverSocket; 
private static Socket clientSocket; 
private static InputStream inputStream; 
private static FileOutputStream fileOutputStream; 
private static BufferedOutputStream bufferedOutputStream; 
private static int filesize = 10000000; 
private static int bytesRead; 
private static int current = 0; 

public static void main(String[] args) throws IOException { 

    serverSocket = new ServerSocket(10898); 

    System.out.println("Server started. Listening to the port 10898"); 

    clientSocket = serverSocket.accept(); 

    byte[] mybytearray = new byte[filesize]; 

    inputStream = clientSocket.getInputStream(); 
    fileOutputStream = new FileOutputStream("E:\\output.zip"); 
    bufferedOutputStream = new BufferedOutputStream(fileOutputStream); 

    System.out.println("Receiving..."); 

    bytesRead = inputStream.read(mybytearray, 0, mybytearray.length); 
    current = bytesRead; 

    do { 
     bytesRead = inputStream.read(mybytearray, current, (mybytearray.length - current)); 
     if (bytesRead >= 0) { 
      current += bytesRead; 
     } 
    } while (bytesRead > -1); 


    bufferedOutputStream.write(mybytearray, 0, current); 
    bufferedOutputStream.flush(); 
    bufferedOutputStream.close(); 
    inputStream.close(); 
    clientSocket.close(); 
    serverSocket.close(); 

    System.out.println("Sever recieved the file"); 

} 
} 

Greetz

[EDIT]: Codice cliente

Answer 1

Ecco un codice di esempio per Java su come ridimensionare un file. È possibile adottarlo per l'applicazione client-server TCP/IP. Altro su chunking è disponibile qui (Java - Read file by chunks?), da cui ho preso l'esempio.

char[] myBuffer = new char[1024]; 
int bytesRead = 0; 
BufferedReader in = new BufferedReader(new FileReader("foo.txt")); 
while ((bytesRead = in.read(myBuffer, 0, 1024)) != -1) 
{ 
    ... 
}