connection.cpp

ril source code for Windows CE

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:

connection.cpp

Abstract:


Notes:


--*/
#include "precomp.h"
#include <connection.h>



extern HRESULT ParseGetCallList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob);
extern HRESULT ConvertCallStat2CPIStat(RILCALLINFO *prgfCallStates, DWORD dwNumCallsInCallList);
extern BOOL GetRegistryPacketSupport( void );
extern HRESULT ParseGetGPRSContextActivatedList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob);

class ATCMDCLCC : public ATCmd
{
public:
    ATCMDCLCC( )
    {
        m_prci = NULL;
        m_dwNumCallsInList = 0;
    }
    virtual ~ATCMDCLCC()
    {
        if ( m_prci )
        {
            delete [] m_prci;
        }
    }
    HRESULT Read()
    {
        char szCmd[128]; 

        (void)strncpyz(szCmd, "AT+CLCC\r", 128);  

        DWORD dwCommandOption = CMDOPT_IGNORERADIOOFF;
          
        HRESULT hr = Execute( szCmd, dwCommandOption);

        return hr;
    }

    DWORD GetCallListSize ( void ) const
    {
        return m_dwNumCallsInList;
    }

    DWORD GetCallList(RILCALLINFO *prci, DWORD dwNumCallsInList) const
    {
        DWORD dwReturnCallsInList = 0;

        if ( prci && m_dwNumCallsInList && (dwNumCallsInList >= m_dwNumCallsInList) && m_prci )
        {
            CeSafeCopyMemory((LPVOID) prci, (LPCVOID) m_prci, m_dwNumCallsInList * sizeof(RILCALLINFO));
            dwReturnCallsInList = m_dwNumCallsInList;
        }

        return dwReturnCallsInList;
    }
protected:
    virtual HRESULT Parse( LPCSTR szRsp )
    {
        void *pBlob = NULL;
        UINT cbBlob = 0;

        HRESULT hr = ParseGetCallList( szRsp, pBlob, cbBlob );
        if ( SUCCEEDED( hr ) && pBlob != NULL && cbBlob >= sizeof(RILCALLINFO) )
        {
            if ( (cbBlob <= (m_dwNumCallsInList * sizeof(RILCALLINFO)))  && m_prci)
            {
                m_dwNumCallsInList = cbBlob/sizeof(RILCALLINFO);
                CeSafeCopyMemory((LPVOID) m_prci, (LPCVOID) pBlob, cbBlob);
            }
            else
            {
                if ( m_prci )
                {
                    delete [] m_prci;
                    m_dwNumCallsInList = 0;
                }
                m_prci = new RILCALLINFO[cbBlob/sizeof(RILCALLINFO)];
                if ( m_prci )
                {
                    m_dwNumCallsInList = cbBlob/sizeof(RILCALLINFO);
                    CeSafeCopyMemory((LPVOID) m_prci, (LPCVOID) pBlob, cbBlob);
                }
            }
        }

        if ( pBlob != NULL )
        {
            FreeBlob( pBlob );
            pBlob = NULL;
        }

        return hr;
    }
private:
    RILCALLINFO *m_prci;
    DWORD         m_dwNumCallsInList;
};

class ATCMDCGACT : public ATCmd
{
public:
    ATCMDCGACT( )
    {
        m_pgContextList = NULL;
        m_dwNumContextsInList = 0;
    }
    virtual ~ATCMDCGACT()
    {
        if ( m_pgContextList )
        {
            delete [] m_pgContextList;
        }
    }
    HRESULT Read()
    {
        char szCmd[128]; 

        (void)strncpyz(szCmd,  "AT+CGACT?\r", 128);  

        DWORD dwCommandOption = CMDOPT_IGNORERADIOOFF;
          
        HRESULT hr = Execute( szCmd, dwCommandOption);

        return hr;
    }

    DWORD GetActiveContextListSize ( void ) const
    {
        return m_dwNumContextsInList;
    }

    DWORD GetActiveContextList (RILGPRSCONTEXTACTIVATED *pgrgca, DWORD dwNumContextsInList) const
    {
        DWORD dwReturnContextsInList = 0;

        if ( pgrgca &&  m_dwNumContextsInList && (dwNumContextsInList >= m_dwNumContextsInList) && m_pgContextList )
        {
            CeSafeCopyMemory((LPVOID) pgrgca, (LPCVOID) m_pgContextList, m_dwNumContextsInList * sizeof(RILGPRSCONTEXTACTIVATED));
            dwReturnContextsInList = m_dwNumContextsInList;
        }

        return dwReturnContextsInList;
    }
protected:
    virtual HRESULT Parse( LPCSTR szRsp )
    {
        void *pBlob = NULL;
        UINT cbBlob = 0;

        HRESULT hr = ParseGetGPRSContextActivatedList( szRsp, pBlob, cbBlob );
        if ( SUCCEEDED( hr ) && pBlob != NULL && cbBlob >= sizeof(RILGPRSCONTEXTACTIVATED) )
        {
            if ( (cbBlob <= (m_dwNumContextsInList * sizeof(RILGPRSCONTEXTACTIVATED)))  && m_pgContextList)
            {
                m_dwNumContextsInList = cbBlob/sizeof(RILGPRSCONTEXTACTIVATED);
                CeSafeCopyMemory((LPVOID) m_pgContextList, (LPCVOID) pBlob, cbBlob);
            }
            else
            {
                if ( m_pgContextList )
                {
                    delete [] m_pgContextList;
                    m_dwNumContextsInList = 0;
                }
                m_pgContextList = new RILGPRSCONTEXTACTIVATED[cbBlob/sizeof(RILGPRSCONTEXTACTIVATED)];
                if ( m_pgContextList )
                {
                    m_dwNumContextsInList = cbBlob/sizeof(RILGPRSCONTEXTACTIVATED);
                    CeSafeCopyMemory((LPVOID) m_pgContextList, (LPCVOID) pBlob, cbBlob);
                }
            }
        }

        if ( pBlob != NULL )
        {
            FreeBlob( pBlob );
            pBlob = NULL;
        }

        return hr;
    }
private:
    RILGPRSCONTEXTACTIVATED *m_pgContextList;
    DWORD         m_dwNumContextsInList;
};

class ATCMDHANGUP : public ATCmd
{
public:
    ATCMDHANGUP( )
    {
    }
    virtual ~ATCMDHANGUP()
    {
    }
    HRESULT HangupActiveCall()
    {
        char szCmd[128]; 

        (void)strncpyz(szCmd, "ATH\r", 128);  

        DWORD dwCommandOption = CMDOPT_HANGUP | CMDOPT_IGNORERADIOOFF;
          
        HRESULT hr = Execute( szCmd, dwCommandOption);

        return hr;
    }

    HRESULT HangupDialingCall()
    {
        char szCmd[128]; 

        (void)strncpyz(szCmd, "AT\r", 128);  

        DWORD dwCommandOption = CMDOPT_HANGUP | CMDOPT_IGNORERADIOOFF;
          
        HRESULT hr = Execute( szCmd, dwCommandOption);

        return hr;
    }

    HRESULT ReleaseHeldCall()
    {
        char szCmd[MAX_PATH]; 

        HRESULT hr = E_NOTIMPL;

        SAFE_PDD_CREATECOMMAND( szCmd, MAX_PATH, hr, PDD_CreateCommand_ReleaseHeld( szCmd, MAX_PATH ) );
        
        if ( FAILED( hr ) )
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : PDD_CreateCommand_ReleaseHeld failed , hr = [0x%08x]\r\n"), hr));
            goto Error;
        }
            
       DWORD dwCommandOption = CMDOPT_HANGUP | CMDOPT_IGNORERADIOOFF;
          
       hr = Execute( szCmd, dwCommandOption);

Error:
       return hr;
    }

    HRESULT ReleaseCall( DWORD dwCallID)
    {
        char szCmd[MAX_PATH]; 

        HRESULT hr = E_NOTIMPL;

        SAFE_PDD_CREATECOMMAND( szCmd, MAX_PATH, hr, PDD_CreateCommand_ReleaseCall( szCmd, MAX_PATH, dwCallID ) );
         
        if ( FAILED( hr ) )
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : PDD_CreateCommand_ReleaseCall failed , hr = [0x%08x]\r\n"), hr));
            goto Error;
        } 
  
        DWORD dwCommandOption = CMDOPT_HANGUP | CMDOPT_IGNORERADIOOFF;
          
        hr = Execute( szCmd, dwCommandOption);

Error:
        return hr;
    }


protected:
    virtual HRESULT Parse( LPCSTR szRsp )
    {
        return S_OK;
    }
private:
};