无法在android中的两个蓝牙设备之间发送文本数据？

我已经下载了android的蓝牙聊天应用程序示例，可以使用蓝牙在两台android设备之间发送文本

我已经在两台android设备上安装并运行了这个应用程序

我在代码中遇到了很多问题

服务发现失败异常-已修复

java.io.IOException:软件导致的连接中止-已修复

java.io.IOException:对等方重置连接-在此基础上触发

1。已清除服务发现失败异常：

public void write(byte[] buffer, int start, int end) {
mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
    if (mmOutStream !=null) {
        try {
             mmOutStream.write(buffer);
        } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
        }
    }
    else{
        Log.e("OutputStream Null","");
    }
}

对于服务发现失败异常，在蓝牙聊天服务中，我已经检查了sdk版本，对于大于的sdk版本

我使用方法类来调用RfCOMM套接字连接，我的第一个异常在这种方法中得到了解决

异常代码

 tmp = device.createRfcommSocketToServiceRecord(MY_UUID);

try {
if (Build.VERSION.SDK_INT < 9) { 
try {
     tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
       } catch (IOException e1) {
            e1.printStackTrace();
       }
       } else {
   Method m = null;
  try {
  m = device.getClass().getMethod("createRfcommSocket",
        new Class[] { int.class });
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
                }
                try {
                    tmp = (BluetoothSocket) m.invoke(device, 1);
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
                }
            } catch (Exception e) {
                Log.e(TAG, "create() failed", e);
            }

bytes = mmInStream.read(buffer);

 if (mmInStream.available() > 0) {
                            // Read from the InputStream
                            bytes = mmInStream.read(buffer);

固定异常代码

 tmp = device.createRfcommSocketToServiceRecord(MY_UUID);

try {
if (Build.VERSION.SDK_INT < 9) { 
try {
     tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
       } catch (IOException e1) {
            e1.printStackTrace();
       }
       } else {
   Method m = null;
  try {
  m = device.getClass().getMethod("createRfcommSocket",
        new Class[] { int.class });
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
                }
                try {
                    tmp = (BluetoothSocket) m.invoke(device, 1);
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
                }
            } catch (Exception e) {
                Log.e(TAG, "create() failed", e);
            }

bytes = mmInStream.read(buffer);

 if (mmInStream.available() > 0) {
                            // Read from the InputStream
                            bytes = mmInStream.read(buffer);

固定异常代码

 tmp = device.createRfcommSocketToServiceRecord(MY_UUID);

try {
if (Build.VERSION.SDK_INT < 9) { 
try {
     tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
       } catch (IOException e1) {
            e1.printStackTrace();
       }
       } else {
   Method m = null;
  try {
  m = device.getClass().getMethod("createRfcommSocket",
        new Class[] { int.class });
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
                }
                try {
                    tmp = (BluetoothSocket) m.invoke(device, 1);
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
                }
            } catch (Exception e) {
                Log.e(TAG, "create() failed", e);
            }

bytes = mmInStream.read(buffer);

 if (mmInStream.available() > 0) {
                            // Read from the InputStream
                            bytes = mmInStream.read(buffer);

现在我的问题是，当我尝试在连接的设备之间发送数据时，它在写入输出流时抛出以下错误消息“由对等方重置连接”

异常代码：

public void write(byte[] buffer, int start, int end) {
mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
    if (mmOutStream !=null) {
        try {
             mmOutStream.write(buffer);
        } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
        }
    }
    else{
        Log.e("OutputStream Null","");
    }
}

==更新==

即使它显示两个设备都已连接，accept方法仍返回fail

**06-19 10:30:23.625: D/BluetoothChatService(2630): connected
06-19 10:30:23.625: D/BluetoothChatService(2630): cancel Thread[AcceptThread,5,main]
06-19 10:30:23.625: V/BluetoothSocket.cpp(2630): abortNative
06-19 10:30:23.625: V/BluetoothSocket.cpp(2630): ...asocket_abort(50) complete
06-19 10:30:23.625: V/BluetoothSocket.cpp(2630): ...accept(50, RFCOMM) = -1 (errno 125)
06-19 10:30:23.632: E/BluetoothChatService(2630): accept() failed
06-19 10:30:23.632: E/BluetoothChatService(2630): java.io.IOException: Operation Canceled
06-19 10:30:23.632: E/BluetoothChatService(2630):   at android.bluetooth.BluetoothSocket.acceptNative(Native Method)

---

我自己对聊天示例有很多问题，所以我尝试了另一种方法

首先，您必须使一台设备成为主机，另一台设备成为客户机，这在示例中非常有效。如果您没有运行此代码，我也可以为您提供该代码

使用上面的类，可以获得连接的套接字。使用它将其传递给此类，然后可以使用write方法发送。传入的消息会在run方法中自动解析（我在前面添加了一个消息id和长度，这就是为什么其中有这么多事情发生的原因）

私有类ConnectedThread扩展线程{
/**连接插座*/
私人最终蓝牙插座mmSocket；
/**传入消息的输入流*/
私有最终输入流mmInStream；
/**传出消息的输出流*/
私有最终输出流mmOutStream；
/**
*保存套接字并获取流
* 
*@param套接字
*/
公共连接线程（BluetoothSocket）{
mmSocket=插座；
InputStream tmpIn=null；
OutputStream tmpOut=null；
//使用临时对象获取输入和输出流，因为
//成员流是最终的
试一试{
tmpIn=socket.getInputStream（）；
tmpOut=socket.getOutputStream（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
mmInStream=tmpIn；
mmOutStream=tmpOut；
}
/**
*读取传入数据并将其拆分为单个消息
*/
公开募捐{
/**单字节消息的缓冲区*/
字节[]缓冲区=新字节[1024]；
/**从读取（）返回的字节数*/
整数字节；
//继续侦听InputStream，直到发生异常
while（true）{
试一试{
//从InputStream读取开销
字节=mmInStream.read（缓冲区，0，LEN_大小+LEN_类型）；
//如果未读取字节，请等待新消息
如果（字节==0）
继续；
//获取大小字节并将其转换为int
byte[]size_arr=新字节[LEN_size]；
对于（int i=0；i

}

---

这对我有用，我希望对你也有用。如果您有任何问题，请随时提问：-）

您可以尝试一下，尽管这可能不是最终解决方案。当我遵循这个例子时，我的主要活动中有一个

onResume（）

，我想你也有类似的东西：

@Override
public synchronized void onResume() {
    super.onResume();
    if(D) Log.e(TAG, "+ ON RESUME +");
}

试试这个：

@Override
public synchronized void onResume() {
//    super.onResume();
    if(D) Log.e(TAG, "+ ON RESUME +");
}

---

这将阻止主活动多次创建AcceptThread。

我认为您的阅读是错误的。我有电话

while (true) {
    try {
        // read overhead from the InputStream
        bytes = mmInStream.read(buffer, 0, LEN_SIZE + LEN_TYPE);

在我的代码中，它工作得很好，没有.available（）和@gtRfnkN。根据我对Java文档的解释，您不能使用.avi