Chinaunix首页 | 论坛 | 博客
  • 博客访问: 2195602
  • 博文数量: 866
  • 博客积分: 14125
  • 博客等级: 上将
  • 技术积分: 10638
  • 用 户 组: 普通用户
  • 注册时间: 2007-07-27 16:53
个人简介

https://github.com/landuochong

文章分类

全部博文(866)

文章存档

2019年(3)

2018年(1)

2017年(10)

2015年(3)

2014年(8)

2013年(3)

2012年(70)

2011年(103)

2010年(360)

2009年(283)

2008年(22)

分类: 嵌入式

2012-12-20 09:47:32

10.6  蓝牙的基本介绍与实现(1)

蓝牙,是一种支持设备短距离通信(一般10m内,且无阻隔媒介)的无线电技术。能在包括移动电话、PDA、无线耳机、笔记本电脑等众多设备之间进行无线信息交换。利用"蓝牙"技术,能够有效地简化移动通信终端设备之间的通信,也能够成功地简化设备与Internet之间的通信,这样数据传输变得更加迅速高效,为无线通信拓宽道路。

几个术语

在Android手机平台中,只到Android 2.0才引入蓝牙接口。在开发时,需要真机测试,如果需要数据传输,还需要两台机器,另外蓝牙需要硬件支持,但一般的智能手机上都会有这方面的支持,特别是Android系统的手机。

正式开发Android 蓝牙时,需要在Android项目中的AndroidManifest.xml中添加对应权限:

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

 

以下介绍android.bluetooth.*中的重要类的作用,如表10-7所示。

表10-7   android.bluetooth.*中的重要类的作用

    

    

BluetoothAdapter

本地蓝牙设备的适配类,所有的蓝牙

操作都要通过该类完成

BluetoothClass

用于描述远端设备的类型,特点等信息

BluetoothDevice

蓝牙设备类,代表了蓝牙通讯过程中的远端设备

BluetoothServerSocket

蓝牙设备服务端,类似ServerSocket

BluetoothSocket

蓝牙设备客户端,类似Socket

BluetoothClass.Device

蓝牙关于设备信息

BluetoothClass.Device.Major

蓝牙设备管理

BluetoothClass.Service

蓝牙相关服务

其中BluetoothAdapter是一个非常重要的适配类,它包含打开蓝牙、关闭蓝牙、蓝牙状态、搜索蓝牙等重要方法,如表10-8所示。

 

表10-8   BluetoothAdapter适配类包含的方法

    

    

getDefaultAdapter

得到默认蓝牙适配器

getRemoteDevice

得到指定蓝牙的BluetoothDevice

isEnabled

蓝牙是否开启

getState

得到蓝牙状态

enable

打开蓝牙

Disable

关闭蓝牙

getAddress

得到蓝牙适配器地址

getName

得到蓝牙的名字

setName

设置蓝牙的名字

getScanMode

得到当前蓝牙的扫描模式

setScanMode

设置当前蓝牙的设置模式

startDiscovery

开始搜索蓝牙设备

cancelDiscovery

取消搜索蓝牙设备

isDiscovering

是否允许被搜索

getBondedDevices

得到BluetoothDevice集合到本地适配器

listenUsingRfcommWithServiceRecord

创建一个监听,安全记录蓝牙

RFCOMM蓝牙套接字

checkBluetoothAddress

检查蓝牙地址是否正确

Android操作蓝牙不是很困难,主要就是打开蓝牙、关闭蓝牙、搜索蓝牙、蓝牙客户端、蓝牙服务器等。蓝牙客户端、服务器和Socket基础中讲解的差不多,但蓝牙中是用BluetoothSocket和BluetoothServerSocket两个类来操作。

关于Android在操作蓝牙过程中的几个要点和操作方式如下。

1.打开蓝牙的方式有两种

  1. (1)Intent enabler = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);  
  2. startActivityForResult(enabler, REQUEST_ENABLE);  
  3. (2)BluetoothAdapter _bluetooth = BluetoothAdapter.getDefaultAdapter();  
  4. _bluetooth.enable();  

第一种方式Android系统会弹出一个提示框,提示用户是否开启蓝牙设备。第二种方式不会提示,会直接打开蓝牙设备,在运用当中视情况而定,有些情况需要友好提示,有些情况则可直接打开使用。

2.使设备能够被搜索

基于安全性考虑,设置开启可被搜索后,Android系统就会默认给出120秒的时间,其他远程设备在这120秒内可以搜索到它:

  1. Intent enabler = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);  
  2. startActivityForResult(enabler, REQUEST_DISCOVERABLE);  

3.搜索蓝牙设备

  1. BluetoothAdapter _bluetooth = BluetoothAdapter.getDefaultAdapter()  
  2. _bluetooth.startDiscovery();  

4.关闭蓝牙设备

  1. BluetoothAdapter _bluetooth = BluetoothAdapter.getDefaultAdapter();  
  2. _bluetooth.disable (); 

5.创建蓝牙客户端

  1. BluetoothSocket socketdevice.
    createRfcommSocketToServiceRecord(UUID.fromString(UUID号));  
  2. socket.connect(); 

6.创建蓝牙服务器

  1. BluetoothServerSocket _serverSocket=_bluetooth.
    listenUsingRfcommWithServiceRecord(服务器名称, UUID.fromString(UUID号));  
  2. BluetoothSocket socket = _serverSocket.accept();  
  3. InputStream inputStream = socket.getInputStream();  

看到_serverSocket.accept()大家想到前面Socket章节所讲到的ServerSocket也有这个方法,原理上它们其实是一样的,都是阻塞等待客户端的数据,如果客户端没有数据过来,它将一直阻塞在此处。

在上述几个重要步骤方法中,最重要的是蓝牙客户端和服务器,这两个操作是在商业应用中和日常使用中最频繁的,例如,利用蓝牙传递数据、游戏、聊天等。目前市场上出现很多关于利用蓝牙技术做的聊天工具和传输数据文件的应用,它们都是采用BluetoothSocket和BluetoothServerSocket技术。

另外还有一点注意,蓝牙和WiFi都是比较耗电的功能模块,所以,在不使用蓝牙的情况下,建议关闭它。

蓝牙的基本操作和代码实现

代码部分就实现打开蓝牙、关闭蓝牙、搜索蓝牙、允许搜索。目前唯一比较复杂的地方就是如何建立蓝牙客户端和蓝牙服务器。

下面看看代码是如何实现蓝牙服务器和蓝牙客户端的,代码如下,代码来源EX_10_05:

服务器端:

  1. ………………………………省略部分代码…………………………..  
  2.         setTitle("蓝牙服务端");  
  3.         // 声明变量  
  4.         BluetoothAdapter bluetooth = null;//本地蓝牙设备  
  5.         BluetoothServerSocket serverSocket = null;// 蓝牙设备Socket服务端  
  6.         BluetoothSocket socket = null;// 蓝牙设备Socket客户端  
  7.         OutputStream os = null;// 蓝牙输出流  
  8.         InputStream is = null;// 蓝牙输入流  
  9.         try {  
  10.             // 1.得到本地设备  
  11.             bluetooth = BluetoothAdapter.getDefaultAdapter();  
  12.             // 2.创建蓝牙Socket服务器  
  13.             serverSocket = bluetooth.
    listenUsingRfcommWithServiceRecord("btspp",         
    UUID.fromString("00000000-2527-eef3-ffff-ffffe3160865"));  
  14.             // 3.阻塞等待Socket客户端请求  
  15.             socket = serverSocket.accept();  
  16.             if (socket != null) {  
  17.                 // 4.处理输出流  
  18.                 os = socket.getOutputStream();  
  19.                 os.write("我是服务器!".getBytes());  
  20.                 if (os != null) {  
  21.                     os.flush();  
  22.                     os.close();  
  23.                 }  
  24.                 // 5.处理输入流  
  25.                 is = socket.getInputStream();  
  26.                 byte[] bytes = new byte[is.available()];  
  27.                 is.read(bytes);  
  28.                 System.out.println("服务器端读取客户端传输的数据时:" + new String(bytes));  
  29.                 if (is != null)  
  30.                     is.close();  
  31.                 if (socket != null)  
  32.                     socket.close();  
  33.                 if (serverSocket != null)  
  34.                     serverSocket.close();  
  35.             }  
  36.         } catch (Exception e) {  
  37.             e.printStackTrace();  
  38.         }  

客户端:

  1. ………………………………省略部分代码…………………………..  
  2.         setTitle("蓝牙客户端");  
  3.         //声明变量  
  4.         BluetoothAdapter bluetooth = null;//本地蓝牙设备  
  5.         BluetoothDevice device = null;//远程蓝牙设备  
  6.         BluetoothSocket socket = null;//蓝牙Socket客户端  
  7.         OutputStream os = null;//输出流  
  8.         InputStream is = null;//输入流  
  9.         try {  
  10.             //1.得到本地蓝牙设备的默认适配器  
  11.             bluetooth = BluetoothAdapter.getDefaultAdapter();  
  12.             //2.通过本地蓝牙设备得到远程蓝牙设备  
  13.             device = bluetooth.getRemoteDevice("A0:75:91:E0:88:D3");  
  14.             //3.根据UUID 创建并返回一个BluetoothSocket     
  15.             socket = device.createRfcommSocketToServiceRecord(UUID  
  16.                     .fromString("00000000-2527-eef3-ffff-ffffe3160865"));  
  17.             if (socket != null) {  
  18.                 // 连接  
  19.                 socket.connect();  
  20.                 //4处理客户端输出流  
  21.                 os = socket.getOutputStream();  
  22.                 os.write("我是客户端!".getBytes());  
  23.                 os.flush();  
  24.                 os.close();  
  25.                 //5处理客户端输入流  
  26.                 is = socket.getInputStream();  
  27.                 byte[] b = new byte[is.available()];  
  28.                 is.read(b);  
  29.                 System.out.println("客户端接收到服务器传输的数据::" + new String(b));  
  30.                 is.close();  
  31.                 socket.close();  
  32.             }  
  33.         } catch (Exception e) {  
  34.             e.printStackTrace();  
  35.         }  

代码解释:

测试代码时,需要手动打开蓝牙并自行配置好蓝牙客户端和服务器,也就是蓝牙配对。代码中注意服务器端和客户端的UUID:00000000-2527-eef3-ffff-ffffe3160865,两个地方一定要一样,另外客户端代码中的bluetooth.getRemoteDevice("A0:75:91:E0:88:D3")是通过服务器端的地址获取远程蓝牙服务器。

从代码角度看其实都很简单,读者要多练并且多灵活运用。如果前期读者对Socket的学习过关的话,学习蓝牙Socket编程是非常轻松的。由于BluetoothSocket支持OutputStream和InputStream,所以,可以利用它们相互传输任何数据。

 

Android平台支持蓝牙网络协议栈,实现蓝牙设备之间数据的无线传输。
本文档描述了怎样利用android平台提供的蓝牙API去实现蓝牙设备之间的通信,蓝牙设备之间的通信主要包括了四个步骤:设置蓝牙设备、寻找局域网内可能或者匹配的设备、连接设备和设备之间的数据传输。以下是建立蓝牙连接的所需要的一些基本类:
  BluetoothAdapter类:代表了一个本地的蓝牙适配器。他是所有蓝牙交互的的入口点。利用它你可以发现其他蓝牙设备,查询绑定了的设备,使用已知的MAC地址实例化一个蓝牙设备和建立一个BluetoothServerSocket(作为服务器端)来监听来自其他设备的连接。
  BluetoothDevice类:代表了一个远端的蓝牙设备,使用它请求远端蓝牙设备连接或者获取远端蓝牙设备的名称、地址、种类和绑定状态。(其信息是封装在bluetoothsocket中)。
  Bluetoothsocket类:代表了一个蓝牙套接字的接口(类似于tcp中的套接字),他是应用程序通过输入、输出流与其他蓝牙设备通信的连接点。
  Blueboothserversocket类:代表打开服务连接来监听可能到来的连接请求(属于server端),为了连接两个蓝牙设备必须有一个设备作为服务器打开一个服务套接字。当远端设备发起连接连接请求的时候,并且已经连接到了的时候,Blueboothserversocket类将会返回一个bluetoothsocket。
  Bluetoothclass类:描述了一个蓝牙设备的一般特点和能力。他的只读属性集定义了设备的主、次设备类和一些相关服务。然而,他并没有准确的描述所有该设备所支持的蓝牙文件和服务,而是作为对设备种类来说的一个小小暗示。
下面说说具体的编程实现:
必须确定你的设备支持蓝牙,并保证他可以用。如果你的设备支持蓝牙,将它使能。当然,有两种方法,一种是在你的系统设置里开启蓝牙,另外一中是在你的应用程序里启动蓝牙功能,第一种方法就不讲了,具体讲一个第二种方法:
 首先通过调用静态方法getDefaultAdapter()获取蓝牙适配器bluetoothadapter,以后你就可以使用该对象了。如果返回为空,the story is over。
 Eg:BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter == null) {
    // Device does not support Bluetooth
}
其次,调用isEnabled()来查询当前蓝牙设备的状态,如果返回为false,则表示蓝牙设备没有开启,接下来你需要封装一个ACTION_REQUEST_ENABLE请求到intent里面,调用startActivityForResult()方法使能蓝牙设备,例如:
if (!mBluetoothAdapter.isEnabled()) {
             Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}
 

至此,如不出意外,恭喜你的蓝牙设备已经开启了,接下来需要查找周边可能存在的蓝牙设备了。
查找设备:
  使用bluetoothadapter类里的方法,你可以查找远端设备(不过蓝牙查找的范围好像是在十米以内吧)或者查询在你手机上已经匹配(或者说绑定)的其他手机了。当然需要确定对方蓝牙设备已经开启或者已经开启了“被发现使能“功能(对方设备是可以被发现的是你能够发起连接的前提条件)。如果该设备是可以被发现的,会反馈回来一些对方的设备信息,比如名字、MAC地址等,利用这些信息,你的设备就可以选择去向对方初始化一个连接。
如果你是第一次与该设备连接,那么一个配对的请求就会自动的显示给用户。当设备配对好之后,他的一些基本信息(主要是名字和MAC)被保存下来并可以使用蓝牙的API来读取。使用已知的MAC地址就可以对远端的蓝牙设备发起连接请求。
  匹配好的设备和连接上的设备的不同点:匹配好只是说明对方设备发现了你的存在,并拥有一个共同的识别码,并且可以连接。连接上:表示当前设备共享一个RFCOMM信道并且两者之间可以交换数据。也就是是说蓝牙设备在建立RFCOMM信道之前,必须是已经配对好了的。
 怎么查询匹配好的设备:

 在建立连接之前你必须先查询配对好了的蓝牙设备集(你周围的蓝牙设备可能不止一个),以便你选取哪一个设备进行通信,例如你可以你可以查询所有配对的蓝牙设备,并使用一个数组适配器将其打印显示出来:
  Set pairedDevices = mBluetoothAdapter.getBondedDevices();
// If there are paired devices
if (pairedDevices.size() > 0) {
    // Loop through paired devices
    for (BluetoothDevice device : pairedDevices) {
        // Add the name and address to an array adapter to show in a ListView
        mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
    }

建立一个蓝牙连接只需要MAC地址就已经足够了。
扫描设备:
   扫描设备,只需要简单的调用startDiscovery()方法,这个扫描的过程大概持续是12秒,应用程序为了ACTION_FOUND动作需要注册一个BroadcastReceiver来接受设备扫描到的信息。对于每一个设备,系统都会广播ACTION_FOUND动作。例如:
   // Create a BroadcastReceiver for ACTION_FOUND
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        // When discovery finds a device
        if (BluetoothDevice.ACTION_FOUND.equals(action)) {
            // Get the BluetoothDevice object from the Intent
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            // Add the name and address to an array adapter to show in a ListView
            mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
        }
    }
};
// Register the BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter); // Don't forget to unregister during onDestroy

注意:扫描的过程是一个很耗费资源的过程,一旦你找到你需要的设备之后,在发起连接请求之前,确保你的程序调用cancelDiscovery()方法停止扫描。显然,如果你已经连接上一个设备,启动扫描会减少你的通信带宽。
  使能被发现:Enabling discoverability

  如果你想使你的设备能够被其他设备发现,将ACTION_REQUEST_DISCOVERABLE动作封装在intent中并调用startActivityForResult(Intent, int)方法就可以了。他将在不使你应用程序退出的情况下使你的设备能够被发现。缺省情况下的使能时间是120秒,当然你可以可以通过添加EXTRA_DISCOVERABLE_DURATION字段来改变使能时间(最大不超过300秒,这是出于对你设备上的信息安全考虑)。例如:
Intent discoverableIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);

运行该段代码之后,系统会弹出一个对话框来提示你启动设备使能被发现(次过程中如果你的蓝牙功能没有开启,系统会帮你开启),并且如果你准备对该远端设备发现一个连接,你不需要开启使能设备被发现功能,以为该功能只是在你的应用程序作为服务器端的时候才需要。

连接设备:
  在你的应用程序中,想建立两个蓝牙设备之间的连接,你必须实现客户端和服务器端的代码(因为任何一个设备都必须可以作为服务端或者客户端)。一个开启服务来监听,一个发起连接请求(使用服务器端设备的MAC地址)。当他们都拥有一个蓝牙套接字在同一RFECOMM信道上的时候,可以认为他们之间已经连接上了。服务端和客户端通过不同的方式或其他们的蓝牙套接字。当一个连接监听到的时候,服务端获取到蓝牙套接字。当客户可打开一个FRCOMM信道给服务器端的时候,客户端获取到蓝牙套接字。

 注意:在此过程中,如果两个蓝牙设备还没有配对好的,android系统会通过一个通知或者对话框的形式来通知用户。RFCOMM连接请求会在用户选择之前阻塞。如下图:

服务端的连接:
 当你想要连接两台设备时,一个必须作为服务端(通过持有一个打开的bluetoothserversocket),目的是监听外来连接请求,当监听到以后提供一个连接上的bluetoothsocket给客户端,当客户端从bluetoothserversocket得到bluetoothsocket以后就可以销毁bluetoothserversocket,除非你还想监听更多的连接请求。
  建立服务套接字和监听连接的基本步骤:
 首先通过调用listenUsingRfcommWithServiceRecord(String, UUID)方法来获取bluetoothserversocket对象,参数string代表了该服务的名称,UUID代表了和客户端连接的一个标识(128位格式的字符串ID,相当于pin码),UUID必须双方匹配才可以建立连接。其次调用accept()方法来监听可能到来的连接请求,当监听到以后,返回一个连接上的蓝牙套接字bluetoothsocket。最后,在监听到一个连接以后,需要调用close()方法来关闭监听程序。(一般蓝牙设备之间是点对点的传输)
注意:accept()方法不应该放在主Acitvity里面,因为他是一种阻塞调用(在没有监听到连接请求之间程序就一直停在那里)。解决方法是新建一个线程来管理。例如:
 private class AcceptThread extends Thread {
    private final BluetoothServerSocket mmServerSocket;

    public AcceptThread() {
        // Use a temporary object that is later assigned to mmServerSocket,
        // because mmServerSocket is final
        BluetoothServerSocket tmp = null;
        try {
            // MY_UUID is the app's UUID string, also used by the client code
            tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
        } catch (IOException e) { }
        mmServerSocket = tmp;
    }

    public void run() {
        BluetoothSocket socket = null;
        // Keep listening until exception occurs or a socket is returned
        while (true) {
            try {
                socket = mmServerSocket.accept();
            } catch (IOException e) {
                break;
            }
            // If a connection was accepted
            if (socket != null) {
                // Do work to manage the connection (in a separate thread)
                manageConnectedSocket(socket);
                mmServerSocket.close();
                break;
            }
        }
    }

    /** Will cancel the listening socket, and cause the thread to finish */
    public void cancel() {
        try {
            mmServerSocket.close();
        } catch (IOException e) { }
    }
}

客户端的连接:
  为了初始化一个与远端设备的连接,需要先获取代表该设备的一个bluetoothdevice对象。通过bluetoothdevice对象来获取bluetoothsocket并初始化连接:
 具体步骤:
  使用bluetoothdevice对象里的方法createRfcommSocketToServiceRecord(UUID)来获取bluetoothsocket。UUID就是匹配码。然后,调用connect()方法来。如果远端设备接收了该连接,他们将在通信过程中共享RFFCOMM信道,并且connect()方法返回。例如:
  private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;

    public ConnectThread(BluetoothDevice device) {
        // Use a temporary object that is later assigned to mmSocket,
        // because mmSocket is final
        BluetoothSocket tmp = null;
        mmDevice = device;

        // Get a BluetoothSocket to connect with the given BluetoothDevice
        try {
            // MY_UUID is the app's UUID string, also used by the server code
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) { }
        mmSocket = tmp;
    }

    public void run() {
        // Cancel discovery because it will slow down the connection
        mAdapter.cancelDiscovery();

        try {
            // Connect the device through the socket. This will block
            // until it succeeds or throws an exception
            mmSocket.connect();
        } catch (IOException connectException) {
            // Unable to connect; close the socket and get out
            try {
                mmSocket.close();
            } catch (IOException closeException) { }
            return;
        }

        // Do work to manage the connection (in a separate thread)
        manageConnectedSocket(mmSocket);
    }

    /** Will cancel an in-progress connection, and close the socket */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
 注意:conncet()方法也是阻塞调用,一般建立一个独立的线程中来调用该方法。在设备discover过程中不应该发起连接connect(),这样会明显减慢速度以至于连接失败。且数据传输完成只有调用close()方法来关闭连接,这样可以节省系统内部资源。
管理连接(主要涉及数据的传输):
 当设备连接上以后,每个设备都拥有各自的bluetoothsocket。现在你就可以实现设备之间数据的共享了。
1.                                首先通过调用getInputStream()和getOutputStream()方法来获取输入输出流。然后通过调用read(byte[]) 和 write(byte[]).方法来读取或者写数据。
2.                               实现细节:以为读取和写操作都是阻塞调用,需要建立一个专用现成来管理。
3.                              private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;

    public ConnectedThread(BluetoothSocket socket) {
        mmSocket = socket;
        InputStream tmpIn = null;
        OutputStream tmpOut = null;

        // Get the input and output streams, using temp objects because
        // member streams are final
        try {
            tmpIn = socket.getInputStream();
            tmpOut = socket.getOutputStream();
        } catch (IOException e) { }

        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }

    public void run() {
        byte[] buffer = new byte[1024];  // buffer store for the stream
        int bytes; // bytes returned from read()

        // Keep listening to the InputStream until an exception occurs
        while (true) {
            try {
                // Read from the InputStream
                bytes = mmInStream.read(buffer);
                // Send the obtained bytes to the UI Activity
                mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                break;
            }
        }
    }

    /* Call this from the main Activity to send data to the remote device */
    public void write(byte[] bytes) {
        try {
            mmOutStream.write(bytes);
        } catch (IOException e) { }
    }

    /* Call this from the main Activity to shutdown the connection */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}

转自:http://www.verydemo.com/demo_c131_i6221.html

阅读(1894) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册