Android端简易蓝牙聊天通讯App（原创）

欢迎转载，但请注明出处！谢谢。http://www.cnblogs.com/weizhxa/p/5792775.html

　　最近公司在做一个蓝牙串口通讯的App，有一个固定的蓝牙设备，需要实现手机连接相互交换数据。以前没怎么做过蓝牙开发，故查看Android App Guide的蓝牙篇，发现有个chat示例，故此做了点研究。在研究的基础上进行了此App的实现。

　　1、App特点：

　　　　1.1 App中同时存在服务器与客户端，任意手机可以作为服务器或者客户端；

　　　　1.2 客户端可以进行蓝牙环境扫描；

　　　　1.3 诸多异常处理……均未做，O(∩_∩)O。demo了，主要学习的是蓝牙技术嘛。

　　2、实现过程中的总结：

　　　　2.1 蓝牙串口通讯，谷歌给出了一个固定UUID： 00001101-0000-1000-8000-00805F9B34FB，大多数蓝牙串口设备使用此UUID作为连接用UUID，此UUID在BluetoothDevice的createRfcommSocketToServiceRecord方法中有提到。具体可以看api doc。

　　3、具体实现代码：

　　　　3.1 客户端服务器选择页：MainActivity。此页仅进行客户端与服务器端选择使用。

　　　　　　3.1.1 Activity：

　　　　　　

package org.fiu.bluetoothdemos;

import org.fiu.bluetoothchatdemos.R;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;

public class MainActivity extends ActionBarActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    /**
     * 建立服务器
     * 
     * @param view
     */
    public void btn_server(View view) {
        startActivity(new Intent(this, ServerActivity.class));
    }

    /**
     * 建立客户端
     * 
     * @param view
     */
    public void btn_client(View view) {
        startActivity(new Intent(this, ClientActivity.class));
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

　　　　　　3.1.2 layout：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="org.fiu.bluetoothdemos.MainActivity" >

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="btn_server"
        android:text="开启服务器" />

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="btn_client"
        android:text="开启客户端" />

</LinearLayout>

　　　　3.2 服务器端代码：

　　　　　　3.2.1 服务器页面：点击进入服务器页面后，直接使用上面所说UUID进行服务器建立，等待客户端连接工作。拥有一个消息显示框和发送EditText，可以与客户端进行交互。内部拥有一个BluetoothServer管理类，这个类主要管理了服务器的蓝牙操作。

　　　　　　

package org.fiu.bluetoothdemos;

import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import org.fiu.bluetoothchatdemos.R;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.TextView;

/**
 * 服务器
 * 
 * @author c
 * 
 */
public class ServerActivity extends Activity {
    private EditText et_msg;
    private BluetoothServer server;
    private List<String> msgs = new ArrayList<String>();
    private TimerTask task = new TimerTask() {

        @Override
        public void run() {
            synchronized (msgs) {
                msgs = server.getMsgs();
            }
            runOnUiThread(new Runnable() {
                public void run() {
                    msgAdapter.notifyDataSetChanged();
                }
            });
        }

    };
    private MyAdapter msgAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);

        et_msg = (EditText) findViewById(R.id.et_msg);
        server = new BluetoothServer(this);
        server.start();

        ListView lv_msg = (ListView) findViewById(R.id.lv_msg);
        msgAdapter = new MyAdapter();
        lv_msg.setAdapter(msgAdapter);

        Timer timer = new Timer();
        timer.schedule(task, 0, 1000);
    }

    public class MyAdapter extends BaseAdapter {

        @Override
        public int getCount() {
            // TODO Auto-generated method stub
            return msgs.size();
        }

        @Override
        public Object getItem(int position) {
            return msgs.get(position);
        }

        @Override
        public long getItemId(int position) {
            // TODO Auto-generated method stub
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            TextView tv = null;
            if (convertView != null) {
                tv = (TextView) convertView;
            } else {
                tv = new TextView(ServerActivity.this);
                AbsListView.LayoutParams params = new AbsListView.LayoutParams(
                        AbsListView.LayoutParams.MATCH_PARENT,
                        AbsListView.LayoutParams.WRAP_CONTENT);
                tv.setLayoutParams(params);
            }
            tv.setTag(msgs.get(position));
            tv.setText(msgs.get(position));
            return tv;
        }

    }

    /**
     * 发送
     * 
     * @param view
     */
    public void btn_send(View view) {
        String msg = et_msg.getText().toString().trim();
        send(msg);
    }

    /**
     * 发送消息到客户端
     * 
     * @param msg
     */
    private void send(String msg) {
        server.send(msg);
        synchronized (msgs) {
            msgs.add("服务器发送：" + msg);
        }
    }
}

　　　　　　3.2.2 服务器页面layout

　　　　　　

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_margin="5dp"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginBottom="5dp"
        android:orientation="horizontal" >

        <EditText
            android:id="@+id/et_msg"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="3"
            android:hint="chatMessage" />

        <Button
            android:layout_width="20dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:onClick="btn_send"
            android:text="send" />
    </LinearLayout>

    <ListView
        android:id="@+id/lv_msg"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
    </ListView>

</LinearLayout>

　　　　　　3.2.3 服务器蓝牙管理类

　　　　　　

package org.fiu.bluetoothdemos;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.widget.Toast;

/**
 * 蓝牙服务器
 * 
 * @author weizh
 * 
 */
public class BluetoothServer {
    /**
     * 消息集合
     */
    private List<String> listMsg = new ArrayList<String>();
    /**
     * 是否工作中
     */
    private boolean isWorking = false;
    /**
     * bluetooth name
     */
    private String name = "FIUBluetoothServer";
    /**
     * spp well-known UUID
     */
    public static final UUID MY_UUID = UUID
            .fromString("00001101-0000-1000-8000-00805F9B34FB");
    private static final String TAG = "BluetoothServer";
    /**
     * 蓝牙服务器socket
     */
    private BluetoothServerSocket bluetoothServerSocket;
    /**
     * 客户端socket
     */
    private BluetoothSocket mClientSocket;

    Context context;

    public BluetoothServer(Context context) {
        this.context = context;
    }

    /**
     * 开启服务器
     */
    public void start() {
        listen();
    }

    /**
     * 开始监听
     */
    private void listen() {
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                // 判断是否有蓝牙设备
                if (!BluetoothUtils.checkBluetoothExists()) {
                    throw new RuntimeException("bluetooth module not exists.");
                }
                // 打开设备
                if (!BluetoothUtils.openBluetoothDevice()) {
                    return;
                }
                try {
                    if (bluetoothServerSocket == null) {
                        bluetoothServerSocket = BluetoothAdapter
                                .getDefaultAdapter()
                                .listenUsingRfcommWithServiceRecord(name,
                                        MY_UUID);
                    }
                    isWorking = true;
                    while (isWorking) {
                        mClientSocket = bluetoothServerSocket.accept();
                        Log.i(TAG, "客户端已连接："
                                + mClientSocket.getRemoteDevice().getName());
                        myHandler.sendEmptyMessage(0x01);
                        new ClientWorkingThread(mClientSocket).start();
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();

    }

    private Handler myHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Toast.makeText(context,
                    "客户端已连接：" + mClientSocket.getRemoteDevice().getName(), 0)
                    .show();
        }

    };

    /**
     * 停止
     */
    public void stop() {
        isWorking = false;
        if (bluetoothServerSocket != null) {
            try {
                bluetoothServerSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                bluetoothServerSocket = null;
            }
        }
        if (mClientSocket != null) {
            try {
                mClientSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                mClientSocket = null;
            }
        }
    }

    /**
     * 客户端socket工作类
     * 
     * @author weizh
     * 
     */
    private class ClientWorkingThread extends Thread {
        /**
         * 客户端socket
         */
        private BluetoothSocket mClientSocket;

        public ClientWorkingThread(BluetoothSocket clientSocket) {
            this.mClientSocket = clientSocket;
        }

        @Override
        public void run() {
            try {
                InputStream inputStream = mClientSocket.getInputStream();// 输入流
                // 从输入流中取出数据，插入消息条中
                byte[] buffer = new byte[1024];
                while (isWorking) {
                    int read = inputStream.read(buffer);
                    if (read != -1) {
                        // 有内容
                        // 判断是否取得的消息填充满了buffer，未到字符串结尾符；如果不是，证明读取到了一条信息，并且信息是完整的，这个完整的前提是不能粘包，不粘包可以使用flush进行处理。
                        StringBuilder sb = new StringBuilder();
                        if (read < buffer.length) {
                            String msg = new String(buffer, 0, read);
                            sb.append(msg);
                        } else {
                            byte[] tempBytes = new byte[1024 * 4];
                            while (read == buffer.length
                                    && buffer[read - 1] != 0x7f) {
                                read = inputStream.read(buffer);
                            }
                            String msg = new String(buffer, 0, read);
                            sb.append(msg);
                        }
                        Log.i(TAG, "服务器收到：" + sb.toString());
                        synchronized (listMsg) {
                            listMsg.add("客户端发送：" + sb.toString());
                        }
                    }
                    // try {
                    // Thread.sleep(300);
                    // } catch (InterruptedException e) {
                    // // TODO Auto-generated catch block
                    // e.printStackTrace();
                    // }
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 工作完毕，关闭socket
            try {
                mClientSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }

    /**
     * 返回listMsg
     * 
     * @return
     */
    public List<String> getMsgs() {
        synchronized (listMsg) {
            return listMsg;
        }
    }

    /**
     * 发送消息
     * 
     * @param msg
     */
    public void send(String msg) {
        if (mClientSocket != null) {
            try {
                mClientSocket.getOutputStream().write(msg.getBytes());
                mClientSocket.getOutputStream().flush();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

　　　　　3.3 客户端页面：客户端除了具有消息框和发送消息框外，加载后首先可以进行蓝牙环境扫描，并且和选择。demo中偷了懒，没在选择后停止蓝牙扫描工作等诸多小细节……

　　　　　　3.3.1 客户端页面代码：

package org.fiu.bluetoothdemos;

import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

import org.fiu.bluetoothchatdemos.R;
import org.fiu.bluetoothdemos.ServerActivity.MyAdapter;

import android.app.Activity;
import android.app.AlertDialog;
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.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.ViewGroup.LayoutParams;
import android.widget.AbsListView;
import android.widget.AbsoluteLayout;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.BaseAdapter;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;

/**
 * 客户端
 * 
 * @author c
 * 
 */
public class ClientActivity extends Activity {
    /**
     * 被发现的设备
     */
    private List<BluetoothDevice> discoverDevices = new ArrayList<BluetoothDevice>();
    /**
     * 蓝牙客户端
     */
    private BluetoothClient bluetoothClient;
    /**
     * tag
     */
    public final String TAG = "ClientActivity";
    /**
     * 搜索对话框
     */
    private AlertDialog dlgSearch;
    /**
     * adapter
     */
    private BaseAdapter adapter;
    private EditText et_msg;
    private List<String> msgs = new ArrayList<String>();
    private TimerTask task = new TimerTask() {

        @Override
        public void run() {
            synchronized (msgs) {
                msgs = bluetoothClient.getMsgs();
            }
            runOnUiThread(new Runnable() {
                public void run() {
                    msgAdapter.notifyDataSetChanged();
                }
            });
        }

    };
    private MyAdapter msgAdapter;
    /**
     * 设备搜索广播
     */
    private BroadcastReceiver receiver = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            switch (action) {
            case BluetoothDevice.ACTION_FOUND:
                // 发现设备，添加到列表，刷新列表
                discoverDevices.add((BluetoothDevice) intent
                        .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE));
                if (adapter != null) {
                    adapter.notifyDataSetChanged();
                }
                break;
            case BluetoothAdapter.ACTION_DISCOVERY_STARTED:
                // 开始搜索
                Log.i(TAG, "开始搜索设备");
                discoverDevices.clear();
                // 弹出对话框
                if (dlgSearch == null) {
                    dlgSearch = new AlertDialog.Builder(ClientActivity.this)
                            .create();
                    // 自定义对话框
                    View view = LayoutInflater.from(ClientActivity.this)
                            .inflate(R.layout.dialog_search, null);
                    ListView lv_devices = (ListView) view
                            .findViewById(R.id.lv_devices);
                    adapter = new DevicesAdapter(ClientActivity.this);
                    lv_devices.setAdapter(adapter);
                    lv_devices
                            .setOnItemClickListener(new OnItemClickListener() {

                                @Override
                                public void onItemClick(AdapterView<?> parent,
                                        View view, int position, long id) {
                                    // 项点击时，进行连接
                                    BluetoothDevice device = (BluetoothDevice) view
                                            .getTag();
                                    bluetoothClient.connect(device);
                                    dlgSearch.dismiss();
                                    dlgSearch = null;

                                }
                            });
                    dlgSearch.setView(view);
                    dlgSearch.setCancelable(true);// 可以按back键取消
                    dlgSearch.setCanceledOnTouchOutside(false);// 不可以按空白地方取消
                }
                dlgSearch.show();
                break;
            case BluetoothAdapter.ACTION_DISCOVERY_FINISHED:
                // 结束搜索
                Log.i(TAG, "结束搜索设备");
                break;

            default:
                break;
            }
        }

    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);

        bluetoothClient = new BluetoothClient();

        et_msg = (EditText) findViewById(R.id.et_msg);

        ListView lv_msg = (ListView) findViewById(R.id.lv_msg);
        msgAdapter = new MyAdapter();
        lv_msg.setAdapter(msgAdapter);

        Timer timer = new Timer();
        timer.schedule(task, 0, 1000);

        // 搜索蓝牙设备
        bluetoothClient.start();
    }

    public class MyAdapter extends BaseAdapter {

        @Override
        public int getCount() {
            // TODO Auto-generated method stub
            return msgs.size();
        }

        @Override
        public Object getItem(int position) {
            return msgs.get(position);
        }

        @Override
        public long getItemId(int position) {
            // TODO Auto-generated method stub
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            TextView tv = null;
            if (convertView != null) {
                tv = (TextView) convertView;
            } else {
                tv = new TextView(ClientActivity.this);
                AbsListView.LayoutParams params = new AbsListView.LayoutParams(
                        AbsListView.LayoutParams.MATCH_PARENT,
                        AbsListView.LayoutParams.WRAP_CONTENT);
                tv.setLayoutParams(params);
            }
            tv.setTag(msgs.get(position));
            tv.setText(msgs.get(position));
            return tv;
        }

    }

    @Override
    protected void onResume() {
        super.onResume();
        registerReceiver();
    }

    private void registerReceiver() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        filter.addAction(BluetoothDevice.ACTION_FOUND);
        registerReceiver(receiver, filter);
    }

    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(receiver);
    }

    /**
     * 设备adapter
     * 
     * @author c
     * 
     */
    private class DevicesAdapter extends BaseAdapter {

        private Context context;

        public DevicesAdapter(Context context) {
            this.context = context;
        }

        @Override
        public int getCount() {
            return discoverDevices.size();
        }

        @Override
        public Object getItem(int position) {
            // TODO Auto-generated method stub
            return discoverDevices.get(position);
        }

        @Override
        public long getItemId(int position) {
            // TODO Auto-generated method stub
            return position;
        }

        @Override
        public View getView(final int position, View convertView,
                ViewGroup parent) {
            TextView tv = null;
            if (convertView != null) {
                tv = (TextView) convertView;
            } else {
                tv = new TextView(context);
                AbsListView.LayoutParams params = new AbsListView.LayoutParams(
                        AbsListView.LayoutParams.MATCH_PARENT,
                        AbsListView.LayoutParams.WRAP_CONTENT);
                tv.setLayoutParams(params);
            }
            tv.setTag(discoverDevices.get(position));
            tv.setText(discoverDevices.get(position).getName());
            tv.setFocusable(false);
            tv.setFocusableInTouchMode(false);
            // tv.setOnClickListener(new OnClickListener() {
            //
            // @Override
            // public void onClick(View v) {
            // // 项点击时，进行连接
            // bluetoothClient.connect(discoverDevices.get(position));
            // dlgSearch.dismiss();
            // dlgSearch = null;
            // }
            // });
            return tv;
        }

    }

    /**
     * 发送
     * 
     * @param view
     */
    public void btn_send(View view) {
        String msg = et_msg.getText().toString().trim();
        send(msg);
    }

    /**
     * 发送消息到客户端
     * 
     * @param msg
     */
    private void send(String msg) {
        bluetoothClient.send(msg);
        synchronized (msgs) {
            msgs.add("客户端发送：" + msg);
        }
    }
}

　　　　　　3.3.2 客户端页面layout　　

　　　　

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_margin="5dp"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginBottom="5dp"
        android:orientation="horizontal" >

        <EditText
            android:id="@+id/et_msg"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="3"
            android:hint="chatMessage" />

        <Button
            android:layout_width="20dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:onClick="btn_send"
            android:text="send" />
    </LinearLayout>

    <ListView
        android:id="@+id/lv_msg"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
    </ListView>

</LinearLayout>

　　　　　　3.3.3 客户端蓝牙管理类

　　　　

package org.fiu.bluetoothdemos;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import android.annotation.SuppressLint;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.util.Log;

/**
 * 蓝牙服务器
 * 
 * @author weizh
 * 
 */
public class BluetoothClient {
    private static final String TAG = "BluetoothClient";
    /**
     * 消息集合
     */
    private List<String> listMsg = new ArrayList<String>();
    /**
     * 是否工作中
     */
    private boolean isWorking = false;
    /**
     * spp well-known UUID
     */
    public final UUID uuid = UUID
            .fromString("00001101-0000-1000-8000-00805F9B34FB");
    /**
     * 客户端socket
     */
    private BluetoothSocket mClientSocket;

    public BluetoothClient() {

    }

    /**
     * 开启服务器
     */
    public void start() {
        startDiscovery();
    }

    /**
     * 开始检查设备
     */
    private void startDiscovery() {
        if (!BluetoothUtils.checkBluetoothExists()) {
            throw new RuntimeException("bluetooth module not exists.");
        }
        // 打开设备
        if (!BluetoothUtils.openBluetoothDevice()) {
            return;
        }
        // 开始扫描设备
        BluetoothAdapter defaultAdapter = BluetoothAdapter.getDefaultAdapter();
        defaultAdapter.startDiscovery();
    }

    OutputStream outputStream;
    private InputStream inputStream;

    /**
     * 停止
     */
    public void stop() {
        isWorking = false;
        if (mClientSocket != null) {
            try {
                mClientSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                mClientSocket = null;
            }
        }
    }

    /**
     * 客户端socket工作类
     * 
     * @author weizh
     * 
     */
    private class ClientWorkingThread extends Thread {

        public ClientWorkingThread() {
        }

        @SuppressLint("NewApi")
        @Override
        public void run() {
            try {
                // 从输入流中取出数据，插入消息条中
                byte[] buffer = new byte[1024];
                while (isWorking) {
                    int read = inputStream.read(buffer);
                    if (read != -1) {
                        // 有内容
                        // 判断是否取得的消息填充满了buffer，未到字符串结尾符；如果不是，证明读取到了一条信息，并且信息是完整的，这个完整的前提是不能粘包，不粘包可以使用flush进行处理。
                        StringBuilder sb = new StringBuilder();
                        if (read < buffer.length) {
                            String msg = new String(buffer, 0, read);
                            sb.append(msg);
                        } else {
                            byte[] tempBytes = new byte[1024 * 4];
                            while (read == buffer.length
                                    && buffer[read - 1] != 0x7f) {
                                read = inputStream.read(buffer);
                            }
                            String msg = new String(buffer, 0, read);
                            sb.append(msg);
                        }
                        Log.i(TAG, "客户端收到：" + sb.toString());
                        synchronized (listMsg) {
                            listMsg.add("服务器发送：" + sb.toString());
                        }
                    }
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 工作完毕，关闭socket
            try {
                mClientSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }

    /**
     * 返回listMsg
     * 
     * @return
     */
    public List<String> getMsgs() {
        synchronized (listMsg) {
            return listMsg;
        }
    }

    /**
     * 发送消息
     * 
     * @param msg
     */
    public void send(final String msg) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                if (mClientSocket != null) {
                    try {
                        if (outputStream != null) {
                            byte[] bytes = msg.getBytes();
                            outputStream.write(bytes);
                            outputStream.flush();
                        }
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }).start();

    }

    /**
     * 进行连接
     * 
     * @param device
     */
    @SuppressLint("NewApi")
    public void connect(final BluetoothDevice device) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    mClientSocket = device
                            .createRfcommSocketToServiceRecord(BluetoothServer.MY_UUID);
                    mClientSocket.connect();
                    isWorking = true;
                    try {
                        outputStream = mClientSocket.getOutputStream();
                        inputStream = mClientSocket.getInputStream();
                    } catch (IOException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                    new ClientWorkingThread().start();

                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    Log.i(TAG, "连接失败");
                }
            }
        }).start();
    }

}

　　　　　　3.4 其它用到的布局和类

　　　　　　　　3.4.1 dialog_search

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="5dp"
        android:orientation="horizontal" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentLeft="true"
            android:text="正在搜索……" />

        <ProgressBar
            android:id="@+id/progressBar1"
            style="?android:attr/progressBarStyleSmall"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentRight="true" />
    </RelativeLayout>

    <View
        android:layout_width="match_parent"
        android:layout_height="2dp"
        android:layout_marginBottom="2dp"
        android:layout_marginTop="2dp"
        android:background="@android:color/darker_gray" />

    <ListView
        android:id="@+id/lv_devices"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_margin="5dp" >
    </ListView>

</LinearLayout>

3.5 BluetoothUtils.java：蓝牙帮助类

package org.fiu.bluetoothdemos;

import java.util.Locale;
import java.util.Set;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;

/**
 * 蓝牙帮助模块
 * 
 * @author c
 * 
 */
public class BluetoothUtils {
    /**
     * 检查蓝牙模块是否存在
     * 
     * @return
     */
    public static boolean checkBluetoothExists() {
        BluetoothAdapter bluetoothAdapter = BluetoothAdapter
                .getDefaultAdapter();
        if (bluetoothAdapter != null) {
            return true;
        }
        return false;
    }

    /**
     * 打开蓝牙模块
     * 
     * @return
     */
    public static boolean openBluetoothDevice() {
        BluetoothAdapter bluetoothAdapter = BluetoothAdapter
                .getDefaultAdapter();
        if (!bluetoothAdapter.isEnabled()) {
            if (bluetoothAdapter.enable()) {
                return true;
            }
        } else {
            return true;
        }
        return false;
    }

    /**
     * 开启蓝牙模块扫描
     * 
     * @return
     */
    public static void startDiscovery() {
        BluetoothAdapter bluetoothAdapter = BluetoothAdapter
                .getDefaultAdapter();
        if (!bluetoothAdapter.isDiscovering()) {
            bluetoothAdapter.startDiscovery();
        }
    }

    /**
     * Convert hex string to byte[] 把为字符串转化为字节数组
     * 
     * @param hexString
     *            the hex string
     * @return byte[]
     */
    public static byte[] hexStringToBytes(String hexString) {
        hexString = hexString.replaceAll(" ", "");
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase(Locale.getDefault());
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }

    /**
     * Convert char to byte
     * 
     * @param c
     *            char
     * @return byte
     */
    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }

    /**
     * 获取已配对的蓝牙设备集合
     * 
     * @return
     */
    public static Set<BluetoothDevice> getBondedDevices() {
        return BluetoothAdapter.getDefaultAdapter().getBondedDevices();
    }

    /**
     * 检测当前device是否已经bonded过
     * 
     * @param device
     * @return
     */
    public static boolean isBonded(BluetoothDevice device) {
        if (checkBluetoothExists()) {
            // 连接之前先确定是否已经bond过，配对过
            Set<BluetoothDevice> bondedDevices = BluetoothAdapter
                    .getDefaultAdapter().getBondedDevices();
            if (bondedDevices != null) {
                for (BluetoothDevice bluetoothDevice : bondedDevices) {
                    if (bluetoothDevice.getAddress()
                            .equals(device.getAddress())) {
                        // 该device已经bond过
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

3.6 AndroidManifest.xml：别忘了添加蓝牙权限

　　　　

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.fiu.bluetoothchatdemos"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="21" />

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

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="org.fiu.bluetoothdemos.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="org.fiu.bluetoothdemos.ServerActivity" />
        <activity android:name="org.fiu.bluetoothdemos.ClientActivity" />
    </application>

</manifest>

　　　　好了，此文章及至这里，如果有问题，欢迎留言。

　　　　整包资源：http://download.csdn.net/detail/weizhhf/9736822