Android蓝牙通信聊天实现发送和接受功能_Android

很不错的蓝牙通信demo实现发送和接受功能,就用了两个类就实现了,具体内容如下

说下思路把 主要有两个类 主界面类 蓝牙聊天服务类 。 首先创建线程 实际上就是创建BluetoothChatService() (蓝牙聊天服务类) 这个时候把handler 传过去 这样就可以操作UI 界面了,在线程中不断轮询读取蓝牙消息,当主界面点击发送按钮时 调用BluetoothChatService 的发送方法write 方法,这里的write 方法 使用了handler 发送消息,在主界面显示,另一个 客户端 不断读取蓝牙消息 类似的有个read 方法 同样显示到界面上去,这样就完成了通信了。

import java.util.ArrayList;
import java.util.Set;

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.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

public class BluetoothChat extends Activity {

  // Message types sent from the BluetoothChatService Handler
  public static final int MESSAGE_STATE_CHANGE = 1;
  public static final int MESSAGE_READ = 2;
  public static final int MESSAGE_WRITE = 3;
  public static final int MESSAGE_DEVICE_NAME = 4;
  public static final int MESSAGE_TOAST = 5;

  // Key names received from the BluetoothChatService Handler
  public static final String DEVICE_NAME = "device_name";
  public static final String TOAST = "toast";

  // Intent request codes
  private static final int REQUEST_CONNECT_DEVICE = 1;
  private static final int REQUEST_ENABLE_BT = 2;

  private TextView mTitle;
  private EditText text_chat;
  private EditText text_input;
  private Button but_On_Off;
  private Button but_search; // ------> 在菜单中可以搜索
  private Button but_create; // ------> 在菜单中设置"可被发现"
  private Button mSendButton;
  // 连接到的蓝牙设备的名称
  private String mConnectedDeviceName;
  // String buffer for outgoing messages
  private StringBuffer mOutStringBuffer;
  // Local Bluetooth adapter
  private BluetoothAdapter mBluetoothAdapter = null;
  // Member object for the chat services
  private BluetoothChatService mChatService = null;

  private ArrayList<String> mPairedDevicesList = new ArrayList<String>();
  private ArrayList<String> mNewDevicesList = new ArrayList<String>();
  private String[] strName;
  private String address;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
    setContentView(R.layout.main);

    mTitle = (TextView) this.findViewById(R.id.text_title);
    text_chat = (EditText) this.findViewById(R.id.text_chat);
    text_input = (EditText) this.findViewById(R.id.text_input);
    but_On_Off = (Button) this.findViewById(R.id.but_off_on);
    but_search = (Button) this.findViewById(R.id.but_search_div);
    but_create = (Button) this.findViewById(R.id.but_cjlj);
    mSendButton = (Button) this.findViewById(R.id.but_fsxx);

    // 获得本地的蓝牙适配器
    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    // 如果为null,说明没有蓝牙设备
    if (mBluetoothAdapter == null) {
      Toast.makeText(this, "没有蓝牙设备", Toast.LENGTH_LONG).show();
      finish();
      return;
    }

    if (mBluetoothAdapter.isEnabled()) {
      but_On_Off.setText("关闭蓝牙");
    } else {
      but_On_Off.setText("开启蓝牙");
    }

    but_On_Off.setOnClickListener(new OnClickListener() {

      @Override
      public void onClick(View v) {
        if (!mBluetoothAdapter.isEnabled()) {
          mBluetoothAdapter.enable();
          Toast.makeText(BluetoothChat.this, "蓝牙已开启",
              Toast.LENGTH_SHORT).show();
          but_On_Off.setText("关闭蓝牙");
        } else {
          mBluetoothAdapter.disable();
          Toast.makeText(BluetoothChat.this, "蓝牙已关闭",
              Toast.LENGTH_SHORT).show();
          but_On_Off.setText("开启蓝牙");
        }
      }
    });

    but_search.setOnClickListener(new OnClickListener() {

      @Override
      public void onClick(View v) {
        searchDevice();
      }
    });

    but_create.setOnClickListener(new OnClickListener() {

      @Override
      public void onClick(View v) {

        final EditText et = new EditText(BluetoothChat.this);
        et.setSingleLine();
        et.setText(mBluetoothAdapter.getName());

        new AlertDialog.Builder(BluetoothChat.this)
            .setTitle("请输入房间名:")
            .setView(et)
            .setPositiveButton("确定",
                new DialogInterface.OnClickListener() {

                  @Override
                  public void onClick(DialogInterface dialog,
                      int which) {
                    String name = et.getText().toString()
                        .trim();
                    if (name.equals("")) {
                      Toast.makeText(BluetoothChat.this,
                          "请输入房间名",
                          Toast.LENGTH_SHORT).show();
                      return;
                    }
                    // 设置房间名
                    mBluetoothAdapter.setName(name);
                  }

                })
            .setNegativeButton("取消",
                new DialogInterface.OnClickListener() {

                  @Override
                  public void onClick(DialogInterface dialog,
                      int which) {

                  }
                }).create().show();

        // 创建连接,也就是设备本地蓝牙设备可被其他用户的蓝牙搜到
        ensureDiscoverable();
      }
    });

    // 获得一个已经配对的蓝牙设备的set集合
    Set<BluetoothDevice> pairedDevices = mBluetoothAdapter
        .getBondedDevices();
    if (pairedDevices.size() > 0) {
      for (BluetoothDevice device : pairedDevices) {
        mPairedDevicesList.add("已配对:" + device.getName() + "\n"
            + device.getAddress());
      }
    } else {
      Toast.makeText(this, "没有已配对的设备", Toast.LENGTH_SHORT).show();
    }

    // 当发现一个新的蓝牙设备时注册广播
    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
    this.registerReceiver(mReceiver, filter);

    // 当搜索完毕后注册广播
    filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
    this.registerReceiver(mReceiver, filter);

  }

  @Override
  public void onStart() {
    super.onStart();
    // If BT is not on, request that it be enabled.
    // setupChat() will then be called during onActivityResult
    if (!mBluetoothAdapter.isEnabled()) {
      Intent enableIntent = new Intent(
          BluetoothAdapter.ACTION_REQUEST_ENABLE);
      startActivityForResult(enableIntent, REQUEST_ENABLE_BT);
      // Otherwise, setup the chat session
    } else {
      if (mChatService == null)
        setupChat();
    }
  }

  @Override
  public synchronized void onResume() {
    super.onResume();
    // Performing this check in onResume() covers the case in which BT was
    // not enabled during onStart(), so we were paused to enable it...
    // onResume() will be called when ACTION_REQUEST_ENABLE activity
    // returns.
    if (mChatService != null) {
      // Only if the state is STATE_NONE, do we know that we haven't
      // started already
      if (mChatService.getState() == BluetoothChatService.STATE_NONE) {
        // Start the Bluetooth chat services
        mChatService.start();
      }
    }
  }

  private void setupChat() {

    mSendButton.setOnClickListener(new OnClickListener() {
      public void onClick(View v) {
        // Send a message using content of the edit text widget
        String message = text_input.getText().toString();
        sendMessage(message);
      }
    });

    // Initialize the BluetoothChatService to perform bluetooth connections
    mChatService = new BluetoothChatService(this, mHandler);

    // Initialize the buffer for outgoing messages
    mOutStringBuffer = new StringBuffer("");
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
    // Stop the Bluetooth chat services
    if (mChatService != null)
      mChatService.stop();

    // Make sure we're not doing discovery anymore
    if (mBluetoothAdapter != null) {
      mBluetoothAdapter.cancelDiscovery();
    }
    // Unregister broadcast listeners
    this.unregisterReceiver(mReceiver);
  }

  /** 使本地的蓝牙设备可被发现 */
  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);
    }
  }

  /**
   * Sends a message.
   *
   * @param message
   *      A string of text to send.
   */
  private void sendMessage(String message) {
    // Check that we're actually connected before trying anything
    if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {
      Toast.makeText(this, "没有连接上", Toast.LENGTH_SHORT).show();
      return;
    }

    // Check that there's actually something to send
    if (message.length() > 0) {
      // Get the message bytes and tell the BluetoothChatService to write
      byte[] send = message.getBytes();
      mChatService.write(send);

      // Reset out string buffer to zero and clear the edit text field
      mOutStringBuffer.setLength(0);
      text_input.setText(mOutStringBuffer);
    }
  }

  // The Handler that gets information back from the BluetoothChatService
  private final Handler mHandler = new Handler() {

    @Override
    public void handleMessage(Message msg) {
      switch (msg.what) {
      case MESSAGE_STATE_CHANGE:
        switch (msg.arg1) {
        case BluetoothChatService.STATE_CONNECTED:
          mTitle.setText("已经连接");
          mTitle.append(mConnectedDeviceName);
          // mConversationArrayAdapter.clear();
          break;
        case BluetoothChatService.STATE_CONNECTING:
          mTitle.setText("正在连接中...");
          break;
        case BluetoothChatService.STATE_LISTEN:
        case BluetoothChatService.STATE_NONE:
          mTitle.setText("未连接上");
          break;
        }
        break;
      case MESSAGE_WRITE:
        byte[] writeBuf = (byte[]) msg.obj;
        // construct a string from the buffer
        String writeMessage = new String(writeBuf);
        // mConversationArrayAdapter.add("Me: " + writeMessage);
        text_chat.append("我:" + writeMessage + "\n");
        break;
      case MESSAGE_READ:
        byte[] readBuf = (byte[]) msg.obj;
        // construct a string from the valid bytes in the buffer
        String readMessage = new String(readBuf, 0, msg.arg1);
        // mConversationArrayAdapter.add(mConnectedDeviceName+": " +
        // readMessage);
        text_chat.append(mConnectedDeviceName + ":" + readMessage
            + "\n");
        break;
      case MESSAGE_DEVICE_NAME:
        // save the connected device's name
        mConnectedDeviceName = msg.getData().getString(DEVICE_NAME);
        Toast.makeText(getApplicationContext(),
            "连接到 " + mConnectedDeviceName, Toast.LENGTH_SHORT)
            .show();
        break;
      case MESSAGE_TOAST:
        Toast.makeText(getApplicationContext(),
            msg.getData().getString(TOAST), Toast.LENGTH_SHORT)
            .show();
        break;
      }
    }
  };

  // 连接蓝牙设备
  private void linkDevice() {
    if (mBluetoothAdapter.isDiscovering()) {
      mBluetoothAdapter.cancelDiscovery();
    }
    int cou = mPairedDevicesList.size() + mNewDevicesList.size();
    if (cou == 0) {
      Toast.makeText(BluetoothChat.this, "没有搜索到可用的蓝牙设备",
          Toast.LENGTH_SHORT).show();
      return;
    }

    // 把已经配对的蓝牙设备和新发现的蓝牙设备的名称都放入数组中,以便在对话框列表中显示
    strName = new String[cou];
    for (int i = 0; i < mPairedDevicesList.size(); i++) {
      strName[i] = mPairedDevicesList.get(i);
    }
    for (int i = mPairedDevicesList.size(); i < strName.length; i++) {
      strName[i] = mNewDevicesList.get(i - mPairedDevicesList.size());
    }
    address = strName[0].substring(strName[0].length() - 17);
    new AlertDialog.Builder(BluetoothChat.this)
        .setTitle("搜索到的蓝牙设备:")
        .setSingleChoiceItems(strName, 0,
            new DialogInterface.OnClickListener() {

              @Override
              public void onClick(DialogInterface dialog,
                  int which) {
                // 当用户点击选中的蓝牙设备时,取出选中的蓝牙设备的MAC地址
                address = strName[which].split("\\n")[1].trim();
              }
            })
        .setPositiveButton("连接", new DialogInterface.OnClickListener() {

          @Override
          public void onClick(DialogInterface dialog, int which) {
            if (address == null) {
              Toast.makeText(BluetoothChat.this, "请先连接外部蓝牙设备",
                  Toast.LENGTH_SHORT).show();
              return;
            }

            Log.i("sxd", "address:" + address);
            // Get the BLuetoothDevice object
            BluetoothDevice device = mBluetoothAdapter
                .getRemoteDevice(address);
            // Attempt to connect to the device
            mChatService.connect(device);
          }
        })
        .setNegativeButton("取消", new DialogInterface.OnClickListener() {

          @Override
          public void onClick(DialogInterface dialog, int which) {

          }
        }).create().show();
  }

  // 搜索蓝牙设备蓝牙设备
  private void searchDevice() {
    mTitle.setText("正在努力搜索中...");
    setProgressBarIndeterminateVisibility(true);
    if (mBluetoothAdapter.isDiscovering()) {
      mBluetoothAdapter.cancelDiscovery();
    }
    mNewDevicesList.clear();
    mBluetoothAdapter.startDiscovery();
  }

  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    menu.add(0, 1, 0, "搜索设备");
    menu.add(0, 2, 0, "可被发现");
    return true;
  }

  private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
      String action = intent.getAction();
      // 当发现一个新的蓝牙设备时
      if (BluetoothDevice.ACTION_FOUND.equals(action)) {
        BluetoothDevice device = intent
            .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
        // If it's already paired, skip it, because it's been listed
        // already
        if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
          String s = "未配对: " + device.getName() + "\n"
              + device.getAddress();
          if (!mNewDevicesList.contains(s))
            mNewDevicesList.add(s);
        }
        // When discovery is finished, change the Activity title
      } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED
          .equals(action)) {
        setProgressBarIndeterminateVisibility(false);
        if (mNewDevicesList.size() == 0) {
          Toast.makeText(BluetoothChat.this, "没有发现新设备",
              Toast.LENGTH_SHORT).show();
        }
        mTitle.setText("未连接");
        linkDevice();
      }
    }
  };

  @Override
  public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
    case 1:
      searchDevice();
      return true;
    case 2:
      // Ensure this device is discoverable by others
      ensureDiscoverable();
      return true;
    }
    return false;
  }

}
package com.it2388.bluetooth;

/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

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

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

/**
 * This class does all the work for setting up and managing Bluetooth
 * connections with other devices. It has a thread that listens for incoming
 * connections, a thread for connecting with a device, and a thread for
 * performing data transmissions when connected.
 *
 * *这个类做所有的工作,建立和管理蓝牙 与其他设备的连接。它有一个线程监听 传入的连接,一个用于连接一个设备的线程,和一个 当连接时执行数据传输的线程。
 */
public class BluetoothChatService {
  // Debugging
  private static final String TAG = "BluetoothChatService";
  private static final boolean D = true;

  // Name for the SDP record when creating server socket 对于SDP记录名称创建服务器套接字时
  private static final String NAME = "BluetoothChat";

  // Unique UUID for this application
  private static final UUID MY_UUID = UUID
      .fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");

  // Member fields
  private final BluetoothAdapter mAdapter;
  private final Handler mHandler;
  private AcceptThread mAcceptThread;
  private ConnectThread mConnectThread;
  private ConnectedThread mConnectedThread;
  private int mState;

  // Constants that indicate the current connection state
  public static final int STATE_NONE = 0; // we're doing nothing 我们什么都不做
  public static final int STATE_LISTEN = 1; // now listening for incoming 现在监听
                        // connections
  public static final int STATE_CONNECTING = 2; // now initiating an outgoing
                          // 启动一个外向
                          // connection
  public static final int STATE_CONNECTED = 3; // now connected to a remote
                          // 连接到一个远程
                          // device

  /**
   * Constructor. Prepares a new BluetoothChat session.
   *
   * @param context
   *      The UI Activity Context
   * @param handler
   *      A Handler to send messages back to the UI Activity
   */
  public BluetoothChatService(Context context, Handler handler) {
    mAdapter = BluetoothAdapter.getDefaultAdapter();
    mState = STATE_NONE;
    mHandler = handler;
  }

  /**
   * Set the current state of the chat connection
   *
   * @param state
   *      An integer defining the current connection state
   */
  private synchronized void setState(int state) {
    if (D)
      Log.d(TAG, "setState() " + mState + " -> " + state);
    mState = state;

    // Give the new state to the Handler so the UI Activity can update
    mHandler.obtainMessage(BluetoothChat.MESSAGE_STATE_CHANGE, state, -1)
        .sendToTarget();
  }

  /**
   * Return the current connection state.
   */
  public synchronized int getState() {
    return mState;
  }

  /**
   * Start the chat service. Specifically start AcceptThread to begin a
   * session in listening (server) mode. Called by the Activity onResume()
   */
  public synchronized void start() {
    if (D)
      Log.d(TAG, "start");

    // Cancel any thread attempting to make a connection
    if (mConnectThread != null) {
      mConnectThread.cancel();
      mConnectThread = null;
    }

    // Cancel any thread currently running a connection
    if (mConnectedThread != null) {
      mConnectedThread.cancel();
      mConnectedThread = null;
    }

    // Start the thread to listen on a BluetoothServerSocket
    if (mAcceptThread == null) {
      mAcceptThread = new AcceptThread();
      mAcceptThread.start();
    }
    setState(STATE_LISTEN);
  }

  /**
   * Start the ConnectThread to initiate a connection to a remote device.
   *
   * @param device
   *      The BluetoothDevice to connect
   */
  public synchronized void connect(BluetoothDevice device) {
    if (D)
      Log.d(TAG, "connect to: " + device);

    // Cancel any thread attempting to make a connection
    if (mState == STATE_CONNECTING) {
      if (mConnectThread != null) {
        mConnectThread.cancel();
        mConnectThread = null;
      }
    }

    // Cancel any thread currently running a connection
    if (mConnectedThread != null) {
      mConnectedThread.cancel();
      mConnectedThread = null;
    }

    // Start the thread to connect with the given device
    mConnectThread = new ConnectThread(device);
    mConnectThread.start();
    setState(STATE_CONNECTING);
  }

  /**
   * Start the ConnectedThread to begin managing a Bluetooth connection
   *
   * @param socket
   *      The BluetoothSocket on which the connection was made
   * @param device
   *      The BluetoothDevice that has been connected
   */
  public synchronized void connected(BluetoothSocket socket,
      BluetoothDevice device) {
    if (D)
      Log.d(TAG, "connected");

    // Cancel the thread that completed the connection
    if (mConnectThread != null) {
      mConnectThread.cancel();
      mConnectThread = null;
    }

    // Cancel any thread currently running a connection
    if (mConnectedThread != null) {
      mConnectedThread.cancel();
      mConnectedThread = null;
    }

    // Cancel the accept thread because we only want to connect to one
    // device
    if (mAcceptThread != null) {
      mAcceptThread.cancel();
      mAcceptThread = null;
    }

    // Start the thread to manage the connection and perform transmissions
    mConnectedThread = new ConnectedThread(socket);
    mConnectedThread.start();

    // Send the name of the connected device back to the UI Activity
    Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_DEVICE_NAME);
    Bundle bundle = new Bundle();
    bundle.putString(BluetoothChat.DEVICE_NAME, device.getName());
    msg.setData(bundle);
    mHandler.sendMessage(msg);

    setState(STATE_CONNECTED);
  }

  /**
   * Stop all threads
   */
  public synchronized void stop() {
    if (D)
      Log.d(TAG, "stop");
    if (mConnectThread != null) {
      mConnectThread.cancel();
      mConnectThread = null;
    }
    if (mConnectedThread != null) {
      mConnectedThread.cancel();
      mConnectedThread = null;
    }
    if (mAcceptThread != null) {
      mAcceptThread.cancel();
      mAcceptThread = null;
    }
    setState(STATE_NONE);
  }

  /**
   * Write to the ConnectedThread in an unsynchronized manner
   *
   * @param out
   *      The bytes to write
   * @see ConnectedThread#write(byte[])
   */
  public void write(byte[] out) {
    // Create temporary object
    ConnectedThread r;
    // Synchronize a copy of the ConnectedThread
    synchronized (this) {
      if (mState != STATE_CONNECTED)
        return;
      r = mConnectedThread;
    }
    // Perform the write unsynchronized
    r.write(out);
  }

  /**
   * Indicate that the connection attempt failed and notify the UI Activity.
   */
  private void connectionFailed() {
    setState(STATE_LISTEN);

    // Send a failure message back to the Activity
    Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);
    Bundle bundle = new Bundle();
    bundle.putString(BluetoothChat.TOAST, "不能连接到设备");
    msg.setData(bundle);
    mHandler.sendMessage(msg);
  }

  /**
   * Indicate that the connection was lost and notify the UI Activity.
   */
  private void connectionLost() {
    setState(STATE_LISTEN);

    // Send a failure message back to the Activity
    Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);
    Bundle bundle = new Bundle();
    bundle.putString(BluetoothChat.TOAST, "设备连接中断");
    msg.setData(bundle);
    mHandler.sendMessage(msg);
  }

  /**
   * This thread runs while listening for incoming connections. It behaves
   * like a server-side client. It runs until a connection is accepted (or
   * until cancelled).
   */
  private class AcceptThread extends Thread {
    // The local server socket
    private final BluetoothServerSocket mmServerSocket;

    public AcceptThread() {
      BluetoothServerSocket tmp = null;
      // Create a new listening server socket
      try {
        tmp = mAdapter
            .listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
      } catch (IOException e) {
        Log.e("sxd", " ======== ufcomm exception =======", e);
      }
      mmServerSocket = tmp;
    }

    public void run() {
      if (D)
        Log.d(TAG, "BEGIN mAcceptThread" + this);
      setName("AcceptThread");
      BluetoothSocket socket = null;

      // Listen to the server socket if we're not connected
      while (mState != STATE_CONNECTED) {
        try {
          // This is a blocking call and will only return on a
          // successful connection or an exception
          socket = mmServerSocket.accept();
        } catch (IOException e) {
          Log.e("sxd", "---> accept socket failed <---", e);
          break;
        }

        // If a connection was accepted
        if (socket != null) {
          synchronized (BluetoothChatService.this) {
            switch (mState) {
            case STATE_LISTEN:
            case STATE_CONNECTING:
              // Situation normal. Start the connected thread.
              connected(socket, socket.getRemoteDevice());
              break;
            case STATE_NONE:
            case STATE_CONNECTED:
              // Either not ready or already connected. Terminate
              // new socket.
              try {
                socket.close();
              } catch (IOException e) {
                Log.e(TAG, "Could not close unwanted socket", e);
              }
              break;
            }
          }
        }
      }
      if (D)
        Log.i(TAG, "END mAcceptThread");
    }

    public void cancel() {
      if (D)
        Log.d(TAG, "cancel " + this);
      try {
        mmServerSocket.close();
      } catch (IOException e) {
        Log.e(TAG, "close() of server failed", e);
      }
    }
  }

  /**
   * This thread runs while attempting to make an outgoing connection with a
   * device. It runs straight through; the connection either succeeds or
   * fails.
   */
  private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;

    public ConnectThread(BluetoothDevice device) {
      mmDevice = device;
      BluetoothSocket tmp = null;

      // Get a BluetoothSocket for a connection with the
      // given BluetoothDevice
      try {
        tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
      } catch (IOException e) {
        Log.e(TAG, "create() failed", e);
      }
      mmSocket = tmp;
    }

    public void run() {
      Log.i(TAG, "BEGIN mConnectThread");
      setName("ConnectThread");

      // Always cancel discovery because it will slow down a connection
      mAdapter.cancelDiscovery();

      // Make a connection to the BluetoothSocket
      try {
        // This is a blocking call and will only return on a
        // successful connection or an exception
        mmSocket.connect();
      } catch (IOException e) {
        Log.e("sxd", "链接发生了异常", e);
        connectionFailed();
        // Close the socket
        try {
          mmSocket.close();
        } catch (IOException e2) {
          Log.e(TAG,
              "unable to close() socket during connection failure",
              e2);
        }
        // Start the service over to restart listening mode
        BluetoothChatService.this.start();
        return;
      }

      // Reset the ConnectThread because we're done
      synchronized (BluetoothChatService.this) {
        mConnectThread = null;
      }

      // Start the connected thread
      connected(mmSocket, mmDevice);
    }

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

  /**
   * This thread runs during a connection with a remote device. It handles all
   * incoming and outgoing transmissions.
   *
   * 和已经建立连接的设置进行数据的传输
   */
  private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;

    public ConnectedThread(BluetoothSocket socket) {
      Log.d(TAG, "create ConnectedThread");
      mmSocket = socket;
      InputStream tmpIn = null;
      OutputStream tmpOut = null;

      // Get the BluetoothSocket input and output streams
      try {
        tmpIn = socket.getInputStream();
        tmpOut = socket.getOutputStream();
      } catch (IOException e) {
        Log.e(TAG, "temp sockets not created", e);
      }

      mmInStream = tmpIn;
      mmOutStream = tmpOut;
    }

    public void run() {
      Log.i(TAG, "BEGIN mConnectedThread");
      byte[] buffer = new byte[1024];
      int bytes;

      // Keep listening to the InputStream while connected
      while (true) {
        try {
          // Read from the InputStream
          bytes = mmInStream.read(buffer);

          // Send the obtained bytes to the UI Activity
          mHandler.obtainMessage(BluetoothChat.MESSAGE_READ, bytes,
              -1, buffer).sendToTarget();
        } catch (IOException e) {
          Log.e(TAG, "disconnected", e);
          connectionLost();
          break;
        }
      }
    }

    /**
     * Write to the connected OutStream.
     *
     * @param buffer
     *      The bytes to write
     */
    public void write(byte[] buffer) {
      try {
        mmOutStream.write(buffer);

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

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

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。

以上是小编为您精心准备的的内容,在的博客、问答、公众号、人物、课程等栏目也有的相关内容,欢迎继续使用右上角搜索按钮进行搜索android蓝牙通信
android蓝牙聊天
smtp是发送还是接受、手机不能接受发送短信、蓝牙怎么接受打开、c 视频流接受和发送、qq无法接受和发送图片,以便于您获取更多的相关知识。

时间: 2024-08-29 07:28:08

Android蓝牙通信聊天实现发送和接受功能_Android的相关文章

android应用-android蓝牙通信,制图

问题描述 android蓝牙通信,制图 目的是做一个android应用,从蓝牙接受数据,数据是16进制的,将其绘制成波形 我的问题是----毫无头绪... S0 S320 S396 S450 S508 S536 S506 S517 S546 S531 S509 S497 S503 S485 S470 S496 S506 S518 S511 S514 S522 S504 S491 S489 S484 S484 S493 S485 S516 S497 S512 S524 S516 S507 S500

Android蓝牙通信概述

通常情况下,我们对蓝牙的操作主要有:开启和关闭蓝牙.搜索周边设备.能被周边设备所发现.获取配对设备.蓝牙设备间的数据传输. 1.打开蓝牙(当然首先要确保你的手机是有蓝牙设备的) 蓝牙设备主要分为两部分,一部分为本地设备,另一部分为远程设备. BluetoothAdapter--本地设备,对蓝牙操作首先就需要有一个BluetoothAdapter实例.常用的几个方法如下: cancelDiscovery()--取消本地蓝牙设备的搜索操作,如果本地设备正在进行搜索,那么调用该方法后将停止搜索操作.

android-关于Android蓝牙通信的问题

问题描述 关于Android蓝牙通信的问题 想实现Android 和PC之间的蓝牙通信,在网上查找后发现有手机端和PC端两个代码要写,但是我不知道PC端的代码是写在手机端的那个APP里,还是单独再创建一个APP写作新的APP里面 解决方案 最近同学要做一个手机与蓝牙模块的通信的毕业设计,让我帮忙写一个手机端的应用,匆匆的找了些资料,总算是能勉强实现通信,总结一些关键的步骤:首先,android蓝牙通信步骤:1:打开蓝牙2:搜索蓝牙设备3:选择设备进行配对(连接前必须先配对)4:对配对好的设备建立

arduino与android蓝牙通信

问题描述 arduino与android蓝牙通信 Arduino与android蓝牙通信.在做一个Arduino的项目,在Arduino的板子上装有温度传感器,然后希望通过蓝牙实时传输到android,请问怎么实现? 解决方案 http://blog.csdn.net/xieyan0811/article/details/21476415 解决方案二: Arduino与Android蓝牙通信笔记

Android 蓝牙2.0的使用方法详解_Android

本文为大家分享了Android操作蓝牙2.0的使用方法,供大家参考,具体内容如下 1.Android操作蓝牙2.0的使用流程 (1)找到设备uuid (2)获取蓝牙适配器,使得蓝牙处于可发现模式,获取下位机的socket,并且与上位机建立建立连接,获取获取输入流和输出流,两个流都不为空时,表示连接成功.否则是连接失败. (3).与下位机的socket开始通信. (4).通信结束后,断开连接(关闭流,关闭socket) 2接下来接直接上代码:2.1找到设备uuid(一般厂商都会给开发者提供) 复制

Android蓝牙通信编程_Android

项目涉及蓝牙通信,所以就简单的学了学,下面是自己参考了一些资料后的总结,希望对大家有帮助.  以下是开发中的几个关键步骤: 1.首先开启蓝牙  2.搜索可用设备  3.创建蓝牙socket,获取输入输出流  4.读取和写入数据 5.断开连接关闭蓝牙  下面是一个蓝牙聊天demo  效果图:  在使用蓝牙是 BluetoothAdapter 对蓝牙开启,关闭,获取设备列表,发现设备,搜索等核心功能  下面对它进行封装:  package com.xiaoyu.bluetooth; import j

Android仿QQ聊天撒花特效 很真实_Android

先看看效果图吧 实现这样的效果,你要知道贝塞尔曲线,何谓贝塞尔曲线?先在这里打个问号 下面就直接写了 1.activity_main.xml <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent

Android使用httpPost向服务器发送请求的方法_Android

本文实例讲述了Android使用httpPost向服务器发送请求的方法.分享给大家供大家参考,具体如下: import java.util.List; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.apache.http.client.HttpClient; import org.apache.http

Android仿微信QQ设置图形头像裁剪功能_Android

最近在做毕业设计,想有一个功能和QQ一样可以裁剪头像并设置圆形头像,额,这是设计狮的一种潮流. 而纵观现在主流的APP,只要有用户系统这个功能,这个需求一般都是在(bu)劫(de)难(bu)逃(xue)! 图片裁剪实现方式有两种,一种是利用系统自带的裁剪工具,一种是使用开源工具Cropper.本节就为大家带来如何使用系统自带的裁剪工具进行图片裁剪~ 还是先来个简单的运行图. 额,简单说下,我待会会把代码写成小demo分享给大家,在文章末尾会附上github链接,需要的可以自行下载~ 下面来简单分