#ifndef __LIBDLL_H__
#define __LIBDLL_H__


#define ALLERROR                      0xFFFFFFFF
#define ALLNOERROR                    0x00000000
#define ERRORSTEP(x)                  (0x1<<x)
#define ERROR_NORESOURCE              0x00000001                     
#define ERROR_NOSPACE                 0x00000002                     
#define ERROR_PARAMETER	              0x00000004                     
#define ERROR_WLAN_QUIRY_INTERFACE    0x00000008                     
#define ERROR_WLAN_SSID_REPEAT        0x00000010                     
#define ERROR_WLAN_NO_PRSSID_LIST     0x00000011                     
#define ERROR_WLAN_NO_ASSOCIATED      0X00000012                     
#define ERROR_WLAN_NO_AVAILABLE_LIST  0x00000013                     
#define ERROR_WLAN_NO_CONNECTED	      0x00000014                     
#define ERROR_WLAN_SSID_UNKNOWN	      0x00000018                     
#define ERROR_WLAN_QUIRY_FAILED	      0x00000021                     
#define ERROR_BT_SERVICE              0x00000020

//========== GPS Error Code =====================
#define ERROR_INCORRECT_BAUDRATE       21
#define ERROR_INCORRECT_SERIAL_PORT    22
#define ERROR_FAIL_TO_START_CLM        23
#define ERROR_FAIL_TO_IMPORT_FILE      24 

//========== Bluetooth Error Code =====================
#define ERROR_NO_DEVICE_INFO          21
#define ERROR_NO_SERVICE_INFO         22
#define ERROR_WRONG_DEVICE_INFO       23
#define ERROR_WRONG_SERVICE_INFO      24
#define ERROR_NOT_DEVICEINFO_OBJ      25
#define ERROR_NOT_SERVICEINFO_OBJ     26
#define ERROR_WRONG_SERVICE_TYPE      27
#define ERROR_DEVICE_NOT_HAS_SERVICE  28
#define ERROR_SERVICE_NOT_CONNECTED   29
#define ERROR_NO_STARTFINDING         30
#define ERROR_WRONG_ARG               31
#define ERROR_OPPERATION_FAIL         32
#define ERROR_MACHINE_NOT_SUPPORTED   33

#define ERROR_NO_DEVICE               0xff
//========== Bluetooth service type =====================
#define UNDEFINED_BT_SERVICE          0
#define BT_HID_SERVICE                1
#define BT_DUN_SERVICE                2
#define BT_SPP_SERVICE                3
#define BT_OPP_SERVICE                4
#define BT_PAN_SERVICE                5
#define BT_HEADSET_SERVICE            6
#define BT_HANDSFREE_SERVICE          7
#define BT_FTP_SERVICE                8

//============== Key define =============================
#define KEY_GENERAL 0x1
#define KEY_ALPHA   0x2
#define KEY_FN      0x4
#define KEY_CTRL    0x8
#define KEY_ALT     0x10
#define KEY_SCAN    0x20
#define KEY_POWER   0x40
#define KEY_SHIFT   0x200
#define KEY_LSTRIGGER 0x80//#define KEY_LSTRIGGER 0x100
#define KEY_RSTRIGGER 0x100//#define KEY_RSTRIGGER 0x200
#define KEY_ALL     0xFFFFFFFF


#ifdef __cplusplus
extern "C" {
#endif

#ifdef LIBDLL_EXPORTS
#define LIBDLL_API __declspec(dllexport)
#else
#define LIBDLL_API __declspec(dllimport)
#endif

typedef struct {
    INT     fileType;
    WCHAR   filePath[1024];
    WCHAR   fileName[200];
    INT     fileSize;
} FTP_FILE_INFO;

typedef struct
{
    BOOL    FullKey;
    BOOL    TaskKey;
    BOOL    FuncKey;
    BOOL    AlphaKey;
}KEYPADLOCK, *PKEYPADLOCK;

typedef struct
{
    TCHAR   szClass[64];
}KEYPADBIND, *PKEYPADBIND;


typedef struct
{
    BOOL    CardInserted;
    BOOL    CardPowered;
    TCHAR   VENDER[32];
    TCHAR   PRODUCT[32];
}CARDINFO, *PCARDINFO;

typedef struct
{
    TCHAR   PIN[12];
}PINNUM, *PPINNUM;

typedef struct
{
    TCHAR   MANUIDENNUM[100];
}MANUINFO, *PMANUINFO;

typedef struct
{
    TCHAR   APINUM[5];
}APIVER, *PAPIVER;

typedef struct
{
    UINT    Color;
    UINT    ONOFF;
}LEDSET, *PLEDSET;

typedef struct _SYSINFO {
    UCHAR   DevDesc[16];
    UCHAR   DevCFG[16];
    UCHAR   SerialNum[16];
    UCHAR   SerialNumReadOnly[16];
    UCHAR   SerialNumPCBA[16];
    UCHAR   Manufactory[32];
    UCHAR   ManuDate[16];
    UCHAR   OsVer[32];
    UCHAR   BootloaderVer[32];
    UCHAR   MicroPVer[32];
    UCHAR   BTAddress[32];
    UCHAR   WiFiAddress[32];
    UCHAR   IMEI[32];
} SYSINFO, *PSYSINFO;

typedef struct _DEVCFGINFO {
    BYTE    DevCFG[16];
} DEVCFGINFO, *PDEVCFGINFO;

typedef struct _PBINFO {
    BYTE    PBCFG[16];
} PBINFO,  *PPBINFO;


typedef struct _BKLCTL {
    DWORD   batttimeout;
    DWORD   lightlevel;
    DWORD   actimeout;
    DWORD   aclightlevel;
    DWORD   backlightontap;
    DWORD   acbacklightontap;
    DWORD   usebattery;
    DWORD   useext;
} BKLCTL, *PBKLCTL;

typedef struct{
    UINT    uDeviceId;
    UINT    uMsg;
    DWORD   dwUser;
    DWORD   dwParam1;
    DWORD   dwParam2;
}AUDIO_MESSAGE_PARAMS;


typedef struct _WLANCTL {
    CHAR    SSID[32];                 
    DWORD   authentication;          
    DWORD   encryption;              
    DWORD   adhoc;                   
    DWORD   eap;                     
    WCHAR   key[80];
} WLANCTL, *PWLANCTL;

typedef struct _WLANCONNECTEDST {
    CHAR    SSID[32];                  
    DWORD   SSIDLength;
    BYTE    BSSID[6];
} WLANCONNECTEDST, *PWLANCONNECTEDST;

typedef struct _WLANADPTINFO {
    DWORD   fUseDHCP;
    DWORD   IPAddr;
    DWORD   SubnetMask;
    DWORD   Gateway;
    DWORD   DNSAddr;
    DWORD   DNSAltAddr;
    DWORD   WINSAddr;
    DWORD   WINSAltAddr;
} WLANADPTINFO, *PWLANADPTINFO;

#ifndef _WZCAPI_H_
typedef struct
{
    DWORD   dwDataLen;
    BYTE*   pData;
} RAW_DATA, *PRAW_DATA;
#endif

//Camera Struct
typedef struct
{
    DWORD   PreviewFlash;
    DWORD   CaptureFlash;  
}FLASH, *PFLASH;


typedef struct
{   
    INT     AutoExposure;
    INT     AutoWhiteBalance;
    INT     ImageFormat;  
    //LPWSTR  lpPathName;
    WCHAR   lpPathName[500]; 
    INT     PathSize;
    //LPWSTR  lpFileName;
    WCHAR   lpFileName[500];
    INT     FileSize;
} PICSTATE;

typedef struct  {
    BOOL    bDevMode;
    DWORD   dwCurrentScenario;
    DWORD   dwCurrentDevice;
}WAVE_DRIVER_PARAMETER,*PWAVE_DRIVER_PARAMETER;

typedef struct
{
    TCHAR   IMEI[16];
}GSMIMEI, *PGSMIMEI;

#define DBG_API                     1
#define AUDIO_MUTEON                0x2222
#define AUDIO_MUTEOFF               0x3333
#define LED_ONOFF                   0x1122
#define BLUETOOTHON                 0x5555
#define BLUETOOTHOFF                0x6666
#define BUZZERON                    0x7777
#define BUZZEROFF                   0x8888
#define SET_VIBRATOR                0x1598
#define SET_LED	                    0x1698
#define GetMCUinfo	                0x1798
#define AC97SET                     0x9999
#define SetGPIO103                  0x1799

#define AUDIOGSMOUT                 0x1001
#define AUDIOGSMIN                  0x1002
#define BTVOIPON                    0x1011
#define BTVOIPOFF                   0x1022
#define BTGSMON                     0x1033
#define BTGSMOFF                    0x1044
//for audio path switch
#define WPDM_SWITCH_AUDIO_PATH      0x1048
#define WPDM_PRIVATE_PARAMETER_DUMP 0x1049
#define SCENARIO_CE                 0x00
#define SCENARIO_GSM                0x10
#define SCENARIO_VOIP               0x20
#define AUDIODEVICE_EARPHONE        0x00
#define AUDIODEVICE_BT              0x01
#define AUDIODEVICE_BOARD           0x02   
#define AUDIODEVICE_UNDEFINE        0xFFFF

//++Summit
// sdc_sdk.h  Header file for Summit Data SDK for the CF10G
#ifndef _SDC_SDK_H_
#define _SDC_SDK_H_ 1

#ifdef __cplusplus
 extern "C" {
#endif

#define CONFIG_NAME_SZ  33
#define SSID_SZ         33
#define CLIENT_NAME_SZ  17
#define USER_NAME_SZ    65
#define USER_PWD_SZ     65
#define PSK_SZ          65
#define MAX_CFGS        20
#define NUM_WEP_KEYS    4
#define PDELAY_LOW      0
#define PDELAY_HIGH     7200000
#define PTIME_LOW       0
#define PTIME_HIGH      30000
#define FRAG_LOW        256
#define FRAG_HIGH       2346
#define RTS_LOW         0
#define RTS_HIGH        2347
#define AUTH_LOW        3
#define AUTH_HIGH       60
#define MAX_CERT_PATH   65
#define CRED_CA_POS     72 //in SDCConfig userName.buffer
#define CRED_UCA_POS    72 //in SDCConfig userPwd.buffer
#define CRED_PFILE_POS  34 //in SDCConfig userPwd.buffer
#define CRED_CERT_SZ    48 //for CRED_CA and CRED_UCA
#define CRED_PFILE_SZ   32

typedef enum _SDCERR {
  SDCERR_SUCCESS = 0,	
  SDCERR_FAIL,
  SDCERR_INVALID_NAME,
  SDCERR_INVALID_CONFIG,
  SDCERR_INVALID_DELETE,
  SDCERR_POWERCYCLE_REQUIRED,
  SDCERR_INVALID_PARAMETER,
  SDCERR_INVALID_EAP_TYPE,
  SDCERR_INVALID_WEP_TYPE,
  SDCERR_INVALID_FILE
} SDCERR;

typedef enum _AUTH {
  AUTH_OPEN = 0,	
  AUTH_SHARED,	
  AUTH_NETWORK_EAP,	
} AUTH;

typedef enum _EAPTYPE {
  EAP_NONE = 0,	
  EAP_LEAP,	
  EAP_EAPFAST,
  EAP_PEAPMSCHAP,	
  EAP_PEAPGTC,	
  EAP_EAPTLS,	
  EAP_EAPTTLS,
  EAP_PEAPTLS
} EAPTYPE;

typedef enum _POWERSAVE {
  POWERSAVE_OFF = 0,	
  POWERSAVE_MAX,	
  POWERSAVE_FAST,	
} POWERSAVE;

typedef enum _WEPTYPE {
  WEP_OFF = 0,	
  WEP_ON,	
  WEP_AUTO,
  WPA_PSK,
  WPA_TKIP,
  WPA2_PSK,
//  WPA2_TKIP,
  WPA2_AES,
  CCKM_TKIP,
  WEP_CKIP,
  WEP_AUTO_CKIP,
  CCKM_AES
} WEPTYPE;

typedef enum _RADIOMODE {
  RADIOMODE_B_ONLY = 0,	
  RADIOMODE_BG,	
  RADIOMODE_G_ONLY,
  RADIOMODE_BG_LRS,
  RADIOMODE_A_ONLY,
  RADIOMODE_ABG,  
  RADIOMODE_BGA,
  RADIOMODE_ADHOC
} RADIOMODE;

typedef enum _TXPOWER {
  TXPOWER_MAX = 0,
  TXPOWER_1   = 1,
  TXPOWER_5   = 5,
  TXPOWER_10  = 10,
  TXPOWER_20  = 20,
  TXPOWER_30  = 30,
  TXPOWER_50  = 50,
} TXPOWER;

typedef enum _BITRATE {
  BITRATE_AUTO = 0,
  BITRATE_1	   = 2,
  BITRATE_2    = 4,
  BITRATE_5_5  = 11,
  BITRATE_6    = 12,
  BITRATE_9    = 18,
  BITRATE_11   = 22,
  BITRATE_12   = 24,
  BITRATE_18   = 36,
  BITRATE_24   = 48,
  BITRATE_36   = 72,
  BITRATE_48   = 96,
  BITRATE_54   = 108
} BITRATE;

typedef enum _PREAMBLE {
  PRE_AUTO = 0,
  PRE_SHORT,
  PRE_LONG,
} PREAMBLE;

typedef enum _GSHORTSLOT {
  GSHORT_AUTO = 0,
  GSHORT_OFF,
  GSHORT_ON,
} GSHORTSLOT;

typedef enum _BT_COEXIST {
  BT_OFF = 0,
  BT_ON,
} BT_COEXIST;

typedef enum _REGDOMAIN {
  REG_FCC   = 0,
  REG_ETSI  = 1,
  REG_TELEC = 2,
  REG_WW = 3,
  REG_KCC = 4, //Korea
} REG_DOMAIN;

typedef enum _PING_PAYLOAD {
  PP_32   = 32,
  PP_64   = 64,
  PP_128  = 128,
  PP_256  = 256,
  PP_512  = 512,
  PP_1024 = 1024
} PING_PAYLOAD;

typedef enum _RX_DIV {
  RXDIV_MAIN = 0,	
  RXDIV_AUX,	
  RXDIV_START_AUX,	
  RXDIV_START_MAIN,	
} RX_DIV;

typedef enum _TX_DIV {
  TXDIV_MAIN = 0,	
  TXDIV_AUX,
  TXDIV_ON   = 3,	
} TX_DIV;

typedef enum _ROAM_TRIG {
  RTRIG_50 = 50,
  RTRIG_55 = 55,
  RTRIG_60 = 60,
  RTRIG_65 = 65,
  RTRIG_70 = 70,
  RTRIG_75 = 75,
  RTRIG_80 = 80,
  RTRIG_85 = 85,
  RTRIG_90 = 90,
} ROAM_TRIG;

typedef enum _ROAM_DELTA {
  RDELTA_5  = 5,
  RDELTA_10 = 10,
  RDELTA_15 = 15,
  RDELTA_20 = 20,
  RDELTA_25 = 25,
  RDELTA_30 = 30,
  RDELTA_35 = 35,
} ROAM_DELTA;

typedef enum _ROAM_PERIOD {
  RPERIOD_5	  = 5,
  RPERIOD_10  = 10,
  RPERIOD_15  = 15,
  RPERIOD_20  = 20,
  RPERIOD_25  = 25,
  RPERIOD_30  = 30,
  RPERIOD_35  = 35,
  RPERIOD_40  = 40,
  RPERIOD_45  = 45,
  RPERIOD_50  = 50,
  RPERIOD_55  = 55,
  RPERIOD_60  = 60,
} ROAM_PERIOD;

typedef enum _CCX_FEATURES {
  CCX_OPTIMIZED = 0,
  CCX_FULL      = 1,
  CCX_OFF       = 2,
} CCX_FEATURES;

typedef enum _WEPLEN {
  WEPLEN_NOT_SET = 0,
  WEPLEN_40BIT,
  WEPLEN_128BIT,
} WEPLEN;

typedef enum _FCCTEST {
  FCCTEST_OFF  = 0,
  FCCTEST_TX   = 1,
  FCCTEST_RX   = 3,
  FCCTEST_FREQ = 2,
} FCC_TEST;

typedef enum _CARDSTATE {
  CARDSTATE_NOT_INSERTED = 0,
  CARDSTATE_NOT_ASSOCIATED,
  CARDSTATE_ASSOCIATED,
  CARDSTATE_AUTHENTICATED,
  CARDSTATE_FCCTEST,
  CARDSTATE_NOT_SDC,
  CARDSTATE_DISABLED,
  CARDSTATE_ERROR
} CARDSTATE;

#define RADIOTYPE_BCM_OFFSET 0x00 //CF,PE,SD10 Radios
#define RADIOTYPE_AR_OFFSET 0x100 //SD30 Radio
typedef enum _RADIOTYPE {
  RADIOTYPE_BG        = 0,	
  RADIOTYPE_ABG       = 1,  
  RADIOTYPE_NBG = 2,  
  RADIOTYPE_NABG = 3,  
  RADIOTYPE_AR_BG = (RADIOTYPE_AR_OFFSET + RADIOTYPE_BG), 
  RADIOTYPE_AR_ABG = (RADIOTYPE_AR_OFFSET + RADIOTYPE_ABG), 
  RADIOTYPE_AR_NBG = (RADIOTYPE_AR_OFFSET + RADIOTYPE_NBG), 
  RADIOTYPE_AR_NABG = (RADIOTYPE_AR_OFFSET + RADIOTYPE_NABG), 
  RADIOTYPE_NOT_SDC = 0x64, 
  RADIOTYPE_NOT_SDC_1 = 0x65, //reserved
} RADIOTYPE;

typedef enum _CERTLOCATION {
  CERT_NONE = 0,   // don't validate the server
  CERT_FILE,       // specify the filename for caCert
  CERT_FULL_STORE, // use the entire MS-store
  CERT_IN_STORE    // use one specific cert from the MS-store, specify the cert's hash
} CERTLOCATION;

typedef enum _INTERFERENCE {
  INTER_NONE = 0, // OFF
  INTER_NONWLAN,  // reduces CCA Tx threshold
  INTER_WLAN,     // reduces interchannel noise
  INTER_AUTO      // automatic
} INTERFERENCE;

typedef enum _TTLS_INNER_METHOD {
  TTLS_AUTO = 0,	// uses any available EAP method
  TTLS_MSCHAPV2,    
  TTLS_MSCHAP,	    
  TTLS_PAP,
  TTLS_CHAP,
  TTLS_EAP_MSCHAPV2,
  //TTLS_EAP_MD5,
  //TTLS_EAP_GTC,
  //TTLS_EAP_OTP,
  //TTLS_EAP_TLS
} TTLS_INNER_METHOD;


// or this in the length to set the XMIT key
#define XMITBIT 0x100

#pragma pack(1)

typedef struct _WEPKEY {
    DWORD              length;   //40 or 128 or 0 for not set
    UCHAR              data[16]; //enough to store 128 bits 
} WEPKey;  

typedef struct _CRYPT {
    DWORD              size;
    CHAR               buffer[120];
    DWORD              offset;
} CRYPT;

typedef struct _SDCConfig {
    CHAR               configName[CONFIG_NAME_SZ];
    CHAR               SSID[SSID_SZ];
    CHAR               clientName[CLIENT_NAME_SZ];
    INT                txPower;
    AUTH               authType;
    EAPTYPE            eapType;
    POWERSAVE          powerSave;
    WEPTYPE	           wepType;
    BITRATE	           bitRate;
    RADIOMODE          radioMode;
    CRYPT              userName;
    CRYPT              userPwd;
    CRYPT              PSK;
    CRYPT              WEPKeys;
} SDCConfig;

typedef struct _SDCGlobalConfig {
    DWORD              fragThreshold;
    DWORD              RTSThreshold;
    RX_DIV             RxDiversity;
    TX_DIV             TxDiversity;
    ROAM_TRIG          roamTrigger;
    ROAM_DELTA         roamDelta;
    ROAM_PERIOD	       roamPeriod;
  PREAMBLE		preamble;	//not used
  GSHORTSLOT	g_shortslot;//not used
    BT_COEXIST         BTcoexist;
    PING_PAYLOAD       pingPayload;
  DWORD			pingTimeout;   //in ms
  DWORD			pingDelay;     //in ms
  DWORD         radioState;  // enabled-1, disabled-0
  DWORD         displayPasswords;  //0 no, 1 yes
    DWORD              adminOverride;
  DWORD         txMax;	  // BG radio - to account for high gain antennae--(max power out desired/19dbm) * 100
  FCC_TEST      FCCtest;      // 0 - off, 1 tx 2 frequency 3 rx
  DWORD         testChannel;  // 1-14
  BITRATE       testRate;	  // 
  TXPOWER       testPower;	  //	0-100 %
  DWORD         regDomain;	  // status purposes only
  DWORD         ledUsed;      //for minimodule GPIO 0, need resistor off board to make it work
  DWORD         txTestTimeout;//in seconds--60000 (decimal) means no timeout--
  DWORD         WMEenabled;   //enable 1
  DWORD         CCXfeatures;  // enable 1 or CCX RM and AP control of TX power
  CHAR          certPath[MAX_CERT_PATH]; // to change the path of the certificate store
    CRYPT              adminPassword;
  DWORD         bLRS;         // bit 0 = chan 1, bit 1 =chan 2, etc.
  DWORD         avgWindow;    // 2-8 (rssi moving average window)
  DWORD         probeDelay;   // 2-60 (delay before sending out probes when AP's aren't located--not config for WZC)
  DWORD         polledIRQ;    // for units that can't share IRQs nicely
  DWORD         keepAlive;	  // in cam mode how often a null packet gets sent in seconds (0 means never, 9 by default)
  DWORD         trayIcon;     // enable 1
  DWORD         aggScanTimer; // enable 1
  DWORD			authTimeout;  // in seconds, for EAP credentials, default is 8 ms
  DWORD			autoProfile;  // not implemented
  DWORD         PMKcaching;   //0 standard, 1 opportunistic key caching enabled
  DWORD         defAdhocChannel; // when no beacons found this channel is used
  DWORD         silentRunning;	 //	enables silent running mode (no active scans unless connected)
  DWORD			Reserved0[3];
  DWORD         txMaxA;	      // A radio - to account for high gain antennae-- %   
  DWORD			adminFiles;   // allows import/export of settings to file
  DWORD			DFSchannels;  //enable 1
  DWORD         interferenceMode;  //0 off, 1 nonWLAN, 2 WLAN, 3 auto
  DWORD         authServerType; //0 ACS (type 1), 1 SBR (type 2)
  DWORD         TTLSInnerMethod;//0 auto-EAP
  DWORD         Reserved1[3];   // future expansion of the global config......
} SDCGlobalConfig;

typedef struct _SDC3rdPartyConfig {
    CHAR               clientName[CLIENT_NAME_SZ];
    POWERSAVE          powerSave;
    INT                txPower;
    BITRATE            bitRate;
    RADIOMODE          radioMode;
} SDC3rdPartyConfig;

typedef struct _CF10G_STATUS {
    CARDSTATE          cardState;
    CHAR               configName[CONFIG_NAME_SZ];
    UCHAR              client_MAC[6];
    UCHAR              client_IP[4];
    CHAR               clientName[CLIENT_NAME_SZ];
    UCHAR              AP_MAC[6];
    UCHAR              AP_IP[4];
    CHAR               APName[CLIENT_NAME_SZ];
    EAPTYPE            eapType;
    DWORD              channel;
    INT                rssi;
    BITRATE            bitRate;
    INT                txPower;
    DWORD              driverVersion;
    RADIOTYPE          radioType;
    DWORD              DTIM;
    DWORD              beaconPeriod;
    DWORD              beaconsReceived;  
} CF10G_STATUS;

typedef struct _CONFIG_FILE_INFO {
	  DWORD              numConfigs;
	  BOOLEAN            globalConfigPresent;
	  BOOLEAN            thirdPartyConfigPresent;
	  DWORD              sdkVersion;
} CONFIG_FILE_INFO;

typedef struct _SDC_ALL {
	  DWORD              numConfigs;
	  SDCConfig         *configs;
	  SDC3rdPartyConfig *configThirdParty;
	  SDCGlobalConfig   *configGlobal;
} SDC_ALL;


#pragma pack()

#ifndef NDIS_MINIPORT_DRIVER

// iphlpapi.lib must be linked into any program using the SDK from user mode
// ws2.lib must also be linked into any program using the SDK from user mode



#endif//NDIS_MINIPORT_DRIVER

#ifdef __cplusplus
 }
#endif

#endif//_SDC_SDK_H_


#define DATA_MEM_MIN    32
#define DATA_MEM_MAX    65536

//  API prototypes


//GPS
DWORD WINAPI ImportInstantFixFile(CHAR *filePath, INT comPort, INT baudrate);

// System
DWORD WINAPI GetAPIVersion(APIVER *apiVer);
DWORD WINAPI GetHALUUID(GUID *guid);
DWORD WINAPI GetSysInfo (SYSINFO *sysInfo);
DWORD WINAPI GetSysDevName (WCHAR *devName,BYTE nameSize);
DWORD WINAPI SetInitLoaderBind(KEYPADBIND *KeypadBind);
DWORD WINAPI SetSysDevName (WCHAR *devName,BYTE nameSize);
DWORD WINAPI SystemSoftReset(void);
DWORD WINAPI SetSystemColdBoot(BYTE CleanFlag,BYTE RemoteUpdate);

DWORD WINAPI GetCipherlabPlatformName (DWORD *devName);
DWORD WINAPI GetCipherlabDeviceID (CHAR *devName,BYTE nameSize);     
DWORD WINAPI StartScreenLock(DWORD dwInterval);      


// Backlight
DWORD GetBacklightCTL (BKLCTL *bklCtl);
DWORD SetBacklightCTL (BKLCTL *bklCtl);
DWORD GetBacklightLV (BYTE byFromAC, BYTE *byLevel);
DWORD SetBacklightLV (BYTE byFromAC, BYTE byLevel);
DWORD GetBacklightST (BYTE *state);
DWORD SetBacklightST (BYTE state);
DWORD SetBacklightDefault ();
DWORD SetBacklightMax ();
DWORD SetBacklightMin ();

// TouchPanel
DWORD WINAPI SetTchLock(BYTE lockState);
DWORD WINAPI GetTchLock(BYTE *lockState);
DWORD WINAPI GetDisplayType (BYTE *panelMode);
DWORD WINAPI SetDisplayType (BYTE panelMode);

// Taskbar
DWORD WINAPI SetTaskBarAlwaysHide(BYTE hide);
DWORD WINAPI SetTaskBarAutoHide(BYTE hide);

// Keypad
DWORD WINAPI SetKeypadSensitivity(DWORD value);
DWORD WINAPI GetKeypadSensitivity(DWORD *value);
DWORD WINAPI SetKeyPadFullKeyLock(BYTE lockState);
DWORD WINAPI GetKeyPadFullKeyState(BYTE *state);
DWORD WINAPI SetKeyAlphaState(BYTE state);
DWORD WINAPI GetKeyAlphaState(BYTE *state);
DWORD WINAPI GetKeyPadKeyLock(KEYPADLOCK *keyLock);
DWORD WINAPI SetKeyPadFuncKeyLock(BYTE lockState);
DWORD WINAPI SetKeyPadAlphaKeyLock(BYTE lockState);
DWORD WINAPI GetKeypadType (BYTE *keypadLayout);
DWORD WINAPI GetKeyFuncKeyState(BYTE *state);
DWORD WINAPI SetKeyFuncKeyState(BYTE state);
DWORD WINAPI GetKeyPadFuncKeyLock(BYTE lockState);
DWORD WINAPI SetKeyPadTestMode(BYTE state);
DWORD WINAPI GetKeypadLock(DWORD key, DWORD *lockState);
DWORD WINAPI SetKeypadLock(DWORD key, DWORD lockState);
DWORD WINAPI GetKeypadMode(DWORD key, DWORD *mode);
DWORD WINAPI SetKeypadMode(DWORD key, DWORD mode);
DWORD WINAPI GetKeypadState(DWORD key, DWORD *state);
DWORD WINAPI SetKeypadState(DWORD key, DWORD state);

// Keylight
DWORD WINAPI GetKeylightOnOff (BYTE *onOff);
DWORD WINAPI SetKeylightOnOff (BYTE onOff);

// Trigger
DWORD WINAPI GetTriggerState(BYTE *state);
DWORD WINAPI SetTriggerLockON(VOID);
DWORD WINAPI SetTriggerLockOFF(VOID);

// Audio
DWORD WINAPI SetBTAudioState(BOOL state);
DWORD WINAPI SetAudioPath(DWORD uiPath);
DWORD WINAPI GetHeadsetState (BYTE *state);

// Vibartor
DWORD SetVibratorPower  (BYTE onOff);
DWORD GetVibratorPower  (BYTE *onOff);

// Wireless
DWORD WINAPI SetWiFiPower(BYTE onOff);
DWORD WINAPI GetWiFiPower(BYTE *onOff);
DWORD SetWlanIpInfo(WLANADPTINFO *adpt);
DWORD GetWlanIpInfo(WLANADPTINFO *adpt);
DWORD AddWlanSsidToPreferredList (WLANCTL &wlanCtl) ;
DWORD GetWlanPreferredList (RAW_DATA *preferredList);
DWORD GetWlanAvailableList (RAW_DATA *availableList);
DWORD GetWlanConnectedStatus(WLANCONNECTEDST *wlanConnSt);
DWORD ResetWlanPreferredList (VOID) ;
DWORD ReconnectWlanPreferredList (VOID) ;
DWORD GetWiFiMac(ULONGLONG *wifiMac);

// Bluetooth
DWORD WINAPI StartBluetooth(VOID);
DWORD WINAPI StopBluetooth(VOID);
DWORD WINAPI StartFindingDevice(VOID);
DWORD WINAPI FindNextBTDevice(INT *deviceInfo);
DWORD WINAPI FindService(INT targetService, INT deviceInfo, INT *serviceInfo);
DWORD WINAPI GetBTConnStatus(INT serviceInfo, INT *status);
DWORD WINAPI SetBTConnStatus(INT serviceType, INT onOff, INT deviceInfo, INT serviceInfo);
DWORD WINAPI StartBrowse(INT serviceInfo, CHAR *targetPath);
DWORD WINAPI GetNextFile(INT serviceInfo, FTP_FILE_INFO *fileInfo);
DWORD WINAPI PutFile(INT serviceInfo, CHAR *filePath, HWND progressBar);
DWORD WINAPI GetFile(INT serviceInfo, FTP_FILE_INFO *fileInfo, HWND progressBar);
DWORD WINAPI GetDeviceName(INT deviceInfo, CHAR *outBuf, INT bufSize);
DWORD WINAPI GetServiceType(INT serviceInfo, INT *serviceType);
DWORD WINAPI GetDeviceAddress(INT deviceInfo, ULONGLONG *btAddr);
DWORD WINAPI StartPairing(INT deviceInfo, CHAR *pinCode, INT pinCodeLen);
DWORD WINAPI StartUnpairing(INT deviceInfo);
DWORD WINAPI GetSppComPort(INT serviceInfo, INT *comPort);
DWORD WINAPI SetSppComport(INT serviceInfo, INT comPort);
DWORD WINAPI GetSppChannel(INT serviceInfo, INT *channel);
DWORD WINAPI GetDeviceType(INT deviceInfo, INT *deviceType);
DWORD WINAPI CreateSppServiceInfo(ULONGLONG deviceMacAddr, WCHAR *deviceName, INT deviceType, INT comPort, INT channel, INT *deviceInfo, INT *serviceInfo);
DWORD WINAPI ConnectByMacAddr(ULONGLONG deviceMacAddr, INT targetService, CHAR *pinCode, INT sppComPort, INT *devinfo, INT *servInfo);
DWORD WINAPI SetBTService(BYTE OnOff);
DWORD WINAPI GetBTService(PBYTE OnOff);

// Status Indication
DWORD WINAPI SetBuzzerOFF(VOID);
DWORD WINAPI SetBuzzerON(DWORD hz);
DWORD WINAPI SetLEDLight(BYTE color,BOOL onOff);

// Button Assignment
DWORD WINAPI SetButtonAssignment (INT buttonID, INT keyCode, TCHAR *program);
DWORD WINAPI GetButtonAssignment (INT buttonID, INT *keyCode, TCHAR *program);

// Headset
DWORD WINAPI EnableBTAudio(BOOL onOff);
DWORD WINAPI EnableGsmBTHeadset(BOOL state);
DWORD WINAPI EnableGsmAudioIn(BOOL onOff);
DWORD WINAPI EnableGsmAudioOut(BOOL onOff);

// GPRS Check
DWORD WINAPI SetGprsPower(BYTE onOff);
DWORD WINAPI GetGprsPower(BYTE *onOff);
DWORD WINAPI SetPINCode(PINNUM *pinCode, BYTE *result);
DWORD WINAPI GetPINCode(PINNUM *pinCode, BYTE *result);
DWORD WINAPI CheckPINCode(PINNUM *pinCode, BYTE *result);
DWORD WINAPI CheckPINNeed(BYTE *state);
DWORD WINAPI GetGPRSManufacturer(MANUINFO *manuInfo);
DWORD WINAPI GetPINChecked(BYTE *checked);
DWORD WINAPI GPRSPowerOnAutoCheckPIN(BYTE *result);
DWORD WINAPI SetPINCodeToSave(BYTE *result);
DWORD WINAPI SetGPRSConnStatus(INT onOff, 
                               WCHAR *entryName,
                               WCHAR *phoneNumber,
                               WCHAR *userName,
                               WCHAR *password,
                               WCHAR *apName,
                               WCHAR *callbackNumber,
                               WCHAR *domain);
DWORD WINAPI GetGPRSConnStatus(INT *status);
DWORD WINAPI ChangePINCode(PINNUM *oldPinCode, PINNUM *newPinCode);
DWORD WINAPI SetPINCodeLock(PINNUM *pinCode, BYTE onOff);
DWORD WINAPI GetGPRSIMEI(GSMIMEI *gsmIMEI);
DWORD WINAPI SetGSMService(BYTE OnOff);
DWORD WINAPI GetGSMService(PBYTE OnOff);
DWORD WINAPI GetGSMSignalStrength(PDWORD dwStrength);
DWORD WINAPI SetGPRSConfig(    WCHAR *phoneNumber, 
                               WCHAR *userName, 
                               WCHAR *password, 
                               WCHAR *apName);

// Camera
DWORD EnableCamera(HWND wnd, BOOL onOff);
DWORD EnablePreviewWindow(BOOL onOff);
VOID  SetPreviewLocation(int posX, int posY);
DWORD GetPreviewLocation(int *posX, int *posY);
DWORD StartStillCapture(INT playSound,DWORD addTimeStamp);   
DWORD SetStillCaptureState(PICSTATE *picInfo);
DWORD GetStillCaptureState(PICSTATE *picInfo);
DWORD SetCameraExposureValue(DWORD level);
DWORD GetCameraExposureValue(DWORD *level);
DWORD SetFlashLight(FLASH *flash);
DWORD GetFlashLight(FLASH *flash);
DWORD SetFeature(DWORD level);
DWORD GetFeature(DWORD *level);
DWORD SetCameraResolution(DWORD resValue);
DWORD GetCameraResolution(DWORD *resValue);
DWORD TerminateGraph();
DWORD StartGraph();
DWORD HaltGraph();


// Summit
SDCERR GetCurrentConfig(DWORD *num, CHAR *name);
SDCERR ModifyConfig(CHAR *name, SDCConfig *config);
SDCERR GetConfig(CHAR *name, SDCConfig *config);
SDCERR DeleteConfig(CHAR *name);
SDCERR GetNumConfigs(DWORD *num);
SDCERR ActivateConfig(CHAR *name);
SDCERR AddConfig(SDCConfig *config);
SDCERR GetAllConfigs(SDCConfig *config, DWORD *num);
SDCERR SetAllConfigs(DWORD num, SDCConfig *config);
SDCERR GetGlobalSettings(SDCGlobalConfig *configGlobal);
SDCERR SetGlobalSettings(SDCGlobalConfig *configGlobal);
SDCERR Get3rdPartyConfig(SDC3rdPartyConfig *config3rd);
SDCERR Set3rdPartyConfig(SDC3rdPartyConfig *config3rd);
SDCERR GetCurrentStatus(CF10G_STATUS *status);
SDCERR RadioDisable();
SDCERR RadioEnable();
REG_DOMAIN GetCurrentDomain();
SDCERR GetSDKVersion(DWORD *version);
SDCERR FlushConfigKeys(INT configNumber);
SDCERR FlushAllConfigKeys();
SDCERR GetConfigFileInfo(CHAR *fileName, CONFIG_FILE_INFO *info);
SDCERR ExportSettings(CHAR *fileName, SDC_ALL *configAll);
SDCERR ImportSettings(CHAR *fileName, SDC_ALL *configAll);
SDCERR SetWEPKey(SDCConfig *config, INT keyIndex,  WEPLEN keyLength, UCHAR *wepKey, BOOLEAN keyState);
SDCERR GetWEPKey(SDCConfig *config, INT keyIndex,  WEPLEN *keyLength, UCHAR *wepKey, BOOLEAN *keyState);
SDCERR SetMultipleWEPKeys(SDCConfig *config,  INT keyIndex,  WEPLEN keyLength1, UCHAR *wepKey1,
                                                        WEPLEN keyLength2, UCHAR * wepKey2,
                                                        WEPLEN keyLength3, UCHAR * wepKey3,
                                                        WEPLEN keyLength4, UCHAR * wepKey4);
SDCERR GetMultipleWEPKeys(SDCConfig *config,  INT *keyIndex, WEPLEN *keyLength1, UCHAR *wepKey1,
                                                        WEPLEN *keyLength2, UCHAR *wepKey2,
                                                        WEPLEN *keyLength3, UCHAR *wepKey3,
                                                        WEPLEN *keyLength4, UCHAR *wepKey4);
SDCERR SetPSK(SDCConfig *config,  CHAR *psk);
SDCERR GetPSK(SDCConfig *config,  CHAR *psk);
SDCERR SetLEAPCred(SDCConfig *config,  CHAR *username, CHAR *password);
SDCERR GetLEAPCred(SDCConfig *config,  CHAR *username, CHAR *password);
SDCERR SetEAPFASTCred(SDCConfig *config,  CHAR *username, CHAR *password, CHAR *pacFileName, CHAR *pacPassword);
SDCERR GetEAPFASTCred(SDCConfig *config,  CHAR *username, CHAR *password, CHAR *pacFileName, CHAR *pacPassword);
SDCERR SetPEAPGTCCred(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION certLocation, CHAR *caCert );
SDCERR GetPEAPGTCCred(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION *certLocation, CHAR *caCert );
SDCERR SetPEAPMSCHAPCred(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION certLocation, CHAR *caCert );
SDCERR GetPEAPMSCHAPCred(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION *certLocation, CHAR *caCert );
SDCERR SetEAPTLSCred(SDCConfig *config,  CHAR *username, CHAR *userCert, CERTLOCATION certLocation, CHAR *caCert);
SDCERR GetEAPTLSCred(SDCConfig *config,  CHAR *username, CHAR *userCert, CERTLOCATION *certLocation, CHAR *caCert);
DWORD  ScanWiFiBSSID(void);
DWORD  GetWiFiBSSIDList(BYTE *buffer);


// Dynamic**********************************
// GPS
typedef DWORD (WINAPI *PFN_ImportInstantFixFile)(CHAR *filePath, INT comPort, INT baudrate);


// System
typedef DWORD (WINAPI *PFN_GetAPIVersion)(APIVER *apiVer);
typedef DWORD (WINAPI *PFN_GetHALUUID)(GUID *guid);
typedef DWORD (WINAPI *PFN_GetSysInfo)(SYSINFO *sysInfo);
typedef DWORD (WINAPI *PFN_GetSysDevName)(WCHAR *devName, BYTE nameSize);
typedef DWORD (WINAPI *PFN_SetInitLoaderBind)(KEYPADBIND *keypadBind);
typedef DWORD (WINAPI *PFN_SetSysDevName)(WCHAR *devName, BYTE nameSize);
typedef DWORD (WINAPI *PFN_SystemSoftReset)(VOID);
typedef DWORD (WINAPI *PFN_SetSystemColdBoot)(BYTE CleanFlag,BYTE RemoteUpdate);

typedef DWORD (WINAPI *PFN_GetCipherlabPlatformName) (DWORD *devName);
typedef DWORD (WINAPI *PFN_GetCipherlabDeviceID) (CHAR *devName,BYTE nameSize);
typedef DWORD (WINAPI *PFN_StartScreenLock) (DWORD dwInterval);    

// Backlight
typedef DWORD (WINAPI *PFN_GetBacklightCTL)(BKLCTL *bklCtl);
typedef DWORD (WINAPI *PFN_SetBacklightCTL)(BKLCTL *bklCtl);
typedef DWORD (WINAPI *PFN_GetBacklightLV) (BYTE byFromAC, BYTE *byLevel);
typedef DWORD (WINAPI *PFN_SetBacklightLV) (BYTE byFromAC, BYTE byLevel);
typedef DWORD (WINAPI *PFN_GetBacklightST) (BYTE *state);
typedef DWORD (WINAPI *PFN_SetBacklightST) (BYTE state);
typedef DWORD (WINAPI *PFN_SetBacklightDefault)();
typedef DWORD (WINAPI *PFN_SetBacklightMax)();
typedef DWORD (WINAPI *PFN_SetBacklightMin)();

// TouchPanel
typedef DWORD (WINAPI *PFN_SetTchLock)(BYTE lockState);
typedef DWORD (WINAPI *PFN_GetTchLock)(BYTE *lockState);
typedef DWORD (WINAPI *PFN_GetDisplayType) (BYTE *panelMode);
typedef DWORD (WINAPI *PFN_SetDisplayType) (BYTE panelMode);

// Taskbar
typedef DWORD (WINAPI *PFN_SetTaskBarAlwaysHide)(BYTE hide);
typedef DWORD (WINAPI *PFN_SetTaskBarAutoHide)(BYTE hide);

// Keypad
typedef DWORD (WINAPI *PFN_SetKeypadSensitivity)(DWORD value);
typedef DWORD (WINAPI *PFN_GetKeypadSensitivity)(DWORD *value);
typedef DWORD (WINAPI *PFN_SetKeyPadFullKeyLock)(BYTE lockState);
typedef DWORD (WINAPI *PFN_GetKeyPadFullKeyState)(BYTE *lockState);
typedef DWORD (WINAPI *PFN_SetKeyAlphaState)(BYTE state);
typedef DWORD (WINAPI *PFN_GetKeyAlphaState)(BYTE *state);
typedef DWORD (WINAPI *PFN_GetKeyPadKeyLock)(KEYPADLOCK *keyLock);
typedef DWORD (WINAPI *PFN_SetKeyPadFuncKeyLock)(BYTE lockState);
typedef DWORD (WINAPI *PFN_SetKeyPadAlphaKeyLock)(BYTE lockState);
typedef DWORD (WINAPI *PFN_GetKeypadType) (BYTE *keypadLayout);
typedef DWORD (WINAPI *PFN_GetKeyFuncKeyState)  (BYTE *State);
typedef DWORD (WINAPI *PFN_SetKeyFuncKeyState)  (BYTE state);
typedef DWORD (WINAPI *PFN_GetKeyPadFuncKeyLock)(BYTE *lockState);
typedef DWORD (WINAPI *PFN_SetKeyPadTestMode)(BYTE state);
typedef DWORD (WINAPI *PFN_GetKeypadLock)(DWORD Key, DWORD *lockState);
typedef DWORD (WINAPI *PFN_SetKeypadLock)(DWORD Key, DWORD lockState);
typedef DWORD (WINAPI *PFN_GetKeypadMode)(DWORD Key, DWORD *mode);
typedef DWORD (WINAPI *PFN_SetKeypadMode)(DWORD Key, DWORD mode);
typedef DWORD (WINAPI *PFN_GetKeypadState)(DWORD Key, DWORD *state);
typedef DWORD (WINAPI *PFN_SetKeypadState)(DWORD Key, DWORD state);

// Keylight
typedef DWORD (WINAPI *PFN_GetKeylightOnOff) (BYTE *onOff);
typedef DWORD (WINAPI *PFN_SetKeylightOnOff) (BYTE onOff);

// Trigger
typedef DWORD (WINAPI *PFN_GetTriggerState)(BYTE *state);
typedef DWORD (WINAPI *PFN_SetTriggerLockON)(VOID);
typedef DWORD (WINAPI *PFN_SetTriggerLockOFF)(VOID);

// Audio
typedef DWORD (WINAPI *PFN_SetBTAudioState)(BOOL state);
typedef DWORD (WINAPI *PFN_SetAudioPath)(DWORD uiPath);
typedef DWORD (WINAPI *PFN_GetHeadsetState)(BYTE *state);

// Vibartor
typedef DWORD (WINAPI *PFN_SetVibratorPower) (BYTE onOff);
typedef DWORD (WINAPI *PFN_GetVibratorPower) (BYTE *onOff);

// Wireless
typedef DWORD (WINAPI *PFN_SetWiFiPower)(BYTE onOff);
typedef DWORD (WINAPI *PFN_GetWiFiPower)(BYTE *onOff);
typedef DWORD (WINAPI *PFN_GetWlanIpInfo) (WLANADPTINFO *adpt);
typedef DWORD (WINAPI *PFN_SetWlanIpInfo) (WLANADPTINFO *adpt);
typedef DWORD (WINAPI *PFN_AddWlanSsidToPreferredList) (WLANCTL &wlanCtl1) ;
typedef DWORD (WINAPI *PFN_GetWlanPreferredList) (RAW_DATA *preferredList);
typedef DWORD (WINAPI *PFN_GetWlanAvailableList) (RAW_DATA *availableList);
typedef DWORD (WINAPI *PFN_GetWlanConnectedStatus) (WLANCONNECTEDST *wlanConnSt);
typedef DWORD (WINAPI *PFN_ResetWlanPreferredList) (VOID) ;
typedef DWORD (WINAPI *PFN_ReconnectWlanPreferredList) (VOID) ;
typedef DWORD (WINAPI *PFN_GetWiFiMac) (ULONGLONG *wifiMac);

// Bluetooth
typedef DWORD (WINAPI *PFN_StartBluetooth)(VOID);
typedef DWORD (WINAPI *PFN_StopBluetooth) (VOID);
typedef DWORD (WINAPI *PFN_StartFindingDevice)(VOID);
typedef DWORD (WINAPI *PFN_FindNextBTDevice)(INT *deviceInfo);
typedef DWORD (WINAPI *PFN_FindService)(INT targetService, INT deviceInfo, INT *serviceInfo);
typedef DWORD (WINAPI *PFN_GetBTConnStatus)(INT serviceInfo, INT *status);
typedef DWORD (WINAPI *PFN_SetBTConnStatus)(INT serviceType, INT onOff, INT deviceInfo, INT serviceInfo);
typedef DWORD (WINAPI *PFN_StartBrowse)(INT serviceInfo, CHAR *targetPath);
typedef DWORD (WINAPI *PFN_GetNextFile)(INT serviceInfo, FTP_FILE_INFO *fileInfo);
typedef DWORD (WINAPI *PFN_PutFile)(INT serviceInfo, CHAR *filePath, HWND progressBar);
typedef DWORD (WINAPI *PFN_GetFile)(INT serviceInfo, FTP_FILE_INFO *fileInfo, HWND progressBar);
typedef DWORD (WINAPI *PFN_GetDeviceName)(INT deviceInfo, CHAR *outBuf, INT bufSize);
typedef DWORD (WINAPI *PFN_GetServiceType)(INT serviceInfo, INT *serviceType);
typedef DWORD (WINAPI *PFN_GetDeviceAddress)(INT deviceInfo, ULONGLONG *btAddr);
typedef DWORD (WINAPI *PFN_StartPairing)(INT deviceInfo, CHAR *pinCode, INT pinCodeLen);
typedef DWORD (WINAPI *PFN_StartUnpairing)(INT deviceInfo);
typedef DWORD (WINAPI *PFN_GetSppComPort)(INT serviceInfo, INT *comPort);
typedef DWORD (WINAPI *PFN_SetSppComport)(INT serviceInfo, INT comPort);
typedef DWORD (WINAPI *PFN_GetSppChannel)(INT serviceInfo, INT *channel);
typedef DWORD (WINAPI *PFN_GetDeviceType)(INT deviceInfo, INT *deviceType);
typedef DWORD (WINAPI *PFN_CreateSppServiceInfo)(ULONGLONG deviceMacAddr, WCHAR *deviceName, INT deviceType, INT comPort, INT channel, INT *deviceInfo, INT *serviceInfo);
typedef DWORD (WINAPI *PFN_ConnectByMacAddr)(ULONGLONG deviceMacAddr, INT targetService, CHAR *pinCode, INT sppComPort, INT *devinfo, INT *servInfo);
typedef DWORD (WINAPI *PFN_SetBTService)(BYTE OnOff);
typedef DWORD (WINAPI *PFN_GetBTService)(PBYTE OnOff);

// Status Indication
typedef DWORD (WINAPI *PFN_SetBuzzerON)(DWORD hz);
typedef DWORD (WINAPI *PFN_SetBuzzerOFF)(VOID);
typedef DWORD (WINAPI *PFN_SetLEDLight)(BYTE color,BOOL onOff);

// Button Assignment
typedef DWORD (WINAPI *PFN_SetButtonAssignment) (INT buttonID, INT keyCode, TCHAR *program);
typedef DWORD (WINAPI *PFN_GetButtonAssignment) (INT buttonID, INT *keyCode, TCHAR *program);

// Headset
typedef DWORD (WINAPI *PFN_EnableBTAudio)(BOOL onOff);
typedef DWORD (WINAPI *PFN_EnableGsmBTHeadset)(BOOL state);
typedef DWORD (WINAPI *PFN_EnableGsmAudioIn)(BOOL onOff);
typedef DWORD (WINAPI *PFN_EnableGsmAudioOut)(BOOL onOff);

// GPRS Check
typedef DWORD (WINAPI *PFN_SetGprsPower)(BYTE onOff);
typedef DWORD (WINAPI *PFN_GetGprsPower)(BYTE *onOff);
typedef DWORD (WINAPI *PFN_SetPINCode)(PINNUM *pinCode, BYTE *result);
typedef DWORD (WINAPI *PFN_GetPINCode)(PINNUM *pinCode, BYTE *result);
typedef DWORD (WINAPI *PFN_CheckPINCode)(PINNUM *pinCode, BYTE *result);
typedef DWORD (WINAPI *PFN_CheckPINNeed)(BYTE *state);
typedef DWORD (WINAPI *PFN_GetGPRSManufacturer)(MANUINFO *manuInfo);
typedef DWORD (WINAPI *PFN_GetPINChecked)(BYTE *checked);
typedef DWORD (WINAPI *PFN_GPRSPOWERONAUTOCHECKPIN)(BYTE *result);
typedef DWORD (WINAPI *PFN_SetPINCodeToSave)(BYTE *result);
typedef DWORD (WINAPI *PFN_SetGPRSConnStatus)(INT onOff,
                                              WCHAR *entryName,
                                              WCHAR *phoneNumber,
                                              WCHAR *userName, 
                                              WCHAR *password, 
                                              WCHAR *apName,
                                              WCHAR *callbackNumber,
                                              WCHAR *domain);
typedef DWORD (WINAPI *PFN_GetGPRSConnStatus)(INT *status);
typedef DWORD (WINAPI *PFN_ChangePINCode)(PINNUM *oldPinCode, PINNUM *newPinCode);
typedef DWORD (WINAPI *PFN_SetPINCodeLock)(PINNUM *pinCode, BYTE onOff);
typedef DWORD (WINAPI *PFN_GetGPRSIMEI)(GSMIMEI *gsmIMEI);
typedef DWORD (WINAPI *PFN_SetGSMService)(BYTE OnOff);
typedef DWORD (WINAPI *PFN_GetGSMService)(PBYTE OnOff);
typedef DWORD (WINAPI *PFN_GetGSMSignalStrength)(PDWORD dwStrength);
typedef DWORD (WINAPI *PFN_SetGPRSConfig)(    WCHAR *phoneNumber, 
                                              WCHAR *userName, 
                                              WCHAR *password, 
                                              WCHAR *apName); 

//Camera
typedef DWORD (WINAPI * PFN_EnableCamera) (HWND wnd, BOOL onOff);
typedef DWORD (WINAPI * PFN_EnablePreviewWindow)(BOOL onOff);
typedef VOID  (WINAPI * PFN_SetPreviewLocation)(int posX, int posY);
typedef DWORD (WINAPI * PFN_GetPreviewLocation)(int *posX, int *posY);
typedef DWORD (WINAPI * PFN_StartStillCapture)(INT playSound,DWORD addTimeStamp);   
typedef DWORD (WINAPI * PFN_SetStillCaptureState)(PICSTATE *picInfo);
typedef DWORD (WINAPI * PFN_GetStillCaptureState)(PICSTATE *picInfo);
typedef DWORD (WINAPI * PFN_SetCameraExposureValue)(DWORD level);
typedef DWORD (WINAPI * PFN_GetCameraExposureValue)(DWORD *level);
typedef DWORD (WINAPI * PFN_SetFlashLight)(FLASH *flash);
typedef DWORD (WINAPI * PFN_GetFlashLight)(FLASH *flash);
typedef DWORD (WINAPI * PFN_SetFeature)(DWORD level);
typedef DWORD (WINAPI * PFN_GetFeature)(DWORD *level);
typedef DWORD (WINAPI * PFN_SetCameraResolution)(DWORD resValue);
typedef DWORD (WINAPI * PFN_GetCameraResolution)(DWORD *resValue);
typedef DWORD (WINAPI * PFN_TerminateGraph)();
typedef DWORD (WINAPI * PFN_StartGraph)();
typedef DWORD (WINAPI * PFN_HaltGraph)();

//Summit
typedef SDCERR (WINAPI * PFN_GetCurrentConfig)(DWORD *num, CHAR *name);
typedef SDCERR (WINAPI * PFN_ModifyConfig)(CHAR *name, SDCConfig *config);
typedef SDCERR (WINAPI * PFN_GetConfig)(CHAR *name, SDCConfig *config);
typedef SDCERR (WINAPI * PFN_DeleteConfig)(CHAR *name);
typedef SDCERR (WINAPI * PFN_GetNumConfigs)(DWORD *num);
typedef SDCERR (WINAPI * PFN_ActivateConfig)(CHAR *name);
typedef SDCERR (WINAPI * PFN_AddConfig)(SDCConfig *config);
typedef SDCERR (WINAPI * PFN_GetAllConfigs)(SDCConfig *config, DWORD *num);
typedef SDCERR (WINAPI * PFN_SetAllConfigs)(DWORD num, SDCConfig *config);
typedef SDCERR (WINAPI * PFN_GetGlobalSettings)(SDCGlobalConfig *configGlobal);
typedef SDCERR (WINAPI * PFN_SetGlobalSettings)(SDCGlobalConfig *configGlobal);
typedef SDCERR (WINAPI * PFN_Get3rdPartyConfig)(SDC3rdPartyConfig *config3rd);
typedef SDCERR (WINAPI * PFN_Set3rdPartyConfig)(SDC3rdPartyConfig *config3rd);
typedef SDCERR (WINAPI * PFN_GetCurrentStatus)(CF10G_STATUS *status);
typedef SDCERR (WINAPI * PFN_RadioDisable)();
typedef SDCERR (WINAPI * PFN_RadioEnable)();
typedef REG_DOMAIN (WINAPI * PFN_GetCurrentDomain)();
typedef SDCERR (WINAPI * PFN_GetSDKVersion)(DWORD *version);
typedef SDCERR (WINAPI * PFN_FlushConfigKeys)(INT configNumber);
typedef SDCERR (WINAPI * PFN_FlushAllConfigKeys)();
typedef SDCERR (WINAPI * PFN_GetConfigFileInfo)(CHAR *fileName, CONFIG_FILE_INFO *info);
typedef SDCERR (WINAPI * PFN_ExportSettings)(CHAR *fileName, SDC_ALL *configAll);
typedef SDCERR (WINAPI * PFN_ImportSettings)(CHAR *fileName, SDC_ALL *configAll);
typedef SDCERR (WINAPI * PFN_SetWEPKey)(SDCConfig *config, INT keyIndex,  WEPLEN keyLength, UCHAR *wepKey, BOOLEAN keyState);
typedef SDCERR (WINAPI * PFN_GetWEPKey)(SDCConfig *config, INT keyIndex,  WEPLEN *keyLength, UCHAR *wepKey, BOOLEAN *keyState);
typedef SDCERR (WINAPI * PFN_SetMultipleWEPKeys)(SDCConfig *config,  INT keyIndex,  WEPLEN keyLength1, UCHAR *wepKey1,
                                                        WEPLEN keyLength2, UCHAR *wepKey2,
                                                        WEPLEN keyLength3, UCHAR *wepKey3,
                                                        WEPLEN keyLength4, UCHAR *wepKey4);
typedef SDCERR (WINAPI * PFN_GetMultipleWEPKeys)(SDCConfig *config,  INT *keyIndex, WEPLEN *keyLength1, UCHAR *wepKey1,
                                                        WEPLEN *keyLength2, UCHAR *wepKey2,
                                                        WEPLEN *keyLength3, UCHAR *wepKey3,
                                                        WEPLEN *keyLength4, UCHAR *wepKey4);
typedef SDCERR (WINAPI * PFN_SetPSK)(SDCConfig *config,  CHAR *psk);
typedef SDCERR (WINAPI * PFN_GetPSK)(SDCConfig *config,  CHAR *psk);
typedef SDCERR (WINAPI * PFN_SetLEAPCred)(SDCConfig *config,  CHAR *username, CHAR *password);
typedef SDCERR (WINAPI * PFN_GetLEAPCred)(SDCConfig *config,  CHAR *username, CHAR *password);
typedef SDCERR (WINAPI * PFN_SetEAPFASTCred)(SDCConfig *config,  CHAR *username, CHAR *password, CHAR *pacFileName, CHAR *pacPassword);
typedef SDCERR (WINAPI * PFN_GetEAPFASTCred)(SDCConfig *config,  CHAR *username, CHAR *password, CHAR *pacFileName, CHAR *pacPassword);
typedef SDCERR (WINAPI * PFN_SetPEAPGTCCred)(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION certLocation, CHAR *caCert );
typedef SDCERR (WINAPI * PFN_GetPEAPGTCCred)(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION *certLocation, CHAR *caCert );
typedef SDCERR (WINAPI * PFN_SetPEAPMSCHAPCred)(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION certLocation, CHAR *caCert );
typedef SDCERR (WINAPI * PFN_GetPEAPMSCHAPCred)(SDCConfig *config,  CHAR *username, CHAR *password, CERTLOCATION *certLocation, CHAR *caCert );
typedef SDCERR (WINAPI * PFN_SetEAPTLSCred)(SDCConfig *config,  CHAR *username, CHAR *userCert, CERTLOCATION certLocation, CHAR *caCert);
typedef SDCERR (WINAPI * PFN_GetEAPTLSCred)(SDCConfig *config,  CHAR *username, CHAR *userCert, CERTLOCATION *certLocation, CHAR *caCert);
typedef DWORD  (WINAPI * PFN_GetWiFiBSSIDList)(BYTE *buffer);
typedef DWORD  (WINAPI * PFN_ScanWiFiBSSID)(void);

#ifdef __cplusplus
}
#endif

#endif // __LIBDLLH__
