Android(十六 ) android 与蓝牙串口通讯

1.得到蓝牙适配器

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); 

2.打开蓝牙

if (!mBluetoothAdapter.isEnabled()) {     
　　　　Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);     
　　　　startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
 }

3.配对（绑定）蓝牙

Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices(); 
if (pairedDevices.size() > 0) {     
　　for (BluetoothDevice device : pairedDevices) {         
　　　　mArrayAdapter.add(device.getName() + "
" + device.getAddress());     
   }
 }

4.连接蓝牙

因为调用BluetoothSocket.connect()会阻塞线程，所以不能在主线程中调用。

private class ConnectThread extends Thread {     
    private final BluetoothSocket mmSocket;     
    private final BluetoothDevice mmDevice; 
    
    public ConnectThread(BluetoothDevice device) {         
        // Use a temporary object that is later assigned to mmSocket,         
        // because mmSocket is final         
        BluetoothSocket tmp = null;         
        mmDevice = device;           
        // Get a BluetoothSocket to connect with the given BluetoothDevice         
        try {             
            // MY_UUID is the app's UUID string, also used by the server code             
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);         
        } catch (IOException e) { 

        }         
        mmSocket = tmp;
　　　　 InputStream iStream　 = mmSocket.getInputStream();
    }       
        
    public void run() {         
        // Cancel discovery because it will slow down the connection         
        mBluetoothAdapter.cancelDiscovery();           
            try {             
                // Connect the device through the socket. This will block             
                // until it succeeds or throws an exception             
                mmSocket.connect();        
            } catch (IOException connectException) {             
                // Unable to connect; close the socket and get out            
                try {                 
                    mmSocket.close();             
                } catch (IOException closeException) { 
                
                }             
                
                return;        
           }           
           // Do work to manage the connection (in a separate thread)         
           manageConnectedSocket(mmSocket);     
    }       
    
    /** Will cancel an in-progress connection, and close the socket */     
    public void cancel() {         
        try {             
            mmSocket.close();         
        } catch (IOException e) { 
        
        }     
    } 
}

5.通信

private class ConnectedThread extends Thread {     
    private final BluetoothSocket mmSocket;     
    private final InputStream mmInStream;     
    private final OutputStream mmOutStream;       
    public ConnectedThread(BluetoothSocket socket) {         
        mmSocket = socket;         
        InputStream tmpIn = null;         
        OutputStream tmpOut = null;           
        // Get the input and output streams, using temp objects because         
        // member streams are final         
        try {             
            tmpIn = socket.getInputStream();             
            tmpOut = socket.getOutputStream();         
        } catch (IOException e) { 
        
        }           
        mmInStream = tmpIn;         
        mmOutStream = tmpOut;     
    }       
    
    public void run() {         
        byte[] buffer = new byte[1024];  
        // buffer store for the stream         
        int bytes; // bytes returned from read()           
        // Keep listening to the InputStream until an exception occurs        
        while (true) {             
            try {                 
                // Read from the InputStream                 
                bytes = mmInStream.read(buffer);                 
                // Send the obtained bytes to the UI activity                 
                mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)                         
                        .sendToTarget();             
            } catch (IOException e) {      
                break;            
            }         
        }     
    }       
    
    /* Call this from the main activity to send data to the remote device */     
    public void write(byte[] bytes) {         
        try {             
            mmOutStream.write(bytes);         
        } catch (IOException e) {
        
        }     
    }      
    
    /* Call this from the main activity to shutdown the connection */     
    
    public void cancel() {         
        try {             
            mmSocket.close();         
        } catch (IOException e) {
        
        }    
   }
}

6.已配对 和 已连接 的区别

（1）To be paired（已经配对） means that two devices are aware of each other's existence, have a shared link-key that can

be used for authentication, and are capable of establishing an encrypted connection with each other.  Pairing（配对过程） is

automatically performed when you initiate an encrypted connection with the Bluetooth APIs.)

（2）To be connected means that the devices currently share an RFCOMM channel and are able to transmit data

with each other. The current Android Bluetooth API's require devices to be paired before an RFCOMM connection

can be established. 

7.地址