provisionmanager.cpp

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

            return false; 
        }

        //register callback interface
        hr = RegisterCallbackInterface(); 
        if (FAILED(hr))
        {
            ASSERT(FALSE); 
            return false; 
        }

        //register for specific event RTCEF_CLIENT
        hr = m_cpRTCClient->put_EventFilter(RTCEF_CLIENT);
        if (FAILED(hr))
        {
            ASSERT(FALSE); 
            return false; 
        }
    }

    CComPtr<IRTCProfile>            cpNewProfile; 
    CComPtr<IRTCClientProvisioning> cpProvisioning; 

    hr = m_cpRTCClient->QueryInterface(
                            IID_IRTCClientProvisioning, 
                            (void**)&cpProvisioning
                            ); 
    if (FAILED(hr))
    {
        ASSERT(FALSE); 
        return false; 
    }

    ce::auto_bstr   bstrValue = SysAllocString(c_pValue); 
    if (bstrValue == NULL)
    {
        ASSERT(FALSE); 
        return false; 
    }
    
    hr = cpProvisioning->CreateProfile(
                            bstrValue, 
                            &cpNewProfile
                            ); 

    return (SUCCEEDED(hr)); 
    
}


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


    HRESULT hr = S_OK; 

    if (m_cpDialPlanParser == NULL)
    {
        hr = DialPlanParser_t::CreateDialPlanParser(&m_cpDialPlanParser); 
        if (FAILED(hr))
        {
            m_cpDialPlanParser = NULL; 
            return false; 
        }
    }

    ce::auto_bstr   bstrValue = SysAllocString(c_pValue); 
    if (bstrValue == NULL)
    {
        ASSERT(FALSE); 
        return false; 
    }
    
    hr = m_cpDialPlanParser->ValidateDialPlan(bstrValue); 
    return (SUCCEEDED(hr)); 


    return true; 

}

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

    return true; 
    
}

void
ProvisionManager_t::ClearQuerySettingsStack(
    void
    )
{
    if (m_QuerySettingsStack.empty())
    {
        return; 
    }

    while (!m_QuerySettingsStack.empty())
    {
        m_QuerySettingsStack.front()->FlushCachedValue(); 
        m_QuerySettingsStack.pop_front(); 
    }

    return; 
}


HRESULT
ProvisionManager_t::GetReturnXML(
    WCHAR**   ppOutputXML
    )
{
    if (ppOutputXML == NULL)
    {
        return E_INVALIDARG; 
    }

    *ppOutputXML = NULL; 
    
    CComPtr<IMXWriter>  cpIMXWriter;
    HRESULT hr = cpIMXWriter.CoCreateInstance(__uuidof(MXXMLWriter));
    if (FAILED(hr))
    {
        return hr; 
    }

    hr = cpIMXWriter->put_omitXMLDeclaration(VARIANT_TRUE); 
    if (FAILED(hr))
    {
        return hr; 
    }

    hr = cpIMXWriter->put_output(CComVariant(L"")); 
    if (FAILED(hr))
    {
        return hr;
    }

    CComPtr<ISAXContentHandler> cpContentHandler; 
    hr = cpIMXWriter->QueryInterface(
                        __uuidof(ISAXContentHandler), 
                        (void**)&cpContentHandler
                        ); 
    if (FAILED(hr))
    {
        return hr;
    }

    hr = cpContentHandler->startDocument(); 
    if (FAILED(hr))
    {
        return hr;
    }

    CComPtr<IMXAttributes>  cpIMXAttributes; 
    CComPtr<ISAXAttributes> cpSAXAttributes; 
    hr = cpIMXAttributes.CoCreateInstance(__uuidof(SAXAttributes)); 
    if (FAILED(hr))
    {
        return hr; 
    }

    hr = cpIMXAttributes->QueryInterface(
                            __uuidof(ISAXAttributes), 
                            (void**)&cpSAXAttributes
                            ); 
    if (FAILED(hr))
    {
        return hr;
    }

    hr = cpContentHandler->startElement(
                            L"", 
                            0, 
                            sc_StartElement, 
                            ARRAYSIZE(sc_StartElement), 
                            sc_StartElement, 
                            ARRAYSIZE(sc_StartElement), 
                            NULL
                            ); 
    if (FAILED(hr))
    {
        return hr;
    }
    
    while (!m_QuerySettingsStack.empty())
    {
        hr = m_QuerySettingsStack.front()->WriteCachedValue(cpIMXAttributes); 
        if (FAILED(hr))
        {
            return hr; 
        }

        hr = cpContentHandler->startElement(
                                    L"",
                                    0, 
                                    sc_QueryElement, 
                                    ARRAYSIZE(sc_QueryElement), 
                                    sc_QueryElement, 
                                    ARRAYSIZE(sc_QueryElement), 
                                    cpSAXAttributes
                                    ); 
        if (FAILED(hr))
        {
            return hr; 
        }

        hr = cpContentHandler->endElement(
                                    L"",
                                    0, 
                                    sc_QueryElement, 
                                    ARRAYSIZE(sc_QueryElement), 
                                    sc_QueryElement, 
                                    ARRAYSIZE(sc_QueryElement)
                                    ); 
        if (FAILED(hr))
        {
            return hr;
        }

        m_QuerySettingsStack.pop_front(); 

        hr = cpIMXAttributes->clear(); 
        if (FAILED(hr))
        {
            return hr; 
        }
        

    }

    hr = cpContentHandler->endElement(
                            L"", 
                            0, 
                            sc_StartElement, 
                            ARRAYSIZE(sc_StartElement), 
                            sc_StartElement, 
                            ARRAYSIZE(sc_StartElement)
                            ); 
    if (FAILED(hr))
    {
        return hr;
    }
    

    hr = cpContentHandler->endDocument(); 
    if (FAILED(hr))
    {
        return hr; 
    }

    VARIANT varXML; 
    VariantInit(&varXML);

    hr = cpIMXWriter->get_output(&varXML);     
    if (FAILED(hr))
    {
        return hr; 
    }

    if (varXML.vt == VT_BSTR && V_BSTR(&varXML))
    {
        unsigned int OutputLength = wcslen(V_BSTR(&varXML)) + 1; 
        *ppOutputXML = new WCHAR[OutputLength]; 
        if (*ppOutputXML == NULL)
        {
            return E_OUTOFMEMORY; 
        }
        memcpy(*ppOutputXML, V_BSTR(&varXML), OutputLength * sizeof(WCHAR)); 
        
    }

    return hr; 
    
}

HRESULT
ProvisionManager_t::CreateListenerWindow(
    void
    )
{
    if (::IsWindow(m_ListenerWindow))
    {
        return S_FALSE; 
    }

    //register our notification window class
    WNDCLASS    WindowClass     = {0};
    WindowClass.lpfnWndProc     = s_ListenerWindowProc;
    WindowClass.hInstance       = GlobalData_t::s_ModuleInstance;
    WindowClass.lpszClassName   = WNDCLASS_PROVISIONMGR;

    //it's ok if our class already exists...
    if (! RegisterClass(&WindowClass) && 
        GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
    {
        ASSERT(FALSE);
        return E_FAIL;
    }

    //create the notification window and pack our 'this' pointer into the CREATESTRUCT
    m_ListenerWindow = CreateWindow(
                            WNDCLASS_PROVISIONMGR,
                            NULL,
                            0, 0, 0, 0, 0, NULL, NULL,
                            GlobalData_t::s_ModuleInstance,
                            NULL
                            );

    if (m_ListenerWindow == NULL)
    {
        ASSERT(FALSE);
        return CommonUtilities_t::GetErrorFromWin32();
    }

    return S_OK;
    
}

HRESULT
ProvisionManager_t::RegisterCallbackInterface(
    void
    )
{
    if (m_cpRTCClient == NULL || m_ConnectionPtCookie != 0)
    {
        return E_FAIL;
    }

    CComPtr<IConnectionPointContainer> cpContainer;

    //Recast the RTC Client as a connection point container
    HRESULT  hr = m_cpRTCClient->QueryInterface(
                                    IID_IConnectionPointContainer, 
                                    reinterpret_cast<void**>(&cpContainer)
                                    );
    if (FAILED(hr))
    {
        return hr;
    }

    //Find the event notification connection point - we will advise the connection point of our
    //event sink in the next step.
    hr = cpContainer->FindConnectionPoint(
                        IID_IRTCEventNotification, 
                        &m_cpConnectionPt
                        );
    if (FAILED(hr))
    {
        return hr;
    }

    //now advise the connection point that this object is the event sink for the given connection
    hr = m_cpConnectionPt->Advise(static_cast<IUnknown*>(static_cast<IRTCEventNotification*>(this)), &m_ConnectionPtCookie);
    if (FAILED(hr))
    {
        return hr;
    }

    ASSERT(m_ConnectionPtCookie != 0);
    return S_OK;    
}

HRESULT
ProvisionManager_t::Event(
    RTC_EVENT   RTCEvent, 
    IDispatch*  piDispatch
    )
{
    if (piDispatch == NULL)
    {
        ASSERT(FALSE); 
        return E_POINTER; 
    }

    if (RTCEvent != RTCE_CLIENT)
    {
        return S_FALSE; 
    }

    CComPtr<IRTCClientEvent> cpRTCClientEvent; 
    HRESULT hr = piDispatch->QueryInterface(IID_IRTCClientEvent, reinterpret_cast<void**>(&cpRTCClientEvent)); 
    if (FAILED(hr))
    {
        ASSERT(FALSE); 
        return hr; 
    }

    RTC_CLIENT_EVENT_TYPE EventType = RTCCET_DEVICE_CHANGE; 
    hr = cpRTCClientEvent->get_EventType(&EventType); 
    if (FAILED(hr))
    {
        return hr; 
    }

    if (EventType != RTCCET_ASYNC_CLEANUP_DONE)
    {
        return S_FALSE; 
    }
            
    PostMessage(m_ListenerWindow, WM_RTC_SHUTDOWN_COMPLETE, 0, 0); 

    return S_OK; 

}

HRESULT 
ProvisionManager_t::UnregisterCallbackInterface()
{
    if (m_cpConnectionPt == NULL)
    {
        return E_FAIL;
    }

    HRESULT hr = m_cpConnectionPt->Unadvise(m_ConnectionPtCookie);
    if (FAILED(hr))
    {
        return hr;
    }

    //release our internal members
    m_cpConnectionPt     = NULL;
    m_ConnectionPtCookie = 0;

    return S_OK;
}