Autore Topic: problema nella ricezione di file dal server  (Letto 909 volte)

Offline Albe85

  • Utente junior
  • **
  • Post: 102
  • Respect: +1
    • Mostra profilo
problema nella ricezione di file dal server
« il: 13 Novembre 2010, 15:39:38 CET »
0
Buongiorno ragazzi.
Sto tendando di ricevere due file provenienti da un server al mio client android (l'SDK per ora).
Il processo inverso cioè l'invio di un file dal client android al server funziona alla perfezione.
Quello che volevo fare ora è andare a ricevere dal server due file e salvarli sulla sd virtuale dell'sdk.

Questo è il mio server:

Codice (Java): [Seleziona]
public class TCPDesktopServer implements Runnable{
       
    public static final String SERVERIP = "127.0.0.1";
    public static final int SERVERPORT = 4444;
         
    public void run() {
         try {
                 System.out.println("S: Connecting...");
             
             ServerSocket serverSocket = new ServerSocket(SERVERPORT);
             while (true) {
                 
                    int filesize=6022386; // filesize temporary hardcoded

                    long start = System.currentTimeMillis();
                    int bytesRead;
                    int current = 0;

                 
                  Socket client = serverSocket.accept();
                  System.out.println("S: Receiving to client...");
         
                  try {
                     
                          BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                      String str = in.readLine();
                      System.out.println("S: Received: '" + str + "'");
                     
                     
                      //RICEZIONE NELLA CARTELLA DI LAVORO DEL FILE QUANTITATOSERVER.xml DAL
                      //DISPOSITIVO MOBILE
                      byte [] mybytearray  = new byte [filesize];
                      InputStream is = client.getInputStream();
                      FileOutputStream fos = new FileOutputStream("QUANTITATOSERVER.xml");
                      BufferedOutputStream bos = new BufferedOutputStream(fos);
                      bytesRead = is.read(mybytearray,0,mybytearray.length);
                      current = bytesRead;

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

                      bos.write(mybytearray, 0 , current);
                      bos.flush();
                      long end = System.currentTimeMillis();
                      System.out.println(end-start);
                      bos.close();
                     
   
                   
                        //INVIO AL DISPOSITIVO MOBILE DEL FILE ARTICOLI.XML
                     
                            File myArticoli = new File ("articoli.xml");
                                FileInputStream fis = new FileInputStream(myArticoli);
                                BufferedInputStream bis = new BufferedInputStream(fis);
                                byte [] mybytearray3 = new byte [(int)myArticoli.length()];
                                bis.read(mybytearray3,0,mybytearray3.length);
                                OutputStream os = client.getOutputStream();
                                os.write(mybytearray3,0, mybytearray3.length);
                                os.flush();
                     
                        //INVIO AL DISPOSITIVO MOBILE DEL FILE LOGSPESA.XML CON
                        //LE QUANTITA CORRETTAMENTE AGGIORNATE
                       
                        File myLogspesa = new File ("logspesa.xml");
                        FileInputStream fis2 = new FileInputStream(myLogspesa);
                        BufferedInputStream bis2 = new BufferedInputStream(fis2);
                        byte [] mybytearray2 = new byte [(int)myLogspesa.length()];
                        bis2.read(mybytearray2,0,mybytearray2.length);
                       OutputStream os2 = client.getOutputStream();
                                os2.write(mybytearray2,0, mybytearray2.length);
                                os2.flush();
                     

                    } catch(Exception e) {
                        System.out.println("S: Error");
                        e.printStackTrace();
                    } finally {
                        client.close();
                        System.out.println("S: Done.");
                    }

             }
             
         } catch (Exception e) {
             System.out.println("S: Error");
             e.printStackTrace();
         }
    }//FINE CLASSE RUN
   
    //MAIN
    public static void main (String a[]) throws SQLException, ClassNotFoundException {
       
        try{
                       
                invioFileXMLtoAndroid();
               
                }catch(IOException ex){
                        ex.printStackTrace();
                }
       
        Thread desktopServerThread = new Thread(new TCPDesktopServer());
        desktopServerThread.start();

    } //Fine MAIN
   
   
   
static public void invioFileXMLtoAndroid() throws IOException, SQLException, ClassNotFoundException{
               
                XmlWriter xmlwriterArt  = new XmlWriter(new     java.io.FileWriter("articoli.xml"));
            XmlWriter xmlwriterLog      = new XmlWriter(new     java.io.FileWriter("logspesa.xml"));
               
                Vector<ArticoloBean> VetArt = ArticoloDB.getAllArticolo(DBConnection.getBDConnection().getConnection());
                Vector<LogSpesaBean> VetLog = LogSpesaDB.getLogSpesa(DBConnection.getBDConnection().getConnection(),CalendarUtility.getTodayLong());           
               

                for(int j=0; j<VetArt.size(); j++)
                        {
                                xmlwriterArt.writeObject(VetArt.elementAt(j));
                        }
                xmlwriterArt.close();
               
               
               
                for(int j=0; j<VetLog.size(); j++)
                        {
                                xmlwriterLog.writeObject(VetLog.elementAt(j));
                        }
                xmlwriterLog.close();
               
       
        } //Fine classe invioFileXMLtoAndroid()
   
} //Fine public class TCPDesktopServer implements Runnable


e questa è la mia classe client:
Codice (Java): [Seleziona]
public class TCPClient implements Runnable {

       
    public void run() {
         try {
                 
                 InetAddress serverAddr = InetAddress.getByName("192.168.0.107");//TCPServer.SERVERIP
                 
                 Log.d("TCP", "C: Connecting to server...");
                 //Socket socket = new Socket(serverAddr, TCPDesktopServer.SERVERPORT);
                 Socket socket = new Socket(serverAddr, 4444);
                 String message = "CONNESSIONE CON IL SERVER AVVENUTA!";
                     try {
                         
                         Log.d("TCP", "C: Sending: '" + message + "'");
                         PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter(socket.getOutputStream())),true);
                         out.println(message);
                       
                         
                         //INVIO AL SERVER DEL FILE QUANTITATOSERVER CON IL QUALE SI AGGIORNERA' LA
                         //TABELLA DISPENSA SUL DATABASE ANFASS
                     File myFile = new File ("mnt/sdcard/QUANTITATOSERVER.xml");
                     FileInputStream fis = new FileInputStream(myFile);
                     BufferedInputStream bis = new BufferedInputStream(fis);
                     byte [] mybytearray = new byte [(int)myFile.length()];
                     bis.read(mybytearray,0,mybytearray.length);
                     OutputStream os = socket.getOutputStream();
                     os.write(mybytearray,0, mybytearray.length);
                     os.flush();
                 
                     
                     int filesize=6022386; // filesize temporary hardcoded

                     long startARTICOLI = System.currentTimeMillis();
                     int bytesReadARTICOLI;
                     int currentARTICOLI = 0;
                     
                     //long startLOGSPESA = System.currentTimeMillis();
                     //int bytesReadLOGSPESA;
                     //int currentLOGSPESA = 0;
                     
                     
                     //RICEZIONE DAL SERVER DEL FILE ARTICOLI.XML
                     
                     byte [] mybytearrayARTICOLI  = new byte [filesize];
                 InputStream isAR = socket.getInputStream();
                 FileOutputStream fosAR = new FileOutputStream("mnt/sdcard/articoli.xml");
                 BufferedOutputStream bosAR = new BufferedOutputStream(fosAR);
                 bytesReadARTICOLI = isAR.read(mybytearrayARTICOLI,0,mybytearrayARTICOLI.length);
                 currentARTICOLI = bytesReadARTICOLI;

                 do {
                    bytesReadARTICOLI = isAR.read(mybytearrayARTICOLI, currentARTICOLI, (mybytearrayARTICOLI.length-currentARTICOLI));
                    if(bytesReadARTICOLI >= 0) currentARTICOLI += bytesReadARTICOLI;
                 } while(bytesReadARTICOLI > -1);

                 bosAR.write(mybytearrayARTICOLI, 0 , currentARTICOLI);
                 bosAR.flush();
                 long endAR = System.currentTimeMillis();
                 System.out.println(endAR-startARTICOLI);
                 bosAR.close();
                 
                 
                 
                     //RICEZIONE DAL SERVER DEL FILE LOGSPESA.XML
                 /*
                 byte [] mybytearrayLOGSPESA  = new byte [filesize];
                 InputStream isLS = socket.getInputStream();
                 FileOutputStream fosLS = new FileOutputStream("mnt/sdcard/logspesa.xml");
                 BufferedOutputStream bosLS = new BufferedOutputStream(fosLS);
                 bytesReadLOGSPESA = isLS.read(mybytearrayLOGSPESA,0,mybytearrayLOGSPESA.length);
                 currentLOGSPESA = bytesReadLOGSPESA;

                 do {
                    bytesReadLOGSPESA = isLS.read(mybytearrayLOGSPESA, currentLOGSPESA, (mybytearrayLOGSPESA.length-currentLOGSPESA));
                    if(bytesReadLOGSPESA >= 0) currentLOGSPESA += bytesReadLOGSPESA;
                 } while(bytesReadLOGSPESA > -1);

                 bosLS.write(mybytearrayLOGSPESA, 0 , currentLOGSPESA);
                 bosLS.flush();
                 long endLS = System.currentTimeMillis();
                 System.out.println(endLS-startLOGSPESA);
                 bosLS.close();
                     
                     */

                     
                     
                     
                     
                     Log.d("TCP", "C: Sent.");
                     Log.d("TCP", "C: Done. DATI INVIATI!");
                     
                     
                     
                     
             } catch(Exception e) {
                 Log.e("TCP", "S: Error", e);
                      } finally {
                        socket.close();
                      }
         } catch (Exception e) {
              Log.e("TCP", "C: Error", e);
         }
    }
}

Per ora sul client sto cercando di andare a salvarmi su sd solo il file articoli.xml ricevuto dal server ma quello che accade che in sd
ho un file articoli.xml vuoto e non riesco a capire come mai...
vi ringrazio ciao...


nel LOGCAT a volte ho il seguente errore:
11-13 14:43:46.679: ERROR/TCP(3678): S: Error
11-13 14:43:46.679: ERROR/TCP(3678): java.lang.ArrayIndexOutOfBoundsException: Offset out of bounds : -1
11-13 14:43:46.679: ERROR/TCP(3678):     at org.apache.harmony.luni.net.SocketInputStream.read(SocketInputStream.java:82)
11-13 14:43:46.679: ERROR/TCP(3678):     at ch.egsolutions.databasetutorial.TCPClient.run(TCPClient.java:71)
11-13 14:43:46.679: ERROR/TCP(3678):     at java.lang.Thread.run(Thread.java:1096)
« Ultima modifica: 13 Novembre 2010, 15:48:10 CET da Albe85 »

Offline Ricky`

  • Amministratore
  • Utente storico
  • *****
  • Post: 3489
  • Respect: +506
    • Github
    • Google+
    • rciovati
    • Mostra profilo
Re:problema nella ricezione di file dal server
« Risposta #1 il: 13 Novembre 2010, 17:08:25 CET »
0
1)I file sulla sd non si indicano il quel modo ma si usa Environment.getExternalStorageDirectory()
2)Dato che l'xml sono file di testo perchè non usi le funzionalità di lettura/scrittura di stringhe da e sul socket?

Offline Albe85

  • Utente junior
  • **
  • Post: 102
  • Respect: +1
    • Mostra profilo
Re:problema nella ricezione di file dal server
« Risposta #2 il: 14 Novembre 2010, 18:01:01 CET »
0
i file xml preferirei riceverli come file perchè successivamente ne faccio il parsing e i campi che vado a leggere all'interno dei tag li salvo in un database su cui poi ci faccio diverse operazioni...quindi preferirei dato che poi ci faccio già il parsing ricevere i due file xml puliti...solo che non capisco perchè mi scrive due file nella sd vuoti...come se non riuscisse a prendere l'input stream sul socket e a scriverlo nel file...non capisco se è un problema di conflitto tra le operazioni di invio al server e di ricezione dal server che faccio sul socket stesso...

Offline Albe85

  • Utente junior
  • **
  • Post: 102
  • Respect: +1
    • Mostra profilo
Re:problema nella ricezione di file dal server
« Risposta #3 il: 14 Novembre 2010, 19:32:01 CET »
0
mi sa che il problema è il fatto che metto due richieste di comunicazione consecutive sia sul server che sul client...se commento la parte sia sul server che sul client inerente al file QUANTITATOSERVER il file (ad esempio) articoli.xml inviato dal server viene correttamente ricevuto dal client...
dite che devo fare diversi try catch per ciascuna azione?

Offline Albe85

  • Utente junior
  • **
  • Post: 102
  • Respect: +1
    • Mostra profilo
Re:problema nella ricezione di file dal server
« Risposta #4 il: 15 Novembre 2010, 10:02:07 CET »
0
Ho un comportamento stranissimo. Praticamente sulla sd mi si creano i due file xml che vengono mandati dal server solo che praticamente in entrambi avviene la scrittura dei file xml consecutiva con conseguente errore quando apro il file che mi dice che ovviamente nei documenti XML è consentito un solo elemento di primo livello. Ho provato a crearmi due thread separati lato client nei quali in uno ricevo il primo file e nell'altro ricevo il secondo ma evidentemente non è quello il problema in quanto mi si creano nella sd virtuale due file identici con diversi nomi  ovviamente ma con contenuto identico che è quello precedentemente descritto.

Quello che faccio lato server è la seguente cosa:

Codice (Java): [Seleziona]
public class TCPDesktopServer implements Runnable{
       
    public static final String SERVERIP = "127.0.0.1";
    public static final int SERVERPORT = 4444;
         
    public void run() {
         try {
                 System.out.println("S: Connecting...");
             
             ServerSocket serverSocket = new ServerSocket(SERVERPORT);
             while (true) {
                 
                    int filesize=6022386; // filesize temporary hardcoded

                    long start = System.currentTimeMillis();
                    int bytesRead;
                    int current = 0;

                 
                  Socket client = serverSocket.accept();
                  System.out.println("S: Receiving to client...");
         
                  try {
                     
                          BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                      String str = in.readLine();
                      System.out.println("S: Received: '" + str + "'");
                     
                               
                            // Server che invia il file articoli.xml
                                DataOutputStream outArt = new DataOutputStream(client.getOutputStream());
                                FileInputStream inArt = new FileInputStream("articoli.xml");
                                byte bufferArt[] = new byte[1024];
                                System.out.println( "Invio file in corso articoli.xml..." );
                                int iArt;
                                while((iArt = inArt.read(bufferArt,0,bufferArt.length)) != -1){
                                outArt.write(bufferArt,0,iArt);
                                outArt.flush();
                                }
                                inArt.close();
                                System.out.println( "Invio completato." );
                               
                               
                            //Server che invia il file logspesa.xml
                                DataOutputStream outLog = new DataOutputStream(client.getOutputStream());
                                FileInputStream inLog = new FileInputStream("logspesa.xml");
                                byte bufferLog[] = new byte[1024];
                                System.out.println( "Invio file in corso logspesa.xml..." );
                                int iLog;
                                while((iLog = inLog.read(bufferLog,0,bufferLog.length)) != -1){
                                outLog.write(bufferLog,0,iLog);
                                outLog.flush();
                                }
                                inLog.close();
                                System.out.println( "Invio completato." );
       

                    } catch(Exception e) {
                        System.out.println("S: Error");
                        e.printStackTrace();
                    } finally {
                        client.close();
                        System.out.println("S: Done.");
                    }

             }
             
         } catch (Exception e) {
             System.out.println("S: Error");
             e.printStackTrace();
         }
    }//FINE CLASSE RUN

Lato android mi sono creato queste due classi di ricezione dei file:
Codice (Java): [Seleziona]
 public void run() {
         try {
                 
                 InetAddress serverAddr = InetAddress.getByName("192.168.0.107");//TCPServer.SERVERIP
                 
                 Log.d("TCP", "C: Connecting to server...");
                 //Socket socket = new Socket(serverAddr, TCPDesktopServer.SERVERPORT);
                 Socket socket = new Socket(serverAddr, 4444);
       
                 
                 String message = "CONNESSIONE CON IL SERVER AVVENUTA!";
                     try {
                         
                         Log.d("TCP", "C: Sending: '" + message + "'");
                         PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter(socket.getOutputStream())),true);
                         out.println(message);

                     System.out.println("Ricezione file in corso articoli.xml..");
                     DataInputStream inArt = new DataInputStream(socket.getInputStream());
                     File sdcardDirArt = Environment.getExternalStorageDirectory();
                         File myFileArt = new File(sdcardDirArt,"articoli.xml");
                     FileOutputStream outArt = new FileOutputStream(myFileArt);
                     byte bufferArt[] = new byte[1024];
                     int iArt;
                     while ((iArt = inArt.read(bufferArt,0,bufferArt.length)) != -1){
                     System.out.println("ci sono");
                     outArt.write(bufferArt,0,iArt);
                     }
                     outArt.flush();
                     outArt.close();
                     System.out.println( "Ricezione completata!" );
   
                     Log.d("TCP", "C: Sent.");
                     Log.d("TCP", "C: Done. DATI INVIATI!");
                     
                     
             } catch(Exception e) {
                 Log.e("TCP", "S: Error", e);
                      } finally {
                        socket.close();
                     
                      }
         } catch (Exception e) {
              Log.e("TCP", "C: Error", e);
         }
         
         
    }//chiusura metodo run

}//chiusura public class TCPClient implements Runnable

L'altra non la metto tanto è identica a questa appena riportata. Quello che cambia è il nome del file che viene ricevuto.
Non capisco come mai il flusso dei dati mandato dal server viene inserito completamente all'interno dei file.
Grazie per l'aiuto.
Ciao

Offline Albe85

  • Utente junior
  • **
  • Post: 102
  • Respect: +1
    • Mostra profilo
Re:problema nella ricezione di file dal server
« Risposta #5 il: 15 Novembre 2010, 19:20:20 CET »
0
ho risolto il problema..più tardi posterò la soluzione...

Offline Albe85

  • Utente junior
  • **
  • Post: 102
  • Respect: +1
    • Mostra profilo
Re:problema nella ricezione di file dal server
« Risposta #6 il: 15 Novembre 2010, 20:45:17 CET »
0
Questa è parte della classe server...in pratica in base al tipo di richiesta che viene fatta dal client viene aperto nell'activity un nuovo thread...il server risponderà fornendo i dati richiesti dal server o salverà i dati inviati dal client....
Codice (Java): [Seleziona]
public class TCPDesktopServer implements Runnable{
       
    public static final String SERVERIP = "127.0.0.1";
    public static final int SERVERPORT = 4444;
         
    public void run() {
         try {
                 System.out.println("SERVER: Connecting...");
             
             ServerSocket serverSocket = new ServerSocket(SERVERPORT);
             while (true) {
                 
                    int filesize=6022386; // filesize temporary hardcoded

                    long start = System.currentTimeMillis();
                    int bytesRead;
                    int current = 0;

                 
                  Socket client = serverSocket.accept();
                  System.out.println("S: Receiving to client...");
         
                  try {
                     
                          BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                      String str = in.readLine();
                      //System.out.println(str);
                     
                   
                     
                     if("INVIAMI IL FILE ARTICOLI.XML".equals(str)){
                      System.out.println("S: CLIENT DICE: '" + str + "'");
                        // Server che invia il file articoli.xml
                        DataOutputStream outArt = new DataOutputStream(client.getOutputStream());
                                FileInputStream inArt = new FileInputStream("articoli.xml");
                                byte bufferArt[] = new byte[1024];
                                System.out.println( "Invio file in corso articoli.xml..." );
                                int iArt;
                                while((iArt = inArt.read(bufferArt,0,bufferArt.length)) != -1){
                                outArt.write(bufferArt,0,iArt);
                                outArt.flush();
                                }
                                inArt.close();
                                System.out.println( "Invio completato." );                    
                     }
                     
                     
                     if("INVIAMI IL FILE LOGSPESA.XML".equals(str)){
                         System.out.println("S: CLIENT DICE: '" + str + "'");
                       //Server che invia il file logspesa.xml
                                DataOutputStream outLog = new DataOutputStream(client.getOutputStream());
                                FileInputStream inLog = new FileInputStream("logspesa.xml");
                                byte bufferLog[] = new byte[1024];
                                System.out.println( "Invio file in corso logspesa.xml..." );
                                int iLog;
                                while((iLog = inLog.read(bufferLog,0,bufferLog.length)) != -1){
                                outLog.write(bufferLog,0,iLog);
                                outLog.flush();
                                }
                                inLog.close();
                                System.out.println( "Invio completato." );
                        }
                     
                     
                     if("TI INVIO LE QUANTITA COMPERATE".equals(str)){
                         System.out.println("S: CLIENT DICE: '" + str + "'");
                           //RICEZIONE NELLA CARTELLA DI LAVORO DEL FILE QUANTITATOSERVER.xml DAL
                           //DISPOSITIVO MOBILE
                           byte [] mybytearray  = new byte [filesize];
                           InputStream is = client.getInputStream();
                           FileOutputStream fos = new FileOutputStream("QUANTITATOSERVER.xml");
                           BufferedOutputStream bos = new BufferedOutputStream(fos);
                           bytesRead = is.read(mybytearray,0,mybytearray.length);
                           current = bytesRead;

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

                           bos.write(mybytearray, 0 , current);
                           bos.flush();
                           long end = System.currentTimeMillis();
                           System.out.println("TEMPO IMPIEGATO RICEZIONE DA PARTE DEL SERVER DEL FILE QUANTITATOSERVER.XML: "+(end-start));
                           bos.close();
                        }

Questa è una classe client...ne ho fatte tre...una per ogni azione che può compiere il client...
Codice (Java): [Seleziona]
public class TCPClientLogSpesa implements Runnable {

       
    public void run() {
         try {
                 
                 InetAddress serverAddr = InetAddress.getByName("192.168.0.107");//TCPServer.SERVERIP
                 
                 Log.d("TCP", "C: Connecting to server...");
                 //Socket socket = new Socket(serverAddr, TCPDesktopServer.SERVERPORT);
                 Socket socket = new Socket(serverAddr, 4444);
       
                 
                 String message = "INVIAMI IL FILE LOGSPESA.XML";
                     try {
                         
                         Log.d("TCP", "C: Sending: '" + message + "'");
                       
                         PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter(socket.getOutputStream())),true);
                         out.println(message);
                       
                     
                     System.out.println("Ricezione file in corso logspesa.xml..");
                     DataInputStream inLog = new DataInputStream(socket.getInputStream());
                     File sdcardDirLog = Environment.getExternalStorageDirectory();
                         File myFileLog = new File(sdcardDirLog,"logspesa.xml");
                     FileOutputStream outLog = new FileOutputStream(myFileLog);
                     byte bufferLog[] = new byte[1024];
                     int iLog;
                     while ((iLog = inLog.read(bufferLog,0,bufferLog.length)) != -1){
                     System.out.println("ci sono");
                     outLog.write(bufferLog,0,iLog);
                     }
                     outLog.flush();
                     outLog.close();
                     System.out.println( "Ricezione completata!" );

                     Log.d("TCP", "C: Sent.");
                     Log.d("TCP", "C: Done. DATI INVIATI!");
                     
                     
                     
                     
             } catch(Exception e) {
                 Log.e("TCP", "S: Error", e);
                      } finally {
                        socket.close();
                     
                      }
         } catch (Exception e) {
              Log.e("TCP", "C: Error", e);
         }
         
         
    }//chiusura metodo run

}//chiusura public class TCPClient implements Runnable

Nell'activity basta chiamare al punto corretto a cui si vuole far partire la richiesta al server il thread nel seguente modo:
Codice (Java): [Seleziona]
 //!!!!!!!!!!!!THREAD COMUNICAZIONE CON IL SERVER!!!!!!!!!!!
                        Thread cThread = new Thread(new TCPClientArticoli());
                        cThread.start();
       
                        Thread cThread2 = new Thread(new TCPClientLogSpesa());
                        cThread2.start();

Praticamente si crea una sorta di protocollo di comunicazione tra client (android) e server...