bthconnector.cpp

通过手机蓝牙控制个人电脑上的幻灯片的播放

#include "stdafx.h"
#include "BTHConnector.h"
#include <initguid.h>
DEFINE_GUID(g_guidServiceClass,0xa9705ad0,0x9edf,0x11db,0xb6,0x06,0x08,0x00,0x20,0x0c,0x9a,0x66);
#define PACKET_SIZE 45
#define BUFFER_SIZE 48
#define SENDBUFFER_SIZE 50
#define RECVBUFFER_SIZE 50
using namespace BTH_Connection;
using namespace std;
BTHConnector::BTHConnector(void)
{
	intDeviceCount = 0;
	sockBTH = INVALID_SOCKET;
	ClientSocket = INVALID_SOCKET;
	SockAddrBthLocal.addressFamily=NULL;
	SockAddrBthLocal.btAddr=NULL;
	SockAddrBthLocal.port=NULL;
	this->deviceAddrList = __nogc new BTH_ADDR[32];
	Disconnected = true;
	//this->devList = __nogc new System::String[32];
}

BTHConnector::~BTHConnector(void)
{
	delete(deviceAddrList);
	deviceAddrList = NULL;
	delete(this->deviceAddrList);
	this->deviceAddrList = NULL;
}

const char* BTHConnector::toChar(const wchar_t* nString)
{
	static char* string = 0;
	static size_t stringLen = 0;

	size_t i, len=wcslen(nString);

	if(len>stringLen)
	{
		stringLen = len;
		delete string;
		string = new char[stringLen+1];
	}

	for(i=0; i<len; i++)
		string[i] = (char)nString[i];
	string[len] = 0;

	return string;	
};

int BTHConnector::toNativeBTHAddr(const WCHAR **pp, BTH_ADDR *pba)
{
	int i;

	while (**pp == ' ')
		++*pp;

	for (i = 0 ; i < 4 ; ++i, ++*pp) {
		if (! iswxdigit (**pp))
			return FALSE;

		int c = **pp;
		if (c >= 'a')
			c = c - 'a' + 0xa;
		else if (c >= 'A')
			c = c - 'A' + 0xa;
		else c = c - '0';

		if ((c < 0) || (c > 16))
			return FALSE;

		*pba = *pba * 16 + c;
	}

	for (i = 0 ; i < 8 ; ++i, ++*pp) {
		if (! iswxdigit (**pp))
			return FALSE;

		int c = **pp;
		if (c >= 'a')
			c = c - 'a' + 0xa;
		else if (c >= 'A')
			c = c - 'A' + 0xa;
		else c = c - '0';

		if ((c < 0) || (c > 16))
			return FALSE;

		*pba = *pba * 16 + c;
	}

	if ((**pp != ' ') && (**pp != '\0'))
		return FALSE;

	return TRUE;
};
void BTHConnector::convertCharToTCHAR(char *c, TCHAR* t)
{
	int i = 0;
	while (c[i] != '\0'){
		t[i] = (TCHAR) c[i];
		i++;
		}
	t[i] = (TCHAR) c[i];
};

void BTHConnector::convertTCHARToChar(char *c, TCHAR* t){
	int i = 0;
	while (t[i] != '\0'){
		c[i] = (char) t[i];
		i++;
	}
	c[i] = (char) t[i];
}

int BTHConnector::FindDevices(void)
{
	WSAQUERYSET querySet;
	HANDLE hLookup;
	char buffer[1000];
	DWORD bufferlength;
	WSAQUERYSET *results;
	SOCKADDR_BTH *btaddr;
	DWORD flags = LUP_RETURN_NAME | LUP_CONTAINERS | LUP_RETURN_ADDR | LUP_FLUSHCACHE | LUP_RETURN_TYPE |LUP_RETURN_BLOB | LUP_RES_SERVICE;

	WSAPROTOCOL_INFO protocolInfo;
	int protocolInfoSize = sizeof(protocolInfo);
	int i = 0;
	if (0 != getsockopt(this->sockBTH, SOL_SOCKET, SO_PROTOCOL_INFO, (char*)&protocolInfo, &protocolInfoSize))
	{
		exit(1);
	}


	memset(&querySet, 0, sizeof(querySet));
	querySet.dwSize = sizeof(querySet);
	querySet.dwNameSpace = NS_BTH;

	intDeviceCount = 0;

	if(WSALookupServiceBegin(&querySet,flags, &hLookup) == SOCKET_ERROR)
	{
		return WSAGetLastError();
	}

	while(intDeviceCount < BLUETOOTHQUERY_MAXDEVICES)
	{
		bufferlength = sizeof(buffer);
		memset(buffer, 0, sizeof(buffer));
		results = (WSAQUERYSET *) &buffer;

		if (WSALookupServiceNext(hLookup, LUP_RETURN_NAME|LUP_RETURN_ADDR, &bufferlength, results) == SOCKET_ERROR)
		{
			break;
		}
		//CSADDR_INFO *pCSAddr = (CSADDR_INFO *)results->lpcsaBuffer;
		char addrString[1000];
		DWORD addrSize = sizeof(addrString);
		btaddr = (SOCKADDR_BTH *) results->lpcsaBuffer->RemoteAddr.lpSockaddr;
		deviceAddrList[this->intDeviceCount] = btaddr->btAddr;
		
		WSAAddressToString(results->lpcsaBuffer->RemoteAddr.lpSockaddr, results->lpcsaBuffer->RemoteAddr.iSockaddrLength,&protocolInfo,addrString,&addrSize);

		//strcpy(*(this->deviceAddrStringList+(this->intDeviceCount)*30),addrString);
		//------------------------------------------------------------------------------------------------------
		//strcpy(addrString[], "asdas");
		i = 0;
			while (addrString[i] != '\0'){
				this->deviceAddrStringList[this->intDeviceCount][i] = (char) addrString[i];
				i++;
			}
			this->deviceAddrStringList[this->intDeviceCount][i] = (char) addrString[i];
		//------------------------------------------------------------------------------------------------------
		if (results->lpszServiceInstanceName != NULL){
		//strcpy(*(this->deviceNameList+(this->intDeviceCount)*100), results->lpszServiceInstanceName);
		//------------------------------------------------------------------------------------------------------	
			i = 0;
			while (results->lpszServiceInstanceName[i] != '\0'){
				this->deviceNameList[this->intDeviceCount][i] = (char) results->lpszServiceInstanceName[i];
				i++;
			}
			this->deviceNameList[this->intDeviceCount][i] = (char) results->lpszServiceInstanceName[i];
			//------------------------------------------------------------------------------------------------------
			
		}
		else{
			//------------------------------------------------------------------------------------------------------
			char tmp[] = "<unnamed>";
			i =0;
			while(tmp[i]!='\0'){
				this->deviceNameList[this->intDeviceCount][0] = tmp[0];
				i++;
				}
			this->deviceNameList[this->intDeviceCount][i] = tmp[i];
			//------------------------------------------------------------------------------------------------------
			}
		this->intDeviceCount++;
	}

	WSALookupServiceEnd(hLookup);
	return 1;
};

int BTHConnector::InitialiseBluetooth(void){
	if(!BluetoothIsDiscoverable(NULL)){
		if(!::BluetoothEnableDiscovery(NULL,TRUE)){
			return 0;
			}
		this->BluetooothIsEnabled = true;
		}
	return 1;
};

void BTHConnector::TerminateBluetooth(void){
	if(this->BluetooothIsEnabled){
		BluetoothEnableDiscovery(NULL,FALSE);
		this->BluetooothIsEnabled = false;
		}
};


int BTHConnector::InitialiseWinsock(void)
{
	int intReturn;
	WSADATA wsd;
	if (WSAStartup (MAKEWORD(1,0), &wsd)){
		intReturn=0;
	}
	else{
		intReturn=1;
	}
	return intReturn;
};
void BTHConnector::TerminateWinsock(void)
{
	::WSACleanup();
};

bool BTHConnector::IsDeviceVaild(int intDeviceNum)
{
	//char* strReturnMsg;
	const WCHAR* tempBTH_AddrStr=NULL;
	//const char* tempBTH_Name="UNKNOWN";
	char tempBTH_Name[] = "Unknown";
	BTH_ADDR* tempBTH_Addr;
	if(intDeviceNum<-1){
		//strReturnMsg="Invalid Device Num";
		return false;
	}
	//strcpy(tempBTH_Name,this->deviceNameList[intDeviceNum]);
	tempBTH_Addr=&this->deviceAddrList[intDeviceNum];
	if(!this->toNativeBTHAddr(&tempBTH_AddrStr,tempBTH_Addr)){
		//strReturnMsg="Invalid Server Address";
		return false;
	}
	//return strReturnMsg;
	return true;
};

int BTHConnector::InitialiseSocket(void)
{
	this->sockBTH = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
	if(this->sockBTH == INVALID_SOCKET) {
		return 0;
	}
	SOCKADDR_BTH __pin* ptSockAddr = &this->SockAddrBthLocal;
	int intLength = sizeof(*ptSockAddr);
	ZeroMemory(ptSockAddr,intLength);
	SOCKADDR_BTH tempSockAddr_BTH={0};
	this->SetLocalSocketAddress(tempSockAddr_BTH);
	this->SockAddrBthLocal.addressFamily = AF_BTH;
	this->SockAddrBthLocal.port = BT_PORT_ANY;

	if((bind(this->sockBTH,reinterpret_cast<SOCKADDR*>(ptSockAddr),sizeof(SOCKADDR_BTH))) == SOCKET_ERROR){
		return 1;
	}
	return 2;
};
void BTHConnector::TerminateSocket(void)
{
	if(this->sockBTH != INVALID_SOCKET){
		closesocket(this->sockBTH);
		this->sockBTH = INVALID_SOCKET;
	}
};

int BTHConnector::RegisterBTHService(void)
{
	LPCSADDR_INFO lpcsAddressInfo =NULL;
	WSAQUERYSET wsaQuerySet = {0};
	
	if((lpcsAddressInfo =(LPCSADDR_INFO)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CSADDR_INFO)))==NULL){
		//return "Allocate Error";
		return 0;
	}
	
	SOCKADDR_BTH __pin* tempSockAddr= &this->SockAddrBthLocal; 
	lpcsAddressInfo[0].LocalAddr.iSockaddrLength = sizeof(SOCKADDR_BTH);
	lpcsAddressInfo[0].LocalAddr.lpSockaddr = reinterpret_cast<SOCKADDR*>(tempSockAddr);
	lpcsAddressInfo[0].RemoteAddr.iSockaddrLength = sizeof(SOCKADDR_BTH);
	lpcsAddressInfo[0].RemoteAddr.lpSockaddr = reinterpret_cast<SOCKADDR*>(tempSockAddr);
	lpcsAddressInfo[0].iSocketType = SOCK_STREAM;
	lpcsAddressInfo[0].iProtocol = BTHPROTO_RFCOMM;

	ZeroMemory(&wsaQuerySet,sizeof(WSAQUERYSET));

	wsaQuerySet.dwSize = sizeof(WSAQUERYSET);
	wsaQuerySet.lpServiceClassId = (LPGUID) &g_guidServiceClass;
	wsaQuerySet.lpszServiceInstanceName = _T("BlueTooth Remote Service");
	wsaQuerySet.lpszComment = _T("BlueTooth Remote Service");
	wsaQuerySet.dwNameSpace = NS_BTH;
	wsaQuerySet.dwNumberOfCsAddrs = 1;
	wsaQuerySet.lpcsaBuffer = lpcsAddressInfo;

	if(::WSASetService(&wsaQuerySet,RNRSERVICE_REGISTER, 0) == SOCKET_ERROR){
		//return "WSASetService() Error";
		return 1;
	}

	//return "WSASetService() success";
	return 2;
}

int BTHConnector::MakeConnection(int intDeviceNum)
{
	int intReturn=-1;
	unsigned int intChannel = 0;
	SOCKADDR_BTH tempSockAddr;
	memset(&tempSockAddr,0,sizeof(tempSockAddr));
	tempSockAddr.addressFamily = AF_BTH;
	tempSockAddr.btAddr = this->deviceAddrList[intDeviceNum];
	for(int count=0; count<=30; count++)
	{
		intChannel = count;
		tempSockAddr.port = intChannel & 0xff;
		intReturn=-1;
		if (connect (this->sockBTH, (SOCKADDR *)&tempSockAddr, sizeof(tempSockAddr))) {
			//strReturnMsg="connect() error";
			intReturn = 0;
		}
		else{
			//strReturnMsg="connected on channel";
			Disconnected = false;
			intReturn = 1;
			break;
			}
		}
	if(intChannel>=30){
		//strReturnMsg="could not connect [inChannel >=30]";
		Disconnected = true;
		intReturn =2;
		return intReturn;
	}
	return intReturn;
}

int BTHConnector::ListenMsg(void)
{
	if(SOCKET_ERROR == listen(this->sockBTH,SOMAXCONN)){
			return 0;
		}
	return 1;
};

int BTHConnector::AcceptMsg(void)
{
	SOCKET tempSock = INVALID_SOCKET;
	tempSock = accept(this->sockBTH,NULL,NULL);
	this->SetClientSocket(tempSock);
	Disconnected = false;
	//return "Client Connected";
	return 1;
}


System::String* BTHConnector::RecieveMsg(void)
{
	int intLen=0;
	char* strReturnMsg="";
	char strRecvBuffer[RECVBUFFER_SIZE];
	if(INVALID_SOCKET == this->GetClientSocket()){
		Disconnected = true;
		return "ClientSocket error";
		}

	intLen = recv(this->GetClientSocket(),strRecvBuffer,RECVBUFFER_SIZE,0);
	if(intLen == SOCKET_ERROR){
		Disconnected = true;
			return "ClientSocket error";
		}

	if(intLen>0){
		strRecvBuffer[intLen]=0;
		strReturnMsg=strRecvBuffer;
		}
	Disconnected = false;
	return strReturnMsg;
}

System::String* BTHConnector::RecieveMsg(int bufSize)
{
	int intLen=0;
	char* strReturnMsg="";
	char* strRecvBuffer = new char[bufSize];
	if(INVALID_SOCKET == this->GetClientSocket()){
		Disconnected = true;
		return "ClientSocket error";
		}

	intLen = recv(this->GetClientSocket(),strRecvBuffer,bufSize,0);
	if(intLen == SOCKET_ERROR){
		Disconnected = true;
			return "ClientSocket error";
		}

	if(intLen>0){
		strRecvBuffer[intLen]=0;
		strReturnMsg=strRecvBuffer;
		}
	Disconnected = false;
	return strReturnMsg;
}


int BTHConnector::SendMsg(System::String* strInput)
{
	int intByteSend=0;
	int intReturn = -1;
	CString strSendBuffer(strInput);

	if(INVALID_SOCKET == this->GetClientSocket()){
		Disconnected = true;
		return 0;	//return "ClientSocket error";
		}
	intByteSend = send(this->GetClientSocket(),strSendBuffer,SENDBUFFER_SIZE,0);
	if( SOCKET_ERROR == intByteSend)
		{
			Disconnected = true;
			intReturn = 1;
			return intReturn;		//strReturnMsg="Send error";
		}else{
			Disconnected = false;
			intReturn = 2;		//strReturnMsg="Send success";
		}
	if(intByteSend !=strInput->Length){
		intReturn = 3;		//strReturnMsg="Send returnerror";

		}else{
			intReturn = 4;		//strReturnMsg="Send Success";
		}
	return intReturn;
}


System::String* BTHConnector::GetDeviceName(int intDeviceNum)
{
	return this->deviceNameList[intDeviceNum];
}

System::String* BTHConnector::GetDeviceAddress(int intDeviceNum)
{
return this->deviceAddrStringList[intDeviceNum];
}

int BTHConnector::GetDeviceCount(void)
{
	return this->intDeviceCount;
}

SOCKADDR_BTH  BTHConnector::GetLocalSocketAddress(void)
{
	SOCKADDR_BTH __pin* tempSockAddr = &this->SockAddrBthLocal;
	return *tempSockAddr;
}
void BTHConnector::SetLocalSocketAddress(SOCKADDR_BTH temp)
{
	this->SockAddrBthLocal.addressFamily = temp.addressFamily;
	this->SockAddrBthLocal.btAddr = temp.btAddr;
	this->SockAddrBthLocal.port = temp.port;
	//this->SockAddrBthLocal.serviceClassId = temp.serviceClassId;
}

SOCKET BTHConnector::GetClientSocket(void)
{
	return this->ClientSocket;
}
void BTHConnector::SetClientSocket(SOCKET tempClientSock)
{
	this->ClientSocket = tempClientSock;
}

bool BTHConnector::IsDisconnect(void){
	return Disconnected;
}