devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android Studio 入门：（七） 安卓蓝牙聊天功能的实现_android studio实现蓝牙聊天

作者：IT小白 | 2024-03-25 02:54:41

赞

踩

android studio实现蓝牙聊天

目录

1. 清单文件注册权限

2. 在文件res/values/strings.xml里，添加程序运行过程中的状态描述文本及配色代码等

3.修改聊天界面布局文件

4.用于蓝牙会话的服务组件ChatService

5.建立选择蓝牙设备的布局文件 device_list.xml

6.新建Activity组件DeviceList，实现选取与之会话的蓝牙设备

7. 界面程序weixinFragment.java

8.源码地址

1. 清单文件注册权限

  1. <!--下面2个是普通权限，只需要在清单文件里注册，不需要在程序里动态申请-->
  2. <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
  3. <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
  4.  
  5. <!--搜索WiFi，需要定位权限，它是危险权限，在此声明外，还需要在程序里动态申请-->
  6. <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

2. 在文件res/values/strings.xml里，添加程序运行过程中的状态描述文本及配色代码等

  1. <resources>
  2.     <string name="app_name">BlueTooth_Chat</string>
  3.     <string name="top_name">蓝牙聊天</string>
  4.     <string name="bottom_image">底部图标</string>
  5.     <string name="bottom_name1">微信</string>
  6.     <string name="bottom_name2">朋友</string>
  7.     <string name="bottom_name3">通讯录</string>
  8.     <string name="bottom_name4">设置</string>
  9.  
  10.     <string name="send">发送</string>
  11.     <string name="not_connected">你没有链接一个设备</string>
  12.     <string name="bt_not_enabled_leaving">蓝牙不可用，离开聊天室</string>
  13.     <string name="title_connecting">链接中...</string>
  14.     <string name="title_connected_to">连接到：</string>
  15.     <string name="title_not_connected">无链接</string>
  16.     <string name="scanning">蓝牙设备搜索中...</string>
  17.     <string name="select_device">选择一个好友链接</string>
  18.     <string name="none_paired">没有配对好友</string>
  19.     <string name="none_found">附近没有发现好友</string>
  20.     <string name="title_paired_devices">已配对好友</string>
  21.     <string name="title_other_devices">其它可连接好友</string>
  22.     <string name="button_scan">搜索好友</string>
  23.     <string name="connect">我的好友</string>
  24.     <string name="discoverable">设置在线</string>
  25.     <string name="back">退出</string>
  26.     <string name="startVideo">开始聊天</string>
  27.     <string name="stopVideo">结束聊天</string>
  28.  
  29.     <!-- TODO: Remove or change this placeholder text -->
  30.     <string name="hello_blank_fragment">Hello blank fragment</string>
  31. </resources>

3.修改聊天界面布局文件

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:id="@+id/device_name"
  4.     android:layout_width="match_parent"
  5.     android:layout_height="match_parent"
  6.     android:background="@color/bg01"
  7.     android:orientation="vertical">
  8.  
  9.     <!--新版Android支持的Toolbar，对标题栏布局-->
  10.     <!--    <android.support.v7.widget.Toolbar-->
  11.     <androidx.appcompat.widget.Toolbar
  12.         android:id="@+id/toolbar"
  13.         android:layout_width="match_parent"
  14.         android:layout_height="34dp">
  15.  
  16.         <LinearLayout
  17.             android:layout_width="match_parent"
  18.             android:layout_height="match_parent"
  19.             android:orientation="horizontal">
  20.  
  21.             <TextView
  22.                 android:id="@+id/title_left_text"
  23.                 style="?android:attr/windowTitleStyle"
  24.                 android:layout_width="0dp"
  25.                 android:layout_height="match_parent"
  26.                 android:layout_alignParentLeft="true"
  27.                 android:layout_weight="1"
  28.                 android:ellipsize="end"
  29.                 android:gravity="left"
  30.                 android:singleLine="true" />
  31.  
  32.             <TextView
  33.                 android:id="@+id/title_right_text"
  34.                 android:layout_width="0dp"
  35.                 android:layout_height="match_parent"
  36.                 android:layout_alignParentRight="true"
  37.                 android:layout_weight="1"
  38.                 android:ellipsize="end"
  39.                 android:gravity="right"
  40.                 android:singleLine="true"
  41.                 android:textColor="#fff" />
  42.         </LinearLayout>
  43.     </androidx.appcompat.widget.Toolbar>
  44.     <!--    </android.support.v7.widget.Toolbar>-->
  45.  
  46.     <ListView
  47.         android:id="@+id/in"
  48.         android:layout_width="match_parent"
  49.         android:layout_height="match_parent"
  50.         android:layout_weight="1"
  51.         android:stackFromBottom="true"
  52.         android:transcriptMode="alwaysScroll" />
  53.  
  54.     <LinearLayout
  55.         android:layout_width="match_parent"
  56.         android:layout_height="wrap_content"
  57.         android:orientation="horizontal">
  58.  
  59.         <EditText
  60.             android:id="@+id/edit_text_out"
  61.             android:layout_width="0dp"
  62.             android:layout_height="wrap_content"
  63.             android:layout_gravity="bottom"
  64.             android:layout_weight="1" />
  65.  
  66.         <Button
  67.             android:id="@+id/button_send"
  68.             android:layout_width="wrap_content"
  69.             android:layout_height="wrap_content"
  70.             android:text="@string/send" />
  71.     </LinearLayout>
  72. </LinearLayout>

4.用于蓝牙会话的服务组件ChatService

  1. package com.e.bluetooth_chat;
  2.  
  3. import android.bluetooth.BluetoothAdapter;
  4. import android.bluetooth.BluetoothDevice;
  5. import android.bluetooth.BluetoothServerSocket;
  6. import android.bluetooth.BluetoothSocket;
  7. import android.content.Context;
  8. import android.os.Bundle;
  9. import android.os.Handler;
  10. import android.os.Message;
  11.  
  12. import java.io.IOException;
  13. import java.io.InputStream;
  14. import java.io.OutputStream;
  15. import java.util.UUID;
  16.  
  17. public class ChatService {
  18.     //本应用的主Activity组件名称
  19.     private static final String NAME = "BlueToothChat";
  20.     // UUID：通用唯一识别码,是一个128位长的数字，一般用十六进制表示
  21.     //算法的核心思想是结合机器的网卡、当地时间、一个随机数来生成
  22.     //在创建蓝牙连接
  23.     private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");
  24.     private final BluetoothAdapter mAdapter;
  25.     private final Handler mHandler;
  26.     private AcceptThread mAcceptThread;
  27.     private ConnectThread mConnectThread;
  28.     private ConnectedThread mConnectedThread;
  29.     private int mState;
  30.     public static final int STATE_NONE = 0;
  31.     public static final int STATE_LISTEN = 1;
  32.     public static final int STATE_CONNECTING = 2;
  33.     public static final int STATE_CONNECTED = 3;
  34.  
  35.     //构造方法，接收UI主线程传递的对象
  36.     public ChatService(Context context,Handler handler){
  37.         //构造方法完成蓝牙对象的创建
  38.         mAdapter = BluetoothAdapter.getDefaultAdapter();
  39.         mState = STATE_NONE;
  40.         mHandler = handler;
  41.     }
  42.  
  43.     private synchronized void setState(int state){
  44.         mState = state;
  45.         mHandler.obtainMessage(weixinFragment.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
  46.     }
  47.  
  48.     public synchronized int getState(){
  49.         return mState;
  50.     }
  51.  
  52.     public synchronized void start(){
  53.         if (mConnectThread != null) {
  54.             mConnectThread.cancel();
  55.             mConnectThread = null;
  56.         }
  57.         if (mConnectedThread != null) {
  58.             mConnectedThread.cancel();
  59.             mConnectedThread = null;
  60.         }
  61.         if (mAcceptThread == null) {
  62.             mAcceptThread = new AcceptThread();
  63.             mAcceptThread.start();
  64.         }
  65.         setState(STATE_LISTEN);
  66.     }
  67.  
  68.     //取消 CONNECTING 和 CONNECTED 状态下的相关线程，然后运行新的 mConnectThread 线程
  69.     public synchronized void connect(BluetoothDevice device) {
  70.         if (mState == STATE_CONNECTING) {
  71.             if (mConnectThread != null) {
  72.                 mConnectThread.cancel();
  73.                 mConnectThread = null;
  74.             }
  75.         }
  76.         if (mConnectedThread != null) {
  77.             mConnectedThread.cancel();
  78.             mConnectedThread = null;
  79.         }
  80.         mConnectThread = new ConnectThread(device);
  81.         mConnectThread.start();
  82.         setState(STATE_CONNECTING);
  83.     }
  84.  
  85.     /*
  86.         开启一个 ConnectedThread 来管理对应的当前连接。之前先取消任意现存的 mConnectThread 、
  87.         mConnectedThread 、 mAcceptThread 线程，然后开启新 mConnectedThread ，传入当前刚刚接受的
  88.         socket 连接。最后通过 Handler来通知UI连接
  89.      */
  90.     public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
  91.         if (mConnectThread != null) {
  92.             mConnectThread.cancel();
  93.             mConnectThread = null;
  94.         }
  95.         if (mConnectedThread != null) {
  96.             mConnectedThread.cancel();
  97.             mConnectedThread = null;
  98.         }
  99.         if (mAcceptThread != null) {
  100.             mAcceptThread.cancel();
  101.             mAcceptThread = null;
  102.         }
  103.         mConnectedThread = new ConnectedThread(socket);
  104.         mConnectedThread.start();
  105.         Message msg = mHandler.obtainMessage(weixinFragment.MESSAGE_DEVICE_NAME);
  106.         Bundle bundle = new Bundle();
  107.         bundle.putString(weixinFragment.DEVICE_NAME, device.getName());
  108.         msg.setData(bundle);
  109.         mHandler.sendMessage(msg);
  110.         setState(STATE_CONNECTED);
  111.     }
  112.  
  113.     // 停止所有相关线程，设当前状态为 NONE
  114.     public synchronized void stop() {
  115.         if (mConnectThread != null) {
  116.             mConnectThread.cancel();
  117.             mConnectThread = null;
  118.         }
  119.         if (mConnectedThread != null) {
  120.             mConnectedThread.cancel();
  121.             mConnectedThread = null;
  122.         }
  123.         if (mAcceptThread != null) {
  124.             mAcceptThread.cancel();
  125.             mAcceptThread = null;
  126.         }
  127.         setState(STATE_NONE);
  128.     }
  129.  
  130.     // 在 STATE_CONNECTED 状态下，调用 mConnectedThread 里的 write 方法，写入 byte
  131.     public void write(byte[] out) {
  132.         ConnectedThread r;
  133.         synchronized (this) {
  134.             if (mState != STATE_CONNECTED)
  135.                 return;
  136.             r = mConnectedThread;
  137.         }
  138.         r.write(out);
  139.     }
  140.  
  141.     // 连接失败的时候处理，通知 ui ，并设为 STATE_LISTEN 状态
  142.     public void connectionFailed() {
  143.         setState(STATE_LISTEN);
  144.         Message msg = mHandler.obtainMessage(weixinFragment.MESSAGE_TOAST);
  145.         Bundle bundle = new Bundle();
  146.         bundle.putString(weixinFragment.TOAST, "链接不到设备");
  147.         msg.setData(bundle);
  148.         mHandler.sendMessage(msg);
  149.     }
  150.  
  151.     // 当连接失去的时候，设为 STATE_LISTEN 状态并通知 ui
  152.     public void connectionLost() {
  153.         setState(STATE_LISTEN);
  154.         Message msg = mHandler.obtainMessage(weixinFragment.MESSAGE_TOAST);
  155.         Bundle bundle = new Bundle();
  156.         bundle.putString(weixinFragment.TOAST, "设备链接中断");
  157.         msg.setData(bundle);
  158.         mHandler.sendMessage(msg);
  159.     }
  160.  
  161.  
  162.     private class AcceptThread extends Thread {
  163.         private final BluetoothServerSocket mmServerSocket;
  164.  
  165.         public AcceptThread() {
  166.             BluetoothServerSocket tmp = null;
  167.             try {
  168.                 //使用射频端口（RF comm）监听
  169.                 tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
  170.             } catch (IOException e) {
  171.             }
  172.             mmServerSocket = tmp;
  173.         }
  174.  
  175.         @Override
  176.         public void run() {
  177.             setName("AcceptThread");
  178.             BluetoothSocket socket = null;
  179.             while (mState != STATE_CONNECTED) {
  180.                 try {
  181.                     socket = mmServerSocket.accept();
  182.                 } catch (IOException e) {
  183.                     e.printStackTrace();
  184.                     break;
  185.                 }
  186.                 if (socket != null) {
  187.                     synchronized (ChatService.this) {
  188.                         switch (mState) {
  189.                             case STATE_LISTEN:
  190.                             case STATE_CONNECTING:
  191.                                 connected(socket, socket.getRemoteDevice());
  192.                                 break;
  193.                             case STATE_NONE:
  194.                             case STATE_CONNECTED:
  195.                                 try {
  196.                                     socket.close();
  197.                                 } catch (IOException e) {
  198.                                     e.printStackTrace();
  199.                                 }
  200.                                 break;
  201.                         }
  202.                     }
  203.                 }
  204.             }
  205.         }
  206.  
  207.  
  208.         public void cancel() {
  209.             try {
  210.                 mmServerSocket.close();
  211.             } catch (IOException e) {
  212.                 e.printStackTrace();
  213.             }
  214.         }
  215.     }
  216.  
  217.     /*
  218.         连接线程，专门用来对外发出连接对方蓝牙的请求和处理流程。
  219.         构造函数里通过 BluetoothDevice.createRfcommSocketToServiceRecord() ，
  220.         从待连接的 device 产生 BluetoothSocket. 然后在 run 方法中 connect ，
  221.         成功后调用 BluetoothChatSevice 的 connected() 方法。定义 cancel() 在关闭线程时能够关闭相关socket 。
  222.      */
  223.     private class ConnectThread extends Thread{
  224.         private final BluetoothSocket mmSocket;
  225.         private final BluetoothDevice mmDevice;
  226.  
  227.         public ConnectThread(BluetoothDevice device) {
  228.             mmDevice = device;
  229.             BluetoothSocket tmp = null;
  230.             try {
  231.                 tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
  232.             } catch (IOException e) {
  233.                 e.printStackTrace();
  234.             }
  235.             mmSocket = tmp;
  236.         }
  237.  
  238.         @Override
  239.         public void run() {
  240.             setName("ConnectThread");
  241.             mAdapter.cancelDiscovery();
  242.             try {
  243.                 mmSocket.connect();
  244.             } catch (IOException e) {
  245.                 connectionFailed();
  246.                 try {
  247.                     mmSocket.close();
  248.                 } catch (IOException e2) {
  249.                     e.printStackTrace();
  250.                 }
  251.                 ChatService.this.start();
  252.                 return;
  253.             }
  254.             synchronized (ChatService.this) {
  255.                 mConnectThread = null;
  256.             }
  257.             connected(mmSocket, mmDevice);
  258.         }
  259.  
  260.         public void cancel() {
  261.             try {
  262.                 mmSocket.close();
  263.             } catch (IOException e) {
  264.                 e.printStackTrace();
  265.             }
  266.         }
  267.     }
  268.  
  269.     /*
  270.         双方蓝牙连接后一直运行的线程；构造函数中设置输入输出流。
  271.         run()方法中使用阻塞模式的 InputStream.read()循环读取输入流，然后发送到 UI 线程中更新聊天消息。
  272.         本线程也提供了 write() 将聊天消息写入输出流传输至对方，传输成功后回写入 UI 线程。最后使用cancel()关闭连接的 socket
  273.      */
  274.     private class ConnectedThread extends Thread{
  275.         private final BluetoothSocket mmSocket;
  276.         private final InputStream mmInStream;
  277.         private final OutputStream mmOutStream;
  278.  
  279.         public ConnectedThread(BluetoothSocket socket) {
  280.             mmSocket = socket;
  281.             InputStream tmpIn = null;
  282.             OutputStream tmpOut = null;
  283.             try {
  284.                 tmpIn = socket.getInputStream();
  285.                 tmpOut = socket.getOutputStream();
  286.             } catch (IOException e) {
  287.                 e.printStackTrace();
  288.             }
  289.             mmInStream = tmpIn;
  290.             mmOutStream = tmpOut;
  291.         }
  292.  
  293.         @Override
  294.         public void run() {
  295.             byte[] buffer = new byte[1024];
  296.             int bytes;
  297.             while (true) {
  298.                 try {
  299.                     bytes = mmInStream.read(buffer);
  300.                     mHandler.obtainMessage(weixinFragment.MESSAGE_READ, bytes, -1, buffer).sendToTarget();
  301.                 } catch (IOException e) {
  302.                     connectionLost();
  303.                     break;
  304.                 }
  305.             }
  306.         }
  307.  
  308.         public void write(byte[] buffer) {
  309.             try {
  310.                 mmOutStream.write(buffer);
  311.                 mHandler.obtainMessage(weixinFragment.MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
  312.             } catch (IOException e) {
  313.                 e.printStackTrace();
  314.             }
  315.         }
  316.  
  317.         public void cancel() {
  318.             try {
  319.                 mmSocket.close();
  320.             } catch (IOException e) {
  321.                 e.printStackTrace();
  322.             }
  323.         }
  324.     }
  325. }

5.建立选择蓝牙设备的布局文件 device_list.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:orientation="vertical"
  4.     android:layout_width="match_parent"
  5.     android:layout_height="match_parent">
  6.     <TextView android:id="@+id/title_paired_devices"
  7.         android:layout_width="match_parent"
  8.         android:layout_height="wrap_content"
  9.         android:text="@string/title_paired_devices"
  10.         android:visibility="gone"
  11.         android:background="#666"
  12.         android:textColor="#fff"
  13.         android:paddingLeft="5dp"
  14.         android:paddingStart="5dp" />
  15.     <ListView android:id="@+id/paired_devices"
  16.         android:layout_width="match_parent"
  17.         android:layout_height="wrap_content"
  18.         android:layout_weight="1" />
  19.     <TextView android:id="@+id/title_new_devices"
  20.         android:layout_width="match_parent"
  21.         android:layout_height="wrap_content"
  22.         android:text="@string/title_other_devices"
  23.         android:visibility="gone"
  24.         android:background="#666"
  25.         android:textColor="#fff"
  26.         android:paddingLeft="5dp"
  27.         android:paddingStart="5dp" />
  28.     <!--android:visibility="gone"表示不占空间的隐藏，invisible是占空间-->
  29.     <ListView android:id="@+id/new_devices"
  30.         android:layout_width="match_parent"
  31.         android:layout_height="wrap_content"
  32.         android:layout_weight="2" />
  33.     <Button android:id="@+id/button_scan"
  34.         android:layout_width="match_parent"
  35.         android:layout_height="wrap_content"
  36.         android:text="@string/button_scan" />
  37. </LinearLayout>

6.新建Activity组件DeviceList，实现选取与之会话的蓝牙设备

  1. package com.e.bluetooth_chat;
  2.  
  3. import android.app.Activity;
  4. import android.bluetooth.BluetoothAdapter;
  5. import android.bluetooth.BluetoothDevice;
  6. import android.content.BroadcastReceiver;
  7. import android.content.Context;
  8. import android.content.Intent;
  9. import android.content.IntentFilter;
  10. import android.os.Bundle;
  11. import android.provider.Settings;
  12. import android.view.View;
  13. import android.widget.AdapterView;
  14. import android.widget.ArrayAdapter;
  15. import android.widget.Button;
  16. import android.widget.ListView;
  17. import android.widget.TextView;
  18. import android.widget.Toast;
  19.  
  20. import androidx.annotation.Nullable;
  21. import androidx.appcompat.app.AppCompatActivity;
  22.  
  23. import java.util.Set;
  24.  
  25. /*
  26.         本程序供菜单项主界面的选项菜单“我的友好”调用，用于：
  27.         （1）显示已配对的好友列表；
  28.         （2）搜索可配对的好友进行配对
  29.         （3）新选择并配对的蓝牙设备将刷新好友列表
  30.         注意：发现新的蓝牙设备并请求配对时，需要对应接受
  31.         关键技术：动态注册一个广播接收者，处理蓝牙设备扫描的结果
  32.     */
  33. public class DeviceList extends AppCompatActivity {
  34.     private BluetoothAdapter mBtAdapter;
  35.     private ArrayAdapter<String> mPairedDevicesArrayAdapter;
  36.     private ArrayAdapter<String> mNewDevicesArrayAdapter;
  37.     public static String EXTRA_DEVICE_ADDRESS = "device_address";  //Mac地址
  38.     //定义广播接收者，用于处理扫描蓝牙设备后的结果
  39.     private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
  40.         @Override
  41.         public void onReceive(Context context, Intent intent) {
  42.             String action = intent.getAction();
  43.             if(BluetoothDevice.ACTION_FOUND.equals(action)){
  44.                 BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  45.                 if(device.getBondState()!=BluetoothDevice.BOND_BONDED){
  46.                     mNewDevicesArrayAdapter.add(device.getName()+"\n"+device.getAddress());
  47.                 }
  48.             }else if(BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)){
  49.                 if(mNewDevicesArrayAdapter.getCount() == 0){
  50.                     String noDevices = getResources().getText(R.string.none_found).toString();
  51.                     mNewDevicesArrayAdapter.add(noDevices);
  52.                 }
  53.             }
  54.         }
  55.     };
  56.  
  57.     @Override
  58.     protected void onCreate(@Nullable Bundle savedInstanceState) {
  59.         super.onCreate(savedInstanceState);
  60.         setContentView(R.layout.device_list);
  61.         //在被调用活动里，设置返回结果码
  62.         setResult(Activity.RESULT_CANCELED);
  63.         init();  //活动界面
  64.     }
  65.  
  66.     private void init() {
  67.         Button scanButton = findViewById(R.id.button_scan);
  68.         scanButton.setOnClickListener(new View.OnClickListener() {
  69.             @Override
  70.             public void onClick(View v) {
  71.                 Toast.makeText(DeviceList.this,R.string.scanning,Toast.LENGTH_LONG).show();
  72.                 doDiscovery();  //搜索蓝牙设备
  73.             }
  74.         });
  75.         mPairedDevicesArrayAdapter = new ArrayAdapter<String>(this,R.layout.device_name);
  76.         mNewDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);
  77. //        mPairedDevicesArrayAdapter = new ArrayAdapter<String>(this,R.layout.device_name);
  78. //        mNewDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);
  79.         //已配对蓝牙设备列表
  80.         ListView pairedListView =findViewById(R.id.paired_devices);
  81.         pairedListView.setAdapter(mPairedDevicesArrayAdapter);
  82.         pairedListView.setOnItemClickListener(mPaireDeviceClickListener);
  83.         //未配对蓝牙设备列表
  84.         ListView newDevicesListView = findViewById(R.id.new_devices);
  85.         newDevicesListView.setAdapter(mNewDevicesArrayAdapter);
  86.         newDevicesListView.setOnItemClickListener(mNewDeviceClickListener);
  87.         //动态注册广播接收者
  88.         IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
  89.         registerReceiver(mReceiver, filter);
  90.         filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
  91.         registerReceiver(mReceiver, filter);
  92.         mBtAdapter = BluetoothAdapter.getDefaultAdapter();
  93.         Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();
  94.         if (pairedDevices.size() > 0) {
  95.             findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
  96.             for (BluetoothDevice device : pairedDevices) {
  97.                 mPairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
  98.             }
  99.         } else {
  100.             String noDevices;
  101.             noDevices = getResources().getText(R.string.none_paired).toString();
  102.             mPairedDevicesArrayAdapter.add(noDevices);
  103.         }
  104.     }
  105.  
  106.     @Override
  107.     protected void onDestroy() {
  108.         super.onDestroy();
  109.         if(mBtAdapter!=null){
  110.             mBtAdapter.cancelDiscovery();
  111.         }
  112.         this.unregisterReceiver(mReceiver);
  113.     }
  114.  
  115.     private void doDiscovery() {
  116.         findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);
  117.         if (mBtAdapter.isDiscovering()) {
  118.             mBtAdapter.cancelDiscovery();
  119.         }
  120.         mBtAdapter.startDiscovery();  //开始搜索蓝牙设备并产生广播
  121.         //startDiscovery是一个异步方法
  122.         //找到一个设备时就发送一个BluetoothDevice.ACTION_FOUND的广播
  123.     }
  124.  
  125.     private AdapterView.OnItemClickListener mPaireDeviceClickListener = new AdapterView.OnItemClickListener() {
  126.         public void onItemClick(AdapterView<?> av, View v, int arg2, long arg3) {
  127.             mBtAdapter.cancelDiscovery();
  128.             String info = ((TextView) v).getText().toString();
  129.             String address = info.substring(info.length() - 17);
  130.             Intent intent = new Intent();
  131.             intent.putExtra(EXTRA_DEVICE_ADDRESS, address);  //Mac地址
  132.             setResult(Activity.RESULT_OK, intent);
  133.             finish();
  134.         }
  135.     };
  136.  
  137.     private AdapterView.OnItemClickListener mNewDeviceClickListener = new AdapterView.OnItemClickListener() {
  138.         public void onItemClick(AdapterView<?> av, View v, int arg2, long arg3) {
  139.             mBtAdapter.cancelDiscovery();
  140.             Toast.makeText(DeviceList.this, "请在蓝牙设置界面手动连接设备",Toast.LENGTH_SHORT).show();
  141.             Intent intent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS);
  142.             startActivityForResult(intent,1);
  143.         }
  144.     };
  145.  
  146.     @Override
  147.     protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
  148.         super.onActivityResult(requestCode, resultCode, data);
  149.         init();
  150.     }
  151. }

7. 界面程序weixinFragment.java

  1. package com.e.bluetooth_chat;
  2.  
  3. import android.Manifest;
  4. import android.app.Activity;
  5. import android.bluetooth.BluetoothAdapter;
  6. import android.bluetooth.BluetoothDevice;
  7. import android.content.Intent;
  8. import android.content.pm.PackageManager;
  9. import android.os.Build;
  10. import android.os.Bundle;
  11.  
  12. import androidx.annotation.NonNull;
  13. import androidx.annotation.RequiresApi;
  14. import androidx.core.app.ActivityCompat;
  15. import androidx.core.content.ContextCompat;
  16. import androidx.fragment.app.Fragment;
  17.  
  18. import android.os.Handler;
  19. import android.os.Message;
  20. import android.view.KeyEvent;
  21. import android.view.LayoutInflater;
  22. import android.view.MenuItem;
  23. import android.view.View;
  24. import android.view.ViewGroup;
  25. import android.view.inputmethod.EditorInfo;
  26. import android.widget.ArrayAdapter;
  27. import android.widget.Button;
  28. import android.widget.EditText;
  29. import android.widget.ListView;
  30. import android.widget.TextView;
  31. import android.widget.Toast;
  32. import androidx.appcompat.widget.Toolbar;
  33.  
  34.  
  35. /**
  36.  * A simple {@link Fragment} subclass.
  37.  */
  38. public class weixinFragment extends Fragment {
  39.  
  40.     //  蓝牙通信
  41.     public static final int MESSAGE_STATE_CHANGE = 1;
  42.     public static final int MESSAGE_READ = 2;
  43.     public static final int MESSAGE_WRITE = 3;
  44.     public static final int MESSAGE_DEVICE_NAME = 4;
  45.     public static final int MESSAGE_TOAST = 5;
  46.     public static final String DEVICE_NAME = "device_name";
  47.     public static final String TOAST = "toast";
  48.     private static final int REQUEST_CONNECT_DEVICE = 1;  //请求连接设备
  49.     private static final int REQUEST_ENABLE_BT = 2;
  50.     private TextView mTitle;
  51.     private ListView mConversationView;
  52.     private EditText mOutEditText;
  53.     private Button mSendButton;
  54.     private String mConnectedDeviceName = null;
  55.     private ArrayAdapter<String> mConversationArrayAdapter;
  56.     private StringBuffer mOutStringBuffer;
  57.     private BluetoothAdapter mBluetoothAdapter = null;
  58.     private ChatService mChatService = null;
  59.  
  60.     View view;
  61.  
  62.  
  63.     @Override
  64.     public View onCreateView(LayoutInflater inflater, ViewGroup container,
  65.                              Bundle savedInstanceState) {
  66.         view = inflater.inflate(R.layout.tab01, container, false);
  67.         Toolbar toolbar = view.findViewById(R.id.toolbar);
  68.         setHasOptionsMenu(true);
  69.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
  70.             if (ContextCompat.checkSelfPermission(view.getContext(), Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
  71.                 ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.ACCESS_COARSE_LOCATION}, 1);
  72.             }
  73.         }
  74.         //创建选项菜单
  75.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  76.             toolbar.inflateMenu(R.menu.option_menu);
  77.         }
  78.         //选项菜单监听
  79.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  80.             toolbar.setOnMenuItemClickListener(new MyMenuItemClickListener());
  81.         }
  82.         mTitle = view.findViewById(R.id.title_left_text);
  83.         mTitle.setText("蓝牙通信");
  84.         mTitle = view.findViewById(R.id.title_right_text);
  85.         // 得到本地蓝牙适配器
  86.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  87.         if (mBluetoothAdapter == null) {
  88.             Toast.makeText(view.getContext(), "蓝牙不可用", Toast.LENGTH_LONG).show();
  89.             getActivity().finish();
  90.             return view;
  91.         }
  92.         if (!mBluetoothAdapter.isEnabled()) { //若当前设备蓝牙功能未开启
  93.             Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  94.             startActivityForResult(enableIntent, REQUEST_ENABLE_BT); //
  95.         } else {
  96.             if (mChatService == null) {
  97.                 setupChat();  //创建会话
  98.             }
  99.         }
  100.  
  101.         return view;
  102.     }
  103.  
  104.     @Override
  105.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
  106.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  107.         if(grantResults.length>0){
  108.             if(grantResults[0]!=PackageManager.PERMISSION_GRANTED){
  109.                 Toast.makeText(view.getContext(), "未授权，蓝牙搜索功能将不可用！", Toast.LENGTH_SHORT).show();
  110.             }
  111.         }
  112.     }
  113.  
  114.  
  115.     private void setupChat() {
  116.         mConversationArrayAdapter = new ArrayAdapter<String>(view.getContext(), R.layout.message);
  117.         mConversationView = view.findViewById(R.id.in);
  118.         mConversationView.setAdapter(mConversationArrayAdapter);
  119.         mOutEditText = view.findViewById(R.id.edit_text_out);
  120.         mOutEditText.setOnEditorActionListener(mWriteListener);
  121.         mSendButton = view.findViewById(R.id.button_send);
  122.         mSendButton.setOnClickListener(new View.OnClickListener() {
  123.             public void onClick(View v) {
  124.                 TextView textView = view.findViewById(R.id.edit_text_out);
  125.                 String message = textView.getText().toString();
  126.                 sendMessage(message);
  127.             }
  128.         });
  129.         //创建服务对象
  130.         mChatService = new ChatService(view.getContext(), mHandler);
  131.         mOutStringBuffer = new StringBuffer("");
  132.     }
  133.  
  134.     private void sendMessage(String message){
  135.         if(mChatService.getState() != ChatService.STATE_CONNECTED){
  136.             Toast.makeText(view.getContext(),R.string.not_connected,Toast.LENGTH_LONG).show();
  137.             return;
  138.         }
  139.         if(message.length()>0){
  140.             byte[] send = message.getBytes();
  141.             mChatService.write(send);
  142.             mOutStringBuffer.setLength(0);
  143.             mOutEditText.setText(mOutStringBuffer);
  144.         }
  145.     }
  146.  
  147.     private void ensureDiscoverable() { 
  148.         if (mBluetoothAdapter.getScanMode() != BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
  149.             Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
  150.             discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
  151.             startActivity(discoverableIntent);
  152.             Toast.makeText(view.getContext(), "已经设置本机蓝牙设备的可见性，对方可搜索了。", Toast.LENGTH_SHORT).show();
  153.         }
  154.     }
  155.  
  156.     private TextView.OnEditorActionListener mWriteListener = new TextView.OnEditorActionListener() {
  157.         @Override
  158.         public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {
  159.             if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_UP) {
  160.                 String message = view.getText().toString();
  161.                 sendMessage(message);
  162.             }
  163.             return true;
  164.         }
  165.     };
  166.  
  167.     private final Handler mHandler = new Handler() {   
  168.         @Override
  169.         public void handleMessage(Message msg) {
  170.             switch (msg.what) {
  171.                 case MESSAGE_STATE_CHANGE:
  172.                     switch (msg.arg1) {
  173.                         case ChatService.STATE_CONNECTED:
  174.                             mTitle.setText(R.string.title_connected_to);
  175.                             mTitle.append(mConnectedDeviceName);
  176.                             mConversationArrayAdapter.clear();
  177.                             break;
  178.                         case ChatService.STATE_CONNECTING:
  179.                             mTitle.setText(R.string.title_connecting);
  180.                             break;
  181.                         case ChatService.STATE_LISTEN:
  182.                         case ChatService.STATE_NONE:
  183.                             mTitle.setText(R.string.title_not_connected);
  184.                             break;
  185.                     }
  186.                     break;
  187.                 case MESSAGE_WRITE:
  188.                     byte[] writeBuf = (byte[]) msg.obj;
  189.                     String writeMessage = new String(writeBuf);
  190.                     mConversationArrayAdapter.add("我:  " + writeMessage);
  191.                     break;
  192.                 case MESSAGE_READ:
  193.                     byte[] readBuf = (byte[]) msg.obj;
  194.                     String readMessage = new String(readBuf, 0, msg.arg1);
  195.                     mConversationArrayAdapter.add(mConnectedDeviceName + ":  "
  196.                             + readMessage);
  197.                     break;
  198.                 case MESSAGE_DEVICE_NAME:
  199.                     mConnectedDeviceName = msg.getData().getString(DEVICE_NAME);
  200.                     Toast.makeText(getActivity().getApplicationContext(),"链接到 " + mConnectedDeviceName, Toast.LENGTH_SHORT).show();
  201.                     break;
  202.                 case MESSAGE_TOAST:
  203.                     Toast.makeText(getActivity().getApplicationContext(), msg.getData().getString(TOAST), Toast.LENGTH_SHORT).show();
  204.                     break;
  205.             }
  206.         }
  207.     };
  208.  
  209.     //返回进入好友列表操作后的数回调方法
  210.     public void onActivityResult(int requestCode, int resultCode, Intent data) {
  211.         switch (requestCode) {
  212.             case REQUEST_CONNECT_DEVICE:
  213.                 if (resultCode == Activity.RESULT_OK) {
  214.                     String address = data.getExtras().getString(DeviceList.EXTRA_DEVICE_ADDRESS);
  215.                     BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
  216.                     mChatService.connect(device);
  217.                 }else if(resultCode==Activity.RESULT_CANCELED){
  218.                     Toast.makeText(view.getContext(), "未选择任何好友！", Toast.LENGTH_SHORT).show();
  219.                 }
  220.                 break;
  221.             case REQUEST_ENABLE_BT:
  222.                 if (resultCode == Activity.RESULT_OK) {
  223.                     setupChat();
  224.                 } else {
  225.                     Toast.makeText(view.getContext(), R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show();
  226.                     getActivity().finish();
  227.                 }
  228.         }
  229.     }
  230.  
  231.  
  232.     //内部类，选项菜单的单击事件处理
  233.     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
  234.     private class MyMenuItemClickListener implements Toolbar.OnMenuItemClickListener {
  235.         @Override
  236.         public boolean onMenuItemClick(MenuItem item) {
  237.             switch (item.getItemId()) {
  238.                 case R.id.scan:
  239.                     //启动DeviceList这个Activity
  240.                     Intent serverIntent = new Intent(getActivity(), DeviceList.class);
  241.                     startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);
  242.                     return true;
  243.                 case R.id.discoverable:
  244.                     ensureDiscoverable();
  245.                     return true;
  246.                 case R.id.back:
  247.                     getActivity().finish();
  248.                     System.exit(0);
  249.                     return true;
  250.             }
  251.             return false;
  252.         }
  253.     }
  254.  
  255.  
  256.     @Override
  257.     public synchronized void onResume() {
  258.         //synchronized：同步方法实现排队调用
  259.         super.onResume();
  260.         if (mChatService != null) {
  261.             if (mChatService.getState() == ChatService.STATE_NONE) {
  262.                 mChatService.start();
  263.             }
  264.         }
  265.     }
  266.  
  267.     @Override
  268.     public void onDestroy() {
  269.         super.onDestroy();
  270.         if(mChatService != null){
  271.             mChatService.stop();
  272.         }
  273.     }
  274. }
  275.

8.源码地址

https://github.com/xixia7/BlueTooth_Chat.git

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/306540
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号