android 源码自带的Demo BluetoothChat

╰+哭是因爲堅強的太久メ 2022-08-02 06:57 121阅读 0赞

聊天的主页面

// setupChat() will then be called during onActivityResult

// 检查蓝牙设备是否可用，获得蓝牙设备的操作。

if (!mBluetoothAdapter.isEnabled()) \{  
Intent enableIntent = new Intent(BluetoothAdapter.ACTION\_REQUEST\_ENABLE);  
startActivityForResult(enableIntent, REQUEST\_ENABLE\_BT);  
// Otherwise, setup the chat session  
\} else \{  
if (mChatService == null) setupChat();  
\}  
\}  
  
@Override  
public synchronized void onResume() \{  
super.onResume();  
if(D) Log.e(TAG, "+ ON RESUME +");  
  
// Performing this check in onResume() covers the case in which BT was  
// not enabled during onStart(), so we were paused to enable it...  
// onResume() will be called when ACTION\_REQUEST\_ENABLE activity returns.  
if (mChatService != null) \{  
// Only if the state is STATE\_NONE, do we know that we haven't started already  
if (mChatService.getState() == BluetoothChatService.STATE\_NONE) \{  
// Start the Bluetooth chat services  
mChatService.start();  
\}  
\}  
\}  
  
private void setupChat() \{  
Log.d(TAG, "setupChat()");  
  
// Initialize the array adapter for the conversation thread  
mConversationArrayAdapter = new ArrayAdapter<String>(this, R.layout.message);  
mConversationView = (ListView) findViewById(R.id.in);  
mConversationView.setAdapter(mConversationArrayAdapter);  
  
// Initialize the compose field with a listener for the return key  
mOutEditText = (EditText) findViewById(R.id.edit\_text\_out);  
mOutEditText.setOnEditorActionListener(mWriteListener);  
  
// Initialize the send button with a listener that for click events  
mSendButton = (Button) findViewById(R.id.button\_send);  
mSendButton.setOnClickListener(new OnClickListener() \{  
public void onClick(View v) \{  
// Send a message using content of the edit text widget  
TextView view = (TextView) findViewById(R.id.edit\_text\_out);  
String message = view.getText().toString();  
sendMessage(message);  
\}  
\});  
  
// Initialize the BluetoothChatService to perform bluetooth connections  
mChatService = new BluetoothChatService(this, mHandler);  
  
// Initialize the buffer for outgoing messages  
mOutStringBuffer = new StringBuffer("");  
\}  
  
@Override  
public synchronized void onPause() \{  
super.onPause();  
if(D) Log.e(TAG, "- ON PAUSE -");  
\}  
  
@Override  
public void onStop() \{  
super.onStop();  
if(D) Log.e(TAG, "-- ON STOP --");  
\}  
  
@Override  
public void onDestroy() \{  
super.onDestroy();  
// Stop the Bluetooth chat services  
if (mChatService != null) mChatService.stop();  
if(D) Log.e(TAG, "--- ON DESTROY ---");  
\}  
  
private void ensureDiscoverable() \{  
if(D) Log.d(TAG, "ensure discoverable");  
if (mBluetoothAdapter.getScanMode() !=  
BluetoothAdapter.SCAN\_MODE\_CONNECTABLE\_DISCOVERABLE) \{  
Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION\_REQUEST\_DISCOVERABLE);  
discoverableIntent.putExtra(BluetoothAdapter.EXTRA\_DISCOVERABLE\_DURATION, 300);  
startActivity(discoverableIntent);  
\}  
\}  
  
/\*\*  
\* Sends a message.  
\* @param message A string of text to send.  
\*/  
private void sendMessage(String message) \{  
// Check that we're actually connected before trying anything  
if (mChatService.getState() != BluetoothChatService.STATE\_CONNECTED) \{  
Toast.makeText(this, R.string.not\_connected, Toast.LENGTH\_SHORT).show();  
return;  
\}  
  
// Check that there's actually something to send  
if (message.length() > 0) \{  
// Get the message bytes and tell the BluetoothChatService to write  
byte\[\] send = message.getBytes();  
mChatService.write(send);  
  
// Reset out string buffer to zero and clear the edit text field  
mOutStringBuffer.setLength(0);  
mOutEditText.setText(mOutStringBuffer);  
\}  
\}  
  
// The action listener for the EditText widget, to listen for the return key  
private TextView.OnEditorActionListener mWriteListener =  
new TextView.OnEditorActionListener() \{  
public boolean onEditorAction(TextView view, int actionId, KeyEvent event) \{  
// If the action is a key-up event on the return key, send the message  
if (actionId == EditorInfo.IME\_NULL && event.getAction() == KeyEvent.ACTION\_UP) \{  
String message = view.getText().toString();  
sendMessage(message);  
\}  
if(D) Log.i(TAG, "END onEditorAction");  
return true;  
\}  
\};  
  
private final void setStatus(int resId) \{  
final ActionBar actionBar = getActionBar();  
actionBar.setSubtitle(resId);  
\}  
  
private final void setStatus(CharSequence subTitle) \{  
final ActionBar actionBar = getActionBar();  
actionBar.setSubtitle(subTitle);  
\}  
  
// The Handler that gets information back from the BluetoothChatService  
private final Handler mHandler = new Handler() \{  
@Override  
public void handleMessage(Message msg) \{  
switch (msg.what) \{  
case MESSAGE\_STATE\_CHANGE:  
if(D) Log.i(TAG, "MESSAGE\_STATE\_CHANGE: " + msg.arg1);  
switch (msg.arg1) \{  
case BluetoothChatService.STATE\_CONNECTED:  
setStatus(getString(R.string.title\_connected\_to, mConnectedDeviceName));  
mConversationArrayAdapter.clear();  
break;  
case BluetoothChatService.STATE\_CONNECTING:  
setStatus(R.string.title\_connecting);  
break;  
case BluetoothChatService.STATE\_LISTEN:  
case BluetoothChatService.STATE\_NONE:  
setStatus(R.string.title\_not\_connected);  
break;  
\}  
break;  
case MESSAGE\_WRITE:  
byte\[\] writeBuf = (byte\[\]) msg.obj;  
// construct a string from the buffer  
String writeMessage = new String(writeBuf);  
mConversationArrayAdapter.add("Me: " + writeMessage);  
break;  
case MESSAGE\_READ:  
byte\[\] readBuf = (byte\[\]) msg.obj;  
// construct a string from the valid bytes in the buffer  
String readMessage = new String(readBuf, 0, msg.arg1);  
mConversationArrayAdapter.add(mConnectedDeviceName+": " + readMessage);  
break;  
case MESSAGE\_DEVICE\_NAME:  
// save the connected device's name  
mConnectedDeviceName = msg.getData().getString(DEVICE\_NAME);  
Toast.makeText(getApplicationContext(), "Connected to "  
\+ mConnectedDeviceName, Toast.LENGTH\_SHORT).show();  
break;  
case MESSAGE\_TOAST:  
Toast.makeText(getApplicationContext(), msg.getData().getString(TOAST),  
Toast.LENGTH\_SHORT).show();  
break;  
\}  
\}  
\};  
  
public void onActivityResult(int requestCode, int resultCode, Intent data) \{  
if(D) Log.d(TAG, "onActivityResult " + resultCode);  
switch (requestCode) \{  
case REQUEST\_CONNECT\_DEVICE\_SECURE:  
// When DeviceListActivity returns with a device to connect  
if (resultCode == Activity.RESULT\_OK) \{  
connectDevice(data, true);  
\}  
break;  
case REQUEST\_CONNECT\_DEVICE\_INSECURE:  
// When DeviceListActivity returns with a device to connect  
if (resultCode == Activity.RESULT\_OK) \{  
connectDevice(data, false);  
\}  
break;  
case REQUEST\_ENABLE\_BT:  
// When the request to enable Bluetooth returns  
if (resultCode == Activity.RESULT\_OK) \{  
// Bluetooth is now enabled, so set up a chat session  
setupChat();  
\} else \{  
// User did not enable Bluetooth or an error occurred  
Log.d(TAG, "BT not enabled");  
Toast.makeText(this, R.string.bt\_not\_enabled\_leaving, Toast.LENGTH\_SHORT).show();  
finish();  
\}  
\}  
\}  
  
private void connectDevice(Intent data, boolean secure) \{  
// Get the device MAC address  
String address = data.getExtras()  
.getString(DeviceListActivity.EXTRA\_DEVICE\_ADDRESS);  
// Get the BluetoothDevice object  
BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);  
// Attempt to connect to the device  
mChatService.connect(device, secure);  
\}  
  
@Override  
public boolean onCreateOptionsMenu(Menu menu) \{  
MenuInflater inflater = getMenuInflater();  
inflater.inflate(R.menu.option\_menu, menu);  
return true;  
\}  
  
@Override  
public boolean onOptionsItemSelected(MenuItem item) \{  
Intent serverIntent = null;  
switch (item.getItemId()) \{  
case R.id.secure\_connect\_scan:  
// Launch the DeviceListActivity to see devices and do scan  
serverIntent = new Intent(this, DeviceListActivity.class);  
startActivityForResult(serverIntent, REQUEST\_CONNECT\_DEVICE\_SECURE);  
return true;  
case R.id.insecure\_connect\_scan:  
// Launch the DeviceListActivity to see devices and do scan  
serverIntent = new Intent(this, DeviceListActivity.class);  
startActivityForResult(serverIntent, REQUEST\_CONNECT\_DEVICE\_INSECURE);  
return true;  
case R.id.discoverable:  
// Ensure this device is discoverable by others  
ensureDiscoverable();  
return true;  
\}  
return false;  
\}  
  
\}

蓝牙聊天的后台线程类用于接受和发送信息和根据蓝牙的状态更新UI。

/\*  
\* Copyright (C) 2009 The Android Open Source Project  
\*  
\* Licensed under the Apache License, Version 2.0 (the "License");  
\* you may not use this file except in compliance with the License.  
\* You may obtain a copy of the License at  
\*  
\* http://www.apache.org/licenses/LICENSE-2.0  
\*  
\* Unless required by applicable law or agreed to in writing, software  
\* distributed under the License is distributed on an "AS IS" BASIS,  
\* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
\* See the License for the specific language governing permissions and  
\* limitations under the License.  
\*/  
  
package com.example.android.BluetoothChat;  
  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.UUID;  
  
import android.bluetooth.BluetoothAdapter;  
import android.bluetooth.BluetoothDevice;  
import android.bluetooth.BluetoothServerSocket;  
import android.bluetooth.BluetoothSocket;  
import android.content.Context;  
import android.os.Bundle;  
import android.os.Handler;  
import android.os.Message;  
import android.util.Log;  
  
/\*\*  
\* This class does all the work for setting up and managing Bluetooth  
\* connections with other devices. It has a thread that listens for incoming  
\* connections, a thread for connecting with a device, and a thread for  
\* performing data transmissions when connected.  
\*/  
public class BluetoothChatService \{  
// Debugging  
private static final String TAG = "BluetoothChatService";  
private static final boolean D = true;  
  
// Name for the SDP record when creating server socket  
private static final String NAME\_SECURE = "BluetoothChatSecure";  
private static final String NAME\_INSECURE = "BluetoothChatInsecure";  
  
// Unique UUID for this application  
private static final UUID MY\_UUID\_SECURE = UUID  
.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");  
private static final UUID MY\_UUID\_INSECURE = UUID  
.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66");  
  
// Member fields  
private final BluetoothAdapter mAdapter;  
private final Handler mHandler;  
private AcceptThread mSecureAcceptThread;  
private AcceptThread mInsecureAcceptThread;  
private ConnectThread mConnectThread;  
private ConnectedThread mConnectedThread;  
private int mState;  
  
// Constants that indicate the current connection state  
public static final int STATE\_NONE = 0; // we're doing nothing  
public static final int STATE\_LISTEN = 1; // now listening for incoming  
// connections  
public static final int STATE\_CONNECTING = 2; // now initiating an outgoing  
// connection  
public static final int STATE\_CONNECTED = 3; // now connected to a remote  
// device  
  
/\*\*  
\* Constructor. Prepares a new BluetoothChat session.  
\*  
\* @param context  
\* The UI Activity Context  
\* @param handler  
\* A Handler to send messages back to the UI Activity  
\*/  
public BluetoothChatService(Context context, Handler handler) \{  
mAdapter = BluetoothAdapter.getDefaultAdapter();  
mState = STATE\_NONE;  
mHandler = handler;  
\}  
  
/\*\*  
\* Set the current state of the chat connection  
\*  
\* @param state  
\* An integer defining the current connection state  
\*/  
private synchronized void setState(int state) \{  
if (D)  
Log.d(TAG, "setState() " + mState + " -> " + state);  
mState = state;  
  
// Give the new state to the Handler so the UI Activity can update  
mHandler.obtainMessage(BluetoothChat.MESSAGE\_STATE\_CHANGE, state, -1)  
.sendToTarget();  
\}  
  
/\*\*  
\* Return the current connection state.  
\*/  
public synchronized int getState() \{  
return mState;  
\}  
  
/\*\*  
\* Start the chat service. Specifically start AcceptThread to begin a  
\* session in listening (server) mode. Called by the Activity onResume()  
\*/  
public synchronized void start() \{  
if (D)  
Log.d(TAG, "start");  
  
// Cancel any thread attempting to make a connection  
if (mConnectThread != null) \{  
mConnectThread.cancel();  
mConnectThread = null;  
\}  
  
// Cancel any thread currently running a connection  
if (mConnectedThread != null) \{  
mConnectedThread.cancel();  
mConnectedThread = null;  
\}  
  
setState(STATE\_LISTEN);  
  
// Start the thread to listen on a BluetoothServerSocket  
if (mSecureAcceptThread == null) \{  
mSecureAcceptThread = new AcceptThread(true);  
mSecureAcceptThread.start();  
\}  
if (mInsecureAcceptThread == null) \{  
mInsecureAcceptThread = new AcceptThread(false);  
mInsecureAcceptThread.start();  
\}  
\}  
  
/\*\*  
\* Start the ConnectThread to initiate a connection to a remote device.  
\*  
\* @param device  
\* The BluetoothDevice to connect  
\* @param secure  
\* Socket Security type - Secure (true) , Insecure (false)  
\*/  
public synchronized void connect(BluetoothDevice device, boolean secure) \{  
if (D)  
Log.d(TAG, "connect to: " + device);  
  
// Cancel any thread attempting to make a connection  
if (mState == STATE\_CONNECTING) \{  
if (mConnectThread != null) \{  
mConnectThread.cancel();  
mConnectThread = null;  
\}  
\}  
  
// Cancel any thread currently running a connection  
if (mConnectedThread != null) \{  
mConnectedThread.cancel();  
mConnectedThread = null;  
\}  
  
// Start the thread to connect with the given device  
mConnectThread = new ConnectThread(device, secure);  
mConnectThread.start();  
setState(STATE\_CONNECTING);  
\}  
  
/\*\*  
\* Start the ConnectedThread to begin managing a Bluetooth connection  
\*  
\* @param socket  
\* The BluetoothSocket on which the connection was made  
\* @param device  
\* The BluetoothDevice that has been connected  
\*/  
public synchronized void connected(BluetoothSocket socket,  
BluetoothDevice device, final String socketType) \{  
if (D)  
Log.d(TAG, "connected, Socket Type:" + socketType);  
  
// Cancel the thread that completed the connection  
if (mConnectThread != null) \{  
mConnectThread.cancel();  
mConnectThread = null;  
\}  
  
// Cancel any thread currently running a connection  
if (mConnectedThread != null) \{  
mConnectedThread.cancel();  
mConnectedThread = null;  
\}  
  
// Cancel the accept thread because we only want to connect to one  
// device  
if (mSecureAcceptThread != null) \{  
mSecureAcceptThread.cancel();  
mSecureAcceptThread = null;  
\}  
if (mInsecureAcceptThread != null) \{  
mInsecureAcceptThread.cancel();  
mInsecureAcceptThread = null;  
\}  
  
// Start the thread to manage the connection and perform transmissions  
mConnectedThread = new ConnectedThread(socket, socketType);  
mConnectedThread.start();  
  
// Send the name of the connected device back to the UI Activity  
Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE\_DEVICE\_NAME);  
Bundle bundle = new Bundle();  
bundle.putString(BluetoothChat.DEVICE\_NAME, device.getName());  
msg.setData(bundle);  
mHandler.sendMessage(msg);  
  
setState(STATE\_CONNECTED);  
\}  
  
/\*\*  
\* Stop all threads  
\*/  
public synchronized void stop() \{  
if (D)  
Log.d(TAG, "stop");  
  
if (mConnectThread != null) \{  
mConnectThread.cancel();  
mConnectThread = null;  
\}  
  
if (mConnectedThread != null) \{  
mConnectedThread.cancel();  
mConnectedThread = null;  
\}  
  
if (mSecureAcceptThread != null) \{  
mSecureAcceptThread.cancel();  
mSecureAcceptThread = null;  
\}  
  
if (mInsecureAcceptThread != null) \{  
mInsecureAcceptThread.cancel();  
mInsecureAcceptThread = null;  
\}  
setState(STATE\_NONE);  
\}  
  
/\*\*  
\* Write to the ConnectedThread in an unsynchronized manner  
\*  
\* @param out  
\* The bytes to write  
\* @see ConnectedThread\#write(byte\[\])  
\*/  
public void write(byte\[\] out) \{  
// Create temporary object  
ConnectedThread r;  
// Synchronize a copy of the ConnectedThread  
synchronized (this) \{  
if (mState != STATE\_CONNECTED)  
return;  
r = mConnectedThread;  
\}  
// Perform the write unsynchronized  
r.write(out);  
\}  
  
/\*\*  
\* Indicate that the connection attempt failed and notify the UI Activity.  
\*/  
private void connectionFailed() \{  
// Send a failure message back to the Activity  
Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE\_TOAST);  
Bundle bundle = new Bundle();  
bundle.putString(BluetoothChat.TOAST, "Unable to connect device");  
msg.setData(bundle);  
mHandler.sendMessage(msg);  
  
// Start the service over to restart listening mode  
BluetoothChatService.this.start();  
\}  
  
/\*\*  
\* Indicate that the connection was lost and notify the UI Activity.  
\*/  
private void connectionLost() \{  
// Send a failure message back to the Activity  
Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE\_TOAST);  
Bundle bundle = new Bundle();  
bundle.putString(BluetoothChat.TOAST, "Device connection was lost");  
msg.setData(bundle);  
mHandler.sendMessage(msg);  
  
// Start the service over to restart listening mode  
BluetoothChatService.this.start();  
\}  
  
/\*\*  
\* This thread runs while listening for incoming connections. It behaves  
\* like a server-side client. It runs until a connection is accepted (or  
\* until cancelled).  
\*/  
private class AcceptThread extends Thread \{  
// The local server socket  
private final BluetoothServerSocket mmServerSocket;  
private String mSocketType;  
  
public AcceptThread(boolean secure) \{  
BluetoothServerSocket tmp = null;  
mSocketType = secure ? "Secure" : "Insecure";  
  
// Create a new listening server socket  
try \{  
if (secure) \{  
tmp = mAdapter.listenUsingRfcommWithServiceRecord(  
NAME\_SECURE, MY\_UUID\_SECURE);  
\} else \{  
tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(  
NAME\_INSECURE, MY\_UUID\_INSECURE);  
\}  
\} catch (IOException e) \{  
Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);  
\}  
mmServerSocket = tmp;  
\}  
  
public void run() \{  
if (D)  
Log.d(TAG, "Socket Type: " + mSocketType  
\+ "BEGIN mAcceptThread" + this);  
setName("AcceptThread" + mSocketType);  
  
BluetoothSocket socket = null;  
  
// Listen to the server socket if we're not connected  
while (mState != STATE\_CONNECTED) \{  
try \{  
// This is a blocking call and will only return on a  
// successful connection or an exception  
socket = mmServerSocket.accept();  
\} catch (IOException e) \{  
Log.e(TAG, "Socket Type: " + mSocketType  
\+ "accept() failed", e);  
break;  
\}  
  
// If a connection was accepted  
if (socket != null) \{  
synchronized (BluetoothChatService.this) \{  
switch (mState) \{  
case STATE\_LISTEN:  
case STATE\_CONNECTING:  
// Situation normal. Start the connected thread.  
connected(socket, socket.getRemoteDevice(),  
mSocketType);  
break;  
case STATE\_NONE:  
case STATE\_CONNECTED:  
// Either not ready or already connected. Terminate  
// new socket.  
try \{  
socket.close();  
\} catch (IOException e) \{  
Log.e(TAG, "Could not close unwanted socket", e);  
\}  
break;  
\}  
\}  
\}  
\}  
if (D)  
Log.i(TAG, "END mAcceptThread, socket Type: " + mSocketType);  
  
\}  
  
public void cancel() \{  
if (D)  
Log.d(TAG, "Socket Type" + mSocketType + "cancel " + this);  
try \{  
mmServerSocket.close();  
\} catch (IOException e) \{  
Log.e(TAG, "Socket Type" + mSocketType  
\+ "close() of server failed", e);  
\}  
\}  
\}  
  
/\*\*  
\* This thread runs while attempting to make an outgoing connection with a  
\* device. It runs straight through; the connection either succeeds or  
\* fails.  
\*/  
private class ConnectThread extends Thread \{  
private final BluetoothSocket mmSocket;  
private final BluetoothDevice mmDevice;  
private String mSocketType;  
  
public ConnectThread(BluetoothDevice device, boolean secure) \{  
mmDevice = device;  
BluetoothSocket tmp = null;  
mSocketType = secure ? "Secure" : "Insecure";  
  
// Get a BluetoothSocket for a connection with the  
// given BluetoothDevice  
try \{  
if (secure) \{  
tmp = device  
.createRfcommSocketToServiceRecord(MY\_UUID\_SECURE);  
\} else \{  
tmp = device  
.createInsecureRfcommSocketToServiceRecord(MY\_UUID\_INSECURE);  
\}  
\} catch (IOException e) \{  
Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);  
\}  
mmSocket = tmp;  
\}  
  
public void run() \{  
Log.i(TAG, "BEGIN mConnectThread SocketType:" + mSocketType);  
setName("ConnectThread" + mSocketType);  
  
// Always cancel discovery because it will slow down a connection  
mAdapter.cancelDiscovery();  
  
// Make a connection to the BluetoothSocket  
try \{  
// This is a blocking call and will only return on a  
// successful connection or an exception  
mmSocket.connect();  
\} catch (IOException e) \{  
// Close the socket  
try \{  
mmSocket.close();  
\} catch (IOException e2) \{  
Log.e(TAG, "unable to close() " + mSocketType  
\+ " socket during connection failure", e2);  
\}  
connectionFailed();  
return;  
\}  
  
// Reset the ConnectThread because we're done  
synchronized (BluetoothChatService.this) \{  
mConnectThread = null;  
\}  
  
// Start the connected thread  
connected(mmSocket, mmDevice, mSocketType);  
\}  
  
public void cancel() \{  
try \{  
mmSocket.close();  
\} catch (IOException e) \{  
Log.e(TAG, "close() of connect " + mSocketType  
\+ " socket failed", e);  
\}  
\}  
\}  
  
/\*\*  
\* This thread runs during a connection with a remote device. It handles all  
\* incoming and outgoing transmissions.  
\*/  
private class ConnectedThread extends Thread \{  
private final BluetoothSocket mmSocket;  
private final InputStream mmInStream;  
private final OutputStream mmOutStream;  
  
public ConnectedThread(BluetoothSocket socket, String socketType) \{  
Log.d(TAG, "create ConnectedThread: " + socketType);  
mmSocket = socket;  
InputStream tmpIn = null;  
OutputStream tmpOut = null;  
  
// Get the BluetoothSocket input and output streams  
try \{  
tmpIn = socket.getInputStream();  
tmpOut = socket.getOutputStream();  
\} catch (IOException e) \{  
Log.e(TAG, "temp sockets not created", e);  
\}  
  
mmInStream = tmpIn;  
mmOutStream = tmpOut;  
\}  
  
public void run() \{  
Log.i(TAG, "BEGIN mConnectedThread");  
byte\[\] buffer = new byte\[1024\];  
int bytes;  
  
// Keep listening to the InputStream while connected  
while (true) \{  
try \{  
// Read from the InputStream  
bytes = mmInStream.read(buffer);  
  
// Send the obtained bytes to the UI Activity  
mHandler.obtainMessage(BluetoothChat.MESSAGE\_READ, bytes,  
\-1, buffer).sendToTarget();  
\} catch (IOException e) \{  
Log.e(TAG, "disconnected", e);  
connectionLost();  
// Start the service over to restart listening mode  
BluetoothChatService.this.start();  
break;  
\}  
\}  
\}  
  
/\*\*  
\* Write to the connected OutStream.  
\*  
\* @param buffer  
\* The bytes to write  
\*/  
public void write(byte\[\] buffer) \{  
try \{  
mmOutStream.write(buffer);  
  
// Share the sent message back to the UI Activity  
mHandler.obtainMessage(BluetoothChat.MESSAGE\_WRITE, -1, -1,  
buffer).sendToTarget();  
\} catch (IOException e) \{  
Log.e(TAG, "Exception during write", e);  
\}  
\}  
  
public void cancel() \{  
try \{  
mmSocket.close();  
\} catch (IOException e) \{  
Log.e(TAG, "close() of connect socket failed", e);  
\}  
\}  
\}  
\}