android连接蓝牙打印机实现打印功能_android编写蓝牙打印功能程序-程序员宅基地

技术标签： android基础  

原文地址：http://blog.csdn.net/reality_jie_blog/article/details/11895843


最近在做一个安卓应用，其中有一个需求是要求用蓝牙连接打印机实现打印功能。一开始没有一点头绪，网上找了很多资料也找不到有用的数据。所以自己就去研究，最终，功夫不负有心人，顺利的完成了这个功能。下边贴出我写的代码，共有需要的IT哥们参考学习。

完整源码下载

我们先看看运行效果图吧。。。

1.这是主界面的效果图


贴上布局文件的代码：bluetooth_layout.xml

[html]  view plain copy
  1. <span style="font-size:12px"><?xml version="1.0" encoding="utf-8"?>  
  2. <RelativeLayout  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent" >  
  5.   
  6.     <Button  
  7.         android:id="@+id/openBluetooth_tb"  
  8.         android:layout_width="130dp"  
  9.         android:layout_height="wrap_content"  
  10.         android:layout_alignParentRight="true"  
  11.         android:layout_marginRight="18dp"  
  12.         android:layout_marginTop="5dp"  
  13.         android:text="打开蓝牙" />  
  14.   
  15.     <Button  
  16.         android:id="@+id/searchDevices"  
  17.         android:layout_width="match_parent"  
  18.         android:layout_height="wrap_content"  
  19.         android:layout_alignParentLeft="true"  
  20.         android:layout_below="@+id/openBluetooth_tb"  
  21.         android:layout_marginTop="20dp"  
  22.         android:text="搜索设备" />  
  23.   
  24.     <View  
  25.         android:layout_width="match_parent"  
  26.         android:layout_height="3dp"  
  27.         android:layout_alignParentLeft="true"  
  28.         android:layout_below="@+id/searchDevices"  
  29.         android:background="@android:color/darker_gray" />  
  30.   
  31.     <LinearLayout  
  32.         android:id="@+id/linearLayout1"  
  33.         android:layout_width="match_parent"  
  34.         android:layout_height="150dp"  
  35.         android:layout_marginTop="125dp"  
  36.         android:orientation="vertical" >  
  37.   
  38.         <TextView  
  39.             android:layout_width="match_parent"  
  40.             android:layout_height="wrap_content"  
  41.             android:text="未配对设备" />  
  42.   
  43.         <ListView  
  44.             android:id="@+id/unbondDevices"  
  45.             android:layout_width="wrap_content"  
  46.             android:layout_height="wrap_content" />  
  47.     </LinearLayout>  
  48.   
  49.     <View  
  50.         android:layout_width="match_parent"  
  51.         android:layout_height="3dp"  
  52.         android:layout_alignParentLeft="true"  
  53.         android:layout_below="@+id/searchDevices"  
  54.         android:layout_marginTop="160dp"  
  55.         android:background="@android:color/darker_gray" />  
  56.   
  57.     <LinearLayout  
  58.         android:layout_width="match_parent"  
  59.         android:layout_height="190dp"  
  60.         android:layout_marginTop="288dp"  
  61.         android:orientation="vertical" >  
  62.   
  63.         <TextView  
  64.             android:layout_width="match_parent"  
  65.             android:layout_height="wrap_content"  
  66.             android:text="已配对设备" />  
  67.           <ListView  
  68.             android:id="@+id/bondDevices"  
  69.             android:layout_width="wrap_content"  
  70.            android:layout_height="wrap_content"  
  71.            android:layout_alignParentLeft="true"  
  72.            android:layout_below="@+id/linearLayout1" >  
  73.          </ListView>  
  74.     </LinearLayout>  
  75.   
  76.     <Button  
  77.         android:id="@+id/return_Bluetooth_btn"  
  78.         android:layout_width="100dp"  
  79.         android:layout_height="wrap_content"  
  80.         android:layout_above="@+id/searchDevices"  
  81.         android:layout_alignParentLeft="true"  
  82.         android:text="返回" />  
  83.   
  84. </RelativeLayout></span>  


从上边的布局文件中不难看出，其中有两个ListView，OK，那下边贴出对应的两个item布局文件

  --> 第一个item：unbonddevice_item.xml

[html]  view plain copy
  1. <span style="font-size:14px"><?xml version="1.0" encoding="utf-8"?>    
  2. <RelativeLayout  
  3.     android:layout_width="match_parent"    
  4.     android:layout_height="match_parent" >    
  5.     
  6.     <TextView    
  7.         android:id="@+id/device_name"    
  8.         android:layout_width="match_parent"    
  9.         android:layout_height="wrap_content"    
  10.         android:layout_alignParentLeft="true"    
  11.         android:layout_alignParentTop="true"    
  12.         android:text="未绑定设备"    
  13.         android:textAppearance="?android:attr/textAppearanceLarge" />    
  14.     
  15. </RelativeLayout></span>  

-->第二个item：bonddevice_item.xml

[html]  view plain copy
  1. <span style="font-size:14px"><?xml version="1.0" encoding="utf-8"?>    
  2. <RelativeLayout  
  3.     android:layout_width="match_parent"    
  4.     android:layout_height="match_parent" >    
  5.     
  6.     <TextView    
  7.         android:id="@+id/device_name"    
  8.         android:layout_width="match_parent"    
  9.         android:layout_height="wrap_content"    
  10.         android:layout_alignParentLeft="true"    
  11.         android:layout_alignParentTop="true"    
  12.         android:text="已绑定设备"    
  13.         android:textAppearance="?android:attr/textAppearanceLarge" />    
  14.     
  15. </RelativeLayout></span>  

2.还有另外一个布局文件，就是当点击已绑定蓝牙设备下边的某个item时进入打印的界面，不多说，看图！



代码如下：printdata_layout.xml

[html]  view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>    
  2. <RelativeLayout    
  3.     android:layout_width="match_parent"    
  4.     android:layout_height="match_parent" >    
  5.     
  6.     <EditText    
  7.         android:id="@+id/print_data"    
  8.         android:layout_width="match_parent"    
  9.         android:layout_height="200dp"    
  10.         android:layout_alignParentLeft="true"    
  11.         android:layout_alignParentTop="true"    
  12.         android:layout_marginTop="46dp" >    
  13.     </EditText>    
  14.     
  15.     <TextView    
  16.         android:id="@+id/device_name"    
  17.         android:layout_width="wrap_content"    
  18.         android:layout_height="wrap_content"    
  19.         android:layout_alignParentLeft="true"    
  20.         android:layout_alignParentTop="true"    
  21.         android:layout_marginTop="16dp"    
  22.         android:text="Large Text"    
  23.         android:textAppearance="?android:attr/textAppearanceLarge" />    
  24.     
  25.     <TextView    
  26.         android:id="@+id/connect_state"    
  27.         android:layout_width="wrap_content"    
  28.         android:layout_height="wrap_content"    
  29.         android:layout_alignBaseline="@+id/device_name"    
  30.         android:layout_alignBottom="@+id/device_name"    
  31.         android:layout_marginLeft="42dp"    
  32.         android:layout_toRightOf="@+id/device_name"    
  33.         android:text="Large Text"    
  34.         android:textAppearance="?android:attr/textAppearanceLarge" />    
  35.     
  36.     <Button    
  37.         android:id="@+id/send"    
  38.         android:layout_width="match_parent"    
  39.         android:layout_height="wrap_content"    
  40.         android:layout_alignParentLeft="true"    
  41.         android:layout_below="@+id/print_data"    
  42.         android:layout_marginTop="21dp"    
  43.         android:text="打印" />    
  44.     
  45.     <Button    
  46.         android:id="@+id/command"    
  47.         android:layout_width="match_parent"    
  48.         android:layout_height="wrap_content"    
  49.         android:layout_alignParentLeft="true"    
  50.         android:layout_below="@+id/send"    
  51.         android:text="指令" />    
  52.         
  53. </RelativeLayout>  

至此，布局文件就搞定了，接下来就要编写java代码了。主要有一下这么几个类，一个一个来哈

BluetoothActivity.java

这个类的主要作用是初始化主界面，看代码

[java]  view plain copy
  1. public class BluetoothActivity extends Activity {    
  2.     private Context context = null;    
  3.     
  4.     public void onCreate(Bundle savedInstanceState) {    
  5.         super.onCreate(savedInstanceState);    
  6.         this.context = this;    
  7.         setTitle("蓝牙打印");    
  8.         setContentView(R.layout.bluetooth_layout);    
  9.         this.initListener();    
  10.     }    
  11.     
  12.     private void initListener() {    
  13.         ListView unbondDevices = (ListView) this    
  14.                 .findViewById(R.id.unbondDevices);    
  15.         ListView bondDevices = (ListView) this.findViewById(R.id.bondDevices);    
  16.         Button switchBT = (Button) this.findViewById(R.id.openBluetooth_tb);    
  17.         Button searchDevices = (Button) this.findViewById(R.id.searchDevices);    
  18.     
  19.         BluetoothAction bluetoothAction = new BluetoothAction(this.context,    
  20.                 unbondDevices, bondDevices, switchBT, searchDevices,    
  21.                 BluetoothActivity.this);    
  22.     
  23.         Button returnButton = (Button) this    
  24.                 .findViewById(R.id.return_Bluetooth_btn);    
  25.         bluetoothAction.setSearchDevices(searchDevices);    
  26.         bluetoothAction.initView();    
  27.     
  28.         switchBT.setOnClickListener(bluetoothAction);    
  29.         searchDevices.setOnClickListener(bluetoothAction);    
  30.         returnButton.setOnClickListener(bluetoothAction);    
  31.     }    
  32.     //屏蔽返回键的代码:    
  33.     public boolean onKeyDown(int keyCode,KeyEvent event)    
  34.     {    
  35.         switch(keyCode)    
  36.         {    
  37.             case KeyEvent.KEYCODE_BACK:return true;    
  38.         }    
  39.         return super.onKeyDown(keyCode, event);    
  40.     }    
  41. }  

BluetoothAction.java

这个类顾名思义，是处理bluetoothActivity中各种操作事件的action类，看代码


[java]  view plain copy
  1. <span style="font-size:14px">public class BluetoothAction implements OnClickListener {    
  2.     
  3.     private Button switchBT = null;    
  4.     private Button searchDevices = null;    
  5.     private Activity activity = null;    
  6.     
  7.     private ListView unbondDevices = null;    
  8.     private ListView bondDevices = null;    
  9.     private Context context = null;    
  10.     private BluetoothService bluetoothService = null;    
  11.     
  12.     public BluetoothAction(Context context, ListView unbondDevices,    
  13.             ListView bondDevices, Button switchBT, Button searchDevices,    
  14.             Activity activity) {    
  15.         super();    
  16.         this.context = context;    
  17.         this.unbondDevices = unbondDevices;    
  18.         this.bondDevices = bondDevices;    
  19.         this.switchBT = switchBT;    
  20.         this.searchDevices = searchDevices;    
  21.         this.activity = activity;    
  22.         this.bluetoothService = new BluetoothService(this.context,    
  23.                 this.unbondDevices, this.bondDevices, this.switchBT,    
  24.                 this.searchDevices);    
  25.     }    
  26.     
  27.     public void setSwitchBT(Button switchBT) {    
  28.         this.switchBT = switchBT;    
  29.     }    
  30.     
  31.     public void setSearchDevices(Button searchDevices) {    
  32.         this.searchDevices = searchDevices;    
  33.     }    
  34.     
  35.     public void setUnbondDevices(ListView unbondDevices) {    
  36.         this.unbondDevices = unbondDevices;    
  37.     }    
  38.     
  39.     /**  
  40.      * 初始化界面  
  41.      */    
  42.     public void initView() {    
  43.     
  44.         if (this.bluetoothService.isOpen()) {    
  45.             System.out.println("蓝牙有开!");    
  46.             switchBT.setText("关闭蓝牙");    
  47.         }    
  48.         if (!this.bluetoothService.isOpen()) {    
  49.             System.out.println("蓝牙没开!");    
  50.             this.searchDevices.setEnabled(false);    
  51.         }    
  52.     }    
  53.     
  54.     private void searchDevices() {    
  55.         bluetoothService.searchDevices();    
  56.     }    
  57.     
  58.     /**  
  59.      * 各种按钮的监听  
  60.      */    
  61.     @Override    
  62.     public void onClick(View v) {    
  63.         if (v.getId() == R.id.searchDevices) {    
  64.             this.searchDevices();    
  65.         } else if (v.getId() == R.id.return_Bluetooth_btn) {    
  66.             activity.finish();    
  67.         } else if (v.getId() == R.id.openBluetooth_tb) {    
  68.             if (!this.bluetoothService.isOpen()) {    
  69.                 // 蓝牙关闭的情况    
  70.                 System.out.println("蓝牙关闭的情况");    
  71.                 this.bluetoothService.openBluetooth(activity);    
  72.             } else {    
  73.                 // 蓝牙打开的情况    
  74.                 System.out.println("蓝牙打开的情况");    
  75.                 this.bluetoothService.closeBluetooth();    
  76.     
  77.             }    
  78.     
  79.         }    
  80.     }    
  81.     
  82. }</span>  



这个类会把各种请求动作分门别类，交给BluetoothService.java来处理，看代码


[java]  view plain copy
  1. public class BluetoothService {    
  2.     private Context context = null;    
  3.     private BluetoothAdapter bluetoothAdapter = BluetoothAdapter    
  4.             .getDefaultAdapter();    
  5.     private ArrayList<BluetoothDevice> unbondDevices = null; // 用于存放未配对蓝牙设备    
  6.     private ArrayList<BluetoothDevice> bondDevices = null;// 用于存放已配对蓝牙设备    
  7.     private Button switchBT = null;    
  8.     private Button searchDevices = null;    
  9.     private ListView unbondDevicesListView = null;    
  10.     private ListView bondDevicesListView = null;    
  11.     
  12.     /**  
  13.      * 添加已绑定蓝牙设备到ListView  
  14.      */    
  15.     private void addBondDevicesToListView() {    
  16.         ArrayList<HashMap<String, Object>> data = new ArrayList<HashMap<String, Object>>();    
  17.         int count = this.bondDevices.size();    
  18.         System.out.println("已绑定设备数量：" + count);    
  19.         for (int i = 0; i < count; i++) {    
  20.             HashMap<String, Object> map = new HashMap<String, Object>();    
  21.             map.put("deviceName", this.bondDevices.get(i).getName());    
  22.             data.add(map);// 把item项的数据加到data中    
  23.         }    
  24.         String[] from = { "deviceName" };    
  25.         int[] to = { R.id.device_name };    
  26.         SimpleAdapter simpleAdapter = new SimpleAdapter(this.context, data,    
  27.                 R.layout.bonddevice_item, from, to);    
  28.         // 把适配器装载到listView中    
  29.         this.bondDevicesListView.setAdapter(simpleAdapter);    
  30.     
  31.         this.bondDevicesListView    
  32.                 .setOnItemClickListener(new OnItemClickListener() {    
  33.     
  34.                     @Override    
  35.                     public void onItemClick(AdapterView<?> arg0, View arg1,    
  36.                             int arg2, long arg3) {    
  37.                         BluetoothDevice device = bondDevices.get(arg2);    
  38.                         Intent intent = new Intent();    
  39.                         intent.setClassName(context,    
  40.                                 "com.lifeng.jdxt.view.PrintDataActivity");    
  41.                         intent.putExtra("deviceAddress", device.getAddress());    
  42.                         context.startActivity(intent);    
  43.                     }    
  44.                 });    
  45.     
  46.     }    
  47.     
  48.     /**  
  49.      * 添加未绑定蓝牙设备到ListView  
  50.      */    
  51.     private void addUnbondDevicesToListView() {    
  52.         ArrayList<HashMap<String, Object>> data = new ArrayList<HashMap<String, Object>>();    
  53.         int count = this.unbondDevices.size();    
  54.         System.out.println("未绑定设备数量：" + count);    
  55.         for (int i = 0; i < count; i++) {    
  56.             HashMap<String, Object> map = new HashMap<String, Object>();    
  57.             map.put("deviceName", this.unbondDevices.get(i).getName());    
  58.             data.add(map);// 把item项的数据加到data中    
  59.         }    
  60.         String[] from = { "deviceName" };    
  61.         int[] to = { R.id.device_name };    
  62.         SimpleAdapter simpleAdapter = new SimpleAdapter(this.context, data,    
  63.                 R.layout.unbonddevice_item, from, to);    
  64.     
  65.         // 把适配器装载到listView中    
  66.         this.unbondDevicesListView.setAdapter(simpleAdapter);    
  67.     
  68.         // 为每个item绑定监听，用于设备间的配对    
  69.         this.unbondDevicesListView    
  70.                 .setOnItemClickListener(new OnItemClickListener() {    
  71.     
  72.                     @Override    
  73.                     public void onItemClick(AdapterView<?> arg0, View arg1,    
  74.                             int arg2, long arg3) {    
  75.                         try {    
  76.                             Method createBondMethod = BluetoothDevice.class    
  77.                                     .getMethod("createBond");    
  78.                             createBondMethod    
  79.                                     .invoke(unbondDevices.get(arg2));    
  80.                             // 将绑定好的设备添加的已绑定list集合    
  81.                             bondDevices.add(unbondDevices.get(arg2));    
  82.                             // 将绑定好的设备从未绑定list集合中移除    
  83.                             unbondDevices.remove(arg2);    
  84.                             addBondDevicesToListView();    
  85.                             addUnbondDevicesToListView();    
  86.                         } catch (Exception e) {    
  87.                             Toast.makeText(context, "配对失败！", Toast.LENGTH_SHORT)    
  88.                                     .show();    
  89.                         }    
  90.     
  91.                     }    
  92.                 });    
  93.     }    
  94.     
  95.     public BluetoothService(Context context, ListView unbondDevicesListView,    
  96.             ListView bondDevicesListView, Button switchBT, Button searchDevices) {    
  97.         this.context = context;    
  98.         this.unbondDevicesListView = unbondDevicesListView;    
  99.         this.bondDevicesListView = bondDevicesListView;    
  100.         // this.bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();    
  101.         this.unbondDevices = new ArrayList<BluetoothDevice>();    
  102.         this.bondDevices = new ArrayList<BluetoothDevice>();    
  103.         this.switchBT = switchBT;    
  104.         this.searchDevices = searchDevices;    
  105.         this.initIntentFilter();    
  106.     
  107.     }    
  108.     
  109.     private void initIntentFilter() {    
  110.         // 设置广播信息过滤    
  111.         IntentFilter intentFilter = new IntentFilter();    
  112.         intentFilter.addAction(BluetoothDevice.ACTION_FOUND);    
  113.         intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);    
  114.         intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);    
  115.         intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);    
  116.         // 注册广播接收器，接收并处理搜索结果    
  117.         context.registerReceiver(receiver, intentFilter);    
  118.     
  119.     }    
  120.     
  121.     /**  
  122.      * 打开蓝牙  
  123.      */    
  124.     public void openBluetooth(Activity activity) {    
  125.         Intent enableBtIntent = new Intent(    
  126.                 BluetoothAdapter.ACTION_REQUEST_ENABLE);    
  127.         activity.startActivityForResult(enableBtIntent, 1);    
  128.     
  129.     }    
  130.     
  131.     /**  
  132.      * 关闭蓝牙  
  133.      */    
  134.     public void closeBluetooth() {    
  135.         this.bluetoothAdapter.disable();    
  136.     }    
  137.     
  138.     /**  
  139.      * 判断蓝牙是否打开  
  140.      *   
  141.      * @return boolean  
  142.      */    
  143.     public boolean isOpen() {    
  144.         return this.bluetoothAdapter.isEnabled();    
  145.     
  146.     }    
  147.     
  148.     /**  
  149.      * 搜索蓝牙设备  
  150.      */    
  151.     public void searchDevices() {    
  152.         this.bondDevices.clear();    
  153.         this.unbondDevices.clear();    
  154.     
  155.         // 寻找蓝牙设备，android会将查找到的设备以广播形式发出去    
  156.         this.bluetoothAdapter.startDiscovery();    
  157.     }    
  158.     
  159.     /**  
  160.      * 添加未绑定蓝牙设备到list集合  
  161.      *   
  162.      * @param device  
  163.      */    
  164.     public void addUnbondDevices(BluetoothDevice device) {    
  165.         System.out.println("未绑定设备名称：" + device.getName());    
  166.         if (!this.unbondDevices.contains(device)) {    
  167.             this.unbondDevices.add(device);    
  168.         }    
  169.     }    
  170.     
  171.     /**  
  172.      * 添加已绑定蓝牙设备到list集合  
  173.      *   
  174.      * @param device  
  175.      */    
  176.     public void addBandDevices(BluetoothDevice device) {    
  177.         System.out.println("已绑定设备名称：" + device.getName());    
  178.         if (!this.bondDevices.contains(device)) {    
  179.             this.bondDevices.add(device);    
  180.         }    
  181.     }    
  182.     
  183.     /**  
  184.      * 蓝牙广播接收器  
  185.      */    
  186.     private BroadcastReceiver receiver = new BroadcastReceiver() {    
  187.     
  188.         ProgressDialog progressDialog = null;    
  189.     
  190.         @Override    
  191.         public void onReceive(Context context, Intent intent) {    
  192.             String action = intent.getAction();    
  193.             if (BluetoothDevice.ACTION_FOUND.equals(action)) {    
  194.                 BluetoothDevice device = intent    
  195.                         .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);    
  196.                 if (device.getBondState() == BluetoothDevice.BOND_BONDED) {    
  197.                     addBandDevices(device);    
  198.                 } else {    
  199.                     addUnbondDevices(device);    
  200.                 }    
  201.             } else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(action)) {    
  202.                 progressDialog = ProgressDialog.show(context, "请稍等...",    
  203.                         "搜索蓝牙设备中...", true);    
  204.     
  205.             } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED    
  206.                     .equals(action)) {    
  207.                 System.out.println("设备搜索完毕");    
  208.                 progressDialog.dismiss();    
  209.     
  210.                 addUnbondDevicesToListView();    
  211.                 addBondDevicesToListView();    
  212.                 // bluetoothAdapter.cancelDiscovery();    
  213.             }    
  214.             if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {    
  215.                 if (bluetoothAdapter.getState() == BluetoothAdapter.STATE_ON) {    
  216.                     System.out.println("--------打开蓝牙-----------");    
  217.                     switchBT.setText("关闭蓝牙");    
  218.                     searchDevices.setEnabled(true);    
  219.                     bondDevicesListView.setEnabled(true);    
  220.                     unbondDevicesListView.setEnabled(true);    
  221.                 } else if (bluetoothAdapter.getState() == BluetoothAdapter.STATE_OFF) {    
  222.                     System.out.println("--------关闭蓝牙-----------");    
  223.                     switchBT.setText("打开蓝牙");    
  224.                     searchDevices.setEnabled(false);    
  225.                     bondDevicesListView.setEnabled(false);    
  226.                     unbondDevicesListView.setEnabled(false);    
  227.                 }    
  228.             }    
  229.     
  230.         }    
  231.     
  232.     };    
  233.     
  234. }  

到这里，第一个界面的代码就写完了，当我们点击要打印的蓝牙设备时就会跳转到打印页面，跳转代码在BluetoothService.java的addBondDevicesToListView()中

接下来让我们来看看第二个界面的代码，结构和第一个界面的代码一样，分类三个类，请看代码。。。。。


PrintDataActivity.java


[java]  view plain copy
  1. public class PrintDataActivity extends Activity {    
  2.     private Context context = null;    
  3.     
  4.     public void onCreate(Bundle savedInstanceState) {    
  5.         super.onCreate(savedInstanceState);    
  6.         this.setTitle("蓝牙打印");    
  7.         this.setContentView(R.layout.printdata_layout);    
  8.         this.context = this;    
  9.         this.initListener();    
  10.     }    
  11.     
  12.     /**  
  13.      * 获得从上一个Activity传来的蓝牙地址  
  14.      * @return String  
  15.      */    
  16.     private String getDeviceAddress() {    
  17.         // 直接通过Context类的getIntent()即可获取Intent    
  18.         Intent intent = this.getIntent();    
  19.         // 判断    
  20.         if (intent != null) {    
  21.             return intent.getStringExtra("deviceAddress");    
  22.         } else {    
  23.             return null;    
  24.         }    
  25.     }    
  26.     
  27.     private void initListener() {    
  28.         TextView deviceName = (TextView) this.findViewById(R.id.device_name);    
  29.         TextView connectState = (TextView) this    
  30.                 .findViewById(R.id.connect_state);    
  31.     
  32.         PrintDataAction printDataAction = new PrintDataAction(this.context,    
  33.                 this.getDeviceAddress(), deviceName, connectState);    
  34.     
  35.         EditText printData = (EditText) this.findViewById(R.id.print_data);    
  36.         Button send = (Button) this.findViewById(R.id.send);    
  37.         Button command = (Button) this.findViewById(R.id.command);    
  38.         printDataAction.setPrintData(printData);    
  39.     
  40.         send.setOnClickListener(printDataAction);    
  41.         command.setOnClickListener(printDataAction);    
  42.     }    
  43.     
  44.         
  45.     @Override    
  46.     protected void onDestroy() {    
  47.         PrintDataService.disconnect();    
  48.         super.onDestroy();    
  49.     }    
  50.         
  51. }  

PrintDataAction.java


[java]  view plain copy
  1. <span style="font-size:14px">public class PrintDataAction implements OnClickListener {    
  2.     private Context context = null;    
  3.     private TextView deviceName = null;    
  4.     private TextView connectState = null;    
  5.     private EditText printData = null;    
  6.     private String deviceAddress = null;    
  7.     private PrintDataService printDataService = null;    
  8.     
  9.     public PrintDataAction(Context context, String deviceAddress,    
  10.             TextView deviceName, TextView connectState) {    
  11.         super();    
  12.         this.context = context;    
  13.         this.deviceAddress = deviceAddress;    
  14.         this.deviceName = deviceName;    
  15.         this.connectState = connectState;    
  16.         this.printDataService = new PrintDataService(this.context,    
  17.                 this.deviceAddress);    
  18.         this.initView();    
  19.     
  20.     }    
  21.     
  22.     private void initView() {    
  23.         // 设置当前设备名称    
  24.         this.deviceName.setText(this.printDataService.getDeviceName());    
  25.         // 一上来就先连接蓝牙设备    
  26.         boolean flag = this.printDataService.connect();    
  27.         if (flag == false) {    
  28.             // 连接失败    
  29.             this.connectState.setText("连接失败！");    
  30.         } else {    
  31.             // 连接成功    
  32.             this.connectState.setText("连接成功！");    
  33.     
  34.         }    
  35.     }    
  36.     
  37.     public void setPrintData(EditText printData) {    
  38.         this.printData = printData;    
  39.     }    
  40.     
  41.     @Override    
  42.     public void onClick(View v) {    
  43.         if (v.getId() == R.id.send) {    
  44.             String sendData = this.printData.getText().toString();    
  45.             this.printDataService.send(sendData + "\n");    
  46.         } else if (v.getId() == R.id.command) {    
  47.             this.printDataService.selectCommand();    
  48.     
  49.         }    
  50.     }    
  51. }</span>  

PrintDataService.java


[java]  view plain copy
  1. <span style="font-size:14px">public class PrintDataService {    
  2.     private Context context = null;    
  3.     private String deviceAddress = null;    
  4.     private BluetoothAdapter bluetoothAdapter = BluetoothAdapter    
  5.             .getDefaultAdapter();    
  6.     private BluetoothDevice device = null;    
  7.     private static BluetoothSocket bluetoothSocket = null;    
  8.     private static OutputStream outputStream = null;    
  9.     private static final UUID uuid = UUID    
  10.             .fromString("00001101-0000-1000-8000-00805F9B34FB");    
  11.     private boolean isConnection = false;    
  12.     final String[] items = { "复位打印机", "标准ASCII字体", "压缩ASCII字体", "字体不放大",    
  13.             "宽高加倍", "取消加粗模式", "选择加粗模式", "取消倒置打印", "选择倒置打印", "取消黑白反显", "选择黑白反显",    
  14.             "取消顺时针旋转90°", "选择顺时针旋转90°" };    
  15.     final byte[][] byteCommands = { { 0x1b, 0x40 },// 复位打印机    
  16.             { 0x1b, 0x4d, 0x00 },// 标准ASCII字体    
  17.             { 0x1b, 0x4d, 0x01 },// 压缩ASCII字体    
  18.             { 0x1d, 0x21, 0x00 },// 字体不放大    
  19.             { 0x1d, 0x21, 0x11 },// 宽高加倍    
  20.             { 0x1b, 0x45, 0x00 },// 取消加粗模式    
  21.             { 0x1b, 0x45, 0x01 },// 选择加粗模式    
  22.             { 0x1b, 0x7b, 0x00 },// 取消倒置打印    
  23.             { 0x1b, 0x7b, 0x01 },// 选择倒置打印    
  24.             { 0x1d, 0x42, 0x00 },// 取消黑白反显    
  25.             { 0x1d, 0x42, 0x01 },// 选择黑白反显    
  26.             { 0x1b, 0x56, 0x00 },// 取消顺时针旋转90°    
  27.             { 0x1b, 0x56, 0x01 },// 选择顺时针旋转90°    
  28.     };    
  29.     
  30.     public PrintDataService(Context context, String deviceAddress) {    
  31.         super();    
  32.         this.context = context;    
  33.         this.deviceAddress = deviceAddress;    
  34.         this.device = this.bluetoothAdapter.getRemoteDevice(this.deviceAddress);    
  35.     }    
  36.     
  37.     /**  
  38.      * 获取设备名称  
  39.      *   
  40.      * @return String  
  41.      */    
  42.     public String getDeviceName() {    
  43.         return this.device.getName();    
  44.     }    
  45.     
  46.     /**  
  47.      * 连接蓝牙设备  
  48.      */    
  49.     public boolean connect() {    
  50.         if (!this.isConnection) {    
  51.             try {    
  52.                 bluetoothSocket = this.device    
  53.                         .createRfcommSocketToServiceRecord(uuid);    
  54.                 bluetoothSocket.connect();    
  55.                 outputStream = bluetoothSocket.getOutputStream();    
  56.                 this.isConnection = true;    
  57.                 if (this.bluetoothAdapter.isDiscovering()) {    
  58.                     System.out.println("关闭适配器！");    
  59.                     this.bluetoothAdapter.isDiscovering();    
  60.                 }    
  61.             } catch (Exception e) {    
  62.                 Toast.makeText(this.context, "连接失败！", 1).show();    
  63.                 return false;    
  64.             }    
  65.             Toast.makeText(this.context, this.device.getName() + "连接成功！",    
  66.                     Toast.LENGTH_SHORT).show();    
  67.             return true;    
  68.         } else {    
  69.             return true;    
  70.         }    
  71.     }    
  72.     
  73.     /**  
  74.      * 断开蓝牙设备连接  
  75.      */    
  76.     public static void disconnect() {    
  77.         System.out.println("断开蓝牙设备连接");    
  78.         try {    
  79.             bluetoothSocket.close();    
  80.             outputStream.close();    
  81.         } catch (IOException e) {    
  82.             // TODO Auto-generated catch block    
  83.             e.printStackTrace();    
  84.         }    
  85.     
  86.     }    
  87.     
  88.     /**  
  89.      * 选择指令  
  90.      */    
  91.     public void selectCommand() {    
  92.         new AlertDialog.Builder(context).setTitle("请选择指令")    
  93.                 .setItems(items, new DialogInterface.OnClickListener() {    
  94.                     @Override    
  95.                     public void onClick(DialogInterface dialog, int which) {    
  96.                         try {    
  97.                             outputStream.write(byteCommands[which]);    
  98.                         } catch (IOException e) {    
  99.                             Toast.makeText(context, "设置指令失败！",    
  100.                                     Toast.LENGTH_SHORT).show();    
  101.                         }    
  102.                     }    
  103.                 }).create().show();    
  104.     }    
  105.     
  106.     /**  
  107.      * 发送数据  
  108.      */    
  109.     public void send(String sendData) {    
  110.         if (this.isConnection) {    
  111.             System.out.println("开始打印！！");    
  112.             try {    
  113.                 byte[] data = sendData.getBytes("gbk");    
  114.                 outputStream.write(data, 0, data.length);    
  115.                 outputStream.flush();    
  116.             } catch (IOException e) {    
  117.                 Toast.makeText(this.context, "发送失败！", Toast.LENGTH_SHORT)    
  118.                         .show();    
  119.             }    
  120.         } else {    
  121.             Toast.makeText(this.context, "设备未连接，请重新连接！", Toast.LENGTH_SHORT)    
  122.                     .show();    
  123.     
  124.         }    
  125.     }    
  126.     
  127. }</span>  

羡慕羡慕羡慕羡慕到此，全部代码贴完，也就大功告成了羡慕羡慕羡慕羡慕

对了对了，差点忘记一件很重要的事情！！清单文件忘记给权限啦！！

权限

[html]  view plain copy
  1. <span style="font-size:14px"><uses-permission android:name="android.permission.BLUETOOTH" />    
  2.     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" /> </span>  

注册Activity

[html]  view plain copy
  1. <span style="font-size:14px"><activity android:name=".BluetoothActivity" />    
  2. <activity android:name=".PrintDataActivity" /> </span><span style="font-size:14px">   
  3.   
  4. </span>  

得意这下子就真的搞定了！
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjh200507609/article/details/50483496

智能推荐

第三十六篇、基于Arduino uno，获取红外寻迹传感器的原始值——结果导向_怎么检测红外寻迹模块返回值-程序员宅基地

文章浏览阅读385次。基于Arduino uno，获取红外寻迹传感器的原始值_怎么检测红外寻迹模块返回值

基于单片机的无线投票显示系统设计-程序员宅基地

文章浏览阅读494次，点赞5次，收藏9次。单片机（Microcontroller）是一种集成了微处理器核心、存储器、输入/输出接口和定时器等功能模块的集成电路芯片，具有体积小、功耗低、性价比高等特点，被广泛应用于各个领域。单片机的发展历史可以追溯到20世纪70年代，当时的单片机功能有限，主要用于简单的控制任务。

生成对抗网络GAN_生成对抗网络 python代码-程序员宅基地

文章浏览阅读412次。https://zhuanlan.zhihu.com/p/54096381_生成对抗网络 python代码

html——网页上添加表格_怎样在网站中添加表格别人可以下载-程序员宅基地

文章浏览阅读5.2k次，点赞7次，收藏18次。有时候我们需要在网页上展示一些数据，如某公司想在网页上展示公司的库存清单。如下表：想在网页上展示上述表格效果可以使用以下代码：创建表格的四个元素：table、tbody、tr、th、td1、…：整个表格以标记开始、标记结束。2、…：当表格内容非常多时，表格会下载一点显示一点，但如果加上标签后，这个表格就要等表格内容全部下载完才会显示。如右侧代码编辑器中的代码。3、…_怎样在网站中添加表格别人可以下载

《Qt MOOC系列教程》第五章第三节：创建新的QML类型_qmlregisteruncreatabletype-程序员宅基地

文章浏览阅读770次。到目前为止，我们已经讨论了如何将对象实例公开给QML上下文。有时我们还希望在QML中可以使用注册类本身。注册允许将类当作QML中的数据类型来使用。此外，注册还可以提供其他功能，比如允许在QML中将类用作可实例化的QML对象类型，或者允许在QML中导入和使用类的单例实例。通常我们使用Q_OBJECT宏注册从QObject派生的类，也可以用Q_GADGET宏声明一个比QObject“更轻”的版本。在这些更轻的类中，我们可以访问它们的属性、枚举和可调用的方法，但不能使用信号槽系统，我们稍后会进行介绍。1. 注_qmlregisteruncreatabletype

头文件与命名空间的关系_c#中命名空间和c语言中头文件之间的关系-程序员宅基地

文章浏览阅读2.1k次，点赞7次，收藏15次。头文件与命名空间的关系 Q:有些书说有些头文件不在std里是什么意思？std里包含些什么？为什么不用std就不能使用cout？头文件中声明的东西为什么在使用的时候需要先using namespace std；一下？如果我不用＃include和其他头文件。只用using namespace std 的话，是不能用cout的。这说明cout是在iostream里声明_c#中命名空间和c语言中头文件之间的关系

随便推点

python实现矩阵乘法（实现文件读写操作）_python 读取csv矩阵乘法-程序员宅基地

文章浏览阅读1.2k次，点赞2次，收藏8次。注释dtype=np.int代表导入数据的格式为整数delimiter=’,'代表原始数据的存储格式为以‘，’为间隔原始文件中以‘#’开头的行代表被注释，不会被np.loadtxt读取通过[[0] * b for i in range(a)]的方式初始化一个x[a][b]的二维数组np.savetxt()函数可以用来保存数据，第一个参数为保存数据的路径，其中C是自定义的文件名，如果该文..._python 读取csv矩阵乘法

《军团要塞2》绘画渲染_军团要塞画师-程序员宅基地

文章浏览阅读1.4k次。军团要塞2绘画渲染(a)美术概念 (b)游戏内玩家看到的角色摘要在《军团要塞2》中我们提出了一整套美术方案和新的实时渲染技术，这种技术能实现出一种独一无二的渲染风格。《军团要塞2》由美术和程序基于20世纪初时商业插画中的传统风格合作完成。在这篇论文中，我们会结合美术方向与技术选择，来讨论如何支持美术目标和玩法限制。除了实现一种有冲击力的风格外，我们也设计了边缘光照和亮度与色调变化的着色器技..._军团要塞画师

【数字图像处理实验二】：RGB图3个通道的提取、RGB图转灰度图、图片反转、图片亮度调整、直方图显示_jupter rgb灰度直方图提取-程序员宅基地

文章浏览阅读9.6k次，点赞8次，收藏65次。这里介绍：RGB图3个通道的提取、RGB图转灰度图、图片反转、图片亮度调整具体操作，需导入的库如下：原图如下：结果如下，从左到右分别是：Red，Green，Blue这里借助skimage库中的exposure函数来进行图像亮度的调整结果如下：........._jupter rgb灰度直方图提取

2023年地级、省级、县级、国界、九段线的shp数据_九段线shp数据-程序员宅基地

文章浏览阅读931次。2023年地级、省级、县级、国界、九段线的shp数据_九段线shp数据

python高校本科生学习成长记录系统的设计与实现flask-django-php-nodejs-程序员宅基地

文章浏览阅读797次，点赞16次，收藏19次。二十一世纪我们的社会进入了信息时代，信息管理系统的建立，大大提高了人们信息化水平。传统的管理方式对时间、地点的限制太多，而在线管理系统刚好能满足这些需求，在线管理系统突破了传统管理方式的局限性。于是本文针对这一需求设计并实现了一个基于django高校本科生学习成长记录系统，为了简捷并有效的解决学习各方面的问题。

redis实现分布式session共享_redis分布式session共享-程序员宅基地

文章浏览阅读7.7k次。为什么要共享session?我们使用单台Tomcat的时候不会有共享sesssion的疑虑，只要使用Tomcat的默认配置即可，session即可存储在Tomcat上。但是随着业务的扩大，增加Tomcat节点构成Tomcat集群大势所趋，分布式带来了增加更大规模并发请求的优势，但是也随之到来了一个问题，每个Tomcat只存储来访问自己的请求产生的session，如果Tomcat-A已经为客..._redis分布式session共享

推荐文章

热门文章

相关标签