UUID藍牙和Android設備

Question

我正在嘗試爲連接兩個設備的Android設備開發應用程序，但問題是我只能使用PC藍牙或與另一個操作系統（而不是Android）連接（使用藍牙）。

我覺得現在的問題是UUID，現在我使用的，在BluetoothCommandService.java：

private static final 
     UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb"); 

然後：

private class ConnectThread extends Thread { 
    private final BluetoothSocket mmSocket; 
    private final BluetoothDevice mmDevice; 

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

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

反正我離開這裏所有相關的代碼BluetoothCommandService.java：

package com.example.vista; 

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

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

public class BluetoothCommandService { 
    // Debugging 
    private static final String LOG_TAG = "BluetoothCommandService"; 
    private static final boolean DEBUG = true; 

    // Unique UUID for this application 
    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb"); 

    /*TelephonyManager tManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE); 
    String uuid = tManager.getDeviceId();*/ 


    // Member fields 
    private final BluetoothAdapter mAdapter; 
    private final Handler mHandler; 
    private ConnectThread mConnectThread; 
    private ConnectedThread mConnectedThread; 
    private int mState; 
// private BluetoothDevice mSavedDevice; 
// private int mConnectionLostCount; 

    // 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 

    // Constants that indicate command to computer 
    public static final int EXIT_CMD = -1; 
    public static final int VOL_UP = 1; 
    public static final int VOL_DOWN = 2; 
    public static final int MOUSE_MOVE = 3; 

    /** 
    * 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 BluetoothCommandService(Context context, Handler handler) { 
     if (DEBUG) Log.e(LOG_TAG, "BluetoothCommandService"); 
     mAdapter = BluetoothAdapter.getDefaultAdapter(); 
     mState = STATE_NONE; 
     //mConnectionLostCount = 0; 
     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 (DEBUG) Log.e(LOG_TAG, "setState() " + mState + " -> " + state); 
     mState = state; 

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

    /** 
    * Return the current connection state. */ 
    public synchronized int getState() { 
     Log.e(LOG_TAG, "MSTATE "+ mState); 
     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 (DEBUG) Log.e(LOG_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;} 


     setState(STATE_NONE); 
     Log.e(LOG_TAG, "start fin "+ mState); 
    } 

    /** 
    * Start the ConnectThread to initiate a connection to a remote device. 
    * @param device The BluetoothDevice to connect 
    */ 
    public synchronized void connect(BluetoothDevice device) { 
     if (DEBUG) Log.e(LOG_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) { 
     // 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;} 

     // 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(Buscarpartida.MESSAGE_DEVICE_NAME); 
     Bundle bundle = new Bundle(); 
     bundle.putString(Buscarpartida.DEVICE_NAME, device.getName()); 
     msg.setData(bundle); 
     mHandler.sendMessage(msg); 



     setState(STATE_CONNECTED); 
    } 

    /** 
    * Stop all threads 
    */ 
    public synchronized void stop() { 
     if (DEBUG) Log.e(LOG_TAG, "stop"); 
     if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;} 
     if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;} 

     setState(STATE_NONE); 
     if (DEBUG) Log.e(LOG_TAG, "stop fin "+ mState); 
    } 

    /** 
    * 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); 
    } 

    public void write(int 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(Buscarpartida.MESSAGE_TOAST); 
     Bundle bundle = new Bundle(); 
     bundle.putString(Buscarpartida.TOAST, "Imposible Conectar"); 
     msg.setData(bundle); 
     mHandler.sendMessage(msg); 
    } 

    /** 
    * Indicate that the connection was lost and notify the UI Activity. 
    */ 
    private void connectionLost() { 
//  mConnectionLostCount++; 
//  if (mConnectionLostCount < 3) { 
//   // Send a reconnect message back to the Activity 
//   Message msg = mHandler.obtainMessage(Main.MESSAGE_TOAST); 
//   Bundle bundle = new Bundle(); 
//   bundle.putString(Main.TOAST, "Device connection was lost. Reconnecting..."); 
//   msg.setData(bundle); 
//   mHandler.sendMessage(msg); 
//   
//   connect(mSavedDevice);  
//  } else { 
      setState(STATE_LISTEN); 
      // Send a failure message back to the Activity 
      Message msg = mHandler.obtainMessage(Buscarpartida.MESSAGE_TOAST); 
      Bundle bundle = new Bundle(); 
      bundle.putString(Buscarpartida.TOAST, "Conexion Perdida"); 
      msg.setData(bundle); 
      mHandler.sendMessage(msg); 
//  } 
    } 

    /** 
    * 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; 

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

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

     public void run() { 
      setName("ConnectThread"); 

      // Always cancel discovery because it will slow down a connection 
      mAdapter.cancelDiscovery(); 
      Log.e(LOG_TAG, "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(); 
       Log.e(LOG_TAG, "mmSocket.connect()"); 

      } catch (IOException e) { 
       connectionFailed(); 
       Log.e(LOG_TAG, " connectionFailed()"); 
       // Close the socket 
       try { 
        mmSocket.close(); 
       } catch (IOException e2) { 
        Log.e(LOG_TAG, "unable to close() socket during connection failure", e2); 
       } 
       // Start the service over to restart listening mode 
       Log.e(LOG_TAG, "run2()"); 
       BluetoothCommandService.this.start(); 

       return; 
      } 

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

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

     public void cancel() { 
      try { 
       mmSocket.close(); 
      } catch (IOException e) { 
       Log.e(LOG_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.e(LOG_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(LOG_TAG, "temp sockets not created", e); 
      } 

      mmInStream = tmpIn; 
      mmOutStream = tmpOut; 
     } 

     public void run() { 
      Log.e(LOG_TAG, "runrer"); 
      byte[] buffer = new byte[1024]; 

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

        // Send the obtained bytes to the UI Activity 
        mHandler.obtainMessage(Buscarpartida.MESSAGE_READ, bytes, -1, buffer) 
          .sendToTarget(); 
       } catch (IOException e) { 
        Log.e(LOG_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 
//    mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer) 
//      .sendToTarget(); 
      } catch (IOException e) { 
       Log.e(LOG_TAG, "Exception during write", e); 
      } 
     } 

     public void write(int out) { 
      try { 
       mmOutStream.write(out); 

       // Share the sent message back to the UI Activity 
//    mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer) 
//      .sendToTarget(); 
      } catch (IOException e) { 
       Log.e(LOG_TAG, "Exception during write", e); 
      } 
     } 

     public void cancel() { 
      try { 
       mmOutStream.write(EXIT_CMD); 
       mmSocket.close(); 
      } catch (IOException e) { 
       Log.e(LOG_TAG, "close() of connect socket failed", e); 
      } 
     } 
    } 
} 

非常感謝你！

Answer 1

你爲什麼會認爲：

private static final 
    UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb"); 

是UUID（通用唯一ID）？

您現在有全部您的設備使用這種代碼與相同 UUID。你需要得到更好的UUID ....

退房這個問題（和它的答案）：How can I get the UUID of my Android phone in an application?