上篇文章我们介绍到了开发经典蓝牙和单片机通讯的过程，安卓通讯之《蓝牙单片机通讯助手》①集成工作 ，我们这里还要兼容最新的安卓6.0及以上的系统，因为从6.0以后的权限机制和以往的不一样，我们需要在代码中向用户询问权限。而且在6.0运行蓝牙，还需要加上获取到此刻的地理位置的权限，这是谷歌加的~~,所以我们先把运行的权限弄好先，再扫描设备、连接设备和双向通讯。

很多小伙伴问我，为什么你以前写的安卓高版本的蓝牙App现在在高版本的安卓机就不可以获取到附近的蓝牙设备啦？这也是我上面提到的：在6.0运行蓝牙，还需要加上获取到此刻的地理位置的权限。所以我们先把权限弄好。我下面是用郭神封装好的权限代码。你们如有不懂，去CSDN搜索郭霖6.0就有当天的直播权限封装视频解说。

  1. private void checkpermission() {
  2.         //判断是否APi等于或大于23，即6.0
  3.         if(Build.VERSION.SDK_INT >= 23){
  4.             //所需要的权限加进去
  5.             requestRuntimePermission(new String[]{Manifest.permission.ACCESS_COARSE_LOCATION
  6.                     ,Manifest.permission.ACCESS_FINE_LOCATION
  7.                     ,Manifest.permission.BLUETOOTH
  8.                     ,Manifest.permission.BLUETOOTH_ADMIN}, new PermissionListener() {
  10.                 //权限回调
  11.                 @Override
  12.                 public void onGranted() {
  13.                     //全部都授权就跳转下个Activity
  14.                     Log.i("权限全部都同意了","-----=="); 
  15.                                            }
  16.                   //某个没有被授权则强制退出程序
  17.                 @Override
  18.                 public void onDenied(List<String> deniedPermission) {
  19.                     for(String persmission:deniedPermission){
  20.                         Toast.makeText(SplashActivity.this,"基于你的安卓版本大于6.0，未授予该权限导致不能运行，强制退出："+persmission,Toast.LENGTH_LONG).show();
  22.                     } }
  23.             });
  24.         }else {
  25.             //手机在6.0以下，则不需要获取到地理位置权限，直接跳过
  26.        }
  27.     }

打开蓝牙工作，相信大家都会，用户在此打开蓝牙的是否，要用 intent回调。在这里，我们还需要写进一个蓝牙广播接收器，来监听系统发出来的已经搜索到的附近蓝牙设备，并且获取该数据的名字和蓝牙地址。

我这里用的是一个listVIew控件来展示当前可以连接的蓝牙设备。点击某一项，则把该项的蓝牙名字和id传下去到一个Activity的通讯工作。中间的是一个进度条之类的，自定义控件。

扫描

  1. package com.example.xuhong.bluetoothassistant_master;
  3. import android.app.Activity;
  4. import android.app.ListActivity;
  5. import android.bluetooth.BluetoothAdapter;
  6. import android.bluetooth.BluetoothDevice;
  7. import android.content.BroadcastReceiver;
  8. import android.content.Context;
  9. import android.content.Intent;
  10. import android.content.IntentFilter;
  11. import android.os.Bundle;
  12. import android.os.Handler;
  13. import android.os.Handler.Callback;
  14. import android.os.Message;
  15. import android.os.Process;
  16. import android.util.Log;
  17. import android.view.View;
  18. import android.widget.ListView;
  19. import android.widget.TextView;
  21. import com.example.xuhong.bluetoothassistant_master.adapter.DeviceListAdapter;
  22. import com.example.xuhong.bluetoothassistant_master.ui.WhorlView;
  25. public class DeviceScanActivity extends ListActivity {
  27.     private TextView mtv_show;
  28.     // 调试用
  29.     private static final String TAG = "DeviceScanActivity";
  31.     // 开启蓝牙请求码
  32.     private static final int REQUEST_ENABLE = 0;
  34.     // 停止扫描蓝牙消息头
  35.     private static final int WHAT_CANCEL_DISCOVERY = 1;
  37.     // 判断蓝牙列表
  38.     private static final int WHAT_DEVICE_UPDATE = 2;
  40.     // 扫描间隔时间
  41.     private static final int SCAN_PERIOD = 30 * 1000;
  43.     //实例化Adapter
  44.     private DeviceListAdapter mLeDeviceListAdapter = null;
  46.      // 蓝牙适配器
  47.     private BluetoothAdapter mBluetoothAdapter = null;
  49.      // 进度条
  50.     private WhorlView mWhorlView = null;
  52.     @Override
  53.     public void onCreate(Bundle savedInstanceState) {
  54.         super.onCreate(savedInstanceState);
  55.         setContentView(R.layout.activity_device_scan);
  56.         init();
  57.     }
  59.     @Override
  60.     protected void onStart() {
  61.         super.onStart();
  62.         mLeDeviceListAdapter = new DeviceListAdapter(this);
  63.         // 设置列表适配器，注：调用此方法必须继承ListActivity
  64.         setListAdapter(mLeDeviceListAdapter);
  65.         scanDevice(true);
  66.         mWhorlView.setVisibility(View.VISIBLE);
  67.     }
  69.     @Override
  70.     protected void onPause() {
  71.         scanDevice(false);
  72.         super.onPause();
  73.     }
  75.     @Override
  76.     protected void onDestroy() {
  77.         unregReceiver();
  78.         super.onDestroy();
  79.     }
  82.     //回调函数
  83.     @Override
  84.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  85.         if ( resultCode == Activity.RESULT_CANCELED) {
  86.             finish();
  87.             Process.killProcess(Process.myPid());
  88.         }
  90.         switch (requestCode){
  91.             case REQUEST_ENABLE:
  92.                 if ( mBluetoothAdapter.isEnabled()) {
  93.                     registerReceiver();
  94.                     scanDevice(true);
  95.                 }
  97.                 break;
  99.         }
  100.     }
  102.     @Override
  103.     protected void onListItemClick(ListView l, View v, int position, long id) {
  104.         super.onListItemClick(l, v, position, id);
  106.         BluetoothDevice device = mLeDeviceListAdapter.getDevice(position);
  108.         if (device == null) {
  109.             return;
  110.         }
  112.         Intent intent = new Intent(this, MainActivity.class);
  113.         Bundle bundle = new Bundle();
  114.         bundle.putParcelable("device", device);
  115.         intent.putExtras(bundle);
  117.         scanDevice(false);
  118.         startActivity(intent);
  119.         finish();
  120.     }
  122.     /**
  123.      * 消息处理者
  124.      */
  125.     private Handler mHandler = new Handler(new Callback() {
  127.         @Override
  128.         public boolean handleMessage(Message msg) {
  129.             switch (msg.what) {
  131.             case WHAT_DEVICE_UPDATE:
  132.                 mLeDeviceListAdapter.addDevice((BluetoothDevice) msg.obj);
  133.                 // 刷新列表
  134.                 mLeDeviceListAdapter.notifyDataSetChanged();
  135.                 break;
  137.             case WHAT_CANCEL_DISCOVERY:
  138.                 mWhorlView.setVisibility(View.GONE);
  139.                 mtv_show.setText("搜索完毕！");
  140.                 break;
  141.                 default:
  142.                 break;
  143.             }
  144.             return false;
  145.         }
  146.     });
  148.     /**
  149.      * 初始化
  150.      */
  151.     private void init() {
  152.         mtv_show= (TextView) findViewById(R.id.tv_show);
  153.         mWhorlView = (WhorlView) findViewById(R.id.whorl_view);
  154.         // 开启动画
  155.         mWhorlView.start();
  157.         // 初始化本地蓝牙设备
  158.         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  160.         // 检测蓝牙设备是否开启，如果未开启，发起Intent并回调
  161.         if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
  162.             Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
  163.             startActivityForResult(enableIntent, REQUEST_ENABLE);
  164.         }
  166.         registerReceiver();
  167.     }
  169.     /**
  170.      * 是否扫描蓝牙设备
  171.      */
  172.     private void scanDevice(boolean enable) {
  173.         if (enable) {
  175.             Log.d(TAG, "[1]--> startDiscovery()");
  177.             // 开启扫描
  178.             mBluetoothAdapter.startDiscovery();
  180.             // 延时30s后取消扫描动作
  181.             mHandler.postDelayed(new Runnable() {
  183.                 @Override
  184.                 public void run() {
  185.                     mBluetoothAdapter.cancelDiscovery();
  187.                     Log.d(TAG, "[2]--> cancelDiscovery()");
  189.                     // 发送消息
  190.                     mHandler.sendEmptyMessage(WHAT_CANCEL_DISCOVERY);
  191.                 }
  192.             }, SCAN_PERIOD);
  193.         } else {
  194.             Log.d(TAG, "[3]--> cancelDiscovery()");
  195.             // 停止扫描
  196.             mBluetoothAdapter.cancelDiscovery();
  197.         }
  198.     }
  200.     /**
  201.      * 注册广播接收器
  202.      */
  203.     private void registerReceiver() {
  204.         registerReceiver(mReceiver, new IntentFilter(BluetoothDevice.ACTION_FOUND));
  205.     }
  207.     /**
  208.      * 注销广播接收器
  209.      */
  210.     private void unregReceiver() {
  211.         if (mReceiver != null) {
  212.             unregisterReceiver(mReceiver);
  213.         }
  214.     }
  216.     /**
  217.      * 广播接收器接收返回的蓝牙信息
  218.      */
  219.     private BroadcastReceiver mReceiver = new BroadcastReceiver() {
  221.         @Override
  222.         public void onReceive(Context context, Intent intent) {
  223.             String action = intent.getAction();
  225.             //未配对的设备
  226.             if (BluetoothDevice.ACTION_FOUND == action) {
  228.                     BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  230.                 Log.d(TAG, "[4] --> " + device.getName() + "------" + device.getAddress());
  232.                 if (device != null) {
  233.                     //发送消息
  234.                     mHandler.sendMessage(mHandler.obtainMessage(WHAT_DEVICE_UPDATE, device));
  235.                 }
  236.             }
  237.         }
  238.     };
  239. }

我这里用的是一个spinner控件和一个button，怎么使用去看看相关博文，我这里只是供用户选择发送到哪一个数据。因为单片机通讯都是基本的 十六进制 0x00格式，所以我这里只是规范下发送的格式，你们也可以完全按照自己的想法设计UI。

通讯工作

  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.io.OutputStream;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import java.util.UUID;
  8. import android.app.AlertDialog;
  9. import android.content.DialogInterface;
  10. import android.os.Bundle;
  11. import android.app.Activity;
  12. import android.bluetooth.BluetoothDevice;
  13. import android.bluetooth.BluetoothSocket;
  15. import android.os.Handler;
  16. import android.os.Message;
  17. import android.util.Log;
  19. import android.view.KeyEvent;
  20. import android.view.View;
  21. import android.view.Window;
  22. import android.view.WindowManager;
  23. import android.widget.AdapterView;
  24. import android.widget.ArrayAdapter;
  25. import android.widget.ImageView;
  26. import android.widget.ListView;
  27. import android.widget.Spinner;
  28. import android.widget.ToggleButton;
  30. import com.example.xuhong.bluetoothassistant_master.adapter.ChatListAdapter;
  31. import com.example.xuhong.bluetoothassistant_master.data.ChatListData;
  32. import com.example.xuhong.bluetoothassistant_master.util.Toaster;
  34. // 2016.09.15.   徐宏 编写
  35. public class MainActivity extends Activity  {
  38.     private ListView mChatListView;
  40.     //列表
  41.     private List<ChatListData> mList = new ArrayList<>();
  43.     private ChatListAdapter chatListAdapter;
  45.     private static final String TAG = "MainActivity";
  46.     // uuid
  47.     private static final String SPP_UUID = "00001101-0000-1000-8000-00805F9B34FB";
  49.     private Spinner mSpinner;
  51.     private String[] data = new String[]{"选择 0x01", "选择 0x02", "选择 0x03", "选择       0x04", "选择 0x05", "选择 0x06", "选择 0x07" , "选择 0x08", "选择 0x09"};
  54.     private Byte sendData = null;
  55.     private String mRecieve =null;
  57.     private ArrayAdapter<String>  adapter;
  58.     //获得系统的适配器
  59.     private BluetoothDevice mBluetoothDevice = null;
  60.     //创建socket
  61.     private BluetoothSocket mSocket = null;
  62.     //io流
  63.     private OutputStream mOutS = null;
  64.     private static  final  int CONNECT_SUCCED =10;
  65.     private static final  int  mRecieve_SUCCED = 20;
  66.     private InputStream input  =null;
  67.     protected void onCreate(Bundle savedInstanceState) {
  68.         super.onCreate(savedInstanceState);
  69.         //全屏显示
  70.         requestWindowFeature(Window.FEATURE_NO_TITLE);
  71.         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  72.         setContentView(R.layout.activity_main);
  73.         initview();
  74.     }
  76.     private void initview() {
  77.         mSpinner = (Spinner) findViewById(R.id.mSpinner);
  78.         mChatListView = (ListView)findViewById(R.id.mChatListView);
  80.         chatListAdapter=new ChatListAdapter(MainActivity.this,mList);
  81.         mChatListView.setAdapter(chatListAdapter);
  84.         adapter= new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,data);
  85.         mSpinner.setAdapter(adapter);
  86.         mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
  87.             @Override
  88.             public void onItemSelected(AdapterView<?> adapterView, View view, int id, long l) {
  89.                 switch (id){
  90.                     case 0:
  91.                         sendData=1;
  92.                         Log.i(TAG,"点击0");
  93.                         break;
  94.                     case 1:
  95.                         sendData=2;
  96.                         Log.i(TAG,"点击1");
  97.                         break;
  98.                     case 2:
  99.                         sendData=3;
  100.                         Log.i(TAG,"点击2");
  101.                         break;
  102.                     case 3:
  103.                         sendData=4;
  104.                         Log.i(TAG,"点击3");
  105.                         break;
  106.                     case 4:
  107.                         sendData=5;
  108.                         Log.i(TAG,"点击4");
  109.                         break;
  110.                     case 5:
  111.                         sendData=6;
  112.                         Log.i(TAG,"点击5");
  113.                         break;
  114.                     case 6:
  115.                         sendData=7;
  116.                         Log.i(TAG,"点击6");
  117.                         break;
  118.                     case 7:
  119.                         sendData=8;
  120.                         Log.i(TAG,"点击7");
  121.                         break;
  122.                     case 8:
  123.                         sendData=9;
  124.                         Log.i(TAG,"点击8");
  125.                         break;
  127.                 }
  128.             }
  130.             @Override
  131.             public void onNothingSelected(AdapterView<?> adapterView) {
  133.             }
  134.         });
  135.     }
  137.     //添加右边文本
  138.     private void addRightItem(String text) {
  139.         ChatListData date = new ChatListData();
  140.         date.setType(ChatListAdapter.VALUE_RIGHT_TEXT);
  141.         date.setText(text);
  142.         mList.add(date);
  143.         //通知adapter刷新
  144.         adapter.notifyDataSetChanged();
  145.         //滚动到底部
  146.         mChatListView.setSelection(mChatListView.getBottom());
  147.     }
  150.     //添加左边文本
  151.     private void addLeftItem(String text) {
  152.         ChatListData date = new ChatListData();
  153.         date.setType(ChatListAdapter.VALUE_LEFT_TEXT);
  154.         date.setText(text);
  155.         mList.add(date);
  156.         //通知adapter刷新
  157.         adapter.notifyDataSetChanged();
  158.         //滚动到底部
  159.         mChatListView.setSelection(mChatListView.getBottom());
  160.     }
  163.     public void btn_send(View v){
  164.         writeStream(sendData);
  165.         addRightItem(sendData+"");
  166.     }
  168.     @Override
  169.     protected void onStart() {
  170.         super.onStart();
  171.         initDevice();
  172.     }
  175.     @Override
  176.     protected void onStop() {
  177.         close();
  178.         super.onStop();
  179.     }
  181.     private void initDevice() {
  182.         Bundle bundle = getIntent().getExtras();
  183.         if (bundle != null) {
  184.             mBluetoothDevice = bundle.getParcelable("device");
  185.             if (mBluetoothDevice != null) {
  186.                 new Thread(mConnRun).start();
  187.             }
  188.         }
  189.     }
  191.     private Runnable mConnRun = new Runnable() {
  193.         @Override
  194.         public void run() {
  195.             connect();
  196.         }
  197.     };
  198.     private void connect() {
  200.         UUID uuid = UUID.fromString(SPP_UUID);
  202.         try {
  203.             mSocket = mBluetoothDevice.createRfcommSocketToServiceRecord(uuid);
  204.         } catch (IOException e) {
  205.             if (mSocket != null) {
  206.                 try {
  207.                     mSocket.close();
  208.                 } catch (IOException e1) {
  209.                     Log.e(TAG, e1.getMessage());
  210.                 }
  211.             }
  212.         }
  214.         try {
  215.             mSocket.connect();
  216.         } catch (IOException e) {
  217.             if (mSocket != null) {
  218.                 try {
  219.                     mSocket.close();
  220.                 } catch (IOException e1) {
  221.                     Log.e(TAG, e1.getMessage());
  222.                 }
  223.             }
  224.         }
  226.         try {
  227.             mOutS = mSocket.getOutputStream();
  228.             input=mSocket.getInputStream();
  229.             handler.sendEmptyMessage(CONNECT_SUCCED);
  230.         } catch (IOException e) {
  231.             if (mOutS != null) {
  232.                 try {
  233.                     mOutS.close();
  234.                 } catch (IOException e1) {
  235.                     Log.e(TAG, e.getMessage());
  236.                 }
  237.             }
  239.             if (mSocket != null) {
  240.                 try {
  241.                     mSocket.close();
  242.                 } catch (IOException e1) {
  243.                     Log.e(TAG, e.getMessage());
  244.                 }
  245.             }
  246.         }
  247.     }
  250.     private void close() {
  251.         if (mOutS != null) {
  252.             try {
  253.                 mOutS.close();
  254.             } catch (IOException e) {
  255.                 Log.e(TAG, e.getMessage());
  256.             }
  257.         }
  259.         if (mSocket != null) {
  260.             try {
  261.                 mSocket.close();
  262.             } catch (IOException e) {
  263.                 Log.e(TAG, e.getMessage());
  264.             }
  265.         }
  266.     }
  269.     private void writeStream(byte data) {
  270.         try {
  271.             if (mOutS != null) {
  272.                 mOutS.write(data);
  273.                 Log.i(TAG,"输出---->>>是："+data);
  274.                 mOutS.flush();
  275.             }
  276.         } catch (IOException e) {
  278.             runOnUiThread(new Runnable() {
  280.                 @Override
  281.                 public void run() {
  282.                     Toaster.shortToastShow(MainActivity.this, "连接超时");
  283.                     MainActivity.this.finish();
  284.                 }
  285.             });
  286.         }
  287.     }
  290.     public Handler handler = new Handler() {
  291.         @Override
  292.         public void handleMessage(Message msg) {
  293.             super.handleMessage(msg);
  295.             switch (msg.what) {
  296.                 case 1:
  297.                     break;
  298.                 case  mRecieve_SUCCED:
  299.                     addLeftItem(mRecieve);
  300.                     break;
  301.                 case CONNECT_SUCCED:
  302.                     Log.i(TAG,"接收成功");
  303.                      new MyThread().start(); //开启下面的线程
  304.                     break;
  306.             }
  307.         }
  308.     };
  310. //新开的一个接收的线程
  311.     class MyThread extends Thread{
  312.         @Override
  313.         public void run() {
  314.             while (true){
  315.             try {
  316.               //获取到的数据
  317.                 int read = input.read();
  318.                 //因为不允许在子线程更新UI所以用handler
  319.                  handler.sendEmptyMessage(mRecieve_SUCCED);
  320.                  Log.i(TAG+"数据是",Integer.toHexString(read));
  321.                 } catch (IOException e) {
  322.                     e.printStackTrace();
  323.                 Log.i(TAG,"异常"+e);
  324.                 }
  326.             }}
  328.         }
  333.     @Override
  334.     public boolean onKeyDown(int keyCode, KeyEvent event) {
  336.         if(keyCode== KeyEvent.KEYCODE_BACK){
  337.             AlertDialog.Builder alertDialog=new AlertDialog.Builder(MainActivity.this);
  338.             alertDialog.setTitle("确认！");
  339.             alertDialog.setMessage("        确定退出智能锁控制吗");
  340.             alertDialog.setPositiveButton("否",new DialogInterface.OnClickListener() {
  341.                 @Override
  342.                 public void onClick(DialogInterface arg0, int arg1) {
  344.                 }
  345.             });
  346.             alertDialog.setNegativeButton("是", new DialogInterface.OnClickListener() {
  347.                 @Override
  348.                 public void onClick(DialogInterface arg0, int arg1) {
  350.                     MainActivity.this.finish();
  351.                 }
  352.             });
  353.             alertDialog.show();
  354.         }
  355.         return false;
  356.     }
  358. }

这里写图片描述

完美通讯~~

版权声明：本文为corehouse原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/corehouse/p/13770905.html