SYMBTChat蓝牙聊天 for s60 1.41
版本说明软件地址1.02查看3.0.9查看1.30查看查看3.11查看
相关合集：
相关热搜：
蓝牙驱动、管理软件全球有5大厂商：Apple Mac OS X、Widcomm、IVT BlueSoleil、Microsoft、Toshiba，比较常见的是Widcomm/IVT BlueSoleil。千月(BlueSoleil) 是IVT公司最新推出的一款中文免费版蓝牙驱动产品，它秉承了BlueSoleil系列一贯的简洁易用的功能特点，以及美观友好的操作界面，轻松帮您实现台式机或笔记本等各种计算机平台间的无线连接；无线访问种类繁多的具...
高速下载地址
联通下载地址
电信下载地址
移动及其他下载地址
(您的评论需要经过审核才能显示)
最近觉得SYMBTChat蓝牙聊天 for s60很不错！我经常用通讯网络！
好嘢啊，终于可以打白话啦
SYMBTChat蓝牙聊天 for s60这么好的软件你到哪里去找啊
亲测SYMBTChat蓝牙聊天 for s60的使用过程流畅无闪退，唯一的缺点就是占用内存稍稍有些大，不过也无伤大雅。
我觉得现在的SYMBTChat蓝牙聊天 for s60已经够我用得了，什么时候想换口味了，就试试共享软件的版本
SYMBTChat蓝牙聊天 for s601.41下载好慢，不知道是不是我网速问题，继续等待……
我发现1.41的SYMBTChat蓝牙聊天 for s60相比上一版不容易崩溃了，不错不错
太谢谢你们了！ 我差点下了！
非常简单 可以用
既然这个SYMBTChat蓝牙聊天 for s60是国产软件，那我就会一直支持下去的
通讯网络推荐
3.1.0 For WP
热门关键词他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)源码自带的Demo BluetoothChat
聊天的主页面
* Copyright (C) 2009 The
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
* https://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.BluetoothC
import android.app.ActionB
import android.app.A
import android.bluetooth.BluetoothA
import android.bluetooth.BluetoothD
import android.content.I
import android.os.B
import android.os.H
import android.os.M
import android.util.L
import android.view.KeyE
import android.view.M
import android.view.MenuI
import android.view.MenuI
import android.view.V
import android.view.W
import android.view.View.OnClickL
import android.view.inputmethod.EditorI
import android.widget.ArrayA
import android.widget.B
import android.widget.EditT
import android.widget.ListV
import android.widget.TextV
import android.widget.T
* This is the main Activity that displays the current chat session.
public class BluetoothChat extends Activity {
// Debugging
private static final String TAG = BluetoothC
private static final boolean D =
// Message types sent from the BluetoothChatService Handler
public static final int MESSAGE_STATE_CHANGE = 1;
public static final int MESSAGE_READ = 2;
public static final int MESSAGE_WRITE = 3;
public static final int MESSAGE_DEVICE_NAME = 4;
public static final int MESSAGE_TOAST = 5;
// Key names received from the BluetoothChatService Handler
public static final String DEVICE_NAME = device_
public static final String TOAST =
// Intent request codes
private static final int REQUEST_CONNECT_DEVICE_SECURE = 1;
private static final int REQUEST_CONNECT_DEVICE_INSECURE = 2;
private static final int REQUEST_ENABLE_BT = 3;
// Layout Views
private ListView mConversationV
private EditText mOutEditT
private Button mSendB
// Name of the connected device
private String mConnectedDeviceName =
// Array adapter for the conversation thread
private ArrayAdapter mConversationArrayA
// String buffer for outgoing messages
private StringBuffer mOutStringB
// Local Bluetooth adapter
private BluetoothAdapter mBluetoothAdapter =
// Member object for the chat services
private BluetoothChatService mChatService =
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(D) Log.e(TAG, +++ ON CREATE +++);
// Set up the window layout
setContentView(R.layout.main);
// Get local Bluetooth adapter
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
// If the adapter is null, then Bluetooth is not supported
if (mBluetoothAdapter == null) {
Toast.makeText(this, Bluetooth is not available, Toast.LENGTH_LONG).show();
public void onStart() {
super.onStart();
if(D) Log.e(TAG, ++ ON START ++);
// If BT is not on, request that it be enabled.
// 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
if (mChatService == null) setupChat();
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(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();
public synchronized void onPause() {
super.onPause();
if(D) Log.e(TAG, - ON PAUSE -);
public void onStop() {
super.onStop();
if(D) Log.e(TAG, -- ON STOP --);
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();
// 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);
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() {
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();
case BluetoothChatService.STATE_CONNECTING:
setStatus(R.string.title_connecting);
case BluetoothChatService.STATE_LISTEN:
case BluetoothChatService.STATE_NONE:
setStatus(R.string.title_not_connected);
case MESSAGE_WRITE:
byte[] writeBuf = (byte[]) msg.
// construct a string from the buffer
String writeMessage = new String(writeBuf);
mConversationArrayAdapter.add(Me: + writeMessage);
case MESSAGE_READ:
byte[] readBuf = (byte[]) msg.
// construct a string from the valid bytes in the buffer
String readMessage = new String(readBuf, 0, msg.arg1);
mConversationArrayAdapter.add(mConnectedDeviceName+: + readMessage);
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();
case MESSAGE_TOAST:
Toast.makeText(getApplicationContext(), msg.getData().getString(TOAST),
Toast.LENGTH_SHORT).show();
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);
case REQUEST_CONNECT_DEVICE_INSECURE:
// When DeviceListActivity returns with a device to connect
if (resultCode == Activity.RESULT_OK) {
connectDevice(data, false);
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();
// 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();
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);
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.option_menu, menu);
public boolean onOptionsItemSelected(MenuItem item) {
Intent serverIntent =
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);
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);
case R.id.discoverable:
// Ensure this device is discoverable by others
ensureDiscoverable();
蓝牙聊天的后台线程类用于接受和发送信息和根据蓝牙的状态更新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
* https://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.BluetoothC
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.util.UUID;
import android.bluetooth.BluetoothA
import android.bluetooth.BluetoothD
import android.bluetooth.BluetoothServerS
import android.bluetooth.BluetoothS
import android.content.C
import android.os.B
import android.os.H
import android.os.M
import android.util.L
* 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 = BluetoothChatS
private static final boolean D =
// Name for the SDP record when creating server socket
private static final String NAME_SECURE = BluetoothChatS
private static final String NAME_INSECURE = BluetoothChatI
// Unique UUID for this application
private static final UUID MY_UUID_SECURE = UUID
.fromString(fa87c0d0-afac-11de-8a39-a66);
private static final UUID MY_UUID_INSECURE = UUID
.fromString(8ce255c0-200a-11e0-ac64-a66);
// Member fields
private final BluetoothAdapter mA
private final Handler mH
private AcceptThread mSecureAcceptT
private AcceptThread mInsecureAcceptT
private ConnectThread mConnectT
private ConnectedThread mConnectedT
private int mS
// 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
* 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 =
* Set the current state of the chat connection
* @param state
* An integer defining the current connection state
private synchronized void setState(int state) {
Log.d(TAG, setState() + 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() {
* Start the chat service. Specifically start AcceptThread to begin a
* session in listening (server) mode. Called by the Activity onResume()
public synchronized void start() {
Log.d(TAG, start);
// Cancel any thread attempting to make a connection
if (mConnectThread != null) {
mConnectThread.cancel();
mConnectThread =
// Cancel any thread currently running a connection
if (mConnectedThread != null) {
mConnectedThread.cancel();
mConnectedThread =
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) {
Log.d(TAG, connect to: + device);
// Cancel any thread attempting to make a connection
if (mState == STATE_CONNECTING) {
if (mConnectThread != null) {
mConnectThread.cancel();
mConnectThread =
// Cancel any thread currently running a connection
if (mConnectedThread != null) {
mConnectedThread.cancel();
mConnectedThread =
// 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) {
Log.d(TAG, connected, Socket Type: + socketType);
// Cancel the thread that completed the connection
if (mConnectThread != null) {
mConnectThread.cancel();
mConnectThread =
// Cancel any thread currently running a connection
if (mConnectedThread != null) {
mConnectedThread.cancel();
mConnectedThread =
// Cancel the accept thread because we only want to connect to one
if (mSecureAcceptThread != null) {
mSecureAcceptThread.cancel();
mSecureAcceptThread =
if (mInsecureAcceptThread != null) {
mInsecureAcceptThread.cancel();
mInsecureAcceptThread =
// 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() {
Log.d(TAG, stop);
if (mConnectThread != null) {
mConnectThread.cancel();
mConnectThread =
if (mConnectedThread != null) {
mConnectedThread.cancel();
mConnectedThread =
if (mSecureAcceptThread != null) {
mSecureAcceptThread.cancel();
mSecureAcceptThread =
if (mInsecureAcceptThread != null) {
mInsecureAcceptThread.cancel();
mInsecureAcceptThread =
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
ConnectedT
// Synchronize a copy of the ConnectedThread
synchronized (this) {
if (mState != STATE_CONNECTED)
r = mConnectedT
// 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 mmServerS
private String mSocketT
public AcceptThread(boolean secure) {
BluetoothServerSocket tmp =
mSocketType = secure ? Secure : I
// Create a new listening server socket
if (secure) {
tmp = mAdapter.listenUsingRfcommWithServiceRecord(
NAME_SECURE, MY_UUID_SECURE);
tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(
NAME_INSECURE, MY_UUID_INSECURE);
} catch (IOException e) {
Log.e(TAG, Socket Type: + mSocketType + listen() failed, e);
mmServerSocket =
public void run() {
Log.d(TAG, Socket Type: + mSocketType
+ BEGIN mAcceptThread + this);
setName(AcceptThread + mSocketType);
BluetoothSocket socket =
// Listen to the server socket if we're not connected
while (mState != STATE_CONNECTED) {
// 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);
// 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);
case STATE_NONE:
case STATE_CONNECTED:
// Either not ready or already connected. Terminate
// new socket.
socket.close();
} catch (IOException e) {
Log.e(TAG, Could not close unwanted socket, e);
Log.i(TAG, END mAcceptThread, socket Type: + mSocketType);
public void cancel() {
Log.d(TAG, Socket Type + mSocketType + cancel + this);
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 r the connection either succeeds or
private class ConnectThread extends Thread {
private final BluetoothSocket mmS
private final BluetoothDevice mmD
private String mSocketT
public ConnectThread(BluetoothDevice device, boolean secure) {
mmDevice =
BluetoothSocket tmp =
mSocketType = secure ? Secure : I
// Get a BluetoothSocket for a connection with the
// given BluetoothDevice
if (secure) {
tmp = device
.createRfcommSocketToServiceRecord(MY_UUID_SECURE);
tmp = device
.createInsecureRfcommSocketToServiceRecord(MY_UUID_INSECURE);
} catch (IOException e) {
Log.e(TAG, Socket Type: + mSocketType + create() failed, e);
mmSocket =
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
// This is a blocking call and will only return on a
// successful connection or an exception
mmSocket.connect();
} catch (IOException e) {
// Close the socket
mmSocket.close();
} catch (IOException e2) {
Log.e(TAG, unable to close() + mSocketType
+ socket during connection failure, e2);
connectionFailed();
// Reset the ConnectThread because we're done
synchronized (BluetoothChatService.this) {
mConnectThread =
// Start the connected thread
connected(mmSocket, mmDevice, mSocketType);
public void cancel() {
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 mmS
private final InputStream mmInS
private final OutputStream mmOutS
public ConnectedThread(BluetoothSocket socket, String socketType) {
Log.d(TAG, create ConnectedThread: + socketType);
mmSocket =
InputStream tmpIn =
OutputStream tmpOut =
// Get the BluetoothSocket input and output streams
tmpIn = socket.getInputStream();
tmpOut = socket.getOutputStream();
} catch (IOException e) {
Log.e(TAG, temp sockets not created, e);
mmInStream = tmpIn;
mmOutStream = tmpO
public void run() {
Log.i(TAG, BEGIN mConnectedThread);
byte[] buffer = new byte[1024];
// Keep listening to the InputStream while connected
while (true) {
// 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();
* Write to the connected OutStream.
* @param buffer
* The bytes to write
public void write(byte[] buffer) {
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() {
mmSocket.close();
} catch (IOException e) {
Log.e(TAG, close() of connect socket failed, e);
获取当前的蓝牙设备的信息，（已配对，可用的蓝牙列表）
* 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
* https://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.BluetoothC
import java.util.S
import android.app.A
import android.bluetooth.BluetoothA
import android.bluetooth.BluetoothD
import android.content.BroadcastR
import android.content.C
import android.content.I
import android.content.IntentF
import android.os.B
import android.util.L
import android.view.V
import android.view.W
import android.view.View.OnClickL
import android.widget.AdapterV
import android.widget.ArrayA
import android.widget.B
import android.widget.ListV
import android.widget.TextV
import android.widget.AdapterView.OnItemClickL
* This Activity appears as a dialog. It lists any paired devices and
* devices detected in the area after discovery. When a device is chosen
* by the user, the MAC address of the device is sent back to the parent
* Activity in the result Intent.
public class DeviceListActivity extends Activity {
// Debugging
private static final String TAG = DeviceListA
private static final boolean D =
// Return Intent extra
public static String EXTRA_DEVICE_ADDRESS = device_
// Member fields
private BluetoothAdapter mBtA
private ArrayAdapter mPairedDevicesArrayA
private ArrayAdapter mNewDevicesArrayA
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Setup the window
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.device_list);
// Set result CANCELED in case the user backs out
setResult(Activity.RESULT_CANCELED);
// Initialize the button to perform device discovery
Button scanButton = (Button) findViewById(R.id.button_scan);
scanButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
doDiscovery();
v.setVisibility(View.GONE);
// Initialize array adapters. One for already paired devices and
// one for newly discovered devices
mPairedDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);
mNewDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);
// Find and set up the ListView for paired devices
ListView pairedListView = (ListView) findViewById(R.id.paired_devices);
pairedListView.setAdapter(mPairedDevicesArrayAdapter);
pairedListView.setOnItemClickListener(mDeviceClickListener);
// Find and set up the ListView for newly discovered devices
ListView newDevicesListView = (ListView) findViewById(R.id.new_devices);
newDevicesListView.setAdapter(mNewDevicesArrayAdapter);
newDevicesListView.setOnItemClickListener(mDeviceClickListener);
// Register for broadcasts when a device is discovered
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
this.registerReceiver(mReceiver, filter);
// Register for broadcasts when discovery has finished
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
this.registerReceiver(mReceiver, filter);
// Get the local Bluetooth adapter
mBtAdapter = BluetoothAdapter.getDefaultAdapter();
// Get a set of currently paired devices
Set pairedDevices = mBtAdapter.getBondedDevices();
// If there are paired devices, add each one to the ArrayAdapter
if (pairedDevices.size() & 0) {
findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
for (BluetoothDevice device : pairedDevices) {
mPairedDevicesArrayAdapter.add(device.getName() + + device.getAddress());
String noDevices = getResources().getText(R.string.none_paired).toString();
mPairedDevicesArrayAdapter.add(noDevices);
protected void onDestroy() {
super.onDestroy();
// Make sure we're not doing discovery anymore
if (mBtAdapter != null) {
mBtAdapter.cancelDiscovery();
// Unregister broadcast listeners
this.unregisterReceiver(mReceiver);
* Start device discover with the BluetoothAdapter
private void doDiscovery() {
if (D) Log.d(TAG, doDiscovery());
// Indicate scanning in the title
setProgressBarIndeterminateVisibility(true);
setTitle(R.string.scanning);
// Turn on sub-title for new devices
findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);
// If we're already discovering, stop it
if (mBtAdapter.isDiscovering()) {
mBtAdapter.cancelDiscovery();
// Request discover from BluetoothAdapter
mBtAdapter.startDiscovery();
// The on-click listener for all devices in the ListViews
private OnItemClickListener mDeviceClickListener = new OnItemClickListener() {
public void onItemClick(AdapterViewav, View v, int arg2, long arg3) {
// Cancel discovery because it's costly and we're about to connect
mBtAdapter.cancelDiscovery();
// Get the device MAC address, which is the last 17 chars in the View
String info = ((TextView) v).getText().toString();
String address = info.substring(info.length() - 17);
// Create the result Intent and include the MAC address
Intent intent = new Intent();
intent.putExtra(EXTRA_DEVICE_ADDRESS, address);
// Set result and finish this Activity
setResult(Activity.RESULT_OK, intent);
// The BroadcastReceiver that listens for discovered devices and
// changes the title when discovery is finished
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);
// If it's already paired, skip it, because it's been listed already
if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
mNewDevicesArrayAdapter.add(device.getName() + + device.getAddress());
// When discovery is finished, change the Activity title
} else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
setProgressBarIndeterminateVisibility(false);
setTitle(R.string.select_device);
if (mNewDevicesArrayAdapter.getCount() == 0) {
String noDevices = getResources().getText(R.string.none_found).toString();
mNewDevicesArrayAdapter.add(noDevices);}