rilhand.h

windows mobile RIL软件

    APIID_GETGPRSATTACHED,                  // 110
    APIID_SETGPRSCONTEXTACTIVATED,          // 111
    APIID_GETGPRSCONTEXTACTIVATEDLIST,      // 112
    APIID_ENTERGPRSDATAMODE,                // 113
    APIID_GETGPRSADDRESS,                   // 114
    APIID_GPRSANSWER,                       // 115
    APIID_GETGPRSREGISTRATIONSTATUS,        // 116
    APIID_GETGPRSCLASS,                     // 117
    APIID_SETGPRSCLASS,                     // 118
    APIID_GETMOSMSSERVICE,                  // 119
    APIID_SETMOSMSSERVICE,                  // 120
    APIID_GETCBMSGCONFIG,                   // 121
    APIID_SETCBMSGCONFIG,                   // 122
    APIID_GETCURRENTADDRESSID,              // 123
    APIID_SETCURRENTADDRESSID,              // 124
    APIID_GETPACKETBYTECOUNT,               // 125
    APIID_RESETPACKETBYTECOUNT,             // 126
    APIID_GETCURRENTPRIVACYSTATUS,          // 127
    APIID_GETCURRENTSYSTEMTYPE,             // 128
    APIID_GETALLOPERATORSLIST,              // 129
    APIID_REBOOTRADIO,                      // 130
    APIID_REGISTERATCOMMANDLOGGING,         // 131
    APIID_ATCOMMANDLOGFILE,                 // 132
    APIID_GETATR,                           // 133
    APIID_SENDSIMTOOLKITEVENTDOWNLOAD,      // 134
    APIID_LOGEVENTTORADIO,                  // 135
    APIID_GETVTSERIALPORTHANDLE,            // 136
    APIID_SETAUDIOCHANNEL,			//137	;added by yanghai 
    APIID_TOTAL                             // 137
};


// API information structure
struct APIINFO {
    DWORD dwExecTime;
    DWORD dwTimeout;
};


// Structure used for specifying init strings
struct INITSTRING_DATA {
    LPCSTR szCmd;
    DWORD dwCmdOption;
};


//
//
//
class CRilHandle
{
public:
            CRilHandle();
            ~CRilHandle();

    BOOL            StartInit();
    void            FinishInit(CCommand* pInitCmd, BOOL bSucceeded);
    void            GeneralInitDone(BOOL bSucceeded);

    void            PrepareForReinit();
    BOOL            LaunchThreads();
    BOOL            FCancelSet() const;
    BOOL            WaitForInit(DWORD dwTimeout) const;
    BOOL            WaitForCommandOrCancel() const;
    BOOL            AddToList(CRilInstanceHandle* const pInstance);
    BOOL            RemoveFromList(CRilInstanceHandle* const pInstance);
    HRESULT         GetNextCmdID();
    void            SendReadyStateNotification(DWORD dwReadyState);
    void            BroadcastNotification(CNotificationData*& rpnd);
    BOOL            BroadcastRealBlobNotification(const DWORD dwNotificationCode, const void* const pBlob,
                                                  const UINT cbBlob);
    BOOL            BroadcastDWORDBlobNotification(const DWORD dwNotificationCode, const DWORD dwBlob);
    BOOL            BroadcastATLogBlobNotification(const void* const pBlob, UINT uBlob);
    BOOL            HandleRsp(CCommand*& rpCmd, CResponse*& rpRsp, BOOL& rfHungUp, BOOL& rfRadioOff);
    BOOL            AppendReadBytes(LPCSTR szBytes, UINT cbBytes, bool fUseBuffer2);
    BOOL            InheritReadBytes(CResponse* const pRsp, bool fUseBuffer2);
    BOOL            GiveUpReadBytes(LPSTR& rszBytes, UINT& rcbBytes, bool fUseBuffer2);
#ifndef RIL_RADIO_RESILIENCE
    BOOL            RegisterWithCPM();
#endif // ! RIL_RADIO_RESILIENCE
    CSimToolkitHandling* GetSimToolkit(void) { return m_pSimToolkitHandling; };//added by vikingwang   
    void            GetAPIInfo(APIID apiid, APIINFO& rapii);
    CCheckPoint*    GetCheckPoint() const               { return m_pCheckPoint; };
    CComHandle*     GetComDevice() const                { return m_pComDevice; };
    DWORD           GetDataModeCmdDelay() const         { return m_dwDataModeCmdDelay; };
    DWORD           GetMaxDataModeTimeWithoutCmd() const { return m_dwMaxDataModeTimeWithoutCmd; };
    void            StartWaitingForRsp(CCommand *pCmd)
    {
        m_fWaitingForRsp = TRUE;
        m_pCurrCommand = pCmd;
    }
    void            SetLastCommandTimedOut() { if (m_pReadBytes && m_pReadBytes->GetLength() > 0) m_fLastCommandTimedOut = TRUE; }

    void            SetDataEvent()                      { SetEvent(m_hDataEvent); }
    void            StopWaitingForRsp()                 { m_fWaitingForRsp = FALSE; };
    BOOL            FWaitingForRsp() const              { return !!m_fWaitingForRsp; };
    BOOL            SetEmergencyMode(const BOOL fMode);
    BOOL            FInEmergencyMode()                  { SYNCBLOCK(m_csEmergency); return !!m_fEmergencyMode; };
    DWORD           ResponseThread();
    DWORD           CommandThread();
    DWORD           SimReadyThread();
    void            StartReadyStateQuery();
    void            StopReadyStateQuery();
    BOOL            HandleRxData(char *szData, DWORD dwRead, bool fDataOnSecondComPort);
    void            SetAtLogOwner(CRilInstanceHandle* pRilInstanceHandle) { m_hATCommandLogOwner = pRilInstanceHandle; };
    void            LogATCommand(  LPCSTR szChars, UINT cbToWrite, BOOL fResponse);
    CRilNDIS        CRilNdis; 
private:
    
    HANDLE                          m_hInitEvent;
    HANDLE                          m_hCancelEvent;
    HANDLE                          m_hDataEvent;
    HANDLE                          m_hSimReadyEvent;
    HANDLE                          m_hInitedForSMSEvent;
    HANDLE                          m_hInitedForSIMPBEvent;
    HANDLE                          m_hCmdThread;
    HANDLE                          m_hReadThread;
    BOOL                            m_fQuitReadyStateThread;
    DWORD                           m_dwCmdThreadID;
    DWORD                           m_dwReadThreadID;
    CCheckPoint*                    m_pCheckPoint;
#ifndef RIL_RADIO_RESILIENCE
    CMonitor*                       m_pMonitor;
#endif // ! RIL_RADIO_RESILIENCE
    CDblList<CRilInstanceHandle>*   m_pInstances;
    HRESULT                         m_hrNextCmdID;
    CRITICAL_SECTION                m_cs;
    CRITICAL_SECTION                m_csInstances;
    CRITICAL_SECTION                m_csCmdID;
    CRITICAL_SECTION                m_csEmergency;
    CComHandle*                     m_pComDevice;
    CBuffer*                        m_pReadBytes;
#ifdef OEM2_DRIVER
    CBuffer*                        m_pReadBytes2;
#endif
    DWORD                           m_dwDataModeCmdDelay;
    DWORD                           m_dwMaxDataModeTimeWithoutCmd;
    APIINFO*                        m_rgpAPIInfo[APIID_TOTAL];
    DWORD                           m_fInited : 1;
    DWORD                           m_fFailedInit : 1;
    DWORD                           m_fInitedForSMS : 1;
    DWORD                           m_fInitedForSIMPB : 1;
    DWORD                           m_fWaitingForRsp : 1;
    DWORD                           m_fEmergencyMode : 1;
    DWORD                           m_fSimReady : 1;
    DWORD                           m_fLastCommandTimedOut : 1;
    DWORD                           m_dwSIMPBLastSize;
    CCommand*                       m_pCurrCommand;
    HANDLE                          m_hATCommandLogOwner;
	CSimToolkitHandling*            m_pSimToolkitHandling;	//added by viking wang
};


typedef CUnboundedQueue<RILDRVNOTIFICATION> CRilNotificationQueue;

class CRilInstanceHandle : public CListElem
{
public:
                        CRilInstanceHandle();
                        ~CRilInstanceHandle();

    BOOL                Init(CRilHandle* const pDevice);
    void                Notify(const DWORD dwCode, const HRESULT hrCmdID, const void* const pBlob, const UINT cbBlob);
    BOOL                GetNextNotification(RILDRVNOTIFICATION& rrdnNotifyData);
    BOOL                CreateNotificationQueue(LPCTSTR tszEventName, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut);
    BOOL                FReadyForNotifications() const  { return !!m_fInited && m_notificationQ.Ready(); };
    CRilHandle*         GetDevice() const               { DEBUGCHK(FALSE != !!m_fInited); return m_pDevice; };
    CDblList<CCommand>* GetCmdList() const              { DEBUGCHK(FALSE != !!m_fInited); return m_pCmdList; };
    BOOL                MakePreferred();
    BOOL                FPreferred() const              { return !!m_fPreferred; };
    void                CancelNotifications() const     { if (m_hNotifyCancelEvent) {SetEvent(m_hNotifyCancelEvent);} }
    CRilInstanceNDIS    CRilInstanceNdis;
    CRilHandle*         GetCrilHandle (void)            { return m_pDevice; }

private:
    CRilHandle*                     m_pDevice;
    CDblList<CCommand>*             m_pCmdList;
    HANDLE                          m_hNotifyCancelEvent;
    CRilNotificationQueue           m_notificationQ;
    DWORD                           m_fInited : 1;
    DWORD                           m_fPreferred : 1;
};


// Functions
BOOL SendComInitString(UINT iString);
BOOL DeinitComPort(const CComHandle* const pComDevice);


// Externs
extern const LPCTSTR g_tszRegKeyRIL;
extern const LPCTSTR g_tszRegKeyAPIInfo;
extern const LPCTSTR g_tszRegKeyOperNames;
extern const LPCTSTR g_tszRegKeyRemoteCalltype;

extern DWORD g_TimeoutCmdInit;
extern DWORD g_TimeoutCmdNoOp;
extern DWORD g_TimeoutCmdOnline;
extern DWORD g_TimeoutAPIDefault;
extern DWORD g_TimeoutDTRDrop;
extern DWORD g_TimeoutWaitForInit;