901 lines
21 KiB
C++
901 lines
21 KiB
C++
/*++
|
|
|
|
Copyright (c) 2008 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
mbapi.cpp
|
|
|
|
Abstract:
|
|
|
|
Sample code for Mobile Broadband APIs
|
|
|
|
Date:
|
|
10/20/2008 created
|
|
|
|
Environment:
|
|
|
|
User mode only
|
|
|
|
--*/
|
|
|
|
#include <atlbase.h>
|
|
// headers needed to use Mobile Broadband APIs
|
|
#include "mbnapi.h"
|
|
|
|
#define MAX_NOTIFICATION_EVENTS 1
|
|
|
|
CComPtr<IMbnInterfaceManager> g_InterfaceMgr = NULL;
|
|
CComPtr<IMbnRadio> g_MbnRadio;
|
|
|
|
VOID DeInitInterfaceMgr();
|
|
HRESULT InitApp()
|
|
{
|
|
//MB API supports both MTA and STA, this example however exhibits
|
|
//the use of MTA
|
|
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
|
return hr;
|
|
}
|
|
|
|
HRESULT InitInterfaceMgr()
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
//Initialize Interface Manager
|
|
hr = CoCreateInstance(CLSID_MbnInterfaceManager,
|
|
NULL,
|
|
CLSCTX_ALL,
|
|
IID_IMbnInterfaceManager,
|
|
(void**)&g_InterfaceMgr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
VOID DeInitInterfaceMgr()
|
|
{
|
|
g_InterfaceMgr = NULL;
|
|
}
|
|
|
|
VOID DeInitApp()
|
|
{
|
|
CoUninitialize();
|
|
}
|
|
|
|
HANDLE g_Event = NULL;
|
|
|
|
// This class is created to implement the event listener notifications. It needs to extend
|
|
// all event interfaces for which application wants to register for event notifications e.g.
|
|
// it extends IMbnRadioEvents for registering to Radio events notifications. If application
|
|
// requires to register for Signal events notifications as well, it should extend IMbnSignalEvents
|
|
// too. It then implements all the members of corresponding event interface say OnRadioStateChange,
|
|
// OnSetSoftwareRadioStateComplete for IMbnRadioEvents. Had it extended the IMbnSignalEvents to
|
|
// register for Signal events notifications, it would have implemented the OnSignalStateChange member
|
|
// of IMbnSignalEvents too.
|
|
|
|
class CMbnSinks:
|
|
public IMbnRadioEvents
|
|
{
|
|
ULONG m_lRef;
|
|
public:
|
|
CMbnSinks();
|
|
~CMbnSinks();
|
|
|
|
//IMbnRadioEvents
|
|
HRESULT STDMETHODCALLTYPE OnRadioStateChange(__in IMbnRadio* Radio);
|
|
|
|
HRESULT STDMETHODCALLTYPE OnSetSoftwareRadioStateComplete(__in IMbnRadio* Radio,
|
|
__in ULONG requestID,
|
|
__in HRESULT Status);
|
|
|
|
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppv);
|
|
|
|
ULONG STDMETHODCALLTYPE AddRef();
|
|
|
|
ULONG STDMETHODCALLTYPE Release();
|
|
};
|
|
|
|
//
|
|
// Utility functions
|
|
//
|
|
|
|
// This function takes the safearray of IMbnInterface objects as input and copies
|
|
// the interface guids to the pointer to the list of guids.
|
|
HRESULT CopyArrayOfInterfaces(SAFEARRAY* psaObjects, UINT* pCount, GUID** ppGuidList)
|
|
{
|
|
if (NULL == psaObjects || NULL == ppGuidList || NULL == pCount)
|
|
{
|
|
return E_POINTER;
|
|
}
|
|
|
|
*ppGuidList = NULL;
|
|
*pCount = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
LONG lLower;
|
|
LONG lUpper;
|
|
|
|
hr = SafeArrayGetLBound(psaObjects, 1, &lLower);
|
|
if(FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
hr = SafeArrayGetUBound(psaObjects, 1, &lUpper);
|
|
if(FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
LONG Num = lUpper - lLower + 1;
|
|
|
|
if(Num > 0)
|
|
{
|
|
*ppGuidList = (GUID*)malloc(sizeof(GUID)* Num);
|
|
if(*ppGuidList == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
BSTR GuidName;
|
|
GUID Guid;
|
|
|
|
CComPtr<IMbnInterface> pMbnInterface = NULL;
|
|
UINT nActualInterfaces = 0;
|
|
for (LONG l = lLower; l <= lUpper; l++)
|
|
{
|
|
hr = SafeArrayGetElement(psaObjects, &l, &pMbnInterface);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pMbnInterface->get_InterfaceID(&GuidName);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = IIDFromString(GuidName, &Guid);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
(*ppGuidList)[nActualInterfaces] = Guid;
|
|
nActualInterfaces ++;
|
|
}
|
|
|
|
SysFreeString(GuidName);
|
|
GuidName = NULL;
|
|
}
|
|
}
|
|
pMbnInterface = NULL;
|
|
}
|
|
|
|
*pCount = nActualInterfaces;
|
|
if(nActualInterfaces > 0)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// print the error message
|
|
VOID
|
|
PrintStatusMsg(
|
|
__in LPWSTR strCommand,
|
|
__in HRESULT hr
|
|
)
|
|
{
|
|
if (strCommand != NULL)
|
|
{
|
|
if (hr == S_OK)
|
|
{
|
|
wprintf(L"Command \"%s\" completed successfully.\n", strCommand);
|
|
}
|
|
else if (hr == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER))
|
|
{
|
|
wprintf(L"The parameter for \"%s\" is not correct.\n", strCommand);
|
|
wprintf(L"Please use \"help %s\" to check the usage of the command.\n", strCommand);
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"Got error 0x%x for command \"%s\"\n", hr, strCommand);
|
|
}
|
|
}
|
|
}
|
|
|
|
// enumerates mobile broadband interfaces
|
|
VOID
|
|
EnumInterface(
|
|
__in int argc,
|
|
__in_ecount(argc) LPWSTR argv[]
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SAFEARRAY *psa = NULL;
|
|
GUID *pList = NULL;
|
|
BOOL isInitAppSuccess = FALSE;
|
|
BOOL isModeSet = TRUE;
|
|
|
|
do
|
|
{
|
|
if (argc != 1)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
hr = InitApp();
|
|
if(FAILED(hr) && hr != RPC_E_CHANGED_MODE)
|
|
{
|
|
break;
|
|
}
|
|
isInitAppSuccess = TRUE;
|
|
if (RPC_E_CHANGED_MODE == hr)
|
|
{
|
|
isModeSet = FALSE;
|
|
}
|
|
|
|
hr = InitInterfaceMgr();
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
hr = g_InterfaceMgr->GetInterfaces(&psa);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
UINT size = 0;
|
|
hr = CopyArrayOfInterfaces(psa, &size, &pList);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (pList)
|
|
{
|
|
for (ULONG l = 0; l < size; l++)
|
|
{
|
|
LPOLESTR pStr = NULL;
|
|
hr = StringFromIID(pList[l], &pStr);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
wprintf(L"Interface [%d] = %s\n", l, pStr);
|
|
CoTaskMemFree(pStr);
|
|
}
|
|
}
|
|
|
|
} while(FALSE);
|
|
|
|
//cleanup
|
|
if(psa)
|
|
{
|
|
SafeArrayDestroy(psa);
|
|
}
|
|
|
|
if(pList)
|
|
{
|
|
free(pList);
|
|
}
|
|
|
|
if(g_InterfaceMgr)
|
|
{
|
|
DeInitInterfaceMgr();
|
|
}
|
|
|
|
if(isInitAppSuccess && isModeSet)
|
|
{
|
|
DeInitApp();
|
|
}
|
|
|
|
PrintStatusMsg(argv[0], hr);
|
|
}
|
|
|
|
// get interface capability
|
|
VOID
|
|
GetInterfaceCapability(
|
|
__in int argc,
|
|
__in_ecount(argc) LPWSTR argv[]
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL isInitAppSuccess = FALSE;
|
|
BOOL isModeSet = TRUE;
|
|
|
|
do
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
hr = InitApp();
|
|
if(FAILED(hr) && hr != RPC_E_CHANGED_MODE)
|
|
{
|
|
break;
|
|
}
|
|
isInitAppSuccess = TRUE;
|
|
if (RPC_E_CHANGED_MODE == hr)
|
|
{
|
|
isModeSet = FALSE;
|
|
}
|
|
|
|
hr = InitInterfaceMgr();
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
MBN_INTERFACE_CAPS InterfaceCaps;
|
|
CComPtr<IMbnInterface> pMbnInterface;
|
|
hr = g_InterfaceMgr->GetInterface(argv[1], &pMbnInterface);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
hr = pMbnInterface->GetInterfaceCapability(&InterfaceCaps);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
wprintf(L"\t DeviceId \t\t%s\n", InterfaceCaps.deviceID);
|
|
wprintf(L"\t Manufacturer \t\t%s\n", InterfaceCaps.manufacturer);
|
|
wprintf(L"\t Model \t\t\t%s\n", InterfaceCaps.model);
|
|
|
|
SysFreeString(InterfaceCaps.customDataClass);
|
|
SysFreeString(InterfaceCaps.customBandClass);
|
|
SysFreeString(InterfaceCaps.deviceID);
|
|
SysFreeString(InterfaceCaps.manufacturer);
|
|
SysFreeString(InterfaceCaps.model);
|
|
SysFreeString(InterfaceCaps.firmwareInfo);
|
|
|
|
} while(FALSE);
|
|
|
|
//cleanup
|
|
if(g_InterfaceMgr)
|
|
{
|
|
DeInitInterfaceMgr();
|
|
}
|
|
|
|
if(isInitAppSuccess && isModeSet)
|
|
{
|
|
DeInitApp();
|
|
}
|
|
|
|
|
|
PrintStatusMsg(argv[0], hr);
|
|
}
|
|
|
|
// get radio state
|
|
VOID
|
|
GetRadioState(
|
|
__in int argc,
|
|
__in_ecount(argc) LPWSTR argv[]
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL isInitAppSuccess = FALSE;
|
|
BOOL isModeSet = TRUE;
|
|
|
|
do
|
|
{
|
|
if (argc != 2)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
hr = InitApp();
|
|
if(FAILED(hr) && hr != RPC_E_CHANGED_MODE)
|
|
{
|
|
break;
|
|
}
|
|
isInitAppSuccess = TRUE;
|
|
if (RPC_E_CHANGED_MODE == hr)
|
|
{
|
|
isModeSet = FALSE;
|
|
}
|
|
|
|
hr = InitInterfaceMgr();
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
MBN_RADIO SoftwareRadioState;
|
|
MBN_RADIO HardwareRadioState;
|
|
CComPtr<IMbnInterface> pMbnInterface;
|
|
CComPtr<IMbnRadio> pMbnRadio;
|
|
hr = g_InterfaceMgr->GetInterface(argv[1], &pMbnInterface);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
hr = pMbnInterface->QueryInterface(__uuidof(IMbnRadio), reinterpret_cast<void**>(&pMbnRadio));
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
hr = pMbnRadio->get_SoftwareRadioState(&SoftwareRadioState);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (MBN_RADIO_OFF == SoftwareRadioState)
|
|
{
|
|
wprintf(L"\t SoftwareRadioState \tOff\n");
|
|
}
|
|
else if (MBN_RADIO_ON == SoftwareRadioState)
|
|
{
|
|
wprintf(L"\t SoftwareRadioState \tOn\n");
|
|
}
|
|
|
|
hr = pMbnRadio->get_HardwareRadioState(&HardwareRadioState);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (MBN_RADIO_OFF == HardwareRadioState)
|
|
{
|
|
wprintf(L"\t HardwareRadioState \tOff\n");
|
|
}
|
|
else if (MBN_RADIO_ON == HardwareRadioState)
|
|
{
|
|
wprintf(L"\t HardwareRadioState \tOn\n");
|
|
}
|
|
|
|
}
|
|
while(FALSE);
|
|
|
|
//cleanup
|
|
if(g_InterfaceMgr)
|
|
{
|
|
DeInitInterfaceMgr();
|
|
}
|
|
|
|
if(isInitAppSuccess && isModeSet)
|
|
{
|
|
DeInitApp();
|
|
}
|
|
|
|
|
|
PrintStatusMsg(argv[0], hr);
|
|
}
|
|
|
|
// set the radio state
|
|
VOID
|
|
SetRadioState(
|
|
__in int argc,
|
|
__in_ecount(argc) LPWSTR argv[]
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CMbnSinks *pCMbnSinks = NULL;
|
|
BOOL isInitAppSuccess = FALSE;
|
|
BOOL isModeSet = TRUE;
|
|
BOOL isAdviseDone = FALSE;
|
|
IConnectionPoint *pcp;
|
|
DWORD dwCookie = 0;
|
|
|
|
do
|
|
{
|
|
if (argc != 3)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
MBN_RADIO softwareRadioState;
|
|
if (_wcsicmp(argv[2], L"on") == 0)
|
|
{
|
|
softwareRadioState = MBN_RADIO_ON;
|
|
}
|
|
else if (_wcsicmp(argv[2], L"off") == 0)
|
|
{
|
|
softwareRadioState = MBN_RADIO_OFF;
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
|
|
break;
|
|
}
|
|
|
|
hr = InitApp();
|
|
if(FAILED(hr) && hr != RPC_E_CHANGED_MODE)
|
|
{
|
|
break;
|
|
}
|
|
isInitAppSuccess = TRUE;
|
|
if (RPC_E_CHANGED_MODE == hr)
|
|
{
|
|
isModeSet = FALSE;
|
|
}
|
|
|
|
hr = InitInterfaceMgr();
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
//CreateEvent
|
|
g_Event = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
if(!g_Event)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
break;
|
|
}
|
|
|
|
// registering for notifications, following steps need to be performed
|
|
IUnknown* pUnkSink;
|
|
CComPtr<IConnectionPointContainer> pcpc;
|
|
|
|
// 1.Get an IConnectionPointContainer interface by calling QueryInterface
|
|
// on corresponding IMbnXXXManager object say IMbnInterfaceManager for IMbnRadioEvents.
|
|
hr = g_InterfaceMgr->QueryInterface(IID_IConnectionPointContainer, reinterpret_cast<VOID**>(&pcpc));
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// 2.Call FindConnectionPoint on the returned interface and pass corresponding
|
|
// IID_IMbnXXXEvents to riid say IID_IMbnRadioEvents.
|
|
hr = pcpc->FindConnectionPoint(IID_IMbnRadioEvents, &pcp);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// 3.Call Advise on the returned connection point and pass a pointer to an IUnknown
|
|
// interface on an object that implements IMbnXXXEvents to pUnk.
|
|
pCMbnSinks = new CMbnSinks;
|
|
if (pCMbnSinks)
|
|
{
|
|
//QI will do AddRef on pCMbnSinks
|
|
pCMbnSinks->QueryInterface(IID_IUnknown, (LPVOID *)&pUnkSink );
|
|
hr = pcp->Advise(pUnkSink, &dwCookie);
|
|
}
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
isAdviseDone = TRUE;
|
|
|
|
//QI MbnRadio object to perform the SetSoftwareRadioState operation
|
|
CComPtr<IMbnInterface> pMbnInterface;
|
|
hr = g_InterfaceMgr->GetInterface(argv[1], &pMbnInterface);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
CComPtr<IMbnRadio> pMbnRadio;
|
|
hr = pMbnInterface->QueryInterface(__uuidof(IMbnRadio), reinterpret_cast<void**>(&pMbnRadio));
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
ULONG requestID = 0;
|
|
hr = pMbnRadio->SetSoftwareRadioState(softwareRadioState, &requestID);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
wprintf(L"\t SetSoftwareRadioState call successful requestID = %d\n", requestID);
|
|
|
|
//Now waiting for set request to get completed
|
|
DWORD waitObject;
|
|
|
|
waitObject = WaitForSingleObject(
|
|
g_Event,
|
|
INFINITE);
|
|
|
|
if (WAIT_OBJECT_0 == waitObject)
|
|
{
|
|
// g_Event is triggerred
|
|
// for getting the status of the software radio state now
|
|
pMbnRadio = g_MbnRadio;
|
|
MBN_RADIO NewSoftwareRadioState;
|
|
hr = pMbnRadio->get_SoftwareRadioState(&NewSoftwareRadioState);
|
|
if(FAILED(hr))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (MBN_RADIO_OFF == NewSoftwareRadioState)
|
|
{
|
|
wprintf(L"\t New SoftwareRadioState \tOff\n");
|
|
}
|
|
else if (MBN_RADIO_ON == NewSoftwareRadioState)
|
|
{
|
|
wprintf(L"\t New SoftwareRadioState \tOn\n");
|
|
}
|
|
|
|
}
|
|
|
|
} while(FALSE);
|
|
|
|
//cleanup
|
|
if(isAdviseDone)
|
|
{
|
|
pcp->Unadvise(dwCookie);
|
|
pcp->Release();
|
|
}
|
|
|
|
if (g_Event)
|
|
{
|
|
CloseHandle(g_Event);
|
|
g_Event = NULL;
|
|
}
|
|
|
|
if (pCMbnSinks)
|
|
{
|
|
pCMbnSinks->Release();
|
|
}
|
|
|
|
g_MbnRadio = NULL;
|
|
|
|
if(g_InterfaceMgr)
|
|
{
|
|
DeInitInterfaceMgr();
|
|
}
|
|
|
|
if(isInitAppSuccess && isModeSet)
|
|
{
|
|
DeInitApp();
|
|
}
|
|
|
|
PrintStatusMsg(argv[0], hr);
|
|
}
|
|
|
|
// show help messages
|
|
VOID
|
|
Help(
|
|
__in int argc,
|
|
__in_ecount(argc) LPWSTR argv[]
|
|
);
|
|
|
|
typedef VOID (*WLSAMPLE_FUNCTION) (int argc, LPWSTR argv[]);
|
|
typedef struct _WLSAMPLE_COMMAND {
|
|
LPWSTR strCommandName; // command name
|
|
LPWSTR strShortHand; // a shorthand for the command
|
|
WLSAMPLE_FUNCTION Func; // pointer to the function
|
|
LPWSTR strHelpMessage; // help message
|
|
LPWSTR strParameters; // parameters for the command
|
|
BOOL bRemarks; // whether have remarks for the command
|
|
LPWSTR strRemarks; // remarks
|
|
} WLSAMPLE_COMMAND, *PWLSAMPLE_COMMAND;
|
|
|
|
WLSAMPLE_COMMAND g_Commands[] = {
|
|
// interface related commands
|
|
{
|
|
L"EnumInterface",
|
|
L"ei",
|
|
EnumInterface,
|
|
L"Enumerate wireless interfaces and print the basic interface information.",
|
|
L"",
|
|
FALSE,
|
|
L""
|
|
},
|
|
{
|
|
L"GetInterfaceCapability",
|
|
L"gic",
|
|
GetInterfaceCapability,
|
|
L"Get the capability of an interface.",
|
|
L"<interface GUID>",
|
|
TRUE,
|
|
L"Use EnumInterface (ei) command to get the GUID of an interface."
|
|
},
|
|
{
|
|
L"GetRadioState",
|
|
L"grs",
|
|
GetRadioState,
|
|
L"Get the software radio state.",
|
|
L"<interface GUID>",
|
|
TRUE,
|
|
L"Use EnumInterface (ei) command to get the GUID of an interface."
|
|
},
|
|
{
|
|
L"SetRadioState",
|
|
L"srs",
|
|
SetRadioState,
|
|
L"Set the software radio state.",
|
|
L"<interface GUID> <on|off>",
|
|
TRUE,
|
|
L"Use EnumInterface (ei) command to get the GUID of an interface."
|
|
},
|
|
{
|
|
L"help",
|
|
L"?",
|
|
Help,
|
|
L"Print this help message.",
|
|
L"[<command>]",
|
|
FALSE,
|
|
L""
|
|
}
|
|
};
|
|
|
|
// show help messages
|
|
VOID
|
|
Help(
|
|
__in int argc,
|
|
__in_ecount(argc) LPWSTR argv[]
|
|
)
|
|
{
|
|
UINT i;
|
|
|
|
if (argc == 1)
|
|
{
|
|
// show all commands
|
|
wprintf(L"This is a sample showing how to use Mobile Broadband APIs to manager wireless networks.\n");
|
|
wprintf(L"The following commands are available. Use \"help xyz\" to show the description of command xyz.\n");
|
|
for (i=0; i < ARRAYSIZE(g_Commands); i++)
|
|
{
|
|
wprintf(L"\t %s", g_Commands[i].strCommandName);
|
|
wprintf(L"(%s)\n", g_Commands[i].strShortHand);
|
|
}
|
|
}
|
|
else if (argc == 2)
|
|
{
|
|
// show the description of a command
|
|
for (i=0; i < ARRAYSIZE(g_Commands); i++)
|
|
{
|
|
if (_wcsicmp(argv[1], g_Commands[i].strCommandName) == 0 ||
|
|
_wcsicmp(argv[1], g_Commands[i].strShortHand) == 0)
|
|
{
|
|
wprintf(L"Command: %s", g_Commands[i].strCommandName);
|
|
wprintf(L"(%s)\n", g_Commands[i].strShortHand);
|
|
wprintf(L"Description: %s\n", g_Commands[i].strHelpMessage);
|
|
wprintf(L"Usage: %s", g_Commands[i].strCommandName);
|
|
wprintf(L"(%s)\n", g_Commands[i].strShortHand);
|
|
wprintf(g_Commands[i].strParameters);
|
|
if (g_Commands[i].bRemarks)
|
|
{
|
|
wprintf(L"Remarks: %s\n", g_Commands[i].strRemarks);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"Invalid Parameter\n");
|
|
}
|
|
}
|
|
|
|
// command is stored in the global variable
|
|
void
|
|
ExecuteCommand(
|
|
__in int argc,
|
|
__in_ecount(argc) LPWSTR argv[]
|
|
)
|
|
{
|
|
UINT i = 0;
|
|
|
|
for (i=0; i < ARRAYSIZE(g_Commands); i++)
|
|
{
|
|
// find the command and call the function
|
|
if (_wcsicmp(argv[0], g_Commands[i].strCommandName) == 0 ||
|
|
_wcsicmp(argv[0], g_Commands[i].strShortHand) == 0)
|
|
{
|
|
g_Commands[i].Func(argc, argv);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == ARRAYSIZE(g_Commands))
|
|
{
|
|
wprintf(L"Invalid command %s !\n", argv[0]);
|
|
|
|
}
|
|
}
|
|
|
|
// the main program
|
|
int _cdecl
|
|
wmain(__in int argc, __in_ecount(argc) LPWSTR argv[])
|
|
{
|
|
DWORD dwRetCode = ERROR_SUCCESS;
|
|
|
|
if (argc == 1)
|
|
{
|
|
wprintf(L"Please type \"%s ?\" for help.\n", argv[0]);
|
|
dwRetCode = ERROR_INVALID_PARAMETER;
|
|
}
|
|
else
|
|
{
|
|
// don't pass in the first parameter
|
|
ExecuteCommand(argc-1, argv+1);
|
|
}
|
|
|
|
return dwRetCode;
|
|
}
|
|
|
|
CMbnSinks::CMbnSinks()
|
|
{
|
|
m_lRef = 0;
|
|
}
|
|
|
|
CMbnSinks::~CMbnSinks()
|
|
{
|
|
}
|
|
|
|
// This method is used to QueryInterface the required riid. As the class
|
|
// CMbnSinks is updated to extend and implement required event interfaces
|
|
// say IMbnSignalEvents, this method should be updated accordingly to QI
|
|
// the additional riids say IID_IMbnSignalEvents.
|
|
|
|
HRESULT STDMETHODCALLTYPE CMbnSinks::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
if ( !ppv )
|
|
{
|
|
return E_POINTER;
|
|
}
|
|
|
|
HRESULT hr = E_NOINTERFACE;
|
|
|
|
*ppv = NULL;
|
|
|
|
if (riid == IID_IUnknown)
|
|
{
|
|
*ppv = this;
|
|
}
|
|
else if(riid == IID_IMbnRadioEvents)
|
|
{
|
|
*ppv = (IMbnRadioEvents *)this;
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
|
|
if (*ppv)
|
|
{
|
|
reinterpret_cast<IUnknown *>(*ppv)->AddRef();
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
ULONG STDMETHODCALLTYPE CMbnSinks::AddRef()
|
|
{
|
|
return InterlockedIncrement( (LONG *)&m_lRef );
|
|
}
|
|
|
|
ULONG STDMETHODCALLTYPE CMbnSinks::Release()
|
|
{
|
|
ULONG ulNewRef = (ULONG)InterlockedDecrement( (LONG *)&m_lRef );
|
|
if( ulNewRef == 0 )
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
return ulNewRef;
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE CMbnSinks::OnRadioStateChange(__in IMbnRadio* Radio)
|
|
{
|
|
wprintf(L"*****Received OnRadioStateChange Event\n");
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE CMbnSinks::OnSetSoftwareRadioStateComplete(__in IMbnRadio* Radio,
|
|
__in ULONG requestID,
|
|
__in HRESULT Status)
|
|
{
|
|
|
|
wprintf(L"***Received OnSetSoftwareRadioStateComplete Event for requestID = %d\n", requestID);
|
|
g_MbnRadio = Radio;
|
|
SetEvent(g_Event);
|
|
return(S_OK);
|
|
}
|
|
|