IOException：読み取りに失敗し、ソケットが閉じられる可能性があります-Android 4.3のBluetooth
現在、Nexus 7（2012）でAndroid 4.3（ビルドJWR66Y、2回目の4.3更新）でBluetoothSocketを開くと、奇妙な例外に対処しようとしています。関連する投稿を見ました（例 https://stackoverflow.com/questions/13648373/bluetoothsocket-connect-throwing-exception-read-failed ）が、この問題の回避策を提供していないようです。また、これらのスレッドで提案されているように、再ペアリングは役に立たず、常に接続（愚かなループを介して）しようとしても効果はありません。
私は組み込みデバイス（noname OBD-IIカーアダプター、 http://images04.olx.com/ui/15/53/76/1316534072_254254776_2-OBD-II-BLUTOOTH-ADAPTERSCLEAR- CHECK-ENGINE-LIGHTS-WITH-YOUR-PHONE-Oceanside.jpg ）。私のAndroid 2.3.7電話には接続の問題がなく、同僚のXperia（Android 4.1.2）も動作します。別のGoogle Nexus（「4」ではなく「1」または「S」かどうかもわかりません）もAndroid 4.3で失敗します。
これが接続確立のスニペットです。サービス内で作成された独自のスレッドで実行されています。
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;
}
}
コードはbluetoothSocket.connect()で失敗しています。 Java.io.IOException: read failed, socket might closed, read ret: -1を取得しています。これはGitHubの対応するソースです。 https://github.com/Android/platform_frameworks_base/blob/Android-4.3_r2/core/Java/Android/bluetooth/BluetoothSocket.Java#L504 その呼び出しreadInt（）、 https://github.com/Android/platform_frameworks_base/blob/Android-4.3_r2/core/Java/Android/bluetooth/BluetoothSocket.Java#L319 から呼び出されます
使用されたソケットの一部のメタデータダンプは、次の情報をもたらしました。これらは、Nexus 7と私の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
他にもいくつかのOBD-IIアダプター（より拡張性の高い）があり、それらはすべて機能します。私は何かを見逃している可能性がありますか、これはAndroidのバグかもしれませんか？
私はついに回避策を見つけました。魔法はBluetoothDeviceクラスの内部に隠れています（ https://github.com/Android/platform_frameworks_base/blob/Android-4.3_r2/core/Java/Android/bluetooth/BluetoothDevice.Java#L1037を参照 ）。
さて、その例外を受け取ったとき、以下のソースコードのようなフォールバックBluetoothSocketをインスタンス化します。ご覧のとおり、リフレクションを介して隠しメソッドcreateRfcommSocketを呼び出しています。この方法が隠されている理由はわかりません。ソースコードでは、publicとして定義しています...
Class<?> clazz = tmp.getRemoteDevice().getClass();
Class<?>[] paramTypes = new Class<?>[] {Integer.TYPE};
Method m = clazz.getMethod("createRfcommSocket", paramTypes);
Object[] params = new Object[] {Integer.valueOf(1)};
fallbackSocket = (BluetoothSocket) m.invoke(tmp.getRemoteDevice(), params);
fallbackSocket.connect();
connect()は失敗しなくなりました。私はまだいくつかの問題を経験しています。基本的に、これは時々ブロックして失敗します。そのような場合には、SPP-Deviceの再起動（プラグオフ/プラグイン）が役立ちます。デバイスが既に結合されている場合でも、connect()の後に別のペアリングリクエストを受け取ることもあります。
更新：
ネストされたクラスを含む完全なクラスがここにあります。実際の実装では、これらは個別のクラスとして保持できます。
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.OutputStream;
import Java.lang.reflect.Method;
import Java.util.List;
import Java.util.UUID;
import Android.bluetooth.BluetoothAdapter;
import Android.bluetooth.BluetoothDevice;
import Android.bluetooth.BluetoothSocket;
import Android.util.Log;
public class BluetoothConnector {
private BluetoothSocketWrapper bluetoothSocket;
private BluetoothDevice device;
private boolean secure;
private BluetoothAdapter adapter;
private List<UUID> uuidCandidates;
private int candidate;
/**
* @param device the device
* @param secure if connection should be done via a secure socket
* @param adapter the Android BT adapter
* @param uuidCandidates a list of UUIDs. if null or empty, the Serial PP id is used
*/
public BluetoothConnector(BluetoothDevice device, boolean secure, BluetoothAdapter adapter,
List<UUID> uuidCandidates) {
this.device = device;
this.secure = secure;
this.adapter = adapter;
this.uuidCandidates = uuidCandidates;
if (this.uuidCandidates == null || this.uuidCandidates.isEmpty()) {
this.uuidCandidates = new ArrayList<UUID>();
this.uuidCandidates.add(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
}
}
public BluetoothSocketWrapper connect() throws IOException {
boolean success = false;
while (selectSocket()) {
adapter.cancelDiscovery();
try {
bluetoothSocket.connect();
success = true;
break;
} catch (IOException e) {
//try the fallback
try {
bluetoothSocket = new FallbackBluetoothSocket(bluetoothSocket.getUnderlyingSocket());
Thread.sleep(500);
bluetoothSocket.connect();
success = true;
break;
} catch (FallbackException e1) {
Log.w("BT", "Could not initialize FallbackBluetoothSocket classes.", e);
} catch (InterruptedException e1) {
Log.w("BT", e1.getMessage(), e1);
} catch (IOException e1) {
Log.w("BT", "Fallback failed. Cancelling.", e1);
}
}
}
if (!success) {
throw new IOException("Could not connect to device: "+ device.getAddress());
}
return bluetoothSocket;
}
private boolean selectSocket() throws IOException {
if (candidate >= uuidCandidates.size()) {
return false;
}
BluetoothSocket tmp;
UUID uuid = uuidCandidates.get(candidate++);
Log.i("BT", "Attempting to connect to Protocol: "+ uuid);
if (secure) {
tmp = device.createRfcommSocketToServiceRecord(uuid);
} else {
tmp = device.createInsecureRfcommSocketToServiceRecord(uuid);
}
bluetoothSocket = new NativeBluetoothSocket(tmp);
return true;
}
public static interface BluetoothSocketWrapper {
InputStream getInputStream() throws IOException;
OutputStream getOutputStream() throws IOException;
String getRemoteDeviceName();
void connect() throws IOException;
String getRemoteDeviceAddress();
void close() throws IOException;
BluetoothSocket getUnderlyingSocket();
}
public static class NativeBluetoothSocket implements BluetoothSocketWrapper {
private BluetoothSocket socket;
public NativeBluetoothSocket(BluetoothSocket tmp) {
this.socket = tmp;
}
@Override
public InputStream getInputStream() throws IOException {
return socket.getInputStream();
}
@Override
public OutputStream getOutputStream() throws IOException {
return socket.getOutputStream();
}
@Override
public String getRemoteDeviceName() {
return socket.getRemoteDevice().getName();
}
@Override
public void connect() throws IOException {
socket.connect();
}
@Override
public String getRemoteDeviceAddress() {
return socket.getRemoteDevice().getAddress();
}
@Override
public void close() throws IOException {
socket.close();
}
@Override
public BluetoothSocket getUnderlyingSocket() {
return socket;
}
}
public class FallbackBluetoothSocket extends NativeBluetoothSocket {
private BluetoothSocket fallbackSocket;
public FallbackBluetoothSocket(BluetoothSocket tmp) throws FallbackException {
super(tmp);
try
{
Class<?> clazz = tmp.getRemoteDevice().getClass();
Class<?>[] paramTypes = new Class<?>[] {Integer.TYPE};
Method m = clazz.getMethod("createRfcommSocket", paramTypes);
Object[] params = new Object[] {Integer.valueOf(1)};
fallbackSocket = (BluetoothSocket) m.invoke(tmp.getRemoteDevice(), params);
}
catch (Exception e)
{
throw new FallbackException(e);
}
}
@Override
public InputStream getInputStream() throws IOException {
return fallbackSocket.getInputStream();
}
@Override
public OutputStream getOutputStream() throws IOException {
return fallbackSocket.getOutputStream();
}
@Override
public void connect() throws IOException {
fallbackSocket.connect();
}
@Override
public void close() throws IOException {
fallbackSocket.close();
}
}
public static class FallbackException extends Exception {
/**
*
*/
private static final long serialVersionUID = 1L;
public FallbackException(Exception e) {
super(e);
}
}
}
まあ、私は私のコードで同じ問題を抱えていました。それはAndroid 4.2 Bluetoothスタックが変更されて以来です。したがって、私のコードはAndroid <4.2のデバイスで正常に実行され、他のデバイスでは有名な例外が表示されました。 1 "
問題はsocket.mPortパラメーターにあります。 socket = device.createRfcommSocketToServiceRecord(SERIAL_UUID);を使用してソケットを作成すると、mPortは整数値「-1」を取得し、この値はAndroidに対して機能しないようです。 > = 4.2なので、「1」に設定する必要があります。悪いニュースは、createRfcommSocketToServiceRecordはパラメータとしてUUIDのみを受け入れ、mPortではなく、他のアプローチを使用する必要があることです。 @ matthesが投稿した回答もうまくいきましたが、私はそれを簡略化しました：socket =(BluetoothSocket) device.getClass().getMethod("createRfcommSocket", new Class[] {int.class}).invoke(device,1);。フォールバックとして2番目のソケットattribsの両方を使用する必要があります。
したがって、コードは次のとおりです（Elm327デバイスのSPPに接続するため）：
BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
if (btAdapter.isEnabled()) {
SharedPreferences prefs_btdev = getSharedPreferences("btdev", 0);
String btdevaddr=prefs_btdev.getString("btdevaddr","?");
if (btdevaddr != "?")
{
BluetoothDevice device = btAdapter.getRemoteDevice(btdevaddr);
UUID SERIAL_UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb"); // bluetooth serial port service
//UUID SERIAL_UUID = device.getUuids()[0].getUuid(); //if you don't know the UUID of the bluetooth device service, you can get it like this from Android cache
BluetoothSocket socket = null;
try {
socket = device.createRfcommSocketToServiceRecord(SERIAL_UUID);
} catch (Exception e) {Log.e("","Error creating socket");}
try {
socket.connect();
Log.e("","Connected");
} catch (IOException e) {
Log.e("",e.getMessage());
try {
Log.e("","trying fallback...");
socket =(BluetoothSocket) device.getClass().getMethod("createRfcommSocket", new Class[] {int.class}).invoke(device,1);
socket.connect();
Log.e("","Connected");
}
catch (Exception e2) {
Log.e("", "Couldn't establish Bluetooth connection!");
}
}
}
else
{
Log.e("","BT device not selected");
}
}
まず、bluetooth 2.xデバイスと通信する必要がある場合、 このドキュメント は次のように述べています。
ヒント：Bluetoothシリアルボードに接続する場合は、既知のSPP UUID 00001101-0000-1000-8000-00805F9B34FBを使用してみてください。ただし、Androidピアに接続する場合は、独自の一意のUUIDを生成してください。
私はそれがうまくいくとは思っていませんでしたが、UUIDを00001101-0000-1000-8000-00805F9B34FBで置き換えることによってのみ動作します。ただし、このコードはSDKバージョンの問題を処理しているようで、次のメソッドを定義した後、関数device.createRfcommSocketToServiceRecord(mMyUuid);をtmp = createBluetoothSocket(mmDevice);に置き換えることができます。
private BluetoothSocket createBluetoothSocket(BluetoothDevice device)
throws IOException {
if(Build.VERSION.SDK_INT >= 10){
try {
final Method m = device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class });
return (BluetoothSocket) m.invoke(device, mMyUuid);
} catch (Exception e) {
Log.e(TAG, "Could not create Insecure RFComm Connection",e);
}
}
return device.createRfcommSocketToServiceRecord(mMyUuid);
}
ソースコードは私のものではありませんが、 このWebサイト からのものです。
さて、私は実際に問題を発見しました。
socket.Connect();を使用して接続しようとするほとんどの人は、Java.IO.IOException: read failed, socket might closed, read ret: -1という例外を受け取ります。
Bluetoothには、BLE（低エネルギー）とクラシックの2つの異なるタイプがあるため、場合によってはBluetoothデバイスにも依存します。
Bluetoothデバイスのタイプを確認する場合は、次のコードをご覧ください。
String checkType;
var listDevices = BluetoothAdapter.BondedDevices;
if (listDevices.Count > 0)
{
foreach (var btDevice in listDevices)
{
if(btDevice.Name == "MOCUTE-032_B52-CA7E")
{
checkType = btDevice.Type.ToString();
Console.WriteLine(checkType);
}
}
}
私は何日も問題を解決しようとしてきましたが、今日から問題を発見しました。 @matthesのソリューションには、残念ながら、彼が既に言ったようにまだいくつかの問題がありますが、ここに私のソリューションがあります。
現時点では、Xamarin Androidで作業していますが、これは他のプラットフォームでも機能するはずです。
ソリューション
ペアリングされたデバイスが複数ある場合は、他のペアリングされたデバイスを削除する必要があります。そのため、接続するもののみを保持します（右の画像を参照）。
左の画像では、2つのペアのデバイス、つまり「MOCUTE-032_B52-CA7E」と「Blue Easy」があることがわかります。それが問題ですが、なぜその問題が発生するのかわかりません。 Bluetoothプロトコルが別のBluetoothデバイスから情報を取得しようとしている可能性があります。
ただし、socket.Connect();は問題なく正常に動作します。このエラーは本当に面倒なので、私はこれを共有したかっただけです。
がんばろう！
ここで説明したのと同じ症状がありました。 Bluetoothプリンターに1回接続できましたが、その後の接続は、「ソケットを閉じた」状態で失敗しました。
ここで説明した回避策が必要になるのは少しおかしいと感じました。コードを調べた後、ソケットのInputStreamとOutputSteramを閉じるのを忘れていて、ConnectedThreadsを適切に終了していないことがわかりました。
私が使用するConnectedThreadは、ここの例と同じです。
http://developer.Android.com/guide/topics/connectivity/bluetooth.html
ConnectThreadとConnectedThreadは2つの異なるクラスであることに注意してください。
ConnectedThreadを開始するクラスは、スレッドでinterrupt（）およびcancel（）を呼び出す必要があります。 ConnectedTread.cancel（）メソッドにmmInStream.close（）およびmmOutStream.close（）を追加しました。
スレッド/ストリーム/ソケットを適切に閉じた後、問題なく新しいソケットを作成できました。
registerReceiver(receiver, new IntentFilter("Android.bleutooth.device.action.UUID"));には、「bluetooth」と綴られた「bluetooth」を付けます。
Androidの新しいバージョンでは、ソケットに接続しようとしたときにアダプターがまだ検出していたため、このエラーが発生していました。 BluetoothアダプターでcancelDiscoveryメソッドを呼び出しましたが、BroadcastReceiverのonReceive（）メソッドへのコールバックがアクションBluetoothAdapter.ACTION_DISCOVERY_FINISHEDで呼び出されるまで待つ必要がありました。
アダプターがディスカバリーを停止するのを待ってから、ソケットでの接続呼び出しが成功しました。
誰かがKotlinで問題を抱えている場合、受け入れられた答えにいくつかのバリエーションを付けて従う必要がありました。
fun print(view: View, text: String) {
var adapter = BluetoothAdapter.getDefaultAdapter();
var pairedDevices = adapter.getBondedDevices()
var uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
if (pairedDevices.size > 0) {
for (device in pairedDevices) {
var s = device.name
if (device.getName().equals(printerName, ignoreCase = true)) {
Thread {
var socket = device.createInsecureRfcommSocketToServiceRecord(uuid)
var clazz = socket.remoteDevice.javaClass
var paramTypes = arrayOf<Class<*>>(Integer.TYPE)
var m = clazz.getMethod("createRfcommSocket", *paramTypes)
var fallbackSocket = m.invoke(socket.remoteDevice, Integer.valueOf(1)) as BluetoothSocket
try {
fallbackSocket.connect()
var stream = fallbackSocket.outputStream
stream.write(text.toByteArray(Charset.forName("UTF-8")))
} catch (e: Exception) {
e.printStackTrace()
Snackbar.make(view, "An error occurred", Snackbar.LENGTH_SHORT).show()
}
}.start()
}
}
}
}
それが役に立てば幸い
Bluetoothデバイスは、クラシックモードとLEモードの両方で同時に動作できます。接続する方法に応じて、異なるMACアドレスを使用する場合があります。 socket.connect()の呼び出しはBluetooth Classicを使用しているため、スキャン時に取得したデバイスが実際にクラシックデバイスであることを確認する必要があります。
ただし、クラシックデバイスのみを簡単にフィルタリングできます。
if(BluetoothDevice.DEVICE_TYPE_LE == device.getType()){ //socket.connect() }
このチェックなしでは、ハイブリッドスキャンが最初にClassicデバイスを提供するかBLEデバイスを提供するかについての競合状態です。断続的に接続できない、または特定のデバイスが確実に接続できる一方で、他のデバイスは接続できないように見える場合があります。
また、私はこの問題に直面しました、前述のようにリフレクションを使用してソケットを作成する2つの方法で解決できます起こる。指定されたクライアントUUIDでサーバーを作成し、サーバー側からクライアントをリッスンして受け入れます。動作します。
この問題に遭遇し、ソケットを閉じる前に入出力ストリームを閉じることで修正しました。これで、問題なく接続を解除して再接続できます。
https://stackoverflow.com/a/3039807/5688612
コトリンで：
fun disconnect() {
bluetoothSocket.inputStream.close()
bluetoothSocket.outputStream.close()
bluetoothSocket.close()
}
コードの別の部分が同じソケットとUUIDで既に接続を確立している場合、このエラーが発生します。
同じ問題が発生した場合でも、最終的に私の問題を理解し、（範囲外の）Bluetoothカバレッジ範囲から接続しようとしました。