rilhand.cpp

手机RILGSM实现的源代码

    }
    return TRUE;    
}
//
//
BOOL  AnotherCardNeedPIN(void)
{
   
    BOOL bRet = FALSE;
    //get the reg state
    DWORD dwPINState = 0;
    if( !GetRegistryDWORD(HKEY_LOCAL_MACHINE, TEXT("System\\CardInfo\\Card1"), TEXT("CardPin"), &dwPINState))
    {
        RETAILMSG(1, (TEXT("[TI]AnotherCardNeedPIN get cardpin failed\r\n")));
        goto Error;
    }
    else
    {
        RETAILMSG(1, (TEXT("[TI]AnotherCardNeedPIN get cardpin succeeded and value  is %d\r\n"),dwPINState));
        if(CARD_PIN == dwPINState)
        {
            bRet = TRUE;
        }
        else
        {
            bRet = FALSE;
        }
    }
Error:
    return bRet;    
}
//
BOOL  ChangePrimaryCard(DWORD dwCardNum)
{
   
    RETAILMSG(1, (TEXT("cuiguoqing ChangePrimaryCard() entered!!!!!\r\n")));
    RETAILMSG(1, (TEXT("cuiguoqing the dwCardNum value is [%d]\r\n"),dwCardNum));
    BOOL bRet = FALSE;
    if((CARD1 != dwCardNum) && (CARD2 != dwCardNum))
    {
        RETAILMSG(1, (TEXT("cuiguoqing goto error!!!!!\r\n")));
        goto Error;
    }
    else
    {
        if( !SetRegistryDWORD(HKEY_LOCAL_MACHINE, TEXT("System\\CardInfo\\CardCom"), TEXT("CardPrimary"), dwCardNum))
        {
            RETAILMSG(1, (TEXT("[TI]ChangePrimaryCard failed\r\n")));
            goto Error;
        }
        else
        {
            RETAILMSG(1, (TEXT("[TI]ChangePrimaryCard succeeded and cardNum  is %d\r\n"),dwCardNum));
            bRet = TRUE;
        }
    }
Error:
    return bRet;    
}
//Change the Reg state for exporting PB and SMS
//
BOOL ChangePBSMSRegState(DWORD dwAddingState, BOOL bClean)
{
    DWORD dwState = 0;

    if (bClean)
    {
        dwState = dwAddingState;
    }
    else
    {
        //get the primary reg state
        if( !GetRegistryDWORD(HKEY_LOCAL_MACHINE, TEXT("Services\\ContactsAndSMS"), TEXT("Sign"), &dwState))
        {
            RETAILMSG(1,(TEXT("[TI]GetRegistry-get ContactsAndSMS  from reg fail \r\n")));
            return FALSE;
        }
        else
        {
            RETAILMSG(1,(TEXT("[TI]pre ContactsAndSMS-=%d ;Adding state = %d;\r\n"), dwState,dwAddingState));
            //caculate the new state
            dwState |= dwAddingState;     
        }
    }
    //write the reg state
    if( !SetRegistryDWORD(HKEY_LOCAL_MACHINE, TEXT("Services\\ContactsAndSMS"), TEXT("Sign"), dwState))
    {
        RETAILMSG(1, (TEXT("[TI]SetRegistry-set ContactsAndSMS failed\r\n")));
        return FALSE;
    }
    else
    {
        RETAILMSG(1, (TEXT("[TI]SetRegistry-set new state is %d\r\n"),dwState));
    }
    return TRUE;    
}



#ifndef SCI_OLD
extern BOOL g_bSciNoMenuVersion;
static BOOL g_SimStateCache = FALSE;
static BOOL bCacheSet = FALSE;
static BOOL bSendSimState = TRUE;

BOOL GetSimCacheState(void)
{
    RETAILMSG(1, (TEXT("[TI]GetSimCacheState=%d\r\n"),g_SimStateCache));
    return g_SimStateCache;
}

void SetSimCacheState(BOOL bCache)
{
    RETAILMSG(1, (TEXT("[TI]SetSimCacheState=%d\r\n"),g_SimStateCache));
    g_SimStateCache = bCache;
}
#endif

//
// RIL handle dtor
//
CRilHandle::~CRilHandle()
{
    // // FUNCTION_TRACE(CRilHandle::~CRilHandle);

    UINT i;

    {
        SYNCBLOCK(m_cs);

        HANDLE rghThreads[2] = { m_hCmdThread, m_hReadThread};

        // Signal the cancel event to kill the thread
        if (m_hCancelEvent)
        {
            (void)SetEvent(m_hCancelEvent);
        }

        // Reset the COM port
        if (m_pComDevice)
        {
            (void)DeinitComPort(m_pComDevice);
        }

        StopReadyStateQuery();

        // Wait for auxiliary threads to terminate
        (void)WaitForSingleObject(m_hCmdThread, 10000);
        (void)WaitForSingleObject(m_hReadThread, 10000);
        
        // Kill NDIS Thread
        CRilNdis.NdisStop();
        
        // Get rid of the threads
        if (m_hCmdThread)
        {
            (void)CloseHandle(m_hCmdThread);
            m_hCmdThread = NULL;
            m_dwCmdThreadID = 0;
        }

        if (m_hReadThread)
        {
            (void)CloseHandle(m_hReadThread);
            m_hReadThread = NULL;
            m_dwReadThreadID = 0;
        }

        // Get rid of the event
        if (m_hCancelEvent)
        {
            (void)CloseHandle(m_hCancelEvent);
            m_hCancelEvent = NULL;
        }

        // Get rid of the checkpoint
        delete m_pCheckPoint;
        m_pCheckPoint = NULL;

#ifndef RIL_RADIO_RESILIENCE
        // Get rid of the monitor
        delete m_pMonitor;
        m_pMonitor = NULL;
#endif // RIL_RADIO_RESILIENCE

        // Get rid of the queues
        delete g_pCmdQ;
        delete g_pRspQ;
        delete g_pSimLockedQueue;
        g_pCmdQ = NULL;
        g_pRspQ = NULL;
        g_pSimLockedQueue = NULL;

        // Close the serial port
        if (m_pComDevice)
        {
            COM_CloseInternal(m_pComDevice);
            m_pComDevice = NULL;
        }

        // All of the instance handles should be closed
        // before the driver handle is destroyed.
        m_pInstances->Enum(DeleteInstanceHandle, 0);

        // Delete the instance handle list
        delete m_pInstances;
        m_pInstances = NULL;

        // Delete the Read Bytes buffer
        delete m_pReadBytes;
        m_pReadBytes = NULL;

#ifdef OEM2_DRIVER
        // Delete the Read Bytes buffer
        delete m_pReadBytes2;
        m_pReadBytes2 = NULL;
#endif

        // Get rid of init event
        if (m_hInitEvent)
        {
            (void)CloseHandle(m_hInitEvent);
            m_hInitEvent = NULL;
        }

        // Get rid of data event
        if (m_hDataEvent)
        {
            (void)CloseHandle(m_hDataEvent);
            m_hDataEvent = NULL;
        }

        // Delete the API information structures
        for (i = 0; i < APIID_TOTAL; i++)
        {
            delete m_rgpAPIInfo[i];
            m_rgpAPIInfo[i] = NULL;
        }

        DeleteCriticalSection(&m_csInstances);
        DeleteCriticalSection(&m_csCmdID);
        DeleteCriticalSection(&m_csEmergency);
        m_fInited = FALSE;
        m_fFailedInit=FALSE;
        m_fInitedForSMS = FALSE;
        m_fInitedForSIMPB = FALSE;
        m_dwSIMPBLastSize = (DWORD)-1;
    }

    DeleteCriticalSection(&m_cs);
}

//
// Broadcasts a change in the radio ready state
//
void CRilHandle::SendReadyStateNotification(DWORD dwReadyState)
{
    RILEQUIPMENTSTATE res;
    CNotificationData *pnd = NULL;

#if defined(OEM1_DRIVER) || defined(OEM2_DRIVER) 
    if ((dwReadyState & RIL_READYSTATE_UNLOCKED) && !(g_dwReadyState & RIL_READYSTATE_UNLOCKED))
    {
        // certain commands like COPS need to wait for the module to
        // "settle" after it's been unlocked.
        g_dwUnlocked = GetTickCount();
    }
#endif

    // Set this in our global
    if (dwReadyState)
    {
        g_dwReadyState |= dwReadyState;
    }
    else
    {
        g_dwReadyState = 0;
    }

#ifndef SCI_OLD
    if( g_bSciNoMenuVersion )
    {
        if( TRUE == GetSimCacheState() )
        {
            RETAILMSG(1, (TEXT("[TI] RILDrv :[SCI_NEW] noneed to bc ,should cache\r\n")));
            return;
        }
        if( !bCacheSet )
        {
            if (g_Initialized && (dwReadyState == RIL_READYSTATE_INITIALIZED))
            {
                SetSimCacheState(TRUE);
                bCacheSet = TRUE;
            }
        }
    }
#endif
    //Dual-card:If the card is not the primary card ,we should not broadcast any info
    if (!IsPrimaryCard())
     {
        RETAILMSG(1, (TEXT("[TI] RILDrv : SendReadyStateNotification---not the primary card return\r\n")));
        return;
     }

    // Broadcast the notification
    memset(&res, 0x00, sizeof(RILEQUIPMENTSTATE));
    res.cbSize = sizeof(RILEQUIPMENTSTATE);
    res.dwParams = RIL_PARAM_EQUIPMENTSTATE_READYSTATE;
    res.dwReadyState = g_dwReadyState;
    pnd = new CNotificationData;
    if (pnd && pnd->InitFromRealBlob(RIL_NOTIFY_RADIOEQUIPMENTSTATECHANGED, (void *) &res, res.cbSize))
    {
        // Note that BroadcastNotification frees pnd
        BroadcastNotification(pnd);
        pnd = NULL;
    }

    delete pnd;
/* Below was added for TTPCOM to insure that the status indicators were correct 
   following boot up
*/
#if defined(OEM2_DRIVER) 

    pnd = new CNotificationData;
    if (pnd && pnd->InitFromRealBlob(RIL_NOTIFY_REGSTATUSCHANGED, (void *) &g_dwRegStatus, sizeof(g_dwRegStatus)))
    {
        // Note that BroadcastNotification frees pnd
        BroadcastNotification(pnd);
        pnd = NULL;
    }

    delete pnd;
#endif

}

//
// Thread responsible for sending commands from the Command Queue to COM port
//
DWORD WINAPI SimReadyThreadProc(LPVOID lpParameter)
{
    FUNCTION_TRACE(SimReadyThreadProc);
    DEBUGCHK(lpParameter != NULL);
    CRilHandle* pRilDevice = (CRilHandle*)lpParameter;
    DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : SimReadyThreadProc : Entering, pRilDevice=0x%x\r\n"),pRilDevice));
    const DWORD dwReturn = pRilDevice->SimReadyThread();
    DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : SimReadyThreadProc : THREAD IS EXITING, dwReturn=0x%x\r\n"),dwReturn));
    return dwReturn;
}

//
// Loop until RIL is ready to process SIM commands
//
DWORD CRilHandle::SimReadyThread()
{
    CCommand *pCmd = NULL;
    APIINFO apiiInfo;
    const APIID apiid = APIID_GETPHONELOCKEDSTATE;

    // Create an event
    m_fSimReady = FALSE;
    m_hSimReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (!m_hSimReadyEvent)
    {
        goto Error;
    }

    // Get the info about this API
    memset(&apiiInfo,0,sizeof(apiiInfo));
    GetAPIInfo(apiid, apiiInfo);

    if(0 != strlen(g_szCard2Pin))
    {
        RETAILMSG(1, (TEXT("[TI] CARDPIN=[%a]\r\n"),g_szCard2Pin));
        CHAR szCmd[MAX_PATH];
        memset(szCmd, 0x00, MAX_PATH);
        (void)_snprintfz(szCmd, MAX_PATH, "AT+CPIN=\"%s\"\r", g_szCard2Pin);
        QueueCmdIgnoreRsp(APIID_NONE, szCmd, CMDOPT_IGNORERADIOOFF, g_TimeoutCmdInit, NULL, NULL, 0, 0, 0);
        Sleep(500);
    }
    else
    {
        RETAILMSG(1, (TEXT("[TI] g_szCardPin == NULL!!\r\n")));
    }
    // Query for the PIN until we don't get back 515 as an error
    do
    {
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : SimReadyThread : Sending SIM Query Command...\r\n")));

        // Set up a CPIN command to be sent
        // Note that we don't care what the return value is, so long as it's not that the radio isn't ready
        pCmd = new CCommand;
#ifdef WAVECOM_DRIVER
        if (!pCmd || !pCmd->Init(NULL, "AT+CPIN?\r", NULL, CMDOPT_SIMQUERY, apiiInfo.dwExecTime, apiiInfo.dwTimeout, NULL, NULL, 0, 0, 0, apiid, NULL, NULL))
 #else
        if (!pCmd || !pCmd->Init(NULL, "AT+CPIN?\r", NULL, CMDOPT_SIMQUERY, apiiInfo.dwExecTime, apiiInfo.dwTimeout, NULL, ParseGetPhoneLockedState, 0, 0, 0, apiid, NULL, NULL))