上一節，我們將連接設備放在了對話框中進行羅列顯示，下面我們將選擇一個藍牙設備進行連接。
1、首先我們添加一個列表單擊事件，發送內容。
2、在onActivityResult中獲取傳來的內容。
3、進行連接
1、DeviceListActivity.java
package com.sangbo.bluetooth;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;
import com.sangb.projecttest.R;
import java.util.Set;
/**
* Created by 桑博 on 2015/10/29.
*/
public class DeviceListActivity extends Activity {
private BluetoothAdapter m_BtAdapter;
private Button m_btnFindDevice;
private ListView m_pairedListView;
private ListView m_newListView;
private ArrayAdapter<String> m_pairedAdapter;
private ArrayAdapter<String> m_newAdapter;
public final static String BLUETOOTH_DEVICE_ADDRESS = "device_address";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//設置窗口
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.activity_blue_tooth_device_list);
//設置取消後，返回
setResult(Activity.RESULT_CANCELED);
//初始化一些控件
initViews();
//獲取默認的藍牙適配器
m_BtAdapter = BluetoothAdapter.getDefaultAdapter();
//註冊相應的監聽
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
this.registerReceiver(mReceiver, filter);
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
this.registerReceiver(mReceiver, filter);
//尋找設備按鈕事件
m_btnFindDevice = (Button) findViewById(R.id.btn_find_device);
m_btnFindDevice.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//隱藏按鈕
v.setVisibility(View.GONE);
//顯示進度條
setProgressBarIndeterminateVisibility(true);
//如果當前本地藍牙適配器處於搜索設備中
if(m_BtAdapter.isDiscovering()){
//那麼取消搜索
m_BtAdapter.cancelDiscovery();
}
//先把數據清除一下，以免重複
m_newAdapter.clear();
//開始搜索藍牙設備
m_BtAdapter.startDiscovery();
}
});
Set<BluetoothDevice> pairedDevices = m_BtAdapter.getBondedDevices();
if(pairedDevices.size() > 0){
for (BluetoothDevice device: pairedDevices) {
m_pairedAdapter.add(device.getName()+"\n" +device.getAddress());
}
}else{
m_pairedAdapter.add("沒有配對的設備");
}
}
public void initViews() {
m_pairedListView = (ListView) findViewById(R.id.paired_devices);
m_newListView = (ListView) findViewById(R.id.new_devices);
m_pairedAdapter = new ArrayAdapter(this,android.R.layout.simple_list_item_1);
m_newAdapter = new ArrayAdapter(this,android.R.layout.simple_list_item_1);
m_pairedListView.setAdapter(m_pairedAdapter);
m_newListView.setAdapter(m_newAdapter);
m_pairedListView.setOnItemClickListener(mDeviceClickListener);
m_newListView.setOnItemClickListener(mDeviceClickListener);
}
//接收消息的一個監聽
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
//如果發現了一個藍牙設備
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
//我們拿到這個藍牙設備
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
//打印出藍牙的名稱和藍牙地址
Log.i("info", "devie 藍牙名稱:" + device.getName() + ",藍牙地址：" + device.getAddress());
m_newAdapter.add(device.getName()+"\n" +device.getAddress());
}
//搜索完成後
else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
//打印搜索完成
Log.i("info", "devie : 搜索結束");
//顯示按鈕
m_btnFindDevice.setVisibility(View.VISIBLE);
//取消進度條
setProgressBarIndeterminateVisibility(false);
}
}
};
//列表單擊事件
private AdapterView.OnItemClickListener mDeviceClickListener = new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
//取消搜索,我們都找到要連接的設備了， 就沒必要搜索了。
m_BtAdapter.cancelDiscovery();
//獲取藍牙的MAC地址
String info = ((TextView)view).getText().toString();
String address = info.substring(info.length() - 17);
//裝載藍牙的MAC地址
Intent intent = new Intent();
intent.putExtra(BLUETOOTH_DEVICE_ADDRESS,address);
//傳輸地址，並關閉當前Activity
setResult(Activity.RESULT_OK, intent);
finish();
}
};
@Override
protected void onDestroy() {
super.onDestroy();
//取消搜索
if (m_BtAdapter != null) {
m_BtAdapter.cancelDiscovery();
}
//接觸事件的監聽
this.unregisterReceiver(mReceiver);
}
}
2、BlueToothActivity.java
package com.sangbo.bluetooth;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import com.sangb.projecttest.BaseActivity;
import com.sangb.projecttest.R;
/**
* Created by 桑博 on 2015/10/28.
*/
public class BlueToothActivity extends BaseActivity{
private Button m_btnConnDevice;
private TextView m_tvDeviceName;
private BluetoothAdapter m_BtAdapter;
private final int REQUEST_ENABLE = 0;
private final int REQUEST_CONNECT_DEVICE = 1;
private BluetoothChatService mChatService = null;
private String mConnectedDeviceName = "";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_blue_tooth);
initViews();
//獲取默認的本地藍牙適配器，參考①
m_BtAdapter = BluetoothAdapter.getDefaultAdapter();
//獲取本地藍牙適配器的狀態，是否啓用
if(!m_BtAdapter.isEnabled()){
//如果沒有啓用，發出提示進行啓用。
Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(intent,REQUEST_ENABLE);
//當然你也可以不提示，強行打開（如果沒有root權限，系統會提示獲取藍牙的root權限）
// m_BtAdapter.enable();
}else if (mChatService == null){
//初始化連接線程
setupChat();
}
//連接列表對話框
m_btnConnDevice.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent serverIntent = new Intent(BlueToothActivity.this,DeviceListActivity.class);
startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);
}
});
}
//初始化連接線程
private void setupChat() {
mChatService = new BluetoothChatService(this, mHandler);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
switch (requestCode){
//選取了mac地址後返回
case REQUEST_CONNECT_DEVICE:
if(resultCode == Activity.RESULT_OK){
String address = data.getExtras().getString(DeviceListActivity.BLUETOOTH_DEVICE_ADDRESS);
BluetoothDevice device = m_BtAdapter.getRemoteDevice(address);
mChatService.connect(device,true);
}
break;
//返回打開了藍牙適配器
case REQUEST_ENABLE:
if(resultCode == Activity.RESULT_OK){
setupChat();
}
break;
}
}
@Override
public void initViews(){
m_btnConnDevice = (Button) findViewById(R.id.btn_conn_device);
m_tvDeviceName = (TextView) findViewById(R.id.tv_device_name);
}
//藍牙連接線程
private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
//藍牙連接狀態改變時
case Constants.MESSAGE_STATE_CHANGE:
switch (msg.arg1) {
//已連接
case BluetoothChatService.STATE_CONNECTED:
//顯示連接設備
m_tvDeviceName.setText("連接設備: " +mConnectedDeviceName);
break;
//連接中
case BluetoothChatService.STATE_CONNECTING:
m_tvDeviceName.setText("正在連接中。。。");
break;
//未連接成功
case BluetoothChatService.STATE_LISTEN:
case BluetoothChatService.STATE_NONE:
m_tvDeviceName.setText("未連接設備");
Toast.makeText(BlueToothActivity.this, "連接失敗", Toast.LENGTH_SHORT).show();
break;
}
break;
//連接成功，獲取設備名稱
case Constants.MESSAGE_DEVICE_NAME:
// save the connected device's name
mConnectedDeviceName = msg.getData().getString(Constants.DEVICE_NAME);
break;
//連接過程中發來的消息
case Constants.MESSAGE_TOAST:
if (null != BlueToothActivity.this) {
Toast.makeText(BlueToothActivity.this, msg.getData().getString(Constants.TOAST),
Toast.LENGTH_SHORT).show();
}
break;
}
}
};
}
3、BluetoothChatService.java
/*
* Copyright (C) 2014 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.sangbo.bluetooth;
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;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;
/**
* 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";
// 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) {
Log.d(TAG, "setState() " + mState + " -> " + state);
mState = state;
// Give the new state to the Handler so the UI Activity can update
mHandler.obtainMessage(Constants.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() {
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) {
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) {
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(Constants.MESSAGE_DEVICE_NAME);
Bundle bundle = new Bundle();
bundle.putString(Constants.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 = 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(Constants.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(Constants.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(Constants.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(Constants.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() {
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;
}
}
}
}
Log.i(TAG, "END mAcceptThread, socket Type: " + mSocketType);
}
public void cancel() {
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(Constants.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(Constants.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);
}
}
}
}
4、activity_blue_tooth.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/tv_device_name"
android:layout_width="fill_parent"
android:text="設備未連接"
android:layout_height="wrap_content" />
<Button
android:id="@+id/btn_conn_device"
android:layout_width="wrap_content"
android:text="@string/conn_blue_toolth_device"
android:layout_height="wrap_content" />
</LinearLayout>5、activity_blue_tooth_device_list
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:layout_width="wrap_content"
android:text="@string/title_paired_devices"
android:layout_height="wrap_content" />
<ListView
android:id="@+id/paired_devices"
android:layout_width="fill_parent"
android:layout_weight="1"
android:layout_height="wrap_content"></ListView>
<TextView
android:layout_width="wrap_content"
android:text="@string/title_other_devices"
android:layout_height="wrap_content" />
<ListView
android:id="@+id/new_devices"
android:layout_width="fill_parent"
android:layout_weight="2"
android:layout_height="wrap_content"></ListView>
<Button
android:id="@+id/btn_find_device"
android:layout_width="wrap_content"
android:text="@string/find_blue_toolth_device"
android:layout_height="wrap_content" />
</LinearLayout>6、strings.xml
<string name="find_blue_toolth_device">查找藍牙設備</string>
<string name="title_paired_devices">配對的設備</string>
<string name="title_other_devices">其他可用設備</string>
<string name="conn_blue_toolth_device">連接藍牙設備</string>轉載請註明： SangBigYe：http://blog.csdn.net/CutelittleBo/article/details/49507121