Mantenere viva la connessione Java Bluetooth
Sto costruendo un semplice server Java Bluetooth per il mio computer utilizzando l'API Bluecove. Sto costruendo anche un'app lato client Android, ma il problema sembra derivare dall'app lato server.
Sono sicuro che qualcuno ha già pubblicato qualche risposta da qualche parte e ho provato diverse soluzioni rigorosamente negli ultimi giorni e ho guardato ogni forum possibile, ma non riesco a mantenere viva la connessione sul thread del socket.
Posso scambiare un messaggio dopo un la connessione viene stabilita da Android al computer e viceversa dal computer ad Android, ma immediatamente dopo lo scambio dei byte, lo stack Bluecove si spegne e chiude la connessione socket anche quando non lo dico esplicitamente alla connessione.vicino().
Ho provato a usare un ciclo while(qualche istruzione è vera) per mantenere viva la connessione e non spegne più il socket dopo aver ricevuto il primo messaggio ma non può ricevere messaggi successivi che invio dal mio smartphone al mio computer sia. Mentre è essenzialmente vivo, non può ricevere nuovi messaggi quando provo a inviarli dallo smartphone. Non so perché.
Mi dispiace, questa è la mia prima pubblicazione e non sono sicuro del motivo per cui la prima parte del codice non viene visualizzata correttamente sulla pagina.
Collegamento per la creazione del codice:
public BluetoothServer()
{
try
{
service = (StreamConnectionNotifier)
Connector.open("btspp://localhost:" + new UUID(0x1101).toString() +
";name=SampleServer");
System.out.println("open connection");
while(runState == true){
connection = (StreamConnection) service.acceptAndOpen();
//send a greeting across to android
outputStream = connection.openOutputStream();
String greeting = "JSR-82 RFCOMM server says hello";
outputStream.write(greeting.getBytes());
//run thread that listens for incoming bytes through socket connection
Thread t = new Thread(new ConnectedThread(connection));
t.start();
}
} catch(IOException e) {}
}
CODICE THREAD PER L'ASCOLTO DEI DATI IN ENTRATA
public void run()
{
try
{
//open input stream to listen to data
inputStream = connection.openInputStream();
byte buffer[] = new byte[1024];
int bytes_read = inputStream.read(buffer);
String received = new String(buffer, 0, bytes_read);
System.out.println("received: " + received);
}
catch(IOException e){}
}
1 answers
Sfortunatamente non posso provare il tuo codice sulla mia macchina in tempo reale, ma penso di aver visto il tuo errore: nel tuo metodo run () che leggi dal flusso di input, stampalo sulla console e poi è finito. Dopo l'ultima riga
System.out.println("received: " + received);
Il metodo run () è terminato e il thread viene scartato dal runtime. Dovresti mettere la ricezione in un ciclo while(true) o while(running).
Ho modificato il tuo codice ed eccolo qui, tuttavia per favore tieni presente quello che ho detto prima: non ho potuto eseguire il test esso, quindi viene totalmente non testato!
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.bluetooth.UUID;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;
import javax.microedition.io.StreamConnectionNotifier;
public class BluetoothServer {
private boolean runState = true;
public BluetoothServer(){
try {
StreamConnectionNotifier service = (StreamConnectionNotifier) Connector.open("btspp://localhost:" + new UUID(0x1101).toString() + ";name=SampleServer");
System.out.println("open connection");
while(runState == true){
StreamConnection connection = (StreamConnection) service.acceptAndOpen();
new Listener(connection).start();
}
} catch(IOException e) {
e.printStackTrace();
}
}
private class Listener extends Thread{
private OutputStream os;
private InputStream is;
public Listener(StreamConnection connection){
try {
this.os = connection.openOutputStream();
os.flush();
this.is = connection.openInputStream();
} catch (IOException e) {
e.printStackTrace();
}
}
public void run(){
StringBuilder builder;
try{
String greeting = "JSR-82 RFCOMM server says hello";
os.write(greeting.getBytes());
while(true){
builder = new StringBuilder();
int tmp = 0;
while((tmp = is.read()) != -1){
builder.append((char) tmp);
}
System.out.println("received: " + builder.toString());
}
}
catch(IOException e){
e.printStackTrace();
}
}
}
}
Ecco alcuni punti generali e pensieri sul mio e sul tuo codice:
- Come puoi vedere, nel thread principale accetto solo una nuova connessione. Non appena un client si è connesso, do l'oggetto di connessione al thread. Inizia quindi a comunicare con il cliente
- In Java, normalmente mettiamo parentesi di apertura sulla stessa riga dell'istruzione che lo richiede, ma questo è solo un dettaglio e non un must.
- SEMPRE fare qualcosa con eccezioni o non li cattura. Quindi il minimo è un printStacktrace () o dichiarare il tuo metodo con "throws xException" ma non catturarli e ignorarli.
Per la prossima volta che pubblichi qualcosa qui, ti consiglio di includere tutte le tue istruzioni di importazione, ecc., può aiutare la gente che sta provando ad aiutarla. (a volte, un'importazione può essere la causa di tutti i problemi, ad esempio quando qualcuno ha importato java.oh.Elenco invece di java.util.Elenco)
Spero che ti ho aiutato!