連接藍牙設備時出現問題

Question

我正在嘗試使用以下代碼連接到設備......基本上是從 BTchat 源修改的。 go 似乎一切都很好，但是設備沒有響應命令，我的手機仍然說它已配對但未連接，並且設備說它未連接。 這讓我很確定它確實沒有連接，但沒有發生錯誤。

我可以輸入錯誤的 UUID 嗎？

日志說：

04-30 18:51:10.116: DEBUG/BluetoothService(1228):     uuid(application): 00001101-0000-1000-8000-00805f9b34fb 1

04-30 18:51:10.116: DEBUG/BluetoothService(1228): Making callback for 00001101-0000-1000-8000-00805f9b34fb with result 1

04-30 18:51:10.131: VERBOSE/BluetoothEventRedirector(31561): Received android.bleutooth.device.action.UUID

我的代碼正在打印到它連接的日志：

04-30 18:53:21.210: DEBUG/BTComm(1044): connect to: K4500-620963
04-30 18:53:21.225: INFO/BTComm(1044): BEGIN ConnectThread
04-30 18:53:26.272: DEBUG/BTComm(1044): connected to: K4500-620963
04-30 18:53:26.272: DEBUG/BTComm(1044): create ConnectedThread
04-30 18:53:26.280: DEBUG/BTComm(1044): setState() 0 -> 3
04-30 18:53:26.280: INFO/BTComm(1044): BEGIN ConnectedThread

這是我的整個代碼：p

ublic class BTCom {
    // Debugging
    private static final String TAG = "BTComm";
    private static final boolean D = true;
    private static final UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

 // Member fields
    private final BluetoothAdapter adapter;
    private final Handler handler;
    private ConnectThread connectThread;
    private ConnectedThread connectedThread;
    private int state;
    private Context context;
    private BluetoothDevice BTDevice;

 // Constants that indicate the current connection state
    public static final int STATE_NONE = 0;       // we're doing nothing
    public static final int STATE_LISTEN = 1;     // now listening for incoming connections
    public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection
    public static final int STATE_CONNECTED = 3;  // now connected to a remote device

    public BTCom(Context context, Handler handler) {
        adapter = BluetoothAdapter.getDefaultAdapter();
        state = STATE_NONE;
        this.handler = handler;
        this.context = context;
    }




    private void checkBluetooth(){
        // check if device supports bluetooth
        if (adapter == null) {
            Toast.makeText(context, "ERROR: This device does not support Bluetooth communication"
                    , Toast.LENGTH_LONG).show();
            return;
        }
        // now make sure bluetooth is enabled
        if (!adapter.isEnabled()) {
            // if not, then prompt the user
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            context.startActivity(enableBtIntent);
        }
    }

    public BluetoothDevice getBTDevice(){
        Set<BluetoothDevice> pairedDevices = adapter.getBondedDevices();
        BluetoothDevice foundDevice = null;
        BTDevice = null;
        // If there are paired devices
        if (pairedDevices.size() > 0) {
            // Loop through paired devices
            for (BluetoothDevice device : pairedDevices) {
                // check if the name fits the pattern K4xxx-xxxxxx
                if (device.getName().matches("K4\\d\\d\\d-\\d\\d\\d\\d\\d\\d")){ 
                    foundDevice = device;
                    break;
                }
            }
            if (foundDevice == null){ // if we didn't find any
                Toast.makeText(context, 
                        "ERROR: No paired BTDevice device was found, please pair a BTDevice device to continue"
                        , Toast.LENGTH_LONG).show();
                return null;
            }
        }
        return foundDevice; // found a BTDevice!
    }


    /**
     * Set the current state of the chat connection
     * @param state  An integer defining the current connection state
     */
    private synchronized void setState(int state) {
        if (D) Log.d(TAG, "setState() " + this.state + " -> " + state);
        this.state = state;
    }

    /**
     * Start the ConnectThread to initiate a connection to a remote device.
     * @param device  The BluetoothDevice to connect
     */
    public synchronized void connect(BluetoothDevice device) {
        Log.d(TAG, "connect to: " + device.getName());

        // Cancel any thread attempting to make a connection
        if (connectThread != null) {connectThread.cancel(); connectThread = null;}


        // Cancel any thread currently running a connection
        if (connectedThread != null) {connectedThread.cancel(); connectedThread = null;}

        // Start the thread to connect with the given device
        connectThread = new ConnectThread(device);
        connectThread.start();
    }

    /**
     * Start the ConnectedThread to begin managing a Bluetooth connection
     * @param socket  The BluetoothSocket on which the connection was made
     * @param device  The BluetoothDevice that has been connected
     */
    public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
        Log.d(TAG, "connected to: " + device.getName());

        // Cancel the thread that completed the connection
        if (connectThread != null) {connectThread.cancel(); connectThread = null;}

        // Cancel any thread currently running a connection
        if (connectedThread != null) {connectedThread.cancel(); connectedThread = null;}


        // Start the thread to manage the connection and perform transmissions
        connectedThread = new ConnectedThread(socket);
        connectedThread.start();
        setState(STATE_CONNECTED);

    }

    /**
     * Stop all threads
     */
    public synchronized void stop() {
        if (D) Log.d(TAG, "stop");

        if (connectThread != null) {
            connectThread.cancel();
            connectThread = null;
        }

        if (connectedThread != null) {
            connectedThread.cancel();
            connectedThread = null;
            setState(STATE_NONE);
        }
    }

    /**
     * Write to the ConnectedThread in an unsynchronized manner
     * @param out The bytes to write
     * @see ConnectedThread#write(byte[])
     */
    public void write(byte[] out) {
        // Create temporary object
        ConnectedThread r;
        // Synchronize a copy of the ConnectedThread
        synchronized (this) {
            if (state != STATE_CONNECTED) return;
            r = connectedThread;
        }
        // Perform the write unsynchronized
        r.write(out);
    }

    private class ConnectThread extends Thread {
        private final BluetoothSocket socket;
        private final BluetoothDevice device;

        public ConnectThread(BluetoothDevice device) {
            this.device = device;
            BluetoothSocket tmp = null;

            // Get a BluetoothSocket for a connection with the
            // given BluetoothDevice
            try {
                tmp = device.createRfcommSocketToServiceRecord(uuid);
            } catch (IOException e) {
                Log.e(TAG, "Socket create failed", e);
            }
            socket = tmp;
        }

        public void run() {
            Log.i(TAG, "BEGIN ConnectThread");


            // Make a connection to the BluetoothSocket
            try {
                // This is a blocking call and will only return on a
                // successful connection or an exception
                socket.connect();
            } catch (IOException e) {
                // Close the socket
                try {
                    socket.close();
                } catch (IOException e2) {
                    Log.e(TAG, "unable to close() socket during connection failure", e2);
                }
                return;
            }

            // Reset the ConnectThread because we're done
            synchronized (BTCom.this) {
                connectThread = null;
            }

            // Start the connected thread
            connected(socket, this.device);
        }

        public void cancel() {
            try {
                socket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

    /**
     * This thread runs during a connection with a remote device.
     * It handles all incoming and outgoing transmissions.
     */
    private class ConnectedThread extends Thread {
        private final BluetoothSocket socket;
        private final InputStream inStream;
        private final OutputStream outStream;

        public ConnectedThread(BluetoothSocket socket) {
            Log.d(TAG, "create ConnectedThread");
            this.socket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;

            // Get the BluetoothSocket input and output streams
            try {
                tmpIn = socket.getInputStream();
                tmpOut = socket.getOutputStream();
            } catch (IOException e) {
                Log.e(TAG, "temp sockets not created", e);
            }

            inStream = tmpIn;
            outStream = tmpOut;
        }

        public void run() {
            Log.i(TAG, "BEGIN ConnectedThread");
            byte[] buffer = new byte[1024];
            int bytes;

            // Keep listening to the InputStream while connected
            while (true) {
                try {
                    // Read from the InputStream
                    bytes = inStream.read(buffer);

                 // Send the obtained bytes to the UI Activity
                    handler.obtainMessage(KestrelTest.MESSAGE_READ, bytes, -1, buffer)
                    .sendToTarget();
                } catch (IOException e) {
                    Log.e(TAG, "disconnected", e);
                    // Start the service over to restart listening mode
                    break;
                }
            }
        }

        /**
         * Write to the connected OutStream.
         * @param buffer  The bytes to write
         */
        public void write(byte[] buffer) {
            try {
                outStream.write(buffer);
                Log.i(TAG, "Sending " + buffer.length + " bytes");
                Log.i(TAG, "Sending: " + new String(buffer));

            } catch (IOException e) {
                Log.e(TAG, "Exception during write", e);
            }
        }

        public void cancel() {
            try {
                socket.close();
            } catch (IOException e) {
                Log.e(TAG, "close() of connect socket failed", e);
            }
        }
    }

}

我很困惑為什么不連接......有什么想法嗎？ 謝謝！

Answer 1

您要連接的設備是什么？ 也許設備需要主機（Android）系統支持某些配置文件，如 A2DP、BIP、BPP 等。

藍牙聊天程序創建一個基本的客戶端-服務器連接，並且不需要藍牙配置文件支持。

為了在 Android 上實現藍牙配置文件支持，有一個名為“Sybase-iAnywhere-Blue-SDK-for-Android”的項目，它取代了 Android 的版本，並提供了底層藍牙配置文件和協議的所有接口。 使用此功能，可以使用此 SDK 提供的 BPP 配置文件，使用您的 Android 手機通過藍牙進行打印。

有關詳細信息，請參見以下鏈接： 鏈接 1： http://www.sybase.com/detail?id=1064424鏈接 2： http://www.sybase.com/products/allproductsa-z/mobiledevicesdks/bluetoothsdks

iAnywhere Blue SDK for Android 支持的應用程序配置文件據說包括：

免提 (HFP) 高級音頻分配 (A2DP) A/V 遠程控制 (AVRCP) 文件傳輸協議 (FTP) Object 推送協議 (OPP) SIM 訪問 (SAP) 電話簿訪問 (PBAP) 消息訪問配置文件 (MAP) 人機界面 ( HID) 基本打印 (BPP) 基本成像 (BIP)