藍牙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地址。