Autore Topic: problema lettura di un InputStream con metodo read()  (Letto 393 volte)

Offline MasterChief

  • Utente junior
  • **
  • Post: 83
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    OnePlus X
  • Sistema operativo:
    windows 10
problema lettura di un InputStream con metodo read()
« il: 16 Maggio 2015, 00:00:36 CEST »
0
Ciao a tutti ragazzi, ho un problema con il metodo read() e lo uso per leggere i dati in ingresso da una porta seriale. In poche parole ho un inputStream di una porta seriale nel quale passano tutti i dati che la mia applicazione android dovrebbe leggere. Il metodo read() legge l'inputStream byte per byte e ritorna -1 se ha raggiunto la fine dello stesso. Il problema sta proprio qui... con questo codice
Codice (Java): [Seleziona]
try {
    while ( (n = mInputStream.read()) != -1 ) {
        inputBuffer.add((byte) n);
    }
}catch (IOException e) {
    e.printStackTrace();
}finally {
    byte[] input = retByte(inputBuffer);//ottengo l'array dall'arrayList
    byte[] block = getBlockFromStream(input, input.length);//estraggo il blocco che mi interessa
    boolean isFrame = checkFrame(block);//guardo se è un frame completo
    if (isFrame) {
        onDataReceived(block, block.length);//se si controllo ack
    }
}

teoricamente dovrei gestire la fine dello stream, ma durante il debugging proprio quando raggiungo la fine dello stream, il codice esce dal while e salta tutto il finally, come se si sollevasse un'eccezione ma non accadesse nulla... e dalla documentazione vengono sollevate solo IOException che qui vengono catturate.
Qualcuno ha avuto esperienze in merito e sa dirmi come risolvere questa cosa?  :-)

Grazie mille in anticipo per le risposte.

Post unito: 16 Maggio 2015, 11:02:03 CEST
Ho risolto googlando come un dannato  ;-) e ho trovato qualcuno che sosteneva che in certi casi è più conveniente leggere solo un tot di byte e non fino alla fine dello stream. Nel mio caso particolare sapevo che al momento della read non ottenevo più di 4 byte in ingresso. Nel dubbio ho tenuto 8 byte per sicurezza e questo è il codice aggiornato
Codice (Java): [Seleziona]
try {
    inputBuffer = new ArrayList<>();
    int bytesRead, count = 0;
    byte[] buffer = new byte[8];
    while ( count < 7 && ((bytesRead = mInputStream.read(buffer, 0, 8)) >= 0) ) { //il controllo così serve per aggirare il problema del -1 tornato dalla read
        for (int i = 0; i < bytesRead; i++) {
            //popolo l'arraylist con i dati letti
            inputBuffer.add(buffer[i]);
        }
        count += bytesRead; //count è al limite 7 perché il frame in ingresso è al massimo 7 bytes
    }
} catch (IOException e) {
    e.printStackTrace();
}finally{
    //Estraggo l'array di byte completo della dimensione inputBuffer.size();
}
Metto tutti i dati in un'ArrayList in quanto a priori non so dare una dimensione precisa ai dati che leggero; ma poi creo un buffer della dimensione corretta.
Non ho dubbi che questo codice possa essere migliorato, ma potrebbe essere un buon punto di partenza per chi incontrerà questo problema come me.  :D

Spero di essere stato sufficientemente chiaro,
Un saluto a tutti  :-)
« Ultima modifica: 16 Maggio 2015, 11:02:03 CEST da MasterChief, Reason: Merged DoublePost »