Question

我在Samsung Express（4.1.2）上读取蓝牙插槽的写入时遇到了一个奇怪的问题。当我在Google Nexus 4（4.3）

上运行应用程序时，问题不会出现

当我尝试对套接字执行任何操作时，我的Logcat中会出现“genlock attach lock open”消息。通常会紧跟“同步关闭”。这里的问题是，如果我尝试写入套接字我得到“同步关闭”，数据发送成功，但我无法访问输入流中的新数据，直到锁再次打开。

此外，Logcat中还会出现大量“availableNative”消息。

这是我发送命令的代码，等待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;
              }

    }

如果我要在字节永远不会到达inputStream时运行此命令，但如果我再次运行该命令，所有字节都是第一次出现，就像洪水门被打开一样。我很难过。有人可以帮忙吗？（注意写入和读取命令都可以在应用程序中使用，而蓝牙套接字可用于其他命令和响应。

请询问您是否需要进一步的信息。

Answer 1

刚刚找到了解决方法。无论出于何种原因，手机都不喜欢一次从蓝牙插座读取多个字节的想法。所以我实现了逐字节方法，提供了一个可接受的补丁。我之前没有接收报告一个字节的套接字因为我在读取之前检查了套接字上的至少3个字节（这对我的目的有意义）。 Phone会持续报告inputStream上的1个字节，因此您在inputStream报告一个字节时获取一个字节。如果有人有解释，仍然会对解释感兴趣。感谢

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

1 个答案: