android 蓝牙客户端与服务端通信

叁歲伎倆 2022-07-14 08:20 513阅读 0赞

![Center][]

首先介绍基本类及方法

一，BlueboothAdapter这个就是表示本机，里面几个常用的方法如下。

1，getDefaultAdapter 这个是静态的方法，通过它可以获取BlueboothAdapter对象

2，enable()  这个方法会弹出一个对话框(包含“确定”，“取消”按钮)提示用户打开蓝牙，用户选择确定则这个方法会返回true,取消返回false.

3,getNmae() 返回本机蓝牙的名称

4，getRemoteDevice(String address)根据给定一个地址参数获取远程蓝牙。

5，getAddress 获取本机的地址

6，startDiscovery() 扫描周围蓝牙，若找到蓝牙会发送 BluetoothDevice. ACTION\_FOUND广播

7 cancelDiscovery() 取消扫描

8，isEnabled() 判断蓝牙是否打开若打开则返回true,没有打开返回false

9，getBondedDevices() 返回绑定的蓝牙，

10，listenUsingRfcommWithServiceReord(String name,UUID uuid) 其中name通常是你的包名，也可以是任意字符串，UUID你可以通过浏览器在线获取

返回的是一个BlueboothServerSocket对象

BlueboothAdapter中常用的方法就是这么多，接下来是BlueboothDevice

二，BlueboothDevice 这个表示远程的设备，常用方法如下

1，getName 获取远程蓝牙的名字

2，getAddress获取远程蓝牙的地址

3，getBondState()获取远程蓝牙的绑定状态,Bond\_none 为绑定，bond\_bonding正在绑定，bond\_bonded已经绑定

3，createBond() 调用这个方法可以进行绑定蓝牙，这个方法要求的最低版本是19，当然你还可以通过反射进行绑定如下

Method method=(Method)BluetoothDevice.class.getMethod("createBond");

method.invoke(device);//device为你想要绑定的远程蓝牙

4，createRfcommSocketToServiceRecord(UUID uuid)//根据uuid获取BlueboothSocket对象，其中uuid一定要跟listenUsingRfcommWithServiceReord中给定的uuid一致

这里再说明一定蓝牙客户端与服务端进行通信时用BlueboothSocket获取输入流，输出流来进行通信的。

下面是代码包含蓝牙的搜索及绑定

public class MainActivity extends AppCompatActivity implements View.OnClickListener, AdapterView.OnItemClickListener {
        private Button search;
        private Button client;
        private ListView listBluebooth;
        private BluetoothAdapter bAdapter;
        private BluetoothDevice bDevice;
        private ListAdapter listAdapter;
        private List<String> deviceNames = new ArrayList<>();
        private List<String> deviceAddress = new ArrayList<>();
        private BluetoothDevice device;
        private IsSuccess isSuccess;
        private String isServer = "on";//判断是否为服务端 private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                search.setText("搜索完成");
                client.setText("搜索完成");
            }
        };
        private boolean sureBlueboothIsOpen=true;//默认蓝牙是打开状态 @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            init();
        }
    
        private void init() {
            client = (Button) findViewById(R.id.client);
            client.setOnClickListener(this);
            search = (Button) findViewById(R.id.search);
            search.setOnClickListener(this);
            listBluebooth = (ListView) findViewById(R.id.list_bluebooth);
            IntentFilter filter = new IntentFilter();
            filter.addAction(BluetoothDevice.ACTION_FOUND);
            filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
            registerReceiver(receiver, filter);
            bAdapter = BluetoothAdapter.getDefaultAdapter();
    
    
        }
    
        //得到已绑定的设备 private void addBoundDevice(BluetoothAdapter bAdapter) {
            Set<BluetoothDevice> set = bAdapter.getBondedDevices();
            Log.d("test", "set:" + set.size());
            for (BluetoothDevice device : set) {
                deviceNames.add(device.getName());
                deviceAddress.add(device.getAddress());
            }
            listAdapter = new ListAdapter(MainActivity.this, R.layout.bluebooth_item, deviceNames);
            /*listAdapter.notifyDataSetChanged();*/ listBluebooth.setAdapter(listAdapter);
            listBluebooth.setOnItemClickListener(this);
        }
    
        //搜索到发现蓝牙广播 BroadcastReceiver receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                Log.d("test", "action:" + intent.getAction());
                if (intent.getAction().equals(BluetoothDevice.ACTION_FOUND)) {
                    bDevice = (BluetoothDevice) intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    if (bDevice.getBondState() == BluetoothDevice.BOND_NONE) {
                        Log.d("test", "none");
                        deviceNames.add(bDevice.getName());
                        deviceAddress.add(bDevice.getAddress());
    
                    }
                    listAdapter.notifyDataSetChanged();
                    listBluebooth.setAdapter(listAdapter);
                } else if (intent.getAction().equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
    
                    handler.sendEmptyMessage(1);
                }
            }
        };
        
        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            if (resultCode == RESULT_OK) {
                Log.d("test", "result ok");
            }else {
                Log.d("test", resultCode + " result");
            }
            super.onActivityResult(requestCode, resultCode, data);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                //服务端只需打开蓝牙，不需扫描，只要等待客户端接入即可 case R.id.search:
                    if (!bAdapter.isEnabled()) {
                        sureBlueboothIsOpen=bAdapter.enable();
                    }
                    if (sureBlueboothIsOpen) {
                        isServer = "yes";
     Intent intent1 = new Intent(MainActivity.this, ChatActivity.class);
                        intent1.putExtra("is_server", isServer);
                        startActivity(intent1);
                        client.setEnabled(false);
                    }else {
                        Toast.makeText(getApplicationContext(),"蓝牙没有开启",Toast.LENGTH_SHORT).show();
                        return;
                    }
    
                    break;
                case R.id.client:
                    addBoundDevice(bAdapter);
                    //用户按下取消按钮返回false,确定返回true if (!bAdapter.isEnabled()) {
                        sureBlueboothIsOpen=bAdapter.enable();
                    }
                    if (sureBlueboothIsOpen) {
                        isServer = "no";
                        bAdapter.startDiscovery();
                        client.setText("搜索蓝牙中");
                        isSuccess = new IsSuccess();
                        isSuccess.start();
                        search.setEnabled(false);
                    }else {
                        Toast.makeText(getApplicationContext(),"蓝牙没有开启",Toast.LENGTH_SHORT).show();
                        return;
                    }
    
                    break;
    
            }
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            unregisterReceiver(receiver);
            if (isSuccess != null)
                isSuccess.interrupt();
        }
    
        //deviceNmaes list子项的点击事件配对蓝牙 @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            //你要想绑定的蓝牙 device = bAdapter.getRemoteDevice(deviceAddress.get(position));
    
                try {
                    Method method = (Method) BluetoothDevice.class.getMethod("createBond");
    
                    Log.d("test", (boolean) method.invoke(device) + ":" + device.getBondState());
                /*Log.d("test", device.createBond() + ":" + device.getBondState());*/ } catch (Exception e) {
                    e.printStackTrace();
                }
    
               /* address = deviceAddress.get(position); Intent intent1 = new Intent(MainActivity.this, ChatActivity.class); intent1.putExtra("device", address); intent1.putExtra("is_server", isServer); startActivity(intent1);*/ }
    
        //根据bDevice绑定状态判断用户是否按下匹配按钮 //这个线程会一直执行下去直到用户绑定蓝牙成功 class IsSuccess extends Thread {
            private int i = 0;
    
            @Override
            public void run() {
                while (true) {
    
                    i++;
    
    
                        /*Log.d("test", "device state:" + bDevice.getBondState());*/ if (device != null) {
                            break;
                        }
                       /* if (bDevice.getBondState() == 12 ) { break; }*/ try {
                        sleep(1000);
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
    
                }
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        if (device.getBondState() == 12) {
                            Intent intent1 = new Intent(MainActivity.this, ChatActivity.class);
                            intent1.putExtra("device", device.getAddress());
                            intent1.putExtra("is_server", isServer);
                            startActivity(intent1);
                        }
                    }
                });
            }
        }
    }

接着是客户端与服务端通信的代码

public class ChatActivity extends Activity implements View.OnClickListener {
        private ListView chat;
        private EditText content;
        private static String UUID_CODE="42385BC1-F486-5196-1956-9CBEF428212B";
        private Button send;
        private BluetoothSocket socket;
        private BluetoothServerSocket serverSocket;
        private BluetoothAdapter bAdapter;
        private BluetoothDevice device;
        private ReadThread readThread;//读线程 private String isServer;
        private List<String> messageLists = new ArrayList<>();
        private ArrayAdapter arrayAdapter;
        private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                if (msg.what == 3) {
                    Log.d("test", "message ==3");
                    readThread = new ReadThread(socket);
                    readThread.start();
                    messageLists.add("已连接到服务端:" + socket.getRemoteDevice().getName());
                }
                arrayAdapter = new ArrayAdapter(ChatActivity.this, android.R.layout.simple_list_item_1, messageLists);
                switch (msg.what) {
                    case 1:
    
                        break;
                    case 2:
                        String content = (String) msg.obj;
                        Log.d("test", "handler:" + content);
                        messageLists.add(content);
    
                        break;
                }
                Log.d("test", messageLists.size() + "");
                arrayAdapter.notifyDataSetChanged();
                chat.setAdapter(arrayAdapter);
                chat.setSelection(messageLists.size()-1);
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.char_layout);
            init();
        }
    
        @Override
        protected void onStart() {
            super.onStart();
            String isServer = getIntent().getStringExtra("is_server");
            if (isServer.equals("yes")) {
                Log.d("test", "server");
                this.isServer = "server";
                ServerThread serverThread = new ServerThread(bAdapter);
                serverThread.start();
            } else if (isServer.equals("no")) {
                Log.d("test", "client");
                this.isServer = "client";
                ClientThread clientThread = new ClientThread(device);
                clientThread.start();
            }
        }
    
        private void init() {
            chat = (ListView) findViewById(R.id.chat);
            content = (EditText) findViewById(R.id.content);
            send = (Button) findViewById(R.id.send);
            send.setOnClickListener(this);
            bAdapter = BluetoothAdapter.getDefaultAdapter();
            String address = getIntent().getStringExtra("device");
            if (!TextUtils.isEmpty(address)) {
                Log.d("test", "chat adress:" + address);
                device = bAdapter.getRemoteDevice(address);
            }
    
        }
    
        @Override
        public void onClick(View v) {
    
            switch (v.getId()) {
                case R.id.send:
                    Log.d("test", "onclick");
                    if (!TextUtils.isEmpty(content.getText())) {
                        /*sendMessage();*/ Log.d("test", "sendmessage");
                            sendMessage(content.getEditableText().toString());
                        //若读线程为空则再次创建读线程 if (readThread == null) {
                            readThread = new ReadThread(socket);
                            readThread.start();
                            Log.d("test", "readThread==nulll");
    
                        }else {
                            Log.d("test", "readThread!=null");
                        }
                    }
                    break;
            }
        }
    
        //发送信息 //客户端 private class ClientThread extends Thread {
            private BluetoothDevice device;
    
            public ClientThread(BluetoothDevice device) {
                this.device = device;
            }
    
            @Override
            public void run() {
                try {
    
                    Log.d("test", "client");
                    bAdapter.cancelDiscovery();
                    socket = device.createRfcommSocketToServiceRecord(UUID.fromString(UUID_CODE));
                    Log.d("test", device.getUuids().toString());
                    socket.connect();

//通过BlueboothSocket的getRemoteDevice()来确认连接的远程蓝牙是否是自己想要连接的
                    Log.d("test", "client connet success:"+socket.getClass().toString() + socket.getRemoteDevice().getName() + ":" + socket.getRemoteDevice().getAddress());
                   /*if (socket != null) { readThread = new ReadThread(socket); readThread.start(); }*/ Log.d("test", "start client read");
                    //这里创建的readThread为空 /*readThread = new ReadThread(socket); readThread.start();*/ Message message=new Message();
                    message.what=3;
                    handler.sendMessage(message);
                } catch (Exception e) {
                    e.printStackTrace();
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        if (socket != null) {
    
                           }
                });}
            }
        }
    
        //服务端 private class ServerThread extends Thread {
            private BluetoothAdapter adapter;
    
            public ServerThread(BluetoothAdapter adapter) {
                this.adapter = adapter;
            }
    
            @Override
            public void run() {
                try {
                    Log.d("test", "serverThread");
                    /*bAdapter.cancelDiscovery();*/ serverSocket = adapter.listenUsingInsecureRfcommWithServiceRecord("bluetoothdemo", UUID.fromString(UUID_CODE));
    
                    socket = serverSocket.accept();
                    Log.d("test", "server connect success");
    
    
                } catch (Exception e) {
    
                }
    
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Log.d("test", "start server read");
                        if (socket != null) {
                            // readThread = new ReadThread(socket);
                            readThread.start();
                            messageLists.add("客户端:" + socket.getRemoteDevice().getName() + "已连接");
                            Message message=new Message();
                            message.what=1;
                            handler.sendMessage(message);
                           /* sendMessage("client:"+socket.getRemoteDevice().getName()+"已经连接");*///自己会读取自己这边放入的字符 /* socket.close();*/ }
                    }
                });
            }
        }
    
        //从输入流中读取，因为read(byte [])这个方法会阻塞，所以要放到子线程中 private class ReadThread extends Thread {
            private BluetoothSocket socket;
            private InputStream stream;
    
    
            public ReadThread(BluetoothSocket socket) {
                this.socket = socket;
            }
    
            @Override
            public void run() {
                super.run();
                while (true) {
                    try {
    
                        stream = socket.getInputStream();
                        /*if (stream != null) *//*Log.d("test", "stram not null");*//* else Log.d("test", "stram null");*/ byte[] buff = new byte[1024];
                        stream.read(buff);
                        String content=new String(buff);
                        //判断是是服务端还是客户端 if (isServer.equals("server")) {
                            content="客户端:"+content;
                        }else {
                            content="服务端:"+content;
                        }
    
                        Message message = new Message();
                        message.obj = content;
                        message.what = 2;
                        handler.sendMessage(message);
    
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
    
                }
    
            }
    
    
        }
        //发送信息 private void sendMessage(String content) {
            if (socket != null) {
                Log.d("test", "socket class:" + socket.getRemoteDevice().getName() + ":" + socket.getRemoteDevice().getAddress());
                Log.d("test", "socket class:" + socket.toString());
                try {
                    Log.d("test", "sock not null");
                    OutputStream outputStream = socket.getOutputStream();
    
                    ;
    
                    if (outputStream != null) {
                        Log.d("test", "output not null");
                    }else {
                        Log.d("test", "output null");
                    }
                    outputStream.write(content.getBytes());
                    messageLists.add(content);
                   /* InputStream stream = socket.getInputStream(); byte[] buff = new byte[1024]; stream.read(buff); String s = new String(buff); Log.d("test", "read:" + s);*/ Log.d("test", "tttt");
                    Message message1 = new Message();
                    message1.what = 1;
                    handler.sendMessage(message1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
            } else {
                Log.d("test", "socket null");
            }
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            if (readThread != null) {
                readThread.interrupt();
            }
        }
    }

这里有几个坑想说一下，当你从输入流中读取信息的时候一定要保证读线程是不为空的，不然一定读取不到信息，所以我在按下发送按钮的时候再重新检查下读线程是否为空

要是为空则重新创建一个读线程

[Center]: /images/20220714/272b6a5b6653483d8865a6675cf2a5fd.png