蓝牙开发

最新推荐文章于 2023-03-28 09:56:27 发布

dasuhsa

最新推荐文章于 2023-03-28 09:56:27 发布

阅读量1.1k

点赞数

关于WIFI就不多介绍啦，直接来个段子吧。

问：“WiFi对人体有伤害么？”

答:“不清楚，反正没有WiFi我就浑身不舒服。

比较重要的一点就是WifiManager wm=(WifiManager)Android_Wifi.this.getSystemService(Context.WIFI_SERVICE);

关闭打开搜索都可以通过调用wm的相关方法实现。可能要开发wifi万能钥匙那一类的程序才用到这个吧，普通应用程序主要就识别是wifi网络还是移动网络。不多讲

代码参考博客：http://blog.csdn.net/sbvfhp/article/details/7007090

重点蓝牙：

　一：什么是蓝牙

　　　　1：Bluetooth是目前使用最广泛的无线通讯协议，近距离无线通讯的标准。传说瑞典有个国王特别爱吃蓝莓导致自己的牙齿天天都是蓝色的，在他执政期间这位国王非常善于交际，能说会到，和邻国的搞得关系非常好，这个Bluetooth的发明者觉得蓝牙它的作用就是在近距离沟通周围的设备，跟这个国王很类似，于是起名叫蓝牙。

　　　　2：主要针对短距离设备通讯（10米）

　　　　3：无线耳机，无线鼠标，无线键盘

蓝牙标志

　二：蓝牙工作流程图

　　　　首先两个设备上都要有蓝牙设备或者专业一点叫蓝牙适配器，以手机和电脑为例我画了如下流程图。其次在手机上进行扫描，扫描周围蓝蓝牙设备，先找到手机附近的电脑，然后给它发出一个信号需要进行蓝牙的配对，再次返回一个信号说明手机和电脑已经配对成功了，最后配对成功后可以进行文件传输了。这是一个最基本的一个流程。

　　三：蓝牙开发相关类

　　在Android手机中开发蓝牙程序时，离不开几个类：

BluetoothSocket：close() connect() getInputStream()......

BluetoothServerSocket : accept()

BlutoothAdapter :代表本地的蓝牙适配器设备，通过此类可以让用户能执行基本的蓝牙任务。

BluetoothClass: 代表了一个描述设备通用特性和功能的蓝牙类。比如一个蓝牙类会指定如电话、计算机或耳机的通用设备类型。

BluetoothClass.Service:

BluetoothClass.Device：

BluetoothClass.Device.Major: 定义了主要设备类的常量

其中与蓝牙相关的最重要的两个API

　　　1：BuletoothAdapter

　　这个类的对象代表了本地的蓝牙适配器，相当于蓝牙工作流程图中的手机里的蓝牙适配器，也就是说比如这个应用程序是运行在手机上，那么手机上的蓝牙适配器就是本地蓝牙适配器。

　　　2：BuletoothDevice

　　　这个类的对象代表了远程的蓝牙设备，相当于蓝牙工作流程图中的计算机里的蓝牙适配器，也就是说比如这个应用程序是运行在手机上，那么BuletoothDevice代表了你要连接的远程的那个设备上面的蓝牙适配器。

四：蓝牙开发步骤：

此部分转载于 http://zhouyunan2010.iteye.com/blog/1186021

从查找蓝牙设备到能够相互通信要经过几个基本步骤(本机做为服务器)：
1.设置权限
在manifest中配置

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

2.启动蓝牙
首先要查看本机是否支持蓝牙，获取BluetoothAdapter蓝牙适配器对象

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if(mBluetoothAdapter == null){
        //表明此手机不支持蓝牙
        return;
}
if(!mBluetoothAdapter.isEnabled()){    //蓝牙未开启，则开启蓝牙
            Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enableIntent, REQUEST_ENABLE_BT);
}
//......
public void onActivityResult(int requestCode, int resultCode, Intent data){
       if(requestCode == REQUEST_ENABLE_BT){
              if(requestCode == RESULT_OK){
                   //蓝牙已经开启 
              }
       }
}

3。发现蓝牙设备
这里可以细分为几个方面
(1)使本机蓝牙处于可见(即处于易被搜索到状态)，便于其他设备发现本机蓝牙

//使本机蓝牙在300秒内可被搜索
private void ensureDiscoverable() {
        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);
        }
}

(2)查找已经配对的蓝牙设备，即以前已经配对过的设备

        Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
        if (pairedDevices.size() > 0) {
            findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
            for (BluetoothDevice device : pairedDevices) {
                //device.getName() +" "+ device.getAddress());
            }
        } else {
            mPairedDevicesArrayAdapter.add("没有找到已匹对的设备");
        }

(3)通过mBluetoothAdapter.startDiscovery();搜索设备，要获得此搜索的结果需要注册
一个BroadcastReceiver来获取。先注册再获取信息，然后处理

//注册，当一个设备被发现时调用onReceive
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
        this.registerReceiver(mReceiver, filter);

//当搜索结束后调用onReceive
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        this.registerReceiver(mReceiver, filter);
//.......
private 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);
                  // 已经配对的则跳过
                 if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
                      mNewDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());  //保存设备地址与名字
                 }
            }else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {  //搜索结束
                if (mNewDevicesArrayAdapter.getCount() == 0) {
                    mNewDevicesArrayAdapter.add("没有搜索到设备");
                }
            }

        }
};

4.建立连接
查找到设备后，则需要建立本机与其他设备之间的连接。
一般用本机搜索其他蓝牙设备时，本机可以作为一个服务端，接收其他设备的连接。
启动一个服务器端的线程，死循环等待客户端的连接，这与ServerSocket极为相似。
这个线程在准备连接之前启动

 
   
 View Code 

5.交换数据

搜索到设备后可以获取设备的地址，通过此地址获取一个BluetoothDeviced对象，可以看做客户端，通过此对象device.createRfcommSocketToServiceRecord(MY_UUID);同一个UUID可与服务器建立连接获取另一个socket对象，由此服务端与客户端各有一个socket对象，此时
他们可以互相交换数据了。
创立客户端socket可建立线程

 
   
 View Code 

6.建立数据通信线程，进行读取数据

//建立连接后，进行数据通信的线程
    private class ConnectedThread extends Thread{
        private BluetoothSocket socket;
        private InputStream inStream;
        private OutputStream outStream;
        
        public ConnectedThread(BluetoothSocket socket){
            
            this.socket = socket;
            try {
                //获得输入输出流
                inStream = socket.getInputStream();
                outStream = socket.getOutputStream();
            } catch (IOException e) {
                Log.e("app", "temp sockets not created", e);
            }
        }
        
        public void run(){
            byte[] buff = new byte[1024];
            int len=0;
            //读数据需不断监听，写不需要
            while(true){
                try {
                    len = inStream.read(buff);
                    //把读取到的数据发送给UI进行显示
                    Message msg = handler.obtainMessage(BluetoothChat.MESSAGE_READ,
                            len, -1, buff);
                    msg.sendToTarget();
                } catch (IOException e) {
                    Log.e("app", "disconnected", e);
                    connectionLost();    //失去连接
                    start();    //重新启动服务器
                    break;
                }
            }
        }
        
        
        public void write(byte[] buffer) {
            try {
                outStream.write(buffer);

                // Share the sent message back to the UI Activity
                handler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                Log.e("app", "Exception during write", e);
            }
        }

        public void cancel() {
            try {
                socket.close();
            } catch (IOException e) {
                Log.e("app", "close() of connect socket failed", e);
            }
        }
    }

到这里，蓝牙通信的基本操作已经全部完成。

五：蓝牙聊天室开发

源码参考 http://download.csdn.net/detail/mr_raptor/8033951#comment

此demo界面优美，实现基本功能，但不能保存聊天记录，黑屏自动断线，在此基础做出修改。

保存和恢复activity的状态数据

自己修改说明：

ChatActivity加入再按一次退出功能，更加人性化。加入消息记录功能。

消息记录实现概述：当在服务中开始收发发送消息时，就通过mActivityHandler通知ChatActivity，完成数据库读写操作。

ChatActivity.java:

 
    
  
package cn.com.farsgiht.bluetoothdemo;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import android.app.Activity;
import android.app.AlertDialog;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.style.ImageSpan;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.GridView;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.LinearLayout.LayoutParams;
import android.widget.ListView;
import android.widget.SimpleAdapter;
import android.widget.Toast;
import cn.com.farsgiht.bluetoothdemo.UI.ChatListViewAdapter;
import cn.com.farsgiht.bluetoothdemo.UI.DrawerHScrollView;
import cn.com.farsgiht.bluetoothdemo.sound.SoundEffect;
import cn.com.farsgiht.bluetoothdemo.task.Task;
import cn.com.farsgiht.bluetoothdemo.task.TaskService;
import cn.com.farsgiht.bluetoothdemo.utils.Utils;

public class ChatActivity extends Activity implements View.OnClickListener{
   private final String TAG = "ChatActivity";
   public static int sAliveCount = 0;
   public static final String EXTRA_MESSAGER = "cn.com.farsgiht.bluetoothdemo.BUNDLE";
   public static final String DEVICE_NAME = "device_name";
   // 蓝牙状态变量
   private static int sBTState = -1;
   
   private final int REQUES_BT_ENABLE_CODE = 123;
   private final int REQUES_SELECT_BT_CODE = 222;
   
   private ListView mList;
   private EditText mInput;
   private Button mSendBtn;
   private ImageView mEmoButton;
   private GridView mGridView;
   private boolean isUpdate = false;
   private BluetoothDevice mRemoteDevice;
   
   private LinearLayout mRootLayout, mChatLayout;
   
   private View mEmoView;
   private boolean isShowEmo = false;
   private boolean isHaspressed = false;
   private int mScrollHeight;
   
   private DrawerHScrollView mScrollView;
   private ChatListViewAdapter mAdapter2;
   private ArrayList<HashMap<String, Object>> mChatContent2 = new ArrayList<HashMap<String, Object>>();
   private BluetoothAdapter mBluetoothAdapter;
   
   private ArrayList<HashMap<String, Object>> mEmoList = new ArrayList<HashMap<String, Object>>();
    // 已连接设备的名字
   private String mConnectedDeviceName = null;
   
   private Handler mHandler = new Handler(){
       @Override
       public void handleMessage(Message msg) {
           //设置聊天信息的时间
           SimpleDateFormat df0 = new SimpleDateFormat("MM-dd HH:mm:ss");
           String pdate=df0.format(System.currentTimeMillis()).toString();            
           switch(msg.what){
           case -1:
               showToast("没有连接其它用户，点击\"Menu\"扫描并选择周国用户");
               SoundEffect.getInstance(ChatActivity.this).play(SoundEffect.SOUND_ERR);
               break;
           case Task.TASK_SEND_MSG:
//               showToast(msg.obj.toString());
              String writeMessage = msg.obj.toString();
              if(writeMessage!=null && isHaspressed)
              {
                  //将发送的信息插入到数据库
                  ContentValues values=new ContentValues();
                  values.put("name", "我");
                  values.put("pdate",pdate);
                  values.put("informations", writeMessage);
                  //创建数据库
                  DatabaseHelper insertdbHelper=new DatabaseHelper(ChatActivity.this,"zhsf_db");
                  SQLiteDatabase insertdb=insertdbHelper.getWritableDatabase();
                  insertdb.insert("info", null, values);
              }
               if(sAliveCount <= 0){
                   Utils.notifyMessage(ChatActivity.this, msg.obj.toString(), ChatActivity.this);
               }              
               break;    
           case Task.TASK_RECV_MSG:    
              String readMessage =((HashMap<String,Object>) msg.obj).get(ChatListViewAdapter.KEY_TEXT).toString();
              mConnectedDeviceName = ((HashMap<String,Object>) msg.obj).get(ChatListViewAdapter.KEY_NAME).toString(); 
              if(readMessage!=null)
              {
                  //将接受的信息插入到数据库
                  ContentValues values2=new ContentValues();
                  values2.put("name", mConnectedDeviceName);
                  values2.put("pdate",pdate);
                  values2.put("informations", readMessage);
                  DatabaseHelper insertdbHelper2=new DatabaseHelper(ChatActivity.this,"zhsf_db");
                  SQLiteDatabase insertdb2=insertdbHelper2.getWritableDatabase();
                  insertdb2.insert("info", null, values2);         
              }
               
               if(msg.obj == null)
                   return;
               if(msg.obj instanceof HashMap<?, ?>){
                   showTargetMessage((HashMap<String, Object>) msg.obj);                    
               }        
               if(sAliveCount <= 0){
                   Utils.notifyMessage(ChatActivity.this, "您有未读取消息", ChatActivity.this);
               }                              
               break;
           case Task.TASK_GET_REMOTE_STATE:
               setTitle((String)msg.obj);
               if(sAliveCount <= 0){
                   if(isBTStateChanged(msg.arg1) && msg.arg1 != TaskService.BT_STAT_WAIT)
                       Utils.notifyMessage(ChatActivity.this, (String)msg.obj, ChatActivity.this);
               }
               break;
   
           }
       }
   };
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_chat);
       
       // 获得蓝牙管理器
       mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); 
       if (mBluetoothAdapter == null) {
           Log.e(TAG, "Your device is not support Bluetooth!");
           Toast.makeText(this, "该设备没有蓝牙设备", Toast.LENGTH_LONG).show();
           return;
       }
       
       mRootLayout = (LinearLayout) findViewById(R.id.root);
       mChatLayout = (LinearLayout) findViewById(R.id.topPanel);
       mList = (ListView) findViewById(R.id.listView1);
   
       mAdapter2 = new ChatListViewAdapter(this, mChatContent2);
       
       mList.setAdapter(mAdapter2);

       // 初始化表情
       mEmoView = initEmoView();
       
       mInput = (EditText) findViewById(R.id.inputEdit);
       mInput.setOnClickListener(new android.view.View.OnClickListener() {
           @Override
           public void onClick(View v) {
               // 点击输入框后，隐藏表情，显示输入法
               InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
               imm.showSoftInput(mInput, 0);
               showEmoPanel(false);
           }
       });
       
       mSendBtn = (Button) findViewById(R.id.sendBtn);
       mEmoButton = (ImageView) findViewById(R.id.emotionBtn);
       
       mSendBtn.setOnClickListener(this);
       mEmoButton.setOnClickListener(this);
       
       //---------------------------------------------------------------------
       // 打开蓝牙设备
       if (!mBluetoothAdapter.isEnabled()) {
           Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
           startActivityForResult(enableBtIntent, REQUES_BT_ENABLE_CODE); 
       }else{
           // 默认设备作为服务端
           startServiceAsServer();
       }
       //---------------------------------------------------------------------
   }
   
   private View initEmoView(){
       if(mEmoView == null){
           LayoutInflater inflater = getLayoutInflater();
           mEmoView = inflater.inflate(R.layout.emo_layout, null);
           
           mScrollView = (DrawerHScrollView) mEmoView.findViewById(R.id.scrollView);
           mGridView = (GridView) mEmoView.findViewById(R.id.gridView);
           mGridView.setOnItemClickListener(new OnItemClickListener() {
               @Override
               public void onItemClick(AdapterView<?> parent, View view,
                       int position, long id) {
                   // 在android中要显示图片信息，必须使用Bitmap位图的对象来装载  
                   Bitmap bitmap = BitmapFactory.decodeResource(getResources(), (Integer) mEmoList.get(position).get("img")); 
                   ImageSpan imageSpan = new ImageSpan(ChatActivity.this, bitmap);  
                   SpannableString spannableString = new SpannableString((String) mEmoList.get(position).get("text"));//face就是图片的前缀名  
                   spannableString.setSpan(imageSpan, 0, 8,Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);  
                   mInput.append(spannableString);
                   System.out.println("mInput:"+mInput.getText());
               }
           });

           mScrollHeight = setScrollGridView(mScrollView, mGridView, 3);
           System.out.println("mScrollHeight:" + mScrollHeight);
       }
       return mEmoView;
   }
   

   
   private void startServiceAsServer(){
       TaskService.start(this, mHandler);
       TaskService.newTask(new Task(mHandler, Task.TASK_START_ACCEPT, null));
       SoundEffect.getInstance(this).play(SoundEffect.SOUND_PLAY);
   }
   
   @Override
   protected void onResume() {
       sAliveCount++;
       super.onResume();
   }

   @Override
   protected void onPause() {
       sAliveCount--;
       super.onPause();
   }
   
   @Override
   protected void onDestroy() {
       super.onDestroy();
       // 关闭蓝牙
       if(mBluetoothAdapter.isEnabled())
           mBluetoothAdapter.disable();
       // 停止服务
       TaskService.stop(this);
   }
   
   
   @Override
   public void onClick(View v) {
       if(v == mSendBtn){
           String msg = mInput.getText().toString().trim();
           TaskService.newTask(new Task(mHandler, Task.TASK_GET_REMOTE_STATE, null));//通过点击按钮触发相应线程的启动，比较巧妙，值得学习
           if(msg.length() == 0){
               showToast("聊天内容为空");
               SoundEffect.getInstance(ChatActivity.this).play(SoundEffect.SOUND_ERR);
               return;
           }
           
           //------ DEUBG ------ 
           TaskService.newTask(new Task(mHandler, Task.TASK_SEND_MSG, new Object[]{msg}));
           showOwnMessage(msg);//立马显示自己发送的消息，所以在handler里面就没有再做处理
           isHaspressed = true;//数据库可以开始记录消息啦
           mInput.setText("");
       }else if(v == mEmoButton){
           System.out.println("Emo btn clicked");
           // 关闭输入法
           InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
           imm.hideSoftInputFromWindow(mInput.getWindowToken(),0);
           if(isShowEmo){
               showEmoPanel(false);
           }else{
               showEmoPanel(true);
           }
       }
   }
   
   private void showEmoPanel(boolean show){
       if(show && !isShowEmo){
           mEmoView.setVisibility(View.VISIBLE);
           mEmoButton.setImageResource(R.drawable.emo_collapse);
           ViewGroup.LayoutParams params = mChatLayout.getLayoutParams();
           params.height = mChatLayout.getHeight() - mScrollHeight;
           mChatLayout.setLayoutParams(params);
           isShowEmo = true;
       }else if(!show && isShowEmo){
           mEmoView.setVisibility(View.GONE);
           mEmoButton.setImageResource(R.drawable.emo_bkg);
           ViewGroup.LayoutParams params = mChatLayout.getLayoutParams();
           params.height = mChatLayout.getHeight() + mScrollHeight;
           mChatLayout.setLayoutParams(params);
           isShowEmo = false;
       }
       if(!isUpdate && show){
           LinearLayout.LayoutParams para = new LinearLayout.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT);
           mRootLayout.addView(mEmoView, para);
           isUpdate = true;
       }
   }
   
   
   
   private boolean isBTStateChanged(int now){
       if(sBTState != now){
           sBTState = now;
           return true;
       }else{
           return false;
       }
   }
   
   /**
    * 显示对方信息
    * @param data
    */
   private void showTargetMessage(HashMap<String, Object> data){
       SimpleDateFormat df1 = new SimpleDateFormat("E MM月dd日   HH:mm ");
       data.put(ChatListViewAdapter.KEY_DATE, df1.format(System.currentTimeMillis()).toString());
       data.put(ChatListViewAdapter.KEY_SHOW_MSG, true);
       mChatContent2.add(data);
       mAdapter2.notifyDataSetChanged();
       SoundEffect.getInstance(ChatActivity.this).play(SoundEffect.SOUND_RECV);
   }
   
   /**
    * 显示自己信息
    * @param data
    */
   private void showOwnMessage(String msg){
       HashMap<String, Object> map = new HashMap<String, Object>();
       map.put(ChatListViewAdapter.KEY_ROLE, ChatListViewAdapter.ROLE_OWN);//哪个角色的消息
       map.put(ChatListViewAdapter.KEY_NAME, mBluetoothAdapter.getName());
       map.put(ChatListViewAdapter.KEY_TEXT, msg);
       SimpleDateFormat df2 = new SimpleDateFormat("E MM月dd日  HH:mm ");
       map.put(ChatListViewAdapter.KEY_DATE, df2.format(System.currentTimeMillis()).toString());
       map.put(ChatListViewAdapter.KEY_SHOW_MSG, true);
       mChatContent2.add(map);
       mAdapter2.notifyDataSetChanged();
       SoundEffect.getInstance(ChatActivity.this).play(SoundEffect.SOUND_SEND);
   }

   @Override
   public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.option_menu, menu);
        return true;
   }

   @Override
   public boolean onOptionsItemSelected(MenuItem item) {
         switch (item.getItemId()) {
           case R.id.scan:
               startActivityForResult(new Intent(this, SelectDevice.class), REQUES_SELECT_BT_CODE);
               break;
           case R.id.discoverable:
               // 调用设置用户名方法
               AlertDialog.Builder dlg = new AlertDialog.Builder(this);
               final EditText devNameEdit = new EditText(this);
               dlg.setView(devNameEdit);
               dlg.setTitle("请输入用户名");
               dlg.setPositiveButton("设置", new OnClickListener() {
                   public void onClick(DialogInterface dialog, int which) {
                       if(devNameEdit.getText().toString().length() != 0)
                           mBluetoothAdapter.setName(devNameEdit.getText().toString());
                   }
               });
               dlg.create();
               dlg.show();
               return true;
           case R.id.record:
               Intent recordIntent = new Intent(ChatActivity.this, RecordListActivity.class);
               startActivity(recordIntent);
               return true;
           case R.id.exit:
               Intent aboutIntent = new Intent(ChatActivity.this, DownloadActivity.class);
               startActivity(aboutIntent);
               return true;
           }
           return false;
   }

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
       if(requestCode == REQUES_BT_ENABLE_CODE && resultCode == RESULT_OK){
           startServiceAsServer();
       }else if(requestCode == REQUES_SELECT_BT_CODE && resultCode == RESULT_OK){
           mRemoteDevice = data.getParcelableExtra("DEVICE");
           if(mRemoteDevice == null)
               return;
           TaskService.newTask(new Task(mHandler, Task.TASK_START_CONN_THREAD, new Object[]{mRemoteDevice}));
       }
       super.onActivityResult(requestCode, resultCode, data);
   }
   
   private void showToast(String msg){
       Toast tst = Toast.makeText(this, msg, Toast.LENGTH_SHORT);
       tst.setGravity(Gravity.CENTER | Gravity.TOP, 0, 240);
       tst.show();
   }
   
   
   // 设置表情的多页滚动显示控件
   public int setScrollGridView(DrawerHScrollView scrollView, GridView gridView, 
           int lines) {
       
       DisplayMetrics dm = new DisplayMetrics();
       getWindowManager().getDefaultDisplay().getMetrics(dm); 
       Display display = getWindowManager().getDefaultDisplay();
       System.out.println("Width:" + display.getWidth());
       System.out.println("Height:" + display.getHeight());

       
       int scrollWid = display.getWidth();
       int scrollHei;
       System.out.println("scrollWid:" + scrollWid);
       if (scrollWid <= 0 ){
           Log.d(TAG, "scrollWid or scrollHei is less than 0");
           return 0;
       }
        
         
       float density  = dm.density;      // 屏幕密度（像素比例：0.75/1.0/1.5/2.0）
       
       int readlViewWidht = 56;
       // 图片都放在了Hdpi中，所以计算出图片的像素独立宽度
       int viewWidth = (int) (readlViewWidht * density / 1.5);
       int viewHeight = viewWidth;
       System.out.println("viewWidth:" + viewWidth + " viewHeight:" + viewHeight);
       
       int numColsPage = scrollWid / viewWidth;
       int spaceing = (scrollWid - viewWidth * numColsPage)/(numColsPage);
       System.out.println("Space:" + spaceing);


       SimpleAdapter adapter = getEmoAdapter();
       int pages = adapter.getCount() / (numColsPage * lines);
       
       if (pages * numColsPage * lines < adapter.getCount()){
           pages++;
       }

       System.out.println("pages:" + pages);
       
       scrollHei = lines * viewHeight + spaceing * (lines + 1);
       
       LayoutParams params = new LayoutParams(pages * scrollWid, LayoutParams.WRAP_CONTENT);
       gridView.setLayoutParams(params);
       gridView.setColumnWidth(viewWidth);
       gridView.setHorizontalSpacing(spaceing);
       gridView.setVerticalSpacing(spaceing);
       gridView.setStretchMode(GridView.NO_STRETCH);
       gridView.setNumColumns(numColsPage * pages);

       //adapter = new DrawerListAdapter(this, colWid, colHei);
       //listener = new DrawerItemClickListener();
       gridView.setAdapter(adapter);
       //mGridView.setOnItemClickListener(listener);

       scrollView.setParameters(pages, 0, scrollWid, spaceing);
       //updateDrawerPageLayout(pageNum, 0);
       // 表情区域还要加上分布显示区
       int pageNumHei = (int) (18 * density); 
       return scrollHei + pageNumHei;
   }
   
       
   private SimpleAdapter getEmoAdapter(){
          HashMap<String, Object> map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo001);
          map.put("text", "<emo001>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo002);
          map.put("text", "<emo002>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo003);
          map.put("text", "<emo003>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo004);
          map.put("text", "<emo004>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo005);
          map.put("text", "<emo005>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo006);
          map.put("text", "<emo006>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo007);
          map.put("text", "<emo007>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo008);
          map.put("text", "<emo008>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo009);
          map.put("text", "<emo009>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo010);
          map.put("text", "<emo010>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo011);
          map.put("text", "<emo011>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo012);
          map.put("text", "<emo012>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo013);
          map.put("text", "<emo013>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo014);
          map.put("text", "<emo014>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo015);
          map.put("text", "<emo015>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo016);
          map.put("text", "<emo016>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo017);
          map.put("text", "<emo017>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo018);
          map.put("text", "<emo018>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo019);
          map.put("text", "<emo019>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo020);
          map.put("text", "<emo020>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo021);
          map.put("text", "<emo021>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo022);
          map.put("text", "<emo022>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo023);
          map.put("text", "<emo023>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo024);
          map.put("text", "<emo024>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo025);
          map.put("text", "<emo025>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo026);
          map.put("text", "<emo026>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo027);
          map.put("text", "<emo027>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo028);
          map.put("text", "<emo028>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo029);
          map.put("text", "<emo029>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo030);
          map.put("text", "<emo030>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo031);
          map.put("text", "<emo031>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo032);
          map.put("text", "<emo032>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo033);
          map.put("text", "<emo033>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo034);
          map.put("text", "<emo034>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo035);
          map.put("text", "<emo035>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo036);
          map.put("text", "<emo036>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo037);
          map.put("text", "<emo037>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo038);
          map.put("text", "<emo038>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo039);
          map.put("text", "<emo039>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo040);
          map.put("text", "<emo040>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo041);
          map.put("text", "<emo041>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo042);
          map.put("text", "<emo042>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo043);
          map.put("text", "<emo043>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo044);
          map.put("text", "<emo044>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo045);
          map.put("text", "<emo045>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo046);
          map.put("text", "<emo046>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo047);
          map.put("text", "<emo047>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo048);
          map.put("text", "<emo048>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo049);
          map.put("text", "<emo049>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo050);
          map.put("text", "<emo050>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo051);
          map.put("text", "<emo051>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo052);
          map.put("text", "<emo052>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo053);
          map.put("text", "<emo053>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo054);
          map.put("text", "<emo054>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo055);
          map.put("text", "<emo055>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo056);
          map.put("text", "<emo056>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo057);
          map.put("text", "<emo057>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo058);
          map.put("text", "<emo058>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo059);
          map.put("text", "<emo059>");
          mEmoList.add(map);
          map = new HashMap<String, Object>();
          map.put("img", R.drawable.emo060);
          map.put("text", "<emo060>");
          mEmoList.add(map);
          
          /**
           * 上述添加表情效率高，但是代码太冗余，下面的方式代码简单，但是效率较低
           */
          /*
          HashMap<String, Integer> map;
          for(int i = 0; i < 100; i++){
              map = new HashMap<String, Integer>();
              Field field=R.drawable.class.getDeclaredField("image"+i);  
              int resourceId=Integer.parseInt(field.get(null).toString());
              map.put("img", resourceId);
              mEmoList.add(map);
          }
          */
       return new SimpleAdapter(this, mEmoList, R.layout.grid_view_item, 
                   new String[]{"img"}, new int[]{R.id.imageView});
   }
   
   
   long waitTime = 2000;
   long touchTime = 0;
   @Override
   public boolean onKeyDown(int keyCode, KeyEvent event) {
       if(event.getAction() == KeyEvent.ACTION_DOWN && KeyEvent.KEYCODE_BACK == keyCode) {
           long currentTime = System.currentTimeMillis();
           if((currentTime-touchTime)>=waitTime) {
               Toast.makeText(this, "再按一次退出", Toast.LENGTH_SHORT).show();
               touchTime = currentTime;
           }else {
               finish();
           }
           return true;
       }
       return super.onKeyDown(keyCode, event);
   }
   
} 
    
  

TaskService.java:

 
    
  
package cn.com.farsgiht.bluetoothdemo.task;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.UUID;
import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;
import android.widget.ArrayAdapter;
import android.widget.Toast;
import cn.com.farsgiht.bluetoothdemo.ChatActivity;
import cn.com.farsgiht.bluetoothdemo.UI.ChatListViewAdapter;
import cn.com.farsgiht.bluetoothdemo.protocol.DataProtocol;
import cn.com.farsgiht.bluetoothdemo.protocol.Message;
import cn.com.farsgiht.bluetoothdemo.sound.SoundEffect;

/**
* 任务处理服务
* @author Administrator
*/
public class TaskService extends Service {
   public static final int BT_STAT_WAIT = 0;
   public static final int BT_STAT_CONN = 1;
   public static final int BT_STAT_ONLINE = 2;
   public static final int BT_STAT_UNKNOWN = 3;
   

   public static final String DEVICE_NAME = "device_name";
   
   private final String TAG = "TaskService";
   private TaskThread mThread;

   private BluetoothAdapter mBluetoothAdapter;
   
   private AcceptThread mAcceptThread;
   private ConnectThread mConnectThread;
   private ConnectedThread mCommThread;
   
   private boolean isServerMode = true;

   private static Handler mActivityHandler;

   // 任务队列
   private static ArrayList<Task> mTaskList = new ArrayList<Task>();

   private Handler mServiceHandler = new Handler() {
       @Override
       public void handleMessage(android.os.Message msg) {        
           switch (msg.what) {
           case Task.TASK_GET_REMOTE_STATE:
               android.os.Message activityMsg = mActivityHandler.obtainMessage();
               activityMsg.what = msg.what;
               if (mAcceptThread != null && mAcceptThread.isAlive()) {
                   activityMsg.obj = "等待连接...";
                   activityMsg.arg1 = BT_STAT_WAIT;
               } else if (mCommThread != null && mCommThread.isAlive()) {
                   activityMsg.obj = mCommThread.getRemoteName() + "[在线]";
                   activityMsg.arg1 = BT_STAT_ONLINE;
               } else if (mConnectThread != null && mConnectThread.isAlive()) {
                   SoundEffect.getInstance(TaskService.this).play(3);
                   activityMsg.obj = "正在连接："
                           + mConnectThread.getDevice().getName();
                   activityMsg.arg1 = BT_STAT_CONN;
               } else {
                   activityMsg.obj = "未知状态";
                   activityMsg.arg1 = BT_STAT_UNKNOWN;
                   SoundEffect.getInstance(TaskService.this).play(2);
                   // 重新等待连接
                   mAcceptThread = new AcceptThread();
                   mAcceptThread.start();
                   isServerMode = true;
               }

               mActivityHandler.sendMessage(activityMsg);
               break;
           default:
               break;
           }
           super.handleMessage(msg);
       }
   };
   
   
   
   @Override
   public void onCreate() {
       super.onCreate();
       mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
       if (mBluetoothAdapter == null) {
           Log.e(TAG, "Your device is not support Bluetooth!");
           return;
       }
       mThread = new TaskThread();
       mThread.start();
   }


   public static void start(Context c, Handler handler){
       mActivityHandler = handler;
       Intent intent = new Intent(c, TaskService.class);
       c.startService(intent);
   }
   
   public static void stop(Context c){
       Intent intent = new Intent(c, TaskService.class);
       c.stopService(intent);
   }
   


   public static void newTask(Task target) {
       synchronized (mTaskList) {
           mTaskList.add(target);
       }
   }

   private class TaskThread extends Thread {
       private boolean isRun = true;
       private int mCount = 0;

       public void cancel() {
           isRun = false;
       }

       @Override
       public void run() {
           Task task;
           while (isRun) {

               // 有任务
               if (mTaskList.size() > 0) {
                   synchronized (mTaskList) {
                       // 获得任务
                       task = mTaskList.get(0);
                       doTask(task);
                   }
               } else {
                   try {
                       Thread.sleep(200);
                       mCount++;
                   } catch (InterruptedException e) {
                   }
                   // 每过10秒钟进行一次状态检查
                   if (mCount >= 50) {
                       mCount = 0;
                       // 检查远程设备状态
                       android.os.Message handlerMsg = mServiceHandler
                               .obtainMessage();
                       handlerMsg.what = Task.TASK_GET_REMOTE_STATE;
                       mServiceHandler.sendMessage(handlerMsg);
                   }
               }
           }
       }

   }
//对应三个线程，其中mCommThread是在mConnectThread的run()方法中new出来的
   private void doTask(Task task) {
       switch (task.getTaskID()) {
       case Task.TASK_START_ACCEPT:
           mAcceptThread = new AcceptThread();
           mAcceptThread.start();
           isServerMode = true;
           break;
       case Task.TASK_START_CONN_THREAD:
           if (task.mParams == null || task.mParams.length == 0) {
               break;
           }
           BluetoothDevice remote = (BluetoothDevice) task.mParams[0];
           mConnectThread = new ConnectThread(remote);
           mConnectThread.start();
           isServerMode = false;
           break;
       case Task.TASK_SEND_MSG:
           boolean sucess = false;
           if (mCommThread == null || !mCommThread.isAlive()
                   || task.mParams == null || task.mParams.length == 0) {
               Log.e(TAG, "mCommThread or task.mParams null");
           }else{
               byte[] msg = null;
               try {
                   
                   msg = DataProtocol.packMsg((String) task.mParams[0]);
                   sucess = mCommThread.write(msg);
    
               } catch (UnsupportedEncodingException e) {
                   sucess = false;
               }
           }
           if (!sucess) {
               android.os.Message returnMsg = mActivityHandler.obtainMessage();
               returnMsg.what = Task.TASK_SEND_MSG_FAIL;
               returnMsg.obj = "消息发送失败";
               mActivityHandler.sendMessage(returnMsg);
           }
           break;
       }

       // 移除任务
       mTaskList.remove(task);//每次保证任务列表里面只有一个任务，task = mTaskList.get(0);
   }

   @Override
   public void onDestroy() {
       super.onDestroy();
       mThread.cancel();
   }

   private final String UUID_STR = "00001101-0000-1000-8000-00805F9B34FB";

   /**
    * 等待客户端连接线程
    * 
    * @author Administrator
    */
   private class AcceptThread extends Thread {
       private final BluetoothServerSocket mmServerSocket;
       private boolean isCancel = false;

       public AcceptThread() {
           Log.d(TAG, "AcceptThread");
           BluetoothServerSocket tmp = null;
           try {
               tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(
                       "MT_Chat_Room", UUID.fromString(UUID_STR));
           } catch (IOException e) {
           }
           mmServerSocket = tmp;
       }

       public void run() {
           BluetoothSocket socket = null;
           while (true) {
               try {
                   // 阻塞等待
                   socket = mmServerSocket.accept();
               } catch (IOException e) {
                   if (!isCancel) {
                       try {
                           mmServerSocket.close();
                       } catch (IOException e1) {
                       }
                       mAcceptThread = new AcceptThread();
                       mAcceptThread.start();
                       isServerMode = true;
                   }
                   break;
               }
               if (socket != null) {
                   manageConnectedSocket(socket);
                   try {
                       mmServerSocket.close();
                   } catch (IOException e) {
                   }
                   mAcceptThread = null;
                   break;
               }
           }
       }

       public void cancel() {
           try {
               Log.d(TAG, "AcceptThread canceled");
               isCancel = true;
               isServerMode = false;
               mmServerSocket.close();
               mAcceptThread = null;
               if (mCommThread != null && mCommThread.isAlive()) {
                   mCommThread.cancel();
               }
           } catch (IOException e) {
           }
       }
   }

   /**
    * 作为客户端连接指定的蓝牙设备线程
    * 
    * @author Administrator
    */
   private class ConnectThread extends Thread {
       private final BluetoothSocket mmSocket;
       private final BluetoothDevice mmDevice;

       public ConnectThread(BluetoothDevice device) {

           Log.d(TAG, "ConnectThread");

           if (mAcceptThread != null && mAcceptThread.isAlive()) {
               mAcceptThread.cancel();
           }

           if (mCommThread != null && mCommThread.isAlive()) {
               mCommThread.cancel();
           }

           // Use a temporary object that is later assigned to mmSocket,
           // because mmSocket is final
           BluetoothSocket tmp = null;
           mmDevice = device;
           try {
               tmp = device.createRfcommSocketToServiceRecord(UUID
                       .fromString(UUID_STR));
           } catch (IOException e) {
               Log.d(TAG, "createRfcommSocketToServiceRecord error!");
           }

           mmSocket = tmp;
       }

       public BluetoothDevice getDevice() {
           return mmDevice;
       }

       public void run() {
           // Cancel discovery because it will slow down the connection
           mBluetoothAdapter.cancelDiscovery();
           try {
               // Connect the device through the socket. This will block
               // until it succeeds or throws an exception
               mmSocket.connect();
           } catch (IOException connectException) {
               // Unable to connect; close the socket and get out
               Log.e(TAG, "Connect server failed");
               try {
                   mmSocket.close();
               } catch (IOException closeException) {
               }
               mAcceptThread = new AcceptThread();
               mAcceptThread.start();
               isServerMode = true;
               return;
           } // Do work to manage the connection (in a separate thread)
           manageConnectedSocket(mmSocket);
       }

       public void cancel() {
           try {
               mmSocket.close();
           } catch (IOException e) {
           }
           mConnectThread = null;
       }
   }

   private void manageConnectedSocket(BluetoothSocket socket) {
       // 启动子线程来维持连接
       mCommThread = new ConnectedThread(socket);
       mCommThread.start();
   }

   private class ConnectedThread extends Thread {
       private final BluetoothSocket mmSocket;
       private final InputStream mmInStream;
       private final OutputStream mmOutStream;
       private BufferedOutputStream mmBos;
       private byte[] buffer;

       public ConnectedThread(BluetoothSocket socket) {
           Log.d(TAG, "ConnectedThread");
           mmSocket = socket;
           InputStream tmpIn = null;
           OutputStream tmpOut = null;
           try {
               tmpIn = socket.getInputStream();
               tmpOut = socket.getOutputStream();
           } catch (IOException e) {
           }
           mmInStream = tmpIn;
           mmOutStream = tmpOut;
           mmBos = new BufferedOutputStream(mmOutStream);
       }

       public OutputStream getOutputStream() {
           return mmOutStream;
       }

       public boolean write(byte[] msg) {
           if (msg == null)
               return false;
           try {
               mmBos.write(msg);
               mmBos.flush();
               
               mActivityHandler.obtainMessage(Task.TASK_SEND_MSG, -1, -1, new String(msg)).sendToTarget();
               System.out.println("Write:" + msg);
           } catch (IOException e) {
               return false;
           }
           return true;
       }

       public String getRemoteName() {
           return mmSocket.getRemoteDevice().getName();
       }

       
       
       
       public void cancel() {
           try {
               mmSocket.close();
           } catch (IOException e) {
           }
           mCommThread = null;
       }

       public void run() {
           try {
               write(DataProtocol.packMsg(mBluetoothAdapter.getName()
                       + "已经上线\n"));//获取本地蓝牙适配器的蓝牙名称，这一条消息默认发送出去啦，
                                     //但消息记录里面不应该有这条消息，消息记录里面记录按过发送键的消息
           } catch (UnsupportedEncodingException e2) {
           }
           int size;
           Message msg;
           android.os.Message handlerMsg;
           buffer = new byte[1024];

           BufferedInputStream bis = new BufferedInputStream(mmInStream);
           // BufferedReader br = new BufferedReader(new
           // InputStreamReader(mmInStream));
           HashMap<String, Object> data;
           while (true) {
               try {
                   size = bis.read(buffer);
                   msg = DataProtocol.unpackData(buffer);
                   if (msg == null)
                       continue;

                   if (mActivityHandler == null) {
                       return;
                   }

                   msg.remoteDevName = mmSocket.getRemoteDevice().getName();//得到对方设备的名字
                   if (msg.type == DataProtocol.TYPE_FILE) {
                       // 文件接收处理忽略

                   } else if (msg.type == DataProtocol.TYPE_MSG) {
                       data = new HashMap<String, Object>();
                       System.out.println("Read data.");
                       data.put(ChatListViewAdapter.KEY_ROLE,
                               ChatListViewAdapter.ROLE_TARGET);
                       data.put(ChatListViewAdapter.KEY_NAME,
                               msg.remoteDevName);
                       data.put(ChatListViewAdapter.KEY_TEXT, msg.msg);
                       
                       // 通过Activity更新到UI上
                       handlerMsg = mActivityHandler.obtainMessage();
                       handlerMsg.what = Task.TASK_RECV_MSG;
                       handlerMsg.obj = data;
                       mActivityHandler.sendMessage(handlerMsg);
                   }
               } catch (IOException e) {
                   try {
                       mmSocket.close();
                   } catch (IOException e1) {
                   }
                   mCommThread = null;
                   if (isServerMode) {
                       // 检查远程设备状态
                       handlerMsg = mServiceHandler.obtainMessage();
                       handlerMsg.what = Task.TASK_GET_REMOTE_STATE;
                       mServiceHandler.sendMessage(handlerMsg);
                       SoundEffect.getInstance(TaskService.this).play(2);
                       mAcceptThread = new AcceptThread();
                       mAcceptThread.start();
                   }
                   break;
               }
           }
       }
   }

   // ================================================================

   @Override
   public IBinder onBind(Intent intent) {
       // TODO Auto-generated method stub
       return null;
   }

} 
    
  