蓝牙socket编程

❶ 安卓开发 蓝牙 后台

用一个service

java">//获取适配器BluetoothAdaptermAdapter=BluetoothAdapter.getDefaultAdapter();
//不做提示，强行打开
if(!mAdapter.isEnabled()){
mAdapter.enable();
}
BroadcastReceivermReceiver=newBroadcastReceiver(){
publicvoidonReceive(Contextcontext,Intentintent){
Stringaction=intent.getAction();
//找到设备
if(BluetoothDevice.ACTION_FOUND.equals(action)){

BluetoothDevicedevice=intent
.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
if(device.getBondState()!=BluetoothDevice.BOND_BONDED){


}

}

//搜索完成

elseif(BluetoothAdapter.ACTION_DISCOVERY_FINISHED
.equals(action)){
if(mNewDevicesAdapter.getCount()==0){

Log.v(TAG,"findover");

}

}
//执行更新列表的代码后台这里就不需要更新
}
};

//注册广播接收者
IntentFilterfilter=newIntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver,filter);
filter=newIntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
registerReceiver(mReceiver,filter);
//这样就可以获取到所有的连接对象了然后在里面选择一个制定的mac地址使用
BluetoothSocketclienSocket=dcvice.(UUID);
clienSocket.connect();
inputStream=socket.getInputStream();
//将对象设备看作服务端然后get出流再将流转化成字符串就可以判断服务端发出的命令了这些都可以在service中完成纯手打如有相同答案请看清楚时间先后杜绝抄袭！望楼主采纳！~

❷ 怎么通过java接受蓝牙传递过来的数据

//服务端：server.cpp
#include<stdio.h>
#include<winsock2.h>

#pragmacomment(lib,"ws2_32.lib")

intmain(intargc,char*argv[])
{
//初始化WSA
WORDsockVersion=MAKEWORD(2,2);
WSADATAwsaData;
if(WSAStartup(sockVersion,&wsaData)!=0)
{
return0;
}

//创建套接字
SOCKETslisten=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(slisten==INVALID_SOCKET)
{
printf("socketerror!");
return0;
}

//绑定IP和端口
sockaddr_insin;
sin.sin_family=AF_INET;
sin.sin_port=htons(8888);
sin.sin_addr.S_un.S_addr=INADDR_ANY;
if(bind(slisten,(LPSOCKADDR)&sin,sizeof(sin))==SOCKET_ERROR)
{
printf("binderror!");
}

//开始监听
if(listen(slisten,5)==SOCKET_ERROR)
{
printf("listenerror!");
return0;
}

//循环接收数据
SOCKETsClient;
sockaddr_inremoteAddr;
intnAddrlen=sizeof(remoteAddr);
charrevData[255];
while(true)
{
printf("等待连接...
");
sClient=accept(slisten,(SOCKADDR*)&remoteAddr,&nAddrlen);
if(sClient==INVALID_SOCKET)
{
printf("accepterror!");
continue;
}
printf("接受到一个连接：%s
",inet_ntoa(remoteAddr.sin_addr));

//接收数据
intret=recv(sClient,revData,255,0);
if(ret>0)
{
revData[ret]=0x00;
printf(revData);
}

//发送数据
constchar*sendData="你好，TCP客户端！
";
send(sClient,sendData,strlen(sendData),0);
closesocket(sClient);
}

closesocket(slisten);
WSACleanup();
return0;
}
//客户端：client.cpp
#include<WINSOCK2.H>
#include<STDIO.H>
#include<iostream>
#include<cstring>
usingnamespacestd;
#pragmacomment(lib,"ws2_32.lib")

intmain()
{
WORDsockVersion=MAKEWORD(2,2);
WSADATAdata;
if(WSAStartup(sockVersion,&data)!=0)
{
return0;
}
while(true){
SOCKETsclient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sclient==INVALID_SOCKET)
{
printf("invalidsocket!");
return0;
}

sockaddr_inserAddr;
serAddr.sin_family=AF_INET;
serAddr.sin_port=htons(8888);
serAddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
if(connect(sclient,(sockaddr*)&serAddr,sizeof(serAddr))==SOCKET_ERROR)
{//连接失败
printf("connecterror!");
closesocket(sclient);
return0;
}

stringdata;
cin>>data;
constchar*sendData;
sendData=data.c_str();//string转constchar*
//char*sendData="你好，TCP服务端，我是客户端
";
send(sclient,sendData,strlen(sendData),0);
//send()用来将数据由指定的socket传给对方主机
//intsend(ints,constvoid*msg,intlen,unsignedintflags)
//s为已建立好连接的socket，msg指向数据内容，len则为数据长度，参数flags一般设0
//成功则返回实际传送出去的字符数，失败返回-1，错误原因存于error

charrecData[255];
intret=recv(sclient,recData,255,0);
if(ret>0){
recData[ret]=0x00;
printf(recData);
}
closesocket(sclient);
}


WSACleanup();
return0;
}

❸ c++中蓝牙编程的库类

安装PSDK就可以用了，之前有写过一个类在MFC里面调用，并能成功与蓝牙手机通信，只不过是非标准的蓝牙协议。代码如下：
=====================h头文件========================

#ifndef NS_BTH
#include "ws2bth.h" //如果没有定义NS_BTH宏，则将PSDK头文件包含进来
#endif

#ifndef BTH_ADDR
typedef ULONGLONG BTH_ADDR;
#endif

#ifndef SAFE_DELETE
#define SAFE_DELETE(pObj) {if(pObj) delete pObj; pObj = NULL;}
#endif

#ifndef SAFE_DELETERG
#define SAFE_DELETERG(pObj) {if(pObj) delete [] pObj; pObj = NULL;}
#endif

#define RECEIVE_OVER_COMMAND 0x00001000

typedef struct _tag_BthDev_Info
{
BTH_ADDR btAddr;
TCHAR szAddr[32];
TCHAR szName[128];

_tag_BthDev_Info()
{
memset(this, 0, sizeof(this));
}
}
BTHDEV_INFO;

class CGGBlueTooth
{
public:
CGGBlueTooth();
~CGGBlueTooth();

BOOL StartSearchBthDev(IN DWORD dwControlFlags);
BOOL GetNextBthDev(
IN OUT BTHDEV_INFO *pcBthDevInfo,
IN DWORD dwControlFlags = LUP_RETURN_NAME | LUP_RETURN_ADDR | LUP_FLUSHCACHE
);
BOOL EndSearchBthDev();

//Socket Api
BOOL Create(int af = AF_BTH, int type = SOCK_STREAM, int protocol = BTHPROTO_RFCOMM);
BOOL Close();

//If no error occurs, this function returns zero. If an error occurs, it returns SOCKET_ERROR
int Bind(BTH_ADDR sktAddr = 0, ULONG port = BT_PORT_ANY);
int Listen(IN int backlog);
int GetSockName(BTH_ADDR *psktAddr, ULONG *port);
int SetBthService(TCHAR *lpServiceName);
int Accept(CGGBlueTooth *pcBth);
int Connect(BTH_ADDR sktAddr, ULONG port, int nMSecond = -1);
int Send(LPVOID lpData, int len, int flags = 0);
int Recv(LPVOID lpData, int len, int flags = 0);
int SendAll(LPVOID lpData, int len, int flags = 0);
int RecvAll(LPVOID lpData, int len, int flags = 0);

private:
void HexMac2String(BTH_ADDR dw64Addr, TCHAR *pstrMac);

private:
HANDLE m_hLookup;
SOCKET m_hSocket;
SOCKADDR_BTH m_sktAddr;
};

==============cpp文件================

#include "stdafx.h"
#include "GGBlueTooth.h"
//#include "tchar.h"

CGGBlueTooth::CGGBlueTooth()
: m_hLookup(NULL)
, m_hSocket(NULL)
{
memset(&m_sktAddr, 0, sizeof(m_sktAddr));
}

CGGBlueTooth::~CGGBlueTooth()
{
EndSearchBthDev();
Close();
}

void CGGBlueTooth::HexMac2String(BTH_ADDR dw64Addr, TCHAR *pstrMac)
{
BYTE *pbAddr = (BYTE*)&dw64Addr;

_stprintf(
pstrMac, _T("%02X:%02X:%02X:%02X:%02X:%02X"),
pbAddr[5], pbAddr[4], pbAddr[3],
pbAddr[2], pbAddr[1], pbAddr[0]
);
}

BOOL CGGBlueTooth::StartSearchBthDev(IN DWORD dwControlFlags)
{
WSAQUERYSET wsaq;
ZeroMemory(&wsaq, sizeof(wsaq));
wsaq.dwSize = sizeof(wsaq);
wsaq.dwNameSpace = NS_BTH;
wsaq.lpcsaBuffer = NULL;

return WSALookupServiceBegin(&wsaq, dwControlFlags, &m_hLookup) == ERROR_SUCCESS ? TRUE : FALSE;
}

BOOL CGGBlueTooth::GetNextBthDev(
IN OUT BTHDEV_INFO *pcBthDevInfo,
IN DWORD dwControlFlags /* = LUP_RETURN_NAME | LUP_RETURN_ADDR | LUP_FLUSHCACHE*/
)
{
if (!m_hLookup || !pcBthDevInfo)
{
return FALSE;
}

memset(pcBthDevInfo->szAddr, 0, sizeof(pcBthDevInfo->szAddr));
memset(pcBthDevInfo->szName, 0, sizeof(pcBthDevInfo->szName));

union
{
CHAR buf[5000];
double __unused; // ensure proper alignment
};
LPWSAQUERYSET pwsaResults = (LPWSAQUERYSET)buf;
DWORD dwSize = sizeof(buf);
int nResult;

ZeroMemory(pwsaResults, sizeof(WSAQUERYSET));
pwsaResults->dwSize = sizeof(WSAQUERYSET);
pwsaResults->dwNameSpace = NS_BTH;
pwsaResults->lpBlob = NULL;

nResult = WSALookupServiceNext (m_hLookup, dwControlFlags, &dwSize, pwsaResults);
if (nResult == ERROR_SUCCESS)
{
pcBthDevInfo->btAddr = ((SOCKADDR_BTH *)pwsaResults->lpcsaBuffer->RemoteAddr.lpSockaddr)->btAddr;
BOOL bHaveName = pwsaResults->lpszServiceInstanceName && *(pwsaResults->lpszServiceInstanceName);

if (bHaveName)
{
HexMac2String(pcBthDevInfo->btAddr, pcBthDevInfo->szAddr);
_tcscpy(pcBthDevInfo->szName, pwsaResults->lpszServiceInstanceName);
}
return TRUE;
}

return FALSE;
}

BOOL CGGBlueTooth::EndSearchBthDev()
{
if (m_hLookup)
{
WSALookupServiceEnd(m_hLookup);
m_hLookup = NULL;
return TRUE;
}

return FALSE;
}

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

BOOL CGGBlueTooth::Create(int af/* = AF_BTH*/, int type/* = SOCK_STREAM*/, int protocol/* = BTHPROTO_RFCOMM*/)
{
if (m_hSocket)
{
return FALSE;
}

m_hSocket = socket(af, type, protocol);
m_sktAddr.addressFamily = af;
m_sktAddr.serviceClassId = GUID_NULL;
return m_hSocket == INVALID_SOCKET ? FALSE : TRUE;
}

BOOL CGGBlueTooth::Close()
{
if (m_hSocket)
{
closesocket(m_hSocket);
return TRUE;
}
return FALSE;
}

int CGGBlueTooth::Bind(BTH_ADDR sktAddr/* = 0*/, ULONG port/* = BT_PORT_ANY*/)
{
m_sktAddr.btAddr = sktAddr;
m_sktAddr.port = port;
return bind(m_hSocket, (SOCKADDR *)&m_sktAddr, sizeof(m_sktAddr));
}

int CGGBlueTooth::Listen(int backlog)
{
return listen(m_hSocket, backlog);
}

int CGGBlueTooth::GetSockName(BTH_ADDR *psktAddr, ULONG *port)
{
int nLen = sizeof(m_sktAddr);
int nResult = getsockname(m_hSocket, (SOCKADDR *)&m_sktAddr, &nLen);
if (nResult == 0)
{
*psktAddr = m_sktAddr.btAddr;
*port = m_sktAddr.port;
}
return nResult;
}

GUID OBEXFileTransferServiceClass_UUID_EX = {0x00001106, 0x0000, 0x1000, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB};
int CGGBlueTooth::SetBthService(TCHAR * lpServiceName)
{
CSADDR_INFO sockInfo;
sockInfo.iProtocol = BTHPROTO_RFCOMM;
sockInfo.iSocketType = SOCK_STREAM;
sockInfo.LocalAddr.lpSockaddr = (SOCKADDR *)&m_sktAddr;
sockInfo.LocalAddr.iSockaddrLength = sizeof(m_sktAddr);
sockInfo.RemoteAddr.lpSockaddr = (SOCKADDR *)&m_sktAddr;
sockInfo.RemoteAddr.iSockaddrLength = sizeof(m_sktAddr);

WSAQUERYSET svcInfo = {0};
svcInfo.dwSize = sizeof(svcInfo);
svcInfo.dwNameSpace = NS_BTH;
svcInfo.lpszServiceInstanceName = lpServiceName;
svcInfo.lpServiceClassId = &OBEXFileTransferServiceClass_UUID_EX;
svcInfo.dwNumberOfCsAddrs = 1;
svcInfo.lpcsaBuffer = &sockInfo;

return WSASetService(&svcInfo, RNRSERVICE_REGISTER, 0);
}

int CGGBlueTooth::Accept(CGGBlueTooth *pcBth)
{
SOCKADDR_BTH ca;
int size = sizeof(ca);
pcBth->m_hSocket = accept (m_hSocket, (SOCKADDR *)&ca, &size);
pcBth->m_sktAddr = ca;
return pcBth->m_hSocket == INVALID_SOCKET ? SOCKET_ERROR : 0;
}

int CGGBlueTooth::Connect(BTH_ADDR sktAddr, ULONG port, int nMSecond/* = -1*/)
{
SOCKADDR_BTH sa = {0};
sa.addressFamily = AF_BTH;
sa.btAddr = sktAddr;
sa.port = port;

if (nMSecond == -1)
{
return connect(m_hSocket, (LPSOCKADDR)&sa, sizeof(SOCKADDR_BTH));
}

ULONG non_blocking = 1;
ULONG blocking = 0;

int nResult = ioctlsocket(m_hSocket, FIONBIO, &non_blocking);
if (nResult == SOCKET_ERROR)
{
return nResult;
}

nResult = SOCKET_ERROR;
if (connect(m_hSocket, (LPSOCKADDR)&sa, sizeof(SOCKADDR_BTH)) == SOCKET_ERROR)
{
struct timeval tv;
fd_set writefds;

// 设置连接超时时间
tv.tv_sec = nMSecond / 1000; // 秒数
tv.tv_usec = nMSecond % 1000; // 毫秒

FD_ZERO(&writefds);
FD_SET(m_hSocket, &writefds);

nResult = select((int)m_hSocket + 1, NULL, &writefds, NULL, &tv);
if(nResult > 0)
{
if(FD_ISSET(m_hSocket, &writefds))
{
int error = 0;
int len = sizeof(error);
//下面的一句一定要，主要针对防火墙
if(!(getsockopt(m_hSocket, SOL_SOCKET, SO_ERROR, (char *)&error, &len) != 0 || error != 0))
{
nResult = 0;
}
}
}
else if (nResult == 0)
{
nResult = -2;
}
}

if (ioctlsocket(m_hSocket, FIONBIO, &blocking) == SOCKET_ERROR)
{
nResult = SOCKET_ERROR;
}
return nResult;
}

int CGGBlueTooth::Send(LPVOID lpData, int len, int flags/* = 0*/)
{
return send(m_hSocket, (char *)lpData, len, flags);
}

int CGGBlueTooth::Recv(LPVOID lpData, int len, int flags/* = 0*/)
{
return recv(m_hSocket, (char *)lpData, len, flags);
}

int CGGBlueTooth::SendAll(LPVOID lpData, int len, int flags/* = 0*/)
{
int nCount = send(m_hSocket, (char *)lpData, len, flags);
if (nCount == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
{
return SOCKET_ERROR;
}

int nCommand = 0;
nCount = recv(m_hSocket, (char *)&nCommand, 4, flags);
if (nCount != 4 || nCommand != RECEIVE_OVER_COMMAND)
{
return SOCKET_ERROR;
}

return ERROR_SUCCESS;
}

int CGGBlueTooth::RecvAll(LPVOID lpData, int len, int flags/* = 0*/)
{
int nCount = -1, nCurRecv = 0, nMaxRead = 32 * 1024;

while (nCurRecv < len)
{
if (len - nCurRecv < nMaxRead)
{
nMaxRead = len - nCurRecv;
}

nCount = recv(m_hSocket, (char *)lpData + nCurRecv, nMaxRead, flags);

if (nCount == SOCKET_ERROR)
{
if (WSAGetLastError() == WSAEWOULDBLOCK)
{
Sleep(1);
continue;
}
else
{
return SOCKET_ERROR;
}
}

nCurRecv += nCount;
}

int nCommand = RECEIVE_OVER_COMMAND;
nCount = send(m_hSocket, (char *)&nCommand, 4, flags);
if (nCount == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
{
return SOCKET_ERROR;
}

return ERROR_SUCCESS;
}

❹ android-蓝牙传输

通过蓝牙传输数据与Socket类似。在网络中使用Socket和ServerSocket控制客户端和服务端的数据读写。而蓝牙通讯也由客户端和服务端Socket来完成。蓝牙客户端Socket是BluetoothSocket，蓝牙服务端Socket是BluetoothServerSocket。这两个类都在android.bluetooth包中。

如果打算建议两个蓝牙设备之间的连接，则必须实现服务器端与客户端的机制。当两个设备在同一个RFCOMM channel下分别拥有一个连接的BluetoothSocket，这两个设备才可以说是建立了连接。

服务器设备与客户端设备获取BluetoothSocket的途径是不同的。服务器设备是通过accepted一个incoming connection来获取的，而客户端设备则是通过打开一个到服务器的RFCOMMchannel来获取的。

通过调用BluetoothAdapter的(String, UUID) 方法来获取
BluetoothServerSocket(UUID用于客户端与服务器端之间的配对)调用BluetoothServerSocket的 accept() 方法监听连接请求，如果收到请求，则返回一个BluetoothSocket实例。

如果不想在accept其他的连接，则调用BluetoothServerSocket的 close() 方法释放资源(调用该方法后，之前获得的BluetoothSocket实例并没有close。但由于RFCOMM一个时刻只允许在一条channel中有一个连接，则一般在accept一个连接后，便close掉BluetoothServerSocket)

通过搜索得到服务器端的BluetoothService，调用BluetoothService的(String, UUID)方法获取BluetoothSocket(该UUID应该同于服务器端的UUID)。

调用BluetoothSocket的 connect() 方法(该方法为block方法)，如果UUID同服务器端的UUID匹配，并且连接被服务器端accept，则 connect() 方法返回。

❺ Android蓝牙开发——实现蓝牙聊天

与蓝牙开发主要的相关类是以下四个

知道对应API后就可以进行对应的蓝牙开发，这里以获取蓝牙设备为例子

}

搜索设备的回调则需要通过注册广播的形式来获取

定义广播

之后就可以进行个人的一些操作

要实现蓝牙聊天则涉及到蓝牙之间的传输通信，前面也说到了，这里肯定就是用到BluetoothServerSocket以及BluetoothSocket。

蓝牙传输通信相当于服务器端与客户端之间的通信，只不过不同是这里每一个蓝牙设备本身自己 既充当服务器端也充当客户端 ，大致的关系就是

注意，这些连接都是阻塞式的，都要放在线程里去执行。

可以看到，当BluetoothServerSocket监听到有设备连接的时候，就会调用dataTransfer开启一个数据传输。

需要一个ConnectThread来发起

之后建立连接之后就会调用dataTransfer来进行数据传输，同样也需要一个线程来维护数据传输

蓝牙聊天则是基于上面三个线程来进行实现，同样，对于蓝牙文件间的传输也是同个道理，通过输入输出流来进行处理。之后的操作就比较容易处理了

蓝牙聊天

Android 蓝牙开发基本流程

❻ 如何使用Android蓝牙开发

转载 Android平台支持蓝牙网络协议栈，实现蓝牙设备之间数据的无线传输。本文档描述了怎样利用android平台提供的蓝牙API去实现蓝压设备之间的通信。蓝牙具有point-to-point 和 multipoint两种连接功能。
使用蓝牙API，可以做到：
* 搜索蓝牙设备
* 从本地的Bluetooth adapter中查询已经配对的设备
* 建立RFCOMM通道
* 通过service discovery连接到其它设备
* 在设备之间传输数据
* 管理多个连接

基础知识
本文档介绍了如何使用Android的蓝牙API来完成的四个必要的主要任务，使用蓝牙进行设备通信，主要包含四个部分：蓝牙设置、搜索设备（配对的或可见的）、连接、传输数据。
所有的蓝牙API在android.bluetooth包中。实现这些功能主要需要下面这几个类和接口：

BluetoothAdapter
代表本地蓝牙适配器（蓝牙发射器），是所有蓝牙交互的入口。通过它可以搜索其它蓝牙设备，查询已经配对的设备列表，通过已知的MAC地址创建BluetoothDevice，创建BluetoothServerSocket监听来自其它设备的通信。

BluetoothDevice
代表了一个远端的蓝牙设备， 使用它请求远端蓝牙设备连接或者获取 远端蓝牙设备的名称、地址、种类和绑定状态。 （其信息是封装在 bluetoothsocket 中） 。

BluetoothSocket
代表了一个蓝牙套接字的接口（类似于 tcp 中的套接字） ，他是应用程 序通过输入、输出流与其他蓝牙设备通信的连接点。

BluetoothServerSocket
代表打开服务连接来监听可能到来的连接请求 （属于 server 端） ， 为了连接两个蓝牙设备必须有一个设备作为服务器打开一个服务套接字。 当远端设备发起连 接连接请求的时候，并且已经连接到了的时候，Blueboothserversocket 类将会返回一个 bluetoothsocket。

BluetoothClass
描述了一个设备的特性（profile）或该设备上的蓝牙大致可以提供哪些服务(service)，但不可信。比如，设备是一个电话、计算机或手持设备；设备可以提供audio/telephony服务等。可以用它来进行一些UI上的提示。
BluetoothProfile

BluetoothHeadset
提供手机使用蓝牙耳机的支持。这既包括蓝牙耳机和免提（V1.5）模式。

BluetoothA2dp
定义高品质的音频，可以从一个设备传输到另一个蓝牙连接。 “A2DP的”代表高级音频分配模式。

BluetoothHealth
代表了医疗设备配置代理控制的蓝牙服务

BluetoothHealthCallback
一个抽象类，使用实现BluetoothHealth回调。你必须扩展这个类并实现回调方法接收更新应用程序的注册状态和蓝牙通道状态的变化。


代表一个应用程序的配置，蓝牙医疗第三方应用注册与远程蓝牙医疗设备交流。

BluetoothProfile.ServiceListener
当他们已经连接到或从服务断开时通知BluetoothProfile IPX的客户时一个接口（即运行一个特定的配置文件，内部服务）。

蓝牙权限
为了在你的应用中使用蓝牙功能，至少要在AndroidManifest.xml中声明两个权限：BLUETOOTH（任何蓝牙相关API都要使用这个权限） 和 BLUETOOTH_ADMIN（设备搜索、蓝牙设置等）。

为了执行蓝牙通信，例如连接请求，接收连接和传送数据都必须有BLUETOOTH权限。

必须要求BLUETOOTH_ADMIN的权限来启动设备发现或操纵蓝牙设置。大多数应用程序都需要这个权限能力，发现当地的蓝牙设备。此权限授予其他的能力不应该使用，除非应用程序是一个“电源管理”，将根据用户要求修改的蓝牙设置

注释：要请求BLUETOOTH_ADMIN的话，必须要先有BLUETOOTH。

在你的应用manifest 文件中声明蓝牙权限。例如：

<manifest ... >
<uses-permission android:name="android.permission.BLUETOOTH" />
...
</manifest>
通过查看<uses-permission>资料来声明应用权限获取更多的信息。

蓝牙设置
在你的应用通过蓝牙进行通信之前，你需要确认设备是否支持蓝牙，如果支持，确信它被打开。

如果不支持，则不能使用蓝牙功能。如果支持蓝牙，但不能够使用，你刚要在你的应用中请求使用蓝牙。这个要两步完成，使用BluetoothAdapter。

1.获取BluetoothAdapter

所有的蓝牙活动请求BluetoothAdapter，为了获取BluetoothAdapter，呼叫静态方法getDefaultAdapter() 。这个会返回一个BluetoothAdapter，代表设备自己的蓝牙适配器（蓝牙无线电）。这个蓝牙适配器应用于整个系统中，你的应用可以通过这个对象进行交互。如果getDefaultAdapter()返回null,则这个设备不支持蓝牙。例如：

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter == null) {
// Device does not support Bluetooth
}
2.打开蓝牙

其次。你需要确定蓝牙能够使用。通过isEnabled()来检查蓝牙当前是否可用。如果这个方法返回false,则蓝牙不能够使用。为了请求蓝牙使用，呼叫startActivityForResult（）与的ACTION_REQUEST_ENABLE动作意图。通过系统设置中启用蓝牙将发出一个请求（不停止蓝牙应用)。例如：

if (mBluetoothAdapter.isEnabled()) {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}
![http://developer.android.com/images/bt_enable_request.png]

对话框中显示请求使用蓝牙权限。如果响应"Yes",这个进程完成（或失败）后你的应用将能够使用蓝牙。
REQUEST_ENABLE_BT常量作为一个整型传到startActivityForResult()中（值必须大于0），该系统传回给你，在你onActivityResult（）作为实现的requestCode参数。

如果调用蓝牙成功，你的Activity就会在onActivityResult()中收到RESULT_OK结果，如果蓝牙不能使用由于错误（或用户响应“NO”那么结果返回RESULT_CANCELED。

除了通过onActivityResult()，还可以通过监听ACTION_STATE_CHANGED这个broadcast Intent来知道蓝牙状态是否改变。这个Intent包含EXTRA_STATE,EXTRA_PREVIOUS_STATE两个字段，分别代表新旧状态。可能的值是STATE_TURNING_ON, STATE_ON, STATE_TURNING_OFF, 还有STATE_OFF。

小贴： Enabling discoverability 将自动启用蓝牙。如果您计划执行蓝牙活动之前，始终使设备可发现，你可以跳过上面的步骤2。参阅enabling discoverability。

搜索设备
使用BluetoothAdapter可以通过设备搜索或查询配对设备找到远程Bluetooth设备。

Device discovery（设备搜索）是一个扫描搜索本地已使能Bluetooth设备并且从搜索到的设备请求一些信息的过程（有时候会收到类似“discovering”，“inquiring”或“scanning”）。但是，搜索到的本地Bluetooth设备只有在打开被发现功能后才会响应一个discovery请求，响应的信息包括设备名，类，唯一的MAC地址。发起搜寻的设备可以使用这些信息来初始化跟被发现的设备的连接。
一旦与远程设备的第一次连接被建立，一个pairing请求就会自动提交给用户。如果设备已配对，配对设备的基本信息（名称，类，MAC地址）就被保存下来了，能够使用Bluetooth API来读取这些信息。使用已知的远程设备的MAC地址，连接可以在任何时候初始化而不必先完成搜索（当然这是假设远程设备是在可连接的空间范围内）。

需要记住，配对和连接是两个不同的概念：

配对意思是两个设备相互意识到对方的存在，共享一个用来鉴别身份的链路键（link-key），能够与对方建立一个加密的连接。

连接意思是两个设备现在共享一个RFCOMM信道，能够相互传输数据。

目前Android Bluetooth API's要求设备在建立RFCOMM信道前必须配对（配对是在使用Bluetooth API初始化一个加密连接时自动完成的）。

下面描述如何查询已配对设备，搜索新设备。

注意：Android的电源设备默认是不能被发现的。用户可以通过系统设置让它在有限的时间内可以被发现，或者可以在应用程序中要求用户使能被发现功能。

查找匹配设备
在搜索设备前，查询配对设备看需要的设备是否已经是已经存在是很值得的，可以调用getBondedDevices()来做到，该函数会返回一个描述配对设备BluetoothDevice的结果集。例如，可以使用ArrayAdapter查询所有配对设备然后显示所有设备名给用户：

Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
// If there are paired devices
if (pairedDevices.size() > 0) {
// Loop through paired devices
for (BluetoothDevice device : pairedDevices) {
// Add the name and address to an array adapter to show in a ListView
mArrayAdapter.add(device.getName() + "n" + device.getAddress());
}
};
BluetoothDevice对象中需要用来初始化一个连接唯一需要用到的信息就是MAC地址。