770 lines
24 KiB
C
770 lines
24 KiB
C
/*++
|
|
|
|
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 |