Android 普通藍芽學習

雖然做開發有一段時間了，但是有關藍芽方面一直接觸的不多，正好目前有一個關於藍芽開發的需求，雖然是用到的BLE和普通藍芽有些區別，但是既然學習了就順便把普通藍芽也學習一下，也為了以後自己少走些彎路，先將這些學習筆記學習下來。官方文件

本例的原始碼已經上傳，檢視原始碼

需要的許可權

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

類

藍芽有關的所有的類如下：

普通藍芽用到的幾個關鍵的類：

• BluetoothAdapter 藍芽介面卡

  Represents the local device Bluetooth adapter. The BluetoothAdapter lets you perform fundamental Bluetooth tasks, such as initiate device discovery,

  query a list of bonded (paired) devices, instantiate a BluetoothDevice using a known MAC address, and create a BluetoothServerSocket to listen for

  connection requests from other devices, and start a scan for Bluetooth LE devices.

  根據官方文件的說明，BluetoothAdapter可以執行基本的藍芽任務，比如啟動裝置發現，查詢已配對的藍芽列表，使用已知的地址例項化一個BluetoothDevice,建立一個BluetoothServerSocket

  監聽連結請求等。

• BluetoothDevice 藍芽裝置

  Represents a remote Bluetooth device. A BluetoothDevice lets you create a connection with the respective device or query information about it,

  such as the name, address, class, and bonding state.

  代表一個遠端藍芽裝置。BluetoothDevice允許建立一個連線的裝置或查詢相關資訊,如名稱、地址、階級和配對的狀態。

• BluetoothSocket

  The interface for Bluetooth Sockets is similar to that of TCP sockets: Socket and ServerSocket.

  顧名思義藍芽連線

• BluetoothServerSocket

  The interface for Bluetooth Sockets is similar to that of TCP sockets: Socket and ServerSocket.

  藍芽服務連結，後兩者都是和TCP埠類似的一個socket。

首先開啟藍芽開始搜尋等；

主要用到的幾個方法：

• getDefaultAdapter() 獲取一個介面卡物件

• getName() 獲取本地藍芽名稱

• getAddress() 獲取本地藍芽的地址

• enable() 開啟本地藍芽（低版本中不會提示使用者）

• isEnabled() 判斷藍芽是否已經開啟

• disable() 關閉本地藍芽

• startDiscovery() 開始搜尋（發現）

• cancelDiscovery() 取消裝置搜尋（發現）

• isDiscovering() 返回當前是否是在搜尋裝置

• listenUsingRfcommWithServiceRecord(String name, UUID uuid) 建立一個安全的BluetoothServerSocket

開啟藍芽

        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        //開啟藍芽 方法一
        if (!bluetoothAdapter.isEnabled()) {
            bluetoothAdapter.enable();
        }

        //方法二 推薦
        Intent enabler = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(enabler, REQUEST_ENABLE);

開始搜尋裝置

呼叫startDiscovery()開始搜尋裝置，但是僅僅呼叫此方法是沒有任何作用的，startDiscovery()是非同步呼叫，立即返回，需要註冊一個廣播接收者

來接受搜尋的結果。整個搜尋過程持續12秒。

//註冊
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, intentFilter);

//廣播接收者
BroadcastReceiver mReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            //找到裝置
            if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                BluetoothDevice device = intent
                        .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                Log.d("MainActivity", "搜尋到裝置");
                //在列表中顯示搜尋出的裝置
                adapter.add("name : " + device.getName() + "\n address : " + device.getAddress());
                bluetoothDevices.add(device);
            }
            //搜尋完成
            else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED
                    .equals(action)) {
                Log.d("MainActivity", "搜尋結束");
            } else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(action)) {
                Log.d("MainActivity", "開始搜尋");
            }
        }
    };

連線裝置

建立連線，Android sdk支援的藍芽連線是通過BluetoothSocket建立連線，伺服器端（BluetoothServerSocket）和客戶端（BluetoothSocket）需指定同樣的UUID，才能建立連線，因為建立連線的方法會阻塞執行緒，所以伺服器端和客戶端都應啟動新執行緒連線。

UUID的格式如下：

String uuid = "a60f35f0-b93a-11de-8a39-08002009c666";

建立伺服器端程式碼如下：

首先建立伺服器，獲取BluetoothServerSocket物件，通過BluetoothAdapter的listenUsingInsecureRfcommWithServiceRecord(String name, UUID uuid)方法和listenUsingRfcommWithServiceRecord(String name, UUID uuid)方法，其中前者是不安全的連結，後者是安全的連結。

然後使用BluetoothServerSocket.accept()方法接受客戶端連線，當連線成功返回一個BluetoothSocket物件。

    private class ServiceThread extends Thread {
        @Override
        public void run() {

            BluetoothServerSocket serverSocket = null;
            try {
                serverSocket = bluetoothAdapter.listenUsingRfcommWithServiceRecord("my_test_lianjie", UUID.fromString(uuid));
                Log.d("ServiceThread", "建立伺服器成功");
            } catch (IOException e) {
                e.printStackTrace();
                Log.d("ServiceThread", "建立伺服器失敗");
            }

            try {
                socket = serverSocket.accept();
                Log.d("ServiceThread", "客戶端連線成功");
                new ReadThread().start();
            } catch (IOException e) {
                e.printStackTrace();
                Log.d("ServiceThread", "客戶端連線失敗");
            }
        }
    }

建立客戶端連結程式碼如下：

這裡需要注意的是要對首先檢測裝置是否進行了配對，只有首先進行配對才能進行連線。藍芽配對是通過反射的方法呼叫BluetoothDevice.creMethod()方法。

建立連線首先獲取BluetoothSocket物件，呼叫BluetoothDevice的createInsecureRfcommSocketToServiceRecord(UUID uuid)或者createRfcommSocketToServiceRecord(UUID uuid)方法，其中前者是不安全的連結，後者是安全的連結。

然後呼叫BluetoothSocket.connect()方法進行連線。

    private class ConnectThread extends Thread {

        BluetoothDevice device;

        public ConnectThread(BluetoothDevice device) {
            this.device = device;
        }

        @Override
        public void run() {

            try {
                socket = device.createRfcommSocketToServiceRecord(UUID.fromString(uuid));
            } catch (IOException e) {
                e.printStackTrace();
            }


            if (device.getBondState() == BluetoothDevice.BOND_BONDED) { //已配對裝置 直接進行連結
                connectSocket();
            } else if (device.getBondState() == BluetoothDevice.BOND_NONE) { //未配對裝置 先配對再連結
                Method creMethod = null;
                try {
                    creMethod = BluetoothDevice.class.getMethod("createBond");
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
                Log.e("TAG", "開始配對");
                try {
                    creMethod.invoke(device);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                    Log.e("TAG", "配對失敗");
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }

        private void connectSocket() {
            try {
                socket.connect();
                Log.e("TAG", "連線成功");
                new ReadThread().start();
            } catch (IOException e) {
                e.printStackTrace();
                Log.e("TAG", "連線失敗");
            }
        }

        public void cancel() {
            try {
                socket.close();
                socket = null;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        }
    }

注意

客戶端建立連線的方式有很多種，這裡使用的是先獲得一個socket然後再檢查是否需要進行配對，再建立連線。

還可以通過反射的方法，通過埠進行連線。

進行通訊

藍芽通訊是通過流的方式進行的：

OutputStream outS = socket.getOutputStream();

InputStream inS = socket.getInputStream();

傳送的方法如：

                OutputStream os = null;
                try {
                    os = socket.getOutputStream();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    os.write("你好".getBytes());
                    Log.d("MainActivity", "傳送成功");
                } catch (IOException e) {
                    e.printStackTrace();
                    Log.d("MainActivity", "傳送失敗");
                }

接受的方法如：

    private class ReadThread extends Thread {
        @Override
        public void run() {
            byte[] buffer = new byte[1024];
            int bytes;
            InputStream mmInStream = null;

            try {
                mmInStream = socket.getInputStream();
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            while (true) {
                try {
                    // Read from the InputStream
                    if ((bytes = mmInStream.read(buffer)) > 0) {
                        byte[] buf_data = new byte[bytes];
                        for (int i = 0; i < bytes; i++) {
                            buf_data[i] = buffer[i];
                        }
                        String s = new String(buf_data);
                        Log.d("ReadThread", s);
                    }
                } catch (IOException e) {
                    try {
                        mmInStream.close();
                    } catch (IOException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                    break;
                }
            }
        }
    }

至此，普通藍芽的基本發現、連線、通訊功能就完成了，當然還有許多需要完善的地方。

寫的可能有些混亂，不足之處，還請指正，不喜忽噴。