provisionmanager.cpp

一个WinCE6。0下的IP phone的源代码

    ProvisionSetting_t* pSetting    = NULL; 
    WCHAR*              pValue      = NULL; 
    int                 ValueSize   = 0; 
    
    const WCHAR*            pAttributeName; 
    const WCHAR*            pAttributeValue; 
    int                     AttributeNameLength; 
    int                     AttributeValueLength; 
    ProvisionAttribute_e    AttributeType; 

    hr = pAttributes->getLocalName(
                        0, 
                        &pAttributeName, 
                        &AttributeNameLength
                        ); 
    if (FAILED(hr))
    {
        return hr; 
    }

    hr = GetAttributeType(
                pAttributeName, 
                AttributeNameLength, 
                &AttributeType
                ); 
    if (FAILED(hr))
    {
        return hr; 
    }

    if (AttributeType != AttributeName)
    {
        return E_UNEXPECTED; ///TODO: invalid parm
    }

    hr = pAttributes->getValue(
                        0, 
                        &pAttributeValue, 
                        &AttributeValueLength
                        ); 
    if (FAILED(hr))
    {
        return hr; 
    }

    if (FAILED(GetProvisionSetting(
                pAttributeValue, 
                AttributeValueLength, 
                &pSetting
                )))
    {
        return E_UNEXPECTED; 
    }

    if (m_Flags & VALIDATE_XML_ONLY)
    {
        return S_OK; 
    }

    hr = pSetting->Query(
                    m_ActiveSettingCategory
                    );    
    if (FAILED(hr))
    {
        return hr; 
    }

    if (!m_QuerySettingsStack.push_back(pSetting))
    {
        return E_OUTOFMEMORY; 
    }
    
    return hr; 

    
}

/*------------------------------------------------------------------------------
    ProvisionManager_t::HandleDelete
    
    Description
    
    Parameters:
        : 
    
    Returns (HRESULT): 
------------------------------------------------------------------------------*/
HRESULT
ProvisionManager_t::HandleDelete(
    ISAXAttributes* pAttributes
    )
{
    if (pAttributes == NULL)
    {
        return E_INVALIDARG; 
    }

    int AttributesCount; 

    HRESULT hr = pAttributes->getLength(&AttributesCount); 
    if (FAILED(hr))
    {
        return hr;        
    }

    //there must be 1 attribut (name) associated with 'delete'
    if (AttributesCount != 1)
    {
        return E_FAIL; 
    }

    ProvisionSetting_t*     pSetting = NULL; 
    const WCHAR*            pAttributeName; 
    const WCHAR*            pAttributeValue; 
    int                     AttributeNameLength; 
    int                     AttributeValueLength; 
    ProvisionAttribute_e    AttributeType; 

    hr = pAttributes->getLocalName(
                        0, 
                        &pAttributeName, 
                        &AttributeNameLength
                        ); 
    if (FAILED(hr))
    {
        return hr; 
    }

    hr = GetAttributeType(
                pAttributeName, 
                AttributeNameLength, 
                &AttributeType
                ); 
    if (FAILED(hr) || 
        AttributeType != AttributeName)
    {
        return E_UNEXPECTED;  ///TODO: Invalid param 
    }

    hr = pAttributes->getValue(
                        0, 
                        &pAttributeValue, 
                        &AttributeValueLength
                        ); 
    if (FAILED(hr))
    {
        return hr; 
    }

    hr = GetProvisionSetting(
                pAttributeValue, 
                AttributeValueLength, 
                &pSetting
                ); 
    if (FAILED(hr))
    {
        return hr;  
    }

    if (m_Flags & VALIDATE_XML_ONLY)
    {
        return S_OK; 
    }

    bool NotExist;     
    hr =  pSetting->CheckOldValueExists(
                        m_ActiveSettingCategory, 
                        &NotExist
                        );
    if (SUCCEEDED(hr) && !NotExist)
    {
        m_UpdatedFlags |= pSetting->GetSettingFlag(); 
    }

    return hr;
    
}



HRESULT
ProvisionManager_t::GetProvisionSetting(
    const WCHAR*            pName, 
    int                     NameLength, 
    ProvisionSetting_t**    ppSetting, 
    pfnValidator*           pValidator            
    )
{
    if (pName == NULL ||
        pName[0] == NULL ||
        NameLength <= 0 ||
        ppSetting == NULL)
    {
        return E_INVALIDARG; 
    }

    *ppSetting = NULL; 
    if (pValidator != NULL)
    {
        *pValidator = NULL; 
    }
        
    for (int Index = 0; Index < ARRAYSIZE(sc_ProvisionSettings); Index++)
    {
        if (sc_ProvisionSettings[Index].pSetting->MatchesName(
                                            pName, 
                                            NameLength
                                            ))
        {
            if (sc_ProvisionSettings[Index].pSetting->GetSettingFlag() & m_UpdatedFlags)
            {
                //if we already processed the same setting, return error
                return PROVISION_E_MULTIPLE_SETTINGS; 
            }
            
            *ppSetting = sc_ProvisionSettings[Index].pSetting; 
            if (pValidator != NULL)
            {
                *pValidator = sc_ProvisionSettings[Index].Validator; 
            }
            
            return S_OK; 
        }
    }

    return E_FAIL; 
}

HRESULT
ProvisionManager_t::DoPreparation(
    void
    )
{

    DWORD Result; 
    HRESULT hr = S_OK; 

    //create the mutex
    m_Mutex = CreateMutex(
                NULL, 
                false, 
                sc_MutexName
                ); 
    if (m_Mutex == NULL)
    {
        hr = E_FAIL; ///get hr from win32 error
        ///TODO: debug message
        return hr; 
    }

    //trying to grab the mutex first
    Result = WaitForSingleObject(
                m_Mutex, 
                sc_MutexTimeoutValue
                ); 
    switch (Result)
    {
        case WAIT_TIMEOUT: 
            ///TODO: debug
            return E_FAIL; 
                
        case WAIT_FAILED: 
            hr = E_FAIL; ///TODO: get hr from win32 error
            return hr; 
            
        case WAIT_OBJECT_0:
        case WAIT_ABANDONED: 
            break; 

        default: 
            ASSERT(FALSE); 
            return E_UNEXPECTED; 
    }

    
    DWORD   UpdatedSettingFlags; 

    hr = RegistryGetDWORD(
                    SN_VOIP_UPDATEDSETTINGS_ROOT, 
                    SN_VOIP_UPDATEDSETTINGS_PATH, 
                    SN_VOIP_UPDATEDSETTINGS_VALUE, 
                    &UpdatedSettingFlags
                    ); 
                    
    if (FAILED(hr))
    {
        UpdatedSettingFlags = 0; 
    }

    //get the active setting category and update setting category
    if (UpdatedSettingFlags & VOIP_UPDATEDSETTINGS_ACTIVEREG_BITMASK)
    {
        m_ActiveSettingCategory = SettingCategory1; 
        m_UpdateSettingCategory = SettingCategory0; 
    }
    else
    {
        m_ActiveSettingCategory = SettingCategory0; 
        m_UpdateSettingCategory = SettingCategory1; 
    }

    //clean up all the settings in update category
    for (int Index = 0; Index < ARRAYSIZE(sc_ProvisionSettings); Index ++)
    {
        hr = sc_ProvisionSettings[Index].pSetting->Delete(m_UpdateSettingCategory); 
        if (FAILED(hr))
        {
            return hr; 
        }
    }

    //special logic to prepare the file store. Because WinCE doens't support recursively create folder, we have to 
    //create the provision file folder first
    hr = FileStore_t::DoPreparation(); 
    if (FAILED(hr))
    {
        return hr; 
    }

    //initialize the update flag
    m_UpdatedFlags = (m_ActiveSettingCategory == SettingCategory1) ? 0 : VOIP_UPDATEDSETTINGS_ACTIVEREG_BITMASK; 
    
    return hr; 

}


HRESULT
ProvisionManager_t::CopyUntouchedSettingFromActiveToUpdate(
    void
    )
{
    HRESULT hr = S_OK; 
    
    for (int Index = 0; Index < ARRAYSIZE(sc_ProvisionSettings); Index ++)
    {
        ProvisionSetting_t* pSetting = sc_ProvisionSettings[Index].pSetting; 
        if (pSetting->GetSettingFlag() & m_UpdatedFlags)
        {
            continue; 
        }

        hr = pSetting->CopyValue(
                        m_ActiveSettingCategory, 
                        m_UpdateSettingCategory
                        ); 
        if (FAILED(hr))
        {
            break; 
        }
    }

    return hr; 
}
    

HRESULT
ProvisionManager_t::DeleteObsoleteSettings(
    bool    IsSuccessful
    )
{
    for (int Index = 0; Index < ARRAYSIZE(sc_ProvisionSettings); Index ++)
    {
        sc_ProvisionSettings[Index].pSetting->Delete(
                                        IsSuccessful ? m_ActiveSettingCategory : m_UpdateSettingCategory
                                        ); 
    }

    return S_OK; 
}

HRESULT
ProvisionManager_t::FinishUp(
    bool*   pUpdateHappened
    )
{
    if (pUpdateHappened == NULL)
    {
        return E_INVALIDARG; 
    }

    *pUpdateHappened = false; 
    
    //bail out if no setting is updated
    if (!(m_UpdatedFlags & VOIP_ALL_PROVISION_SETTINGS))
    {
        return S_OK; 
    }

    HRESULT hr = CopyUntouchedSettingFromActiveToUpdate(); 
    if (FAILED(hr))
    {
        return hr;  
    }

    ReleaseMutex(m_Mutex); 

    hr = RegistrySetDWORD(
            SN_VOIP_UPDATEDSETTINGS_ROOT, 
            SN_VOIP_UPDATEDSETTINGS_PATH, 
            SN_VOIP_UPDATEDSETTINGS_VALUE, 
            m_UpdatedFlags
            ); 
    if (FAILED(hr))
    {
        return hr;
    }

    *pUpdateHappened = true; 
    
    return S_OK; 
}

bool
ProvisionManager_t::IsValidRTCXML(
    const WCHAR*    c_pValue, 
    int             ValueSize
    )
{
    if (c_pValue == NULL ||
        c_pValue[0] == NULL ||
        ValueSize <= 0)
    {
        return false; 
    }

    HRESULT hr = S_OK; 

    if (m_cpRTCClient == NULL)
    {
        //create the listener window if it doesn't already exist
        hr = CreateListenerWindow(); 
        if (FAILED(hr))
        {
            ASSERT(FALSE); 
            return false; 
        }
        
        hr = m_cpRTCClient.CoCreateInstance(CLSID_RTCClient); 
        if (FAILED(hr))
        {
            ASSERT(FALSE); 
            return false; 
        }

        hr = m_cpRTCClient->Initialize(); 
        if (FAILED(hr))
        {
            ASSERT(FALSE);