无法使2个设备之间的蓝牙连接

我试图通过使用Android开发者网站上的Android蓝牙聊天示例连接两个设备。它只能从其中一个设备连接,当我尝试从其他设备连接时,它没有连接,并弹出消息“无法连接:[设备名称]

我想知道如果我在两个设备上使用相同的代码,为什么连接只从一侧,而被拒绝从另一侧?

我有2个设备 – 1运行版本2.2和1运行v2.3.3。
我的请求总是从我的Galaxy Y运行2.3.3发送到运行Android 2.2的Galaxy fit-v,但不是反过来。任何一个请帮助我或给我建议基于下面的代码…

@Override
public void onActivityResult(int requestCode, int resultCode, final Intent data) {

    switch (requestCode) {
    case REQUEST_CONNECT_DEVICE:

        // When DeviceListActivity returns with a device to connect
        if (resultCode == Activity.RESULT_OK) {
            FaceCardList.requestConnection = true;
            FaceCardList.deviceSelected = false;

            address = data.getExtras().getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);              

            device = FaceCardList.mBluetoothAdapter.getRemoteDevice(address);

            // Attempt to connect to the device
            FaceCardList.mChatService.connect(device);
            // Get the device MAC address
        }
        break;
    case REQUEST_ENABLE_BT:
        // When the request to enable Bluetooth returns
        if (resultCode == Activity.RESULT_OK) {
            // Bluetooth is now enabled, so set up a chat session
            setupChat();
        } else {
            // User did not enable Bluetooth or an error occured
            Toast.makeText(this, R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show();
            finish();
        }
    }
}

我的BluetoothChat服务的代码是:

public class BluetoothChatService extends Activity {
    private static final String TAG = "BluetoothChatService";
    private static final boolean D = true;
    // Name for the SDP record when creating server socket
    private static final String NAME = "BluetoothChat";
    // Unique UUID for this application
    private static final UUID MY_UUID =  UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

    // ("fa87c0d0-afac-11de-8a39-0800200c9a66");
    // Member fields
    private final BluetoothAdapter mAdapter;
    private final Handler mHandler;
    private AcceptThread mAcceptThread;
    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;
    private int mState;
    // 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

    /**
     * Constructor. Prepares a new BluetoothChat session.
     * 
     * @param context
     *            The UI Activity Context
     * @param handler
     *            A Handler to send messages back to the UI Activity
     */
    public BluetoothChatService(Context context, Handler handler) {
        mAdapter = FaceCardList.mBluetoothAdapter;
        mState = STATE_NONE;
        mHandler = handler;
    }

    /**
     * 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() " + mState + " -> " + state);
        }
        mState = state;

        // Give the new state to the Handler so the UI Activity can update
        mHandler.obtainMessage(FaceCardList.MESSAGE_STATE_CHANGE, state, -1)
                .sendToTarget();
    }

    /**
     * Return the current connection state.
     */
    public synchronized int getState() {
        return mState;
    }

    /**
     * Start the chat service. Specifically start AcceptThread to begin a
     * session in listening (server) mode. Called by the Activity onResume()
     */
    public synchronized void start() {
        if (D) {
            Log.d(TAG, "start");
        }

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

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

        // Start the thread to listen on a BluetoothServerSocket
        if (mAcceptThread == null) {
            mAcceptThread = new AcceptThread();
            mAcceptThread.start();
        }
        setState(STATE_LISTEN);
    }

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

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

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

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

    /**
     * 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) {
        if (D) {
            Log.d(TAG, "######connected");
        }

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

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

        // Cancel the accept thread because we only want to connect to one
        // device
        if (mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = null;
        }

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

        // Send the name of the connected device back to the UI Activity
        Message msg = mHandler.obtainMessage(FaceCardList.MESSAGE_DEVICE_NAME);

        Bundle bundle = new Bundle();
        bundle.putString(FaceCardList.DEVICE_NAME, device.getName());
        msg.setData(bundle);
        mHandler.sendMessage(msg);

        setState(STATE_CONNECTED);
    }

    /**
     * Stop all threads
     */
    public synchronized void stop() {
        if (D) {
            Log.d(TAG, "stop");
        }
        if (mConnectThread != null) {
        mConnectThread.cancel();
        mConnectThread = null;
        }
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        if (mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = 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 (mState != STATE_CONNECTED) {
                return;
            }
        r = mConnectedThread;
        }
        // Perform the write unsynchronized
        r.write(out);

    }

    /**
     * Indicate that the connection attempt failed and notify the UI Activity.
     */
    private void connectionFailed() {
        setState(STATE_LISTEN);

        // Send a failure message back to the Activity
        Message msg = mHandler.obtainMessage(FaceCardList.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(FaceCardList.TOAST, "Unable to connect device");
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    /**
     * Indicate that the connection was lost and notify the UI Activity.
     */
    private void connectionLost() {
        setState(STATE_LISTEN);
        // Send a failure message back to the Activity
        Message msg = mHandler.obtainMessage(FaceCardList.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(FaceCardList.TOAST, "Device connection was lost");
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }

    /**
     * This thread runs while listening for incoming connections. It behaves
     * like a server-side client. It runs until a connection is accepted (or
     * until cancelled).
     */
    private class AcceptThread extends Thread {
        // The local server socket
        private final BluetoothServerSocket mmServerSocket;

        public AcceptThread() {
            BluetoothServerSocket tmp = null;

            // Create a new listening server socket
            try {

                tmp = mAdapter
                        .listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
//                if(!tmp.toString().equalsIgnoreCase(null)){

   //               
      //          }
            } catch (IOException e) {
                //Log.e(TAG, "listen() failed", e);
            }
            mmServerSocket = tmp;
        }

        @Override
        public void run() {
            if (D) {
               Log.d(TAG, "BEGIN mAcceptThread" + this);
            }

            setName("AcceptThread");
            BluetoothSocket socket = null;

            // Listen to the server socket if we're not connected
            while (mState != STATE_CONNECTED) {


                    try {
                        socket = mmServerSocket.accept();
                    } catch (IOException e1) {
                        // TODO Auto-generated catch block
                        //e1.printStackTrace();
                    }


                // If a connection was accepted
                if (socket != null) {
                    synchronized (BluetoothChatService.this) {
                        switch (mState) {
                        case STATE_LISTEN:
                        case STATE_CONNECTING:
                            // Situation normal. Start the connected thread.
                            connected(socket, socket.getRemoteDevice());
                            break;
                        case STATE_NONE:
                        case STATE_CONNECTED:
                            // Either not ready or already connected. Terminate
                            // new socket.
                            //Log.e("STATE_CONNECTED: service","STATE_CONNECTED: service");

                            try {
                                socket.close();
                            } catch (IOException e) {
                                //Log.e(TAG,"Could not close unwanted socket",                                                e);
                            }
                            break;
                        }
                    }
                }
            }
            if (D) {
                //Log.i(TAG, "END mAcceptThread");
            }
        }

        public void cancel() {
            if (D) {
                //Log.d(TAG, "cancel " + this);
            }
            try {
                mmServerSocket.close();
            } catch (IOException e) {
                //Log.e(TAG, "close() of server failed", e);
            }
        }
    }

    /**
     * This thread runs while attempting to make an outgoing connection with a
     * device. It runs straight through; the connection either succeeds or
     * fails.
     */
      private class ConnectThread extends Thread {
        private BluetoothSocket mmSocket= null;

        private final BluetoothDevice mmDevice;

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

            System.out.println("my uuid :-"+MY_UUID);
            try {
                try {
                    //tmp = device.createRfcommSocketToServiceRecord(MY_UUID);

                    mmSocket = device.createRfcommSocketToServiceRecord(MY_UUID);

                    System.out.println("mm socket value :-"+mmSocket);

                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("error in connecting :-"+e.getMessage());
                     //Log.e(TAG, "create() failed", e);

                    // TODO Auto-generated catch block
                    //e.printStackTrace();
                }



            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                //e.printStackTrace();
            }



         //   mmSocket = tmp;
            System.out.println("mm socket value as temp :-----------------");
        }





          @Override
           public void run() {
            //Log.i(TAG, "BEGIN mConnectThread");
            setName("ConnectThread");

            // Always cancel discovery because it will slow down a connection
            mAdapter.cancelDiscovery();

            // Make a connection to the BluetoothSocket
            try {
                // This is a blocking call and will only return on a
                // successful connection or an exception
                System.out.println("before connection");

                mmSocket.connect();
                System.out.println("after connection ");

            } catch (Exception e) {
                System.out.println("in connection failed :-"+e.getMessage());
                connectionFailed();
                // Close the socket
                try {
                    mmSocket.close();
                } catch (IOException e2) {
                    //Log.e(TAG,"unable to close() socket during connection failure",                                    e2);
                }
                // Start the service over to restart listening mode

                try {
                    BluetoothChatService.this.start();  
                } catch (Exception e2) {
                    // TODO: handle exception
                    e2.printStackTrace();
                    System.out.println("in connection failed start bluetooth chat service :-"+e2.getMessage());
                }

                return;
            }

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

            // Start the connected thread
            connected(mmSocket, mmDevice);
        }

        public void cancel() {
            try {
                mmSocket.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 mmSocket;

        private final InputStream mmInStream;

        private final OutputStream mmOutStream;

        public ConnectedThread(BluetoothSocket socket) {
            //Log.d(TAG, "create ConnectedThread");
            mmSocket = 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);
            }

            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

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

            // Keep listening to the InputStream while connected                                                                                                                                                                                        
            while (true) {
                try {
                    // Read from the InputStream\


                    bytes = mmInStream.read(buffer);

                    // Send the obtained bytes to the UI Activity

                    // XXX !!!
                    String buffer2 = new String(buffer);
                    buffer2= buffer2.substring(0, buffer2.length()-3)+"\n";

                    mHandler.obtainMessage(FaceCardList.MESSAGE_READ, bytes, -1, buffer2.getBytes()).sendToTarget();

                } catch (IOException e) {
                    //Log.e(TAG, "disconnected", e);
                    connectionLost();
                    break;
                }
            }
        }

        /**
         * Write to the connected OutStream.
         * 
         * @param buffer
         *            The bytes to write
         */
        public void write(byte[] buffer) {
            try {
                mmOutStream.write(buffer);
                // Share the sent message back to the UI Activity

                // XXX !!!
                String buffer2 = new String(buffer);
                buffer2= buffer2.substring(0, buffer2.length()-2);
                mHandler.obtainMessage(FaceCardList.MESSAGE_WRITE, -1, -1,
                        buffer2.getBytes()).sendToTarget();

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

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

我被卡住了。为什么连接总是从较高版本到较低版本,而不是从较低版本到较高版本?

我做到了这一点,我想你得到连接丢失时,设备可发现的变化。请检查设备是否可在两者中发现,您可以通过代码启用它。

Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,0);
startActivity(discoverableIntent);
http://stackoverflow.com/questions/9954642/unable-to-make-connection-between-2-device-bluetooth-android

本站文章除注明转载外,均为本站原创或编译
转载请明显位置注明出处:无法使2个设备之间的蓝牙连接