sdkfunc.cpp

基于BlueSleil的Sample 查找附近的蓝牙设备 确定安装了蓝牙和BlueSleil

#include "SdkFunc.h"
#include "Config.h"
#include "Comport.h"
#include "DevClass.h"
#include "CallBack.h"

BOOL SDK_Init(VOID)
{
    DWORD dwBtVersion;

	if (!BT_IsBlueSoleilStarted(0))
	{
	    printf("BlueSolei yet haven`t started, now start it...\n");
		DWORD result = BT_StartBluetooth();
		if (BTSTATUS_SUCCESS == result)
		{
		    printf("BlueSolei start sucess\n");
		}
		else if (BTSTATUS_SYSTEM_ERROR == result)
		{
		    printf("system errors happen while BlueSoleil is starting\n");
			return FALSE;
		}
		else
		{
		    printf("BlueSoleil cannot start\n");
			return FALSE;
		}
	}
	
   	if(!BT_InitializeLibrary())
   	{
   		printf("BT_InitializeLibrary() failed!\n");
   		return FALSE;
   	}
   	dwBtVersion = BT_GetVersion();
   	printf("BlueSoleil API version: %d.%d\n", LOBYTE(LOWORD(dwBtVersion)), HIBYTE(LOWORD(dwBtVersion)));
   	
   	BT_GetBtSpecVersion(&dwBtVersion);
   	printf("Compliant BT Spec version: %d.%d\n", LOBYTE(LOWORD(dwBtVersion)), HIBYTE(LOWORD(dwBtVersion)));

	return TRUE;
}

VOID SDK_Done(VOID)
{
	BT_UninitializeLibrary();
}

DWORD SDK_BtBrowseServices(UINT32 index)
{
    if (NULL == g_DeviceInfo[index].DeviceInfo.address)
    {
        printf("invalid device\n");
        return BTSTATUS_FAIL;
    }

	GENERAL_SERVICE_INFO svcList[MAX_SERVICE_COUNT] = {0};
	
	DWORD ClsidListLen = MAX_SERVICE_COUNT*sizeof(GENERAL_SERVICE_INFO);
	BOOL bBrowseAllService = TRUE;
	
	DWORD dwResult;
	dwResult = BT_BrowseServices(&(g_DeviceInfo[index].DeviceInfo), bBrowseAllService, &ClsidListLen, svcList);

    if(dwResult == BTSTATUS_SUCCESS)
	{
	    g_DeviceInfo[index].iServiceNum = ClsidListLen / sizeof(GENERAL_SERVICE_INFO);
		g_DeviceInfo[index].pServiceInfo = 
		    (GENERAL_SERVICE_INFO*)malloc(sizeof(GENERAL_SERVICE_INFO)*g_DeviceInfo[index].iServiceNum);

		for(UINT32 i = 0; i < g_DeviceInfo[index].iServiceNum; i++)
		{
			g_DeviceInfo[index].pServiceInfo[i] = svcList[i];
		}
	}
	return dwResult;
}

DWORD SDK_BtInquiry(VOID)
{
	UCHAR	ucInqMode = INQUIRY_GENERAL_MODE, ucInqLen = 15;
	DWORD	DevsListLen = sizeof(BLUETOOTH_DEVICE_INFO) * MAX_CONNECT_COUNT;

	BLUETOOTH_DEVICE_INFO devList[MAX_SERVICE_COUNT] = {0};//clear the device info
	ucInqMode = g_iInquireMode;
	//Get Inquiry Length		0x00-0xFF
	
	ucInqLen = g_iInquireLen;
	if(ucInqLen <= 0)
	{
		printf("Get Inquiry Mode Failed!\n");
		return BTSTATUS_FAIL;
	}
	
	DWORD dwResult;
	if(g_bAsynchronous)
		DevsListLen = 0;
	
	dwResult = BT_InquireDevices(ucInqMode, ucInqLen, &DevsListLen, devList);
	PrintError("BT_InquireDevices",dwResult);

	if(!g_bAsynchronous && dwResult == BTSTATUS_SUCCESS)
	{
		for(UINT32 i=0; i<((DevsListLen)/sizeof(BLUETOOTH_DEVICE_INFO)); i++)
		{
			g_DeviceInfo[i].DeviceInfo = devList[i];
			g_DeviceInfo[i].DeviceInfo.dwSize = sizeof(BLUETOOTH_DEVICE_INFO);
		}
	}
	return dwResult;
}

DWORD SDK_BtConnectService(UINT32 dev_index, UINT32 service_index)
{
    DWORD handle;
	UCHAR port;
	
    if (NULL == g_DeviceInfo[dev_index].DeviceInfo.address || 
		service_index >= g_DeviceInfo[dev_index].iServiceNum)
    {
        printf("invalid service\n");
        return BTSTATUS_FAIL;
    }
	
	BYTE abyConnParam[512];
	DWORD dwParamLen = 512;
	
	if(!ConfigConnectParams(g_DeviceInfo[dev_index].pServiceInfo[service_index].wServiceClassUuid16,
		abyConnParam,&dwParamLen))
	{
		printf("Failed to config parameters.\n");
		return BTSTATUS_FAIL;
	}
	
	DWORD dwResult;
	dwResult = BT_ConnectService(&(g_DeviceInfo[dev_index].DeviceInfo), 
		&(g_DeviceInfo[dev_index].pServiceInfo[service_index]), 
		dwParamLen==0 ? NULL : abyConnParam, &handle);
	port = ((PSPP_CLIENT_PARAM)abyConnParam)->ucComPort;
	return dwResult;
}

DWORD SDK_EnumConnections(GENERAL_CONNECT_INFO* list)
{
	DWORD dwSize = MAX_CONNECT_COUNT*sizeof(GENERAL_CONNECT_INFO);
	memset(list, 0, dwSize);
	
	DWORD dwResult = BT_EnumConnections(&dwSize, list);
	return dwResult;
}

DWORD SDK_GetSPPInfo(DWORD* handle, INT32* port)
{
    DWORD dwResult;
	GENERAL_CONNECT_INFO list[MAX_CONNECT_COUNT] = {0};
	
    dwResult = SDK_EnumConnections(list);
	if (BTSTATUS_SUCCESS == dwResult)
	{
        for (INT32 i = 0; 0 != list[i].dwHandle; i++)
        {
            if (g_iSpecificService == list[i].wServiceClass)
            {
                BOOL bIsOutGoing;
				SPP_CONNECT_INFO sppConnInfo ={0};
				DWORD dwLen = sizeof(SPP_CONNECT_INFO);
				BYTE bdAddr[6]={0};
				WORD wClass;

				if(BT_GetConnectInfo(list[i].dwHandle,&bIsOutGoing,&wClass,bdAddr,&dwLen,(BYTE*)&sppConnInfo) == BTSTATUS_SUCCESS)
				{
				    *handle = list[i].dwHandle;
					*port = (INT32)(sppConnInfo.ucComPort);
					return BTSTATUS_SUCCESS;
				}
            }
        }
	}
    *handle = 0;
    *port = 0;
    return BTSTATUS_FAIL;
}

VOID SDK_BtRegisterCallBack(INT32 nInput)
{
	DWORD dwResult;
	
	switch(nInput)
	{
    	case EVENT_CONNECTION_STATUS:
    		dwResult=BT_RegisterCallback(EVENT_CONNECTION_STATUS, Connection_CallBack);
			if (BTSTATUS_SUCCESS != dwResult)
			{
    		    PrintError("BT_RegisterCallback EVENT_CONNECTION_STATUS", dwResult);
			}
    		break;

    	case EVENT_ERROR:
    		dwResult=BT_RegisterCallback(EVENT_ERROR, Error_CallBack);
			if (BTSTATUS_SUCCESS != dwResult)
			{
    		    PrintError("BT_RegisterCallback EVENT_ERROR", dwResult);
			}
    		break;
/*
    	case EVENT_INQUIRY_DEVICE_REPORT:
    		dwResult=BT_RegisterCallback(EVENT_INQUIRY_DEVICE_REPORT, CBK_InquiryDeviceReport);
    		PrintError("BT_RegisterCallback EVENT_INQUIRY_DEVICE_REPORT",dwResult);
    		break;

    	case EVENT_SPPEX_CONNECTION_STATUS:
    		dwResult=BT_RegisterCallback(EVENT_SPPEX_CONNECTION_STATUS, CBK_SPPExConnection);
    		PrintError("BT_RegisterCallback EVENT_SPPEX_CONNECTION_STATUS",dwResult);
    		break;*/

    	case EVENT_BLUETOOTH_STATUS:
    		dwResult=BT_RegisterCallback(EVENT_BLUETOOTH_STATUS, BTStatus_CallBack);
			if (BTSTATUS_SUCCESS != dwResult)
			{
    		    PrintError("BT_RegisterCallback EVENT_BLUETOOTH_STATUS", dwResult);
			}
    		break;
			
    	default:
    		break;
	}
}

VOID SDK_BtUnRegisterCallBack(INT32 nInput)
{
    DWORD dwResult;
    dwResult=BT_UnregisterCallback(nInput);
    PrintError("BT_UnregisterCallback",dwResult);
}

VOID showDeviceInfo(VOID)
{
}