通过蓝牙将多个设备连接到一个设备

Question

我想创建一个游戏，您必须通过蓝牙将多个设备（4+）连接到主设备（例如平板电脑）。将会有两个应用程序，一个主要的应用程序，所有数据将从手机发送到手机。 这甚至可能吗？

Answer 1

这是部分可能的（对于最多2个设备），因为设备只能同时连接到另一个设备。在你的情况下更好的解决方案将创建一个TCP服务器，它将信息发送到其他设备 - 但这当然需要互联网连接。另请参阅三星Chord API - 它提供了您需要的功能，但是每个设备都必须连接到同一个Wi-Fi网络

Answer 2

是的，这是可能的。在最低级别，蓝牙允许您将最多7个设备连接到一个主设备。我已经做到了这一点，它对我来说效果很好，但是只在其他平台（linux）上有很多手动控制 - 我从来没有在Android上尝试过，并且有一些可能的复杂因素，所以您需要进行一些测试待确认。

其中一个问题是，你需要平板电脑的主人，Android不给你任何明确的控制。这很可能不会成为问题，因为 *平板电脑将在您尝试连接第二台设备时自动成为主设备，或者您可以通过设置方式控制主/从角色你的套接字连接

虽然大多数在移动设备上使用蓝牙的应用都不会尝试多次同时连接，并且蓝牙可能有点脆弱，例如如果两个设备已经为其他应用程序建立了蓝牙连接，那么该怎么影响角色呢？

Answer 3

我不认为这是可能的蓝牙，但你可以尝试寻找WiFi Peer-to-Peer,
它允许一对多的连接。

Answer 4

蓝牙4.0允许你在一个蓝牙微微网中，一个主站可以传送多达7个活动的从站，可以有一些其他设备多达248个设备正在休眠。

此外，您可以使用一些奴隶作为桥梁参与更多的设备。

Answer 5

是的，你可以这样做，我创建了a library为相同。
这允许您将最多四个设备连接到主服务器设备，为每个客户端创建不同的通道并在不同线程上运行交互。
要使用此库，请简单地在您的build.gradl e的依赖部分中添加编译com.mdg.androble:library:0.1.2。

Answer 6

这是建立连接并收到消息的类。 确保在运行应用程序之前配对设备。 如果您想要有一个从站/主站连接，其中每个从站只能将消息发送给主站，并且主站可以将消息广播到所有从站。 您应该只将主机与每个从机配对，但不应将从机配对在一起。

package com.example.gaby.coordinatorv1; 
    import java.io.DataInputStream; 
    import java.io.IOException; 
    import java.io.InputStream; 
    import java.io.OutputStream; 
    import java.util.ArrayList; 
    import java.util.HashMap; 
    import java.util.Set; 
    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 android.widget.Toast; 

    public class Piconet { 


     private final static String TAG = Piconet.class.getSimpleName(); 

     // Name for the SDP record when creating server socket 
     private static final String PICONET = "ANDROID_PICONET_BLUETOOTH"; 

     private final BluetoothAdapter mBluetoothAdapter; 

     // String: device address 
     // BluetoothSocket: socket that represent a bluetooth connection 
     private HashMap<String, BluetoothSocket> mBtSockets; 

     // String: device address 
     // Thread: thread for connection 
     private HashMap<String, Thread> mBtConnectionThreads; 

     private ArrayList<UUID> mUuidList; 

     private ArrayList<String> mBtDeviceAddresses; 

     private Context context; 


     private Handler handler = new Handler() { 
      public void handleMessage(Message msg) { 
       switch (msg.what) { 
        case 1: 
         Toast.makeText(context, msg.getData().getString("msg"), Toast.LENGTH_SHORT).show(); 
         break; 
        default: 
         break; 
       } 
      }; 
     }; 

     public Piconet(Context context) { 
      this.context = context; 

      mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); 

      mBtSockets = new HashMap<String, BluetoothSocket>(); 
      mBtConnectionThreads = new HashMap<String, Thread>(); 
      mUuidList = new ArrayList<UUID>(); 
      mBtDeviceAddresses = new ArrayList<String>(); 

      // Allow up to 7 devices to connect to the server 
      mUuidList.add(UUID.fromString("a60f35f0-b93a-11de-8a39-08002009c666")); 
      mUuidList.add(UUID.fromString("54d1cc90-1169-11e2-892e-0800200c9a66")); 
      mUuidList.add(UUID.fromString("6acffcb0-1169-11e2-892e-0800200c9a66")); 
      mUuidList.add(UUID.fromString("7b977d20-1169-11e2-892e-0800200c9a66")); 
      mUuidList.add(UUID.fromString("815473d0-1169-11e2-892e-0800200c9a66")); 
      mUuidList.add(UUID.fromString("503c7434-bc23-11de-8a39-0800200c9a66")); 
      mUuidList.add(UUID.fromString("503c7435-bc23-11de-8a39-0800200c9a66")); 

      Thread connectionProvider = new Thread(new ConnectionProvider()); 
      connectionProvider.start(); 

     } 



     public void startPiconet() { 
      Log.d(TAG, " -- Looking devices -- "); 
      // The devices must be already paired 
      Set<BluetoothDevice> pairedDevices = mBluetoothAdapter 
        .getBondedDevices(); 
      if (pairedDevices.size() > 0) { 
       for (BluetoothDevice device : pairedDevices) { 
        // X , Y and Z are the Bluetooth name (ID) for each device you want to connect to 
        if (device != null && (device.getName().equalsIgnoreCase("X") || device.getName().equalsIgnoreCase("Y") 
          || device.getName().equalsIgnoreCase("Z") || device.getName().equalsIgnoreCase("M"))) { 
         Log.d(TAG, " -- Device " + device.getName() + " found --"); 
         BluetoothDevice remoteDevice = mBluetoothAdapter 
           .getRemoteDevice(device.getAddress()); 
         connect(remoteDevice); 
        } 
       } 
      } else { 
       Toast.makeText(context, "No paired devices", Toast.LENGTH_SHORT).show(); 
      } 
     } 

     private class ConnectionProvider implements Runnable { 
      @Override 
      public void run() { 
       try { 
        for (int i=0; i<mUuidList.size(); i++) { 
         BluetoothServerSocket myServerSocket = mBluetoothAdapter 
           .listenUsingRfcommWithServiceRecord(PICONET, mUuidList.get(i)); 
         Log.d(TAG, " ** Opened connection for uuid " + i + " ** "); 

         // This is a blocking call and will only return on a 
         // successful connection or an exception 
         Log.d(TAG, " ** Waiting connection for socket " + i + " ** "); 
         BluetoothSocket myBTsocket = myServerSocket.accept(); 
         Log.d(TAG, " ** Socket accept for uuid " + i + " ** "); 
         try { 
          // Close the socket now that the 
          // connection has been made. 
          myServerSocket.close(); 
         } catch (IOException e) { 
          Log.e(TAG, " ** IOException when trying to close serverSocket ** "); 
         } 

         if (myBTsocket != null) { 
          String address = myBTsocket.getRemoteDevice().getAddress(); 

          mBtSockets.put(address, myBTsocket); 
          mBtDeviceAddresses.add(address); 

          Thread mBtConnectionThread = new Thread(new BluetoohConnection(myBTsocket)); 
          mBtConnectionThread.start(); 

          Log.i(TAG," ** Adding " + address + " in mBtDeviceAddresses ** "); 
          mBtConnectionThreads.put(address, mBtConnectionThread); 
         } else { 
          Log.e(TAG, " ** Can't establish connection ** "); 
         } 
        } 
       } catch (IOException e) { 
        Log.e(TAG, " ** IOException in ConnectionService:ConnectionProvider ** ", e); 
       } 
      } 
     } 

     private class BluetoohConnection implements Runnable { 
      private String address; 

      private final InputStream mmInStream; 

      public BluetoohConnection(BluetoothSocket btSocket) { 

       InputStream tmpIn = null; 

       try { 
        tmpIn = new DataInputStream(btSocket.getInputStream()); 
       } catch (IOException e) { 
        Log.e(TAG, " ** IOException on create InputStream object ** ", e); 
       } 
       mmInStream = tmpIn; 
      } 
      @Override 
      public void run() { 
       byte[] buffer = new byte[1]; 
       String message = ""; 
       while (true) { 

        try { 
         int readByte = mmInStream.read(); 
         if (readByte == -1) { 
          Log.e(TAG, "Discarting message: " + message); 
          message = ""; 
          continue; 
         } 
         buffer[0] = (byte) readByte; 

         if (readByte == 0) { // see terminateFlag on write method 
          onReceive(message); 
          message = ""; 
         } else { // a message has been recieved 
          message += new String(buffer, 0, 1); 
         } 
        } catch (IOException e) { 
         Log.e(TAG, " ** disconnected ** ", e); 
        } 

        mBtDeviceAddresses.remove(address); 
        mBtSockets.remove(address); 
        mBtConnectionThreads.remove(address); 
       } 
      } 
     } 

     /** 
     * @param receiveMessage 
     */ 
     private void onReceive(String receiveMessage) { 
      if (receiveMessage != null && receiveMessage.length() > 0) { 
       Log.i(TAG, " $$$$ " + receiveMessage + " $$$$ "); 
       Bundle bundle = new Bundle(); 
       bundle.putString("msg", receiveMessage); 
       Message message = new Message(); 
       message.what = 1; 
       message.setData(bundle); 
       handler.sendMessage(message); 
      } 
     } 

     /** 
     * @param device 
     * @param uuidToTry 
     * @return 
     */ 
     private BluetoothSocket getConnectedSocket(BluetoothDevice device, UUID uuidToTry) { 
      BluetoothSocket myBtSocket; 
      try { 
       myBtSocket = device.createRfcommSocketToServiceRecord(uuidToTry); 
       myBtSocket.connect(); 
       return myBtSocket; 
      } catch (IOException e) { 
       Log.e(TAG, "IOException in getConnectedSocket", e); 
      } 
      return null; 
     } 

     private void connect(BluetoothDevice device) { 
      BluetoothSocket myBtSocket = null; 
      String address = device.getAddress(); 
      BluetoothDevice remoteDevice = mBluetoothAdapter.getRemoteDevice(address); 
      // Try to get connection through all uuids available 
      for (int i = 0; i < mUuidList.size() && myBtSocket == null; i++) { 
       // Try to get the socket 2 times for each uuid of the list 
       for (int j = 0; j < 2 && myBtSocket == null; j++) { 
        Log.d(TAG, " ** Trying connection..." + j + " with " + device.getName() + ", uuid " + i + "...** "); 
        myBtSocket = getConnectedSocket(remoteDevice, mUuidList.get(i)); 
        if (myBtSocket == null) { 
         try { 
          Thread.sleep(200); 
         } catch (InterruptedException e) { 
          Log.e(TAG, "InterruptedException in connect", e); 
         } 
        } 
       } 
      } 
      if (myBtSocket == null) { 
       Log.e(TAG, " ** Could not connect ** "); 
       return; 
      } 
      Log.d(TAG, " ** Connection established with " + device.getName() +"! ** "); 
      mBtSockets.put(address, myBtSocket); 
      mBtDeviceAddresses.add(address); 
      Thread mBluetoohConnectionThread = new Thread(new BluetoohConnection(myBtSocket)); 
      mBluetoohConnectionThread.start(); 
      mBtConnectionThreads.put(address, mBluetoohConnectionThread); 

     } 

     public void bluetoothBroadcastMessage(String message) { 
      //send message to all except Id 
      for (int i = 0; i < mBtDeviceAddresses.size(); i++) { 
       sendMessage(mBtDeviceAddresses.get(i), message); 
      } 
     } 

     private void sendMessage(String destination, String message) { 
      BluetoothSocket myBsock = mBtSockets.get(destination); 
      if (myBsock != null) { 
       try { 
        OutputStream outStream = myBsock.getOutputStream(); 
        final int pieceSize = 16; 
        for (int i = 0; i < message.length(); i += pieceSize) { 
         byte[] send = message.substring(i, 
           Math.min(message.length(), i + pieceSize)).getBytes(); 
         outStream.write(send); 
        } 
        // we put at the end of message a character to sinalize that message 
        // was finished 
        byte[] terminateFlag = new byte[1]; 
        terminateFlag[0] = 0; // ascii table value NULL (code 0) 
        outStream.write(new byte[1]); 
       } catch (IOException e) { 
        Log.d(TAG, "line 278", e); 
       } 
      } 
     } 

    } 

您的主要活动应为：

package com.example.gaby.coordinatorv1; 

import android.app.Activity; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.Button; 

public class MainActivity extends Activity { 

    private Button discoveryButton; 
    private Button messageButton; 

    private Piconet piconet; 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 

     piconet = new Piconet(getApplicationContext()); 

     messageButton = (Button) findViewById(R.id.messageButton); 
     messageButton.setOnClickListener(new View.OnClickListener() { 
      @Override 
      public void onClick(View v) { 
       piconet.bluetoothBroadcastMessage("Hello World---*Gaby Bou Tayeh*"); 
      } 
     }); 

     discoveryButton = (Button) findViewById(R.id.discoveryButton); 
     discoveryButton.setOnClickListener(new View.OnClickListener() { 
      @Override 
      public void onClick(View v) { 
       piconet.startPiconet(); 
      } 
     }); 

    } 

} 

而这里的XML布局：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
xmlns:tools="http://schemas.android.com/tools" 
android:layout_width="match_parent" 
android:layout_height="match_parent" 
tools:context=".MainActivity" > 

<Button 
    android:id="@+id/discoveryButton" 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:text="Discover" 
    /> 

<Button 
    android:id="@+id/messageButton" 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:text="Send message" 
    /> 

不要忘了下列权限添加到您的清单文件：

<uses-permission android:name="android.permission.BLUETOOTH" /> 
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" /> 

Answer 7

我认为它可能提供，如果它是一个串行数据在广播方法。但您将无法将任何语音/音频数据传输到其他从属设备。按照蓝牙4.0，协议不支持这一点。然而，广播音频/语音数据正在改进。