十三、BluetoothChat之BluetoothChat.java

最新推荐文章于 2022-03-26 11:49:17 发布
最新推荐文章于 2022-03-26 11:49:17 发布
阅读量3.3k 收藏 4
点赞数
分类专栏： wifi、bluetoth、zigbee
本文深入解析并实现了一个蓝牙聊天程序，详细介绍了界面布局、蓝牙适配器获取、服务设置、消息发送与接收等关键步骤，同时展示了如何通过XML布局文件与事件监听实现用户交互。此外，文章还探讨了菜单的创建与处理，以及如何在不同场景下调整蓝牙设备的可见性和连接状态。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

　

参考：

http://blog.youkuaiyun.com/wyzxk888/article/details/7543364

http://blog.chinaunix.net/uid-7552018-id-173419.html

 

BluetoothChat.java

例程的主 Activity 。

          BluetoothChat：

                主界面，

                显示聊天信息BluetoothChatService：

                里面有3个主要线程类：

                               AcceptThread：蓝牙服务端socket监听线程.。

                               ConnectThread：蓝牙socket连接线程。

                               ConnectedThread：连接后的通信线程DeviceListActivity：

               蓝牙扫描选择界面，负责传回选择连接的设备BluetoothChat：

              定义了很多常量，用于处理消息和请求：

1、BluetoothChat的成员变量

其中Debugging部分则将用于我们在调试程序时通过log打印日志用，其他部分我们都加入了注释，需要说明的是BluetoothChatService ，它是我们自己定义的一个用来管理蓝牙的端口监听，链接，管理聊天的程序，后面我们会介绍。在这里需要说明一点，这些代码都出自google的员工之手，大家在学习时，可以借鉴很多代码编写的技巧和风格，这都将对我们有非常大的帮助。

 

 2、onCreate（）

   1、main及自定义title布局

1、onCreate函数中对窗口进行了设置，窗口风格设置为自定义风格，并且指定了自定义title布局为custom_title.xml

// Set up the window layout
        requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
        setContentView(R.layout.main);
        getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title);

 1、该布局将title设置为一个相对布局RelativeLayout，其中包含了两个TextView，一个在左边一个在右边，分别用于显示应用程序的标题title和当前的蓝牙配对链接名称，如下图所示。
 

 

其中左边显示为应用程序名称"BluetoothChat",右边显示一个connected：scort，则表示当前配对成功正在进行聊天的链接名称

2、整个聊天界面的布局在main.xml中实现：采用一个线性布局LinearLayout，其中包含了另一个ListView（用于显示聊天的对话信息）和另外一个线性布局来实现一个发送信息的窗口，发送消息发送框有一个输入框和一个发送按钮构成。整个界面如下图所示。

 


 

2、设置自定义title布局

 我们就需要对界面进行一些设置，如下代码将用来设置我们自定义的标题title需要显示的内容：

1.// 设置自定义title布局   
 2.　　mTitle = (TextView) findViewById(R.id.title_left_text);   
 3.　　mTitle.setText(R.string.app_name);   
 4.　　mTitle = (TextView) findViewById(R.id.title_right_text);

左边的TextView被设置为显示应用程序名称，右边的则需要我们在链接之后在设置更新，目前则显示没有链接字样,所以这里我们暂不设置


3、蓝牙适配器BluetoothAdapter

进一步就需要获取本地蓝牙适配器BluetoothAdapter了，因为对于有关蓝牙的任何操作都需要首先获得该蓝牙适配器，获取代码非常简单，如下

 

 getDefaultAdapter()函数用于获取本地蓝牙适配器，然后检测是否为null，如果为null则表示没有蓝牙设备的支持，将通过toast告知用户。 

 

onStart()

 在onStart()函数中，我们将检测蓝牙是否被打开，如果没有打开，则请求打开，否则就可以设置一些聊天信息的准备工作，代码如下

 

3、控件

一个显示连接到某个设备的TextView，

一个用于显示对话的ListView，

一个用于输入聊天内容的EditText，

一个发送按钮Button

1、 在EditText注册一个监听器（另外）

 实现了软键盘按回车return键发送消息（一般我们在EditText里按return键是换行）

01.// 用于监听EditText的一个return键事件  
02.private TextView.OnEditorActionListener mWriteListener =  
03.    new TextView.OnEditorActionListener() {  
04.    public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {  
05.        // If the action is a key-up event on the return key, send the message  
06.        if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_UP) {  
07.            String message = view.getText().toString();  
08.            sendMessage(message);  
09.        }  
10.        if(D) Log.i(TAG, "END onEditorAction");  
11.        return true;  
12.    }  
13.};


 

 得到本地 BluetoothAdapter 设备，检查是否支持。

                onStart（） 中检查是否启用蓝牙，并请求启用，然后执行 setupChat（） 。

                setupChat（） 中先对界面中的控件进行初始化增加点击监听器等，然创建 BluetoothChatService 对象，该对象在整个应用过程中存在，并执行蓝牙连接建立、消息发送接受等实际的行为。

 

首先，程序启动进入BluetoothChat，在onCreate函数中对窗口进行了设置，代码如下：

  1. // 设置窗口布局  
  2. 　　requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);  
  3. 　　setContentView(R.layout.main);  
  4. 　　getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title); 
// 设置窗口布局 　　requestWindowFeature(Window.FEATURE_CUSTOM_TITLE); 　　setContentView(R.layout.main); 　　getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title);


　　这里可以看到将窗口风格设置为自定义风格了，并且指定了自定义title布局为custom_title，其定义代码如下：

view plain copy to clipboard print ?
  1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 
  2. 　　android:layout_width="match_parent" 
  3. 　　android:layout_height="match_parent" 
  4. 　　android:gravity="center_vertical" 
  5. 　　>  
  6. 　　<TextView android:id="@+id/title_left_text" 
  7. 　　android:layout_alignParentLeft="true" 
  8. 　　android:ellipsize="end" 
  9. 　　android:singleLine="true" 
  10. 　　style="?android:attr/windowTitleStyle" 
  11. 　　android:layout_width="wrap_content" 
  12. 　　android:layout_height="match_parent" 
  13. 　　android:layout_weight="1" 
  14. 　　/>  
  15. 　　<TextView android:id="@+id/title_right_text" 
  16. 　　android:layout_alignParentRight="true" 
  17. 　　android:ellipsize="end" 
  18. 　　android:singleLine="true" 
  19. 　　android:layout_width="wrap_content" 
  20. 　　android:layout_height="match_parent" 
  21. 　　android:textColor="#fff" 
  22. 　　android:layout_weight="1"   
  23. 　　/>  
  24. 　　</RelativeLayout>  
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 　　android:layout_width="match_parent" 　　android:layout_height="match_parent" 　　android:gravity="center_vertical" 　　> 　　<TextView android:id="@+id/title_left_text" 　　android:layout_alignParentLeft="true" 　　android:ellipsize="end" 　　android:singleLine="true" 　　style="?android:attr/windowTitleStyle" 　　android:layout_width="wrap_content" 　　android:layout_height="match_parent" 　　android:layout_weight="1" 　　/> 　　<TextView android:id="@+id/title_right_text" 　　android:layout_alignParentRight="true" 　　android:ellipsize="end" 　　android:singleLine="true" 　　android:layout_width="wrap_content" 　　android:layout_height="match_parent" 　　android:textColor="#fff" 　　android:layout_weight="1" 　　/> 　　</RelativeLayout>


　　该布局将title设置为一个相对布局RelativeLayout，其中包含了两个TextView，一个在左边一个在右边，分别用于显示应用程序的标题title和当前的蓝牙配对链接名称，如下图所示。

　　其中左边显示为应用程序名称"BluetoothChat",右边显示一个connected：scort则表示当前配对成功正在进行聊天的链接名称。整个聊天界面的布局在main.xml中实现，代码如下：

view plain copy to clipboard print ?
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
  2. 　　android:orientation="vertical" 
  3. 　　android:layout_width="match_parent" 
  4. 　　android:layout_height="match_parent" 
  5. 　　>  
  6. 　　<!-- 显示设备列表 -->  
  7. 　　<ListView android:id="@+id/in" 
  8. 　　android:layout_width="match_parent" 
  9. 　　android:layout_height="match_parent" 
  10. 　　android:stackFromBottom="true" 
  11. 　　android:transcriptMode="alwaysScroll" 
  12. 　　android:layout_weight="1" 
  13. 　　/>  
  14. 　　<!-- 显示发送消息的编辑框 -->  
  15. 　　<LinearLayout  
  16. 　　android:orientation="horizontal" 
  17. 　　android:layout_width="match_parent" 
  18. 　　android:layout_height="wrap_content" 
  19. 　　>  
  20. 　　<EditText android:id="@+id/edit_text_out" 
  21. 　　android:layout_width="wrap_content" 
  22. 　　android:layout_height="wrap_content" 
  23. 　　android:layout_weight="1" 
  24. 　　android:layout_gravity="bottom" 
  25. 　　/>  
  26. 　　<Button android:id="@+id/button_send" 
  27. 　　android:layout_width="wrap_content" 
  28. 　　android:layout_height="wrap_content" 
  29. 　　android:text="@string/send" 
  30. 　　/>  
  31. 　　</LinearLayout>  
  32. 　　</LinearLayout>  
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 　　android:orientation="vertical" 　　android:layout_width="match_parent" 　　android:layout_height="match_parent" 　　> 　　<!-- 显示设备列表 --> 　　<ListView android:id="@+id/in" 　　android:layout_width="match_parent" 　　android:layout_height="match_parent" 　　android:stackFromBottom="true" 　　android:transcriptMode="alwaysScroll" 　　android:layout_weight="1" 　　/> 　　<!-- 显示发送消息的编辑框 --> 　　<LinearLayout 　　android:orientation="horizontal" 　　android:layout_width="match_parent" 　　android:layout_height="wrap_content" 　　> 　　<EditText android:id="@+id/edit_text_out" 　　android:layout_width="wrap_content" 　　android:layout_height="wrap_content" 　　android:layout_weight="1" 　　android:layout_gravity="bottom" 　　/> 　　<Button android:id="@+id/button_send" 　　android:layout_width="wrap_content" 　　android:layout_height="wrap_content" 　　android:text="@string/send" 　　/> 　　</LinearLayout> 　　</LinearLayout>


　　整个界面的布局将是一个线性布局LinearLayout，其中包含了另一个ListView（用于显示聊天的对话信息）和另外一个线性布局来实现一个发送信息的窗口，发送消息发送框有一个输入框和一个发送按钮构成。整个界面如下图所示。

　　布局好界面，下面我们需要进入编码状态，首先看BluetoothChat所要那些成员变量，如下代码所示：

view plain copy to clipboard print ?
  1. public class BluetoothChatextends Activity {  
  2. 　　// Debugging  
  3. 　　private static final String TAG ="BluetoothChat";  
  4. 　　private staticfinalboolean D =true;  
  5.  
  6. 　　//从BluetoothChatService Handler发送的消息类型  
  7. 　　public staticfinalint MESSAGE_STATE_CHANGE =1;  
  8. 　　public staticfinalint MESSAGE_READ =2;  
  9. 　　public staticfinalint MESSAGE_WRITE =3;  
  10. 　　public staticfinalint MESSAGE_DEVICE_NAME =4;  
  11. 　　public staticfinalint MESSAGE_TOAST =5;  
  12.  
  13. 　　// 从BluetoothChatService Handler接收消息时使用的键名(键-值模型) 
  14. 　　public staticfinal String DEVICE_NAME ="device_name";  
  15. 　　public staticfinal String TOAST ="toast";  
  16.  
  17. 　　// Intent请求代码（请求链接，请求可见）  
  18. 　　private staticfinalint REQUEST_CONNECT_DEVICE =1;  
  19. 　　private static finalint REQUEST_ENABLE_BT =2;  
  20.  
  21. 　　// Layout Views  
  22. 　　private TextView mTitle;  
  23. 　　private ListView mConversationView;  
  24. 　　private EditText mOutEditText;  
  25. 　　private Button mSendButton;  
  26.  
  27. 　　// 链接的设备的名称  
  28. 　　private String mConnectedDeviceName =null;  
  29. 　　// Array adapter for the conversation thread 
  30. 　　private ArrayAdapter<String> mConversationArrayAdapter;  
  31. 　　// 将要发送出去的字符串  
  32. 　　private StringBuffer mOutStringBuffer;  
  33. 　　// 本地蓝牙适配器  
  34. 　　private BluetoothAdapter mBluetoothAdapter =null;  
  35. 　　// 聊天服务的对象  
  36. 　　private BluetoothChatService mChatService =null;  
  37. 　　//......  
public class BluetoothChat extends Activity { 　　// Debugging 　　private static final String TAG = "BluetoothChat"; 　　private static final boolean D = true; 　　//从BluetoothChatService Handler发送的消息类型 　　public static final int MESSAGE_STATE_CHANGE = 1; 　　public static final int MESSAGE_READ = 2; 　　public static final int MESSAGE_WRITE = 3; 　　public static final int MESSAGE_DEVICE_NAME = 4; 　　public static final int MESSAGE_TOAST = 5; 　　// 从BluetoothChatService Handler接收消息时使用的键名(键-值模型) 　　public static final String DEVICE_NAME = "device_name"; 　　public static final String TOAST = "toast"; 　　// Intent请求代码（请求链接，请求可见） 　　private static final int REQUEST_CONNECT_DEVICE = 1; 　　private static final int REQUEST_ENABLE_BT = 2; 　　// Layout Views 　　private TextView mTitle; 　　private ListView mConversationView; 　　private EditText mOutEditText; 　　private Button mSendButton; 　　// 链接的设备的名称 　　private String mConnectedDeviceName = null; 　　// Array adapter for the conversation thread 　　private ArrayAdapter<String> mConversationArrayAdapter; 　　// 将要发送出去的字符串 　　private StringBuffer mOutStringBuffer; 　　// 本地蓝牙适配器 　　private BluetoothAdapter mBluetoothAdapter = null; 　　// 聊天服务的对象 　　private BluetoothChatService mChatService = null; 　　//......


　　其中Debugging部分则将用于我们在调试程序时通过log打印日志用，其他部分我们都加入了注释，需要说明的是BluetoothChatService ，它是我们自己定义的一个用来管理蓝牙的端口监听，链接，管理聊天的程序，后面我们会介绍。在这里需要说明一点，这些代码都出自google的员工之手，大家在学习时，可以借鉴很多代码编写的技巧和风格，这都将对我们有非常大的帮助。
　　然后，我们就需要对界面进行一些设置，如下代码将用来设置我们自定义的标题title需要显示的内容：

view plain copy to clipboard print ?
  1. // 设置自定义title布局  
  2. 　　mTitle = (TextView) findViewById(R.id.title_left_text);  
  3. 　　mTitle.setText(R.string.app_name);  
  4. 　　mTitle = (TextView) findViewById(R.id.title_right_text); 
// 设置自定义title布局 　　mTitle = (TextView) findViewById(R.id.title_left_text); 　　mTitle.setText(R.string.app_name); 　　mTitle = (TextView) findViewById(R.id.title_right_text);


　　左边的TextView被设置为显示应用程序名称，右边的则需要我们在链接之后在设置更新，目前则显示没有链接字样,所以这里我们暂不设置,进一步就需要获取本地蓝牙适配器BluetoothAdapter了，因为对于有关蓝牙的任何操作都需要首先获得该蓝牙适配器，获取代码非常简单，如下：

view plain copy to clipboard print ?
  1. // 得到一个本地蓝牙适配器  
  2. 　　mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();  
  3.  
  4. 　　// 如果适配器为null，则不支持蓝牙  
  5. 　　if (mBluetoothAdapter ==null) {  
  6. 　　Toast.makeText(this, "Bluetooth is not available", Toast.LENGTH_LONG).show();  
  7. 　　finish();  
  8. 　　return;  
  9. 　　}  
  10. 　　getDefaultAdapter()函数用于获取本地蓝牙适配器，然后检测是否为null，如果为null则表示没有蓝牙设备的支持，将通过toast告知用户。  
  11. 　　在onStart()函数中，我们将检测蓝牙是否被打开，如果没有打开，则请求打开，否则就可以设置一些聊天信息的准备工作，代码如下：  
  12. 　　@Override 
  13. 　　public void onStart() {  
  14. 　　super.onStart();  
  15. 　　if(D) Log.e(TAG,"++ ON START ++");  
  16.  
  17. 　　// 如果蓝牙没有打开，则请求打开  
  18. 　　// setupChat() will then be called during onActivityResult 
  19. 　　if (!mBluetoothAdapter.isEnabled()) {  
  20. 　　Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);  
  21. 　　startActivityForResult(enableIntent, REQUEST_ENABLE_BT);  
  22. 　　// 否则，设置聊天会话  
  23. 　　} else {  
  24. 　　if (mChatService == null) setupChat();  
  25. 　　}  
  26. 　　}  
// 得到一个本地蓝牙适配器 　　mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); 　　// 如果适配器为null，则不支持蓝牙 　　if (mBluetoothAdapter == null) { 　　Toast.makeText(this, "Bluetooth is not available", Toast.LENGTH_LONG).show(); 　　finish(); 　　return; 　　} 　　getDefaultAdapter()函数用于获取本地蓝牙适配器，然后检测是否为null，如果为null则表示没有蓝牙设备的支持，将通过toast告知用户。 　　在onStart()函数中，我们将检测蓝牙是否被打开，如果没有打开，则请求打开，否则就可以设置一些聊天信息的准备工作，代码如下： 　　@Override 　　public void onStart() { 　　super.onStart(); 　　if(D) Log.e(TAG, "++ ON START ++"); 　　// 如果蓝牙没有打开，则请求打开 　　// setupChat() will then be called during onActivityResult 　　if (!mBluetoothAdapter.isEnabled()) { 　　Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); 　　startActivityForResult(enableIntent, REQUEST_ENABLE_BT); 　　// 否则，设置聊天会话 　　} else { 　　if (mChatService == null) setupChat(); 　　} 　　}

 

onStart()函数_检测蓝牙


　　如果蓝牙没有打开，我们则通过BluetoothAdapter.ACTION_REQUEST_ENABLE来请求打开蓝牙，REQUEST_ENABLE_BT则是我们自己定义的用于请求打开蓝牙的Intent代码，最后当我们调用startActivityForResult来执行请求时，就会在onActivityResult函数中得到一个反馈，如果当前蓝牙已经打开，那么就可以调用setupChat函数来准备蓝牙聊天相关的工作，稍后分析该函数的具体实现。
　　下面我们分析一下请求打开蓝牙之后，在onActivityResult 中得到的反馈信息，我们传递了REQUEST_ENABLE_BT代码作为请求蓝牙打开的命令，因此在onActivityResult 中，需要会得到一个请求代码为REQUEST_ENABLE_B的消息，对于其处理如下代码所示：

view plain copy to clipboard print ?
  1. case REQUEST_ENABLE_BT:  
  2. 　　// 在请求打开蓝牙时返回的代码  
  3. 　　if (resultCode == Activity.RESULT_OK) {  
  4. 　　// 蓝牙已经打开，所以设置一个聊天会话  
  5. 　　setupChat();  
  6. 　　} else {  
  7. 　　// 请求打开蓝牙出错  
  8. 　　Log.d(TAG, "BT not enabled");  
  9. 　　Toast.makeText(this, R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show();  
  10. 　　finish();  
  11. 　　}  
case REQUEST_ENABLE_BT: 　　// 在请求打开蓝牙时返回的代码 　　if (resultCode == Activity.RESULT_OK) { 　　// 蓝牙已经打开，所以设置一个聊天会话 　　setupChat(); 　　} else { 　　// 请求打开蓝牙出错 　　Log.d(TAG, "BT not enabled"); 　　Toast.makeText(this, R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show(); 　　finish(); 　　}


　　在请求时，如果返回代码为Activity.RESULT_OK，则表示请求打开蓝牙成功，那么我们就可以和上面的操作进度一样，调用setupChat来设置蓝牙聊天相关信息，如果返回其他代码，则表示请求打开蓝牙失败，这时我们同样通过一个Toast来告诉用户，同时也需要调用finish()函数来结束应用程序。
　　

setupChat设置

如果打开蓝牙无误，那么下面我们开始进入setupChat的设置，其代码实现如下：

view plain copy to clipboard print ?
  1. private void setupChat() {  
  2. 　　Log.d(TAG, "setupChat()");  
  3.  
  4. 　　// 初始化对话进程  
  5. 　　mConversationArrayAdapter = new ArrayAdapter<String>(this, R.layout.message);  
  6. 　　// 初始化对话显示列表  
  7. 　　mConversationView = (ListView) findViewById(R.id.in);  
  8. 　　// 设置话显示列表源  
  9. 　　mConversationView.setAdapter(mConversationArrayAdapter);  
  10.  
  11. 　　// 初始化编辑框，并设置一个监听，用于处理按回车键发送消息 
  12. 　　mOutEditText = (EditText) findViewById(R.id.edit_text_out);  
  13. 　　mOutEditText.setOnEditorActionListener(mWriteListener);  
  14.  
  15. 　　// 初始化发送按钮，并设置事件监听  
  16. 　　mSendButton = (Button) findViewById(R.id.button_send);  
  17. 　　mSendButton.setOnClickListener(new OnClickListener() {  
  18. 　　public void onClick(View v) {  
  19. 　　// 取得TextView中的内容来发送消息  
  20. 　　TextView view = (TextView) findViewById(R.id.edit_text_out);  
  21. 　　String message = view.getText().toString();  
  22. 　　sendMessage(message);  
  23. 　　}  
  24. 　　});  
  25.  
  26. 　　// 初始化BluetoothChatService并执行蓝牙连接  
  27. 　　mChatService = new BluetoothChatService(this, mHandler);  
  28.  
  29. 　　// 初始化将要发出的消息的字符串  
  30. 　　mOutStringBuffer = new StringBuffer("");  
  31. 　　}  
private void setupChat() { 　　Log.d(TAG, "setupChat()"); 　　// 初始化对话进程 　　mConversationArrayAdapter = new ArrayAdapter<String>(this, R.layout.message); 　　// 初始化对话显示列表 　　mConversationView = (ListView) findViewById(R.id.in); 　　// 设置话显示列表源 　　mConversationView.setAdapter(mConversationArrayAdapter); 　　// 初始化编辑框，并设置一个监听，用于处理按回车键发送消息 　　mOutEditText = (EditText) findViewById(R.id.edit_text_out); 　　mOutEditText.setOnEditorActionListener(mWriteListener); 　　// 初始化发送按钮，并设置事件监听 　　mSendButton = (Button) findViewById(R.id.button_send); 　　mSendButton.setOnClickListener(new OnClickListener() { 　　public void onClick(View v) { 　　// 取得TextView中的内容来发送消息 　　TextView view = (TextView) findViewById(R.id.edit_text_out); 　　String message = view.getText().toString(); 　　sendMessage(message); 　　} 　　}); 　　// 初始化BluetoothChatService并执行蓝牙连接 　　mChatService = new BluetoothChatService(this, mHandler); 　　// 初始化将要发出的消息的字符串 　　mOutStringBuffer = new StringBuffer(""); 　　}


　　首先构建一个对话进程mConversationArrayAdapter，然后从xml中取得用于显示对话信息的列表mConversationView，最后将列表的数据来源Adapter设置为mConversationArrayAdapter，这里我们可以看到mConversationArrayAdapter所指定的资源为message.xml，其定义实现如下：

view plain copy to clipboard print ?
  1. <TextView xmlns:android="http://schemas.android.com/apk/res/android" 
  2. 　　android:layout_width="match_parent" 
  3. 　　android:layout_height="wrap_content" 
  4. 　　android:textSize="18sp" 
  5. 　　android:padding="5dp" 
  6. 　　/>  
<TextView xmlns:android="http://schemas.android.com/apk/res/android" 　　android:layout_width="match_parent" 　　android:layout_height="wrap_content" 　　android:textSize="18sp" 　　android:padding="5dp" 　　/>


　　很简单，就包含了一个TextView用来显示对话内容即可，这里设置了文字标签的尺寸大小textSize和padding属性。
　　然后我们取得了编辑框mOutEditText，用于输入聊天内容的输入框，并对其设置了一个事件监听mWriteListener，其监听函数的实现如下：

view plain copy to clipboard print ?
  1. // The action listener for the EditText widget, to listen for the return key 
  2. 　　private TextView.OnEditorActionListener mWriteListener =  
  3. 　　new TextView.OnEditorActionListener() {  
  4. 　　public boolean onEditorAction(TextView view,int actionId, KeyEvent event) {  
  5. 　　// 按下回车键并且是按键弹起的事件时发送消息  
  6. 　　if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_UP) {  
  7. 　　String message = view.getText().toString();  
  8. 　　sendMessage(message);  
  9. 　　}  
  10. 　　if(D) Log.i(TAG, "END onEditorAction");  
  11. 　　return true;  
  12. 　　}  
  13. 　　};  
// The action listener for the EditText widget, to listen for the return key 　　private TextView.OnEditorActionListener mWriteListener = 　　new TextView.OnEditorActionListener() { 　　public boolean onEditorAction(TextView view, int actionId, KeyEvent event) { 　　// 按下回车键并且是按键弹起的事件时发送消息 　　if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_UP) { 　　String message = view.getText().toString(); 　　sendMessage(message); 　　} 　　if(D) Log.i(TAG, "END onEditorAction"); 　　return true; 　　} 　　};


　　首先在其监听中实现了onEditorAction函数，我们通过判断其参数actionId来确定事件触发的动作，其中的"EditorInfo.IME_NULL"在Ophone中表示回车键消息，然后再加上KeyEvent.ACTION_UP，则表示当用户按下回车键并弹起时才触发消息的处理，处理过程也很简单，将输入框中内容取出到变量message中，然后调用sendMessage函数来发送一条消息，具体的发送细节，我们稍后分析。

setupChat函数_发送消息


　　在setupChat函数中，我们还对发送消息的按钮进行的初始化，同样为其设置了事件监听（setOnClickListener），监听的内容则也是取得输入框中的信息，然后调用sendMessage函数来发送消息，和用户按回车键来发送消息一样。
　　最后一个重要的操作就是初始化了BluetoothChatService对象mChatService用来管理蓝牙的链接，聊天的操作,并且设置了其Handler对象mHandler来负责数据的交换和线程之间的通信。另外还准备了一个空的字符串对象mOutStringBuffer，用于当我们在发送消息之后，对输入框的清理。


应用菜单用option_menu.xml


　　该应用程序除了这些界面的布局之外，我们还为其设置了一个菜单，菜单包括了"扫描设备"和"使设备可见（能够被其他设备所搜索到）"，创建菜单的方式有很多种，这里gogole的员工，比较喜欢和推崇使用option_menu.xml布局（将界面和逻辑分开），所以我们首先看一下对于该应用程序通过xml所定义的菜单布局，代码如下：

view plain copy to clipboard print ?
  1. <menu xmlns:android="http://schemas.android.com/apk/res/android">  
  2. 　　 <!-- 扫描菜单 -->  
  3. 　　<item android:id="@+id/scan" 
  4. 　　android:icon="@android:drawable/ic_menu_search" 
  5. 　　android:title="@string/connect" />  
  6. 　　<!-- 可见操作 -->  
  7. 　　<item android:id="@+id/discoverable" 
  8. 　　android:icon="@android:drawable/ic_menu_mylocation" 
  9. 　　android:title="@string/discoverable" />  
  10. 　　</menu>  
<menu xmlns:android="http://schemas.android.com/apk/res/android"> 　　 <!-- 扫描菜单 --> 　　<item android:id="@+id/scan" 　　android:icon="@android:drawable/ic_menu_search" 　　android:title="@string/connect" /> 　　<!-- 可见操作 --> 　　<item android:id="@+id/discoverable" 　　android:icon="@android:drawable/ic_menu_mylocation" 　　android:title="@string/discoverable" /> 　　</menu>

 

onOptionsItemSelected函数、onCreateOptionsMenu函数_菜单的处理与装载


　　这样的定义的确非常的清晰，我们可以随意向这个Menu中添加菜单选项（itme）,这里就定义了上面我们所说的两个菜单。然后再程序中通过onCreateOptionsMenu函数中来装载该菜单布局，遂于菜单的点击可以通过onOptionsItemSelected函数的不同参数来辨别，下面是该应用程序中对菜单选项的处理和装载菜单布局：

view plain copy to clipboard print ?
  1. //创建一个菜单  
  2. 　　@Override 
  3. 　　public boolean onCreateOptionsMenu(Menu menu) {  
  4. 　　MenuInflater inflater = getMenuInflater();  
  5. 　　inflater.inflate(R.menu.option_menu, menu);  
  6. 　　return true;  
  7. 　　}  
  8. 　　//处理菜单事件  
  9. 　　@Override 
  10. 　　public boolean onOptionsItemSelected(MenuItem item) {  
  11. 　　switch (item.getItemId()) {  
  12. 　　case R.id.scan:  
  13. 　　// 启动DeviceListActivity查看设备并扫描 
  14. 　　Intent serverIntent = new Intent(this, DeviceListActivity.class);  
  15. 　　startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);  
  16. 　　return true;  
  17. 　　case R.id.discoverable:  
  18. 　　// 确保设备处于可见状态  
  19. 　　ensureDiscoverable();  
  20. 　　return true;  
  21. 　　}  
  22. 　　return false;  
  23. 　　}  
//创建一个菜单 　　@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: 　　// 启动DeviceListActivity查看设备并扫描 　　Intent serverIntent = new Intent(this, DeviceListActivity.class); 　　startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE); 　　return true; 　　case R.id.discoverable: 　　// 确保设备处于可见状态 　　ensureDiscoverable(); 　　return true; 　　} 　　return false; 　　}


　　装载菜单布局的时候使用了MenuInflater对象，整个过程很简单，大家可以参考上面的代码实现，在处理菜单事件的时候，通过item.getItemId()我们可以得到当前选择的菜单项的ID，首先是扫描设备（R.id.scan），这里我们有启动了另外一个Activity来专门处理扫描设备DeviceListActivity，如果扫描之后我们将通过startActivityForResult函数来请求链接该设备，

onActivityResult函数_扫描反馈信息

同样我们也会在onActivityResult函数中收到一个反馈信息，命令代码为REQUEST_CONNECT_DEVICE，如果反馈的请求代码为Activity.RESULT_OK，则表示扫描成功（扫描过程我们稍后介绍），那么下面就可以开始准备链接了，实现代码如下：

view plain copy to clipboard print ?
  1. case REQUEST_CONNECT_DEVICE:  
  2. 　　// 当DeviceListActivity返回设备连接  
  3. 　　if (resultCode == Activity.RESULT_OK) {  
  4. 　　// 从Intent中得到设备的MAC地址  
  5. 　　String address = data.getExtras()  
  6. 　　.getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);  
  7. 　　// 得到蓝牙设备对象  
  8. 　　BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);  
  9. 　　// 尝试连接这个设备  
  10. 　　mChatService.connect(device);  
  11. 　　}  
  12. 　　break;  
case REQUEST_CONNECT_DEVICE: 　　// 当DeviceListActivity返回设备连接 　　if (resultCode == Activity.RESULT_OK) { 　　// 从Intent中得到设备的MAC地址 　　String address = data.getExtras() 　　.getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS); 　　// 得到蓝牙设备对象 　　BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address); 　　// 尝试连接这个设备 　　mChatService.connect(device); 　　} 　　break;


　　首先我们可以通过DeviceListActivity.EXTRA_DEVICE_ADDRESS来取得设备的Mac地址，然后通过Mac地址使用蓝牙适配器mBluetoothAdapter的getRemoteDevice函数来查找到该地址的设备BluetoothDevice，查询到之后我们可以通过mChatService对象的connect来链接该设备。

ensureDiscoverable函数_使设备处于可见状态


　　上面我们说的是扫描蓝牙设备并链接的过程，一般蓝牙设备在打开之后都需要设置可见状态，下面我们来看一下另一个菜单选项的实现，用于使设备处于可见状态，其菜单项的ID为R.id.discoverable，具体实现过程则位于ensureDiscoverable函数中,其实现如下代码：

view plain copy to clipboard print ?
  1. private void ensureDiscoverable() {  
  2. 　　if(D) Log.d(TAG, "ensure discoverable");  
  3. 　　//判断扫描模式是否为既可被发现又可以被连接  
  4. 　　if (mBluetoothAdapter.getScanMode() !=  
  5. 　　BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {  
  6. 　　 //请求可见状态  
  7. 　　Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);  
  8. 　　//添加附加属性，可见状态的时间  
  9. 　　discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,300);  
  10. 　　startActivity(discoverableIntent);  
  11. 　　}  
  12. 　　}  
private void ensureDiscoverable() { 　　if(D) Log.d(TAG, "ensure discoverable"); 　　//判断扫描模式是否为既可被发现又可以被连接 　　if (mBluetoothAdapter.getScanMode() != 　　BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) { 　　 //请求可见状态 　　Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); 　　//添加附加属性，可见状态的时间 　　discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300); 　　startActivity(discoverableIntent); 　　} 　　}


　　这里首先通过mBluetoothAdapter.getScanMode()函数取得该蓝牙的扫描模式，然后通过BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE设置可见属性，在这里我们加入一个附加属性BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION，用来设置可见状态的时间，表示在指定的时间中蓝牙处于可见状态，设置好之后通过startActivity来执行即可。

 

onResume()函数_端口监听


　　这里忧一个需要注意的问题，在链接某个设备之前，我们需要开启一个端口监听，该应用程序将其放在onResume()函数中来处理了，代码如下：

view plain copy to clipboard print ?
  1. @Override 
  2. 　　public synchronizedvoid onResume() {  
  3. 　　super.onResume();  
  4. 　　if(D) Log.e(TAG, "+ ON RESUME +");  
  5.  
  6. 　　// Performing this check in onResume() covers the case in which BT was 
  7. 　　// not enabled during onStart(), so we were paused to enable it... 
  8. 　　// onResume() will be called when ACTION_REQUEST_ENABLE activity returns. 
  9. 　　if (mChatService !=null) {  
  10. 　　// 如果当前状态为STATE_NONE，则需要开启蓝牙聊天服务  
  11. 　　if (mChatService.getState() == BluetoothChatService.STATE_NONE) {  
  12. 　　// 开始一个蓝牙聊天服务  
  13. 　　mChatService.start();  
  14. 　　}  
  15. 　　}  
  16. 　　}  
@Override 　　public synchronized void onResume() { 　　super.onResume(); 　　if(D) Log.e(TAG, "+ ON RESUME +"); 　　// Performing this check in onResume() covers the case in which BT was 　　// not enabled during onStart(), so we were paused to enable it... 　　// onResume() will be called when ACTION_REQUEST_ENABLE activity returns. 　　if (mChatService != null) { 　　// 如果当前状态为STATE_NONE，则需要开启蓝牙聊天服务 　　if (mChatService.getState() == BluetoothChatService.STATE_NONE) { 　　// 开始一个蓝牙聊天服务 　　mChatService.start(); 　　} 　　} 　　}


　　首先检测mChatService是否被初始化，然后检测其状态是否为STATE_NONE，STATE_NONE表示初始化之后处于等待的状态，当我们在setupChat函数中初始时，其实就已经将其状态设置为STATE_NONE了（该操作是在BluetoothChatService的构造函数中处理的），所以这里就可以通过一个start函数来启动一个进程即可，实际上就是启动了一个端口监听进程，当有设备连接时，该监听进程结束，然后转向链接进程，链接之后同样又将转换到一个聊天管理进程，对于这些链接过程和通信模块看来只有下一篇文章介绍了.


　　总结
　　本文试图完成一个蓝牙聊天程序的分析和实现，但是我发现只要涉及网络通信模块的程序分析过程都比较复杂，可能是因为分析太细的原因，并没有分析完该程序，因此，下一篇文章我们继续分析，同时下一篇要介绍的也是最核心的内容，网络通信过程，希望能得到大家的支持。！

 

 

Android蓝牙详析 | 经典蓝牙通讯架构
aaLiweipeng的博客
05-19 603
连接设备 蓝牙通讯机制建立在socket上； 要在两台设备上创建连接，需要实现服务器端和客户端机制 一般通讯过程： 在服务端等待客户端的连接请求， 有连接请求后连接， 连接成功后有一个socket（也即套接字）， 通过socket套接字得到IO流， 往输入流中读数据， 或者往输出流中写数据， 即可以实现两台设备之间的通讯； 服务器设备和客户端设备分别获得...
Android实现TCP服务器
chenxihanhui的博客
03-21 3709
Android实现TCP服务器 1.获取本机ip地址 建立socket连接之前，我们首先要获取本地的ip地址，这样，才能让客户端通过ip地址连接到服务器 /**获得IP地址，分为两种情况，一是wifi下，二是移动网络下，得到的ip地址是不一样的*/ String getIPAddress() { Context context=MainActivity.this; NetworkInfo info = ((ConnectivityManager) context
QT connect第五个参数以及QThread用法
dhl11的博客
07-22 516
Qt 的线程与事件循环——可打印threadid进行观察槽函数到底是在哪个线程里执行，学习moveToThread的使用） https://www.cnblogs.com/findumars/p/5031239.html Qt学习记录—（6）线程（QThread）和connect的第五个参数 https://blog.csdn.net/qq_38836825/article/details/105203864 ...
Android蓝牙开发教程（二）——连接蓝牙设备
犀利的小牛
09-06 1万+
在上一篇中已经介绍如何搜索附近可连接的蓝牙设备，如果你还没阅读过，建议先看看上一篇文章Android蓝牙开发教程（一）——搜索蓝牙设备获取到设备后就可以开始处理蓝牙设备之间的连接。在上一篇教程中我们将搜索到的蓝牙设备展示在列表中，现在我们为列表项增加上点击事件。listView.setOnItemClickListener(new AdapterView.OnItemClickListener()
Unity【Socket TCP】- 服务端与客户端通讯的简单示例
当代野生程序猿
03-26 8246
应粉丝需求做一个服务端与客户端通讯的示例，需求比较简单，我们使用Socket TCP协议去构建，直接使用固定长度信息法。 一、服务端搭建： 打开Visual Studio，文件/新建/项目，创建一个控制台应用： 新建Server类与Client类： 代码如下： using System.Net; using System.Net.Sockets; namespace CoderZ { public class Server { //端口
Unity使用C#实现简单Scoket连接及服务端与客户端通讯
lizhenxiqnmlgb的博客
09-16 1800
服务端代码： using System.Collections; using System.Collections.Generic; using UnityEngine; using System; using System.Threading; using System.Net.Sockets; using System.Net; using System.Text; /*** * ...
Google官网蓝牙通信模块BluetoothChatService类分析与使用
sonwfly的博客
09-13 2394
BluetoothChatService类包含了三个Thread的内部类： · AcceptThread类：监听来自其他设备的蓝牙连接（ This thread runs while listening for incoming connections. It behaves like a server-side client. It runs until a connection is
BluetoothChat.java android源代码.doc
06-09
BluetoothChat.java android源代码
BluetoothChat
05-17
Android BluetoothChat示例 此示例演示如何使用所有基本的蓝牙API功能在两个Android设备之间通过蓝牙实现双向文本聊天。 介绍 此示例应同时在两个Android设备上运行，以在两个设备之间通过蓝牙建立双向聊天。 在一台...
BluetoothChat例子官方源码
06-04
"BluetoothChat"是Android官方提供的一款示例应用，旨在帮助开发者理解和实现蓝牙通信功能。这个例子的源码是一个宝贵的教育资源，可以帮助我们深入理解如何在Android应用中集成蓝牙功能。 在Android中，蓝牙通信...
BluetoothChat 蓝牙聊天 Android 官方源码 带注释
01-13
BluetoothChat是Android官方提供的一款用于演示蓝牙通信的应用源码，它仅使用了三个Java文件就实现了基本的蓝牙聊天功能。这个简单而直观的实现方式，使得开发者能够快速理解和掌握Android蓝牙通信的基本原理和操作...
Socket连接与断开重连
valiantMan
05-22 1万+
Socket连接与断开重连 近期在做一个与硬件交互的项目，通过TCP/IP协议通讯。 首先来看一下Socket通信模型 思路是使用service，需要频繁的与服务端交互所以使用BindService 创建绑定服务 必须使用IBinder，用以提供客户端与服务交互...
QThread 使用探讨
MichaelSrc的草稿簿
05-09 1569
<br />转载自 dbzhang800<br />QThread 似乎是很难的一个东西，特别是信号和槽，有非常多的人(尽管使用者本人往往不知道)在用不恰当(甚至错误)的方式在使用 QThread，随便用google一搜，就能搜出大量结果出来。无怪乎Qt的开发人员 Bradley T. Hughes 声嘶力竭地喊you are-doing-it-wrong<br />和众多用户一样，初次看到这个时，感到 Bradley T. Hughes有 些莫名奇妙，小题大作。尽管不舒服，当时还是整理过一篇博客QThre
Android 蓝牙开发实例--蓝牙聊天程序的设计和实现 Android 蓝牙开发实例--蓝牙聊天程序的设计和实现...
xiaoheliushuiya
01-04 231
Android 蓝牙开发实例--蓝牙聊天程序的设计和实现 转自：http://blog.csdn.net/dlutbrucezhang/article/details/8963696 作者在这里介绍的这个实例是Google SDK中提供的一个蓝牙聊天程序，简单但信息量巨大，非常适合初学者学习蓝牙方面的知识。 在学习这个实例前请读者仔细...
手把手教你做蓝牙聊天应用（四）－蓝牙连接模块
不积跬步无以至千里
07-13 8380
蓝牙连接的管理模块需要提供连接相关的所有功能，要设计的方便使用，并尽量隐藏连接的细节。其他模块只要想使用蓝牙的连接，通过这个模块就可以了。
Qt学习记录---（6）线程（QThread）和connect的第五个参数
qq_38836825的博客
03-30 1615
Qt中线程是一个非常难的问题。这里记录下我的理解。 Qt中线程解决问题：由于复杂的操作（复杂计算、复杂绘图等操作）使得整个应用程序变得卡顿时。 这个时候就可以使用线程，将复杂的操作放到新开的线程中完成，完成后emit一个信号给主线程表明其操作完成。 注意： 1.QThread其实是管理线程的工具，它是属于主线程的，直接调用QThread的槽函数（不是run函数），也是在主线程中调用。需要使用到...
android开发之蓝牙配对连接的方法
热门推荐
一个本科小生的奋斗史
01-03 7万+
新年第一篇。最近在做蓝牙开锁的小项目，手机去连接单片机总是出现问题，和手机的连接也不稳定，看了不少蓝牙方面的文档，做了个关于蓝牙连接的小结。 在做android蓝牙串口连接的时候一般会使用 BluetoothSocket tmp = null; // Get a BluetoothSocket for a connection with the // given BluetoothDevi
Java通俗易懂30天 第19天:多线程(下)
程序员小刘
09-16 1307
文章目录 文章目录文章目录第8章 多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题线程安全的单例模式之懒汉式死锁的问题Lock锁方式解决线程安全问题线程的通信sleep()和wait()的异同经典例题：生产者/消费者问题JDK5.0新增线程创建方式创建多线程的方式三：实现Callable接口使用线程池的好处创建多线程的方式四：使用线程池 ..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值