Actualmente estoy tratando de lidiar con una extraña Excepción al abrir un BluetoothSocket en mi Nexus 7 (2012), con Android 4.3 (Build JWR66Y, supongo que la segunda actualización 4.3). He visto algunas publicaciones relacionadas (por ejemplo, /programming/13648373/bluetoothsocket-connect-throwing-exception-read-failed ), pero ninguna parece proporcionar una solución para este problema. Además, como se sugiere en estos hilos, volver a emparejar no ayuda, y tratar de conectarse constantemente (a través de un bucle estúpido) tampoco tiene ningún efecto.
Estoy tratando con un dispositivo integrado (un adaptador para automóvil OBD-II que no es de nombre, similar a http://images04.olx.com/ui/15/53/76/1316534072_254254776_2-OBD-II-BLUTOOTH-ADAPTERSCLEAR-CHECK-ENGINE- LUCES-CON-SU-TELÉFONO-Oceanside.jpg ). Mi teléfono Android 2.3.7 no tiene problemas para conectarse y el Xperia de un colega (Android 4.1.2) también funciona. Otro Google Nexus (no sé si 'One' o 'S', pero no '4') también falla con Android 4.3.
Aquí está el fragmento del establecimiento de la conexión. Se ejecuta en su propio subproceso, creado dentro de un servicio.
private class ConnectThread extends Thread {
private static final UUID EMBEDDED_BOARD_SPP = UUID
.fromString("00001101-0000-1000-8000-00805F9B34FB");
private BluetoothAdapter adapter;
private boolean secure;
private BluetoothDevice device;
private List<UUID> uuidCandidates;
private int candidate;
protected boolean started;
public ConnectThread(BluetoothDevice device, boolean secure) {
logger.info("initiliasing connection to device "+device.getName() +" / "+ device.getAddress());
adapter = BluetoothAdapter.getDefaultAdapter();
this.secure = secure;
this.device = device;
setName("BluetoothConnectThread");
if (!startQueryingForUUIDs()) {
this.uuidCandidates = Collections.singletonList(EMBEDDED_BOARD_SPP);
this.start();
} else{
logger.info("Using UUID discovery mechanism.");
}
/*
* it will start upon the broadcast receive otherwise
*/
}
private boolean startQueryingForUUIDs() {
Class<?> cl = BluetoothDevice.class;
Class<?>[] par = {};
Method fetchUuidsWithSdpMethod;
try {
fetchUuidsWithSdpMethod = cl.getMethod("fetchUuidsWithSdp", par);
} catch (NoSuchMethodException e) {
logger.warn(e.getMessage());
return false;
}
Object[] args = {};
try {
BroadcastReceiver receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
BluetoothDevice deviceExtra = intent.getParcelableExtra("android.bluetooth.device.extra.DEVICE");
Parcelable[] uuidExtra = intent.getParcelableArrayExtra("android.bluetooth.device.extra.UUID");
uuidCandidates = new ArrayList<UUID>();
for (Parcelable uuid : uuidExtra) {
uuidCandidates.add(UUID.fromString(uuid.toString()));
}
synchronized (ConnectThread.this) {
if (!ConnectThread.this.started) {
ConnectThread.this.start();
ConnectThread.this.started = true;
unregisterReceiver(this);
}
}
}
};
registerReceiver(receiver, new IntentFilter("android.bleutooth.device.action.UUID"));
registerReceiver(receiver, new IntentFilter("android.bluetooth.device.action.UUID"));
fetchUuidsWithSdpMethod.invoke(device, args);
} catch (IllegalArgumentException e) {
logger.warn(e.getMessage());
return false;
} catch (IllegalAccessException e) {
logger.warn(e.getMessage());
return false;
} catch (InvocationTargetException e) {
logger.warn(e.getMessage());
return false;
}
return true;
}
public void run() {
boolean success = false;
while (selectSocket()) {
if (bluetoothSocket == null) {
logger.warn("Socket is null! Cancelling!");
deviceDisconnected();
openTroubleshootingActivity(TroubleshootingActivity.BLUETOOTH_EXCEPTION);
}
// Always cancel discovery because it will slow down a connection
adapter.cancelDiscovery();
// Make a connection to the BluetoothSocket
try {
// This is a blocking call and will only return on a
// successful connection or an exception
bluetoothSocket.connect();
success = true;
break;
} catch (IOException e) {
// Close the socket
try {
shutdownSocket();
} catch (IOException e2) {
logger.warn(e2.getMessage(), e2);
}
}
}
if (success) {
deviceConnected();
} else {
deviceDisconnected();
openTroubleshootingActivity(TroubleshootingActivity.BLUETOOTH_EXCEPTION);
}
}
private boolean selectSocket() {
if (candidate >= uuidCandidates.size()) {
return false;
}
BluetoothSocket tmp;
UUID uuid = uuidCandidates.get(candidate++);
logger.info("Attempting to connect to SDP "+ uuid);
try {
if (secure) {
tmp = device.createRfcommSocketToServiceRecord(
uuid);
} else {
tmp = device.createInsecureRfcommSocketToServiceRecord(
uuid);
}
bluetoothSocket = tmp;
return true;
} catch (IOException e) {
logger.warn(e.getMessage() ,e);
}
return false;
}
}
El código falla en bluetoothSocket.connect()
. Estoy obteniendo un java.io.IOException: read failed, socket might closed, read ret: -1
. Esta es la fuente correspondiente en GitHub: https://github.com/android/platform_frameworks_base/blob/android-4.3_r2/core/java/android/bluetooth/BluetoothSocket.java#L504
Se llama a través de readInt (), llamado desde https : //github.com/android/platform_frameworks_base/blob/android-4.3_r2/core/java/android/bluetooth/BluetoothSocket.java#L319
Algunos volcados de metadatos del socket utilizado dieron como resultado la siguiente información. Son exactamente iguales en Nexus 7 y mi teléfono 2.3.7.
Bluetooth Device 'OBDII'
Address: 11:22:33:DD:EE:FF
Bond state: 12 (bonded)
Type: 1
Class major version: 7936
Class minor version: 7936
Class Contents: 0
Contents: 0
Tengo algunos otros adaptadores OBD-II (más expansivos) y todos funcionan. ¿Existe alguna posibilidad de que me esté perdiendo algo o podría tratarse de un error en Android?
Respuestas:
Finalmente encontré una solución. La magia está oculta bajo el capó de la
BluetoothDevice
clase (ver https://github.com/android/platform_frameworks_base/blob/android-4.3_r2/core/java/android/bluetooth/BluetoothDevice.java#L1037 ).Ahora, cuando recibo esa excepción, creo una instancia de respaldo
BluetoothSocket
, similar al código fuente a continuación. Como puede ver, invocando el método oculto acreateRfcommSocket
través de reflejos. No tengo ni idea de por qué este método está oculto. El código fuente lo define comopublic
si ...connect()
entonces ya no falla. Todavía he experimentado algunos problemas. Básicamente, esto a veces se bloquea y falla. Reiniciar el dispositivo SPP (desconectar / conectar) ayuda en tales casos. A veces también recibo otra solicitud de emparejamientoconnect()
incluso cuando el dispositivo ya está vinculado.ACTUALIZAR:
aquí hay una clase completa, que contiene algunas clases anidadas. para una implementación real, estos podrían llevarse a cabo como clases separadas.
fuente
Fallback failed. Cancelling. java.io.IOException: Connection refused
Por favor ayuda.Bueno, tuve el mismo problema con mi código, y es porque desde Android 4.2 la pila bluetooth ha cambiado. así que mi código funcionaba bien en dispositivos con Android <4.2, en los otros dispositivos recibía la famosa excepción "falló la lectura, el socket podría cerrarse o se agotó el tiempo de espera, leer ret: -1"
El problema está en el
socket.mPort
parámetro. Cuando crea su socket usandosocket = device.createRfcommSocketToServiceRecord(SERIAL_UUID);
,mPort
obtiene el valor entero " -1 ", y este valor parece no funcionar para android> = 4.2, por lo que debe establecerlo en " 1 ". La mala noticia es quecreateRfcommSocketToServiceRecord
solo acepta UUID como parámetro y nomPort
por eso tenemos que usar otro enfoque. La respuesta Publicado por @matthes también trabajó para mí, pero yo lo simplificó:socket =(BluetoothSocket) device.getClass().getMethod("createRfcommSocket", new Class[] {int.class}).invoke(device,1);
. Necesitamos usar ambos atributos de socket, el segundo como respaldo.Entonces el código es (para conectarse a un SPP en un dispositivo ELM327):
fuente
mPort
parámetro! En mi humilde opinión, el flujo de trabajo sigue siendo el mismo, acabo de envolver las cosas con algunas clases que implementan una interfaz.Primero, si necesita hablar con un dispositivo bluetooth 2.x, esta documentación establece que:
No pensé que funcionaría, pero solo reemplazando el UUID con
00001101-0000-1000-8000-00805F9B34FB
él funciona. Sin embargo, este código parece manejar el problema de la versión del SDK, y puede reemplazar la funcióndevice.createRfcommSocketToServiceRecord(mMyUuid);
contmp = createBluetoothSocket(mmDevice);
después de definir el siguiente método:El código fuente no es mío, sino que proviene de este sitio web .
fuente
Tuve los mismos síntomas que se describen aquí. Pude conectarme una vez a una impresora bluetooth, pero las conexiones posteriores fallaron con el "enchufe cerrado" sin importar lo que hice.
Me pareció un poco extraño que fueran necesarias las soluciones que se describen aquí. Después de revisar mi código, descubrí que había olvidado cerrar InputStream y OutputSteram del socket y no había terminado ConnectedThreads correctamente.
El ConnectedThread que uso es el mismo que en el ejemplo aquí:
http://developer.android.com/guide/topics/connectivity/bluetooth.html
Tenga en cuenta que ConnectThread y ConnectedThread son dos clases diferentes.
Cualquier clase que inicie ConnectedThread debe llamar a interrupt () y cancel () en el hilo. Agregué mmInStream.close () y mmOutStream.close () en el método ConnectedTread.cancel ().
Después de cerrar los subprocesos / flujos / sockets correctamente, pude crear nuevos sockets sin ningún problema.
fuente
Bueno, de hecho encontré el problema.
La mayoría de las personas que intentan establecer una conexión con
socket.Connect();
obtienen una excepción llamadaJava.IO.IOException: read failed, socket might closed, read ret: -1
.En algunos casos, también depende de su dispositivo Bluetooth, porque hay dos tipos diferentes de Bluetooth, a saber, BLE (baja energía) y Classic.
Si desea verificar el tipo de dispositivo Bluetooth que es, aquí está el código:
Llevo días intentando solucionar el problema, pero desde hoy he encontrado el problema. La solución de @matthes lamentablemente todavía tiene algunos problemas como ya dijo, pero aquí está mi solución.
Actualmente trabajo en Xamarin Android, pero esto también debería funcionar para otras plataformas.
SOLUCIÓN
Si hay más de un dispositivo emparejado, debe eliminar los otros dispositivos emparejados. Así que conserve solo el que desea conectar (vea la imagen de la derecha).
En la imagen de la izquierda puede ver que tengo dos dispositivos emparejados, a saber, "MOCUTE-032_B52-CA7E" y "Blue Easy". Ese es el problema, pero no tengo idea de por qué ocurre ese problema. Quizás el protocolo Bluetooth esté intentando obtener información de otro dispositivo Bluetooth.
sin embargo, el
socket.Connect();
funciona muy bien ahora mismo, sin ningún problema. Así que solo quería compartir esto, porque ese error es realmente molesto.¡Buena suerte!
fuente
En las versiones más recientes de Android, recibía este error porque el adaptador todavía estaba descubriendo cuando intenté conectarme al enchufe. Aunque llamé al método cancelDiscovery en el adaptador Bluetooth, tuve que esperar hasta que se llamara a la devolución de llamada al método onReceive () de BroadcastReceiver con la acción BluetoothAdapter.ACTION_DISCOVERY_FINISHED.
Una vez que esperé a que el adaptador detuviera el descubrimiento, la llamada de conexión en el socket se realizó correctamente.
fuente
Lo pones
registerReceiver(receiver, new IntentFilter("android.bleutooth.device.action.UUID"));
con "bluetooth" deletreado "bleutooth".fuente
En caso de que alguien tenga problemas con Kotlin, tuve que seguir la respuesta aceptada con algunas variaciones:
Espero eso ayude
fuente
Los dispositivos Bluetooth pueden funcionar en modo clásico y LE al mismo tiempo. A veces usan una dirección MAC diferente dependiendo de la forma en que se conecte. Vocación
socket.connect()
se usa Bluetooth Classic, por lo que debe asegurarse de que el dispositivo que obtuvo cuando escaneó fuera realmente un dispositivo clásico.Sin embargo, es fácil filtrar solo para dispositivos Classic:
if(BluetoothDevice.DEVICE_TYPE_LE == device.getType()){ //socket.connect() }
Sin esta verificación, es una condición de carrera si un escaneo híbrido le dará primero el dispositivo Classic o el dispositivo BLE. Puede parecer como una incapacidad intermitente para conectarse, o como ciertos dispositivos que pueden conectarse de manera confiable mientras que otros aparentemente nunca pueden hacerlo.
fuente
También me enfrenté a este problema, podría resolverlo de 2 maneras, como se mencionó anteriormente, use la reflexión para crear el socket.La segunda es, el cliente está buscando un servidor con UUID dado y si su servidor no se ejecuta en paralelo al cliente, entonces esto sucede. Cree un servidor con el UUID de cliente dado y luego escuche y acepte el cliente desde el lado del servidor.
fuente
Me encontré con este problema y lo solucioné cerrando los flujos de entrada y salida antes de cerrar el socket. Ahora puedo desconectarme y conectarme de nuevo sin problemas.
https://stackoverflow.com/a/3039807/5688612
En Kotlin:
fuente
Si otra parte de su código ya ha realizado una conexión con el mismo socket y UUID, obtiene este error.
fuente
Incluso tuve el mismo problema, finalmente entendí mi problema, estaba tratando de conectarme desde el rango de cobertura de Bluetooth (fuera del alcance).
fuente
Tuve este problema y la solución fue usar el GUID mágico especial.
Sospecho que estos son los UUID que funcionan:
Sin embargo, no los he probado todos.
fuente
Al agregar una acción de filtro, mi problema se resolvió
fuente
También he recibido lo mismo
IOException
, pero encuentro la demostración del sistema Android: el proyecto "BluetoothChat" está funcionando. Determiné que el problema es el UUID.Así reemplazo mi
UUID.fromString("00001001-0000-1000-8000-00805F9B34FB")
aUUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66")
y funcionó más escena, sólo a veces tenga que reiniciar el dispositivo Bluetooth;fuente