able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tapi/skywalker/hidtsp/hidphone.h

770 lines
24 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1999 Microsoft Corporation
Module Name:
hidphone.h
Abstract:
This module contains the definitions of all the data structures being used
in hidphone.c
Author: Shivani Aggarwal
--*/
#ifndef _HIDPHONE_H_
#define _HIDPHONE_H_
#include <windows.h>
#include <tspi.h>
#include <tapi.h>
#include <winbase.h>
#include <setupapi.h>
#include <TCHAR.h>
#include <mmsystem.h>
// * NOTE - initguid.h must always be defined before devguid.h
#include <initguid.h>
#include <hidclass.h>
#include <dbt.h>
#include "hidsdi.h"
#include "hid.h"
#include "resource.h"
#include "audio.h"
#include "mymem.h"
#define LOW_VERSION 0x00020000
#define HIGH_VERSION 0x00030001
//
// MAX_CHARS is used as an upper limit on the number of chars required
// to store the phone id as a string. The phone ids begin from 0
// to gdwNumPhones which a DWORD, hence 32-bit. Therefore the largest number
// possible is 4294967296. Hence 20 chars are enough to store the largest string
//
#define MAX_CHARS 20
// In order to distinguish between value and button usages
#define PHONESP_BUTTON 1
#define PHONESP_VALUE 0
// Registry strings
#define REGSTR_PATH_WINDOWS_CURRENTVERSION TEXT("Software\\Microsoft\\Windows\\CurrentVersion")
#define TAPI_REGKEY_ROOT REGSTR_PATH_WINDOWS_CURRENTVERSION TEXT("\\Telephony")
#define TAPI_REGKEY_PROVIDERS TAPI_REGKEY_ROOT TEXT("\\Providers")
#define TAPI_REGVAL_NUMPROVIDERS TEXT("NumProviders")
#define HIDPHONE_TSPDLL TEXT("HIDPHONE.TSP")
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// Telephony HID definitions
// These are usages already defined in the Hid Telephony page.
// Just defining the usages with User-friendly names
//
// Definitions of relevant usages on the telephony page.
#define HID_USAGE_TELEPHONY_HANDSET ((USAGE) 0x04)
#define HID_USAGE_TELEPHONY_HEADSET ((USAGE) 0x05)
#define HID_USAGE_TELEPHONY_HOOKSWITCH ((USAGE) 0x20)
#define HID_USAGE_TELEPHONY_FLASH ((USAGE) 0x21)
#define HID_USAGE_TELEPHONY_HOLD ((USAGE) 0x23)
#define HID_USAGE_TELEPHONY_REDIAL ((USAGE) 0x24)
#define HID_USAGE_TELEPHONY_TRANSFER ((USAGE) 0x25)
#define HID_USAGE_TELEPHONY_DROP ((USAGE) 0x26)
#define HID_USAGE_TELEPHONY_PARK ((USAGE) 0x27)
#define HID_USAGE_TELEPHONY_FORWARD_CALLS ((USAGE) 0x28)
#define HID_USAGE_TELEPHONY_LINE ((USAGE) 0x2A)
#define HID_USAGE_TELEPHONY_SPEAKER_PHONE ((USAGE) 0x2B)
#define HID_USAGE_TELEPHONY_CONFERENCE ((USAGE) 0x2C)
#define HID_USAGE_TELEPHONY_RING_SELECT ((USAGE) 0x2E)
#define HID_USAGE_TELEPHONY_PHONE_MUTE ((USAGE) 0x2F)
#define HID_USAGE_TELEPHONY_CALLERID ((USAGE) 0x30)
#define HID_USAGE_TELEPHONY_SEND ((USAGE) 0x31)
#define HID_USAGE_TELEPHONY_DONOTDISTURB ((USAGE) 0x72)
#define HID_USAGE_TELEPHONY_RINGER ((USAGE) 0x9E)
#define HID_USAGE_TELEPHONY_PHONE_KEY_0 ((USAGE) 0xB0)
#define HID_USAGE_TELEPHONY_PHONE_KEY_1 ((USAGE) 0xB1)
#define HID_USAGE_TELEPHONY_PHONE_KEY_2 ((USAGE) 0xB2)
#define HID_USAGE_TELEPHONY_PHONE_KEY_3 ((USAGE) 0xB3)
#define HID_USAGE_TELEPHONY_PHONE_KEY_4 ((USAGE) 0xB4)
#define HID_USAGE_TELEPHONY_PHONE_KEY_5 ((USAGE) 0xB5)
#define HID_USAGE_TELEPHONY_PHONE_KEY_6 ((USAGE) 0xB6)
#define HID_USAGE_TELEPHONY_PHONE_KEY_7 ((USAGE) 0xB7)
#define HID_USAGE_TELEPHONY_PHONE_KEY_8 ((USAGE) 0xB8)
#define HID_USAGE_TELEPHONY_PHONE_KEY_9 ((USAGE) 0xB9)
#define HID_USAGE_TELEPHONY_PHONE_KEY_STAR ((USAGE) 0xBA)
#define HID_USAGE_TELEPHONY_PHONE_KEY_POUND ((USAGE) 0xBB)
#define HID_USAGE_TELEPHONY_PHONE_KEY_A ((USAGE) 0xBC)
#define HID_USAGE_TELEPHONY_PHONE_KEY_B ((USAGE) 0xBD)
#define HID_USAGE_TELEPHONY_PHONE_KEY_C ((USAGE) 0xBE)
#define HID_USAGE_TELEPHONY_PHONE_KEY_D ((USAGE) 0xBF)
#define HID_USAGE_CONSUMER_VOLUME ((USAGE) 0xE0)
#define PHONESP_ALLBUTTONMODES \
( PHONEBUTTONMODE_CALL | \
PHONEBUTTONMODE_FEATURE | \
PHONEBUTTONMODE_KEYPAD | \
PHONEBUTTONMODE_LOCAL | \
PHONEBUTTONMODE_DISPLAY )
#define PHONESP_ALLBUTTONSTATES \
(PHONEBUTTONSTATE_UP | \
PHONEBUTTONSTATE_DOWN)
// These act like bit masks which specify which reports are valid for a usage
#define INPUT_REPORT 1
#define OUTPUT_REPORT 2
#define FEATURE_REPORT 4
/*****************************************************************************/
//
// This structure holds the information for the button
//
typedef struct _PHONESP_BUTTON_INFO
{
// The ID for this button
DWORD dwButtonID;
// The ButtonMode (whether it is a PHONEBUTTONMODE_FEATURE or _KEYPAD, etc)
DWORD dwButtonMode;
// the Function (PHONEBUTTONFUNCTION_NONE or _FLASH, etc),
DWORD dwButtonFunction;
//
// This data is relevant for only on-off control buttons. The current state
// of the button is stored here
//
DWORD dwButtonState;
// the Button Text associated for the button - these are present in the
// string table
LPWSTR szButtonText;
} PHONESP_BUTTONINFO, *PPHONESP_BUTTONINFO;
/*****************************************************************************/
//
//
// User friendly names for the indexes into the capabilities of the phone structure
//
#define PHONESP_PHONE_KEY_0 0
#define PHONESP_PHONE_KEY_1 1
#define PHONESP_PHONE_KEY_2 2
#define PHONESP_PHONE_KEY_3 3
#define PHONESP_PHONE_KEY_4 4
#define PHONESP_PHONE_KEY_5 5
#define PHONESP_PHONE_KEY_6 6
#define PHONESP_PHONE_KEY_7 7
#define PHONESP_PHONE_KEY_8 8
#define PHONESP_PHONE_KEY_9 9
#define PHONESP_PHONE_KEY_STAR 10
#define PHONESP_PHONE_KEY_POUND 11
#define PHONESP_PHONE_KEY_A 12
#define PHONESP_PHONE_KEY_B 13
#define PHONESP_PHONE_KEY_C 14
#define PHONESP_PHONE_KEY_D 15
// The number of dial buttons supported by this tsp
#define PHONESP_NUMBER_PHONE_KEYS 16
// Feature Button indices
#define PHONESP_FEATURE_FLASH 16
#define PHONESP_FEATURE_HOLD 17
#define PHONESP_FEATURE_REDIAL 18
#define PHONESP_FEATURE_TRANSFER 19
#define PHONESP_FEATURE_DROP 20
#define PHONESP_FEATURE_PARK 21
#define PHONESP_FEATURE_FORWARD 22
#define PHONESP_FEATURE_LINE 23
#define PHONESP_FEATURE_CONFERENCE 24
#define PHONESP_FEATURE_RING_SELECT 25
#define PHONESP_FEATURE_PHONE_MUTE 26
#define PHONESP_FEATURE_CALLERID 27
#define PHONESP_FEATURE_DONOTDISTURB 28
#define PHONESP_FEATURE_SEND 29
#define PHONESP_FEATURE_VOLUMEUP 30
#define PHONESP_FEATURE_VOLUMEDOWN 31
// The number of Feature buttons supported by this tsp
#define PHONESP_NUMBER_FEATURE_BUTTONS 16
#define PHONESP_NUMBER_BUTTONS ( PHONESP_NUMBER_PHONE_KEYS + \
PHONESP_NUMBER_FEATURE_BUTTONS )
//
// The functions associated with the feature buttons
//
DWORD gdwButtonFunction[] =
{
PHONEBUTTONFUNCTION_FLASH,
PHONEBUTTONFUNCTION_HOLD,
PHONEBUTTONFUNCTION_LASTNUM,
PHONEBUTTONFUNCTION_TRANSFER,
PHONEBUTTONFUNCTION_DROP,
PHONEBUTTONFUNCTION_PARK,
PHONEBUTTONFUNCTION_FORWARD,
PHONEBUTTONFUNCTION_CALLAPP,
PHONEBUTTONFUNCTION_CONFERENCE,
PHONEBUTTONFUNCTION_SELECTRING,
PHONEBUTTONFUNCTION_MUTE,
PHONEBUTTONFUNCTION_CALLID,
PHONEBUTTONFUNCTION_DONOTDISTURB,
PHONEBUTTONFUNCTION_SEND,
PHONEBUTTONFUNCTION_VOLUMEUP,
PHONEBUTTONFUNCTION_VOLUMEDOWN
};
//
// The associated string table ID for the text of the phone buttons
//
DWORD gdwButtonText[] =
{
IDS_PHONE_KEY_0,
IDS_PHONE_KEY_1,
IDS_PHONE_KEY_2,
IDS_PHONE_KEY_3,
IDS_PHONE_KEY_4,
IDS_PHONE_KEY_5,
IDS_PHONE_KEY_6,
IDS_PHONE_KEY_7,
IDS_PHONE_KEY_8,
IDS_PHONE_KEY_9,
IDS_PHONE_KEY_STAR,
IDS_PHONE_KEY_POUND,
IDS_PHONE_KEY_A,
IDS_PHONE_KEY_B,
IDS_PHONE_KEY_C,
IDS_PHONE_KEY_D,
IDS_BUTTON_FLASH,
IDS_BUTTON_HOLD,
IDS_BUTTON_REDIAL,
IDS_BUTTON_TRANSFER,
IDS_BUTTON_DROP,
IDS_BUTTON_PARK,
IDS_BUTTON_FORWARD,
IDS_BUTTON_LINE,
IDS_BUTTON_CONFERENCE,
IDS_BUTTON_RING_SELECT,
IDS_BUTTON_MUTE,
IDS_BUTTON_CALLERID,
IDS_BUTTON_DONOTDISTURB,
IDS_BUTTON_SEND,
IDS_BUTTON_VOLUMEUP,
IDS_BUTTON_VOLUMEDOWN
};
typedef struct _PHONESP_LOOKUP_USAGEINDEX
{
USAGE Usage;
DWORD Index;
}PHONESP_LOOKUPUSAGEINDEX, *PPHONESP_LOOKUPUSAGEINDEX;
// inorder to look up the index for the feature button usages
// The 1st value in this 2-D array are the feature usages supported
// The 2nd value is the respective index
PHONESP_LOOKUPUSAGEINDEX gdwLookupFeatureIndex [] =
{
{ HID_USAGE_TELEPHONY_FLASH, PHONESP_FEATURE_FLASH },
{ HID_USAGE_TELEPHONY_HOLD, PHONESP_FEATURE_HOLD },
{ HID_USAGE_TELEPHONY_REDIAL, PHONESP_FEATURE_REDIAL },
{ HID_USAGE_TELEPHONY_TRANSFER, PHONESP_FEATURE_TRANSFER },
{ HID_USAGE_TELEPHONY_DROP, PHONESP_FEATURE_DROP },
{ HID_USAGE_TELEPHONY_PARK, PHONESP_FEATURE_PARK },
{ HID_USAGE_TELEPHONY_FORWARD_CALLS, PHONESP_FEATURE_FORWARD },
{ HID_USAGE_TELEPHONY_LINE, PHONESP_FEATURE_LINE },
{ HID_USAGE_TELEPHONY_CONFERENCE, PHONESP_FEATURE_CONFERENCE },
{ HID_USAGE_TELEPHONY_RING_SELECT, PHONESP_FEATURE_RING_SELECT },
{ HID_USAGE_TELEPHONY_PHONE_MUTE, PHONESP_FEATURE_PHONE_MUTE },
{ HID_USAGE_TELEPHONY_CALLERID, PHONESP_FEATURE_CALLERID },
{ HID_USAGE_TELEPHONY_DONOTDISTURB, PHONESP_FEATURE_DONOTDISTURB },
{ HID_USAGE_TELEPHONY_SEND, PHONESP_FEATURE_SEND }
};
/****************************************************************************/
//
// This structure maintains the information available about the phone. Every
// phone that has been enumerated has this structure associated with it
//
typedef struct _PHONESP_PHONE_INFO
{
// The deviceID for the phone. The Device ID for the phone is initialized
// in TSPI_providerInit
DWORD dwDeviceID;
//
// The version negotiated with TAPI using TSPI_phoneNegotiateTSPIVersion
// function that returns the highest SPI version the TSP can operate under
// for this device.
//
DWORD dwVersion;
//
// if this is true then it means that the
// phone is open and phone close on the device hasn't been called yet
//
BOOL bPhoneOpen;
//
// if this is false it means that this entry in the phone array is
// unused and can be filled in with a new phone
//
BOOL bAllocated;
//
// if this is true it means that a PHONE_CREATE message was sent for this
// phone, but we are waiting for a TSPI_providerCreatePhoneDevice
//
BOOL bCreatePending;
//
// if this is true it means that a PHONE_REMOVE message was sent for this
// phone, but we are waiting for a TSPI_phoneClose
//
BOOL bRemovePending;
//
// This variable keeps a count of the number of requests queued for this
// phone in the async queue
//
DWORD dwNumPendingReqInQueue;
//
// A handle to an event object which is set when there are no requests
// pending in the queue for this phone. Phone Close waits on this event
// to ensure that all asynchronous operations on the phone has been
// completed
//
HANDLE hNoPendingReqInQueueEvent;
//
// The handle for the phone received from TAPI and used by the phone
// to notify TAPI about the events occuring on this phone
//
HTAPIPHONE htPhone;
//
//Pointer to the Hid Device structure associated with this device
//
PHID_DEVICE pHidDevice;
//
// Whether the phone device has a render device associated with it
//
BOOL bRender;
//
// if the render device exists for this phone, this data contains the
// render device id
//
DWORD dwRenderWaveId;
//
// Whether the phone device has a capture device associated with it
//
BOOL bCapture;
//
// if the capture device exists for this phone, this data contains the
// capture device id
//
DWORD dwCaptureWaveId;
// This event is signalled when a input report is recieved from the device
HANDLE hInputReportEvent;
// This event is signalled when the phone is closed
HANDLE hCloseEvent;
// A handle to the read thread
HANDLE hReadThread;
// The structure to be passed to the ReadFile function - This struct will
// pass the hInputReportEvent which will be triggered when ReadFile returns
LPOVERLAPPED lpOverlapped;
// The Critical Section for this phone
CRITICAL_SECTION csThisPhone;
// lpfnPhoneEventProc is a callback function implemented by TAPI and
// supplied to the TSP as a parameter to TSPI_phoneOpen The TSP calls this
// function to report events that occur on the phone.
//
PHONEEVENT lpfnPhoneEventProc;
// The phone states messages for which TAPI can receive notification
DWORD dwPhoneStates;
//
// The phone state messages TAPI is interested in receiving
//
DWORD dwPhoneStateMsgs;
//
// The last three bits of this data signify which reports are valid for the
// handset/speaker. If zero, the handset does not exist, if bit 0 is set -
// input report can be received, if bit 1 is set - output report can be
// sent, if bit 2 is set - feature report supported
//
DWORD dwHandset;
DWORD dwSpeaker;
//
// The mode of the handset/ speaker at the moment whether _ONHOOK, _MIC,
// _SPEAKER, _MICSPEAKER. These modes are defined by TAPI
//
DWORD dwHandsetHookSwitchMode;
DWORD dwSpeakerHookSwitchMode;
BOOL bSpeakerHookSwitchButton;
//
// The hookswitch supported on this phone - handset and/or speaker
//
DWORD dwHookSwitchDevs;
// To determine whether the phone has a keypad
BOOL bKeyPad;
//
// The last three bits of this data signify which reports are valid for the
// ringer. If zero, the handset does not exist, if bit 0 is set - input
// report can be received, if bit 1 is set - output report can be sent, if
// bit 2 is set - feature report supported
//
DWORD dwRing;
//
// The last three bits of this data signify which reports are valid for the
// volume control. If zero, the handset does not exist, if bit 0 is set - input
// report can be received, if bit 1 is set - output report can be sent, if
// bit 2 is set - feature report supported
//
DWORD dwVolume;
//
// The mode of the handset/ speaker at the moment whether ringing or not
// if zero the phone is not ringing
//
DWORD dwRingMode;
// The buttonmodes for which the phone will send phone events
DWORD dwButtonModesMsgs;
// The button states for which the phone will send phone events
DWORD dwButtonStateMsgs;
// Number of usable buttons on this phone
DWORD dwNumButtons;
PPHONESP_BUTTONINFO pButtonInfo;
//
// The Phone Name and other Info on this Phone which will be displayed
//
LPWSTR wszPhoneName, wszPhoneInfo;
//
// The buttons valid for this phone - the entry for the
// corresponding button contains 0 if the button associated with the index
// does not exist else it specifies the report types valid for this button
// using the last 3 bits.
//
DWORD dwReportTypes[PHONESP_NUMBER_BUTTONS];
//
// After the button is created this contains the
// report Id assigned to the button
//
DWORD dwButtonIds[PHONESP_NUMBER_BUTTONS];
} PHONESP_PHONE_INFO, *PPHONESP_PHONE_INFO;
/*****************************************************************************/
typedef void (CALLBACK *ASYNCPROC)(PPHONESP_ASYNCREQINFO, BOOL);
/*****************************************************************************/
typedef struct _PHONESP_FUNC_INFO
{
// number of parameters in this array - don't actually use it, can be removed
DWORD dwNumParams;
// The pointer to the phone
ULONG_PTR dwParam1;
//
// The rest of the parameters are dependent on the function
// to which this parameter list is passed
//
ULONG_PTR dwParam2;
ULONG_PTR dwParam3;
ULONG_PTR dwParam4;
ULONG_PTR dwParam5;
ULONG_PTR dwParam6;
ULONG_PTR dwParam7;
ULONG_PTR dwParam8;
} PHONESP_FUNC_INFO, far *PPHONESP_FUNC_INFO;
/*****************************************************************************/
typedef struct _PHONESP_ASYNC_REQUEST_INFO
{
// The function to be executed
ASYNCPROC pfnAsyncProc;
// Parameters to be passed to the async function
PPHONESP_FUNC_INFO pFuncInfo;
} PHONESP_ASYNC_REQ_INFO, *PPHONESP_ASYNC_REQ_INFO;
/*****************************************************************************/
typedef struct _PHONESP_ASYNC_QUEUE
{
//
//The handle to the thread which services the queue
//
HANDLE hAsyncEventQueueServiceThread;
//
// The event if set signifies pending entries in the queue
// else the thread waits on this thread
//
HANDLE hAsyncEventsPendingEvent;
CRITICAL_SECTION AsyncEventQueueCritSec;
DWORD dwNumTotalQueueEntries;
DWORD dwNumUsedQueueEntries;
//Pointer to the queue
PPHONESP_ASYNC_REQ_INFO *pAsyncRequestQueue;
//Pointer to the next entry in the queue where the request can be added
PPHONESP_ASYNC_REQ_INFO *pAsyncRequestQueueIn;
//Pointer to the next request to be serviced in the queue
PPHONESP_ASYNC_REQ_INFO *pAsyncRequestQueueOut;
} PHONESP_ASYNCQUEUE, *PPHONESP_ASYNCQUEUE;
/*****************************************************************************/
//
// All these might be combined in a global structure
//
DWORD gdwNumPhones;
HINSTANCE ghInst;
DWORD gdwPermanentProviderID;
DWORD gdwPhoneDeviceIDBase;
HPROVIDER ghProvider;
// The memory for this queue is allocated in providerInit and will be used to
// store requests on the phone. These requests will be processed asynchronously
// by a separate Thread created on this queue
PHONESP_ASYNCQUEUE gAsyncQueue, gInputReportQueue;
// 256 is just a random number taken for the initial number of entries that the
// can have.. the queue can be expanded later as required
#define MAX_QUEUE_ENTRIES 256
//
// glpfnCompletionProc is a callback function implemented by TAPI and supplied
// to the TSP as a parameter to TSPI_providerInit.The TSP calls this function
// to report the completion of a line or phone procedure that it executes
// asynchronously.
//
ASYNC_COMPLETION glpfnCompletionProc;
//
// glpfnPhoneCreateProc is a callback function implemented by TAPI and supplied
// to the TSP as a parameter to TSPI_providerInit The TSP calls this function
// to report the creation of a new device.
//
PHONEEVENT glpfnPhoneCreateProc;
// gpPhone maintains an array of the phones enumerated - each of these phones
// have a corresponding HidDevice value in the gpHidDevices.
PPHONESP_PHONE_INFO *gpPhone;
// This the global heap from which all the memory allocations are carried out
HANDLE ghHeap;
// This two handles are required for registering for PNP events
HANDLE ghDevNotify;
HWND ghWndNotify;
const LPCWSTR gpcstrServiceName = _T("TapiSrv");
LPCWSTR gszProviderInfo;
// This is to notify the thread that services the queue to exit
// maybe this could be changed to an event based termination of thread
BOOL gbProviderShutdown = FALSE;
CRITICAL_SECTION csAllPhones;
CRITICAL_SECTION csHidList;
PPHONESP_MEMINFO gpMemFirst = NULL, gpMemLast = NULL;
CRITICAL_SECTION csMemoryList;
BOOL gbBreakOnLeak = FALSE;
/**********************PRIVATE FUNCTIONS**************************************/
BOOL
AsyncRequestQueueIn (
PPHONESP_ASYNC_REQ_INFO pAsyncReqInfo
);
LONG
CreateButtonsAndAssignID(
PPHONESP_PHONE_INFO pPhone
);
PPHONESP_BUTTONINFO
GetButtonFromID (
PPHONESP_PHONE_INFO pPhone,
DWORD dwButtonID
);
VOID
GetButtonUsages(
PPHONESP_PHONE_INFO pPhone,
PHIDP_BUTTON_CAPS pButtonCaps,
DWORD dwNumberButtonCaps,
DWORD ReportType
);
PPHONESP_PHONE_INFO
GetPhoneFromID(
DWORD dwDeviceID,
DWORD * pdwPhoneID
);
PPHONESP_PHONE_INFO
GetPhoneFromHid (
PHID_DEVICE HidDevice
);
VOID
GetValueUsages(
PPHONESP_PHONE_INFO pPhone,
PHIDP_VALUE_CAPS pValueCaps,
DWORD dwNumberCaps,
DWORD ReportType
);
VOID
InitPhoneAttribFromUsage (
DWORD ReportType,
USAGE UsagePage,
USAGE Usage,
PPHONESP_PHONE_INFO pPhone,
LONG Min,
LONG Max
);
LONG
LookupIndexForUsage(
IN DWORD Usage,
OUT DWORD *Index
);
DWORD
WINAPI
PNPServiceHandler(
DWORD dwControl,
DWORD dwEventType,
LPVOID lpEventData,
LPVOID lpContext
);
VOID
ReportUsage (
PPHONESP_PHONE_INFO pPhone,
USAGE UsagePage,
USAGE Usage,
ULONG Value
);
VOID
SendPhoneEvent(
PPHONESP_PHONE_INFO pPhone,
DWORD dwMsg,
ULONG_PTR Param1,
ULONG_PTR Param2,
ULONG_PTR Param3
);
LONG
SendOutputReport(
PHID_DEVICE pHidDevice,
USAGE Usage,
BOOL bSet
);
VOID
CALLBACK
ShowData(
PPHONESP_FUNC_INFO pAsyncFuncInfo
);
LPWSTR
PHONESP_LoadString(
IN UINT ResourceID,
PLONG lResult
);
BOOL
ReadInputReport (
PPHONESP_PHONE_INFO pPhone
);
VOID
InitUsage (
PPHONESP_PHONE_INFO pPhone,
USAGE Usage,
BOOL bON
);
VOID
ReenumDevices ();
VOID
FreePhone (
PPHONESP_PHONE_INFO pPhone
);
LONG
CreatePhone (
PPHONESP_PHONE_INFO pPhone,
PHID_DEVICE pHidDevice,
DWORD dwPhoneCnt
);
#endif
Reference in a new issue Copy permalink