Android 三星Express上奇怪的蓝牙锁定行为

我在三星Express（4.1.2）上的蓝牙插座上读写时遇到了一个奇怪的问题。当我在我的Google Nexus 4（4.3）上运行应用程序时，这个问题不会出现

当我尝试在套接字上执行任何操作时，我在日志猫中得到一条“genlock attach lock open”消息。通常紧接着是“genlock close”。这里的问题是，如果我尝试写入套接字，我会得到一个“genlock close”，数据会成功发送，但在锁再次打开之前，我无法访问输入流中的新数据

此外，Logcat中还出现了许多“可用”消息

下面是我发送命令、等待0.5秒并尝试读取输入缓冲区的代码：

public boolean ReadFaultTable()
{


    byte[] in_packet = new byte[100];

    int err_byte_count;
    int err_symp_count;


    if(!(BTCheck()))
            {
                Log.i(TAG,"ReadFaultTable() BT Fail!");
                //Toast.makeText(getApplicationContext(), "Socket not open for fault read", Toast.LENGTH_SHORT).show();
                return false;

            }


                byte [] out_packet = new byte[1];
                out_packet[0]= 0x0a;//READ_CURRENT_FAULT_CODES_CMD

                byte []full_packet=AddDRCheckSum(out_packet);

                connectedThread.clearBuffer();
                try{
                    Thread.sleep(200);
                   }
                catch(InterruptedException e){}

                connectedThread.write(full_packet);

                Log.i("Read Faults", "After Write");

            sleepForProcessingTime(500);
            Log.i("Read Faults", "0.5 Secs, Num Bytes = "+Integer.toString(connectedThread.bytesAvail()));


            if(connectedThread.bytesAvail() > 3)
            {
                //Log.i("Read Faults", "bytes avail = " + Integer.toString(connectedThread.bytesAvail()));
                for (int i =0;i<3;i++)
                {

                        Log.i("Read Faults", "In here");

                        if((in_packet[i]=connectedThread.readByte())==-1)
                        {
                            Log.i(TAG, "End of Input stream reached on iteration= "+ Integer.toString(i));
                            return false;
                        }
                        Log.i("Read Faults", "Byte read in =" +Integer.toHexString(in_packet[i]));
                }
            }
            else
            {
                Log.i("Read Faults", "No Bytes to read .. return false");
                return false;
            }

            /*
            if(connectedThread.bytesAvail() > 0)
            {
                in_packet= new byte[connectedThread.bytesAvail()];
                in_packet = connectedThread.read();
                Log.i("Read Faults","Bytes Read in =" + printCMD(in_packet));
            }
            */
            Log.i("Read Faults", "Made it here with "+ printCMD(in_packet));

            int fault_table_index =0;
              if (in_packet[0] == 0x0A && in_packet[1] == 0x0E )
              {
                  Log.i("Read Faults","in packet passed checks");
                  err_byte_count=in_packet[2];
                  fault_table= new boolean[err_byte_count*8];
                  Log.i("Read Faults","err byte count = "+ Integer.toString(err_byte_count));
                  for (int i=0;i<(err_byte_count);i++)
                  {
                      int val =connectedThread.readByte();
                      Log.i("Read Faults","Next byte read in =0x" + Integer.toHexString(val));
                      in_packet[3+i]=(byte)val;

                      int mask =0x01;
                      for (int x = 0; x < 8; x++)
                      {
                          if ((val & mask)== mask)
                          {
                              Log.i("Read Faults","Fault Index "+ Integer.toString(fault_table_index +1) + "true");
                              fault_table[fault_table_index++]=true;
                          }
                          else
                          {
                              Log.i("Read Faults","Fault Index "+ Integer.toString(fault_table_index +1) + "false");
                              fault_table[fault_table_index++] = false;
                          }
                          mask <<= 1;
                      }


                  }
                  Log.i("Read Faults","Made it to here");
                  in_packet[3 + err_byte_count] = (byte)connectedThread.readByte();

                  err_symp_count = in_packet[3 + err_byte_count];

                  symp_table = new byte[err_symp_count];
                  for (int i=0; i < err_symp_count; i++)
                  {
                      in_packet[3 + err_byte_count + 1 + i] = (byte)connectedThread.readByte();
                      symp_table[i] = in_packet[3 + err_byte_count + 1 + i];
                  }
                   return true;
              }
              else
              {
                  return false;
              }

    }

public boolean ReadFaultTable（）
{
_数据包中的字节[]=新字节[100]；
整数错误字节计数；
整数错误计数；
如果（！（BTCheck（）））
{
i（标记“ReadFaultTable（）BT Fail！”）；
//Toast.makeText（getApplicationContext（），“套接字未打开以进行错误读取”，Toast.LENGTH\u SHORT.show（）；
返回false；
}
字节[]out_数据包=新字节[1]；
out_数据包[0]=0x0a；//读取当前错误代码
字节[]完整数据包=ADDDR校验和（数据包外）；
connectedThread.clearBuffer（）；
试一试{
睡眠（200）；
}
捕获（中断异常e）{}
connectedThread.write（完整_数据包）；
Log.i（“读取错误”、“写入后”）；
睡眠处理时间（500）；
Log.i（“读取错误”，“0.5秒，Num Bytes=“+Integer.toString（connectedThread.bytesAvail（）））；
if（connectedThread.bytesAvail（）>3）
{
//Log.i（“读取错误”，“字节数有效=“+Integer.toString（connectedThread.bytesAvail（）））；
对于（int i=0；i 0）
{
in_packet=新字节[connectedThread.bytesAvail（）]；
in_packet=connectedThread.read（）；
Log.i（“读取错误”，“读取字节数=“+printCMD（in_数据包））；
}
*/
Log.i（“读取错误”，“在这里使用“+printCMD（in_packet））；
int fault_table_index=0；
if（数据包[0]==0x0A&&in数据包[1]==0x0E）
{
Log.i（“读取错误”，“包内通过检查”）；
err_byte_count=in_数据包[2]；
fault_table=新布尔值[err_byte_count*8]；
Log.i（“读取错误”、“错误字节计数=“+Integer.toString（错误字节计数））；
对于（int i=0；i刚刚找到解决办法。无论出于何种原因，手机不喜欢一次从蓝牙插座读取多个字节的想法。因此，我实施了一种逐字节的方法，提供了一个可接受的补丁。我以前没有在插座上报告一个字节可用，因为我检查了至少3个字节n在读入之前打开插座（这对我来说是有意义的）。
Phone持续报告inputStream上的1个可用字节，因此您在inputStream报告一个字节时获取一个字节。
如果有人有解释的话，我还是会感兴趣的。谢谢