serversettings.cpp

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

        return hr; 
    }

    if (*pbstrValue == NULL)
    {
        return E_OUTOFMEMORY; 
    }

    return hr; 

}


HRESULT
GetExchangeProxy(
    IXMLDOMDocument*    pDocument, 
    BSTR*               pbstrValue
    )
{
    if (pbstrValue == NULL)
    {
        return E_INVALIDARG; 
    }
    
    if (pDocument != NULL)
    {
        //getting exchange proxy doesn't need IXMLDOMDocument
        return E_INVALIDARG; 
    }

    *pbstrValue = NULL; 

    WCHAR Value[MAX_PATH] = L""; 
    HRESULT hr = RegistryGetString(
                    SN_VOIP_EXCHANGEPROXY_ROOT, 
                    SN_VOIP_EXCHANGEPROXY_PATH, 
                    SN_VOIP_EXCHANGEPROXY_VALUE, 
                    Value, 
                    _countof(Value)
                    ); 

    if (SUCCEEDED(hr))
    {
        *pbstrValue = SysAllocString(Value); 
    }
    else if (HRESULT_CODE(hr) == ERROR_FILE_NOT_FOUND)
    {
        *pbstrValue = SysAllocString(L"");         
        hr = S_FALSE;
    }
    else if (FAILED(hr))
    {
        return hr; 
    }

    if (*pbstrValue == NULL)
    {
        return E_OUTOFMEMORY; 
    }

    return hr; 

}

const ServerSettings_t::ServerSettingData ServerSettings_t::sc_ServerSettings[] =
{
    {AccountName,           SIPSettings,            GetAccountName,     EIM_SPELL,      0,              IDS_ACCOUNT_LABEL,              IDS_STATUS_HELP_ACCOUNT                 },
    {Password,              SIPSettings,            GetPassword,        EIM_SPELL,      ES_PASSWORD,    IDS_PASSWORD_LABEL,             IDS_STATUS_HELP_PASSWORD                },
    {PhoneNumber,           SIPSettings,            GetUri,             EIM_NUMBERS,      0,              IDS_PHONENUMBER_LABEL,          IDS_STATUS_HELP_PHONENUMBER             },
    {SIPProxy,              SIPSettings,            GetSIPProxy,        EIM_SPELL,      0,              IDS_SIPPROXY_LABEL,             IDS_STATUS_HELP_SIPPROXY                },
    {SIPRegistrar,          SIPSettings,            GetSIPRegistrar,    EIM_SPELL,      0,              IDS_SIPREGISTRAR_LABEL,         IDS_STATUS_HELP_SIPREGISTRAR            },
    {SIPTransport,          SIPSettings,            GetSIPTransport,    EIM_SPELL,      ES_READONLY,    IDS_SIPTRANSPORT_LABEL,         IDS_STATUS_HELP_SIPTRANSPORT            },
    {BackupSIPProxy,        BackupSIPSettings,      GetSIPProxy,        EIM_SPELL,      0,              IDS_BACKUPSIPPROXY_LABEL,       IDS_STATUS_HELP_BACKUPSIPPROXY          },
    {BackupSIPRegistrar,    BackupSIPSettings,      GetSIPRegistrar,    EIM_SPELL,      0,              IDS_BACKUPSIPREGISTRAR_LABEL,   IDS_STATUS_HELP_BACKUPSIPREGISTRAR      },
    {VoicemailProxy,        VoicemailSettings,      GetSIPProxy,        EIM_SPELL,      0,              IDS_VOICEMAILPROXY_LABEL,       IDS_STATUS_HELP_VOICEMAILPROXY          },
    {VoicemailNumber,       ProvisionSettings,      GetVoicemailNumber, EIM_NUMBERS,    ES_NUMBER,      IDS_VOICEMAILNUMBER_LABEL,      IDS_STATUS_HELP_VOICEMAIL               },
    {ExchangeServer,        ExchangeServerSetting,  GetExchangeServer,  EIM_SPELL,      0,              IDS_EXCHANGESERVER_LABEL,       IDS_STATUS_HELP_EXCHANGESERVER          },
    {ExchangeProxy,         ExchangeProxySetting,   GetExchangeProxy,   EIM_SPELL,      0,              IDS_EXCHANGEPROXY_LABEL,        IDS_STATUS_HELP_EXCHANGEPROXY           },
};

const unsigned int ServerSettings_t::sc_ServerSettingsItems = _countof(ServerSettings_t::sc_ServerSettings);

const WCHAR ServerSettings_t::sc_QueryXML[] = L"<voip-provision>" 
                                              L"<query name=\"SIPSettings\" />" 
                                              L"<query name=\"VoicemailSettings\" />" 
                                              L"<query name=\"VoicemailNumber\" />" 
                                              L"<query name=\"BackupSIPSettings\" />" 
                                              L"</voip-provision>"; 

const WCHAR ServerSettings_t::sc_NameAttribute[]  = L"name"; 
const WCHAR ServerSettings_t::sc_ValueAttribute[] = L"value"; 

const WCHAR ServerSettings_t::sc_SIPSettings[]        = L"SIPSettings"; 
const WCHAR ServerSettings_t::sc_BackupSIPSettings[]  = L"BackupSIPSettings"; 
const WCHAR ServerSettings_t::sc_VoicemailSettings[]  = L"VoicemailSettings"; 

ce::wstring ServerSettings_t::s_ServerSettings[ServerSettings_t::LastSetting]; 

ServerSettings_t::ServerSettings_t()
{
}

ServerSettings_t::~ServerSettings_t()
{
}

HRESULT 
ServerSettings_t::RetrieveSettingsFromProvision(
    void
    )
{
    HRESULT hr = S_OK;

    //clear up the cached setting values first
    for (unsigned int Index = 0; Index < _countof(s_ServerSettings); Index ++)
    {
        s_ServerSettings[Index].clear(); 
    }
        
    //retrieve XML output from provision
    WCHAR*  pOutputBuffer = NULL; 
    hr = PHProcessProvisionXML(
                    sc_QueryXML, 
                    &pOutputBuffer
                    );
    if (FAILED(hr) || pOutputBuffer == NULL)
    {
        return hr; 
    }

    //allocate a bstr string
    ce::auto_bstr bstrProvisionXML = SysAllocString(pOutputBuffer); 
    delete [] pOutputBuffer; 

    if (bstrProvisionXML == NULL)
    {
        return E_OUTOFMEMORY;  
    }
        
    //retrieve data from xml 
    hr = RetriveDataFromXML(bstrProvisionXML); 
    if (FAILED(hr))
    {
        ASSERT(FALSE); 
        ///TODO: Need to show an error message?
        return hr; 
    }

    return hr;
}

HRESULT
ServerSettings_t::RetriveDataFromXML(
    BSTR    ProvisionXML
    )
{
    if (ProvisionXML == NULL)
    {
        return E_INVALIDARG;         
    }
    
    VARIANT_BOOL varIsSuccessful = VARIANT_FALSE; 
    
    HRESULT hr = m_cpProvision.CoCreateInstance(__uuidof(DOMDocument)); 
    if (FAILED(hr))
    {   
        return hr; 
    }

    hr = m_cpProvision->loadXML(
                            ProvisionXML, 
                            &varIsSuccessful
                            ); 
    if (hr != S_OK || varIsSuccessful == VARIANT_FALSE)
    {
        return E_FAIL; //treate S_FALSE as error
    }

    CComPtr<IXMLDOMNode>    cpXMLRootNode; 
    hr = m_cpProvision->get_firstChild(&cpXMLRootNode); 
    if (FAILED(hr))
    {
        return hr; 
    }

    if (cpXMLRootNode == NULL)
    {
        ASSERT(FALSE);          //no root node? 
        return E_UNEXPECTED; 
    }

    //start our first round of parsing, dispatch each settings to corresponding IXMLDOMDocument
    CComPtr<IXMLDOMNode>    cpXMLNode;     
    hr = cpXMLRootNode->get_firstChild(&cpXMLNode); 
    while (hr == S_OK)
    {
        hr = DispatchSettings(cpXMLNode); 
        if (FAILED(hr))
        {
            return hr; 
        }

        //get next sibling
        hr = cpXMLNode->get_nextSibling(&cpXMLNode);         
    }

    return ParseEachSetting(); 

}

HRESULT
ServerSettings_t::DispatchSettings(
    IXMLDOMNode* pCurrentNode
    )
{
    if (pCurrentNode == NULL)
    {
        return E_INVALIDARG; 
    }

    ce::auto_bstr bstrName; 
    HRESULT hr = GetAttributeValue(
                    pCurrentNode, 
                    sc_NameAttribute, 
                    &bstrName
                    ); 
    if (hr != S_OK)
    {
        return hr; 
    }

    ce::auto_bstr bstrValue; 
    hr = GetAttributeValue(
            pCurrentNode, 
            sc_ValueAttribute, 
            &bstrValue
            ); 
    if (hr != S_OK)
    {
        return hr; 
    }
    
    //dispath other settings to corresponding IXMLDOMDocument object
    VARIANT_BOOL varIsSuccessful = VARIANT_FALSE; 

    ///TODO: abstract below duplicate logic into a macro
    if (wcsicmp(bstrName, sc_SIPSettings) == 0)
    {
        if (m_cpSIPSettings == NULL)
        {
            hr = m_cpSIPSettings.CoCreateInstance(__uuidof(DOMDocument)); 
            if (FAILED(hr))
            {
                return hr; 
            }
        }

        return m_cpSIPSettings->loadXML(
                                    bstrValue, 
                                    &varIsSuccessful
                                    ); 
    }        


    if (wcsicmp(bstrName, sc_VoicemailSettings) == 0)
    {
        if (m_cpVoicemailSettings == NULL)
        {
            hr = m_cpVoicemailSettings.CoCreateInstance(__uuidof(DOMDocument)); 
            if (FAILED(hr))
            {
                return hr; 
            }
        }

        return m_cpVoicemailSettings->loadXML(
                                    bstrValue, 
                                    &varIsSuccessful
                                    ); 
    }        
    
    if (wcsicmp(bstrName, sc_BackupSIPSettings) == 0)
    {
        if (m_cpBackupSIPSettings == NULL)
        {
            hr = m_cpBackupSIPSettings.CoCreateInstance(__uuidof(DOMDocument)); 
            if (FAILED(hr))
            {
                return hr; 
            }
        }

        return m_cpBackupSIPSettings->loadXML(
                                        bstrValue, 
                                        &varIsSuccessful
                                        ); 
    }

    return hr; 
}


HRESULT
ServerSettings_t::ParseEachSetting(
    void
    )
{
    HRESULT hr = S_OK; 

    IXMLDOMDocument* CategoryMappings[] = {    //MUST be sync with the order of SettingCagetory_e
        m_cpSIPSettings,            // sip settings
        m_cpVoicemailSettings,      // voicemail settings
        m_cpBackupSIPSettings,      // backup sip settings
        m_cpProvision,              // provision settings
        NULL,                       // Exchange Server setting
        NULL,                       // Exchange Proxy setting
    }; 

    ce::auto_bstr bstrValue; 
    
    for (unsigned int Index = 0; Index < _countof(sc_ServerSettings); Index ++)
    {
        hr = sc_ServerSettings[Index].GetSettingValue(
                                        CategoryMappings[sc_ServerSettings[Index].Category], 
                                        &bstrValue
                                        ); 
        if (FAILED(hr))
        {
            return hr; 
        }

        if (!s_ServerSettings[Index].assign(bstrValue == NULL ? L"" : bstrValue))
        {
            return E_OUTOFMEMORY; 
        }

        bstrValue = NULL; 
    }

    return S_OK; 
}