在android中通过蓝牙进行多连接

Posted

技术标签:

【中文标题】在android中通过蓝牙进行多连接【英文标题】:Multi connection via bluetooth in android 【发布时间】:2012-11-09 22:20:33 【问题描述】:

Hy,我们正在通过蓝牙开发安卓多人游戏。 这是一款多人 LUDO 游戏,其中 4 名玩家相互连接并玩游戏。

我们在第 3 和第 4 玩家连接上卡住了。

private OnMaxConnectionsReachedListener maxConnectionsListener = new OnMaxConnectionsReachedListener() 
    public void OnMaxConnectionsReached() 

    
;

private OnIncomingConnectionListener connectedListener = new OnIncomingConnectionListener() 
    public void OnIncomingConnection(String device) 
        //rivalDevice = device;
        if(index < 1000)
        
            clients[index] = device;
            index++;
            Log.d("Khawar", "Khawar"+device);
            if(index == 1)
            
                //blue.setText(clients[0]);
                mConnection.sendMessage(clients[0], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]);
            
            else if(index == 2)
            
                //blue.setText(clients[0]);
                //red.setText(clients[1]);
                mConnection.sendMessage(clients[0], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]);
                mConnection.sendMessage(clients[1], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]);
            
            else if(index==3)
            
                //blue.setText(clients[0]);
                //red.setText(clients[1]);
                //yellow.setText(clients[2]);
                mConnection.sendMessage(clients[0], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]+"--Ludofyp309509--"+clients[2]);
                mConnection.sendMessage(clients[1], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]+"--Ludofyp309509--"+clients[2]);
                mConnection.sendMessage(clients[2], "ConnectionList--Ludofyp309509--"+server+"--Ludofyp309509--"+clients[0]+"--Ludofyp309509--"+clients[1]+"--Ludofyp309509--"+clients[2]);
            
        
        //Toast.makeText(getBaseContext(), "Client found" + device , Toast.LENGTH_LONG).show();
      //  WindowManager w = getWindowManager();
      //  Display d = w.getDefaultDisplay();
       // int width = d.getWidth();
        //int height = d.getHeight();
    
;

private OnConnectionLostListener disconnectedListener = new OnConnectionLostListener() 
    public void OnConnectionLost(String device) 
        class displayConnectionLostAlert implements Runnable 
            public void run() 
                Builder connectionLostAlert = new Builder(self);

                connectionLostAlert.setTitle("Connection lost");
                connectionLostAlert
                        .setMessage("Your connection with the other player has been lost.");

                connectionLostAlert.setPositiveButton("Ok", new OnClickListener() 
                    public void onClick(DialogInterface dialog, int which) 
                        finish();
                    
                );
                connectionLostAlert.setCancelable(false);
                try 
                connectionLostAlert.show();
                 catch (BadTokenException e)
                    Log.v("TAG", "Exception throws here");
                
            
        
        self.runOnUiThread(new displayConnectionLostAlert());
    
;

private OnConnectionServiceReadyListener serviceReadyListener = new OnConnectionServiceReadyListener() 
    public void OnConnectionServiceReady() 
        if (mType == 0) 
            mConnection.startServer(1, connectedListener, maxConnectionsListener,
                    dataReceivedListener, disconnectedListener);
            self.setTitle("LudoOverandroid: " + mConnection.getName() + "-" + mConnection.getAddress());
            server = mConnection.getAddress();
            green.setText(server);
            Log.v("1", server);
      //      Intent Game = new Intent(self, Board.class);
            // .putExtra("TYPE", 1);
        //     startActivity(Game);

         else 

            self.setTitle("LudoOverAndroid: " + mConnection.getName() + "-" + mConnection.getAddress());
            Intent serverListIntent = new Intent(self, ServerListActivity.class);
            startActivityForResult(serverListIntent, SERVER_LIST_RESULT_CODE);
            clients[index] = mConnection.getAddress();
         //   Intent Game = new Intent(self, Board.class);
            // .putExtra("TYPE", 1);
         //    startActivity(Game);

        
    
;

以上是建立连接的示例代码。 但是在连接服务类中我们有以下代码

       public int connect(String srcApp, String device) throws RemoteException 
        if (mApp.length() > 0) 
            Log.v("a", "connection service->connect->mApp.length");
            return Connection.FAILURE;
        
        mApp = srcApp;
        BluetoothDevice myBtServer = mBtAdapter.getRemoteDevice(device);
        BluetoothSocket myBSock = null;
        Log.v("a", "Yaah aya hay aik baar nahe bar bar :");
        for (int i = 0; i < Connection.MAX_SUPPORTED && myBSock == null; i++) 
            for (int j = 0; j < 3 && myBSock == null; j++) 
                myBSock = getConnectedSocket(myBtServer, mUuid.get(i));
                if (myBSock == null) 
                    try 
                        Log.v("a", "connection service->connect->myBSock==NULL thread sleep");
                        Thread.sleep(200);
                     catch (InterruptedException e) 
                        Log.e(TAG, "InterruptedException in connect", e);
                    
                
            
        
        if (myBSock == null) 
            Log.v("a", "connection service->connect->myBSock==NULLss");
            return Connection.FAILURE;
        
        mBtSockets.put(device, myBSock);
        mBtDeviceAddresses.add(device);
        Thread mBtStreamWatcherThread = new Thread(new BtStreamWatcher(device));
        mBtStreamWatcherThread.start();
        mBtStreamWatcherThreads.put(device, mBtStreamWatcherThread);
        return Connection.SUCCESS;
    

手机与第 3 或第 4 个设备连接时返回 myBSock==null。 但如果代码工作正常,它必须返回设备的地址和 应该添加 mBtDeviceAddresses.add(device);进入服务器列表。

请帮助我们解决问题。

提前致谢

【问题讨论】:

我不确定您是否可以在同一个蓝牙配置文件上启动多个连接... 这取决于设备,它可以同时支持多少连接。 superuser.com/questions/332767/… 【参考方案1】:
package com.switching.bluetooth;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import com.switching.ServerMainActivity;

/**
 * This class does all the work for setting up and managing Bluetooth
 * connections with other devices. It has a thread that listens for incoming
 * connections, a thread for connecting with a device, and a thread for
 * performing data transmissions when connected.
 */
public class BluetoothService 
    // Debugging
    private static final String TAG = "BluetoothService iBT";
    private static final boolean D = true;

    // Name for the SDP record when creating server socket
    private static final String NAME = "i BT";

    // Unique UUID for this application
    private static UUID MY_UUID;

    // Member fields
    private final BluetoothAdapter mAdapter;
    private final Handler mHandler;
    private AcceptThread mAcceptThread;
    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;
    private int mState;

    private ArrayList<String> mDeviceAddresses;
    private ArrayList<String> mDeviceNames;
    private ArrayList<ConnectedThread> mConnThreads;
    private ArrayList<BluetoothSocket> mSockets;

    /**
     * A bluetooth piconet can support up to 7 connections. This array holds 7
     * unique UUIDs. When attempting to make a connection, the UUID on the
     * client must match one that the server is listening for. When accepting
     * incoming connections server listens for all 7 UUIDs. When trying to form
     * an outgoing connection, the client tries each UUID one at a time.
     */
    private ArrayList<UUID> mUuids;

    // 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 BluetoothService(Context context, Handler handler) 
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;
        mHandler = handler;

        initializeArrayLists();

        // 7 randomly-generated UUIDs. These must match on both server and
        // client.
        // mUuids.add(UUID.fromString("b7746a40-c758-4868-aa19-7ac6b3475dfc"));
        // mUuids.add(UUID.fromString("2d64189d-5a2c-4511-a074-77f199fd0834"));
        // mUuids.add(UUID.fromString("e442e09a-51f3-4a7b-91cb-f638491d1412"));
        // mUuids.add(UUID.fromString("a81d6504-4536-49ee-a475-7d96d09439e4"));
        // mUuids.add(UUID.fromString("aa91eab1-d8ad-448e-abdb-95ebba4a9b55"));
        // mUuids.add(UUID.fromString("4d34da73-d0a4-4f40-ac38-917e0a9dee97"));
        // mUuids.add(UUID.fromString("5e14d4df-9c8a-4db7-81e4-c937564c86e0"));
    

    public static UUID getMY_UUID() 
        return MY_UUID;
    

    public static void setMY_UUID(UUID mY_UUID) 
        MY_UUID = mY_UUID;
    

    public boolean isDeviceConnectedAtPosition(int position) 
        if (mConnThreads.get(position) == null) 
            return false;
        
        return true;
    

    private void initializeArrayLists() 
        mDeviceAddresses = new ArrayList<String>(5);
        mDeviceNames = new ArrayList<String>(5);
        mConnThreads = new ArrayList<ConnectedThread>(5);
        mSockets = new ArrayList<BluetoothSocket>(5);
        mUuids = new ArrayList<UUID>(5);

        for (int i = 0; i < 5; i++) 
            mDeviceAddresses.add(null);
            mDeviceNames.add(null);
            mConnThreads.add(null);
            mSockets.add(null);
            mUuids.add(null);
        

        Log.i(TAG, "mConnThreads.size() in Service Constructor--"
                + mConnThreads.size());
    

    public ArrayList<String> getmDeviceNames() 
        return this.mDeviceNames;
    

    public void setmDeviceNames(ArrayList<String> mDeviceNames) 
        this.mDeviceNames = mDeviceNames;
    

    public ArrayList<String> getmDeviceAddresses() 
        return mDeviceAddresses;
    

    public void setmDeviceAddresses(ArrayList<String> mDeviceAddresses) 
        this.mDeviceAddresses = mDeviceAddresses;
    

    /**
     * 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(ServerMainActivity.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,
            int selectedPosition) 

        if (getPositionIndexOfDevice(device) == -1) 
            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 (mConnThreads.get(selectedPosition) != null) 
                mConnThreads.get(selectedPosition).cancel();
                // mConnectedThread = null;
                mConnThreads.set(selectedPosition, null);
            

            // Create a new thread and attempt to connect to each UUID
            // one-by-one.
            try 

                // String
                // s="00001101-0000-1000-8000"+device.getAddress().split(":");
                ConnectThread mConnectThread = new ConnectThread(device,
                        UUID.fromString("00001101-0000-1000-8000-"
                                + device.getAddress().replace(":", "")),
                        selectedPosition);
                Log.i(TAG, "uuid-string at server side"
                        + ("00001101-0000-1000-8000" + device.getAddress()
                                .replace(":", "")));
                mConnectThread.start();
                setState(STATE_CONNECTING);
             catch (Exception e) 
            
         else 
            Message msg = mHandler
                    .obtainMessage(ServerMainActivity.MESSAGE_TOAST);
            Bundle bundle = new Bundle();
            bundle.putString(ServerMainActivity.TOAST,
                    "This device " + device.getName() + " Already Connected");
            msg.setData(bundle);
            mHandler.sendMessage(msg);
        
    

    /**
     * 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, int selectedPosition) 
        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
        ConnectedThread mConnectedThread = new ConnectedThread(socket);
        mConnectedThread.start();
        // Add each connected thread to an array
        mConnThreads.set(selectedPosition, mConnectedThread);

        // Send the name of the connected device back to the UI Activity
        Message msg = mHandler
                .obtainMessage(ServerMainActivity.MESSAGE_DEVICE_NAME);
        Bundle bundle = new Bundle();
        bundle.putString(ServerMainActivity.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;
        

        for (int i = 0; i < 5; i++) 
            mDeviceNames.set(i, null);
            mDeviceAddresses.set(i, null);
            mSockets.set(i, null);
            if (mConnThreads.get(i) != null) 
                mConnThreads.get(i).cancel();
                mConnThreads.set(i, 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) 
        // When writing, try to write out to all connected threads
        for (int i = 0; i < mConnThreads.size(); i++) 
            try 
                // Create temporary object
                ConnectedThread r;
                // Synchronize a copy of the ConnectedThread
                synchronized (this) 
                    if (mState != STATE_CONNECTED)
                        return;
                    r = mConnThreads.get(i);
                
                // Perform the write unsynchronized
                r.write(out);
             catch (Exception e) 
            
        
    

    /**
     * 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(ServerMainActivity.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString(ServerMainActivity.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(BluetoothDevice device) 
        // setState(STATE_LISTEN);
        int positionIndex = getPositionIndexOfDevice(device);
        if (positionIndex != -1) 
            Log.i(TAG, "getPositionIndexOfDevice(device) ==="
                    + mDeviceAddresses.get(getPositionIndexOfDevice(device)));
            mDeviceAddresses.set(positionIndex, null);
            mDeviceNames.set(positionIndex, null);
            mConnThreads.set(positionIndex, null);

            Message msg = mHandler
                    .obtainMessage(ServerMainActivity.MESSAGE_TOAST);
            Bundle bundle = new Bundle();
            bundle.putString(ServerMainActivity.TOAST,
                    "Device connection was lost from " + device.getName());
            msg.setData(bundle);
            mHandler.sendMessage(msg);
        
        // Send a failure message back to the Activity
    

    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 

                if (mAdapter.isEnabled()) 
                    BluetoothService.setMY_UUID(UUID
                            .fromString("00001101-0000-1000-8000-"
                                    + mAdapter.getAddress().replace(":", "")));
                
                Log.i(TAG, "MY_UUID.toString()=="
                        + BluetoothService.getMY_UUID().toString());

                tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME,
                        BluetoothService.getMY_UUID());
             catch (IOException e) 
                Log.e(TAG, "listen() failed", e);
            
            mmServerSocket = tmp;
        

        public void run() 
            if (D)
                Log.d(TAG, "BEGIN mAcceptThread" + this);
            setName("AcceptThread");
            BluetoothSocket socket = null;
            Log.i(TAG, "mState in acceptThread==" + mState);
            // Listen to the server socket if we're not connected
            while (mState != STATE_CONNECTED) 
                try 
                    // This is a blocking call and will only return on a
                    // successful connection or an exception
                    socket = mmServerSocket.accept();
                 catch (IOException e) 
                    Log.e(TAG, "accept() failed", e);
                    break;
                

                // If a connection was accepted
                if (socket != null) 
                    synchronized (BluetoothService.this) 
                        switch (mState) 
                        case STATE_LISTEN:
                        case STATE_CONNECTING:
                            // Situation normal. Start the connected thread.
                            connected(socket, socket.getRemoteDevice(),getAvailablePositionIndexForNewConnection(socket.getRemoteDevice()));
                            break;
                        case STATE_NONE:
                        case STATE_CONNECTED:
                            // Either not ready or already connected. Terminate
                            // new socket.
                            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 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 
    // BluetoothServerSocket serverSocket = null;
    //
    // public AcceptThread() 
    // 
    //
    // public void run() 
    // if (D)
    // Log.d(TAG, "BEGIN mAcceptThread" + this);
    // setName("AcceptThread");
    // BluetoothSocket socket = null;
    // try 
    // // Listen for all 7 UUIDs
    // serverSocket = mAdapter.listenUsingRfcommWithServiceRecord(
    // NAME, MY_UUID);
    // socket = serverSocket.accept();
    // if (socket != null) 
    // String address = socket.getRemoteDevice().getAddress();
    // mSockets.add(socket);
    // mDeviceAddresses.add(address);
    // mDeviceNames.add(socket.getRemoteDevice().getName());
    // // connected(socket, socket.getRemoteDevice());
    // 
    //  catch (IOException e) 
    // Log.e(TAG, "accept() failed", e);
    // 
    // if (D)
    // Log.i(TAG, "END mAcceptThread");
    // 
    //
    // public void cancel() 
    // if (D)
    // Log.d(TAG, "cancel " + this);
    // try 
    // serverSocket.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 final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;
        private UUID tempUuid;
        private int selectedPosition;

        public ConnectThread(BluetoothDevice device, UUID uuidToTry,
                int selectedPosition) 
            mmDevice = device;
            BluetoothSocket tmp = null;
            tempUuid = uuidToTry;
            this.selectedPosition = selectedPosition;
            // Get a BluetoothSocket for a connection with the
            // given BluetoothDevice
            try 
                tmp = device.createRfcommSocketToServiceRecord(uuidToTry);
             catch (IOException e) 
                Log.e(TAG, "create() failed", e);
            
            mmSocket = tmp;
        

        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
                mmSocket.connect();
             catch (IOException e) 
                // if
                // (tempUuid.toString().contentEquals(mUuids.get(6).toString()))
                // 
                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
                BluetoothService.this.start();
                return;
            

            // Reset the ConnectThread because we're done
            synchronized (BluetoothService.this) 
                mConnectThread = null;
            
            mDeviceAddresses.set(selectedPosition, mmDevice.getAddress());
            mDeviceNames.set(selectedPosition, mmDevice.getName());
            // Start the connected thread
            connected(mmSocket, mmDevice, selectedPosition);
        

        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;
        

        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
                    mHandler.obtainMessage(
                            ServerMainActivity.MESSAGE_READ,
                            bytes,
                            getPositionIndexOfDevice(mmSocket.getRemoteDevice()),
                            buffer).sendToTarget();
                    Log.i("**********read", "read Called........");
                 catch (IOException e) 
                    Log.e(TAG, "disconnected", e);
                    connectionLost(mmSocket.getRemoteDevice());
                    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
                mHandler.obtainMessage(ServerMainActivity.MESSAGE_WRITE, -1,
                        -1, buffer).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);
            
        
    

    public int getPositionIndexOfDevice(BluetoothDevice device) 
        for (int i = 0; i < mDeviceAddresses.size(); i++) 
            if (mDeviceAddresses.get(i) != null
                    && mDeviceAddresses.get(i).equalsIgnoreCase(
                            device.getAddress()))
                return i;
        
        return -1;
    

    public int getAvailablePositionIndexForNewConnection(BluetoothDevice device)       
        if (getPositionIndexOfDevice(device) == -1) 
            for (int i = 0; i < mDeviceAddresses.size(); i++) 
                if (mDeviceAddresses.get(i) == null) 
                    return i;
                
            
        
        return -1;
    

【讨论】:

一个蓝牙微微网最多可以支持7个连接。 1个主人和7个奴隶。 infowester.com/img_art/esqbluetooth.gif【参考方案2】:

我在完成相关工作后成功实现了这一点,在此过程中我遇到了一些棘手的错误,例如我必须实现握手协议(类似于that)以避免连接尝试期间出现超时问题。

好吧,我开始查看 BluetoothChat 示例(Android SDK 示例),它实现了 2 个设备之间的通信。因此,我对其进行了修改,以允许多个连接。随着代码变大,我只告诉你我使用的方法。

基本上,运行我的应用程序的所有设备都可以是服务器或客户端。所以每一个,总是有一个BluetoothServerSocket(AcceptThread)在运行,这样,每一个设备总是能够接收到一个请求连接。

一个想要连接的设备,启动一个 ConnectThread,这个线程在发现过程之后启动,或者如果它选择 PairedDevices Using getBondedDevices 的 BluetoothDevice。

建立连接后,我创建一个新的线程(ConnectedThread)来表示该连接。如果你想有不同的行为取决于你的设备角色(主或从),你可以有一个 ConnectedThread 子类,如 MasterThread 和 SlaveThread

Android 文档很好地解释了如何使用蓝牙:http://developer.android.com/guide/topics/connectivity/bluetooth.html

【讨论】:

一旦 ServerSocket 接受了一个新的套接字,你是否关闭了服务器套接字并使用相同的 UUID 重新创建它? 是的。我只为所有连接使用了一个 UUID。 @BrunoMateus:我们可以在某处看到您的代码吗?会很有帮助的!

以上是关于在android中通过蓝牙进行多连接的主要内容,如果未能解决你的问题,请参考以下文章

如何实现在 Flutter 中通过蓝牙打印字符串?

android多连接蓝牙编程,据说可以同时进行7个连接?

Android 蓝牙开发-打开蓝牙后能不能立即连接固定地址的蓝牙设备??还是需要进行判断啥的?

Android项目实战(三十四):蓝牙4.0 BLE 多设备连接

Android 经典蓝牙开发(一)

在 NodeJS 中通过 USB 连接 Android/iPhone 设备